@junghanacs/entwurf 0.23.1 → 0.25.0

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

@@ -170,14 +170,13 @@ async function main(): Promise<void> {
 
 	// ── one nonce, into whichever rail ───────────────────────────────────────────────────
 	const nonceSpawn = recordingSpawn();
-	await dispatchFreshCall(REQUEST, HERDR_ENV, nonceSpawn.spawn, "fresh-call-dispatch-test-nonce");
-	const startCall = nonceSpawn.calls.find((call) => call[1] === "agent" && call[2] === "start");
+	const dispatchNonce = "mux-fresh-call-deadbeefdeadbeefdeadbeef";
+	await dispatchFreshCall(REQUEST, HERDR_ENV, nonceSpawn.spawn, dispatchNonce);
+	const tabCall = nonceSpawn.calls.find((call) => call[1] === "tab" && call[2] === "create");
 	ok(
 		"[QK:FCD-ONE-NONCE] ONE nonce is minted per call and handed to the selected rail — two mints would mean the sibling calls back with a tag the caller never recorded",
 		dispatchCode.split("mintNonce(").length - 1 === 1 &&
-			(startCall === undefined ||
-				startCall.some((token) => token.includes("fresh-call-dispatch-test-nonce")) ||
-				nonceSpawn.calls.length > 0),
+			(tabCall === undefined || tabCall.some((token) => token.includes(dispatchNonce)) || nonceSpawn.calls.length > 0),
 	);
 
 	// ── the composition root holds no synchronous child authority ────────────────────────

package/scripts/check-gate-qualification.ts

@@ -49,6 +49,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
 	classifyMutantRun,
+	countOccurrences,
 	createRepoSnapshot,
 	ManifestError,
 	type MutantManifest,
@@ -820,6 +821,7 @@ let manifestCount: number;
 	// manifest lost in a merge must name itself here — "0/0 killed" is not a pass.
 	// Extend this inventory and the manifests TOGETHER, never silently.
 	const EXPECTED_LANE_MUTANTS: Record<string, number> = {
+		"acp-backend-preflight": 1,
 		"acp-augment": 10,
 		"acp-cortex": 14,
 		"acp-launch-namespace": 2,
@@ -829,37 +831,39 @@ let manifestCount: number;
 		"acp-stream-hooks": 10,
 		"acp-usage-accounting": 12,
 		"agy-permission": 6,
-		"bridge-boot-resume": 3,
-		"bridge-command-boot": 9,
+		"bridge-boot-resume": 5,
+		"bridge-command-boot": 12,
 		"capability-cache": 3,
 		"codex-app-server-launch": 9,
 		"codex-caller-seat": 28,
+		"control-send-receipt": 19,
 		"codex-native": 82,
 		"compaction-send-guard": 7,
 		"control-socket-disconnect": 4,
 		"copilot-birth": 19,
 		"copilot-launch": 14,
 		"pi-launch": 9,
+		"pi-floor": 1,
 		"copilot-receive": 20,
 		"entwurf-peers": 1,
 		"fresh-call-dispatch": 12,
 		"fresh-cut": 3,
 		"gate-qualification": 2,
 		"herdr-placement": 13,
-		"herdr-plugin": 11,
+		"herdr-plugin": 25,
 		"herdr-plugin-profile": 14,
-		"herdr-activation": 24,
+		"herdr-activation": 25,
 		"herdr-plugin-build": 13,
 		"herdr-runtime-bootstrap": 31,
-		"herdr-fresh-call": 37,
+		"herdr-fresh-call": 38,
 		"herdr-supply": 11,
 		"meta-facts": 4,
 		"peer-facts": 8,
 		"meta-hook-session-switch": 17,
 		"meta-identity": 4,
-		"meta-retire": 3,
+		"meta-retire": 4,
 		"mux-boundary": 16,
-		"mux-fresh-call": 58,
+		"mux-fresh-call": 59,
 		"mux-launcher-fence": 8,
 		"mux-parent-artifact": 3,
 		"pack-install": 2,
@@ -869,7 +873,8 @@ let manifestCount: number;
 		"omp-fresh": 24,
 		"omp-receive": 11,
 		"probe-ordering": 1,
-		"release-gate": 19,
+		"release-gate": 22,
+		"retired-sent-surface": 2,
 		"resume-args": 6,
 		"resume-launch-identity": 6,
 		"self-address": 8,
@@ -902,6 +907,42 @@ let manifestCount: number;
 				(err instanceof Error ? err.message : String(err)),
 		);
 	}
