@orkestrel/scaffold 0.0.103 → 0.0.105

package/dist/host/agents/skills/orkestrel-harden/references/contract.md

@@ -21,7 +21,7 @@ Inventory local code involving:
 - JSON parsing and narrowing;
 - `Result`, success/failure outcomes, and safe exception capture;
 - contract shapes, compiled guards/parsers/schemas/generators/reporters;
-- finite/integer checks, error narrowing, and hostile-boundary containment.
+- finite/integer checks, error narrowing, and untrusted-boundary containment.
 
 For each local symbol, record:
 
@@ -46,7 +46,7 @@ Do not force contract abstractions into plain control flow where they obscure be
 
 Test every adopted boundary for relevant invariants:
 
-- guards are total for adversarial values and hostile prototypes;
+- guards are total for any value, including revoked proxies, throwing accessors, and exotic prototypes;
 - parsed values satisfy the paired guard;
 - guard-valid values retain identity when promised;
 - invalid or ambiguous values fail in the documented form;

package/dist/host/agents/skills/orkestrel-harden/references/equivalence.md

@@ -0,0 +1,48 @@
+# Equivalence of a rewrite
+
+Judge a structural rewrite that claims unchanged behavior, such as a sweep under
+`.claude/rules/typescript.md` § Bindings, a centralization move, or a nested-function extraction, by
+this contract against its baseline revision. Prove it with a differential under
+`.claude/rules/quality.md` § Instruments that runs the baseline and the rewrite on the same inputs,
+with a row for each class this contract names that the changed code admits.
+
+## Hold the contract
+
+- Treat every value the declared parameter types admit as inside the contract: holes, entries read
+  through getters (their count and order), entries that throw, an array whose `Symbol.iterator` is
+  missing or replaced, and an iterator's `return()`.
+- Match the outcome (the return value, or the thrown error's constructor), the element reads (which
+  indices, in what order, how often), and every effect before a throw. Let a message differ only
+  where the throwing expression differs, and name each such row.
+- For an entry whose own getters are pure, returning the same value on every read with no side
+  effect, match the outcome. For an entry that throws, match the thrown constructor. Leave the count
+  and order of an entry's own property reads outside the contract.
+- Leave outside the contract a value outside the declared types, such as a number or a plain
+  array-like where an array is declared; a `Proxy` trap other than element `get` and
+  `Symbol.iterator`; the order of a record's own property reads when each is read as often as before
+  and no outcome changes; and tampering with a global prototype.
+
+## Keep the iterator protocol
+
+When a rewrite replaces a `for…of` over a caller's array, refuse each form that changes what it
+reads:
+
+- `Array.from(source, mapper)` falls back to index access when `Symbol.iterator` is missing, so it
+  returns where `for…of` threw a `TypeError`.
+- `source.values()` and the array methods read by index, so they accept a missing iterator and
+  bypass a replaced or closing one; `flatMap`, `filter`, `reduce`, `forEach`, `some`, and `every`
+  skip a hole that `for…of` reads.
+- A spread copies every element first, so it reads past a hole or ahead of a throwing entry where
+  the baseline threw at the earlier element.
+
+Consume the source through `Iterator.from(source)` and its helpers, or through a generator whose
+body is the baseline `for…of`. To keep `Array.from`, hand it an iterable that forwards only
+`[Symbol.iterator]()`. Never bound a hand-written stepper by `length`: a replaced iterator that
+yields more entries than `length` is truncated.
+
+## Keep every test
+
+Before a claim that a rewrite lost no test, run
+`node .agents/skills/orkestrel-harden/scripts/titles.ts --base REV`, where `REV` is the baseline
+revision. Restore each missing title, or rule its removal with the behavior it proved, and confirm
+each moved title by reading the registration that uses it.

package/dist/host/agents/skills/orkestrel-harden/references/hardening.md

@@ -10,7 +10,7 @@ List every boundary where assumptions can fail:
 - partial work, abort, timeout, retry, pause/resume, stop/destroy, and cleanup;
 - concurrency, reentrancy, ordering, idempotency, fairness, and backpressure;
 - filesystem, process, socket, protocol, browser, model, and network boundaries;
