@junghanacs/entwurf 0.51.0 → 0.53.1

package/scripts/check-acp-session-reuse.ts

@@ -52,8 +52,22 @@ function tctx(messages: Context["messages"]): TranscriptContext {
 	return normalizeContext({ tools: PI_DECLARED_TOOLS, messages });
 }
 
-const sonnet = { id: "claude-sonnet-5-5" } as unknown as Model<Api>;
-const opus = { id: "claude-opus-5-5" } 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 sonnet = { id: "claude-sonnet-5-5", thinkingLevelMap: FIXTURE_THINKING_LEVEL_MAP } as unknown as Model<Api>;
+const opus = { id: "claude-opus-5-5", thinkingLevelMap: FIXTURE_THINKING_LEVEL_MAP } as unknown as Model<Api>;
 
 type Stream = AsyncIterable<AssistantMessageEvent> & {
 	result: () => Promise<{ stopReason: string; errorMessage?: string }>;
@@ -155,7 +169,7 @@ function makeHarness(recordDir: string, config: any = DEFAULT_RESOLVED_CONFIG, e
 			newSessionSeq++;
 			return { sessionId: `ACP-${newSessionSeq}` };
 		},
-		setSessionConfigOption: async (p: any) => ({ configOptions: [{ id: "model", currentValue: p.value }] }),
+		setSessionConfigOption: async (p: any) => ({ configOptions: [{ id: p.configId, currentValue: p.value }] }),
 		prompt: async ({ sessionId, prompt }: any) => {
 			promptCalls.push({ sessionId, text: prompt.map((b: { text: string }) => b.text).join("\n") });
 			if (block) await block;
@@ -282,7 +296,12 @@ try {
 	copyFileSync("pi-extensions/lib/acp/prompts/engraving.md", resolve(promptsOut, "engraving.md"));
 	const backendUrl = pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/backend.js")).href;
 	const storeUrl = pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/session-store.js")).href;
-	const backend = (await import(backendUrl)) as any;
+	const backendModule = (await import(backendUrl)) 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);
 	const store = (await import(storeUrl)) as any;
 	const configUrl = pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/config.js")).href;

package/scripts/check-acp-stop-reason.ts

@@ -56,7 +56,21 @@ import type { Api, AssistantMessageEvent, Model } from "@earendil-works/pi-ai";
 import { normalizeContext } from "@earendil-works/pi-ai";
 import { assertOverlayInSandbox, sandboxAcpGateHome } from "./lib/acp-gate-home.ts";
 
-const sonnet = { id: "claude-sonnet-5-5" } 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 sonnet = { id: "claude-sonnet-5-5", thinkingLevelMap: FIXTURE_THINKING_LEVEL_MAP } as unknown as Model<Api>;
 
 type Stream = AsyncIterable<AssistantMessageEvent> & {
 	result: () => Promise<{ stopReason: string; errorMessage?: string }>;
@@ -123,7 +137,7 @@ function makeHarness(recordDir: string, wireReason: string | null) {
 		createConnection: (_child: any, handlers: any) => ({
 			initialize: async () => ({ agentCapabilities: {} }),
 			newSession: async () => ({ 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) => {
 				await handlers.sessionUpdate({
 					update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "PARTIAL" } },
@@ -249,7 +263,12 @@ try {
 
 	const backendUrl = pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/backend.js")).href;
 	const eventUrl = pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/event-mapper.js")).href;
-	const backend = (await import(backendUrl)) as any;
+	const backendModule = (await import(backendUrl)) 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);
 	const eventMod = (await import(eventUrl)) as any;
 

package/scripts/check-acp-stream-hooks.ts

@@ -36,7 +36,21 @@ import type { Api, AssistantMessageEvent, Message, Model, TranscriptContext } fr
 import { normalizeContext } from "@earendil-works/pi-ai";
 import { assertOverlayInSandbox, sandboxAcpGateHome } from "./lib/acp-gate-home.ts";
 
-const sonnet = { id: "claude-sonnet-5-5" } 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 sonnet = { id: "claude-sonnet-5-5", thinkingLevelMap: FIXTURE_THINKING_LEVEL_MAP } as unknown as Model<Api>;
 
 type Stream = AsyncIterable<AssistantMessageEvent>;
 
@@ -94,7 +108,7 @@ function makeHarness(recordDir: string) {
 	const makeConnection = (_handlers: any) => ({
 		initialize: async () => ({ agentCapabilities: {} }),
 		newSession: async () => ({ 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 (params: any) => {
 			// Deep-cloned: the capture must be the bytes that crossed the seam, not a
 			// live reference a later mutation could rewrite.
@@ -195,7 +209,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);
 
 	// ----------------------------------------------------------------------

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-entwurf-v2-surface.ts

@@ -92,7 +92,7 @@ function assertRailSemantics(tag: string, longDescRaw: string, intentDescRaw: st
 	);
 	ok(
 		`${tag} — long description names the THIRD result for an unsupported citizen`,
-		/mailbox-undeliverable/.test(longDesc) && /THIRD RESULT/.test(longDesc),
+		/mailbox-undeliverable/.test(longDesc) && /target without a live socket, the THIRD RESULT/.test(longDesc),
 	);
 	ok(
 		`${tag} — intent param names a rail's reject, not only its allow cell`,
@@ -139,30 +139,16 @@ function assertRailSemantics(tag: string, longDescRaw: string, intentDescRaw: st
  * whose subject (two distinct OWNED rejects) left with the `owned-outcome` intent.
  *
  * After the visible-first cut a dormant socket-domain citizen rejects delivery by v2, and
- * these four strings are the only place a caller learns that BEFORE spending a dispatch. So each
- * one must, on its own:
- *   - name the reason it will actually get back (`dormant-fire-forget-unsupported`);
- *   - name the intent that used to answer there (`owned-outcome`) — silently deleting it leaves
- *     an operator who read last week's docs with no way to find out what happened;
- *   - say it was `withdrawn`, ADJACENTLY to that name. Presence alone is not enough: naming a
- *     retired intent without the retirement verb beside it reads as an offer, which is exactly
- *     the "advertised as selectable" failure this claim exists to forbid;
- *   - carry NEITHER retired advertisement form (`owned-outcome = …` enum styling, or the old
- *     "DORMANT socket-domain citizen … never auto-converted" sentence that described picking it).
- *
- * ORDER IS LOAD-BEARING, and not for readability. `ok` throws on the FIRST failure, and the kill
- * signature is read off the failing line — so the `[QK:…]` label must sit on the assertion this
- * claim's mutant reaches FIRST. That mutant drops the reason AND the withdrawal in one edit; with
- * the reason check leading, an UNLABELLED line would throw first and the kill would read as
- * WRONG-REASON. The adjacency check therefore goes first and carries the only token; the other two
- * run unlabelled behind it — still real assertions, just not this claim's signature.
+ * both caller-facing strings must independently name the actual dormant rejection and say that
+ * delivery never launches or resumes a process. Neither may advertise the retired offer. History
+ * belongs in the issue and literal amendment, not in the current caller contract. The labelled
+ * assertion comes first because qualification reads the first failing line as the kill signature.
  */
 function assertDormantHonesty(tag: string, rawText: string): void {
 	const text = rawText;
-	const at = text.indexOf("owned-outcome");
 	ok(
-		`${tag} — names the withdrawn intent owned-outcome and says "withdrawn" beside it (not as an offer) [QK:V2SURF-DORMANT-HONESTY]`,
-		at >= 0 && /withdrawn/.test(text.slice(at, at + 200)),
+		`${tag} — delivery never launches or resumes a process and names the dormant rejection [QK:V2SURF-DORMANT-HONESTY]`,
+		/This delivery verb never launches or resumes a process/.test(text) && /dormant-fire-forget-unsupported/.test(text),
 	);
 	ok(`${tag} — names the reason a dormant target actually returns`, /dormant-fire-forget-unsupported/.test(text));
 	ok(

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,
@@ -3460,7 +3460,7 @@ let manifestCount: number;
 		"pi-retire-request": 6,
 		"retirement-event": 16,
 		"control-retire": 9,
-		"control-send-receipt": 20,
+		"control-send-receipt": 23,
 		"codex-native": 95,
 		"native-push-paused": 1,
 		"chain-terminus-publication": 1,
@@ -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-pi-durable-send.ts

@@ -900,7 +900,10 @@ async function cell(): Promise<void> {
 			hostReceiver.ownerKind === "pi-durable-host";
 		ok(
 			`[QK:${QK}-SENDER-REPLYABILITY] the host's receiver marker is armed and owned by the spawned host, and the landed body says what that predicts: replyable (armed ${hostArmed})`,
-			hostArmed && body.includes(`session:     ${hostGid} (meta-session, replyable — reply via entwurf_v2`),
+			hostArmed &&
+				body.includes(
+					`session:     ${hostGid} (meta-session, replyable — when a reply is requested, send the result via entwurf_v2`,
+				),
 		);
 		const hostRecords = fs
 			.readdirSync(dirs.sessions)

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)",
 	);