@junghanacs/entwurf 0.23.0 → 0.24.0

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

@@ -1,151 +0,0 @@
-/**
- * check-entwurf-v2-release — deterministic gate for the PURE release-policy reducer
- * (0.11 Stage 0 step 5c-1). Proves the Fable-3 "release-after-observation" timing as
- * a pure state machine BEFORE any send IO exists:
- *
- *   1. decideReleasePolicy maps each transport correctly and ENFORCES the lock
- *      invariants (meta-mailbox ⇒ null else throw; in-domain ⇒ non-null AND
- *      lock.gardenId === plan.targetGardenId, else throw).
- *   2. no-lock policy NEVER releases — on any event.
- *   3. control-socket holds before send-final, releases EXACTLY ONCE on send-final
- *      (every terminal outcome), holds after.
- *   9. single-release: after a release, no later event releases again.
- *
- * No IO — the reducer is pure; the gate folds event sequences and checks the
- * shouldRelease transitions.
- */
-
-import assert from "node:assert/strict";
-import type { ExecutionPlan } from "../pi-extensions/lib/entwurf-v2-decider.ts";
-import type { LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
-import {
-	decideReleasePolicy,
-	initialReleaseState,
-	type ReleaseEvent,
-	type ReleasePolicy,
-	reduceRelease,
-} from "../pi-extensions/lib/entwurf-v2-release.ts";
-
-let passed = 0;
-function ok(label: string, cond: boolean): void {
-	assert.ok(cond, label);
-	console.log(`  ok    ${label}`);
-	passed++;
-}
-
-const GID = "20260612T100000-aaaaaa";
-
-function lockClaim(): LockClaim {
-	return {
-		gardenId: GID,
-		pid: 4242,
-		hostname: "test-host",
-		createdAt: "2026-06-12T01:00:00.000Z",
-		nonce: "deadbeefcafef00d",
-		owner: "entwurf_v2",
-		lockPath: `/fake/locks/${GID}.lock`,
-	};
-}
-
-const MAILBOX_PLAN: ExecutionPlan = {
-	transport: "meta-mailbox",
-	action: "send",
-	targetGardenId: GID,
-	mailboxDir: "/fake/mailbox",
-	sessionsDir: "/fake/sessions",
-	wantsReply: false,
-	message: "m",
-};
-const CONTROL_PLAN: ExecutionPlan = {
-	transport: "control-socket",
-	action: "send",
-	targetGardenId: GID,
-	socketPath: "/fake/ctl/s.sock",
-	mode: "follow_up",
-	wantsReply: false,
-	message: "m",
-};
-
-// Fold a sequence of events; return the shouldRelease flag emitted per event.
-function fold(policy: ReleasePolicy, events: ReleaseEvent[]): boolean[] {
-	let state = initialReleaseState();
-	const flags: boolean[] = [];
-	for (const ev of events) {
-		const r = reduceRelease(policy, state, ev);
-		state = r.state;
-		flags.push(r.shouldRelease);
-	}
-	return flags;
-}
-
-function throws(fn: () => unknown): boolean {
-	try {
-		fn();
-		return false;
-	} catch {
-		return true;
-	}
-}
-
-// ── 1: decideReleasePolicy mapping + lock-nullness enforcement ───────────────
-ok("policy: meta-mailbox + null → no-lock", decideReleasePolicy(MAILBOX_PLAN, null).kind === "no-lock");
-ok(
-	"policy: control-socket + lock → release-after-send-final",
-	decideReleasePolicy(CONTROL_PLAN, lockClaim()).kind === "release-after-send-final",
-);
-ok(
-	"policy: meta-mailbox + lock → throws (？7 violated)",
-	throws(() => decideReleasePolicy(MAILBOX_PLAN, lockClaim())),
-);
-ok(
-	"policy: control-socket + null → throws (must hold lock)",
-	throws(() => decideReleasePolicy(CONTROL_PLAN, null)),
-);
-// in-domain lock whose gardenId ≠ plan target = mis-paired plan/lock (same grade as
-// a null lock — a later release would free a DIFFERENT gid). Fail loud.
-const WRONG_GID = "20260612T999999-bbbbbb";
-ok(
-	"policy: control-socket + mismatched lock gid → throws",
-	throws(() => decideReleasePolicy(CONTROL_PLAN, { ...lockClaim(), gardenId: WRONG_GID })),
-);
-
-// ── 2: no-lock NEVER releases ────────────────────────────────────────────────
-{
-	const policy: ReleasePolicy = { kind: "no-lock" };
-	const flags = fold(policy, [{ kind: "mailbox-enqueued" }, { kind: "send-final", outcome: "sent" }]);
-	ok(
-		"no-lock: never releases on any event",
-		flags.every((f) => f === false),
-	);
-}
-
-// ── 3: control-socket holds before send-final, releases once, holds after ────
-{
-	const policy: ReleasePolicy = { kind: "release-after-send-final" };
-	for (const outcome of ["sent", "fallback-sent", "rejected", "failed"] as const) {
-		const flags = fold(policy, [
-			{ kind: "send-final", outcome },
-			{ kind: "send-final", outcome },
-		]);
-		ok(`control: send-final(${outcome}) releases exactly once`, flags[0] === true && flags[1] === false);
-	}
-}
-
-// ── 9: single-release — after release, no later event releases again ─────────
-// Restated on the control-socket policy: the spawn observation events this used to fold
-// went with their transport, but the at-most-once guarantee is the reducer's own and must
-// still be proven against repeated terminal events.
-{
-	const policy: ReleasePolicy = { kind: "release-after-send-final" };
-	const flags = fold(policy, [
-		{ kind: "send-final", outcome: "sent" },
-		{ kind: "send-final", outcome: "fallback-sent" },
-		{ kind: "send-final", outcome: "failed" },
-	]);
-	ok(
-		"single-release: exactly one release across many terminal events",
-		flags.filter((f) => f).length === 1 && flags[0] === true,
-	);
-}
-
-console.log(`\n[check-entwurf-v2-release] ${passed} assertions ok`);

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

@@ -1,448 +0,0 @@
-/**
- * check-entwurf-v2-runner — deterministic gate for the 5d-1 execute-router
- * (`executeDispatch`). It proves the DECISION→hand routing + the outcome-rich result
- * mapping over injected fake hands, with NO socket or timer:
- *
- *   1. reject decision        → kind "rejected", receipt+diagnostic carried, NO hand called.
- *   2. control-socket execute → sendControl(plan, lock) called with the SAME plan + lock;
- *      result outcome "sent" → executed{control-socket, outcome:"sent"}.
- *   4. meta-mailbox execute   → sendMailbox(plan, null) with the NULL lock (？7); success
- *      → executed{meta-mailbox, success:true}.
- *   5. N3 — control rejected with rejectReason → executed{outcome:"rejected", rejectReason}
- *      carried verbatim.
- *   6. N1 — control hand throws SendDeliveredReleaseFailedError → execution-failed with
- *      finalizedOutcome + releaseFailed:true + retrySafe:false.
- *   7. control hand throws a PLAIN transport error → execution-failed, retrySafe:false,
- *      NO finalizedOutcome / releaseFailed (a failed send, lock already released).
- *   8. the mailbox hand throws → execution-failed, retrySafe:false.
- *   9. mailbox hand returns {success:false} → CONTRACT VIOLATION (a mailbox has no
- *      in-band reject) → fail loud → execution-failed, NOT a silent success.
- *  (exactly ONE hand runs per execute — the other two are never called — is asserted
- *   inline in cases 2/3/4.)
- *
- * 5d-2a adds the `runEntwurfV2` COMPOSITION gate (cases 10–14): `decide → execute` joined
- * over a FAKE `decide` (not the real decider — that is check-entwurf-v2-decider's job):
- *  10. decide called EXACTLY once, with the SAME input.
- *  11. reject decision  → no executor hand called, the rejected result returned.
- *  12. execute decision → the matching executor hand ran (control/mailbox).
- *  13. decide THROWS    → propagates (no decision = no receipt to wrap).
- *  14. executeDispatch result returned VERBATIM (passthrough, no re-wrapping).
- *
- * No real IO — fake hands record (plan, lock) so "the decided plan + lock reach the
- * matching hand, and only that hand" is asserted structurally.
- */
-
-import assert from "node:assert/strict";
-import type {
-	DispatchDecision,
-	DispatchInput,
-	ExecutionPlan,
-	RejectReceipt,
-	SuccessReceipt,
-} from "../pi-extensions/lib/entwurf-v2-decider.ts";
-import type { LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
-import type { NativePushPlan, NativePushSendResult } from "../pi-extensions/lib/entwurf-v2-native-push.ts";
-import {
-	type DispatchExecutorDeps,
-	type EntwurfV2RunDeps,
-	executeDispatch,
-	runEntwurfV2,
-} from "../pi-extensions/lib/entwurf-v2-runner.ts";
-import type {
-	ControlSocketPlan,
-	ControlSocketSendResult,
-	MetaMailboxPlan,
-	RpcSendResult,
-} from "../pi-extensions/lib/entwurf-v2-send.ts";
-import { SendDeliveredReleaseFailedError } from "../pi-extensions/lib/entwurf-v2-send.ts";
-
-let passed = 0;
-function ok(label: string, cond: boolean): void {
-	assert.ok(cond, label);
-	console.log(`  ok    ${label}`);
-	passed++;
-}
-
-const GID = "20260613T100000-aaaaaa";
-
-function lockClaim(gardenId = GID): LockClaim {
-	return {
-		gardenId,
-		pid: 4242,
-		hostname: "test-host",
-		createdAt: "2026-06-13T01:00:00.000Z",
-		nonce: "deadbeefcafef00d",
-		owner: "entwurf_v2",
-		lockPath: `/fake/locks/${gardenId}.lock`,
-	};
-}
-
-const CONTROL_PLAN: ControlSocketPlan = {
-	transport: "control-socket",
-	action: "send",
-	targetGardenId: GID,
-	socketPath: "/fake/ctl/s.sock",
-	mode: "follow_up",
-	wantsReply: false,
-	message: "m",
-};
-const MAILBOX_PLAN: MetaMailboxPlan = {
-	transport: "meta-mailbox",
-	action: "send",
-	targetGardenId: GID,
-	mailboxDir: "/fake/mailbox",
-	sessionsDir: "/fake/sessions",
-	wantsReply: false,
-	message: "m",
-};
-const NATIVE_PUSH_PLAN: NativePushPlan = {
-	transport: "native-push",
-	action: "send",
-	targetGardenId: GID,
-	backend: "antigravity",
-	nativeSessionId: "conv-xyz",
-	route: { backend: "antigravity", lsAddress: "127.0.0.1:5599" },
-	wantsReply: false,
-	message: "m",
-};
-
-const SUCCESS_RECEIPT: SuccessReceipt = {
-	ok: true,
-	action: "send",
-	transport: "control-socket",
-	ownership: "ack-only",
-	observedLiveness: "alive",
-};
-const REJECT_RECEIPT: RejectReceipt = { ok: false, reason: "bad-target", observedLiveness: null };
-
-function executeDecision(plan: ExecutionPlan, lock: LockClaim | null): Extract<DispatchDecision, { kind: "execute" }> {
-	return { kind: "execute", receipt: SUCCESS_RECEIPT, plan, lock };
-}
-
-interface Trace {
-	calls: string[];
-	controlArgs?: { plan: ControlSocketPlan; lock: LockClaim | null };
-	mailboxArgs?: { plan: MetaMailboxPlan; lock: LockClaim | null };
-	nativePushArgs?: { plan: NativePushPlan; lock: LockClaim | null };
-}
-
-interface FakeSpec {
-	control?: { result: ControlSocketSendResult } | { throw: unknown };
-	mailbox?: { result: RpcSendResult } | { throw: unknown };
-	nativePush?: { result: NativePushSendResult } | { throw: unknown };
-}
-
-function makeDeps(spec: FakeSpec): { deps: DispatchExecutorDeps; trace: Trace } {
-	const trace: Trace = { calls: [] };
-	const deps: DispatchExecutorDeps = {
-		async sendControl(plan, lock) {
-			trace.calls.push("sendControl");
-			trace.controlArgs = { plan, lock };
-			if (!spec.control) throw new Error("test: sendControl called but no spec");
-			if ("throw" in spec.control) throw spec.control.throw;
-			return spec.control.result;
-		},
-		async sendMailbox(plan, lock) {
-			trace.calls.push("sendMailbox");
-			trace.mailboxArgs = { plan, lock };
-			if (!spec.mailbox) throw new Error("test: sendMailbox called but no spec");
-			if ("throw" in spec.mailbox) throw spec.mailbox.throw;
-			return spec.mailbox.result;
-		},
-		async sendNativePush(plan, lock) {
-			trace.calls.push("sendNativePush");
-			trace.nativePushArgs = { plan, lock };
-			if (!spec.nativePush) throw new Error("test: sendNativePush called but no spec");
-			if ("throw" in spec.nativePush) throw spec.nativePush.throw;
-			return spec.nativePush.result;
-		},
-	};
-	return { deps, trace };
-}
-
-async function main(): Promise<void> {
-	// ── 1: reject → no hand called, receipt+diagnostic carried ────────────────
-	{
-		const { deps, trace } = makeDeps({});
-		const conflict = {
-			reason: "target-locked" as const,
-			lockPath: "/fake/locks/x.lock",
-			holder: lockClaim(),
-			detail: "held",
-		};
-		const decision: DispatchDecision = {
-			kind: "reject",
-			receipt: REJECT_RECEIPT,
-			diagnostic: { kind: "target-locked", conflict },
-		};
-		const res = await executeDispatch(decision, deps);
-		ok("1: reject → kind 'rejected'", res.kind === "rejected");
-		ok("1: reject → receipt carried", res.kind === "rejected" && res.receipt === REJECT_RECEIPT);
-		ok("1: reject → diagnostic carried", res.kind === "rejected" && res.diagnostic?.kind === "target-locked");
-		ok("1: reject → NO hand called", trace.calls.length === 0);
-	}
-
-	// ── 2: control-socket execute → sendControl(plan, lock), sent ─────────────
-	{
-		const lock = lockClaim();
-		const { deps, trace } = makeDeps({ control: { result: { outcome: "sent" } } });
-		const res = await executeDispatch(executeDecision(CONTROL_PLAN, lock), deps);
-		ok("2: only sendControl ran", trace.calls.length === 1 && trace.calls[0] === "sendControl");
-		ok(
-			"2: same plan + lock reach the hand",
-			trace.controlArgs?.plan === CONTROL_PLAN && trace.controlArgs?.lock === lock,
-		);
-		ok(
-			"2: executed{control-socket, sent}",
-			res.kind === "executed" && res.outcome.transport === "control-socket" && res.outcome.outcome === "sent",
-		);
-		ok("2: success receipt carried", res.kind === "executed" && res.receipt === SUCCESS_RECEIPT);
-	}
-
-	// ── 4: meta-mailbox execute → sendMailbox(plan, null), success ────────────
-	{
-		const { deps, trace } = makeDeps({ mailbox: { result: { success: true } } });
-		const res = await executeDispatch(executeDecision(MAILBOX_PLAN, null), deps);
-		ok("4: only sendMailbox ran", trace.calls.length === 1 && trace.calls[0] === "sendMailbox");
-		ok(
-			"4: NULL lock passed verbatim (？7)",
-			trace.mailboxArgs?.lock === null && trace.mailboxArgs?.plan === MAILBOX_PLAN,
-		);
-		ok(
-			"4: executed{meta-mailbox, success}",
-			res.kind === "executed" && res.outcome.transport === "meta-mailbox" && res.outcome.success === true,
-		);
-		// #98 R: a dep that reports no path leaves the outcome's receipt undefined. The
-		// runner must not invent one — a guessed path is worse than no path.
-		ok(
-			"4: no enqueue receipt from the dep → messagePath stays undefined (never invented)",
-			res.kind === "executed" && res.outcome.transport === "meta-mailbox" && res.outcome.messagePath === undefined,
-		);
-	}
-
-	// ── 4a: #98 R — the mailbox enqueue receipt is carried through verbatim ───
-	{
-		const { deps } = makeDeps({ mailbox: { result: { success: true, messagePath: "/fake/mailbox/g/2026.msg" } } });
-		const res = await executeDispatch(executeDecision(MAILBOX_PLAN, null), deps);
-		ok(
-			"4a: executed{meta-mailbox} carries the dep's messagePath verbatim",
-			res.kind === "executed" &&
-				res.outcome.transport === "meta-mailbox" &&
-				res.outcome.messagePath === "/fake/mailbox/g/2026.msg",
-		);
-	}
-
-	// ── 4b: native-push execute → sendNativePush(plan, null), lock-free (봉인 4) ──
-	{
-		const { deps, trace } = makeDeps({ nativePush: { result: { success: true, retried: false } } });
-		const res = await executeDispatch(executeDecision(NATIVE_PUSH_PLAN, null), deps);
-		ok("4b: only sendNativePush ran", trace.calls.length === 1 && trace.calls[0] === "sendNativePush");
-		ok(
-			"4b: NULL lock passed verbatim (lock-free rail)",
-			trace.nativePushArgs?.lock === null && trace.nativePushArgs?.plan === NATIVE_PUSH_PLAN,
-		);
-		ok(
-			"4b: executed{native-push, success, retried:false}",
-			res.kind === "executed" &&
-				res.outcome.transport === "native-push" &&
-				res.outcome.success === true &&
-				res.outcome.retried === false,
-		);
-	}
-
-	// ── 4c: native-push retried flag surfaces onto the executed outcome ──────────
-	{
-		const { deps } = makeDeps({ nativePush: { result: { success: true, retried: true } } });
-		const res = await executeDispatch(executeDecision(NATIVE_PUSH_PLAN, null), deps);
-		ok(
-			"4c: retried:true carried onto executed{native-push}",
-			res.kind === "executed" && res.outcome.transport === "native-push" && res.outcome.retried === true,
-		);
-	}
-
-	// ── 4d: native-push hand THROWS → execution-failed, retry-unsafe ─────────────
-	{
-		const { deps } = makeDeps({ nativePush: { throw: new Error("agy send boom") } });
-		const res = await executeDispatch(executeDecision(NATIVE_PUSH_PLAN, null), deps);
-		ok(
-			"4d: native-push throw → execution-failed (retrySafe:false)",
-			res.kind === "execution-failed" && res.transport === "native-push" && res.retrySafe === false,
-		);
-	}
-
-	// ── 5: N3 — control rejected with rejectReason carried ────────────────────
-	{
-		const { deps } = makeDeps({
-			control: { result: { outcome: "rejected", rejectReason: "dormant-fire-forget-unsupported" } },
-		});
-		const res = await executeDispatch(executeDecision(CONTROL_PLAN, lockClaim()), deps);
-		ok(
-			"5: N3 rejectReason carried onto executed result",
-			res.kind === "executed" &&
-				res.outcome.transport === "control-socket" &&
-				res.outcome.rejectReason === "dormant-fire-forget-unsupported",
-		);
-	}
-
-	// ── 6: N1 — SendDeliveredReleaseFailedError → execution-failed, no-retry ───
-	{
-		const releaseErr = new Error("release boom");
-		const { deps } = makeDeps({ control: { throw: new SendDeliveredReleaseFailedError("sent", releaseErr) } });
-		const res = await executeDispatch(executeDecision(CONTROL_PLAN, lockClaim()), deps);
-		ok("6: N1 → execution-failed", res.kind === "execution-failed");
-		ok(
-			"6: N1 → finalizedOutcome 'sent' + releaseFailed + retrySafe:false",
-			res.kind === "execution-failed" &&
-				res.finalizedOutcome === "sent" &&
-				res.releaseFailed === true &&
-				res.retrySafe === false,
-		);
-	}
-
-	// ── 7: control PLAIN throw → execution-failed, no finalizedOutcome ────────
-	{
-		const { deps } = makeDeps({ control: { throw: new Error("connect indeterminate / dep boom") } });
-		const res = await executeDispatch(executeDecision(CONTROL_PLAN, lockClaim()), deps);
-		ok(
-			"7: plain throw → execution-failed, retrySafe:false",
-			res.kind === "execution-failed" && res.retrySafe === false,
-		);
-		ok(
-			"7: plain throw → no finalizedOutcome / releaseFailed",
-			res.kind === "execution-failed" && res.finalizedOutcome === undefined && res.releaseFailed === undefined,
-		);
-	}
-
-	// ── 8: the mailbox hand throws → execution-failed ─────────────────────────
-	{
-		const m = makeDeps({ mailbox: { throw: new Error("enqueue boom") } });
-		const rm = await executeDispatch(executeDecision(MAILBOX_PLAN, null), m.deps);
-		ok(
-			"8: mailbox throw → execution-failed",
-			rm.kind === "execution-failed" && rm.transport === "meta-mailbox" && rm.retrySafe === false,
-		);
-	}
-
-	// ── 9: mailbox returns {success:false} → CONTRACT VIOLATION, fail loud ─────
-	// 5c-4: a mailbox enqueue is {success:true} OR a throw — there is no in-band reject.
-	// A success:false must NOT be silently rendered as a success; the runner fails loud.
-	{
-		const { deps } = makeDeps({ mailbox: { result: { success: false, error: "should never happen" } } });
-		const res = await executeDispatch(executeDecision(MAILBOX_PLAN, null), deps);
-		ok(
-			"9: mailbox success:false → execution-failed (not a silent success)",
-			res.kind === "execution-failed" && res.transport === "meta-mailbox" && res.retrySafe === false,
-		);
-	}
-
-	// ── 10–14: runEntwurfV2 composition (5d-2a) over a FAKE decide ─────────────
-	const DISPATCH_INPUT: DispatchInput = {
-		target: GID,
-		intent: "fire-and-forget",
-		mode: "follow_up",
-		wantsReply: false,
-		message: "m",
-	};
-
-	// A fake decide records how it was called and returns a scripted decision (or throws).
-	function makeRunDeps(
-		decideSpec: { decision: DispatchDecision } | { throw: unknown },
-		execSpec: FakeSpec,
-	): { deps: EntwurfV2RunDeps; decideCalls: DispatchInput[]; trace: Trace } {
-		const { deps: executor, trace } = makeDeps(execSpec);
-		const decideCalls: DispatchInput[] = [];
-		const deps: EntwurfV2RunDeps = {
-			decide(input) {
-				decideCalls.push(input);
-				if ("throw" in decideSpec) throw decideSpec.throw;
-				return decideSpec.decision;
-			},
-			executor,
-		};
-		return { deps, decideCalls, trace };
-	}
-
-	// ── 10: decide called exactly once, with the same input ───────────────────
-	{
-		const decision: DispatchDecision = { kind: "reject", receipt: REJECT_RECEIPT };
-		const { deps, decideCalls } = makeRunDeps({ decision }, {});
-		await runEntwurfV2(DISPATCH_INPUT, deps);
-		ok("10: decide called exactly once", decideCalls.length === 1);
-		ok("10: decide got the SAME input", decideCalls[0] === DISPATCH_INPUT);
-	}
-
-	// ── 11: reject decision → no hand called, rejected result returned ────────
-	{
-		const decision: DispatchDecision = { kind: "reject", receipt: REJECT_RECEIPT };
-		const { deps, trace } = makeRunDeps({ decision }, {});
-		const res = await runEntwurfV2(DISPATCH_INPUT, deps);
-		ok("11: reject → rejected result", res.kind === "rejected" && res.receipt === REJECT_RECEIPT);
-		ok("11: reject → NO executor hand called", trace.calls.length === 0);
-	}
-
-	// ── 12: execute decision → the matching hand ran (per transport) ──────────
-	{
-		const lock = lockClaim();
-		const ctl = makeRunDeps(
-			{ decision: executeDecision(CONTROL_PLAN, lock) },
-			{ control: { result: { outcome: "sent" } } },
-		);
-		const rc = await runEntwurfV2(DISPATCH_INPUT, ctl.deps);
-		ok(
-			"12: control execute → sendControl ran, executed{control-socket}",
-			ctl.trace.calls.length === 1 &&
-				ctl.trace.calls[0] === "sendControl" &&
-				rc.kind === "executed" &&
-				rc.outcome.transport === "control-socket",
-		);
-		const mbx = makeRunDeps(
-			{ decision: executeDecision(MAILBOX_PLAN, null) },
-			{ mailbox: { result: { success: true } } },
-		);
-		const rmb = await runEntwurfV2(DISPATCH_INPUT, mbx.deps);
-		ok(
-			"12: mailbox execute → sendMailbox ran, executed{meta-mailbox}",
-			mbx.trace.calls.length === 1 &&
-				mbx.trace.calls[0] === "sendMailbox" &&
-				rmb.kind === "executed" &&
-				rmb.outcome.transport === "meta-mailbox",
-		);
-	}
-
-	// ── 13: decide THROWS → propagates (no decision = no receipt to wrap) ─────
-	{
-		const boom = new Error("decider boom");
-		const { deps, trace } = makeRunDeps({ throw: boom }, {});
-		let caught: unknown;
-		try {
-			await runEntwurfV2(DISPATCH_INPUT, deps);
-		} catch (err) {
-			caught = err;
-		}
-		ok("13: decide throw → propagates the SAME error", caught === boom);
-		ok("13: decide throw → NO executor hand called", trace.calls.length === 0);
-	}
-
-	// ── 14: executeDispatch result returned VERBATIM (passthrough) ────────────
-	// A control hand throwing the N1 error must surface AS execution-failed{...} through
-	// runEntwurfV2 unchanged — the runner adds no wrapping over executeDispatch's mapping.
-	{
-		const releaseErr = new Error("release boom");
-		const { deps } = makeRunDeps(
-			{ decision: executeDecision(CONTROL_PLAN, lockClaim()) },
-			{ control: { throw: new SendDeliveredReleaseFailedError("sent", releaseErr) } },
-		);
-		const res = await runEntwurfV2(DISPATCH_INPUT, deps);
-		ok(
-			"14: N1 surfaces verbatim → execution-failed{finalizedOutcome,releaseFailed,retrySafe:false}",
-			res.kind === "execution-failed" &&
-				res.finalizedOutcome === "sent" &&
-				res.releaseFailed === true &&
-				res.retrySafe === false,
-		);
-	}
-
-	console.log(`\ncheck-entwurf-v2-runner: ${passed} checks passed`);
-}
-
-await main();