@junghanacs/entwurf 0.25.0 → 0.30.0

package/scripts/lib/qualification-release.ts

@@ -0,0 +1,271 @@
+/**
+ * qualification-release — compose a RELEASE ledger from CI collections along a
+ * first-parent chain (#124 step 2). PURE: no network, no git, no fs. The caller hands
+ * in what it has already fetched and verified elsewhere; this function never claims its
+ * inputs came from anywhere in particular, and it produces no acceptance class.
+ *
+ * Inputs:
+ *   - finalSha and firstParent (`git rev-list --first-parent finalSha`, finalSha first);
+ *   - runs: one entry per CI run attempt — runId, runAttempt, headSha, and the unpacked
+ *     collection files (name → bytes);
+ *   - independent: the candidate recomputed by the caller from the final tree ITSELF
+ *     (surface, groups, manifest claims, CORE_FILES fingerprints). Its node/node_modules
+ *     part cannot be recomputed off the CI runner and is not used;
+ *   - operatorDeclared: extra groups a human requires to be measured on the final SHA.
+ *
+ * Contract errors (any → RED): a run that is not CI provenance (runId/runAttempt not
+ * digits), a headSha off the first-parent chain, the same (runId, runAttempt) twice, a
+ * collection whose own runId/runAttempt/head disagree with the run, no collection at the
+ * final SHA, an incomplete final collection, or a final candidate the independent
+ * recomputation contradicts.
+ *
+ * Per SHA only the newest (runId, then runAttempt) run counts; older ones are listed as
+ * superseded. An incomplete ancestor collection is excluded from the basis with its
+ * reason. Order across runs is first-parent position, then collection index — never a
+ * clock. Release blockers on top of the local ones: every group needs a usable pass
+ * receipt somewhere in the chain (UNRUN blocks), and the runner group, every group whose
+ * newest receipt in the chain is red, and every operator-declared group must be
+ * exact-MEASURED on the final SHA. A red on an ancestor that the final SHA re-measured
+ * green stays in history and contributes no FAIL.
+ */
+
+import { type Collection, checkCollectionData, mapReader } from "./qualification-collection.ts";
+import {
+	type ContentCandidate,
+	type CurrentCandidate,
+	composeLedger,
+	type Ledger,
+	type LoadedReceipt,
+} from "./qualification-ledger.ts";
+import { canonicalJson } from "./qualification-receipt.ts";
+
+export interface CiRun {
+	runId: string;
+	runAttempt: string;
+	headSha: string;
+	files: Record<string, Buffer>;
+}
+
+export interface ReleaseInput {
+	finalSha: string;
+	firstParent: string[];
+	runs: CiRun[];
+	/** The final tree's content projection — no C0 environment part (see ContentCandidate). */
+	independent: ContentCandidate;
+	operatorDeclared: string[][];
+}
+
+export interface RunRef {
+	runId: string;
+	runAttempt: string;
+	headSha: string;
+}
+
+export interface ReleaseLedger extends Ledger {
+	release: {
+		finalSha: string;
+		contractErrors: string[];
+		crossCheck: string[];
+		used: RunRef[];
+		excluded: (RunRef & { reason: string })[];
+		required: string[][];
+		denominator: {
+			groups: number;
+			claims: number;
+			measuredOnFinal: { groups: number; claims: number; list: string[] };
+			inheritedCore: { gate: string; from: RunRef | null; reason: string }[];
+			flagged: string[];
+			unrun: number;
+			fail: number;
+		};
+		/** What this ledger can and cannot vouch for. */
+		provenance: string[];
+	};
+}
+
+const DIGITS = /^[0-9]+$/;
+const refOf = (r: CiRun): RunRef => ({ runId: r.runId, runAttempt: r.runAttempt, headSha: r.headSha });
+const newer = (a: CiRun, b: CiRun): boolean =>
+	BigInt(a.runId) !== BigInt(b.runId) ? BigInt(a.runId) > BigInt(b.runId) : BigInt(a.runAttempt) > BigInt(b.runAttempt);
+
+/** Content fields a CI-claimed candidate must share with the independent recomputation. */
+export function crossCheckCandidate(claimed: CurrentCandidate, independent: ContentCandidate): string[] {
+	const out: string[] = [];
+	if (claimed.head !== independent.head) out.push(`head: CI ${claimed.head} vs tree ${independent.head}`);
+	if (claimed.workSurfaceSha256 !== independent.workSurfaceSha256) out.push("workSurface");
+	if (canonicalJson(claimed.manifestClaims) !== canonicalJson(independent.manifestClaims)) out.push("manifestClaims");
+	if (canonicalJson(claimed.groups) !== canonicalJson(independent.groups)) out.push("groups");
+	if (!claimed.coreFiles || !independent.coreFiles) out.push("coreFiles: missing on one side");
+	else if (canonicalJson(claimed.coreFiles) !== canonicalJson(independent.coreFiles)) out.push("coreFiles");
+	return out;
+}
+
+export function composeRelease(input: ReleaseInput): ReleaseLedger {
+	const contractErrors: string[] = [];
+	const excluded: ReleaseLedger["release"]["excluded"] = [];
+	const chainPos = new Map(input.firstParent.map((sha, i) => [sha, i]));
+	if (input.firstParent[0] !== input.finalSha) contractErrors.push("firstParent must start with finalSha");
+
+	// 1. Admission: provenance shape, chain membership, uniqueness, collection integrity.
+	const seenAttempt = new Set<string>();
+	const admitted: { run: CiRun; collection: Collection; complete: boolean; errors: string[] }[] = [];
+	for (const run of input.runs) {
+		const tag = `run ${run.runId}#${run.runAttempt}@${run.headSha.slice(0, 12)}`;
+		if (!DIGITS.test(run.runId) || !DIGITS.test(run.runAttempt)) {
+			contractErrors.push(`${tag}: runId/runAttempt are not CI provenance`);
+			continue;
+		}
+		const key = `${run.runId}#${run.runAttempt}`;
+		if (seenAttempt.has(key)) {
+			contractErrors.push(`${tag}: the same run attempt is supplied twice`);
+			continue;
+		}
+		seenAttempt.add(key);
+		if (!chainPos.has(run.headSha)) {
+			contractErrors.push(`${tag}: headSha is not on the first-parent chain of ${input.finalSha.slice(0, 12)}`);
+			continue;
+		}
+		const { errors, collection } = checkCollectionData(mapReader(run.files), Object.keys(run.files).sort());
+		if (!collection) {
+			contractErrors.push(`${tag}: ${errors.join("; ")}`);
+			continue;
+		}
+		if (collection.runId !== run.runId || collection.runAttempt !== run.runAttempt) {
+			contractErrors.push(`${tag}: the collection records run ${collection.runId}#${collection.runAttempt}`);
+			continue;
+		}
+		if (collection.candidate.head !== run.headSha) {
+			contractErrors.push(`${tag}: the collection measured head ${collection.candidate.head}`);
+			continue;
+		}
+		admitted.push({ run, collection, complete: errors.length === 0, errors });
+	}
+
+	// 2. One run per SHA: the newest attempt wins; the rest are superseded, never mixed in.
+	const perSha = new Map<string, (typeof admitted)[number]>();
+	for (const a of admitted) {
+		const cur = perSha.get(a.run.headSha);
+		if (!cur || newer(a.run, cur.run)) {
+			if (cur) excluded.push({ ...refOf(cur.run), reason: `superseded by run ${a.run.runId}#${a.run.runAttempt}` });
+			perSha.set(a.run.headSha, a);
+		} else {
+			excluded.push({ ...refOf(a.run), reason: `superseded by run ${cur.run.runId}#${cur.run.runAttempt}` });
+		}
+	}
+	const finalEntry = perSha.get(input.finalSha);
+	if (!finalEntry) contractErrors.push(`no CI collection at the final SHA ${input.finalSha.slice(0, 12)}`);
+	else if (!finalEntry.complete)
+		contractErrors.push(`final-SHA collection incomplete: ${finalEntry.errors.join("; ")}`);
+	const used: (typeof admitted)[number][] = [];
+	for (const [sha, a] of perSha) {
+		if (sha !== input.finalSha && !a.complete) {
+			excluded.push({ ...refOf(a.run), reason: `incomplete ancestor collection, not a basis: ${a.errors.join("; ")}` });
+			continue;
+		}
+		used.push(a);
+	}
+
+	// 3. The final candidate: content from the independent recomputation, C0 environment
+	//    part (node, node_modules) as the final run witnessed it.
+	const crossCheck = finalEntry ? crossCheckCandidate(finalEntry.collection.candidate, input.independent) : [];
+	const current: CurrentCandidate = {
+		...input.independent,
+		head: input.finalSha,
+		// porcelainClean stays the INDEPENDENT candidate's own: a clean final tree is the
+		// oracle's to produce and prove, never this function's to assume.
+		coreSha256: finalEntry ? finalEntry.collection.candidate.coreSha256 : "unwitnessed",
+	};
+
+	// 4. Receipts in chain order (older first-parent position first), collection index next.
+	const maxPos = input.firstParent.length;
+	const loaded: LoadedReceipt[] = [];
+	const receiptRun = new Map<string, RunRef>();
+	const finalSources = new Set<string>();
+	for (const a of used) {
+		const base = (maxPos - (chainPos.get(a.run.headSha) ?? maxPos)) * 1_000_000;
+		a.collection.attempted.forEach((att, i) => {
+			if (att.outcome !== "receipt-written" || !att.file) return;
+			const bytes = a.run.files[att.file];
+			if (!bytes) return;
+			if (a.run.headSha === input.finalSha) finalSources.add(`run ${a.run.runId}#${a.run.runAttempt}/${att.file}`);
+			loaded.push({
+				source: `run ${a.run.runId}#${a.run.runAttempt}/${att.file}`,
+				text: bytes.toString("utf8"),
+				seq: base + i,
+			});
+			try {
+				receiptRun.set(JSON.parse(bytes.toString("utf8")).receiptSha256, refOf(a.run));
+			} catch {
+				// unparseable: composeLedger reports it as INVALID
+			}
+		});
+	}
+
+	// 5. The required set on the final SHA: runner, every group whose newest receipt among
+	//    the ANCESTOR runs is red (the section that broke — computed before the final run,
+	//    so re-measuring it green does not erase the requirement), operator-declared.
+	const newestPassed = new Map<string, boolean>();
+	for (const l of [...loaded].filter((x) => !finalSources.has(x.source)).sort((x, y) => (x.seq ?? 0) - (y.seq ?? 0))) {
+		try {
+			const r = JSON.parse(l.text);
+			newestPassed.set(JSON.stringify(r.group.gate), r.result.passed === true);
+		} catch {
+			// INVALID, reported by composeLedger
+		}
+	}
+	const requiredKeys = new Set<string>([JSON.stringify(input.independent.coreGroupGate)]);
+	for (const [k, passed] of newestPassed) if (!passed) requiredKeys.add(k);
+	for (const argv of input.operatorDeclared) requiredKeys.add(JSON.stringify(argv));
+	const required = [...requiredKeys].map((k) => JSON.parse(k) as string[]);
+
+	const ledger = composeLedger(loaded, current, undefined, { mode: "release", required });
+	const red = contractErrors.length > 0 || crossCheck.length > 0;
+	const verdict = red ? "RED" : ledger.verdict;
+	const summary = [
+		...(red ? [`[qualification-release] RED on ${input.finalSha.slice(0, 12)}`] : []),
+		...contractErrors.map((e) => `  CONTRACT ${e}`),
+		...crossCheck.map((e) => `  CROSS-CHECK ${e}: the CI-claimed candidate contradicts the final tree`),
+		...excluded.map((e) => `  EXCLUDED run ${e.runId}#${e.runAttempt}@${e.headSha.slice(0, 12)}: ${e.reason}`),
+		...ledger.summary,
+	];
+	const measured = ledger.groups.filter((g) => g.state === "MEASURED" && g.provenance === "exact");
+	return {
+		...ledger,
+		verdict,
+		summary,
+		release: {
+			finalSha: input.finalSha,
+			contractErrors,
+			crossCheck,
+			used: used.map((a) => refOf(a.run)),
+			excluded,
+			required,
+			denominator: {
+				groups: ledger.counts.groups.total,
+				claims: ledger.counts.claims.total,
+				measuredOnFinal: {
+					groups: measured.length,
+					claims: measured.reduce((n, g) => n + g.claims.length, 0),
+					list: measured.map((g) => g.gate.join(" ")),
+				},
+				inheritedCore: ledger.groups
+					.filter((g) => g.state === "INHERITED-UNVERIFIED" && g.inheritKind === "c-core")
+					.map((g) => ({
+						gate: g.gate.join(" "),
+						from: (g.decidedBy && receiptRun.get(g.decidedBy)) || null,
+						reason: g.reasons[0],
+					})),
+				flagged: ledger.groups
+					.filter((g) => g.flags.length > 0)
+					.map((g) => `${g.gate.join(" ")}: ${g.flags.join("; ")}`),
+				unrun: ledger.counts.groups.UNRUN,
+				fail: ledger.counts.groups.FAIL,
+			},
+			provenance: [
+				"inputs are whatever the caller supplied; this function does not fetch or authenticate them",
+				"node/node_modules identity is the final run's own witness, not recomputed here",
+				"no acceptance class is produced: RISK-PENDING awaits a human decision",
+			],
+		},
+	};
+}

