@orkestrel/scaffold 0.0.100 → 0.0.102

package/dist/host/agents/skills/orkestrel-scout/scripts/map.ts

@@ -53,6 +53,31 @@ interface AnchorRow {
 	readonly heading: string
 }
 
+interface TomlState {
+	readonly table: string
+	readonly fence: string | undefined
+	readonly rows: readonly LineRow[]
+}
+
+interface YamlLine {
+	readonly line: number
+	readonly indent: number
+	readonly content: string
+	readonly key: string | undefined
+	readonly value: string
+}
+
+interface YamlHead {
+	readonly position: number
+	readonly line: YamlLine
+	readonly key: string
+}
+
+interface YamlState {
+	readonly stack: ReadonlyArray<{ readonly indent: number; readonly key: string }>
+	readonly heads: readonly YamlHead[]
+}
+
 interface Report {
 	readonly tree?: readonly TreeRow[]
 	readonly headings?: readonly LineRow[]
@@ -93,35 +118,42 @@ function mapTree(paths: readonly string[]): readonly TreeRow[] {
 		.sort((left, right) => left.path.localeCompare(right.path))
 }
 
+function scanFences(lines: readonly string[]): readonly boolean[] {
+	const fenced: boolean[] = []
+	for (const text of lines) fenced.push((fenced.at(-1) ?? false) !== text.startsWith('```'))
+	return fenced
+}
+
 function mapHeadings(paths: readonly string[]): readonly LineRow[] {
-	const rows: LineRow[] = []
-	for (const path of expandPaths(paths).filter((candidate) => candidate.endsWith('.md'))) {
-		let fenced = false
-		readLines(path).forEach((text, index) => {
-			if (text.startsWith('```')) fenced = !fenced
-			if (fenced) return
-			const match = text.match(HEADING)
-			if (match?.[1] !== undefined && match[2] !== undefined) {
-				rows.push({ path, line: index + 1, text: `${match[1]} ${match[2]}` })
-			}
+	return expandPaths(paths)
+		.filter((candidate) => candidate.endsWith('.md'))
+		.flatMap((path) => {
+			const lines = readLines(path)
+			const fenced = scanFences(lines)
+			return lines.flatMap((text, index) => {
+				if (fenced[index] === true) return []
+				const match = text.match(HEADING)
+				return match?.[1] !== undefined && match[2] !== undefined
+					? [{ path, line: index + 1, text: `${match[1]} ${match[2]}` }]
+					: []
+			})
 		})
-	}
-	return rows
 }
 
 function mapExports(paths: readonly string[]): readonly LineRow[] {
-	const rows: LineRow[] = []
-	for (const path of expandPaths(paths).filter((candidate) => /\.[cm]?ts$/u.test(candidate))) {
-		readLines(path).forEach((text, index) => {
-			const match = text.match(EXPORT)
-			if (match?.[1] !== undefined && match[2] !== undefined) {
-				rows.push({ path, line: index + 1, text: `${match[1]} ${match[2]}` })
-			} else if (/^export\s+\*\s+from\s+/u.test(text)) {
-				rows.push({ path, line: index + 1, text: text.trim() })
-			}
-		})
-	}
-	return rows
+	return expandPaths(paths)
+		.filter((candidate) => /\.[cm]?ts$/u.test(candidate))
+		.flatMap((path) =>
+			readLines(path).flatMap((text, index) => {
+				const match = text.match(EXPORT)
+				if (match?.[1] !== undefined && match[2] !== undefined) {
+					return [{ path, line: index + 1, text: `${match[1]} ${match[2]}` }]
+				}
+				return /^export\s+\*\s+from\s+/u.test(text)
+					? [{ path, line: index + 1, text: text.trim() }]
+					: []
+			}),
+		)
 }
 
 function buildMatcher(term: string, ignoreCase: boolean): (text: string) => boolean {
@@ -137,102 +169,129 @@ function mapCensus(
 	const files = expandPaths(roots).filter(isText)
 	return terms.map((term) => {
 		const matches = buildMatcher(term, ignoreCase)
-		const rows: LineRow[] = []
-		for (const path of files) {
-			readLines(path).forEach((text, index) => {
-				if (matches(text)) rows.push({ path, line: index + 1, text: text.trim().slice(0, 160) })
-			})
+		return {
+			term,
+			rows: files.flatMap((path) =>
+				readLines(path).flatMap((text, index) =>
+					matches(text) ? [{ path, line: index + 1, text: text.trim().slice(0, 160) }] : [],
+				),
+			),
 		}
-		return { term, rows }
 	})
 }
 
 function mapRefs(target: string, roots: readonly string[]): readonly LineRow[] {
 	const needle = normalizeSlashes(target)
 	const name = basename(needle)
-	const rows: LineRow[] = []
-	for (const path of expandPaths(roots).filter(isText)) {
-		if (path === needle) continue
-		readLines(path).forEach((text, index) => {
-			if (text.includes(needle) || text.includes(name)) {
-				rows.push({ path, line: index + 1, text: text.trim().slice(0, 160) })
-			}
-		})
-	}
-	return rows
+	return expandPaths(roots)
+		.filter(isText)
+		.filter((path) => path !== needle)
+		.flatMap((path) =>
+			readLines(path).flatMap((text, index) =>
+				text.includes(needle) || text.includes(name)
+					? [{ path, line: index + 1, text: text.trim().slice(0, 160) }]
+					: [],
+			),
+		)
 }
 
-function readYamlKeys(path: string, lines: readonly string[], offset: number): readonly LineRow[] {
-	const rows: LineRow[] = []
-	const stack: Array<{ readonly indent: number; readonly key: string }> = []
-	lines.forEach((text, index) => {
+function classifyYamlLines(lines: readonly string[], offset: number): readonly YamlLine[] {
+	return lines.flatMap((text, index): readonly YamlLine[] => {
 		const content = text.trimStart()
-		if (content === '' || content.startsWith('#')) return
-		const indent = text.length - content.length
+		if (content === '' || content.startsWith('#')) return []
 		const match = content.match(/^([A-Za-z_][\w-]*)\s*:(?:\s+(.*))?$/u)
-		if (match?.[1] === undefined) {
-			// A list item, a block scalar line, or a wrapped value extends the key before it.
-			const last = rows.at(-1)
-			if (last !== undefined && indent >= (stack.at(-1)?.indent ?? 0)) {
-				rows[rows.length - 1] = { ...last, text: `${last.text} ${content.trim()}`.trimEnd() }
-			}
-			return
-		}
-		while (stack.length > 0 && (stack.at(-1)?.indent ?? 0) >= indent) stack.pop()
-		const key = [...stack.map((entry) => entry.key), match[1]].join('.')
-		stack.push({ indent, key: match[1] })
-		rows.push({ path, line: index + offset, text: `${key}: ${(match[2] ?? '').trim()}`.trimEnd() })
+		return [
+			{
+				line: index + offset,
+				indent: text.length - content.length,
+				content,
+				key: match?.[1],
+				value: (match?.[2] ?? '').trim(),
+			},
+		]
 	})
-	return rows
+}
+
+function stepYamlState(state: YamlState, line: YamlLine, position: number): YamlState {
+	if (line.key === undefined) return state
+	// Indents strictly increase along the stack, so the entries at or past this indent are the tail.
+	const stack = state.stack.filter((entry) => entry.indent < line.indent)
+	const key = [...stack.map((entry) => entry.key), line.key].join('.')
+	return {
+		stack: [...stack, { indent: line.indent, key: line.key }],
+		heads: [...state.heads, { position, line, key }],
+	}
+}
+
+function readYamlKeys(path: string, lines: readonly string[], offset: number): readonly LineRow[] {
+	const classified = classifyYamlLines(lines, offset)
+	const { heads } = classified.reduce<YamlState>(
+		(state, line, position) => stepYamlState(state, line, position),
+		{ stack: [], heads: [] },
+	)
+	// A list item, a block scalar line, or a wrapped value extends the key line before it when it is
+	// indented at least as far; between two key lines every classified line is a non-key line.
+	return heads.map((head, rank) => ({
+		path,
+		line: head.line.line,
+		text: [
+			`${head.key}: ${head.line.value}`.trimEnd(),
+			...classified
+				.slice(head.position + 1, heads[rank + 1]?.position ?? classified.length)
+				.filter((line) => line.indent >= head.line.indent)
+				.map((line) => line.content.trim()),
+		]
+			.join(' ')
+			.trimEnd(),
+	}))
+}
+
+function stepTomlState(state: TomlState, text: string, path: string, line: number): TomlState {
+	if (state.fence !== undefined) {
+		// The body of a multi-line string carries no key.
+		return text.includes(state.fence) ? { ...state, fence: undefined } : state
+	}
+	const header = text.match(/^\s*\[\[?([^\]]+)\]\]?\s*$/u)
+	if (header?.[1] !== undefined) return { ...state, table: header[1].trim() }
+	const match = text.match(/^\s*([A-Za-z0-9_.-]+|"[^"]+")\s*=\s*(.*)$/u)
+	if (match?.[1] === undefined) return state
+	const value = (match[2] ?? '').trim()
+	const opening = value.match(/^("""|''')/u)?.[1]
+	return {
+		table: state.table,
+		fence: opening !== undefined && value.indexOf(opening, 3) === -1 ? opening : undefined,
+		rows: [
+			...state.rows,
+			{
+				path,
+				line,
+				text: `${state.table === '' ? '' : `${state.table}.`}${match[1]}: ${value}`.trimEnd(),
+			},
+		],
+	}
 }
 
 function readTomlKeys(path: string, lines: readonly string[], offset: number): readonly LineRow[] {
-	const rows: LineRow[] = []
-	let table = ''
-	let fence: string | undefined
-	lines.forEach((text, index) => {
-		if (fence !== undefined) {
-			// The body of a multi-line string carries no key.
-			if (text.includes(fence)) fence = undefined
-			return
-		}
-		const header = text.match(/^\s*\[\[?([^\]]+)\]\]?\s*$/u)
-		if (header?.[1] !== undefined) {
-			table = header[1].trim()
-			return
-		}
-		const match = text.match(/^\s*([A-Za-z0-9_.-]+|"[^"]+")\s*=\s*(.*)$/u)
-		if (match?.[1] === undefined) return
-		const value = (match[2] ?? '').trim()
-		const opening = value.match(/^("""|''')/u)?.[1]
-		if (opening !== undefined && value.indexOf(opening, 3) === -1) fence = opening
-		rows.push({
-			path,
-			line: index + offset,
-			text: `${table === '' ? '' : `${table}.`}${match[1]}: ${value}`.trimEnd(),
-		})
-	})
-	return rows
+	return lines.reduce<TomlState>(
+		(state, text, index) => stepTomlState(state, text, path, index + offset),
+		{ table: '', fence: undefined, rows: [] },
+	).rows
 }
 
 function mapFrontmatter(paths: readonly string[]): readonly LineRow[] {
-	const rows: LineRow[] = []
-	for (const path of expandPaths(paths).filter((candidate) =>
-		/\.(md|mdc|toml|ya?ml)$/u.test(candidate),
-	)) {
-		const lines = readLines(path)
-		const markdown = /\.mdc?$/u.test(path)
-		const end = markdown ? lines.indexOf('---', 1) : lines.length
-		if (markdown && (lines[0] !== '---' || end === -1)) continue
-		const body = lines.slice(markdown ? 1 : 0, end)
-		const offset = markdown ? 2 : 1
-		rows.push(
-			...(path.endsWith('.toml')
+	return expandPaths(paths)
+		.filter((candidate) => /\.(md|mdc|toml|ya?ml)$/u.test(candidate))
+		.flatMap((path) => {
+			const lines = readLines(path)
+			const markdown = /\.mdc?$/u.test(path)
+			const end = markdown ? lines.indexOf('---', 1) : lines.length
+			if (markdown && (lines[0] !== '---' || end === -1)) return []
+			const body = lines.slice(markdown ? 1 : 0, end)
+			const offset = markdown ? 2 : 1
+			return path.endsWith('.toml')
 				? readTomlKeys(path, body, offset)
-				: readYamlKeys(path, body, offset)),
-		)
-	}
-	return rows
+				: readYamlKeys(path, body, offset)
+		})
 }
 
 function readHeadingTexts(path: string): ReadonlySet<string> {
@@ -240,63 +299,64 @@ function readHeadingTexts(path: string): ReadonlySet<string> {
 }
 
 function mapAnchors(paths: readonly string[]): readonly AnchorRow[] {
-	const headings = new Map<string, ReadonlySet<string>>()
-	const rows: AnchorRow[] = []
-	for (const path of expandPaths(paths).filter((candidate) => candidate.endsWith('.md'))) {
-		readLines(path).forEach((text, index) => {
-			for (const match of text.matchAll(ANCHOR)) {
-				const target = match[1] === undefined ? path : normalizeSlashes(match[1])
-				const heading = (match[2] ?? '').trim()
-				if (heading === '') continue
-				if (!existsSync(target)) {
-					rows.push({ path, line: index + 1, target, heading })
-					continue
-				}
-				const known = headings.get(target) ?? readHeadingTexts(target)
-				headings.set(target, known)
-				if (!known.has(heading.toLowerCase())) rows.push({ path, line: index + 1, target, heading })
-			}
-		})
-	}
-	return rows
+	const citations = expandPaths(paths)
+		.filter((candidate) => candidate.endsWith('.md'))
+		.flatMap((path) =>
+			readLines(path).flatMap((text, index) =>
+				[...text.matchAll(ANCHOR)].flatMap((match) => {
+					const target = match[1] === undefined ? path : normalizeSlashes(match[1])
+					const heading = (match[2] ?? '').trim()
+					return heading === '' ? [] : [{ path, line: index + 1, target, heading }]
+				}),
+			),
+		)
+	// Each existing target is read once, in the order its first citation names it.
+	const headings = new Map(
+		[...new Set(citations.map(({ target }) => target).filter((target) => existsSync(target)))].map(
+			(target) => [target, readHeadingTexts(target)],
+		),
+	)
+	return citations.filter(
+		({ target, heading }) => headings.get(target)?.has(heading.toLowerCase()) !== true,
+	)
 }
 
 function renderReport(report: Report): string {
-	const lines: string[] = []
-	if (report.tree !== undefined) {
-		lines.push('## Tree')
-		for (const row of report.tree) lines.push(`${row.path}\t${row.lines} lines\t${row.bytes} bytes`)
-		lines.push(
-			`total\t${report.tree.length} files\t${report.tree.reduce((sum, row) => sum + row.lines, 0)} lines`,
-		)
-	}
-	if (report.headings !== undefined) {
-		lines.push('## Headings')
-		for (const row of report.headings) lines.push(`${row.path}:${row.line}\t${row.text}`)
-	}
-	if (report.frontmatter !== undefined) {
-		lines.push('## Frontmatter')
-		for (const row of report.frontmatter) lines.push(`${row.path}:${row.line}	${row.text}`)
-	}
-	if (report.exports !== undefined) {
-		lines.push('## Exports (text reading)')
-		for (const row of report.exports) lines.push(`${row.path}:${row.line}\t${row.text}`)
-	}
-	if (report.census !== undefined) {
-		for (const entry of report.census) {
-			lines.push(`## Census: ${entry.term} (${entry.rows.length})`)
-			for (const row of entry.rows) lines.push(`${row.path}:${row.line}\t${row.text}`)
-		}
-	}
-	if (report.refs !== undefined) {
-		lines.push(`## Refs (${report.refs.length})`)
-		for (const row of report.refs) lines.push(`${row.path}:${row.line}\t${row.text}`)
-	}
-	if (report.anchors !== undefined) {
-		lines.push(`## Unresolved anchors (${report.anchors.length})`)
-		for (const row of report.anchors)
-			lines.push(`${row.path}:${row.line}\t${row.target} § ${row.heading}`)
-	}
+	const { tree, headings, frontmatter, exports, census, refs, anchors } = report
+	const lines = [
+		...(tree === undefined
+			? []
+			: [
+					'## Tree',
+					...tree.map((row) => `${row.path}\t${row.lines} lines\t${row.bytes} bytes`),
+					`total\t${tree.length} files\t${tree.reduce((sum, row) => sum + row.lines, 0)} lines`,
+				]),
+		...(headings === undefined
+			? []
+			: ['## Headings', ...headings.map((row) => `${row.path}:${row.line}\t${row.text}`)]),
+		...(frontmatter === undefined
+			? []
+			: ['## Frontmatter', ...frontmatter.map((row) => `${row.path}:${row.line}\t${row.text}`)]),
+		...(exports === undefined
+			? []
+			: [
+					'## Exports (text reading)',
+					...exports.map((row) => `${row.path}:${row.line}\t${row.text}`),
+				]),
+		...(census ?? []).flatMap((entry) => [
+			`## Census: ${entry.term} (${entry.rows.length})`,
+			...entry.rows.map((row) => `${row.path}:${row.line}\t${row.text}`),
+		]),
+		...(refs === undefined
+			? []
+			: [`## Refs (${refs.length})`, ...refs.map((row) => `${row.path}:${row.line}\t${row.text}`)]),
+		...(anchors === undefined
+			? []
+			: [
+					`## Unresolved anchors (${anchors.length})`,
+					...anchors.map((row) => `${row.path}:${row.line}\t${row.target} § ${row.heading}`),
+				]),
+	]
 	return `${lines.join('\n')}\n`
 }
 

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

@@ -203,8 +203,8 @@ Store child managers in `#` fields and expose readonly getters typed as their in
 
 - Middleware is behavior `(context, next) => ...`, never a class with one `handle` method.
 - Place middleware factories in `middlewares.ts` as `createX(options): Middleware`; keep them distinct from entity/value factories.
-- Keep middleware-local state closure-private.
-- If consumers must address, share, inspect, or replace that state, extract the state to a pluggable class supplied as an option, with an in-memory default.
+- Keep the values a middleware never changes, such as its resolved options and what its factory derives from them, closure-private, and apply `.claude/rules/typescript.md` § Bindings to the state one request changes.
+- Keep the state a middleware changes across requests, such as a per-key count, a cache, or a session table, in a pluggable class supplied as an option, with an in-memory default.
 - Extract reusable cross-middleware machinery to helpers/classes.
 - `MiddlewareManager` is the sole manager of the middleware composition chain; do not create one manager per middleware.
 

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

@@ -22,7 +22,9 @@ paths:
   resolves to `tests/setup<Name>.ts`. A root `tests/setup<Name>.ts` that declares an export has
   `tests/setup<Name>.test.ts` or is imported by `tests/setup.test.ts`, which can prove several
   setup modules when their helpers serve several projects. A vendored module is outside this
-  population. The policy sweep (`tests/setupPolicy.ts`) enforces both directions.
+  population. The policy sweep (`tests/setupPolicy.ts`) enforces both directions. `tests/studies/**`
+  is outside the mirrored population: a study test names a package-level subject and mirrors no
+  module.
 - Prefer test filenames matching entrypoints: `index.test.ts` for `index.ts`, `main.test.ts` for `main.ts`.
 - Tests are deterministic: identical inputs produce identical results.
 - Keep default suites fast: give each timer the shortest real duration that still separates the orderings the test asserts on a loaded host, and make no network calls.
@@ -57,6 +59,7 @@ its own:
 | `tests/guides.test.ts`       | Every documented API exists, every public API is documented, every compared summary, example, and pitch equals its source, and every executable fence returns what the guide says it returns |
 | `tests/conformance.test.ts`  | Where this package drifts from the official tooling it tracks                                                                                                                                |
 | `tests/agents/**/*.test.ts`  | Each skill script does what its `SKILL.md` states, driven as a child process against a scratch fixture from its mirrored proof; the scaffold checkout alone carries them                     |
+| `tests/studies/**/*.test.ts` | Evaluations of the workspace's consumer study code under `studies/`, run through bounded subprocesses and protocol fixtures; the `test:studies` script is their gate                         |
 | `tests/distribution.test.ts` | The packed package installs and resolves through its public exports                                                                                                                          |
 | `tests/integration.test.ts`  | The package's features work together end to end across environments                                                                                                                          |
 | `tests/setup*.test.ts`       | Reusable behavior exported from sibling `tests/setup*.ts` modules works as the workspace's suites require                                                                                    |
@@ -167,7 +170,7 @@ A test that spawns a process, packs, installs, or drives a real build is a proof
 - Keep it out of the default run where the workspace has a gate that can hold it.
   `.claude/rules/workspace.md` fixes which gate each isolated project runs from, and that placement
   differs between a publishing and a `private: true` workspace.
-- The fixed expensive-proof projects are `distribution` and `service`.
+- The fixed expensive-proof projects are `distribution`, `service`, and `studies`.
 - A `distribution` proof reads `import.meta.env.MODE` and fails, rather than skips, on an unreachable
   registry under `--mode release`. The publish gate invokes it that way, so a proof that skips there
   passes the gate without ever proving the artifact installs. An ordinary local run may still skip.
@@ -201,6 +204,9 @@ Place helpers by environment:
 - `tests/setupBrowser.ts`: DOM/Vue/browser helpers and setup CSS.
 - `tests/setupStyles.ts`: the CSSOM and sheet helpers `.claude/rules/styles.md` places there; every
   sheet-face project loads it after `tests/setupBrowser.ts`.
+- `tests/setupStudy.ts`: the harness module the study tests import and, in a study-engine package,
+  its source tests too. Name it in no project's `setupFiles`; tests import it, as the policy proof
+  imports `tests/setupPolicy.ts`.
 
 ### Recorder
 

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

@@ -41,6 +41,136 @@ The non-negotiables and design laws in `AGENTS.md` apply without exception and a
 - Return copies or readonly views; never leak a mutable internal reference.
 - Compute derived facts instead of persisting duplicate state.
 
+## Bindings
+
+- **Variables.** Never write a `let` or `var` declaration, at module scope, in a function, in a loop
+  head, or in a test; declare each variable with the `const` keyword. Never assign to a parameter or
+  a `catch` binding, whether by `=`, by a compound operator such as `+=` or `??=`, by `++` or `--`,
+  or as a destructuring target.
+- **Derivation.** Derive a value instead of accumulating it: write the expression that produces it
+  (`some`, `every`, `find`, `filter`, `map`, `reduce`, a conditional expression), or extract a
+  `{verb}{Noun}` helper that returns it. Build text from its parts with `join` or a template literal,
+  never with a fold whose step appends a part to the text it carries.
+- **Iteration.** Iterate with `for…of` over `entries()` or an iterable instead of an index counter.
+- **Try results.** Take a value out of a `try` block through a helper that runs the block and
+  returns the value. Treat a log that the block appends to as a log rather than such a value, and
+  apply the **Lists and logs** rule to it.
+- **Running values.** Treat a flag, a counter, a sum, a latest value, a one-slot cell, or text built
+  piece by piece as a running value. Treat carrying one by changing a record, an array, a `Map`, a
+  `Set`, or a recorder as a reassigned binding, whether a variable, a parameter, or a `reduce`
+  accumulator holds that collection, directly or through a property: derive the value, or keep it
+  where the **Per-call state** or **Entity state** rule places it. Treat a collection that holds at
+  most one entry and that code reads by position, such as `cell[0]`, `cell.at(-1)`, or
+  `const [entry] = cell`, as a one-slot cell. Treat selecting an entry by iteration order as a
+  position read, including an iterator read such as `values().next()` or `keys().next()`, and a key
+  obtained that way.
+- **Lists and logs.** Build a list from a list with `map`, `filter`, or `flatMap`, and a lookup with
+  `new Map(…)` or `new Set(…)` over a derived list. When a loop awaits or yields between steps, or
+  its step depends on earlier steps, append each step's readonly result to a log that the loop owns,
+  and derive every aggregate from the log, never from a running value. Apply these conditions whether
+  the loop pushes to the log or a `reduce` call returns it:
+  - let only the loop's own steps, in order, or the callbacks of one event source, in emission order,
+    append to the log, and apply the **Per-call state** rule to a list that concurrent paths append
+    to;
+  - let a step read the record before it and carry an aggregate computed from that record, such as a
+    running total;
+  - append each record final: never replace, rewrite, or remove a record the log holds, and never
+    append a record whose text extends an earlier record's text;
+  - treat a log, or a `Map` keyed by step, whose every read takes its last entry or its length as the
+    carrier of a latest value or a counter: derive that value from the source list, return it from a
+    bounded recursion, or carry it in a `reduce` accumulator;
+  - find a log's reads through its aliases, the calls it is passed to, and the callers it is returned
+    to, and never count passing or returning the log as a read of its history.
+- **Exemptions.** Exempt these from the **Running values**, **Lists and logs**, and **Per-call state**
+  rules:
+  - a traversal's worklist, which is a list, `Set`, or `Map` that a loop visits while its steps add
+    the entries left to visit, provided one step can add more than one entry. Treat a loop as a
+    traversal only when it reaches each node after its roots as a successor of a node it has already
+    reached, such as a child directory, a dependency, an amendment, or a child process. Count as one
+    step a complete iteration that removes or visits an entry of the worklist, its nested loops
+    included. Treat a worklist that no step can add more than one entry to as a cursor, and return
+    what it reaches from a bounded recursion;
+  - a traversal's membership set or map, which the traversal reads to avoid revisiting a node or to
+    discover the nodes reachable from nodes it has recorded, whether or not it iterates that
+    collection, and to which the cursor condition never applies;
+  - a memo, which is a `Map` that caches a computation's result by its input or identity key for
+    reuse within one owning operation, writes each key once, and never changes a stored value. Never
+    key a memo by iteration position: treat a `Map` keyed by step as a log;
+  - a list or record that straight-line branches outside any loop append to, with no entry written
+    twice;
+  - a write that a platform API requires, such as `process.exitCode`, a DOM property, or a Vue `ref`
+    value, and one write per key into a fresh local object that builds a fixture a literal cannot
+    express, such as a cycle or a sparse array.
+- **Per-call state.** Keep state that the awaits or callbacks of one call change, other than a log,
+  in `#` fields of an entity created for that call. Treat a list that more than one concurrently
+  pending async path of one call appends to, such as the workers of a pool, as state of that call:
+  collect each path's result through `Promise.all` or `Promise.allSettled`, or keep the list in the
+  call's entity. Treat an iterator or an `AbortController` instance created for the call as that
+  entity for its own protocol, its cursor, its abort, and its first reason, and never treat an array,
+  a record, a `Map`, or a `Set` as that entity. Treat an entity created for one call, or for one unit
+  under the **Bound values** rule, as short-lived for that call or unit, and every other entity as
+  long-lived. Judge lifetime against the call or bound unit whose state you classify: treat an owner
+  that can serve another such call or unit as long-lived, even when that owner belongs to an enclosing
+  call or unit.
+- **Entity state.** Keep state that outlives one call in a `#` field on its owning class, never in
+  an array, a record, a `Map`, or a `Set` that a function holds in its closure and changes after the
+  call that created the function returns. Keep a composable's reactive state as
+  `.claude/rules/browser.md` states, and a middleware's changing state where
+  `.claude/rules/architecture.md` § Middleware places it.
+- **Call slots.** In a long-lived entity, never keep a call's own entity, context, promise, or
+  scratch value in a `#` field that the call sets when it starts or clears when it settles, for its
+  steps, its callbacks, a handler registered outside it, or a later call to reach while it runs:
+  treat that field as a reassigned binding, even when a refusal keeps the calls from overlapping.
+  Reach the call's entity through the **Registries** rule. Treat neither a bound value nor a latch,
+  under the **Bound values** rule, as a call slot.
+- **Unit resets.** In a long-lived entity, never let a method that binds or releases a unit of work
+  reset a `#` field other than the bound value's own field for the unit's later calls to change,
+  whether by assigning the field or by emptying the collection it holds: treat that field as a
+  reassigned binding. Treat an assignment as such a reset when it discards the preceding unit's state
+  and initializes state for another unit, even when its expression reads the old field. Keep that
+  state in `#` fields of the bound value.
+- **Bound values.** When a long-lived entity binds one unit of work at a time that later calls
+  continue, such as a goal, a session, or a lease, and holds that unit nowhere else, keep the unit's
+  value in one `#` field typed `T | undefined`, never in a collection:
+  - in the binding method, throw while the field holds a value and publish the incoming value, both
+    before the method's first suspension, and keep asynchronous initialization inside that value's
+    lifecycle;
+  - in a `start` method that restarts instead, call the bound value's own end method and publish the
+    incoming value before the method's first suspension, and await the previous value's end only
+    after publishing;
+  - set the field back to `undefined` in a later call, such as a `clear` method, the method that ends
+    the unit, or the entity's teardown, and never in the binding call's own settle path. Treat as a
+    later call only an independent invocation made after the binding invocation returned, never
+    cleanup that the binding invocation invokes or registers;
+  - narrow the field's `T | undefined` type by throwing, branching, or optional chaining before you
+    use the value as present, or return or forward it unnarrowed through a contract that admits
+    absence;
+  - keep state whose lifetime is the bound unit in `#` fields of the bound value, and keep state that
+    continues across units in the owning entity's `#` fields.
+
+  Treat an explicit bind-to-release lifecycle as a bound unit. Keep several units bound at once in a
+  registry under the **Registries** rule, read by key. Treat a field that selects an entry the entity
+  already holds, such as the id of its active conversation, as a selection, not a bound value. Treat a
+  field as a latch, not a bound value, when it can acquire a value only once during its owner's
+  lifetime, whether a repeated invocation throws or keeps that value.
+
+- **Registries.** Reach the entities of operations in flight, such as calls, streams, tickets, or
+  units bound at once, through a `readonly` `#` registry, a `Set` or a `Map`: add each entity when its
+  operation starts, delete it on every path that ends the operation, and clear the registry in bulk
+  only in the method that tears the entity down. Delete each settling operation's entry even when
+  that leaves the registry empty. Apply this rule to unfinished calls, streams, tickets, and
+  explicitly bound units, and never to a manager's population, a subscription, a cache, or a
+  persisted record merely because a collection holds it. Read a registry through its `size` property,
+  through every entry, or through the entry a key names. Take its entry by position, as
+  `const [entry] = registry` does, only while a refusal on every add caps the registry at one entry
+  and the call that added the entry deletes it on every path that settles that call, and handle the
+  empty registry at that read.
+- **Immutability exceptions.** As an exception to § Immutability, change in place the membership of a
+  registry that the **Registries** rule admits, and keep its field binding `readonly`. As an exception
+  to the § Immutability ban on mutating caller-owned inputs, let a helper that takes part in one
+  owning operation append to that operation's log under the **Lists and logs** rule, or insert into
+  its memo under the **Exemptions** rule, and mutate no other caller-owned input.
+
 ## Errors and outcomes
 
 | Condition                            | Required strategy                           |