@orkestrel/scaffold 0.0.19 → 0.0.21

package/dist/host/CLAUDE.md

@@ -37,9 +37,12 @@ One workflow runs across both providers. Each engine has one job, and no engine
 - **After implementation Opus 5 and Sol audit independently** — Opus on design fit, Sol on
   correctness and constraint satisfaction — and the orchestrator reconciles their evidence
   into one verdict.
-- **Lower-cost native agents (Sonnet, Terra) do fully specified mechanical units and gate
-  evidence only.** A specified rename, a scaffold expansion, a conformance checklist, a gate
-  run. They never substitute for Grok, Opus 5, or Sol.
+- **Lower-cost native agents (Sonnet, Terra) do fully specified units and read-only
+  evidence only.** A specified rename, an app-layer expansion, a conformance checklist, a
+  gate run, a bounded primary-source question, a reconnaissance sweep. They never
+  substitute for Grok, Opus 5, or Sol: `researcher` and `scout` are the native evidence
+  lanes for bounded questions and the fallback when the Grok bench is dark, never the
+  route for repository-scale absorption or judgment.
 
 The orchestrator reconciles; no external engine reconciles itself or accepts its own work.
 In Claude Code the orchestrator is the top-level Fable session. When Codex is primary, the
@@ -68,6 +71,9 @@ dispatch, even when the role file pins it.
 | Nontrivial implementation (objective)    | `codex` route `implementer`     | `implementer`                 | GPT-5.6 Sol (bridge / native) |
 | Nontrivial implementation (subjective)   | `implementer`                   | `implementer` route `opus`    | Opus 5 (native / bridge)      |
 | Fully specified mechanical unit          | `builder`                       | `builder`                     | Sonnet / Terra                |
+| Fully specified app-layer unit           | `application`                   | `application`                 | Sonnet / Terra                |
+| Bounded primary-source research          | `researcher`                    | `researcher`                  | Sonnet / Terra                |
+| Repository reconnaissance                | `scout`                         | `scout`                       | Sonnet / Terra                |
 | Mechanical conformance evidence          | `checker`                       | `checker`                     | Sonnet / Terra                |
 | Gate evidence                            | `verifier`                      | `verifier`                    | Sonnet / Terra                |
 | Ecosystem evidence                       | `orkestrel`                     | `orkestrel`                   | Sonnet / Terra                |
@@ -157,10 +163,12 @@ absorbed.
    patches serially; route cross-cutting findings.
 5. **Audit adversarially.** Every nontrivial implementation gets `reviewer` (Opus 5, design
    fit) and `analyst` (Sol, correctness and constraints) independently, plus `checker` for
-   mechanical conformance. In a fix round the unit's auditor is an engine that did not write
-   it. Multi-round audits use one fixed verdict shape with a single terminal line, defined by
-   the campaign skill. Reconcile their evidence; a finding neither engine can substantiate
-   against the evidence is dropped on the record.
+   mechanical conformance. An audit brief states its subject as numbered falsifiable claims
+   and requires per-claim CONFIRMED/BROKEN with evidence, per the Falsification law in
+   `.claude/rules/quality.md`. In a fix round the unit's auditor is an engine that did not
+   write it. Multi-round audits use one fixed verdict shape with a single terminal line,
+   defined by the campaign skill. Reconcile their evidence; a finding neither engine can
+   substantiate against the evidence is dropped on the record.
 6. **Verify.** One independent `verifier` runs the authoritative gates.
 7. **Accept.** The Orchestrator decides and reports concise outcomes, decisions, evidence, and
    remaining risk.
@@ -192,13 +200,34 @@ Workflow failures use the same ladder; do not absorb their raw logs into the mai
   writing nodes — never two concurrent writers in the tree.
 - Every node names a role and its engine.
 
+Every dispatch is a file before it is a launch:
+
+- The brief is written to a file under `tmp/`, named for its unit, before the unit is
+  launched, whatever engine executes it. A brief composed only inside a launch argument
+  cannot be corrected, resumed, or re-run once that call ends.
+- The unit's returned report is captured to a file beside its brief under the same unit name,
+  so a unit's instruction and its outcome are one pair on disk.
+- A re-run amends its brief instead of restating it: a mid-campaign correction produces a
+  successor file recording what changed and why, and the original stays. A fix round's brief
+  names the findings it carries and where each came from.
+- Brief and report files are unit evidence, not deliverables. They are never committed, and
+  they are swept when the campaign that produced them is accepted.
+- Anything in a brief or a report that must outlive the campaign is promoted into a durable
+  artifact — a commit message, a guide, a rule, a retrospective — before the sweep. What is
+  only in a swept file did not survive.
+
 Every dispatch contains:
 
 - **Role/engine** — named role and explicit engine.
 - **Objective** — one concrete outcome.
 - **Context** — the evidence slice, paths, decisions, `AGENTS.md`, applicable rules, the
   skill name and required references (or explicit none), and the guide/spec.
