@junghanacs/entwurf 0.51.0 → 0.53.1

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

@@ -659,13 +659,24 @@
 			"claim": "FRESHCOMP-PEERS-TOOL-DIALECT",
 			"title": "the corroboration the framing offers goes back to one bare spelling, so four of the five backends are offered a tool name their own session does not expose",
 			"subject": "pi-extensions/lib/fresh-call-composition.ts",
-			"find": ["\tconst peersTool = FRESH_CALL_PEERS_TOOL[params.backend];"],
+			"find": ["\tconst peersTool = FRESH_CALL_PEERS_TOOL[dialect];"],
 			"replace": ["\tconst peersTool = \"entwurf_peers\";"],
 			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:FRESHCOMP-PEERS-TOOL-DIALECT]",
 			"signatureSource": "test/fresh-call-composition.contract.test.ts"
 		},
+		{
+			"claim": "FRESHCOMP-ACP-CLAUDE-TOOL-DIALECT",
+			"title": "the framing goes back to keying tool names on the backend alone, so a pi sibling opened on an ACP Claude model is told Pi's underscore spelling its Claude tool surface does not expose",
+			"subject": "pi-extensions/lib/fresh-call-composition.ts",
+			"find": ["\tconst dialect = freshCallToolDialect(params.backend, params.model);"],
+			"replace": ["\tconst dialect = params.backend;"],
+			"gate": ["bash", "run.sh", "check-mux-fresh-call"],
+			"timeoutSeconds": 120,
+			"signature": "[QK:FRESHCOMP-ACP-CLAUDE-TOOL-DIALECT]",
+			"signatureSource": "test/fresh-call-composition.contract.test.ts"
+		},
 		{
 			"claim": "FRESHCOMP-RESULT-GOES-TO-CALLER",
 			"title": "the first turn stops naming where the result goes, so a sibling finishes its task, prints the answer in its own window, and the caller never learns it is done",

package/scripts/mutants/pack-install.json

@@ -6,8 +6,8 @@
 			"claim": "PACK-INSTALL-PIN-MATCHER-BOUNDED",
 			"title": "the pin-leak matcher loses its version boundary and blesses substring lookalikes \u2014 @0.85.10 reads as the pinned 0.85.1 and the gate announces a verified tree it never verified (independent review, 2026-08-25)",
 			"subject": "run.sh",
-			"find": ["  grep '^@earendil-works+' | grep -Ev '@1\\.5\\.0(_|$)' || true"],
-			"replace": ["  grep '^@earendil-works+' | grep -v '@1\\.5\\.0' || true"],
+			"find": ["  grep '^@earendil-works+' | grep -Ev '@1\\.5\\.2(_|$)' || true"],
+			"replace": ["  grep '^@earendil-works+' | grep -v '@1\\.5\\.2' || true"],
 			"gate": ["bash", "run.sh", "check-pack-pin-matcher"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:PACK-INSTALL-PIN-MATCHER-BOUNDED]",
@@ -17,8 +17,8 @@
 			"claim": "PACK-INSTALL-PIN-MATCHER-COVERS-CLOSURE",
 			"title": "the pin-leak matcher narrows back to the pi-* families and goes blind to a non-pi member of the same runtime closure \u2014 @earendil-works/chord (new in pi 0.85.0, a runtime dependency of pi-coding-agent/pi-agent-core/pi-client/pi-protocol) floats unpinned while the gate prints a verified pin (measured 2026-09-06 on a real 0.85.1 install tree)",
 			"subject": "run.sh",
-			"find": ["  grep '^@earendil-works+' | grep -Ev '@1\\.5\\.0(_|$)' || true"],
-			"replace": ["  grep '^@earendil-works+pi-' | grep -Ev '@1\\.5\\.0(_|$)' || true"],
+			"find": ["  grep '^@earendil-works+' | grep -Ev '@1\\.5\\.2(_|$)' || true"],
+			"replace": ["  grep '^@earendil-works+pi-' | grep -Ev '@1\\.5\\.2(_|$)' || true"],
 			"gate": ["bash", "run.sh", "check-pack-pin-matcher"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:PACK-INSTALL-PIN-MATCHER-COVERS-CLOSURE]",

package/scripts/mutants/pi-floor.json

@@ -7,10 +7,10 @@
 			"title": "one row of the pnpm workspace closure is left on the previous floor while every other surface moved — the shape a version bump actually fails in. Nothing else reads that file, so the stranded row surfaces only at install time, in a different command, far from the change that stranded it",
 			"subject": "pnpm-workspace.yaml",
 			"find": [
-				"  - '@earendil-works/pi-telemetry@0.85.0 || 0.85.1 || 0.86.0 || 0.87.0 || 0.87.1 || 0.99.1 || 0.99.2 || 1.0.0 || 1.0.2 || 1.0.4 || 1.1.0 || 1.2.0 || 1.3.0 || 1.4.0 || 1.5.0'"
+				"  - '@earendil-works/pi-telemetry@0.85.0 || 0.85.1 || 0.86.0 || 0.87.0 || 0.87.1 || 0.99.1 || 0.99.2 || 1.0.0 || 1.0.2 || 1.0.4 || 1.1.0 || 1.2.0 || 1.3.0 || 1.4.0 || 1.5.0 || 1.5.2'"
 			],
 			"replace": [
-				"  - '@earendil-works/pi-telemetry@0.85.0 || 0.85.1 || 0.86.0 || 0.87.0 || 0.87.1 || 0.99.1 || 0.99.2 || 1.0.0 || 1.0.2 || 1.0.4 || 1.1.0 || 1.2.0 || 1.3.0 || 1.4.0'"
+				"  - '@earendil-works/pi-telemetry@0.85.0 || 0.85.1 || 0.86.0 || 0.87.0 || 0.87.1 || 0.99.1 || 0.99.2 || 1.0.0 || 1.0.2 || 1.0.4 || 1.1.0 || 1.2.0 || 1.3.0 || 1.4.0 || 1.5.0'"
 			],
 			"gate": ["bash", "run.sh", "check-dep-versions"],
 			"timeoutSeconds": 300,
@@ -21,8 +21,8 @@
 			"claim": "PI-SDK-PRODUCTION-SET",
 			"title": "the durable library's production pin falls one release behind the SDK set the pin declares, so the carrier would bind a pi-durable nobody verified it against",
 			"subject": "package.json",
-			"find": ["\"@earendil-works/pi-durable\": \"1.5.0\","],
-			"replace": ["\"@earendil-works/pi-durable\": \"1.4.0\","],
+			"find": ["\"@earendil-works/pi-durable\": \"1.5.2\","],
+			"replace": ["\"@earendil-works/pi-durable\": \"1.5.0\","],
 			"gate": ["bash", "run.sh", "check-dep-versions"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:PI-SDK-PRODUCTION-SET]",
@@ -33,7 +33,7 @@
 			"title": "an @earendil-works package returns as a dev dependency beside its production pin, one name in two dependency classes",
 			"subject": "package.json",
 			"find": ["\"@biomejs/biome\": \"^2.4.13\","],
-			"replace": ["\"@biomejs/biome\": \"^2.4.13\",\n\t\t\"@earendil-works/pi-ai\": \"1.5.0\","],
+			"replace": ["\"@biomejs/biome\": \"^2.4.13\",\n\t\t\"@earendil-works/pi-ai\": \"1.5.2\","],
 			"gate": ["bash", "run.sh", "check-dep-versions"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:PI-SDK-NO-DUAL-DECLARATION]",
@@ -41,15 +41,13 @@
 		},
 		{
 			"claim": "PI-FLOOR-PUBLISHED-SCOPE",
-			"title": "a published-scope region in an operator doc names a package the frozen published manifest does not record, so the 1.4 instructions inside it would be held to a pairing no artifact ships — the doc can no longer prove which published package its install steps belong to",
+			"title": "a published-scope region in an operator doc names a package the frozen published manifest does not record, so the 1.5.0 instructions inside it would be held to a pairing no artifact ships — the doc can no longer prove which published package its install steps belong to",
 			"subject": "docs/setup-clean-host.md",
 			"find": [
-				"<!-- entwurf:published @junghanacs/entwurf@0.50.0 pi 1.4.0 -->",
-				"| Component | Requirement | Needed for |"
+				"| pi | optional-by-presence — current 0.52.0: `>=1.5.2 <1.6`; historical 0.51.0: <!-- entwurf:published @junghanacs/entwurf@0.51.0 pi 1.5.0 -->"
 			],
 			"replace": [
-				"<!-- entwurf:published @junghanacs/entwurf@0.49.0 pi 1.4.0 -->",
-				"| Component | Requirement | Needed for |"
+				"| pi | optional-by-presence — current 0.52.0: `>=1.5.2 <1.6`; historical 0.51.0: <!-- entwurf:published @junghanacs/entwurf@0.50.0 pi 1.5.0 -->"
 			],
 			"gate": ["bash", "run.sh", "check-dep-versions"],
 			"timeoutSeconds": 300,

package/scripts/mutants/release-gate.json

@@ -62,14 +62,14 @@
 		},
 		{
 			"claim": "WRAPPER-SKIP-IS-PROTOCOL-EXIT",
-			"title": "a run.sh smoke wrapper returns 0 on a missing prerequisite — the second skip surface, where cortex/matrix/spawn decline before their .ts is ever reached",
+			"title": "the matrix smoke wrapper returns 0 on a missing prerequisite before its .ts is reached",
 			"subject": "run.sh",
 			"find": [
-				"    echo \"[entwurf:skip] smoke-acp-cortex-live — set LIVE=1 (+ ENTWURF_ACP_CORTEX_CONNECTION) to run.\"",
+				"    echo \"[entwurf:skip] smoke-entwurf-v2-matrix-live — set LIVE=1 to run (spawns a real pi --entwurf-control + opens a real socket).\"",
 				"    return \"$ENTWURF_STEP_SKIP_EXIT\""
 			],
 			"replace": [
-				"    echo \"[entwurf:skip] smoke-acp-cortex-live — set LIVE=1 (+ ENTWURF_ACP_CORTEX_CONNECTION) to run.\"",
+				"    echo \"[entwurf:skip] smoke-entwurf-v2-matrix-live — set LIVE=1 to run (spawns a real pi --entwurf-control + opens a real socket).\"",
 				"    return 0"
 			],
 			"gate": ["bash", "run.sh", "check-release-gate-outcomes"],

package/scripts/mutants/v2-surface.json

@@ -22,7 +22,7 @@
 			"title": "MCP long description reverts to the false \"socket paths take a per-target lock\" claim",
 			"subject": "ENTWURF.json",
 			"find": [
-				"LOCK: taken for a control-socket-DOMAIN dispatch. The mailbox and native-push rails are lock-free — deliverability and the adapter probe guard them. mode "
+				"A control-socket-DOMAIN dispatch takes a target lock; mailbox and native-push rails are lock-free. mode "
 			],
 			"replace": ["LOCK POLICY: socket paths take a per-target lock; the mailbox path does not. mode "],
 			"gate": ["bash", "run.sh", "check-entwurf-v2-surface"],
@@ -81,7 +81,7 @@
 			"title": "MCP long description advertises owned-outcome as a selectable dormant verb again and drops the reason a dormant target actually returns",
 			"subject": "ENTWURF.json",
 			"find": [
-				"A dormant socket rejects this delivery verb as dormant-fire-forget-unsupported. owned-outcome was withdrawn. Only on an explicit operator request, entwurf_resume_call may visibly reopen a proven-dormant Pi, pi-durable or Claude Code citizen under the same id, submitting no prompt; that lifecycle is separate from delivery. "
+				"A dormant socket rejects this delivery verb as dormant-fire-forget-unsupported. This delivery verb never launches or resumes a process. Only on an explicit operator request, entwurf_resume_call may visibly reopen a proven-dormant Pi, pi-durable or Claude Code citizen under the same id, submitting no prompt; that lifecycle is separate from delivery. "
 			],
 			"replace": [
 				"owned-outcome wakes a DORMANT socket-domain citizen by spawn-bg resume ONLY and is never auto-converted. "
@@ -132,11 +132,9 @@
 			"claim": "V2SURF-DESC-FITS-HOST-CAP",
 			"title": "the v2 tool description grows back past the host's 2048-char cap — the INTENT contract is silently cut off before the model that must choose an intent ever reads it",
 			"subject": "ENTWURF.json",
-			"find": [
-				"CANONICAL DELIVERY SURFACE for garden ids: message, reply, or hand off to whoever an id names. The id "
-			],
+			"find": ["Send, reply or hand off to an existing garden id; the decider selects the live rail "],
 			"replace": [
-				"CANONICAL DELIVERY SURFACE for garden ids: message, reply, or hand off to whoever an id names. The id PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING "
+				"Send, reply or hand off to an existing garden id; the decider selects the live rail PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING PADDING "
 			],
 			"gate": ["bash", "run.sh", "check-entwurf-v2-surface"],
 			"timeoutSeconds": 60,

package/scripts/raw-acp-compaction-measure/probe.ts

@@ -18,10 +18,11 @@
 // It asserts nothing and blocks nothing. The receipt goes in README.md next to it.
 
 import { type ChildProcessByStdio, spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { Readable, Writable } from "node:stream";
 import { ndJsonStream, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 import { connectAcpClient } from "../../pi-extensions/lib/acp/acp-client.ts";
@@ -47,7 +48,12 @@ function withTimeout<T>(label: string, p: Promise<T>, ms: number): Promise<T> {
 }
 
 const require = createRequire(import.meta.url);
-const bin = require.resolve("@agentclientprotocol/claude-agent-acp/dist/index.js");
+// 0.103.0 exports only `.` and `./package.json`; take the bin path from the manifest.
+const acpPkgJson = require.resolve("@agentclientprotocol/claude-agent-acp/package.json");
+const bin = join(
+	dirname(acpPkgJson),
+	(JSON.parse(readFileSync(acpPkgJson, "utf8")) as { bin: Record<string, string> }).bin["claude-agent-acp"],
+);
 
 const scratch = await mkdtemp(join(tmpdir(), "raw-acp-compaction-"));
 const child: ChildProcessByStdio<Writable, Readable, Readable> = spawn(process.execPath, [bin], {

package/scripts/smoke-acp-cortex-live.ts

@@ -1,408 +1,4 @@
-// CP2 LIVE — the cortex ACP citizen path, end to end: a REAL `cortex acp serve`
-// child behind the entwurf provider carries a model to outbound sibling
-// dispatch, under the dual-HOME overlay, and is reclaimed by process-group
-// teardown afterwards.
-//
-//   LIVE=1 ENTWURF_ACP_CORTEX_CONNECTION=<conn> ./run.sh smoke-acp-cortex-live
-//
-// WHY this exact axis. The CP0 audit (docs/acp-backend-rail.md, Cortex D1–D10) measured
-// three things no offline gate can prove:
-//   - D9/D10: cortex ignores the wire `mcpServers` param, so the bundled
-//     entwurf-bridge reaches a cortex session ONLY through the overlay-private
-//     mcp.json projection — and only the dual-HOME env restore keeps the bridge
-//     child's garden store real (an isolated-HOME bridge saw "(none)" citizens).
-//     The CP0 LIVE run proved tool exposure + entwurf_peers; the outbound
-//     `entwurf_v2` send was DELIBERATELY not exercised there ("흉내내지 않았다")
-//     and is owed to THIS smoke.
-//   - CP0-M: set-model is accepted live, but "the prompt actually runs on the
-//     selected model" needed a model turn — this smoke drives one.
-//   - teardown: an MCP-configured cortex child does NOT exit on stdin EOF
-//     (measured twice); only process-group signalling reclaims it. This smoke
-//     asserts the reclaim actually happens after the resident dies.
-//
-// METHOD — mirrors smoke-acp-v2-send-live: seed an isolated garden world (store
-// + mailbox + receivers) with ONE armed self-fetch receiver, launch a real
-// `pi --entwurf-control --mode rpc` resident on entwurf/cortex-claude-sonnet-5
-// with that world in env, drive one turn telling the model to call
-// `mcp__entwurf-bridge__entwurf_v2` at the seeded receiver with a nonce, then
-// assert ON DISK: the landed .msg, the envelope naming the resident's own gid +
-// entwurf/<cortex model>, the overlay scope dir + its mcp.json projection, and
-// (after teardown) that no process still lives inside this run's overlay.
-//
-// LIVE-only and OUTSIDE the claude-only AGGREGATE release floor (capability
-// dignity): a host that runs no cortex must not redden a claude release. That is
-// a wiring decision — shipping cortex still owes a deliberate run of this smoke,
-// and the aggregate gate's silence is not a pass (ACP rail verification boundary).
-// Honest skip when LIVE!=1, when `cortex` is not on PATH, or when
-// ENTWURF_ACP_CORTEX_CONNECTION is unset — the overlay denies the operator's
-// cortex settings.json (where a default connection would live), so the
-// connection must arrive through the adapter's own env/settings seam, and
-// running without one would measure a config hole, not the rail. This gate
-// touches the real host exactly where LIVE gates may: the operator's real
-// cortex auth (read-only through symlinks) and ~/.pi/agent/cortex-overlays.
-//
-// Model override: ENTWURF_ACP_CORTEX_MODEL (default cortex-claude-sonnet-5).
-
-import { type ChildProcess, spawn } from "node:child_process";
-import * as crypto from "node:crypto";
-import { existsSync } from "node:fs";
-import * as fsp from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as readline from "node:readline";
-import { fileURLToPath } from "node:url";
-import {
-	upsertMetaSession,
-	writeMetaReceiverMarker,
-	writeMetaSenderMarker,
-} from "../pi-extensions/lib/meta-session.ts";
-import { terminateChild } from "./lib/acp-child-cleanup.ts";
-import { skipLive } from "./lib/live-skip.ts";
-import { PI_BOOT_TIMEOUT_MS, waitForPiRecord } from "./lib/pi-record-discovery.ts";
-
-const ACP_PROVIDER = "entwurf";
-const ACP_MODEL = process.env.ENTWURF_ACP_CORTEX_MODEL?.trim() || "cortex-claude-sonnet-5";
-
-const REAL_CONTROL_DIR = path.join(os.homedir(), ".pi", "entwurf-control");
-const CORTEX_OVERLAYS_ROOT = path.join(os.homedir(), ".pi", "agent", "cortex-overlays");
-const SOCKET_SUFFIX = ".sock";
-const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-// Load ONLY this checkout's extensions so the resident registers THIS acp-provider.ts.
-// `builtin:mcp`: `--no-extensions` also turns off Pi's built-in MCP, which a citizen's entwurf-bridge
-// registration needs (scripts/resident-rpc-drive.ts has the measurement).
-const REPO_EXTENSION_ARGS = ["--no-extensions", "-e", "builtin:mcp", "-e", REPO_ROOT] as const;
-
-const BOOT_TIMEOUT_MS = PI_BOOT_TIMEOUT_MS; // shared: pi lock-stale window + boot (see pi-record-discovery)
-// The cortex CLI self-extracts on first launch and its newSession alone is
-// ~2.5 s; keep the generous default of the sibling smoke.
-const TURN_TIMEOUT_MS = Number(process.env.ENTWURF_ACP_CORTEX_TIMEOUT_MS) || 300_000;
-const RECLAIM_TIMEOUT_MS = 20_000;
-const POLL_MS = 100;
-
-let passed = 0;
-function ok(label: string, cond: boolean): void {
-	if (!cond) throw new Error(`SMOKE FAIL: ${label}`);
-	console.log(`  ok    ${label}`);
-	passed++;
-}
-
-async function writeFailureArtifact(cap: { stream: string } | null, stderrTail: string, err: unknown): Promise<void> {
-	try {
-		const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-		const file = path.join(os.tmpdir(), `entwurf-smoke-acp-cortex-live-FAIL-${stamp}.log`);
-		await fsp.writeFile(
-			file,
-			`# smoke-acp-cortex-live FAILURE\n# ${err instanceof Error ? err.message : String(err)}\n` +
-				`# model: ${ACP_PROVIDER}/${ACP_MODEL}\n\n` +
-				`## event stream\n${cap?.stream ?? "(no turn captured)"}\n\n` +
-				`## resident stderr tail\n${stderrTail || "(empty)"}\n`,
-			"utf8",
-		);
-		console.error(`[smoke-acp-cortex-live] FAILURE transcript: ${file}`);
-	} catch {
-		console.error("[smoke-acp-cortex-live] could not write the failure transcript (reporting the original error)");
-	}
-}
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function waitForSocket(sockPath: string, timeoutMs: number): Promise<boolean> {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (existsSync(sockPath)) return true;
-		await sleep(POLL_MS);
-	}
-	return false;
-}
-
-/** pids (other than ours) whose environ carries `needle` — the overlay scope
- *  path is unique per run, so this finds exactly the cortex child + its
- *  grandchildren, never an unrelated operator cortex. Foreign-user /proc
- *  entries EACCES-skip (they cannot be our children). */
-async function pidsWithEnvNeedle(needle: string): Promise<number[]> {
-	const hits: number[] = [];
-	const entries = await fsp.readdir("/proc").catch(() => [] as string[]);
-	for (const entry of entries) {
-		if (!/^\d+$/.test(entry)) continue;
-		const pid = Number(entry);
-		if (pid === process.pid) continue;
-		try {
-			const environ = await fsp.readFile(path.join("/proc", entry, "environ"), "utf8");
-			if (environ.includes(needle)) hits.push(pid);
-		} catch {
-			// gone or not ours — either way not a leak we own
-		}
-	}
-	return hits;
-}
-
-interface TurnCapture {
-	agentStartSeen: boolean;
-	agentEndSeen: boolean;
-	extensionErrors: Array<{ path: unknown; event: unknown; error: unknown }>;
-	promptAccepted: boolean;
-	stream: string;
-}
-
-// Drive exactly one model turn over the resident's stdin RPC and capture the
-// stdout event stream until `agent_end` (or the hard turn timeout).
-function driveTurn(child: ChildProcess, prompt: string): Promise<TurnCapture> {
-	return new Promise((resolve) => {
-		const cap: TurnCapture = {
-			agentStartSeen: false,
-			agentEndSeen: false,
-			extensionErrors: [],
-			promptAccepted: false,
-			stream: "",
-		};
-		let settled = false;
-		const finish = (): void => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			rl.close();
-			resolve(cap);
-		};
-		const timer = setTimeout(finish, TURN_TIMEOUT_MS);
-		child.once("exit", finish);
-
-		const rl = readline.createInterface({ input: child.stdout! });
-		rl.on("line", (line: string) => {
-			const trimmed = line.trim();
-			if (!trimmed) return;
-			cap.stream += `${trimmed}\n`;
-			let evt: Record<string, unknown>;
-			try {
-				evt = JSON.parse(trimmed) as Record<string, unknown>;
-			} catch {
-				return;
-			}
-			if (evt.type === "agent_start") cap.agentStartSeen = true;
-			if (evt.type === "extension_error") {
-				cap.extensionErrors.push({ path: evt.extensionPath, event: evt.event, error: evt.error });
-			}
-			if (evt.type === "response" && evt.command === "prompt") cap.promptAccepted = evt.success === true;
-			if (evt.type === "agent_end") {
-				cap.agentEndSeen = true;
-				finish();
-			}
-		});
-
-		child.stdin?.write(`${JSON.stringify({ type: "prompt", message: prompt, id: "cortexv2" })}\n`);
-	});
-}
-
-async function main(): Promise<void> {
-	if (process.env.LIVE !== "1") {
-		skipLive("smoke-acp-cortex-live", "set LIVE=1 to run (spawns a real cortex ACP resident + one model turn).");
-	}
-	const connection = process.env.ENTWURF_ACP_CORTEX_CONNECTION?.trim();
-	if (!connection) {
-		skipLive(
-			"smoke-acp-cortex-live",
-			"set ENTWURF_ACP_CORTEX_CONNECTION=<snowflake connection> (the dual-HOME overlay denies the operator cortex settings.json, so the connection must ride the adapter's own seam).",
-		);
-	}
-	if ("CORTEX_HOME" in process.env) {
-		skipLive("smoke-acp-cortex-live", "unset CORTEX_HOME first (the adapter refuses its presence, CP0 D3).");
-	}
-
-	// One temp root holding the whole garden this smoke can see: store, mailbox
-	// and receiver markers. Only these move — the operator's real cortex auth
-	// (via overlay symlinks) and the control dir stay real.
-	const world = await fsp.mkdtemp(path.join(os.tmpdir(), "acp-cortex-"));
-	const sessionsDir = path.join(world, "sessions");
-	const mailboxDir = path.join(world, "mailbox");
-	const receiversDir = path.join(world, "receivers");
-	const sendersDir = path.join(world, "senders");
-	for (const d of [sessionsDir, mailboxDir, receiversDir, sendersDir]) await fsp.mkdir(d, { recursive: true });
-
-	const nonce = `CORTEXV2-${crypto.randomBytes(5).toString("hex").toUpperCase()}`;
-
-	console.error(`[smoke-acp-cortex-live] repo:  ${REPO_ROOT}`);
-	console.error(`[smoke-acp-cortex-live] model: ${ACP_PROVIDER}/${ACP_MODEL} (connection ${connection})`);
-	console.error(`[smoke-acp-cortex-live] world: ${world}`);
-
-	// ── the peer: an armed self-fetch citizen, deliverable by the mailbox rail ──
-	const receiver = upsertMetaSession({
-		input: { backend: "claude-code", nativeSessionId: `acp-cortex-${process.pid}`, cwd: world },
-		dir: sessionsDir,
-	});
-	const receiverGid = receiver.record.gardenId;
-	// The receiver marker alone is no longer the whole fixture (#101): a `claude-code-cli` watch
-	// owner is deliverable only while ITS OWN sender marker still names the garden it is armed
-	// for — that join is what refuses a session which switched away in place. A receiver marker
-	// with no sender marker beside it models a state the product now treats as retired, so this
-	// smoke would fail on its own fixture instead of on the rail it exists to prove. Same shape
-	// as smoke-mux-lifecycle-live / smoke-omp-fresh-live, which already seeded both.
-	writeMetaReceiverMarker({
-		gardenId: receiverGid,
-		backend: "claude-code",
-		nativeSessionId: receiver.record.nativeSessionId,
-		ownerPid: process.pid,
-		armProvenance: "session-start",
-		receiversDir,
-	});
-	writeMetaSenderMarker({
-		backend: "claude-code",
-		gardenId: receiverGid,
-		nativeSessionId: receiver.record.nativeSessionId,
-		cwd: world,
-		ownerPid: process.pid,
-		sendersDir,
-	});
-	console.error(`[smoke-acp-cortex-live] peer:  ${receiverGid} (armed mailbox receiver)`);
-
-	let senderGid = "";
-	let stderrTail = "";
-	let resident: ChildProcess | null = null;
-	let cap: TurnCapture | null = null;
-	let overlayScopeDir = "";
-	try {
-		resident = spawn(
-			"pi",
-			[...REPO_EXTENSION_ARGS, "--entwurf-control", "--provider", ACP_PROVIDER, "--model", ACP_MODEL, "--mode", "rpc"],
-			{
-				cwd: world,
-				stdio: ["pipe", "pipe", "pipe"],
-				detached: false,
-				env: {
-					...process.env,
-					ENTWURF_META_SESSIONS_DIR: sessionsDir,
-					ENTWURF_META_MAILBOX_DIR: mailboxDir,
-					ENTWURF_META_RECEIVERS_DIR: receiversDir,
-					ENTWURF_META_SENDERS_DIR: sendersDir,
-				},
-			},
-		);
-		resident.stderr?.on("data", (b: Buffer) => {
-			stderrTail = (stderrTail + b.toString()).slice(-4000);
-		});
-
-		const bornGid = await waitForPiRecord(sessionsDir, BOOT_TIMEOUT_MS);
-		ok(`cortex-model resident birthed its own V3 record (${ACP_PROVIDER}/${ACP_MODEL})`, bornGid !== null);
-		senderGid = bornGid as string;
-		console.error(`[smoke-acp-cortex-live] sender:${senderGid} (never told to the model)`);
-		ok("sender and receiver are distinct citizens", senderGid !== receiverGid);
-		const sockPath = path.join(REAL_CONTROL_DIR, `${senderGid}${SOCKET_SUFFIX}`);
-		ok(
-			"resident stood up a control socket keyed on its record gardenId",
-			await waitForSocket(sockPath, BOOT_TIMEOUT_MS),
-		);
-
-		// The prompt names the TARGET but never the sender's own gid — that can
-		// only reach the mailbox via the real envelope the projection carried.
-		const prompt =
-			`Call the mcp__entwurf-bridge__entwurf_v2 tool exactly once with these arguments: ` +
-			`target="${receiverGid}", intent="fire-and-forget", message="${nonce}". ` +
-			`Then reply with ONLY the tool's outcome line.`;
-		cap = await driveTurn(resident, prompt);
-
-		ok("the prompt RPC command was accepted", cap.promptAccepted);
-		ok("a real model turn ran over the stdin RPC (agent_start)", cap.agentStartSeen);
-		ok("the turn completed cleanly over RPC (agent_end — no hang)", cap.agentEndSeen);
-		ok("no extension_error during the turn", cap.extensionErrors.length === 0);
-
-		// ── the dual-HOME overlay is a disk fact, not an implementation detail ──
-		// scope id = `<resident pid>-<hash>` (the resident hosts the ACP spawn).
-		const scopeEntries = (await fsp.readdir(CORTEX_OVERLAYS_ROOT).catch(() => [] as string[])).filter((e) =>
-			e.startsWith(`${resident?.pid}-`),
-		);
-		ok(
-			`the resident materialized exactly one overlay scope dir (got ${scopeEntries.length})`,
-			scopeEntries.length === 1,
-		);
-		overlayScopeDir = path.join(CORTEX_OVERLAYS_ROOT, scopeEntries[0] as string);
-		const ovlCortex = path.join(overlayScopeDir, "home", ".snowflake", "cortex");
-		const ovlSettings = JSON.parse(await fsp.readFile(path.join(ovlCortex, "settings.json"), "utf8"));
-		ok("the overlay pinned autoUpdate:false (D4)", ovlSettings.autoUpdate === false);
-		const ovlMcp = JSON.parse(await fsp.readFile(path.join(ovlCortex, "mcp.json"), "utf8"));
-		const bridge = ovlMcp.mcpServers?.["entwurf-bridge"];
-		ok("the overlay mcp.json projected the entwurf-bridge entry (D9)", Boolean(bridge));
-		ok("the projected bridge entry restored the REAL operator HOME (D10 dual-HOME)", bridge.env?.HOME === os.homedir());
-		ok(
-			"the projected bridge entry carries the live PI_SESSION_ID envelope",
-			typeof bridge.env?.PI_SESSION_ID === "string" && bridge.env.PI_SESSION_ID.length > 0,
-		);
-		ok(
-			`the projected bridge entry carries PI_AGENT_ID=entwurf/${ACP_MODEL}`,
-			bridge.env?.PI_AGENT_ID === `${ACP_PROVIDER}/${ACP_MODEL}`,
-		);
-
-		// ── the outbound proof is on disk, not in the transcript ──
-		const boxDir = path.join(mailboxDir, receiverGid);
-		const entries = await fsp.readdir(boxDir).catch(() => [] as string[]);
-		const msgs = entries.filter((f) => f.endsWith(".msg"));
-		ok(`the model's entwurf_v2 call enqueued exactly one .msg to the peer (got ${msgs.length})`, msgs.length === 1);
-		ok("the doorbell inbox.signal was poked", existsSync(path.join(boxDir, "inbox.signal")));
-
-		const body = await fsp.readFile(path.join(boxDir, msgs[0] as string), "utf8");
-		const SEPARATOR = "────────────────────────────────────────";
-		const sepAt = body.indexOf(`\n${SEPARATOR}\n`);
-		ok("the delivered body carries the rendered envelope separator", sepAt !== -1);
-		const header = body.slice(0, sepAt + 1);
-		const payload = body.slice(sepAt + 1 + SEPARATOR.length + 1);
-
-		const rx = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-		ok("the payload is EXACTLY the nonce (no envelope text folded into it)", payload === `${nonce}\n`);
-		ok(
-			"the landed sender agentId is the cortex ACP model (anchored envelope line)",
-			new RegExp(`^ {2}from: {8}${rx(ACP_PROVIDER)}/${rx(ACP_MODEL)} @ \\S`, "m").test(header),
-		);
-		ok(
-			"the landed sender session IS the resident's own garden id, replyable (anchored envelope line)",
-			new RegExp(
-				`^ {2}session: {5}${rx(senderGid)} \\(replyable — reply via entwurf_v2 to this sessionId, intent=fire-and-forget\\)$`,
-				"m",
-			).test(header),
-		);
-		ok("the sender gid appears ONLY in the envelope, never in the payload", !payload.includes(senderGid));
-		ok("the landed sender renders as a pi-session, not a meta-session", !header.includes("(meta-session"));
-
-		// ── process-group reclaim (CP0 teardown finding) ──
-		// While the resident lives, its retained cortex child inhabits this run's
-		// overlay (SNOWFLAKE_HOME env is unique per scope). An MCP-configured
-		// cortex child ignores stdin EOF, so only the resident's process-group
-		// teardown can reclaim it — kill the resident and require extinction.
-		const liveBefore = await pidsWithEnvNeedle(overlayScopeDir);
-		ok(
-			`the cortex child (group) is alive inside this run's overlay pre-teardown (got ${liveBefore.length})`,
-			liveBefore.length > 0,
-		);
-		await terminateChild(resident);
-		resident = null;
-		let leaked: number[] = [];
-		const deadline = Date.now() + RECLAIM_TIMEOUT_MS;
-		for (;;) {
-			leaked = await pidsWithEnvNeedle(overlayScopeDir);
-			if (leaked.length === 0 || Date.now() > deadline) break;
-			await sleep(250);
-		}
-		ok(
-			`process-group teardown reclaimed every process in this run's overlay (leaked: ${leaked.join(",") || "none"})`,
-			leaked.length === 0,
-		);
-	} catch (err) {
-		await writeFailureArtifact(cap, stderrTail, err);
-		throw err;
-	} finally {
-		if (resident) await terminateChild(resident);
-		if (overlayScopeDir) await fsp.rm(overlayScopeDir, { recursive: true, force: true }).catch(() => {});
-		if (process.env.ENTWURF_KEEP_SMOKE_WORLD === "1") {
-			console.error(`[smoke-acp-cortex-live] kept world: ${world}`);
-		} else {
-			await fsp.rm(world, { recursive: true, force: true }).catch(() => {});
-		}
-	}
-
-	if (stderrTail && process.env.ENTWURF_SMOKE_VERBOSE === "1") {
-		console.error(`[smoke-acp-cortex-live] resident stderr tail:\n${stderrTail}`);
-	}
-	console.log(
-		`smoke-acp-cortex-live: PASS (${passed} assertions) — a cortex ACP model delivered to a peer as itself and was reclaimed`,
-	);
-}
-
-await main();
+// Cortex ACP is no longer a supported Entwurf backend. Keep the old developer
+// entry as a named refusal, never a vendor launch or a successful/skipped probe.
+console.error("[entwurf:cortex-acp-disabled] Cortex ACP is not supported; no live probe was started.");
+process.exitCode = 2;

package/scripts/smoke-acp-ordering-probe-live.ts

@@ -41,6 +41,7 @@
 import { type ChildProcessByStdio, execFileSync, spawn } from "node:child_process";
 import { copyFileSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { Readable, Writable } from "node:stream";
@@ -576,7 +577,12 @@ async function main(): Promise<void> {
 		CLI_TARGET = await resolveProbeCliTarget({
 			env: process.env,
 			resolveNative: async () => {
-				const mod = (await import("@agentclientprotocol/claude-agent-acp/dist/acp-agent.js")) as {
+				// claude-agent-acp 0.103.0 narrowed `exports` to `.` and `./package.json`, so
+				// a bare deep specifier now fails ERR_PACKAGE_PATH_NOT_EXPORTED. The resolver
+				// still ships at `dist/claude-cli.js`; reach it by file URL from the exported
+				// package.json, the same anchor the production launcher uses.
+				const pkgJson = createRequire(import.meta.url).resolve("@agentclientprotocol/claude-agent-acp/package.json");
+				const mod = (await import(pathToFileURL(join(dirname(pkgJson), "dist", "claude-cli.js")).href)) as {
 					claudeCliPath: () => Promise<string>;
 				};
 				return mod.claudeCliPath();

package/scripts/smoke-acp-session-reuse-live.ts

@@ -114,8 +114,17 @@ async function main(): Promise<void> {
 	// pick `process-scoped`, so turn 2 reuses the in-memory child.
 	if (!process.argv.includes("--entwurf-control")) process.argv.push("--entwurf-control");
 
-	const model = { id: MODEL } as unknown as Model<Api>;
-	const options = { cwd: scratch, sessionId: "reuse-smoke" };
+	// #142: the Claude ACP rail maps pi's thinking level through the REGISTERED row's
+	// `thinkingLevelMap` and refuses a turn with no level (pi sends none for `off` or an unset
+	// level). So this smoke takes the curated row's map and states a level, as an operator's pi
+	// does through its registered model and defaultThinkingLevel.
+	const models = (await import(pathToFileURL(resolve(TMP_EMIT, "pi-extensions/lib/acp/models.js")).href)) as {
+		curatedClaudeModels: () => Array<{ id: string; thinkingLevelMap?: unknown }>;
+	};
+	const row = models.curatedClaudeModels().find((m) => m.id === MODEL);
+	if (!row) fail(`model ${MODEL} is not a curated Claude ACP row`);
+	const model = { id: MODEL, thinkingLevelMap: row.thinkingLevelMap } as unknown as Model<Api>;
+	const options = { cwd: scratch, sessionId: "reuse-smoke", reasoning: "medium" as const };
 
 	console.error(`[smoke-acp-session-reuse-live] repo:     ${REPO_ROOT}`);
 	console.error(`[smoke-acp-session-reuse-live] cwd:      ${scratch}`);

package/scripts/smoke-acp-v2-send-live.ts

@@ -345,7 +345,7 @@ async function main(): Promise<void> {
 		ok(
 			"the landed sender session IS the resident's own garden id, replyable (anchored envelope line)",
 			new RegExp(
-				`^ {2}session: {5}${rx(senderGid)} \\(replyable — reply via entwurf_v2 to this sessionId, intent=fire-and-forget\\)$`,
+				`^ {2}session: {5}${rx(senderGid)} ${rx("(replyable — when a reply is requested, send the result via entwurf_v2 (intent=fire-and-forget) to the requested recipient, defaulting to this sessionId; a local final is not delivery. Honor routing and no-send instructions; an absent or false wants_reply does not cancel a request. A replyable address alone needs no acknowledgment)")}$`,
 				"m",
 			).test(header),
 		);