@orkestrel/scaffold 0.0.107 → 0.0.108

package/dist/host/AGENTS.md

@@ -70,6 +70,8 @@ configs/  thin target wrappers around root Vite/TypeScript configuration
 
 ## Work loop
 
+Types, tests, and implementation decide every step; comments, TSDoc, and guides follow the final implementation. Report results against the goal, and prefer the smallest change that reaches green over a perfect one.
+
 Size the change before touching a file. Take the largest row whose trigger applies: large, then medium, then small. Run only what the row names.
 
 | Size   | Trigger                                                                                                                                                                                                 | Do                                                                                                                                                                                                           |
@@ -87,7 +89,7 @@ Within the size, in order:
 3. **Implement.** Conform to the types. Place each declaration in its kind file. Update the barrel.
 4. **Test.** Cover happy paths, edge cases, failures, and boundaries with deterministic tests against real implementations. For a defect, record the failing command and count before the fix and the same command green after.
 5. **Consolidate.** Remove duplication, nested functions, and superfluous wrappers without widening the API.
-6. **Document.** Update the matching guide and parity. Prose comes last and stays short.
+6. **Document.** Once the implementation is final, update the matching guide, comments, and TSDoc in one minimal pass. Before then, write, revise, and review no prose.
 
 Test ladder, narrowest first; stop at the boundary the change size names:
 
@@ -96,6 +98,7 @@ Test ladder, narrowest first; stop at the boundary the change size names:
 3. The touched project: `npm run test:<project>`, plus the `check:` script for that project where `package.json` declares one.
 4. Tree-wide gates, once, by `verifier`: `npm run format:check`, `npm run lint:check`, `npm run check`, `npm run build`, `npm test`.
 
+- Run types and behavior tests before format, lint, and guide checks. A format, lint, or guide failure never stops a behavior run; fix it in the final pass.
 - Run the mutating `npm run lint` then `npm run format` only to converge before the non-mutating gates.
 - A writing unit stops at the project boundary and reports the commands it ran. `verifier` runs the tree-wide gates when dispatched for them and edits no source.
 - Never claim a gate passed without running it and reading its output bare, with no `| tail` or `| grep` behind it.
@@ -122,6 +125,7 @@ Each row is a normative extension of this file. Its `paths` frontmatter controls
 | `.claude/rules/documentation.md` | Guides, parity, roadmap, showcase, examples, skill files               |
 | `.claude/rules/writing.md`       | Prose in guides, replies, commits, and instruction files               |
 | `.claude/rules/quality.md`       | Evidence, probes, instruments, performance, research, completion       |
+| `.claude/rules/campaign.md`      | The `.orkestrel/` campaign folder: layout, content, session start      |
 
 ## Writing
 

package/dist/host/agents/orchestration.md

@@ -6,41 +6,44 @@ How agents are dispatched, parallelized, reviewed, and cleaned up. Every harness
 
 Read in order: the user's instruction; `AGENTS.md` and the rules it scopes to your paths; this file; the named skill; the guide. A harness bridge (`.claude/AGENTS.md`, `.codex/config.toml`, `.cursor/rules/orchestration.mdc`) adds mechanics and restates nothing here.
 
+On a harness with no bridge, orchestrate natively, record the harness in the roster, and dispatch no writer or runner lane until a page under `.agents/skills/orkestrel-parallel/references/` answers that skill's bring-up questions for it.
+
 ## Engines
 
 Name the harness family and its access route: Claude through Claude Code or the Claude CLI; Codex through Codex native agents or the Codex CLI; Cursor through the Cursor CLI, with Grok 4.7 Extra High for the Grok bench. Classify GPT-6 Astra, GPT-6.1 Sol, and GPT-6 Luna as Codex-family engines, including when another harness hosts the Orchestrator.
 
-| Engine                  | Job                                                                             | Posture                                                                 |
-| ----------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| Claude Fable 5.1        | orchestration in Claude Code: the plan, every decision, integration, acceptance | never dispatched: never a subagent, a bench, a fork, or a Workflow node |
-| Cursor Grok             | context absorption, distillation, broad mapping, exploration                    | read-only; returns evidence, never decisions                            |
-| Claude Opus 5.5         | subjective design, design-fit review, implementation                            | proposes, audits, implements; never accepts its own work                |
-| GPT-6 Astra             | objective analysis, correctness audit, implementation                           | proposes, audits, implements; never accepts its own work                |
-| Claude Sonnet 5.5       | bounded implementation of a closed shape, ecosystem reconciliation              | executes a fully specified brief                                        |
-| Claude Haiku 5.5        | bench drivers, small precise tasks, exact lookups, conformance, gates           | executes a fully specified brief; edits no source                       |
-| GPT-6.1 Sol, GPT-6 Luna | mechanical units, drivers, small precise tasks, gates, exact lookups            | executes a fully specified brief                                        |
+| Engine                  | Job                                                                             | Posture                                                                                                                                                                               |
+| ----------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Claude Fable 5.1        | orchestration in Claude Code: the plan, every decision, integration, acceptance | never dispatched: never a subagent, a bench, a fork, or a Workflow node, except as the consultant the user names for a wording and coherence pass after research and technical review |
+| Cursor Grok             | context absorption, distillation, broad mapping, exploration                    | read-only; returns evidence, never decisions                                                                                                                                          |
+| Claude Opus 5.5         | subjective design, design-fit review, implementation                            | proposes, audits, implements; never accepts its own work                                                                                                                              |
+| GPT-6 Astra             | objective analysis, correctness audit, implementation                           | proposes, audits, implements; never accepts its own work                                                                                                                              |
+| Claude Sonnet 5.5       | bounded implementation of a closed shape, ecosystem reconciliation              | executes a fully specified brief                                                                                                                                                      |
+| Claude Haiku 5.5        | bench drivers, small precise tasks, exact lookups, conformance, gates           | executes a fully specified brief; edits no source                                                                                                                                     |
+| GPT-6.1 Sol, GPT-6 Luna | mechanical units, drivers, small precise tasks, gates, exact lookups            | executes a fully specified brief                                                                                                                                                      |
 
 The harness's own engine orchestrates: Claude Fable 5.1 or Claude Opus 5.5 in Claude Code, GPT-6 Astra in Codex, Cursor Grok in Cursor. The Orchestrator owns the plan, every decision, integration, and acceptance. When the harness is Codex or the Orchestrator uses a Codex-family engine, use the Codex column: map Opus to GPT-6 Astra, Sonnet to GPT-6.1 Sol, and Haiku to GPT-6 Luna; execute mapped Astra roles natively without an Opus bench probe. Under this mapping, assign review to another agent in a clean context and forbid self-review, including when writer and reviewer both use Astra. For other harnesses, review runs on an engine that did not write the work.
 
 ## Roles
 
