@junghanacs/entwurf 0.13.0 → 0.14.0

package/scripts/check-resume-launch-identity.ts

@@ -0,0 +1,244 @@
+/**
+ * check-resume-launch-identity — deterministic gate for `resume-launch-identity.ts`, the
+ * record-authoritative leaf preserved when the visible-first cut deleted `spawn-bg` and every
+ * caller it had.
+ *
+ * WHY A GATE FOR A CONSUMER-ZERO MODULE. Identity authority is a fail-closed risk class: this
+ * leaf's whole job is deciding WHICH being a resume turn lands in. A preserved leaf whose only
+ * guarantee is its own header comment is exactly the rot preservation was meant to prevent — it
+ * would be re-adopted, months later, by a visible-resume composition that trusts prose. The cells
+ * below are transplanted from the deleted `check-entwurf-v2-spawn-production` §9 (the plan
+ * parameter became a bare garden id; nothing else about the identity contract changed), plus one
+ * new cell for the #52 read the leaf's header claims and the deleted gate never isolated.
+ *
+ * What is certified, all through a temp `ENTWURF_META_SESSIONS_DIR` fixture store:
+ *
+ *   1. HAPPY — gardenId → record.transcriptPath → header id === record.nativeSessionId →
+ *      LaunchIdentity carrying the header's own cwd/provider/model (#50 C2, #9).
+ *   2. C3 INTEGRITY — a transcript whose header id is NOT this citizen's `nativeSessionId` is
+ *      refused, never resumed. This is the one that keeps a turn out of another being's session.
+ *   3. #52 ADDRESSABLE READ — a garden id that does not hold its `nativeSessionId` ALONE is
+ *      refused. Two records sharing one native session would each pass their own per-record
+ *      integrity check and resume one transcript twice under two per-garden-id locks, so the
+ *      plain targeted read is not enough here and the leaf must not be "simplified" back to it.
+ *   4. CAUSE FIDELITY — each impossible resume names ITS OWN cause: absent record, out-of-domain
+ *      backend, no recorded transcript, recorded-but-missing file, no model, headerless file. The
+ *      missing-file cell is a regression pin: before the existence check that case fell through
+ *      `readSessionIdentity`'s ENOENT swallow and lied "no recorded model".
+ *   4b. THE ONE EXPECTED REFUSAL — a backend with no same-id resume is not a defect at all: the
+ *      record is fine and the operator reached past a capability boundary. It alone carries a
+ *      TYPED reason (`target-not-pi`) so the visible-resume composition can match a FIELD instead
+ *      of parsing a sentence or re-reading the record. Everything else here stays a bare throw.
+ *   4c. ABSOLUTE TRANSCRIPT — a relative recorded path would resolve against the WINDOW's own cwd
+ *      at launch, not against this process's, so it names a different file than the one checked
+ *      here. Refused before anything opens.
+ *   5. SSOT — the module header names THIS gate, so the preserved leaf cannot advertise a
+ *      certification that does not exist.
+ *
+ * No spawn, no socket, no timer: the launch this identity feeds is deliberately not in scope.
+ */
+
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { serializeMetaIdentity, upsertMetaSession } from "../pi-extensions/lib/meta-session.ts";
+import {
+	ResumeBackendUnsupportedError,
+	resolveResumeLaunchIdentity,
+} from "../pi-extensions/lib/resume-launch-identity.ts";
+
+let passed = 0;
+function ok(label: string, cond: boolean): void {
+	assert.ok(cond, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+
+const HERE = path.dirname(new URL(import.meta.url).pathname);
+const REPO = path.join(HERE, "..");
+const LEAF_SRC = path.join(REPO, "pi-extensions/lib/resume-launch-identity.ts");
+
+function main(): void {
+	const world = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), "resume-launch-id-"));
+	const storeDir = path.join(world, "meta-sessions");
+	fs.mkdirSync(storeDir, { recursive: true });
+	const prevStore = process.env.ENTWURF_META_SESSIONS_DIR;
+	process.env.ENTWURF_META_SESSIONS_DIR = storeDir;
+	try {
+		const cwd = path.join(world, "repo");
+		fs.mkdirSync(cwd, { recursive: true });
+		const sessionLine = (id: string) => `${JSON.stringify({ type: "session", id, cwd })}\n`;
+		const modelLine = `${JSON.stringify({ type: "model_change", provider: "openai-codex", modelId: "gpt-5.4" })}\n`;
+		const writeTranscript = (name: string, content: string): string => {
+			const p = path.join(world, name);
+			fs.writeFileSync(p, content);
+			return p;
+		};
+		const mintRecord = (nativeSessionId: string, transcriptPath: string | null, backend = "pi"): string =>
+			upsertMetaSession({
+				input: { backend: backend as "pi", nativeSessionId, cwd, model: "gpt-5.4", transcriptPath },
+				dir: storeDir,
+			}).record.gardenId;
+		const rejects = (gid: string, needle: string, label: string): void => {
+			let msg = "";
+			try {
+				resolveResumeLaunchIdentity(gid);
+			} catch (e) {
+				msg = e instanceof Error ? e.message : String(e);
+			}
+			ok(label, msg.includes(needle));
+		};
+
+		// ── 1. HAPPY ──────────────────────────────────────────────────────────────
+		const nativeOk = "0199aaaa-1111-4222-8333-444455556666";
+		const fileOk = writeTranscript("own.jsonl", sessionLine(nativeOk) + modelLine);
+		const gidOk = mintRecord(nativeOk, fileOk);
+		const launch = resolveResumeLaunchIdentity(gidOk);
+		ok("1: record-backed resume resolves the recorded transcript", launch.sessionFile === fileOk);
+		ok("1: resume cwd = transcript header authority (#9 cold-resume)", launch.cwd === cwd);
+		ok(
+			"1: resume model/provider = first model_change",
+			launch.model === "gpt-5.4" && launch.provider === "openai-codex",
+		);
+		// (No arity/shape assertion here on purpose: "the garden id is the only input" is carried
+		// by the type system and by every cell below actually resolving through the record.
+		// A `fn.length === 1` check would be a claim whose mutant could only be synthetic.)
+
+		// ── 2. C3 INTEGRITY — header id must be THIS citizen's ────────────────────
+		const nativeMine = "0199bbbb-1111-4222-8333-444455556666";
+		const foreignFile = writeTranscript(
+			"foreign.jsonl",
+			sessionLine("0199cccc-9999-4999-8999-999999999999") + modelLine,
+		);
+		const gidForeign = mintRecord(nativeMine, foreignFile);
+		rejects(
+			gidForeign,
+			"does not match the record's nativeSessionId",
+			"2: header ≠ nativeSessionId → refused, never resumed (C3) [QK:RESUME-ID-HEADER-INTEGRITY]",
+		);
+
+		// ── 4. CAUSE FIDELITY ─────────────────────────────────────────────────────
+		rejects("20260101T000000-facade", "not a garden citizen", "4: recordless gid → not a citizen");
+
+		const gidClaude = mintRecord("claude-native-1", null, "claude-code");
+		rejects(
+			gidClaude,
+			"is a claude-code citizen",
+			"4: out-of-domain citizen → refused as a capability-domain miss, not as citizen rank",
+		);
+		// This one refusal is EXPECTED, not a defect: the record is perfectly good and the operator
+		// has reached past a capability boundary. So it is the only failure here that carries a
+		// typed `reason` a caller can match on a FIELD — the visible-resume composition turns it
+		// into `target-not-pi`, and if it degraded to a bare Error that caller would either parse
+		// this sentence or read the record a second time to ask which backend it was.
+		{
+			let caught: Error | null = null;
+			try {
+				resolveResumeLaunchIdentity(gidClaude);
+			} catch (err) {
+				caught = err as Error;
+			}
+			ok(
+				"4: the backend miss is a TYPED refusal carrying reason + backend, not a bare Error [QK:RESUME-ID-BACKEND-TYPED-REFUSAL]",
+				caught instanceof ResumeBackendUnsupportedError &&
+					caught.reason === "target-not-pi" &&
+					caught.backend === "claude-code",
+			);
+		}
+
+		// A RELATIVE recorded path passes existsSync here whenever this process happens to sit in
+		// the right directory, but the launch resolves `--session` inside the window's own
+		// `-c <record cwd>`. Two directories, two files, one receipt that looks correct — so the
+		// leaf refuses before anything opens rather than resuming an unknown transcript.
+		{
+			const nativeRel = "0199ffff-1111-4222-8333-444455556666";
+			writeTranscript("relative.jsonl", sessionLine(nativeRel) + modelLine);
+			const gidRel = mintRecord(nativeRel, "relative.jsonl");
+			rejects(
+				gidRel,
+				"RELATIVE transcriptPath",
+				"4: a relative recorded transcriptPath → refused before launch, because --session would resolve against the WINDOW's cwd, not this one [QK:RESUME-ID-SESSION-ABSOLUTE]",
+			);
+		}
+
+		const gidNoFile = mintRecord("0199dddd-1111-4222-8333-444455556666", null);
+		rejects(gidNoFile, "no recorded transcriptPath", "4: transcriptPath null → nothing to resume");
+
+		// Regression pin (F7): before the existsSync guard this fell through readSessionIdentity's
+		// ENOENT swallow and reported "no recorded model" — a true refusal naming a false cause,
+		// which sends an operator to look for a model setting instead of a deleted transcript.
+		const gidGhost = mintRecord("0199abcd-1111-4222-8333-444455556666", path.join(world, "never-written.jsonl"));
+		rejects(
+			gidGhost,
+			"does not exist on disk",
+			"4: recorded transcript missing on disk → refused as MISSING, not as no-model [QK:RESUME-ID-MISSING-TRANSCRIPT-CAUSE]",
+		);
+
+		const nativeNoModel = "0199eeee-1111-4222-8333-444455556666";
+		const fileNoModel = writeTranscript("no-model.jsonl", sessionLine(nativeNoModel));
+		const gidNoModel = mintRecord(nativeNoModel, fileNoModel);
+		rejects(gidNoModel, "no recorded model", "4: no model_change → refused (model preservation)");
+
+		// A headerless transcript has an UNDEFINED header id, which can never equal the record's
+		// nativeSessionId — so the integrity check catches it and says "(none)" rather than
+		// resuming a file whose ownership was never stated.
+		const nativeNoHeader = "0199ffff-1111-4222-8333-444455556666";
+		const fileNoHeader = writeTranscript("no-header.jsonl", modelLine);
+		const gidNoHeader = mintRecord(nativeNoHeader, fileNoHeader);
+		rejects(gidNoHeader, '"(none)"', "4: headerless transcript → refused as (none), never resumed");
+
+		// ── 3. #52 ADDRESSABLE READ ───────────────────────────────────────────────
+		// Planted LAST so the duplicate cannot disturb the cells above: a store-wide uniqueness
+		// scan sees every record, and `upsertMetaSession` would attach to the existing garden id
+		// rather than mint a rival, so the rival record is written directly.
+		const rivalGid = "20260301T120009-a1b2c3";
+		fs.writeFileSync(
+			path.join(storeDir, `${rivalGid}.meta.json`),
+			serializeMetaIdentity({
+				schemaVersion: 3,
+				gardenId: rivalGid,
+				backend: "pi",
+				nativeSessionId: nativeOk, // the SAME native session as gidOk
+				cwd,
+				model: "gpt-5.4",
+				transcriptPath: fileOk,
+				createdAt: "2026-03-01T12:00:00.000Z",
+				recordUpdatedAt: "2026-03-01T12:30:00.000Z",
+			}),
+		);
+		// The happy-path id resolved a moment ago; the ONLY thing that changed is a second record
+		// claiming its native session. If this leaf used the plain targeted read, that resolve
+		// would still succeed and two garden ids would resume one transcript under two locks.
+		rejects(
+			gidOk,
+			"must be unique",
+			"3: a garden id that no longer holds its nativeSessionId alone → refused by the ADDRESSABLE read [QK:RESUME-ID-ADDRESSABLE-READ]",
+		);
+		rejects(
+			rivalGid,
+			"must be unique",
+			"3: …refused from EITHER side of the pair (neither rival is silently preferred)",
+		);
+	} finally {
+		if (prevStore === undefined) delete process.env.ENTWURF_META_SESSIONS_DIR;
+		else process.env.ENTWURF_META_SESSIONS_DIR = prevStore;
+		fs.rmSync(world, { recursive: true, force: true });
+	}
+
+	// ── 5. SSOT — the leaf's header must name the gate that actually certifies it ──
+	{
+		const src = fs.readFileSync(LEAF_SRC, "utf8");
+		ok(
+			"5: the leaf's header names check-resume-launch-identity (no certification it does not have) [QK:RESUME-ID-GATE-SSOT]",
+			src.includes("`check-resume-launch-identity`"),
+		);
+		// The preservation is deliberate and stated: a reader who finds an uncalled export must
+		// be able to tell "kept on purpose, for the visible lane" from "forgotten".
+		ok("5: the leaf states it is preserved with no consumer, on purpose", /no consumer in the shipped tree/.test(src));
+	}
+
+	console.log(`\ncheck-resume-launch-identity: ${passed} checks passed`);
+}
+
+main();

