@junghanacs/entwurf 0.22.0 → 0.23.1

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

@@ -1,401 +0,0 @@
-/**
- * check-entwurf-v2-matrix — the 5d-5 (a) REACHABILITY + LOCK SSOT TABLE.
- *
- * GPT Q5 design: a deterministic gate (no API, no real pi) that fixes the 5d-5
- * operating claim — "target kind × resulting transport × lock acquire→release×1" —
- * as ONE readable table, so a release note can say "the matrix is closed" without a
- * reader grepping the 12 scattered check-entwurf-v2-* gates.
- *
- * This is a THIN coverage gate, NOT a re-implementation of the decider. It drives
- * the REAL `decideDispatch` over minimal injected fakes (the same shape
- * check-entwurf-v2-decider uses) and asserts, per row, the (transport, lock class,
- * reject reason) the decider actually produces. A final COVERAGE pass then FAILS if
- * any transport, lock class, or pre-probe reject is missing from the table — so a
- * future decider change that silently drops a reachability cell cannot pass.
- *
- * Sender-surface parity (MCP entwurf_v2 vs pi-native) is NOT re-run here: both ride
- * the same `runAndRenderEntwurfV2FromSurface` (proven once in check-entwurf-v2-surface),
- * and the matrix is keyed on the decider both surfaces share. Adding a second surface
- * sweep would duplicate that proof — Q-a: "전수 실행을 두 surface로 중복하지 말 것".
- *
- * Lock classes (the "acquire→release×1" axis made machine-checkable):
- *   none          — no lock acquired at all (pre-probe reject, or the lock-free
- *                   unsupported/meta-mailbox path): acquire 0, release 0.
- *   held          — in-domain execute keeps the claim for 5c re-resolve: acquire 1,
- *                   release 0, decision.lock non-null.
- *   mailbox-null  — unsupported execute → meta-mailbox, deliberately lock-free (？7):
- *                   acquire 0, release 0, decision.lock === null.
- *   released      — in-domain reject after the probe: the held lock is released
- *                   exactly once: acquire 1, release 1.
- *   acquire-fail  — target-locked: the acquire itself failed, nothing to release:
- *                   acquire 1, release 0.
- */
-
-import assert from "node:assert/strict";
-import {
-	type EntwurfIntent,
-	type EntwurfV2Transport,
-	isLivenessSupported,
-} from "../pi-extensions/lib/entwurf-v2-contract.ts";
-import {
-	type DispatchDeciderDeps,
-	type DispatchDecision,
-	decideDispatch,
-	type ExecutionPlan,
-	type RejectDiagnostic,
-	type TargetResolution,
-} from "../pi-extensions/lib/entwurf-v2-decider.ts";
-import type { AcquireLockResult, LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
-import type { MetaCitizenBackend, MetaIdentity } from "../pi-extensions/lib/meta-session.ts";
-import { controlSocketPath, type TargetSocketInspection } from "../pi-extensions/lib/socket-discovery.ts";
-import type { SocketLiveness } from "../pi-extensions/lib/socket-probe.ts";
-
-let passed = 0;
-function ok(label: string, cond: boolean): void {
-	assert.ok(cond, label);
-	console.log(`  ok    ${label}`);
-	passed++;
-}
-
-const GID = "20260612T100000-aaaaaa";
-const CWD = "/home/junghan/repos/gh/entwurf";
-
-function identity(backend: MetaCitizenBackend): MetaIdentity {
-	return {
-		schemaVersion: 3,
-		gardenId: GID,
-		backend,
-		nativeSessionId: `native-${GID}`,
-		cwd: CWD,
-		model: null,
-		transcriptPath: null,
-		createdAt: "2026-06-12T01:00:00.000Z",
-		recordUpdatedAt: "2026-06-12T01:00:00.000Z",
-	};
-}
-
-function lockClaim(gardenId: string): LockClaim {
-	return {
-		gardenId,
-		pid: 4242,
-		hostname: "test-host",
-		createdAt: "2026-06-12T01:00:00.000Z",
-		nonce: "deadbeefcafef00d",
-		owner: "entwurf_v2",
-		lockPath: `/fake/locks/${gardenId}.lock`,
-	};
-}
-
-// ── injected fakes with call tracking (decider-gate shape, minimal copy) ─────
-interface ScenarioOpts {
-	resolution: TargetResolution;
-	lock?: "ok" | "conflict";
-	inspection?: TargetSocketInspection;
-	probe?: SocketLiveness;
-	mailboxDeliverable?: boolean;
-}
-interface Tracked {
-	deps: DispatchDeciderDeps;
-	acquireCalls: string[];
-	releaseCalls: LockClaim[];
-	inspectCalls: string[];
-	probeCalls: string[];
-	mailboxCalls: MetaIdentity[];
-}
-function mkDeps(opts: ScenarioOpts): Tracked {
-	const acquireCalls: string[] = [];
-	const releaseCalls: LockClaim[] = [];
-	const inspectCalls: string[] = [];
-	const probeCalls: string[] = [];
-	const mailboxCalls: MetaIdentity[] = [];
-	const deps: DispatchDeciderDeps = {
-		resolveTarget: () => opts.resolution,
-		acquireLock: (gardenId: string): AcquireLockResult => {
-			acquireCalls.push(gardenId);
-			if (opts.lock === "conflict") {
-				return {
-					ok: false,
-					conflict: {
-						reason: "target-locked",
-						lockPath: `/fake/locks/${gardenId}.lock`,
-						holder: lockClaim(gardenId),
-						detail: "held by a live dispatcher",
-					},
-				};
-			}
-			return { ok: true, claim: lockClaim(gardenId) };
-		},
-		releaseLock: (claim: LockClaim) => {
-			releaseCalls.push(claim);
-		},
-		inspectSocket: async (gardenId: string): Promise<TargetSocketInspection> => {
-			inspectCalls.push(gardenId);
-			return opts.inspection ?? { kind: "absent", socketPath: controlSocketPath(gardenId, "/fake/ctl") };
-		},
-		probeSocket: async (socketPath: string): Promise<SocketLiveness> => {
-			probeCalls.push(socketPath);
-			return opts.probe ?? "dead";
-		},
-		mailboxDeliverabilityFor: (id: MetaIdentity) => {
-			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",
-	};
-	return { deps, acquireCalls, releaseCalls, inspectCalls, probeCalls, mailboxCalls };
-}
-
-type LockClass = "none" | "held" | "mailbox-null" | "released" | "acquire-fail";
-
-type Expect =
-	| { decision: "execute"; transport: EntwurfV2Transport; lock: LockClass }
-	// `diagnostic` names the KIND a reject must carry, not a boolean: two reject cells now
-	// carry machine-readable evidence, and the axis has to say which — a reject that carried
-	// the wrong diagnostic would pass a yes/no cell (#101 갭 C).
-	| { decision: "reject"; reason: string; lock: LockClass; diagnostic?: RejectDiagnostic["kind"] };
-
-/**
- * Which IO seams the decider is ALLOWED to touch — the "어느 축을 만지면 안 되는지"
- * axis (GPT D4-a review). A row name says "no inspect"; reachOf() + runRow make the
- * machine enforce it instead of trusting the prose. DERIVED from the scenario, never
- * hand-set, so a new row cannot drift from its declared target kind:
- *   pre-probe   — rejected before any socket work: inspect 0, probe 0, mailbox 0
- *                 (bad-target, pre-probe conflict, target-locked = lock fails first).
- *   unsupported — lock-free mailbox branch: the deliverability seam is consulted
- *                 exactly once, NO socket inspect/probe: inspect 0, probe 0, mailbox 1.
- *   in-domain   — locked socket branch: inspect ≥1, mailbox 0 (probe count varies by
- *                 inspection kind, so it is not asserted here).
- */
-type Reaches = "pre-probe" | "unsupported" | "in-domain";
-
-function reachOf(s: ScenarioOpts): Reaches {
-	const id = s.resolution.identity;
-	if (!id) return "pre-probe"; // bad-target — no citizen
-	if (s.resolution.preProbeAddressConflict) return "pre-probe";
-	if (s.lock === "conflict") return "pre-probe"; // target-locked: lock fails before the socket
-	return isLivenessSupported(id.backend) ? "in-domain" : "unsupported";
-}
-
-interface Row {
-	name: string;
-	targetKind: string;
-	intent: EntwurfIntent;
-	scenario: ScenarioOpts;
-	expect: Expect;
-}
-
-const present = (i: TargetSocketInspection) => i;
-
-// ── THE TABLE — every reachability + lock cell the 5d-5 claim covers ─────────
-const ROWS: Row[] = [
-	{
-		name: "bad-target",
-		targetKind: "no citizen",
-		intent: "fire-and-forget",
-		scenario: { resolution: { identity: null, preProbeAddressConflict: false } },
-		expect: { decision: "reject", reason: "bad-target", lock: "none" },
-	},
-	{
-		name: "address-conflict (pre-probe)",
-		targetKind: "quarantined gid/socket",
-		intent: "fire-and-forget",
-		scenario: { resolution: { identity: identity("claude-code"), preProbeAddressConflict: true } },
-		expect: { decision: "reject", reason: "target-address-conflict", lock: "none" },
-	},
-	{
-		name: "target-locked",
-		targetKind: "pi, lock held by another",
-		intent: "fire-and-forget",
-		scenario: { resolution: { identity: identity("pi"), preProbeAddressConflict: false }, lock: "conflict" },
-		expect: { decision: "reject", reason: "target-locked", lock: "acquire-fail", diagnostic: "target-locked" },
-	},
-	{
-		name: "unsupported self-fetch active → meta-mailbox",
-		targetKind: "claude-code, active receiver",
-		intent: "fire-and-forget",
-		scenario: {
-			resolution: { identity: identity("claude-code"), preProbeAddressConflict: false },
-			mailboxDeliverable: true,
-		},
-		expect: { decision: "execute", transport: "meta-mailbox", lock: "mailbox-null" },
-	},
-	{
-		name: "unsupported self-fetch inactive → reject",
-		targetKind: "claude-code, inactive receiver",
-		intent: "fire-and-forget",
-		scenario: {
-			resolution: { identity: identity("claude-code"), preProbeAddressConflict: false },
-			mailboxDeliverable: false,
-		},
-		// #101 갭 C: an undeliverable mailbox reject carries the receiver axis that failed.
-		expect: { decision: "reject", reason: "mailbox-undeliverable", lock: "none", diagnostic: "mailbox-undeliverable" },
-	},
-	{
-		name: "in-domain live ff → control-socket",
-		targetKind: "pi, socket alive",
-		intent: "fire-and-forget",
-		scenario: {
-			resolution: { identity: identity("pi"), preProbeAddressConflict: false },
-			lock: "ok",
-			inspection: present({ kind: "socket-file", socketPath: "/fake/ctl/s.sock" }),
-			probe: "alive",
-		},
-		expect: { decision: "execute", transport: "control-socket", lock: "held" },
-	},
-	{
-		name: "in-domain ff dormant → reject",
-		targetKind: "pi, confirmed dormant, ff intent",
-		intent: "fire-and-forget",
-		scenario: {
-			resolution: { identity: identity("pi"), preProbeAddressConflict: false },
-			lock: "ok",
-			inspection: present({ kind: "absent", socketPath: "/fake/ctl/s.sock" }),
-			probe: "dead",
-		},
-		expect: { decision: "reject", reason: "dormant-fire-forget-unsupported", lock: "released" },
-	},
-	{
-		name: "in-domain indeterminate → reject",
-		targetKind: "pi, socket indeterminate (EACCES)",
-		intent: "fire-and-forget",
-		scenario: {
-			resolution: { identity: identity("pi"), preProbeAddressConflict: false },
-			lock: "ok",
-			inspection: present({ kind: "indeterminate", socketPath: "/fake/ctl/s.sock", error: "EACCES" }),
-		},
-		expect: { decision: "reject", reason: "indeterminate-no-spawn", lock: "released" },
-	},
-	{
-		name: "in-domain address-conflict under lock → reject (released)",
-		targetKind: "pi, socket symlink address-conflict",
-		intent: "fire-and-forget",
-		scenario: {
-			resolution: { identity: identity("pi"), preProbeAddressConflict: false },
-			lock: "ok",
-			inspection: present({ kind: "address-conflict", socketPath: "/fake/ctl/s.sock", reason: "symlink" }),
-		},
-		expect: { decision: "reject", reason: "target-address-conflict", lock: "released" },
-	},
-];
-
-function planTransport(d: DispatchDecision): EntwurfV2Transport | null {
-	return d.kind === "execute" ? (d.plan as ExecutionPlan).transport : null;
-}
-
-// Verify a row against the REAL decideDispatch + the tracked lock calls.
-async function runRow(row: Row): Promise<void> {
-	const t = mkDeps(row.scenario);
-	const d = await decideDispatch({ target: GID, intent: row.intent, message: "hi" }, t.deps);
-	const acq = t.acquireCalls.length;
-	const rel = t.releaseCalls.length;
-
-	// reach axis (GPT D4-a): the decider must touch ONLY the seams this target kind
-	// allows — make the "no inspect / no mailbox" prose machine-checked.
-	const reaches = reachOf(row.scenario);
-	const insp = t.inspectCalls.length;
-	const prb = t.probeCalls.length;
-	const mbx = t.mailboxCalls.length;
-	if (reaches === "pre-probe") {
-		ok(`${row.name}: pre-probe reach — no inspect, no probe, no mailbox`, insp === 0 && prb === 0 && mbx === 0);
-	} else if (reaches === "unsupported") {
-		ok(
-			`${row.name}: unsupported reach — deliverability seam ×1, no socket inspect/probe`,
-			mbx === 1 && insp === 0 && prb === 0,
-		);
-	} else {
-		ok(`${row.name}: in-domain reach — socket inspected, deliverability seam untouched`, insp >= 1 && mbx === 0);
-	}
-
-	if (row.expect.decision === "execute") {
-		ok(`${row.name}: execute`, d.kind === "execute");
-		ok(`${row.name}: transport=${row.expect.transport}`, planTransport(d) === row.expect.transport);
-		const lockNull = d.kind === "execute" && d.lock === null;
-		if (row.expect.lock === "held") {
-			ok(`${row.name}: lock held (acquire 1, release 0, non-null)`, acq === 1 && rel === 0 && !lockNull);
-		} else {
-			// mailbox-null
-			ok(`${row.name}: lock-free meta-mailbox (acquire 0, lock null)`, acq === 0 && rel === 0 && lockNull);
-		}
-	} else {
-		ok(`${row.name}: reject`, d.kind === "reject");
-		ok(`${row.name}: reason=${row.expect.reason}`, d.kind === "reject" && d.receipt.reason === row.expect.reason);
-		ok(`${row.name}: no plan field`, !("plan" in d));
-		switch (row.expect.lock) {
-			case "none":
-				ok(`${row.name}: no lock (acquire 0, release 0)`, acq === 0 && rel === 0);
-				break;
-			case "acquire-fail":
-				ok(`${row.name}: acquire failed (acquire 1, release 0)`, acq === 1 && rel === 0);
-				break;
-			case "released":
-				ok(`${row.name}: lock acquired then released ×1 (acquire 1, release 1)`, acq === 1 && rel === 1);
-				break;
-			default:
-				assert.fail(`${row.name}: reject row cannot expect lock=${row.expect.lock}`);
-		}
-		if (row.expect.diagnostic) {
-			ok(
-				`${row.name}: carries the ${row.expect.diagnostic} diagnostic`,
-				d.kind === "reject" && d.diagnostic?.kind === row.expect.diagnostic,
-			);
-		} else {
-			ok(`${row.name}: no diagnostic`, d.kind === "reject" && d.diagnostic === undefined);
-		}
-	}
-}
-
-async function main(): Promise<void> {
-	console.log("[check-entwurf-v2-matrix] 5d-5 (a) reachability + lock SSOT table\n");
-	for (const row of ROWS) {
-		console.log(`── ${row.name}  [${row.targetKind}]`);
-		await runRow(row);
-	}
-
-	// ── 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>();
-	const rejectReasons = new Set<string>();
-	for (const row of ROWS) {
-		lockClasses.add(row.expect.lock);
-		if (row.expect.decision === "execute") transports.add(row.expect.transport);
-		else rejectReasons.add(row.expect.reason);
-	}
-	for (const tr of ["control-socket", "meta-mailbox"]) {
-		ok(`coverage: transport "${tr}" exercised`, transports.has(tr));
-	}
-	for (const lc of ["none", "held", "mailbox-null", "released", "acquire-fail"] as LockClass[]) {
-		ok(`coverage: lock class "${lc}" exercised`, lockClasses.has(lc));
-	}
-	for (const rr of [
-		"bad-target",
-		"target-address-conflict",
-		"target-locked",
-		"mailbox-undeliverable",
-		"dormant-fire-forget-unsupported",
-		"indeterminate-no-spawn",
-	]) {
-		ok(`coverage: reject reason "${rr}" in table`, rejectReasons.has(rr));
-	}
-
-	console.log(`\n[check-entwurf-v2-matrix] ${passed} assertions ok`);
-}
-
-main().catch((err) => {
-	console.error(err);
-	process.exit(1);
-});

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

@@ -1,221 +0,0 @@
-/**
- * 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 = { backend: "antigravity", lsAddress: "127.0.0.1:5600" };
-
-function agyAddress(route: NativePushRoute | undefined): string | undefined {
-	return route?.backend === "antigravity" ? route.lsAddress : undefined;
-}
-
-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[];
-	retriable?: boolean;
-}
-
-function makeFakeAdapter(config: FakeAdapterConfig): {
-	adapter: NativePushAdapter;
-	sends: SendCall[];
-	probeCount: () => number;
-} {
-	let probeIdx = 0;
-	let sendIdx = 0;
-	const sends: SendCall[] = [];
-	const adapter: NativePushAdapter = {
-		id: "antigravity",
-		retriable: config.retriable ?? true,
-		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)", agyAddress(sends[0]?.route) === "127.0.0.1:5600");
-		ok("success: ZERO re-probe", probeCount() === 0);
-	}
-
-	// Codex's vendor queue may accept before its receipt fails: no re-probe, no replay.
-	{
-		const { adapter, sends, probeCount } = makeFakeAdapter({
-			probes: [{ status: "alive", route: { backend: "antigravity", lsAddress: "must-not-be-used" } }],
-			sendFailAt: [0, 1],
-			retriable: false,
-		});
-		await assert.rejects(() => deliverViaNativePush(adapter, PLANTED, CONV, "hi"), /fake send fail/);
-		ok("non-retriable failure makes exactly ONE send", sends.length === 1);
-		ok("non-retriable failure makes ZERO probes", probeCount() === 0);
-	}
-
-	// ── fail → re-probe alive → re-send success: retried, fresh route ────────────
-	{
-		const { adapter, sends, probeCount } = makeFakeAdapter({
-			probes: [{ status: "alive", route: { backend: "antigravity", 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", agyAddress(sends[0]?.route) === "127.0.0.1:5600");
-		ok(
-			"retry: 2nd send used the RE-DISCOVERED route (not the stale one)",
-			agyAddress(sends[1]?.route) === "127.0.0.1:5601",
-		);
-		// The retry replays CONTENT, never re-derives it. The caller hands this leaf one already
-		// rendered string (the #95 sender envelope is rendered ONCE, upstream, with its own
-		// timestamp), so the only honest retry is the same bytes — a second render, or any
-		// per-attempt decoration here, would deliver a body that disagrees with the first
-		// attempt the target may already have accepted. Asserted at this leaf so the claim holds
-		// without coupling sender rendering into the adapter hand.
-		ok(
-			"[QK:NATIVE-PUSH-RETRY-BYTE-IDENTITY] the retry replays byte-identical content, never a re-derived body",
-			sends[0]?.content === sends[1]?.content,
-		);
-	}
-
-	// ── fail → re-probe alive → re-send FAIL: throws (fail-loud, no 3rd attempt) ──
-	{
-		const { adapter, sends } = makeFakeAdapter({
-			probes: [{ status: "alive", route: { backend: "antigravity", 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" && agyAddress(sends[0]?.route) === "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();