@jterrazz/test 13.0.2 → 14.0.1

package/dist/checker.js

@@ -1,25 +1,64 @@
 #!/usr/bin/env node
 import { a as assertedStreams, d as isMap, f as isScalar, i as SpecSyntaxError, m as renderYamlSource, n as RUN_KEYS, o as parseSpecDocument, p as isSeq, r as SPEC_EXTENSION, s as readSpecFile, t as DOCUMENT_KEYS, u as Scalar } from "./spec-document.js";
-import { o as resolveFixtureSource, r as TOKEN_KINDS } from "./match.js";
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { c as GROUND_EXPECTED, l as GROUND_FIXTURES, o as resolveFixtureSource, r as TOKEN_KINDS, s as GROUND_DIRS, u as GROUND_REQUESTS } from "./match.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
-//#region src/lint/checker-spec.ts
-function finding(rule, line, message, severity = "error") {
-	return {
-		line,
-		message,
-		rule,
-		severity
-	};
-}
-/** Directories the walks never enter — `fixtures/` holds INPUTS, never scenarios. */
+//#region src/lint/checker-crossfile.ts
+/**
+* The cross-file checker passes — the analyses oxlint cannot express because
+* they need to read TWO files at once (a `*.specification.ts` record and the
+* `specs/` test files importing it) or a whole feature tree at once.
+*
+* They live in the checker channel (bundled as `dist/checker.js`) rather than
+* the oxlint plugin, which only ever sees one source file. Each pass follows
+* the checker doctrine: **precision over recall** — a heuristic that cannot
+* decide stays silent (under-reports) so the pass never blocks a legitimate
+* shape. All three are string/scan based (no TS parser in the light lint
+* bundle), matching the token checker's aesthetic.
+*
+* - **C9 dead fixtures** — per feature dir, a fixture file no test literal
+*   references is dead weight; a feature dir with ground subdirs but no
+*   `<feature>.test.ts` is an orphan. A `<case>.spec.yaml` counts as a test
+*   AND as a referrer: the paths of its `fixture:` entries keep those trees
+*   alive exactly as a `.fixture('…')` literal does.
+* - **B5 await-using (inference)** — the docker-aware runners of a spec file
+*   are derived from its `docker:` option, then every `<runner>….exec()` bound
+*   without `await using` in an importing test is flagged. The primary B5
+*   channel now (the oxlint rule needs the runner names spelled out by hand).
+* - **A7 database property** — a spec's `services:` record fixes how many SQL
+*   databases exist; importing tests must (≥2) or must not (==1) pass
+*   `{ database }` to every `.seed()` / `.table()`.
+* - **C14 / C15 where a fixture lives** — a pool entry only ONE spec directory
+*   reaches for belongs beside that leaf (autofixed), and a leaf's own fixture
+*   path may not escape its own `_fixtures/`.
+*/
+/** Directories the cross-file walks never descend into. */
 const PRUNED$1 = /* @__PURE__ */ new Set([
 	".git",
 	"dist",
-	"fixtures",
 	"node_modules"
 ]);
