dsh-ecc

dsh-ecc is a DeepSeek Harness (DSH) plugin that adapts the most useful runtime surfaces of Everything Claude Code (ECC) to DSH. It is an adapter package, not a fork of DSH and not a replacement for Claude Code or Codex.

The plugin currently provides:

• ECC agent Markdown as persona and instruction resources for child agents.
• ECC skills through the DSH skill provider.
• ECC hook assets and a validated hook configuration boundary; the runtime hook bridge is a planned follow-up release gate.
• spawn_subagent, with explicit provider, model, reasoning effort, ECC persona, and continuable follow-up support.

Release status

Item	Current value
dsh-ecc	0.1.0
Bundled ECC	v2.2.0
ECC commit	50743cec75852e32d6517c9894a3339a2462a713
DSH peer floor	>=0.1.0-rc.5
Validated DSH runtime	0.1.0-rc.7
Hook runtime	Assets/config bundled; bridge pending
Distribution	GitHub release tarball; registry publication is optional

The bundled ECC revision is recorded in assets/ecc/revision.json. A release must use a pinned ECC tag or commit. The plugin does not fetch main or latest during startup. The current ECC version comes from the upstream version metadata; the upstream repository does not provide a v2.2.0 tag, so future remote synchronization must use the verified commit SHA rather than assuming that tag exists.

Capability mapping

ECC surface	DSH implementation	Runtime behavior
agents/*.md	EccPersonaCatalog + spawn_subagent.persona	Injects persona/instructions into the child session. Frontmatter tools becomes a DSH tool allowlist.
skills/*/SKILL.md	EccSkillProvider	Discovers, validates, and loads ECC skill bodies from the bundled revision.
hooks/*.json	Hook asset/config boundary	Bundles the Claude/Codex definitions. Runtime event registration is a follow-up release gate.
ECC built-in tools	EccToolMapper	Maps exact or explicitly configured aliases to tools exposed by the child scope.
ECC MCP entries	Compatibility report only	MCP servers are not bundled or silently mapped. Configure DSH MCP servers separately.

The plugin installs the complete agents, skills, and hook asset surface. Agents and skills are active in the current runtime; hook event execution remains blocked until the bridge is released. The MVP has no per-surface enable/disable switch.

spawn_subagent

spawn_subagent is a native DSH tool implemented by dsh-ecc. It does not call the existing DSH subagent or workflow tool from inside another tool.

Start a child:

{
  "operation": "start",
  "prompt": "Review the authentication boundary and report concrete risks.",
  "provider": "deepseek-official",
  "model": "deepseek-v4-flash",
  "effort": "high",
  "persona": "ecc:security-reviewer",
  "label": "security-review"
}

Continue the same child:

{
  "operation": "followup",
  "childId": "<durable-child-id>",
  "prompt": "Now verify the highest-risk finding against the current tests."
}

effort is resolved against the selected DSH model's published reasoning efforts and is persisted with the child request selection. persona resolves to one file under the bundled ECC agents/ root; raw Markdown is not accepted from the model.

Skill invocation and name collisions

DSH's native skill registry accepts kebab-case names only. Its public registry does not accept a colon in a candidate name, so the internal ECC identifier may be ecc:accessibility while the DSH candidate remains accessibility.

The intended adapter contract is:

/ecc:<name>  -> the ECC skill with that name
/<name>      -> the native/project DSH skill

The 0.1.0 runtime currently registers ECC candidates in the native flat DSH catalog. Therefore the Web picker displays plain names and /name is the working entrypoint. The /ecc:<name> client and host alias bridge is a planned compatibility fix; it must be implemented before claiming strict namespace support in a release.

Until that bridge exists, a project skill with the same name can shadow the ECC candidate according to DSH scope and rank rules. Do not assume that both bodies are available under the same name.

Hooks (current status)

Hook definitions and their script closure are bundled from the pinned ECC revision. The current 0.1.0 runtime validates dialect, hookProfile, and failure policy configuration, but it does not yet register an EccHookBridge against DSH lifecycle events. Therefore hooks must not be described as active until the bridge work in the synchronization plan is complete.

The planned bridge will:

1. Resolve the active immutable ECC asset root.
2. Selects the configured dialect (auto, claude, or codex).
3. Loads the hook configuration once for the mounted runtime.
4. Runs only commands resolved inside the trusted ECC asset root.
5. Applies the configured failure policy (report by default).

The adapter exposes only DSH events with a supported semantic equivalent. ECC events without a DSH boundary are reported as unsupported; they are not silently emulated.

Installation

Install a published release into a DSH profile:

dsh plugin --profile web add dsh-ecc@0.1.0

Install the GitHub release tarball before registry publication:

dsh plugin --profile web add https://github.com/staavanothanh/dsh-ecc/releases/download/v0.1.0/dsh-ecc-0.1.0.tgz

The package is installed under the selected DSH profile. The logical package layout is:

<DSH_HOME>/profiles/<profile>/
  package.json
  node_modules/dsh-ecc/
    dist/
    assets/ecc/
      agents/
      skills/
      hooks/
      scripts/
    cordis.patch.yml
    LICENSE
    NOTICE

The runtime resolves the package root from the DSH module loader. It does not read an author's checkout, the current project, or a hard-coded Windows path.

Local file: installation is for development only. A local package containing node_modules can trigger pnpm junction or symlink errors on Windows; build and pack the artifact, then test the resulting tarball instead.

Update or roll back a profile with a known package version:

dsh plugin --profile web update dsh-ecc
dsh plugin --profile web add dsh-ecc@0.1.0

The second command is the rollback example. Keep the previous release tag and ECC commit available until the new release passes the clean-profile smoke test.

Configuration boundary

The package patch mounts the adapter with a bundled, pinned ECC source:

eccSource:
  mode: bundled
  repository: https://github.com/affaan-m/ECC.git
  ref: 50743cec75852e32d6517c9894a3339a2462a713
  updatePolicy: explicit
dialect: auto
transportProvider: spawn
hookProfile: standard

The bundled package also records the human-readable ECC version v2.2.0 in assets/ecc/revision.json. A remote mode must resolve and verify the commit before activation; it must not infer a ref from the version string.

Remote revision caching and atomic activation are post-MVP features. They must accept only an explicit tag or commit, verify the downloaded snapshot, and keep the last known-good revision for rollback.

Development and verification

Requirements: Node.js >=22.19.0 and pnpm.

pnpm install
pnpm typecheck
pnpm test
pnpm build
pnpm pack:check

Before a release, also install the generated tarball into a temporary DSH_HOME profile and verify:

• the plugin row loads without changing DSH core;
• all expected ECC agents and skills are discoverable;
• spawn_subagent starts and follows up with provider/model/effort selection;
• persona tool filtering rejects unmapped tools according to policy;
• if the release claims hook support, supported hooks run with the pinned asset root;
• package contents contain dist, assets/ecc, cordis.patch.yml, LICENSE, and NOTICE.

ECC runtime synchronization

ECC changes independently from dsh-ecc. The release process therefore treats the ECC revision as an explicit input and publishes an immutable snapshot with each dsh-ecc release. The detailed update, compatibility, release, and rollback plan is in docs/plans/ecc-runtime-sync.md.

The short rule is:

ECC tag/commit -> synchronized asset snapshot -> compatibility checks
-> dsh-ecc version bump -> package/release smoke test -> publish

Documentation

• Plugin specification
• Architecture
• Compatibility research
• ECC runtime synchronization plan

License and attribution

dsh-ecc is distributed under the license in LICENSE. ECC source attribution and the bundled-revision notice are recorded in NOTICE.