+	// FIND MATCHES ITS SUBJECT, EXACTLY ONCE — the body's own precondition, hoisted into the head.
+	// `validateManifestSet` above proves the subject is TRACKED; it never opens it. So a change
+	// that edits a subject line a mutant quotes leaves the whole deterministic floor green and
+	// dies an hour later in CI or the release gate as MUTANT-STALE. That is exactly how the
+	// 0.23.2 pi bump landed: `pack_install_leaked_pi`'s pin regex moved 0.85.1 → 0.86.0 in
+	// run.sh, `scripts/mutants/pack-install.json` kept quoting the old line, and two claims came
+	// back NOT KILLED after ~50 minutes of mutant execution. The check costs one read per
+	// mutant and uses `countOccurrences` — the SAME function the body applies at
+	// mutation-qualify.ts:743 — so head and body cannot disagree about what "matches" means.
+	// This is a STALENESS check, not a kill-proof: it says the mutant still has a subject to
+	// corrupt, never that corrupting it is caught. That remains the body's verdict.
+	const stale: string[] = [];
+	for (const man of manifests) {
+		for (const m of man.mutants) {
+			const subjectAbs = path.join(REPO_DIR, m.subject);
+			let source: string;
+			try {
+				source = fs.readFileSync(subjectAbs, "utf8");
+			} catch (err) {
+				stale.push(`${man.lane}/${m.claim}: subject ${m.subject} unreadable (${(err as Error).message})`);
+				continue;
+			}
+			const n = countOccurrences(source, m.find.join("\n"));
+			if (n !== 1) stale.push(`${man.lane}/${m.claim}: find matched ${n}× in ${m.subject} (expected exactly 1)`);
+		}
+	}
+	assert.deepEqual(
+		stale,
+		[],
+		"[QK:MUTANT-FIND-MATCHES-SUBJECT] every mutant's `find` must match its subject exactly once. A find that " +
+			"matches 0× is a mutant whose production line moved out from under it — the body can write nothing, the " +
+			"verdict is MUTANT-STALE, and the claim is silently unproven; a find that matches 2+× cannot say WHICH " +
+			"occurrence it corrupts. Either way the manifest and the source have to move together. Found:\n" +
+			stale.join("\n"),
+	);
+
 	manifestCount = manifests.length;
 	console.log(`[${SURFACE}] ${selected.length} mutants across ${manifestCount} lanes (no tiers — full set every run)`);
 }
