@junghanacs/entwurf 0.31.0 → 0.33.0

package/pi/pi-durable/carrier-relocation.mjs

@@ -0,0 +1,160 @@
+// The pi-durable carrier's ONE relocation grammar (#130), shared by the maintainer emitter
+// (scripts/emit-pi-durable-carrier.ts) and the runtime resolver (./carrier-resolver.mjs), so the
+// rewrite the emitter performs and the resolution the runtime accepts cannot drift apart.
+//
+// The durable app is source-only upstream: published `@earendil-works/pi-coding-agent` ships no
+// `dist/experimental`, and its exports map exposes no deep `dist/` path. The carrier is the pinned
+// upstream app files, type-stripped, with exactly two rewrites:
+//
+//   "./<sibling>.ts"   → "./<sibling>.js"                 a carrier file importing another carrier file
+//   "../../<path>.ts"  → entwurf-pi-dist:<path>.js        the app importing a pi-coding-agent internal
+//
+// Every other specifier — `@earendil-works/*`, `proper-lockfile`, `node:*` — is left untouched and
+// resolves by Node's own rules from where the carrier is installed. The reserved scheme is chosen so
+// that a carrier loaded WITHOUT the resolver fails by name (Node refuses an unknown URL scheme) rather
+// than quietly resolving `../../` inside this package. The resolver accepts the scheme only from a
+// declared carrier file and only for a declared target, and maps it to that file under the PHYSICAL
+// root of the pi-coding-agent the carrier itself resolves — never through the exports map.
+//
+// Plain JS on purpose: the resolver is preloaded with `node --import` from an installed package,
+// where Node does not strip types, and it must not depend on the compiled bridge closure.
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const CARRIER_SCHEME = "entwurf-pi-dist:";
+export const CODING_AGENT = "@earendil-works/pi-coding-agent";
+
+/** A refusal with a stable name first, as the bootstrap's. */
+function refuse(reason, detail) {
+	return Object.assign(new Error(`${reason}: ${detail}`), { reason });
+}
+
+/** A static import, export-from or side-effect import statement as upstream writes them: double quotes,
+ * the statement ending its line. A multi-line `import {` … `} from "x";` matches from its `import`. */
+const STATEMENT = /^(\s*(?:import|export|\})[^;]*?\bfrom\s*")([^"]+)(";[ \t]*)$|^(\s*import\s*")([^"]+)(";[ \t]*)$/gm;
+/** Every place a module specifier can begin — the statements above, and anything they would miss. */
+const ANY_SPECIFIER = /\b(?:from|import)\s*["'(]/g;
+
+/**
+ * Rewrite one type-stripped carrier source. `siblings` are the carrier file names (`runtime.js` …),
+ * `targets` the declared pi-coding-agent dist paths (`core/model-runtime.js` …). Throws by name on a
+ * relative specifier outside those two rules, a dynamic import, or a specifier the statement grammar
+ * did not recognize. Returns the rewritten code and the targets it used.
+ *
+ * @param {string} file
+ * @param {string} code
+ * @param {{ siblings: readonly string[], targets: readonly string[] }} declared
+ * @returns {{ code: string, used: string[] }}
+ */
+export function relocateCarrierSource(file, code, { siblings, targets }) {
+	const used = new Set();
+	let statements = 0;
+	const rewrite = (spec) => {
+		if (spec.startsWith("./")) {
+			const name = `${spec.slice(2, -3)}.js`;
+			if (!spec.endsWith(".ts") || !siblings.includes(name)) {
+				throw refuse("carrier-relocation-unknown-sibling", `${file} imports ${spec}`);
+			}
+			return `./${name}`;
+		}
+		if (spec.startsWith("../../")) {
+			const target = `${spec.slice(6, -3)}.js`;
+			if (!spec.endsWith(".ts") || !targets.includes(target)) {
+				throw refuse("carrier-relocation-unknown-target", `${file} imports ${spec}`);
+			}
+			used.add(target);
+			return `${CARRIER_SCHEME}${target}`;
+		}
+		if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith(CARRIER_SCHEME)) {
+			throw refuse("carrier-relocation-unknown-relative", `${file} imports ${spec}`);
+		}
+		return spec;
+	};
+	const out = code.replace(STATEMENT, (_all, headA, specA, tailA, headB, specB, tailB) => {
+		statements++;
+		return headA !== undefined ? `${headA}${rewrite(specA)}${tailA}` : `${headB}${rewrite(specB)}${tailB}`;
+	});
+	const begun = (code.match(ANY_SPECIFIER) ?? []).length;
+	if (begun !== statements) {
+		throw refuse(
+			"carrier-relocation-unrecognized-import",
+			`${file}: ${begun} specifier openings, ${statements} recognized statements (a dynamic import, a single-quoted or mid-line import)`,
+		);
+	}
+	return { code: out, used: [...used].sort() };
+}
+
+/**
+ * The carrier section of the packaged pin, validated. A malformed pin throws (crash, don't warn).
+ *
+ * @param {URL | string} pinPath
+ * @returns {{ files: string[], targets: string[] }}
+ */
+export function readCarrierDeclaration(pinPath) {
+	const pin = JSON.parse(readFileSync(pinPath, "utf8"));
+	const carrier = pin?.carrier;
+	const names = Array.isArray(carrier?.files) ? carrier.files.map((f) => f?.name) : undefined;
+	const targets = carrier?.distTargets;
+	const plain = (s) => typeof s === "string" && /^[a-z0-9-]+(?:\/[a-z0-9-]+)*\.js$/.test(s);
+	if (!names?.every(plain) || names.length === 0 || names.some((n) => n.includes("/"))) {
+		throw refuse("pi-durable-carrier-pin-malformed", "carrier.files must name plain carrier .js files");
+	}
+	if (!Array.isArray(targets) || targets.length === 0 || !targets.every(plain)) {
+		throw refuse("pi-durable-carrier-pin-malformed", "carrier.distTargets must list relative dist .js paths");
+	}
+	return { files: names, targets };
+}
+
+/**
+ * The PHYSICAL `dist/` directory of the pi-coding-agent the carrier resolves, from the URL its root
+ * export resolved to (`<root>/dist/index.js`). Refuses by name when that is not the package root.
+ *
+ * @param {string} rootExportUrl
+ */
+export function codingAgentDistFrom(rootExportUrl) {
+	const entry = rootExportUrl.startsWith("file:") ? fileURLToPath(rootExportUrl) : "";
+	const dist = path.dirname(entry);
+	const root = path.dirname(dist);
+	const manifest = path.join(root, "package.json");
+	if (path.basename(entry) !== "index.js" || path.basename(dist) !== "dist" || !existsSync(manifest)) {
+		throw refuse(
+			"pi-durable-carrier-host-root",
+			`${CODING_AGENT} resolved to ${rootExportUrl}, not <root>/dist/index.js`,
+		);
+	}
+	const name = JSON.parse(readFileSync(manifest, "utf8")).name;
+	if (name !== CODING_AGENT) {
+		throw refuse("pi-durable-carrier-host-root", `${manifest} names ${JSON.stringify(name)}, not ${CODING_AGENT}`);
+	}
+	return dist;
+}
+
+/**
+ * Resolve one reserved specifier. Only a declared carrier file may ask, only for a declared target,
+ * and the target file must exist. Returns the file URL; everything else throws by name.
+ *
+ * @param {string} specifier  begins with CARRIER_SCHEME
+ * @param {string | undefined} parentURL
+ * @param {{ carrierDirUrl: string, files: readonly string[], targets: readonly string[], dist: () => string }} declared
+ */
+export function resolveCarrierSpecifier(specifier, parentURL, { carrierDirUrl, files, targets, dist }) {
+	const parent =
+		typeof parentURL === "string" && parentURL.startsWith(carrierDirUrl) ? parentURL.slice(carrierDirUrl.length) : "";
+	if (!files.includes(parent)) {
+		throw refuse(
+			"pi-durable-carrier-specifier-origin",
+			`${specifier} asked from ${parentURL ?? "no parent"}, not a carrier file`,
+		);
+	}
+	const target = specifier.slice(CARRIER_SCHEME.length);
+	if (!targets.includes(target)) {
+		throw refuse("pi-durable-carrier-specifier-unknown", `${specifier} (from ${parent}) is not a declared target`);
+	}
+	const file = path.join(dist(), target);
+	if (!existsSync(file)) {
+		throw refuse("pi-durable-carrier-target-missing", `${specifier} → ${file} does not exist`);
+	}
+	return pathToFileURL(file).href;
+}

package/pi/pi-durable/carrier-resolver.mjs

@@ -0,0 +1,38 @@
+// The pi-durable carrier's resolver (#130): preloaded as `node --import <this file>` before the
+// packaged bootstrap. It registers ONE synchronous resolve hook that answers only the carrier's
+// reserved entwurf-pi-dist: specifiers (grammar and refusals: ./carrier-relocation.mjs) and hands
+// every other specifier to Node unchanged. It is not a source/TypeScript resolver and it never reads
+// a checkout, a runtime directory or an environment variable: the pi-coding-agent it maps into is the
+// one the carrier itself resolves from where this package is installed.
+
+import { registerHooks } from "node:module";
+import {
+	CARRIER_SCHEME,
+	CODING_AGENT,
+	codingAgentDistFrom,
+	readCarrierDeclaration,
+	resolveCarrierSpecifier,
+} from "./carrier-relocation.mjs";
+
+const { files, targets } = readCarrierDeclaration(new URL("./overlay/upstream-pin.json", import.meta.url));
+const carrierDirUrl = new URL("./carrier/", import.meta.url).href;
+let dist;
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (!specifier.startsWith(CARRIER_SCHEME)) return nextResolve(specifier, context);
+		const url = resolveCarrierSpecifier(specifier, context.parentURL, {
+			carrierDirUrl,
+			files,
+			targets,
+			// From a carrier file, as the carrier's own bare imports resolve — never the exports map.
+			dist: () => {
+				dist ??= codingAgentDistFrom(
+					nextResolve(CODING_AGENT, { ...context, parentURL: `${carrierDirUrl}${files[0]}` }).url,
+				);
+				return dist;
+			},
+		});
+		return { url, shortCircuit: true };
+	},
+});