package/scripts/meta-bridge-doctor.sh

@@ -1252,12 +1252,23 @@ V2_MCP_SRC="$REPO/mcp/entwurf-bridge/src/index.ts"
 if [ -f "$V2_CONTROL_SRC" ] && grep -q 'ENTWURF_FLAG = "entwurf-control"' "$V2_CONTROL_SRC" && grep -q 'registerFlag(ENTWURF_FLAG' "$V2_CONTROL_SRC"; then
   ok "pi-native --entwurf-control flag registered (ENTWURF_FLAG)"
 else
-  bad "pi-native --entwurf-control flag not found in entwurf-control.ts — the v2 pi tool depends on it"
+  bad "pi-native --entwurf-control flag not found in entwurf-control.ts — record birth and the MCP registration depend on it"
 fi
-if [ -f "$V2_CONTROL_SRC" ] && grep -q 'registerEntwurfV2Tool' "$V2_CONTROL_SRC" && grep -q 'name: "entwurf_v2"' "$V2_CONTROL_SRC"; then
-  ok "pi-native entwurf_v2 tool registered"
+# #125: a pi session no longer carries native Entwurf tools — the extension registers the compiled
+# entwurf-bridge with Pi's built-in MCP after record birth. This is STATIC DETECTION only: it proves
+# the shipped source makes that registration and the compiled entry it points at shipped. It does NOT
+# prove a running pi spawned the child or that a same-name mcp.json entry did not replace it (Pi's
+# `/mcp` reports that) — runtime reachability is the MCP verb check below and `doctor-pi-provider`.
+V2_BRIDGE_DIST="$REPO/mcp/entwurf-bridge/dist/mcp/entwurf-bridge/src/index.js"
+if [ -f "$V2_CONTROL_SRC" ] && grep -q 'pi.registerMcpServer(' "$V2_CONTROL_SRC" && grep -q 'ENTWURF_MCP_SERVER_NAME' "$V2_CONTROL_SRC"; then
+  ok "pi-native: entwurf-control registers the entwurf-bridge MCP server (static detection)"
 else