-- hostile strings, paths, headers, frames, JSON, prototypes, getters, and proxies;
+- malformed or unexpected strings, paths, headers, frames, JSON, prototypes, getters, and proxies;
 - resource ownership, leaks, teardown, and pressure;
 - environment isolation and unsupported-host behavior;
 - serialization, restore, public exports, and consumer ergonomics.
@@ -78,7 +78,7 @@ For every fetch, write, delete, extraction, path, protocol, or authentication bo
 - fail closed when an allowlist or target cannot be established;
 - avoid logging secrets or untrusted full payloads;
 - make destructive scope explicit and recoverable where practical;
-- prove malformed, partial, oversized, and adversarial input behavior.
+- prove malformed, partial, oversized, and unexpected input behavior.
 
 ## Audit the tests themselves
 
@@ -92,6 +92,8 @@ Run `node .agents/skills/orkestrel-harden/scripts/discovery.ts` for the discover
 - helpers do not reimplement production logic;
 - real cleanup runs even after assertion or setup failure.
 
+Collection evaluates every collected project's `setupFiles`, so the census runs each setup module's load-time work, and `--projects` narrows the report, never that listing. When a setup module contacts a live service at load, such as a `service` project's readiness gate in `tests/setupService.ts`, run the census only while an instance the run may contact is up and the service's address points at it; with the address on a closed port, that project's listing fails and the census exits 2 naming its gate.
+
 ## Inspect generated outputs
 
 - build all supported environments;

package/dist/host/agents/skills/orkestrel-harden/scripts/titles.ts

