@junghanacs/entwurf 0.17.2 → 0.18.1

package/scripts/check-entwurf-self-address.ts

@@ -469,8 +469,26 @@ const metaBody = functionBody("buildTrustedMetaSenderEnvelope");
 ok("buildTrustedMetaSenderEnvelope calls computeSelfAddressability", /computeSelfAddressability\s*\(/.test(metaBody));
 ok("buildTrustedMetaSenderEnvelope no longer hardcodes `replyable: true`", !/replyable:\s*true/.test(metaBody));
 ok(
-	"buildTrustedMetaSenderEnvelope derives active-receiver from the receiver marker (identity-matched)",
-	/readMetaReceiverMarker\s*\(/.test(metaBody) && /receiverMarkerMatchesIdentity\s*\(/.test(metaBody),
+	// #101: the identity match alone is no longer the whole answer. `entwurf_self` composes
+	// the SAME `resolveMailboxReceiverFacts` the v2 dispatch seam uses — reading the receiver
+	// marker AND, where the watch owner is the sender-marker process, the join that says that
+	// owner is still serving this garden. A citizen's self-reported replyability and what
+	// dispatch decides about it come from one measurement, so they cannot disagree.
+	"buildTrustedMetaSenderEnvelope derives active-receiver from the SHARED receiver composition (both markers)",
+	/resolveMailboxReceiverFacts\s*\(/.test(metaBody) &&
+		/readMetaReceiverMarker\s*\(/.test(metaBody) &&
+		/readMetaSenderMarker\s*\(/.test(metaBody),
+);
+ok(
+	"buildTrustedMetaSenderEnvelope no longer copies one match into both receiver facts",
+	!/ownerAlive:\s*active/.test(metaBody) && !/watchArmed:\s*active/.test(metaBody),
+);
+ok(
+	// #101 (cross-review): both markers are read with their liveness guards ON. A reader that
+	// opted out would accept a dead session's leftover file as "which garden this pid serves
+	// now", and every fixture pid in a gate is live, so nothing dynamic here could tell.
+	"buildTrustedMetaSenderEnvelope reads neither marker with the owner guard disabled",
+	!/verifyOwner:\s*false/.test(metaBody),
 );
 ok(
 	"buildTrustedMetaSenderEnvelope keeps meta identity + derived replyable (inactive → not null)",

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

@@ -207,11 +207,13 @@ async function main(): Promise<void> {
 		ok("target-locked: diagnostic carried", d.kind === "reject" && d.diagnostic?.kind === "target-locked");
 		ok(
 			"target-locked: diagnostic holder pid preserved",
-			d.kind === "reject" && d.diagnostic?.conflict.holder?.pid === 4242,
+			d.kind === "reject" && d.diagnostic?.kind === "target-locked" && d.diagnostic.conflict.holder?.pid === 4242,
 		);
 		ok(
 			"target-locked: diagnostic lockPath preserved",
-			d.kind === "reject" && d.diagnostic?.conflict.lockPath === `/fake/locks/${GID}.lock`,
+			d.kind === "reject" &&
+				d.diagnostic?.kind === "target-locked" &&
+				d.diagnostic.conflict.lockPath === `/fake/locks/${GID}.lock`,
 		);
 	}
 
@@ -253,7 +255,8 @@ async function main(): Promise<void> {
 		ok(
 			"target-locked(corrupt): diagnostic detail preserved",
 			d.kind === "reject" &&
-				d.diagnostic?.conflict.detail === "lockfile is empty, corrupt, or holds a different garden id",
+				d.diagnostic?.kind === "target-locked" &&
+				d.diagnostic.conflict.detail === "lockfile is empty, corrupt, or holds a different garden id",
 		);
 	}
 

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

@@ -42,6 +42,7 @@ import {
 	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";
@@ -156,7 +157,10 @@ type LockClass = "none" | "held" | "mailbox-null" | "released" | "acquire-fail";
 
 type Expect =
 	| { decision: "execute"; transport: EntwurfV2Transport; lock: LockClass }
-	| { decision: "reject"; reason: string; lock: LockClass; diagnostic?: boolean };
+	// `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 "어느 축을 만지면 안 되는지"
@@ -211,7 +215,7 @@ const ROWS: Row[] = [
 		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: true },
+		expect: { decision: "reject", reason: "target-locked", lock: "acquire-fail", diagnostic: "target-locked" },
 	},
 	{
 		name: "unsupported self-fetch active → meta-mailbox",
@@ -231,7 +235,8 @@ const ROWS: Row[] = [
 			resolution: { identity: identity("claude-code"), preProbeAddressConflict: false },
 			mailboxDeliverable: false,
 		},
-		expect: { decision: "reject", reason: "mailbox-undeliverable", lock: "none" },
+		// #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",
@@ -338,8 +343,8 @@ async function runRow(row: Row): Promise<void> {
 		}
 		if (row.expect.diagnostic) {
 			ok(
-				`${row.name}: carries target-locked diagnostic`,
-				d.kind === "reject" && d.diagnostic?.kind === "target-locked",
+				`${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);

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

@@ -13,6 +13,9 @@
  *   E. Q3 + Q5 — a dead control send re-resolves (claude-code citizen) to the mailbox and
  *      enqueues through the SAME sendViaMailbox instance (same enqueue spy) on the SAME dirs
  *      the direct hand used — direct send and fallback send never drift.
+ *   E4. #101 — the deliverability seam reads BOTH markers: a live receiver marker whose
+ *      owner's sender marker names ANOTHER garden is undeliverable. The SAME closure serves
+ *      the direct send and the dead-control fallback, so neither can be fooled alone.
  *
  * No real IO — every seam is a spy; the factory's COMPOSITION is what is under test.
  */
@@ -26,7 +29,7 @@ import {
 } from "../pi-extensions/lib/entwurf-v2-production.ts";
 import { runEntwurfV2 } from "../pi-extensions/lib/entwurf-v2-runner.ts";
 import type { ControlSocketPlan, MetaMailboxPlan } from "../pi-extensions/lib/entwurf-v2-send.ts";
-import type { MetaIdentity, MetaReceiverMarker } from "../pi-extensions/lib/meta-session.ts";
+import type { MetaIdentity, MetaReceiverMarker, MetaSenderMarker } from "../pi-extensions/lib/meta-session.ts";
 import type { NativePushAdapter, NativePushProbeResult } from "../pi-extensions/lib/native-push/adapter.ts";
 import type { TargetSocketInspection } from "../pi-extensions/lib/socket-discovery.ts";
 
@@ -38,6 +41,8 @@ function ok(label: string, cond: boolean): void {
 }
 
 const GID = "20260613T100000-aaaaaa";
+/** The garden a switched-away owner serves instead (#101). */
+const OTHER_GID = "20260613T100000-bbbbbb";
 const LOCK_DIR = "/fake/locks";
 const SESSIONS_DIR = "/fake/sessions";
 const MAILBOX_DIR = "/fake/mailbox";
@@ -74,6 +79,19 @@ function receiverMarker(gid: string, backend: string, nativeSessionId = "n"): Me
 	};
 }
 
+/** The receiver owner's sender marker — "which garden does this pid serve NOW?" (#101). */
+function senderMarker(gardenId: string, backend: string, ownerPid: number): MetaSenderMarker {
+	return {
+		gardenId,
+		backend: backend as MetaSenderMarker["backend"],
+		nativeSessionId: "n",
+		cwd: "/cwd",
+		ownerPid,
+		ownerStartKey: "x",
+		updatedAt: "t",
+	};
+}
+
 function lockClaim(gardenId = GID): LockClaim {
 	return {
 		gardenId,
@@ -133,6 +151,11 @@ function makeSpiedFactory(over: {
 	/** SE-2 2d-3 — the target's receiver presence marker: "active" (matches identity,
 	 * default), "absent" (terminated/never-armed), or "mismatch" (drifted native id). */
 	receiverMarker?: "active" | "absent" | "mismatch";
+	/** #101 — the receiver owner's SENDER marker, i.e. which garden that pid serves NOW:
+	 * "same" (still this one, default), "other-garden" (the owner switched sessions in
+	 * place — a live marker whose watch is retired), or "absent" (no sender marker at all).
+	 * Injected rather than defaulted so this gate never stats the operator's real roots. */
+	senderMarker?: "same" | "other-garden" | "absent";
 }) {
 	const spies: Spies = {
 		acquire: [],
@@ -161,6 +184,10 @@ function makeSpiedFactory(over: {
 				const nsid = over.receiverMarker === "mismatch" ? "DRIFT" : "n";
 				return receiverMarker(gid, over.backend ?? "pi", nsid);
 			},
+			readSenderMarker: (backend, ownerPid) => {
+				if (over.senderMarker === "absent") return null;
+				return senderMarker(over.senderMarker === "other-garden" ? OTHER_GID : GID, backend, ownerPid);
+			},
 			inspectPath: async (socketPath) => {
 				spies.inspectPath.push({ socketPath });
 				if (over.inspectKind === "indeterminate") {
@@ -388,6 +415,50 @@ async function main(): Promise<void> {
 		ok("E3: drifted marker → enqueue NEVER called (presence ≠ identity match)", spies.enqueue.length === 0);
 	}
 
+	// ── E4: #101 — a LIVE receiver marker whose owner switched gardens. Every axis the
+	// pre-#101 seam looked at says "active": the marker exists, its owner is live, and it
+	// matches this identity exactly. Only the owner's sender marker — which garden that pid
+	// serves NOW — says the watch is retired. This is the cell where a real message was
+	// enqueued into a mailbox nobody was draining (oracle, 2026-09-04). ─────────────────
+	{
+		const { deps, spies } = makeSpiedFactory({
+			backend: "claude-code",
+			rpc: "dead-throw",
+			classifyDead: true,
+			receiverMarker: "active",
+			senderMarker: "other-garden",
+		});
+		const res = await deps.executor.sendControl(CONTROL_PLAN, lockClaim());
+		ok(
+			"E4: owner switched gardens → rejected (mailbox-undeliverable), never fallback-sent",
+			res.outcome === "rejected" && res.rejectReason === "mailbox-undeliverable",
+		);
+		ok("E4: nothing enqueued into the retired garden's mailbox", spies.enqueue.length === 0);
+		// …and the same wiring still DELIVERS when that owner is serving this garden, so the
+		// join is a measurement and not a blanket refusal.
+		const served = makeSpiedFactory({
+			backend: "claude-code",
+			rpc: "dead-throw",
+			classifyDead: true,
+			receiverMarker: "active",
+			senderMarker: "same",
+		});
+		const ok2 = await served.deps.executor.sendControl(CONTROL_PLAN, lockClaim());
+		ok("E4: the served garden still falls back to a real mailbox enqueue", ok2.outcome === "fallback-sent");
+		ok(
+			"E4: a MISSING sender marker is fail-closed, not optimistic",
+			(
+				await makeSpiedFactory({
+					backend: "claude-code",
+					rpc: "dead-throw",
+					classifyDead: true,
+					receiverMarker: "active",
+					senderMarker: "absent",
+				}).deps.executor.sendControl(CONTROL_PLAN, lockClaim())
+			).outcome === "rejected",
+		);
+	}
+
 	// ── F: #50 C4 — record-LESS control socket → pre-probe record-less-socket reject ──
 	// resolveTarget finds no meta-record, does ONE record-side lstat (inspectPath), sees a
 	// non-symlink socket → recordLessSocket. EVERY intent then rejects pre-probe as

package/scripts/check-gate-qualification.ts

@@ -1,6 +1,18 @@
 /**
  * check-gate-qualification — kill-proof qualification of the shipped gates.
  *
+ * TWO ENTRYPOINTS, ONE FILE. `--manifests-only` (shipped as `run.sh
+ * check-gate-manifests`) stops after the HEAD — the runner self-test plus the real
+ * manifests' validation and lane inventory — having executed ZERO mutants from
+ * `scripts/mutants/` and having made NO snapshot of this repo. The default
+ * entrypoint is unchanged: it runs the same head first and then the body. The head
+ * is separable because of what it has actually caught: across 549 CI runs the
+ * qualification step went red five times, and three of those died in the head in
+ * 4-5 seconds, before a single mutant gate was invoked (#99 B-3). The head costs
+ * ~8s, so it belongs in the deterministic floor every push already pays for; the
+ * body's contract — which mutants run, how they are classified, what it prints —
+ * is untouched by the split.
+ *
  * Two phases, in a fixed order:
  *
  *   1. RUNNER SELF-TEST. The runner is itself a SUT: a qualification harness that
@@ -58,6 +70,10 @@ import {
 const REPO_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const MUTANTS_DIR = path.join(REPO_DIR, "scripts", "mutants");
 
+/** Head-only mode: validate, count, and stop — no mutant is executed, no repo snapshot is made. */
+const MANIFESTS_ONLY = process.argv.includes("--manifests-only");
+const SURFACE = MANIFESTS_ONLY ? "check-gate-manifests" : "gate-qualification";
+
 let passed = 0;
 function ok(label: string, cond: boolean): void {
 	assert.ok(cond, label);
@@ -775,10 +791,16 @@ const quiet = (): void => {};
 	}
 }
 
-console.log(`\n[gate-qualification] self-test: ${passed} checks passed`);
+console.log(`\n[${SURFACE}] self-test: ${passed} checks passed`);
 
-// ═══ Phase 2 — the real manifests against a snapshot of THIS repo ═══════════
+// ═══ Phase 1d — the real manifests, VALIDATED but not yet run ═══════════════
+//
+// The HEAD ends here. Everything above and in this block is pure reading and
+// checking: no mutant from `scripts/mutants/` is executed and no snapshot of THIS
+// repo exists yet. `--manifests-only` returns from exactly this point.
 
+let selected: MutantSpec[];
+let manifestCount: number;
 {
 	const manifests: MutantManifest[] = fs
 		.readdirSync(MUTANTS_DIR)
@@ -813,21 +835,23 @@ console.log(`\n[gate-qualification] self-test: ${passed} checks passed`);
 		"copilot-launch": 14,
 		"copilot-receive": 18,
 		"fresh-cut": 1,
+		"gate-qualification": 2,
 		"meta-facts": 4,
+		"meta-hook-session-switch": 17,
 		"meta-identity": 4,
 		"meta-retire": 3,
 		"mux-boundary": 14,
 		"mux-fresh-call": 37,
 		"mux-launcher-fence": 7,
 		"mux-parent-artifact": 3,
-		"pack-install": 1,
+		"pack-install": 2,
 		"pi-package-ownership": 6,
 		"mux-resume-call": 12,
 		"omp-birth": 11,
 		"omp-fresh": 24,
 		"omp-receive": 11,
 		"probe-ordering": 1,
-		"release-gate": 12,
+		"release-gate": 14,
 		"resume-args": 6,
 		"resume-launch-identity": 6,
 		"self-address": 5,
@@ -838,17 +862,44 @@ console.log(`\n[gate-qualification] self-test: ${passed} checks passed`);
 	};
 	const laneTally: Record<string, number> = {};
 	for (const man of manifests) laneTally[man.lane] = (laneTally[man.lane] ?? 0) + man.mutants.length;
-	assert.deepEqual(
-		laneTally,
-		EXPECTED_LANE_MUTANTS,
-		"mutant lane inventory drifted from the declared contract — extend EXPECTED_LANE_MUTANTS and the manifests together, never silently",
-	);
-	const allMutants = validateManifestSet(manifests, makeOriginChecks(REPO_DIR));
-	const selected = allMutants;
+	try {
+		assert.deepEqual(laneTally, EXPECTED_LANE_MUTANTS);
+	} catch {
+		assert.fail(
+			"[QK:LANE-INVENTORY-DECLARED] the mutant lane inventory drifted from the declared contract — extend " +
+				"EXPECTED_LANE_MUTANTS and the manifests together, never silently. A lane that lost its manifest in a " +
+				"merge, or gained mutants nobody declared, would otherwise pass as `n/n killed` over whatever set " +
+				`happened to be on disk. declared=${JSON.stringify(EXPECTED_LANE_MUTANTS)} onDisk=${JSON.stringify(laneTally)}`,
+		);
+	}
+	try {
+		selected = validateManifestSet(manifests, makeOriginChecks(REPO_DIR));
+	} catch (err) {
+		assert.fail(
+			"[QK:MANIFEST-SET-INTEGRITY-REFUSED] the committed manifest set broke its cross-manifest contract (global " +
+				"claim uniqueness, subject tracked + lstat-regular in the ORIGIN index, signatureSource on the origin work " +
+				"surface, claim token present exactly once in its gate source). Every one of those is what makes a KILLED " +
+				"verdict mean something, so the set is refused rather than run. Refusal: " +
+				(err instanceof Error ? err.message : String(err)),
+		);
+	}
+	manifestCount = manifests.length;
+	console.log(`[${SURFACE}] ${selected.length} mutants across ${manifestCount} lanes (no tiers — full set every run)`);
+}
+
+if (MANIFESTS_ONLY) {
 	console.log(
-		`[gate-qualification] ${selected.length} mutants across ${manifests.length} lanes (no tiers — full set every run)`,
+		`[check-gate-manifests] ok — runner self-test green, ${selected.length} committed mutants across ` +
+			`${manifestCount} lanes validated against the origin index, and the lane inventory matches its declared ` +
+			"contract. ZERO mutants were executed and this repo was never snapshotted: the body " +
+			"(check-gate-qualification) owns that, unchanged.",
 	);
+	process.exit(0);
+}
+
+// ═══ Phase 2 — the real manifests against a snapshot of THIS repo ═══════════
 
+{
 	const headBefore = originHead(REPO_DIR);
 	const workSurfaceBefore = originWorkSurfaceSha(REPO_DIR);