-  bad "pi-native entwurf_v2 tool not found in entwurf-control.ts"
+  bad "pi-native: entwurf-control.ts does not register the entwurf-bridge MCP server — a pi session would have no Entwurf verbs"
+fi
+if [ -f "$V2_BRIDGE_DIST" ]; then
+  ok "pi-native: compiled entwurf-bridge entry present (the path the registration points at)"
+else
+  bad "pi-native: compiled entwurf-bridge entry missing at $V2_BRIDGE_DIST — run: pnpm run build-bridge"
 fi
 if [ -f "$V2_MCP_SRC" ] && grep -q 'server.tool(' "$V2_MCP_SRC" && grep -q '"entwurf_v2"' "$V2_MCP_SRC"; then
   ok "MCP entwurf_v2 verb registered"
@@ -1282,7 +1293,7 @@ case "$REPO" in
     ;;
   *)
     if [ -f "$V2_SURFACE_SRC" ] && (cd "$REPO" && node --experimental-strip-types scripts/check-entwurf-v2-surface.ts >/dev/null 2>&1); then
-      ok "check-entwurf-v2-surface gate passes (surface adapter + pi-native/MCP wiring)"
+      ok "check-entwurf-v2-surface gate passes (surface adapter + MCP wiring + pi receiver)"
     else
       bad "check-entwurf-v2-surface gate FAILED or surface adapter missing — run: ./run.sh check-entwurf-v2-surface"
     fi