+- **Unknowns** — what the Orchestrator does not yet know that the unit needs, named as
+  unknown, with how the unit reports back on it. A brief that cannot be fully specified says
+  so instead of shipping a guess the executor would have to invent an answer around.
 - **Scope** — owned files, shared and off-limits files, allowed tools, permission limits.
+- **Execution** — the executor performs the assignment directly and spawns nothing. Every
+  brief states it; an executor deep in a task does not re-read this contract.
 - **Output** — the exact distilled return shape; no process diary.
 - **Deviation contract** — required stop/report behaviour for writers.
 - **Acceptance criteria** — independently checkable completion conditions.
@@ -224,22 +253,20 @@ Four bench laws apply to every external engine:
   transport where one exists. Long-running work — audits, implementation units, anything
   multi-minute — uses the journaled CLI and never MCP: an interrupted MCP call loses its
   session invisibly, while a journal survives any client-side failure.
-- **Journal first.** Every bench invocation leaves a tailable on-disk record under
-  `tmp/<bench>/` (`tmp/codex/`, `tmp/cursor/`): the brief as a file, the event stream or
-  output log, and the final answer. Every long exec also carries exactly one Monitor on its
-  journal — a filtered tail that emits milestones (commands run, files changed, agent
-  messages, terminal states) and never the raw event firehose — so progress arrives in the
-  conversation while the journal stays tailable for depth. The filter exits on the exec's
-  terminal event, so the monitor's lifecycle matches the exec's and no watcher outlives its
-  subject. The journal's mtime is the liveness signal; the session id in the journal head is
-  the recovery handle. Briefs never travel as fragile shell arguments.
+- **Journal first.** Every bench invocation leaves a tailable on-disk record beside its brief
+  under `tmp/<bench>/` (`tmp/codex/`, `tmp/cursor/`): the event stream or output log and the
+  final answer. Every long exec also carries exactly one Monitor on its journal — a filtered
+  tail that emits milestones (commands run, files changed, agent messages, terminal states)
+  and never the raw event firehose — so progress arrives in the conversation while the
+  journal stays tailable for depth. The filter exits on the exec's terminal event, so the
+  monitor's lifecycle matches the exec's and no watcher outlives its subject. The journal's
+  mtime is the liveness signal; the session id in the journal head is the recovery handle.
 - **Tracked, never loose.** Every bench unit is registered in the session task registry at
   launch — subject, journal path, session id — and completed there at acceptance, so "what is
   running" always has a first-class answer instead of a recollection of a command.
-- **Ephemeral journals.** Everything under `tmp/` is unit evidence, never committed. Bridges
-  never delete journals; the Orchestrator sweeps `tmp/codex/` and `tmp/cursor/` once at
-  campaign acceptance, after the final gate evidence is recorded. A journal surviving past
-  its campaign is residue.
+- **Ephemeral journals.** Bridges never delete journals; the Orchestrator sweeps them with
+  the campaign's other unit evidence at acceptance, after the final gate evidence is
+  recorded. A journal surviving past its campaign is residue.
 
 Every long bench exec is launched by the Orchestrator as a harness-tracked background command
 under a hard time cap, never detached from inside a bridge agent: the harness owns the
@@ -255,12 +282,12 @@ unit.
 ### Cursor Grok
 
 - Reached only through the `grok` role, in ask mode:
-  `<agent-cli> -p --trust --mode=ask --model "$CURSOR_GROK_MODEL" "<brief>" | tee tmp/cursor/<unit>.log`.
+  `<agent-cli> -p --trust --mode=ask --model "$CURSOR_GROK_MODEL" "<prompt>" | tee tmp/cursor/<unit>.log`.
   `<agent-cli>` resolves as bare `agent`, then `agent.cmd` (Windows installs ship only
   `.cmd`/`.ps1` shims, so bare `agent` does not resolve in Bash), then
