@orkestrel/scaffold 0.0.108 → 0.0.109

package/dist/host/agents/skills/orkestrel-parallel/references/claude.md

@@ -4,19 +4,19 @@ Lanes that Claude Code starts in its own session. `.claude/AGENTS.md` owns loadi
 
 ## Mechanics
 
-| Question            | Claude Code                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Start               | The Agent tool for one unit or when the next step depends on the result, with a role from `.claude/agents/` as `subagent_type`; never `general-purpose`, `Plan`, `claude`, or `fork`. A Workflow for a fan-out of small units, a staged pipeline, or a loop, its nodes configured per `.claude/AGENTS.md` § Dispatch. The built-in `Explore` agent for an exact bounded lookup, per `.claude/AGENTS.md` § Dispatch; it loads no instruction files. |
-| Continue            | Resume a custom subagent by its agent id through the installed tool's resume or message interface; a team teammate is not a custom subagent, so verify which one the installed version resumes. Recover an interrupted Workflow with `resumeFromRunId`; its journal replays the finished agents. A surviving transcript file is no continuation route, and a one-shot `Explore` or `Plan` agent cannot continue.                                   |
-| Wake versus deliver | A finished subagent, Workflow, or background command wakes the session with a notification.                                                                                                                                                                                                                                                                                                                                                        |
-| Track               | The agent id, not its display name, and the parent session that can recover it. A Workflow's `scriptPath` and `runId`, recorded at launch; its journal writes only at agent start and result, so read its liveness from the newest subagent transcript. A background command's task id and output file.                                                                                                                                            |
-| Background          | A foreground shell call is capped at 10 minutes. A background command runs to its own timeout, at most 2 hours, then stops. Run anything longer under `.agents/skills/orkestrel-dispatch/references/launch.md` § Launch ownership.                                                                                                                                                                                                                 |
-| Isolation           | Agents share the session's checkout; `isolation: worktree` gives one agent its own worktree.                                                                                                                                                                                                                                                                                                                                                       |
-| Tools               | A role's frontmatter lists its tools, and the host can still withhold one: in-process roles in the desktop host ran with no shell although their charter listed one (2026-10-03), and the harness can refuse an in-process agent's file write.                                                                                                                                                                                                     |
-| Limits              | At the account's usage limit, running agents and Workflow agents stop mid-run and keep the edits they made.                                                                                                                                                                                                                                                                                                                                        |
-| Host effects        | Agents and Workflow nodes run inside the session's process and open no window (2026-10-21). An agent's shell can restart in the session root between calls (2026-10-17).                                                                                                                                                                                                                                                                           |
-| Visibility          | Agent tool calls, Workflow runs, and background commands appear in the session the user watches, where the user can stop them; a CLI started from a shell shows only its command line, so run it as a capped command inside such a lane.                                                                                                                                                                                                           |
-| Capability map      | `.agents/orchestration.md` § Roles, Claude column; `.claude/AGENTS.md` § Models owns the aliases.                                                                                                                                                                                                                                                                                                                                                  |
+| Question            | Claude Code                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Start               | The Agent tool for one unit or when the next step depends on the result, with a role from `.claude/agents/` as `subagent_type`; never `general-purpose`, `Plan`, `claude`, `fork`, or `Explore`. A Workflow for a fan-out of small units, a staged pipeline, or a loop, its nodes configured per `.claude/AGENTS.md` § Dispatch. `scout` for an exact bounded lookup, per `.agents/orchestration.md` § Routing.  |
+| Continue            | Resume a custom subagent by its agent id through the installed tool's resume or message interface; a team teammate is not a custom subagent, so verify which one the installed version resumes. Recover an interrupted Workflow with `resumeFromRunId`; its journal replays the finished agents. A surviving transcript file is no continuation route, and a one-shot `Explore` or `Plan` agent cannot continue. |
+| Wake versus deliver | A finished subagent, Workflow, or background command wakes the session with a notification.                                                                                                                                                                                                                                                                                                                      |
+| Track               | The agent id, not its display name, and the parent session that can recover it. A Workflow's `scriptPath` and `runId`, recorded at launch; its journal writes only at agent start and result, so read its liveness from the newest subagent transcript. A background command's task id and output file.                                                                                                          |
+| Background          | A foreground shell call is capped at 10 minutes. A background command runs to its own timeout, at most 2 hours, then stops. Run anything longer under `.agents/skills/orkestrel-dispatch/references/launch.md` § Launch ownership.                                                                                                                                                                               |
+| Isolation           | Agents share the session's checkout; `isolation: worktree` gives one agent its own worktree.                                                                                                                                                                                                                                                                                                                     |
+| Tools               | A role's frontmatter lists its tools, and the host can still withhold one: in-process roles in the desktop host ran with no shell although their charter listed one (2026-10-03), and the harness can refuse an in-process agent's file write.                                                                                                                                                                   |
+| Limits              | At the account's usage limit, running agents and Workflow agents stop mid-run and keep the edits they made.                                                                                                                                                                                                                                                                                                      |
+| Host effects        | Agents and Workflow nodes run inside the session's process and open no window (2026-10-21). An agent's shell can restart in the session root between calls (2026-10-17).                                                                                                                                                                                                                                         |
+| Visibility          | Agent tool calls, Workflow runs, and background commands appear in the session the user watches, where the user can stop them; a CLI started from a shell shows only its command line, so run it as a capped command inside such a lane.                                                                                                                                                                         |
+| Capability map      | `.agents/orchestration.md` § Roles, Claude column; `.claude/AGENTS.md` § Models owns the aliases.                                                                                                                                                                                                                                                                                                                |
 
 ## Quirks
 
