@junghanacs/entwurf 0.12.0

package/scripts/check-entwurf-bridge-boot.ts

@@ -0,0 +1,199 @@
+/**
+ * check-entwurf-bridge-boot — deterministic gate (0.11 step 5d-5-pre, G1a/G1b):
+ * boots the entwurf-bridge MCP server EXACTLY as it ships (start.sh →
+ * `node --experimental-strip-types src/index.ts`, no build step) and asserts the
+ * runtime contract that the source-shape gate `check-entwurf-v2-surface` cannot:
+ *
+ *   - G1a: the server actually BOOTS. start.sh static-imports the whole v2 fence
+ *     graph (entwurf-v2-surface → runner → production → decider/lock/send/spawn/
+ *     mailbox/control-rpc) at top level under strip-types; a strip-types-hostile
+ *     construct (enum / namespace / parameter property / `import =`) anywhere in
+ *     that graph would crash the server at boot. A parseable tools/list (id:2)
+ *     response IS the proof the graph loaded and `server.tool` registration ran.
+ *   - G1b: `entwurf_v2` is registered on the runtime tools/list surface with the
+ *     expected input schema (props ⊇ target/intent/message/mode/wants_reply;
+ *     required ⊇ target/intent/message; intent/mode enums).
+ *
+ * Scope boundary (D1=A안): this gate owns boot + entwurf_v2 registration/schema.
+ * The broad protocol/negative suite stays in check-bridge/test.sh. Only a
+ * `tools/list` is sent — no `tools/call` — so there is NO lock/filesystem side
+ * effect and no auth/model is needed; it lives in `pnpm check`.
+ */
+
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const START_SH = path.join(REPO_DIR, "mcp", "entwurf-bridge", "start.sh");
+
+let passed = 0;
+function ok(label: string, cond: boolean, detail?: string): void {
+	if (!cond) {
+		console.error(`  ✗ ${label}`);
+		if (detail) console.error(detail);
+		process.exit(1);
+	}
+	passed++;
+}
+
+function fatal(msg: string): never {
+	console.error(`check-entwurf-bridge-boot: ${msg}`);
+	process.exit(1);
+}
+
+interface BridgeTool {
+	name?: string;
+	inputSchema?: {
+		properties?: Record<string, { enum?: unknown; maxLength?: unknown }>;
+		required?: unknown;
+	};
+}
+
+/**
+ * Boot start.sh, run the MCP handshake + a single tools/list (id:2), and resolve
+ * with the registered tools. The failure paths are split (timeout / early-exit /
+ * parse / missing result.tools) so a strip-types boot crash surfaces with its
+ * rc/signal/stderr — not as an opaque "no response".
+ */
+function bootAndListTools(): Promise<BridgeTool[]> {
+	return new Promise((resolve) => {
+		const child = spawn(START_SH, { stdio: ["pipe", "pipe", "pipe"] });
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			try {
+				child.kill("SIGTERM");
+			} catch {}
+			setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {}
+			}, 300);
+			fatal(`no tools/list response before timeout${stderr.trim() ? `\n--- stderr ---\n${stderr.trim()}` : ""}`);
+		}, 10_000);
+
+		function tryResolve(): void {
+			if (settled) return;
+			// MCP frames are newline-delimited JSON-RPC; find the id:2 (tools/list) reply.
+			for (const line of stdout
+				.split("\n")
+				.map((l) => l.trim())
+				.filter(Boolean)) {
+				let msg: { id?: unknown; result?: { tools?: unknown } };
+				try {
+					msg = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				if (msg?.id !== 2) continue;
+				settled = true;
+				clearTimeout(timer);
+				try {
+					child.kill("SIGTERM");
+				} catch {}
+				const tools = msg?.result?.tools;
+				if (!Array.isArray(tools)) {
+					fatal(`id:2 response missing result.tools\n--- raw ---\n${line}`);
+				}
+				resolve(tools as BridgeTool[]);
+				return;
+			}
+		}
+
+		child.stdout.on("data", (d) => {
+			stdout += d.toString();
+			tryResolve();
+		});
+		child.stderr.on("data", (d) => {
+			stderr += d.toString();
+		});
+		child.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			fatal(`failed to spawn start.sh: ${String(err)}`);
+		});
+		child.on("close", (code, signal) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			// Closed before id:2 — this is where a strip-types boot crash / SyntaxError
+			// in the static-import fence graph surfaces.
+			fatal(
+				`server exited before tools/list response (code=${code} signal=${String(signal)})` +
+					(stderr.trim() ? `\n--- stderr ---\n${stderr.trim()}` : "") +
+					(stdout.trim() ? `\n--- stdout ---\n${stdout.trim()}` : ""),
+			);
+		});
+
+		const send = (obj: unknown): void => {
+			child.stdin.write(`${JSON.stringify(obj)}\n`);
+		};
+		send({
+			jsonrpc: "2.0",
+			id: 1,
+			method: "initialize",
+			params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "check-boot", version: "0" } },
+		});
+		send({ jsonrpc: "2.0", method: "notifications/initialized" });
+		send({ jsonrpc: "2.0", id: 2, method: "tools/list" });
+	});
+}
+
+/** Order-independent set equality — the enum is a contract on membership, not order. */
+function setEq(actual: unknown, expected: string[]): boolean {
+	if (!Array.isArray(actual)) return false;
+	const got = new Set(actual.map(String));
+	return got.size === expected.length && expected.every((e) => got.has(e));
+}
+
+async function main(): Promise<void> {
+	const tools = await bootAndListTools();
+
+	// G1a — a parseable tools/list arrived → the strip-types fence graph loaded + server.tool ran.
+	ok("G1a: MCP server boots under strip-types and answers tools/list", tools.length > 0);
+
+	// G1b — entwurf_v2 registered + schema contract.
+	const v2 = tools.find((t) => t?.name === "entwurf_v2");
+	ok("G1b: entwurf_v2 registered on the runtime tools/list surface", !!v2);
+
+	const schema = v2?.inputSchema ?? {};
+	const rawSchema = JSON.stringify(schema);
+	const props = schema.properties ?? {};
+	for (const p of ["target", "intent", "message", "mode", "wants_reply"]) {
+		ok(`G1b: entwurf_v2 schema has property '${p}'`, p in props, `--- inputSchema ---\n${rawSchema}`);
+	}
+	const required = Array.isArray(schema.required) ? schema.required.map(String) : [];
+	for (const r of ["target", "intent", "message"]) {
+		ok(`G1b: entwurf_v2 schema requires '${r}'`, required.includes(r), `--- inputSchema ---\n${rawSchema}`);
+	}
+	ok(
+		"G1b: entwurf_v2 intent enum == {fire-and-forget, owned-outcome}",
+		setEq(props.intent?.enum, ["fire-and-forget", "owned-outcome"]),
+		`--- inputSchema ---\n${rawSchema}`,
+	);
+	ok(
+		"G1b: entwurf_v2 mode enum == {steer, follow_up}",
+		setEq(props.mode?.enum, ["steer", "follow_up"]),
+		`--- inputSchema ---\n${rawSchema}`,
+	);
+	ok(
+		"G1b: entwurf_v2 message maxLength == 16000",
+		props.message?.maxLength === 16000,
+		`--- inputSchema ---\n${rawSchema}`,
+	);
+
+	ok(
+		"G1c: legacy v1 MCP tools are absent",
+		!tools.some((t) => ["entwurf", "entwurf_resume", "entwurf_send"].includes(String(t?.name))),
+	);
+
+	console.log(`\ncheck-entwurf-bridge-boot: ${passed} checks passed`);
+}
+
+await main();