package/scripts/mutants/acp-foreground-only.json

@@ -0,0 +1,17 @@
+{
+	"schemaVersion": 1,
+	"lane": "acp-foreground-only",
+	"mutants": [
+		{
+			"claim": "ACP-CLAUDE-FOREGROUND-ONLY",
+			"title": "the claude launch env loses the background-task switch — a backgrounded command outlives an ACP cancel and is orphaned to init when the child exits",
+			"subject": "pi-extensions/lib/acp/backend-adapter.ts",
+			"find": ["\t\treturn { ...claudeLaunchEnvDefaults(), ...CLAUDE_FOREGROUND_ONLY_ENV };"],
+			"replace": ["\t\treturn claudeLaunchEnvDefaults();"],
+			"gate": ["bash", "run.sh", "check-acp-foreground-only"],
+			"timeoutSeconds": 60,
+			"signature": "[QK:ACP-CLAUDE-FOREGROUND-ONLY]",
+			"signatureSource": "pi-extensions/lib/acp/backend-adapter.test.ts"
+		}
+	]
+}

package/scripts/mutants/codex-native.json

@@ -393,17 +393,6 @@
 			"signature": "[QK:FRESHCALL-CODEX-PREMUTATION-MCP]",
 			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
 		},
-		{
-			"claim": "FRESHCALL-CODEX-PREMUTATION-PI",
-			"title": "the native pi public surface relabels a Codex request as pi at the shared dispatcher seam, bypassing the same central preflight from the other public door",
-			"subject": "pi-extensions/entwurf-control.ts",
-			"find": ["\t\t\t\t\tbackend: params.backend,"],
-			"replace": ["\t\t\t\t\tbackend: \"pi\","],
-			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
-			"timeoutSeconds": 180,
-			"signature": "[QK:FRESHCALL-CODEX-PREMUTATION-PI]",
-			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
-		},
 		{
 			"claim": "CODEX-BIRTH-DOCTOR-REQUIRES-TRUST",
 			"title": "the doctor treats the vendor trust receipt as optional, so a declared hook the vendor will never run reports green",
@@ -648,6 +637,17 @@
 			"signature": "[QK:CODEX-LIVE-REPORT-TOKEN-EXACT]",
 			"signatureSource": "test/codex-fresh-live-protocol.test.ts"
 		},
