@junghanacs/entwurf 0.13.0 → 0.14.0

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

@@ -1,7 +1,7 @@
 /**
  * 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 spawn/send IO exists:
+ * 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
@@ -9,11 +9,6 @@
  *   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.
- *   4. spawn-bg: spawn-started ALONE does NOT release (the load-bearing rule).
- *   5. spawn-bg: first socket-alive releases.
- *   6. spawn-bg: first child-exited (any code: 0 / non-zero / null-signal) releases.
- *   7. spawn-bg: socket↔exit race is idempotent — one release regardless of order.
- *   8. spawn-bg: spawn-start-failed finalizes (no child to watch) with one release.
  *   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
@@ -70,19 +65,6 @@ const CONTROL_PLAN: ExecutionPlan = {
 	wantsReply: false,
 	message: "m",
 };
-const SPAWN_PLAN: ExecutionPlan = {
-	transport: "spawn-bg",
-	action: "resume",
-	targetGardenId: GID,
-	sessionId: GID,
-	cwd: "/home/junghan/repos/gh/entwurf",
-	prompt: "p",
-	wantsReply: false,
-	launchArgs: ["--approve"],
-	expectedSocketPath: "/fake/ctl/s.sock",
-	observeTimeoutMs: 30_000,
-	releaseWhen: "socket-alive-or-child-exited",
-};
 
 // Fold a sequence of events; return the shouldRelease flag emitted per event.
 function fold(policy: ReleasePolicy, events: ReleaseEvent[]): boolean[] {
@@ -111,10 +93,6 @@ ok(
 	"policy: control-socket + lock → release-after-send-final",
 	decideReleasePolicy(CONTROL_PLAN, lockClaim()).kind === "release-after-send-final",
 );
-ok(
-	"policy: spawn-bg + lock → release-after-spawn-observation",
-	decideReleasePolicy(SPAWN_PLAN, lockClaim()).kind === "release-after-spawn-observation",
-);
 ok(
 	"policy: meta-mailbox + lock → throws (？7 violated)",
 	throws(() => decideReleasePolicy(MAILBOX_PLAN, lockClaim())),
@@ -123,10 +101,6 @@ ok(
 	"policy: control-socket + null → throws (must hold lock)",
 	throws(() => decideReleasePolicy(CONTROL_PLAN, null)),
 );
-ok(
-	"policy: spawn-bg + null → throws (must hold lock)",
-	throws(() => decideReleasePolicy(SPAWN_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";
@@ -134,21 +108,11 @@ ok(
 	"policy: control-socket + mismatched lock gid → throws",
 	throws(() => decideReleasePolicy(CONTROL_PLAN, { ...lockClaim(), gardenId: WRONG_GID })),
 );
-ok(
-	"policy: spawn-bg + mismatched lock gid → throws",
-	throws(() => decideReleasePolicy(SPAWN_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" },
-		{ kind: "socket-alive" },
-		{ kind: "child-exited", code: 0 },
-		{ kind: "spawn-started", pid: 1 },
-	]);
+	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),
@@ -158,8 +122,6 @@ ok(
 // ── 3: control-socket holds before send-final, releases once, holds after ────
 {
 	const policy: ReleasePolicy = { kind: "release-after-send-final" };
-	ok("control: spawn-started before final → hold", fold(policy, [{ kind: "spawn-started", pid: 1 }])[0] === false);
-	ok("control: socket-alive before final → hold", fold(policy, [{ kind: "socket-alive" }])[0] === false);
 	for (const outcome of ["sent", "fallback-sent", "rejected", "failed"] as const) {
 		const flags = fold(policy, [
 			{ kind: "send-final", outcome },
@@ -169,76 +131,19 @@ ok(
 	}
 }
 
-// ── 4: spawn-bg — spawn-started ALONE does NOT release (load-bearing) ─────────
-{
-	const policy: ReleasePolicy = { kind: "release-after-spawn-observation" };
-	ok("spawn: spawn-started alone → NO release", fold(policy, [{ kind: "spawn-started", pid: 99 }])[0] === false);
-	ok(
-		"spawn: spawn-started then socket-alive → release only on observation",
-		(() => {
-			const f = fold(policy, [{ kind: "spawn-started", pid: 99 }, { kind: "socket-alive" }]);
-			return f[0] === false && f[1] === true;
-		})(),
-	);
-}
-
-// ── 5: spawn-bg — first socket-alive releases ────────────────────────────────
-{
-	const policy: ReleasePolicy = { kind: "release-after-spawn-observation" };
-	ok("spawn: socket-alive releases", fold(policy, [{ kind: "socket-alive" }])[0] === true);
-}
-
-// ── 6: spawn-bg — first child-exited (any code) releases ─────────────────────
-{
-	const policy: ReleasePolicy = { kind: "release-after-spawn-observation" };
-	for (const code of [0, 1, 137, null] as const) {
-		ok(`spawn: child-exited(code=${code}) releases`, fold(policy, [{ kind: "child-exited", code }])[0] === true);
-	}
-}
-
-// ── 7: spawn-bg — socket↔exit race idempotent (one release, either order) ────
-{
-	const policy: ReleasePolicy = { kind: "release-after-spawn-observation" };
-	const socketThenExit = fold(policy, [{ kind: "socket-alive" }, { kind: "child-exited", code: 0 }]);
-	ok(
-		"spawn: socket-alive then child-exited → release only on first",
-		socketThenExit[0] === true && socketThenExit[1] === false,
-	);
-	const exitThenSocket = fold(policy, [{ kind: "child-exited", code: 1 }, { kind: "socket-alive" }]);
-	ok(
-		"spawn: child-exited then socket-alive → release only on first",
-		exitThenSocket[0] === true && exitThenSocket[1] === false,
-	);
-}
-
-// ── 8: spawn-bg — spawn-start-failed finalizes (no child to watch) ───────────
-{
-	const policy: ReleasePolicy = { kind: "release-after-spawn-observation" };
-	ok(
-		"spawn: spawn-start-failed releases (frees the gid, no child)",
-		fold(policy, [{ kind: "spawn-start-failed", error: "ENOENT" }])[0] === true,
-	);
-	const startedThenFailedImpossibleButSafe = fold(policy, [
-		{ kind: "spawn-started", pid: 1 },
-		{ kind: "spawn-start-failed", error: "late" },
-	]);
-	ok(
-		"spawn: started(hold) then start-failed(release) — still one release",
-		startedThenFailedImpossibleButSafe[0] === false && startedThenFailedImpossibleButSafe[1] === true,
-	);
-}
-
 // ── 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-spawn-observation" };
+	const policy: ReleasePolicy = { kind: "release-after-send-final" };
 	const flags = fold(policy, [
-		{ kind: "socket-alive" },
-		{ kind: "child-exited", code: 0 },
-		{ kind: "child-exited", code: 1 },
-		{ kind: "socket-alive" },
+		{ kind: "send-final", outcome: "sent" },
+		{ kind: "send-final", outcome: "fallback-sent" },
+		{ kind: "send-final", outcome: "failed" },
 	]);
 	ok(
-		"single-release: exactly one release across many triggers",
+		"single-release: exactly one release across many terminal events",
 		flags.filter((f) => f).length === 1 && flags[0] === true,
 	);
 }

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

@@ -1,13 +1,11 @@
 /**
  * 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/spawn/timer:
+ * 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"}.
- *   3. spawn-bg execute       → resumeSpawnBg(plan, lock); a `socket-alive` result rides
- *      executed; a `lock-retained` result ALSO rides executed (fail-closed, not a failure).
  *   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}
@@ -16,7 +14,7 @@
  *      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. spawn / mailbox hand throws → execution-failed, retrySafe:false.
+ *   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
@@ -26,7 +24,7 @@
  * 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/spawn/mailbox).
+ *  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).
  *
@@ -57,7 +55,6 @@ import type {
 	RpcSendResult,
 } from "../pi-extensions/lib/entwurf-v2-send.ts";
 import { SendDeliveredReleaseFailedError } from "../pi-extensions/lib/entwurf-v2-send.ts";
-import type { SpawnBgPlan, SpawnBgResumeResult } from "../pi-extensions/lib/entwurf-v2-spawn.ts";
 
 let passed = 0;
 function ok(label: string, cond: boolean): void {
@@ -89,19 +86,6 @@ const CONTROL_PLAN: ControlSocketPlan = {
 	wantsReply: false,
 	message: "m",
 };
-const SPAWN_PLAN: SpawnBgPlan = {
-	transport: "spawn-bg",
-	action: "resume",
-	targetGardenId: GID,
-	sessionId: GID,
-	cwd: "/home/junghan/repos/gh/entwurf",
-	prompt: "p",
-	wantsReply: false,
-	launchArgs: [],
-	expectedSocketPath: "/fake/ctl/s.sock",
-	observeTimeoutMs: 30_000,
-	releaseWhen: "socket-alive-or-child-exited",
-};
 const MAILBOX_PLAN: MetaMailboxPlan = {
 	transport: "meta-mailbox",
 	action: "send",
@@ -138,14 +122,12 @@ function executeDecision(plan: ExecutionPlan, lock: LockClaim | null): Extract<D
 interface Trace {
 	calls: string[];
 	controlArgs?: { plan: ControlSocketPlan; lock: LockClaim | null };
-	spawnArgs?: { plan: SpawnBgPlan; lock: LockClaim | null };
 	mailboxArgs?: { plan: MetaMailboxPlan; lock: LockClaim | null };
 	nativePushArgs?: { plan: NativePushPlan; lock: LockClaim | null };
 }
 
 interface FakeSpec {
 	control?: { result: ControlSocketSendResult } | { throw: unknown };
-	spawn?: { result: SpawnBgResumeResult } | { throw: unknown };
 	mailbox?: { result: RpcSendResult } | { throw: unknown };
 	nativePush?: { result: NativePushSendResult } | { throw: unknown };
 }
@@ -160,13 +142,6 @@ function makeDeps(spec: FakeSpec): { deps: DispatchExecutorDeps; trace: Trace }
 			if ("throw" in spec.control) throw spec.control.throw;
 			return spec.control.result;
 		},
-		async resumeSpawnBg(plan, lock) {
-			trace.calls.push("resumeSpawnBg");
-			trace.spawnArgs = { plan, lock };
-			if (!spec.spawn) throw new Error("test: resumeSpawnBg called but no spec");
-			if ("throw" in spec.spawn) throw spec.spawn.throw;
-			return spec.spawn.result;
-		},
 		async sendMailbox(plan, lock) {
 			trace.calls.push("sendMailbox");
 			trace.mailboxArgs = { plan, lock };
@@ -224,41 +199,6 @@ async function main(): Promise<void> {
 		ok("2: success receipt carried", res.kind === "executed" && res.receipt === SUCCESS_RECEIPT);
 	}
 
-	// ── 3: spawn-bg execute → socket-alive AND lock-retained both ride executed ─
-	{
-		const lock = lockClaim();
-		const alive = makeDeps({ spawn: { result: { kind: "socket-alive", released: true, pid: 7 } } });
-		const r1 = await executeDispatch(executeDecision(SPAWN_PLAN, lock), alive.deps);
-		ok("3: spawn → only resumeSpawnBg ran", alive.trace.calls.length === 1 && alive.trace.calls[0] === "resumeSpawnBg");
-		ok(
-			"3: spawn plan + lock reach the hand",
-			alive.trace.spawnArgs?.plan === SPAWN_PLAN && alive.trace.spawnArgs?.lock === lock,
-		);
-		ok(
-			"3: socket-alive → executed{spawn-bg, socket-alive}",
-			r1.kind === "executed" && r1.outcome.transport === "spawn-bg" && r1.outcome.result.kind === "socket-alive",
-		);
-
-		const retainedResult: SpawnBgResumeResult = {
-			kind: "lock-retained",
-			released: false,
-			reason: "observe-failed",
-			diagnostic: {
-				targetGardenId: GID,
-				lockPath: "/fake/locks/x.lock",
-				expectedSocketPath: "/fake/ctl/s.sock",
-				observeTimeoutMs: 30_000,
-				killGraceMs: 5_000,
-			},
-		};
-		const retained = makeDeps({ spawn: { result: retainedResult } });
-		const r2 = await executeDispatch(executeDecision(SPAWN_PLAN, lock), retained.deps);
-		ok(
-			"3: lock-retained rides executed (fail-closed, not a failure)",
-			r2.kind === "executed" && r2.outcome.transport === "spawn-bg" && r2.outcome.result.kind === "lock-retained",
-		);
-	}
-
 	// ── 4: meta-mailbox execute → sendMailbox(plan, null), success ────────────
 	{
 		const { deps, trace } = makeDeps({ mailbox: { result: { success: true } } });
@@ -355,15 +295,8 @@ async function main(): Promise<void> {
 		);
 	}
 
-	// ── 8: spawn / mailbox hand throw → execution-failed ──────────────────────
+	// ── 8: the mailbox hand throws → execution-failed ─────────────────────────
 	{
-		const s = makeDeps({ spawn: { throw: new Error("spawn boom") } });
-		const rs = await executeDispatch(executeDecision(SPAWN_PLAN, lockClaim()), s.deps);
-		ok(
-			"8: spawn throw → execution-failed",
-			rs.kind === "execution-failed" && rs.transport === "spawn-bg" && rs.retrySafe === false,
-		);
-
 		const m = makeDeps({ mailbox: { throw: new Error("enqueue boom") } });
 		const rm = await executeDispatch(executeDecision(MAILBOX_PLAN, null), m.deps);
 		ok(
@@ -444,20 +377,6 @@ async function main(): Promise<void> {
 				rc.kind === "executed" &&
 				rc.outcome.transport === "control-socket",
 		);
-
-		const spw = makeRunDeps(
-			{ decision: executeDecision(SPAWN_PLAN, lock) },
-			{ spawn: { result: { kind: "socket-alive", released: true, pid: 7 } } },
-		);
-		const rsp = await runEntwurfV2(DISPATCH_INPUT, spw.deps);
-		ok(
-			"12: spawn execute → resumeSpawnBg ran, executed{spawn-bg}",
-			spw.trace.calls.length === 1 &&
-				spw.trace.calls[0] === "resumeSpawnBg" &&
-				rsp.kind === "executed" &&
-				rsp.outcome.transport === "spawn-bg",
-		);
-
 		const mbx = makeRunDeps(
 			{ decision: executeDecision(MAILBOX_PLAN, null) },
 			{ mailbox: { result: { success: true } } },

package/scripts/check-entwurf-v2-send-fallback.ts

@@ -14,14 +14,14 @@
  *   6. in-domain pi + socket-file + probe alive → control-socket plan with the INSPECTED
  *      socketPath; message/mode/wantsReply preserved, same target gid.
  *   7. in-domain pi + absent (ENOENT → dead) → reject (dormant-fire-forget-unsupported);
- *      NEVER a spawn-bg plan, NEVER a mailbox.
+ *      NEVER a mailbox.
  *   8. in-domain pi + probe indeterminate → reject (indeterminate-no-spawn); no mailbox.
  *   9. in-domain pi + inspect indeterminate → reject; no probe connect, no mailbox.
  *  10. address-conflict (symlink) → reject (target-address-conflict).
  *  11. probe throw / inspect throw → PROPAGATE (resolver does not catch; the 5c-2a hand
  *      owns failed+release). The resolver NEVER calls a release seam (it has none).
  *  12. every execute plan targets plan.targetGardenId === lock.gardenId, and is one of
- *      control-socket / meta-mailbox — never spawn-bg.
+ *      control-socket / meta-mailbox only.
  *
  * No real IO — fakes count inspect/probe calls so "short-circuits before probing" is
  * asserted structurally.
@@ -221,7 +221,7 @@ async function main(): Promise<void> {
 		ok("pi + alive → inspected once, probed once", trace.inspectCalls === 1 && trace.probeCalls === 1);
 	}
 
-	// ── 7: in-domain pi + absent (dead) → reject, NEVER spawn-bg/mailbox ───────
+	// ── 7: in-domain pi + absent (dead) → reject, NEVER a mailbox enqueue ─────
 	{
 		const { deps, trace } = makeDeps({
 			resolution: present(identity("pi")),
@@ -324,7 +324,7 @@ async function main(): Promise<void> {
 		ok("inspect throw → propagates", e2 === inspectBoom);
 	}
 
-	// ── 12: every execute plan targets the held gid, never spawn-bg ───────────
+	// ── 12: every execute plan targets the held gid ───────────────────────────
 	{
 		const cases: FakeSpec[] = [
 			{ resolution: present(identity("claude-code")), mailboxDeliverable: true },
@@ -340,9 +340,8 @@ async function main(): Promise<void> {
 			const r = await resolveDeadControlSendFallback(CONTROL_PLAN, lockClaim(), deps);
 			if (r.kind !== "execute") allSameTargetNonSpawn = false;
 			else if (r.plan.targetGardenId !== GID) allSameTargetNonSpawn = false;
-			else if (r.plan.transport === "spawn-bg") allSameTargetNonSpawn = false;
 		}
-		ok("every execute plan: same target gid, never spawn-bg", allSameTargetNonSpawn);
+		ok("every execute plan: same target gid (a SEND fallback never re-targets)", allSameTargetNonSpawn);
 	}
 
 	console.log(`\n[check-entwurf-v2-send-fallback] ${passed} assertions ok`);

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

@@ -23,8 +23,6 @@
  *  10. masking guard: on a `failed` send the ORIGINAL send error is rethrown even if
  *      releaseLock itself throws (a release failure must not mask the send failure).
  *  11. lock invariants: null lock / mismatched-gid lock → throws (decideReleasePolicy).
- *  12. contract: a re-resolve into a spawn-bg plan for a SEND → throws AND still
- *      releases the held lock ×1 (lock-leak backstop, not a leak).
  *  13. lock-leak backstop: any UNEXPECTED dep throw after the lock is held
  *      (classifyConnect) still releases ×1 and rethrows the original error.
  *  14. mis-route: a re-resolve returning a DIFFERENT-target control plan fails loud
@@ -95,20 +93,6 @@ const MAILBOX_PLAN = {
 	message: "m",
 } as const satisfies Extract<ExecutionPlan, { transport: "meta-mailbox" }>;
 
-const SPAWN_PLAN = {
-	transport: "spawn-bg",
-	action: "resume",
-	targetGardenId: GID,
-	sessionId: GID,
-	cwd: "/home/junghan/repos/gh/entwurf",
-	prompt: "p",
-	wantsReply: false,
-	launchArgs: [],
-	expectedSocketPath: "/fake/ctl/s.sock",
-	observeTimeoutMs: 30_000,
-	releaseWhen: "socket-alive-or-child-exited",
-} as const satisfies Extract<ExecutionPlan, { transport: "spawn-bg" }>;
-
 // A connect-time error with a real `.code` (drives the F3 classifier the way a node
 // net error would). dead = ECONNREFUSED/ENOENT; everything else = indeterminate.
 function connError(code: string): NodeJS.ErrnoException {
@@ -351,18 +335,6 @@ async function main(): Promise<void> {
 		ok("mismatched-gid lock → throws (mis-paired plan/lock)", mismatchErr instanceof Error);
 	}
 
-	// ── 12: contract — re-resolve into a spawn-bg plan for a SEND → throws,
-	//        AND the held lock is STILL released (lock-leak backstop) ───────────
-	{
-		const { deps, trace } = makeDeps({
-			firstSend: { throwCode: "ECONNREFUSED" },
-			deadFallback: { kind: "execute", plan: SPAWN_PLAN },
-		});
-		const err = await rejects(() => executeControlSocketSend(CONTROL_PLAN, lockClaim(), deps));
-		ok("re-resolve → spawn-bg for a send → throws (contract violation)", err instanceof Error);
-		ok("re-resolve → spawn-bg → lock STILL released ×1 (no leak)", trace.releases.length === 1);
-	}
-
 	// ── 13: lock-leak backstop — an UNEXPECTED dep throw (classifyConnect) after
 	//        the lock is held still releases ×1 and rethrows the original error ──
 	{