@junghanacs/entwurf 0.30.1 → 0.32.0

package/scripts/check-entwurf-bridge-pi-free.ts

@@ -1,10 +1,12 @@
 // check-entwurf-bridge-pi-free (0.12.1 A-gate, static half)
 //
-// INVARIANT: the entwurf-bridge MCP server must boot WITHOUT any pi package
-// (`@earendil-works/pi-*`). entwurf is a harness-neutral npm package; pi is one
-// optional adapter lane, not a boot dependency. A plain `npm install
-// @junghanacs/entwurf` (no pi peers) must still stand `entwurf-bridge` up and
-// answer MCP `tools/list`.
+// INVARIANT: the entwurf-bridge MCP server must boot WITHOUT importing any pi
+// package (`@earendil-works/pi-*`). entwurf is a harness-neutral npm package; pi is
+// one adapter lane, not a boot dependency. A plain `npm install @junghanacs/entwurf`
+// must still stand `entwurf-bridge` up and answer MCP `tools/list` without touching
+// pi. Since #130 that install carries the pi SDK as a production dependency (the
+// pi-durable carrier's), so the runtime half proves this under a deny hook in
+// check-pack-install rather than by the SDK's absence.
 //
 // This gate is the STATIC half of that contract: it walks the EAGER static
 // value-import closure of the bridge entry (`mcp/entwurf-bridge/src/index.ts`)

package/scripts/check-fresh-call-dispatch.ts

@@ -138,6 +138,24 @@ async function main(): Promise<void> {
 			!herdrBranch.includes("codexCallerFreshPreflight"),
 	);
 
+	// #129: pi-durable joined the tmux fresh set, NOT the herdr pilot set (GLG, 2026-10-06: no herdr
+	// pi-durable support in 0.31). Same axis as the codex cell: refused by the herdr reason, nothing
+	// spawned, no tmux fallback, and its installed-carrier preflight is never asked on this branch.
+	const durable = recordingSpawn();
+	const durableRefused = await dispatchFreshCall(
+		{ ...REQUEST, backend: "pi-durable", model: "loopback/scripted" },
+		HERDR_ENV,
+		durable.spawn,
+	);
+	ok(
+		"[QK:FCD-HERDR-PI-DURABLE-UNSUPPORTED] inside herdr pi-durable is not a pilot backend: it refuses by the herdr reason with nothing spawned, never falls back to a tmux window, and its runtime preflight is never consulted there",
+		durableRefused.rail === "herdr" &&
+			!durableRefused.result.ok &&
+			durableRefused.result.reason === "herdr-backend-unsupported" &&
+			durable.calls.length === 0 &&
+			!herdrBranch.includes("piDurable"),
+	);
+
 	// ── the tmux rail keeps its pre-existing ordering ────────────────────────────────────
 	// The import line names the preflight too, so the body is what gets counted: the claim is
 	// "called once, on one path", not "the word appears once".

package/scripts/check-gate-qualification.ts

@@ -66,9 +66,9 @@ import {
 	runGateBounded,
 	signatureAttributedToFailure,
 	signatureOnFailureLine,
-	sweepStaleSnapshots,
 	validateManifest,
 	validateManifestSet,
+	withOwnSnapshot,
 } from "./lib/mutation-qualify.ts";
 import { ACCEPTANCE_SCHEMA, checkAcceptanceRecord, RECORD_CONSISTENT } from "./lib/qualification-acceptance.ts";
 import {
@@ -637,6 +637,32 @@ function fixtureSpec(patch: Partial<MutantSpec>): MutantSpec {
 	};
 }
 