-| Role         | Job                                                        | Claude       | Codex       |
-| ------------ | ---------------------------------------------------------- | ------------ | ----------- |
-| `grok`       | absorption, distillation, broad mapping, exploration       | haiku driver | luna driver |
-| `analyst`    | objective design argument or correctness audit on Astra    | haiku driver | astra       |
-| `astra`      | objective, constraint-heavy implementation on Astra        | haiku driver | astra       |
-| `planner`    | subjective design                                          | opus         | astra       |
-| `reviewer`   | design-fit or correctness review                           | opus         | astra       |
-| `opus`       | subjective implementation (API shape, naming, guide voice) | opus         | astra       |
-| `builder`    | one bounded unit with a closed shape, app layer included   | sonnet       | sol         |
-| `checker`    | mechanical conformance against criteria and rules          | haiku        | luna        |
-| `verifier`   | gates and evidence commands, exit-code truth               | haiku        | luna        |
-| `scout`      | exact bounded lookup of files, symbols, seams              | haiku        | luna        |
-| `distiller`  | bulk reading when the Cursor bench is dark                 | haiku        | luna        |
-| `researcher` | primary-source research when the Cursor bench is dark      | haiku        | luna        |
-| `orkestrel`  | ecosystem reconciliation over supplied evidence            | sonnet       | sol         |
+| Role         | Job                                                        | Capability   | Claude       | Codex       |
+| ------------ | ---------------------------------------------------------- | ------------ | ------------ | ----------- |
+| `grok`       | absorption, distillation, broad mapping, exploration       | reader       | haiku driver | luna driver |
+| `analyst`    | objective design argument or correctness audit on Astra    | objective    | haiku driver | astra       |
+| `astra`      | objective, constraint-heavy implementation on Astra        | objective    | haiku driver | astra       |
+| `planner`    | subjective design                                          | subjective   | opus         | astra       |
+| `reviewer`   | design-fit or correctness review                           | subjective   | opus         | astra       |
+| `opus`       | subjective implementation (API shape, naming, guide voice) | subjective   | opus         | astra       |
+| `builder`    | one bounded unit with a closed shape, app layer included   | closed-shape | sonnet       | sol         |
+| `checker`    | mechanical conformance against criteria and rules          | mechanical   | haiku        | luna        |
+| `verifier`   | gates and evidence commands, exit-code truth               | mechanical   | haiku        | luna        |
+| `scout`      | exact bounded lookup of files, symbols, seams              | mechanical   | haiku        | luna        |
+| `distiller`  | bulk reading when the Cursor bench is dark                 | reader       | haiku        | luna        |
+| `researcher` | primary-source research when the Cursor bench is dark      | reader       | haiku        | luna        |
+| `orkestrel`  | ecosystem reconciliation over supplied evidence            | closed-shape | sonnet       | sol         |
 
 - Name the role and its engine in every dispatch. Reach a role by its own name.
+- On a harness with no column, map each capability to an engine in the roster and route by that map; add the harness's column here when it carries campaign work.
 - A driver launches another harness's CLI and returns the journal path and session id with the result. It never judges or implements. Refuse a bench result that carries no journal path and session id; it ran on the driver.
 - `.agents/transports/<harness>.md` owns each bench's invocation, sandbox, journal, and recovery. `.claude/agents/` and `.codex/agents/` hold one file per role.
 
@@ -50,20 +53,34 @@ The harness's own engine orchestrates: Claude Fable 5.1 or Claude Opus 5.5 in Cl
 - Route all context absorption, distillation, broad mapping, and exploratory or fishing reads to `grok` on Cursor Grok 4.7 Extra High: terrain, prior art, diff sweeps, scattered sources. Keep decision-bearing reading with the decision owner. Fall back to `distiller` or `researcher` only when the Cursor bench is dark, and record the fallback; ease or cost never authorizes a fallback.
 - Keep small tedious precise tasks native: Claude Haiku in Claude, Codex Luna in Codex. Use `scout` for an exact bounded lookup; keep bench drivers, `checker`, and `verifier` on their mapped native engines. A bounded file scope does not turn context absorption or exploratory reading into a native lookup.
 - Route gates to `verifier`. A writer's self-reported gate is not evidence.
+- Under the Codex mapping, put falsify lanes on Astra or Sol at high effort; keep Luna for gates and verifier runs, never for a lane that must resolve runtime claims.
 - Work directly on a one-file change or a one-line fix, subject to the preceding routing rules. Route standalone lookups through `scout`. Dispatch when isolation, parallelism, a second engine, or a large read pays for the brief.
 
 ## Sessions and consultation
 
 - Before launching a unit, check the roster for an existing session whose responsibility, model, permissions, workspace, and retained context fit the task, and resume it. Keep related tasks for one responsibility in that session.
 - Start a fresh session when no suitable session survives, the work is unrelated, or retained context would compromise the judgment. Use fresh contexts for independent review and the blind design round. An agent that helped design or implement the subject cannot independently review that contribution.