@@ -0,0 +1,425 @@
+// Run from the checkout root:
+//   node .agents/skills/orkestrel-harden/scripts/titles.ts --base REV [--root DIR] [--json] [--out FILE]
+// Compare exact decoded describe/it/test title counts in tests/**/*.test.ts against REV. Report
+// deficits with their baseline files, or as moved when another tests/**/*.ts string literal holds
+// the title. Confirm moved registrations by reading their holder. Decode quote and backslash
+// escapes only. Balance each-table parentheses over code tokens, skipping lexical regions.
+// Print text by default or one JSON line with --json; --out writes .json or .txt independently.
+// Compare interpolated templates by full raw spelling. Refuse unclosed lexical tokens.
+// Track lexical brace context without a syntax tree. Function-expression and arrow bodies cannot
+// establish a following slash's grammar; refuse that detectable ambiguity instead of claiming a move.
+// Exit 0 with no missing titles, 3 with missing titles, 2 on git, filesystem or token refusal, 64 on usage.
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, extname, join, relative, resolve } from 'node:path'
+import {
+	listFiles,
+	normalizeSlashes,
+	readMissingFlags,
+	readOption,
+} from '../../orkestrel-dispatch/scripts/helpers.ts'
+
+interface Title {
+	readonly file: string
+	readonly title: string
+}
+
+interface Missing extends Title {
+	readonly deficit: number
+}
+
+interface Moved extends Title {
+	readonly holder: string
+}
+
+interface Report {
+	readonly base: string
+	readonly root: string
+	readonly count: number
+	readonly missing: readonly Missing[]
+	readonly moved: readonly Moved[]
+}
+
+interface Token {
+	readonly category: 'code' | 'line' | 'block' | 'string' | 'template' | 'regex'
+	readonly start: number
+	readonly end: number
+	readonly children: readonly Token[]
+	readonly prefix?: boolean
+	readonly ambiguous?: boolean
+}
+
+interface Brace {
+	readonly category: 'block' | 'expression' | 'template'
+	readonly ambiguous: boolean
+}
+
+interface Parenthesis {
+	readonly prefix: boolean
+	readonly ambiguous: boolean
+}
+
+const TITLE_PATTERN = /^\s*(?:it|test|describe)(?:\.\w+)*\(/gmu
+const REGEX_PREFIX =
+	/^(?:return|throw|case|delete|void|typeof|instanceof|in|of|yield|await|else|do)$/u
+
+function decodeTitle(text: string, token: Token): string {
+	const raw = text.slice(token.start + 1, token.end - 1)
+	return token.category === 'template' && token.children.length > 0
+		? raw
+		: raw.replace(/\\(['"`\\])/gu, '$1')
+}
+
+class TokenScanner {
+	readonly #text: string
+	readonly #file: string
+	readonly #parentheses: Parenthesis[] = []
+	readonly #braces: Brace[] = []
+	#position = 0
+
+	constructor(text: string, file: string) {
+		this.#text = text
+		this.#file = file
+	}
+
+	scan(): readonly Token[] {
+		return this.#readCode(false, 0)
+	}
+
+	#readCode(expression: boolean, depth: number): readonly Token[] {
+		if (depth > 256) throw new Error(`${this.#file}: token nesting exceeds 256`)
+		const tokens: Token[] = []
+		while (this.#position < this.#text.length) {
+			const start = this.#position
+			const rest = this.#text.slice(start)
+			const character = this.#text[start]
+			const previous = tokens.findLast(
+				(token) =>
+					token.category !== 'line' &&
+					token.category !== 'block' &&
+					this.#text.slice(token.start, token.end).trim().length > 0,
+			)
+			const spelling = previous === undefined ? '' : this.#text.slice(previous.start, previous.end)
+			if (character === '}' && expression) {
+				this.#position += 1
+				return tokens
+			}
+			if (character === '{') {
+				const block =
+					previous === undefined
+						? this.#braces.at(-1)?.category !== 'template'
+						: previous.category === 'code' &&
+							/^(?:\)|=>|;|\{|\}|else|try|finally|do)$/u.test(spelling)
+				this.#braces.push({
+					category: block ? 'block' : 'expression',
+					ambiguous: block && (spelling === '=>' || previous?.ambiguous === true),
+				})
+				this.#position += 1
+				tokens.push({ category: 'code', start, end: this.#position, children: [] })
+				tokens.push(...this.#readCode(true, depth + 1))
+				const brace = this.#braces.pop()
+				tokens.push({
+					category: 'code',
+					start: this.#position - 1,
+					end: this.#position,
+					children: [],
+					prefix: brace?.category === 'block',
+					ambiguous: brace?.ambiguous === true,
+				})
+				continue
+			}
+			if (character === '`') {
+				tokens.push(this.#readTemplate(depth + 1))
+				continue
+			}
+			if (
+				character === '/' &&
+				!rest.startsWith('//') &&
+				!rest.startsWith('/*') &&
+				previous?.ambiguous === true
+			)
+				throw new Error(`${this.#file}:${start}: Ambiguous brace before slash`)
+			const regex =
+				character === '/' &&
+				!rest.startsWith('//') &&
+				!rest.startsWith('/*') &&
+				(previous === undefined ||
+					previous.prefix === true ||
+					(previous.category === 'code' &&
+						(REGEX_PREFIX.test(spelling) ||
+							!/^(?:[\p{ID_Continue}$]+|[\])}]|\+\+|--)$/u.test(spelling))))
+			const category = rest.startsWith('//')
+				? 'line'
+				: rest.startsWith('/*')
+					? 'block'
+					: character === "'" || character === '"'
+						? 'string'
+						: regex
+							? 'regex'
+							: 'code'
+			const match =
+				category === 'line'
+					? /^\/\/[^\r\n]*/u.exec(rest)
+					: category === 'block'
+						? /^\/\*[\s\S]*?\*\//u.exec(rest)
+						: category === 'string'
+							? (character === "'"
+									? /^'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n\u2028\u2029])*'/u
+									: /^"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n\u2028\u2029])*"/u
+								).exec(rest)
+							: category === 'regex'
+								? /^\/(?:\\[^\r\n]|\[(?:\\[^\r\n]|[^\]\\\r\n])*\]|[^/\\[\r\n])*\/[a-z]*/iu.exec(
+										rest,
+									)
+								: /^(?:[\p{ID_Start}_$][\p{ID_Continue}$]*|\d[\w.]*|\s+|\+\+|--|=>|.)/u.exec(rest)
+			if (match === null) throw new Error(`${this.#file}:${start}: Unclosed ${category} token`)
+			this.#position += match[0].length
+			if (category === 'code' && character === '(') {
+				const words = tokens
+					.filter((token) => token.category === 'code')
+					.map((token) => this.#text.slice(token.start, token.end))
+					.filter((word) => word.trim().length > 0)
+				const keyword = words.findLastIndex((word) => word === 'function')
+				const callable =
+					keyword >= 0 &&
+					words
+						.slice(keyword + 1)
+						.every((word) => word === '*' || /^[\p{ID_Start}_$][\p{ID_Continue}$]*$/u.test(word))
+				const before = words[words[keyword - 1] === 'async' ? keyword - 2 : keyword - 1]
+				this.#parentheses.push({
+					prefix: /^(?:if|while|for|with|switch|catch)$/u.test(spelling),
+					ambiguous:
+						callable &&
+						(before === undefined
+							? this.#braces.at(-1)?.category === 'template'
+							: /^(?:[=(,:[?+\-*/%&|^!~<>]|=>|return|throw|yield|await|case|new|void|typeof|delete|instanceof|in|of)$/u.test(
+									before,
+								)),
+				})
+			}
+			const parenthesis =
+				category === 'code' && character === ')' ? this.#parentheses.pop() : undefined
+			tokens.push({
+				category,
+				start,
+				end: this.#position,
+				children: [],
+				prefix: parenthesis?.prefix === true,
+				ambiguous: parenthesis?.ambiguous === true,
+			})
+		}
+		if (expression)
+			throw new Error(`${this.#file}:${this.#position}: Unclosed template expression or brace`)
+		return tokens
+	}
+
+	#readTemplate(depth: number): Token {
+		const start = this.#position
+		const children: Token[] = []
+		this.#position += 1
+		while (this.#position < this.#text.length) {
+			if (this.#text[this.#position] === '\\') {
+				this.#position += 2
+			} else if (this.#text[this.#position] === '`') {
+				this.#position += 1
+				return { category: 'template', start, end: this.#position, children }
+			} else if (this.#text.startsWith('${', this.#position)) {
+				const opening = this.#position
+				this.#position += 2
+				this.#braces.push({ category: 'template', ambiguous: false })
+				const expression = this.#readCode(true, depth)
+				this.#braces.pop()
+				children.push({
+					category: 'code',
+					start: opening,
+					end: this.#position,
+					children: expression,
+				})
+			} else {
+				this.#position += 1
+			}
+		}
+		throw new Error(`${this.#file}:${start}: Unclosed template token`)
+	}
+}
+
+function readArguments(
+	text: string,
+	tokens: IterableIterator<Token>,
+	location: string,
+	depth: number,
+): number {
+	if (depth > 256) throw new Error(`${location}: each argument nesting exceeds 256`)
+	for (const token of tokens) {
+		if (token.category !== 'code') continue
+		const spelling = text.slice(token.start, token.end)
+		if (spelling === '(') readArguments(text, tokens, location, depth + 1)
+		else if (spelling === ')') return token.end
+	}
+	throw new Error(`${location}: Unbalanced each arguments`)
+}
+
+function readRegistrations(text: string, tokens: readonly Token[], file: string): readonly Token[] {
+	const code = tokens
+		.map((token) => {
+			const raw = text.slice(token.start, token.end)
+			if (token.category === 'code') return raw
+			const blank = raw
+				.split('')
+				.map((character) => (/[\r\n]/u.test(character) ? character : ' '))
+				.join('')
+			return token.category === 'string' || token.category === 'template'
+				? `\0${blank.slice(1)}`
+				: blank
+		})
+		.join('')
+	const offset = tokens[0]?.start ?? 0
+	const positions = new Map(tokens.map((token, index) => [token.start, index]))
+	const starts = new Set(
+		Array.from(code.matchAll(TITLE_PATTERN)).flatMap((match) => {
+			const opening = offset + match.index + match[0].length - 1
+			const direct = /^\s*\0/u.exec(code.slice(opening + 1 - offset))
+			if (!/\.each\(/u.test(match[0]) && direct !== null) return [opening + direct[0].length]
+			const index = positions.get(opening)
+			if (index === undefined) return []
+			const line = text.slice(0, opening).split(/\r\n|\n/u).length
+			const end = readArguments(text, tokens.slice(index + 1).values(), `${file}:${line}`, 0)
+			const title = /^\s*\(\s*\0/u.exec(code.slice(end - offset))
+			return title === null ? [] : [end + title[0].length - 1]
+		}),
+	)
+	return [
+		...tokens.filter((token) => starts.has(token.start)),
+		...tokens.flatMap((token) => readRegistrations(text, token.children, file)),
+	]
+}
+
+function collectLiterals(tokens: readonly Token[]): readonly Token[] {
+	return tokens.flatMap((token) => [
+		...(token.category === 'string' || token.category === 'template' ? [token] : []),
+		...collectLiterals(token.children),
+	])
+}
+
+function readGit(root: string, args: readonly string[]): string {
+	const result = spawnSync('git', ['-C', root, ...args], {
+		encoding: 'utf8',
+		windowsHide: true,
+		maxBuffer: 256 * 1024 * 1024,
+	})
+	if (result.error !== undefined || result.status !== 0) {
+		throw new Error(`git: ${result.error?.message ?? result.stderr.trim()}`)
+	}
+	return result.stdout
+}
+
+function readReport(base: string, root: string): Report {
+	const baseline = readGit(root, ['ls-tree', '-r', '-z', '--name-only', base, '--', 'tests'])
+		.split('\0')
+		.filter((file) => file.endsWith('.test.ts'))
+		.flatMap((file) => {
+			const text = readGit(root, ['show', `${base}:${file}`])
+			return readRegistrations(
+				text,
+				new TokenScanner(text, `${base}:${file}`).scan(),
+				`${base}:${file}`,
+			).map((token) => ({
+				file,
+				title: decodeTitle(text, token),
+			}))
+		})
+	const directory = join(root, 'tests')
+	const files = (existsSync(directory) ? listFiles(directory) : [])
+		.filter(({ path }) => path.endsWith('.ts'))
+		.map(({ path }) => {
+			const file = normalizeSlashes(relative(root, path))
+			const text = readFileSync(path, 'utf8')
+			const tokens = new TokenScanner(text, file).scan()
+			return {
+				file,
+				text,
+				tokens,
+				registrations: file.endsWith('.test.ts') ? readRegistrations(text, tokens, file) : [],
+			}
+		})
+		.sort((left, right) => left.file.localeCompare(right.file))
+	const titles = files
+		.filter(({ file }) => file.endsWith('.test.ts'))
+		.flatMap(({ file, text, registrations }) =>
+			registrations.map((token) => ({ file, title: decodeTitle(text, token) })),
+		)
+	// A surviving registration supplies its title count, never evidence that a lost duplicate moved.
+	const holders = files.flatMap(({ file, text, tokens, registrations }) =>
+		collectLiterals(tokens)
+			.filter((token) => !registrations.includes(token))
+			.map((token) => ({ file, title: decodeTitle(text, token) })),
+	)
+	const deficits = [...Map.groupBy(baseline, ({ title }) => title)].flatMap(([title, entries]) => {
+		const survivors = titles.filter((candidate) => candidate.title === title)
+		const unmatched = [...Map.groupBy(entries, ({ file }) => file)].flatMap(([file, local]) =>
+			local.slice(survivors.filter((candidate) => candidate.file === file).length),
+		)
+		const surplus = [...Map.groupBy(survivors, ({ file }) => file)].flatMap(([file, local]) =>
+			local.slice(entries.filter((candidate) => candidate.file === file).length),
+		)
+		return [...Map.groupBy(unmatched.slice(surplus.length), ({ file }) => file)].map(
+			([file, lost]) => ({
+				file,
+				title,
+				deficit: lost.length,
+			}),
+		)
+	})
+	const classified = deficits.map((entry) => ({
+		entry,
+		holder: holders.find(({ title }) => title === entry.title)?.file,
+	}))
+	return {
+		base,
+		root: normalizeSlashes(root),
+		count: baseline.length,
+		missing: classified.flatMap(({ entry, holder }) => (holder === undefined ? [entry] : [])),
+		moved: classified.flatMap(({ entry, holder }) =>
+			holder === undefined ? [] : [{ file: entry.file, title: entry.title, holder }],
+		),
+	}
+}
+
+function renderReport(report: Report): string {
+	return [
+		`titles: ${report.count} baseline title(s) at ${report.base}, ${report.missing.length} missing, ${report.moved.length} moved`,
+		...report.missing.map(({ file, title, deficit }) => `missing\t${file}\t${title}\t${deficit}`),
+		...report.moved.map(({ file, title, holder }) => `moved\t${file}\t${title}\t${holder}`),
+	].join('\n')
+}
+
+function main(argv: readonly string[]): number {
+	const missing = readMissingFlags(argv, ['--base', '--root', '--out'])
+	if (missing.length > 0) {
+		console.error(`titles: ${missing.join(', ')} given with no value`)
+		return 64
+	}
+	const base = readOption(argv, '--base')
+	const out = readOption(argv, '--out')
+	if (base === undefined || (out !== undefined && !['.json', '.txt'].includes(extname(out)))) {
+		console.error('usage: titles.ts --base REV [--root DIR] [--json] [--out FILE.json|FILE.txt]')
+		return 64
+	}
+	try {
+		const report = readReport(base, resolve(readOption(argv, '--root') ?? process.cwd()))
+		const json = JSON.stringify(report)
+		const text = renderReport(report)
+		if (out !== undefined) {
+			const target = resolve(out)
+			mkdirSync(dirname(target), { recursive: true })
+			writeFileSync(target, `${extname(target) === '.json' ? json : text}\n`)
+		}
+		console.log(argv.includes('--json') ? json : text)
+		return report.missing.length > 0 ? 3 : 0
+	} catch (error) {
+		console.error(`titles: ${error instanceof Error ? error.message : String(error)}`)
+		return 2
+	}
+}
+
+process.exitCode = main(process.argv.slice(2))

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

@@ -201,8 +201,8 @@ await PORTFOLIO.place('home')
    control, a Tab away, or a named button. Report a screen that commits on a timer, on an
    unpredictable event, or only after work the person cannot observe as a screen finding, and never
    work around it in the layer.
-7. **Type only what a person would.** Journeys carry trusted input; adversarial payloads belong to
-   the transport family and the parser suites.
+7. **Type only what a person would.** Journeys carry trusted input; inputs no person would type
+   belong to the transport family and the parser suites.
 8. **Perform every interaction step unconditionally.** Never gate a step on whether the control it
    is about to drive exists or is reachable, and never branch a journey on `readRefusal`. Let the
    resolver's failure voice name what the interface withheld. A guarded step passes whether or not

package/dist/host/agents/skills/orkestrel-journey/references/captures.md

@@ -30,7 +30,8 @@ file is written to, and the flag as `enabled`.
   picture is one element.
 - Take `enabled` from `inject('capture')`, which the generated root configuration provides from the
   `CAPTURE` environment variable set to `1` in the shell that runs the axis. An ordinary run leaves
-  it false, so `place` returns `undefined`, resizes nothing, writes nothing, and records nothing.
+  it false, so `place` returns `undefined`, resizes nothing, writes nothing, records no placement,
+  and still refuses an unregistered state and a second placement of one state.
 - Read `files` for the registry expanded across every variant, `placements` for what this run placed,
   and `paths` for what it wrote. Each hands back a snapshot.
 - Reach for `readFrame` where the written image itself is the subject — its decoded size, or its
@@ -42,8 +43,8 @@ The package already refuses these, so assert none of them again:
 | Refusal                                                              | Raised by             |
 | -------------------------------------------------------------------- | --------------------- |
 | `Capture variant "<name>" is not registered`                         | `createPortfolio`     |
-| `Capture state "<state>" is not registered`                          | `place`, when enabled |
-| `Capture state "<state>" is already placed`                          | `place`, when enabled |
+| `Capture state "<state>" is not registered`                          | `place`, in every run |
+| `Capture state "<state>" is already placed`                          | `place`, in every run |
 | `Capture frame at <path> is not the one this run shot`               | `captureFrame`        |
 | `Capture frame was written to <written> where <asked> was asked for` | `captureFrame`        |
 
@@ -92,11 +93,11 @@ Write each of the following proofs into the suite. The package asserts none of t
 - Keep the filename proof always-on, so a registry edit that introduces a duplicate or a collision
   fails the ordinary run. Compare `expandCaptures(states, variants)` against `files` and against a
   set built from it; a length equal to the set's size is what proves the expansion unique.
-- Assert placement as set equality against the registry, in every run. Never assert a count: a count
-  passes while one state is placed twice and another never.
-- Read the placement proof from the suite's own set rather than from `placements`. An ordinary run's
-  `place` returns before it reads the registry, so `placements` is empty there and an unregistered name
-  reaches no refusal until a capture run. The always-on placement proof is what catches it.
+- Assert placement as set equality against the registry, in every run.
+- Read the placement proof from the suite's own set rather than from `placements`, which stays empty
+  in an ordinary run. `place` refuses an unregistered name and a second placement of one state in
+  every run, but a registered state that no journey placed reaches no refusal; the always-on
+  placement proof catches it.
 - Under the flag, assert the written filenames equal the registry expanded for the run's variant.
   `captureFrame` already reads each file back and compares its bytes against the frame it shot, so
   the path `place` returns is proof the file exists and holds that frame.

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

@@ -0,0 +1,72 @@
+---
+name: orkestrel-parallel
+description: >-
+  Run several writer lanes in one checkout at the same time, coordinated by messages: writers edit owned regions in phases, one runner lane owns every test and check process, and the Orchestrator rules and mediates. Use when a campaign has three or more units whose files are mostly disjoint and whose shared files are a few kind files, guides, or entry tests. Do not use it when two units rewrite the same region, when a unit needs a quiet tree for a measurement, or when the harness gives lanes no shared file system or no message channel that wakes an idle lane.
+---
+
+# Parallel lanes
+
+## Lanes
+
+| Lane               | Role                                                                                               | Owns                                                                                                                  | Never                                                |
+| ------------------ | -------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
+| Orchestrator       | the harness's own engine                                                                           | the protocol, the roster, launches, rulings, holds, acceptance, commits                                               | delegates acceptance                                 |
+| `runner`           | `verifier` on the native small engine                                                              | every test, typecheck, lint, format, build, and citation process; its log, run files, and result files under `coord/` | writes outside `coord/`; runs an unrequested command |
+| writer (`w<unit>`) | `builder`, `astra`, or `opus` by `.agents/orchestration.md` § Routing                              | its owned files, its owned regions of shared files, and its log                                                       | runs a test, check, lint, format, or build process   |
+| reviewer           | `analyst` or `reviewer`, independent of the lane's writer per `.agents/orchestration.md` § Engines | a read-only verdict on the work the size gate sends it                                                                | edits, writes, runs, or messages                     |
+
+- Run at most three writers and one runner. Keep every live lane, reviewers included, inside the harness's concurrency limit (`references/harnesses.md`), and queue a lane that does not fit.
+- Before launch, assign every file region to exactly one writer. A shared file is owned by region (a doc block, a table, a guide section, a list entry), never as a whole.
+
+## Set up
+
+1. Commit the accepted state; every lane starts from one commit.
+2. Write `tmp/units/<round>/coord/protocol.md`: the path of this skill, the round's lanes, each writer's owned files and regions, and each writer's acceptance commands. Write `coord/roster.md` (lane, role, address, Orchestrator address). Create `coord/results/` and `coord/runs/`.
+3. Launch the runner first. Its first turn logs `ready` with its address and ends.
+4. Launch the writers one at a time. Fill each roster row from its launch result; after launch, send each lane that messages peers their addresses.
+5. For a lane already running, send one in-flight message naming the protocol, its lane name, its log, and its next request number.
+
+## Channels
+
+- File channel: each writer and the runner append only to their own log, `coord/<lane>.md`, one line per event: `<lane> | <request or phase> | <kind> | <text>`. Never write another lane's log. A reviewer returns its verdict to the Orchestrator and writes nothing.
+- Push channel (`references/harnesses.md`): requests queue to the runner one turn each, in arrival order; replies and rulings join the receiver's running turn or start one.
+- Number requests from 1 per lane across the whole round, fix units included, and never reuse a number.
+- Results: the runner writes each result under a temporary name in `coord/results/`, renames it to `coord/results/<lane>-<n>.md` when it is complete, then replies. A waiting writer polls for that file; a lost message does not stall it.
+- Request format:
+
+```
+REQUEST <lane>-<n>
+from: <lane> <address>
+commands:
+1. <exact command>
+expect: <red or green per command, with case names>
+```
+
+- Escalation: send the Orchestrator `ESCALATE <lane>: expected, found, evidence, proposed action`. Continue the work the question does not block. The ruling arrives in your turn; record any scope extension in your report.
+- A writer can message another writer a cross-lane fact (a line it added, a window it opens). Rulings come only from the Orchestrator.
+
+## Writers
+
+- Work in phases and log each: `types` (types and API docs), `red` (failing-first cases, then a red-run request), `source` (the change, then a green-run request), `docs` (guide sentences).
+- In a shared file, edit small, complete hunks inside your owned regions. Re-read the region immediately before each patch, never rewrite a whole file, and leave every hunk syntactically complete. When a patch fails on changed context, re-read and re-apply.
+- Request every test, check, lint, format, and build process from the runner. Read-only shell and search commands stay yours.
+- Run no formatter. Fix a format finding by hand; when the finding names only a file, ask the Orchestrator for the exact hunk.
+- Before a temporary mutation (a mutation proof), ask the runner to hold unrelated runs and each lane that owns a region of the mutated file to hold its edits, and mutate only after each has logged `held`. Restore the exact text, confirm with `git diff`, log `restored`, and tell them.
+- When done and green, log `done`, send the runner `FINAL <lane>`, write your report, and end your task.
+
+## Runner
+
+- Before each command, wait until no test or typecheck process runs in this checkout, excluding editor language services. Bound the wait by the request's expected run time. When any conflicting process exceeds that budget, report its recorded ownership, process id, and command line to the Orchestrator and suspend the request for a ruling. Never kill a process yourself. For a capped run, have the Orchestrator apply the `orkestrel-dispatch` skill's launch reference § Kill and relaunch before releasing the affected files or starting another command.
+- Launch each command through `node .agents/skills/orkestrel-dispatch/scripts/launch.ts` under a cap sized from prior runs, with `--journal coord/runs/<lane>-<n>-<k>.txt` and `--errors coord/runs/<lane>-<n>-<k>.err`, and log the process id it prints. When the shell returns before the launcher ends, resume its tracked shell session until the launcher exits, then read both files and require the terminal exit record. Track descendant process ids while their parent lives, and confirm that the command and its descendants have ended before publishing completion; otherwise escalate under the preceding wait rule.
+- Report each finding only to the lane that owns its file.
+- Serve the commands each writer's acceptance criteria name, plus the standing list: the root typecheck, the scoped typecheck, the guide parity check, the package entry test, and lint or format checks over paths the writer names. Run each read-only; none writes the tree.
+- After every writer's current `FINAL` has arrived, wait for the Orchestrator's closing request naming a unique gate number and confirming acknowledged write holds. Run the root typecheck, scoped typecheck, every acceptance test file alone, the guide parity check, and lint and format checks over every path `git status --porcelain` lists. Publish the complete result atomically as `coord/results/closing-<k>.md`, reply with that gate number, and end your task.
+
+## Orchestrator
+
+- Before ruling on an escalation, reproduce its evidence at its cited lines. Bound every ruling: what to change, what to leave.
+- When a format check names only a file, inspect the file and send the writer the exact formatting hunk. After the writer applies it, request a read-only format check from the runner.
+- Run the review `.agents/orchestration.md` § Size gate names, and supply its diff and status. A unit's review can start read-only when its lane logs `done`, while the others write; a campaign's `orkestrel-falsify` round runs on the integrated result after the closing gate.
+- Before resuming a writer for a fix unit, send the runner that lane's `FINAL` invalidation and wait for acknowledgment; every other lane's `FINAL` stands. Follow `references/harnesses.md` to resume the writer's lane or dispatch its successor. If a closing gate is active, keep the reopened writer read-only until that gate completes.
+- Before requesting a closing gate, obtain write-hold acknowledgments from every live writer and hold your own source edits. Allocate a gate number never used earlier in the round. Keep those holds until the matching complete result is published. After a fix unit, request another gate covering the affected checks and acceptance tests.
+- After the last green gate and the review the size gate names, commit. When shared files mix several units' hunks, commit the batch once and name each unit, its engine, and each fix unit in the message.

package/dist/host/agents/skills/orkestrel-parallel/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: 'Orkestrel Parallel'
+  short_description: 'Coordinate writer lanes and one runner in a shared checkout'
+  default_prompt: 'Use $orkestrel-parallel to coordinate writers in one checkout with owned regions, queued checks, and Orchestrator rulings.'