package/scripts/check-socket-discovery.ts

@@ -291,7 +291,7 @@ async function main(): Promise<void> {
 	}
 
 	// ── inspectControlSocketPath (5c-3c R1 — the path-addressed SSOT) ────────────────
-	// The 5c-3 spawn-bg watcher observes plan.expectedSocketPath and MUST inspect THAT exact
+	// A resume watcher observes an expected socket path and MUST inspect THAT exact
 	// path (no gid re-derivation). Proves the path-taking core classifies every branch
 	// identically to the gid wrapper, and that the wrapper just feeds it controlSocketPath(gid).
 	{

package/scripts/fixtures/mux-parent-transcript.scrubbed.jsonl

@@ -0,0 +1,3 @@
+{"type":"fixture-provenance","note":"Structure extracted from a fixture-only real Pi parent retake (2026-08-06) and then scrubbed: a real record-backed pi citizen called the native entwurf_fresh_call once, and the fresh sibling's nonce callback arrived in that parent's own transcript. MEASURED and preserved: pi records NO separate toolCall row — the call surfaces as a toolResult row carrying toolCallId + toolName, and the callback arrives later as a custom_message of customType entwurf-message whose body embeds a <sender_info> JSON envelope. Event order, roles, content types, toolName, the nonce flowing from the launch receipt into the callback body, and the sender_info FIELD NAMES are real. Every id, uuid, toolCallId, timestamp, model, path, cwd and message body is a fixture value. This is a sample of the PARENT-SIDE SHAPE — it is NOT placement evidence and says nothing about whether a window opened."}
+{"type":"message","id":"0199f000-0000-7000-8000-000000000000-1","parentId":"0199f000-0000-7000-8000-000000000000-0","timestamp":"2026-01-01T00:00:00.000Z","message":{"role":"toolResult","toolCallId":"fixture-toolcall-1","toolName":"entwurf_fresh_call","content":[{"type":"text","text":"[entwurf fresh call →]\n  backend:  pi (/fixture/bin/pi)\n  model:    fixture-provider/fixture-model (requested on the runtime CLI)\n  window:   @2 (index 2) in session $0\n  pane:     %2 pid 4242\n  nonce:    mux-fresh-call-000000000000000000000000\n\nThis is a LAUNCH receipt: tmux created that window and was asked to start the runtime with the model above. It does NOT mean the sibling is running, that its first turn ran, or that the task was delivered.\nThe sibling's garden id arrives separately — it calls entwurf_v2 back with the nonce above as its first action, and the sender envelope of THAT message is the address. Nothing is polling for it; if it never comes, the window is visible and can be read directly."}],"details":{"isError":false},"isError":false,"timestamp":1767225600000}}
+{"type":"custom_message","customType":"entwurf-message","content":"mux-fresh-call-000000000000000000000000\n\n<sender_info>{\"sessionId\":\"20260101T000001-bbbbbb\",\"agentId\":\"fixture-provider/fixture-model\",\"cwd\":\"/fixture/project\",\"timestamp\":\"2026-01-01T00:00:00.000Z\",\"origin\":\"pi-session\",\"replyable\":true}</sender_info>","display":true,"id":"0199f000-0000-7000-8000-000000000000-2","parentId":"0199f000-0000-7000-8000-000000000000-1","timestamp":"2026-01-01T00:00:00.000Z"}

package/scripts/inventory-verification-surface.ts

@@ -0,0 +1,349 @@
+/**
+ * inventory-verification-surface — Phase 0 of issue #62 (vitest adoption).
+ *
+ * The issue's own measurements shifted with the glob used; this script FIXES the
+ * denominator. Review (2026-08-07) found the first cut mis-measured the migration
+ * itself, so the denominator is now BOTH verification axes together:
+ *
+ *   legacy axis     scripts/  (hand-built gates, lib, mutants, fixtures)
+ *   framework axis  test/ + vitest.config.ts  (vitest-managed lanes)
+ *
+ * both from `git ls-files --cached --others --exclude-standard` (tracked plus
+ * untracked-non-ignored — the same work surface qualification hashes), so moving a
+ * gate from scripts/ into test/ moves lines BETWEEN axes and the combined total
+ * stays honest: migration is not subtraction unless the combined number drops.
+ *
+ * PRIMARY classification is the issue's own six semantic classes, decided by the
+ * first matching rule below (re-derivable; narrow explicit overrides carry a
+ * reason and are printed). `unclassified` is asserted to be ZERO — a file no rule
+ * reaches is a loud error, never a silent bucket:
+ *
+ *   1 real-live             name *-live.* OR gates on LIVE=1 (needs real
+ *                           accounts/models/tmux; smoke-*-install-state is NOT
+ *                           live — it matches rule 2 first by name)
+ *   2 package-install       name carries pack|install (tarball/install surface)
+ *   3 hermetic-integration  spawns a subprocess, stands a local server, or is a
+ *                           .sh gate — real processes, no external accounts
+ *   4 source-topology       reads product source as text WITHOUT importing it
+ *   5 behavioral-contract   imports and executes product code, with fs/fixtures
+ *                           or auxiliary source reads
+ *   6 pure-unit             imports and executes product code, no fs, no text
+ *                           reads, no processes
+ *
+ * The SECONDARY style axis (imports-product / source-text / subprocess / mixed /
+ * shell / other) is the issue's measurement table, kept for continuity with the
+ * recorded e405d64 baseline snapshot — style describes HOW a gate is written,
+ * the six classes describe WHAT it proves.
+ *
+ * A test/*.test.ts file is classified together with the ./helpers/* bodies it
+ * imports: the helper is part of how that lane earns its green (a bridge boot
+ * hidden in a helper still makes the lane an integration lane).
+ *
+ * Plus the mutant inventory per lane, split by whether the mutant's SUBJECT is
+ * product code or the verification surface itself (scripts/).
+ *
+ * Read-only and not a gate: it never writes; its one assertion (unclassified=0)
+ * exists so the classification cannot silently rot. Phase 1–4 decisions cite this
+ * one reproducible table instead of ad-hoc greps.
+ */
+
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function git(args: string[]): string {
+	return execFileSync("git", args, { cwd: REPO_DIR, encoding: "utf8" });
+}
+
+function listWorkSurface(pathspec: string[]): string[] {
+	return [
+		...new Set(
+			git(["ls-files", "--cached", "--others", "--exclude-standard", "--", ...pathspec])
+				.split("\n")
+				.filter((f) => f.length > 0 && fs.existsSync(path.join(REPO_DIR, f))),
+		),
+	].sort();
+}
+
+const legacyFiles = listWorkSurface(["scripts/"]);
+const frameworkFiles = listWorkSurface(["test/", "vitest.config.ts"]);
+
+function countLines(rel: string): number {
+	const body = fs.readFileSync(path.join(REPO_DIR, rel), "utf8");
+	if (body.length === 0) return 0;
+	return body.split("\n").length - (body.endsWith("\n") ? 1 : 0);
+}
+
+// ── rule predicates (printed, so every number is re-derivable) ───────────────
+const H_IMPORTS = /(?:from\s+["']|import\(\s*["'])(?:\.\.\/)+(?:pi-extensions|mcp)\//;
+const H_TEXT = /readFileSync[^\n]*(?:pi-extensions|mcp\/|\.ts["'`]|SOURCE|SRC)|\bread\(["'](?:pi-extensions|mcp)\//;
+const H_PROC = /\b(?:spawn|spawnSync|execFile|execFileSync|execSync|fork)\s*\(|subprocess\.(?:run|Popen|check_)/;
+const H_NET = /\b(?:http|net)\.createServer|\.listen\(/;
+const H_FS = /from\s+["']node:fs["']|require\(["']node:fs["']\)/;
+// H_LIVE asks whether the file's OWN CODE reads the LIVE switch — not whether the
+// three letters appear. The naive `\bLIVE=1\b` form classified
+// scripts/check-release-gate-outcomes.ts as real-live because that gate QUOTES the
+// sentence "a CUT needs LIVE=1, SKIP=0" and greps other files for the literal
+// "process.env.LIVE"; it spawns no live turn of its own. So the predicate runs on the
+// CODE-ONLY projection (comments and inert literals blanked, shell expansions kept)
+// and matches a variable READ or an assignment, never prose.
+const H_LIVE = /process\.env\.LIVE\b|\$\{LIVE[:}\-]|\$LIVE\b|(?:^|\n)\s*(?:export\s+)?LIVE=1\b/;
+
+/**
+ * Blank what cannot gate execution, so H_LIVE reads code and not prose.
+ *
+ * TS: `//` and block comments, and the contents of every quoted literal.
+ * Shell: `#` comments and single-quoted literals only — a double-quoted shell string
+ * still expands `${LIVE:-0}`, so blanking it would hide a real read.
+ */
+function codeOnly(body: string, isShell: boolean): string {
+	if (isShell) {
+		return body.replace(/(^|\s)#[^\n]*/g, "$1").replace(/'[^'\n]*'/g, "''");
+	}
+	return body
+		.replace(/\/\*[\s\S]*?\*\//g, "")
+		.replace(/(^|[^:])\/\/[^\n]*/g, "$1")
+		.replace(/`(?:[^`\\]|\\.)*`/g, "``")
+		.replace(/"(?:[^"\\\n]|\\.)*"/g, '""')
+		.replace(/'(?:[^'\\\n]|\\.)*'/g, "''");
+}
+
+type SemanticClass =
+	| "real-live"
+	| "package-install"
+	| "hermetic-integration"
+	| "source-topology"
+	| "behavioral-contract"
+	| "pure-unit";
+
+/** Narrow explicit overrides for files the mechanical rules cannot reach. Every
+ * entry carries its reason and is printed with the table — extending this map is
+ * a reviewed decision, not a default. */
+const CLASS_OVERRIDES: Record<string, { cls: SemanticClass; reason: string }> = {
+	// These three read repo files through paths assembled at runtime, so the
+	// H_TEXT line-level heuristic cannot see them; each is a structure-over-text
+	// gate with no product execution.
+	"scripts/check-entwurf-bridge-pi-free.ts": {
+		cls: "source-topology",
+		reason: "walks the bridge's static value-import closure as text to forbid @earendil-works imports",
+	},
+	"scripts/check-shell-quote.ts": {
+		cls: "source-topology",
+		reason: "reads the shellQuote() implementation sites as text and cross-checks the POSIX escape contract",
+	},
+	// Imports only scripts/lib (the shared launcher-fence), spawns nothing, and its
+	// smoke-wiring reads assemble paths at runtime — so no mechanical rule reaches it.
+	"scripts/check-mux-launcher-fence.ts": {
+		cls: "behavioral-contract",
+		reason:
+			"executes the shared claude-launcher-fence lib against disposable fs fixtures and source-reads both mux LIVE smoke wiring sites",
+	},
+	"scripts/check-mux-parent-artifact.ts": {
+		cls: "source-topology",
+		reason: "asserts the scrubbed parent-transcript fixture's recorded shape — an artifact contract, no product run",
+	},
+};
+
+/**
+ * A single class name is the file's STRONGEST tier; some gates also ship a weaker
+ * one. Recording that here keeps "real-live" from being read as "never runs without
+ * LIVE=1" — and keeps the reverse, a two-tier gate quietly counted as deterministic,
+ * from passing as honest either. Stale entries throw.
+ */
+const TWO_TIER_NOTES: Record<string, string> = {
+	"scripts/smoke-meta-async-drift.sh":
+		"deterministic default tier (pin/marker/doorbell contract — no model, no network) + LIVE=1 add-on tier that delegates to repro-plugin-idle-wake.sh and spawns one metered `claude -p`. Counted real-live because its strongest tier is a real live turn; `pnpm check` only ever runs the deterministic tier.",
+};
+
+type Style = "imports-product" | "source-text" | "subprocess" | "mixed" | "shell" | "other";
+
+interface Row {
+	file: string;
+	axis: "legacy" | "framework";
+	lines: number;
+	cls: SemanticClass;
+	overridden: boolean;
+	style: Style;
+}
+
+/** A test file is judged together with the ./helpers/ bodies it imports. */
+function effectiveBody(rel: string): string {
+	let body = fs.readFileSync(path.join(REPO_DIR, rel), "utf8");
+	if (rel.startsWith("test/") && rel.endsWith(".test.ts")) {
+		for (const m of body.matchAll(/from\s+["']\.\/(helpers\/[^"']+?)(?:\.ts)?["']/g)) {
+			const helper = path.join(REPO_DIR, "test", `${m[1]}.ts`.replace(/\.ts\.ts$/, ".ts"));
+			if (fs.existsSync(helper)) body += `\n${fs.readFileSync(helper, "utf8")}`;
+		}
+	}
+	return body;
+}
+
+function classify(rel: string, axis: "legacy" | "framework"): Row {
+	const lines = countLines(rel);
+	const isShell = rel.endsWith(".sh");
+	const body = isShell ? fs.readFileSync(path.join(REPO_DIR, rel), "utf8") : effectiveBody(rel);
+	const base = path.basename(rel);
+
+	const style: Style = (() => {
+		if (isShell) return "shell";
+		const axes = [H_IMPORTS.test(body), H_TEXT.test(body), H_PROC.test(body)];
+		const n = axes.filter(Boolean).length;
+		if (n >= 2) return "mixed";
+		if (axes[0]) return "imports-product";
+		if (axes[1]) return "source-text";
+		if (axes[2]) return "subprocess";
+		return "other";
+	})();
+
+	const override = CLASS_OVERRIDES[rel];
+	const cls: SemanticClass | null = override
+		? override.cls
+		: /-live\.(ts|sh)$/.test(base) || H_LIVE.test(codeOnly(body, isShell))
+			? "real-live"
+			: /pack|install/.test(base)
+				? "package-install"
+				: isShell || H_PROC.test(body) || H_NET.test(body)
+					? "hermetic-integration"
+					: H_TEXT.test(body) && !H_IMPORTS.test(body)
+						? "source-topology"
+						: H_IMPORTS.test(body) && (H_TEXT.test(body) || H_FS.test(body))
+							? "behavioral-contract"
+							: H_IMPORTS.test(body)
+								? "pure-unit"
+								: null;
+	if (cls === null) {
+		throw new Error(
+			`unclassified gate: ${rel} — no rule reaches it; extend the rules or add a reasoned CLASS_OVERRIDES entry`,
+		);
+	}
+	return { file: rel, axis, lines, cls, overridden: Boolean(override), style };
+}
+
+// ── buckets ──────────────────────────────────────────────────────────────────
+const legacyGates = legacyFiles.filter((f) => /^scripts\/(check-|smoke-)/.test(f));
+const frameworkGates = frameworkFiles.filter((f) => /^test\/.*\.test\.ts$/.test(f));
+const lib = legacyFiles.filter((f) => f.startsWith("scripts/lib/"));
+const mutantManifests = legacyFiles.filter((f) => f.startsWith("scripts/mutants/") && f.endsWith(".json"));
+const fixtures = legacyFiles.filter((f) => f.startsWith("scripts/fixtures/"));
+const legacyOther = legacyFiles.filter(
+	(f) => !legacyGates.includes(f) && !lib.includes(f) && !mutantManifests.includes(f) && !fixtures.includes(f),
+);
+const frameworkSupport = frameworkFiles.filter((f) => !frameworkGates.includes(f));
+
+const rows: Row[] = [
+	...legacyGates.map((f) => classify(f, "legacy")),
+	...frameworkGates.map((f) => classify(f, "framework")),
+];
+
+function sum(rs: Row[]): number {
+	return rs.reduce((a, r) => a + r.lines, 0);
+}
+function total(files: string[]): number {
+	return files.reduce((a, f) => a + countLines(f), 0);
+}
+
+const head = git(["rev-parse", "--short", "HEAD"]).trim();
+console.log(`inventory-verification-surface — work surface (tracked + untracked-non-ignored) @ HEAD ${head}`);
+console.log(`
+rule predicates (re-derive any number from these):
+  H_IMPORTS  ${H_IMPORTS}
+  H_TEXT     ${H_TEXT}
+  H_PROC     ${H_PROC}
+  H_NET      ${H_NET}
+  H_FS       ${H_FS}
+  H_LIVE     ${H_LIVE}
+H_LIVE is applied to the CODE-ONLY projection (comments and inert literals blanked;
+shell double-quoted expansions kept), so a gate that merely QUOTES "LIVE=1" is not
+real-live. Two-tier gates are listed under the class breakdown.
+semantic classes, first match wins: override → real-live (name -live | H_LIVE on code) →
+  package-install (name pack|install) → hermetic-integration (.sh | H_PROC | H_NET) →
+  source-topology (H_TEXT ∧ ¬H_IMPORTS) → behavioral-contract (H_IMPORTS ∧ (H_TEXT ∨ H_FS)) →
+  pure-unit (H_IMPORTS) → ERROR (unclassified is asserted zero)
+test/*.test.ts is classified together with the ./helpers/* bodies it imports.
+`);
+
+const legacyTotal = total(legacyFiles);
+const frameworkTotal = total(frameworkFiles);
+console.log(`legacy axis (scripts/):            ${legacyFiles.length} files, ${legacyTotal} lines`);
+console.log(
+	`  gates (check-*/smoke-*):         ${legacyGates.length} files, ${sum(rows.filter((r) => r.axis === "legacy"))} lines`,
+);
+console.log(`  scripts/lib/:                    ${lib.length} files, ${total(lib)} lines`);
+console.log(`  scripts/mutants/:                ${mutantManifests.length} manifests`);
+console.log(`  scripts/fixtures/:               ${fixtures.length} files`);
+console.log(`  other:                           ${legacyOther.length} files, ${total(legacyOther)} lines`);
+console.log(`framework axis (test/ + vitest.config.ts): ${frameworkFiles.length} files, ${frameworkTotal} lines`);
+console.log(
+	`  vitest lanes (test/**/*.test.ts):  ${frameworkGates.length} files, ${sum(rows.filter((r) => r.axis === "framework"))} lines`,
+);
+console.log(`  helpers/config:                    ${frameworkSupport.length} files, ${total(frameworkSupport)} lines`);
+console.log(
+	`COMBINED verification total:       ${legacyFiles.length + frameworkFiles.length} files, ${legacyTotal + frameworkTotal} lines`,
+);
+console.log("  (migration moves lines between axes; only a drop in THIS number is subtraction)");
+
+console.log("\nsemantic class breakdown (all gates, both axes):");
+const classes: SemanticClass[] = [
+	"pure-unit",
+	"behavioral-contract",
+	"source-topology",
+	"hermetic-integration",
+	"package-install",
+	"real-live",
+];
+for (const c of classes) {
+	const rs = rows.filter((r) => r.cls === c);
+	console.log(`  ${c.padEnd(21)} ${String(rs.length).padStart(3)} files ${String(sum(rs)).padStart(7)} lines`);
+}
+console.log(`  ${"unclassified".padEnd(21)}   0 files       0 lines (asserted: the classifier throws otherwise)`);
+
+console.log("\ntwo-tier gates (one class name, two execution tiers):");
+for (const [rel, note] of Object.entries(TWO_TIER_NOTES)) {
+	const row = rows.find((r) => r.file === rel);
+	if (!row) throw new Error(`stale TWO_TIER_NOTES entry: ${rel} is not a classified gate — remove or repoint it`);
+	console.log(`  ${rel} [${row.cls}] — ${note}`);
+}
+
+console.log("\nstyle axis (secondary, e405d64-baseline continuity):");
+const styles: Style[] = ["imports-product", "source-text", "subprocess", "mixed", "shell", "other"];
+for (const s of styles) {
+	const rs = rows.filter((r) => r.style === s);
+	console.log(`  ${s.padEnd(21)} ${String(rs.length).padStart(3)} files ${String(sum(rs)).padStart(7)} lines`);
+}
+
+const overridden = rows.filter((r) => r.overridden);
+if (overridden.length > 0) {
+	console.log("\nexplicit overrides in effect (each is a reviewed decision):");
+	for (const r of overridden) console.log(`  ${r.file} → ${r.cls} (${CLASS_OVERRIDES[r.file].reason})`);
+}
+
+// ── mutant inventory ─────────────────────────────────────────────────────────
+interface MutantEntry {
+	subject: string;
+}
+let totalMutants = 0;
+let infraMutants = 0;
+console.log("\nmutant lanes (subject=scripts/* counts as verification-infra):");
+for (const manifest of mutantManifests) {
+	const parsed = JSON.parse(fs.readFileSync(path.join(REPO_DIR, manifest), "utf8")) as {
+		lane: string;
+		mutants: MutantEntry[];
+	};
+	const infra = parsed.mutants.filter((m) => m.subject.startsWith("scripts/")).length;
+	totalMutants += parsed.mutants.length;
+	infraMutants += infra;
+	console.log(
+		`  ${parsed.lane.padEnd(24)} ${String(parsed.mutants.length).padStart(3)} mutants  (${infra} infra-subject)`,
+	);
+}
+console.log(`  ${"TOTAL".padEnd(24)} ${String(totalMutants).padStart(3)} mutants  (${infraMutants} infra-subject)`);
+
+console.log("\nper-gate table (axis, class, style, lines):");
+for (const r of rows) {
+	console.log(
+		`  ${r.axis.padEnd(9)} ${r.cls.padEnd(21)} ${r.style.padEnd(16)} ${String(r.lines).padStart(6)}  ${r.file}${r.overridden ? "  [override]" : ""}`,
+	);
+}