-- Record the session identity separately from its task, turn, process, and message address. Record each session's harness, provider, model, options, workspace, responsibility, owned paths, continuation address, latest task, and evidence paths in the roster, and preserve its prior task results.
+- Record the session identity separately from its task, turn, process, and message address. Record each session's harness, provider, model, options, workspace, responsibility, owned paths, continuation address, most recent task, and evidence paths in the roster, and preserve its prior task results. The roster is `coord/roster.md` of the live `orkestrel-parallel` round, or `tmp/units/roster.md` when no round is live.
 - Treat a live writer as an agent with an active assignment and edit authority. A retained session without an assignment holds no resource merely by existing. Preserve an explicit hold until its owner releases it.
 - Continue a unit through compaction. Before a handoff or context limit, record decisions, changed instructions, source identity, unresolved questions, failed and passing evidence, active process identities, ownership, and the next action. Compaction neither completes a task nor releases its files or processes.
 - On continuation, the Orchestrator sends the next bounded objective and the facts changed after the last turn. The continued agent reads changed or missing authority and the source regions that objective needs, and rechecks mutable facts such as source state and process liveness. Do not repeat unchanged bulk reads merely because a unit resumes.
 - Consult a suitable peer when a consequential approach remains open, evidence conflicts, or repeated attempts stop narrowing a failure. Give the peer the question, relevant evidence, attempted approaches, constraints, and requested answer. Use an existing specialist when its context helps and a fresh peer when the question needs an independent challenge.
 - Keep consultation read-only and bounded. Ask for a recommendation, its evidence, uncertainty, and a concrete next check. The executor retains the work; the Orchestrator rules on scope and acceptance. Advice grants no authority and does not satisfy an independent review gate.
 - Resolve conflicting advice against the contract and observable evidence. Do not add consultation to routine steps or repeat it without a changed question or evidence.
-- When a requested transport fails, record the failure and whether a child was created. Before retrying an uncertain launch, inspect the recorded task or session. Use a permitted fallback with its actual model and options disclosed; retry a refused route only after a relevant condition changes.
+- When a requested launch channel fails, record the failure and whether a child was created. Before retrying an uncertain launch, inspect the recorded task or session. Use a permitted fallback with its actual model and options disclosed; retry a refused route only after a relevant condition changes.
+
+## Memory
+
+- Agent memory is per user and per machine; it travels with neither the repository nor the harness. Keep only machine-local facts and pointers to tracked files there: paths, accounts, engine availability, process ids.
+- When a ruling, correction, or lesson arrives, write it to its tracked home in the same turn: ecosystem law in the scaffold repository, a package decision in its campaign folder, a harness mechanic on its page under `.agents/skills/orkestrel-parallel/references/`, a platform quirk on its page under `.agents/platforms/`. No tracked file cites memory.
+
+## Pace
+
+- Spend process only where it changes a result. Launch, run, and report: no fixed clock windows, readiness-only turns, per-command acknowledgments, hash pins of a brief, or process queries beyond the recorded process ids.
+- Re-run a check only when its inputs changed; never repeat a passing check to collect another receipt.
+- Ask the user only for a decision that is theirs: scope, a conflicting ruling, a credential, publication, or a commit or push the law reserves. Decide routine matters yourself, such as time and lane allowances, retries, and order, and report them.
+- Never end a turn with work pending and nothing that will wake the session: run the work as a tracked background command or a child whose completion notifies, or schedule a wake. While a lane runs, continue independent work.
+- Keep the goal, the current step, and the next action visible in the campaign plan, and report progress against the goal at each milestone.
 
 ## Size gate
 
@@ -76,16 +93,17 @@ The harness's own engine orchestrates: Claude Fable 5.1 or Claude Opus 5.5 in Cl
 | large  | one independent round: `planner` and `analyst`, same brief, clean contexts, blind to each other | disjoint units in parallel                     | one `orkestrel-falsify` round on the integrated result                                                       | `verifier` tree-wide, once         |
 
 - Never run a review on a small change. Never run a second design round on the same brief.
+- A review judges types, tests, and implementation. It reports comment, TSDoc, or guide wording only where the text contradicts the final behavior, and no fix round opens for prose alone.
 - A fix round re-audits the repaired claim only. A fix that adopted the reviewer's prescription verbatim closes with a mutation probe (disable the load-bearing line, watch the test fail, restore it). A fix that departs from it gets one pass by an independent reviewer per § Engines.
 - When review rounds at one seam keep surfacing defects without converging on their source, follow `.agents/skills/orkestrel-falsify/SKILL.md` § End the depth search.
 - An all-confirmed round ends the audit. A round needs an added or repaired claim to test; reviewer appetite is not a subject.
 
 ## Campaign
 
-A large change runs these phases once each, in order, and ends when the exit criterion written at the start is met.
+A large change opens with a concise goal and its exit criterion, short enough to serve as a goal prompt. It runs these phases once each, in order, and ends when that exit criterion is met.
 
 1. **Absorb.** Map the terrain with the `orkestrel-scout` skill's `map.ts`, then `grok` distills it and the prior art. In an Orkestrel repository, `verifier` or another tool-capable role collects manifests, lockfiles, installed declarations, and registry readings, and `orkestrel` reconciles them.
-2. **Design.** One independent round: `planner` (subjective) and `analyst` (objective) on one brief, clean contexts, blind to each other. Reconcile into one plan: units, owned files, dependencies, parallel and serial order, acceptance criteria, exit criterion, routing ledger.
+2. **Design.** One independent round: `planner` (subjective) and `analyst` (objective) on one brief, clean contexts, blind to each other. Reconcile into one plan: units, owned files, dependencies, parallel and serial order, acceptance criteria, exit criterion, ledger.
 3. **Implement.** Dispatch units per § Routing and § Parallelism.
 4. **Integrate.** Apply returned patches to shared files serially. A type, mechanism, or criterion found here is a successor unit, never an integration edit.
 5. **Audit.** One `orkestrel-falsify` round on the integrated result, an independent reviewer per § Engines in each lane; add `checker` when the criteria are mechanical.