@@ -29,4 +29,6 @@ Lanes that Claude Code starts in its own session. `.claude/AGENTS.md` owns loadi
 - When an agent works outside the session root, give it absolute paths, and check the root's `git status` for strays after it returns.
 - When read-only fan-out runs on a host where child CLIs open windows, prefer in-process agents and Workflow nodes.
 - When the Edit or Write tool must reproduce a literal Unicode escape in source (a backslash, the letter `u`, and four hexadecimal digits), write that backslash itself as a Unicode escape (code point 5C). The tools decode every such escape you type before matching or writing, so a typed escape for a backtick lands as a backtick (2026-10-27). Never fall back to a shell edit.
+- When a command carries a program, keep it in a TypeScript file run by `node`: a heredoc, `node -e`, an `&&` chain, or a `${...}` argument trips the harness's approval classifier on a Windows host; a one-shot read-only check can run inline.
+- When a `Remove-Item` runs on a Windows host, run it as its own short command with a relative path: the approval classifier blocks a command that pairs it with a path-like literal elsewhere, such as a `'\'` string. Verify with `git status`.
 - When a claim about caching, resume, or team behavior matters, verify it against the installed version and the official [subagent documentation](https://code.claude.com/docs/en/sub-agents), [team limitations](https://code.claude.com/docs/en/agent-teams), and [prompt-cache documentation](https://code.claude.com/docs/en/prompt-caching).

package/dist/host/agents/skills/orkestrel-parallel/references/codex.md

@@ -24,5 +24,6 @@ Native Codex agents, and Codex lanes another harness hosts. `.codex/config.toml`
 - When the shell yields before the command exits, start nothing else, and confirm no owned leftover remains before the next lane; a lane that started the next test file broke the one-runner bound (2026-10-22).
 - When a brief launches a long command, name its terminal record, such as the launcher's `exit=` line; a lane read a finished step as running and polled it for six minutes (2026-10-22).
 - When a review brief describes risks in offensive-security wording, the provider's filter can end the lane without a verdict (2026-10-20). Brief the review as quality assurance of the user's own code in neutral words, require an early verdict file, retry once, then use a recorded fallback.
+- When a `codex exec` run is killed, treat it as dead only when its `codex-code-mode-host` child is gone too.
 - When a Codex child runs through a hosting harness, it can reach that harness's messaging tools; probe them before a writer or runner depends on them (`references/t3.md`).
 - When a launch fails on a tool server's handshake timeout, relaunch that lane alone; a lane beside it started with the same server (2026-10-19). Stagger launches that start the same server.

package/dist/host/agents/skills/orkestrel-parallel/references/cursor.md

@@ -4,19 +4,19 @@ Cursor lanes, through the Cursor CLI or a hosting harness. `.cursor/rules/orches
 
 ## Mechanics
 
-| Question            | Cursor                                                                                                                                                                                                              |
-| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Start               | The CLI bench per `.agents/transports/cursor.md`, or the hosting harness's child-task channel (`references/t3.md`).                                                                                                 |
-| Continue            | The CLI's `--resume` option with the session id from the `init` event continues the session with its read context intact (2026-10-01); probe it before its first use.                                               |
-| Wake versus deliver | No peer-message wake channel is demonstrated.                                                                                                                                                                       |
-| Track               | The session id from the `init` event and the journal path.                                                                                                                                                          |
-| Background          | The CLI runs under `.agents/skills/orkestrel-dispatch/scripts/launch.ts` with a cap. A lane outlived its stated 600-second timeout by running 764 seconds (2026-09-30).                                             |
-| Isolation           | Lanes share the checkout.                                                                                                                                                                                           |
-| Tools               | The bench runs in ask mode, read-only. It reads images: it read a capture's heading, captions, and fills exactly in 36 seconds (2026-10-16).                                                                        |
-| Limits              | At the account's usage limit, the bench reads dark; record it and use the native reader per `.agents/orchestration.md` § Benches.                                                                                   |
-| Host effects        | A Grok lane that ran shell commands leaked about one orphaned `conhost.exe` a second on a Windows host (838 in 12 minutes, 8.8 GB, 2026-10-19). Briefs that forbade every command ran ten lanes clean (2026-10-21). |
-| Visibility          | The CLI bench is hidden; run it only as a capped command inside a visible lane.                                                                                                                                     |
-| Capability map      | Reader only: the `grok` role.                                                                                                                                                                                       |
+| Question            | Cursor                                                                                                                                                                                                       |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Start               | The CLI bench per `.agents/transports/cursor.md`, or the hosting harness's child-task channel (`references/t3.md`).                                                                                          |
+| Continue            | The CLI's `--resume` option with the session id from the `init` event continues the session with its read context intact (2026-10-01); probe it before its first use.                                        |
+| Wake versus deliver | No peer-message wake channel is demonstrated.                                                                                                                                                                |
+| Track               | The session id from the `init` event and the journal path.                                                                                                                                                   |
+| Background          | The CLI runs under `.agents/skills/orkestrel-dispatch/scripts/launch.ts` with a cap. A lane outlived its stated 600-second timeout by running 764 seconds (2026-09-30).                                      |
+| Isolation           | Lanes share the checkout.                                                                                                                                                                                    |
+| Tools               | The bench runs in ask mode, read-only. It reads images: it read a capture's heading, captions, and fills exactly (2026-10-16).                                                                               |
+| Limits              | At the account's usage limit, the bench reads dark; record it and use the native reader per `.agents/orchestration.md` § Benches.                                                                            |
+| Host effects        | A Grok lane that ran shell commands leaked `conhost.exe` processes on a Windows host (2026-10-19; see `.agents/platforms/windows.md` § Processes). Briefs that forbade every command ran clean (2026-10-21). |
+| Visibility          | The CLI bench is hidden; run it only as a capped command inside a visible lane.                                                                                                                              |
+| Capability map      | Reader only: the `grok` role.                                                                                                                                                                                |
 
 ## Quirks
 

package/dist/host/agents/skills/orkestrel-parallel/scripts/cases.ts

@@ -0,0 +1,389 @@
+// Check a Vitest JSON report against named red and green cases. Run from the checkout root:
+//   node .agents/skills/orkestrel-parallel/scripts/cases.ts --report FILE.json [--passed NAME ...] [--failed NAME ...]
+// The report is Vitest's `--reporter=json` output. A name matches every case whose full name (its
+// `describe` titles and its own title, joined by spaces) or whose own title equals it exactly; a name
+// that opens with `--` cannot be given. Each `--passed NAME` requires every case it matches to have
+// passed and each `--failed NAME` requires every one to have failed; a name that matches no case is
+// missing. A failed case that no name matches is refused, so a run that fails more than the request
+// expected reads as a difference. A test file that failed with no failed case (it did not collect,
+// or a hook threw) is an unnamed failure named by its file, and a report whose `success` is false
+// while no case and no file failed is a difference too. Name no case to require a report with no
+// failure. Both flags repeat and a name may not be given to both. The script prints one summary
+// line, one line per difference, and `ok` or `differences=N`. The script refuses a flag it does not
+// read, the `--flag=value` form included, and names an unknown flag before a flag given with no
+// value. Exit 0 when the report matches the names, 3 when it does not, 2 when the report cannot be
+// read as a Vitest report, 64 on usage.
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import { relative } from 'node:path'
+
+/** Lists the flags that take a value. */
+export const VALUE_FLAGS: readonly string[] = ['--report', '--passed', '--failed']
+
+/** Lists every flag the script reads, value flags and switches alike. */
+export const FLAGS: readonly string[] = VALUE_FLAGS
+
+/** Holds the usage line printed when a call names no report. */
+export const USAGE =
+	'usage: cases.ts --report FILE.json [--passed NAME ...] [--failed NAME ...]; --passed and --failed repeat'
+
+/** Describes one test case a report holds. */
+export interface Case {
+	readonly file: string
+	readonly fullName: string
+	readonly title: string
+	readonly status: string
+}
+
+/**
+ * Names the value flags a caller gave with no value, at any occurrence.
+ *
+ * @param argv - The arguments after the script path.
+ * @param names - The flags that take a value.
+ * @returns Each named flag that appears last or is followed by another flag, in argument order.
+ */
+export function readMissingFlags(
+	argv: readonly string[],
+	names: readonly string[],
+): readonly string[] {
+	return names.filter((name) =>
+		argv.some((argument, index) => argument === name && isMissingValue(argv, index)),
+	)
+}
+
+/**
+ * Checks whether the argument after a flag is absent or is another flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param index - The position of the flag.
+ * @returns True when no value follows the flag; false otherwise.
+ */
+export function isMissingValue(argv: readonly string[], index: number): boolean {
+	const value = argv[index + 1]
+	return value === undefined || value.startsWith('--')
+}
+
+/**
+ * Names the flags a caller gave that the script does not read.
+ *
+ * @remarks
+ * A `--flag=value` argument is unknown, because the script reads no such form. A bare `--` ends the
+ * scan.
+ *
+ * @param argv - The arguments after the script path.
+ * @param flags - Every flag the script reads, value flags and switches alike.
+ * @returns Each argument that opens with `--` and is not a read flag, in argument order.
+ */
+export function readUnknownFlags(
+	argv: readonly string[],
+	flags: readonly string[],
+): readonly string[] {
+	const end = argv.indexOf('--')
+	return (end === -1 ? argv : argv.slice(0, end)).filter(
+		(argument) => argument.startsWith('--') && !flags.includes(argument),
+	)
+}
+
+/**
+ * Reads every value that follows a repeatable flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param name - The flag, such as `--passed`.
+ * @returns The values in order, empty when the flag never appears.
+ */
+export function readOptions(argv: readonly string[], name: string): readonly string[] {
+	return argv.flatMap((argument, index) => {
+		const value = argv[index + 1]
+		return argument === name && value !== undefined && !value.startsWith('--') ? [value] : []
+	})
+}
+
+/**
+ * Reads the arguments that are neither a flag nor the value of a value flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param valueFlags - The flags that take a value.
+ * @returns The positional arguments in order.
+ */
+export function readPositionals(
+	argv: readonly string[],
+	valueFlags: readonly string[],
+): readonly string[] {
+	return argv.filter(
+		(argument, index) => !argument.startsWith('--') && !valueFlags.includes(argv[index - 1] ?? ''),
+	)
+}
+
+/**
+ * Checks whether a value is a non-null, non-array object.
+ *
+ * @param value - The value to inspect.
+ * @returns True if the value is an object other than null or an array; false otherwise.
+ */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/**
+ * Quotes an untrusted text for a diagnostic, JSON-encoded and cut to a bounded length.
+ *
+ * @param text - The text to quote.
+ * @returns The JSON string literal of the text, ending in an ellipsis inside the quotes when cut.
+ */
+export function quote(text: string): string {
+	return JSON.stringify(text.length > 120 ? `${text.slice(0, 120)}…` : text)
+}
+
+/**
+ * Reads one assertion result of a report as a case.
+ *
+ * @param file - The test file the result belongs to.
+ * @param result - The parsed JSON value of one assertion result.
+ * @returns The case as a one-member list, or an empty list when the result lacks a title or status.
+ */
+export function readCase(file: string, result: unknown): readonly Case[] {
+	if (!isRecord(result)) return []
+	const { title, status, fullName, ancestorTitles } = result
+	if (typeof title !== 'string' || typeof status !== 'string') return []
+	const ancestors = Array.isArray(ancestorTitles)
+		? ancestorTitles.filter((member) => typeof member === 'string')
+		: []
+	return [
+		{
+			file,
+			title,
+			status,
+			fullName: typeof fullName === 'string' ? fullName : [...ancestors, title].join(' '),
+		},
+	]
+}
+
+/**
+ * Reads the cases of a Vitest JSON report.
+ *
+ * @param report - The parsed JSON value of the report.
+ * @returns Every case in file order, or undefined when the value is not a Vitest report: an object
+ * whose `testResults` is an array.
+ */
+export function readCases(report: unknown): readonly Case[] | undefined {
+	if (!isRecord(report) || !Array.isArray(report.testResults)) return undefined
+	return report.testResults.flatMap((suite): readonly Case[] => {
+		if (!isRecord(suite) || !Array.isArray(suite.assertionResults)) return []
+		const file = typeof suite.name === 'string' ? suite.name : ''
+		return suite.assertionResults.flatMap((result) => readCase(file, result))
+	})
+}
+
+/**
+ * Reads the test files of a report that failed with no failed case.
+ *
+ * @param report - The parsed JSON value of the report.
+ * @returns The `name` of each `testResults` entry whose `status` is `failed` and whose assertion
+ * results hold no failed case, in file order; an empty text stands for an entry with no name.
+ */
+export function readFailedFiles(report: unknown): readonly string[] {
+	if (!isRecord(report) || !Array.isArray(report.testResults)) return []
+	return report.testResults.flatMap((suite): readonly string[] => {
+		if (!isRecord(suite) || suite.status !== 'failed') return []
+		const results = Array.isArray(suite.assertionResults) ? suite.assertionResults : []
+		if (results.some((result) => isRecord(result) && result.status === 'failed')) return []
+		return [typeof suite.name === 'string' ? suite.name : '']
+	})
+}
+
+/**
+ * Checks whether a report states that the run did not succeed.
+ *
+ * @param report - The parsed JSON value of the report.
+ * @returns True when the report is an object whose `success` is `false`; false otherwise.
+ */
+export function isUnsuccessful(report: unknown): boolean {
+	return isRecord(report) && report.success === false
+}
+
+/**
+ * Checks whether a name matches a case.
+ *
+ * @param entry - The case.
+ * @param name - The name from `--passed` or `--failed`.
+ * @returns True when the name equals the case's full name or its own title; false otherwise.
+ */
+export function matchesCase(entry: Case, name: string): boolean {
+	return entry.fullName === name || entry.title === name
+}
+
+/**
+ * Judges the cases of a report against the names a caller gave.
+ *
+ * @param cases - The report's cases.
+ * @param passed - The names that must have passed.
+ * @param failed - The names that must have failed.
+ * @param base - The directory the file names in each difference are written relative to.
+ * @returns Each difference in order: missing names, wrong statuses, then failed cases no name
+ * matches; empty when the report matches.
+ */
+export function judgeCases(
+	cases: readonly Case[],
+	passed: readonly string[],
+	failed: readonly string[],
+	base: string,
+): readonly string[] {
+	const expectations = [
+		...passed.map((name) => ({ name, status: 'passed' })),
+		...failed.map((name) => ({ name, status: 'failed' })),
+	]
+	const named = expectations.flatMap((expectation) => {
+		const matches = cases.filter((entry) => matchesCase(entry, expectation.name))
+		if (matches.length === 0) return [`missing: ${quote(expectation.name)} matches no case`]
+		return matches
+			.filter((entry) => entry.status !== expectation.status)
+			.map(
+				(entry) =>
+					`status: ${quote(entry.fullName)} is ${entry.status}, expected ${expectation.status}${describeFile(base, entry.file)}`,
+			)
+	})
+	const unnamed = cases
+		.filter(
+			(entry) =>
+				entry.status === 'failed' &&
+				!expectations.some((expectation) => matchesCase(entry, expectation.name)),
+		)
+		.map((entry) => `unnamed failure: ${quote(entry.fullName)}${describeFile(base, entry.file)}`)
+	return [...named, ...unnamed]
+}
+
+/**
+ * Judges the failures a report holds outside its cases.
+ *
+ * @param cases - The report's cases.
+ * @param failedFiles - The test files that failed with no failed case, from {@link readFailedFiles}.
+ * @param unsuccessful - Whether the report states that the run did not succeed.
+ * @param base - The directory the file names in each difference are written relative to.
+ * @returns One unnamed failure per failed file; or, when no file and no case failed yet the report
+ * is not successful, one unnamed failure for the report; empty otherwise.
+ */
+export function judgeFailures(
+	cases: readonly Case[],
+	failedFiles: readonly string[],
+	unsuccessful: boolean,
+	base: string,
+): readonly string[] {
+	if (failedFiles.length > 0) {
+		return failedFiles.map(
+			(file) =>
+				`unnamed failure: ${file === '' ? 'a test file' : quote(relativeFile(base, file))} failed with no failed case`,
+		)
+	}
+	return unsuccessful && cases.every((entry) => entry.status !== 'failed')
+		? ['unnamed failure: the report is not successful, yet no case and no file in it failed']
+		: []
+}
+
+/**
+ * Writes a test file path relative to a directory.
+ *
+ * @param base - The directory the path is written relative to.
+ * @param file - The test file path from the report.
+ * @returns The relative path with forward slashes.
+ */
+export function relativeFile(base: string, file: string): string {
+	return relative(base, file).split('\\').join('/')
+}
+
+/**
+ * Describes the file a case belongs to, written relative to a directory.
+ *
+ * @param base - The directory the path is written relative to.
+ * @param file - The test file path from the report.
+ * @returns ` in <path>` with forward slashes, or an empty text when the report names no file.
+ */
+export function describeFile(base: string, file: string): string {
+	return file === '' ? '' : ` in ${relativeFile(base, file)}`
+}
+
+/**
+ * Counts the cases that carry a status.
+ *
+ * @param cases - The report's cases.
+ * @param status - The status, such as `passed`.
+ * @returns How many cases have exactly that status.
+ */
+export function countStatus(cases: readonly Case[], status: string): number {
+	return cases.filter((entry) => entry.status === status).length
+}
+
+/**
+ * Reads a report file as JSON.
+ *
+ * @param path - The report file.
+ * @returns The parsed value, or undefined when the file is not readable JSON.
+ */
+export function readReport(path: string): unknown {
+	try {
+		return JSON.parse(readFileSync(path, 'utf8'))
+	} catch {
+		return undefined
+	}
+}
+
+/**
+ * Runs the script on its arguments.
+ *
+ * @param argv - The arguments after the script path.
+ * @returns The exit code: 0 when the report matches the names, 3 when it does not, 2 when the report
+ * cannot be read as a Vitest report, 64 on usage.
+ */
+export function main(argv: readonly string[]): number {
+	const unknown = readUnknownFlags(argv, FLAGS)
+	if (unknown.length > 0) {
+		console.error(`cases: ${unknown.join(', ')} is not a flag this script reads; ${USAGE}`)
+		return 64
+	}
+	const missing = readMissingFlags(argv, VALUE_FLAGS)
+	if (missing.length > 0) {
+		console.error(`cases: ${missing.join(', ')} given with no value`)
+		return 64
+	}
+	const reports = readOptions(argv, '--report')
+	const path = reports[0]
+	const passed = readOptions(argv, '--passed')
+	const failed = readOptions(argv, '--failed')
+	if (path === undefined || readPositionals(argv, VALUE_FLAGS).length > 0) {
+		console.error(USAGE)
+		return 64
+	}
+	const both = passed.filter((name) => failed.includes(name))
+	if (both.length > 0) {
+		console.error(
+			`cases: ${both.map(quote).join(', ')} given to both --passed and --failed; ${USAGE}`,
+		)
+		return 64
+	}
+	if (!existsSync(path) || !statSync(path).isFile()) {
+		console.error(`cases: ${quote(path)} is not a readable file`)
+		return 2
+	}
+	const report = readReport(path)
+	const cases = readCases(report)
+	if (cases === undefined) {
+		console.error(
+			`cases: ${quote(path)} is not a Vitest JSON report; it needs a "testResults" array (run vitest with --reporter=json)`,
+		)
+		return 2
+	}
+	const differences = [
+		...judgeCases(cases, passed, failed, process.cwd()),
+		...judgeFailures(cases, readFailedFiles(report), isUnsuccessful(report), process.cwd()),
+	]
+	const green = countStatus(cases, 'passed')
+	const red = countStatus(cases, 'failed')
+	console.log(
+		`cases total=${String(cases.length)} passed=${String(green)} failed=${String(red)} other=${String(cases.length - green - red)}`,
+	)
+	for (const difference of differences) console.log(difference)
+	console.log(differences.length === 0 ? 'ok' : `differences=${String(differences.length)}`)
+	return differences.length === 0 ? 0 : 3
+}
+
+if (process.argv[1] !== undefined && realpathSync(process.argv[1]) === import.meta.filename) {
+	process.exitCode = main(process.argv.slice(2))
+}

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

@@ -24,8 +24,8 @@ supposed to produce it. Source-reading review passes a component that renders no
   accessibility snapshot, and an interaction log.
 - Source is corroboration for a mechanism, never the proof that the surface shows it.
 - A claim the portfolio cannot show is unproven, not passed. Say so.
-- The same law governs an externally driven surface: a compatibility claim is proven by
-  driving it with a representative real client, not by its own tests.
+- Prove an externally driven surface's compatibility claim per the `orkestrel-harden` skill's
+  Production hardening → Use real implementations.
 
 ## Select the scope
 
@@ -36,29 +36,25 @@ Choose the smallest scope that satisfies the request:
   re-verdict on the repaired items → independent gates.
 
 A narrow verdict request does not authorize fixes. A polish request authorizes fixing every
-confirmed finding in scope and rebuilding the harness gaps the verdicts expose. A second round
-over the same surface needs an instruction from the user.
+confirmed finding in scope and rebuilding the harness gaps the verdicts expose.
 
 ## Execute the round
 
 1. **Build the portfolio.** Produce the full evidence set with the harness reference, then
-   eyeball every artifact yourself before spending a verdict round on it. An unexamined
-   portfolio buys harness bugs at verdict prices.
+   eyeball every artifact yourself before spending a verdict round on it.
 2. **Seed candidates.** Turn your own mid-integration observations into numbered
-   confirm-or-refute candidates inside the verdict brief. Observations that stay in your
-   head are neither evidence nor findings.
+   confirm-or-refute candidates inside the verdict brief.
 3. **Take independent verdicts** on the SAME portfolio, in the shape
-   § "Return the fixed verdict shape" fixes. The
-   lanes are subjective design fit; objective state truth; and mechanical inventory of
-   copy, classes, icons, and accessibility attributes. This is the surface variant of the
-   review in `.agents/orchestration.md` § Size gate, so its rules bind: each lane is a fresh
-   subagent with a clean context, blind to the others until reconciliation, run once, and no
-   lane is dropped because an engine is dark. A narrow verdict request runs the selected lane once
-   and stops.
+   § "Return the fixed verdict shape" fixes. Judgment runs as the two lanes
+   `.agents/orchestration.md` § Parallelism names: subjective design fit and objective state
+   truth. The mechanical inventory of copy, classes, icons, and accessibility attributes runs as a
+   `checker` lane. This is the surface variant of the review in `.agents/orchestration.md`
+   § Size gate, so its rules bind: each judgment lane is a fresh subagent with a clean context,
+   blind to the other until reconciliation, run once, and no lane is dropped because an engine is
+   dark. A narrow verdict request runs the selected lane once and stops.
 4. **Reconcile.** Confirmed findings get carriers; refuted findings close on the record with
    the evidence that refuted them; conflicts get a dated ruling. Then walk the reconciled
-   list once and name the fix-brief item carrying each finding — a finding with no carrier
-   is a dropped finding, and it will cost the next round.
+   list once and name the fix-brief item carrying each finding.
 5. **Dispatch serialized fix units,** objective lane first because it changes the ground
    truth the subjective lane reads. Each unit records the failing proof before the
    repair — the exact command and its red count — and the same command's green count
@@ -87,7 +83,7 @@ over the same surface needs an instruction from the user.
 
 ## Return the fixed verdict shape
 
-Free-form verdicts cost one reconciliation pass each. Every verdict returns:
+Every verdict returns:
 
 - one line per item, in the brief's numbering:
   - `RENDERED-PROVEN(<capture>)` — the artifact shows it;
@@ -101,8 +97,8 @@ Triage it against the capture reference before it becomes a finding.
 
 ## Accept the result
 
-Do not accept a source-only verdict, a self-audited fix unit, a round without a terminal
-line, or a green claim from the engine that wrote the code. Completion requires:
+Accept per `.agents/orchestration.md` § Acceptance. Refuse a source-only verdict, a self-audited
+fix unit, and a round without a terminal line. Completion requires:
 
 - every confirmed finding fixed or explicitly ruled out of scope on the record;
 - a final portfolio whose captures show the accepted state;

package/dist/host/agents/skills/orkestrel-polish/references/capture-harness.md

@@ -17,9 +17,7 @@ journey-generated and part spawned.
 Apply this section to a spawned harness only.
 
 - Write the harness as one self-contained script that spawns its own children, waits for readiness,
-  does the capture, and kills them before returning.
-- Never leave a child running across calls or expect one to survive its parent. A process started
-  inside one tool call dies with that call's process group.
+  does the capture, and kills them before returning. Spawn, capture, and tear down in one call.
 - Give every child a pinned working directory. A process that resolves assets, configuration, or
   fixtures relative to the current directory dies silently when launched from elsewhere.
 - Pipe child standard error somewhere readable and print it on failure.
@@ -43,33 +41,26 @@ and `orkestrel-journey` fixes how it enters and what it may reach past.
 
 ## Capture the full portfolio
 
-Produce every artifact in the following table each round, for every scenario in scope. The Source
-column names what produces the artifact in the journey run; a spawned harness produces each one
-itself.
-
-| Artifact               | Source in the journey run            | What the artifact must show                                                           |
-| ---------------------- | ------------------------------------ | ------------------------------------------------------------------------------------- |
-| Viewport captures      | `place` across the declared variants | Every breakpoint the surface declares, never one convenient size                      |
-| Theme captures         | `place` across the declared variants | Every theme the surface ships, at every declared viewport                             |
-| Accessibility snapshot | `describeTree` and `describeFocus`   | The rendered roles, names, and states, and the focus order the walk took              |
-| Interaction log        | The journal's `steps`                | Each interaction, its trigger, and the result observed after it                       |
-| Console and error log  | The journal's `output`               | Everything the page emitted, including an uncaught error                              |
-| Statechart outcome     | The harness after a play-all run     | The terminal status, the passed, failed, and total tallies, and each row's own result |
-
-- Require the statechart outcome of every surface that declares the statechart family, and omit the
-  row only where the surface declares none.
-- Read the journey run's per-variant written artifact for the accessibility snapshot and the logs,
-  and cite the statechart harness by its deep link where a lane must watch the widget move rather
-  than read a still of it. `orkestrel-journey` fixes what each holds and what each is named
-  for.
+Produce each of the following every round, for every scenario in scope:
+
+- Viewport captures at every breakpoint the surface declares, and theme captures for every theme it ships at every declared viewport. In the journey run, `place` across the declared variants produces them.
+- The rendered artifact per variant, composed as the `orkestrel-journey` skill's Routing a question → The rendered artifact fixes: the accessibility snapshot, the focus order, the interaction log, and the console and error log.
+- The statechart outcome of every surface that declares the statechart family: the terminal status, the passed, failed, and total tallies, and each row's own result. The harness produces it after a play-all run; cite its deep link where a lane must watch the widget move rather than read a still of it.
+
+A spawned harness produces each artifact itself.
+
 - Shoot the whole surface before selecting or focusing anything inside it. A capture taken after a
   selection reports a duplicate or highlighted artifact that does not exist.
 - Start a keyboard walk from a neutral state, never from an already-focused control, or the log will
   report a broken order no person meets.
 - Name a spawned harness's artifacts so a verdict cites one exactly: scenario, viewport, theme,
   step. The journey run's filename law already does this.
-- Keep the artifacts of each round beside its verdicts. A round judged against the previous round's
-  captures is not a round.
+- Keep the artifacts of each round beside its verdicts.
+- For a journey-generated portfolio, record the capture manifest snapshot the round judges beside
+  its verdicts. Require every judged frame to be current, with its recorded source digests equal
+  to the tree's; recapture every stale judged frame before dispatch. Apply this rule to sittings
+  and checkpoints alike. Admit
+  frames assembled from several runs only when every judged frame is current.
 
 ## Preflight before spending a round
 
@@ -84,8 +75,7 @@ Confirm each of the following:
   to the total;
 - nothing in the console log indicates the harness, rather than the surface, failed.
 
-Repair a portfolio that fails preflight before dispatching it. Never spend a verdict round
-discovering a harness defect.
+Repair a portfolio that fails preflight before dispatching it.
 
 ## Triage missing evidence to the harness first