+		{
+			"claim": "CODEX-LIVE-PI-MCP-SOURCE-DIALECT",
+			"title": "Pi's current qualified fresh-call receipt no longer reaches semantic launch and cleanup authority, recreating the Pi 1.0 timeout",
+			"subject": "scripts/lib/codex-fresh-source-receipts.ts",
+			"find": ["\t[\"mcp__entwurf_bridge__entwurf_fresh_call\", \"entwurf_fresh_call\"],"],
+			"replace": ["\t[\"mcp__entwurf_bridge__entwurf_fresh_call\", \"unrecognized_pi_fresh_call\"],"],
+			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:CODEX-LIVE-PI-MCP-SOURCE-DIALECT]",
+			"signatureSource": "test/codex-fresh-live-protocol.test.ts"
+		},
 		{
 			"claim": "CODEX-LIVE-SOURCE-JOIN",
 			"title": "a Pi tool result can be joined to a call whose tool name differs, turning an unrelated result body into launch authority",

package/scripts/mutants/control-send-receipt.json

@@ -174,14 +174,15 @@
 			"gate": ["bash", "run.sh", "check-tests-beside-behavior"],
 			"timeoutSeconds": 600,
 			"signature": "[QK:VITEST-TEST-DIR-ON-THE-FLOOR]",
-			"signatureSource": "run.sh"
+			"signatureSource": "run.sh",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
 		},
 		{
 			"claim": "PI-CORE-PIN-TRACKS-FLOOR",
 			"title": "the queue oracle's pi-agent-core pin drifts off the floor the rest of the pi runtime is pinned to, so the oracle keeps answering honestly — about a pi nobody in this repo runs",
 			"subject": "package.json",
-			"find": ["\"@earendil-works/pi-agent-core\": \"0.87.1\","],
-			"replace": ["\"@earendil-works/pi-agent-core\": \"0.86.0\","],
+			"find": ["\"@earendil-works/pi-agent-core\": \"1.0.0\","],
+			"replace": ["\"@earendil-works/pi-agent-core\": \"0.87.1\","],
 			"gate": ["bash", "run.sh", "check-dep-versions"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:PI-CORE-PIN-TRACKS-FLOOR]",
@@ -218,7 +219,8 @@
 			"gate": ["bash", "run.sh", "check-tests-beside-behavior"],
 			"timeoutSeconds": 600,
 			"signature": "[QK:VITEST-TEST-DIR-HAS-COORDINATE]",
-			"signatureSource": "run.sh"
+			"signatureSource": "run.sh",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
 		},
 		{
 			"claim": "SEND-OUTCOME-LIST-NAMES-EVERY-RAIL",

package/scripts/mutants/copilot-birth.json

@@ -101,7 +101,8 @@
 			"gate": ["bash", "run.sh", "check-meta-doctor-oracle"],
 			"timeoutSeconds": 600,
 			"signature": "[QK:HOOK-LOG-RAIL-SCOPED]",
-			"signatureSource": "scripts/check-meta-doctor-oracle.sh"
+			"signatureSource": "scripts/check-meta-doctor-oracle.sh",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
 		},
 		{
 			"claim": "COPILOT-BIRTH-DOES-NOT-ARM-RECEIVER",

package/scripts/mutants/fresh-call-dispatch.json

@@ -75,8 +75,8 @@
 			"signatureSource": "scripts/check-fresh-call-dispatch.ts"
 		},
 		{
-			"claim": "FCD-SURFACE-PARITY",
-			"title": "the MCP surface goes back to calling a rail directly, so the two public surfaces can drift on rail choice",
+			"claim": "FCD-SURFACE-ROOT-ONLY",
+			"title": "the one public fresh-call surface goes back to choosing a rail itself instead of reaching the composition root, so rail choice lives outside the root again",
 			"subject": "mcp/entwurf-bridge/src/index.ts",
 			"find": [
 				"\t\t\tconst dispatched = await dispatchFreshCall({\n\t\t\t\tbackend,\n\t\t\t\tmodel,\n\t\t\t\ttask,\n\t\t\t\tcwd,\n\t\t\t\tplacement,\n\t\t\t\tcallerGardenId,\n\t\t\t\tcallerNativeSessionId,\n\t\t\t\tcallerCwd,\n\t\t\t});"
@@ -86,18 +86,7 @@
 			],
 			"gate": ["bash", "run.sh", "check-fresh-call-dispatch"],
 			"timeoutSeconds": 120,
-			"signature": "[QK:FCD-SURFACE-PARITY]",
-			"signatureSource": "scripts/check-fresh-call-dispatch.ts"
-		},
-		{
-			"claim": "FCD-PI-DYNAMIC-IMPORT",
-			"title": "pi reaches the composition root by a literal path again, which is how the lazy import fence erodes",
-			"subject": "pi-extensions/entwurf-control.ts",
-			"find": ["const FRESH_CALL_DISPATCH_MODULE = \"./lib/fresh-call-dispatch.ts\";"],
-			"replace": ["const FRESH_CALL_DISPATCH_MODULE = \"./lib/fresh-call-dispatch-renamed.ts\";"],
-			"gate": ["bash", "run.sh", "check-fresh-call-dispatch"],
-			"timeoutSeconds": 120,
-			"signature": "[QK:FCD-PI-DYNAMIC-IMPORT]",
+			"signature": "[QK:FCD-SURFACE-ROOT-ONLY]",
 			"signatureSource": "scripts/check-fresh-call-dispatch.ts"
 		},
 		{

package/scripts/mutants/gate-qualification.json

@@ -23,6 +23,65 @@
 			"timeoutSeconds": 120,
 			"signature": "[QK:LANE-INVENTORY-DECLARED]",
 			"signatureSource": "scripts/check-gate-qualification.ts"
+		},
+		{
+			"claim": "QUALIFY-BUILD-TRACKS-MUTATION",
+			"title": "the runner keeps the baseline build output across a mutation instead of rebuilding it from the mutated bytes — a gate that reads only the compiled output judges source it was never handed, and every mutant planted in the build's source survives (#125: the compiled entwurf-bridge a pi citizen registers)",
+			"subject": "scripts/lib/mutation-qualify.ts",
+			"find": ["\t\t\t\t\tconst b = await buildOutput(build, outputAbs, m.timeoutSeconds);"],
+			"replace": ["\t\t\t\t\tconst b = { run: pre, digest: baseline };"],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:QUALIFY-BUILD-TRACKS-MUTATION]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
+		},
+		{
+			"claim": "QUALIFY-BUILD-RED-NOT-A-KILL",
+			"title": "a mutation that breaks the declared build is attributed like a gate run — the build's own failure output is read for the claim token, so a broken build is certified as the gate killing the defect",
+			"subject": "scripts/lib/mutation-qualify.ts",
+			"find": [
+				"\t\t\t\tsignatureOnFailureLine: !buildRed && signatureAttributedToFailure(run.output, m.signature, run.failedTitles),"
+			],
+			"replace": [
+				"\t\t\t\tsignatureOnFailureLine: signatureAttributedToFailure(run.output, m.signature, run.failedTitles),"
+			],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:QUALIFY-BUILD-RED-NOT-A-KILL]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
+		},
+		{
+			"claim": "QUALIFY-BUILD-SCOPED-TO-GROUP",
+			"title": "the declared build output outlives its group — a later group runs against an input it never declared, and the ignored output is left in the snapshot",
+			"subject": "scripts/lib/mutation-qualify.ts",
+			"find": ["\t\t\tif (outputAbs) fs.rmSync(outputAbs, { recursive: true, force: true });"],
+			"replace": ["\t\t\tif (outputAbs) void 0;"],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:QUALIFY-BUILD-SCOPED-TO-GROUP]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
+		},
+		{
+			"claim": "QUALIFY-BUILD-OUTPUT-GUARDED",
+			"title": "a gate that writes into its declared build output keeps its KILLED verdict — the next run is judged against bytes no build produced",
+			"subject": "scripts/lib/mutation-qualify.ts",
+			"find": ["\t\t\t\t\t\toutputWritten = wroteOutput(b.digest);"],
+			"replace": ["\t\t\t\t\t\toutputWritten = false;"],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:QUALIFY-BUILD-OUTPUT-GUARDED]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
+		},
+		{
+			"claim": "QUALIFY-BUILD-GROUP-CONSISTENT",
+			"title": "mutants of one gate may declare different builds (or one none) — the same gate is handed different inputs depending on run order, and a group's control no longer describes all of its mutants",
+			"subject": "scripts/lib/mutation-qualify.ts",
+			"find": ["\t\tif (mine !== first) {"],
+			"replace": ["\t\tif (mine !== first && false) {"],
+			"gate": ["bash", "run.sh", "check-gate-manifests"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:QUALIFY-BUILD-GROUP-CONSISTENT]",
+			"signatureSource": "scripts/check-gate-qualification.ts"
 		}
 	]
 }

