@junghanacs/entwurf 0.45.0 → 0.50.0

package/mcp/entwurf-bridge/dist/ENTWURF.json

@@ -6,8 +6,56 @@
 		"editing": "Preserve decoded strings exactly unless an explicit semantic amendment is intended. Review related consumers and independent oracles atomically. Accepted payload changes advance revision; history-only edits, routine releases and unrelated code changes do not. schemaVersion tracks reader/structural compatibility. A slotted hint holds only the text around its slot: the slot value (for record-less-socket, the fresh-cut command in both invocation forms) is supplied by its code owner and never copied here. Metadata is not delivered to models."
 	},
 	"schemaVersion": 6,
-	"revision": 11,
+	"revision": 19,
 	"history": [
+		{
+			"revision": 19,
+			"source": "2734f524bfeca6eb1a0ae092494d45576af9ebef",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "Claude Code same-id resume on the herdr rail (#157 stage 4): both entwurf_resume_call descriptions open every resumable backend inside herdr in a new herdr tab and drop the Claude Code refusal there, the MCP description's Claude Code observation names the window or tab and herdr's pane-process-unread outcome, and the tmux leaf's herdr guard hint no longer says the herdr rail reopens pi only (stale since B3)"
+		},
+		{
+			"revision": 18,
+			"source": "43594eba588a51bdb9d58a4631e3ebc7b3a235ea",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "pi-durable same-id resume, joint-review alignment (#157 B3): the entwurf_resume_call MCP description is rewritten within the host cap to state pi-durable eligibility (claim closed and released, or holder proven gone), its observation classes and that a held session is refused without unconditional delivery advice, since a pi-durable reservation awaiting adoption is not reachable by entwurf_v2; the durable description names that holder; the entwurf_v2 and entwurf_peers descriptions add pi-durable to the resume domain; the target-live and target-indeterminate visible-resume hints become holder-neutral. No wire value, argument, schema or reason identifier changes."
+		},
+		{
+			"revision": 17,
+			"source": "46c7c776c7fed9001be4498ea024cfd214f4347f",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "Same-id visible resume names pi-durable (#157 B3): both entwurf_resume_call descriptions and its target parameter add pi-durable beside pi and Claude Code, the MCP description's OBSERVATION receipt names the pi-durable adoption of this call's reservation and both descriptions put pi-durable with pi inside herdr, and the target-backend-unsupported hint lists pi-durable among the backends that do resume. No wire value, argument, schema shape or reason identifier changes."
+		},
+		{
+			"revision": 16,
+			"source": "d6129139ad9738a3bc0ade9b5ef3abbac4b7580f",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "The entwurf_fresh_call cwd parameter's last sentence names every source an echoed directory can come from: the REQUESTED path, a Codex caller's record directory, or another caller's own process directory, which its default clause already named (checkpoint amendment A1 D3). Every description and every other parameter are unchanged. No wire value, argument, schema or reason identifier changes."
+		},
+		{
+			"revision": 15,
+			"source": "d6129139ad9738a3bc0ade9b5ef3abbac4b7580f",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "The entwurf_fresh_call MCP description restores four contract phrases that revision 14's host-cap rewrite dropped (entwurf_peers only reports, Model is REQUIRED, the CALLER, NOTHING is created), at 1748 characters under the 2048-character host description cap (A-L1 host-cap recovery). The durable description, every parameter and the other tools are unchanged. No wire value, argument, schema or reason identifier changes."
+		},
+		{
+			"revision": 14,
+			"source": "d6129139ad9738a3bc0ade9b5ef3abbac4b7580f",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "The entwurf_fresh_call MCP description is rewritten to fit the 2048-character host description cap (A-L1 host-cap recovery): revision 13's 2182-character text becomes 1732 characters. The durable description, every parameter and the other tools are unchanged. No wire value, argument, schema or reason identifier changes."
+		},
+		{
+			"revision": 13,
+			"source": "d6129139ad9738a3bc0ade9b5ef3abbac4b7580f",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "pi-durable opens inside herdr through one layout.apply request (A-L1): the entwurf_fresh_call MCP description says the herdr tab is requested unfocused, names pi and claude-code through agent start and pi-durable through a native layout command, and keeps the by-name herdr refusal for copilot/omp/codex only; the durable description's last sentence and the backend parameter name pi-durable among the herdr backends. No wire value, argument, schema or reason identifier changes."
+		},
+		{
+			"revision": 12,
+			"source": "0e04bf6e728aa14320decc056ec91e74727a8f2b",
+			"issue": "https://github.com/junghan0611/entwurf/issues/157",
+			"change": "Pi same-id visible resume gains a herdr rail (G1a): both entwurf_resume_call descriptions name the pi-only herdr tab and the Claude Code refusal there, the launch-refused hint no longer says only tmux was not asked, and the tmux leaf's herdr guard hint is narrowed to that leaf. No wire value, schema or reason identifier changes."
+		},
 		{
 			"revision": 11,
 			"source": "d3963c2d16a93453baf7a318ad9395c57990531d",
@@ -78,7 +126,7 @@
 	"tools": {
 		"entwurf_v2": {
 			"descriptions": {
-				"mcp": "CANONICAL DELIVERY SURFACE for garden ids: message, reply, or hand off to whoever an id names. The id alone does not say which rail that citizen answers on. Give target + intent; the decider picks transport from liveness (live socket citizen → control-socket send; deliverable self-fetch citizen → meta-bridge mailbox; probe-alive native-push citizen → direct injection into its conversation) and reports ONE outcome, named per rail: a control receiver's acceptance boundary (`sent` / `queued-steer` / `queued-follow-up` / `accepted-unknown-boundary` — those four, or `mailbox-enqueued` on a re-resolved mailbox leg), a mailbox ENQUEUE receipt, a native-push INJECTION, a rejection, or lock-dirty. This receipt is not the colleague's reply or evidence of reading. EXISTING targets only; discover with entwurf_peers. A live socket can receive fire-and-forget. unsupported means only \"no control-socket probe,\" not reachability. The decider resolves the actual rail at dispatch time: a self-fetch mailbox only while deliverable, native-push direct injection only while its adapter probe is alive, or a THIRD RESULT: rejection when neither holds. An inactive self-fetch citizen is mailbox-undeliverable; native-push has NO mailbox: dead → native-push-target-dead; indeterminate → native-push-probe-indeterminate; agy (paused, #152) → native-push-paused, no probe. A dormant socket rejects this delivery verb as dormant-fire-forget-unsupported. owned-outcome was withdrawn. Only on an explicit operator request, entwurf_resume_call may visibly reopen a proven-dormant Pi or Claude Code citizen under the same id, submitting no prompt; that lifecycle is separate from delivery. LOCK: taken for a control-socket-DOMAIN dispatch. The mailbox and native-push rails are lock-free — deliverability and the adapter probe guard them. mode applies to a CONTROL-SOCKET send only; other plans carry no mode. wants_reply rides every rail. message caps at 16000 chars; send an artifact path + digest for more.",
+				"mcp": "CANONICAL DELIVERY SURFACE for garden ids: message, reply, or hand off to whoever an id names. The id alone does not say which rail that citizen answers on. Give target + intent; the decider picks transport from liveness (live socket citizen → control-socket send; deliverable self-fetch citizen → meta-bridge mailbox; probe-alive native-push citizen → direct injection into its conversation) and reports ONE outcome, named per rail: a control receiver's acceptance boundary (`sent` / `queued-steer` / `queued-follow-up` / `accepted-unknown-boundary` — those four, or `mailbox-enqueued` on a re-resolved mailbox leg), a mailbox ENQUEUE receipt, a native-push INJECTION, a rejection, or lock-dirty. This receipt is not the colleague's reply or evidence of reading. EXISTING targets only; discover with entwurf_peers. A live socket can receive fire-and-forget. unsupported means only \"no control-socket probe,\" not reachability. The decider resolves the actual rail at dispatch time: a self-fetch mailbox only while deliverable, native-push direct injection only while its adapter probe is alive, or a THIRD RESULT: rejection when neither holds. An inactive self-fetch citizen is mailbox-undeliverable; native-push has NO mailbox: dead → native-push-target-dead; indeterminate → native-push-probe-indeterminate; agy (paused, #152) → native-push-paused, no probe. A dormant socket rejects this delivery verb as dormant-fire-forget-unsupported. owned-outcome was withdrawn. Only on an explicit operator request, entwurf_resume_call may visibly reopen a proven-dormant Pi, pi-durable or Claude Code citizen under the same id, submitting no prompt; that lifecycle is separate from delivery. LOCK: taken for a control-socket-DOMAIN dispatch. The mailbox and native-push rails are lock-free — deliverability and the adapter probe guard them. mode applies to a CONTROL-SOCKET send only; other plans carry no mode. wants_reply rides every rail. message caps at 16000 chars; send an artifact path + digest for more.",
 				"durable": "Send a message to an existing garden citizen by garden id through the entwurf-bridge (intent fire-and-forget). Returns the bridge's delivery receipt, or fails with its named rejection. This receipt is not the colleague's reply."
 			},
 			"parameters": {
@@ -98,7 +146,7 @@
 		},
 		"entwurf_peers": {
 			"descriptions": {
-				"mcp": "List the entwurf fact surface: garden citizens (from meta-records) with their liveness, plus diagnostics. The record is the sole address axis — a control socket no record claims is a `record-less-socket` diagnostic (a stale/diagnostic state), never a peer row. This reports FACTS, never verbs: `liveness` is a fact (alive/dead/indeterminate, or `unsupported` for a backend with no control-socket probe such as claude-code); the delivery choice or rejection is resolved LATER by entwurf_v2 from the record and current rail facts, not here — this surface carries no per-row routing field, so do not read a transport off a row. A `dead` socket row is a REPORTED FACT: no entwurf_v2 delivery is available while it is dormant. Listing it grants no action and is not an invitation to dispatch. Only on an explicit operator request, the separate entwurf_resume_call may visibly reopen a proven-dormant Pi or Claude Code citizen under the same id, submitting no prompt. In particular `unsupported` does NOT mean mailbox: it means this backend has no control-socket probe. Dispatch has THREE possible answers — a self-fetch mailbox (only while that mailbox is deliverable), native-push direct injection (only while its adapter probe is alive), or a REJECT when neither holds: mailbox-undeliverable for a self-fetch citizen whose inbox nobody drains, and on the native-push probe dead → native-push-target-dead vs indeterminate → native-push-probe-indeterminate, kept apart because an unestablished probe is not a departed host; an agy target rejects as native-push-paused (#152) without being probed. Note: this is the *active* world and it is facts-only — it creates nothing. Pass an existing garden id to entwurf_v2; to open a NEW sibling use entwurf_fresh_call.",
+				"mcp": "List the entwurf fact surface: garden citizens (from meta-records) with their liveness, plus diagnostics. The record is the sole address axis — a control socket no record claims is a `record-less-socket` diagnostic (a stale/diagnostic state), never a peer row. This reports FACTS, never verbs: `liveness` is a fact (alive/dead/indeterminate, or `unsupported` for a backend with no control-socket probe such as claude-code); the delivery choice or rejection is resolved LATER by entwurf_v2 from the record and current rail facts, not here — this surface carries no per-row routing field, so do not read a transport off a row. A `dead` socket row is a REPORTED FACT: no entwurf_v2 delivery is available while it is dormant. Listing it grants no action and is not an invitation to dispatch. Only on an explicit operator request, the separate entwurf_resume_call may visibly reopen a proven-dormant Pi, pi-durable or Claude Code citizen under the same id, submitting no prompt. In particular `unsupported` does NOT mean mailbox: it means this backend has no control-socket probe. Dispatch has THREE possible answers — a self-fetch mailbox (only while that mailbox is deliverable), native-push direct injection (only while its adapter probe is alive), or a REJECT when neither holds: mailbox-undeliverable for a self-fetch citizen whose inbox nobody drains, and on the native-push probe dead → native-push-target-dead vs indeterminate → native-push-probe-indeterminate, kept apart because an unestablished probe is not a departed host; an agy target rejects as native-push-paused (#152) without being probed. Note: this is the *active* world and it is facts-only — it creates nothing. Pass an existing garden id to entwurf_v2; to open a NEW sibling use entwurf_fresh_call.",
 				"durable": "List the garden's citizens with their liveness facts from the entwurf-bridge. Read-only; facts, not verbs."
 			},
 			"parameters": {}
@@ -124,12 +172,12 @@
 		},
 		"entwurf_fresh_call": {
 			"descriptions": {
-				"mcp": "Open ONE fresh visible sibling beside you and hand it a first task. The launch rail follows THIS agent's process context; tmux placement can be explicitly named: inside herdr (HERDR_ENV=1) it opens a NEW UNFOCUSED TAB in your own herdr workspace, pi and claude-code only; everywhere else it opens in the operator's tmux with all six backends (pi, claude-code, copilot, omp, codex, pi-durable). No fallback: an incomplete herdr context is refused by name, never by a tmux window you cannot see from herdr. The sibling is asked to call back before its task with the launch nonce; match that nonce and use the callback sender envelope for its garden id. This returns a LAUNCH receipt (the owner's coordinates plus that nonce): it does NOT mean the runtime started, the first turn ran, or the task was delivered. Those coordinates are a VIEW, never an address — a herdr tab/pane id can change under a running sibling. Nothing polls. For EXISTING citizens use entwurf_v2 — this tool only creates, and entwurf_peers only reports. Model is REQUIRED and passed to the chosen runtime CLI (`provider/model` for pi, an id/alias for Claude Code, `provider/model id` exactly as the catalog names it for pi-durable, a pattern for the rest). On tmux, copilot/omp/codex/pi-durable are refused BEFORE any window opens when their birth, MCP, receive or visible-identity units are absent, pi-durable also on named refusals of its installed carrier or exact SDK set, and codex also needs the operator-owned app-server socket entwurf never starts; in herdr they are refused by name first. Optional placement.tmuxSession is a TMUX-ONLY seat naming ONE EXISTING session and ALWAYS wins; omitted, the seat follows the CALLER, never the backend opened: a CODEX CALLER opens beside its own TUI pane, every other caller in its own session; a missing one is tmux-session-missing and NOTHING is created. In herdr the field is refused by name. Do not put secrets in the task — model and task argv are visible to same-user processes.",
-				"durable": "Open ONE fresh visible sibling beside this durable host through the entwurf-bridge and hand it a first task (backend, model and task required; optional cwd and placement). Returns the bridge's LAUNCH receipt or its named refusal — not a started runtime, a delivered task or a reply; the sibling's callback names it. Opening beside this host needs the tmux pane this host itself was launched in."
+				"mcp": "Open ONE fresh visible sibling beside you and hand it a first task. Rail follows THIS agent's process context: inside herdr (HERDR_ENV=1), request a NEW UNFOCUSED TAB in your workspace: pi/claude-code via agent start, pi-durable via one native layout request; otherwise use the operator's tmux with all six backends (pi, claude-code, copilot, omp, codex, pi-durable). No fallback: incomplete herdr context rejects by name, never opens unseen tmux. The sibling is asked to call back before its task with the launch nonce; match it and take its garden id from the callback sender envelope. Returns a LAUNCH receipt (owner coordinates + nonce), NOT proof of runtime start, first turn or task delivery. Coordinates are a VIEW, never an address; herdr tab/pane ids can change. Nothing polls. EXISTING citizens: entwurf_v2; entwurf_peers only reports. Model is REQUIRED, passed to runtime CLI: provider/model for pi; id/alias for Claude Code; provider/<exact catalog model id> for pi-durable; pattern for the rest. On tmux, copilot/omp/codex/pi-durable refuse BEFORE window creation if birth, MCP, receive or visible-identity units are absent; pi-durable also refuses installed-carrier/exact-SDK failures; codex needs the operator-owned app-server socket Entwurf never starts. In herdr, copilot/omp/codex reject first; pi-durable runs the same unit/carrier/SDK preflight before layout. Optional placement.tmuxSession is TMUX ONLY: ONE EXISTING session, always wins. Omitted, seat follows the CALLER, not opened backend: a CODEX CALLER opens beside its TUI pane, others in their own session. Missing session: tmux-session-missing, NOTHING is created. Herdr refuses placement by name. No secrets in task: model/task argv are visible to same-user processes.",
+				"durable": "Open ONE fresh visible sibling beside this durable host through the entwurf-bridge and hand it a first task (backend, model and task required; optional cwd and placement). Returns the bridge's LAUNCH receipt or its named refusal — not a started runtime, a delivered task or a reply; the sibling's callback names it. Inside herdr, it requests a new unfocused tab in this host's workspace for pi, claude-code or pi-durable; elsewhere it needs the tmux pane this host itself was launched in."
 			},
 			"parameters": {
-				"backend": "Which fixed runtime to open. Only these six, and only pi/claude-code when this agent runs inside herdr; there is no arbitrary command.",
-				"cwd": "Optional literal ABSOLUTE path of an existing directory to start the sibling in (cross-repo fresh). Omit or pass \"\" to start where the CALLER is — this agent's own cwd on BOTH rails, or for a Codex caller its own record directory, because this bridge is the app-server's child and that process's directory is not the caller's. Taken exactly as given: no trim, no realpath, no project-name resolution. '#' is refused on the tmux rail only, because tmux format-expands a start directory; inside herdr it is an ordinary path character. The receipt echoes the directory that was REQUESTED or the caller record it came from, never an observation of where the pane landed.",
+				"backend": "Which fixed runtime to open. Only these six, and only pi/claude-code/pi-durable when this agent runs inside herdr; there is no arbitrary command.",
+				"cwd": "Optional literal ABSOLUTE path of an existing directory to start the sibling in (cross-repo fresh). Omit or pass \"\" to start where the CALLER is — this agent's own cwd on BOTH rails, or for a Codex caller its own record directory, because this bridge is the app-server's child and that process's directory is not the caller's. Taken exactly as given: no trim, no realpath, no project-name resolution. '#' is refused on the tmux rail only, because tmux format-expands a start directory; inside herdr it is an ordinary path character. The receipt echoes the directory that was REQUESTED, a Codex caller's record directory, or another caller's own process directory, never an observation of where the pane landed.",
 				"model": "Required runtime model: canonical provider/model for pi (a bare alias is refused), provider/<exact catalog model id> for pi-durable, a Claude Code model id/alias, or a Copilot/OMP/Codex model name. Neither pi nor pi-durable may name the openrouter provider.",
 				"placement": "Optional expert seat override, TMUX ONLY: open the sibling in ONE EXISTING tmux session of this agent's own server, and it always wins. When omitted the seat follows the CALLER, never the backend being opened: a Codex CALLER opens beside its own TUI pane, matched by thread-id in that pane's terminal title (0 or 2+ matching panes refuse, never fall back); every other caller opens in its own session. A pane title is a placement input only — never an address, liveness or delivery fact. Nothing is ever created. Inside herdr this field is refused by name — placement there belongs to herdr, and a tmux session name would silently place the sibling somewhere else. Independent of cwd; neither is inferred from the other. The receipt reports the selected name (absent for the caller-pane rule, which observed a session rather than requesting a name), its source, and resolved target session id.",
 				"placement.tmuxSession": "EXACT name of an EXISTING session on this agent's own tmux server. Nothing is created: an absent session is refused as tmux-session-missing, and a name outside [A-Za-z0-9][A-Za-z0-9_-]* as tmux-session-name-invalid.",
@@ -138,11 +186,11 @@
 		},
 		"entwurf_resume_call": {
 			"descriptions": {
-				"mcp": "Only on an explicit operator request, reopen ONE DORMANT pi or Claude Code citizen under its OWN garden id, in a visible window in the operator's own tmux session. The record supplies everything — which session, which cwd, and for pi which transcript, model and provider — so the only input is the target id: there is no model override, no task, and no prompt, and a Claude Code session comes back as `claude --resume <its session id>` with none of the model or permission flags it was once started with. This verb submits NO prompt; what the runtime itself does after it comes back (for Claude Code, its hook re-arms the doorbell and unread mail may then wake a turn) is not measured, and talking to it is still entwurf_v2 fire-and-forget. You get TWO receipts and they mean different things: a LAUNCH receipt (tmux made a window and was asked to start the runtime) and an OBSERVATION receipt (pi: the control socket answered under the same id; Claude Code: a NEW live process in the window this call opened re-armed its receiver marker for the same session with a fresh arm binding the record also carries; or resume-unobserved; or record-unreadable with its cause). Unobserved is a real outcome, not an error to retry — the window is visible, so read it. A citizen that is already LIVE is refused: address it with entwurf_v2 instead. A Claude Code citizen is reopened only when the last validated owner the Entwurf hook armed for its session is proven gone AND that arm is still the record's last one; no marker, an unreadable or mismatched one, an inconclusive owner or an unbound one is refused, and a process holding the session without a committed hook attach is invisible to that proof. Other backends have no same-id resume. Requires that this agent itself runs inside tmux (inside herdr it is refused).",
-				"durable": "Only on an explicit operator request, reopen ONE dormant pi or Claude Code citizen under its own garden id in a visible tmux window through the entwurf-bridge (target required; the record supplies the session and cwd — no task or prompt is submitted). Returns the bridge's LAUNCH and OBSERVATION receipts or its named refusal: a live target, another backend, or a Claude Code citizen not proven dormant is refused by name, and opening the window needs the tmux session this host itself was launched in. Existing unread mail may still wake the resumed runtime; neither receipt proves what it did."
+				"mcp": "Only on an explicit operator request, reopen ONE DORMANT pi, pi-durable or Claude Code citizen under its OWN garden id, in a visible window in the operator's own tmux session — or, inside herdr, a new herdr tab. The record supplies session, cwd and, for pi, the transcript's model and provider; the only input is the target id (no model override, task or prompt). Claude Code returns as `claude --resume <session id>` without its earlier model or permission flags. This verb submits NO prompt; what the runtime does once back (for Claude Code, unread mail may wake a turn) is not measured; talking to it is still entwurf_v2 fire-and-forget. TWO receipts mean different things: a LAUNCH receipt (a tmux window or herdr tab was made and asked to start the runtime) and an OBSERVATION receipt (pi: the control socket answered under the same id; pi-durable: the started child adopted this call's reservation (not readiness), or not-yet-adopted / reservation-lost; Claude Code: a NEW live process in this call's window or tab re-armed the session's marker with a fresh binding in the record, or pane-process-unread if herdr reports no pane child; or resume-unobserved, or record-unreadable with its cause). Unobserved is an outcome, not an error to retry; read the visible window. A session a live process holds is refused: a running citizen is reached only via entwurf_v2's rail check; an unadopted pi-durable reservation is not reachable by entwurf_v2. pi-durable reopens only if its session claim is closed and released or its holder is proven gone. Claude Code reopens only if the last validated owner its Entwurf hook armed is proven gone AND that arm is still the record's last; a missing, unreadable, mismatched or unbound marker or an inconclusive owner refuses, and a session held without a committed hook attach is invisible to that proof. Other backends have no same-id resume. This agent itself must run inside tmux or herdr; a herdr launch never falls back to tmux.",
+				"durable": "Only on an explicit operator request, reopen ONE dormant pi, pi-durable or Claude Code citizen under its own garden id in a visible tmux window — or, inside herdr, a new herdr tab — through the entwurf-bridge (target required; the record supplies the session and cwd — no task or prompt is submitted). Returns the bridge's LAUNCH and OBSERVATION receipts or its named refusal: a session a live process holds (a running citizen, or a pi-durable reservation awaiting adoption), another backend, or a citizen not proven dormant is refused by name, and opening it needs the tmux session — or the herdr pane — this host itself was launched in; a herdr launch never falls back to tmux. Existing unread mail may still wake the resumed runtime; neither receipt proves what it did."
 			},
 			"parameters": {
-				"target": "Garden id of the DORMANT pi or Claude Code citizen to reopen (discover with entwurf_peers)."
+				"target": "Garden id of the DORMANT pi, pi-durable or Claude Code citizen to reopen (discover with entwurf_peers)."
 			}
 		},
 		"entwurf_retire_call": {
@@ -171,16 +219,16 @@
 	},
 	"resumeRejectHints": {
 		"target-invalid": "the target is not a valid garden id; use entwurf_peers to discover valid targets",
-		"target-backend-unsupported": "that citizen's backend has no same-id resume (only pi and Claude Code do) — reach it with entwurf_v2, or open a fresh sibling",
+		"target-backend-unsupported": "that citizen's backend has no same-id resume (only pi, pi-durable and Claude Code do) — reach it with entwurf_v2, or open a fresh sibling",
 		"target-locked": "another resume or dispatch holds this citizen's lock right now",
-		"target-live": "that citizen is already running — this verb only reopens dormant ones",
-		"target-indeterminate": "the citizen could not be proven dormant (an inconclusive socket probe or receiver owner), so nothing was started",
+		"target-live": "a live process holds that citizen's session — this verb only reopens dormant ones",
+		"target-indeterminate": "the citizen could not be proven dormant (an inconclusive socket probe, receiver owner or session holder), so nothing was started",
 		"target-receiver-absent": "a Claude Code citizen is proven dormant only by its receiver marker, and it has none — there is no marker with which this verb could prove dormancy, so it opens nothing. Ask the human operator whether its window is still open; reopening it is the operator's act, not this verb's",
 		"target-receiver-corrupt": "the citizen's receiver marker cannot be read as a marker, so its owner cannot be judged",
 		"target-receiver-mismatch": "the receiver marker under this garden id names another backend or native session than the record — look at the store before anything reopens",
 		"target-receiver-unbound": "the dead receiver owner is not bound to the record's last arm (none observed, a later attach, or the record moved), so a Claude Code process may still hold the session and this verb opens nothing. Ask the human operator whether its window is still open; reopening it is the operator's act, not this verb's",
 		"target-address-conflict": "that citizen's control-socket path is corrupt",
-		"launch-refused": "tmux was never asked to open a window"
+		"launch-refused": "the launcher refused before creating anything — no tmux window and no herdr tab was opened"
 	},
 	"freshLaunchRejectHints": {
 		"no-tmux-context": "this agent is not running inside tmux, so there is no session to open a sibling beside",
@@ -212,7 +260,7 @@
 		"cwd-format-token": "the recorded cwd contains '#', which tmux expands as a format inside -c — it would silently rewrite the path or run a command",
 		"cwd-missing": "the recorded cwd no longer exists; tmux would not report this, it would open the window in $HOME and look successful",
 		"cwd-not-directory": "the recorded cwd exists but is not a directory",
-		"herdr-resume-unsupported": "this agent runs inside herdr, and same-id resume has only a tmux rail — nothing was opened in any ambient tmux session",
+		"herdr-resume-unsupported": "this agent runs inside herdr, where this tmux resume leaf does not open anything — nothing was opened in any ambient tmux session (from inside herdr, entwurf_resume_call reopens through its herdr rail instead)",
 		"runtime-unresolved": "the citizen's runtime (pi or claude) is not installed on PATH",
 		"runtime-not-absolute": "the resolved runtime path is not absolute",
 		"runtime-path-whitespace": "the resolved runtime path contains whitespace, which tmux would re-split",

package/mcp/entwurf-bridge/dist/mcp/entwurf-bridge/src/index.js

@@ -31,9 +31,10 @@
  *                       seat, #105; nothing is ever created), optionally at ONE literal requested
  *                       cwd (cross-repo fresh, #73); returns a LAUNCH receipt only, and the new
  *                       address arrives later as the sender envelope of the sibling's nonce callback.
- *   - entwurf_resume_call — reopen ONE DORMANT pi or Claude Code citizen under its OWN garden id
- *                       in a visible window; target-only, submits no prompt, LAUNCH and OBSERVATION
- *                       receipts stay apart, the caller is attributed but grants nothing.
+ *   - entwurf_resume_call — reopen ONE DORMANT pi, pi-durable or Claude Code citizen under its OWN
+ *                       garden id in a visible window or herdr tab; target-only, submits no prompt,
+ *                       LAUNCH and OBSERVATION receipts stay apart, the caller is attributed but
+ *                       grants nothing.
  *   - entwurf_retire_call — one operator-requested target, one retirement attempt; actor is not
  *                       permission, and action / append-record / lock-release receipts stay separate.
  *   - entwurf_callback — ZERO-ARGUMENT fresh-sibling callback. Reads ENTWURF_CALLBACK_TARGET +
@@ -84,10 +85,10 @@ import { retireCitizen } from "../../../pi-extensions/lib/entwurf-v2-retire.js";
 import { makeProductionRetireDeps } from "../../../pi-extensions/lib/entwurf-v2-retire-production.js";
 import { runAndRenderEntwurfV2FromSurface } from "../../../pi-extensions/lib/entwurf-v2-surface.js";
 import { makeVisibleResumeDeps, renderVisibleResume, visibleResume, } from "../../../pi-extensions/lib/entwurf-v2-visible-resume.js";
-import { dispatchFreshCall, renderDispatchedFreshCall } from "../../../pi-extensions/lib/fresh-call-dispatch.js";
+import { dispatchFreshCall, dispatchResumeLaunch, renderDispatchedFreshCall, } from "../../../pi-extensions/lib/fresh-call-dispatch.js";
 import { probeNativeSenderAlive, reconcileSenderIdentityClaims, resolveCodexRequestSenderIdentity, resolveTrustedMetaSenderIdentity, } from "../../../pi-extensions/lib/meta-sender-identity.js";
 import { applyOmpBridgeChildRootPolicy, defaultMetaMailboxDir, defaultMetaSessionsDir, makeStoreRecordReader, readActiveStoreEntries, readMetaIdentityByGardenId, readMetaInbox, readMetaReceiverMarker, readMetaSenderMarker, requireBackend, } from "../../../pi-extensions/lib/meta-session.js";
-import { RESUME_CALL_REJECT_HINT, resumeCall } from "../../../pi-extensions/lib/mux-resume-call.js";
+import { RESUME_CALL_REJECT_HINT, resumeCall, resumePiDurableCall, } from "../../../pi-extensions/lib/mux-resume-call.js";
 import { registerNativeConversation } from "../../../pi-extensions/lib/native-push/register.js";
 import { makeLocalTraceFact, readRemotePairOptIn, remotePairOptInPath, runEntwurfV2WithRemoteRoute, } from "../../../pi-extensions/lib/remote-pair-send.js";
 import { processTransport } from "../../../pi-extensions/lib/remote-pair-transport.js";
@@ -641,12 +642,22 @@ server.tool("entwurf_fresh_call", ENTWURF_TOOL_GUIDANCE.entwurf_fresh_call.descr
 // halves, so it is where the mux launcher is handed to the v2 composition. `entwurf-v2-visible-
 // resume` cannot open a window on its own and `mux-resume-call` cannot read a record — that is
 // the import fence in docs/mux-launch-rail.md §11, expressed as a function argument.
-const visibleResumeLaunch = (input) => {
-    const launched = resumeCall({ backend: input.backend, cwd: input.cwd, runtimeArgs: input.runtimeArgs });
+//
+// #157 G1a: this surface does NOT choose the rail. It hands the fixed tmux mapping below to the
+// shared rail root (`fresh-call-dispatch`), which reads the same capability fact fresh_call reads
+// and, inside herdr, launches the herdr resume instead — never calling this mapping there.
+//
+// #157 B3: a pi-durable resume is the same leaf's second entry, which also carries the fixed adopt
+// projection the v2 side built from its reservation; no other backend can hand it one.
+const tmuxResumeLaunch = (input) => {
+    const launched = input.backend === "pi-durable"
+        ? resumePiDurableCall({ cwd: input.cwd, runtimeArgs: input.runtimeArgs, adoptEnv: input.piDurableAdoptEnv })
+        : resumeCall({ backend: input.backend, cwd: input.cwd, runtimeArgs: input.runtimeArgs });
     return launched.ok
-        ? { ok: true, handle: launched.receipt }
+        ? { ok: true, handle: { rail: "tmux", ...launched.receipt } }
         : { ok: false, reason: launched.reason, hint: RESUME_CALL_REJECT_HINT[launched.reason] };
 };
+const visibleResumeLaunch = (input) => dispatchResumeLaunch(input, tmuxResumeLaunch);
 server.tool("entwurf_resume_call", ENTWURF_TOOL_GUIDANCE.entwurf_resume_call.descriptions.mcp, {
     target: z
         .string()