-function listSpecFiles(dir) {
+/** The ground directories of a leaf — the files a spec stands on. */
+const GROUND_SUBDIRS = new Set(GROUND_DIRS);
+/** Destructured names that are never a runner (so never the A7/B5 subject). */
+const NON_RUNNER_BINDINGS = /* @__PURE__ */ new Set([
+	"cleanup",
+	"docker",
+	"orchestrator"
+]);
+/** The specification constructors whose records/options the passes read. */
+const CONSTRUCTORS = "api|cli|jobs";
+/**
+* A `$FIXTURES` pool (`.../specs/_fixtures`) is verbatim fixture material — the
+* reusable apps AND the lint-violation trees that fail on purpose — never live
+* specs. The cross-file walks prune it (like the token checker skips
+* `_fixtures/`); {@link checkPoolFixtures} inspects its top level separately.
+*/
+function isPool(dir) {
+	return basename(dir) === "_fixtures" && basename(dirname(dir)) === "specs";
+}
+/** Recursively list every file under `dir`, skipping pruned dirs and the pool. */
+function listFiles(dir, predicate) {
 	const out = [];
 	const visit = (current) => {
 		let entries;
@@ -31,13 +70,75 @@ function listSpecFiles(dir) {
 		for (const entry of entries) {
 			const path = join(current, entry.name);
 			if (entry.isDirectory()) {
-				if (!PRUNED$1.has(entry.name)) visit(path);
-			} else if (entry.name.endsWith(".spec.yaml")) out.push(path);
+				if (!PRUNED$1.has(entry.name) && !isPool(path)) visit(path);
+			} else if (predicate(path)) out.push(path);
+		}
+	};
+	visit(dir);
+	return out;
+}
+/** Recursively list every directory under `dir` (inclusive), pool pruned. */
+function listDirs(dir) {
+	const out = [];
+	const visit = (current) => {
+		out.push(current);
+		let entries;
+		try {
+			entries = readdirSync(current, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const path = join(current, entry.name);
+			if (entry.isDirectory() && !PRUNED$1.has(entry.name) && !isPool(path)) visit(path);
 		}
 	};
 	visit(dir);
 	return out;
 }
+/**
+* Locate every `specs/` root under `dir` — the anchor a fixture path is
+* measured from. A nested one (a fixture project's own tree) sits inside a pool,
+* which the walk does not enter; the pool's contents are inputs, not live specs.
+*/
+function findSpecsRoots(dir) {
+	const roots = [];
+	const visit = (current) => {
+		if (basename(current) === "specs") {
+			roots.push(current);
+			return;
+		}
+		let entries;
+		try {
+			entries = readdirSync(current, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) if (entry.isDirectory() && !PRUNED$1.has(entry.name)) visit(join(current, entry.name));
+	};
+	visit(dir);
+	return roots;
+}
+/** Locate `$FIXTURES` pools (unlike {@link listDirs}, does not prune them). */
+function findPools(dir) {
+	const pools = [];
+	const visit = (current) => {
+		let entries;
+		try {
+			entries = readdirSync(current, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || PRUNED$1.has(entry.name)) continue;
+			const path = join(current, entry.name);
+			if (isPool(path)) pools.push(path);
+			else visit(path);
+		}
+	};
+	visit(dir);
+	return pools;
+}
 function readText$1(path) {
 	try {
 		return readFileSync(path, "utf8");
@@ -45,511 +146,617 @@ function readText$1(path) {
 		return "";
 	}
 }
-function documentMap(file) {
-	const root = file.source.document.contents;
-	return isMap(root) ? root : null;
+/**
+* Blank out `//` and block comments (replacing them with spaces, newlines
+* preserved so offsets and line numbers stay intact) while leaving string
+* literals untouched. The regex/scan passes read this so a commented-out
+* `.exec()` or a comma inside a `services:` comment never confuses them.
+*/
+function blankComments(text) {
+	const out = [...text];
+	let state = "";
+	for (let i = 0; i < text.length; i += 1) {
+		const char = text[i];
+		const next = text[i + 1];
+		if (state === "line") if (char === "\n") state = "";
+		else out[i] = " ";
+		else if (state === "block") {
+			if (char === "*" && next === "/") {
+				out[i] = " ";
+				out[i + 1] = " ";
+				i += 1;
+				state = "";
+			} else if (char !== "\n") out[i] = " ";
+		} else if (state === "\"" || state === "'" || state === "`") {
+			if (char === "\\") i += 1;
+			else if (char === state) state = "";
+		} else if (char === "/" && next === "/") {
+			out[i] = " ";
+			state = "line";
+		} else if (char === "/" && next === "*") {
+			out[i] = " ";
+			state = "block";
+		} else if (char === "\"" || char === "'" || char === "`") state = char;
+	}
+	return out.join("");
 }
-function pairsOf(map) {
-	return map.items;
+/** File contents with comments blanked — the parse view for the scan passes. */
+function readSource(path) {
+	return blankComments(readText$1(path));
 }
-function keyName(pair) {
-	return isScalar(pair.key) && typeof pair.key.value === "string" ? pair.key.value : null;
+/**
+* The fixture paths a `<case>.spec.yaml` names — its referrer literals. The
+* runner's own parser reads them, so the two channels cannot disagree about
+* what the document says; an unparseable file vouches for nothing (the
+* `d4b-spec-shape` pass is what reports it).
+*/
+function collectSpecLiterals(path) {
+	try {
+		return new Set(parseSpecDocument(readText$1(path), path).fixtures.map((fixture) => fixture.path));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
 }
-function runMaps(file) {
-	const runs = documentMap(file)?.get("runs", true);
-	return isSeq(runs) ? runs.items.filter((item) => isMap(item)) : [];
+/** Is this a file a leaf's ground may be referenced from? */
+function isReferrer(name) {
+	return name.endsWith(".test.ts") || name.endsWith(".spec.yaml");
 }
-/** The stream scalars of one run — the values the block-scalar rule judges. */
-function streamScalars(run) {
-	const found = [];
-	for (const pair of pairsOf(run)) {
-		const key = keyName(pair);
-		if (key === null) continue;
-		if ([
-			"stderr",
-			"stdin",
-			"stdout"
-		].includes(key) && isScalar(pair.value)) {
-			found.push({
-				key,
-				scalar: pair.value
-			});
-			continue;
-		}
-		if (key !== "files" || !isMap(pair.value)) continue;
-		for (const entry of pairsOf(pair.value)) {
-			if (!isMap(entry.value)) continue;
-			for (const assertion of pairsOf(entry.value)) if (keyName(assertion) === "equals" && isScalar(assertion.value)) found.push({
-				key: `files.${keyName(entry) ?? "?"}.equals`,
-				scalar: assertion.value
-			});
-		}
+function isDir(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
 	}
-	return found;
 }
-function isBlock(scalar) {
-	return String(scalar.type ?? "").startsWith("BLOCK");
+/** The 1-based line number of a source offset. */
+function lineAt(text, index) {
+	let line = 1;
+	for (let i = 0; i < index && i < text.length; i += 1) if (text[i] === "\n") line += 1;
+	return line;
 }
 /**
-* The canonical order, top level and inside a run: the ground a session stands
-* on before the session, what was given to a command before what came back.
-* Two authors ordering differently make an unreadable diff out of an unchanged
-* document; a `runs:` above `env:` makes a reader meet the session before its
-* setup.
+* Every quoted string and simple template literal in a source. Over-collection
+* only ever *hides* a dead-fixture finding, so a greedy regex is safe here.
 */
-function checkKeyOrder(file, lineAt) {
-	const findings = [];
-	const inspect = (map, order, where) => {
-		let highest = -1;
-		let highestKey = "";
-		for (const pair of pairsOf(map)) {
-			const key = keyName(pair);
-			const rank = key === null ? -1 : order.indexOf(key);
-			if (rank === -1) continue;
-			if (rank < highest) {
-				findings.push(finding("d4b-spec-key-order", lineAt(pair), `"${key}:" comes after "${highestKey}:" in ${where} — the canonical order is ${order.join(", ")} (fixable: \`node dist/checker.js <root> --fix\`)`));
-				return;
-			}
-			highest = rank;
-			highestKey = key ?? "";
-		}
-	};
-	const map = documentMap(file);
-	if (map !== null) inspect(map, DOCUMENT_KEYS, "a spec document");
-	for (const run of runMaps(file)) inspect(run, RUN_KEYS, "a run");
-	return findings;
+const STRING_LITERAL = /'(?<single>(?:[^'\\\n]|\\.)*)'|"(?<double>(?:[^"\\\n]|\\.)*)"|`(?<template>(?:[^`$\\]|\\.)*)`/g;
+function collectLiterals(text) {
+	const found = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(STRING_LITERAL)) {
+		const value = match.groups?.single ?? match.groups?.double ?? match.groups?.template;
+		if (value !== void 0 && value.length > 0) found.add(value);
+	}
+	return found;
 }
 /**
-* A stream is written as a block scalar (`|` or `|-`), never as a quoted string
-* with `\n` escapes. A one-line golden is unreadable, and no diff can show it:
-* the whole point of the format is that the expected output looks like output.
+* Does the text pass a NON-literal argument to a fixture-ish verb
+* (`.seed`/`.request`/`.fixture`/`toMatch`)? A template with an expression or a
+* variable makes the reference set incomplete, so the feature is reported at
+* warn level instead of error (a false positive would be worse than a miss).
 */
-function checkBlockScalars(file, lineOf) {
-	const findings = [];
-	for (const run of runMaps(file)) for (const { key, scalar } of streamScalars(run)) {
-		if (isBlock(scalar) || scalar.value === "") continue;
-		findings.push(finding("d4b-spec-block-scalar", lineOf(scalar), `${key} is a ${scalar.type === Scalar.PLAIN ? "plain" : "quoted"} scalar — a stream is written as a block scalar (\`|\` keeps the final newline, \`|-\` drops it) (fixable: \`node dist/checker.js <root> --fix\`)`));
+const FIXTURE_VERB_ARG = /(?:\.(?:seed|request|fixture)|\btoMatch)\s*\(\s*(?<arg>[^,)]*)/g;
+function hasNonLiteralFixtureArg(text) {
+	for (const match of text.matchAll(FIXTURE_VERB_ARG)) {
+		const arg = (match.groups?.arg ?? "").trim();
+		if (arg.length === 0) continue;
+		if (!(/^'(?:[^'\\\n]|\\.)*'$/.test(arg) || /^"(?:[^"\\\n]|\\.)*"$/.test(arg) || /^`(?:[^`$\\]|\\.)*`$/.test(arg))) return true;
 	}
-	return findings;
+	return false;
 }
-const KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-/** Words the `.spec.yaml` suffix already says — a case name repeating one says nothing. */
-const REDUNDANT_WORDS = /* @__PURE__ */ new Set([
-	"cli",
-	"spec",
-	"test"
-]);
 /**
-* The file is `<case>.spec.yaml`, and `<case>` NAMES the case: kebab-case, no
-* word the suffix already carries, and never the bare name of its directory —
-* a `rm/` folder holding `rm.spec.yaml` says nothing twice, where `removed`,
-* `unattended` and `missing` each say one thing.
+* `// checker-disable-next-line <id>[,<id>] -- reason` suppresses the passes
+* named by id (`a7`, `b5`, `c9`, or `*`) on the next non-blank line;
+* `checker-disable-line` suppresses its own line. Mirrors the oxlint-disable
+* idiom the repo already uses for negative specs.
 */
-function checkFileName(rel) {
-	const name = basename(rel);
-	const caseName = name.slice(0, -SPEC_EXTENSION.length);
-	const findings = [];
-	if (!KEBAB.test(caseName)) {
-		findings.push(finding("c12-spec-file-name", 1, `"${name}" — <case> is kebab-case: lowercase words joined by single hyphens`));
-		return findings;
+function suppressedLines(text, id) {
+	const suppressed = /* @__PURE__ */ new Set();
+	const lines = text.split("\n");
+	const applies = (raw) => {
+		const ids = raw.replace(/--.*$/, "").trim().split(/[\s,]+/);
+		return ids.includes(id) || ids.includes("*");
+	};
+	for (const [index, line] of lines.entries()) {
+		let match = /checker-disable-next-line\s+(?<ids>.*)$/i.exec(line);
+		if (match !== null && applies(match.groups?.ids ?? "")) {
+			for (let next = index + 1; next < lines.length; next += 1) if (lines[next].trim().length > 0) {
+				suppressed.add(next + 1);
+				break;
+			}
+		}
+		match = /checker-disable-line\s+(?<ids>.*)$/i.exec(line);
+		if (match !== null && applies(match.groups?.ids ?? "")) suppressed.add(index + 1);
 	}
-	const redundant = caseName.split("-").filter((word) => REDUNDANT_WORDS.has(word));
-	if (redundant.length > 0) findings.push(finding("c12-spec-file-name", 1, `"${name}" repeats "${redundant[0]}" — the .spec.yaml suffix already says it; name the CASE instead`));
-	const folder = basename(dirname(rel));
-	if (caseName === folder) findings.push(finding("c12-spec-file-name", 1, `"${name}" repeats its directory "${folder}/" — name what this case proves, not where it sits`));
-	return findings;
+	return suppressed;
 }
-const MAX_DESCRIPTION = 100;
-/** A first word that is an identifier, not prose — exempt from the lowercase rule. */
-const SYMBOL_WORD = /^[A-Z0-9_]+$/;
-/**
-* The description IS the vitest test title, and it is held to the title rules:
-* one lowercase line of prose, no trailing period, short enough to read in a
-* runner's output. A title that is a paragraph is a comment in the wrong place.
-*/
-function checkDescription(document) {
-	const findings = [];
-	const text = document.description;
-	const line = document.descriptionLine;
-	const at = (message) => finding("j5-spec-description", line, message);
-	if (text.includes("\n")) {
-		findings.push(at("description: is one line — the vitest title, not a paragraph"));
-		return findings;
+/** From the `(` at `openIndex`, the substring inside the matching `)`. */
+function balancedParens(text, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < text.length; i += 1) {
+		const char = text[i];
+		if (char === "(") depth += 1;
+		else if (char === ")") {
+			depth -= 1;
+			if (depth === 0) return text.slice(openIndex + 1, i);
+		}
 	}
-	if (text.length > MAX_DESCRIPTION) findings.push(at(`description: is ${text.length} characters — keep it under ${MAX_DESCRIPTION}`));
-	if (text.endsWith(".")) findings.push(at("description: ends with a period — a title is a fragment, not a sentence"));
-	const first = text.split(/\s+/)[0] ?? "";
-	if (/^[A-Z]/.test(text) && !SYMBOL_WORD.test(first)) findings.push(at("description: starts with a capital — a title is lowercase prose"));
-	return findings;
+	return text.slice(openIndex + 1);
 }
-/** The literals the update writer must have failed to tokenise, and their token. */
-const VOLATILE = [
-	{
-		pattern: /\b(?:127\.0\.0\.1|localhost|0\.0\.0\.0):\d{2,5}\b/,
-		token: "{{url}} (or {{port}})"
-	},
-	{
-		pattern: /(?:^|[\s"'(=])(?:\/private)?\/tmp\//,
-		token: "{{workdir}}"
-	},
-	{
-		pattern: /(?:^|[\s"'(=])\/var\/folders\//,
-		token: "{{workdir}}"
-	},
-	{
-		pattern: /(?:^|[\s"'(=])\/(?:Users|home)\/[^\s"'/]+\//,
-		token: "{{workdir}} or {{path}}"
-	}
-];
-/**
-* A stream that pins a loopback port, a temp directory or somebody's home is a
-* golden that passed once, on one machine: the port was free that second, the
-* temp path belonged to that run. It is the exact shape of a value the update
-* writer would have tokenised, which is why finding one means a token was
-* overwritten by hand.
-*/
-function checkVolatileLiterals(document) {
-	const findings = [];
-	for (const stream of assertedStreams(document)) for (const [index, text] of stream.text.split("\n").entries()) for (const { pattern, token } of VOLATILE) {
-		const found = pattern.exec(text);
-		if (found === null) continue;
-		findings.push(finding("d5-spec-volatile-literal", stream.line + index, `"${found[0].trim()}" is a value the next run will not reproduce — write ${token}`));
-		break;
+/** From the `{` at `openIndex`, the substring inside the matching `}`. */
+function balancedBraces(text, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < text.length; i += 1) {
+		const char = text[i];
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return text.slice(openIndex + 1, i);
+		}
 	}
-	return findings;
+	return null;
 }
-const ISO8601 = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})/;
-const UUID = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/;
-/** Everything the document itself FIXED: what it feeds in, and what its fixtures hold. */
-function fixedData(document, dir) {
-	const parts = document.runs.map((run) => run.stdin ?? "");
-	for (const fixture of document.fixtures) {
-		let source;
-		try {
-			source = resolveFixtureSource(fixture.path, dir);
-		} catch {
-			continue;
+/** Split an object/argument body on its depth-0 commas. */
+function splitTopLevel(body) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < body.length; i += 1) {
+		const char = body[i];
+		if (char === "{" || char === "(" || char === "[") depth += 1;
+		else if (char === "}" || char === ")" || char === "]") depth -= 1;
+		else if (char === "," && depth === 0) {
+			parts.push(body.slice(start, i));
+			start = i + 1;
 		}
-		const visit = (path) => {
-			let stat;
-			try {
-				stat = statSync(path);
-			} catch {
-				return;
-			}
-			if (!stat.isDirectory()) {
-				parts.push(readText$1(path));
-				return;
-			}
-			for (const entry of readdirSync(path)) visit(join(path, entry));
-		};
-		visit(source);
 	}
-	return parts.join("\n");
+	parts.push(body.slice(start));
+	return parts;
 }
-/**
-* A timestamp or a uuid spelled out in a golden is a value nothing fixed —
-* unless the document DID fix it, by feeding it in through `stdin:` or shipping
-* it in a `fixture:`. That carve-out is the whole rule: the defect is not the
-* literal, it is the literal nobody pinned.
-*/
-function checkPinnedValues(document, dir) {
-	const findings = [];
-	const streams = assertedStreams(document);
-	if (streams.length === 0) return findings;
-	let fixed = null;
-	for (const stream of streams) for (const [index, text] of stream.text.split("\n").entries()) for (const [pattern, token] of [[ISO8601, "{{iso8601}}"], [UUID, "{{uuid}}"]]) {
-		const found = pattern.exec(text);
-		if (found === null) continue;
-		fixed ??= fixedData(document, dir);
-		if (fixed.includes(found[0])) continue;
-		findings.push(finding("d5w-spec-pinned-value", stream.line + index, `"${found[0]}" is not fixed by any fixture: or stdin: of this document — write ${token}`, "warn"));
+/** The destructured export names of a `= await specification.<ctor>(` binding. */
+function runnerExportsOf(text) {
+	const names = /* @__PURE__ */ new Set();
+	const decl = new RegExp(String.raw`\{(?<names>[^}]*)\}\s*=\s*await\s+specification\.(?:${CONSTRUCTORS})\s*\(`, "g");
+	for (const match of text.matchAll(decl)) for (const raw of (match.groups?.names ?? "").split(",")) {
+		const key = raw.split(":")[0].trim();
+		if (key.length > 0 && !NON_RUNNER_BINDINGS.has(key)) names.add(key);
 	}
-	return findings;
+	return names;
 }
-/**
-* A stream whose entire content is `{{any}}` states that the command printed
-* something, or nothing, of any shape — which is what a stream does anyway. The
-* run happens and proves nothing.
-*/
-function checkEmptyAssertions(document) {
-	const findings = [];
-	for (const stream of assertedStreams(document)) if (stream.text.replaceAll("{{any}}", "").trim() === "" && stream.text.includes("{{any}}")) findings.push(finding("j3w-spec-empty-assertion", stream.line, "a stream that is only {{any}} asserts nothing — golden what the command actually printed", "warn"));
-	return findings;
+/** The leading callee identifier of an expression (`postgres()` → `postgres`). */
+function leadingCallee(value) {
+	const match = /^(?<callee>[A-Za-z_$][\w$]*)\s*\(/.exec(value.trim());
+	return match === null ? match : match.groups?.callee ?? null;
 }
-/**
-* A non-zero exit with neither stream is a CLI that failed without a word — or,
-* far more often, a golden whose author forgot that the words went to stderr.
-* Either way the document does not say WHY the command refused.
-*/
-function checkSilentRefusals(document) {
-	return document.runs.filter((run) => run.exitCode !== 0 && run.stdout === null && run.stderr === null).map((run) => finding("d11w-spec-silent-refusal", run.commandLine, `exit: ${run.exitCode} with no stdout: and no stderr: — golden the words the refusal printed`, "warn"));
+/** SQL factory count of a `services:` record, or null if non-literal/absent. */
+function sqlDatabaseCount(text) {
+	const keyword = /\bservices\s*:/.exec(text);
+	if (keyword === null) return null;
+	const braceIndex = text.indexOf("{", keyword.index + keyword[0].length);
+	if (braceIndex === -1 || text.slice(keyword.index + keyword[0].length, braceIndex).trim() !== "") return null;
+	const body = balancedBraces(text, braceIndex);
+	if (body === null) return null;
+	let count = 0;
+	for (const pair of splitTopLevel(body)) {
+		if (pair.trim().length === 0) continue;
+		const colon = pair.indexOf(":");
+		if (colon === -1) return null;
+		const callee = leadingCallee(pair.slice(colon + 1).trim());
+		if (callee === null) return null;
+		if (callee === "postgres" || callee === "sqlite" || callee === "mysql") count += 1;
+	}
+	return count;
 }
-/** The top-level keys of an object literal, read by depth, not by parsing. */
-function objectKeys(source, from) {
-	const keys = [];
-	let depth = 0;
-	let quote = "";
-	for (let index = from; index < source.length; index += 1) {
-		const char = source[index];
-		if (quote !== "") {
-			if (char === quote && source[index - 1] !== "\\") quote = "";
-			continue;
-		}
-		if (char === "'" || char === "\"" || char === "`") {
-			quote = char;
-			continue;
-		}
-		if (char === "{" || char === "[" || char === "(") {
-			depth += 1;
-			continue;
-		}
-		if (char === "}" || char === "]" || char === ")") {
-			depth -= 1;
-			if (depth === 0) return {
-				end: index,
-				keys
-			};
-			continue;
-		}
-		if (depth === 1 && /[A-Za-z_$'"]/.test(char)) {
-			const rest = /^(?<quote>['"]?)(?<name>[A-Za-z_$][\w$]*)\k<quote>\s*:/.exec(source.slice(index));
-			if (rest?.groups) {
-				keys.push(rest.groups.name);
-				index += rest[0].length - 1;
-			}
-		}
+function modelSpecFile(file) {
+	const text = readSource(file);
+	let dockerAware = false;
+	for (const match of text.matchAll(/specification\.cli\s*\(/g)) {
+		const argsOpen = text.indexOf("(", match.index);
+		if (argsOpen !== -1 && /\bdocker\s*:/.test(balancedParens(text, argsOpen))) dockerAware = true;
 	}
 	return {
-		end: source.length,
-		keys
+		dockerAware,
+		file,
+		runnerExports: runnerExportsOf(text),
+		sqlDatabaseCount: sqlDatabaseCount(text)
 	};
 }
+/** Resolve a relative import specifier to a `.ts` path (else undefined). */
+function resolveRelativeImport(fromFile, specifier) {
+	if (!specifier.startsWith(".")) return;
+	return resolve(dirname(fromFile), specifier).replace(/\.js$/, ".ts");
+}
+/** Every `import { a, b as c } from '…'` binding in a file. */
+function namedImports(text) {
+	const bindings = [];
+	for (const match of text.matchAll(/import\s+(?:type\s+)?\{(?<names>[^}]*)\}\s+from\s+['"](?<source>[^'"]+)['"]/g)) {
+		const source = match.groups?.source ?? "";
+		for (const raw of (match.groups?.names ?? "").split(",")) {
+			const part = raw.trim();
+			if (part.length === 0) continue;
+			const [name, local] = part.split(/\s+as\s+/).map((token) => token.trim());
+			bindings.push({
+				local: local ?? name,
+				name,
+				source
+			});
+		}
+	}
+	return bindings;
+}
 /**
-* The `env` and `serve` names registered by the `specification.cli(…)` calls of
-* the nearest directory holding a `*.specification.ts`, read as literals. A
-* directory may declare several runners, and nothing in a document says which
-* one runs it, so their registries are read as a UNION: a name known to any
-* neighbouring runner passes, and only a name known to none is a typo.
+* Docker-aware runner results must be bound with `await using`. The runner
+* identifiers are inferred from the `docker:` option of imported spec files —
+* no hand-maintained runner list, unlike the oxlint rule.
 */
-function registeredNames(dir) {
-	let current = dir;
-	for (;;) {
-		let entries;
-		try {
-			entries = readdirSync(current).filter((name) => name.endsWith(".specification.ts"));
-		} catch {
-			entries = [];
+function checkDockerRunnerAwaitUsing(rootDir) {
+	const violations = [];
+	const specFiles = listFiles(rootDir, (path) => path.endsWith(".specification.ts"));
+	const dockerSpecs = /* @__PURE__ */ new Map();
+	for (const file of specFiles) {
+		const model = modelSpecFile(file);
+		if (model.dockerAware && model.runnerExports.size > 0) dockerSpecs.set(file, model);
+	}
+	if (dockerSpecs.size === 0) return violations;
+	for (const testFile of listFiles(rootDir, (path) => path.endsWith(".test.ts"))) {
+		const text = readSource(testFile);
+		const runners = /* @__PURE__ */ new Set();
+		for (const binding of namedImports(text)) {
+			const target = resolveRelativeImport(testFile, binding.source);
+			if ((target === void 0 ? void 0 : dockerSpecs.get(target))?.runnerExports.has(binding.name) === true) runners.add(binding.local);
 		}
-		if (entries.length > 0) {
-			const env = /* @__PURE__ */ new Set();
-			const serve = /* @__PURE__ */ new Set();
-			for (const entry of entries) {
-				const text = readText$1(join(current, entry));
-				for (const call of text.matchAll(/specification\.cli\s*\(/g)) {
-					const open = text.indexOf("{", call.index + call[0].length);
-					if (open === -1) continue;
-					const options = objectKeys(text, open);
-					for (const [key, into] of [["env", env], ["serve", serve]]) {
-						const marker = new RegExp(String.raw`\b${key}\s*:\s*\{`).exec(text.slice(open, options.end));
-						if (marker === null) continue;
-						const at = open + marker.index + marker[0].length - 1;
-						for (const name of objectKeys(text, at).keys) into.add(name);
-					}
-				}
-			}
-			return {
-				env,
-				serve
-			};
+		if (runners.size === 0) continue;
+		const suppressed = suppressedLines(readText$1(testFile), "b5");
+		for (const match of text.matchAll(/\b(?<kind>await\s+using|const|let|var)\s+[A-Za-z_$][\w$]*\s*=\s*await\s+(?<runner>[A-Za-z_$][\w$]*)\b[^;]*?\.exec\s*\(/g)) {
+			const kind = match.groups?.kind ?? "";
+			const runner = match.groups?.runner ?? "";
+			if (kind.startsWith("await using") || !runners.has(runner)) continue;
+			const line = lineAt(text, match.index);
+			if (suppressed.has(line)) continue;
+			const rel = relative(rootDir, testFile);
+			violations.push({
+				file: rel,
+				line,
+				message: `${rel}:${line}: result of docker-aware runner "${runner}" must be bound with \`await using\` so its containers are disposed (B5 — see docs/10-linting.md)`,
+				severity: "error"
+			});
 		}
-		const parent = dirname(current);
-		if (parent === current) return null;
-		current = parent;
 	}
+	return violations;
 }
-/**
-* Every bare word of `env:` and every `serve:` name must be a key of a runner
-* registered above the document. A typo (`serve: dashbord`) is a refusal at
-* run time today, one test file into a suite; here it is a line in a lint run.
-*/
-function checkRegisteredNames(document, dir) {
-	if (document.env.length === 0 && document.serve.length === 0) return [];
-	const registered = registeredNames(dir);
-	if (registered === null) return [];
-	const findings = [];
-	for (const token of document.env) if (token.kind === "set" && !registered.env.has(token.name)) findings.push(finding("c8-spec-registered-name", token.line, `env: "${token.name}" is not a registered env set${registered.env.size === 0 ? "" : ` — registered: ${[...registered.env].sort().join(", ")}`}`));
-	for (const entry of document.serve) if (!registered.serve.has(entry.name)) findings.push(finding("c8-spec-registered-name", entry.line, `serve: "${entry.name}" is not a registered server${registered.serve.size === 0 ? "" : ` — registered: ${[...registered.serve].sort().join(", ")}`}`));
-	return findings;
+/** Local inline runners a test declares itself (`specification.api(…)`). */
+function localRunnerBindings(text) {
+	const locals = /* @__PURE__ */ new Set();
+	const decl = new RegExp(String.raw`\{(?<names>[^}]*)\}\s*=\s*await\s+specification\.(?:${CONSTRUCTORS})\s*\(`, "g");
+	for (const match of text.matchAll(decl)) for (const raw of (match.groups?.names ?? "").split(",")) {
+		const part = raw.trim();
+		const local = (part.includes(":") ? part.split(":")[1] : part).trim();
+		if (local.length > 0 && !NON_RUNNER_BINDINGS.has(part.split(":")[0].trim())) locals.add(local);
+	}
+	return locals;
 }
-/**
-* Run every document-conventions pass over one `<case>.spec.yaml`. A document
-* the grammar refuses yields NOTHING here: `d4b-spec-shape` already reported
-* it, and a second cascade of findings about a file nobody can parse only
-* buries the one line that matters.
-*/
-function checkSpecConventions(text, rel, path) {
-	let file;
+/** The identifier immediately before a `.seed(`/`.table(` member, if any. */
+function memberObjectIdentifier(text, dotIndex) {
+	const before = text.slice(0, dotIndex);
+	const match = /(?<name>[A-Za-z_$][\w$]*)\s*$/.exec(before);
+	return match === null ? match : match.groups?.name ?? null;
+}
+function checkDatabaseProperty(rootDir) {
+	const violations = [];
+	const enforced = /* @__PURE__ */ new Map();
+	for (const file of listFiles(rootDir, (path) => path.endsWith(".specification.ts"))) {
+		const model = modelSpecFile(file);
+		if (model.sqlDatabaseCount !== null && model.sqlDatabaseCount >= 1 && model.runnerExports.size > 0) enforced.set(file, model);
+	}
+	if (enforced.size === 0) return violations;
+	for (const testFile of listFiles(rootDir, (path) => path.endsWith(".test.ts"))) {
+		const text = readSource(testFile);
+		const applicable = /* @__PURE__ */ new Set();
+		for (const binding of namedImports(text)) {
+			const target = resolveRelativeImport(testFile, binding.source);
+			const model = target === void 0 ? void 0 : enforced.get(target);
+			if (model?.runnerExports.has(binding.name) === true) applicable.add(model);
+		}
+		if (applicable.size !== 1) continue;
+		const count = [...applicable][0].sqlDatabaseCount ?? 0;
+		const locals = localRunnerBindings(text);
+		const suppressed = suppressedLines(readText$1(testFile), "a7");
+		const rel = relative(rootDir, testFile);
+		for (const match of text.matchAll(/\.(?<verb>seed|table)\s*\(/g)) {
+			const verb = match.groups?.verb ?? "";
+			const object = memberObjectIdentifier(text, match.index);
+			if (object !== null && locals.has(object)) continue;
+			const args = balancedParens(text, text.indexOf("(", match.index));
+			const hasDatabase = /\bdatabase\s*:/.test(args);
+			const line = lineAt(text, match.index);
+			if (suppressed.has(line)) continue;
+			if (count >= 2 && !hasDatabase) violations.push({
+				file: rel,
+				line,
+				message: `${rel}:${line}: .${verb}() must pass { database } — ${count} SQL databases are declared (A7 — see docs/10-linting.md)`,
+				severity: "error"
+			});
+			else if (count === 1 && hasDatabase) violations.push({
+				file: rel,
+				line,
+				message: `${rel}:${line}: .${verb}() must not pass { database } — a single SQL database is declared (A7 — see docs/10-linting.md)`,
+				severity: "error"
+			});
+		}
+	}
+	return violations;
+}
+/** Is a top-level ground-subdir entry referenced by any test literal? */
+function entryReferenced(entry, entryIsDir, literals) {
+	for (const literal of literals) {
+		if (entryIsDir) {
+			if (literal === entry || literal.startsWith(`${entry}/`) || literal.includes(`/${entry}`)) return true;
+		}
+		if (literal === entry || literal.includes(entry)) return true;
+	}
+	return false;
+}
+/** A child named like a ground subdir but actually a fixture container. */
+function isConventionalSubdir(path) {
+	if (!isDir(path)) return false;
+	if (listFiles(path, (candidate) => candidate.endsWith(".test.ts")).length > 0) return false;
+	let children;
 	try {
-		file = readSpecFile(text, rel);
+		children = readdirSync(path, { withFileTypes: true });
 	} catch {
-		return [];
+		return false;
 	}
-	const lineAt = (node) => {
-		const range = "range" in node && Array.isArray(node.range) ? node.range : void 0;
-		const key = node.key;
-		const target = range ?? (isScalar(key) && Array.isArray(key.range) ? key.range : void 0);
-		return target === void 0 ? 1 : file.source.lineAt(target[0]);
-	};
-	const dir = dirname(path);
-	return [
-		...checkKeyOrder(file, (pair) => lineAt(pair.key)),
-		...checkBlockScalars(file, (scalar) => lineAt(scalar)),
-		...checkFileName(rel),
-		...checkDescription(file.document),
-		...checkVolatileLiterals(file.document),
-		...checkPinnedValues(file.document, dir),
-		...checkEmptyAssertions(file.document),
-		...checkSilentRefusals(file.document),
-		...checkRegisteredNames(file.document, dir)
-	].map(({ line, message, rule, severity }) => ({
-		file: rel,
-		line,
-		message: `${rel}:${line}: ${message} (${rule} — see docs/10-linting.md)`,
-		severity
-	}));
+	return !children.some((child) => child.isDirectory() && GROUND_SUBDIRS.has(child.name));
 }
-/**
-* J4-spec-description-unique — the description is the test title, and two
-* documents in one directory sharing it make a failing run ambiguous: the
-* reporter names the title, and the reader has two files to open.
-*/
-function checkSpecDescriptionsUnique(rootDir) {
-	const byDirectory = /* @__PURE__ */ new Map();
+function checkDeadFixtures(rootDir) {
 	const violations = [];
-	for (const path of listSpecFiles(rootDir)) {
-		let document;
+	for (const dir of listDirs(rootDir)) {
+		if (basename(dir) === "specs") continue;
+		let entries;
 		try {
-			document = readSpecFile(readText$1(path), path).document;
+			entries = readdirSync(dir, { withFileTypes: true });
 		} catch {
 			continue;
 		}
-		const dir = dirname(path);
-		const seen = byDirectory.get(dir) ?? /* @__PURE__ */ new Map();
-		byDirectory.set(dir, seen);
-		const first = seen.get(document.description);
-		const rel = relative(rootDir, path);
-		if (first === void 0) {
-			seen.set(document.description, rel);
-			continue;
-		}
-		violations.push({
-			file: rel,
-			line: document.descriptionLine,
-			message: `${rel}:${document.descriptionLine}: "${document.description}" is already the description of ${first} — two documents of one directory cannot share a title (j4-spec-description-unique — see docs/10-linting.md)`,
-			severity: "error"
-		});
+		const groundSubdirs = entries.filter((entry) => entry.isDirectory() && GROUND_SUBDIRS.has(entry.name) && isConventionalSubdir(join(dir, entry.name))).map((entry) => entry.name);
+		if (groundSubdirs.length === 0) continue;
+		const feature = basename(dir);
+		const testFiles = entries.filter((entry) => entry.isFile() && isReferrer(entry.name)).map((entry) => join(dir, entry.name));
+		const rel = relative(rootDir, dir);
+		if (testFiles.length === 0) {
+			violations.push({
+				file: rel,
+				line: 1,
+				message: `${rel}: domain directory has ground subdirs (${groundSubdirs.join(", ")}) but no *.test.ts or *.spec.yaml (C9 — see docs/10-linting.md)`,
+				severity: "error"
+			});
+			continue;
+		}
+		const literals = /* @__PURE__ */ new Set();
+		let downgrade = false;
+		for (const testFile of testFiles) {
+			if (testFile.endsWith(".spec.yaml")) {
+				for (const literal of collectSpecLiterals(testFile)) literals.add(literal);
+				continue;
+			}
+			const text = readSource(testFile);
+			for (const literal of collectLiterals(text)) literals.add(literal);
+			downgrade ||= hasNonLiteralFixtureArg(text);
+		}
+		const severity = downgrade ? "warn" : "error";
+		for (const sub of groundSubdirs) {
+			const subPath = join(dir, sub);
+			for (const entry of readdirSync(subPath, { withFileTypes: true })) {
+				const entryIsDir = entry.isDirectory();
+				if (entryReferenced(entry.name, entryIsDir, literals)) continue;
+				const relEntry = relative(rootDir, join(subPath, entry.name));
+				violations.push({
+					file: relEntry,
+					line: 1,
+					message: `${relEntry}: dead fixture — no test literal in ${feature} references ${sub}/${entry.name} (C9 — see docs/10-linting.md)`,
+					severity
+				});
+			}
+		}
+	}
+	violations.push(...checkPoolFixtures(rootDir));
+	return violations;
+}
+/** Unreferenced top-level entries of a `$FIXTURES` pool (`specs/_fixtures`). */
+function checkPoolFixtures(rootDir) {
+	const violations = [];
+	for (const pool of findPools(rootDir)) {
+		const specsRoot = dirname(pool);
+		const literals = /* @__PURE__ */ new Set();
+		for (const file of listFiles(specsRoot, (path) => path.endsWith(".ts") || path.endsWith(".spec.yaml"))) {
+			if (file.startsWith(`${pool}/`) || file.startsWith(`${pool}\\`)) continue;
+			const found = file.endsWith(".spec.yaml") ? collectSpecLiterals(file) : collectLiterals(readSource(file));
+			for (const literal of found) literals.add(literal);
+		}
+		for (const entry of readdirSync(pool, { withFileTypes: true })) if (![...literals].some((literal) => literal.includes(entry.name))) {
+			const relEntry = relative(rootDir, join(pool, entry.name));
+			violations.push({
+				file: relEntry,
+				line: 1,
+				message: `${relEntry}: dead pool fixture — no spec under ${relative(rootDir, specsRoot)} references $FIXTURES/${entry.name} (C9 — see docs/10-linting.md)`,
+				severity: "error"
+			});
+		}
 	}
 	return violations;
 }
+/** A `.fixture('…')` call with a plain string argument. */
+const FIXTURE_CALL = /\.fixture\(\s*(?<quote>['"`])(?<path>(?:[^'"`\\]|\\.)*)\k<quote>/g;
 /**
-* Apply the two fixable passes to one document: reorder its keys, and re-style
-* every stream as a block scalar. Returns `null` when nothing moved — the
-* caller writes only what changed, so a clean tree keeps its mtimes.
+* Every fixture path a spec file names, with the line it names it on. A
+* `<case>.spec.yaml` is read through the runner's own parser; a `.ts` file
+* through its literal `.fixture()` arguments — a non-literal argument is out of
+* static reach and stays silent (the checker doctrine: precision over recall).
 */
-function fixSpecDocument(text, rel) {
-	let file;
-	try {
-		file = readSpecFile(text, rel);
+function collectFixtureReferences(file) {
+	if (file.endsWith(".spec.yaml")) try {
+		return parseSpecDocument(readText$1(file), file).fixtures.map((fixture) => ({
+			file,
+			line: fixture.line,
+			path: fixture.path
+		}));
 	} catch {
-		return null;
+		return [];
 	}
-	const reorder = (map, order) => {
-		const sorted = [...pairsOf(map).filter((pair) => order.includes(keyName(pair) ?? ""))].sort((a, b) => order.indexOf(keyName(a)) - order.indexOf(keyName(b)));
-		let cursor = 0;
-		map.items = pairsOf(map).map((pair) => order.includes(keyName(pair) ?? "") ? sorted[cursor++] : pair);
-	};
-	const map = documentMap(file);
-	if (map === null) return null;
-	reorder(map, DOCUMENT_KEYS);
-	for (const run of runMaps(file)) {
-		reorder(run, RUN_KEYS);
-		for (const { scalar } of streamScalars(run)) if (!isBlock(scalar) && scalar.value !== "") scalar.type = Scalar.BLOCK_LITERAL;
+	const text = readSource(file);
+	const references = [];
+	for (const match of text.matchAll(FIXTURE_CALL)) {
+		const path = match.groups?.path;
+		if (path !== void 0 && path.length > 0) references.push({
+			file,
+			line: lineAt(text, match.index),
+			path
+		});
 	}
-	const next = renderYamlSource(file.source);
-	return next === text ? null : next;
+	return references;
+}
+/** Every spec file of a tree that may name a fixture, the pool excluded. */
+function listReferrers(specsRoot, pool) {
+	return listFiles(specsRoot, (path) => path.endsWith(".ts") || path.endsWith(".spec.yaml")).filter((file) => !file.startsWith(`${pool}/`) && !file.startsWith(`${pool}\\`));
+}
+/** The pool entry a `$FIXTURES/…` path names — its FIRST segment. */
+function poolEntryOf(path) {
+	if (!path.startsWith("$FIXTURES/")) return;
+	const entry = path.slice(10).split("/")[0];
+	return entry.length > 0 ? entry : void 0;
+}
+/** Pool entry → the spec directories that reference it, each with its referrers. */
+function poolUsage(specsRoot, pool) {
+	const usage = /* @__PURE__ */ new Map();
+	for (const file of listReferrers(specsRoot, pool)) for (const { path } of collectFixtureReferences(file)) {
+		const entry = poolEntryOf(path);
+		if (entry === void 0) continue;
+		const leaves = usage.get(entry) ?? /* @__PURE__ */ new Map();
+		const referrers = leaves.get(dirname(file)) ?? [];
+		if (!referrers.includes(file)) referrers.push(file);
+		leaves.set(dirname(file), referrers);
+		usage.set(entry, leaves);
+	}
+	return usage;
 }
-/** Fix every `<case>.spec.yaml` under `rootDir`; returns the paths rewritten. */
-function fixSpecFiles(rootDir) {
-	const written = [];
-	for (const path of listSpecFiles(rootDir)) {
-		const next = fixSpecDocument(readText$1(path), relative(rootDir, path));
-		if (next !== null) {
-			writeFileSync(path, next);
-			written.push(relative(rootDir, path));
+/**
+* Pool entries reached from exactly ONE spec directory. Two documents of the
+* same leaf count as one — the unit is the folder, not the file. An entry no
+* `$FIXTURES` reference names at all is C9's dead-fixture case, not this one.
+*/
+function misplacedPoolFixtures(rootDir) {
+	const misplaced = [];
+	for (const pool of findPools(rootDir)) {
+		const usage = poolUsage(dirname(pool), pool);
+		for (const [entry, leaves] of usage) {
+			if (leaves.size !== 1 || !isDir(join(pool, entry))) continue;
+			const [leaf, referrers] = [...leaves][0];
+			misplaced.push({
+				entry,
+				leaf,
+				pool,
+				referrers
+			});
 		}
 	}
-	return written;
+	return misplaced;
 }
-//#endregion
-//#region src/lint/checker-crossfile.ts
 /**
-* The cross-file checker passes — the analyses oxlint cannot express because
-* they need to read TWO files at once (a `*.specification.ts` record and the
-* `specs/` test files importing it) or a whole feature tree at once.
+* CONVENTIONS C14 — a pool fixture is SHARED, or it is local. A directory of the
+* specs-root `_fixtures/` pool that exactly one spec directory reaches for is
+* misplaced: it belongs beside that leaf, as `<leaf>/_fixtures/<name>/`, named by
+* the plain relative form.
 *
-* They live in the checker channel (bundled as `dist/checker.js`) rather than
-* the oxlint plugin, which only ever sees one source file. Each pass follows
-* the checker doctrine: **precision over recall** — a heuristic that cannot
-* decide stays silent (under-reports) so the pass never blocks a legitimate
-* shape. All three are string/scan based (no TS parser in the light lint
-* bundle), matching the token checker's aesthetic.
+* The catch: a fixture built for one scenario and parked in the pool reads as
+* shared ground. Every later author assumes some other spec depends on it, so
+* nobody dares change it — and the one spec that actually owns it is a directory
+* away, invisible. Fixed by `--fix`, which moves the tree and rewrites the
+* referrers.
+*/
+function checkPoolFixtureSharing(rootDir) {
+	return misplacedPoolFixtures(rootDir).map(({ entry, leaf, pool }) => {
+		const relEntry = relative(rootDir, join(pool, entry));
+		const relLeaf = relative(rootDir, leaf);
+		return {
+			file: relEntry,
+			line: 1,
+			message: `${relEntry}: only ${relLeaf} reaches for this pool fixture — the pool is what SEVERAL leaves share; move it to ${relLeaf}/${GROUND_FIXTURES}/${entry} and reference it as '${entry}' (C14 — see docs/10-linting.md, or run the checker with --fix)`,
+			severity: "error"
+		};
+	});
+}
+/**
+* Apply C14: move each single-reader pool entry beside its leaf and rewrite the
+* `$FIXTURES/<name>` literals that named it. The move is a plain rename — the
+* checker never runs git, so the working tree sees it and the author stages it.
+* Returns what moved, relative to `rootDir`.
+*/
+function fixPoolFixtures(rootDir) {
+	const moved = [];
+	for (const { entry, leaf, pool, referrers } of misplacedPoolFixtures(rootDir)) {
+		const destination = join(leaf, GROUND_FIXTURES, entry);
+		if (existsSync(destination)) continue;
+		mkdirSync(dirname(destination), { recursive: true });
+		renameSync(join(pool, entry), destination);
+		for (const file of referrers) {
+			const text = readText$1(file);
+			const next = text.replaceAll(`$FIXTURES/${entry}`, entry);
+			if (next !== text) writeFileSync(file, next);
+		}
+		moved.push(`${relative(rootDir, join(pool, entry))} → ${relative(rootDir, destination)}`);
+	}
+	return moved;
+}
+/**
+* CONVENTIONS C15 — a local fixture is reached only from its own folder. A
+* marker-less `.fixture()` / `fixture:` path resolves under the referring spec's
+* own `_fixtures/`; a `..` segment or an absolute path escapes it, and reaching
+* into a sibling's ground is the pool by another door — with none of the pool's
+* visibility.
 *
-* - **C9 dead fixtures** — per feature dir, a fixture file no test literal
-*   references is dead weight; a feature dir with conventional subdirs but no
-*   `<feature>.test.ts` is an orphan. A `<case>.spec.yaml` counts as a test
-*   AND as a referrer: the paths of its `fixture:` entries keep those trees
-*   alive exactly as a `.fixture('…')` literal does.
-* - **B5 await-using (inference)** — the docker-aware runners of a spec file
-*   are derived from its `docker:` option, then every `<runner>….exec()` bound
-*   without `await using` in an importing test is flagged. The primary B5
-*   channel now (the oxlint rule needs the runner names spelled out by hand).
-* - **A7 database property** — a spec's `services:` record fixes how many SQL
-*   databases exist; importing tests must (≥2) or must not (==1) pass
-*   `{ database }` to every `.seed()` / `.table()`.
+* The catch: a leaf quietly depending on a neighbour's fixtures. The neighbour's
+* author has no way to know, edits their own ground, and breaks a spec two
+* folders away. Ground several leaves share belongs in the pool, where its
+* sharing is declared.
 */
-/** Directories the cross-file walks never descend into. */
+function checkLocalFixtureReach(rootDir) {
+	const violations = [];
+	for (const specsRoot of findSpecsRoots(rootDir)) {
+		const pool = join(specsRoot, GROUND_FIXTURES);
+		for (const file of listReferrers(specsRoot, pool)) {
+			const ground = join(dirname(file), GROUND_FIXTURES);
+			for (const { line, path } of collectFixtureReferences(file)) {
+				if (path.startsWith("$")) continue;
+				const target = resolve(ground, path);
+				if (target === ground || target.startsWith(`${ground}/`)) continue;
+				const rel = relative(rootDir, file);
+				violations.push({
+					file: rel,
+					line,
+					message: `${rel}:${line}: fixture "${path}" reaches outside ${relative(rootDir, ground)} — a leaf's ground sits beside it; ground several leaves share goes to the $FIXTURES pool at ${relative(rootDir, pool)} (C15 — see docs/10-linting.md)`,
+					severity: "error"
+				});
+			}
+		}
+	}
+	return violations;
+}
+//#endregion
+//#region src/lint/checker-spec.ts
+function finding(rule, line, message, severity = "error") {
+	return {
+		line,
+		message,
+		rule,
+		severity
+	};
+}
+/** Directories the walks never enter — `_fixtures/` holds INPUTS, never scenarios. */
 const PRUNED = /* @__PURE__ */ new Set([
 	".git",
 	"dist",
+	GROUND_FIXTURES,
 	"node_modules"
 ]);
-/** Conventional per-feature subdirectories whose files are assertion fixtures. */
-const CONVENTIONAL_SUBDIRS = /* @__PURE__ */ new Set([
-	"expected",
-	"fixtures",
-	"requests",
-	"seeds"
-]);
-/** Destructured names that are never a runner (so never the A7/B5 subject). */
-const NON_RUNNER_BINDINGS = /* @__PURE__ */ new Set([
-	"cleanup",
-	"docker",
-	"orchestrator"
-]);
-/** The specification constructors whose records/options the passes read. */
-const CONSTRUCTORS = "api|cli|jobs";
-/**
-* A `$FIXTURES` pool (`.../specs/fixtures`) is verbatim fixture material — the
-* reusable apps AND the lint-violation trees that fail on purpose — never live
-* specs. The cross-file walks prune it (like the token checker skips
-* `fixtures/`); {@link checkPoolFixtures} inspects its top level separately.
-*/
-function isPool(dir) {
-	return basename(dir) === "fixtures" && basename(dirname(dir)) === "specs";
-}
-/** Recursively list every file under `dir`, skipping pruned dirs and the pool. */
-function listFiles(dir, predicate) {
+function listSpecFiles(dir) {
 	const out = [];
 	const visit = (current) => {
 		let entries;
@@ -561,52 +768,13 @@ function listFiles(dir, predicate) {
 		for (const entry of entries) {
 			const path = join(current, entry.name);
 			if (entry.isDirectory()) {
-				if (!PRUNED.has(entry.name) && !isPool(path)) visit(path);
-			} else if (predicate(path)) out.push(path);
-		}
-	};
-	visit(dir);
-	return out;
-}
-/** Recursively list every directory under `dir` (inclusive), pool pruned. */
-function listDirs(dir) {
-	const out = [];
-	const visit = (current) => {
-		out.push(current);
-		let entries;
-		try {
-			entries = readdirSync(current, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			const path = join(current, entry.name);
-			if (entry.isDirectory() && !PRUNED.has(entry.name) && !isPool(path)) visit(path);
+				if (!PRUNED.has(entry.name)) visit(path);
+			} else if (entry.name.endsWith(".spec.yaml")) out.push(path);
 		}
 	};
 	visit(dir);
 	return out;
 }
-/** Locate `$FIXTURES` pools (unlike {@link listDirs}, does not prune them). */
-function findPools(dir) {
-	const pools = [];
-	const visit = (current) => {
-		let entries;
-		try {
-			entries = readdirSync(current, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			if (!entry.isDirectory() || PRUNED.has(entry.name)) continue;
-			const path = join(current, entry.name);
-			if (isPool(path)) pools.push(path);
-			else visit(path);
-		}
-	};
-	visit(dir);
-	return pools;
-}
 function readText(path) {
 	try {
 		return readFileSync(path, "utf8");
@@ -614,442 +782,451 @@ function readText(path) {
 		return "";
 	}
 }
-/**
-* Blank out `//` and block comments (replacing them with spaces, newlines
-* preserved so offsets and line numbers stay intact) while leaving string
-* literals untouched. The regex/scan passes read this so a commented-out
-* `.exec()` or a comma inside a `services:` comment never confuses them.
-*/
-function blankComments(text) {
-	const out = [...text];
-	let state = "";
-	for (let i = 0; i < text.length; i += 1) {
-		const char = text[i];
-		const next = text[i + 1];
-		if (state === "line") if (char === "\n") state = "";
-		else out[i] = " ";
-		else if (state === "block") {
-			if (char === "*" && next === "/") {
-				out[i] = " ";
-				out[i + 1] = " ";
-				i += 1;
-				state = "";
-			} else if (char !== "\n") out[i] = " ";
-		} else if (state === "\"" || state === "'" || state === "`") {
-			if (char === "\\") i += 1;
-			else if (char === state) state = "";
-		} else if (char === "/" && next === "/") {
-			out[i] = " ";
-			state = "line";
-		} else if (char === "/" && next === "*") {
-			out[i] = " ";
-			state = "block";
-		} else if (char === "\"" || char === "'" || char === "`") state = char;
-	}
-	return out.join("");
+function documentMap(file) {
+	const root = file.source.document.contents;
+	return isMap(root) ? root : null;
 }
-/** File contents with comments blanked — the parse view for the scan passes. */
-function readSource(path) {
-	return blankComments(readText(path));
+function pairsOf(map) {
+	return map.items;
 }
-/**
-* The fixture paths a `<case>.spec.yaml` names — its referrer literals. The
-* runner's own parser reads them, so the two channels cannot disagree about
-* what the document says; an unparseable file vouches for nothing (the
-* `d4b-spec-shape` pass is what reports it).
-*/
-function collectSpecLiterals(path) {
-	try {
-		return new Set(parseSpecDocument(readText(path), path).fixtures.map((fixture) => fixture.path));
-	} catch {
-		return /* @__PURE__ */ new Set();
-	}
+function keyName(pair) {
+	return isScalar(pair.key) && typeof pair.key.value === "string" ? pair.key.value : null;
 }
-/** Is this a file a domain's assets may be referenced from? */
-function isReferrer(name) {
-	return name.endsWith(".test.ts") || name.endsWith(".spec.yaml");
+function runMaps(file) {
+	const runs = documentMap(file)?.get("runs", true);
+	return isSeq(runs) ? runs.items.filter((item) => isMap(item)) : [];
 }
-function isDir(path) {
-	try {
-		return statSync(path).isDirectory();
-	} catch {
-		return false;
+/** The stream scalars of one run — the values the block-scalar rule judges. */
+function streamScalars(run) {
+	const found = [];
+	for (const pair of pairsOf(run)) {
+		const key = keyName(pair);
+		if (key === null) continue;
+		if ([
+			"stderr",
+			"stdin",
+			"stdout"
+		].includes(key) && isScalar(pair.value)) {
+			found.push({
+				key,
+				scalar: pair.value
+			});
+			continue;
+		}
+		if (key !== "files" || !isMap(pair.value)) continue;
+		for (const entry of pairsOf(pair.value)) {
+			if (!isMap(entry.value)) continue;
+			for (const assertion of pairsOf(entry.value)) if (keyName(assertion) === "equals" && isScalar(assertion.value)) found.push({
+				key: `files.${keyName(entry) ?? "?"}.equals`,
+				scalar: assertion.value
+			});
+		}
 	}
+	return found;
 }
-/** The 1-based line number of a source offset. */
-function lineAt(text, index) {
-	let line = 1;
-	for (let i = 0; i < index && i < text.length; i += 1) if (text[i] === "\n") line += 1;
-	return line;
+function isBlock(scalar) {
+	return String(scalar.type ?? "").startsWith("BLOCK");
 }
 /**
-* Every quoted string and simple template literal in a source. Over-collection
-* only ever *hides* a dead-fixture finding, so a greedy regex is safe here.
+* The canonical order, top level and inside a run: the ground a session stands
+* on before the session, what was given to a command before what came back.
+* Two authors ordering differently make an unreadable diff out of an unchanged
+* document; a `runs:` above `env:` makes a reader meet the session before its
+* setup.
 */
-const STRING_LITERAL = /'(?<single>(?:[^'\\\n]|\\.)*)'|"(?<double>(?:[^"\\\n]|\\.)*)"|`(?<template>(?:[^`$\\]|\\.)*)`/g;
-function collectLiterals(text) {
-	const found = /* @__PURE__ */ new Set();
-	for (const match of text.matchAll(STRING_LITERAL)) {
-		const value = match.groups?.single ?? match.groups?.double ?? match.groups?.template;
-		if (value !== void 0 && value.length > 0) found.add(value);
-	}
-	return found;
+function checkKeyOrder(file, lineAt) {
+	const findings = [];
+	const inspect = (map, order, where) => {
+		let highest = -1;
+		let highestKey = "";
+		for (const pair of pairsOf(map)) {
+			const key = keyName(pair);
+			const rank = key === null ? -1 : order.indexOf(key);
+			if (rank === -1) continue;
+			if (rank < highest) {
+				findings.push(finding("d4b-spec-key-order", lineAt(pair), `"${key}:" comes after "${highestKey}:" in ${where} — the canonical order is ${order.join(", ")} (fixable: \`node dist/checker.js <root> --fix\`)`));
+				return;
+			}
+			highest = rank;
+			highestKey = key ?? "";
+		}
+	};
+	const map = documentMap(file);
+	if (map !== null) inspect(map, DOCUMENT_KEYS, "a spec document");
+	for (const run of runMaps(file)) inspect(run, RUN_KEYS, "a run");
+	return findings;
 }
 /**
-* Does the text pass a NON-literal argument to a fixture-ish verb
-* (`.seed`/`.request`/`.fixture`/`toMatch`)? A template with an expression or a
-* variable makes the reference set incomplete, so the feature is reported at
-* warn level instead of error (a false positive would be worse than a miss).
+* A stream is written as a block scalar (`|` or `|-`), never as a quoted string
+* with `\n` escapes. A one-line golden is unreadable, and no diff can show it:
+* the whole point of the format is that the expected output looks like output.
 */
-const FIXTURE_VERB_ARG = /(?:\.(?:seed|request|fixture)|\btoMatch)\s*\(\s*(?<arg>[^,)]*)/g;
-function hasNonLiteralFixtureArg(text) {
-	for (const match of text.matchAll(FIXTURE_VERB_ARG)) {
-		const arg = (match.groups?.arg ?? "").trim();
-		if (arg.length === 0) continue;
-		if (!(/^'(?:[^'\\\n]|\\.)*'$/.test(arg) || /^"(?:[^"\\\n]|\\.)*"$/.test(arg) || /^`(?:[^`$\\]|\\.)*`$/.test(arg))) return true;
+function checkBlockScalars(file, lineOf) {
+	const findings = [];
+	for (const run of runMaps(file)) for (const { key, scalar } of streamScalars(run)) {
+		if (isBlock(scalar) || scalar.value === "") continue;
+		findings.push(finding("d4b-spec-block-scalar", lineOf(scalar), `${key} is a ${scalar.type === Scalar.PLAIN ? "plain" : "quoted"} scalar — a stream is written as a block scalar (\`|\` keeps the final newline, \`|-\` drops it) (fixable: \`node dist/checker.js <root> --fix\`)`));
 	}
-	return false;
+	return findings;
 }
+const KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** Words the `.spec.yaml` suffix already says — a case name repeating one says nothing. */
+const REDUNDANT_WORDS = /* @__PURE__ */ new Set([
+	"cli",
+	"spec",
+	"test"
+]);
 /**
-* `// checker-disable-next-line <id>[,<id>] -- reason` suppresses the passes
-* named by id (`a7`, `b5`, `c9`, or `*`) on the next non-blank line;
-* `checker-disable-line` suppresses its own line. Mirrors the oxlint-disable
-* idiom the repo already uses for negative specs.
+* The file is `<case>.spec.yaml`, and `<case>` NAMES the case: kebab-case, no
+* word the suffix already carries, and never the bare name of its directory —
+* a `rm/` folder holding `rm.spec.yaml` says nothing twice, where `removed`,
+* `unattended` and `missing` each say one thing.
 */
-function suppressedLines(text, id) {
-	const suppressed = /* @__PURE__ */ new Set();
-	const lines = text.split("\n");
-	const applies = (raw) => {
-		const ids = raw.replace(/--.*$/, "").trim().split(/[\s,]+/);
-		return ids.includes(id) || ids.includes("*");
-	};
-	for (const [index, line] of lines.entries()) {
-		let match = /checker-disable-next-line\s+(?<ids>.*)$/i.exec(line);
-		if (match !== null && applies(match.groups?.ids ?? "")) {
-			for (let next = index + 1; next < lines.length; next += 1) if (lines[next].trim().length > 0) {
-				suppressed.add(next + 1);
-				break;
-			}
-		}
-		match = /checker-disable-line\s+(?<ids>.*)$/i.exec(line);
-		if (match !== null && applies(match.groups?.ids ?? "")) suppressed.add(index + 1);
-	}
-	return suppressed;
-}
-/** From the `(` at `openIndex`, the substring inside the matching `)`. */
-function balancedParens(text, openIndex) {
-	let depth = 0;
-	for (let i = openIndex; i < text.length; i += 1) {
-		const char = text[i];
-		if (char === "(") depth += 1;
-		else if (char === ")") {
-			depth -= 1;
-			if (depth === 0) return text.slice(openIndex + 1, i);
-		}
-	}
-	return text.slice(openIndex + 1);
-}
-/** From the `{` at `openIndex`, the substring inside the matching `}`. */
-function balancedBraces(text, openIndex) {
-	let depth = 0;
-	for (let i = openIndex; i < text.length; i += 1) {
-		const char = text[i];
-		if (char === "{") depth += 1;
-		else if (char === "}") {
-			depth -= 1;
-			if (depth === 0) return text.slice(openIndex + 1, i);
-		}
-	}
-	return null;
-}
-/** Split an object/argument body on its depth-0 commas. */
-function splitTopLevel(body) {
-	const parts = [];
-	let depth = 0;
-	let start = 0;
-	for (let i = 0; i < body.length; i += 1) {
-		const char = body[i];
-		if (char === "{" || char === "(" || char === "[") depth += 1;
-		else if (char === "}" || char === ")" || char === "]") depth -= 1;
-		else if (char === "," && depth === 0) {
-			parts.push(body.slice(start, i));
-			start = i + 1;
-		}
+function checkFileName(rel) {
+	const name = basename(rel);
+	const caseName = name.slice(0, -SPEC_EXTENSION.length);
+	const findings = [];
+	if (!KEBAB.test(caseName)) {
+		findings.push(finding("c12-spec-file-name", 1, `"${name}" — <case> is kebab-case: lowercase words joined by single hyphens`));
+		return findings;
 	}
-	parts.push(body.slice(start));
-	return parts;
+	const redundant = caseName.split("-").filter((word) => REDUNDANT_WORDS.has(word));
+	if (redundant.length > 0) findings.push(finding("c12-spec-file-name", 1, `"${name}" repeats "${redundant[0]}" — the .spec.yaml suffix already says it; name the CASE instead`));
+	const folder = basename(dirname(rel));
+	if (caseName === folder) findings.push(finding("c12-spec-file-name", 1, `"${name}" repeats its directory "${folder}/" — name what this case proves, not where it sits`));
+	return findings;
 }
-/** The destructured export names of a `= await specification.<ctor>(` binding. */
-function runnerExportsOf(text) {
-	const names = /* @__PURE__ */ new Set();
-	const decl = new RegExp(String.raw`\{(?<names>[^}]*)\}\s*=\s*await\s+specification\.(?:${CONSTRUCTORS})\s*\(`, "g");
-	for (const match of text.matchAll(decl)) for (const raw of (match.groups?.names ?? "").split(",")) {
-		const key = raw.split(":")[0].trim();
-		if (key.length > 0 && !NON_RUNNER_BINDINGS.has(key)) names.add(key);
+const MAX_DESCRIPTION = 100;
+/** A first word that is an identifier, not prose — exempt from the lowercase rule. */
+const SYMBOL_WORD = /^[A-Z0-9_]+$/;
+/**
+* The description IS the vitest test title, and it is held to the title rules:
+* one lowercase line of prose, no trailing period, short enough to read in a
+* runner's output. A title that is a paragraph is a comment in the wrong place.
+*/
+function checkDescription(document) {
+	const findings = [];
+	const text = document.description;
+	const line = document.descriptionLine;
+	const at = (message) => finding("j5-spec-description", line, message);
+	if (text.includes("\n")) {
+		findings.push(at("description: is one line — the vitest title, not a paragraph"));
+		return findings;
 	}
-	return names;
-}
-/** The leading callee identifier of an expression (`postgres()` → `postgres`). */
-function leadingCallee(value) {
-	const match = /^(?<callee>[A-Za-z_$][\w$]*)\s*\(/.exec(value.trim());
-	return match === null ? match : match.groups?.callee ?? null;
+	if (text.length > MAX_DESCRIPTION) findings.push(at(`description: is ${text.length} characters — keep it under ${MAX_DESCRIPTION}`));
+	if (text.endsWith(".")) findings.push(at("description: ends with a period — a title is a fragment, not a sentence"));
+	const first = text.split(/\s+/)[0] ?? "";
+	if (/^[A-Z]/.test(text) && !SYMBOL_WORD.test(first)) findings.push(at("description: starts with a capital — a title is lowercase prose"));
+	return findings;
 }
-/** SQL factory count of a `services:` record, or null if non-literal/absent. */
-function sqlDatabaseCount(text) {
-	const keyword = /\bservices\s*:/.exec(text);
-	if (keyword === null) return null;
-	const braceIndex = text.indexOf("{", keyword.index + keyword[0].length);
-	if (braceIndex === -1 || text.slice(keyword.index + keyword[0].length, braceIndex).trim() !== "") return null;
-	const body = balancedBraces(text, braceIndex);
-	if (body === null) return null;
-	let count = 0;
-	for (const pair of splitTopLevel(body)) {
-		if (pair.trim().length === 0) continue;
-		const colon = pair.indexOf(":");
-		if (colon === -1) return null;
-		const callee = leadingCallee(pair.slice(colon + 1).trim());
-		if (callee === null) return null;
-		if (callee === "postgres" || callee === "sqlite" || callee === "mysql") count += 1;
+/** The literals the update writer must have failed to tokenise, and their token. */
+const VOLATILE = [
+	{
+		pattern: /\b(?:127\.0\.0\.1|localhost|0\.0\.0\.0):\d{2,5}\b/,
+		token: "{{url}} (or {{port}})"
+	},
+	{
+		pattern: /(?:^|[\s"'(=])(?:\/private)?\/tmp\//,
+		token: "{{workdir}}"
+	},
+	{
+		pattern: /(?:^|[\s"'(=])\/var\/folders\//,
+		token: "{{workdir}}"
+	},
+	{
+		pattern: /(?:^|[\s"'(=])\/(?:Users|home)\/[^\s"'/]+\//,
+		token: "{{workdir}} or {{path}}"
 	}
-	return count;
-}
-function modelSpecFile(file) {
-	const text = readSource(file);
-	let dockerAware = false;
-	for (const match of text.matchAll(/specification\.cli\s*\(/g)) {
-		const argsOpen = text.indexOf("(", match.index);
-		if (argsOpen !== -1 && /\bdocker\s*:/.test(balancedParens(text, argsOpen))) dockerAware = true;
+];
+/**
+* A stream that pins a loopback port, a temp directory or somebody's home is a
+* golden that passed once, on one machine: the port was free that second, the
+* temp path belonged to that run. It is the exact shape of a value the update
+* writer would have tokenised, which is why finding one means a token was
+* overwritten by hand.
+*/
+function checkVolatileLiterals(document) {
+	const findings = [];
+	for (const stream of assertedStreams(document)) for (const [index, text] of stream.text.split("\n").entries()) for (const { pattern, token } of VOLATILE) {
+		const found = pattern.exec(text);
+		if (found === null) continue;
+		findings.push(finding("d5-spec-volatile-literal", stream.line + index, `"${found[0].trim()}" is a value the next run will not reproduce — write ${token}`));
+		break;
 	}
-	return {
-		dockerAware,
-		file,
-		runnerExports: runnerExportsOf(text),
-		sqlDatabaseCount: sqlDatabaseCount(text)
-	};
-}
-/** Resolve a relative import specifier to a `.ts` path (else undefined). */
-function resolveRelativeImport(fromFile, specifier) {
-	if (!specifier.startsWith(".")) return;
-	return resolve(dirname(fromFile), specifier).replace(/\.js$/, ".ts");
+	return findings;
 }
-/** Every `import { a, b as c } from '…'` binding in a file. */
-function namedImports(text) {
-	const bindings = [];
-	for (const match of text.matchAll(/import\s+(?:type\s+)?\{(?<names>[^}]*)\}\s+from\s+['"](?<source>[^'"]+)['"]/g)) {
-		const source = match.groups?.source ?? "";
-		for (const raw of (match.groups?.names ?? "").split(",")) {
-			const part = raw.trim();
-			if (part.length === 0) continue;
-			const [name, local] = part.split(/\s+as\s+/).map((token) => token.trim());
-			bindings.push({
-				local: local ?? name,
-				name,
-				source
-			});
+const ISO8601 = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})/;
+const UUID = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/;
+/** Everything the document itself FIXED: what it feeds in, and what its fixtures hold. */
+function fixedData(document, dir) {
+	const parts = document.runs.map((run) => run.stdin ?? "");
+	for (const fixture of document.fixtures) {
+		let source;
+		try {
+			source = resolveFixtureSource(fixture.path, dir);
+		} catch {
+			continue;
 		}
+		const visit = (path) => {
+			let stat;
+			try {
+				stat = statSync(path);
+			} catch {
+				return;
+			}
+			if (!stat.isDirectory()) {
+				parts.push(readText(path));
+				return;
+			}
+			for (const entry of readdirSync(path)) visit(join(path, entry));
+		};
+		visit(source);
 	}
-	return bindings;
+	return parts.join("\n");
 }
 /**
-* Docker-aware runner results must be bound with `await using`. The runner
-* identifiers are inferred from the `docker:` option of imported spec files —
-* no hand-maintained runner list, unlike the oxlint rule.
+* A timestamp or a uuid spelled out in a golden is a value nothing fixed —
+* unless the document DID fix it, by feeding it in through `stdin:` or shipping
+* it in a `fixture:`. That carve-out is the whole rule: the defect is not the
+* literal, it is the literal nobody pinned.
 */
-function checkDockerRunnerAwaitUsing(rootDir) {
-	const violations = [];
-	const specFiles = listFiles(rootDir, (path) => path.endsWith(".specification.ts"));
-	const dockerSpecs = /* @__PURE__ */ new Map();
-	for (const file of specFiles) {
-		const model = modelSpecFile(file);
-		if (model.dockerAware && model.runnerExports.size > 0) dockerSpecs.set(file, model);
-	}
-	if (dockerSpecs.size === 0) return violations;
-	for (const testFile of listFiles(rootDir, (path) => path.endsWith(".test.ts"))) {
-		const text = readSource(testFile);
-		const runners = /* @__PURE__ */ new Set();
-		for (const binding of namedImports(text)) {
-			const target = resolveRelativeImport(testFile, binding.source);
-			if ((target === void 0 ? void 0 : dockerSpecs.get(target))?.runnerExports.has(binding.name) === true) runners.add(binding.local);
-		}
-		if (runners.size === 0) continue;
-		const suppressed = suppressedLines(readText(testFile), "b5");
-		for (const match of text.matchAll(/\b(?<kind>await\s+using|const|let|var)\s+[A-Za-z_$][\w$]*\s*=\s*await\s+(?<runner>[A-Za-z_$][\w$]*)\b[^;]*?\.exec\s*\(/g)) {
-			const kind = match.groups?.kind ?? "";
-			const runner = match.groups?.runner ?? "";
-			if (kind.startsWith("await using") || !runners.has(runner)) continue;
-			const line = lineAt(text, match.index);
-			if (suppressed.has(line)) continue;
-			const rel = relative(rootDir, testFile);
-			violations.push({
-				file: rel,
-				line,
-				message: `${rel}:${line}: result of docker-aware runner "${runner}" must be bound with \`await using\` so its containers are disposed (B5 — see docs/10-linting.md)`,
-				severity: "error"
-			});
-		}
+function checkPinnedValues(document, dir) {
+	const findings = [];
+	const streams = assertedStreams(document);
+	if (streams.length === 0) return findings;
+	let fixed = null;
+	for (const stream of streams) for (const [index, text] of stream.text.split("\n").entries()) for (const [pattern, token] of [[ISO8601, "{{iso8601}}"], [UUID, "{{uuid}}"]]) {
+		const found = pattern.exec(text);
+		if (found === null) continue;
+		fixed ??= fixedData(document, dir);
+		if (fixed.includes(found[0])) continue;
+		findings.push(finding("d5w-spec-pinned-value", stream.line + index, `"${found[0]}" is not fixed by any fixture: or stdin: of this document — write ${token}`, "warn"));
 	}
-	return violations;
+	return findings;
 }
-/** Local inline runners a test declares itself (`specification.api(…)`). */
-function localRunnerBindings(text) {
-	const locals = /* @__PURE__ */ new Set();
-	const decl = new RegExp(String.raw`\{(?<names>[^}]*)\}\s*=\s*await\s+specification\.(?:${CONSTRUCTORS})\s*\(`, "g");
-	for (const match of text.matchAll(decl)) for (const raw of (match.groups?.names ?? "").split(",")) {
-		const part = raw.trim();
-		const local = (part.includes(":") ? part.split(":")[1] : part).trim();
-		if (local.length > 0 && !NON_RUNNER_BINDINGS.has(part.split(":")[0].trim())) locals.add(local);
-	}
-	return locals;
+/**
+* A stream whose entire content is `{{any}}` states that the command printed
+* something, or nothing, of any shape — which is what a stream does anyway. The
+* run happens and proves nothing.
+*/
+function checkEmptyAssertions(document) {
+	const findings = [];
+	for (const stream of assertedStreams(document)) if (stream.text.replaceAll("{{any}}", "").trim() === "" && stream.text.includes("{{any}}")) findings.push(finding("j3w-spec-empty-assertion", stream.line, "a stream that is only {{any}} asserts nothing — golden what the command actually printed", "warn"));
+	return findings;
 }
-/** The identifier immediately before a `.seed(`/`.table(` member, if any. */
-function memberObjectIdentifier(text, dotIndex) {
-	const before = text.slice(0, dotIndex);
-	const match = /(?<name>[A-Za-z_$][\w$]*)\s*$/.exec(before);
-	return match === null ? match : match.groups?.name ?? null;
+/**
+* A non-zero exit with neither stream is a CLI that failed without a word — or,
+* far more often, a golden whose author forgot that the words went to stderr.
+* Either way the document does not say WHY the command refused.
+*/
+function checkSilentRefusals(document) {
+	return document.runs.filter((run) => run.exitCode !== 0 && run.stdout === null && run.stderr === null).map((run) => finding("d11w-spec-silent-refusal", run.commandLine, `exit: ${run.exitCode} with no stdout: and no stderr: — golden the words the refusal printed`, "warn"));
 }
-function checkDatabaseProperty(rootDir) {
-	const violations = [];
-	const enforced = /* @__PURE__ */ new Map();
-	for (const file of listFiles(rootDir, (path) => path.endsWith(".specification.ts"))) {
-		const model = modelSpecFile(file);
-		if (model.sqlDatabaseCount !== null && model.sqlDatabaseCount >= 1 && model.runnerExports.size > 0) enforced.set(file, model);
-	}
-	if (enforced.size === 0) return violations;
-	for (const testFile of listFiles(rootDir, (path) => path.endsWith(".test.ts"))) {
-		const text = readSource(testFile);
-		const applicable = /* @__PURE__ */ new Set();
-		for (const binding of namedImports(text)) {
-			const target = resolveRelativeImport(testFile, binding.source);
-			const model = target === void 0 ? void 0 : enforced.get(target);
-			if (model?.runnerExports.has(binding.name) === true) applicable.add(model);
+/** The top-level keys of an object literal, read by depth, not by parsing. */
+function objectKeys(source, from) {
+	const keys = [];
+	let depth = 0;
+	let quote = "";
+	for (let index = from; index < source.length; index += 1) {
+		const char = source[index];
+		if (quote !== "") {
+			if (char === quote && source[index - 1] !== "\\") quote = "";
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "{" || char === "[" || char === "(") {
+			depth += 1;
+			continue;
+		}
+		if (char === "}" || char === "]" || char === ")") {
+			depth -= 1;
+			if (depth === 0) return {
+				end: index,
+				keys
+			};
+			continue;
 		}
-		if (applicable.size !== 1) continue;
-		const count = [...applicable][0].sqlDatabaseCount ?? 0;
-		const locals = localRunnerBindings(text);
-		const suppressed = suppressedLines(readText(testFile), "a7");
-		const rel = relative(rootDir, testFile);
-		for (const match of text.matchAll(/\.(?<verb>seed|table)\s*\(/g)) {
-			const verb = match.groups?.verb ?? "";
-			const object = memberObjectIdentifier(text, match.index);
-			if (object !== null && locals.has(object)) continue;
-			const args = balancedParens(text, text.indexOf("(", match.index));
-			const hasDatabase = /\bdatabase\s*:/.test(args);
-			const line = lineAt(text, match.index);
-			if (suppressed.has(line)) continue;
-			if (count >= 2 && !hasDatabase) violations.push({
-				file: rel,
-				line,
-				message: `${rel}:${line}: .${verb}() must pass { database } — ${count} SQL databases are declared (A7 — see docs/10-linting.md)`,
-				severity: "error"
-			});
-			else if (count === 1 && hasDatabase) violations.push({
-				file: rel,
-				line,
-				message: `${rel}:${line}: .${verb}() must not pass { database } — a single SQL database is declared (A7 — see docs/10-linting.md)`,
-				severity: "error"
-			});
+		if (depth === 1 && /[A-Za-z_$'"]/.test(char)) {
+			const rest = /^(?<quote>['"]?)(?<name>[A-Za-z_$][\w$]*)\k<quote>\s*:/.exec(source.slice(index));
+			if (rest?.groups) {
+				keys.push(rest.groups.name);
+				index += rest[0].length - 1;
+			}
 		}
 	}
-	return violations;
+	return {
+		end: source.length,
+		keys
+	};
 }
-/** Is a top-level conventional-subdir entry referenced by any test literal? */
-function entryReferenced(entry, entryIsDir, literals) {
-	for (const literal of literals) {
-		if (entryIsDir) {
-			if (literal === entry || literal.startsWith(`${entry}/`) || literal.includes(`/${entry}`)) return true;
+/**
+* The `env` and `serve` names registered by the `specification.cli(…)` calls of
+* the nearest directory holding a `*.specification.ts`, read as literals. A
+* directory may declare several runners, and nothing in a document says which
+* one runs it, so their registries are read as a UNION: a name known to any
+* neighbouring runner passes, and only a name known to none is a typo.
+*/
+function registeredNames(dir) {
+	let current = dir;
+	for (;;) {
+		let entries;
+		try {
+			entries = readdirSync(current).filter((name) => name.endsWith(".specification.ts"));
+		} catch {
+			entries = [];
 		}
-		if (literal === entry || literal.includes(entry)) return true;
+		if (entries.length > 0) {
+			const env = /* @__PURE__ */ new Set();
+			const serve = /* @__PURE__ */ new Set();
+			for (const entry of entries) {
+				const text = readText(join(current, entry));
+				for (const call of text.matchAll(/specification\.cli\s*\(/g)) {
+					const open = text.indexOf("{", call.index + call[0].length);
+					if (open === -1) continue;
+					const options = objectKeys(text, open);
+					for (const [key, into] of [["env", env], ["serve", serve]]) {
+						const marker = new RegExp(String.raw`\b${key}\s*:\s*\{`).exec(text.slice(open, options.end));
+						if (marker === null) continue;
+						const at = open + marker.index + marker[0].length - 1;
+						for (const name of objectKeys(text, at).keys) into.add(name);
+					}
+				}
+			}
+			return {
+				env,
+				serve
+			};
+		}
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
 	}
-	return false;
 }
-/** A child named like a conventional subdir but actually a fixture container. */
-function isConventionalSubdir(path) {
-	if (!isDir(path)) return false;
-	if (listFiles(path, (candidate) => candidate.endsWith(".test.ts")).length > 0) return false;
-	let children;
+/**
+* Every bare word of `env:` and every `serve:` name must be a key of a runner
+* registered above the document. A typo (`serve: dashbord`) is a refusal at
+* run time today, one test file into a suite; here it is a line in a lint run.
+*/
+function checkRegisteredNames(document, dir) {
+	if (document.env.length === 0 && document.serve.length === 0) return [];
+	const registered = registeredNames(dir);
+	if (registered === null) return [];
+	const findings = [];
+	for (const token of document.env) if (token.kind === "set" && !registered.env.has(token.name)) findings.push(finding("c8-spec-registered-name", token.line, `env: "${token.name}" is not a registered env set${registered.env.size === 0 ? "" : ` — registered: ${[...registered.env].sort().join(", ")}`}`));
+	for (const entry of document.serve) if (!registered.serve.has(entry.name)) findings.push(finding("c8-spec-registered-name", entry.line, `serve: "${entry.name}" is not a registered server${registered.serve.size === 0 ? "" : ` — registered: ${[...registered.serve].sort().join(", ")}`}`));
+	return findings;
+}
+/**
+* Run every document-conventions pass over one `<case>.spec.yaml`. A document
+* the grammar refuses yields NOTHING here: `d4b-spec-shape` already reported
+* it, and a second cascade of findings about a file nobody can parse only
+* buries the one line that matters.
+*/
+function checkSpecConventions(text, rel, path) {
+	let file;
 	try {
-		children = readdirSync(path, { withFileTypes: true });
+		file = readSpecFile(text, rel);
 	} catch {
-		return false;
+		return [];
 	}
-	return !children.some((child) => child.isDirectory() && CONVENTIONAL_SUBDIRS.has(child.name));
+	const lineAt = (node) => {
+		const range = "range" in node && Array.isArray(node.range) ? node.range : void 0;
+		const key = node.key;
+		const target = range ?? (isScalar(key) && Array.isArray(key.range) ? key.range : void 0);
+		return target === void 0 ? 1 : file.source.lineAt(target[0]);
+	};
+	const dir = dirname(path);
+	return [
+		...checkKeyOrder(file, (pair) => lineAt(pair.key)),
+		...checkBlockScalars(file, (scalar) => lineAt(scalar)),
+		...checkFileName(rel),
+		...checkDescription(file.document),
+		...checkVolatileLiterals(file.document),
+		...checkPinnedValues(file.document, dir),
+		...checkEmptyAssertions(file.document),
+		...checkSilentRefusals(file.document),
+		...checkRegisteredNames(file.document, dir)
+	].map(({ line, message, rule, severity }) => ({
+		file: rel,
+		line,
+		message: `${rel}:${line}: ${message} (${rule} — see docs/10-linting.md)`,
+		severity
+	}));
 }
-function checkDeadFixtures(rootDir) {
+/**
+* J4-spec-description-unique — the description is the test title, and two
+* documents in one directory sharing it make a failing run ambiguous: the
+* reporter names the title, and the reader has two files to open.
+*/
+function checkSpecDescriptionsUnique(rootDir) {
+	const byDirectory = /* @__PURE__ */ new Map();
 	const violations = [];
-	for (const dir of listDirs(rootDir)) {
-		if (basename(dir) === "specs") continue;
-		let entries;
+	for (const path of listSpecFiles(rootDir)) {
+		let document;
 		try {
-			entries = readdirSync(dir, { withFileTypes: true });
+			document = readSpecFile(readText(path), path).document;
 		} catch {
 			continue;
 		}
-		const convSubdirs = entries.filter((entry) => entry.isDirectory() && CONVENTIONAL_SUBDIRS.has(entry.name) && isConventionalSubdir(join(dir, entry.name))).map((entry) => entry.name);
-		if (convSubdirs.length === 0) continue;
-		const feature = basename(dir);
-		const testFiles = entries.filter((entry) => entry.isFile() && isReferrer(entry.name)).map((entry) => join(dir, entry.name));
-		const rel = relative(rootDir, dir);
-		if (testFiles.length === 0) {
-			violations.push({
-				file: rel,
-				line: 1,
-				message: `${rel}: domain directory has conventional subdirs (${convSubdirs.join(", ")}) but no *.test.ts or *.spec.yaml (C9 — see docs/10-linting.md)`,
-				severity: "error"
-			});
+		const dir = dirname(path);
+		const seen = byDirectory.get(dir) ?? /* @__PURE__ */ new Map();
+		byDirectory.set(dir, seen);
+		const first = seen.get(document.description);
+		const rel = relative(rootDir, path);
+		if (first === void 0) {
+			seen.set(document.description, rel);
 			continue;
 		}
-		const literals = /* @__PURE__ */ new Set();
-		let downgrade = false;
-		for (const testFile of testFiles) {
-			if (testFile.endsWith(".spec.yaml")) {
-				for (const literal of collectSpecLiterals(testFile)) literals.add(literal);
-				continue;
-			}
-			const text = readSource(testFile);
-			for (const literal of collectLiterals(text)) literals.add(literal);
-			downgrade ||= hasNonLiteralFixtureArg(text);
-		}
-		const severity = downgrade ? "warn" : "error";
-		for (const sub of convSubdirs) {
-			const subPath = join(dir, sub);
-			for (const entry of readdirSync(subPath, { withFileTypes: true })) {
-				const entryIsDir = entry.isDirectory();
-				if (entryReferenced(entry.name, entryIsDir, literals)) continue;
-				const relEntry = relative(rootDir, join(subPath, entry.name));
-				violations.push({
-					file: relEntry,
-					line: 1,
-					message: `${relEntry}: dead fixture — no test literal in ${feature} references ${sub}/${entry.name} (C9 — see docs/10-linting.md)`,
-					severity
-				});
-			}
-		}
+		violations.push({
+			file: rel,
+			line: document.descriptionLine,
+			message: `${rel}:${document.descriptionLine}: "${document.description}" is already the description of ${first} — two documents of one directory cannot share a title (j4-spec-description-unique — see docs/10-linting.md)`,
+			severity: "error"
+		});
 	}
-	violations.push(...checkPoolFixtures(rootDir));
 	return violations;
 }
-/** Unreferenced top-level entries of a `$FIXTURES` pool (`specs/fixtures`). */
-function checkPoolFixtures(rootDir) {
-	const violations = [];
-	for (const pool of findPools(rootDir)) {
-		const specsRoot = dirname(pool);
-		const literals = /* @__PURE__ */ new Set();
-		for (const file of listFiles(specsRoot, (path) => path.endsWith(".ts") || path.endsWith(".spec.yaml"))) {
-			if (file.startsWith(`${pool}/`) || file.startsWith(`${pool}\\`)) continue;
-			const found = file.endsWith(".spec.yaml") ? collectSpecLiterals(file) : collectLiterals(readSource(file));
-			for (const literal of found) literals.add(literal);
-		}
-		for (const entry of readdirSync(pool, { withFileTypes: true })) if (![...literals].some((literal) => literal.includes(entry.name))) {
-			const relEntry = relative(rootDir, join(pool, entry.name));
-			violations.push({
-				file: relEntry,
-				line: 1,
-				message: `${relEntry}: dead pool fixture — no spec under ${relative(rootDir, specsRoot)} references $FIXTURES/${entry.name} (C9 — see docs/10-linting.md)`,
-				severity: "error"
-			});
+/**
+* Apply the two fixable passes to one document: reorder its keys, and re-style
+* every stream as a block scalar. Returns `null` when nothing moved — the
+* caller writes only what changed, so a clean tree keeps its mtimes.
+*/
+function fixSpecDocument(text, rel) {
+	let file;
+	try {
+		file = readSpecFile(text, rel);
+	} catch {
+		return null;
+	}
+	const reorder = (map, order) => {
+		const sorted = [...pairsOf(map).filter((pair) => order.includes(keyName(pair) ?? ""))].sort((a, b) => order.indexOf(keyName(a)) - order.indexOf(keyName(b)));
+		let cursor = 0;
+		map.items = pairsOf(map).map((pair) => order.includes(keyName(pair) ?? "") ? sorted[cursor++] : pair);
+	};
+	const map = documentMap(file);
+	if (map === null) return null;
+	reorder(map, DOCUMENT_KEYS);
+	for (const run of runMaps(file)) {
+		reorder(run, RUN_KEYS);
+		for (const { scalar } of streamScalars(run)) if (!isBlock(scalar) && scalar.value !== "") scalar.type = Scalar.BLOCK_LITERAL;
+	}
+	const next = renderYamlSource(file.source);
+	return next === text ? null : next;
+}
+/** Fix every `<case>.spec.yaml` under `rootDir`; returns the paths rewritten. */
+function fixSpecFiles(rootDir) {
+	const written = [];
+	for (const path of listSpecFiles(rootDir)) {
+		const next = fixSpecDocument(readText(path), relative(rootDir, path));
+		if (next !== null) {
+			writeFileSync(path, next);
+			written.push(relative(rootDir, path));
 		}
 	}
-	return violations;
+	return written;
 }
 //#endregion
 //#region src/lint/checker.ts
@@ -1057,14 +1234,14 @@ function checkPoolFixtures(rootDir) {
 * The conventions checker — the non-oxlint static channel.
 *
 * Oxlint only visits JS/TS sources; the D4 token grammar also constrains the
-* DATA fixtures under `expected/**` and `requests/**`. This module walks a specs
+* DATA fixtures under `_expected/**` and `_requests/**`. This module walks a specs
 * tree and reports:
 *
-* - **unknown / malformed tokens** in `expected/` fixtures — any text file, not
+* - **unknown / malformed tokens** in `_expected/` fixtures — any text file, not
 *   just `.http`/`.json`/`.txt` (D4);
-* - the **HTTP first-line grammar** of depth-1 `requests/*.http` (a request line)
-*   and `expected/*.http` (a status line) (D4b);
-* - **tokens leaking into `requests/`** — requests are inputs, never matched, so
+* - the **HTTP first-line grammar** of depth-1 `_requests/*.http` (a request line)
+*   and `_expected/*.http` (a status line) (D4b);
+* - **tokens leaking into `_requests/`** — requests are inputs, never matched, so
 *   a `{{token}}` there is almost always a mistake (D10, warning);
 * - the **`<case>.spec.yaml` grammar** wherever a scenario document sits: its
 *   shape (D4b), read through the runner's own parser, plus the token
@@ -1082,16 +1259,16 @@ const BRACE_BLOCK = /\{\{(?<inner>[^{}]*)\}\}/g;
 const LEADING_WORD = /^(?<kind>[A-Za-z][A-Za-z0-9]*)/;
 const KNOWN = new Set(TOKEN_KINDS);
 /** Directories whose files carry the token grammar (D4). */
-const FIXTURE_DIRS = /* @__PURE__ */ new Set(["expected", "requests"]);
+const FIXTURE_DIRS = /* @__PURE__ */ new Set([GROUND_EXPECTED, GROUND_REQUESTS]);
 /**
-* Directories the walk never enters. `fixtures/` trees (the shared pool and
-* feature-local ones) are verbatim `.fixture()` cwd material — file STATE, not
+* Directories the walk never enters. `_fixtures/` trees (the shared pool and
+* the leaf-local ones) are verbatim `.fixture()` cwd material — file STATE, not
 * assertion fixtures — so the token grammar has no meaning inside them.
 */
 const SKIPPED_DIRS = /* @__PURE__ */ new Set([
 	".git",
 	"dist",
-	"fixtures",
+	GROUND_FIXTURES,
 	"node_modules"
 ]);
 /**
@@ -1120,7 +1297,7 @@ function findUnknownTokens(text) {
 	}
 	return violations;
 }
-/** Known tokens present in a text — for the `requests/` leak warning (D10). */
+/** Known tokens present in a text — for the `_requests/` leak warning (D10). */
 function findKnownTokens(text) {
 	const found = [];
 	const lines = text.split("\n");
@@ -1217,20 +1394,20 @@ function checkConventionFiles(rootDir) {
 			}
 			if (inside === null) continue;
 			const depth1 = dir.endsWith(`/${inside}`) || dir.endsWith(`\\${inside}`);
-			if (inside === "requests") {
+			if (inside === "_requests") {
 				if (!entry.name.endsWith(".http")) continue;
 				const text = decodeText(path);
 				if (text === null) continue;
 				if (depth1 && !REQUEST_LINE.test(firstLine(text))) violations.push({
 					file: rel,
 					line: 1,
-					message: `${rel}:1: a requests/*.http file must start with a request line "METHOD /path" (D4b — see docs/10-linting.md)`,
+					message: `${rel}:1: a _requests/*.http file must start with a request line "METHOD /path" (D4b — see docs/10-linting.md)`,
 					severity: "error"
 				});
 				for (const { line, token } of findKnownTokens(text)) violations.push({
 					file: rel,
 					line,
-					message: `${rel}:${line}: token ${token} in a requests/ file — requests are inputs, never matched; tokens are not validated here (D10 — see docs/10-linting.md)`,
+					message: `${rel}:${line}: token ${token} in a _requests/ file — requests are inputs, never matched; tokens are not validated here (D10 — see docs/10-linting.md)`,
 					severity: "warn",
 					token
 				});
@@ -1241,7 +1418,7 @@ function checkConventionFiles(rootDir) {
 			if (depth1 && entry.name.endsWith(".http") && !STATUS_LINE.test(firstLine(text))) violations.push({
 				file: rel,
 				line: 1,
-				message: `${rel}:1: an expected/*.http file must start with a status line "HTTP/1.1 <status>" (D4b — see docs/10-linting.md)`,
+				message: `${rel}:1: an _expected/*.http file must start with a status line "HTTP/1.1 <status>" (D4b — see docs/10-linting.md)`,
 				severity: "error"
 			});
 			for (const { line, token } of findUnknownTokens(text)) violations.push({
@@ -1258,14 +1435,17 @@ function checkConventionFiles(rootDir) {
 }
 /**
 * Run every checker pass over `rootDir`: the token/HTTP grammar passes (D4 /
-* D4b / D10) plus the cross-file passes (C9 dead fixtures, B5 await-using
-* inference, A7 database property). This is the entry the bundled bin drives.
+* D4b / D10) plus the cross-file passes (C9 dead fixtures, C14/C15 fixture
+* placement, B5 await-using inference, A7 database property). This is the entry
+* the bundled bin drives.
 */
 function runAllChecks(rootDir) {
 	return [
 		...checkConventionFiles(rootDir),
 		...checkSpecDescriptionsUnique(rootDir),
 		...checkDeadFixtures(rootDir),
+		...checkPoolFixtureSharing(rootDir),
+		...checkLocalFixtureReach(rootDir),
 		...checkDockerRunnerAwaitUsing(rootDir),
 		...checkDatabaseProperty(rootDir)
 	];
@@ -1283,12 +1463,15 @@ function formatViolations(violations) {
 *
 * Runs every checker pass — the token/HTTP grammar (D4 / D4b / D10), the
 * `<case>.spec.yaml` document conventions, and the cross-file passes (C9 dead
-* fixtures, B5 await-using inference, A7 database property). Exit 1 on any
-* ERROR-level violation; warnings (D10, a downgraded C9 feature) are printed
-* but do not fail the run.
+* fixtures, C14/C15 fixture placement, B5 await-using inference, A7 database
+* property). Exit 1 on any ERROR-level violation; warnings (D10, a downgraded C9
+* feature) are printed but do not fail the run.
 *
-* `--fix` first applies the two rewritable document passes (key order and block
-* scalars), then checks what is left — so a run that fixes everything exits 0.
+* `--fix` applies the rewritable passes — the two document ones (key order and
+* block scalars) and C14, which MOVES a single-reader pool fixture beside its
+* leaf and rewrites the literals that named it — then checks what is left, so a
+* run that fixes everything exits 0. The move is a plain rename: the checker
+* never runs git, and the author stages what the working tree now shows.
 */
 const fix = process.argv.includes("--fix");
 const root = resolve(process.argv.slice(2).find((arg) => !arg.startsWith("--")) ?? ".");
@@ -1299,6 +1482,7 @@ if (!existsSync(root) || !statSync(root).isDirectory()) {
 if (fix) {
 	const written = fixSpecFiles(root);
 	if (written.length > 0) console.log(`conventions checker: rewrote ${written.length} spec document(s)`);
+	for (const move of fixPoolFixtures(root)) console.log(`conventions checker: moved ${move} (C14) — stage the rename`);
 }
 const violations = runAllChecks(root);
 const errors = violations.filter((violation) => violation.severity === "error");
@@ -1307,6 +1491,6 @@ if (errors.length > 0) {
 	console.error(`\nconventions checker: ${errors.length} error(s) found under ${root}`);
 	process.exit(1);
 }
-console.log(`conventions checker: all passes clean under ${root} (D4/D4b/D10 grammar, spec documents, C9 dead fixtures, B5 await-using, A7 database)${violations.length > 0 ? ` — ${violations.length} warning(s)` : ""}`);
+console.log(`conventions checker: all passes clean under ${root} (D4/D4b/D10 grammar, spec documents, C9 dead fixtures, C14/C15 fixture placement, B5 await-using, A7 database)${violations.length > 0 ? ` — ${violations.length} warning(s)` : ""}`);
 //#endregion
 export {};