@orkestrel/scaffold 0.0.103 → 0.0.104

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-polish/SKILL.md

@@ -55,8 +55,8 @@ over the same surface needs an instruction from the user.
    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.
-4. **Reconcile.** Confirmed findings get carriers; refuted findings die on the record with
-   the evidence that killed them; conflicts get a dated ruling. Then walk the reconciled
+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.
 5. **Dispatch serialized fix units,** objective lane first because it changes the ground
@@ -82,7 +82,7 @@ over the same surface needs an instruction from the user.
 - Do not narrow a selector, add a local exception, or restyle one instance to make a
   capture pass while the underlying rule stays wrong.
 - When a law of the repository genuinely conflicts with the surface's required anatomy,
-  stop and report both horns with evidence. An improvised local exception poisons an
+  stop and report both horns with evidence. An improvised local exception voids an
   enforced invariant.
 
 ## Return the fixed verdict shape

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

@@ -25,7 +25,7 @@ description: Run an Orkestrel release from layer order to registry confirmation.
 | `scripts/compare.ts` | `[--package NAME] [--version V] [--tarball PATH] [--dist dist] [--json]`, run from the package root after its build: fetches the published tarball and lists the material differences from the rebuilt `dist/` (sourcemaps excluded, whitespace-only differences ignored). Exit 0 when nothing differs, 3 when something does, 2 when the tarball cannot be read, 64 on usage (no package name, no `dist/`, or `--tarball` with no path).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `scripts/pins.ts`    | `--version PRIOR [--range PRIOR_RANGE ...] [--paths src,tests] [--json]`, run from the package root: lists every line under the paths carrying the prior version literal or a prior range literal, once per line, sweeping a one-comparator range such as `^8.3.0` for its bare version in any form. Exit 0 with no hits, 3 with hits, 64 on usage (no literal, or a flag with no value).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `scripts/swap.ts`    | One mode per run, from any directory: `--pin --consumer DIR --source DIR [--source DIR ...] [--override NAME ...] [--no-build] [--dry-run] [--json]` refuses a source whose packed manifest names a local dependency spec in any dependency field (a `file:` or `link:` prefix, a path start of `.`, `~/`, `/`, `\`, or a drive letter, or a protocol-free archive name ending in `.tgz`, `.tar.gz`, or `.tar` that is not a `user/repo` shorthand), builds and packs each source into `<consumer>/tmp/tarballs/` under a name carrying its SHA-256, records each replaced range in the ledger `pins.json` there, the record of which build the consumer runs, writes each tarball's absolute `file:` spec and each `--override` (repeatable, like `--source`) where oxfmt sorts it, installs, and proves that every pinned source, an override-only one included, is installed with the source's bytes; `--restore --consumer DIR [--package NAME ...] [--json]` puts back each recorded range and override, keeps an `overrides` block that existed before the pin, installs, proves the restored copy, and lists the re-pin arguments, and refuses with 64, before it writes anything, a ledger whose package or override keys are not package names or whose removal would leave `node_modules`; `--status --consumer DIR [--json]` writes nothing and reports drift between the ledger, the manifest, the tarballs, the installed bytes, and the source commits, a manifest spec holding its tarball only when it names the ledger archive's location. `--pin` and `--restore` write a receipt under `tmp/units/`. Exit 0 on success, 1 when a command or a proof failed, 3 when `--status` reports drift, 64 on usage. |
-| `scripts/wave.ts`    | `--visit [--target DIR] [--offline] [--from STEP] [--to STEP] [--prior VERSION] [--dry-run] [--json] [--out FILE]` runs one repository's visit in the order [wave.md](references/wave.md) § Visit a repository fixes (pin, commit, overwrite, verify, install, pins, format, gates, compare), stops at the first failing step, and prints each step's exit (a failed step names the `code: message` refusal or the `note` a JSON verb writes on stdout, else the last stderr lines), the bump ruling (the rebuilt dist against the published tarball, and the final runtime dependency set against the published manifest), and a row for `.orkestrel/release.md`; `--prior` names the version a pre-ruled bump replaced so the self-pin sweep finds it; `--plan` prints the packages by layer from the catalog table. Exit 0 when every step passed, 1 when one failed, 2 when a reading failed, 64 on usage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `scripts/wave.ts`    | `--visit [--target DIR] [--offline] [--regenerate] [--from STEP] [--to STEP] [--prior VERSION] [--dry-run] [--json] [--out FILE]` runs one repository's visit in the order [wave.md](references/wave.md) § Visit a repository fixes (pin, commit, overwrite, verify, install, pins, format, record, gates, compare), stops at the first failing step, journals each executed step's full output under the target's `tmp/units/wave/` when the work tree ignores `tmp/` and names the journal in its row, and prints each step's exit (a failed step names the `code: message` refusal or the `note` a JSON verb writes on stdout, else the last stderr lines), the bump ruling (the rebuilt dist against the published tarball, and the final runtime dependency set against the published manifest), and a row for `.orkestrel/release.md`; `--prior` names the version a pre-ruled bump replaced so the self-pin sweep finds it; `--plan` prints the packages by layer from the catalog table. An install that fails `ERESOLVE` names the rerun command, and `--regenerate` replaces the lockfile and `node_modules` from the manifest under the refusals and proof [wave.md](references/wave.md) § Regenerate a lock the install cannot move states; `record` commits the overwrite's writes as `Overwrite with scaffold VERSION`. Exit 0 when every step passed, 1 when one failed, 2 when a reading failed, 64 on usage, including `--regenerate` with `--plan`.                                                                                                                                                                                                                                                        |
 | `scripts/window.ts`  | `--whoami [--wait SECONDS]` reads or polls `npm whoami`; `--login` prints the operator's login command and polls `whoami` until it answers; `--publish DIR... --otp CODE` refuses a batch whose nearest `.git` entry is a file, including ancestor entries, with exit 3 before contacting npm; it names a linked worktree's primary clone or identifies a submodule, then uploads back to back with `npm publish --ignore-scripts --otp`, journals each upload under `tmp/units/`, stops at the first refusal naming where to resume, and confirms each accepted version against the registry; `--confirm NAME@VERSION...` re-reads the registry until it serves the version. Exit 0 on success, 3 when not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
 The user's current instruction wins. `references/release.md` owns the credential
@@ -53,7 +53,7 @@ following the skill.
    Derive each pin from that reading, never from a local manifest.
 3. **Visit each repository.** Run `node .agents/skills/orkestrel-publish/scripts/wave.ts --visit --target <repository>`,
    which runs the visit in [wave.md](references/wave.md) in its stated order and stops at the first
-   failing step; repair that step by hand and re-run from it with `--from`. Run visits in parallel
+   failing step; repair that step by hand and re-run from it with `--from`; for an `ERESOLVE`, follow [wave.md](references/wave.md) § Regenerate a lock the install cannot move. Run visits in parallel
    slices of disjoint repositories, each slice serial inside itself.
 4. **Rule on each package's bump.** Take the visit's comparison and range reading; repeat `compare.ts` only after the artifact changes or an unanswered result. Apply the triggers in [wave.md](references/wave.md) § Rule on
    the bump; `references/release.md` § What a bump obliges owns the blast radius.

package/dist/host/agents/skills/orkestrel-publish/references/release.md

@@ -34,6 +34,7 @@ When a consumer needs a dependency's unpublished source, to meet a defect that l
 
 ## The scaffold surface
 
+- After a package's first publish, run `scaffold catalog --all` in the scaffold checkout and release scaffold, so the `surface` rule reads the package's guide from that release.
 - `scaffold` is a development dependency of every package, so it publishes on its own and propagates as files, never as a cascade. Each package builds against the published `scaffold`.
 - `scaffold` ships `dist/host`, the vendored file set every target receives through `repair`. Bump and publish `scaffold` when any vendored byte or the set of vendored paths changes.
 - After a vendored-only release, re-pin `@orkestrel/scaffold` in each target, run `repair` there, and prove that target's gates still green. A target bumps only when its own published surface moved.