package/scripts/mutants/mux-fresh-call.json

@@ -121,8 +121,8 @@
 			"signatureSource": "test/mux-fresh-call.test.ts"
 		},
 		{
-			"claim": "FRESHCALL-CWD-SURFACE-PARITY",
-			"title": "one surface drops the optional cwd from its schema, so cross-repo fresh works from pi and silently cannot exist from the MCP bridge",
+			"claim": "FRESHCALL-CWD-SURFACE",
+			"title": "the fresh-call surface drops the optional cwd from its schema, so cross-repo fresh silently cannot exist from any caller — pi included, which reaches this bridge since #125",
 			"subject": "mcp/entwurf-bridge/src/index.ts",
 			"find": [
 				"\t\tcwd: z\n\t\t\t.string()\n\t\t\t.optional()\n\t\t\t.describe(\n\t\t\t\t\"Optional literal ABSOLUTE path of an existing directory to start the sibling in (cross-repo fresh). Omit or pass \\\"\\\" to start where the CALLER is — this agent's own cwd on BOTH rails, or for a Codex caller its own record directory, because this bridge is the app-server's child and that process's directory is not the caller's. Taken exactly as given: no trim, no realpath, no project-name resolution. '#' is refused on the tmux rail only, because tmux format-expands a start directory; inside herdr it is an ordinary path character. The receipt echoes the directory that was REQUESTED or the caller record it came from, never an observation of where the pane landed.\",\n\t\t\t),\n"
@@ -130,31 +130,7 @@
 			"replace": [""],
 			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
 			"timeoutSeconds": 120,
-			"signature": "[QK:FRESHCALL-CWD-SURFACE-PARITY]",
-			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
-		},
-		{
-			"claim": "FRESHCALL-PI-SURFACE-IDENTITY",
-			"title": "native pi takes the caller garden id from the environment instead of its own resident closure — the uuidv7 confusion, reintroduced",
-			"subject": "pi-extensions/entwurf-control.ts",
-			"find": ["\t\t\t\t\tcallerGardenId: residentGardenId,"],
-			"replace": ["\t\t\t\t\tcallerGardenId: process.env.PI_SESSION_ID ?? null,"],
-			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
-			"timeoutSeconds": 120,
-			"signature": "[QK:FRESHCALL-PI-SURFACE-IDENTITY]",
-			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
-		},
-		{
-			"claim": "FRESHCALL-PI-MODEL-SCHEMA",
-			"title": "native pi drops the required model field from fresh-call while the composition still expects one",
-			"subject": "pi-extensions/entwurf-control.ts",
-			"find": [
-				"\t\t\tmodel: Type.String({\n\t\t\t\tminLength: 1,\n\t\t\t\tmaxLength: 200,\n\t\t\t\tpattern: \"^[A-Za-z0-9][A-Za-z0-9._/:\\\\[\\\\]-]*$\",\n\t\t\t\tdescription:\n\t\t\t\t\t\"Required runtime model: canonical provider/model for pi, a Claude Code model id/alias, or a Copilot/OMP/Codex model name.\",\n\t\t\t}),\n"
-			],
-			"replace": [""],
-			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
-			"timeoutSeconds": 120,
-			"signature": "[QK:FRESHCALL-PI-MODEL-SCHEMA]",
+			"signature": "[QK:FRESHCALL-CWD-SURFACE]",
 			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
 		},
 		{
@@ -196,10 +172,10 @@
 		},
 		{
 			"claim": "FRESHCALL-MODEL-PATTERN-PROVIDER-VALID",
-			"title": "the same unescape planted on the TypeBox surface rides pi-ai's real anthropic-messages conversion into the request body as an invalid Rust-family pattern",
-			"subject": "pi-extensions/entwurf-control.ts",
-			"find": ["\t\t\t\tpattern: \"^[A-Za-z0-9][A-Za-z0-9._/:\\\\[\\\\]-]*$\","],
-			"replace": ["\t\t\t\tpattern: \"^[A-Za-z0-9][A-Za-z0-9._/:[\\\\]-]*$\","],
+			"title": "the #62 unescape planted on the bridge's zod pattern rides Pi's built-in MCP spread and pi-ai's real anthropic-messages conversion into the request body as an invalid Rust-family pattern",
+			"subject": "mcp/entwurf-bridge/src/index.ts",
+			"find": ["\t\t\t.regex(/^[A-Za-z0-9][A-Za-z0-9._/:\\[\\]-]*$/)"],
+			"replace": ["\t\t\t.regex(/^[A-Za-z0-9][A-Za-z0-9._/:[\\]-]*$/)"],
 			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:FRESHCALL-MODEL-PATTERN-PROVIDER-VALID]",
@@ -284,6 +260,39 @@
 			"signature": "[QK:FRESHCALL-COPILOT-CALLBACK-TOOL]",
 			"signatureSource": "test/mux-fresh-call.test.ts"
 		},
