@junghanacs/entwurf 0.13.0 → 0.14.0

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

@@ -1,399 +0,0 @@
-/**
- * check-entwurf-v2-spawn — deterministic gate for the 5c-3a spawn-bg RESUME watcher hand
- * (`executeSpawnBgResume`). It proves the spawn→observe→release WIRING over injected fakes
- * with controlled promises — NO real child, socket, or timer — exactly as 5b/5c-2 proved
- * their hands. The load-bearing property under test is Fable 3: TIMEOUT IS NOT A RELEASE.
- *
- *   1. spawnChild throws → `spawn-start-failed`, release ×1, original error surfaced.
- *   2. socket-alive wins → `socket-alive`, release ×1; the exit loser settling later is a
- *      no-op (single release); killChild NOT called.
- *   3. child-exited wins (code 0 / 1 / null) → `child-exited`, release ×1; killChild NOT
- *      called; socket loser later no-op.
- *   4. timeout wins → release 0 AT KILL TIME (bare timeout never releases) AND killChild
- *      called ×1 — the timeout escalates to a kill, it does not release.
- *   5. timeout → kill → child-exited (null) observed in grace → `child-exited`, release ×1.
- *   6. timeout → kill → socket-alive observed in grace → `socket-alive`, release ×1.
- *   7. timeout → kill → grace elapses with NO observation → `lock-retained`
- *      (reason `kill-unconfirmed`), release 0, full diagnostic surfaced, bounded return.
- *   8. post-spawn dep throw (awaitChildExit rejects in the primary race) → best-effort kill,
- *      exit cannot be observed → `lock-retained` (reason `observe-failed`), release 0.
- *   9. post-spawn dep throw (awaitSocketAlive rejects in the primary race) → kill → exit
- *      observed in grace → `child-exited`, release ×1 (the working exit watcher still wins).
- *  10. releaseLock throw on a RELEASED (socket-alive) path PROPAGATES — the observation
- *      already happened, the caller must not re-spawn (release error surfaces honestly).
- *  11. lock invariants: null lock / mismatched-gid lock → throws (decideReleasePolicy),
- *      BEFORE any spawn (spawnChild NOT called).
- *  12. no direct-release hatch: across the retained paths (7,8) deps.releaseLock is never
- *      reached — the ONLY release path is reduceRelease on a real observation event.
- *
- * Each await dep is a deferred the gate resolves in a chosen order, flushing microtasks
- * between steps, so "release happens after the observation, exactly once" is asserted
- * structurally over every event order.
- */
-
-import assert from "node:assert/strict";
-import type { LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
-import {
-	executeSpawnBgResume,
-	type SpawnBgPlan,
-	type SpawnBgResumeDeps,
-	type SpawnedChild,
-} from "../pi-extensions/lib/entwurf-v2-spawn.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 WRONG_GID = "20260612T999999-bbbbbb";
-const SOCK = "/fake/entwurf-control/20260612T100000-aaaaaa.sock";
-const LOCKPATH = `/fake/locks/${GID}.lock`;
-
-function lockClaim(gardenId = GID): 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`,
-	};
-}
-
-function spawnBgPlan(): SpawnBgPlan {
-	return {
-		transport: "spawn-bg",
-		action: "resume",
-		targetGardenId: GID,
-		sessionId: GID,
-		cwd: "/home/test/repo",
-		prompt: "continue",
-		wantsReply: false,
-		launchArgs: ["--approve"],
-		expectedSocketPath: SOCK,
-		observeTimeoutMs: 30_000,
-		releaseWhen: "socket-alive-or-child-exited",
-	};
-}
-
-interface Deferred<T> {
-	promise: Promise<T>;
-	resolve: (v: T) => void;
-	reject: (e: unknown) => void;
-}
-function deferred<T>(): Deferred<T> {
-	let resolve!: (v: T) => void;
-	let reject!: (e: unknown) => void;
-	const promise = new Promise<T>((res, rej) => {
-		resolve = res;
-		reject = rej;
-	});
-	return { promise, resolve, reject };
-}
-
-const flush = (): Promise<void> => new Promise((res) => setImmediate(res));
-
-interface Calls {
-	spawn: number;
-	socket: number;
-	exit: number;
-	timeout: number;
-	kill: number;
-	release: number;
-}
-
-interface Harness {
-	deps: SpawnBgResumeDeps;
-	calls: Calls;
-	socket: Deferred<void>;
-	exit: Deferred<number | null>;
-	observe: Deferred<void>; // 1st awaitTimeout call (observeTimeoutMs)
-	grace: Deferred<void>; // 2nd awaitTimeout call (killGraceMs)
-}
-
-interface HarnessOpts {
-	spawnThrows?: string;
-	killThrows?: boolean;
-	releaseThrows?: boolean;
-	socketSyncThrows?: string; // awaitSocketAlive throws SYNCHRONOUSLY (buggy dep)
-	exitSyncThrows?: string; // awaitChildExit throws SYNCHRONOUSLY (buggy dep)
-	child?: SpawnedChild;
-}
-
-function makeHarness(opts: HarnessOpts = {}): Harness {
-	const calls: Calls = { spawn: 0, socket: 0, exit: 0, timeout: 0, kill: 0, release: 0 };
-	const socket = deferred<void>();
-	const exit = deferred<number | null>();
-	const observe = deferred<void>();
-	const grace = deferred<void>();
-	const child: SpawnedChild = opts.child ?? { pid: 9191 };
-
-	const deps: SpawnBgResumeDeps = {
-		spawnChild: async () => {
-			calls.spawn++;
-			if (opts.spawnThrows) throw new Error(opts.spawnThrows);
-			return child;
-		},
-		awaitSocketAlive: (_socketPath, _signal) => {
-			calls.socket++;
-			if (opts.socketSyncThrows) throw new Error(opts.socketSyncThrows);
-			return socket.promise;
-		},
-		awaitChildExit: (_c, _signal) => {
-			calls.exit++;
-			if (opts.exitSyncThrows) throw new Error(opts.exitSyncThrows);
-			return exit.promise;
-		},
-		awaitTimeout: (_ms, _signal) => {
-			calls.timeout++;
-			return calls.timeout === 1 ? observe.promise : grace.promise;
-		},
-		killChild: (_c) => {
-			calls.kill++;
-			if (opts.killThrows) throw new Error("kill failed");
-		},
-		releaseLock: (_lock) => {
-			calls.release++;
-			if (opts.releaseThrows) throw new Error("release failed");
-		},
-		killGraceMs: 5_000,
-	};
-	return { deps, calls, socket, exit, observe, grace };
-}
-
-async function main(): Promise<void> {
-	// ── 1. spawnChild throws → spawn-start-failed, release ×1, error surfaced ────────
-	{
-		const h = makeHarness({ spawnThrows: "ENOENT pi binary" });
-		const r = await executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		ok("1 spawn-start-failed kind", r.kind === "spawn-start-failed");
-		ok("1 released true", r.released === true);
-		ok("1 error surfaced", r.kind === "spawn-start-failed" && r.error.includes("ENOENT pi binary"));
-		ok("1 release ×1", h.calls.release === 1);
-		ok("1 no socket/exit/timeout watch", h.calls.socket === 0 && h.calls.exit === 0 && h.calls.timeout === 0);
-		ok("1 no kill", h.calls.kill === 0);
-	}
-
-	// ── 2. socket-alive wins → socket-alive, release ×1, no kill; exit loser no-op ───
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.socket.resolve();
-		await flush();
-		// the exit loser settles AFTER the win — must not double release.
-		h.exit.resolve(0);
-		const r = await p;
-		ok("2 socket-alive kind", r.kind === "socket-alive");
-		ok("2 released true", r.released === true);
-		ok("2 pid surfaced", r.kind === "socket-alive" && r.pid === 9191);
-		ok("2 release exactly once", h.calls.release === 1);
-		ok("2 no kill (no timeout)", h.calls.kill === 0);
-	}
-
-	// ── 3. child-exited wins (code 0 / 1 / null) → child-exited, release ×1, no kill ──
-	for (const code of [0, 1, null] as const) {
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.exit.resolve(code);
-		await flush();
-		h.socket.resolve(); // loser
-		const r = await p;
-		ok(`3 child-exited kind (code=${code})`, r.kind === "child-exited");
-		ok(`3 exitCode=${code}`, r.kind === "child-exited" && r.exitCode === code);
-		ok(`3 release exactly once (code=${code})`, h.calls.release === 1);
-		ok(`3 no kill (code=${code})`, h.calls.kill === 0);
-	}
-
-	// ── 4. timeout wins → release 0 at kill time, killChild ×1 (bare timeout ≠ release) ─
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.observe.resolve(); // observe timeout fires first
-		await flush();
-		// At this point the hand has killed and is awaiting the grace observation.
-		ok("4 release 0 after bare timeout", h.calls.release === 0);
-		ok("4 killChild ×1 on timeout", h.calls.kill === 1);
-		// drain: let the kill produce an exit so the promise settles.
-		h.exit.resolve(null);
-		const r = await p;
-		ok("4 settles as child-exited after kill", r.kind === "child-exited");
-	}
-
-	// ── 5. timeout → kill → child-exited(null) in grace → child-exited, release ×1 ───
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.observe.resolve();
-		await flush();
-		h.exit.resolve(null); // the kill's exit observed within grace
-		const r = await p;
-		ok("5 child-exited after kill", r.kind === "child-exited");
-		ok("5 exitCode null (signal)", r.kind === "child-exited" && r.exitCode === null);
-		ok("5 release exactly once", h.calls.release === 1);
-		ok("5 kill ×1", h.calls.kill === 1);
-	}
-
-	// ── 6. timeout → kill → socket-alive in grace → socket-alive, release ×1 ─────────
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.observe.resolve();
-		await flush();
-		h.socket.resolve(); // child raced its socket up just as we killed
-		const r = await p;
-		ok("6 socket-alive after kill", r.kind === "socket-alive");
-		ok("6 release exactly once", h.calls.release === 1);
-	}
-
-	// ── 7. timeout → kill → grace elapses, no observation → lock-retained, release 0 ──
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.observe.resolve();
-		await flush();
-		h.grace.resolve(); // grace elapses with no socket/exit
-		const r = await p;
-		ok("7 lock-retained kind", r.kind === "lock-retained");
-		ok("7 released false", r.released === false);
-		ok("7 reason kill-unconfirmed", r.kind === "lock-retained" && r.reason === "kill-unconfirmed");
-		ok("7 release NEVER (no blind release)", h.calls.release === 0);
-		const diag = r.kind === "lock-retained" ? r.diagnostic : null;
-		ok("7 diagnostic targetGardenId", diag?.targetGardenId === GID);
-		ok("7 diagnostic socketPath", diag?.expectedSocketPath === SOCK);
-		ok("7 diagnostic lockPath", diag?.lockPath === LOCKPATH);
-		ok("7 diagnostic pid", diag?.pid === 9191);
-		ok("7 diagnostic observeTimeoutMs", diag?.observeTimeoutMs === 30_000);
-		ok("7 diagnostic killGraceMs", diag?.killGraceMs === 5_000);
-	}
-
-	// ── 8. post-spawn dep throw (awaitChildExit rejects) → kill, no exit → retained ──
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		// the exit watcher itself fails — its rejection both triggers the backstop AND means
-		// the exit can never be observed → fail-closed to lock-retained.
-		h.exit.reject(new Error("exit watcher EBADF"));
-		const r = await p;
-		ok("8 lock-retained kind", r.kind === "lock-retained");
-		ok("8 reason observe-failed", r.kind === "lock-retained" && r.reason === "observe-failed");
-		ok("8 original error surfaced", r.kind === "lock-retained" && (r.error ?? "").includes("exit watcher EBADF"));
-		ok("8 best-effort kill called", h.calls.kill === 1);
-		ok("8 release NEVER", h.calls.release === 0);
-	}
-
-	// ── 9. post-spawn dep throw (awaitSocketAlive rejects) → kill → exit in grace ────
-	{
-		const h = makeHarness();
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.socket.reject(new Error("socket watcher EACCES")); // primary race rejects → backstop
-		await flush();
-		// the exit watcher is healthy → the kill's exit is observed within grace.
-		h.exit.resolve(137);
-		const r = await p;
-		ok("9 child-exited after backstop kill", r.kind === "child-exited");
-		ok("9 exitCode 137", r.kind === "child-exited" && r.exitCode === 137);
-		ok("9 release exactly once", h.calls.release === 1);
-		ok("9 kill ×1", h.calls.kill === 1);
-	}
-
-	// ── 10. releaseLock throw on a released path PROPAGATES (caller must not re-spawn) ─
-	{
-		const h = makeHarness({ releaseThrows: true });
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.socket.resolve();
-		let threw: unknown;
-		try {
-			await p;
-		} catch (e) {
-			threw = e;
-		}
-		ok("10 release error propagates", threw instanceof Error && threw.message === "release failed");
-		ok("10 release was attempted once", h.calls.release === 1);
-	}
-
-	// ── 11. lock invariants → decideReleasePolicy throws BEFORE any spawn ────────────
-	{
-		const h = makeHarness();
-		let threw = false;
-		try {
-			await executeSpawnBgResume(spawnBgPlan(), null, h.deps);
-		} catch {
-			threw = true;
-		}
-		ok("11 null lock throws", threw);
-		ok("11 null lock: no spawn attempted", h.calls.spawn === 0);
-
-		const h2 = makeHarness();
-		let threw2 = false;
-		try {
-			await executeSpawnBgResume(spawnBgPlan(), lockClaim(WRONG_GID), h2.deps);
-		} catch {
-			threw2 = true;
-		}
-		ok("11 mismatched-gid lock throws", threw2);
-		ok("11 mismatched-gid: no spawn attempted", h2.calls.spawn === 0);
-	}
-
-	// ── 12. kill grace where kill itself throws but exit still observed → released ───
-	// (proves killChild throwing is best-effort: the observation still drives release.)
-	{
-		const h = makeHarness({ killThrows: true });
-		const p = executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		await flush();
-		h.observe.resolve();
-		await flush();
-		h.exit.resolve(0); // exit observed despite the kill throw
-		const r = await p;
-		ok("12 child-exited despite kill throw", r.kind === "child-exited");
-		ok("12 release exactly once", h.calls.release === 1);
-		ok("12 kill attempted once", h.calls.kill === 1);
-	}
-
-	// ── 13. S1 (Fable 2차): awaitSocketAlive throws SYNCHRONOUSLY at creation (a buggy dep
-	//        that throws where it must return a Promise). The child exists → no blind release;
-	//        best-effort kill + lock-retained fail-closed. The async race (cases 8/9) never
-	//        runs, so this would be a silent leak without the dedicated creation try. ────────
-	{
-		const h = makeHarness({ socketSyncThrows: "awaitSocketAlive EFAULT (sync)" });
-		const r = await executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		ok("13 lock-retained on sync socket throw", r.kind === "lock-retained");
-		ok("13 reason observe-failed", r.kind === "lock-retained" && r.reason === "observe-failed");
-		ok("13 sync error surfaced", r.kind === "lock-retained" && (r.error ?? "").includes("awaitSocketAlive EFAULT"));
-		ok("13 best-effort kill ×1", h.calls.kill === 1);
-		ok("13 release NEVER (no blind release)", h.calls.release === 0);
-		ok("13 diagnostic lockPath surfaced", r.kind === "lock-retained" && r.diagnostic.lockPath === LOCKPATH);
-	}
-
-	// ── 14. S1 sibling: awaitChildExit throws SYNCHRONOUSLY at creation (socket watcher DID
-	//        start, then exit creation throws). Same fail-closed retained; the started socket
-	//        watcher is defused so it cannot surface as an unhandled rejection. ──────────────
-	{
-		const h = makeHarness({ exitSyncThrows: "awaitChildExit EFAULT (sync)" });
-		const r = await executeSpawnBgResume(spawnBgPlan(), lockClaim(), h.deps);
-		ok("14 lock-retained on sync exit throw", r.kind === "lock-retained");
-		ok("14 reason observe-failed", r.kind === "lock-retained" && r.reason === "observe-failed");
-		ok("14 best-effort kill ×1", h.calls.kill === 1);
-		ok("14 release NEVER", h.calls.release === 0);
-		ok("14 socket watcher had started", h.calls.socket === 1);
-	}
-
-	console.log(`\ncheck-entwurf-v2-spawn: ${passed} checks passed`);
-}
-
-main().catch((err) => {
-	console.error(err);
-	process.exit(1);
-});

package/scripts/smoke-entwurf-v2-spawn-live.ts

@@ -1,188 +0,0 @@
-/**
- * smoke-entwurf-v2-spawn-live — the 5c-3c LIVE phase gate (D5). Unlike the deterministic
- * gate (check-entwurf-v2-spawn-production, fakes only), this exercises the production
- * SpawnBgResumeDeps against REAL OS objects — a real unix socket, real child processes, real
- * timers, real abort teardown — to catch what fakes cannot: actual spawn/exit/error event
- * semantics, real lstat+connect liveness, real timer/abort cleanup, and the 5c-3a watcher's
- * timeout→kill→child-exited→release integration on a live process.
- *
- * It does NOT spawn a real `pi --entwurf-control` resume (that needs a saved session, model
- * auth, and backend state — flaky); proving the argv actually launches pi end-to-end is the
- * 5d surface matrix's job. `buildResumePiArgs` is already pinned by the deterministic gate.
- *
- * Kept OUT of `pnpm check` (it spawns processes / opens sockets); run it manually before 5d:
- *   LIVE=1 ./run.sh smoke-entwurf-v2-spawn-live
- * and record the result in NEXT.md / the commit body (chain-outside, phase-gate-inside).
- */
-
-import { type ChildProcess, spawn } from "node:child_process";
-import * as fsp from "node:fs/promises";
-import * as net from "node:net";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { LockClaim } from "../pi-extensions/lib/entwurf-v2-lock.ts";
-import { executeSpawnBgResume, type SpawnBgPlan } from "../pi-extensions/lib/entwurf-v2-spawn.ts";
-import { makeProductionSpawnBgResumeDeps } from "../pi-extensions/lib/entwurf-v2-spawn-production.ts";
-
-let passed = 0;
-function ok(label: string, cond: boolean): void {
-	if (!cond) throw new Error(`SMOKE FAIL: ${label}`);
-	console.log(`  ok    ${label}`);
-	passed++;
-}
-
-// A resident child that survives until SIGTERM, then exits 0 — a stand-in for a pi child
-// (we are proving the OS-level lifecycle wiring, not pi's resume behavior).
-const RESIDENT_CHILD = "process.on('SIGTERM',()=>process.exit(0)); setInterval(()=>{},1e9);";
-
-function lockClaim(gardenId: string): LockClaim {
-	return {
-		gardenId,
-		pid: process.pid,
-		hostname: os.hostname(),
-		createdAt: new Date(0).toISOString(),
-		nonce: "live5c3csmoke00",
-		owner: "entwurf_v2",
-		lockPath: `/tmp/${gardenId}.lock`,
-	};
-}
-
-function spawnBgPlan(over: Partial<SpawnBgPlan> = {}): SpawnBgPlan {
-	const gid = "20260613T000000-aaaaaa";
-	return {
-		transport: "spawn-bg",
-		action: "resume",
-		targetGardenId: gid,
-		sessionId: gid,
-		cwd: process.cwd(),
-		prompt: "continue",
-		wantsReply: false,
-		launchArgs: [],
-		expectedSocketPath: "/nonexistent/never.sock",
-		observeTimeoutMs: 30_000,
-		releaseWhen: "socket-alive-or-child-exited",
-		...over,
-	};
-}
-
-async function main(): Promise<void> {
-	const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "v2spawn-"));
-	const children: ChildProcess[] = [];
-	let server: net.Server | null = null;
-
-	try {
-		// ── S1: real unix-socket connectability (real fs.lstat + real probeSocketLiveness) ─
-		{
-			const sockPath = path.join(tmp, "live.sock");
-			server = net.createServer();
-			await new Promise<void>((resolve) => server?.listen(sockPath, resolve));
-			const deps = makeProductionSpawnBgResumeDeps({ pollIntervalMs: 20 });
-			await deps.awaitSocketAlive(sockPath, new AbortController().signal);
-			ok("S1 a real listening unix socket → awaitSocketAlive resolves (connectable)", true);
-
-			// symlink at the path → forged (real lstat catches it; never connected — P1).
-			const symPath = path.join(tmp, "sym.sock");
-			await fsp.symlink(sockPath, symPath);
-			let forged = false;
-			try {
-				await deps.awaitSocketAlive(symPath, new AbortController().signal);
-			} catch (e) {
-				forged = e instanceof Error && e.message.includes("forged");
-			}
-			ok("S1 a symlink at the socket path → forged reject (real lstat P1)", forged);
-
-			// absent path → dead → wait; abort settles it (real timer + abort cleanup).
-			const ctrl = new AbortController();
-			const absentP = deps.awaitSocketAlive(path.join(tmp, "absent.sock"), ctrl.signal);
-			setTimeout(() => ctrl.abort(), 60);
-			let aborted = false;
-			try {
-				await absentP;
-			} catch {
-				aborted = true;
-			}
-			ok("S1 an absent socket → waits, then abort settles it (no hang)", aborted);
-
-			await new Promise<void>((resolve) => server?.close(() => resolve()));
-			server = null;
-		}
-
-		// ── S2: real child lifecycle — spawn event, exit capture, SIGTERM kill ───────────
-		{
-			const deps = makeProductionSpawnBgResumeDeps({
-				resolveIdentity: () => ({
-					sessionFile: path.join(tmp, "smoke-session.jsonl"),
-					cwd: tmp,
-					explicitExtensionArgs: [],
-					provider: null,
-					model: "smoke",
-				}),
-				spawnChild: () => {
-					const proc = spawn(process.execPath, ["-e", RESIDENT_CHILD], { stdio: "ignore" });
-					children.push(proc);
-					return proc;
-				},
-			});
-			// spawnChild awaits the REAL 'spawn' event before resolving (B1).
-			const child = await deps.spawnChild(spawnBgPlan());
-			ok("S2 spawnChild resolves on the real 'spawn' event (B1)", typeof child.pid === "number" && child.pid > 0);
-
-			// SIGTERM → the resident child terminates; awaitChildExit OBSERVES the exit via the
-			// eager exitPromise (B2). The code is 0 if the child's SIGTERM handler ran, or null if
-			// the signal landed before the handler was installed — both are a real, observed exit
-			// (the watcher releases on child-exited for ANY code), which is what this proves.
-			deps.killChild(child);
-			const code = await deps.awaitChildExit(child, new AbortController().signal);
-			ok("S2 killChild(SIGTERM) → awaitChildExit observes the exit (code 0 or null)", code === 0 || code === null);
-		}
-
-		// ── S3: watcher integration — real timeout → kill → child-exited → release ───────
-		{
-			let releases = 0;
-			const deps = makeProductionSpawnBgResumeDeps({
-				resolveIdentity: () => ({
-					sessionFile: path.join(tmp, "smoke-session.jsonl"),
-					cwd: tmp,
-					explicitExtensionArgs: [],
-					provider: null,
-					model: "smoke",
-				}),
-				spawnChild: () => {
-					const proc = spawn(process.execPath, ["-e", RESIDENT_CHILD], { stdio: "ignore" });
-					children.push(proc);
-					return proc;
-				},
-				releaseFn: () => {
-					releases++;
-				},
-				pollIntervalMs: 20,
-				killGraceMs: 2_000,
-			});
-			// A child that never stands a socket up + a short observe window → the watcher must
-			// time out, NOT release on the timeout, kill, observe the real exit, then release once.
-			const plan = spawnBgPlan({ observeTimeoutMs: 80, expectedSocketPath: path.join(tmp, "never-appears.sock") });
-			const result = await executeSpawnBgResume(plan, lockClaim(plan.sessionId), deps);
-			ok("S3 timeout→kill→child-exited (real timer + real child + 5c-3a watcher)", result.kind === "child-exited");
-			ok("S3 lock released exactly once on the observed exit", result.released === true && releases === 1);
-		}
-
-		console.log(`\nsmoke-entwurf-v2-spawn-live: ${passed} checks passed (real OS primitives)`);
-	} finally {
-		for (const c of children) {
-			try {
-				c.kill("SIGKILL");
-			} catch {
-				// best-effort
-			}
-		}
-		if (server) {
-			await new Promise<void>((resolve) => server?.close(() => resolve()));
-		}
-		await fsp.rm(tmp, { recursive: true, force: true });
-	}
-}
-
-main().catch((err) => {
-	console.error(err);
-	process.exit(1);
-});