@@ -97,7 +115,10 @@ A large change runs these phases once each, in order, and ends when the exit cri
 
 - Parallelize independently owned work when useful progress can overlap. Reuse suitable sessions per § Sessions and consultation, bound each objective, and count coordination and verification costs when choosing the lanes. § Cache governs model and tool settings.
 - Judgment stays narrow: a design or review pass is at most the two lanes the size gate names, each in a clean context, blind to the other, and it runs once. Never fan judgment out further, and never run it as a loop.
+- Keep every lane, in this session and in peer sessions on the same machine, within the host budget of `.agents/skills/orkestrel-parallel/SKILL.md` § Bound the host.
 - One writer per checkout, except under `orkestrel-parallel`: there, at most three writers share one checkout, each owns disjoint files and disjoint regions of shared files, and one runner lane owns every test, check, and build process. Otherwise give parallel writers disjoint owned files, and give a writer its own worktree under `tmp/worktrees/` only when two units must write the same files at once. Commit a checkpoint before a writing dispatch.
+- Fold every branch, clone, copy, or worktree an agent creates back into the original checkout's main branch with its changes left uncommitted there, so the user sees the whole difference from that branch. Commit inside the branch, clone, copy, or worktree as its unit needs, then remove it and delete its branch.
+- In a checkout another session shares, read the branch and `git status` before a write, and stop and ask the user when another session's uncommitted work is present.
 - Shared files are report-only; a unit returns an exact patch. Under `orkestrel-parallel`, a writer edits its owned regions of a shared file directly.
 - Scope validation by the claim and its input dependencies, not by writer ownership alone. Under `orkestrel-parallel`, the runner owns checks and obtains the required write holds. Preserve valid receipts; rerun a check when its inputs, configuration, environment, or claim changed. Never run tree-wide `format`, lint `--fix`, or `build` beside a live writer.
 - One Grok lane at a time; queue the rest. An empty lane beside a live probe is starvation, not darkness.
@@ -122,7 +143,7 @@ Every working file lives under the checkout's gitignored `tmp/`, in the director
 | Directory                                  | Holds                                                                                              |
 | ------------------------------------------ | -------------------------------------------------------------------------------------------------- |
 | `tmp/claude/`, `tmp/codex/`, `tmp/cursor/` | bench briefs, launch scripts, journals, `.err` files, last-message files, login logs, per harness  |
-| `tmp/units/`                               | native unit briefs, reports, claims files, and campaign records                                    |
+| `tmp/units/`                               | native unit briefs, reports, claims files, and unit records                                        |
 | `tmp/probes/`                              | runtime probes the `probe` Vitest project collects and the `probe` MCP server arms                 |
 | `tmp/type/`                                | the type stage's workspace mirror, owned by `@orkestrel/probe`                                     |
 | `tmp/captures/`                            | screenshots, resolved-style snapshots, and other capture portfolios                                |
@@ -131,28 +152,20 @@ Every working file lives under the checkout's gitignored `tmp/`, in the director
 
 ## .orkestrel layout
 
-`.orkestrel/` is the campaign folder: tracked, deleted in the acceptance commit, never a home for a rule. A nested directory belongs to one package; a file at the top level belongs to the ecosystem.
-
-| Path                    | Holds                                                                                                                                    |
-| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| `.orkestrel/<package>/` | one package's live campaign: its `plan.md`, its routing ledger, the verdicts of its open seams, and its exposure records                 |
-| `.orkestrel/plan.md`    | the live fleet campaign's plan: goal, exit criterion, packages, layer order, and the units each package owes                             |
-| `.orkestrel/ledger.md`  | the fleet campaign's routing ledger: every dispatch, engine, and bench substitution across packages                                      |
-| `.orkestrel/release.md` | the live release wave: its layers, each package's bump ruling with its evidence, the round each package landed in, and standing readings |
-
-- Write a file about one package under that package's directory and never at the top level; write a file about two or more packages at the top level and never under a package.
-- Delete a package directory in that campaign's acceptance commit and a top-level file when the wave or fleet campaign it records closes. `sweep.ts --report` lists both.
+`.orkestrel/` is the campaign folder, never a home for a rule. `.claude/rules/campaign.md` owns its layout, its content, its deletion, and how a session starts from it and hands it off. Read that rule at the start of every session in a repository that has the folder, whether or not the harness loads it by path.
 
 ## Dispatch
 
 `orkestrel-dispatch` owns the brief template, launch mechanics for native and bench units, long-running commands, liveness, and recovery. Load it before a bench lane, a campaign unit, or any command that outlives the turn. The floor that follows binds every dispatch.
 
-- A small native unit's brief is the dispatch message: scope, law references, expected result. Write a brief file with the dispatch skill's `scripts/brief.ts` at `tmp/units/<unit>-brief.md` (native) or `tmp/<bench>/<unit>-brief.md` (bench) when the unit is a bench lane, belongs to a campaign, or may need re-running. A re-run gets `<unit>-brief-<n>.md`; never edit a launched brief.
+- A small native unit's brief is the dispatch message: scope, law references, expected result. Write a brief file with the dispatch skill's `scripts/brief.ts` at `tmp/units/<unit>-brief.md` (native) or `tmp/<bench>/<unit>-brief.md` (bench) when the unit is a bench lane, belongs to a campaign, or might need re-running. A re-run gets `<unit>-brief-<n>.md`; never edit a launched brief.
 - State in every brief: role and engine, one objective, the evidence slice, owned and off-limits files, the acceptance criteria cheap-first, the return shape, the deviation contract, and that the executor performs the work itself and spawns nothing.
 - Capture a campaign unit's report to `tmp/units/<unit>-report.md`, or read the bench's last-message file.
 - Launch every multi-minute command as a harness-tracked background command through `node .agents/skills/orkestrel-dispatch/scripts/launch.ts` under a cap sized from prior runs, and read a bench answer with that skill's `scripts/result.ts`. Every launcher, probe, and instrument is a TypeScript file run by `node`, never a shell or Python script. Read liveness from the artifact the work produces. Kill only a recorded process id, never a pattern, and confirm the process and its descendants are gone before another writer takes its files.
 - Probe a bench with the dispatch skill's `scripts/bench.ts` before its first lane, and re-read liveness at every dispatch after a failure.
 - Send a changed decision to every affected session before it continues, including an idle session selected for reuse. Preserve the original brief and supply a checked successor brief when scope or acceptance changes.
