@junghanacs/entwurf 0.41.2 → 0.50.0

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

@@ -21,6 +21,12 @@ import assert from "node:assert/strict";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+	ENTWURF_DELIVERY_RESULT_CLAUSES,
+	ENTWURF_REJECT_HINTS,
+	ENTWURF_SLOTTED_REJECT_HINTS,
+	ENTWURF_TOOL_GUIDANCE,
+} from "../pi-extensions/lib/agent-guidance.ts";
 import type { EntwurfV2RunResult } from "../pi-extensions/lib/entwurf-v2-runner.ts";
 import {
 	actionableRejectHint,
@@ -28,17 +34,7 @@ import {
 	type SurfaceEntwurfV2Params,
 	toDispatchInput,
 } from "../pi-extensions/lib/entwurf-v2-surface.ts";
-
-/** Cut ONE model-facing string out of a registration block so two descriptions in the same
- * block cannot satisfy an assertion for each other (round-4 masking, 2026-07-27). Returns ""
- * when either marker is missing, which the callers' `length > 120` guard turns into a loud
- * failure rather than a silent pass. */
-function sliceDescription(block: string, startMarker: string, endMarker: string): string {
-	const s = block.indexOf(startMarker);
-	if (s === -1) return "";
-	const e = block.indexOf(endMarker, s + startMarker.length);
-	return e === -1 ? "" : block.slice(s, e);
-}
+import { FRESH_CUT_PRESCRIPTION } from "../pi-extensions/lib/meta-session.ts";
 
 let passed = 0;
 function ok(label: string, cond: boolean): void {
@@ -47,17 +43,6 @@ function ok(label: string, cond: boolean): void {
 	passed++;
 }
 
-/**
- * Collapse a model-facing string's SOURCE form into the text the model actually reads:
- * drop TS string-concat glue between adjacent literals and normalize whitespace.
- */
-function modelText(slice: string): string {
-	return slice
-		.replace(/["']\s*\+\s*["']/g, "")
-		.replace(/\s+/g, " ")
-		.trim();
-}
-
 /**
  * F-2 (2026-07-27): the two model-facing surfaces described the lock, `mode`, and the
  * unsupported-citizen outcome set in ways the code does not support. Measured against
@@ -77,13 +62,11 @@ function modelText(slice: string): string {
  * Applied to BOTH surfaces from one predicate so they cannot drift apart again.
  */
 function assertRailSemantics(tag: string, longDescRaw: string, intentDescRaw: string, modeDescRaw: string): void {
-	// Compare the text the MODEL reads, not the shape the author happened to type. pi-native
-	// wraps inside one template literal; the MCP surface wraps by `+`-concatenating literals.
-	// Without this normalization the same sentence matches on one surface and not the other,
-	// and the assertion silently measures line-wrapping instead of meaning.
-	const longDesc = modelText(longDescRaw);
-	const intentDesc = modelText(intentDescRaw);
-	const modeDesc = modelText(modeDescRaw);
+	// Inputs are decoded product strings, not TS scaffolding. Keep these semantic predicates
+	// separate from the exact, unnormalized pre-extraction byte oracle beside the reader.
+	const longDesc = longDescRaw;
+	const intentDesc = intentDescRaw;
+	const modeDesc = modeDescRaw;
 	ok(
 		`${tag} — long description scopes the per-target lock to the control-socket DOMAIN [QK:V2SURF-MCP-LOCK-DOMAIN]`,
 		/control-socket-DOMAIN\s+dispatch/.test(longDesc) && /lock-free/.test(longDesc),
@@ -155,7 +138,7 @@ function assertRailSemantics(tag: string, longDescRaw: string, intentDescRaw: st
  * DORMANT HONESTY — the model-facing replacement for the retired `V2SURF-MERGED-REJECT` claim,
  * whose subject (two distinct OWNED rejects) left with the `owned-outcome` intent.
  *
- * After the visible-first cut a dormant socket-domain citizen is unreachable by every verb, and
+ * After the visible-first cut a dormant socket-domain citizen rejects delivery by v2, and
  * these four strings are the only place a caller learns that BEFORE spending a dispatch. So each
  * one must, on its own:
  *   - name the reason it will actually get back (`dormant-fire-forget-unsupported`);
@@ -175,7 +158,7 @@ function assertRailSemantics(tag: string, longDescRaw: string, intentDescRaw: st
  * run unlabelled behind it — still real assertions, just not this claim's signature.
  */
 function assertDormantHonesty(tag: string, rawText: string): void {
-	const text = modelText(rawText);
+	const text = rawText;
 	const at = text.indexOf("owned-outcome");
 	ok(
 		`${tag} — names the withdrawn intent owned-outcome and says "withdrawn" beside it (not as an offer) [QK:V2SURF-DORMANT-HONESTY]`,
@@ -192,18 +175,23 @@ function assertDormantHonesty(tag: string, rawText: string): void {
  * PEERS DEAD-ROW HONESTY. `entwurf_peers` is a FACT surface and stays one: this claim must never
  * be satisfiable by adding a per-row action/routing field, which is why it is asserted on the
  * DESCRIPTION and paired with a negative that forbids the row-level fix. What the description owes
- * a caller is that `dead` is a reported fact carrying no invitation — the citizen is dormant and,
- * since the visible-first cut, reachable by no verb at all.
+ * a caller is that `dead` is a reported fact carrying no delivery invitation. A separately
+ * requested, proven-dormant Pi/pi-durable/Claude lifecycle can reopen the same id without submitting a prompt.
  */
 function assertPeersDeadRowHonesty(tag: string, rawBlock: string): void {
-	const text = modelText(rawBlock);
+	const text = rawBlock;
 	ok(
-		`${tag} — entwurf_peers says a dead/dormant row is a REPORTED FACT that grants no action [QK:V2SURF-PEERS-DEAD-ROW]`,
-		/REPORTED FACT/.test(text) && /grants no action/.test(text) && /not an invitation to dispatch/.test(text),
+		`${tag} — entwurf_peers reports dead delivery unavailable, no action grant, and separate explicit-operator promptless resume [QK:V2SURF-PEERS-DEAD-ROW]`,
+		/REPORTED FACT/.test(text) &&
+			/grants no action/.test(text) &&
+			/not an invitation to dispatch/.test(text) &&
+			/no entwurf_v2 delivery is available while it is dormant/.test(text) &&
+			/Only on an explicit operator request, the separate entwurf_resume_call/.test(text) &&
+			/proven-dormant Pi, pi-durable or Claude Code citizen under the same id, submitting no prompt/.test(text),
 	);
 	ok(
-		`${tag} — entwurf_peers calls a dead row currently unreachable by any verb`,
-		/dormant/.test(text) && /unreachable by any verb/.test(text),
+		`${tag} — entwurf_peers does not turn delivery dormancy into a ban on every lifecycle verb`,
+		/dormant/.test(text) && !/unreachable by any verb/.test(text),
 	);
 	// The forbidden repair: teaching the row itself to carry a verb. The facts-only rule is what
 	// keeps this surface from becoming a second dispatch table, so a description that promised a
@@ -214,14 +202,6 @@ function assertPeersDeadRowHonesty(tag: string, rawBlock: string): void {
 	);
 }
 
-/**
- * Containment-disjointness is NOT enough to prove a description slice is tight. Round 5
- * (2026-07-27) shipped a "long description" slice of 4,468 chars that SPANNED the parameter
- * entries because a bare `description:` marker matched the `target` param first — and two
- * over-wide slices can still be mutually non-containing. So pin the ABSENCE of every
- * parameter marker in the long-description slice: if the slice ever swallows the schema
- * again, this fails instead of silently satisfying the schema's own text.
- */
 /**
  * HOST TRUNCATION CAP. Measured 2026-07-30 on both Claude ACP and stock Claude Code: a tool
  * description longer than this is cut mid-sentence and the tail is replaced with `… [truncated]`.
@@ -230,30 +210,12 @@ function assertPeersDeadRowHonesty(tag: string, rawBlock: string): void {
  * to choose an intent. Every other assertion in this file checks that a sentence is PRESENT in
  * source; none of them can see that the host threw half of it away. This one can.
  *
- * Judged on `modelText` (the rendered string), not the source slice: pi-native wraps inside one
- * template literal and the MCP surface `+`-concatenates, so only the normalized text has the
- * length the host actually measures.
+ * Judged on the decoded JSON string, with no source scaffolding or whitespace normalization.
+ * Exact current fields are checked separately against frozen originals plus reviewed literal amendments.
  */
 const HOST_DESCRIPTION_CAP = 2048;
 
-/**
- * The string the HOST measures, recovered from either surface's source scaffolding: drop the
- * `description:` key and the outer template-literal / string-literal fence, and unescape `\"`.
- * Counting the raw slice instead would charge the text for punctuation the model never sees —
- * and the two surfaces carry DIFFERENT punctuation, so the cap would mean two different things.
- */
-function renderedDescription(raw: string): string {
-	const flat = modelText(raw);
-	// Anchor on the description's own first word rather than on scaffolding: the two surfaces put
-	// DIFFERENT preludes in front of it (the MCP slice starts at the tool name), and counting those
-	// would report a number the host never measures — a cap gate that cites the wrong length gets
-	// quoted as if it were the real one.
-	const from = flat.indexOf("CANONICAL");
-	return (from >= 0 ? flat.slice(from) : flat).replace(/[`"],?$/, "").replace(/\\"/g, '"');
-}
-
-function assertDescriptionFitsHostCap(tag: string, longDescRaw: string): void {
-	const rendered = renderedDescription(longDescRaw);
+function assertDescriptionFitsHostCap(tag: string, rendered: string): void {
 	ok(
 		`${tag} — long description fits the host's ${HOST_DESCRIPTION_CAP}-char cap (${rendered.length}) ` +
 			"[QK:V2SURF-DESC-FITS-HOST-CAP]",
@@ -261,12 +223,6 @@ function assertDescriptionFitsHostCap(tag: string, longDescRaw: string): void {
 	);
 }
 
-function assertLongDescExcludesParams(tag: string, longDesc: string, markers: readonly string[]): void {
-	for (const marker of markers) {
-		ok(`${tag} — long description slice excludes the \`${marker}\` parameter marker`, !longDesc.includes(marker));
-	}
-}
-
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO = path.join(HERE, "..");
 const SURFACE_SRC = path.join(REPO, "pi-extensions/lib/entwurf-v2-surface.ts");
@@ -587,9 +543,24 @@ async function main(): Promise<void> {
 				!/DELIVERED|\bdelivered\b/.test(dirtyRefused.text) &&
 				// and every one of them keeps the thing the operator must act on
 				[dirtyBusy, dirtyMailbox, dirtyRefused].every(
-					(r) => r.isError && r.text.includes("DIRTY") && r.text.includes("do NOT retry"),
+					(r) =>
+						r.isError &&
+						r.text.includes("DIRTY") &&
+						r.text.includes("do NOT retry automatically") &&
+						r.text.includes("operator resolve the lock") &&
+						!r.text.includes("would double-deliver"),
 				),
 		);
+		// #154 E1a: the two static clauses of this receipt are authored in root ENTWURF.json; the
+		// syntax around them stays here, so the whole rendered line is compared, not a fragment.
+		const dirtyClause = ENTWURF_DELIVERY_RESULT_CLAUSES["dirty-lock"];
+		ok(
+			"[QK:V2SURF-DELIVERY-RESULT-CLAUSES-FROM-ROOT] the dirty-lock receipt renders the root finalized-rejected and dirty-lock clauses byte for byte inside its code-owned syntax",
+			dirtyBusy.text ===
+				`entwurf_v2 control-socket finalized as queued-steer, and ${dirtyClause}\n  error: release boom` &&
+				dirtyRefused.text ===
+					`entwurf_v2 control-socket finalized as rejected (compacting) — ${ENTWURF_DELIVERY_RESULT_CLAUSES["finalized-rejected"]}, and ${dirtyClause}\n  error: release boom`,
+		);
 
 		// plain execution-failed → error
 		const failed: EntwurfV2RunResult = {
@@ -683,6 +654,25 @@ async function main(): Promise<void> {
 				rls.includes("restart it under the current runtime") &&
 				rls.includes("meta-bridge-fresh-cut"),
 		);
+		// #154 E1b: the text on either side of the fix command is authored in root ENTWURF.json and the
+		// command comes from its owner, so the WHOLE hint is compared against that composition — the
+		// phrase checks above stay, and a hand-kept copy of the text that still carries them dies here.
+		const rlsRoot = ENTWURF_SLOTTED_REJECT_HINTS["record-less-socket"];
+		ok(
+			"[QK:V2SURF-RECORD-LESS-SOCKET-HINT-FROM-ROOT] the record-less-socket hint is exactly the root text before the fix command, the command from its meta-session owner, and the root text after it",
+			rls === `${rlsRoot.beforeFreshCutPrescription}${FRESH_CUT_PRESCRIPTION}${rlsRoot.afterFreshCutPrescription}`,
+		);
+		// #154 C1-B: the five static hints are authored in root ENTWURF.json. This is the WIRING
+		// claim — what the surface returns is the Root value for every declared reason — compared
+		// against the loaded Root, never a fixture, so a Root prose mutant still dies at its own
+		// semantic QK above. The C0 byte oracle lives beside the reader (GUIDANCE-REJECT-HINTS-ORIGINAL).
+		const unwired = Object.entries(ENTWURF_REJECT_HINTS)
+			.filter(([reason, text]) => actionableRejectHint(reason) !== text)
+			.map(([reason]) => reason);
+		ok(
+			`2D: every static reject hint the surface renders is the root ENTWURF.json value [QK:V2SURF-REJECT-HINTS-FROM-ROOT] (unwired: ${JSON.stringify(unwired)})`,
+			Object.keys(ENTWURF_REJECT_HINTS).length === 5 && unwired.length === 0,
+		);
 	}
 
 	// ── 6: RETIRED — parseEntwurfPrefixRootsEnv / ENTWURF_PREFIX_ROOTS ────────
@@ -776,14 +766,10 @@ async function main(): Promise<void> {
 		// Same shipped-rail completeness rule as the pi-native surface (4), and split the SAME
 		// two ways: the long tool description and the `intent` param description must EACH be
 		// true on their own (see the round-4 masking note in block 4).
-		// Same fail-loud rule as block 4: a missing marker would make `slice(0, -1)` return
-		// nearly the whole block and sail past the length guard, so assert the boundary first.
-		const mcpSchemaStart = v2Block.indexOf("\t{");
-		ok("5: MCP — schema boundary marker is present (slice cannot silently widen)", mcpSchemaStart > 0);
-		const mcpLongDesc = v2Block.slice(0, mcpSchemaStart);
-		const mcpIntentDesc = sliceDescription(v2Block, "intent: z", "message: z");
+		const mcpLongDesc = ENTWURF_TOOL_GUIDANCE.entwurf_v2.descriptions.mcp;
+		const mcpIntentDesc = ENTWURF_TOOL_GUIDANCE.entwurf_v2.parameters.intent;
 		ok(
-			"5: MCP — long/intent slices are disjoint (neither can satisfy the other's claim)",
+			"5: MCP — long/intent strings are disjoint (neither can satisfy the other's claim)",
 			mcpLongDesc.length > 0 &&
 				mcpIntentDesc.length > 0 &&
 				!mcpLongDesc.includes(mcpIntentDesc) &&
@@ -799,11 +785,12 @@ async function main(): Promise<void> {
 		}
 		ok("5: MCP — long description denies native-push a mailbox", /NO mailbox/.test(mcpLongDesc));
 		ok(
-			"5: MCP — long description steers live/alive peer → fire-and-forget",
-			/liveness=alive/.test(mcpLongDesc) && /fire-and-forget/.test(mcpLongDesc),
+			"5: MCP — long description says a live socket can receive fire-and-forget, and unsupported is not reachability",
+			/A live socket can receive fire-and-forget/.test(mcpLongDesc) &&
+				/not reachability/.test(mcpLongDesc) &&
+				!/liveness=alive\s*→\s*fire-and-forget/.test(mcpLongDesc),
 		);
-		assertLongDescExcludesParams("5: MCP", mcpLongDesc, ["target: z", "intent: z", "mode: z", "wants_reply: z"]);
-		const mcpModeDesc = sliceDescription(v2Block, "mode: z", "wants_reply: z");
+		const mcpModeDesc = ENTWURF_TOOL_GUIDANCE.entwurf_v2.parameters.mode;
 		assertRailSemantics("5: MCP", mcpLongDesc, mcpIntentDesc, mcpModeDesc);
 		assertDescriptionFitsHostCap("5: MCP", mcpLongDesc);
 
@@ -817,21 +804,20 @@ async function main(): Promise<void> {
 			"5: MCP — entwurf_peers block has a REAL end boundary (next server.tool present)",
 			peersStart !== -1 && peersAfter > peersStart,
 		);
-		const peersBlock = src.slice(peersStart, peersAfter);
-		ok("5: MCP — entwurf_peers block is isolated (non-vacuous)", peersBlock.length > 200);
+		const peersText = ENTWURF_TOOL_GUIDANCE.entwurf_peers.descriptions.mcp;
 		ok(
 			"5: MCP — entwurf_peers names the THIRD answer (a reject), not just the two allow rails",
-			/mailbox-undeliverable/.test(peersBlock) && /native-push-target-dead/.test(peersBlock),
+			/mailbox-undeliverable/.test(peersText) && /native-push-target-dead/.test(peersText),
 		);
 		ok(
 			"5: MCP — entwurf_peers no longer claims `unsupported` does NOT mean unreachable",
-			!/does NOT mean unreachable/.test(peersBlock),
+			!/does NOT mean unreachable/.test(peersText),
 		);
 		// Visible-first cut, operator-surface half: a dormant citizen still gets a row here, and a
 		// caller who reads "it is in the list" as "I can dispatch to it" spends a dispatch to find
 		// out otherwise. The FACT stays a fact — no per-row action field, no routing verb, which is
 		// the rule this surface exists under — so the correction has to live in the description.
-		assertPeersDeadRowHonesty("5: MCP", peersBlock);
+		assertPeersDeadRowHonesty("5: MCP", peersText);
 
 		// F-7: entwurf_inbox_read described itself as draining "your own" inbox while the handler
 		// passes the CALLER-SUPPLIED gardenId straight to readMetaInbox with no comparison against
@@ -845,7 +831,7 @@ async function main(): Promise<void> {
 			inboxStart !== -1 && inboxAfter > inboxStart,
 		);
 		const inboxBlock = src.slice(inboxStart, inboxAfter);
-		const inboxText = modelText(inboxBlock);
+		const inboxText = ENTWURF_TOOL_GUIDANCE.entwurf_inbox_read.descriptions.mcp;
 		ok("5: MCP — entwurf_inbox_read block is isolated (non-vacuous)", inboxText.length > 200);
 		ok(
 			"5: MCP — entwurf_inbox_read states the garden id is CALLER-SUPPLIED and unverified [QK:V2SURF-INBOX-SCOPE-HONESTY]",
@@ -971,20 +957,27 @@ async function main(): Promise<void> {
 	// rail's four boundaries are the ONLY receiver-acceptance values; a mailbox answers with an
 	// ENQUEUE receipt and native-push with an INJECTION, and folding those into the boundary union
 	// would tell a caller that `mailbox-enqueued` is something a receiver observed about its own
-	// queues. Missing either rail is red — the earlier draft listed `mailbox-enqueued` beside the
+	// queues. The socket dispatch may re-resolve to a mailbox leg and report mailbox-enqueued;
+	// that exception must name the leg, not silently invent a fifth receiver queue boundary.
+	// Missing either rail is red — the earlier draft listed `mailbox-enqueued` beside the
 	// four and left native-push out entirely, and nothing noticed.
 	{
-		const outcomeSites = ["mcp/entwurf-bridge/src/index.ts"];
+		const outcomeSites = [
+			{
+				rel: "ENTWURF.json tools.entwurf_v2.descriptions.mcp",
+				text: ENTWURF_TOOL_GUIDANCE.entwurf_v2.descriptions.mcp,
+			},
+		];
 		const missing: string[] = [];
-		for (const rel of outcomeSites) {
-			const text = await fs.readFile(path.join(REPO, rel), "utf8");
+		for (const { rel, text } of outcomeSites) {
 			const at = text.indexOf("reports ONE");
 			const blurb = at < 0 ? "" : text.slice(at, at + 900);
 			if (!/acceptance boundary/i.test(blurb)) missing.push(`${rel}: control receiver acceptance boundary`);
 			for (const b of ["sent", "queued-steer", "queued-follow-up", "accepted-unknown-boundary"]) {
 				if (!blurb.includes(b)) missing.push(`${rel}: boundary ${b}`);
 			}
-			if (!/those four only/i.test(blurb)) missing.push(`${rel}: the four-only scope of the boundary union`);
+			if (!blurb.includes("those four, or `mailbox-enqueued` on a re-resolved mailbox leg"))
+				missing.push(`${rel}: the four receiver boundaries and the explicitly re-resolved mailbox leg`);
 			if (!/mailbox ENQUEUE/i.test(blurb)) missing.push(`${rel}: mailbox enqueue receipt`);
 			if (!/native-push INJECTION/i.test(blurb)) missing.push(`${rel}: native-push injection`);
 			if (!/rejection|rejected/i.test(blurb)) missing.push(`${rel}: rejection`);
@@ -994,7 +987,7 @@ async function main(): Promise<void> {
 			}
 		}
 		ok(
-			`[QK:SEND-OUTCOME-LIST-NAMES-EVERY-RAIL] the tool description names each rail's own result — the control receiver's four acceptance boundaries (and that those four are the whole union), the mailbox ENQUEUE receipt, the native-push INJECTION, a rejection, and accepted-but-lock-dirty — so a caller is never told that one rail's vocabulary describes another's (missing: ${JSON.stringify(missing)})`,
+			`[QK:SEND-OUTCOME-LIST-NAMES-EVERY-RAIL] the tool description names each rail's own result — the control receiver's four acceptance boundaries (or mailbox-enqueued on an explicitly re-resolved mailbox leg), the mailbox ENQUEUE receipt, the native-push INJECTION, a rejection, and accepted-but-lock-dirty — so a caller is never told that one rail's vocabulary describes another's (missing: ${JSON.stringify(missing)})`,
 			missing.length === 0,
 		);
 	}
@@ -1029,7 +1022,10 @@ async function main(): Promise<void> {
 		];
 		const gaps: string[] = [];
 		for (const rel of sites) {
-			const text = await fs.readFile(path.join(REPO, rel), "utf8");
+			const text =
+				rel === "mcp/entwurf-bridge/src/index.ts"
+					? ENTWURF_TOOL_GUIDANCE.entwurf_v2.parameters.mode
+					: await fs.readFile(path.join(REPO, rel), "utf8");
 			for (const axis of axes) if (!axis.holds(text)) gaps.push(`${rel}: ${axis.name}`);
 			if (/steer \((?:interrupt|immediate)|interrupt the current turn|steer = interrupt/i.test(text)) {
 				gaps.push(`${rel}: still claims steer interrupts`);

package/scripts/check-fresh-call-dispatch.ts

@@ -18,6 +18,11 @@
  *   FCD-NO-RAIL-PARAMETER     no caller-facing input can choose a rail
  *   FCD-NO-FALLBACK           an incomplete herdr context refuses by its herdr reason
  *   FCD-HERDR-BACKEND-FIRST   a non-pilot backend refuses before any preflight and any mutation
+ *   FCD-HERDR-PI-DURABLE-LAYOUT  inside herdr pi-durable reaches the layout branch, which is told
+ *                             only WHETHER the caller is a Codex citizen and never falls back from
+ *                             its missing record cwd to this process's own (#157 A-L1)
+ *   FCD-HERDR-NO-THREAD-ID    the herdr branch builds its request from an explicit field list in
+ *                             which the Codex thread id appears only as that boolean (#157 A-L1 D5)
  *   FCD-CODEX-PREFLIGHT-TMUX  the Codex preflight still gates the tmux rail, and only that rail
  *   FCD-ONE-NONCE             one nonce is minted per call and reaches the selected rail
  *   FCD-SURFACE-ROOT-ONLY     the one public surface (the bridge; pi reaches it through Pi's
@@ -28,6 +33,8 @@
  *   FCD-RECOVERY-VISIBLE      a post-split failure shows closed vs orphan-unreclaimed:reason
  *   FCD-ACP-MODEL-EXACT       a pi `entwurf/<id>` that is not an exact curated ACP id refuses on
  *                             either rail before anything runs (#128)
+ *   FCD-RESUME-RAIL-SHARED    a same-id visible resume reaches the same exact rail choice through
+ *                             its own entry point, with no fallback in either direction (#157 G1a)
  */
 
 import assert from "node:assert/strict";
@@ -36,6 +43,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
 	dispatchFreshCall,
+	dispatchResumeLaunch,
 	renderDispatchedFreshCall,
 	selectFreshCallRail,
 } from "../pi-extensions/lib/fresh-call-dispatch.ts";
@@ -180,25 +188,45 @@ async function main(): Promise<void> {
 			!herdrBranch.includes("codexCallerFreshPreflight"),
 	);
 
-	// #129: pi-durable joined the tmux fresh set, NOT the herdr pilot set (GLG, 2026-10-06: no herdr
-	// pi-durable support in 0.31). Same axis as the codex cell: refused by the herdr reason, nothing
-	// spawned, no tmux fallback, and its installed-carrier preflight is never asked on this branch.
+	// #157 A-L1 (main 0a6f9b relaying GLG's #157 grant; supersedes the #129 "not in herdr" cell):
+	// inside herdr pi-durable reaches the herdr LAYOUT branch, which never runs the herdr CLI. The
+	// root hands that branch one boolean — the caller IS a record-backed Codex citizen — and the
+	// branch, not this root, owns the pi-durable preflight. Both calls below are refused before any
+	// socket is opened (this env names none), so nothing here can reach a herdr server.
 	const durable = recordingSpawn();
-	const durableRefused = await dispatchFreshCall(
-		{ ...REQUEST, backend: "pi-durable", model: "loopback/scripted" },
+	const durableRequest = { ...REQUEST, backend: "pi-durable", model: "loopback/scripted" };
+	const durablePlain = await dispatchFreshCall(durableRequest, HERDR_ENV, durable.spawn);
+	const durableCodexCaller = await dispatchFreshCall(
+		{ ...durableRequest, callerNativeSessionId: "019a0000-0000-7000-8000-000000000000" },
 		HERDR_ENV,
 		durable.spawn,
 	);
 	ok(
-		"[QK:FCD-HERDR-PI-DURABLE-UNSUPPORTED] inside herdr pi-durable is not a pilot backend: it refuses by the herdr reason with nothing spawned, never falls back to a tmux window, and its runtime preflight is never consulted there",
-		durableRefused.rail === "herdr" &&
-			!durableRefused.result.ok &&
-			durableRefused.result.reason === "herdr-backend-unsupported" &&
+		"[QK:FCD-HERDR-PI-DURABLE-LAYOUT] inside herdr pi-durable is no longer refused as unsupported: with the caller's own process cwd it reaches the layout branch's socket-path refusal, while a known Codex caller with no record cwd is refused as codex-caller-cwd-unavailable instead of falling back to this process's cwd — the root passes Codex-ness as a boolean, nothing spawns the herdr CLI, no tmux fallback, and the root's herdr branch names no pi-durable preflight",
+		durablePlain.rail === "herdr" &&
+			!durablePlain.result.ok &&
+			durablePlain.result.reason === "herdr-socket-path-missing" &&
+			durableCodexCaller.rail === "herdr" &&
+			!durableCodexCaller.result.ok &&
+			durableCodexCaller.result.reason === "codex-caller-cwd-unavailable" &&
 			durable.calls.length === 0 &&
 			herdrBranchLocated &&
 			!herdrBranch.includes("piDurable"),
 	);
 
+	// #157 A-L1 D5: the Codex thread id is a tmux seat input and STOPS at this root. The herdr branch
+	// therefore spells its request field by field — a spread of the whole request would carry the id
+	// along even if no herdr code read it today — and names the id once, inside the boolean.
+	const threadIdMentions = herdrBranch.split("callerNativeSessionId").length - 1;
+	ok(
+		"[QK:FCD-HERDR-NO-THREAD-ID] the herdr branch hands its rail an explicit field list, not a spread of the request, and the Codex thread id appears in it exactly once — as `callerIsCodex: request.callerNativeSessionId !== undefined` — so only a boolean and the record cwd cross to herdr while the tmux request stays whole",
+		herdrBranchLocated &&
+			!/\.\.\.request\b/.test(herdrBranch) &&
+			threadIdMentions === 1 &&
+			herdrBranch.includes("callerIsCodex: request.callerNativeSessionId !== undefined,") &&
+			herdrBranch.includes("callerCwd: request.callerCwd"),
+	);
+
 	// ── the tmux rail keeps its pre-existing ordering ────────────────────────────────────
 	// The import line names the preflight too, so the body is what gets counted: the claim is
 	// "called once, on one path", not "the word appears once".
@@ -292,6 +320,8 @@ async function main(): Promise<void> {
 			backend: "pi",
 			requestedKind: "pi",
 			model: "m/1",
+			cwd: "/repo/dir",
+			cwdSource: "caller-process",
 			herdrAgentName: "entwurf-abc",
 			herdrWorkspaceId: "w7",
 			herdrTabId: "w7:t3",
@@ -354,6 +384,37 @@ async function main(): Promise<void> {
 			!unknown.text.includes("orphan-unreclaimed"),
 	);
 
+	// ── #157 G1a: a visible resume reaches the SAME rail choice ──────────────────────────
+	// The root's second entry point owns only the rail choice for a same-id visible resume. Its tmux
+	// half is whatever the surface hands in, so a recording stub stands for it; its herdr half is the
+	// real herdr resume launch, driven with an incomplete herdr context so it refuses before any
+	// runner exists. No existing cell exercises this entry point: a resume entry that read the marker
+	// loosely, or fell back to the surface's tmux mapping, would leave every cell above green.
+	{
+		const RESUME_INPUT = { backend: "pi", cwd: "/x/project", runtimeArgs: ["--session", "/x/s.jsonl"] } as const;
+		const tmuxCalls: unknown[] = [];
+		const tmuxLaunch = (input: typeof RESUME_INPUT) => {
+			tmuxCalls.push(input);
+			return { ok: false as const, reason: "tmux-stub" };
+		};
+		const resumeSpawn = recordingSpawn();
+		const inHerdr = await dispatchResumeLaunch(RESUME_INPUT, tmuxLaunch, { HERDR_ENV: "1" }, resumeSpawn.spawn);
+		const tmuxCallsInHerdr = tmuxCalls.length;
+		const elsewhere = [{ HERDR_ENV: "0" }, { HERDR_ENV: "true" }, { HERDR_ENV: "" }, { HERDR_ENV: " 1" }, {}].map(
+			(env) => dispatchResumeLaunch(RESUME_INPUT, tmuxLaunch, env, resumeSpawn.spawn),
+		);
+		ok(
+			"[QK:FCD-RESUME-RAIL-SHARED] a same-id visible resume reaches the SAME rail choice fresh call does, through its own entry point: exactly `HERDR_ENV=1` goes to the herdr resume launch and, with that herdr context incomplete, refuses by the herdr reason without ever calling the surface's tmux mapping; every other value, and an absent variable, goes to that tmux mapping with the record-derived input unchanged — a second, looser predicate or a fallback either way would reopen a citizen where the operator is not looking",
+			!inHerdr.ok &&
+				inHerdr.reason === "herdr-context-missing" &&
+				tmuxCallsInHerdr === 0 &&
+				resumeSpawn.calls.length === 0 &&
+				elsewhere.every((r) => !("then" in r) && r.reason === "tmux-stub") &&
+				tmuxCalls.length === elsewhere.length &&
+				tmuxCalls.every((input) => input === RESUME_INPUT),
+		);
+	}
+
 	console.log(`\n[check-fresh-call-dispatch] ${passed} assertions ok`);
 }
 

package/scripts/check-fresh-cut-gate.sh

@@ -63,6 +63,7 @@ export HOME="$SANDBOX/home"
 export XDG_DATA_HOME="$SANDBOX/home/.local/share"
 export XDG_STATE_HOME="$SANDBOX/home/.local/state"
 export XDG_CACHE_HOME="$SANDBOX/home/.cache"
+export XDG_CONFIG_HOME="$SANDBOX/home/.config"
 export PI_CODING_AGENT_DIR="$SANDBOX/home/.pi/agent"
 export ENTWURF_META_SESSIONS_DIR="$SANDBOX/store"
 export ENTWURF_META_MAILBOX_DIR="$SANDBOX/mailbox"
@@ -1460,6 +1461,11 @@ fake_pkg="$SANDBOX/nm/node_modules/@junghanacs/entwurf"
 mkdir -p "$fake_pkg/scripts"
 cp "$REPO/run.sh" "$fake_pkg/run.sh"
 cp "$REPO/scripts/meta-bridge-store-doctor.ts" "$fake_pkg/scripts/"
+# Sourcing run.sh with no argv still walks its dispatch to the root usage, which renders
+# ENTWURF-CLI.json through scripts/cli-help.mjs (#153). Without those two files that render fails
+# first, under run.sh's own errexit, and the doctor branch below is never reached.
+cp "$REPO/ENTWURF-CLI.json" "$fake_pkg/ENTWURF-CLI.json"
+cp "$REPO/scripts/cli-help.mjs" "$fake_pkg/scripts/"
 set +e
 out="$(RUNSH="$fake_pkg/run.sh" bash -c 'set --; source "$RUNSH" >/dev/null; preflight_v3_store install' 2>&1)"; rc=$?
 set -e
@@ -1485,19 +1491,27 @@ rm -rf "$SANDBOX/nm"
 # names — the point is not that failures are nonzero, it is that a caller can BRANCH.
 echo "[check-fresh-cut-gate] J. exit contract"
 
-# J1/J2 — the two states that need no host at all.
+# J1/J2 — the two states that need no host at all. Streams are kept apart: the leaf's own
+# usage line is now only the address of the description (#153), and the contract text itself —
+# exit numbers included — is the public page `entwurf meta-bridge-fresh-cut --help` prints, which
+# check-install-surface S9u holds against this verb's ce92dc7 text and FRESH_CUT_EXIT.
+fc_pointer='meta-bridge-fresh-cut: see `entwurf help meta-bridge-fresh-cut` (from that checkout'"'"'s root: `./run.sh help meta-bridge-fresh-cut`)'
 set +e
-help_out="$(node --experimental-strip-types "${FRESH_CUT[@]}" --help 2>&1)"; rc=$?
+node --experimental-strip-types "${FRESH_CUT[@]}" --help >"$SANDBOX/j1.out" 2>"$SANDBOX/j1.err"; rc=$?
 set -e
-if [ "$rc" = 0 ]; then ok "J1 --help exits 0"; else bad "J1 --help exited $rc" "$help_out"; fi
-case "$help_out" in
-  *"EXIT CONTRACT"*) ok "J1b --help PRINTS the contract (an operator can read it where they hit it)" ;;
-  *) bad "J1b --help never printed the exit contract" "$help_out" ;;
-esac
+if [ "$rc" = 0 ]; then ok "J1 --help exits 0"; else bad "J1 --help exited $rc" "$(cat "$SANDBOX/j1.err")"; fi
 set +e
-bad_out="$(node --experimental-strip-types "${FRESH_CUT[@]}" --wat 2>&1)"; rc=$?
+node --experimental-strip-types "${FRESH_CUT[@]}" --wat >"$SANDBOX/j2.out" 2>"$SANDBOX/j2.err"; rc2=$?
 set -e
-if [ "$rc" = 2 ]; then ok "J2 an unknown argument is USAGE (exit 2), never a store verdict"; else bad "J2 unknown arg exited $rc, want 2" "$bad_out"; fi
+if [ "$rc2" = 2 ]; then ok "J2 an unknown argument is USAGE (exit 2), never a store verdict"; else bad "J2 unknown arg exited $rc2, want 2" "$(cat "$SANDBOX/j2.err")"; fi
+if [ "$rc" = 0 ] && [ "$rc2" = 2 ] && [ ! -s "$SANDBOX/j1.out" ] && [ ! -s "$SANDBOX/j2.out" ] \
+  && [ "$(cat "$SANDBOX/j1.err")" = "$fc_pointer" ] && [ "$(wc -l <"$SANDBOX/j1.err")" = 1 ] \
+  && cmp -s "$SANDBOX/j1.err" "$SANDBOX/j2.err"; then
+  ok "J1b --help (exit 0) and an unknown argument (exit 2) print nothing on stdout and one stderr line pointing at \`entwurf help meta-bridge-fresh-cut\`"
+else
+  bad "[QK:FRESHCUT-HELP-POINTER] J1b the leaf's usage is not exactly the one pointer line on stderr with an empty stdout" \
+    "help rc=$rc stdout=$(head -c 200 "$SANDBOX/j1.out") stderr=$(head -c 400 "$SANDBOX/j1.err") | wat rc=$rc2 stdout=$(head -c 200 "$SANDBOX/j2.out") stderr=$(head -c 400 "$SANDBOX/j2.err")"
+fi
 
 # J3 — the success state, distinct from every failure below.
 reset_world prevgen