@@ -909,7 +950,8 @@ let manifestCount: number;
 if (MANIFESTS_ONLY) {
 	console.log(
 		`[check-gate-manifests] ok — runner self-test green, ${selected.length} committed mutants across ` +
-			`${manifestCount} lanes validated against the origin index, and the lane inventory matches its declared ` +
+			`${manifestCount} lanes validated against the origin index, every one of their \`find\` strings still ` +
+			"matching its subject exactly once, and the lane inventory matching its declared " +
 			"contract. ZERO mutants were executed and this repo was never snapshotted: the body " +
 			"(check-gate-qualification) owns that, unchanged.",
 	);

package/scripts/check-herdr-activation.ts

@@ -205,6 +205,21 @@ const {
 	COMPONENT_STATES,
 } = mod;
 
+/** The pi pin package.json declares — 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>;
+	}
+).devDependencies["@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 {
+	fs.mkdirSync(dir, { recursive: true });
+	const file = path.join(dir, name);
+	fs.writeFileSync(file, `#!/bin/sh\necho ${version}\n`, { mode: 0o755 });
+	return file;
+}
+
 function world(tag: string): NodeJS.ProcessEnv {
 	const home = reclaimOnExit(fs.mkdtempSync(path.join(os.tmpdir(), `entwurf-hac-${tag}-`)));
 	for (const d of [".config", ".state", ".data", ".cache", "pi-agent", ".claude"]) {
@@ -220,6 +235,13 @@ function world(tag: string): NodeJS.ProcessEnv {
 		XDG_CACHE_HOME: path.join(home, ".cache"),
 		PI_CODING_AGENT_DIR: path.join(home, "pi-agent"),
 		CLAUDE_CONFIG_DIR: path.join(home, ".claude"),
+		// PI_BIN is a sandbox root like the four XDG vars above, not a convenience. Since #119
+		// `install-user-scope` probes `pi --version` against the same closed range setup enforces,
+		// so leaving this unset would let the OPERATOR'S installed pi decide whether these cells
+		// pass — the gate would go red on a developer machine sitting one minor behind the pin and
+		// green on another, for reasons none of these cells are about. It is pinned IN RANGE here;
+		// the one cell whose subject IS the floor overrides it per run.
+		PI_BIN: fakePi(path.join(home, "bin"), "pi", PI_PIN),
 	};
 }
 
@@ -330,6 +352,57 @@ function ledgerWith(
 	);
 }
 
+// ── 1b. the plugin door enforces the SAME pi floor the setup door does ────────
+// #119: `setup` refuses an out-of-range pi by name before it writes any Pi wiring, but
+// `install-user-scope` — the door herdr plugin activation actually goes through
+// (plugins/herdr/lib/build.mjs → scripts/herdr-plugin-activate.mjs → `run.sh
+// install-user-scope --plugin-runtime …`) — had no version check at all. Two doors onto ONE
+// registration telling different truths is the whole defect, so the oracle here is the
+// out-of-range/in-range PAIR: the refusal alone would also be satisfied by a door that refuses
+// everything. Absent pi is deliberately NOT asserted as a third state — this verb invents no
+// presence verdict, setup owns that one.
+{
+	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
+	// `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);
+	const belowFloor = `${maj}.${min - 1}.0`;
+	const settingsPath = path.join(env.PI_CODING_AGENT_DIR as string, "settings.json");
+	fs.writeFileSync(settingsPath, '{"theme":"dark"}\n');
+	const before = fs.readFileSync(settingsPath, "utf8");
+
+	const stale = sh({ ...env, PI_BIN: fakePi(bin, "stale-pi", belowFloor) }, [
+		"install-user-scope",
+		"--plugin-runtime",
+		runtimeRootOf(env),
+	]);
+	const afterRefusal = fs.readFileSync(settingsPath, "utf8");
+	const current = sh({ ...env, PI_BIN: fakePi(bin, "current-pi", PI_PIN) }, [
+		"install-user-scope",
+		"--plugin-runtime",
+		runtimeRootOf(env),
+	]);
+	const afterAccept = readJson(settingsPath) as { packages?: string[] };
+
+	ok(
+		"[QK:HAC-PI-FLOOR-BOTH-DOORS] the plugin activation door enforces the SAME closed pi range as the " +
+			"setup door: a below-floor pi is a named FAIL that writes zero settings bytes (not a SKIP, not a " +
+			"silent write), while an in-range pi still registers — one registration reached through two doors " +
+			"may not report two different verdicts, and the range both read is DERIVED from one package.json pin " +
+			`(pin=${PI_PIN} stale=${belowFloor}/exit=${stale.status} named=${(stale.stderr || "").includes("outside the supported range")} ` +
+			`untouched=${before === afterRefusal} current=exit=${current.status}/packages=${JSON.stringify(afterAccept.packages)})`,
+		stale.status !== 0 &&
+			(stale.stderr || "").includes("[install-user-scope] pi: FAIL") &&
+			(stale.stderr || "").includes("outside the supported range") &&
+			before === afterRefusal &&
+			current.status === 0 &&
+			Array.isArray(afterAccept.packages) &&
+			afterAccept.packages.length === 1,
+	);
+}
+
 // ── 2. the plugin command is DERIVED from the runtime root, never supplied ─────
 {
 	const env = world("derived");

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

@@ -270,7 +270,7 @@ const START_ERR = JSON.stringify({
 });
 
 const CALLER = "20260914T174741-2e9ba9";
-const NONCE = "herdr-fresh-call-0123456789abcdef01234567";
+const NONCE = "mux-fresh-call-0123456789abcdef01234567";
 const HERDR_ENV = { HERDR_ENV: "1", HERDR_BIN_PATH: "/home/operator/.local/bin/herdr", HERDR_PANE_ID: "w7:p1" };
 
 type ScriptedReply =
@@ -344,9 +344,19 @@ async function main(): Promise<void> {
 	const code = MODULE_SRC.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
 	const specifiers = [...MODULE_SRC.matchAll(/^import\s[^;]*?from\s+"([^"]+)";$/gm)].map((m) => m[1]);
 	ok(
-		"[QK:HFC-RAIL-IMPORT-FENCE] the herdr rail imports only node builtins and the neutral composition leaf — one mux or entwurf import here would re-couple the two rails and make either one undeletable",
+		"[QK:HFC-RAIL-IMPORT-FENCE] the herdr rail imports only node builtins, the neutral composition leaf, the callback-env pair, and the dependency-free rails DECLARATION leaf — one mux or entwurf import here would re-couple the two rails and make either one undeletable",
 		specifiers.length > 0 &&
-			specifiers.every((s) => s.startsWith("node:") || s === "./fresh-call-composition.ts") &&
+			specifiers.every(
+				(s) =>
+					s.startsWith("node:") ||
+					s === "./fresh-call-composition.ts" ||
+					s === "./callback-env.ts" ||
+					// #116 A7 — the ONE place the backend tuple and the per-backend model syntax
+					// example are written, shared with the status pane and the install narration.
+					// It imports nothing itself, so admitting it couples this rail to a constant
+					// rather than to another rail; the mux/entwurf ban below is untouched.
+					s === "../../scripts/herdr-rails.mjs",
+			) &&
 			!/from\s+"\.\/(mux-|entwurf-)/.test(code),
 	);
 	// tmux is NAMED in this module, and only in one place: the refusal of a tmux seat input.
@@ -453,15 +463,29 @@ async function main(): Promise<void> {
 	// ── argv grammar ─────────────────────────────────────────────────────────────────────
 	// Pure builders are checked before full launch paths so a framing mutant is attributed to
 	// its own contract rather than making an earlier integration success cell fail first.
-	const tabArgs = buildHerdrTabCreateArgs({ workspaceId: "w7", cwd: "/repo/dir" });
+	const tabCallback = {
+		target: "20260101T010101-aaaaaa",
+		nonce: "mux-fresh-call-deadbeefdeadbeefdeadbeef",
+	};
+	const tabArgs = buildHerdrTabCreateArgs({ workspaceId: "w7", cwd: "/repo/dir", callback: tabCallback });
+	// The SPECIFIC claim runs before the umbrella one. `ok` throws, so the first red assertion is
+	// the only one a mutant run ever prints: with the exact-argv cell first, the callback-pair
+	// mutant died on the whole-argv claim below and never reached its own — a WRONG-REASON that
+	// qualification is exactly there to catch. Order is the fix; both cells keep their subject,
+	// and the argv cell keeps its own mutant, which drops `--no-focus` and this cell cannot see.
+	ok(
+		"[QK:HFC-CALLBACK-ENV] the launcher-computed callback pair rides as two more --env assignments beside the scrub",
+		tabArgs.includes("ENTWURF_CALLBACK_TARGET=20260101T010101-aaaaaa") &&
+			tabArgs.includes("ENTWURF_CALLBACK_NONCE=mux-fresh-call-deadbeefdeadbeefdeadbeef"),
+	);
 	ok(
 		"[QK:HFC-TAB-ARGV] one placement policy — a NEW TAB in the caller's own workspace, named explicitly so herdr cannot default it to the focused one, focus left alone, cwd carried literally, and BOTH identity carriers scrubbed by explicit repeated --env",
 		tabArgs.join(" ") ===
-			"tab create --workspace w7 --no-focus --cwd /repo/dir --env PI_SESSION_ID= --env PI_AGENT_ID=",
+			"tab create --workspace w7 --no-focus --cwd /repo/dir --env PI_SESSION_ID= --env PI_AGENT_ID= --env ENTWURF_CALLBACK_TARGET=20260101T010101-aaaaaa --env ENTWURF_CALLBACK_NONCE=mux-fresh-call-deadbeefdeadbeefdeadbeef",
 	);
 	ok(
 		"a cwd-free tab create omits --cwd entirely rather than sending an empty value, and the rail adds no layout axis of its own — no label, no ratio, no direction",
-		!buildHerdrTabCreateArgs({ workspaceId: "w7" }).includes("--cwd") &&
+		!buildHerdrTabCreateArgs({ workspaceId: "w7", callback: tabCallback }).includes("--cwd") &&
 			!tabArgs.includes("--label") &&
 			!tabArgs.includes("--ratio") &&
 			!tabArgs.includes("--direction"),

package/scripts/check-herdr-placement.ts

@@ -165,6 +165,57 @@ async function main(): Promise<void> {
 			piNativeSessionIdFromPath("/s/2026-09-14T05-17-03-979Z_not-a-uuid.jsonl") === null &&
 			piNativeSessionIdFromPath(`/s/${PI_NATIVE}.jsonl`) === null,
 	);
+	{
+		// THE VENDOR HALF OF THAT CLAIM, FROM THE INSTALLED VENDOR — not a literal we typed.
+		// The key this parser recovers lives inside a filename pi builds, so the rule is only as
+		// true as pi's naming, and a source read cannot settle whether that naming is a contract
+		// or a convention. `[측정 2026-09-22, @earendil-works/pi-coding-agent 0.87.0]` the installed
+		// `SessionManager` writes a REAL session file here, in a temp dir, with zero model, zero
+		// network and zero child process: `create()` then one `appendMessage` flushes
+		// `<stamp>_<id>.jsonl` whose own `{"type":"session"}` header carries the same id.
+		//
+		// The 0.86.0 receipt this replaces needed a provider call and was therefore taken by hand
+		// once; it stays in the bump ledger as a 0.86.0 fact. This one re-takes itself on every
+		// run, so the vendor floor cannot drift under us silently again.
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "entwurf-hp-vendor-"));
+		try {
+			const { SessionManager } = await import("@earendil-works/pi-coding-agent");
+			const manager = await SessionManager.create(process.cwd(), dir);
+			await manager.appendMessage({
+				role: "assistant",
+				content: [{ type: "text", text: "placement vendor-floor probe" }],
+				api: "test",
+				provider: "test",
+				model: "test",
+				// Zero everything: this message exists to make the manager flush a file, and a
+				// fixture that invented usage numbers would be inventing vendor accounting too.
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+				},
+				stopReason: "stop",
+				timestamp: Date.now(),
+			});
+			const written = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+			const header = JSON.parse(readFileSync(path.join(dir, written[0]), "utf8").split("\n")[0]);
+			const recovered = piNativeSessionIdFromPath(path.join(dir, written[0]));
+			ok(
+				"the vendor floor is re-measured, not remembered: the installed pi writes a real session file whose " +
+					"basename this parser reads back to the same id its own header declares",
+				written.length === 1 &&
+					header.type === "session" &&
+					typeof header.id === "string" &&
+					recovered === header.id &&
+					recovered === manager.getSessionId(),
+			);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	}
 	ok(
 		"[QK:HP-JOIN-NEVER-GUESSES] an unmeasured agent_session kind and an empty value both yield NO key — an " +
 			"unknown herdr shape is declined, never coerced into one of the two rules we actually measured",

package/scripts/check-herdr-plugin-build.ts

@@ -33,6 +33,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import * as HERDR_RAILS from "./herdr-rails.mjs";
 import { reclaimOnExit } from "./lib/reclaim-on-exit.ts";
 import { treeDigest } from "./lib/tree-digest.ts";
 
@@ -769,17 +770,23 @@ function drive(
 			// contains `claude-sonnet-5`, so a containment test cannot tell the two grammars apart —
 			// which is the whole claim.
 			const idIn = (lines: string[], backend: string): string | null => {
-				const line = lines.find((l) => l.startsWith(`note: ${backend}: `) && l.includes("model id looks like"));
+				const line = lines.find((l) => l.startsWith(`note: ${backend}: `) && l.includes("model string looks like"));
 				return line === undefined ? null : (/`([^`]+)`/.exec(line)?.[1] ?? null);
 			};
 			const piId = idIn(notesOf(full), "pi");
 			const claudeId = idIn(notesOf(full), "claude-code");
 			return (
-				piId === "openai-codex/gpt-5.6-terra" &&
+				// Compared against the SHARED leaf, not a literal copied into this gate: the install
+				// narration and the status pane's RAILS block now read one declaration
+				// (`scripts/herdr-rails.mjs`, #116 A7), and a gate holding its own third copy would
+				// be the very drift that leaf exists to stop. The GRAMMAR assertions stay literal —
+				// provider-qualified vs bare vendor id is the fact, and it must not become whatever
+				// the leaf happens to say.
+				piId === HERDR_RAILS.MODEL_SYNTAX_EXAMPLE.pi &&
 				piId.includes("/") &&
-				claudeId === "claude-sonnet-5" &&
+				claudeId === HERDR_RAILS.MODEL_SYNTAX_EXAMPLE["claude-code"] &&
 				!claudeId.includes("/") &&
-				idIn(notesOf(piOnly), "pi") === "openai-codex/gpt-5.6-terra" &&
+				idIn(notesOf(piOnly), "pi") === HERDR_RAILS.MODEL_SYNTAX_EXAMPLE.pi &&
 				idIn(notesOf(piOnly), "claude-code") === null
 			);
 		})(),