package/scripts/check-entwurf-capabilities.ts

@@ -0,0 +1,123 @@
+/**
+ * check-entwurf-capabilities — deterministic gate for 0.11 Stage 0 step 3C:
+ * the backend capability source. Pure parse over the packaged registry data
+ * file; no backend, no network, no hook. Safe in the `pnpm check` static floor.
+ *
+ * Proves the capability registry (`pi/entwurf-capabilities.json`) that gives the
+ * v2 record a place to send wakeMode/deliveryLevel/nativeIdLabel:
+ *   - the shipped file parses + COVERS exactly META_BACKENDS_V2 (pi included),
+ *   - it AGREES with the live `META_BACKEND_DESCRIPTORS` for the three existing
+ *     backends (a drift guard for the 3C→3D transition while the live const is
+ *     still the authority — frozen "META_BACKEND_DESCRIPTORS 소비처 유지"),
+ *   - strict keyset / coverage / field validation all crash, not warn.
+ *
+ * Scope is 3C ONLY: schema + parser + gate. No live routing — the record writer/
+ * upsert/readMetaInbox/enqueueMetaMessage and the META_BACKEND_DESCRIPTORS live
+ * consumers are untouched; cutting them over (and dropping wakeMode from the
+ * record) lands in step 3D.
+ */
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import {
+	META_BACKEND_DESCRIPTORS,
+	META_BACKENDS_V2,
+	MetaRecordError,
+	metaCapabilitiesFilePath,
+	parseMetaCapabilityRegistry,
+} from "../pi-extensions/lib/meta-session.ts";
+
+let passed = 0;
+function ok(label: string, cond: boolean): void {
+	assert.ok(cond, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+function throws(label: string, fn: () => unknown): void {
+	assert.throws(fn, MetaRecordError, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+
+// The shipped registry, read from disk and parsed.
+const SHIPPED = fs.readFileSync(metaCapabilitiesFilePath(), "utf8");
+const reg = parseMetaCapabilityRegistry(SHIPPED);
+
+// 1. coverage — the shipped file covers exactly META_BACKENDS_V2, pi included.
+ok(
+	"shipped registry covers exactly META_BACKENDS_V2 (pi included)",
+	[...META_BACKENDS_V2].sort().join(",") === Object.keys(reg.backends).sort().join(","),
+);
+ok("shipped registry includes the pi backend", reg.backends.pi !== undefined);
+
+// 2. drift guard — for the three backends the live const still owns, the JSON
+//    must agree field-for-field (so the new source cannot silently diverge from
+//    META_BACKEND_DESCRIPTORS before 3D cuts the live consumer over).
+for (const backend of ["claude-code", "antigravity", "codex"] as const) {
+	const live = META_BACKEND_DESCRIPTORS[backend];
+	const cap = reg.backends[backend];
+	ok(
+		`capability for ${backend} agrees with live META_BACKEND_DESCRIPTORS (wakeMode/deliveryLevel/nativeIdLabel)`,
+		cap.wakeMode === live.wakeMode &&
+			cap.deliveryLevel === live.deliveryLevel &&
+			cap.nativeIdLabel === live.nativeIdLabel,
+	);
+}
+
+// 3. pi capability is well-formed (its values are NEW — no live const to compare).
+//    pi = direct-inject: pi's live wake path is the control socket
+//    (pi.sendMessage triggerTurn) which injects the body straight into the
+//    model-visible turn — that is direct-inject, not Claude's mailbox self-fetch.
+ok(
+	"pi capability is well-formed (direct-inject / D6 / sessionId)",
+	reg.backends.pi.wakeMode === "direct-inject" &&
+		reg.backends.pi.deliveryLevel === "D6" &&
+		reg.backends.pi.nativeIdLabel === "sessionId",
+);
+
+// 4. crash, don't warn — schema/coverage/keyset/field validation.
+const base = JSON.parse(SHIPPED) as Record<string, unknown>;
+throws("parse: invalid JSON throws", () => parseMetaCapabilityRegistry("{nope"));
+throws("parse: array (non-object) throws", () => parseMetaCapabilityRegistry("[]"));
+throws("parse: wrong schemaVersion throws", () =>
+	parseMetaCapabilityRegistry(JSON.stringify({ ...base, schemaVersion: 2 })),
+);
+throws("parse: unexpected top-level key throws", () =>
+	parseMetaCapabilityRegistry(JSON.stringify({ ...base, extra: 1 })),
+);
+throws("parse: missing a backend (coverage short) throws", () => {
+	const backends = { ...(base.backends as Record<string, unknown>) };
+	delete backends.pi;
+	return parseMetaCapabilityRegistry(JSON.stringify({ ...base, backends }));
+});
+throws("parse: unknown extra backend (coverage over) throws", () =>
+	parseMetaCapabilityRegistry(
+		JSON.stringify({ ...base, backends: { ...(base.backends as Record<string, unknown>), gemini: reg.backends.pi } }),
+	),
+);
+throws("parse: bad wakeMode value throws", () =>
+	parseMetaCapabilityRegistry(
+		JSON.stringify({
+			...base,
+			backends: { ...(base.backends as Record<string, unknown>), pi: { ...reg.backends.pi, wakeMode: "telepathy" } },
+		}),
+	),
+);
+throws("parse: unexpected key inside a capability entry throws", () =>
+	parseMetaCapabilityRegistry(
+		JSON.stringify({
+			...base,
+			backends: { ...(base.backends as Record<string, unknown>), pi: { ...reg.backends.pi, tmuxTarget: "psa:3.1" } },
+		}),
+	),
+);
+throws("parse: empty deliveryLevel throws", () =>
+	parseMetaCapabilityRegistry(
+		JSON.stringify({
+			...base,
+			backends: { ...(base.backends as Record<string, unknown>), pi: { ...reg.backends.pi, deliveryLevel: "" } },
+		}),
+	),
+);
+
+console.log(`[check-entwurf-capabilities] ${passed} assertions ok`);

package/scripts/check-entwurf-control-rpc.ts

@@ -0,0 +1,187 @@
+/**
+ * check-entwurf-control-rpc — gate for the 5d-2 RPC-helper EXTRACTION micro-slice. It
+ * proves the `--entwurf-control` socket protocol moved to the ctx-free SSOT
+ * `lib/entwurf-control-rpc.ts` WITHOUT a behaviour change, and that the surface file now
+ * consumes it instead of defining its own:
+ *
+ *   1. ctx-free source guard — the new lib imports NO surface-only world
+ *      (ExtensionContext / ExtensionAPI / pi. / @earendil-works/pi-ai). It is a pure
+ *      transport so the 5d-2b production `sendOverSocket` can share it from lib/.
+ *   2. extraction guard — `entwurf-control.ts` IMPORTS `sendRpcCommand` from the shared
+ *      lib and no longer DEFINES its own `async function sendRpcCommand` (no protocol fork).
+ *   3. round-trip — a real (short) unix-socket server echoes `{type:"response",
+ *      command:<same>, success:true}` and `sendRpcCommand` resolves `{response.success:true}`
+ *      with the matching command tag (the newline-JSON write + matched-response parse wire).
+ *   4. close-before-response — a server that accepts then closes WITHOUT a response makes
+ *      `sendRpcCommand` reject `connection closed before response` (the 2026-05-18
+ *      receiver-stuck backstop the settled-guard preserves).
+ *   5. get_info runtime helper parses/formats cwd/model/idle once for every caller.
+ *
+ * No model / auth / pi process — only `net.Server` on a tmp socket, so it rides `pnpm check`.
+ */
+
+import assert from "node:assert/strict";
+import * as fs from "node:fs/promises";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	fetchControlSocketRuntimeInfo,
+	formatRuntimeModel,
+	parseGetInfoResponseData,
+	type RpcSendCommand,
+	sendRpcCommand,
+} from "../pi-extensions/lib/entwurf-control-rpc.ts";
+
+let passed = 0;
+function ok(label: string, cond: boolean): void {
+	assert.ok(cond, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO = path.join(HERE, "..");
+const LIB_SRC = path.join(REPO, "pi-extensions/lib/entwurf-control-rpc.ts");
+const CONTROL_SRC = path.join(REPO, "pi-extensions/entwurf-control.ts");
+
+/** Spin up a one-shot unix-socket server; `onLine` decides the reply (or null = no reply). */
+async function withServer(
+	onLine: (line: string, socket: net.Socket) => void,
+	body: (socketPath: string) => Promise<void>,
+): Promise<void> {
+	const dir = await fs.mkdtemp(path.join(os.tmpdir(), "rpc-"));
+	const socketPath = path.join(dir, "s.sock");
+	const server = net.createServer((socket) => {
+		socket.setEncoding("utf8");
+		let buf = "";
+		socket.on("data", (chunk) => {
+			buf += chunk;
+			let nl = buf.indexOf("\n");
+			while (nl !== -1) {
+				const line = buf.slice(0, nl).trim();
+				buf = buf.slice(nl + 1);
+				nl = buf.indexOf("\n");
+				if (line) onLine(line, socket);
+			}
+		});
+	});
+	await new Promise<void>((resolve) => server.listen(socketPath, resolve));
+	try {
+		await body(socketPath);
+	} finally {
+		await new Promise<void>((resolve) => server.close(() => resolve()));
+		await fs.rm(dir, { recursive: true, force: true });
+	}
+}
+
+async function main(): Promise<void> {
+	// ── 1: ctx-free source guard ──────────────────────────────────────────────
+	{
+		const src = await fs.readFile(LIB_SRC, "utf8");
+		// Strip line/block comments so the module-header prose ("must NOT import …") never
+		// trips the guard — only real import statements count.
+		const code = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+		const forbidden = ["ExtensionContext", "ExtensionAPI", "@earendil-works/pi-ai", "pi."];
+		for (const term of forbidden) {
+			ok(`1: lib is ctx-free — no '${term}'`, !code.includes(term));
+		}
+		ok("1: lib imports only node:net (value)", /import \* as net from "node:net";/.test(code));
+	}
+
+	// ── 2: extraction guard — surface imports shared runtime helper, no fork ────
+	{
+		const src = await fs.readFile(CONTROL_SRC, "utf8");
+		ok(
+			"2: entwurf-control imports fetchControlSocketRuntimeInfo from the shared lib",
+			/from "\.\/lib\/entwurf-control-rpc\.js"/.test(src) && /\bfetchControlSocketRuntimeInfo\b/.test(src),
+		);
+		ok("2: entwurf-control no longer DEFINES sendRpcCommand", !/(async\s+)?function\s+sendRpcCommand\s*\(/.test(src));
+		ok("2: entwurf-control does not call sendRpcCommand directly", !/[^.]\bsendRpcCommand\s*\(/.test(src));
+	}
+
+	// ── 3: round-trip — write command, matched response, success:true ─────────
+	{
+		let seenLine: string | null = null;
+		await withServer(
+			(line, socket) => {
+				seenLine = line;
+				const cmd = JSON.parse(line);
+				socket.write(`${JSON.stringify({ type: "response", command: cmd.type, success: true, data: { ok: 1 } })}\n`);
+			},
+			async (socketPath) => {
+				const cmd: RpcSendCommand = { type: "send", message: "hi", mode: "follow_up", wants_reply: false };
+				const { response } = await sendRpcCommand(socketPath, cmd, { timeout: 2000 });
+				ok("3: round-trip → response.success true", response.success === true);
+				ok("3: response tagged with the SAME command", response.command === "send");
+				ok(
+					"3: server saw the newline-JSON command",
+					seenLine !== null && JSON.parse(seenLine as string).type === "send",
+				);
+			},
+		);
+	}
+
+	// ── 4: close-before-response → reject 'connection closed before response' ──
+	{
+		let rejected: unknown;
+		await withServer(
+			(_line, socket) => {
+				// Accept the command, then close WITHOUT replying.
+				socket.end();
+			},
+			async (socketPath) => {
+				try {
+					await sendRpcCommand(socketPath, { type: "get_info" }, { timeout: 2000 });
+				} catch (err) {
+					rejected = err;
+				}
+			},
+		);
+		ok(
+			"4: close-before-response → rejects 'connection closed before response'",
+			rejected instanceof Error && rejected.message === "connection closed before response",
+		);
+	}
+
+	// ── 5: get_info runtime parse/format/fetch SSOT ───────────────────────────
+	{
+		const parsed = parseGetInfoResponseData({
+			cwd: "/work/cos",
+			model: { provider: "entwurf", id: "gpt-5.5" },
+			idle: false,
+		});
+		ok("5: parse cwd", parsed.cwd === "/work/cos");
+		ok("5: parse model id", parsed.modelId === "gpt-5.5");
+		ok("5: parse model provider", parsed.modelProvider === "entwurf");
+		ok("5: parse idle false", parsed.idle === false);
+		ok("5: format provider/model", formatRuntimeModel(parsed) === "entwurf/gpt-5.5");
+		ok("5: format model-only fallback", formatRuntimeModel({ modelId: "gpt-5.5" }) === "gpt-5.5");
+		const malformed = parseGetInfoResponseData({ model: null });
+		ok(
+			"5: parse malformed data yields undefined fields",
+			malformed.cwd === undefined && malformed.modelId === undefined,
+		);
+
+		await withServer(
+			(line, socket) => {
+				const cmd = JSON.parse(line);
+				socket.write(
+					`${JSON.stringify({ type: "response", command: cmd.type, success: true, data: { cwd: "/w", model: { provider: "p", id: "m" }, idle: true } })}\n`,
+				);
+			},
+			async (socketPath) => {
+				const info = await fetchControlSocketRuntimeInfo(socketPath, { timeout: 2000 });
+				ok(
+					"5: fetch get_info parses response",
+					info.cwd === "/w" && formatRuntimeModel(info) === "p/m" && info.idle === true,
+				);
+			},
+		);
+	}
+
+	console.log(`\ncheck-entwurf-control-rpc: ${passed} checks passed`);
+}
+
+await main();

package/scripts/check-entwurf-deliverability.ts

@@ -0,0 +1,158 @@
+/**
+ * check-entwurf-deliverability — deterministic gate for the conversational-mailbox
+ * deliverability predicate (SE-1/SE-2 slice 2c). This is the predicate the enqueue
+ * sites (v1 fallback, MCP v1, pi-native v1, v2 decider/send-fallback) must consult in
+ * slice 2d before writing a .msg, so a reply never rots in a dead session's mailbox
+ * (SE-2) and is never enqueued for a backend that has no mailbox drain (SE-1, pi).
+ *
+ * Proves:
+ *   - computeMetaReceiverActive: the shared atom — active ⟺ recordBacked ∧ ownerAlive ∧
+ *     watchArmed; every axis required, undefined treated as false (fail-closed), each
+ *     failure names its own cause.
+ *   - mailboxConversationalDeliverable: deliverable ⟺ wakeMode "self-fetch" AND active.
+ *     KEY ROWS — direct-inject (pi) is refused even when the receiver looks active
+ *     (SE-1: no mailbox drain), and a self-fetch receiver with a dead owner / unarmed
+ *     watch is refused (SE-2: would rot as garbage).
+ *   - WIRING: the self-addressability predicate shares this exact atom (one source of
+ *     truth for "active receiver"), so self-reply and target-enqueue cannot drift.
+ */
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	computeMetaReceiverActive,
+	mailboxConversationalDeliverable,
+	receiverMarkerMatchesIdentity,
+} from "../pi-extensions/lib/entwurf-deliverability.ts";
+
+let passed = 0;
+function ok(label: string, cond: boolean): void {
+	assert.ok(cond, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+
+const REPO_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+// ── computeMetaReceiverActive: the shared atom ──────────────────────────────
+ok(
+	"active ⟺ recordBacked ∧ ownerAlive ∧ watchArmed",
+	computeMetaReceiverActive({ recordBacked: true, ownerAlive: true, watchArmed: true }).active === true,
+);
+ok(
+	"no backing record → inactive",
+	computeMetaReceiverActive({ recordBacked: false, ownerAlive: true, watchArmed: true }).active === false,
+);
+ok(
+	"owner dead → inactive",
+	computeMetaReceiverActive({ recordBacked: true, ownerAlive: false, watchArmed: true }).active === false,
+);
+ok(
+	"watch unarmed → inactive",
+	computeMetaReceiverActive({ recordBacked: true, ownerAlive: true, watchArmed: false }).active === false,
+);
+ok("undefined axes → fail-closed inactive", computeMetaReceiverActive({ recordBacked: true }).active === false);
+// each failure names its own cause (no conflation)
+ok(
+	"owner-dead reason mentions start-key",
+	/start-key/.test(computeMetaReceiverActive({ recordBacked: true, ownerAlive: false, watchArmed: true }).reason),
+);
+ok(
+	"watch-unarmed reason mentions doorbell",
+	/doorbell/.test(computeMetaReceiverActive({ recordBacked: true, ownerAlive: true, watchArmed: false }).reason),
+);
+
+// ── mailboxConversationalDeliverable: the enqueue gate ──────────────────────
+const D = (f: Parameters<typeof mailboxConversationalDeliverable>[0]) =>
+	mailboxConversationalDeliverable(f).deliverable;
+
+ok(
+	"self-fetch + active → deliverable",
+	D({ wakeMode: "self-fetch", recordBacked: true, ownerAlive: true, watchArmed: true }) === true,
+);
+// SE-1 KEY ROW: a direct-inject backend (pi) has no mailbox drain — refuse even when
+// the receiver otherwise looks fully active.
+ok(
+	"direct-inject (pi) + active → NOT deliverable (no mailbox drain — SE-1)",
+	D({ wakeMode: "direct-inject", recordBacked: true, ownerAlive: true, watchArmed: true }) === false,
+);
+// SE-2 KEY ROWS: self-fetch but the receiver is gone / never armed.
+ok(
+	"self-fetch + owner-dead → NOT deliverable (terminated session — SE-2)",
+	D({ wakeMode: "self-fetch", recordBacked: true, ownerAlive: false, watchArmed: true }) === false,
+);
+ok(
+	"self-fetch + watch-unarmed → NOT deliverable (no doorbell wake — SE-2)",
+	D({ wakeMode: "self-fetch", recordBacked: true, ownerAlive: true, watchArmed: false }) === false,
+);
+ok(
+	"self-fetch + no record → NOT deliverable",
+	D({ wakeMode: "self-fetch", recordBacked: false, ownerAlive: true, watchArmed: true }) === false,
+);
+ok("unset wakeMode → NOT deliverable", D({ recordBacked: true, ownerAlive: true, watchArmed: true }) === false);
+ok(
+	"unknown wakeMode string → fail-closed NOT deliverable",
+	D({ wakeMode: "direct-inject-future", recordBacked: true, ownerAlive: true, watchArmed: true }) === false,
+);
+// reasons distinguish the wake-mode refusal from the receiver-inactive refusal
+ok(
+	"direct-inject refusal reason names wake mode",
+	/wake mode/.test(
+		mailboxConversationalDeliverable({
+			wakeMode: "direct-inject",
+			recordBacked: true,
+			ownerAlive: true,
+			watchArmed: true,
+		}).reason,
+	),
+);
+ok(
+	"self-fetch inactive refusal reason names the receiver",
+	/receiver inactive/.test(
+		mailboxConversationalDeliverable({
+			wakeMode: "self-fetch",
+			recordBacked: true,
+			ownerAlive: false,
+			watchArmed: true,
+		}).reason,
+	),
+);
+
+// ── receiverMarkerMatchesIdentity: the marker ↔ identity SSOT (SE-2 2d-3) ───
+// A present marker only raises a receiver to active when it agrees with the record on
+// garden/backend/native id. The v1 mailbox guard AND the v2 production deliverability seam
+// both route through this one helper, so presence-only false-positives are closed in both.
+const ID = { gardenId: "20260612T100000-aaaaaa", backend: "claude-code", nativeSessionId: "n-1" };
+ok(
+	"marker matches identity on all three axes → true",
+	receiverMarkerMatchesIdentity(
+		{ gardenId: ID.gardenId, backend: ID.backend, nativeSessionId: ID.nativeSessionId },
+		ID,
+	),
+);
+ok(
+	"garden id drift → false (foreign marker)",
+	!receiverMarkerMatchesIdentity({ ...ID, gardenId: "20260612T999999-bbbbbb" }, ID),
+);
+ok("backend drift → false", !receiverMarkerMatchesIdentity({ ...ID, backend: "pi" }, ID));
+ok(
+	"native session id drift → false (stale/recycled marker)",
+	!receiverMarkerMatchesIdentity({ ...ID, nativeSessionId: "n-2" }, ID),
+);
+ok("null marker → false (fail-closed)", !receiverMarkerMatchesIdentity(null, ID));
+ok("undefined marker → false (fail-closed)", !receiverMarkerMatchesIdentity(undefined, ID));
+
+// ── WIRING: self-addressability shares the SAME atom ────────────────────────
+const selfSrc = readFileSync(path.join(REPO_DIR, "pi-extensions", "lib", "entwurf-self-address.ts"), "utf8");
+ok(
+	"entwurf-self-address imports computeMetaReceiverActive from the deliverability lib",
+	/computeMetaReceiverActive/.test(selfSrc) && /entwurf-deliverability\.ts/.test(selfSrc),
+);
+ok(
+	"entwurf-self-address calls computeMetaReceiverActive (no duplicated conjunction)",
+	/computeMetaReceiverActive\s*\(/.test(selfSrc),
+);
+
+console.log(`\ncheck-entwurf-deliverability: ${passed} checks passed`);