@junghanacs/entwurf 0.13.1 → 0.14.0

package/scripts/check-release-gate-outcomes.ts

@@ -32,7 +32,7 @@
 // exactly what this gate must not make. They are cheap — each smoke declines
 // before it does any work.
 //
-// Pure + subprocess, no network/model — IN pnpm check.
+// Pure + subprocess, no network/model — IN pnpm run check:full.
 
 import { strict as assert } from "node:assert";
 import { execFileSync } from "node:child_process";
@@ -243,8 +243,8 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 		viaWrapper.code,
 		LIVE_SKIP_EXIT,
 		`[QK:WRAPPER-SKIP-IS-PROTOCOL-EXIT] a run.sh smoke WRAPPER that declines a prerequisite must return the protocol ` +
-			`SKIP code, not 0 — got exit ${viaWrapper.code}. The wrapper is a skip surface of its own (cortex, matrix, ` +
-			"spawn-live and spawn-resume all decline before their .ts is ever reached), so fixing only the TypeScript " +
+			`SKIP code, not 0 — got exit ${viaWrapper.code}. The wrapper is a skip surface of its own (cortex and matrix ` +
+			"both decline before their .ts is ever reached), so fixing only the TypeScript " +
 			`half would leave the aggregate counting those as PASS. Output: ${JSON.stringify(viaWrapper.output.slice(-300))}`,
 	);
 
@@ -269,7 +269,9 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 //    the gate RUNS; it says nothing about steps the gate never lists. Three LIVE
 //    smokes (cortex, spawn-live, claude-native-resume) sat outside the aggregate
 //    with no stated reason until 2026-07-31, so a green cut was silent about the
-//    second backend, the spawn substrate, and native resume.
+//    second backend, the spawn substrate, and native resume. (spawn-live was
+//    deleted with its transport in the visible-first cut; the incident is kept
+//    verbatim because it is what this rule was derived from.)
 //
 //    So: every LIVE smoke is either WIRED into release_gate or EXCLUDED for a
 //    reason an operator can read in the docs. The exclusion half is checked
@@ -284,13 +286,14 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 	// name → the sentence in the docs that carries its exclusion, and where.
 	const DOCUMENTED_EXCLUSIONS: Record<string, [file: string, sentence: string]> = {
 		"smoke-acp-long-turn-live": ["VERIFY.md", "on-demand, not part of `release-gate`"],
+		"smoke-mux-fresh-call-live": ["VERIFY.md", "Fresh-call LIVE is on-demand, not part of `release-gate`"],
 		"smoke-agy-native-push-live": ["VERIFY.md", "Aggregate release-gate does not own an agy conversation id"],
 		"smoke-acp-ordering-probe-live": ["docs/acp-backend-rail.md", "opt-in paired observation"],
 		// Cortex needs an external Snowflake connection the HOST owns, so an aggregate
 		// that required it would block every cut taken without that account. Excluded —
 		// NOT waived: its direct call stays required for a Cortex-rail cut, and running
 		// it without the connection still reports protocol SKIP rather than a pass.
-		"smoke-acp-cortex-live": ["VERIFY.md", "The 0.13.1 aggregate does not re-certify Cortex"],
+		"smoke-acp-cortex-live": ["VERIFY.md", "The release aggregate does not re-certify Cortex"],
 	};
 
 	const allLive = globSync("scripts/smoke-*live*.{ts,sh}", { cwd: REPO_DIR })
@@ -309,7 +312,7 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 			excused,
 			`[QK:NO-SILENT-AGGREGATE-OMISSION] ${name} is neither wired into release_gate nor excluded in the docs. ` +
 				"A LIVE smoke that exists but is never listed makes a green cut silent about the axis it covers — exactly " +
-				"how cortex (the second shipped backend), spawn-live and claude-native-resume went unrun for releases. " +
+				"how cortex (the second shipped backend) and claude-native-resume went unrun for releases. " +
 				"Wire it, or state the exclusion where an operator reads it.",
 		);
 		const [file, sentence] = excused as [string, string];
@@ -321,6 +324,121 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 	}
 }
 
