@orkestrel/scaffold 0.0.77 → 0.0.78

package/dist/host/agents/skills/orkestrel-dispatch/scripts/sweep.ts

@@ -0,0 +1,157 @@
+// Campaign artifact sweep. Run from the checkout root with Node's type stripping:
+//   node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --report
+//   node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --tmp [--older-than MINUTES]
+//   node .agents/skills/orkestrel-dispatch/scripts/sweep.ts --unit UNIT [--delete]
+// --report lists leftovers under tmp/ and .orkestrel/ by age and deletes nothing.
+// --tmp deletes launch files older than the threshold (default 60 minutes), removes emptied
+// directories, and refuses while any launch file changed in the last 2 minutes.
+// --unit lists one accepted unit's files under the launch directories (the brief, report, claims,
+// journal, errors, status, pid, and last-message files whose name is UNIT followed by `-` or `.`), and
+// --delete removes them, refusing while one changed in the last 2 minutes.
+// Exit 0 on success, 2 when a deletion is refused, 64 on usage.
+import { existsSync, readdirSync, rmSync } from 'node:fs'
+import { basename, join } from 'node:path'
+import { listFiles, readMissingFlags, readOption } from './helpers.ts'
+
+const LAUNCH_DIRECTORIES = [
+	'tmp/units',
+	'tmp/cursor',
+	'tmp/codex',
+	'tmp/claude',
+	'tmp/probes',
+	'tmp/type',
+	'tmp/captures',
+]
+const RECENT_MS = 2 * 60_000
+
+// A launch directory holds nothing a walk skips, so every file beneath it counts.
+const NOTHING_SKIPPED: ReadonlySet<string> = new Set()
+
+function formatDay(modified: number): string {
+	return new Date(modified).toISOString().slice(0, 10)
+}
+
+function reportDirectory(directory: string): string | undefined {
+	if (!existsSync(directory)) return undefined
+	const files = listFiles(directory, NOTHING_SKIPPED)
+	if (files.length === 0) return undefined
+	const oldest = files.reduce((low, file) => Math.min(low, file.modified), Number.POSITIVE_INFINITY)
+	return `sweep: ${directory} holds ${files.length} file(s), oldest ${formatDay(oldest)}`
+}
+
+function listCampaignDirectories(): readonly string[] {
+	if (!existsSync('.orkestrel')) return []
+	return readdirSync('.orkestrel', { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => join('.orkestrel', entry.name))
+}
+
+function reportCampaignFiles(): string | undefined {
+	if (!existsSync('.orkestrel')) return undefined
+	const files = readdirSync('.orkestrel', { withFileTypes: true }).filter((entry) => entry.isFile())
+	if (files.length === 0) return undefined
+	return `sweep: .orkestrel holds ${files.length} ecosystem file(s): ${files.map((entry) => entry.name).join(', ')}`
+}
+
+function removeEmptyDirectories(directory: string): void {
+	for (const entry of readdirSync(directory, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue
+		const path = join(directory, entry.name)
+		removeEmptyDirectories(path)
+		if (readdirSync(path).length === 0) rmSync(path, { recursive: true })
+	}
+}
+
+function readThreshold(argv: readonly string[]): number | undefined {
+	if (!argv.includes('--older-than')) return 60
+	const value = Number(readOption(argv, '--older-than'))
+	return Number.isFinite(value) && value > 0 ? value : undefined
+}
+
+function runReport(): number {
+	for (const directory of [...LAUNCH_DIRECTORIES, ...listCampaignDirectories()]) {
+		const line = reportDirectory(directory)
+		if (line !== undefined) console.log(line)
+	}
+	const files = reportCampaignFiles()
+	if (files !== undefined) console.log(files)
+	return 0
+}
+
+function runSweep(thresholdMinutes: number): number {
+	const now = Date.now()
+	const present = LAUNCH_DIRECTORIES.filter((directory) => existsSync(directory))
+	const files = present.flatMap((directory) => listFiles(directory, NOTHING_SKIPPED))
+	if (files.some((file) => now - file.modified < RECENT_MS)) {
+		console.error('sweep: a launch file changed within the last 2 minutes; refusing to delete')
+		return 2
+	}
+	const cutoff = now - thresholdMinutes * 60_000
+	for (const file of files) {
+		if (file.modified > cutoff) continue
+		rmSync(file.path, { force: true })
+		console.log(`sweep: deleted ${file.path}`)
+	}
+	for (const directory of present) removeEmptyDirectories(directory)
+	return 0
+}
+
+function listUnitFiles(unit: string): ReadonlyArray<{ path: string; modified: number }> {
+	return LAUNCH_DIRECTORIES.filter((directory) => existsSync(directory))
+		.flatMap((directory) => listFiles(directory, NOTHING_SKIPPED))
+		.filter((file) => {
+			const name = basename(file.path)
+			return name.startsWith(unit) && /^[-.]/u.test(name.slice(unit.length))
+		})
+}
+
+function runUnit(unit: string | undefined, remove: boolean): number {
+	if (unit === undefined || !/^[A-Za-z0-9._][A-Za-z0-9._-]*$/u.test(unit)) {
+		console.error('usage: sweep.ts --unit UNIT [--delete]')
+		return 64
+	}
+	const files = listUnitFiles(unit)
+	if (remove && files.some((file) => Date.now() - file.modified < RECENT_MS)) {
+		console.error(`sweep: a file of ${unit} changed within the last 2 minutes; refusing to delete`)
+		return 2
+	}
+	for (const file of files) {
+		if (remove) rmSync(file.path, { force: true })
+		console.log(`sweep: ${remove ? 'deleted' : 'found'} ${file.path}`)
+	}
+	console.log(`sweep: ${files.length} file(s) for ${unit}`)
+	return 0
+}
+
+function main(argv: readonly string[]): number {
+	if (!existsSync('.git')) {
+		console.error('sweep: run from the repository root')
+		return 64
+	}
+	const missing = readMissingFlags(argv, ['--unit', '--older-than'])
+	if (missing.length > 0) {
+		console.error(`sweep: ${missing.join(', ')} given with no value`)
+		return 64
+	}
+	const modes = ['--report', '--tmp', '--unit'].filter((flag) => argv.includes(flag))
+	if (modes.length > 1) {
+		console.error(
+			'usage: sweep.ts names one mode: --report | --tmp [--older-than MINUTES] | --unit UNIT [--delete]',
+		)
+		return 64
+	}
+	if (argv.includes('--tmp')) {
+		const threshold = readThreshold(argv)
+		if (threshold === undefined) {
+			console.error('usage: sweep.ts --tmp [--older-than MINUTES]; MINUTES is a positive number')
+			return 64
+		}
+		return runSweep(threshold)
+	}
+	if (argv.includes('--unit')) return runUnit(readOption(argv, '--unit'), argv.includes('--delete'))
+	if (argv.length === 0 || argv.includes('--report')) return runReport()
+	console.error('usage: sweep.ts --report | --tmp [--older-than MINUTES] | --unit UNIT [--delete]')
+	return 64
+}
+
+process.exitCode = main(process.argv.slice(2))

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

@@ -1,218 +1,67 @@
 ---
 name: orkestrel-falsify
-description: Run an adversarial audit round against work that already looks finished — write the subject as numbered falsifiable claims, dispatch independent auditors instructed to break them rather than confirm them, reconcile their evidence, and rule. Use before accepting a fix round, before a version bump or publication, when green gates are the only evidence a change works, when a defect has recurred across rounds, or whenever a review would otherwise read a diff and agree with it.
+description: >-
+  Run one adversarial audit round against finished work: write the subject as numbered falsifiable claims, dispatch independent auditors instructed to break them, reconcile their evidence, and rule. Use when the size gate in `.agents/orchestration.md` names a review, before a fix round is accepted, before a version bump or publication, or when a defect has recurred across rounds. Do not use it for a small change, a mechanical rename, or a round with no added or repaired claim to attack.
 ---
 
 # Falsify
 
-Green gates prove a suite ran. They prove nothing about the claim the work makes. This skill is for
-the moment when everything passes and the work is still not known to be right.
+One round. It ends with a ruling, and a second round needs an added or repaired claim.
 
-## Load authority
+## Run a round only when
 
-1. `AGENTS.md`.
-2. `.claude/rules/quality.md`, especially **Falsification** — the laws governing auditor behaviour.
-   This skill prescribes the round; that section prescribes the conduct inside it. Do not restate it.
-3. The governing guide/spec for the subject.
-4. `references/brief.md` before writing a brief; `references/reconcile.md` before ruling.
-
-## When a round is warranted
-
-Run one when the work is finished and the evidence is weak in a specific way:
-
-- gates are green and nothing has attacked the claim;
-- a fix round is about to be accepted, especially one whose author reported success;
+- the size gate names a review (medium: one pass; large: one round on the integrated result);
+- a fix round is about to be accepted and the fix departed from the reviewer's prescription;
 - a version is about to be bumped, packed, or published;
-- the same defect class has now appeared in more than one round;
-- a self-declared "sound, unchanged, no fix needed" verdict is load-bearing.
-
-Do not run one for a typo, a mechanical rename, or work whose failure would be immediately visible.
-
-A round also needs something new to attack. When the previous round's claims all held, nothing has
-been added or repaired since, and the only motive is that an auditor could still imagine an attack,
-there is no subject — closing is the correct action and the next subject is the deliverable.
-
-When the same class has recurred along one seam to the budget in `.claude/rules/quality.md`
-§ Rounds and verdicts, the next move is that law's strategy switch — the breadth sweep of the
-stream, the ruling, or the dropped moving-target claim — rather than another successor round.
-
-## Write the brief
-
-The brief is the instrument. A weak brief produces a confirming review no matter which auditor reads
-it. Follow `references/brief.md`. What this skill adds beyond the conduct law:
-
-- Every re-run is a **successor**, not a restatement. It carries what the previous round closed so
-  nothing is re-reported, and it adds claims that attack **the previous round's own rulings**.
-- The brief names what the round **decides**. An auditor that does not know the stakes calibrates to
-  politeness.
-- Unknowns are named as unknowns, with how the auditor reports back on them.
-
-The claim form itself is the Falsification law's — read it there. The **verdict shape** in
-§ "Verdict shape" is this skill's, because `.agents/orchestration.md` assigns it here; everything
-else about auditor conduct is the law's.
-
-## Evidence, by subject type
-
-The brief supplies the evidence its subject actually has. Requiring a diff for a subject that has no
-diff is a rule the brief cannot satisfy.
-
-| subject                                 | required evidence                                                                     |
-| --------------------------------------- | ------------------------------------------------------------------------------------- |
-| a code change                           | the actual diff and the actual status output; omitting either is a dispatch deviation |
-| a rendered or externally driven surface | the capture portfolio as primary, source as corroboration                             |
-| a policy, design, or process proposal   | the proposal, the canon it must satisfy, and the record of what motivated it          |
-
-**A subject can occupy more than one row; supply every row it occupies.** A ruling whose fixes
-already landed as edits is both a proposal and a code change, and withholding the diff on the grounds
-that the subject is "a proposal" leaves the auditor unable to check whether a fix changed anything
-nobody claimed.
-
-## Run the round
-
-- **Verify every authority the brief references exists in the tree the auditor is rooted in.** A
-  brief that points at a rule file, section, or guide the executor cannot find delivers nothing while
-  looking like authority — and it fails silently, because an auditor does not report a heading it
-  never saw. Check before dispatch; propagate the missing file rather than restating its contents in
-  the brief. This is the reason restatement felt necessary, and it is the wrong cure. Where the
-  executor's tree carries a superseded vendored copy of an authority, take the stale-authority
-  branch in `references/brief.md` § "What not to put in a brief".
-- Run the **adversarial pass** on one identical brief: a subjective lane and an objective
-  lane, each a fresh subagent with a clean context, blind to each other. Reconcile them yourself.
-  `.agents/orchestration.md` owns lane definitions, engine assignment, and what happens when an
-  engine is dark; do not restate them here.
-- `.agents/orchestration.md` § Execution loop owns which lanes a round runs and the deviation a
-  short round records; § Engine assignment owns the substitution.
-- **Pair every finder with an independent refuter when the round fans out past the subjective and
-  objective lanes.** The
-  refuter receives one slice's findings, never that finder's work, and is briefed to BREAK them
-  rather than to re-audit the subject. It reproduces each stated vector itself and defaults to
-  refuted when uncertain.
-- Refute on any of these grounds, and name which: the vector does not reproduce; the behaviour is
-  correct and documented; it is unreachable through the public API or a documented seam; it asks
-  for new capability rather than naming a defect; it restates a finding an earlier round
-  repaired; or its diagnosis is wrong — then CONFIRM with the correction.
-- Only a survivor earns a fix unit. An unrefuted finding is a hypothesis. The scope grounds,
-  unreachable and new capability, are what keep a round from drifting into a redesign.
-- **Give every auditor the means to run its attacks.** A lens that can only read returns derivations,
-  and a derivation reads exactly like a verdict — it will confirm a claim that one probe would break.
-- **Tell each auditor exactly where a probe may live, and verify that place works before you say it.**
-  A test runner resolves only what its own configuration includes: a probe written outside every
-  configured project is not discovered at all, and the run reports no test files rather than a result.
-  Where the repository provides a probe project, use it and name that project in the brief;
-  `.claude/rules/tests.md` governs what may live there. Where it does not, the reliable form is a file
-  inside the canonical mirrored suite, run by explicit path. Either way the probe is deleted before the
-  auditor returns, and promoted into a permanent test when it proves something worth keeping. Give each
-  concurrent auditor a distinct filename that already satisfies the repository's test naming
-  convention; never invent a prefix to dodge collisions, and never let two auditors claim one path. A
-  probe left in the mirrored suite is discovered and fails a run nobody else caused.
-- **Run auditors concurrently only when their writes cannot collide.** A lens that can execute
-  still writes probes; give each a distinct path and forbid whole-project runs, or serialize the
-  round. **This binds
-  the orchestrator too:** a tree-wide gate run while a round is live sees the auditors' in-flight probes
-  and reports a failure nobody caused. Wait for the round, or scope the command to paths no auditor
-  owns. Never delete another executor's working file to make your own command pass.
-- **Tell a lane when its own engine wrote the half it is auditing, and tell it to attack that half
-  harder.** A fix round reviewed by the engine that wrote it is the case the round exists to avoid,
-  and where the pass cannot avoid it, naming it is what recovers the round. A clean pass on its own
-  engine's work is the least valuable result a lane can return.
-- Supply the evidence the subject type requires, per § "Evidence, by subject type".
-- Auditors edit no source and spawn nothing. Read-only describes the SUBJECT, never the lane's
-  tools.
-- **Derive a lane's executable actions from its tool allowlist and its sandbox, and read both before
-  writing its brief.** A lane with no write tool cannot create a probe; a lane with no shell runs
-  none; a read-only filesystem does not forbid a nonmutating command. Naming an action the lane
-  cannot take stops the unit on arrival over a detail the allowlist and the sandbox already settled.
-- Where an attack needs a tool the lane lacks or a write its sandbox refuses, run the probe
-  yourself, record its control and its output, and supply that record as the lane's evidence before
-  ruling on the claim. The Orchestrator produces, the lane rules. Never widen a lane's tools to fit
-  a brief.
-- Blind reports are **immutable**. Nothing an auditor returns is edited, merged, or revised — by
-  anyone, including the auditor — once it has been returned.
+- the same defect class appeared in more than one round.
 
-## Verdict shape
+Do not run one for a small change, a rename, or work whose failure the touched test already shows. Do not re-run a round whose claims all held when nothing was added or repaired since. A fix that adopted the prescription verbatim closes with a mutation probe instead of a round.
 
-Every auditor in every round returns exactly this, and nothing else. One shape makes rounds
-comparable; a round that invents its own cannot be read against the last one.
+## Write the claims
 
-1. **Numbered verdicts**, one per claim, in the brief's order. Exactly one of these values:
+Write `tmp/units/<unit>-claims.md` and point every lane at it. Read `references/brief.md` for the claim form.
 
-   | value           | meaning                                                                                | evidence                                                                                                                                                      |
-   | --------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-   | `CONFIRMED`     | attacked and it held                                                                   | as the Falsification law requires                                                                                                                             |
-   | `BROKEN`        | falsified                                                                              | as the Falsification law requires — note it says _input, **state, or interleaving**_, so a concurrency claim is falsified by an interleaving, not by an input |
-   | `UNRESOLVED`    | cannot be decided from the evidence available                                          | what would settle it; a claim whose only evidence is the writer's own report takes this value                                                                 |
-   | `NOT-EVIDENCED` | a claim about a rendered or externally driven surface the supplied capture cannot show | which capture is missing                                                                                                                                      |
+- State the subject as numbered falsifiable claims: properties a concrete input, state, or interleaving could show false. Never "review this diff".
+- Derive claims from adverse conditions: cancellation, restart, concurrency, partial failure, hostile input, resource exhaustion, orderings the happy path never reaches.
+- Limit claims to the public contract and the risky seams. A claim about a comment or a name is not a claim.
+- Supply the evidence the subject type requires: a code change carries the actual diff and `git status --porcelain`; a rendered surface carries its capture portfolio with source as corroboration; a proposal carries the proposal, the canon it must satisfy, and its motivation.
+- Name where a lane may run a probe (`tmp/probes/` through the `probe` project) and that it deletes the probe before returning.
+- Name the stakes: what this round decides.
+- A successor brief carries what the previous round closed and adds claims against that round's rulings.
 
-   `CONFIRMED` and `BROKEN` defer; only `UNRESOLVED` and `NOT-EVIDENCED` are this skill's, because
-   the law does not name them. `BROKEN` and `UNRESOLVED` are **separate**: a claim nobody could
-   decide has not been falsified, and it cannot supply the fields falsification requires.
-   `NOT-EVIDENCED` is the auditing lanes' own token; it is kept, not re-invented.
+## Dispatch the lanes
 
-2. **Findings fitting no claim**, if any, each substantiated to the same standard as `BROKEN`.
+- Medium: one lane, on an engine that did not write the work (`reviewer` for Astra-written work, `analyst` for Opus-written work). Large: the objective lane and the subjective lane, same claims file, each in a clean context, neither shown the other's answer before reconciliation. Add `checker` when criteria are mechanical.
+- Tell a lane when its own engine wrote the half it audits.
+- Give a lane the evidence a read-only allowlist cannot produce: run the probe yourself, record its control and output, and hand it over.
+- Auditors edit no source and spawn nothing. Their reports are immutable after they return.
 
-3. **Attacked and held**: the claims this round attacked and could not break, each with the attack
-   that failed, and the adjacent behaviour that looks like the defect and is correct. This is where
-   the next round reads what has already been tried, so a claim listed here without its attack is
-   worth nothing to it. A claim's own `CONFIRMED` line already carries the evidence that convinced
-   the auditor, so list here only the attacks no verdict line carries and the adjacent behaviour.
+## Verdict shape
+
+Every lane returns exactly this:
 
-4. **One terminal line**, and only one:
+1. Numbered verdicts in claim order, one value each: `CONFIRMED` (attacked and held, with the attack), `BROKEN` (the failing input, state, or interleaving plus the smallest correct fix), `UNRESOLVED` (what would settle it; a claim whose only evidence is the writer's report), `NOT-EVIDENCED` (the capture that is missing).
+2. Findings outside the claims, each substantiated to the `BROKEN` standard.
+3. Attacked and held: attacks no verdict line carries, and the adjacent behavior that looks like the defect and is correct.
+4. One terminal line: `VERDICT: PASS` or `VERDICT: FAIL <claim numbers>; outside the claims: <finding ids or none>`. `PASS` needs every claim `CONFIRMED` and no substantiated outside finding.
 
-   ```text
-   VERDICT: PASS
-   VERDICT: FAIL <claim numbers>; outside the claims: <finding ids>
-   ```
+Before confirming a claim about a proof, the lane names the mutation that would make the proof fail and states whether the assertions distinguish it. No process diary.
 
-   The claim numbers are every claim that is not `CONFIRMED`. Write `none` in a slot the round
-   leaves empty, so a `FAIL` driven only by a finding outside the claims still names both.
+## Reconcile and rule
 
-   **`PASS` requires all of this**: every claim `CONFIRMED`, nothing `UNRESOLVED`, nothing
-   `NOT-EVIDENCED`, and no substantiated finding outside the claims. A single substantiated finding
-   forces `FAIL` however the numbered claims landed — otherwise a round can report a real
-   defect and still emit the word that authorises the release.
+Read `references/reconcile.md`.
 
-No process diary. No summary of what was read.
+- Reproduce every `BROKEN` and every outside finding yourself before acting on it.
+- Run `node .agents/skills/orkestrel-dispatch/scripts/cite.ts <verdict>` and discard a verdict whose citation does not resolve, then sample that lane's other citations.
+- Treat lane disagreement as answers to different questions; find each question.
+- Drop, on the record, any finding no lane substantiates.
+- Bound every accepted finding: what is not broken and what over-correcting would break. Put each bound in the fix brief.
+- An all-confirmed round puts the claims on trial: if none could have been falsified by evidence the round had, sharpen them for one successor round; if they could have been, the pass stands and the audit ends.
 
-## When a round comes back all-confirmed
+## Write the verdict
 
-The Falsification law governs this: the brief goes on trial, not the subject. Apply it, and if the
-claims turn out to have been descriptive, the successor brief is where the sharper ones go.
+Write `.orkestrel/<package>/<unit>-audit-verdict.md` with the lanes that ran, their engines, the per-claim rulings, the findings carried into fix units, and any lane the round did not run with the reason. Delete the claims file and the verdict when the seam closes.
 
-## Reconcile and rule
+## After three rounds at one seam
 
-Follow `references/reconcile.md`. The obligations that are not delegable:
-
-- **Reproduce every sharp finding yourself** before acting on it. An auditor's finding is a
-  hypothesis until the orchestrator has run it.
-- **Build before you pack.** `npm pack` runs no build, so it ships whatever `dist/` is on disk. An
-  auditor who packs an artifact to inspect it is reading the last build, not the current source, and
-  will report deleted exports as still shipping. Run the package's build first, and say in the brief
-  that the tarball was built from the commit under audit.
-- **Check the subject before acting on a finding, not only the reasoning.** A brief that names attack
-  vectors teaches the lane those vectors matter, and a lane can hand back the brief's own questions as
-  the subject's claims — demanding coverage for a property the subject never documented. Grep the
-  subject for the claim the finding rests on. Where it is not there, the finding is against the brief.
-- **A disagreement between auditors is rarely a tie to average.** It is usually correct answers
-  to different questions. Find the question each one answered.
-- **Bound every finding**: state what is _not_ broken, and why the adjacent behaviour that looks the
-  same is correct. An audit that reports everything is as useless as one that reports nothing.
-- **Bound the fix before briefing it.** Establish what over-correcting would break, and include that
-  in the fix brief as a constraint.
-- Drop, on the record, any finding neither auditor can substantiate.
-
-## Accept, or run it again
-
-The threshold is **a `PASS` terminal line on a brief whose claims cover what the subject owns** —
-every numbered claim `CONFIRMED` on evidence, nothing `UNRESOLVED`, nothing `NOT-EVIDENCED`, no
-substantiated finding beside them. Never green gates, which prove only that a suite ran.
-
-A round that finds something is a success, not a delay. The alternative is a consumer finding it
-after publication, when the version number is already spent. But an unsubstantiated attack is not a
-finding, and the supply of imaginable ones never runs out: a round is not re-run because an auditor
-can still think of one. A substantiated finding against something no claim names is real and forces
-`FAIL`; an unsubstantiated one is a claim for the successor brief. The escalation law in
-`.claude/rules/quality.md` governs a subject that keeps producing findings at the same seam — after
-enough of them the ruling owed is on the design, not on the next defect.
-
-When a fix round follows, its auditor must be an engine that did not write it, and the next round's
-brief is the successor of this one.
+Stop the depth search. Name what the audit is for, dispatch one blind lens per station of the stream the defect moves along, locate the source, and plan from the source. A subject that reprices on every edit (a count, a census) is not a seam; drop the claim.

package/dist/host/agents/skills/orkestrel-falsify/references/brief.md

@@ -1,124 +1,54 @@
 # Writing the claims brief
 
-The brief decides the round. An auditor reads it faithfully, so a claim too vague to attack
-returns a confirmation that proves nothing. Write every claim sharply enough to be broken.
+Write every claim sharply enough to be broken. A claim too vague to attack returns a confirmation that proves nothing.
 
-## Anatomy
+## Rows
 
-**Subject.** The whole chain, not the last commit. A fix round's defect usually lives in what an
-earlier round assumed, so an audit scoped to the newest diff cannot see it. State the tip, the
-branch, and the chain of rounds with one line each on what each claimed to close.
+Give every claims brief these rows.
 
-**What the round decides.** Say it plainly — "this decides whether the package is bumped and
-consumed downstream", "this decides whether the fix is accepted". An auditor that does not know the
-stakes calibrates to politeness, and politeness confirms.
+- **Subject.** The whole chain, not the last commit: the tip, the branch, and one line per prior round on what it claimed to close.
+- **What the round decides.** One sentence, such as "this decides whether the package is bumped and consumed downstream" or "this decides whether the fix is accepted".
+- **Already established.** What the Orchestrator verified directly, so no lane re-derives it or re-reports it. State that the Orchestrator verified each item itself.
+- **Review evidence.** The actual diff and the actual `git status --porcelain` output, by path. For a rendered or externally driven surface, the capture; source is corroboration.
+- **Numbered falsifiable claims.** Written to `tmp/units/<unit>-claims.md`, one file both lanes read. Each claim names a property a concrete input, state, or interleaving could show false. Assign a primary lane where the lanes differ in strength; no lane skips a claim. The claim set is the round's scope: cover what the subject owns, then hold it closed. An attack against something no claim names enters the verdict only when substantiated to the `BROKEN` standard; otherwise it is a claim for the successor brief.
+- **Unknowns.** What the Orchestrator does not know that the round needs, and how the lane reports on it.
+- **The threshold.** State that a finding is worth more than a clean pass: the alternative is a consumer finding it after publication.
 
-**Already established — do not re-run.** List what the orchestrator has already verified, so effort
-goes somewhere new and settled findings are not re-reported as fresh. State that these were verified
-by the orchestrator directly rather than taken from a writer's report; an auditor that suspects the
-established list is hearsay will re-derive all of it.
+## The lane's brief
 
-**Review evidence.** The actual diff and the actual status output, by path. Omitting either is a
-dispatch deviation. For any claim about a rendered or externally driven surface, the capture is the
-evidence and source is corroboration.
+- Give a lane every row of § Rows plus **Role and lane** (the role, its engine, which lane it holds) and **Output** (the verdict shape and its single terminal line from `SKILL.md` § Verdict shape).
+- Omit the writer rows: owned, shared, and off-limits files; acceptance criteria stated as gate commands. Keep the sentence that the lane performs the assignment itself and spawns nothing.
+- Never hand a lane with no shell a gate criterion; it can only rule on the writer's report.
 
-**Numbered falsifiable claims.** Write them to one file both lanes are pointed at,
-`tmp/audit/<unit>-audit-claims.md`, retained beside the round's verdict. One file is what makes
-"both lanes ran the same brief" checkable after the round, and each lane's own brief then carries
-only its role, its lane, its evidence slice, and its output shape. Each claim is a property some
-concrete input, state, or interleaving could show false. Assign the primary lane where auditors
-differ in strength, but do not let an auditor skip a claim because it assumes the other covers it
-better. The claim set is the round's
-scope: write it to cover what the subject owns, then hold it closed. An attack the round invents
-against something no claim names enters the verdict only when it is substantiated to the `BROKEN`
-standard; otherwise it is a claim for the successor brief, not a finding.
+## The successor brief
 
-**Unknowns, named as unknowns.** What the orchestrator does not know that the round needs, and how
-the auditor reports back on it. A brief that cannot be fully specified says so; the alternative is
-an executor inventing an answer and building on it silently.
+A re-run takes a successor brief named per `.agents/orchestration.md` § Dispatch. It never restates the round from scratch and never edits the brief that ran.
 
-**The threshold.** State that a finding is worth more than a clean pass, and why: the alternative is
-a consumer finding it after publication, when the version is already spent.
+- Add the successor round to the chain table.
+- Move the closed findings into "already established".
+- State what changed in the brief itself.
+- Add a claim for each ruling the previous round made: an input refused rather than carried, a widening called deliberate, a site called sound and unchanged. Attack those first.
 
-## The audit lane's brief
+## Claims that find defects
 
-An audit lane changes no source, so its brief carries fewer rows than a writing unit's. `SKILL.md`
-§ "Run the round" fixes what a lane can execute; read it there before deciding which rows a lane
-can use. Give a lane every row § Anatomy names — the subject with the evidence
-§ "Evidence, by subject type" requires of each row it occupies, what the round decides, already
-established, the numbered falsifiable claims, the unknowns, and the threshold — plus its own
-**Role and lane** row (the role, its engine, and which lane it holds) and **Output** row (the
-verdict shape and its single terminal line). Review evidence folds into the subject.
+- "The containment has no remaining door." Require the lane to enumerate the surface itself, never a registry, table, or sweep the writer produced.
+- "No refusal was widened into a regression." Require the broken legitimate caller pattern to be named.
+- "The instruments bind." Attack the instrument's rule: name a change it would not catch.
+- "No instrument is vacuous." Require a control that cannot produce its failing verdict; name a tautology a previous round shipped.
+- "The guide is true." Ask whether a false universal was replaced by an unfalsifiable one.
+- "The package is coherent as a whole. Would you ship this?"
+- "The self-declared sound-and-unchanged verdicts are sound." Require the lane to attack the ones it judges most likely wrong.
 
-Omit the rows a writer needs and a lane cannot use: owned, shared, and off-limits files; the
-Execution line's writer form, keeping the sentence that the lane performs the assignment directly
-and spawns nothing; and acceptance criteria stated as gate commands. A lane that holds no shell
-cannot close a gate criterion, so a brief handing it one is asking for a ruling on the writer's
-report.
+## Sentences that change lane behavior
 
-## The successor rule
+- "CONFIRMED requires naming the attack you tried that failed."
+- "A claim you cannot decide is UNRESOLVED, not CONFIRMED; say what would settle it."
+- "Assume this chain has one more." Name the prior rounds and the defect a previous round believed closed.
+- "Do not hedge toward an imagined consensus."
+- Never write "an audit returning only confirmations has not tried"; a lane that manufactures a finding to satisfy the brief costs a fix unit and the credibility of the true findings beside it. Test the adequacy of an all-confirmed round afterwards, against the brief.
 
-A re-run takes a **successor brief** that carries the previous round forward. It never restates the
-round from scratch and never edits the brief that already ran; `.agents/orchestration.md`
-§ "Every dispatch is a file before it is a launch" fixes the successor's name and its retention.
-Rewriting a brief from scratch loses the shape of what has already been attacked, and the round
-re-derives it at full cost.
+## Keep out of a brief
 
-A successor brief:
-
-- **carries the chain forward** with the new round added to the table;
-- **moves the closed findings into "already established"** so they are not re-reported;
-- **states what changed in the brief itself**, so a reader can see which claims are new;
-- **adds claims that attack the previous round's own rulings.**
-
-Attack the previous round's rulings first. A fix round makes _decisions_ — that some input is
-refused rather than carried, that some widening is deliberate, that some site is sound and needs no
-change. Those rulings are the freshest and least-examined surface in the package, and the engine
-that made them is least able to see their consequences. Write a claim for each one. Expect a
-repair to carry the next defect; a round that finds them is converging, not failing.
-
-## Claims that repeatedly find things
-
-- **"The containment has no remaining door."** Require the auditor to enumerate the surface itself
-  rather than trust any registry, table, or sweep the writer produced.
-- **"No refusal was widened into a regression."** Every hardening round risks over-correcting. Ask
-  which legitimate caller pattern broke, and require it to be named.
-- **"The instruments bind."** Attack the instrument's _rule_, not its output: name a change it would
-  not catch. An instrument nobody has tried to evade is not evidence.
-- **"No instrument is vacuous."** Ask for a control that cannot produce its failing verdict. If a
-  previous round shipped one, say so and name it — a round told a tautology already shipped here
-  looks harder than one told to check generally.
-- **"The guide is true."** Not plausible — true. Ask specifically whether a false universal has been
-  replaced by an **unfalsifiable** one, which is worse, because it reads as rigour.
-- **"The package is coherent as a whole. Would you ship this?"** The only claim that catches
-  accumulated damage no single diff shows.
-- **"The self-declared sound-and-unchanged verdicts are sound."** A writer's table saying a site
-  needed no change is a claim like any other, made by the party least able to test it. Require the
-  auditor to pick the ones it considers most likely wrong and actually attack them.
-
-## Instructions that change auditor behaviour
-
-- _"CONFIRMED requires naming the attack you tried that failed."_ — the single most effective
-  sentence, because it converts a confirmation from an opinion into a report of work done.
-- _"A claim you cannot decide is UNRESOLVED, not CONFIRMED — say what would settle it."_
-- _"Assume this chain has one more."_ — naming the prior rounds and which of them a defect the
-  previous round believed closed provoked.
-- _"Do not hedge toward an imagined consensus."_ — when auditors run blind, each will otherwise
-  soften toward what it guesses the other said.
-
-Do **not** write _"an audit returning only confirmations has not tried."_ It reads as pressure to
-produce a finding, and an auditor that manufactures one to satisfy the brief has corrupted the round
-in the more expensive direction — a false finding costs a fix unit, an argument, and the credibility
-of the true findings beside it. The adequacy of an all-confirmed round is tested afterwards, against
-the brief, by the orchestrator.
-
-## What not to put in a brief
-
-- Laws already binding from `AGENTS.md` and the rule files. Reference them; restating invites drift
-  between the copy and the original. Where the executor's tree carries a vendored copy of an
-  authority the canon has since superseded, quote the landed text with its canonical path and mark
-  the quotation as superseding the vendored copy, because a bare reference resolves to the stale
-  copy the executor holds.
-- Any hint of what the other auditor is finding, or has found.
-- Your own hypothesis about where the defect is, beyond what the claims state. An auditor handed a
-  suspect investigates the suspect and stops.
+- A law already binding from `AGENTS.md` and the rule files: reference it. Where the executor's tree holds a vendored copy the canon has superseded, quote the landed text with its canonical path and mark the quotation as superseding the copy.
+- Any hint of what the other lane is finding or has found.
+- Your own hypothesis about where the defect is, beyond what the claims state.