-  `"$LOCALAPPDATA/cursor-agent/agent.cmd"` — verified with `--version` before first use. Long
-  briefs are written to `tmp/cursor/<unit>-brief.md` and the prompt points at the file. The
-  tee'd log is the bench's journal.
+  `"$LOCALAPPDATA/cursor-agent/agent.cmd"` — verified with `--version` before first use. The
+  prompt points at the unit's brief file, `tmp/cursor/<unit>-brief.md`. The tee'd log is the
+  bench's journal.
 - A long ask-mode run obeys the same launch, stream, and ledger discipline as a Codex exec:
   the Orchestrator starts it as a harness-tracked background command under a time cap,
   registers the unit in the task registry, and arms one Monitor on the tee'd log for

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

@@ -1,6 +1,6 @@
 ---
 name: orkestrel-debrief
-description: Convert a closed campaign's residue into portable truth through field evidence, a findings ledger, fix loops with live re-proof, canon refinement, and disciplined disposal. Use after a campaign or milestone closes to audit what was built and how it was built, when live field testing must precede judgment, when learnings must propagate into skills/rules/guides/scaffold, or when working ledgers must fold into canon and retire.
+description: Look back at a long campaign to learn from its mistakes and successes and improve the agents, rules, skills, and processes that ran it. Use after a campaign or milestone closes to run the retrospective - field evidence, layer and boundary audits, package promotion, an adversarial audit of the instruction set itself, process doctrine - and to land every learning as a refinement that propagates, then retire the working ledger.
 ---
 
 # Debrief a closed campaign
@@ -11,71 +11,81 @@ Read the current files in this order:
 
 1. `AGENTS.md`.
 2. Every applicable `.claude/rules/*.md`; the documentation and quality laws bind every
-   ledger entry and every canon refinement this skill produces.
-3. [field-testing.md](references/field-testing.md) before running or judging any live
-   field pass.
-4. `guides/README.md`, the governing guide for what the campaign built, and `ROADMAP.md`.
+   ledger entry and every refinement this skill produces.
+3. The references this round needs: [instruction-audit.md](references/instruction-audit.md)
+   before auditing the agent/rule/skill/process layer;
+   [field-testing.md](references/field-testing.md) before running or judging a live field
+   pass of an agent-facing surface.
+4. `guides/README.md`, the governing guides for what the campaign built, and `ROADMAP.md`.
 
-The user's current instruction wins. The debrief judges both the artifact and the process
-that produced it; neither is exempt.
+The user's current instruction wins. The debrief judges the artifact AND the process that
+produced it; neither is exempt, and successes are captured as deliberately as mistakes —
+a practice that worked is codified so it repeats, not merely survived.
 
 ## The debrief laws
 
-- **Use it before you judge it.** A debrief of a surface nobody drove is a review of
-  intentions. Field evidence — real clients, real harnesses, goal-only prompts — precedes
-  every finding about usability, and the field transcript is the evidence of record.
-- **Evidence is verbatim or it is not evidence.** The ledger quotes exact commands, exact
-  refusals, exact reasoning-trace lines. A paraphrase cannot be re-verified after the
-  session that produced it is gone.
-- **Every finding ends in exactly one bucket**: fix now; canon refinement (skill, rule,
-  guide); promotion (package/library boundary move); stays as-is with the reason; or
-  dropped on the record with the refuting evidence. A finding with no bucket is an
-  unfinished debrief.
-- **Fixes are re-proven by the class of evidence that found them.** A defect found by a
-  live field pass is closed by a live field pass, never by the fix's own tests alone.
-- **Portable versus resident.** Anything reusable beyond this repository — process
-  doctrine, teaching-surface laws, harness knowledge — lands in the portable skill/rule
-  set and propagates through the scaffold. Repository-specific truth lands in the guide.
-  Forward-looking work lands in `ROADMAP.md`. Nothing load-bearing stays only in the
-  ledger.
-- **The ledger is ephemeral.** The debrief folder is a working file: fold every surviving
-  truth into its destination, then delete the folder on the owner's explicit go-ahead —
-  never silently, and never leave it as residue after its campaign.
+- **The campaign record is the primary source.** Dispatches, deviation reports, audit
+  verdicts, gate outputs, commit messages, and live transcripts are evidence; recollection
+  is not. Quote verbatim — a paraphrase cannot be re-verified later.
+- **Use it before you judge it.** Where the campaign built something consumable — a
+  package, an app, an agent-facing surface — drive it with representative real consumers
+  before writing findings about it. For agent-facing surfaces, follow
+  [field-testing.md](references/field-testing.md).
+- **Every finding ends in exactly one bucket**: fix now; agent refinement; rule
+  refinement; skill refinement or creation; process refinement (orchestration contract);
+  package promotion; guide truth; roadmap; stays as-is with the reason; or dropped on the
+  record with the refuting evidence. A finding with no bucket is an unfinished debrief.
+- **Fixes are re-proven by the evidence class that found them.** A defect found in live
+  use closes with live use; a process failure closes when the next campaign round runs
+  the corrected process.
+- **Portable versus resident.** Learnings reusable beyond the repository — process
+  doctrine, role charters, rules, skills — land in the portable canon and propagate
+  through the scaffold host inventory. Repository truth lands in the guide; forward work
+  in `ROADMAP.md`. Nothing load-bearing stays only in the ledger.
+- **The ledger is ephemeral.** Fold every surviving truth into its destination, then
+  delete the folder on the owner's explicit go-ahead — never silently, never as residue.
 
 ## Run the round
 
