In the DeepSeek Harness (DSH) ecosystem, developers usually need to integrate with multiple plugins, MCP Skills, and external tools, which increases management costs. Polaris, as a general-purpose capability aggregation and evolutionary selection layer, sits above DSH plugins, third-party MCP/Skills, and emerging desktop tools. It is responsible for continuous sniffing, normalization, competition, verification, signing, indexing, and routing. Its goal is to ensure that, when developers face a single intent interface, the underlying system can transparently route to the current best implementation.

Core Features

Polaris is composed of a series of atomic primitives and uses pipelines to create a closed loop from discovery to invocation.

  1. Heterogeneous sniffing: Detects heterogeneous resources such as DSH bundles, SKILL.md, MCP configurations, CLI binaries, etc., extracts core contracts, and normalizes them into Polaris IR (stripping redundant dependencies and permissions).
  2. Dual-track arena:
    • Hot-start minimal track: Runs smoke tests and self-consistency checks, and mounts them into the context to assist development.
    • Cold release production track: Runs full contract tests, fuzz testing, performance benchmarks, SBOM audits, and adversarial replay.
  3. SLSA provenance and immutable index: Validates service evidence through Ed25519 signatures and maintains an immutable index with GitOps to ensure the trustworthiness of production invocations.
  4. Semantic scheduling: Provides deterministic intent routing and transparently routes based on the index contents to the optimal native, in-house, or external implementation.
  5. Automatic model tool registration: After installing and restarting the profile, the development agent automatically registers and invokes polaris_* model tools without manual command input.

Installation and Activation

Install the Polaris plugin in a DSH environment:

dsh plugin --profile web add github:existyay/Polaris
dsh web

After installation, the plugin registers model tools with DSH under the same names and also provides independent CLI commands.

Atomic Primitives and Tools

Polaris exists inside DSH as atomic plugins; each primitive has a single responsibility and can be configured separately via cordis.patch.yml.

Model tools (automatically triggered)

During project development, the development agent automatically sees and invokes the following tools:

Tool Name Trigger Scenario
polaris_discover Find existing DSH capabilities to avoid reinventing the wheel
polaris_audit Automatically scan risks such as dependencies and authentication after code changes
polaris_exec When a single bounded smoke run and monitoring of exit, timeout, and output are needed
polaris_verify Automatically run tests before task completion and enforce coverage thresholds
polaris_retrieve Automatically retrieve when locating functions, classes, or documentation concepts
polaris_license Automatically check license compliance when adding dependencies or before release
polaris_rules Inject Chinese STEM terminology mappings and code optimization rules

Command-line primitives

The corresponding standalone CLI primitives are as follows:

  • polaris-discovery (/polaris-discover): Real-time discovery and minimal scoring of GitHub topic:dsh-plugin.
  • polaris-audit (/polaris-audit): Static code scanning and dependency vulnerability auditing.
  • polaris-exec (/polaris-exec): Bounded subprocess execution and runtime behavior monitoring.
  • polaris-verify (/polaris-verify): Schema-driven deterministic functional testing.
  • polaris-retrieve (/polaris-retrieve): Hybrid retrieval of code symbols and documentation.
  • polaris-license (/polaris-license): License compliance queries.
  • polaris-rules (/polaris-rules): Declarative rule injection.

Usage Examples

1. Heterogeneous Sniffing

Sniff heterogeneous resources in the specified project directory and extract core contracts.

dsh-polaris sniff --root /path/to/project

2. Dual-track Arena

Run dual-track tests in the arena directory to verify whether the utility increment of candidate services is significantly greater than that of the existing best implementation.

dsh-polaris arena --root /path/to/arena-root

3. Semantic Scheduling

Route to the optimal implementation from the immutable index based on intent.

dsh-polaris route "code review" --indexRoot /path/to/index

4. Immutable Index and GitOps

Issue candidate services as SLSA provenance and write them to the immutable index.

dsh-polaris seal --name demo --entry node --capabilities demo,cli --persist
dsh-polaris promote --name demo --entry node --capabilities demo,cli --indexRoot /path/to/index

Design Constraints

  • Stateless: Each atomic primitive reads inputs and produces deterministic outputs; pipeline state exists only in the immutable index.
  • Single Responsibility: One plugin does one thing; composition is handled by the profile patch layer and pipeline configuration.
  • Bounded Cost: All primitives and pipeline stages declare file count, file size, timeout, and output limits.

Applicable Scenarios and Notes

Polaris is especially suitable for STEM (mathematics/physics/chemistry/engineering/scientific research/numerical computation/simulation) and code optimization (performance/refactoring/static analysis/testing quality/benchmarking/debugging) scenarios.

Note: The plugin runs with the permissions of the current DSH process. Inspect the source code and license before installation. The plugin does not include background services; all state changes are written to the immutable index via GitOps.

Summary

By providing heterogeneous sniffing, dual-track arena, SLSA provenance, immutable indexing, and semantic scheduling, Polaris builds a complete closed loop from discovery to validation to invocation for the DSH plugin system. For more details, refer to the project repository.