@junghanacs/entwurf 0.17.2 → 0.18.1

package/scripts/smoke-entwurf-chain-live.ts

@@ -54,7 +54,15 @@ import fsp from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { readMetaInbox, upsertMetaSession, writeMetaReceiverMarker } from "../pi-extensions/lib/meta-session.ts";
+import { resolveMailboxReceiverFacts } from "../pi-extensions/lib/entwurf-deliverability.ts";
+import {
+	readMetaInbox,
+	readMetaReceiverMarker,
+	readMetaSenderMarker,
+	upsertMetaSession,
+	writeMetaReceiverMarker,
+	writeMetaSenderMarker,
+} from "../pi-extensions/lib/meta-session.ts";
 import { terminateChild } from "./lib/acp-child-cleanup.ts";
 import { skipLive } from "./lib/live-skip.ts";
 
@@ -155,11 +163,13 @@ async function main(): Promise<void> {
 	const sessionsDir = path.join(world, "sessions");
 	const mailboxDir = path.join(world, "mailbox");
 	const receiversDir = path.join(world, "receivers");
-	for (const d of [sessionsDir, mailboxDir, receiversDir]) await fsp.mkdir(d, { recursive: true });
+	const sendersDir = path.join(world, "senders");
+	for (const d of [sessionsDir, mailboxDir, receiversDir, sendersDir]) await fsp.mkdir(d, { recursive: true });
 	const worldEnv = {
 		ENTWURF_META_SESSIONS_DIR: sessionsDir,
 		ENTWURF_META_MAILBOX_DIR: mailboxDir,
 		ENTWURF_META_RECEIVERS_DIR: receiversDir,
+		ENTWURF_META_SENDERS_DIR: sendersDir,
 	};
 	// The MCP bridge prefers PI_SESSION_ID+PI_AGENT_ID over a meta-sender marker when both
 	// are present. A runner that is itself a pi --entwurf-control session (release-gate,
@@ -183,20 +193,46 @@ async function main(): Promise<void> {
 		dir: sessionsDir,
 	});
 	const gidD = terminus.record.gardenId;
-	writeMetaReceiverMarker({
-		gardenId: gidD,
-		backend: "claude-code",
-		nativeSessionId: terminus.record.nativeSessionId,
-		ownerPid: process.pid,
-		armProvenance: "session-start",
-		receiversDir,
-	});
-	console.error(`[smoke-entwurf-chain-live] D:      ${gidD} (mailbox terminus)`);
-
 	const children: ChildProcess[] = [];