package/pi/pi-durable/overlay/upstream-pin.json

@@ -1,16 +1,108 @@
 {
-	"schemaVersion": 1,
-	"comment": "The one upstream commit this overlay is maintained against, and the patch it applies. The experimental durable app is source-only upstream, so its runtime is a pinned checkout plus this patch, provisioned by the operator; Entwurf ships neither. A checkout's TRACKED tree counts as this overlay only when HEAD equals commit, `git diff` equals the patch bytes exactly, and no non-ignored file is untracked. Git-ignored runtime inputs are outside that equality and are described separately below.",
+	"schemaVersion": 2,
+	"comment": "The one upstream commit the pi-durable carrier is emitted from, the patch it applies, the emitted files and the published SDK set they run against. The experimental durable app is source-only upstream (published pi-coding-agent ships no dist/experimental), so Entwurf ships it as a CARRIER: the pinned app files, type-stripped, with the relocation in pi/pi-durable/carrier-relocation.mjs. scripts/emit-pi-durable-carrier.ts is the only writer of the generated fields (blob, sha256, emitter.node) and the only reader of upstream source; an installed package never reads source. Model data rides the published @earendil-works/pi-ai.",
 	"repository": "https://github.com/earendil-works/pi",
-	"commit": "cd32f7725fdbddbaecdff5b1e68491563394e0ca",
+	"tag": "v1.1.0",
+	"commit": "abe508e1b89912adde45528136c3221eb69acdd7",
 	"patches": ["runtime-contacts.patch"],
-	"modelData": {
-		"comment": "Git-ignored generated model data the runtime imports at open. Upstream hydrates it by calling vendor model-list endpoints; this overlay instead takes the bytes the v1.0.2 release built from this commit, from the published package below, with no network. aggregateSha256 is sha256 over one `<sha256 of file>  <file name>\\n` line per *.json file (dotfiles excluded), names in C byte order. upstream `packages/ai/scripts/check-model-data.ts` validates these bytes against the manifest.",
-		"path": "packages/ai/src/providers/data",
-		"source": "@earendil-works/pi-ai@1.0.2 dist/providers/data",
-		"integrity": "sha512-JP59xGlSAQ/HhQ6EHN5qmneBlWfDyu6FPPryAvAaSo8A38ubAsEpS9YisCM5Jbbns0srrDffLZonE0OXorHI5A==",
-		"files": 42,
-		"aggregateSha256": "e71a1965a81c29fbe83d6e90dc1f4595602588281374603dee9e3bcbb7f46fa4",
-		"manifestSha256": "d373b99c0860f84281d786d493e8d8237c0a9fd98f142ef31c6db187c5089bc5"
+	"carrier": {
+		"comment": "files: the six app files bootstrap.mjs needs (main.ts is replaced by the bootstrap). distTargets: every pi-coding-agent internal the stripped files import, as paths under the published dist/; the emitter refuses a set that differs and the resolver answers no other.",
+		"emitter": {
+			"tool": "node:module.stripTypeScriptTypes",
+			"mode": "strip",
+			"node": "v24.18.1"
+		},
+		"license": {
+			"source": "LICENSE",
+			"blob": "b0a8e9b81083294360c69b4ec45d3d39a2b28197",
+			"sha256": "0457f5bcec3b3b211605dfb5d1a49042fd638f3686a410fe099c24a25af13c48"
+		},
+		"files": [
+			{
+				"name": "runtime.js",
+				"source": "packages/coding-agent/src/experimental/durable/runtime.ts",
+				"patched": true,
+				"blob": "fcd6e5239e999ebf17dea0335fb3dc9cd7f7ce45",
+				"sha256": "ca0ee10dc904a57d46bb33b37fcc4efe48dfa08b2f0d10e79e7bc22136871f0a"
+			},
+			{
+				"name": "tui.js",
+				"source": "packages/coding-agent/src/experimental/durable/tui.ts",
+				"patched": false,
+				"blob": "397b276cbeb1c90e1fbc96c3cc59e6a25f92dad7",
+				"sha256": "bef1ea4bd6e8ab150273752a9b94552d8ce672b518ba3d1ed1a209b8405be1b3"
+			},
+			{
+				"name": "harness-setup.js",
+				"source": "packages/coding-agent/src/experimental/durable/harness-setup.ts",
+				"patched": false,
+				"blob": "4d6a4be5333ebb8e0f17eac1987f18ea35a91fc7",
+				"sha256": "712b630145dc6f5c655a85b01b1e20299c962542e63c5494d2202bb7bf414a15"
+			},
+			{
+				"name": "prompt.js",
+				"source": "packages/coding-agent/src/experimental/durable/prompt.ts",
+				"patched": false,
+				"blob": "8e2f5d5273fba58da8b314766956ed62951c3814",
+				"sha256": "ff1ff765fa313e5cb1c3d7537c901c23adb0562ee433bd050fd35eb3d892134c"
+			},
+			{
+				"name": "sessions.js",
+				"source": "packages/coding-agent/src/experimental/durable/sessions.ts",
+				"patched": false,
+				"blob": "34f9ceeeaeaf874f7478d56115da2e4f726c6a85",
+				"sha256": "1bd1a04ece66f5ab3ca22860c64dba9abc848334d11a27a9afe543f1365c7254"
+			},
+			{
+				"name": "subagent.js",
+				"source": "packages/coding-agent/src/experimental/durable/subagent.ts",
+				"patched": false,
+				"blob": "e767d54e0bf2908e0f4f41c6933b55c00562eb25",
+				"sha256": "8a75d934ef87efbb0bb2006a2141f1ea932560851f1718b991ed947d6efdb54c"
+			}
+		],
+		"distTargets": [
+			"config.js",
+			"core/http-dispatcher.js",
+			"core/keybindings.js",
+			"core/model-resolver.js",
+			"core/model-runtime.js",
+			"core/resource-loader.js",
+			"core/settings-manager.js",
+			"core/skills.js",
+			"core/system-prompt.js",
+			"core/tools/bash.js",
+			"core/tools/edit.js",
+			"core/tools/read.js",
+			"core/tools/renderers/index.js",
+			"core/tools/write.js",
+			"modes/interactive/components/assistant-message.js",
+			"modes/interactive/components/custom-editor.js",
+			"modes/interactive/components/dynamic-border.js",
+			"modes/interactive/components/footer.js",
+			"modes/interactive/components/keybinding-hints.js",
+			"modes/interactive/components/status-indicator.js",
+			"modes/interactive/components/tool-execution.js",
+			"modes/interactive/components/user-message.js",
+			"modes/interactive/theme/theme-controller.js",
+			"modes/interactive/theme/theme.js"
+		]
+	},
+	"sdk": {
+		"comment": "The published library set the carrier runs against, derived from the 1.1.0 declarations. members: the @earendil-works packages the carrier imports and every @earendil-works package those declare. direct: a third-party package a carrier file imports itself (sessions.ts: proper-lockfile, at the version pi-coding-agent 1.1.0 pins). Each is an exact production dependency in package.json; the members' own edges are caret ranges, so the installed physical edges, not semver, are what must equal these versions.",
+		"members": {
+			"@earendil-works/chord": "1.1.0",
+			"@earendil-works/pi-agent-core": "1.1.0",
+			"@earendil-works/pi-ai": "1.1.0",
+			"@earendil-works/pi-codemode": "1.1.0",
+			"@earendil-works/pi-coding-agent": "1.1.0",
+			"@earendil-works/pi-durable": "1.1.0",
+			"@earendil-works/pi-mcp": "1.1.0",
+			"@earendil-works/pi-telemetry": "1.1.0",
+			"@earendil-works/pi-tui": "1.1.0"
+		},
+		"direct": {
+			"proper-lockfile": "4.1.2"
+		}
 	}
 }

package/pi-extensions/lib/fresh-call-composition.ts

@@ -27,7 +27,7 @@ import { randomBytes } from "node:crypto";
 /** The backends this rail can open. Fixed set, not a profile — a further one is a decision,
  * not a config entry. `copilot` was added by #82 RAIL 9, `omp` by #87 Bundle C, `codex`
  * by #95 after its system birth and app-server rails were measured, and `pi-durable` by #129
- * (the operator-provided durable app through the managed `entwurf pi-durable`). The set is joined to the
+ * (the durable app this package carries, through the managed `entwurf pi-durable`). The set is joined to the
  * citizen backends by `check-harness-admission-parity`: a harness that mints records but is
  * missing HERE is not an unwired convenience, it is a release blocker. */
 export const FRESH_CALL_BACKENDS = ["pi", "claude-code", "copilot", "omp", "codex", "pi-durable"] as const;

package/pi-extensions/lib/mux-fresh-call.ts

@@ -244,9 +244,9 @@ export const FRESH_CALL_RUNTIME: Record<FreshCallBackend, string> = {
 	copilot: "entwurf",
 	omp: "omp",
 	codex: "codex",
-	// #129: like copilot, a MANAGED verb and never the bare app. The durable app is source-only
-	// and runs under the operator-provided runtime's own resolver; `entwurf pi-durable` is the one
-	// fixed invocation that verifies that runtime against the pin and execs the packaged bootstrap.
+	// #129/#130: like copilot, a MANAGED verb and never the bare app. The durable app is this
+	// package's carrier and runs under the carrier's resolver; `entwurf pi-durable` is the one fixed
+	// invocation that verifies the carrier and its SDK set and execs the packaged bootstrap.
 	"pi-durable": "entwurf",
 };
 
@@ -519,15 +519,13 @@ export function freshCall(
 	}
 	if (params.backend === "pi-durable") {
 		// The framed first input is computed here only to MEASURE it against the bootstrap payload
-		// cap; the same pure function composes it again below. The runtime is located and verified
-		// with THIS process's env, before anything is placed. That is the bridge's env, not
-		// necessarily the window's: a new-window pane inherits the tmux SERVER's environment
-		// (measured, see SCRUBBED_INHERITED_ENV), and the window runs whatever `entwurf` PATH names.
-		// The managed verb re-verifies with its own env before it execs anything, so the window never
-		// runs an unverified runtime — but when HOME/XDG_DATA_HOME or the package closure differ, this
+		// cap; the same pure function composes it again below. The carrier is verified from THIS
+		// process's package closure, before anything is placed. The window runs whatever `entwurf`
+		// PATH names, and the managed verb re-verifies its own package before it execs anything, so
+		// the window never runs an unverified carrier — but when the two package closures differ, this
 		// verdict and the window's can disagree, and the window is left showing its own refusal.
 		const layout = piDurablePackageLayout();
-		const runtime = layout === null ? null : checkPiDurableRuntime(env, layout);
+		const runtime = layout === null ? null : checkPiDurableRuntime(layout);
 		const missing = piDurableFreshPreflight({
 			model,
 			firstInput: buildFreshCallPrompt({ backend: params.backend, task, callerGardenId, nonce }),

package/pi-extensions/lib/pi-durable-fresh-preflight.ts

@@ -19,9 +19,9 @@
  *                 `{v:2,task}` payload, whose decoder caps `task` at 16000 characters. A framed
  *                 task over that cap would open a window whose bootstrap refuses its own argv.
  *
- * ── Then the runtime, then the four units ──
+ * ── Then the carrier, then the four units ──
  *
- *   runtime          operator-provided at the fixed locator and verified against the pin
+ *   carrier          the package's own pi-durable carrier and its declared SDK set, verified
  *                    (`pi-durable-runtime.ts`); passed in as that check's verdict.
  *   birth            the compiled contact in this package's closure — it mints the record.
  *   MCP hand         the compiled entwurf-bridge entry in the same closure — the contact spawns it.
@@ -32,7 +32,7 @@
  *
  * ── What this deliberately does NOT claim ──
  *
- * Filesystem truth about ONE package closure and ONE runtime directory. It does not prove the durable
+ * Filesystem truth about ONE package closure and the SDK it resolves. It does not prove the durable
  * app opens, the bridge connects, the doorbell arms or a garden id renders — that is runtime truth for
  * the clause 7 LIVE receipt. No spawn, no network, no mutation; every path arrives as an argument, so
  * this leaf imports nothing but types.