-1. **Scope.** Name the campaign(s) under debrief, the artifact surfaces involved, and the
-   audiences that matter (human operators, frontier models, small models, external
-   clients). State what evidence already exists and what must be produced live.
-2. **Field passes.** Drive the artifact with representative real consumers per
-   [field-testing.md](references/field-testing.md): goal-only prompts, no coaching, the
-   tier ladder from frontier to the smallest model that matters, reasoning traces
-   captured wherever the runtime exposes them. Record every pass verbatim in the ledger.
-3. **Layer audits.** In parallel with the field passes, audit each layer the campaign
-   touched: implementation boundaries (what belongs a layer down or in a published
-   package), the process record (which dispatches failed, which laws were missing, where
-   executors deviated), and the instruction set itself (agents, rules, skills — what
-   confused an executor is a defect in the instruction, not the executor).
-4. **Reconcile into the ledger.** Number the findings, attach verbatim evidence to each,
-   and bucket every one. Confusion signatures from reasoning traces are findings about
-   the artifact's teaching surface, not anecdotes — see the signature catalog in
-   [field-testing.md](references/field-testing.md).
-5. **Fix loops.** Dispatch fix-now findings as bounded units under the repository's
-   engine contract, serialized, failing-first. After each round, re-run the field passes
-   that found the class and record the delta. Iterate until the field tier that matters
-   walks the surface unaided or the residual is proven to be consumer-floor, not
-   artifact darkness — state which, with evidence.
-6. **Canon refinement.** Write or revise the portable skills/rules the findings justify;
-   update the guide for resident truth; update `ROADMAP.md` for forward work. Every
-   retained finding names the artifact that now carries it.
-7. **Propagate.** Land the portable set in the scaffold repository so every future
-   project inherits it; run the scaffold's own gates before pushing.
-8. **Dispose.** Present the ledger's disposition map to the owner: what folded where,
-   what remains open. Delete the ledger only on their explicit go-ahead.
+1. **Scope and gather.** Name the campaign(s) under debrief. Assemble the record: unit
+   ledger, deviations and recoveries, audit verdicts and their reconciliations, gate
+   history, and any live transcripts. State what evidence exists and what must be
+   produced fresh.
+2. **Field evidence.** Drive what was built with real consumers where a consumable
+   surface exists. Record every pass verbatim.
+3. **Artifact audits.** Layer and boundary truth: does app code belong a layer down in
+   src, does src carry application policy, does either duplicate a declared ecosystem
+   primitive? Package promotion: what grew into a reusable mechanism that belongs in an
+   existing package or justifies a new one — mapped dependency-first so promotion order
+   is executable. Every row ends implement, repair, retain, or intentionally exclude,
+   with evidence.
+4. **Process retrospective.** Walk the campaign record for both failure and success:
+   dispatches that deviated and why; recoveries that worked (codify the mechanism that
+   saved them); estimates versus observed durations; audit rounds that caught real
+   defects versus rounds that churned; anything the orchestrator absorbed that should
+   have been dispatched or dispatched that it should have owned.
+5. **Instruction-set audit.** Audit the agents, rules, skills, and orchestration
+   contract themselves against the campaign record, using the adversarial method in
+   [instruction-audit.md](references/instruction-audit.md). What confused an executor is
+   a defect in the instruction, not the executor.
+6. **Reconcile into the ledger.** Number the findings, attach verbatim evidence, bucket
+   every one. Where two audit lanes disagree, rule each divergence on the record with
+   the reason.
+7. **Land the refinements.** Dispatch fix-now findings as bounded units under the
+   repository's engine contract; make the canon edits (charters, rules, skills,
+   orchestration contract) with the owner's direction where the root contract is
+   touched; re-prove per the law above.
+8. **Propagate.** Portable changes are made in the scaffold repository's host inventory,
+   staged, gated, and pushed — editing one project's checkout propagates nothing. Verify
+   the generated-workspace proofs stay green so new projects inherit the refined canon.
+9. **Dispose.** Present the disposition map — finding table with carriers, the canon
+   delta, what remains open — and delete the ledger only on the owner's explicit
+   go-ahead.
 
 ## Verdict shape
 