+- Commit every tracked record edit before a dispatch whose entry reads `git status`, and edit only ignored files while that unit runs.
+- `.agents/platforms/<platform>.md` owns the host shell's commands and quirks; read it before the first command on that host. On a host family with no page, write one from measurement before the first long command.
 
 ## Deviation protocol
 
@@ -163,14 +176,14 @@ The Orchestrator triages: obvious correction → tighten and re-dispatch; missin
 ## Benches
 
 - Probe a bench with the dispatch skill's `scripts/bench.ts` and the model its transport pins before its first lane in a session. A version string or a login status is not liveness.
-- For a harness that uses a bench, record a dispatch that fails on auth, quota, model access, or network as bench dark and re-plan the lane: Astra bench dark → Claude Opus holds the objective lane too; Claude Opus bench dark → Astra holds the subjective lane too; Grok dark → the harness's native reader, `distiller` or `researcher`: Claude Haiku 5.5 in Claude Code, GPT-6 Luna under the Codex mapping. When Haiku refuses the read, re-dispatch the role with `model: sonnet`. Record every substitution in the routing ledger. For a native role failure, use § Deviation protocol without a Claude fallback prerequisite.
+- For a harness that uses a bench, record a dispatch that fails on auth, quota, model access, or network as bench dark and re-plan the lane: Astra bench dark → Claude Opus holds the objective lane too; Claude Opus bench dark → Astra holds the subjective lane too; Grok dark → the harness's native reader, `distiller` or `researcher`: Claude Haiku 5.5 in Claude Code, GPT-6 Luna under the Codex mapping. When Haiku refuses the read, re-dispatch the role with `model: sonnet`. Record every substitution in the brief and in the commit that carries the unit. For a native role failure, use § Deviation protocol without a Claude fallback prerequisite.
 - Never assign Grok a design or review lane in Claude Code or Codex.
 - Journal every bench run under `tmp/<bench>/` with its session id. Never commit a journal.
 
 ## Cleanup
 
-- When a unit is accepted, carry its measurements, unresolved findings, and any instrument worth keeping into the commit message, the campaign ledger, or a test, then delete its `tmp/units/<unit>-*` files and its bench journals.
-- `.orkestrel/` holds only what § .orkestrel layout names. Delete a verdict when its seam closes and the package directory in the acceptance commit; git history is the archive.
+- When a unit is accepted, carry its measurements, unresolved findings, and any instrument worth keeping into the commit message, a tracked design, or a test, then delete its `tmp/units/<unit>-*` files and its bench journals.
+- `.claude/rules/campaign.md` owns what `.orkestrel/` holds and when each file goes; git history is the archive.
 - Delete a probe from the source tree before the unit returns; promote a probe that settled a claim into a test.
 - Run `node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --report` at acceptance; it lists leftovers under `tmp/` and `.orkestrel/` by age and deletes nothing. Run the same script with `--tmp` after the last live unit exits; it deletes files older than its threshold and refuses while a journal is changing.
 - A campaign artifact never lives in the package it is about.
@@ -186,5 +199,7 @@ The Orchestrator triages: obvious correction → tighten and re-dispatch; missin
 
 - No writer's and no bench's self-assessment is authoritative. The Orchestrator accepts after the review and the gates the size gate names.
 - Accept when the exit criterion is met and the gates are green. Reopening an accepted criterion is the user's instruction, not a reviewer's finding.
-- Substitute an engine only when the same session recorded the bench dark; name the fallback in the ledger.
+- Substitute an engine only when the same session recorded the bench dark; name the fallback in the brief and the carrying commit.
+- In a repository whose package the registry already serves, commit on the main branch and push it only on the user's go-ahead.
+- Commit by explicit paths. Before a push, read `git log @{upstream}..` and push only commits meant to publish together; hold a push while a commit depends on an unpublished local pin.
 - Publishing is the user's decision and credential; `orkestrel-publish` owns the release procedure, the bump rules, and the dependency-tarball rules.

package/dist/host/agents/platforms/posix.md

@@ -0,0 +1,15 @@
+# POSIX host
+
+The commands an agent runs on a Linux or macOS host. `.claude/rules/portability.md` owns product code that runs on these hosts; `.agents/skills/orkestrel-dispatch/references/launch.md` owns the portable launch and kill procedure this page serves.
+
+## Processes
+
+- Read liveness with `kill -0 <pid>`; exit 0 means alive.
+- List descendants by running `ps -A -o pid= -o ppid=`, taking the rows whose parent is the recorded pid, then each listed id in turn. Never take a pid from `pgrep -f` or `pkill -f`.
+- Kill each listed id and the recorded pid with `kill -KILL <id>`. `launch.ts` kills only the command at its cap on this host; kill the listed descendants of a capped run by hand.
+- No detach procedure is proven on this host. Before a run relies on one, prove that a detached run outlives the harness's idle stop, and record the procedure here with its date.
+
+## Shell
+
+- Gate a command on the previous one with `&&`, and read `$?` immediately after the command it reports on.
+- Pass arguments as an array from a TypeScript launcher rather than through shell quoting.

package/dist/host/agents/platforms/windows.md

