Introduction¶

When doing skill management in DeepSeek Harness (DSH), you encounter a recurring problem: every time the skill evolution page accumulates a batch of pending suggestions, clicking through each one is a burden in itself. Moreover, suggestions automatically proposed by the model are often “a stream from a specific task”; if adopted directly, the skill library will quickly balloon into hundreds of unrelated narrow skills.

dsh-skill-autopilot offloads the “review” and “publish” steps to a Large Language Model (LLM) configured by you, but writes deterministic admission rules for “what kind of skills qualify for the library”. The model can only judge within this box, and the code judges again. Finally, passing skills are packed into SKILL.md and written to the disk via the skill data source, with version records and the ability to roll back.

What is it¶

• Plugin Name: dsh-skill-autopilot
• Maintainer: BrainZombie
• Category: Workflow
• Source: SkillHub Directory Page, GitHub
• Version and License: 0.1.0, MIT

It solves a clear problem: transforming the accumulated pending suggestions in the evolution pipeline—after model review and anti-fragmentation gating—into actual skills entering the library, rather than turning every suggestion into a new file.

What it does (One Run)¶

The flow for one run is as follows:

pending suggestions ──► Review Model (your choice) ──► Deterministic Gate ──► Pack SKILL.md ──► Disk Write + Version Record
   (mnemon)        (semantic judgment)          (non-bypassable)        (distill/clean)        (adopt)

1. Read: Retrieve pending suggestions, evidence trails, test cases, and the full skill directory from Mnemon’s Skills Source.
2. Review: Call the review model in one batch, outputting create / merge / dismiss / defer for each suggestion, along with a reason and merge target.
3. Gate: The model’s output is not final; the code judges again. This layer is the core of the plugin, discussed later.
4. Package: Call the model again specifically for passed items to generate the body, while removing time-sensitive content that degrades over time, such as dates, session IDs, UUIDs, absolute machine paths, and “N hours ago”.
5. Write: recordDraft → adoptDraft, using the skill data source’s own write entry. Suggestions are set to adopted, version records are generated, and rollback is possible from “Skill Management → Versions/Recycle Bin” if needed. The plugin does not write to SKILL.md directly.

By default autoApply: false. review only outputs decisions and the body to be written, writing not a single byte; apply actually writes to disk only after confirmation.

Anti-Fragmentation Strategy¶

This is the core of the plugin. It breaks down the principle that “the library is class-level knowledge, not a stream” into executable rules.

Several hard conditions in the gate are worth listing separately:

• Suggestion confidence below minConfidence → do not create (this item does not enter model review).
• Model’s confidence in “creation” is below minModelConfidence → defer to the next round, do not force publish.
• No strong signal (procedure / correction / directive / skill-gap / skill-misleading / approach-change) → do not create.
• Plugin already provides this capability → do not create.
• Similarity to existing skills ≥ mergeSimilarity, or same xxx-* prefix cluster and related content → force merge, disallow creating new sibling skills.
• create exceeds maxNewPerRun this round → leave for the next round.
• The resulting SKILL.md must pass lint.

consolidate is the accompanying existing-data health check. It clusters existing skills by prefix/domain, allowing the model to judge which should converge into an “umbrella”. When applied, it writes the merged body to the keeper and moves the absorbed ones to the recycle bin.

Packaging Validation¶

Packaging validation is implemented in lib/policy.js: lintSkillDoc. Hard blocks include: name is not kebab-case or is a duplicate; missing or excessively long description; body is empty, too short, or too long; body contains frontmatter; missing “When to use” or “Steps”; is a router skill. Soft prompts include missing acceptance section, body has no executable commands, or description starts with clichés.

Installation and Activation¶

Installation commands come from the repository’s built-in install.ps1. There are two modes. The standard mode edits the profile’s package.json (link: dependencies + dsh.profile.bundles) and executes pnpm install:

# First check the plan
powershell -ExecutionPolicy Bypass -File .\install.ps1 -DryRun

# Execute standard installation
powershell -ExecutionPolicy Bypass -File .\install.ps1

The no-pnpm mode only creates soft links and appends insert entries to the profile’s cordis.patch.yml:

powershell -ExecutionPolicy Bypass -File .\install.ps1 -Link

Rollback is recognized by both modes, restoring the backup of package.json / cordis.patch.yml:

powershell -ExecutionPolicy Bypass -File .\install.ps1 -Rollback

After installation but before starting or restarting, a pre-check can be performed:

dsh --profile web --dump-config | Select-String skill-autopilot

Activation requires restarting DSH, which the user performs themselves.

Typical Usage¶

After installation and restart, slash commands can be used directly in any session:

/skill-autopilot status       # View queue, counts, review model, strategy, log directory
/skill-autopilot review       # Review only, no writing (default dry-run)
/skill-autopilot apply        # Review and write to disk directly
/skill-autopilot consolidate  # Existing data consolidation review (proposes only)
/skill-autopilot history      # Recent decisions

You can also let the agent call the tool directly:

{"action": "review", "maxItems": 3}
{"action": "apply", "ids": ["<suggestionId>"]}
{"action": "apply", "provider": "deepseek-official", "model": "deepseek-reasoner"}
{"action": "consolidate", "confirm": true}

Decision logs are append-only JSONL, and there is also a recent complete result located at $DSH_HOME/storages/skill-autopilot/: decisions.jsonl is one line per suggestion, containing the final action, reason, whether it was written, and errors; last-run.json is the complete content of the most recent run, including the SKILL.md body that is to be written or has been written. The significance of review being dry-run by default lies here: you can read before writing.

Relevant Configuration¶

The config in the plugin patch can be omitted. Common keys are as follows, default values taken from README:

To make judgment stricter, you can point reviewer.model to a stronger model, set mergeSimilarity to 0.55, and maxNewPerRun to 1. Note that deepseek-flash’s self-assessment for “create” is usually between 0.65–0.8. This is a calibration value, not a ruling value, so minModelConfidence is only set to 0.5 by default. The things that truly determine “whether it qualifies for the library” are suggestion confidence, strong signals, deduplication, and document linting.

Verification¶

node test/selftest.mjs          # Unit gate/dedup/pack/write (temporary ledger + temporary skill root, doesn't touch real data)
node test/selftest.mjs --live   # Additional: read-only real ledger, confirms ability to read pending and directories
node test/host-contract.mjs     # Walk through registration and one LLM assembly call using real dsh-tools/dsh-llm
dsh-plugin verify .             # Real pack, real install, mount check

selftest never touches ~/.mnemon/skills and ~/.dsh/skills: it copies a ledger under %TEMP%, creates an empty temporary skill root, and deletes it after running. Tests requiring “DSH installed locally” or “mnemon data source installed” will automatically skip rather than fail on machines without them, so CI only runs npm test; host-contract and verify require a real host, please run them on a machine where DSH is installed.

Use Cases and Notes¶

The target audience for this plugin is developers already using Mnemon to manage skills within DSH and who are troubled by manual review of evolution suggestions and skill library fragmentation.

A few points to note:

• The plugin runs with the permissions of the current DSH process; you should check the source code and license (MIT) before installing. This plugin reads and writes the same ledger via dsh-mnemon-source-skills’s manage(), which is an implementation relying on internal mnemon contracts.
• apply will truly add or modify skills under ~/.dsh/skills, but only via the data source write entry, so there are version records and a recycle bin as two fallback paths. The model’s judgment is not 100% satisfactory, so it is dry-run by default.
• Do not enable autoApply together with short intervalMinutes; that is equivalent to letting the model infinitely self-grow the skill library. It is recommended to trigger apply manually, or only use autoApply with maxNewPerRun: 1.
• Project-level skills (project-dsh / project-agents) are read-only by default and not created; consolidate only handles user-dsh / user-agents.
• Runtime requirements: DeepSeek Harness >= 0.2.0, Node.js >= 20; dsh-mnemon-source-skills >= 0.4.0 is an optional peer dependency. The plugin can still load if missing, but it cannot read pending suggestions.

Conclusion¶

The value of dsh-skill-autopilot lies not in letting the model decide, but in hardcoding “what kind of skills qualify for the library” into deterministic rules, allowing review and merging to run automatically while preserving version records and rollback capability. If you happen to be on the DSH skill evolution chain, you can start trying from the dry-run review.

• Directory Page: https://www.skillhub.cn/plugins/BrainZombie/dsh-skill-autopilot
• GitHub: https://github.com/BrainZombie/dsh-skill-autopilot