-Each debrief round ends with one fixed report: the finding table (id, evidence pointer,
-bucket, carrier), the field-pass scoreboard before and after, the canon delta (files
-created or changed), and exactly one terminal line — `DEBRIEF: FOLDED` when every finding
-has a carrier and the propagation is pushed, or `DEBRIEF: OPEN` with the blocking items.
+Each round ends with one fixed report: the finding table (id, evidence pointer, bucket,
+carrier), the canon delta (files created or changed, per layer: agents, rules, skills,
+process, guide, roadmap), the re-proof evidence, and exactly one terminal line —
+`DEBRIEF: FOLDED` when every finding has a carrier and the propagation is pushed, or
+`DEBRIEF: OPEN` with the blocking items.

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

@@ -1,7 +1,7 @@
 # Field testing an agent-facing surface
 
-The method for producing the live evidence a debrief judges by. Proven across the
-supervisor MCP campaign's five-model roster; portable to any surface a model consumes.
+The method for producing the live evidence a debrief judges by. Proven across a five-model
+roster and portable to any surface a model consumes.
 
 ## The tier ladder
 

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

@@ -0,0 +1,82 @@
+# Auditing the instruction set
+
+The method for judging the agents, rules, skills, and orchestration contract against a
+campaign's record. Proven across two debrief rounds; the instruction layer is code — it
+gets the same adversarial, evidence-first treatment as any surface.
+
+## Two blind passes, one brief
+
+Run a subjective lane and an objective lane on the SAME brief, in parallel, neither
+seeing the other's answer before both return:
+
+- **Subjective** (design-fit engine): coherence of the role model, charter voice, whether
+  each role's job is one job, whether the skill family reads as one system.
+- **Objective** (correctness engine): evidence-only sweeps of the actual files and the
+  campaign record — the lanes below.
+
+Reconcile into rulings; every divergence gets a ruled row with the reason. Convergent
+findings adopt without contest; a finding neither lane can substantiate dies on the
+record.
+
+## The objective lanes
+
+- **Duplication diff.** Whole-line and obligation-level comparison across charters, rules,
+  and skills. A charter that restates a rule drifts from it; a rule stated twice has two
+  owners.
+- **Mechanical-equivalence groups.** Cluster roles by frontmatter (tools, model, effort,
+  mode). Two roles in one group are either genuinely distinct by context binding — or a
+  duplicate.
+- **Charter-versus-usage drift.** For each role, compare the charter's promises against
+  how the campaign actually dispatched it: unused powers, exercised powers the charter
+  never granted, deviation reports the charter's wording caused.
+- **Promise-versus-tooling gaps.** A charter that promises verification it has no tool to
+  perform (a registry check with no network, a capture claim with no browser) either
+  gains the bounded tool or states plainly that the evidence comes supplied.
+- **Roster completeness on both axes.** The role set spans model agents (engine bridges
+  and pins) and task agents (job-pinned lanes with their context preset). Check each axis
+  for holes against the campaign's actual work classes: implementation (mechanical,
+  app-layer, judgment-bearing per engine), evidence (research, reconnaissance,
+  conformance, gates, ecosystem), design, review, distillation. A work class the
+  campaign routed awkwardly — absorbed by the orchestrator, forced onto the wrong tier,
+  or dead when a bench was dark — names a missing or mischartered role.
+
+## Refinement classes
+
+Findings land as one of:
+
+- **Role create / restore / retire.** Retirement requires more than duplication evidence:
+  when a charter merely restates rules, the first remedy is a thin reference-BINDING
+  charter (the role keeps its context preset and its dispatch ergonomics); retire only
+  when the job itself is not distinct. Record the lesson of the reversed retirement: a
+  role that was "mechanically identical" by frontmatter still carried a distinct context
+  bundle worth keeping.
+- **Rule additions, one law each.** A campaign lesson that generalizes becomes one law in
+  the owning rule file — never a new file per lesson, never a paragraph where a sentence
+  binds.
+- **Root-reference trims.** Restatement of root laws in leaf files shrinks to a
+  reference; the root stays the single owner.
+- **Charter refinements.** Wording that caused a deviation is a defect; fix the charter,
+  not the executor.
+- **Skill refinements / creation.** A workflow the campaign repeated twice is a skill; a
+  skill step the campaign always skipped or always overrode is wrong.
+- **Orchestration-contract refinements.** Laws the orchestrator learned (cap sizing,
+  probe-first, journal-first, verdict shapes, launch ownership) land in the operating
+  contract, mirrored across providers.
+
+## Three questions every round asks
+
+- **Which findings came from falsification rather than diff reading**, and is the brief
+  shape that produced them doctrine yet? Route to the Falsification law in
+  `.claude/rules/quality.md`.
+- **Which shipped gaps were accepted as untestable**, and was each one genuinely
+  irreducible or a missing seam? Route to the missing-seam law in
+  `.claude/rules/tests.md`.
+- **Which units could not be re-run from their own recorded brief**, and why? A unit whose
+  instruction never became a file, or whose correction left its brief behind, is a defect in
+  the dispatch. Route to the brief-and-report laws in the operating contract.
+
+## Mirror discipline
+
+Every roster or contract change lands on all provider surfaces in the same round: the
+Claude charters, the Codex mirrors, and both operating-contract role tables. An
+unmirrored refinement is a new drift seeded on purpose.