+	let terminusOwner: ChildProcess | null = null;
 	let streamB = "";
 	let streamC = "";
 	try {
+		// The receiver marker alone is no longer the whole fixture (#101): a `claude-code-cli` watch
+		// owner is deliverable only while ITS OWN sender marker still names the garden it is armed
+		// for — that join is what refuses a session which switched away in place. A receiver marker
+		// with no sender marker beside it models a state the product now treats as retired, so this
+		// smoke would fail on its own fixture instead of on the rail it exists to prove.
+		//
+		// THE OWNER IS A SPAWNED IDLE PROCESS, NOT THIS ONE, and that is specific to this smoke:
+		// hop 1 is a native `claude` child of THIS process, and the bridge resolves a sender's
+		// identity through its ancestry. A terminus marker under this pid therefore puts TWO garden
+		// citizens on one host process, which the bridge refuses outright as ambiguous sender
+		// identity — measured on oracle 2026-09-04, where hop 1 came back "refused: ambiguous sender
+		// identity (…-f34713, …-912b42)" and the chain never started. The sibling smokes keep
+		// `process.pid` because their children are pi/ACP sessions carrying their own identity, or
+		// tmux siblings that are not descendants at all.
+		terminusOwner = spawn(process.execPath, ["-e", "setTimeout(() => {}, 900000)"], { stdio: "ignore" });
+		const terminusOwnerPid = terminusOwner.pid;
+		if (typeof terminusOwnerPid !== "number") throw new Error("could not spawn the terminus owner process");
+		writeMetaReceiverMarker({
+			gardenId: gidD,
+			backend: "claude-code",
+			nativeSessionId: terminus.record.nativeSessionId,
+			ownerPid: terminusOwnerPid,
+			armProvenance: "session-start",
+			receiversDir,
+		});
+		writeMetaSenderMarker({
+			backend: "claude-code",
+			gardenId: gidD,
+			nativeSessionId: terminus.record.nativeSessionId,
+			cwd: world,
+			ownerPid: terminusOwnerPid,
+			sendersDir,
+		});
+		console.error(`[smoke-entwurf-chain-live] D:      ${gidD} (mailbox terminus)`);
+
 		// ── C: the ACP Claude Sonnet citizen (spawned first so B can be told its id) ──
 		const known = new Set((await readRecords(sessionsDir)).map((r) => r.gardenId));
 		const c = spawn(
@@ -283,6 +319,21 @@ async function main(): Promise<void> {
 		ok("A is distinct from every other citizen", !new Set([gidB, gidC, gidD]).has(gidA as string));
 		console.error(`[smoke-entwurf-chain-live] A:      ${gidA} (native Claude Code)`);
 
+		// ── the fixture must still be a deliverable citizen when the chain arrives ──
+		// The terminus is only reachable while its owner is alive AND that owner's sender marker
+		// still names it (#101). Both are fixture state this smoke owns, and both can decay while
+		// three model turns run. Asserting it here separates "the chain did not arrive" from "the
+		// target stopped being addressable", which cost a LIVE run to tell apart once.
+		const terminusFacts = resolveMailboxReceiverFacts(terminus.record, {
+			readReceiverMarker: (gardenId: string) => readMetaReceiverMarker({ gardenId, receiversDir }),
+			readSenderMarker: (backend: string, pid: number) =>
+				readMetaSenderMarker({ backend: backend as "claude-code", ownerPid: pid, sendersDir }),
+		});
+		ok(
+			"fixture: the terminus is a deliverable citizen at the moment the chain starts",
+			terminusFacts.ownerAlive && terminusFacts.watchArmed,
+		);
+
 		// ── the chain runs on its own from here; wait for the terminus ───────────
 		const boxDir = path.join(mailboxDir, gidD);
 		const until = Date.now() + CHAIN_TIMEOUT_MS;
@@ -295,7 +346,25 @@ async function main(): Promise<void> {
 			await sleep(POLL_MS);
 		}
 		if (msgs.length === 0) {
-			console.error(`[smoke-entwurf-chain-live] A turn output:\n${claudeOut.slice(0, 1500)}`);
+			let ownerAlive = false;
+			try {
+				process.kill(terminusOwnerPid, 0);
+				ownerAlive = true;
+			} catch {}
+			const facts = resolveMailboxReceiverFacts(terminus.record, {
+				readReceiverMarker: (gardenId: string) => readMetaReceiverMarker({ gardenId, receiversDir }),
+				readSenderMarker: (backend: string, pid: number) =>
+					readMetaSenderMarker({ backend: backend as "claude-code", ownerPid: pid, sendersDir }),
+			});
+			console.error(
+				`[smoke-entwurf-chain-live] terminus fixture at timeout: ownerPid=${terminusOwnerPid} alive=${ownerAlive} ` +
+					`ownerAlive=${facts.ownerAlive} watchArmed=${facts.watchArmed}`,
+			);
+			// The FULL turn, not a 1500-char head: that slice cut the JSON before its `result`
+			// field, so the one line that says what A actually did — the tool outcome it was told
+			// to echo back — was the first thing this diagnostic dropped. A failure that hides its
+			// own cause costs another LIVE run to re-learn.
+			console.error(`[smoke-entwurf-chain-live] A turn output:\n${claudeOut}`);
 			console.error(`[smoke-entwurf-chain-live] B stream tail:\n${streamB.slice(-2000)}`);
 			console.error(`[smoke-entwurf-chain-live] C stream tail:\n${streamC.slice(-2000)}`);
 		}
@@ -350,6 +419,9 @@ async function main(): Promise<void> {
 		console.error(`[smoke-entwurf-chain-live] chain: ${gidA} → ${gidB} → ${gidC} → ${gidD}`);
 	} finally {
 		for (const ch of children) await terminateChild(ch).catch(() => undefined);
+		try {
+			terminusOwner?.kill("SIGTERM");
+		} catch {}
 	}
 
 	console.log(

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

@@ -62,6 +62,7 @@ import {
 	metaRecordExistsByGardenId,
 	upsertMetaSession,
 	writeMetaReceiverMarker,
+	writeMetaSenderMarker,
 } from "../pi-extensions/lib/meta-session.ts";
 import { terminateChild } from "./lib/acp-child-cleanup.ts";
 import { skipLive } from "./lib/live-skip.ts";
@@ -187,10 +188,15 @@ async function main(): Promise<void> {
 	const mailboxDir = path.join(tmp, "mailbox");
 	const lockDir = path.join(tmp, "locks");
 	const receiversDir = path.join(tmp, "receivers");
-	for (const d of [sessionsDir, mailboxDir, lockDir, receiversDir]) await fsp.mkdir(d, { recursive: true });
+	const sendersDir = path.join(tmp, "senders");
+	for (const d of [sessionsDir, mailboxDir, lockDir, receiversDir, sendersDir]) await fsp.mkdir(d, { recursive: true });
 	// The receiver marker is read through defaultMetaReceiversDir() (env-overridable); point it
 	// (and the store/mailbox defaults, belt-and-suspenders to the opts dirs) at the temp world.
+	// The SENDER dir joins that list for #101: deliverability now also reads the receiver owner's
+	// sender marker, and leaving this one pointed at the operator's real root would have the
+	// fixture judged against markers this smoke never wrote.
 	process.env.ENTWURF_META_RECEIVERS_DIR = receiversDir;
+	process.env.ENTWURF_META_SENDERS_DIR = sendersDir;
 	process.env.ENTWURF_META_SESSIONS_DIR = sessionsDir;
 	process.env.ENTWURF_META_MAILBOX_DIR = mailboxDir;
 
@@ -341,6 +347,14 @@ async function main(): Promise<void> {
 			const gid = minted.record.gardenId;
 			artifacts["C2.gid"] = gid;
 			// armed = a presence marker owned by THIS (live) process → deliverable.
+			//
+			// The receiver marker alone is no longer the whole fixture (#101): a `claude-code-cli`
+			// watch owner is deliverable only while ITS OWN sender marker still names the garden it
+			// is armed for — that join is what refuses a session which switched away in place. A
+			// receiver marker with no sender marker beside it models a state the product now treats
+			// as retired, so this smoke would fail on its own fixture instead of on the rail it
+			// exists to prove. Same shape as smoke-mux-lifecycle-live / smoke-omp-fresh-live, which
+			// already seeded both.
 			writeMetaReceiverMarker({
 				gardenId: gid,
 				backend: "claude-code",
@@ -349,6 +363,14 @@ async function main(): Promise<void> {
 				armProvenance: "session-start",
 				receiversDir,
 			});
+			writeMetaSenderMarker({
+				backend: "claude-code",
+				gardenId: gid,
+				nativeSessionId: minted.record.nativeSessionId,
+				cwd: tmp,
+				ownerPid: process.pid,
+				sendersDir,
+			});
 
 			const result: EntwurfV2RunResult = await runEntwurfV2(
 				{ target: gid, intent: "fire-and-forget", message: "matrix-live C2 meta-mailbox probe" },

package/scripts/smoke-mux-fresh-call-live.ts

@@ -194,7 +194,10 @@ async function main(): Promise<void> {
 		const callerGid = caller.record.gardenId;
 		// A record proves identity; only an ARMED receiver marker makes the mailbox deliverable —
 		// without it the callbacks would be refused as mailbox-undeliverable and this smoke would
-		// measure nothing.
+		// measure nothing. Since #101 the marker is half of that: a `claude-code-cli` watch owner
+		// is deliverable only while ITS OWN sender marker still names the garden it is armed for,
+		// which is what refuses a session that switched away in place. Both, or the fixture models
+		// a retired watch — the same shape smoke-mux-lifecycle-live already seeds.
 		meta.writeMetaReceiverMarker({
 			gardenId: callerGid,
 			backend: "claude-code",
@@ -202,9 +205,16 @@ async function main(): Promise<void> {
 			ownerPid: process.pid,
 			armProvenance: "session-start",
 		});
+		const callerSenderMarker = meta.writeMetaSenderMarker({
+			backend: "claude-code",
+			gardenId: callerGid,
+			nativeSessionId,
+			cwd: scratch,
+			ownerPid: process.pid,
+		});
 		ok(
-			"fixture: the caller citizen was minted INSIDE the fixture store and its mailbox is armed",
-			Boolean(callerGid) && caller.path.startsWith(root),
+			"fixture: the caller citizen was minted INSIDE the fixture store, with an armed mailbox and a sender marker",
+			Boolean(callerGid) && caller.path.startsWith(root) && callerSenderMarker.startsWith(root),
 		);
 
 		// ── One private tmux server per backend ──────────────────────────────────