@orkestrel/scaffold 0.0.107 → 0.0.109

package/dist/host/AGENTS.md

@@ -9,7 +9,7 @@
 - `*/types.ts` is authoritative for public APIs. Never undo a user's type edit.
 - `.agents/orchestration.md` governs agent operation and cannot weaken this file. Harness bridges (`.claude/AGENTS.md`, `.codex/config.toml`, `.cursor/rules/orchestration.mdc`) add harness mechanics only.
 - A skill under `.agents/skills/` is a procedure. Follow it when the user or a dispatch names it, or when its trigger fires. A skill cannot weaken this file or a rule.
-- Before editing, read: this file; each rule the Rule map scopes to the paths you touch; the named skill and the references it names; the matching guide under `guides/` and `ROADMAP.md` when present. Read nothing else up front.
+- Before editing, read: this file; each rule whose `paths` frontmatter matches the paths you touch; the named skill and the references it names; the matching guide under `guides/` and `ROADMAP.md` when present. Read nothing else up front.
 - Rules state how to write. Guides state what to build. On conflict, stop and report the conflict.
 - A rule file's stated exception to a law in this file applies.
 
@@ -43,7 +43,7 @@ configs/  thin target wrappers around root Vite/TypeScript configuration
 - **NEVER** use mocks, behavioral fakes, module replacement, framework spies, or fake clocks for project-owned behavior. Use real implementations, recorders, temporary resources, protocol-faithful fixture servers, and inert data stubs.
 - **ALWAYS** make interface properties and public return collections readonly.
 - **ALWAYS** define reusable and public types in `*/types.ts` before implementation.
-- **ALWAYS** inspect the declared and installed `@orkestrel/*` capabilities before writing overlapping logic. Reuse a primitive whose semantics match; never wrap one to rename it.
+- **ALWAYS** check whether an `@orkestrel` package already provides a capability before writing logic, a tool, or an instrument that could overlap it. Read the package guides first: `guides/README.md` maps them, and a target holds them under `node_modules/@orkestrel/scaffold/dist/host/guides/`. When a guide leaves the question open, read the package's source in a checkout beside the repository. When no checkout exists, read its repository at `https://github.com/orkestrel/<package>`, online or cloned under `tmp/`. Reuse a primitive whose semantics match; never wrap one to rename it.
 - **ALWAYS** finish the requested implementation: no stubs, deferred logic, or hidden follow-up.
 - **ALWAYS** write a script as TypeScript run by Node (`node path/to/script.ts`, type stripping, `node:` modules only): a skill script, a probe, a launcher, an instrument, a one-off tool. Never write a bash, PowerShell, or Python script. The Claude Code Cloud hooks under `scripts/` are the one bash exception, and that folder holds nothing else.
 
@@ -70,6 +70,10 @@ 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.
+
+Open a task with its goal, its acceptance criteria, and the cheapest pass/fail check that proves them. Before writing a fixture, proof, or tool around a command, run that command on real data. `.agents/orchestration.md` § Depth, breadth, and machinery sizes the effort and rules on what becomes a package.
+
 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 +91,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.** After 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 +100,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.
@@ -105,23 +110,24 @@ Test ladder, narrowest first; stop at the boundary the change size names:
 
 ## Rule map
 