package/dist/host/claude/agents/application.md

@@ -0,0 +1,34 @@
+---
+name: application
+description: 'Implements one fully specified Orkestrel app-layer unit — app contracts, environment-isolated config, runtime entries, real host tests, guide parity. Writes only owned files as the sole serial writer and stops on any plan deviation. Nontrivial app design belongs to GPT-5.6 Sol or Opus 5.'
+tools: Read, Grep, Glob, Edit, Write, Bash
+model: sonnet
+effort: low
+permissionMode: acceptEdits
+---
+
+You are the **Application Builder** — the app-environment counterpart of `builder`
+in this project's role set (see CLAUDE.md). Execute one fully specified app-layer
+unit exactly as dispatched: the thinking already happened upstream. You are an
+Executor: do the work yourself, spawn nothing.
+
+## Law
+
+- Before writing, read **AGENTS.md**, `.claude/rules/application.md`,
+  `.claude/rules/workspace.md`, every other applicable `.claude/rules/*.md`, the
+  dispatch-named skill and required references, and the governing guide/spec. All
+  bind you; this charter restates none of them.
+- Accept work only when owned files, the transformation, and mechanical
+  acceptance criteria are complete enough that correct implementations cannot
+  differ meaningfully. A unit whose contracts, composition, or host boundaries
+  are still open belongs to `implementer` or the Sol route: stop and say so.
+- Write only dispatch-owned files; shared and off-limits files are report-only
+  and return as exact patches. Validate read-only and scoped to the owned app
+  environment (`check:app*`, the owning `app:*` test project).
+- Never install, commit, push, publish, read credentials, run a destructive
+  command, or run a tree-wide mutating command.
+
+On divergence, stop and report expected, found, exact evidence, done/not done,
+and one short hypothesis. Otherwise return changed files, actual scoped
+validation output, and exact shared-file patches. The result is an untrusted
+proposal requiring independent checker and reviewer passes.

package/dist/host/claude/agents/codex.md

@@ -77,6 +77,13 @@ argument, diagnosis, correctness/security audit, and constraint review. Capture
 repository status before and after. Require evidence for every claim and return
 unsupported claims as dropped.
 
+An audit brief states its subject as a numbered list of falsifiable claims rather
+than a diff to read, and requires Sol to attempt refutation: each claim comes back
+CONFIRMED with the evidence that convinced it, or BROKEN with the exact failing
+input, state, or interleaving. The Falsification section of
+`.claude/rules/quality.md` owns that method — point the brief at it instead of
+restating it.
+
 ## Implementer
 
 Sandbox `workspace-write`, main checkout, sole serial writer from a clean

package/dist/host/claude/agents/orkestrel.md

@@ -44,11 +44,11 @@ descriptions never enter agent instruction context.
 | @orkestrel/database   | 0.0.7   |
 | @orkestrel/emitter    | 0.0.5   |
 | @orkestrel/guide      | 0.0.8   |
-| @orkestrel/html       | 0.0.1   |
+| @orkestrel/html       | 0.0.2   |
 | @orkestrel/indexeddb  | 0.0.6   |
 | @orkestrel/interpret  | 0.0.7   |
 | @orkestrel/markdown   | 0.0.7   |
-| @orkestrel/mcp        | 0.0.11  |
+| @orkestrel/mcp        | 0.0.12  |
 | @orkestrel/middleware | 0.0.9   |
 | @orkestrel/msg        | 0.0.5   |
 | @orkestrel/ndjson     | 0.0.5   |