+/**
+ * A PRIOR run's snapshot root inside a self-test's private `tmpRoot`, in the exact shape the
+ * retired ambient sweep deleted (snapshot prefix, a `runner.json` naming a dead pid). It is
+ * that run's evidence: no qualification run may list it, let alone remove it. `state()`
+ * names every entry with its bytes, so a removal or a rewrite both read as a change.
+ */
+const PRIOR_RUN_ROOT = "entwurf-qualify-prior1";
+function seedPriorRunRoot(tmpRoot: string): { before: string; state: () => string } {
+	const dir = path.join(tmpRoot, PRIOR_RUN_ROOT);
+	fs.mkdirSync(dir);
+	fs.writeFileSync(path.join(dir, "runner.json"), JSON.stringify({ pid: 999_999_999, startedAt: 0 }));
+	fs.writeFileSync(path.join(dir, "evidence.log"), "a prior run's red evidence\n");
+	const state = (): string =>
+		fs.existsSync(dir)
+			? fs
+					.readdirSync(dir)
+					.sort()
+					.map((name) => `${name}\0${fs.readFileSync(path.join(dir, name), "utf8")}`)
+					.join("\n")
+			: "absent";
+	return { before: state(), state };
+}
+
+/** Each prior-root observation, asserted ONCE under its QK by Phase 1c-s (the token is exactly-once). */
+const priorRunKept: Record<string, boolean> = {};
+
 const quiet = (): void => {};
 
 {
@@ -897,21 +923,6 @@ const quiet = (): void => {};
 			ok(`pgroup: the GRANDCHILD (pid ${grandchild}) is dead after the group SIGKILL`, dead);
 			fs.rmSync(invocationDir, { recursive: true, force: true });
 		}
-
-		// Stale-snapshot sweep: dead-pid residue is reclaimed, a live runner's dir survives.
-		{
-			const tmpRoot = reclaimOnExit(fs.mkdtempSync(path.join(os.tmpdir(), "entwurf-qualify-sweep-")));
-			const deadDir = path.join(tmpRoot, "entwurf-qualify-dead1");
-			fs.mkdirSync(deadDir);
-			fs.writeFileSync(path.join(deadDir, "runner.json"), JSON.stringify({ pid: 999_999_999, startedAt: 0 }));
-			const liveDir = path.join(tmpRoot, "entwurf-qualify-live1");
-			fs.mkdirSync(liveDir);
-			fs.writeFileSync(path.join(liveDir, "runner.json"), JSON.stringify({ pid: process.pid, startedAt: Date.now() }));
-			const swept = sweepStaleSnapshots(tmpRoot);
-			ok("sweep: a dead-pid snapshot dir is reclaimed", swept.includes(deadDir) && !fs.existsSync(deadDir));
-			ok("sweep: a live runner's snapshot dir survives", fs.existsSync(liveDir));
-			fs.rmSync(tmpRoot, { recursive: true, force: true });
-		}
 	} finally {
 		fs.rmSync(fixtureOrigin, { recursive: true, force: true });
 		fs.rmSync(path.dirname(externalTarget), { recursive: true, force: true });
@@ -1262,8 +1273,11 @@ function buildDeclaredOutputFixture(): string {
 				logError: quiet,
 				tmpRoot,
 			});
-		const snapshotsLeft = (): string[] => fs.readdirSync(tmpRoot).filter((f) => f.startsWith("entwurf-qualify-"));
+		// This run's own snapshots only: the seeded prior root is not this run's to reclaim.
+		const snapshotsLeft = (): string[] =>
+			fs.readdirSync(tmpRoot).filter((f) => f.startsWith("entwurf-qualify-") && f !== PRIOR_RUN_ROOT);
 		const readReceipt = (name: string) => JSON.parse(fs.readFileSync(out(name), "utf8"));
+		const prior = seedPriorRunRoot(tmpRoot);
 
 		const green = await runFx(["bash", "gates/kill.sh"], "green.json");
 		const gr = readReceipt("green.json");
@@ -1279,6 +1293,7 @@ function buildDeclaredOutputFixture(): string {
 				gr.receiptSha256 === green.receiptSha256,
 		);
 		ok("group run: the snapshot is reclaimed", snapshotsLeft().length === 0);
+		priorRunKept["group green"] = prior.state() === prior.before;
 
 		const red = await runFx(["bash", "gates/survive.sh"], "red.json");
 		const rr = readReceipt("red.json");
@@ -1286,6 +1301,7 @@ function buildDeclaredOutputFixture(): string {
 			"group run: a SURVIVED mutant is still written — red receipt, passed false",
 			red.passed === false && rr.result.passed === false && rr.result.mutants[0].verdict === "SURVIVED",
 		);