+		{
+			"claim": "FRESHCALL-PI-CALLBACK-DIALECT",
+			"title": "pi callback rolls back to the 0.99.1 hyphen spelling, which a 0.99.2 host no longer declares — the first turn is spent on a tool that is not there",
+			"subject": "pi-extensions/lib/fresh-call-composition.ts",
+			"find": ["\tpi: \"mcp__entwurf_bridge__entwurf_callback\","],
+			"replace": ["\tpi: \"mcp__entwurf-bridge__entwurf_callback\","],
+			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:FRESHCALL-PI-CALLBACK-DIALECT]",
+			"signatureSource": "test/mux-fresh-call.test.ts"
+		},
+		{
+			"claim": "FRESHCALL-PI-DELIVERY-DIALECT",
+			"title": "pi delivery rolls back to the 0.99.1 hyphen spelling — the result is sent to a tool a 0.99.2 host does not declare",
+			"subject": "pi-extensions/lib/fresh-call-composition.ts",
+			"find": ["\tpi: \"mcp__entwurf_bridge__entwurf_v2\","],
+			"replace": ["\tpi: \"mcp__entwurf-bridge__entwurf_v2\","],
+			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:FRESHCALL-PI-DELIVERY-DIALECT]",
+			"signatureSource": "test/mux-fresh-call.test.ts"
+		},
+		{
+			"claim": "FRESHCALL-PI-PEERS-DIALECT",
+			"title": "pi peers offer rolls back to the 0.99.1 hyphen spelling — the corroboration tool is named in a spelling the sibling cannot reach",
+			"subject": "pi-extensions/lib/fresh-call-composition.ts",
+			"find": ["\tpi: \"mcp__entwurf_bridge__entwurf_peers\","],
+			"replace": ["\tpi: \"mcp__entwurf-bridge__entwurf_peers\","],
+			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:FRESHCALL-PI-PEERS-DIALECT]",
+			"signatureSource": "test/mux-fresh-call.test.ts"
+		},
 		{
 			"claim": "FRESHCALL-COPILOT-PREFLIGHT-PREMUTATION",
 			"title": "the capability preflight is removed — a host missing the birth, MCP, receiver or footer unit gets a real window and a launch receipt for a sibling that can never call home",
@@ -430,17 +439,6 @@
 			"signature": "[QK:FRESHCALL-COPILOT-EXPLICIT-POLICY]",
 			"signatureSource": "test/mux-fresh-call.test.ts"
 		},
