@junghanacs/entwurf 0.45.0 → 0.50.0

package/pi-extensions/lib/pi-durable-runtime.ts

@@ -61,6 +61,9 @@ export interface PiDurablePackageLayout {
 	readonly bridgeEntry: string;
 	/** The compiled sender/receiver owner join the bridge decides deliverability with. */
 	readonly deliverability: string;
+	/** The compiled owner fence the packaged bootstrap imports. A fixed unit of this package that only the
+	 * fresh preflight asks for; the carrier/SDK verifier below does not read it. */
+	readonly ownerFence: string;
 }
 
 /** The layout rooted at `root`, as plain paths. */
@@ -77,6 +80,7 @@ export function piDurableLayoutAt(root: string): PiDurablePackageLayout {
 		adapter: path.join(dist, "pi-extensions", "meta-bridge-pi-durable.js"),
 		bridgeEntry: path.join(dist, "mcp", "entwurf-bridge", "src", "index.js"),
 		deliverability: path.join(dist, "pi-extensions", "lib", "entwurf-deliverability.js"),
+		ownerFence: path.join(dist, "pi-extensions", "lib", "pi-durable-owner-fence.js"),
 	};
 }
 

package/pi-extensions/lib/resume-launch-identity.ts

@@ -10,13 +10,15 @@
  * must equal `record.nativeSessionId`, an addressable read (#52) rather than a plain targeted one,
  * a recorded ACP provider must resolve its bridge.
  *
- * The domain is pi and claude-code (#147 L2). Both own their transcript and re-attach to the same
- * record when their native session reopens; this leaf only names that session. For pi it reads
- * the transcript header (the launch needs its provider/model/cwd). For claude-code it reads no
- * transcript at all — the vendor owns it, and `claude --resume <id>` needs nothing from it — and
- * checks only that the recorded path is an absolute file that still exists. Every other backend
- * is a named refusal: native-push citizens have no resume authority (AGENTS Hard Rule 10), and a
- * durable host is not reopened through Entwurf.
+ * The domain is pi and claude-code (#147 L2), and pi-durable (#157 B3). Each owns its transcript
+ * and re-attaches to the same record when its native session reopens; this leaf only names that
+ * session. For pi it reads the transcript header (the launch needs its provider/model/cwd). For
+ * claude-code it reads no transcript at all — the vendor owns it, and `claude --resume <id>` needs
+ * nothing from it — and checks only that the recorded path is an absolute file that still exists.
+ * For pi-durable it reads nothing beyond the record: the parent's reservation re-reads the record
+ * and its location inside its own holds, and the launched child selects its session from the record
+ * itself, so this leaf only says WHICH backend the address names. Every other backend is a named
+ * refusal: native-push citizens have no resume authority (AGENTS Hard Rule 10).
  *
  * It takes a bare garden id, not a plan: the plan type it used to destructure belonged to
  * the removed transport, and the identity question never needed the rest of it.
@@ -29,7 +31,7 @@ import { getEntwurfExplicitExtensions, readSessionIdentity } from "./entwurf-cor
 import { readAddressableMetaIdentity } from "./meta-session.ts";
 
 /** The backends with a visible same-id resume. A closed set: nothing outside it is reopened. */
-export const RESUME_BACKENDS = ["pi", "claude-code"] as const;
+export const RESUME_BACKENDS = ["pi", "claude-code", "pi-durable"] as const;
 export type ResumeBackend = (typeof RESUME_BACKENDS)[number];
 
 /**
@@ -42,8 +44,7 @@ export type ResumeBackend = (typeof RESUME_BACKENDS)[number];
  * except by looking. A Claude Code or agy garden id is different in kind: nothing is broken,
  * the operator simply asked a capability boundary to do something it does not cover, and the
  * honest answer is a named refusal rather than an error report about a store that is fine. Since
- * #147 L2 the boundary is `RESUME_BACKENDS`; a Codex, agy, Copilot, OMP or pi-durable garden id is
- * this refusal.
+ * #147 L2 the boundary is `RESUME_BACKENDS`; a Codex, agy, Copilot or OMP garden id is this refusal.
  *
  * It carries a `reason` so the caller matches on a FIELD. Parsing the message string would make
  * the wording load-bearing, and re-reading the record to ask "was it pi?" would read an address
@@ -55,7 +56,7 @@ export class ResumeBackendUnsupportedError extends Error {
 	constructor(gardenId: string, backend: string) {
 		super(
 			`resume-launch-identity: ${gardenId} is a ${backend} citizen — same-id resume is a host-adapter relaunch ` +
-				`capability, and its domain is ${RESUME_BACKENDS.join(" and ")}. ` +
+				`capability, and its domain is ${RESUME_BACKENDS.join(", ")}. ` +
 				`This is a capability boundary, not citizen rank.`,
 		);
 		this.name = "ResumeBackendUnsupportedError";
@@ -91,7 +92,19 @@ export interface ClaudeCodeLaunchIdentity {
 	attachIncarnation: string | null;
 }
 
-export type LaunchIdentity = PiLaunchIdentity | ClaudeCodeLaunchIdentity;
+/**
+ * A pi-durable citizen's facts, from the record only (#157 B3). Not launch inputs: the parent's
+ * reservation re-reads the record and its C4 location inside its own record-arm then S_D holds, and
+ * its launch takes the cwd from THAT pair. They are here so the backend the address names is read
+ * once, by the same addressable reader as every other backend.
+ */
+export interface PiDurableLaunchIdentity {
+	backend: "pi-durable";
+	nativeSessionId: string;
+	cwd: string;
+}
+
+export type LaunchIdentity = PiLaunchIdentity | ClaudeCodeLaunchIdentity | PiDurableLaunchIdentity;
 
 /**
  * Claude Code's session id grammar: a lowercase UUID. The value becomes an argv token after
@@ -180,6 +193,12 @@ function resolveClaudeCodeLaunchIdentity(
 export function resolveResumeLaunchIdentity(gardenId: string): LaunchIdentity {
 	const record = readAddressableMetaIdentity(gardenId);
 	if (record.backend === "claude-code") return resolveClaudeCodeLaunchIdentity(gardenId, record);
+	if (record.backend === "pi-durable") {
+		if (!path.isAbsolute(record.cwd)) {
+			throw new Error(`resume-launch-identity: ${gardenId} records a relative cwd ${JSON.stringify(record.cwd)}.`);
+		}
+		return { backend: "pi-durable", nativeSessionId: record.nativeSessionId, cwd: record.cwd };
+	}
 	if (record.backend !== "pi") {
 		throw new ResumeBackendUnsupportedError(gardenId, record.backend);
 	}

package/pi-extensions/meta-bridge-pi-durable.ts

@@ -10,7 +10,8 @@
  *   createPiDurableContact({ bridgeEntry })
  *     .extension          tools-only durable Extension, handed to the overlay's
  *                         `openDurable({ extensions })` BEFORE the Harness opens
- *     .attach(session)    once `openDurable` returns: upsert the record, name this process as
+ *     .attach(session)    once `openDurable` returns: commit the record's binding and its
+ *                         location evidence (`lib/pi-durable-location.ts`), name this process as
  *                         sender, spawn the compiled entwurf-bridge as a DIRECT child, then
  *                         release the tools
  *
@@ -93,17 +94,21 @@
  * refusal.
  *
  * CALLER FRESH (the sixth tool). `entwurf_fresh_call` lets this durable citizen open a sibling, under the
- * bridge's own schema (pinned below, including the `pi-durable` backend itself). The bridge places it
- * beside the tmux pane this host was launched in, which a fresh-opened durable host inherits; an
- * operator host started outside tmux gets the bridge's named `no-tmux-context` refusal. Exposing the
- * tool is not a caller LIVE proof.
+ * bridge's own schema (pinned below, including the `pi-durable` backend itself). Outside herdr, the bridge
+ * places it beside the tmux pane this host was launched in, which a fresh-opened durable host inherits,
+ * and an operator host started outside tmux gets the bridge's named `no-tmux-context` refusal. Inside
+ * herdr (`HERDR_ENV=1`, which the bridge child inherits from this host) it requests a new herdr tab
+ * instead, for pi, claude-code or pi-durable only; the other backends are refused by name, and nothing
+ * falls back to tmux. Exposing the tool is not a caller LIVE proof.
  *
  * CALLER RESUME (the seventh tool, #147 L1). `entwurf_resume_call` lets this durable citizen reopen a
- * DORMANT pi or Claude Code citizen under its own garden id (#147 L2), under the bridge's own
- * single-`target` schema (pinned below). The bridge decides everything else from the target's record,
- * exactly as for any other caller: other backends have no same-id resume, a live target is refused,
- * and the window opens in the tmux session this host was launched in. Exposing the tool names no new authority and is not a caller LIVE
- * proof; it never resumes this durable host itself.
+ * DORMANT pi, pi-durable or Claude Code citizen under its own garden id (#147 L2; pi-durable since
+ * #157 B3), under the bridge's own single-`target` schema (pinned below). The bridge decides everything
+ * else from the target's record, exactly as for any other caller: other backends have no same-id
+ * resume, a session a live process holds is refused, and outside herdr the window opens in the tmux
+ * session this host was launched in. Inside herdr a pi, pi-durable or Claude Code target reopens, in a
+ * new herdr tab (Claude Code since #157 stage 4). Exposing the tool names no new authority and is not a caller LIVE proof; it never resumes
+ * this durable host itself.
  *
  * NOT HERE: crash-safe receive. `entwurf_inbox_read` archives a body before the durable tool
  * result commits, so a crash between the two loses that body to the model; recovery settles the
@@ -126,10 +131,10 @@ import {
 	readMetaReceiverMarker,
 	readMetaSenderMarker,
 	requireGardenId,
-	upsertMetaSession,
 	writeMetaReceiverMarker,
 	writeMetaSenderMarker,
 } from "./lib/meta-session.ts";
+import { commitPiDurableBirth } from "./lib/pi-durable-location.ts";
 
 /** The backend id this contact mints under. */
 export const PI_DURABLE_BACKEND = "pi-durable" as const;
@@ -1159,9 +1164,18 @@ export function createPiDurableContact(options: PiDurableContactOptions): PiDura
 				}
 				const ownerPid = options.ownerPid ?? process.pid;
 				const sendersDir = path.resolve(options.sendersDir ?? defaultMetaSendersDir());
-				const upsert = upsertMetaSession({
-					input: { backend: PI_DURABLE_BACKEND, nativeSessionId: id, cwd, model: null, transcriptPath: null },
-					dir: options.sessionsDir ?? defaultMetaSessionsDir(),
+				const receiversDir = path.resolve(options.receiversDir ?? defaultMetaReceiversDir());
+				// The record and its location evidence, bound by one minted attachIncarnation under the
+				// record-arm lock of the receivers root this birth uses. A refusal here fails the birth;
+				// there is no unbound fallback. The pair is not one atomic commit: see the leaf's
+				// FAILURE STATES for what each failure leaves behind.
+				const upsert = commitPiDurableBirth({
+					nativeSessionId: id,
+					cwd,
+					sessionDirectory: session.directory,
+					ownerPid,
+					sessionsDir: options.sessionsDir ?? defaultMetaSessionsDir(),
+					receiversDir,
 				});
 				const gardenId = upsert.record.gardenId;
 				const markerPath = writeMetaSenderMarker({
@@ -1176,7 +1190,7 @@ export function createPiDurableContact(options: PiDurableContactOptions): PiDura
 					sessionsDir: upsert.dir,
 					sendersDir,
 					mailboxDir: path.resolve(options.mailboxDir ?? defaultMetaMailboxDir()),
-					receiversDir: path.resolve(options.receiversDir ?? defaultMetaReceiversDir()),
+					receiversDir,
 				};
 				const client = await connect({
 					command: process.execPath,