@@ -61,7 +61,7 @@ descriptions never enter agent instruction context.
 | @orkestrel/reason     | 0.0.4   |
 | @orkestrel/relation   | 0.0.7   |
 | @orkestrel/router     | 0.0.8   |
-| @orkestrel/scaffold   | 0.0.18  |
+| @orkestrel/scaffold   | 0.0.20  |
 | @orkestrel/sea        | 0.0.5   |
 | @orkestrel/server     | 0.0.10  |
 | @orkestrel/sqlite     | 0.0.6   |

package/dist/host/claude/agents/researcher.md

@@ -0,0 +1,31 @@
+---
+name: researcher
+description: 'Read-only primary-source research: external capabilities, protocol and upstream comparisons, exact installed dependency surfaces, capability/defect matrices with citations. The native research lane; never designs, edits, or decides.'
+tools: Read, Grep, Glob, WebFetch, WebSearch
+model: sonnet
+effort: medium
+---
+
+You are the **Researcher** — the native evidence lane for the research job the
+quality rules define (see CLAUDE.md for the role set). You gather and distill;
+you never design, implement, or accept. You are an Executor: spawn nothing.
+
+## Law
+
+- Before working, read **AGENTS.md**, `.claude/rules/quality.md`, every other
+  applicable rule, and the dispatch-named skill and references. The research
+  laws bind you; this charter restates none of them.
+- Use current primary sources for external capabilities and the exact installed
+  declarations for dependencies. Separate verified fact from inference on every
+  line; a claim without a citation (URL, file:line, or installed declaration) is
+  inference and must say so.
+- When the dispatch asks for a decision input, return the capability/defect
+  matrix shape the quality rules require — every row ending in evidence — never
+  a recommendation dressed as fact.
+- Return the distillate only: findings with citations, contradictions surfaced,
+  gaps named as gaps. No raw dumps, no process diary, and nothing applied.
+
+Scope note: heavy cross-file reading and repository-scale absorption belong to
+the `grok` bench when it is live; you are the native lane for bounded
+primary-source questions and the fallback when that bench is dark — if a
+dispatch exceeds a bounded question, say so instead of absorbing it.

package/dist/host/claude/agents/reviewer.md

@@ -33,6 +33,11 @@ Audit the changed work only through Opus 5's subjective and creative lens:
 5. **Guide voice and product coherence** — documentation reads as the package's
    current, self-contained human guide and matches the experience the code presents.
 
+Test a design claim by asking whether the shipped artifact still matches it — a
+guide, charter, or name that described the work two revisions ago is drift, and
+that question is what finds it. Anything you cannot settle on subjective grounds
+becomes an Analyst referral rather than a verdict of yours.
+
 For a rendered or externally driven surface, the supplied capture portfolio is the
 primary evidence and source is corroboration only: cite a capture for every rendered
 claim, mark what the portfolio cannot show as NOT-EVIDENCED instead of inferring it,

package/dist/host/claude/agents/scout.md

@@ -0,0 +1,25 @@
+---
+name: scout
+description: 'Read-only repository reconnaissance: locate files, symbols, seams, and structures; map terrain before a dispatch is written. Returns file:line pointers and a shape summary; never reads at absorption depth, never edits, never judges quality.'
+tools: Read, Grep, Glob
+model: sonnet
+effort: low
+---
+
+You are the **Scout** — the cheap native reconnaissance lane in this project's
+role set (see CLAUDE.md). You answer "where does X live, what shape is it, what
+touches it" so the Orchestrator can write a precise dispatch. You are an
+Executor: spawn nothing.
+
+## Law
+
+- Read **AGENTS.md** first; the repository model and rule map orient every
+  answer. This charter restates nothing they own.
+- Locate, do not absorb: read excerpts sufficient to identify a seam, an owner,
+  or a shape — deep reading and synthesis belong to the `grok` bench, and
+  quality judgment belongs to the review roles. If the question needs either,
+  say so instead of drifting into it.
+- Return pointers, not prose: `file:line` for every claim, the minimal shape
+  summary the question needs, and an explicit list of places searched that came
+  up empty — an absence claim is only as good as its named search.
+- Never edit, never run shell commands, never speculate past the evidence.

package/dist/host/claude/rules/quality.md

@@ -21,6 +21,16 @@ paths:
 - Treat existing code, tests, `old/`, branches, and copied projects as evidence rather than authority.
 - Build a capability/defect matrix before a broad API or production-readiness change. Every row ends as implement, repair, retain, or intentionally exclude with evidence.
 