-		{
-			"claim": "FRESHCALL-BACKEND-SET-SURFACE-PARITY-PI",
-			"title": "a backend the composition can open is missing from the native pi surface enum — an in-process pi session cannot name a capability the module already opens",
-			"subject": "pi-extensions/entwurf-control.ts",
-			"find": ["\t\t\tbackend: StringEnum([\"pi\", \"claude-code\", \"copilot\", \"omp\", \"codex\"], {"],
-			"replace": ["\t\t\tbackend: StringEnum([\"pi\", \"claude-code\", \"copilot\", \"omp\"], {"],
-			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
-			"timeoutSeconds": 180,
-			"signature": "[QK:FRESHCALL-BACKEND-SET-SURFACE-PARITY-PI]",
-			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
-		},
 		{
 			"claim": "TMUXSESSION-LOOKUP-ENGINE",
 			"title": "the seat lookup goes back to the `-f` filter engine, which was measured to match EVERY session when the name contains a '}' — a fresh sibling then opens in whichever session tmux listed first",
@@ -510,8 +508,8 @@
 			"signatureSource": "test/mux-fresh-call.test.ts"
 		},
 		{
-			"claim": "FRESHCALL-PLACEMENT-SURFACE-PARITY",
-			"title": "one surface drops the optional seat from its schema, so opening a sibling in the operator's project session works from pi and silently cannot exist from the MCP bridge",
+			"claim": "FRESHCALL-PLACEMENT-SURFACE",
+			"title": "the fresh-call surface drops the optional seat from its schema, so opening a sibling in the operator's project session silently cannot exist from any caller",
 			"subject": "mcp/entwurf-bridge/src/index.ts",
 			"find": [
 				"\t\tplacement: z\n\t\t\t.object({\n\t\t\t\ttmuxSession: z\n\t\t\t\t\t.string()\n\t\t\t\t\t.describe(\n\t\t\t\t\t\t\"EXACT name of an EXISTING session on this agent's own tmux server. Nothing is created: an absent session is refused as tmux-session-missing, and a name outside [A-Za-z0-9][A-Za-z0-9_-]* as tmux-session-name-invalid.\",\n\t\t\t\t\t),\n\t\t\t})\n\t\t\t.optional()\n\t\t\t.describe(\n\t\t\t\t\"Optional expert seat override, TMUX ONLY: open the sibling in ONE EXISTING tmux session of this agent's own server, and it always wins. When omitted the seat follows the CALLER, never the backend being opened: a Codex CALLER opens beside its own TUI pane, matched by thread-id in that pane's terminal title (0 or 2+ matching panes refuse, never fall back); every other caller opens in its own session. A pane title is a placement input only — never an address, liveness or delivery fact. Nothing is ever created. Inside herdr this field is refused by name — placement there belongs to herdr, and a tmux session name would silently place the sibling somewhere else. Independent of cwd; neither is inferred from the other. The receipt reports the selected name (absent for the caller-pane rule, which observed a session rather than requesting a name), its source, and resolved target session id.\",\n\t\t\t),\n"
@@ -519,7 +517,7 @@
 			"replace": [""],
 			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
 			"timeoutSeconds": 180,
-			"signature": "[QK:FRESHCALL-PLACEMENT-SURFACE-PARITY]",
+			"signature": "[QK:FRESHCALL-PLACEMENT-SURFACE]",
 			"signatureSource": "test/fresh-call-surfaces.contract.test.ts"
 		},
 		{