+// ===========================================================================
+// 8. qualification scheduling topology — the subtraction has its own oracle.
+//    check-gate-qualification left the default check chains (operator
+//    inner-loop cost, 2026-08 subtraction). That move is a gate/release
+//    contract: the step must stay REACHABLE on the axes that now own it — the
+//    CI check job on every push and release_gate as its own MUST step — and
+//    must not silently return to the default chain. Without this cell,
+//    deleting the release_gate qualification block or the CI line leaves every
+//    focused gate green while a cut quietly loses its discriminating-power
+//    step.
+//
+//    TWO claims, because #70 added a second independent contract here. 8a is
+//    REACHABILITY (absent from the default chain; present exactly once in CI and
+//    exactly once as a wired release_gate MUST step; named in VERIFY). 8b is what
+//    the CI step qualifies (the FULL floor, before the qualification run). Each
+//    carries its own replant — one mutant must never stand in for both.
+// ===========================================================================
+{
+	// The default chain is tiered (#70): `check` (core) and `check:full` compose the
+	// named group scripts, so the reachability scan covers EVERY check* script —
+	// qualification sneaking into any group re-doubles the closure floor.
+	const pkgScripts = (
+		JSON.parse(readFileSync(join(REPO_DIR, "package.json"), "utf8")) as { scripts: Record<string, string> }
+	).scripts;
+	const pkgCheck = Object.entries(pkgScripts)
+		.filter(([name]) => name === "check" || name.startsWith("check:"))
+		.map(([, body]) => body)
+		.join(" && ");
+	const ciYml = readFileSync(join(REPO_DIR, ".github/workflows/ci.yml"), "utf8");
+	const ciHits = ciYml.split("- run: ./run.sh check-gate-qualification").length - 1;
+	const runShQ = readFileSync(join(REPO_DIR, "run.sh"), "utf8");
+	const qualGateBody = runShQ.slice(runShQ.indexOf("release_gate() {"), runShQ.indexOf("# 5. Summary"));
+	const invocations = qualGateBody.split('bash "$self" check-gate-qualification').length - 1;
+	const verifyDoc = readFileSync(join(REPO_DIR, "VERIFY.md"), "utf8");
+
+	// One claim token, one assert (the qualification runner requires the exact-once
+	// signature); each broken axis names itself in the joined message.
+	const holes: string[] = [];
+	if (pkgCheck.includes("check-gate-qualification"))
+		holes.push(
+			"package.json's default `check` chain contains check-gate-qualification again (doubles every closure floor)",
+		);
+	if (ciHits !== 1) holes.push(`the CI check job runs check-gate-qualification ${ciHits}x (need exactly once)`);
+	if (invocations !== 1)
+		holes.push(`release_gate invokes check-gate-qualification ${invocations}x (need exactly one MUST step)`);
+	if (
+		!qualGateBody.includes('results+=("PASS  check-gate-qualification")') ||
+		!qualGateBody.includes('results+=("FAIL  check-gate-qualification")')
+	)
+		holes.push("the release_gate qualification step does not wire PASS/FAIL into the MUST counters");
+	if (!verifyDoc.includes("in the CI `check` job on every push, and as a release-gate MUST step"))
+		holes.push("VERIFY.md no longer names the owners of the moved qualification step");
+	assert.ok(
+		holes.length === 0,
+		"[QK:QUALIFICATION-SCHEDULING-REACHABLE] check-gate-qualification left the default check chains " +
+			"deliberately, so it must stay REACHABLE on the axes that own it now — absent from the default chain, " +
+			"exactly once in the CI check job, exactly once as a release_gate MUST step with its " +
+			`outcome wired, and named in VERIFY. Broken: ${holes.join("; ")}`,
+	);
+
+	// 8b. WHAT the CI qualification step qualifies — its own claim, not a branch
+	//     folded into the one above. #70 split the deterministic floor into tiers,
+	//     so "CI runs qualification once" stopped being sufficient evidence on its
+	//     own: qualification on top of the ≤60s core would certify kill-power over
+	//     a floor no candidate ships on. This is ONE contract with one condition —
+	//     the full floor is present in the CI check job AND qualification follows
+	//     it — because a floor that is absent and a floor that runs afterwards
+	//     break the same promise identically. The committed replant qualifies the
+	//     downgrade/omission axis (the tier rename downgrading CI back to core);
+	//     ordering stays directly asserted here and has no incident-earned mutant.
+	const ciFloorAt = ciYml.indexOf("- run: pnpm run check:full");
+	const ciQualAt = ciYml.indexOf("- run: ./run.sh check-gate-qualification");
+	assert.ok(
+		ciFloorAt !== -1 && ciQualAt > ciFloorAt,
+		"[QK:CI-FULL-FLOOR-QUALIFIED] the CI check job owns the FULL deterministic floor (#70): it must run " +
+			"`pnpm run check:full` — not the ≤60s core — and check-gate-qualification must come AFTER it, so the " +
+			"kill-power proof covers the floor a candidate actually ships on. The committed replant qualifies the " +
+			"downgrade/omission axis; ordering is directly asserted by this same oracle. " +
+			`Broken: check:full at index ${ciFloorAt}, qualification at index ${ciQualAt}.`,
+	);
+}
+
+// ===========================================================================
+// The integrated mux lifecycle is a MUST, and the focused fresh-call LIVE is not
+//
+// Two LIVE smokes now cover the mux rail and they are NOT interchangeable:
+// `smoke-mux-fresh-call-live` drives the composition from SOURCE and is on-demand,
+// while `smoke-mux-lifecycle-live` enters through the real MCP surface and follows a
+// citizen through resume and recall. A cut that ran only the focused one would be
+// green about the axis nobody proved. So the MUST wiring is pinned here, exactly
+// once, together with the doc sentence that keeps the two apart for an operator.
+// ===========================================================================
+{
+	const runSh = readFileSync(join(REPO_DIR, "run.sh"), "utf8");
+	const gateBody = runSh.slice(runSh.indexOf("release_gate() {"), runSh.indexOf("# 5. Summary"));
+	const verify = readFileSync(join(REPO_DIR, "VERIFY.md"), "utf8");
+	const mustSteps = gateBody.split("\n").filter((l) => l.includes('"$self" smoke-mux-lifecycle-live'));
+	const gaps: string[] = [];
+	if (mustSteps.length !== 1)
+		gaps.push(`release_gate runs smoke-mux-lifecycle-live ${mustSteps.length}x (need exactly one MUST step)`);
+	if (mustSteps.length === 1 && !mustSteps[0]?.includes("run_live_step"))
+		gaps.push("the lifecycle step does not go through run_live_step, so its SKIP would not reach the classifier");
+	if (!verify.includes("Fresh-call LIVE is on-demand, not part of `release-gate`"))
+		gaps.push("VERIFY.md no longer excuses the focused fresh-call LIVE from the aggregate");
+	if (!verify.includes("smoke-mux-lifecycle-live"))
+		gaps.push("VERIFY.md does not name the integrated lifecycle MUST at all");
+	assert.ok(
+		gaps.length === 0,
+		"[QK:MUX-LIFECYCLE-IS-RELEASE-MUST] the integrated mux lifecycle LIVE must be a release-gate MUST exactly once " +
+			"and go through run_live_step (so a missing prerequisite is a SKIP the cut refuses, never a silent pass), " +
+			"while the focused fresh-call LIVE stays on-demand and VERIFY keeps the two distinguishable — a cut that " +
+			`ran only the source-level smoke would be green about the surface no one entered. Broken: ${gaps.join("; ")}`,
+	);
+}
+
 console.log(
 	"[check-release-gate-outcomes] ok — STEP OUTCOME protocol: one skip exit code shared by the shell and TS halves " +
 		`(${LIVE_SKIP_EXIT}, clear of the per-tool 0..4 and shell 126+ bands), classifier maps 0→PASS / skip→SKIP / ` +
@@ -328,5 +446,7 @@ console.log(
 		"exit 0, no LIVE smoke still carries the pre-P1 exit-0 skip shape, and both real skip surfaces were INVOKED and " +
 		"observed to propagate the code: a smoke with LIVE unset (through run_ts, with its operator-readable marker) and " +
 		"a run.sh wrapper declining its own prerequisite (including the measured LIVE=1 no-cortex-connection cell); and every " +
-		"LIVE smoke is either wired into release_gate or excluded by a sentence the docs still carry",
+		"LIVE smoke is either wired into release_gate or excluded by a sentence the docs still carry; and the moved " +
+		"check-gate-qualification stays reachable on its owners (absent from the default chain, exactly once in CI, " +
+		"exactly once as a release-gate MUST step) and the CI step qualifies the FULL floor, which runs before it",
 );

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"}