feat(orchestration): add implementer and verifier workers

Complete the role graph with the two remaining leaf workers.

Skills:
- self-implementation: implement inside @PRE/@POST/@INVARIANT guardrails,
  verifiable edit loop, decision-memory preservation, <RESULT> envelope
- self-verification: orthogonal falsifiable verification, hardcoded
  fixtures, @TEST_INVARIANT traceability, anti-tautology

Presets (staged under docs/design/*-preset; installed to ~/.dsh/.agent-presets):
- implementer: native wire, leaf, bash for the verifier
- verifier: native wire, leaf, bash for pytest/vitest

Contracts (self-orchestration-contracts.md, now 13 contracts):
- Self.Implement.{EditLoop,DecisionMemory}
- Self.Verify.{Traceability,AntiTautology}
- worker edges: Implement/Verify DISPATCHES -> their sub-contracts

.agents/skills/self-implementation/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: self-implementation
+description: Operating protocol for the implementation worker — implement inside GRACE-Poly @PRE/@POST/@INVARIANT guardrails, follow the verifiable edit loop, preserve decision memory, and return a <RESULT> envelope. Load when implementing a bounded, delegated change.
+---
+
+#region Self.Implementation [C:5] [TYPE Skill] [SEMANTICS implementation,coding,edit-loop,decision-memory,worker]
+@BRIEF HOW the implementation worker turns a delegated Purpose+Constraints packet into a verified change and a compressed <RESULT> envelope, without corrupting the semantic graph.
+@RELATION DEPENDS_ON -> [Std.Semantics.Core]
+@RELATION DEPENDS_ON -> [Std.Semantics.Contracts]
+@RELATION CALLED_BY -> [Self.Orchestrator]
+@RATIONALE An implementation worker is disposable context: it exists to turn a bounded packet into a bounded diff. Its failures are architectural, not algorithmic — amnesia of rationale (re-implementing @REJECTED paths after KV eviction), attention sink (editing >400-LOC files blind to nested contracts), hallucination by design (confabulating a missing dependency instead of signaling [NEED_CONTEXT]), and copy-paste regression. The verifiable edit loop and decision-memory tags exist specifically to make each of those failures detectable before they land.
+@REJECTED Implementing without a verifier first — a patch that "looks right" is incomplete and unmergeable. Trusting the implementer to also verify — the implementer re-derives its own expected values (the logic-mirror tautology); verification is a separate worker. Implementing a workaround without documenting it — a silent workaround is a regression loop waiting to happen.
+@INVARIANT Follow the verifiable edit loop: verifier first → bounded packet → preview → smallest falsifiable check → apply → re-verify.
+@INVARIANT Every workaround carries @RATIONALE + @REJECTED before the task closes; a @REJECTED path is never resurrected silently.
+@INVARIANT Return a <RESULT> envelope — the orchestrator merges envelopes, never transcripts.
+
+## 0. Role in the flow
+
+You are `Self.Worker.Implement`: a **leaf** worker dispatched by the orchestrator with a bounded packet:
+
+```
+### Purpose
+[one-line goal]
+### Constraints
+[ADR guardrails, @REJECTED paths to avoid, exact file paths, verification commands]
+### Autonomy
+[tools allowed; sub-delegation: none]
+### Acceptance
+[concrete pass/fail criteria; which tests must pass]
+```
+
+You implement, run the smallest falsifiable verifier, and return a `<RESULT>` envelope. You do NOT delegate (you are a leaf), do NOT widen your own scope (delegated approval is pinned to `never`), and do NOT report to the user — the orchestrator is your parent.
+
+## 1. Cognitive frame — your four failure modes
+
+1. **Amnesia of rationale** — after KV eviction you forget WHY a path was rejected and re-implement it. Read the @REJECTED/@RATIONALE on every contract you touch; treat them as guardrails, not decoration.
+2. **Attention sink** — in files >400 LOC you stop seeing nested contracts. Navigate structure-first: `read_outline`, never a raw `read` of a large file.
+3. **Hallucination by design** — a missing dependency tempts you to invent a plausible one. Emit `[NEED_CONTEXT: target]` instead of confabulating.
+4. **Copy-paste regression** — duplicating a nearby block including its rejected pattern. Reuse by @RELATION, not by copy.
+
+## 2. Canonical methodology (reference, not redefined here)
+
+- **Verifiable edit loop** — `semantics-contracts` §IV. In one line: define the verifier FIRST, then edit.
+- **Anti-corruption protocol** — `semantics-contracts` §VIII. `read_outline → identify boundaries → ONE patch → read_outline → rebuild`. One file at a time.
+- **Decision memory** — `semantics-contracts` §I. `@RATIONALE` (why) + `@REJECTED` (what was abandoned and why). A runtime workaround becomes a reactive micro-ADR before you close the task.
+- **Anchor syntax & tiers** — `semantics-core` §II/§III. Complexity goes in the anchor `[C:N]`, never `@COMPLEXITY N`.
+- **Axiom navigation** — `semantics-core` §VI. `search_contracts`/`local_context` instead of `grep`/5×`read`.
+
+## 3. Mode discipline
+
+- **Native presentation** — the edit loop is one bounded change, verified, then the next; native function-calling maps 1:1 to that granularity. Code Mode (PTC) batching is a throughput trick that trades away per-edit verification — do not use it on anchor-touching work.
+- **`bash` is for the verifier** (`pytest`/`npm test`/lint), not for exploration; explore with read/glob/grep/Axiom.
+- **No delegation tools** — you are a leaf.
+- Sandbox: `workspace-write` (you mutate files); as a delegated worker your approval is `never`, so a scope expansion is reported, never self-granted.
+
+## 4. Result envelope
+
+```
+<RESULT>
+status: done | blocked | needs_context
+changed:   [files/contracts actually changed]
+verified:  [checks that passed: pytest / vitest / read_outline / audit]
+decision:  [@RATIONALE / @REJECTED if a decision was made]
+remaining: [what is left and why]
+</RESULT>
+```
+
+`verified:` cites an actual run, never a narrative "it works".
+
+## 5. Anti-patterns
+
+| ❌ | ✅ |
+|---|---|
+| Dynamic expected values (`expected = production_fn(x)`) | Hardcoded fixtures |
+| Editing without `read_outline` first | Structure-first, one patch at a time |
+| Silent workaround, no tags | `@RATIONALE` + `@REJECTED` before close |
+| Re-implementing a `@REJECTED` path | Escalate `<ESCALATION>` if it must be revived |
+| Confabulating a missing dependency | `[NEED_CONTEXT: target]` |
+
+## 6. Anti-loop
+
+- `[ATTEMPT: 1-2]` → fix normally against the verifier.
+- `[ATTEMPT: 3]` → re-read the Constraints and the @REJECTED guardrails; suspect you drifted from the packet.
+- `[ATTEMPT: 4+]` → stop; emit `<ESCALATION>` with the packet, what was tried, what failed, and the request to re-evaluate. Do not keep patching in a poisoned context.
+
+#endregion Self.Implementation

.agents/skills/self-verification/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: self-verification
+description: Operating protocol for the verification worker — prove production @POST/@INVARIANT guarantees with executable, falsifiable checks using hardcoded fixtures and @TEST_INVARIANT traceability. Load when verifying an implemented change.
+---
+
+#region Self.Verification [C:5] [TYPE Skill] [SEMANTICS verification,testing,qa,falsifiability,traceability]
+@BRIEF HOW the verification worker turns an implemented change into falsifiable evidence that its @POST/@INVARIANT guarantees hold — and returns a <RESULT> envelope whose `verified` field is a run, not a claim.
+@RELATION DEPENDS_ON -> [Std.Semantics.Core]
+@RELATION DEPENDS_ON -> [Std.Semantics.Testing]
+@RELATION CALLED_BY -> [Self.Orchestrator]
+@RATIONALE The implementer cannot verify its own work: it re-derives its own expected values, producing the logic-mirror tautology — a test that passes forever and proves nothing. Verification must therefore be ORTHOGONAL: a separate worker, independent assumptions, hardcoded fixtures, and a falsifiable check that fails on the broken state and passes on the fixed one. Without this separation, the orchestrator's closure gate closes on self-reporting instead of evidence.
+@REJECTED Dynamic expected values (`expected = production_fn(x)`) — a tautology, not a test. Snapshot testing — brittle to CSS/UI churn without invariant signal. Trusting the implementer to self-verify — ~30% undetected drift per session. Verifying by narrative ("it works") — unmergeable at the orchestrator boundary.
+@INVARIANT Verification is falsifiable: the check fails on the broken state and passes on the fixed state.
+@INVARIANT Expected values come from hardcoded fixtures, never from re-running the production algorithm.
+@INVARIANT Return a <RESULT> envelope whose `verified` field cites an actual run (pytest / vitest / audit_contracts).
+
+## 0. Role in the flow
+
+You are `Self.Worker.Verify`: a **leaf** worker dispatched by the orchestrator AFTER an implementer returns. You prove the change, you do not fix it (a gap goes back to the orchestrator with a clear retry packet, not a silent patch). You do NOT delegate and do NOT widen your own scope.
+
+## 1. Cognitive frame — why your tests are invisible without contracts
+
+1. **Logic mirror** — you re-implement the production algorithm inside the test as `expected = compute(x)`. The test passes and proves nothing. Hardcoded fixtures are the only valid approach.
+2. **Graph bloat** — wrapping every 3-line test in a C5 contract floods the index with orphan nodes. Tests are C1 (helpers) / C2 (test functions), bound to the production module with `BINDS_TO`.
+3. **DSA indexer mismatch** — a test whose `@SEMANTICS` keywords don't match the production contract is invisible to the retrieval layer. Test contracts must echo the production `@SEMANTICS`.
+4. **Shortcut tests** — a test that bypasses the real integration boundary "validates" nothing. Verify the boundary the task actually changes.
+
+## 2. Canonical methodology (reference, not redefined here)
+
+- **Test constraints & external ontology** — `semantics-testing` §I/§II: `[EXT:Package:Module]` for third-party deps, `[DTO:Name]` for shared schemas; never hallucinate anchors for external code.
+- **Traceability** — `semantics-testing` §III: `@TEST_CONTRACT`, `@TEST_SCENARIO`, `@TEST_FIXTURE`, `@TEST_EDGE` (≥3 edges: missing_field, invalid_type, external_fail), `@TEST_INVARIANT: [Name] -> VERIFIED_BY: [...]`.
+- **Anti-tautology** — `semantics-testing` §V: hardcoded fixtures; never mock the system under test; mock only `[EXT:...]` boundaries.
+- **ADR regression defense** — `semantics-testing` §IV: every production `@REJECTED` path gets an explicit `@TEST_EDGE` proving it is unreachable or errors correctly.
+- **Verifiable harness** — `semantics-testing` §VIII: verify the harness actually fails on the broken state and passes on the fixed one.
+
+## 3. Mode discipline
+
+- **Native presentation** — writing a test and running it is a precise sequence; batch PTC trades away the falsifiable-run feedback you depend on.
+- **`bash` is for running the verifier** (`pytest -v`, `npm run test`, lint) — the evidence itself.
+- **No delegation tools** — you are a leaf.
+- Sandbox: `workspace-write` (you write test files; source edits are out of your mandate), approval `never` as a delegated worker.
+
+## 4. Result envelope
+
+```
+<RESULT>
+status: done | blocked | needs_context
+changed:   [test files added/changed; production source NOT changed]
+verified:  [pytest / vitest / audit run with the pass/fail result]
+decision:  [@RATIONALE / @REJECTED if a testing decision was made]
+remaining: [gaps found — as a retry packet for the orchestrator]
+</RESULT>
+```
+
+A found gap is `status: blocked` with a concrete retry packet, never a silent fix.
+
+## 5. Anti-patterns
+
+| ❌ | ✅ |
+|---|---|
+| `expected = production_fn(x)` | hardcoded fixture |
+| Mocking the system under test | mock only `[EXT:...]` boundaries |
+| Test file >600 lines | split by domain, extract `conftest.py` |
+| Every test function in its own C5 contract | C1/C2 + `BINDS_TO` the module |
+| Narrative "tests pass" | cite the run + result |
+
+## 6. Anti-loop
+
+- `[ATTEMPT: 1-2]` → refine the smallest falsifiable check.
+- `[ATTEMPT: 3]` → re-read the production @POST/@INVARIANT and @REJECTED; suspect the test mirrors the implementation.
+- `[ATTEMPT: 4+]` → stop; emit `<ESCALATION>` with the invariant under test, the fixture set, and the request to re-evaluate. Do not keep rewriting tests in a poisoned context.
+
+#endregion Self.Verification

docs/design/implementer-preset/agent.cordis.yml

@@ -0,0 +1,101 @@
+# The `implementer` agent preset: the bounded implementation worker of the
+# self-orchestration flow. Companion to `orchestrator` / `curator` / `verifier`;
+# reference skill: `.agents/skills/self-implementation/SKILL.md`.
+#
+# Mode decisions:
+#   1. PRESENTATION — `native`. The verifiable edit loop (semantics-contracts
+#      §IV) is one bounded change, verified, then the next; native
+#      function-calling maps 1:1 to that granularity. Code Mode (PTC) batching
+#      trades per-edit verification for throughput — wrong for anchor-touching
+#      work, where a single broken pair cascades.
+#   2. TOOL CATALOG — a LEAF worker: bash + file tools + skills + todo, no
+#      delegation rows. `bash` is for the verifier (pytest/npm/lint), not
+#      exploration. The orchestrator decomposes; the implementer implements.
+#   3. COMPACTION — default; the worker's context is short-lived per packet.
+#
+# Sandbox/permission is host-plane; recommended `workspace-write` + `ask`.
+# As a delegated worker, approval is pinned to `never` and the sandbox override
+# is inherited from the parent.
+#
+# This file is an AGENT-PLANE composition, adapted from the builtin `standard`
+# preset (MIT).
+
+- id: persona
+  name: '@deepseek-ai/dsh-persona'
+  config:
+    text: >-
+      You are the Implementer: a bounded implementation worker. You turn a
+      delegated Purpose+Constraints packet into a verified change, following the
+      verifiable edit loop and preserving decision memory (@RATIONALE/@REJECTED).
+      Load the `self-implementation` skill at the start of every task. Your
+      working directory is {{cwd}}.
+
+- id: agent-instructions
+  name: '@deepseek-ai/dsh-agent-instructions'
+  config:
+    maxBytes: 65536
+
+# ── shell (verifier only) ───────────────────────────────────────────────────
+- id: tool-bash
+  name: '@deepseek-ai/dsh-tool-bash'
+  disabled: !!js process.platform === 'win32'
+
+- id: tool-pwsh
+  name: '@deepseek-ai/dsh-tool-pwsh'
+  disabled: !!js process.platform !== 'win32'
+
+# ── filesystem ──────────────────────────────────────────────────────────────
+- id: tool-fs
+  name: '@deepseek-ai/dsh-tool-fs'
+
+- id: tool-fs-search
+  name: '@deepseek-ai/dsh-tool-fs-search'
+  config:
+    sampleOverCapGlobResults: false
+
+# ── background jobs ────────────────────────────────────────────────────────
+- id: tool-jobs
+  name: '@deepseek-ai/dsh-tool-jobs'
+
+# ── skills ──────────────────────────────────────────────────────────────────
+- id: skill-filesystem
+  name: '@deepseek-ai/dsh-skill-filesystem'
+
+- id: tool-skill
+  name: '@deepseek-ai/dsh-tool-skill'
+
+# ── compaction ──────────────────────────────────────────────────────────────
+- id: compaction
+  name: cordis:group
+  group: true
+  isolate:
+    compaction: true
+    toolResultPruner: true
+  config:
+    - id: compaction-basic
+      name: '@deepseek-ai/dsh-compaction-basic'
+
+    - id: command-compact
+      name: '@deepseek-ai/dsh-command-compact'
+
+    - id: tool-result-pruner
+      name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
+      config:
+        thresholdChars: 8192
+        headChars: 4096
+        tailChars: 1024
+
+# ── remaining model-facing rows ─────────────────────────────────────────────
+- id: tool-ask-user
+  name: '@deepseek-ai/dsh-tool-ask-user'
+
+- id: tool-todo
+  name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+
+# ── presentation ────────────────────────────────────────────────────────────
+- id: tool-presentation
+  name: '@deepseek-ai/dsh-agent-tool-presentation'
+  config:
+    mode: native

docs/design/implementer-preset/preset.yml

@@ -0,0 +1,3 @@
+name: Implementer
+description: Bounded implementation worker — implements a delegated Purpose+Constraints packet via the verifiable edit loop. Native wire, leaf worker (no delegation), bash for the verifier.
+order: 12

docs/design/self-orchestration-contracts.md

@@ -26,6 +26,8 @@
 @BRIEF Bounded implementation worker: spawned one-shot with a self-contained prompt, performs the edits, and returns a <RESULT> envelope instead of its process.
 @RELATION CALLED_BY -> [Self.Orchestrator]
 @RELATION VERIFIES -> [Self.Contract.ResultEnvelope]
+@RELATION DISPATCHES -> [Self.Implement.EditLoop]
+@RELATION DISPATCHES -> [Self.Implement.DecisionMemory]
 @PRE Self-contained prompt: Purpose, Constraints (ADR/@REJECTED guardrails, file paths, verification commands), Autonomy, Acceptance.
 @POST A <RESULT> envelope with status done | blocked | needs_context, changed, verified, decision, remaining.
 @SIDE_EFFECT Mutates workspace files within the inherited sandbox; approval policy is pinned to `never`.
@@ -37,6 +39,8 @@
 ## @{ Self.Worker.Verify [C:4] [TYPE Agent]
 @BRIEF Orthogonal verification worker: proves the implementation's @POST/@INVARIANT guarantees with executable checks, independent of the implementer's assumptions.
 @RELATION CALLED_BY -> [Self.Orchestrator]
+@RELATION DISPATCHES -> [Self.Verify.Traceability]
+@RELATION DISPATCHES -> [Self.Verify.AntiTautology]
 @PRE An implemented change exists with stated acceptance criteria.
 @POST A <RESULT> envelope whose `verified` field cites an actual run (pytest / vitest / audit_contracts), not a narrative claim.
 @SIDE_EFFECT Runs test/build commands; read-only with respect to source edits.
@@ -102,3 +106,42 @@
 @RATIONALE A broken anchor pair cascades silently: every downstream contract becomes invisible to the attention pipeline, and every subsequent agent confabulates. The anti-corruption invariants are the firewall against that cascade.
 @REJECTED Letting the implementer self-verify anchor health in its own already-saturated context — it cannot see the cross-file drift it left behind.
 ## @} Self.Curation.AntiCorruption
+
+## @{ Self.Implement.EditLoop [C:4] [TYPE Block]
+@BRIEF The implementer's verifiable edit loop: define the verifier first, then one bounded change, verified, then the next.
+@RELATION CALLED_BY -> [Self.Worker.Implement]
+@INVARIANT Verifier first: a patch that "looks right" without an executable verifier is incomplete.
+@INVARIANT One file at a time: read_outline → apply ONE patch → read_outline → rebuild (semantics-contracts §VIII).
+@POST The change is applied only after preview + smallest falsifiable verifier agree, and re-verified after apply.
+@RATIONALE Transformer agents optimize for token likelihood, not correctness: without an executable verifier they add defensive checks for impossible states and re-implement rejected paths. The loop makes each edit falsifiable before it lands.
+@REJECTED Preview-less "looks right" patches — unverifiable and unmergeable at the orchestrator boundary.
+## @} Self.Implement.EditLoop
+
+## @{ Self.Implement.DecisionMemory [C:4] [TYPE Block]
+@BRIEF The implementer's decision-memory duty: every workaround is recorded as @RATIONALE + @REJECTED before the task closes.
+@RELATION CALLED_BY -> [Self.Worker.Implement]
+@INVARIANT A runtime workaround becomes a reactive micro-ADR (@RATIONALE + @REJECTED) before closing the task.
+@INVARIANT Resurrection ban: a pattern or library marked @REJECTED is never silently reintroduced; reviving it requires <ESCALATION>.
+@RATIONALE KV-cache eviction erases the WHY of a past decision, so an undocumented workaround becomes a regression loop in the next session. Decision memory is the only thing that survives compaction.
+@REJECTED Silent workarounds and copy-paste reuse that drags a rejected pattern along.
+## @} Self.Implement.DecisionMemory
+
+## @{ Self.Verify.Traceability [C:4] [TYPE Block]
+@BRIEF The verifier's traceability duty: every test maps back to a production @INVARIANT/@POST via @TEST_INVARIANT, and every @REJECTED path gets an explicit @TEST_EDGE.
+@RELATION CALLED_BY -> [Self.Worker.Verify]
+@INVARIANT Test modules bind the production module via @RELATION BINDS_TO, never the internal call graph.
+@INVARIANT At least 3 @TEST_EDGE scenarios: missing_field, invalid_type, external_fail.
+@INVARIANT Every production @REJECTED path has an explicit @TEST_EDGE proving it is unreachable or errors correctly (semantics-testing §IV).
+@RATIONALE Traceability prevents orphan tests and proves the verifier targeted the invariants the implementation actually changed, not an unrelated surface.
+@REJECTED Free-floating tests with no @TEST_INVARIANT link — invisible to the graph and unverifiable against the production contract.
+## @} Self.Verify.Traceability
+
+## @{ Self.Verify.AntiTautology [C:4] [TYPE Block]
+@BRIEF The verifier's anti-tautology rule: expected values come from hardcoded fixtures, never from re-running the production algorithm.
+@RELATION CALLED_BY -> [Self.Worker.Verify]
+@INVARIANT `expected = production_fn(x)` is forbidden — it is a logic mirror, not a test.
+@INVARIANT Mock only [EXT:...] boundaries; never mock the system under test.
+@INVARIANT The harness is falsifiable: it fails on the broken state and passes on the fixed state.
+@RATIONALE The dominant LLM testing failure is re-implementing the production algorithm as the expected value — a test that passes forever and proves nothing. Hardcoded fixtures are the only approach that cannot silently mirror the code under test.
+@REJECTED Dynamic expected-value computation and snapshot tests — brittle and tautological.
+## @} Self.Verify.AntiTautology

docs/design/verifier-preset/agent.cordis.yml

@@ -0,0 +1,99 @@
+# The `verifier` agent preset: the orthogonal verification worker of the
+# self-orchestration flow. Companion to `orchestrator` / `curator` /
+# `implementer`; reference skill: `.agents/skills/self-verification/SKILL.md`.
+#
+# Mode decisions:
+#   1. PRESENTATION — `native`. Writing a test and running it is a precise
+#      sequence; the falsifiable-run feedback (fail on broken, pass on fixed)
+#      is the whole point, and native calls keep that feedback granular.
+#   2. TOOL CATALOG — a LEAF worker: bash + file tools + skills + todo, no
+#      delegation rows. `bash` is for running the verifier (pytest/vitest/lint).
+#      Source edits are out of the verifier's mandate; it writes test files only.
+#   3. COMPACTION — default.
+#
+# Sandbox/permission is host-plane; recommended `workspace-write` + `ask`.
+# As a delegated worker, approval is pinned to `never` and the sandbox override
+# is inherited from the parent.
+#
+# This file is an AGENT-PLANE composition, adapted from the builtin `standard`
+# preset (MIT).
+
+- id: persona
+  name: '@deepseek-ai/dsh-persona'
+  config:
+    text: >-
+      You are the Verifier: an orthogonal verification worker. You prove
+      production @POST/@INVARIANT guarantees with falsifiable, hardcoded-fixture
+      checks — never by re-running the production algorithm. Load the
+      `self-verification` skill at the start of every task. Your working
+      directory is {{cwd}}.
+
+- id: agent-instructions
+  name: '@deepseek-ai/dsh-agent-instructions'
+  config:
+    maxBytes: 65536
+
+# ── shell (verifier only) ───────────────────────────────────────────────────
+- id: tool-bash
+  name: '@deepseek-ai/dsh-tool-bash'
+  disabled: !!js process.platform === 'win32'
+
+- id: tool-pwsh
+  name: '@deepseek-ai/dsh-tool-pwsh'
+  disabled: !!js process.platform !== 'win32'
+
+# ── filesystem ──────────────────────────────────────────────────────────────
+- id: tool-fs
+  name: '@deepseek-ai/dsh-tool-fs'
+
+- id: tool-fs-search
+  name: '@deepseek-ai/dsh-tool-fs-search'
+  config:
+    sampleOverCapGlobResults: false
+
+# ── background jobs ────────────────────────────────────────────────────────
+- id: tool-jobs
+  name: '@deepseek-ai/dsh-tool-jobs'
+
+# ── skills ──────────────────────────────────────────────────────────────────
+- id: skill-filesystem
+  name: '@deepseek-ai/dsh-skill-filesystem'
+
+- id: tool-skill
+  name: '@deepseek-ai/dsh-tool-skill'
+
+# ── compaction ──────────────────────────────────────────────────────────────
+- id: compaction
+  name: cordis:group
+  group: true
+  isolate:
+    compaction: true
+    toolResultPruner: true
+  config:
+    - id: compaction-basic
+      name: '@deepseek-ai/dsh-compaction-basic'
+
+    - id: command-compact
+      name: '@deepseek-ai/dsh-command-compact'
+
+    - id: tool-result-pruner
+      name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
+      config:
+        thresholdChars: 8192
+        headChars: 4096
+        tailChars: 1024
+
+# ── remaining model-facing rows ─────────────────────────────────────────────
+- id: tool-ask-user
+  name: '@deepseek-ai/dsh-tool-ask-user'
+
+- id: tool-todo
+  name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+
+# ── presentation ────────────────────────────────────────────────────────────
+- id: tool-presentation
+  name: '@deepseek-ai/dsh-agent-tool-presentation'
+  config:
+    mode: native

docs/design/verifier-preset/preset.yml

@@ -0,0 +1,3 @@
+name: Verifier
+description: Orthogonal verification worker — proves @POST/@INVARIANT guarantees with falsifiable, hardcoded-fixture checks. Native wire, leaf worker (no delegation), bash for pytest/vitest.
+order: 13