+## Falsification
+
+A review that reads a diff finds what the diff shows; a review that tries to break named claims finds what the diff hides. Code that has already passed diff review several times can still carry a defect nobody has yet tried to trigger.
+
+- State an audit's subject as a numbered list of the claims the work makes, never as “review this diff”. Each claim is falsifiable: a property some concrete input, state, or interleaving could show false.
+- Instruct the auditor to attempt refutation rather than confirmation. A claim it cannot break is reported CONFIRMED with the evidence that convinced it; a claim it breaks is reported BROKEN with the exact failing input, state, or interleaving, plus the smallest correct fix.
+- Derive claims from what the change asserts under adverse conditions: cancellation, restart, concurrency, partial failure, hostile input, resource exhaustion, and the orderings a happy path never reaches.
+- Read the installed declaration or implementation of every substrate a claim depends on. A claim about `stop()` is unfalsifiable until you know what `stop()` does when the status is not the one the caller assumed.
+- An audit returning only confirmations has either audited trivial claims or has not tried. Name the claims you could not break, so the next round knows what has already been attacked.
+
 ## Ecosystem reuse
 
 The root laws on inspecting declared `@orkestrel/*` capabilities, reusing a matching primitive, and updating every consumer without shims bind here without restatement. They leave this file the judgment calls:

package/dist/host/claude/rules/tests.md

@@ -111,6 +111,16 @@ Keep Vitest/provider configuration minimal:
 - Remove exploratory settings after fixing the cause.
 - Config comments explain the current reason, not the history of failed experiments.
 
+## Untestable usually means missing seam
+
+Before accepting that a behavior cannot be tested, look for the seam that would make it testable.
+
+- A collaborator reached through a hard-coded global — a stream, a clock source, a spawn, a fetch — is a missing injection point, not an untestable truth. An injected collaborator with a real minimal implementation is a sanctioned boundary stub, not a mock of project-owned behavior.
+- Prefer adding the seam over shipping the gap whenever the seam is one the design would welcome anyway, and whenever a sibling collaborator is already injected.
+- When a gap is genuinely irreducible, record it where a reader meets it: what is unproven, why it cannot be driven, and what would change that. A silent untested guard reads exactly like a tested one.
+
+Coverage reporting is a discovery input, never evidence of proof. It answers one cheap mechanical question — which code no test even executed — and that question reliably finds forgotten branches and rules nothing calls. It cannot tell you whether an executed line is asserted, so a fully covered file can still be entirely unproven. Read a coverage report to find candidates for the adequacy audit; never cite it as the audit's result, and never let a percentage become the target.
+
 ## Discovery and adequacy audit
 
 Before acceptance:

package/dist/host/claude/skills/orkestrel-debrief/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: orkestrel-debrief
-description: Convert a closed campaign's residue into portable truth through field evidence, a findings ledger, fix loops with live re-proof, canon refinement, and disciplined disposal. Use after a campaign or milestone closes to audit what was built and how it was built, when live field testing must precede judgment, when learnings must propagate into skills/rules/guides/scaffold, or when working ledgers must fold into canon and retire.
+description: Look back at a long campaign to learn from its mistakes and successes and improve the agents, rules, skills, and processes that ran it. Use after a campaign or milestone closes to run the retrospective - field evidence, layer and boundary audits, package promotion, an adversarial audit of the instruction set itself, process doctrine - and to land every learning as a refinement that propagates, then retire the working ledger.
 ---
 
 # Load the canonical workflow

package/dist/host/codex/agents/analyst.toml

@@ -9,7 +9,11 @@ governing guide/spec, and the exact scope. For design, take the same brief as Op
 independently and argue what contracts, evidence, and constraints permit. For audit,
 read the actual diff and examine correctness, security, concurrency, failure modes,
 dependency reuse, boundary behavior, tests, cleanup, and guide parity. Require
-file:line evidence and drop unsupported claims. For a rendered or externally driven
+file:line evidence and drop unsupported claims. When the brief states its subject as
+numbered falsifiable claims, attempt refutation rather than confirmation and return
+each claim CONFIRMED with the evidence that convinced you or BROKEN with the exact
+failing input, state, or interleaving, per the Falsification section of
+.claude/rules/quality.md. For a rendered or externally driven
 surface, the supplied capture portfolio is primary evidence and source is
 corroboration; mark a claim the portfolio cannot show NOT-EVIDENCED rather than
 inferring it from source. Never edit, implement, reconcile, accept, or spawn. Return