@@ -0,0 +1,37 @@
+# Windows host
+
+The commands an agent runs on a Windows host, and their quirks. `.claude/rules/portability.md` owns product code that runs on Windows; `.agents/skills/orkestrel-dispatch/references/launch.md` owns the portable launch and kill procedure this page serves.
+
+## Processes
+
+- Read liveness with `Get-Process -Id <pid>` in PowerShell, or under Git Bash from the output of `tasklist //FI "PID eq <pid>" //NH`: a row naming the pid means alive, and the `INFO:` line means gone. Never read liveness from `tasklist`'s exit code, `kill -0`, or `ps -eo`.
+- List descendants with `Get-CimInstance Win32_Process -Filter "ParentProcessId=<pid>"`, applied to each listed id in turn. Under Git Bash, run it through `powershell -NoProfile -Command`, and write every Windows slash option as `//`.
+- Kill a recorded tree with `taskkill /pid <pid> /T /F`. `launch.ts` kills the tree at its cap on this host.
+- Detach a run from the session's process tree with WMI: `Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = '<command>' }`. The run starts under `WmiPrvSE.exe`, outside the session's job and process tree (verified 2026-10-16). It receives the user's registry environment, not the caller's, so pass each value it needs on its command line. Record its journal and pid-file paths before the launch.
+- Spawn npm without a shell through its JavaScript entry: `node <node directory>/node_modules/npm/bin/npm-cli.js <arguments>`. A `.cmd` shim cannot start without a shell, and `launch.ts` reports exit `127`.
+- A child CLI can leak orphaned `conhost.exe` processes and open console windows. Count them with `Get-Process conhost` at each launch while such a lane is live.
+
+## PowerShell 5.1
+
+- Chain with `;` and gate with `if ($?) { ... }`; `&&` and `||` are parse errors.
+- Edit text with the harness's file tools, never `Get-Content` piped through `-replace` into `Set-Content`. `-replace` matches case-insensitively, `Set-Content` writes the ANSI code page, `Set-Content -Encoding utf8` and `Out-File` write a byte-order mark, and the round trip turns non-ASCII punctuation into mojibake.
+- Write a commit message to a file with the harness's file tool and commit with `git commit -F <file>`. A here-string carrying double quotes splits into stray arguments, and a byte-order mark in the file lands in the commit subject.
+- Never pipe a command whose exit code gates the next step, a `node` probe included, into `Select-Object -First` or `-Last`. The cut pipeline kills the command early and leaves a misleading `$LASTEXITCODE`. Run it bare, read `$LASTEXITCODE`, or decide from `git status --porcelain` and `git rev-parse`.
+- PowerShell drops a bare `--` before a native command, so `npm run <script> -- <arguments>` loses the separator. Run the tool's own entry with an argument array, or call `npm.cmd`.
+- `Start-Process -ArgumentList` splits an element that contains spaces into several arguments. Put the launch in a TypeScript file run by `node`. `Start-Process` also detaches with no completion notice.
+- Pass an absolute path to every .NET file call; `[System.IO.File]` resolves a relative path against the process directory, which `Set-Location` does not move.
+- `Get-Content` without `-Encoding` reads a UTF-8 file with no byte-order mark as ANSI. Read with `-Encoding utf8` before concluding the bytes are corrupt.
+- `*>` writes UTF-16LE. Redirect large output through a Node writer.
+- Inside a double-quoted string, write `${name}:`; `$name:` parses as a drive reference.
+- `Get-FileHash` prints uppercase hexadecimal, and Node's `createHash` prints lowercase. Compare digests case-insensitively.
+- Redirecting a native command's standard error with `2>&1` wraps each line in an error record and sets `$?` to false on success. Let the harness capture standard error.
+
+## Harness approval on this host
+
+- Keep every program-carrying command in a TypeScript file run by `node`. A heredoc, `node -e`, an `&&` chain, or a `${...}` argument trips the harness's approval classifier; a one-shot read-only check can run inline.
+- Run a `Remove-Item` as its own short command with a relative path. The classifier blocks a command that pairs it with a path-like literal elsewhere, such as a `'\'` string. Verify with `git status`.
+
+## Deleting untracked files
+
+- When a sweep you run by hand deletes untracked files, send them to the Recycle Bin through a shell file operation with undo, never permanent deletion, and report what went there. Leave emptying the bin to the user; hand them `Clear-RecycleBin -Force`.
+- Remove a worktree with `git worktree remove`. Delete a leftover `node_modules` junction without recursing into its target.

package/dist/host/agents/skills/orkestrel-debrief/references/retention.md

@@ -10,7 +10,7 @@ carrier. A campaign that accepts with no debrief arrives at acceptance, per
 either door.
 
 Call the `.orkestrel/` folder the campaign folder, never a ledger. The word `ledger` names the
-routing ledger and the carry ledger only.
+campaign's ledger file and the carry ledger only.
 
 ## The gate order
 
@@ -33,15 +33,15 @@ step.
 
 Rule on every location in this table before deleting anything.
 
