@junghanacs/entwurf 0.12.6 → 0.12.7

package/scripts/check-entwurf-v2-contract.ts

@@ -46,11 +46,18 @@ import {
 	factLivenessOf,
 	isLivenessSupported,
 	isPreProbeReject,
+	LIVENESS_DOMAIN_BACKENDS,
 	makeRejectReceipt,
+	NATIVE_PUSH_BACKENDS,
+	NATIVE_PUSH_DISPATCH_TABLE,
+	NATIVE_PUSH_REJECT_REASONS,
+	type NativePushLiveness,
+	nativePushSupported,
 	PRE_PROBE_REJECT_REASONS,
 	RESOLVER_REJECT_REASONS,
 	rejectObservedLivenessWellFormed,
 	resolveDispatch,
+	resolveNativePushDispatch,
 	UNSUPPORTED_DISPATCH_TABLE,
 } from "../pi-extensions/lib/entwurf-v2-contract.ts";
 import {
@@ -291,6 +298,128 @@ ok(
 	(RESOLVER_REJECT_REASONS as readonly string[]).includes("mailbox-undeliverable"),
 );
 
+// ── native-push (봉인 1/2/4): a THIRD table, disjoint from pi socket + mailbox ──
+const NATIVE_PUSH_LIVENESSES = ["alive", "dead", "indeterminate"] as const;
+
+// domain: antigravity is native-push; pi/claude-code are NOT; the domain is DISJOINT
+// from the pi socket liveness domain (a backend is never in both rails).
+eq("native-push domain: antigravity supported", nativePushSupported("antigravity"), true);
+eq("native-push domain: pi is NOT native-push (it is pi-socket)", nativePushSupported("pi"), false);
+eq(
+	"native-push domain: claude-code is NOT native-push (self-fetch mailbox)",
+	nativePushSupported("claude-code"),
+	false,
+);
+eq("native-push domain: NATIVE_PUSH_BACKENDS == ['antigravity']", [...NATIVE_PUSH_BACKENDS], ["antigravity"]);
+ok(
+	"native-push ∩ pi-socket liveness domain = ∅ (separate rails)",
+	!NATIVE_PUSH_BACKENDS.some((b) => (LIVENESS_DOMAIN_BACKENDS as readonly string[]).includes(b)),
+);
+
+// transport present + stays OUT of the pi 6-cell table (like meta-mailbox).
+ok(
+	"transport: native-push present (direct-inject into a live app-server conversation)",
+	(ENTWURF_V2_TRANSPORTS as readonly string[]).includes("native-push"),
+);
+for (const intent of ENTWURF_INTENTS) {
+	for (const dl of DISPATCH_LIVENESSES) {
+		const cell = DISPATCH_TABLE[intent][dl as DispatchLiveness];
+		ok(
+			`guard: DISPATCH_TABLE[${intent}][${dl}] is NOT native-push (native-push stays out of the pi 6-cell table)`,
+			cell.action === "reject" || cell.transport !== "native-push",
+		);
+	}
+}
+
+// NATIVE_PUSH_DISPATCH_TABLE: 6 cells (2 intents × 3 liveness), single verdict each.
+{
+	let allow = 0;
+	let reject = 0;
+	for (const intent of ENTWURF_INTENTS) {
+		for (const lv of NATIVE_PUSH_LIVENESSES) {
+			const cell = NATIVE_PUSH_DISPATCH_TABLE[intent]?.[lv as NativePushLiveness];
+			ok(`native-push table[${intent}][${lv}] present`, cell != null);
+			if (cell.action === "reject") {
+				reject++;
+				ok(
+					`native-push table[${intent}][${lv}] reason in taxonomy`,
+					(ENTWURF_V2_REJECT_REASONS as readonly string[]).includes(cell.reason),
+				);
+			} else {
+				allow++;
+			}
+		}
+	}
+	eq("native-push table has 6 cells (2 intents × 3 liveness)", allow + reject, 6);
+	eq("native-push: exactly 1 allow cell (fire-and-forget × alive)", allow, 1);
+	eq("native-push: exactly 5 reject cells", reject, 5);
+}
+// the one allow cell + the intended reject reasons.
+eq("native-push allow: ff+alive = send/native-push/ack-only", NATIVE_PUSH_DISPATCH_TABLE["fire-and-forget"].alive, {
+	action: "send",
+	transport: "native-push",
+	ownership: "ack-only",
+});
+eq("native-push: ff+dead = reject(native-push-target-dead)", NATIVE_PUSH_DISPATCH_TABLE["fire-and-forget"].dead, {
+	action: "reject",
+	reason: "native-push-target-dead",
+});
+eq(
+	"native-push: ff+indeterminate = reject(native-push-probe-indeterminate)",
+	NATIVE_PUSH_DISPATCH_TABLE["fire-and-forget"].indeterminate,
+	{ action: "reject", reason: "native-push-probe-indeterminate" },
+);
+// owned-outcome × * = single, state-independent no-resume-authority reject.
+for (const lv of NATIVE_PUSH_LIVENESSES) {
+	eq(
+		`native-push: owned+${lv} = reject(native-push-no-resume-authority)`,
+		NATIVE_PUSH_DISPATCH_TABLE["owned-outcome"][lv],
+		{
+			action: "reject",
+			reason: "native-push-no-resume-authority",
+		},
+	);
+}
+// `backend-liveness-unsupported` is NOT reused for a native-push backend (봉인 1).
+ok(
+	"native-push: reject reasons never reuse backend-liveness-unsupported (agy IS measured)",
+	!(NATIVE_PUSH_REJECT_REASONS as readonly string[]).includes("backend-liveness-unsupported"),
+);
+// resolveNativePushDispatch round-trip: observedLiveness === probed value, verdict === cell.
+for (const intent of ENTWURF_INTENTS) {
+	for (const lv of NATIVE_PUSH_LIVENESSES as readonly NativePushLiveness[]) {
+		const cell = NATIVE_PUSH_DISPATCH_TABLE[intent][lv];
+		const receipt = resolveNativePushDispatch(intent, lv);
+		ok(
+			`native-push round-trip ${intent}/${lv}: observedLiveness === probed value (post-probe stamp)`,
+			receipt.observedLiveness === lv,
+		);
+		if (cell.action === "reject") {
+			ok(
+				`native-push round-trip ${intent}/${lv}: receipt reject matches cell`,
+				receipt.ok === false && receipt.reason === cell.reason,
+			);
+		} else {
+			ok(
+				`native-push round-trip ${intent}/${lv}: receipt allow matches cell (native-push send)`,
+				receipt.ok === true &&
+					receipt.action === "send" &&
+					receipt.transport === "native-push" &&
+					receipt.ownership === "ack-only",
+			);
+		}
+	}
+}
+// every native-push reject reason is post-probe (non-null) and in the master taxonomy.
+for (const r of NATIVE_PUSH_REJECT_REASONS) {
+	ok(`native-push taxonomy: '${r}' is in the enum`, (ENTWURF_V2_REJECT_REASONS as readonly string[]).includes(r));
+	ok(`native-push: '${r}' is post-probe (non-null observedLiveness required)`, !isPreProbeReject(r));
+	ok(
+		`native-push: '${r}' is NOT a pi/mailbox resolver reason (separate table)`,
+		!(RESOLVER_REJECT_REASONS as readonly string[]).includes(r),
+	);
+}
+
 // ── R5: taxonomy coverage + pre-claims + pre-dispatch scope ────────────────
 for (const r of RESOLVER_REJECT_REASONS) {
 	ok(`taxonomy: resolver reason '${r}' is in the enum`, (ENTWURF_V2_REJECT_REASONS as readonly string[]).includes(r));
@@ -377,6 +506,7 @@ for (const r of PRE_PROBE_REJECT_REASONS) {
 }
 for (const r of [
 	...RESOLVER_REJECT_REASONS,
+	...NATIVE_PUSH_REJECT_REASONS,
 	"untrusted-fail-fast" as const,
 	"socket-only-no-resume-authority" as const,
 ]) {
@@ -440,7 +570,12 @@ for (const r of PRE_PROBE_REJECT_REASONS) {
 		passed++;
 	}
 }
-for (const r of [...RESOLVER_REJECT_REASONS, "untrusted-fail-fast" as const]) {
+for (const r of [
+	...RESOLVER_REJECT_REASONS,
+	...NATIVE_PUSH_REJECT_REASONS,
+	"untrusted-fail-fast" as const,
+	"socket-only-no-resume-authority" as const,
+]) {
 	assert.throws(
 		() => makeRejectReceipt(r, null),
 		/ill-formed reject/,

package/scripts/check-entwurf-v2-decider.ts

@@ -48,6 +48,7 @@ import {
 } from "../pi-extensions/lib/entwurf-v2-decider.ts";
 import type { AcquireLockResult, LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
 import type { MetaBackendV2, MetaCapability, MetaIdentity } from "../pi-extensions/lib/meta-session.ts";
+import type { NativePushProbeResult } from "../pi-extensions/lib/native-push/adapter.ts";
 import { controlSocketPath, type TargetSocketInspection } from "../pi-extensions/lib/socket-discovery.ts";
 import type { SocketLiveness } from "../pi-extensions/lib/socket-probe.ts";
 
@@ -131,6 +132,9 @@ interface ScenarioOpts {
 	 * unsupported path. Default false (fail-closed) — the decider trusts the seam, never
 	 * wake-mode alone, so this is how a test asserts both the deliverable and inactive cells. */
 	mailboxDeliverable?: boolean;
+	/** 봉인 4: the native-push adapter probe result the injected nativePushProbe seam returns
+	 * (only reached on a nativePushSupported backend, e.g. antigravity). */
+	nativePush?: NativePushProbeResult;
 }
 
 interface Tracked {
@@ -139,6 +143,7 @@ interface Tracked {
 	releaseCalls: LockClaim[];
 	inspectCalls: string[];
 	mailboxCalls: MetaIdentity[];
+	nativePushCalls: MetaIdentity[];
 }
 
 // Build injected deps with call tracking. A lock "conflict" returns a failed
@@ -149,6 +154,7 @@ function mkDeps(opts: ScenarioOpts): Tracked {
 	const releaseCalls: LockClaim[] = [];
 	const inspectCalls: string[] = [];
 	const mailboxCalls: MetaIdentity[] = [];
+	const nativePushCalls: MetaIdentity[] = [];
 	const deps: DispatchDeciderDeps = {
 		resolveTarget: () => opts.resolution,
 		acquireLock: (gardenId: string): AcquireLockResult => {
@@ -179,10 +185,14 @@ function mkDeps(opts: ScenarioOpts): Tracked {
 			mailboxCalls.push(identity);
 			return { deliverable: opts.mailboxDeliverable ?? false, reason: "fake-deliverability" };
 		},
+		nativePushProbe: (identity: MetaIdentity): NativePushProbeResult => {
+			nativePushCalls.push(identity);
+			return opts.nativePush ?? { status: "dead", reason: "fake: no native-push probe configured" };
+		},
 		mailboxDir: "/fake/mailbox",
 		sessionsDir: "/fake/sessions",
 	};
-	return { deps, acquireCalls, releaseCalls, inspectCalls, mailboxCalls };
+	return { deps, acquireCalls, releaseCalls, inspectCalls, mailboxCalls, nativePushCalls };
 }
 
 function isExecute(d: DispatchDecision): d is Extract<DispatchDecision, { kind: "execute" }> {
@@ -265,6 +275,9 @@ async function main(): Promise<void> {
 				mailboxDeliverabilityFor: () => {
 					throw new Error("target-locked(corrupt): in-domain pi never consults the mailbox seam");
 				},
+				nativePushProbe: () => {
+					throw new Error("target-locked(corrupt): in-domain pi never consults the native-push seam");
+				},
 			},
 		);
 		ok("target-locked(corrupt): reject", d.kind === "reject" && d.receipt.reason === "target-locked");
@@ -670,6 +683,9 @@ async function main(): Promise<void> {
 						probeSocket: async () => "dead",
 						preflightForCwd: () => APPROVE,
 						mailboxDeliverabilityFor: () => ({ deliverable: false, reason: "in-domain pi: seam unused" }),
+						nativePushProbe: () => {
+							throw new Error("lock-leak: in-domain pi never consults the native-push seam");
+						},
 						...over,
 					},
 				);
@@ -724,6 +740,9 @@ async function main(): Promise<void> {
 					probeSocket: async () => "alive",
 					preflightForCwd: () => APPROVE,
 					mailboxDeliverabilityFor: () => ({ deliverable: false, reason: "in-domain pi: seam unused" }),
+					nativePushProbe: () => {
+						throw new Error("reject-release-throw: in-domain pi never consults the native-push seam");
+					},
 				},
 			);
 		} catch (e) {
@@ -763,6 +782,9 @@ async function main(): Promise<void> {
 			mailboxDeliverabilityFor: () => {
 				throw new Error("invalid-gid: mailboxDeliverabilityFor must not be reached");
 			},
+			nativePushProbe: () => {
+				throw new Error("invalid-gid: nativePushProbe must not be reached");
+			},
 		};
 		try {
 			await decideDispatch({ target: "../etc/passwd", intent: "owned-outcome", message: "x" }, deps);
@@ -772,6 +794,78 @@ async function main(): Promise<void> {
 		ok("invalid-gid: throws", threw);
 		ok("invalid-gid: throws BEFORE resolveTarget (no path/lookup built)", !resolveCalled);
 	}
+
+	// ── native-push rail (봉인 4): antigravity is intercepted BEFORE the unsupported ──
+	// mailbox branch, routed by nativePushProbe + the NATIVE_PUSH table, LOCK-FREE.
+	const npResolution = { identity: identity("antigravity"), preProbeAddressConflict: false };
+	{
+		// ff × alive → execute native-push send; plan carries route/backend/nativeSessionId; lock null.
+		const t = mkDeps({
+			resolution: npResolution,
+			nativePush: { status: "alive", route: { lsAddress: "127.0.0.1:5599" } },
+		});
+		const d = await decideDispatch({ target: GID, intent: "fire-and-forget", message: "yo" }, t.deps);
+		ok("native-push ff+alive: execute", isExecute(d));
+		ok("native-push ff+alive: transport native-push", isExecute(d) && d.plan.transport === "native-push");
+		ok("native-push ff+alive: LOCK-FREE (decision lock null)", isExecute(d) && d.lock === null);
+		ok("native-push ff+alive: acquireLock NOT called (lock-free rail)", t.acquireCalls.length === 0);
+		ok("native-push ff+alive: nativePushProbe consulted once", t.nativePushCalls.length === 1);
+		ok(
+			"native-push ff+alive: mailbox seam NOT consulted (intercepts before unsupported branch)",
+			t.mailboxCalls.length === 0,
+		);
+		if (isExecute(d) && d.plan.transport === "native-push") {
+			ok("native-push ff+alive: plan route = probed route", d.plan.route.lsAddress === "127.0.0.1:5599");
+			ok("native-push ff+alive: plan backend = antigravity", d.plan.backend === "antigravity");
+			ok("native-push ff+alive: plan nativeSessionId from identity", d.plan.nativeSessionId === `native-${GID}`);
+			ok(
+				"native-push ff+alive: plan keyset exact",
+				planKeys(d.plan).join(",") ===
+					"action,backend,message,nativeSessionId,route,targetGardenId,transport,wantsReply",
+			);
+		}
+		ok(
+			"native-push ff+alive: receipt success transport native-push, observedLiveness alive",
+			isExecute(d) && d.receipt.ok && d.receipt.transport === "native-push" && d.receipt.observedLiveness === "alive",
+		);
+	}
+	{
+		// ff × dead → reject native-push-target-dead (post-probe, dead), lock-free.
+		const t = mkDeps({ resolution: npResolution, nativePush: { status: "dead", reason: "no host" } });
+		const d = await decideDispatch({ target: GID, intent: "fire-and-forget", message: "yo" }, t.deps);
+		ok(
+			"native-push ff+dead: reject native-push-target-dead",
+			d.kind === "reject" && d.receipt.reason === "native-push-target-dead",
+		);
+		ok(
+			"native-push ff+dead: observedLiveness dead (post-probe stamp)",
+			d.kind === "reject" && d.receipt.observedLiveness === "dead",
+		);
+		ok("native-push ff+dead: acquireLock NOT called", t.acquireCalls.length === 0);
+	}
+	{
+		// ff × indeterminate → reject native-push-probe-indeterminate.
+		const t = mkDeps({ resolution: npResolution, nativePush: { status: "indeterminate", reason: "no port served" } });
+		const d = await decideDispatch({ target: GID, intent: "fire-and-forget", message: "yo" }, t.deps);
+		ok(
+			"native-push ff+indeterminate: reject native-push-probe-indeterminate",
+			d.kind === "reject" && d.receipt.reason === "native-push-probe-indeterminate",
+		);
+	}
+	{
+		// owned × alive → reject native-push-no-resume-authority (state-independent), lock-free.
+		const t = mkDeps({
+			resolution: npResolution,
+			nativePush: { status: "alive", route: { lsAddress: "127.0.0.1:5599" } },
+		});
+		const d = await decideDispatch({ target: GID, intent: "owned-outcome", message: "yo" }, t.deps);
+		ok(
+			"native-push owned+alive: reject native-push-no-resume-authority",
+			d.kind === "reject" && d.receipt.reason === "native-push-no-resume-authority",
+		);
+		ok("native-push owned+alive: acquireLock NOT called (lock-free)", t.acquireCalls.length === 0);
+	}
+
 	// The wake-mode capability HELPER stays gate-pinned (renamed; the decider no longer
 	// calls it directly — deliverability flows through the required seam). It answers the
 	// capability HALF only; the active-receiver half lives in the production seam.

package/scripts/check-entwurf-v2-matrix.ts

@@ -154,6 +154,13 @@ function mkDeps(opts: ScenarioOpts): Tracked {
 			mailboxCalls.push(id);
 			return { deliverable: opts.mailboxDeliverable ?? false, reason: "fake-deliverability" };
 		},
+		// The matrix rows are pi / claude-code targets — the native-push branch (antigravity)
+		// is NOT exercised here (it is a SEPARATE table, covered by check-entwurf-v2-contract's
+		// NATIVE_PUSH round-trip + check-entwurf-v2-decider's branch scenarios). A tripwire so a
+		// future antigravity row that forgets to wire this fails loud instead of misrouting.
+		nativePushProbe: () => {
+			throw new Error("matrix: native-push branch must not be reached (no antigravity row wired)");
+		},
 		mailboxDir: "/fake/mailbox",
 		sessionsDir: "/fake/sessions",
 	};
@@ -397,9 +404,13 @@ async function main(): Promise<void> {
 		await runRow(row);
 	}
 
-	// ── COVERAGE: the table must span every transport + lock class + pre-probe ──
-	// reject, or the "matrix is closed" claim is a lie. A dropped decider cell makes
-	// one of these sets shrink → fail (not a silent green).
+	// ── COVERAGE: the table must span every matrix-owned transport + lock class + ──
+	// pre-probe reject, or the "matrix is closed" claim is a lie. A dropped decider cell
+	// makes one of these sets shrink → fail (not a silent green). NOTE: native-push is NOT
+	// a matrix-owned transport — it is a SEPARATE NATIVE_PUSH_DISPATCH_TABLE (check-entwurf-
+	// v2-contract round-trip + check-entwurf-v2-decider branch), so it is deliberately absent
+	// from this coverage set (adding an antigravity row would blur the matrix's lock-class /
+	// transport semantics — GPT R8).
 	console.log("\n── coverage (table completeness)");
 	const transports = new Set<string>();
 	const lockClasses = new Set<LockClass>();

package/scripts/check-entwurf-v2-native-push.ts

@@ -0,0 +1,193 @@
+/**
+ * check-entwurf-v2-native-push — deterministic gate for the native-push SEND hand
+ * (봉인 3/4), the executor half of the native-push rail. This is where the 1-shot retry
+ * lives (moved out of the adapter leaf per the review): the decider planted a fresh route,
+ * the hand sends over it, and on failure re-probes ONCE and re-sends.
+ *
+ * Proves (deliverViaNativePush, fake adapter):
+ *   - success first try → {retried:false}, ONE send, ZERO re-probe (the planted route is used).
+ *   - fail → re-probe alive → re-send success → {retried:true}, TWO sends, ONE re-probe, and
+ *     the second send uses the RE-DISCOVERED route (not the stale planted one).
+ *   - fail → re-probe alive → re-send FAIL → THROWS (fail-loud, no third attempt).
+ *   - fail → re-probe dead/indeterminate → THROWS (not retried), NO second send.
+ * Proves (makeNativePushSend):
+ *   - resolves the adapter from plan.backend, delivers via deliverViaNativePush, and IGNORES
+ *     the lock (native-push is lock-free, 봉인 4).
+ *
+ * Pure; no backend, no socket, no real process.
+ */
+
+import assert from "node:assert/strict";
+import type { LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
+import type { NativePushPlan } from "../pi-extensions/lib/entwurf-v2-native-push.ts";
+import { deliverViaNativePush, makeNativePushSend } from "../pi-extensions/lib/entwurf-v2-native-push.ts";
+import type {
+	NativePushAdapter,
+	NativePushProbeResult,
+	NativePushRoute,
+} from "../pi-extensions/lib/native-push/adapter.ts";
+
+let passed = 0;
+function ok(label: string, cond: boolean): void {
+	assert.ok(cond, label);
+	console.log(`  ok    ${label}`);
+	passed++;
+}
+
+const CONV = "conv-xyz";
+const PLANTED: NativePushRoute = { lsAddress: "127.0.0.1:5600" };
+
+interface SendCall {
+	route: NativePushRoute;
+	nativeSessionId: string;
+	content: string;
+}
+
+interface FakeAdapterConfig {
+	/** probe() results consumed in order (each re-probe pops the next). */
+	probes: NativePushProbeResult[];
+	/** 0-based indices of send() calls that THROW. */
+	sendFailAt?: number[];
+}
+
+function makeFakeAdapter(config: FakeAdapterConfig): {
+	adapter: NativePushAdapter;
+	sends: SendCall[];
+	probeCount: () => number;
+} {
+	let probeIdx = 0;
+	let sendIdx = 0;
+	const sends: SendCall[] = [];
+	const adapter: NativePushAdapter = {
+		id: "antigravity",
+		async probe() {
+			const p = config.probes[probeIdx] ?? { status: "dead", reason: "fake: probes exhausted" };
+			probeIdx++;
+			return p;
+		},
+		async send(route, nativeSessionId, content) {
+			const i = sendIdx++;
+			sends.push({ route, nativeSessionId, content });
+			if (config.sendFailAt?.includes(i)) throw new Error(`fake send fail #${i}`);
+		},
+	};
+	return { adapter, sends, probeCount: () => probeIdx };
+}
+
+async function main(): Promise<void> {
+	// ── success first try: ONE send over the planted route, ZERO re-probe ────────
+	{
+		const { adapter, sends, probeCount } = makeFakeAdapter({ probes: [] });
+		const r = await deliverViaNativePush(adapter, PLANTED, CONV, "hi");
+		ok("success: retried:false", r.success === true && r.retried === false);
+		ok("success: exactly ONE send", sends.length === 1);
+		ok("success: send used the PLANTED route (no re-probe)", sends[0]?.route.lsAddress === "127.0.0.1:5600");
+		ok("success: ZERO re-probe", probeCount() === 0);
+	}
+
+	// ── fail → re-probe alive → re-send success: retried, fresh route ────────────
+	{
+		const { adapter, sends, probeCount } = makeFakeAdapter({
+			probes: [{ status: "alive", route: { lsAddress: "127.0.0.1:5601" } }],
+			sendFailAt: [0],
+		});
+		const r = await deliverViaNativePush(adapter, PLANTED, CONV, "hi");
+		ok("retry: retried:true", r.success === true && r.retried === true);
+		ok("retry: TWO sends (initial + one retry)", sends.length === 2);
+		ok("retry: exactly ONE re-probe", probeCount() === 1);
+		ok("retry: 1st send used the planted route", sends[0]?.route.lsAddress === "127.0.0.1:5600");
+		ok(
+			"retry: 2nd send used the RE-DISCOVERED route (not the stale one)",
+			sends[1]?.route.lsAddress === "127.0.0.1:5601",
+		);
+	}
+
+	// ── fail → re-probe alive → re-send FAIL: throws (fail-loud, no 3rd attempt) ──
+	{
+		const { adapter, sends } = makeFakeAdapter({
+			probes: [{ status: "alive", route: { lsAddress: "127.0.0.1:5601" } }],
+			sendFailAt: [0, 1],
+		});
+		let threw = false;
+		try {
+			await deliverViaNativePush(adapter, PLANTED, CONV, "hi");
+		} catch {
+			threw = true;
+		}
+		ok("double-fail: THROWS (fail-loud)", threw);
+		ok("double-fail: exactly TWO sends, no third attempt", sends.length === 2);
+	}
+
+	// ── fail → re-probe dead: throws (not retried), NO second send ───────────────
+	{
+		const { adapter, sends, probeCount } = makeFakeAdapter({
+			probes: [{ status: "dead", reason: "host gone" }],
+			sendFailAt: [0],
+		});
+		let msg = "";
+		try {
+			await deliverViaNativePush(adapter, PLANTED, CONV, "hi");
+		} catch (err) {
+			msg = (err as Error).message;
+		}
+		ok("reprobe-dead: THROWS", msg.length > 0);
+		ok("reprobe-dead: error names the dead re-probe + 'not retried'", /dead/.test(msg) && /not retried/.test(msg));
+		ok("reprobe-dead: exactly ONE send (no re-send into a dead conversation)", sends.length === 1);
+		ok("reprobe-dead: re-probe was attempted once", probeCount() === 1);
+	}
+
+	// ── fail → re-probe indeterminate: throws (not retried) ──────────────────────
+	{
+		const { adapter, sends } = makeFakeAdapter({
+			probes: [{ status: "indeterminate", reason: "no port" }],
+			sendFailAt: [0],
+		});
+		let threw = false;
+		try {
+			await deliverViaNativePush(adapter, PLANTED, CONV, "hi");
+		} catch {
+			threw = true;
+		}
+		ok("reprobe-indeterminate: THROWS (never coerced to a retry)", threw);
+		ok("reprobe-indeterminate: exactly ONE send", sends.length === 1);
+	}
+
+	// ── makeNativePushSend: resolves adapter from plan.backend, ignores lock ─────
+	{
+		const plan: NativePushPlan = {
+			transport: "native-push",
+			action: "send",
+			targetGardenId: "20260704T000000-abcdef",
+			backend: "antigravity",
+			nativeSessionId: CONV,
+			route: PLANTED,
+			wantsReply: false,
+			message: "payload",
+		};
+		const { adapter, sends } = makeFakeAdapter({ probes: [] });
+		const resolvedBackends: string[] = [];
+		const send = makeNativePushSend({
+			resolveAdapter: (backend) => {
+				resolvedBackends.push(backend);
+				return adapter;
+			},
+		});
+		// pass a NON-null lock to prove it is ignored (lock-free rail).
+		const bogusLock = { gardenId: "x" } as unknown as LockClaim;
+		const r = await send(plan, bogusLock);
+		ok("makeNativePushSend: delivered success", r.success === true && r.retried === false);
+		ok(
+			"makeNativePushSend: resolved the adapter from plan.backend",
+			resolvedBackends.length === 1 && resolvedBackends[0] === "antigravity",
+		);
+		ok(
+			"makeNativePushSend: sent the plan message over the plan route",
+			sends[0]?.content === "payload" && sends[0]?.route.lsAddress === "127.0.0.1:5600",
+		);
+		ok("makeNativePushSend: lock IGNORED (lock-free — a bogus lock did not break delivery)", sends.length === 1);
+	}
+
+	console.log(`\ncheck-entwurf-v2-native-push: ${passed} assertions passed`);
+}
+
+void main();

package/scripts/check-entwurf-v2-production.ts

@@ -27,9 +27,11 @@ import {
 	makeProductionEntwurfV2Deps,
 	type ProductionEntwurfV2Opts,
 } from "../pi-extensions/lib/entwurf-v2-production.ts";
+import { runEntwurfV2 } from "../pi-extensions/lib/entwurf-v2-runner.ts";
 import type { ControlSocketPlan, MetaMailboxPlan } from "../pi-extensions/lib/entwurf-v2-send.ts";
 import type { SpawnBgPlan } from "../pi-extensions/lib/entwurf-v2-spawn.ts";
 import type { MetaIdentity, MetaReceiverMarker } from "../pi-extensions/lib/meta-session.ts";
+import type { NativePushAdapter, NativePushProbeResult } from "../pi-extensions/lib/native-push/adapter.ts";
 import type { TargetSocketInspection } from "../pi-extensions/lib/socket-discovery.ts";
 
 let passed = 0;
@@ -125,6 +127,10 @@ interface Spies {
 	enqueue: { gardenId: string; sessionsDir?: string; mailboxDir?: string }[];
 	rpc: { socketPath: string; command: Record<string, unknown> }[];
 	inspectPath: { socketPath: string }[];
+	/** which backend the native-push adapter resolver was asked for (decide + execute). */
+	nativePushResolve: string[];
+	nativePushProbe: { conv: string }[];
+	nativePushSend: { lsAddress: string; conv: string; content: string }[];
 }
 
 /** Build a factory whose every leaf IO is a spy. `over` lets a case shape the decision
@@ -137,11 +143,22 @@ function makeSpiedFactory(over: {
 	rpc?: "success" | "dead-throw";
 	classifyDead?: boolean;
 	spawnChildThrows?: boolean;
+	/** the native-push adapter probe result (only reached on a native-push backend). */
+	nativePushProbe?: NativePushProbeResult;
 	/** SE-2 2d-3 — the target's receiver presence marker: "active" (matches identity,
 	 * default), "absent" (terminated/never-armed), or "mismatch" (drifted native id). */
 	receiverMarker?: "active" | "absent" | "mismatch";
 }) {
-	const spies: Spies = { acquire: [], release: [], enqueue: [], rpc: [], inspectPath: [] };
+	const spies: Spies = {
+		acquire: [],
+		release: [],
+		enqueue: [],
+		rpc: [],
+		inspectPath: [],
+		nativePushResolve: [],
+		nativePushProbe: [],
+		nativePushSend: [],
+	};
 	const opts: ProductionEntwurfV2Opts = {
 		senderProvider: () => ({ sessionId: "self", agentId: "pi/x", cwd: "/cwd", timestamp: "2026-06-13T00:00:00.000Z" }),
 		lockDir: LOCK_DIR,
@@ -194,6 +211,23 @@ function makeSpiedFactory(over: {
 				spies.enqueue.push({ gardenId: o.gardenId, sessionsDir: o.sessionsDir, mailboxDir: o.mailboxDir });
 				return { gardenId: o.gardenId, recordPath: "r", messagePath: "m", signalPath: "s" };
 			},
+			// ONE native-push adapter resolver (봉인 4): the SAME injected fake feeds the
+			// decider's nativePushProbe AND the executor's sendNativePush — so a single dispatch
+			// records both a probe (decide) and a send (execute) on this one adapter, proving the
+			// two hands never resolve different adapters.
+			resolveNativePushAdapter: (backend: string): NativePushAdapter => {
+				spies.nativePushResolve.push(backend);
+				return {
+					id: "antigravity",
+					async probe(conv) {
+						spies.nativePushProbe.push({ conv });
+						return over.nativePushProbe ?? { status: "dead", reason: "fake: no native-push probe configured" };
+					},
+					async send(route, conv, content) {
+						spies.nativePushSend.push({ lsAddress: route.lsAddress, conv, content });
+					},
+				};
+			},
 			spawnOverrides: {
 				spawnChild: over.spawnChildThrows
 					? () => {
@@ -232,6 +266,39 @@ async function main(): Promise<void> {
 		ok("A2: a quarantined target is never lock-acquired", spies.acquire.length === 0);
 	}
 
+	// ── A3: native-push wiring — ONE injected adapter feeds BOTH decider + executor ─
+	{
+		const { deps, spies } = makeSpiedFactory({
+			backend: "antigravity",
+			nativePushProbe: { status: "alive", route: { lsAddress: "127.0.0.1:5599" } },
+		});
+		const result = await runEntwurfV2({ target: GID, intent: "fire-and-forget", message: "hi agy" }, deps);
+		ok("A3: antigravity ff → native-push delivered", result.kind === "executed" && result.transport === "native-push");
+		ok("A3: decider probed the native-push adapter once (decide side)", spies.nativePushProbe.length === 1);
+		ok("A3: executor sent via the native-push adapter once (execute side)", spies.nativePushSend.length === 1);
+		ok("A3: send used the DECIDER-probed route", spies.nativePushSend[0]?.lsAddress === "127.0.0.1:5599");
+		ok("A3: send carried the dispatch message", spies.nativePushSend[0]?.content === "hi agy");
+		ok(
+			"A3: BOTH hands resolved the SAME adapter (for 'antigravity')",
+			spies.nativePushResolve.length === 2 && spies.nativePushResolve.every((b) => b === "antigravity"),
+		);
+		ok("A3: native-push is LOCK-FREE (no acquire)", spies.acquire.length === 0);
+		ok("A3: native-push did NOT enqueue a mailbox (not the unsupported path)", spies.enqueue.length === 0);
+	}
+	{
+		// antigravity + dead probe → reject native-push-target-dead, NO send.
+		const { deps, spies } = makeSpiedFactory({
+			backend: "antigravity",
+			nativePushProbe: { status: "dead", reason: "no host" },
+		});
+		const result = await runEntwurfV2({ target: GID, intent: "fire-and-forget", message: "x" }, deps);
+		ok(
+			"A3b: antigravity ff + dead → rejected native-push-target-dead",
+			result.kind === "rejected" && result.receipt.reason === "native-push-target-dead",
+		);
+		ok("A3b: no send attempted on a dead target", spies.nativePushSend.length === 0);
+	}
+
 	// ── A3: QB2 — a non-pi indeterminate lstat FAILS LOUD (never "no conflict") ─
 	{
 		const { deps } = makeSpiedFactory({ backend: "claude-code", inspectKind: "indeterminate" });