+		priorRunKept["group red"] = prior.state() === prior.before && snapshotsLeft().length === 0;
 
 		let refused = "";
 		try {
@@ -1405,6 +1421,7 @@ const refuseArgs = (argv: string[], naming: string): void =>
 		const receiptOf = (dir: string, file: string | null) =>
 			JSON.parse(fs.readFileSync(path.join(tmpRoot, dir, file ?? ""), "utf8"));
 
+		const prior = seedPriorRunRoot(tmpRoot);
 		const abc = await collect("abc", [sA, sB, sC]);
 		ok(
 			"[QK:COLLECT-RED-DOES-NOT-STOP] collect: green / red / green — the red middle does not stop the tail; collection COMPLETE and intact",
@@ -1430,8 +1447,9 @@ const refuseArgs = (argv: string[], naming: string): void =>
 			) &&
 				rB.result.control === "ok" &&
 				rB.result.mutants[0].verdict === "SURVIVED" &&
-				fs.readdirSync(tmpRoot).every((f) => !f.startsWith("entwurf-qualify-")),
+				fs.readdirSync(tmpRoot).every((f) => f === PRIOR_RUN_ROOT || !f.startsWith("entwurf-qualify-")),
 		);
+		priorRunKept["collect green/red/green"] = prior.state() === prior.before;
 		ok(
 			"collect: runId/runAttempt recorded exactly as the environment gave them; requested order kept",
 			abc.runId === "123" &&
@@ -1586,6 +1604,47 @@ const refuseArgs = (argv: string[], naming: string): void =>
 	}
 }
 
+// ═══ Phase 1c-s — every real run owns exactly its own snapshot (#130 r3) ═════
+//
+// The group (1c-g) and collection (1c-m) fixtures above seeded a prior run's root and
+// recorded whether it survived their green and red runs. That holds for real runs only while
+// every real run goes THROUGH the seam, so the production callers are read here too: the full
+// body and the group receipt each make their snapshot only via withOwnSnapshot, the collection
+// only via the group receipt, and the library exports no sweep and lists no tmp root. The
+// retired ambient sweep removed a protected prior snapshot during a release-gate run; the
+// fixtures cannot see a caller that bypasses the seam, this can. All four observations are
+// asserted once, under the claim's single token.
+
+{
+	const read = (rel: string): string => fs.readFileSync(path.join(REPO_DIR, rel), "utf8");
+	const qualifier = read("scripts/check-gate-qualification.ts");
+	// The LAST occurrence is the real header: this block's own needle sits above it.
+	const bodyAt = qualifier.lastIndexOf("// ═══ Phase 2m — several exact-argv groups");
+	const body = qualifier.slice(bodyAt);
+	const receipt = read("scripts/lib/qualification-receipt.ts");
+	const collection = read("scripts/lib/qualification-collection.ts");
+	const lib = read("scripts/lib/mutation-qualify.ts");
+	const libExports = Object.keys(await import("./lib/mutation-qualify.ts"));
+	priorRunKept.wiring =
+		bodyAt > qualifier.indexOf("// ═══ Phase 1c-s") &&
+		countOccurrences(body, "withOwnSnapshot(REPO_DIR, undefined,") === 1 &&
+		countOccurrences(body, "createRepoSnapshot(") === 0 &&
+		countOccurrences(receipt, "withOwnSnapshot(repoDir, opts.tmpRoot,") === 1 &&
+		countOccurrences(receipt, "createRepoSnapshot(") === 0 &&
+		countOccurrences(collection, "runGroupReceipt(") >= 1 &&
+		countOccurrences(collection, "createRepoSnapshot(") === 0 &&
+		countOccurrences(collection, "withOwnSnapshot(") === 0 &&
+		countOccurrences(lib, "createRepoSnapshot(") === 2 &&
+		countOccurrences(lib, "const snap = createRepoSnapshot(originDir, tmpRoot);") === 1 &&
+		countOccurrences(lib, "readdirSync(tmpRoot") === 0 &&
+		!libExports.some((name) => /sweep/i.test(name));
+	const failed = Object.keys(priorRunKept).filter((k) => !priorRunKept[k]);
+	ok(
+		`[QK:QUALIFY-PRIOR-RUN-EVIDENCE-KEPT] a prior run's dead-pid snapshot root keeps every name and byte through a green and a red group run and a green/red/green collection, each run's own snapshot is reclaimed, and the full body and group receipt snapshot only through withOwnSnapshot — failed: ${failed.join(", ") || "none"}`,
+		Object.keys(priorRunKept).length === 4 && failed.length === 0,
+	);
+}
+
 // ═══ Phase 1c-l — the composite ledger over REAL fixture receipts (#124 P2) ═
 //
 // A late failure, end to end: receipts are written by runGroupReceipt on a fixture
@@ -3342,15 +3401,16 @@ let manifestCount: number;
 		"copilot-birth": 19,
 		"copilot-launch": 14,
 		"pi-launch": 9,