-| Location                | What it holds                                                                                                                                       | What the prune does                                                                                                                 |
-| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
-| `.orkestrel/<package>/` | One package's live campaign per `.agents/orchestration.md` § .orkestrel layout: its plan, routing ledger, open-seam verdicts, and exposure records. | Deleted in the prune commit.                                                                                                        |
-| `.orkestrel/*.md`       | The ecosystem's records per the same section: the fleet campaign's `plan.md` and `ledger.md`, and the release wave's `release.md`.                  | Deleted in the prune commit of the wave or fleet campaign each records.                                                             |
-| `tmp/units/`            | A native unit's `<unit>-brief.md` and `<unit>-report.md` pair.                                                                                      | Swept after the unit's measurements and unresolved findings are carried into the acceptance record, the campaign ledger, or a test. |
-| `tmp/<bench>/`          | A bench unit's brief, report, event stream, final answer, and any login log.                                                                        | Swept after the final gate evidence is recorded. Never committed.                                                                   |
-| `tmp/probes/`           | The runtime probes the campaign wrote.                                                                                                              | Swept. A probe that settled a claim becomes a test before the prune, per `.claude/rules/quality.md` § Instruments.                  |
-| `ROADMAP.md`            | The repository's sequenced plan of record, where it keeps one.                                                                                      | Kept. Strike the chunks the campaign closed and add the forward work it revealed.                                                   |
-| `PROPOSAL.md`           | A proposal for work nobody has ruled on yet.                                                                                                        | Deleted after the work lands or the proposal is refused. The ruling goes in the prune commit message.                               |
+| Location                | What it holds                                                                                                                                | What the prune does                                                                                                              |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `.orkestrel/<package>/` | One package's live campaign per `.claude/rules/campaign.md` § Layout: its plan, ledger, open-seam verdicts, and the records that rule names. | Deleted in the prune commit, after each file that outlives the campaign moves to its root home.                                  |
+| `.orkestrel/*.md`       | The ecosystem's records per the same section: the fleet campaign's `plan.md` and `ledger.md`, and the release wave's `release.md`.           | Deleted in the prune commit of the wave or fleet campaign each records.                                                          |
+| `tmp/units/`            | A native unit's `<unit>-brief.md` and `<unit>-report.md` pair.                                                                               | Swept after the unit's measurements and unresolved findings are carried into the acceptance record, a tracked design, or a test. |
+| `tmp/<bench>/`          | A bench unit's brief, report, event stream, final answer, and any login log.                                                                 | Swept after the final gate evidence is recorded. Never committed.                                                                |
+| `tmp/probes/`           | The runtime probes the campaign wrote.                                                                                                       | Swept. A probe that settled a claim becomes a test before the prune, per `.claude/rules/quality.md` § Instruments.               |
+| `ROADMAP.md`            | The repository's sequenced plan of record, where it keeps one.                                                                               | Kept. Strike the chunks the campaign closed and add the forward work it revealed.                                                |
+| `PROPOSAL.md`           | A proposal for work nobody has ruled on yet.                                                                                                 | Deleted after the work lands or the proposal is refused. The ruling goes in the prune commit message.                            |
 
 A plan-of-record file is not campaign residue. `ROADMAP.md` outlives every prune and takes the
 campaign's forward work; `PROPOSAL.md` is spent the moment its proposal is ruled on, and a spent

package/dist/host/agents/skills/orkestrel-dispatch/SKILL.md

@@ -19,7 +19,7 @@ description: >-
 | `scripts/result.ts`  | `--cursor\|--claude\|--codex JOURNAL [--out PATH]` prints the session id, the answer length, the run's `exit`, `capped`, and `durationMs` from the errors file, and the journal's `bytes`, `ageMs`, and `lastEvent`. Exit 3 when the journal carries no session or answer.                                                                                                                                                                                                                                                              |
 | `scripts/cite.ts`    | `PATH [--root DIR] [--json]` lists every `file:line` citation in a report whose file does not exist or whose line is past the end. Exit 3 when one does not resolve.                                                                                                                                                                                                                                                                                                                                                                    |
 | `scripts/helpers.ts` | Import with `.ts`: `readOption`, `readOptions`, `readList`, `listFiles`, `readJsonObject`, `readString`, `readNumber`, `normalizeSlashes`, `resolveNpm`, `runNpm`, `SPEC_FIELDS`, `LOCAL_SPEC_PATTERN`, `ARCHIVE_SPEC_PATTERN`, `SHORTHAND_SPEC_PATTERN`, `matchesLocalSpec`, `collectSpecs`, `scanLocalSpecs`, `removeTree`, `isRecord`. Runs nothing.                                                                                                                                                                                 |
-| `scripts/sweep.ts`   | `--report` lists leftovers under `tmp/` and `.orkestrel/` by age and deletes nothing; `--tmp [--older-than MINUTES]` deletes stale launch files and refuses while a journal is changing; `--unit UNIT [--delete]` lists or deletes one accepted unit's brief, report, claims, journal, errors, status, pid, and last-message files.                                                                                                                                                                                                     |
+| `scripts/sweep.ts`   | `--report` lists leftovers under `tmp/` and `.orkestrel/` by age, deletes nothing, and flags a `.orkestrel/**/*.md` line that cites a backticked path git ignores or names a machine path; `--tmp [--older-than MINUTES]` deletes stale launch files and refuses while a journal is changing; `--unit UNIT [--delete]` lists or deletes one accepted unit's brief, report, claims, journal, errors, status, pid, and last-message files; `--tmp` and `--unit --delete` keep every file git tracks and print `kept tracked <path>`.      |
 
 ## Write the brief
 
@@ -28,13 +28,14 @@ description: >-
 3. Scope by what the change makes false: run the `orkestrel-scout` skill's `map.ts --refs` and `--census` for an existing member of any enumerated population the unit extends, and own every file that comes back, with the tests that pin the behavior, the fixtures derived from a constant, and the materialized copy of a template.
 4. Order acceptance criteria cheap-first (regenerate, typecheck, lint, scoped test). Name a timing-sensitive or tree-wide gate as an observation, not a criterion.
 5. State that the executor performs the work itself and spawns nothing. A bridge driver carries the brief unaltered and returns the journal path and session id.
-6. Name the host conditions the unit will hit: shell, sandbox, network, files expected dirty, commands known to fail.
-7. Run `brief.ts --check <brief>` and fix every missing path before the launch.
+6. Name the host conditions the unit will hit: shell, sandbox, network, files expected dirty, commands known to fail. Give absolute paths for work outside the session's root; a lane's shell can restart in another directory between calls.
+7. Fill each placeholder at its value sites only; a global replace also rewrites a stop clause that names the placeholder.
+8. Run `brief.ts --check <brief>` and fix every missing path before the launch.
 
 ## Launch
 