-Each row is a normative extension of this file. Its `paths` frontmatter controls automatic loading; read the row when its subject matches your change.
-
-| Rule                             | Governs                                                                |
-| -------------------------------- | ---------------------------------------------------------------------- |
-| `.claude/rules/names.md`         | Identifiers, API shape, acronyms, lifecycle vocabulary, files/folders  |
-| `.claude/rules/typescript.md`    | TypeScript syntax, imports, immutability, errors, TSDoc                |
-| `.claude/rules/architecture.md`  | Centralized files, exports, classes, modules, extension points, stores |
-| `.claude/rules/patterns.md`      | Options, managers, emitters, guards, parsers, contracts                |
-| `.claude/rules/tests.md`         | Test behavior, helpers, probes, browser tests, Vitest configuration    |
-| `.claude/rules/workspace.md`     | Src/app environments, aliases, isolation, builds, scripts, tooling     |
-| `.claude/rules/application.md`   | App composition, entries, manifest safety, lifecycle, integration      |
-| `.claude/rules/browser.md`       | Vue/browser architecture and platform usage                            |
-| `.claude/rules/styles.md`        | SCSS/CSS centralization, tokens, mixins, layers, naming                |
-| `.claude/rules/portability.md`   | Host branching, paths, line endings, processes, terminals, OS claims   |
-| `.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       |
+Each row is a normative extension of this file. A rule's `paths` frontmatter controls automatic loading, and `.claude/rules/writing.md` carries none and loads always. Read the row when its subject matches your change.
+
+| Rule                             | Governs                                                                                                                                     |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `.claude/rules/names.md`         | Identifiers, API shape, helper prefixes, acronyms, fleet name ownership, lifecycle vocabulary, files and folders                            |
+| `.claude/rules/typescript.md`    | TypeScript syntax, imports, types, immutability, bindings and state, errors, TSDoc                                                          |
+| `.claude/rules/architecture.md`  | Centralized files, declaration placement, kind purity, wrappers, functions, classes, middleware, plugins, stores, barrels                   |
+| `.claude/rules/patterns.md`      | Ecosystem reuse, options, managers, emitters, validation and contracts, foreign contracts                                                   |
+| `.claude/rules/tests.md`         | Test contract, cross-cutting proofs, probes, live-service and expensive proofs, shared helpers, browser tests, runner configuration         |
+| `.claude/rules/workspace.md`     | Src/app environments, aliases, configuration, builds, test project matrix, typechecking scopes, scripts, policy instruments, text integrity |
+| `.claude/rules/application.md`   | App composition, CLI selections, entries, manifests, server runner                                                                          |
+| `.claude/rules/browser.md`       | Vue and browser architecture: composables, reactivity, platform APIs                                                                        |
+| `.claude/rules/styles.md`        | SCSS/CSS centralization, tokens, mixins, layers, folders, proofs, naming                                                                    |
+| `.claude/rules/portability.md`   | Host branching, line endings, paths, processes, terminals, scripts and packaging, host claims                                               |
+| `.claude/rules/documentation.md` | Guides, parity, examples, agent-facing surfaces, skill files                                                                                |
+| `.claude/rules/writing.md`       | Prose in guides, replies, commits, and instruction files                                                                                    |
+| `.claude/rules/quality.md`       | Evidence, probes, instruments, performance, ecosystem reuse, hardening, completion                                                          |
+| `.claude/rules/campaign.md`      | The `.orkestrel/` campaign folder: layout, content, session start, hand off and close                                                       |
 
 ## 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.
 
@@ -49,21 +52,59 @@ The harness's own engine orchestrates: Claude Fable 5.1 or Claude Opus 5.5 in Cl
 - Route by judgment load. Objective, constraint-heavy, mechanical-precision work goes to `astra`. API shape, naming, and documentation voice go to `opus`. A bounded unit whose brief or types fix its names, API, and architecture goes to `builder`, whatever its private lines; a unit that spans packages or leaves one of those open goes to `astra` or `opus`.
 - 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 a unit that authors path-containment, import-resolution-boundary, unescaped-input, or credential-exposure proofs to `opus` from the start where `opus` runs on Claude, and record the Codex bench dark for that unit only. Under native Codex roles, report a harness refusal through § Deviation protocol.
 - 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.
+- When a verifier lane fails in its harness rather than in the gate, run the gate once yourself and read its exit code; write no comparator, snapshot, or retry chain to obtain evidence.
+- Keep valid receipts. Re-run a check only when its inputs, configuration, environment, or claim changed; never repeat a passing check to collect another receipt.
+- Ask the user only for a decision that is theirs: scope, the spend ceiling and stop line § Hold the plan names, 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, with time in whole minutes.
+- 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.
+
+## Hold the plan
+
+- Open with the goal and acceptance criteria per `AGENTS.md` § Work loop, then estimate the scope: the units, the review and evidence each needs, and what stays out. When the estimate is large, agree with the user the estimate, the spend ceiling, and the stop line: how much lane time the work can take, and the point at which work stops and reports.
+- Before each unit, name the plan step it serves. Cut a unit no step needs; set an unplanned idea aside in the plan and return to the step.
+- Add a tracked file only where the request, the plan, or a rule names it.
+- After every unit return, unexpected result, or user message, compare the work with the plan: mark what is done, restate the next step, and set aside what no longer serves the goal.
+- When the work outgrows its estimate, stop, re-estimate, and bring the user the choice to cut, defer, or extend before continuing.
+- When the user questions the plan, test it against the evidence in hand: reopen it where the evidence disagrees and report what changed; where the evidence holds, answer with that evidence.
+- Answer a status question before dispatching more work, and close every report the same way: the goal, what is done against it, what is measured, what remains, and the next step.
+
+## Depth, breadth, and machinery
+
+- Size the effort to the task before spending: a lookup takes one lane, routed per § Routing, and only open-ended work with independent, high-value parts fans out, per § Parallelism.
+- Locate the evidence with short broad probes before any deep pass: a run of the shipped command, a census, a search. Go deep only on a defect or gap a run has shown, in one lane, with the narrowest instrument that answers it: a counting probe or a mutation.
+- When a failure recurs, read the exact input and output of the failing case before adding capability, and fix the cause.
+- Deepen in rounds and report a usable result after each. Stop at the first result that clears the acceptance criteria and name the gaps that remain.
+- Prove a change in one consumer, with its gate green, before spreading it to the rest.
+- Use the simplest method that can clear the criteria, starting with what an `@orkestrel` package already provides, looked up per `AGENTS.md` § Non-negotiable rules. Add machinery only after that method fails a measured check, and build nothing for a hypothetical need.
+- Do a one-use step inline. Keep a tool one unit runs more than once as a throwaway under `tmp/`, deleted with the unit and never committed.
+- When a second unit, package, or campaign needs a tool, move it out of `tmp/`: into a skill script under `.agents/skills/` when it only runs a procedure, and into its own package, with its own tests and release, when it carries correctness claims of its own or an identity consumers pin, replay, or audit. Write the promotion path and the removal path when you first build it.
+- When a throwaway grows a mechanism per step instead of answering its question, stop and map it against the owning packages before building more.
+- Ship the proven fix first, and run experiments behind it under a stated cap.
 
 ## Size gate
 
@@ -76,18 +117,19 @@ 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 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.
+- 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); `node .agents/skills/orkestrel-falsify/scripts/mutate.ts --edits EDITS.md -- COMMAND` runs the probe and proves the restore. 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.
+4. **Integrate.** Apply returned patches to shared files serially with `node .agents/skills/orkestrel-dispatch/scripts/patch.ts EDITS.md --plan`, then `--apply`. 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.
 6. **Verify.** `verifier` runs the tree-wide gates once.
 7. **Re-baseline.** Strike satisfied units, restate transformed ones, add units the exit criterion already required. A re-baseline never moves the exit criterion; that needs the user.
@@ -97,9 +139,12 @@ 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.
-- 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.
+- 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 as an edit file that `.agents/skills/orkestrel-dispatch/scripts/patch.ts` applies. 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; § Pace rules on reruns. 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.
 - The Orchestrator's own sweep is a writing dispatch: run it before or after the units, never beside them.
 
@@ -119,40 +164,32 @@ A large change runs these phases once each, in order, and ends when the exit cri
 
 Every working file lives under the checkout's gitignored `tmp/`, in the directory its kind names.
 
-| 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/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                                |
-| `tmp/browsers/`                            | the journeys a `browse` server saves, their runs and captures, and its profiles under `.profiles/` |
-| `tmp/worktrees/`                           | worktrees the Orchestrator creates for a parallel writer                                           |
+| 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 unit records                                                                                                                 |
+| `tmp/probes/`                              | runtime probes the `probe` Vitest project collects and the `probe` MCP server arms, and a skill script's scratch under its own subdirectory (`census/`, `lint/`, `mutate/`) |
+| `tmp/type/`                                | the type stage's workspace mirror, owned by `@orkestrel/probe`                                                                                                              |
+| `tmp/captures/`                            | screenshots, resolved-style snapshots, and other capture portfolios                                                                                                         |
+| `tmp/browsers/`                            | the journeys a `browse` server saves, their runs and captures, and its profiles under `.profiles/`                                                                          |
+| `tmp/worktrees/`                           | worktrees the Orchestrator creates for a parallel writer                                                                                                                    |
 
 ## .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.
+- Write each brief per `.agents/skills/orkestrel-dispatch/SKILL.md` § Write the brief. A brief file lives at `tmp/units/<unit>-brief.md` (native) or `tmp/<bench>/<unit>-brief.md` (bench), and a re-run at `<unit>-brief-<n>.md`.
 - 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 +200,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.
@@ -179,12 +216,15 @@ The Orchestrator triages: obvious correction → tighten and re-dispatch; missin
 
 - Keep the model, options, tools, and instruction prefix unchanged while they fit the task. Check the active provider and harness before claiming that a change preserves or invalidates caching. Treat a continued session as retained context, not as a cache hit; a cache hit depends on the provider, the prefix, and the retention window. Claim a saving only from recorded usage.
 - Keep the always-on instruction set small and load supporting rules by scope. When instructions change, use the harness's documented reload mechanism and tell affected agents what changed. Do not assume a file edit updates an active session.
-- Give reading and driver roles no instruction files (`omitClaudeMd` in Claude Code) when their charter carries the floor they need.
+- Give reading and driver roles no instruction files when their charter carries the floor they need.
 - Route bulk reads per § Routing and keep only the distillate.
 
 ## Acceptance
 
 - 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.
+- Before calling work ready, try the shipped result as the user will, on the build they run, and report what did not run.
+- 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.
+
+## Release packs and terminals
+
+- Git Bash ships no `script` binary, so an agent cannot give npm a TTY there; the operator runs a browser-authorized `npm login` or `npm publish` in a real terminal.
+- A pack made on Windows records `0644` for an entry git tracks as `100755`. Compare release packs between hosts by paths, sizes, and content hashes, and report executable-mode differences separately.
+
+## 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-align/SKILL.md

@@ -19,17 +19,15 @@ Invoke `$orkestrel-harden` for each package implementation unit. This skill owns
 
 ## Execute the campaign
 
-1. **Create one registry.** Record the campaign goal, authoritative session, repositories, branches, dirty state, declared/resolved versions, dependency edges, guide state, write scope, and exclusions.
-2. **Bound context.** Scout only packages and consumers relevant to the behavior. Use registry/canonical sources for the rest of the fleet.
-3. **Trace the real flow.** Follow public types and one concrete consumer end to end. Identify where ergonomics break and which layer owns the reusable mechanism.
-4. **Assign ownership.** Keep core host-independent. Keep server free of browser assumptions and browser free of Node assumptions. Keep product policy in applications.
-5. **Judge downstream friction.** Treat consumer gymnastics as evidence, not automatic proof. Decide whether the consumer misused a coherent API or exposed a general upstream defect.
-6. **Design in dependency order.** Update guides and types first in the lowest owning package, then update every affected consumer atomically. Do not add compatibility shims.
-7. **Harden each unit.** Apply `$orkestrel-harden` to every touched package with the exact owned scope and acceptance criteria.
-8. **Prove the round trip.** Put integration coverage at the highest package that can exercise the real composed behavior. Retain focused deterministic coverage in lower packages.
-9. **Validate local changes safely.** When necessary, use built artifacts in an isolated consumer and prove the resolved graph. Restore temporary manifest/lockfile state.
-10. **Verify topologically.** Run local gates for touched packages from dependencies to dependents and inspect relevant generated outputs.
-11. **Review the campaign.** Run the review `.agents/orchestration.md` § Size gate names on the integrated result, with one cross-package architecture and ergonomics pass over the whole graph. Do not review each unit separately.
+Run `.agents/orchestration.md` § Campaign for the phases, the review, and the gates, and `$orkestrel-harden` for each package unit. Record the live state of every relevant repository per [fleet.md](references/fleet.md) § Verify live state. This skill adds:
+
+1. **Trace the real flow.** Follow public types and one concrete consumer end to end. Identify where ergonomics break and which layer owns the reusable mechanism.
+2. **Assign ownership.** Keep core host-independent. Keep server free of browser assumptions and browser free of Node assumptions. Keep product policy in applications.
+3. **Judge downstream friction.** Treat consumer gymnastics as evidence, not automatic proof. Decide whether the consumer misused a coherent API or exposed a general upstream defect.
+4. **Prove the round trip.** Put integration coverage at the highest package that can exercise the real composed behavior. Retain focused deterministic coverage in lower packages.
+5. **Validate local changes safely.** When necessary, use built artifacts in an isolated consumer and prove the resolved graph, per [fleet.md](references/fleet.md) § Validate local packages.
+
+The review is one cross-package architecture and ergonomics pass over the whole graph, not one per unit.
 
 ## Accept the result
 
@@ -40,7 +38,6 @@ Completion requires:
 - every changed public contract, consumer, test, and guide is aligned;
 - real round-trip behavior is proven at the correct layer;
 - package versions/ranges/guides are reported from live evidence;
-- every touched repository's requested local gates are green;
-- no in-scope work is deferred.
+- every touched repository's requested local gates are green.
 
 Report the final package graph, ownership decisions, shipped behavior, exact verification, residual risk, and any user decision still required.

package/dist/host/agents/skills/orkestrel-align/references/fleet.md

@@ -1,5 +1,7 @@
 # Fleet alignment
 
+This reference governs fleet alignment across repositories: verifying live state, planning dependency order, and verifying consumers.
+
 ## Verify live state
 
 For every relevant repository, record:
@@ -29,19 +31,11 @@ Keep one authoritative session per package. Re-establish live state before actin
 
 ## Validate local packages
 
-When a dependent must verify a local package:
-
-- build the dependency;
-- consume its built artifact only in an isolated or explicitly authorized consumer;
-- prove every relevant resolution points to the intended artifact;
-- run the dependent's targeted then final local gates;
-- restore temporary overrides, manifest edits, and lockfile state.
-
-Do not treat an undeclared source-checkout import as consumer proof.
+When a dependent must verify a local package, pin it to a built tarball in an isolated or explicitly authorized consumer, run the dependent's targeted then final local gates, and restore the pin, per `.agents/skills/orkestrel-publish/references/release.md` § Fix a dependency before it publishes. Do not treat an undeclared source-checkout import as consumer proof.
 
 ## Align guides and verification
 
-Refresh dependency guides through the current scaffold workflow when the owning repository and scope permit it. Report drift rather than hand-editing a vendored guide whose canonical source lives elsewhere.
+Refresh dependency guides with `scaffold catalog` when the owning repository and scope permit it. Report drift rather than hand-editing a vendored guide whose canonical source lives elsewhere.
 
 Run package-local verification from dependencies to dependents. A passing lower package does not prove its consumer; a passing consumer does not replace lower-package invariants.
 

package/dist/host/agents/skills/orkestrel-align/references/integration.md

@@ -42,6 +42,6 @@ Place each proof at the highest useful layer:
 
 Use the actual packages and transports. Use temporary resources or protocol-faithful fixture servers for deterministic network boundaries. Use the real external service when its behavior is the claim. Never simulate an owned package with a mock or fake.
 
-When the claim is that a foreign client can consume the stack — an editor, an agent CLI, a third-party protocol client — one representative real client of that class drives the surface end to end before the claim ships. Record the exact commands, the authentication and approval model that client needed, and every part of the surface it could not reach. Protocol-level tests prove the protocol; only the client proves the integration.
+Prove a claim that a foreign client can consume the stack per `.agents/skills/orkestrel-harden/references/hardening.md` § Use real implementations.
 
 Test both successful composition and contract disagreement: invalid options, unavailable capability, partial failure, abort/cleanup, version mismatch, and lifecycle ordering where applicable.