@junghanacs/entwurf 0.52.0 → 0.53.1

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)} ${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),
-		);
-		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-herdr-raw-install-live.sh

@@ -6,7 +6,7 @@
 # `smoke-herdr-plugin-build-live` redirects the product remote to a local bare clone with
 # git `insteadOf` and asserts `identity.kind === "herdr-checkout"`. Both are honest about
 # what they are, and neither has ever watched the plugin acquire its runtime from npm on a
-# machine that has never seen this repository. VERIFY.md:61 says a source switch is a
+# machine that has never seen this repository. VERIFY.md's "Switching the plugin's production acquisition source is a re-proof" note says a source switch is a
 # re-proof, and the production lock has said `npm` since dd84ac0 with that re-proof's
 # acquisition axis still empty. Cells [1]–[5] close that one axis.
 #
@@ -17,7 +17,7 @@
 # garden citizen with a record and a control socket; `entwurf peer-facts` and the plugin's
 # own status fan are asked about that citizen with neither side stubbed; and the shipped
 # teardown deletes the runtime it is executing from and then comes back. Those are
-# VERIFY.md:102's installed-runtime and deactivation rows, re-proved against the npm source
+# that VERIFY.md note's installed-runtime and deactivation rows, re-proved against the npm source
 # rather than against a fixture.
 #
 # AT A REF WHOSE LOCK NAMES `herdr-checkout`, the acquisition axis reports a NAMED SKIP and
@@ -456,7 +456,7 @@ fi
 # ── 6. the INSTALLED runtime, MEASURED instead of implied (#118 H1-5) ────────
 # A green [2] already implies this: `certifyInstalledTree` refuses an install whose tree
 # lacks the compiled entry, the three bins, or a `check-bridge` that exits 0
-# (herdr-runtime.mjs:824-843). Implication is not observation, and VERIFY.md:102 lists
+# (herdr-runtime.mjs:824-843). Implication is not observation, and that VERIFY.md note lists
 # "the installed runtime (name@version, compiled entry, three executable bins, a real
 # check-bridge)" as its own re-proof row against THIS source. A row closed by inference
 # cannot print the verb set it claims, so these lines run the npm-acquired bytes and print
@@ -838,7 +838,7 @@ fi
 # `check-herdr-activation` cell 16 proves this against fixtures: [QK:HAC-DEACTIVATE-ROUNDTRIP]
 # asserts the pi settings return to their ORIGINAL MEANING (JSON equality, not bytes — the
 # writer may reindent), zero install-state survives, and the runtime and ledger are retired.
-# VERIFY.md:102 lists deactivation as a row that must be re-run against the production
+# that VERIFY.md note lists deactivation as a row that must be re-run against the production
 # source, and #118's table still carries it as `deactivate 미결`. This runs the verb that
 # actually ships — `entwurf herdr-plugin-deactivate` from the npm-installed bin, deleting
 # the runtime it is itself executing from — and then reinstalls, because a teardown nobody