-- Select continuation or a fresh session per `.agents/orchestration.md` § Sessions and consultation. Use the message or resume mechanism the harness's live tool descriptions name, and record the session and task identities it returns. Read the harness reference named by `.agents/skills/orkestrel-parallel/SKILL.md` § Assign lanes for T3 and native channel mechanics.
-- For a fresh native Claude Code unit, use the Agent tool with the role as `subagent_type`; for native Codex, use the custom agent by name. Use T3 `delegate_task` when the selected provider, model, options, or workspace require it.
+- Select continuation or a fresh session per `.agents/orchestration.md` § Sessions and consultation. Use the message or resume mechanism the harness's live tool descriptions name, and record the session and task identities it returns.
+- Start a native unit by the Start row of the session's harness page under `.agents/skills/orkestrel-parallel/references/`; that row also names when a hosting harness's child-task channel replaces the native one.
 - Bench: run `bench.ts --<bench>` once per session before the first lane, then launch the transport contract's command through `launch.ts` in the background with `--status`.
 - Size the cap from the `durationMs` that `result.ts` reported for comparable runs, plus gate time, plus slack. Never let the unit name it.
 - Confirm the launch within a minute with `result.ts`: `bytes` past the header and a small `ageMs`. An instantly dead journal is a failed launch; read its errors file.

package/dist/host/agents/skills/orkestrel-dispatch/references/launch.md

@@ -4,27 +4,31 @@ Apply these rules to every command that outlives the turn that starts it: a benc
 
 ## Launch
 
-- Launch as a harness-tracked background command through `scripts/launch.ts` under a hard cap. Never detach a run from inside a dispatched agent; an unowned run has no completion signal and no death notice.
-- On Windows, launch npm through its JavaScript entry, `node <directory of node>/node_modules/npm/bin/npm-cli.js ARGS`: `launch.ts` spawns with no shell, a `.cmd` shim cannot start that way, and the launcher reports exit `127`.
+- Launch as a harness-tracked background command through `scripts/launch.ts` under a hard cap, per § Launch ownership.
+- Spawn a package manager through its JavaScript entry; `.agents/platforms/<platform>.md` names the entry and the shell quirks of each host.
 - Write a multi-step chain as a TypeScript file run by `node`, with an opening comment naming its log, its cap, and what changed from the file it supersedes. Never edit a script while it runs: copy, edit the copy, launch the copy.
-- On Windows, keep every program-carrying command in a file: a heredoc, `node -e`, an `&&` chain, or a `${...}` argument trips the approval classifier.
 - Run the first use of any flag, subcommand, or quoting form in a throwaway probe, never inside a unit.
 - Keep network-dependent work (installs, lockfile generation, live fetches) out of sandboxed bench execs.
 - Confirm the journal advanced past its header before recording the launch as started; `scripts/result.ts` reports `bytes` and `ageMs`.
 - Never push a git commit through a hosting REST API when a file's content must ride in the request; the per-call cap truncates it.
 
+## Launch ownership
+
+- Give every run one owner whose lifetime exceeds the run: the owner holds the journal, the pid file, and the cap. A dispatched agent never detaches a run; its turn can end before the run does.
+- When the expected duration exceeds the harness's background cap or idle-session window, which its page under `.agents/skills/orkestrel-parallel/references/` states, the Orchestrator starts the run outside the session's process tree by the detach procedure of `.agents/platforms/<platform>.md`. Record the journal and pid-file paths in the unit's records before the launch, and read liveness from the journal. No other session kills that pid.
+- On a host whose platform page records no proven detach procedure, keep the session in its turn for the run's whole duration.
+
 ## Watch
 
-- Arm one Monitor per long exec, filtered to milestones and terminal states, exiting on the terminal event. Never stream the raw journal.
-- A Workflow journal writes only at agent start and result; read liveness from the newest subagent transcript. Recover with `resumeFromRunId`.
+- Watch each long exec through one harness-native watcher (Claude Code's Monitor), filtered to milestones and terminal states and exiting on the terminal event; on a harness with none, wait for its completion notice. Never stream the raw journal.
+- Read a harness fan-out run's liveness and recover it per its page under `.agents/skills/orkestrel-parallel/references/`.
 - Judge a unit by the tree it changes: owned-file mtimes, suite counts, its report file. Check before killing anything; a unit killed on a false signal loses unwritten work.
 
 ## Kill and relaunch
 
 - Take the child's `pid` from the spawn line `scripts/launch.ts` prints when the command starts, or from `<journal>.pid`. Never take it from a pattern match over command lines, and never run `pgrep -f` or `pkill -f`.
-- On a POSIX host, read liveness with `kill -0 <pid>` (exit 0 means alive), list descendants by running `ps -A -o pid= -o ppid=` and taking the rows whose ppid is the recorded pid, then each listed id in turn, print the list, then kill each listed id and the recorded pid with `kill -KILL <id>`.
-- On Windows under Git Bash, write every Windows slash option as `//`. Read liveness from the output of `tasklist //FI "PID eq <pid>" //NH`, never from its exit code: a row naming `<pid>` means alive, and the `INFO:` line means gone. Alternatively, read the `WINPID` column of `ps -W`. Never read liveness with `kill -0` or `ps -eo`. List descendants with `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=<pid>' | Select-Object -ExpandProperty ProcessId"` applied to each listed id in turn, print the list, then kill the recorded tree with `taskkill //pid <pid> //T //F`.
-- Refuse a list holding PID 1, the harness shell, or an id outside the descent of the recorded pid. At the cap, `launch.ts` kills the tree on Windows and the command alone on any other host; on a POSIX host, kill the listed descendants of a capped run by hand.
+- Read liveness, list descendants, and kill with the commands of `.agents/platforms/<platform>.md`: list every descendant of the recorded pid, print the list, then kill each listed id and the recorded pid.
+- Refuse a list holding PID 1, the harness shell, or an id outside the descent of the recorded pid. At the cap, `launch.ts` kills what the platform page states; kill the remaining listed descendants by hand.
 - Confirm the recorded process and every listed descendant are gone before another writer takes the files. A killed `codex exec` is dead only when its `codex-code-mode-host` child is gone too. Check owned-file mtimes before dispatching the substitute.
 - Re-run a timing failure alone, after the unit exits, before believing it; a unit's own re-run is never alone.