-		"pi-floor": 1,
+		"pi-floor": 3,
 		"pi-bridge-sender": 4,
 		"pi-mcp-bridge": 2,
 		"pi-mcp-register": 3,
+		"pi-durable": 47,
 		"copilot-receive": 20,
 		"entwurf-peers": 1,
 		"fresh-call-dispatch": 11,
 		"fresh-cut": 3,
-		"gate-qualification": 7,
+		"gate-qualification": 8,
 		"herdr-placement": 13,
 		"herdr-plugin": 25,
 		"herdr-plugin-profile": 14,
@@ -3365,7 +3425,7 @@ let manifestCount: number;
 		"meta-identity": 4,
 		"meta-retire": 4,
 		"mux-boundary": 16,
-		"mux-fresh-call": 59,
+		"mux-fresh-call": 65,
 		"mux-launcher-fence": 8,
 		"mux-parent-artifact": 3,
 		"pack-install": 3,
@@ -3502,7 +3562,6 @@ if (ARGS.mode === "compose") {
 if (ARGS.mode === "groups") {
 	const requested = ARGS.groups === "all" ? allGroupArgv(selected) : ARGS.groups;
 	checkRequestedGroups(requested, selected);
-	sweepStaleSnapshots(os.tmpdir());
 	const c = await collectGroups({
 		repoDir: REPO_DIR,
 		selected,
@@ -3531,7 +3590,6 @@ if (ARGS.mode === "groups") {
 // prints `[gate-qualification] ok` and never claims the full set.
 
 if (ARGS.mode === "group") {
-	sweepStaleSnapshots(os.tmpdir());
 	const { passed: groupPassed } = await runGroupReceipt({
 		repoDir: REPO_DIR,
 		selected,
@@ -3549,17 +3607,12 @@ if (ARGS.mode === "group") {
 	const headBefore = originHead(REPO_DIR);
 	const workSurfaceBefore = originWorkSurfaceSha(REPO_DIR);
 
-	sweepStaleSnapshots(os.tmpdir());
-	const snap = createRepoSnapshot(REPO_DIR);
-	console.log(
-		`[gate-qualification] snapshot: ${snap.repoDir} (${snap.fileCount} files, origin HEAD ${headBefore.slice(0, 12)})`,
-	);
-	let report: Awaited<ReturnType<typeof qualifyMutants>>;
-	try {
-		report = await qualifyMutants(snap, selected, (line) => console.log(line));
-	} finally {
-		fs.rmSync(snap.baseDir, { recursive: true, force: true });
-	}
+	const report = await withOwnSnapshot(REPO_DIR, undefined, (snap) => {
+		console.log(
+			`[gate-qualification] snapshot: ${snap.repoDir} (${snap.fileCount} files, origin HEAD ${headBefore.slice(0, 12)})`,
+		);
+		return qualifyMutants(snap, selected, (line) => console.log(line));
+	});
 
 	// Tripwire, not recovery: the runner never writes the origin, so any drift here is
 	// an outside writer racing the qualification — evidence cannot be attributed.

package/scripts/check-herdr-activation.ts

@@ -205,12 +205,13 @@ const {
 	COMPONENT_STATES,
 } = mod;
 
-/** The pi pin package.json declares — the SSOT `run.sh pi_supported_range` derives its range from. */
+/** The pi pin package.json declares (an exact production dependency since #130) — the SSOT
+ * `run.sh pi_supported_range` derives its range from. */
 const PI_PIN = (
 	JSON.parse(fs.readFileSync(path.join(REPO, "package.json"), "utf8")) as {
-		devDependencies: Record<string, string>;
+		dependencies: Record<string, string>;
 	}
-).devDependencies["@earendil-works/pi-coding-agent"];
+).dependencies["@earendil-works/pi-coding-agent"];
 
 /** A `pi` stand-in that reports `version` and nothing else — enough for a `--version` floor probe. */
 function fakePi(dir: string, name: string, version: string): string {
@@ -364,7 +365,7 @@ function ledgerWith(
 {
 	const env = world("pi-floor");
 	const bin = path.join(env.HOME as string, "bin");
-	// The supported range is DERIVED from the package.json devDep pin (run.sh
+	// The supported range is DERIVED from the package.json production dependency pin (run.sh
 	// `pi_supported_range`), so the fixtures are derived from it too — a hardcoded "0.85.1" here
 	// would silently stop being out-of-range the day the pin moves past it.
 	const [maj, min] = PI_PIN.split(".").map(Number);