@junghanacs/entwurf 0.52.0 → 0.53.1

package/scripts/check-acp-usage-accounting.ts

@@ -27,7 +27,7 @@
 //   totalTokens is CONTEXT OCCUPANCY, not a turn total, and is never overwritten
 //             with the turn aggregate — pi reads that field as the context gauge.
 //   a backend with no measured semantics (no sealsTurnAccounting) is sealed NOT AT
-//             ALL: cortex's emitted usage must be byte-identical to pre-#93.
+//             ALL: the no-capability fixture preserves the mapper's output.
 //
 // ORACLES, each independent of the subject:
 //   - the cost sum: THIS FILE constructs the cumulative series and asserts the
@@ -62,8 +62,21 @@ import { isContextOverflow, normalizeContext } from "@earendil-works/pi-ai";
 import { calculateContextTokens } from "@earendil-works/pi-coding-agent";
 import { assertOverlayInSandbox, sandboxAcpGateHome } from "./lib/acp-gate-home.ts";
 
-const claude = { id: "claude-sonnet-5-5" } as unknown as Model<Api>;
-const cortex = { id: "cortex-auto" } as unknown as Model<Api>;
+// #142: a Claude turn carries pi's thinking level, which the backend sets as effort and reads back
+// before the prompt. This fixture runs every turn at one fixed level on rows carrying the curated
+// level map, and its fake driver reads back whatever config option it was asked to set. The effort
+// contract itself is certified in pi-extensions/lib/acp/backend.thinking.test.ts.
+const FIXTURE_THINKING_LEVEL = "medium";
+const FIXTURE_THINKING_LEVEL_MAP = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max",
+};
+const claude = { id: "claude-sonnet-5-5", thinkingLevelMap: FIXTURE_THINKING_LEVEL_MAP } as unknown as Model<Api>;
 
 type Stream = AsyncIterable<AssistantMessageEvent>;
 
@@ -161,7 +174,7 @@ function makeHarness(recordDir: string, scripts: TurnScript[]) {
 			newSessionCalls++;
 			return { sessionId: "ACP-1" };
 		},
-		setSessionConfigOption: async (p: any) => ({ configOptions: [{ id: "model", currentValue: p.value }] }),
+		setSessionConfigOption: async (p: any) => ({ configOptions: [{ id: p.configId, currentValue: p.value }] }),
 		prompt: async ({ sessionId }: any) => {
 			const script = scripts[turnIndex++] ?? {};
 			const update: Record<string, unknown> = { sessionUpdate: "usage_update" };
@@ -305,7 +318,14 @@ try {
 	const promptsOut = resolve(TMP_EMIT, "pi-extensions/lib/acp/prompts");
 	mkdirSync(promptsOut, { recursive: true });
 	copyFileSync("pi-extensions/lib/acp/prompts/engraving.md", resolve(promptsOut, "engraving.md"));
-	const backend = (await import(pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/backend.js")).href)) as any;
+	const backendModule = (await import(
+		pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/backend.js")).href
+	)) as any;
+	const backend = {
+		...backendModule,
+		streamAcpTurn: (model: unknown, context: unknown, options: Record<string, unknown> | undefined, deps: unknown) =>
+			backendModule.streamAcpTurn(model, context, { reasoning: FIXTURE_THINKING_LEVEL, ...options }, deps),
+	};
 	await assertOverlayInSandbox(TMP_EMIT, gateHome);
 
 	// ----------------------------------------------------------------------
@@ -915,13 +935,10 @@ try {
 	// ----------------------------------------------------------------------
 	// CELL 5 — a backend with no MEASURED semantics is sealed NOT AT ALL.
 	//
-	// backend.ts / event-mapper.ts are COMMON layer: cortex drives the same turn
-	// loop and the same mapper. Nobody has measured what cortex's ACP `usage`
-	// means (turn delta or session total? against which price table?), and ACP's
-	// own type is self-contradictory about it — the outer comment says "for this
-	// turn", the field comments say "across all turns/session". So cortex must
-	// keep exactly its pre-#93 output: the coarse mapper assignment, and no token
-	// projection, no baseline, no diff.
+	// The common loop must not invent accounting semantics for an adapter that
+	// declares none. Cortex is disabled, so this isolated fixture temporarily
+	// removes the capability from the compiled Claude adapter; it changes no
+	// production routing and restores the capability before the next cell.
 	// ----------------------------------------------------------------------
 	// TWO turns, and the second one is what carries the claim: on turn ONE a
 	// diff-against-an-empty-baseline and the raw cumulative are the SAME number, so
@@ -946,18 +963,30 @@ try {
 				occupancyTokens: 140_000,
 			},
 		]);
-		await collect(backend.streamAcpTurn(cortex, userCtx("cortex NONCE-1"), { sessionId: "usage-E" }, h.deps) as Stream);
-		const msg = sealedMessage(
-			await collect(
-				backend.streamAcpTurn(
-					cortex,
-					reuseCtx("cortex NONCE-1", "cortex NONCE-2"),
-					{ sessionId: "usage-E" },
-					h.deps,
-				) as Stream,
-			),
+		const { claudeAdapter } = await import(
+			pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/backend-adapter.js")).href
 		);
-		assert.equal(h.children.length, 1, "both cortex turns ran on ONE reused child");
+		const oldCapability = claudeAdapter.sealsTurnAccounting;
+		claudeAdapter.sealsTurnAccounting = false;
+		let msg: AssistantMessage;
+		try {
+			await collect(
+				backend.streamAcpTurn(claude, userCtx("fixture NONCE-1"), { sessionId: "usage-E" }, h.deps) as Stream,
+			);
+			msg = sealedMessage(
+				await collect(
+					backend.streamAcpTurn(
+						claude,
+						reuseCtx("fixture NONCE-1", "fixture NONCE-2"),
+						{ sessionId: "usage-E" },
+						h.deps,
+					) as Stream,
+				),
+			);
+		} finally {
+			claudeAdapter.sealsTurnAccounting = oldCapability;
+		}
+		assert.equal(h.children.length, 1, "both synthetic no-accounting turns ran on ONE reused child");
 		assert.deepEqual(
 			{
 				input: msg.usage.input,
@@ -1094,7 +1123,7 @@ console.log(
 		"a reused session; a turn with no cost notification attributes $0 while HOLDING the baseline so the session sum " +
 		"reproduces the backend's own cumulative ESTIMATE exactly (agreement with that carrier, never with a bill); a DECREASING total rebaselines, attributes $0 and says so to the operator with both numbers; " +
 		"totalTokens stays CONTEXT OCCUPANCY (verified through pi's own calculateContextTokens) and is carried forward " +
-		"when a turn reports none; a backend that declares no measured semantics — cortex — is sealed not at all; and a next turn " +
+		"when a turn reports none; an injected no-accounting capability fixture is sealed not at all; and a next turn " +
 		"started from INSIDE the previous turn's terminal event still reuses the one session, so the cost baseline " +
 		"survives the turn boundary",
 );

package/scripts/check-copilot-receive-arm.ts

@@ -705,12 +705,29 @@ ok(
 		"python3",
 		[nonDumpable, path.join(root, "node_modules", "@github", "copilot", "npm-loader.js")],
 		{
-			stdio: "ignore",
+			stdio: ["ignore", "ignore", "pipe"],
 		},
 	);
 	running.push(opaque);
 	try {
-		await sleep(400);
+		// Wait for the child's own "ready" (written after prctl succeeded), not a fixed delay: on a
+		// loaded host 400 ms was not enough for python to start and drop dumpability, so the
+		// environ was still readable and this cell failed for a timing reason (0.53.0 release gate).
+		await new Promise<void>((resolve, reject) => {
+			let seen = "";
+			const timer = setTimeout(() => reject(new Error("non-dumpable fixture never reported ready")), 15_000);
+			opaque.stderr?.on("data", (b: Buffer) => {
+				seen += b.toString();
+				if (seen.includes("ready")) {
+					clearTimeout(timer);
+					resolve();
+				}
+			});
+			opaque.once("exit", (code) => {
+				clearTimeout(timer);
+				reject(new Error(`non-dumpable fixture exited early (${code})`));
+			});
+		});
 		let environReadable = true;
 		try {
 			readFileSync(`/proc/${opaque.pid}/environ`);

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

@@ -150,7 +150,10 @@ async function main(): Promise<void> {
 		const tmuxRetired = await dispatchFreshCall(pi(" entwurf/claude-opus-5 "), {}, recordingSpawn().spawn);
 		const current = recordingSpawn();
 		const herdrCurrent = await dispatchFreshCall(pi("entwurf/claude-opus-5-5"), HERDR_ENV, current.spawn);
-		const cortex = await dispatchFreshCall(pi("entwurf/cortex-claude-sonnet-5"), {}, recordingSpawn().spawn);
+		const cortexSpawn = recordingSpawn();
+		const cortex = await dispatchFreshCall(pi("entwurf/cortex-claude-sonnet-5"), {}, cortexSpawn.spawn);
+		const cortexHerdrSpawn = recordingSpawn();
+		const cortexHerdr = await dispatchFreshCall(pi("entwurf/cortex-auto"), HERDR_ENV, cortexHerdrSpawn.spawn);
 		const otherBackend = await dispatchFreshCall(
 			{ ...REQUEST, backend: "claude-code", model: "entwurf/claude-sonnet-5" },
 			{},
@@ -158,7 +161,7 @@ async function main(): Promise<void> {
 		);
 		const reasonOf = (d: Awaited<ReturnType<typeof dispatchFreshCall>>) => (d.result.ok ? null : d.result.reason);
 		ok(
-			"[QK:FCD-ACP-MODEL-EXACT] a pi sibling under the entwurf provider must name an EXACT curated ACP id: a retired Claude 5 id refuses as acp-model-not-curated on BOTH rails (trimmed like the rails read it) before herdr is asked anything, while the 5.5 id and a Cortex id pass through and another backend is not judged — Pi would otherwise open the retired id on a Cortex row by substring",
+			"[QK:FCD-ACP-MODEL-EXACT] a pi sibling under the entwurf provider names an exact supported Claude id: retired Claude and Cortex ids refuse before launch, while a current Claude id passes and another backend is not judged",
 			herdrRetired.rail === "herdr" &&
 				reasonOf(herdrRetired) === "acp-model-not-curated" &&
 				herdrSpawn.calls.length === 0 &&
@@ -166,7 +169,10 @@ async function main(): Promise<void> {
 				reasonOf(tmuxRetired) === "acp-model-not-curated" &&
 				reasonOf(herdrCurrent) !== "acp-model-not-curated" &&
 				current.calls.length > 0 &&
-				reasonOf(cortex) !== "acp-model-not-curated" &&
+				reasonOf(cortex) === "acp-model-not-curated" &&
+				cortexSpawn.calls.length === 0 &&
+				reasonOf(cortexHerdr) === "acp-model-not-curated" &&
+				cortexHerdrSpawn.calls.length === 0 &&
 				reasonOf(otherBackend) !== "acp-model-not-curated" &&
 				renderDispatchedFreshCall(herdrRetired).text.includes("exact curated ACP id") &&
 				renderDispatchedFreshCall(tmuxRetired).text.includes("exact curated ACP id"),

package/scripts/check-gate-qualification.ts

@@ -3435,13 +3435,13 @@ let manifestCount: number;
 	// 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-foreground-only": 1,
+		"acp-augment": 8,
+		"acp-cortex": 3,
+		"acp-foreground-only": 2,
 		"acp-launch-namespace": 2,
 		"acp-overlay": 1,
 		"acp-prompt-lifecycle": 15,
-		"acp-set-model-readback": 2,
+		"acp-set-model-readback": 44,
 		"acp-stop-reason": 7,
 		"acp-stream-hooks": 10,
 		"acp-usage-accounting": 12,
@@ -3500,7 +3500,7 @@ let manifestCount: number;
 		"meta-identity": 9,
 		"meta-retire": 4,
 		"mux-boundary": 16,
-		"mux-fresh-call": 67,
+		"mux-fresh-call": 68,
 		"mux-launcher-fence": 8,
 		"mux-parent-artifact": 3,
 		"pack-install": 9,

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

@@ -413,6 +413,7 @@ async function main(): Promise<void> {
 	// bytes somebody wrote — while the framing gets its own claim about surviving the fold verbatim.
 	const FRAMING = composeFreshCallFraming({
 		backend: "claude-code",
+		model: "claude-sonnet-5-5",
 		callerGardenId: "20260101T010101-aaaaaa",
 		nonce: "mux-fresh-call-deadbeefdeadbeefdeadbeef",
 		openingLine: HERDR_FRESH_CALL_OPENING_LINE,

package/scripts/check-install-surface.ts

@@ -516,6 +516,12 @@ const operatorCmds = [...targets].filter(([cmd, ts]) => !isDevGate(cmd) && ts.le
 		l.replace(/^ {2}\.\/run\.sh (\S.*?)( +)# /, (_m, syn, gap) => `  entwurf ${syn}${gap} # `);
 	const toolCountWord = ({ 9: "nine" } as Record<number, string>)[EXPECTED_TOOLS.length];
 	const literalAmendments: { old: string; next: string; receipt: string }[] = [
+		{
+			old: "claude-native-resume; Cortex stays a documented on-demand direct call",
+			next: "claude-native-resume; Cortex ACP is disabled",
+			receipt:
+				"run.sh smoke_acp_cortex_live refuses with cortex-acp-disabled before a probe; the other MUST axes are unchanged",
+		},
 		{
 			old: "EXACTLY the eight shipped garden verbs",
 			next: `EXACTLY the ${toolCountWord} shipped garden verbs`,

package/scripts/check-probe-ordering.ts

@@ -1892,20 +1892,24 @@ function intervention(
 //     a mutant subject (§11-7-c), so kill-power here is the synthetic
 //     negatives, not a manifest entry.
 {
-	const inspect = (acpSrc: string, sdkSrc: string): string[] => {
+	// claude-agent-acp 0.103.0+ split the resolver out of the agent: `claudeCliPath` lives in
+	// `dist/claude-cli.js` (`cliSrc`) and the query-options literal in `dist/v1/acp-agent.js`
+	// (`acpSrc`), which now passes `await claudeCliPath()` alone — the env check moved inside
+	// the resolver, so the verbatim-override premise is judged there.
+	const inspect = (cliSrc: string, acpSrc: string, sdkSrc: string): string[] => {
 		const violations: string[] = [];
-		if (!acpSrc.includes("export async function claudeCliPath()")) {
-			violations.push("claudeCliPath export missing from acp-agent.js");
+		if (!cliSrc.includes("export async function claudeCliPath()")) {
+			violations.push("claudeCliPath export missing from claude-cli.js");
 		}
-		if (!/if \(process\.env\.CLAUDE_CODE_EXECUTABLE\) \{\s*return process\.env\.CLAUDE_CODE_EXECUTABLE;/.test(acpSrc)) {
+		if (!/if \(process\.env\.CLAUDE_CODE_EXECUTABLE\) \{\s*return process\.env\.CLAUDE_CODE_EXECUTABLE;/.test(cliSrc)) {
 			violations.push(
 				"claudeCliPath no longer returns the ambient override VERBATIM — the refusal precondition's premise moved",
 			);
 		}
-		const overrideLine = "pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE ?? (await claudeCliPath())";
+		const overrideLine = "pathToClaudeCodeExecutable: await claudeCliPath(),";
 		const iOverride = acpSrc.indexOf(overrideLine);
 		if (iOverride === -1) {
-			violations.push("the env-??-claudeCliPath resolution at the query options literal is gone");
+			violations.push("the claudeCliPath resolution at the query options literal is gone");
 		} else {
 			const iSpread = acpSrc.indexOf("...userProvidedOptions,");
 			if (iSpread === -1 || iSpread > iOverride) {
@@ -1944,49 +1948,55 @@ function intervention(
 
 	// Synthetic fixtures FIRST — an inspector that cannot see the defect it
 	// exists for is no inspector.
-	const goodAcp =
+	const goodCli =
 		"export async function claudeCliPath() {\n" +
-		"    if (process.env.CLAUDE_CODE_EXECUTABLE) {\n        return process.env.CLAUDE_CODE_EXECUTABLE;\n    }\n}\n" +
+		"    if (process.env.CLAUDE_CODE_EXECUTABLE) {\n        return process.env.CLAUDE_CODE_EXECUTABLE;\n    }\n}\n";
+	const goodAcp =
 		"const options = {\n            ...userProvidedOptions,\n" +
-		"            pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE ?? (await claudeCliPath()),\n};\n";
+		"            pathToClaudeCodeExecutable: await claudeCliPath(),\n};\n";
 	const goodSdk = `x=![".js",".mjs",".tsx",".ts",".jsx"].some((r)=>e.endsWith(r));y=Cs()?"bun":"node";spawnLocalProcess(e){let{command:t,args:r,cwd:n,env:o,signal:i}=e,s=cxe(t,r,{cwd:n,stdio:["pipe","pipe","pipe"],signal:i,env:o,windowsHide:!0})}`;
-	assert.deepEqual(inspect(goodAcp, goodSdk), [], "inspector passes the correct synthetic fixture");
+	assert.deepEqual(inspect(goodCli, goodAcp, goodSdk), [], "inspector passes the correct synthetic fixture");
 	const invertedAcp = goodAcp.replace(
-		"            ...userProvidedOptions,\n            pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE ?? (await claudeCliPath()),\n",
-		"            pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE ?? (await claudeCliPath()),\n            ...userProvidedOptions,\n",
+		"            ...userProvidedOptions,\n            pathToClaudeCodeExecutable: await claudeCliPath(),\n",
+		"            pathToClaudeCodeExecutable: await claudeCliPath(),\n            ...userProvidedOptions,\n",
 	);
 	assert.ok(
-		inspect(invertedAcp, goodSdk).some((v) => v.includes("key-order")),
+		inspect(goodCli, invertedAcp, goodSdk).some((v) => v.includes("key-order")),
 		"inspector catches userProvidedOptions inverted to win over the explicit override key",
 	);
 	assert.ok(
-		inspect(goodAcp.replace("export async function claudeCliPath()", "async function claudeCliPath()"), goodSdk).some(
-			(v) => v.includes("export missing"),
-		),
+		inspect(
+			goodCli.replace("export async function claudeCliPath()", "async function claudeCliPath()"),
+			goodAcp,
+			goodSdk,
+		).some((v) => v.includes("export missing")),
 		"inspector catches the claudeCliPath export disappearing",
 	);
 	assert.ok(
-		inspect(goodAcp, goodSdk.replace('".mjs",', "")).some((v) => v.includes("discriminator")),
+		inspect(goodCli, goodAcp, goodSdk.replace('".mjs",', "")).some((v) => v.includes("discriminator")),
 		"inspector catches the SDK suffix list drifting from the pinned SDK_SCRIPT_SUFFIXES",
 	);
 	// The no-shell negatives must be caught IN THE LEAF WINDOW, in both the
 	// minified and the plain spelling — the global one-spelling absence check
 	// this replaced passed them all.
 	assert.ok(
-		inspect(goodAcp, goodSdk.replace("windowsHide:!0", "windowsHide:!0,shell:!0")).some((v) =>
+		inspect(goodCli, goodAcp, goodSdk.replace("windowsHide:!0", "windowsHide:!0,shell:!0")).some((v) =>
 			v.includes("no-shell"),
 		) &&
-			inspect(goodAcp, goodSdk.replace("windowsHide:!0", "windowsHide:!0,shell:true")).some((v) =>
+			inspect(goodCli, goodAcp, goodSdk.replace("windowsHide:!0", "windowsHide:!0,shell:true")).some((v) =>
 				v.includes("no-shell"),
 			) &&
-			inspect(goodAcp, goodSdk.replace("spawnLocalProcess(", "spawnElsewhere(")).some((v) => v.includes("anchor")),
+			inspect(goodCli, goodAcp, goodSdk.replace("spawnLocalProcess(", "spawnElsewhere(")).some((v) =>
+				v.includes("anchor"),
+			),
 		"inspector catches shell:!0 AND shell:true inside the spawn leaf, and the leaf disappearing entirely",
 	);
 
 	// Installed dists — the actual §11-7-c load-bearing assumptions.
 	const rootRequire = createRequire(resolve(REPO_ROOT, "package.json"));
 	const acpPkgJson = rootRequire.resolve("@agentclientprotocol/claude-agent-acp/package.json");
-	const acpDist = readFileSync(join(dirname(acpPkgJson), "dist", "acp-agent.js"), "utf8");
+	const cliDist = readFileSync(join(dirname(acpPkgJson), "dist", "claude-cli.js"), "utf8");
+	const acpDist = readFileSync(join(dirname(acpPkgJson), "dist", "v1", "acp-agent.js"), "utf8");
 	const acpRequire = createRequire(acpPkgJson);
 	const sdkEntry = acpRequire.resolve("@anthropic-ai/claude-agent-sdk");
 	let sdkDist = readFileSync(sdkEntry, "utf8");
@@ -1995,9 +2005,9 @@ function intervention(
 		if (existsSync(sibling)) sdkDist = readFileSync(sibling, "utf8");
 	}
 	assert.deepEqual(
-		inspect(acpDist, sdkDist),
+		inspect(cliDist, acpDist, sdkDist),
 		[],
-		"installed acp-agent.js + sdk.mjs still carry every §11-7-c launch-semantics assumption (claudeCliPath verbatim env, override key order, suffix discriminator, node|bun choice, piped no-shell spawn)",
+		"installed claude-cli.js + v1/acp-agent.js + sdk.mjs still carry every §11-7-c launch-semantics assumption (claudeCliPath verbatim env, override key order, suffix discriminator, node|bun choice, piped no-shell spawn)",
 	);
 }
 
@@ -2050,7 +2060,7 @@ function intervention(
 	);
 	assert.ok(
 		RUNNER_SRC.includes("CLI_TARGET = await resolveProbeCliTarget({") &&
-			RUNNER_SRC.includes('"@agentclientprotocol/claude-agent-acp/dist/acp-agent.js"') &&
+			RUNNER_SRC.includes('join(dirname(pkgJson), "dist", "claude-cli.js")') &&
 			RUNNER_SRC.includes("`precondition-${err.reason}`"),
 		"the runner resolves the target through upstream claudeCliPath BEFORE any run, and a precondition refusal writes a NAMED classification on the artifact (not stderr alone)",
 	);

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

@@ -260,30 +260,18 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 //    is the second skip surface: some smokes never reach their .ts file at all.
 // ===========================================================================
 {
-	const viaWrapper = runSubcommand("smoke-acp-cortex-live", { LIVE: undefined });
+	const viaWrapper = runSubcommand("smoke-entwurf-v2-matrix-live", { LIVE: undefined });
 	assert.equal(
 		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 and matrix ` +
-			"both decline before their .ts is ever reached), so fixing only the TypeScript " +
+			`SKIP code, not 0 — got exit ${viaWrapper.code}. The matrix wrapper declines before its .ts is reached, so fixing only the TypeScript ` +
 			`half would leave the aggregate counting those as PASS. Output: ${JSON.stringify(viaWrapper.output.slice(-300))}`,
 	);
 
-	// The measured Cortex cell: LIVE IS set, but the connection the adapter needs
-	// is not. Which branch declines (the wrapper's `cortex` PATH check or the
-	// smoke's own connection check) depends on the host; the OUTCOME must not.
-	const missingPrereq = runSubcommand("smoke-acp-cortex-live", {
-		LIVE: "1",
-		ENTWURF_ACP_CORTEX_CONNECTION: undefined,
-	});
-	assert.equal(
-		missingPrereq.code,
-		LIVE_SKIP_EXIT,
-		"LIVE=1 with no ENTWURF_ACP_CORTEX_CONNECTION must be a SKIP, not a PASS — this is the exact cell that made a " +
-			"cortex-less host look like cortex acceptance. Output: " +
-			JSON.stringify(missingPrereq.output.slice(-300)),
-	);
+	const disabled = runSubcommand("smoke-acp-cortex-live", { LIVE: undefined });
+	assert.equal(disabled.code, 2, "disabled Cortex smoke must refuse before a vendor probe");
+	assert.match(disabled.output, /cortex-acp-disabled/);
 }
 
 // ===========================================================================
@@ -312,11 +300,9 @@ function runSubcommand(sub: string, env: Record<string, string | undefined>): {
 		"smoke-agy-native-push-live": ["VERIFY.md", "Aggregate release-gate does not own an agy conversation id"],
 		"smoke-codex-native-push-live": ["VERIFY.md", "Aggregate release-gate does not own a loaded Codex thread"],
 		"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 release aggregate does not re-certify Cortex"],
+		// Cortex ACP is disabled. Its former direct LIVE requirement is historical;
+		// the retained command refuses by name without starting a vendor probe.
+		"smoke-acp-cortex-live": ["VERIFY.md", "Cortex ACP is disabled"],
 		// #116 C4: first evidence precedes promotion. The herdr rail's LIVE acceptance exists and
 		// runs on demand, but a rail whose first real acceptance run is days old has not earned a
 		// place in the aggregate that blocks every cut — and herdr is an OPTIONAL rail, so a cut
@@ -1066,7 +1052,7 @@ console.log(
 		"everything else→FAIL (never rounding a skip up), `--cut` refuses a MUST SKIP while a bare diagnostic run stays " +
 		"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 " +
+		"a run.sh wrapper declining its own prerequisite; the retired Cortex smoke refuses by name; and every " +
 		"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 only as the schedule/dispatch drift diagnostic (absent from the " +
 		"default chain, from release_gate, from every push and from the release skill; exactly once in CI) over the " +

package/scripts/lib/probe-cli-target.ts

@@ -92,8 +92,9 @@ export function hashFileSha256(path: string): string {
 
 /** Refuse if the given env carries the upstream override — KEY PRESENCE is the
  *  predicate, an empty string included. Upstream consumers disagree about
- *  empty (`??` at acp-agent.js:4083 treats "" as set and passes it on; a
- *  truthy check treats it as unset), and the probe refuses the ambiguity
+ *  empty (0.85.1's `??` at acp-agent.js:4083 treated "" as set and passed it
+ *  on; 0.106.0's truthy check at dist/claude-cli.js:20 treats it as unset), and
+ *  the probe refuses the ambiguity
  *  instead of picking a side. Used twice: on the runner's own process.env
  *  before resolving, and on the COMPOSED spawn env of every ACP child (adapter
  *  launch defaults / overlay overrides could inject what process.env did not

package/scripts/mutants/acp-augment.json

@@ -52,32 +52,6 @@
 			"signature": "[QK:CARRIER-FRAME-NAMES-CLAUDE-CARRIER]",
 			"signatureSource": "scripts/check-acp-carrier-augment.ts"
 		},
-		{
-			"claim": "CARRIER-FRAME-DENIES-CORTEX-CARRIER",
-			"title": "the carrier-less rail is told it has a tiny system-prompt carrier — a flat lie, since cortex's buildSessionMeta sends no _meta at all",
-			"subject": "pi-extensions/lib/acp/augment.ts",
-			"find": [
-				"\t\t\t\t\t`The ${params.backend} rail carries no system-prompt carrier at all — entwurf sends no \\`_meta.systemPrompt\\`, so everything entwurf tells you, including any operator engraving above, arrives here as user-message text.`,"
-			],
-			"replace": [
-				"\t\t\t\t\t`The ${params.backend} rail does have a system-prompt carrier (\\`_meta.systemPrompt\\`), and entwurf keeps it deliberately tiny: it carries the operator engraving only.`,"
-			],
-			"gate": ["bash", "run.sh", "check-acp-carrier-augment"],
-			"timeoutSeconds": 60,
-			"signature": "[QK:CARRIER-FRAME-DENIES-CORTEX-CARRIER]",
-			"signatureSource": "scripts/check-acp-carrier-augment.ts"
-		},
-		{
-			"claim": "CARRIER-RAIL-DIFF-IS-SOURCE-PINNED",
-			"title": "cortex grows a session carrier while the augment still tells it there is none — the frame becomes a lie and no prose check would notice",
-			"subject": "pi-extensions/lib/acp/backend-adapter.ts",
-			"find": ["\tbuildSessionMeta() {\n\t\treturn undefined;\n\t},"],
-			"replace": ["\tbuildSessionMeta() {\n\t\treturn { systemPrompt: \"x\" };\n\t},"],
-			"gate": ["bash", "run.sh", "check-acp-carrier-augment"],
-			"timeoutSeconds": 60,
-			"signature": "[QK:CARRIER-RAIL-DIFF-IS-SOURCE-PINNED]",
-			"signatureSource": "scripts/check-acp-carrier-augment.ts"
-		},
 		{
 			"claim": "CARRIER-LEADS-ITS-OWN-BLOCK",
 			"title": "the carrier loses its leading boundary — the Claude SDK's fixed sentence swallows the operator engraving again (the measured 2026-07-31 A-join)",