@junghanacs/entwurf 0.36.1 → 0.37.0

package/CHANGELOG.md

@@ -4,6 +4,102 @@ All notable changes to this project will be documented here. Format follows [Kee
 
 ## Unreleased
 
+## 0.37.0 - 2026-10-15
+
+### pi-durable
+
+- **The durable app forwards pi's transport and stops compacting beside a running turn (#143).**
+  The owned Harness settings now carry `SettingsManager.getTransport()` (pi's default `auto`)
+  into every request; the reference app had left the field out, so the SDK chose per connection.
+  `auto` permits a cached WebSocket continuation only when the provider's own body and prefix
+  conditions hold; it does not make every request a delta. Background compaction is off
+  (`backgroundTokens: 0`): a turn past the blocking threshold waits for the SDK's summary instead
+  of one being written beside it. Threshold, manual and overflow compaction stay the SDK's, on
+  pi's own compaction settings. The SDK engine, models, auth and storage are unchanged, and this
+  claims neither lower vendor overload nor better memory.
+- **`entwurf pi-durable --resume` reopens a chosen session (#143).** It lists the current
+  directory's durable sessions from their files and the record store only (creation time, garden
+  id, last write, open elsewhere), most recently written first, and opens the chosen one as it
+  was saved, under its own garden id. Cancelling opens nothing. No session, a non-terminal, a
+  session open elsewhere, or a new session's argument beside it refuse by name, with no fallback.
+  `--continue` still opens the newest-created session.
+- **The durable app lists a project's skills again.** The owned prompt handed pi's `skills`
+  setting to the skill loader as written, so a relative entry was read against the session
+  directory: a project's `.pi/settings.json` entry `../.claude/skills` named a `.claude/skills`
+  beside the project, in its parent, and the project's own skills were silently not listed.
+  Relative path entries are now read as pi reads them, the project's against its `.pi` and the
+  global ones against the agent directory. Both scopes are kept, the project's first, so a project
+  skill wins over a global one of the same name. Absolute and `~` entries are unchanged.
+  Patterns, package skills, `.agents/skills` and skill diagnostics are not supported by this
+  change. No project trust check is added: the durable app reads a project's settings without a
+  trust decision, as it did before.
+
+### Herdr plugin
+
+- **The measured Herdr moves to 0.9.5, the hotfix of 0.9.4.** `scripts/fixtures/herdr-supply.json`
+  pins v0.9.5 (`2ecf19a9`), protocol 22, with both Linux asset digests taken from the immutable
+  release and named by its attestation. On aarch64 the pin rests on a private CLI baseline:
+  version, protocol 22, 18 `integration status` rows unchanged from 0.9.4, and a residue-free
+  `server stop`. The full `check-herdr-sandbox` then passed at this pin on x86_64 in the CI run of
+  the SHA that introduced it (run 38667564413 at `d8cd8f3`, 12 assertions on private Herdr 0.9.5),
+  and the x86_64 asset is recorded as executed with that receipt; it has not run on aarch64. The
+  supply receipt mutant now removes the x86_64 receipt instead of flipping an unexecuted flag,
+  because no asset at this pin is unexecuted. Plugin admission (Herdr >= 0.9.0), the plugin
+  version and the runtime lock are unchanged.
+- **A host that uses the Claude integration needs `herdr integration install claude` again
+  after upgrading to Herdr 0.9.5.** 0.9.5 raises its claude integration from v10 to v11 and leaves pi at v9. Over integrations seeded by
+  0.9.4 it reads claude as `outdated (v10 < v11)`, which the plugin's activation profile files as
+  `herdr-integration-outdated`, so the build and pane block [1] refuse by name until the
+  reinstall. In the measured 0.9.4-seeded private sandbox, the reinstall changed only the hook's
+  version line; the pi extension and the Claude settings stayed byte-identical. The plugin README
+  and the launch-rail document say so.
+
+### Release boundary and verification
+
+- **Scope.** A core minor over `v0.36.1`: #143 at `3a65c8d`, the Herdr 0.9.5 pin at `d8cd8f3`
+  and its CI record at `dbb8a32`, and the skill fix at `4968ffd`. Not in it: #142 (the ACP
+  thinking option), and the default thinking level of a new durable session named by a model
+  without `:<level>`, which starts at `off` where pi starts at its configured default; that is
+  recorded on #142 and not changed here. The Herdr manifest stays 0.36.0; plugin 0.37.0 is a
+  separate cut after the core is published.
+- **Local evidence before this preparation is focused, not a whole pass.** Each affected
+  qualification group (PARTIAL) measured its own change with a green control, and none is
+  carried to another. #143 killed 81/81 in the `check-pi-durable-beside` group. The supply
+  receipt mutant re-aimed at `dbb8a32` killed with its whole `check-herdr-supply` group, 11/11;
+  that commit skipped CI, so the re-aimed mutant has no CI run yet. The skill fix killed 82/82 in
+  the `check-pi-durable-beside` group (receipt `d934e43c4dad5dc28b49a3a85c5a133d126df9558f2bc260087c1b34cf7422f9`),
+  with 900 of the 982 committed claims not run. The qualification body has not run on any of them.
+- **Unpublished candidate carrier.** As in 0.36.1, `plugins/herdr/runtime-lock.json` names the
+  closed `herdr-checkout` source, because 0.37.0 has no published integrity yet. The npm 0.36.1
+  bytes and every existing tag are unchanged. Re-pinning registry bytes is the separate Herdr
+  0.37.0 cut, after the operator publishes core 0.37.0.
+- **No local static floor; it is the exact CI's.** `check:hermetic` carries
+  `check-herdr-plugin-build` and `check-herdr-sandbox`, which must not run on the operator host,
+  and `release-gate`'s first MUST step is `pnpm run check:full`. By the operator's decision for
+  this cut only, `check:full` was not run locally and is owed whole to the prepared SHA's CI.
+  The decision is not inherited by a later cut.
+- **LIVE, taken step by step, not as `release-gate --cut`.** The gate's 23 non-static MUST steps
+  and its BEHAVIOR step ran in the gate's own order, command, environment and working directory,
+  stopping at the first red, on the frozen candidate (`4968ffd` with this preparation's edits),
+  with the candidate fingerprint the same before and after each run. The first run passed steps
+  1-18 and failed `smoke-mux-lifecycle-live`: its pi-native sibling (`openai-codex/gpt-6-luna`)
+  was alive and answered with a shell call and "ACK" but never called the callback tool within
+  300 s. No input of that step changed in this cut, and the cause was not measured. By the
+  operator's choice it was run again once, unchanged, with steps 1-18 reused: steps 19-23 and the
+  BEHAVIOR step then passed. **MUST 23/23 PASS (18 + 5 on the second run), SKIP 0; BEHAVIOR 1/1
+  PASS.** `smoke-mux-lifecycle-live` passed 81 checks, `smoke-codex-fresh-live` 66 assertions
+  against an app-server started for each run in its own tmux session (named pane pid, a child
+  holding the kernel LISTEN inode, `gpt-5.6-luna` and `openai-codex/gpt-5.6-luna`, stopped by one
+  TERM after the run), and `smoke-pi-durable-fresh-live` 36 assertions. The gate sessions held no
+  ambient identity carrier. This is local LIVE evidence, not a release-gate verdict and not the
+  exact CI.
+- **Exact CI owes the whole floor.** The prepared SHA's exact CI (the four required jobs, the
+  whole qualification body over the 982 committed claims, the re-aimed supply mutant included,
+  and `check-herdr-sandbox` on pinned Herdr 0.9.5) is the next checkpoint and is not presumed
+  PASS.
+- **Publication boundary.** No make artifact, core tag, GitHub Release or npm publication is
+  claimed; they wait for the exact CI, the make decision and the operator.
+
 ## 0.36.1 - 2026-10-14
 
 ### ACP

package/README.md

@@ -91,8 +91,13 @@ incomplete, drifted or mixed supply refuses by name.
 ```bash
 entwurf pi-durable --provider <provider> --model <model-id> --width task-wide
 entwurf pi-durable --continue
+entwurf pi-durable --resume
 ```
 
+`--continue` opens this directory's newest durable session. `--resume` lists its
+sessions, most recently written first, by creation time, garden id and last write, and
+reopens the one you choose as it was saved; a cancelled choice opens nothing.
+
 The contact adds garden identity and two-way mailbox communication. Entwurf owns the
 thin app/TUI composition (shipped as an emitted JS carrier); execution, models/auth, queues,
 SQLite, transcripts and recovery remain the upstream SDK's:

package/VERIFY.md

@@ -227,7 +227,14 @@ holds that node and the badge counts it, `pending` while recovered), and the car
 `durableLayout` drawn by the published pi-tui renderer on a fake terminal across rows 1–8 × cols
 1–12, count changes and resizes, against the pinned upstream screen for the zero-task case. Its
 editor is a fixed stand-in: the real `CustomEditor`, overlays, emoji width and a consumer's own task
-are the visible-terminal and consumer subjects. `check-pi-runtime-version` asks the
+are the visible-terminal and consumer subjects. The 1.2 bootstrap child also observes `--resume`
+reopening the chosen session and cancelling to nothing (#143). Two more sandboxed children reach the
+reference app's settings and prompt mapping: one drives the real bootstrap against a loopback
+WebSocket Responses endpoint, whose received frames decide the forwarded transport and its
+continuation and the reference compaction policy (no background summary; blocking and overflow
+kept, #143); the other renders the carrier prompt's skills section with no model, against a fixture
+of both settings scopes, an absolute entry, a same-name pair and a wrong-base decoy.
+`check-pi-runtime-version` asks the
 same verifier whether this checkout resolves exactly the pinned SDK set (the native set; the PATH
 host is setup's subject), and `check-pi-import-surface` asserts the carrier fence. The separate
 `check-pi-durable-contact`, `check-pi-durable-send` and `check-pi-durable-receive` are

package/docs/setup-clean-host.md

@@ -358,6 +358,7 @@ tree (for example an override that binds pi-durable's `pi-ai` to an older publis
   ```bash
   entwurf pi-durable --provider <provider> --model <exact catalog id> --width task-wide
   entwurf pi-durable --continue    # this directory's newest durable session
+  entwurf pi-durable --resume      # choose one of this directory's durable sessions
   ```
 
   The bootstrap imports only the compiled closure shipped beside it

package/mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-pi-durable.js

@@ -107,9 +107,24 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { defaultMetaMailboxDir, defaultMetaReceiversDir, defaultMetaSendersDir, defaultMetaSessionsDir, readAddressableMetaIdentity, readMetaReceiverMarker, readMetaSenderMarker, requireGardenId, upsertMetaSession, writeMetaReceiverMarker, writeMetaSenderMarker, } from "./lib/meta-session.js";
+import { defaultMetaMailboxDir, defaultMetaReceiversDir, defaultMetaSendersDir, defaultMetaSessionsDir, listAllMetaIdentitiesDir, readAddressableMetaIdentity, readMetaReceiverMarker, readMetaSenderMarker, requireGardenId, upsertMetaSession, writeMetaReceiverMarker, writeMetaSenderMarker, } from "./lib/meta-session.js";
 /** The backend id this contact mints under. */
 export const PI_DURABLE_BACKEND = "pi-durable";
+/**
+ * The garden ids the record store holds for these durable sessions (#143 `--resume`), read only: a session no record
+ * names is absent, and an unreadable record is counted, never guessed.
+ */
+export function piDurableGardenIds(nativeSessionIds, sessionsDir = defaultMetaSessionsDir()) {
+    const wanted = new Set(nativeSessionIds);
+    const { identities, errors } = listAllMetaIdentitiesDir(sessionsDir);
+    const gardens = new Map();
+    for (const identity of identities) {
+        if (identity.backend === PI_DURABLE_BACKEND && wanted.has(identity.nativeSessionId)) {
+            gardens.set(identity.nativeSessionId, identity.gardenId);
+        }
+    }
+    return { gardens, unreadable: errors.length };
+}
 /** The durable Extension's name, owned exactly. */
 export const PI_DURABLE_EXTENSION_NAME = "entwurf";
 /** Every bridge tool this contact exposes. A tool outside this list is not callable here. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@junghanacs/entwurf",
-	"version": "0.36.1",
+	"version": "0.37.0",
 	"description": "Visible sibling sessions across independent agent harnesses: launch in Herdr or tmux, reopen pi in tmux, and deliver messages by garden id; native bridges and Claude/Cortex ACP adapters.",
 	"license": "MIT",
 	"author": {
@@ -123,7 +123,8 @@
 		"husky": "^9.1.7",
 		"rregex": "1.13.1",
 		"typescript": "^6.0.2",
-		"vitest": "4.1.9"
+		"vitest": "4.1.9",
+		"ws": "8.21.3"
 	},
 	"scripts": {
 		"prepare": "npm run --silent build-bridge 1>&2",

package/pi/pi-durable/bootstrap.mjs

@@ -80,19 +80,21 @@ import {
 	failAfterCleanup,
 	PI_DURABLE_EXTENSION_NAME,
 	PI_DURABLE_TOOL_NAMES,
+	piDurableGardenIds,
 	withGardenIdentity,
 } from "../../mcp/entwurf-bridge/dist/pi-extensions/meta-bridge-pi-durable.js";
 
 const RUNTIME = "./carrier/runtime.js";
 const TUI = "./carrier/tui.js";
+const SESSIONS = "./carrier/sessions.js";
 
 /** The entwurf-bridge of THIS package closure: the one the contact spawns as its MCP hand. */
 export const PACKAGED_BRIDGE_ENTRY = fileURLToPath(
 	new URL("../../mcp/entwurf-bridge/dist/mcp/entwurf-bridge/src/index.js", import.meta.url),
 );
 
-/** Flags that take a value. Anything else but `--continue`/`-c` is an unknown argument — a bridge
- * entry included: the launch argv cannot point the contact at another bridge. */
+/** Flags that take a value. Anything else but `--continue`/`-c` and `--resume` is an unknown argument — a
+ * bridge entry included: the launch argv cannot point the contact at another bridge. */
 const VALUE_FLAGS = [
 	"--provider",
 	"--model",
@@ -293,12 +295,13 @@ async function loadNativeModules(files) {
  * @param {{
  *   bridgeEntry?: string,
  *   continueSession?: boolean,
+ *   session?: string,
  *   cwd?: string,
  *   model?: { provider: string, model: string },
  *   firstInput?: string,
  *   extensions?: readonly object[],
  *   contact?: Record<string, unknown>,
- *   open?: (options: { cwd: string, continueSession: boolean, extensions: readonly object[], model?: { provider: string, model: string } }) => Promise<any>,
+ *   open?: (options: { cwd: string, continueSession: boolean, session?: string, extensions: readonly object[], model?: { provider: string, model: string } }) => Promise<any>,
  * }} options
  * @returns {Promise<{ durable: any, contact: any, attachment: { gardenId: string } & Record<string, any>, firstInput?: any, close(): Promise<void> }>}
  *   (stated, because the compiled closure carries no declarations: a cleanup path that rethrows
@@ -307,6 +310,7 @@ async function loadNativeModules(files) {
 export async function openDurableCitizen({
 	bridgeEntry = PACKAGED_BRIDGE_ENTRY,
 	continueSession = false,
+	session,
 	cwd = process.cwd(),
 	model,
 	firstInput,
@@ -320,6 +324,12 @@ export async function openDurableCitizen({
 			"an explicit model and a first input apply only to a new session; a continued session is reopened as it was saved",
 		);
 	}
+	if (session !== undefined && (continueSession || model !== undefined || firstInput !== undefined)) {
+		throw refuse(
+			"fresh-only-argument-with-resume",
+			"a chosen session is reopened as it was saved: no --continue, explicit model or first input",
+		);
+	}
 	if (model !== undefined && !(nonEmpty(model.provider) && nonEmpty(model.model))) {
 		throw refuse("explicit-model-incomplete", "an explicit model names both its provider and its model id");
 	}
@@ -333,6 +343,7 @@ export async function openDurableCitizen({
 		durable = await openDurable({
 			cwd,
 			continueSession,
+			...(session === undefined ? {} : { session }),
 			extensions: [contact.extension, ...extensions],
 			...(model === undefined ? {} : { model }),
 		});
@@ -389,6 +400,7 @@ export async function openDurableCitizen({
 
 function parseArgs(argv) {
 	let continueSession = false;
+	let resume = false;
 	const values = new Map();
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
@@ -396,6 +408,10 @@ function parseArgs(argv) {
 			continueSession = true;
 			continue;
 		}
+		if (arg === "--resume") {
+			resume = true;
+			continue;
+		}
 		if (!VALUE_FLAGS.includes(arg)) throw new Error(`Unknown argument: ${arg}`);
 		if (values.has(arg)) throw refuse("argument-repeated", `${arg} is given more than once`);
 		const value = argv[++i];
@@ -404,7 +420,19 @@ function parseArgs(argv) {
 		}
 		values.set(arg, value);
 	}
+	if (resume && continueSession) {
+		throw refuse(
+			"resume-continue-exclusive",
+			"--resume chooses a session and --continue opens the newest one; give one of them",
+		);
+	}
 	const fresh = FRESH_ONLY_FLAGS.filter((flag) => values.has(flag));
+	if (resume && fresh.length > 0) {
+		throw refuse(
+			"fresh-only-argument-with-resume",
+			`${fresh.join(", ")} apply only to a new session; --resume reopens the chosen session as it was saved`,
+		);
+	}
 	if (continueSession && fresh.length > 0) {
 		throw refuse(
 			"fresh-only-argument-with-continue",
@@ -426,6 +454,7 @@ function parseArgs(argv) {
 				? { nativeModules: nativeModuleDirFiles(dirArg) }
 				: {};
 	if (continueSession) return { continueSession, ...nativeModule };
+	if (resume) return { resume, ...nativeModule };
 	const provider = values.get("--provider");
 	if (provider === undefined) {
 		throw refuse(
@@ -457,29 +486,102 @@ function parseArgs(argv) {
 	};
 }
 
+/** A local `YYYY-MM-DD HH:MM` for a list line. */
+function localTime(ms) {
+	const date = new Date(ms);
+	const two = (n) => String(n).padStart(2, "0");
+	return `${date.getFullYear()}-${two(date.getMonth() + 1)}-${two(date.getDate())} ${two(date.getHours())}:${two(date.getMinutes())}`;
+}
+
 /**
- * Parse, initialize the operator's module, load the TUI, open, run, close. `loadTui`, `open` and
- * `contact` are test seams; `bridgeEntry` is the checkout-only gates' private bundle, as in
- * `openDurableCitizen` — never the launch argv.
+ * `--resume` (#143): this directory's durable sessions, most recently written first, each by what its files and
+ * the record store already say — creation time, garden id, last write, whether another process holds it. No
+ * session database is opened to list them, and nothing is named that the store does not hold. Resolves the
+ * chosen session's id, or undefined when the choice was cancelled; never a fallback to another session.
+ */
+async function chooseSession(cwd, sessionsDir, pick) {
+	const { listSessions } = await import(SESSIONS);
+	const sessions = await listSessions(cwd);
+	if (sessions.length === 0) throw refuse("resume-no-session", `no durable session exists for ${cwd}`);
+	const { gardens, unreadable } = piDurableGardenIds(
+		sessions.map((session) => session.id),
+		sessionsDir,
+	);
+	const items = sessions.map((session) => ({
+		value: session.id,
+		label: `${localTime(session.createdAt)}  ${gardens.get(session.id) ?? "no record"}`,
+		description: [
+			session.lastWriteAt === undefined ? "never written" : `last write ${localTime(session.lastWriteAt)}`,
+			session.id,
+			...(session.openElsewhere ? ["open elsewhere"] : []),
+		].join(" · "),
+	}));
+	const title =
+		unreadable === 0 ? "Resume durable session:" : `Resume durable session (${unreadable} unreadable record(s)):`;
+	const id = await pick(title, items);
+	if (id === undefined) return undefined;
+	const chosen = sessions.find((session) => session.id === id);
+	if (chosen === undefined) throw refuse("session-not-found", `${id} is not one of the listed sessions`);
+	if (chosen.openElsewhere) {
+		throw refuse("session-open-elsewhere", `${id} is open in another process; close it there first`);
+	}
+	return chosen.id;
+}
+
+/**
+ * Parse, initialize the operator's module, load the TUI, open, run, close. `loadTui`, `open`,
+ * `contact` and `pick` (the `--resume` list's choice) are test seams; `bridgeEntry` is the
+ * checkout-only gates' private bundle, as in `openDurableCitizen` — never the launch argv.
  *
  * @param {readonly string[]} argv
  * @param {{
- *   loadTui?: () => Promise<{ runDurableTui: (...args: any[]) => Promise<void> }>,
+ *   loadTui?: () => Promise<{ runDurableTui: (...args: any[]) => Promise<void>, pickDurableSession?: (title: string, items: object[]) => Promise<string | undefined> }>,
  *   open?: (options: any) => Promise<any>,
  *   contact?: Record<string, unknown>,
  *   bridgeEntry?: string,
+ *   pick?: (title: string, items: { value: string, label: string, description: string }[]) => Promise<string | undefined>,
  * }} [seams]
  */
-export async function main(argv, { loadTui = () => import(TUI), open, contact, bridgeEntry } = {}) {
+export async function main(argv, { loadTui = () => import(TUI), open, contact, bridgeEntry, pick } = {}) {
 	// Every argument refusal is decided here, before any module, the TUI or the app loads.
-	const { nativeModules = [], ...args } = parseArgs(argv);
+	const { nativeModules = [], resume = false, ...args } = parseArgs(argv);
 	// The caller's directory, fixed before any operator code runs and handed to the app explicitly.
 	const cwd = process.cwd();
 	const extensions = await loadNativeModules(nativeModules);
 	// Loaded before anything opens, as upstream main.ts imports it statically: a TUI that cannot
 	// load opens no session, mints no citizen and leaves nothing to clean up.
-	const { runDurableTui } = await loadTui();
-	const citizen = await openDurableCitizen({ ...args, cwd, extensions, bridgeEntry, open, contact });
+	const tui = await loadTui();
+	const { runDurableTui } = tui;
+	let session;
+	if (resume) {
+		session = await chooseSession(
+			cwd,
+			contact?.sessionsDir,
+			pick ??
+				((title, items) => {
+					if (!process.stdin.isTTY || !process.stdout.isTTY) {
+						throw refuse(
+							"resume-needs-terminal",
+							"--resume lists the sessions to choose from in an interactive terminal",
+						);
+					}
+					return tui.pickDurableSession(title, items);
+				}),
+		);
+		if (session === undefined) {
+			process.stderr.write("[pi-durable] resume-cancelled: nothing was opened\n");
+			return;
+		}
+	}
+	const citizen = await openDurableCitizen({
+		...args,
+		...(session === undefined ? {} : { session }),
+		cwd,
+		extensions,
+		bridgeEntry,
+		open,
+		contact,
+	});
 	try {
 		await runDurableTui(
 			withGardenIdentity(citizen.durable.view, citizen.attachment.gardenId),

package/pi/pi-durable/carrier/harness-setup.js

@@ -28,13 +28,16 @@ export function createHarnessSettings(settingsManager                 )
 			const provider = settingsManager.getProviderRetrySettings();
 			const idle = settingsManager.getHttpIdleTimeoutMs();
 			return {
+				transport: settingsManager.getTransport(),
 				timeoutMs: provider.timeoutMs ?? (idle === 0 ? 2147483647 : idle),
 				maxRetryDelayMs: provider.maxRetryDelayMs,
 				...(provider.maxRetries === undefined ? {} : { maxRetries: provider.maxRetries }),
 			};
 		},
+		// The reference app waits for a compaction instead of summarizing beside the running turn (#143): no background
+		// compaction. Threshold, manual and overflow compaction stay the SDK's, on pi's own compaction settings.
 		get compaction() {
-			return settingsManager.getCompactionSettings();
+			return { ...settingsManager.getCompactionSettings(), backgroundTokens: 0 };
 		},
 		get retry() {
 			return settingsManager.getRetrySettings();

package/pi/pi-durable/carrier/prompt.js

@@ -1,5 +1,6 @@
+import { isAbsolute, join, resolve } from "node:path";
 import { defineExtension,                   section } from "@earendil-works/pi-durable";
-import { getAgentDir } from "entwurf-pi-dist:config.js";
+import { CONFIG_DIR_NAME, getAgentDir } from "entwurf-pi-dist:config.js";
 import { loadProjectContextFiles } from "entwurf-pi-dist:core/resource-loader.js";
                                                                       
 import { loadSkills,            } from "entwurf-pi-dist:core/skills.js";
@@ -19,6 +20,29 @@ const CONTRIBUTIONS = {
 /** pi's section order; `buildSystemPromptSections()` omits the ones without content. */
 const KEYS = ["preamble", "tools", "rules", "docs", "project_context", "skills", "cwd"]         ;
 
+/** An entry pi reads as a pattern, not a path: an override or a glob. */
+const PATTERN = /^[!+-]|[*?]/u;
+
+/**
+ * The `skills` setting with each scope's relative entries read against that scope's own directory, as pi resolves
+ * them: the project's against the session directory's `.pi`, the global ones against the agent directory, the
+ * project's first. Read against the conversation's directory, a relative entry names another place. Absolute, `~`
+ * and pattern entries go on unchanged.
+ */
+function scopedSkillPaths(settings                 , agentDir        , projectCwd        )           {
+	const against = (entries                               , base        )           =>
+		(entries ?? []).map((entry) => {
+			const path = entry.trim();
+			return path === "" || isAbsolute(path) || path === "~" || path.startsWith("~/") || PATTERN.test(path)
+				? entry
+				: resolve(base, path);
+		});
+	return [
+		...against(settings.getProjectSettings().skills, join(projectCwd, CONFIG_DIR_NAME)),
+		...against(settings.getGlobalSettings().skills, agentDir),
+	];
+}
+
 /**
  * pi's system prompt as one extension: the sections of `buildSystemPromptSections()` for the request's tools and the
  * conversation's directory. Context files and skills load once per directory, like pi at startup.
@@ -31,7 +55,12 @@ export function createPiPrompt(settings                 , fallbackCwd        ) {
 			const agentDir = getAgentDir();
 			found = {
 				contextFiles: loadProjectContextFiles({ cwd, agentDir }),
-				skills: loadSkills({ cwd, agentDir, skillPaths: settings.getSkillPaths(), includeDefaults: true }).skills,
+				skills: loadSkills({
+					cwd,
+					agentDir,
+					skillPaths: scopedSkillPaths(settings, agentDir, fallbackCwd),
+					includeDefaults: true,
+				}).skills,
 			};
 			resources.set(cwd, found);
 		}

package/pi/pi-durable/carrier/runtime.js

@@ -90,6 +90,8 @@ const context = BACKGROUND_CONTEXT;
                                      
 	                      
 	                                   
+	                                                                                         
+	                          
 	                                                                                                                 
 	                                           
 	                                                                                                           
@@ -143,10 +145,17 @@ function titleOf(entry                         )                     {
 }
 
 export async function openDurable(options                     = {})                             {
-	if (options.model !== undefined && options.continueSession) {
+	if (options.model !== undefined && (options.continueSession || options.session !== undefined)) {
 		throw new Error("An explicit model applies only to a new session, not to a continued one");
 	}
-	const location = await selectSession(options.cwd ?? process.cwd(), options.continueSession ?? false);
+	if (options.continueSession && options.session !== undefined) {
+		throw new Error("A chosen session and the newest one are two different sessions; name one");
+	}
+	const location = await selectSession(
+		options.cwd ?? process.cwd(),
+		options.continueSession ?? false,
+		options.session,
+	);
 	const envs = new ExecutionEnvs(location.cwd);
 	let harness                     ;
 	try {

package/pi/pi-durable/carrier/sessions.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readdir, realpath } from "node:fs/promises";
+                                             
+import { mkdir, readdir, realpath, stat } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import lockfile from "proper-lockfile";
 import { getAgentDir } from "entwurf-pi-dist:config.js";
@@ -14,8 +15,31 @@ import { getAgentDir } from "entwurf-pi-dist:config.js";
 	                         
  
 
-/** A new session for `cwd`, or its newest one with `continueSession`. */
-export async function selectSession(cwdInput        , continueSession         )                           {
+/** One session of a directory as its files show it (#143): nothing in it is opened. */
+                               
+	           
+	                  
+	                                        
+	                  
+	                                                                                          
+	                     
+	                                                
+	                       
+ 
+
+const SESSION_NAME = /^\d{13}-[0-9a-f-]{36}$/u;
+
+/** A path's stat, or undefined when nothing is there; any other failure is thrown, never read as absence. */
+async function statIfPresent(path        )                             {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if ((error                         ).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+async function sessionRoot(cwdInput        )                                         {
 	const cwd = await realpath(resolve(cwdInput));
 	const root = join(
 		getAgentDir(),
@@ -23,14 +47,60 @@ export async function selectSession(cwdInput        , continueSession         )
 		"durable-sessions",
 		createHash("sha256").update(cwd).digest("hex").slice(0, 24),
 	);
+	return { cwd, root };
+}
+
+/** The sessions of `cwd`, most recently written first. Reads names, file times and locks; creates nothing. */
+export async function listSessions(cwdInput        )                          {
+	const { root } = await sessionRoot(cwdInput);
+	let entries          ;
+	try {
+		entries = await readdir(root, { withFileTypes: true });
+	} catch (error) {
+		if ((error                         ).code === "ENOENT") return [];
+		throw error;
+	}
+	const sessions                 = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !SESSION_NAME.test(entry.name)) continue;
+		const directory = join(root, entry.name);
+		let lastWriteAt                    ;
+		for (const file of ["session.sqlite", "session.sqlite-wal"]) {
+			const mtime = (await statIfPresent(join(directory, file)))?.mtimeMs;
+			if (mtime !== undefined && (lastWriteAt === undefined || mtime > lastWriteAt)) lastWriteAt = mtime;
+		}
+		sessions.push({
+			id: entry.name,
+			directory,
+			createdAt: Number(entry.name.slice(0, 13)),
+			...(lastWriteAt === undefined ? {} : { lastWriteAt }),
+			openElsewhere: await lockfile.check(directory, { realpath: false }),
+		});
+	}
+	return sessions.sort((a, b) => (b.lastWriteAt ?? b.createdAt) - (a.lastWriteAt ?? a.createdAt));
+}
+
+/** A new session for `cwd`, its newest one with `continueSession`, or the existing one named by `sessionId`. */
+export async function selectSession(
+	cwdInput        ,
+	continueSession         ,
+	sessionId         ,
+)                           {
+	const { cwd, root } = await sessionRoot(cwdInput);
 	await mkdir(root, { recursive: true });
 
 	let directory        ;
 	let created = false;
-	if (continueSession) {
+	if (sessionId !== undefined) {
+		const chosen = SESSION_NAME.test(sessionId) ? join(root, sessionId) : undefined;
+		if (chosen === undefined || !(await statIfPresent(chosen))?.isDirectory()) {
+			throw new Error(`No durable session ${sessionId} exists for ${cwd}`);
+		}
+		directory = chosen;
+	} else if (continueSession) {
 		const entries = await readdir(root, { withFileTypes: true });
 		const newest = entries
-			.filter((entry) => entry.isDirectory() && /^\d{13}-[0-9a-f-]{36}$/u.test(entry.name))
+			.filter((entry) => entry.isDirectory() && SESSION_NAME.test(entry.name))
 			.map((entry) => entry.name)
 			.sort()
 			.at(-1);

package/pi/pi-durable/carrier/tui.js

@@ -113,6 +113,29 @@ class ListSelector extends Container                      {
 	}
 }
 
+/**
+ * Choose one of the sessions `--resume` lists (#143) before any of them opens: the /agents list on a screen of its
+ * own, stopped before the session's TUI starts. Resolves the chosen value, or undefined when cancelled.
+ */
+export function pickDurableSession(title        , items              )                              {
+	initTheme();
+	const ui = new TuiAltScreen(new ProcessTerminal(), false, getAgentDir());
+	setKeybindings(KeybindingsManager.create());
+	return new Promise((resolve) => {
+		let done = false;
+		const finish = (value                    )       => {
+			if (done) return;
+			done = true;
+			ui.stop();
+			resolve(value);
+		};
+		const selector = new ListSelector(title, items, finish, () => finish(undefined));
+		ui.addChild(selector);
+		ui.setFocus(selector);
+		ui.start();
+	});
+}
+
 /** The summary that replaced earlier context: collapsed to one line until expanded. */
 class CompactionComponent extends Box {
 	         #summary        ;

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

@@ -70,32 +70,32 @@
 			{
 				"name": "runtime.js",
 				"source": "pi/pi-durable/src/experimental/durable/runtime.ts",
-				"blob": "36c352291620ab86184172a1b4a0df4562ab9581",
-				"sha256": "60c2965eadbdbbe78fce1b7eeb89d97eb3104a30b7d58ebca87009d2e9118403"
+				"blob": "75d7bf2b4fdc36aa775f73f9d7f3de8659f19187",
+				"sha256": "725757156580ad2a2d170c790440763371bb8035052a0c6caae6af5159d4718f"
 			},
 			{
 				"name": "tui.js",
 				"source": "pi/pi-durable/src/experimental/durable/tui.ts",
-				"blob": "dab99cd4778ae1db7f062e64db2d0c068f7e342d",
-				"sha256": "0f9ebaf8fbb2a532ccd1a7198e1a25533a99720b5fedbf03f42d5c381db3abc5"
+				"blob": "eb5e2ec4e98919cd3ff4f81f166eb52afe6555af",
+				"sha256": "a1b0d9d9358c5b54ac0974de84068b7792669171917ebd7b7351374ed625c9c5"
 			},
 			{
 				"name": "harness-setup.js",
 				"source": "pi/pi-durable/src/experimental/durable/harness-setup.ts",
-				"blob": "4d6a4be5333ebb8e0f17eac1987f18ea35a91fc7",
-				"sha256": "712b630145dc6f5c655a85b01b1e20299c962542e63c5494d2202bb7bf414a15"
+				"blob": "36a622ec6d5dccda828ffaceaf74ce8ec241e39d",
+				"sha256": "efb06ae25258fbbab5b28f8a9bbb50956c7ebfd77a5ed23b065706f662e70ba3"
 			},
 			{
 				"name": "prompt.js",
 				"source": "pi/pi-durable/src/experimental/durable/prompt.ts",
-				"blob": "8e2f5d5273fba58da8b314766956ed62951c3814",
-				"sha256": "ff1ff765fa313e5cb1c3d7537c901c23adb0562ee433bd050fd35eb3d892134c"
+				"blob": "0e99ff64214c44986c1c2259490e401898659fd5",
+				"sha256": "15870ea4c9cb465395d70189be4f1480c48544d724bd9fc3b0e6650f17226c0f"
 			},
 			{
 				"name": "sessions.js",
 				"source": "pi/pi-durable/src/experimental/durable/sessions.ts",
-				"blob": "34f9ceeeaeaf874f7478d56115da2e4f726c6a85",
-				"sha256": "1bd1a04ece66f5ab3ca22860c64dba9abc848334d11a27a9afe543f1365c7254"
+				"blob": "eed4b3ca51c6f5a3bab8106adaf0062f3f7d5b56",
+				"sha256": "668373feadabcf13bd4dd7431e5429b7d7376c47c367e4b15353c57cb8711892"
 			},
 			{
 				"name": "subagent.js",

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

@@ -113,6 +113,7 @@ import {
 	defaultMetaReceiversDir,
 	defaultMetaSendersDir,
 	defaultMetaSessionsDir,
+	listAllMetaIdentitiesDir,
 	readAddressableMetaIdentity,
 	readMetaReceiverMarker,
 	readMetaSenderMarker,
@@ -125,6 +126,25 @@ import {
 /** The backend id this contact mints under. */
 export const PI_DURABLE_BACKEND = "pi-durable" as const;
 
+/**
+ * The garden ids the record store holds for these durable sessions (#143 `--resume`), read only: a session no record
+ * names is absent, and an unreadable record is counted, never guessed.
+ */
+export function piDurableGardenIds(
+	nativeSessionIds: readonly string[],
+	sessionsDir: string = defaultMetaSessionsDir(),
+): { gardens: Map<string, string>; unreadable: number } {
+	const wanted = new Set(nativeSessionIds);
+	const { identities, errors } = listAllMetaIdentitiesDir(sessionsDir);
+	const gardens = new Map<string, string>();
+	for (const identity of identities) {
+		if (identity.backend === PI_DURABLE_BACKEND && wanted.has(identity.nativeSessionId)) {
+			gardens.set(identity.nativeSessionId, identity.gardenId);
+		}
+	}
+	return { gardens, unreadable: errors.length };
+}
+
 /** The durable Extension's name, owned exactly. */
 export const PI_DURABLE_EXTENSION_NAME = "entwurf";
 

package/run.sh

@@ -273,7 +273,7 @@ Usage:
   ./run.sh uninstall-meta-bridge      # 1.0.0 meta-bridge Phase 2: stateful GLOBAL uninstall (restore only keys/items captured in install-state)
   ./run.sh doctor-meta-bridge         # THE RELEASE ORACLE (#51, Linux-certified repair axis). exit 0 = every required layer was MEASURED on this Linux host: toolchain + state + plugin/MCP + resolved-artifact launch-form classification (all 3 owner hooks + doorbell static contract) + synthetic owner join + store scan + hook errors + SessionStart evidence + REQUIRED live MCP↔marker join + writer-version parity. Missing live evidence is NOT CERTIFIED (open a Claude session and re-run), never a pass; Darwin is NOT CERTIFIED and stays nonzero, on ONE narrowed reason — start-key and ppid are portable there (`ps` fallback, same string the TS core mints), so what holds the lane closed is per-process environment DISCOVERY alone, pending physical-host evidence. Detection power is held by check-meta-doctor-oracle
   ./run.sh copilot [args...]          # #82 RAIL 7: the MANAGED Copilot launch. exec()s the vendor CLI in THIS terminal (cwd/pid/exit preserved) with COPILOT_CLI_ENABLED_FEATURE_FLAGS=EXTENSIONS set for that one invocation — entwurf owns no part of your shell and writes nothing to it, but it owns the process it is about to become. Without that flag Copilot skips the extension scan SILENTLY. Refuses to launch unless the receiver unit is actually installed. Injects `--model auto` when no --model was given and `--yolo` when no explicit permission/surface policy flag was given, both BEFORE any `--`; every argument you pass is forwarded byte-identical. RUNNING THIS IS YOUR CONSENT to that profile — use plain `copilot` for stock vendor behaviour. Not tmux, not fresh-call, mints no citizen (birth is still the first prompt)
-  ./run.sh pi-durable [args...]       # #129/#130: the MANAGED durable launch. Verifies this package's pi-durable CARRIER (pi/pi-durable/carrier/, emitted deterministically from Entwurf's owned source pi/pi-durable/src) and the pi SDK set it resolves — every declared member/direct edge at exactly the pinned version — refusing by name (package-incomplete / carrier-drift / sdk-absent / sdk-mismatch, exit 3), then exec()s node under the carrier resolver with the packaged bootstrap (pi/pi-durable/bootstrap.mjs) in this terminal. A new session needs --provider <p> --model <exact catalog id> --width task-wide [--entwurf-bootstrap <{v:2,task}>]; --continue takes none of them. Nothing outside the package is located, installed or repaired
+  ./run.sh pi-durable [args...]       # #129/#130: the MANAGED durable launch. Verifies this package's pi-durable CARRIER (pi/pi-durable/carrier/, emitted deterministically from Entwurf's owned source pi/pi-durable/src) and the pi SDK set it resolves — every declared member/direct edge at exactly the pinned version — refusing by name (package-incomplete / carrier-drift / sdk-absent / sdk-mismatch, exit 3), then exec()s node under the carrier resolver with the packaged bootstrap (pi/pi-durable/bootstrap.mjs) in this terminal. A new session needs --provider <p> --model <exact catalog id> --width task-wide [--entwurf-bootstrap <{v:2,task}>]; --continue (this directory's newest session) and --resume (choose one of its sessions) take none of them. Nothing outside the package is located, installed or repaired
   ./run.sh install-copilot-bridge     # #82: GLOBAL install of the Copilot BIRTH plugin (own marketplace root; node+entry baked into the no-argv exec string). MCP wiring and the RECEIVER extension are separate install surfaces (install-copilot-mcp, install-copilot-receive). Also retires the stale Claude unit (--keep-stale-claude-unit opts out)
   ./run.sh uninstall-copilot-bridge   # #86 C3a: honest inverse of install-copilot-bridge from the package-owned install-state (exact qualified id + exact marketplace name/path + recorded assembly only; state deleted LAST; a failing vendor list is UNKNOWN and refuses; never --force, never the stale Claude unit)
   ./run.sh doctor-copilot-bridge      # #82/#86: fail-loud surface for that unit — runtime axis (red = a hook that RAN and failed, or a broken/unbaked artifact; "installed with zero records" is NOT red and is reported as NOT-YET: a Copilot session is born on its FIRST PROMPT, not when the window opens, measured) + ownership axis (install-state shape/binding, marketplace path drift, UNKNOWN vendor lists; legacy no-state install = named non-green, repair = install-copilot-bridge adoption). Either axis red = red

package/scripts/check-gate-qualification.ts

@@ -3464,7 +3464,7 @@ let manifestCount: number;
 		"pi-bridge-sender": 4,
 		"pi-mcp-bridge": 2,
 		"pi-mcp-register": 3,
-		"pi-durable": 78,
+		"pi-durable": 84,
 		"copilot-receive": 20,
 		"entwurf-peers": 1,
 		"fresh-call-dispatch": 12,

package/scripts/fixtures/herdr-supply.json

@@ -1,10 +1,10 @@
 {
 	"$comment": "SSOT for the herdr binary this repository has MEASURED against. Nothing else may carry a version or a digest: the CI installer, the sandbox gate's boundary check and the launch-rail document all read or cite this file. Re-measuring a new herdr means measuring it FIRST — fetched by digest and verified before it is made executable, then run against a private sandbox server (at least version, status-client protocol and integration rows) — then editing this file and repairing the measured sentences in docs/herdr-launch-rail.md in the same commit; miss one and the gate fails on version mismatch, which is the point. A private baseline is not the full gate: check-herdr-sandbox at a new pin is certified by its exact-SHA CI run unless it was also run locally, and an asset is recorded `executed` only with a receipt bound to this version and its full digest (check-herdr-supply HSUP-EXECUTION-RECEIPT-BOUND).",
-	"version": "0.9.4",
-	"tag": "v0.9.4",
-	"tagCommit": "7e26bad94044eba205033111a0ce8033ede7e24f",
+	"version": "0.9.5",
+	"tag": "v0.9.5",
+	"tagCommit": "2ecf19a92fc3a7fff75b6ce3655ef04f4625ec01",
 	"socketProtocol": 22,
-	"measuredOn": "2026-10-14",
+	"measuredOn": "2026-10-15",
 	"measuredArch": "aarch64",
 	"releaseUrlPrefix": "https://github.com/herdrdev/herdr/releases/download",
 	"integrity": {
@@ -15,16 +15,17 @@
 	"assets": {
 		"x86_64": {
 			"name": "herdr-linux-x86_64",
-			"sha256": "493304fbefb0ed0ea0455f373b47f48d24e8774bc7974f4c916ad2e937675b23",
-			"executed": false,
-			"executedNote": "not yet executed at this pin: the digest is pinned and named by GitHub's release attestation for pkg:github/herdrdev/herdr@v0.9.4, and the first CI check job at a SHA carrying this pin will be its first run. The previous pin's x86_64 asset (v0.9.3, sha256 18a8dc65…) did run there — CI run 38456259822, check-herdr-sandbox 12 assertions — which is dated history of that asset, not evidence for this one"
+			"sha256": "14d9e8bc8b4a9e0118d77c32266f76d461f09b40342eb23752960bd89f59929d",
+			"executed": true,
+			"executedReceipt": "herdr 0.9.5 linux-x86_64 sha256 14d9e8bc8b4a9e0118d77c32266f76d461f09b40342eb23752960bd89f59929d — 2026-10-15, GitHub Actions check job (x86_64), CI run 38667564413 at d8cd8f3, read from that run's check-job log: `install-herdr-ci` verified this digest before execution, and check-herdr-sandbox passed 12 assertions on private herdr 0.9.5, HS-VERSION-BOUNDARY included",
+			"executedNote": "the receipt is the full sandbox gate at the SHA that introduced this pin; it is not a claim for any later SHA. The previous pin's x86_64 asset (v0.9.4, sha256 493304fb…) ran in CI run 38479767989 at 9f33dd1, check-herdr-sandbox 12 assertions — dated history of that asset, not evidence for this one"
 		},
 		"aarch64": {
 			"name": "herdr-linux-aarch64",
-			"sha256": "9511cb70982c1ef115f232058e7ed7cf9640aa5a2c0ca78934cefda3aeb093fd",
+			"sha256": "17d7536f2da50859523680ef279dffcac8e4a235f4e46fe8da6c2ec44141897c",
 			"executed": true,
-			"executedReceipt": "herdr 0.9.4 linux-aarch64 sha256 9511cb70982c1ef115f232058e7ed7cf9640aa5a2c0ca78934cefda3aeb093fd — 2026-10-14, oracle aarch64, Phase A private CLI baseline (docs/herdr-launch-rail.md, 재측정 2026-10-14): `herdr --version` 0.9.4; `status client` protocol 22, endpoint_protocol_generation 1; `integration status` 18 rows, zero diff against 0.9.3; pi (v9) and claude (v10) integrations seeded by 0.9.3 read `current` and a 0.9.4 reinstall leaves their three files byte-identical; `server stop` leaves no socket and no process",
-			"executedNote": "the receipt is a private CLI baseline only. check-herdr-sandbox has NOT run on this architecture at this pin — its operator-untouched cell reads the operator's own panes — so the full gate's first run at this pin is the CI check job, on the x86_64 asset — not this one. The operator host still runs 0.9.3 and was not touched. The 0.9.3 receipt (2026-10-03, #126) stays dated in docs/herdr-launch-rail.md"
+			"executedReceipt": "herdr 0.9.5 linux-aarch64 sha256 17d7536f2da50859523680ef279dffcac8e4a235f4e46fe8da6c2ec44141897c — 2026-10-15, oracle aarch64, Phase A private CLI baseline (docs/herdr-launch-rail.md, 재측정 2026-10-15): `herdr --version` 0.9.5; `status client` protocol 22, endpoint_protocol_generation 1; `integration status` 18 rows, zero diff against 0.9.4 in a fresh sandbox; over integrations seeded by 0.9.4, pi reads `current (v9)` and claude reads `outdated (v10 < v11)`; a 0.9.5 reinstall leaves the pi extension and claude settings.json byte-identical, changes the claude hook only in its `HERDR_INTEGRATION_VERSION` line (10 → 11), and then reads `current (v11)`; `server stop` leaves no socket and no process",
+			"executedNote": "the receipt is a private CLI baseline only. check-herdr-sandbox has NOT run on this architecture at this pin — its operator-untouched cell reads the operator's own panes — so the full gate's first run at this pin was the CI check job on the x86_64 asset (CI run 38667564413) — not this one. The operator host was not touched. The 0.9.4 receipt (2026-10-14) stays dated in docs/herdr-launch-rail.md"
 		}
 	}
 }

package/scripts/mutants/herdr-supply.json

@@ -8,7 +8,7 @@
 			"subject": "scripts/check-herdr-sandbox.ts",
 			"find": ["const SUPPLY_MANIFEST = \"scripts/fixtures/herdr-supply.json\";"],
 			"replace": [
-				"const SUPPLY_MANIFEST = \"scripts/fixtures/herdr-supply.json\";\nconst PINNED_FALLBACK = \"0.9.4\";\nvoid PINNED_FALLBACK;"
+				"const SUPPLY_MANIFEST = \"scripts/fixtures/herdr-supply.json\";\nconst PINNED_FALLBACK = \"0.9.5\";\nvoid PINNED_FALLBACK;"
 			],
 			"gate": ["bash", "run.sh", "check-herdr-supply"],
 			"timeoutSeconds": 120,
@@ -19,8 +19,8 @@
 			"claim": "HSUP-DIGEST-SHAPE",
 			"title": "a pinned digest is truncated, so the check that is supposed to catch a swapped binary can no longer fail",
 			"subject": "scripts/fixtures/herdr-supply.json",
-			"find": ["\"sha256\": \"493304fbefb0ed0ea0455f373b47f48d24e8774bc7974f4c916ad2e937675b23\""],
-			"replace": ["\"sha256\": \"493304fbefb0ed0ea0455f373b47\""],
+			"find": ["\"sha256\": \"14d9e8bc8b4a9e0118d77c32266f76d461f09b40342eb23752960bd89f59929d\""],
+			"replace": ["\"sha256\": \"14d9e8bc8b4a9e0118d77c32266f\""],
 			"gate": ["bash", "run.sh", "check-herdr-supply"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:HSUP-DIGEST-SHAPE]",
@@ -122,8 +122,8 @@
 			"claim": "HSUP-EXECUTION-RECEIPT-BOUND",
 			"title": "the x86_64 asset is recorded as executed with no receipt bound to this pin's version and its own full digest",
 			"subject": "scripts/fixtures/herdr-supply.json",
-			"find": ["\"executed\": false"],
-			"replace": ["\"executed\": true"],
+			"find": ["\"executedReceipt\": \"herdr 0.9.5 linux-x86_64"],
+			"replace": ["\"unboundReceipt\": \"herdr 0.9.5 linux-x86_64"],
 			"gate": ["bash", "run.sh", "check-herdr-supply"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:HSUP-EXECUTION-RECEIPT-BOUND]",

package/scripts/mutants/pi-durable.json

@@ -458,7 +458,7 @@
 			"claim": "PI-DURABLE-CARRIER-PIN-MATCHES",
 			"title": "the pin records a digest the committed carrier file does not carry, so a carrier edited after emission would still be the declared one",
 			"subject": "pi/pi-durable/overlay/upstream-pin.json",
-			"find": ["\"sha256\": \"60c2965eadbdbbe78fce1b7eeb89d97eb3104a30b7d58ebca87009d2e9118403\""],
+			"find": ["\"sha256\": \"725757156580ad2a2d170c790440763371bb8035052a0c6caae6af5159d4718f\""],
 			"replace": ["\"sha256\": \"0000000000000000000000000000000000000000000000000000000000000000\""],
 			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
 			"timeoutSeconds": 300,
@@ -701,8 +701,8 @@
 			"claim": "PI-DURABLE-MODULE-ABSENT-UNCHANGED",
 			"title": "the module phase runs without a --native-module, so a launch that names no module still tries to import one",
 			"subject": "pi/pi-durable/bootstrap.mjs",
-			"find": ["\tconst { nativeModules = [], ...args } = parseArgs(argv);"],
-			"replace": ["\tconst { nativeModules = [undefined], ...args } = parseArgs(argv);"],
+			"find": ["\tconst { nativeModules = [], resume = false, ...args } = parseArgs(argv);"],
+			"replace": ["\tconst { nativeModules = [undefined], resume = false, ...args } = parseArgs(argv);"],
 			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:PI-DURABLE-MODULE-ABSENT-UNCHANGED]",
@@ -735,12 +735,12 @@
 				"\tconst extensions = await loadNativeModules(nativeModules);",
 				"\t// Loaded before anything opens, as upstream main.ts imports it statically: a TUI that cannot",
 				"\t// load opens no session, mints no citizen and leaves nothing to clean up.",
-				"\tconst { runDurableTui } = await loadTui();"
+				"\tconst tui = await loadTui();"
 			],
 			"replace": [
 				"\t// Loaded before anything opens, as upstream main.ts imports it statically: a TUI that cannot",
 				"\t// load opens no session, mints no citizen and leaves nothing to clean up.",
-				"\tconst { runDurableTui } = await loadTui();",
+				"\tconst tui = await loadTui();",
 				"\tconst extensions = await loadNativeModules(nativeModules);"
 			],
 			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
@@ -791,8 +791,8 @@
 			"claim": "PI-DURABLE-MODULE-CWD-PINNED",
 			"title": "the app is opened wherever the process is at open time, not in the caller's directory fixed before the module ran",
 			"subject": "pi/pi-durable/bootstrap.mjs",
-			"find": ["\tconst citizen = await openDurableCitizen({ ...args, cwd, extensions, bridgeEntry, open, contact });"],
-			"replace": ["\tconst citizen = await openDurableCitizen({ ...args, extensions, bridgeEntry, open, contact });"],
+			"find": ["\t\t...(session === undefined ? {} : { session }),\n\t\tcwd,\n\t\textensions,\n\t\tbridgeEntry,"],
+			"replace": ["\t\t...(session === undefined ? {} : { session }),\n\t\textensions,\n\t\tbridgeEntry,"],
 			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:PI-DURABLE-MODULE-CWD-PINNED]",
@@ -1142,7 +1142,7 @@
 		},
 		{
 			"claim": "PI-DURABLE-COMPACTION-FAILURE-SHOWN",
-			"title": "the TUI drops the conversation's retained compaction failure: a failed background compaction vanishes from the screen once its status is removed",
+			"title": "the TUI drops the conversation's retained compaction failure: a failed threshold compaction vanishes from the screen once its status is removed",
 			"subject": "pi/pi-durable/carrier/tui.js",
 			"find": ["\tif (compaction !== undefined) {\n\t\tlines.push"],
 			"replace": ["\tif (compaction === null) {\n\t\tlines.push"],
@@ -1151,6 +1151,78 @@
 			"signature": "[QK:PI-DURABLE-COMPACTION-FAILURE-SHOWN]",
 			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
 			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
+		},
+		{
+			"claim": "PI-DURABLE-STREAM-TRANSPORT-WIRE",
+			"title": "the Harness settings stop carrying the transport: the provider never continues a response, so every request of a long session resends the whole conversation",
+			"subject": "pi/pi-durable/carrier/harness-setup.js",
+			"find": ["\t\t\t\ttransport: settingsManager.getTransport(),"],
+			"replace": ["\t\t\t\t// transport is not forwarded"],
+			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:PI-DURABLE-STREAM-TRANSPORT-WIRE]",
+			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
+		},
+		{
+			"claim": "PI-DURABLE-STREAM-TRANSPORT-FORWARDED",
+			"title": "the Harness settings fix the transport instead of reading the operator's: a chosen sse or plain websocket is silently replaced by auto",
+			"subject": "pi/pi-durable/carrier/harness-setup.js",
+			"find": ["\t\t\t\ttransport: settingsManager.getTransport(),"],
+			"replace": ["\t\t\t\ttransport: \"auto\","],
+			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:PI-DURABLE-STREAM-TRANSPORT-FORWARDED]",
+			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
+		},
+		{
+			"claim": "PI-DURABLE-COMPACTION-WAITS",
+			"title": "the Harness settings hand the SDK pi's compaction settings alone: its default background policy summarizes beside a running turn instead of the turn waiting",
+			"subject": "pi/pi-durable/carrier/harness-setup.js",
+			"find": ["\t\t\treturn { ...settingsManager.getCompactionSettings(), backgroundTokens: 0 };"],
+			"replace": ["\t\t\treturn settingsManager.getCompactionSettings();"],
+			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:PI-DURABLE-COMPACTION-WAITS]",
+			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
+		},
+		{
+			"claim": "PI-DURABLE-PROMPT-SKILL-SCOPE-BASE",
+			"title": "the prompt hands the skills setting over as written: a relative project entry is read against the conversation's directory and its skills are silently not listed",
+			"subject": "pi/pi-durable/carrier/prompt.js",
+			"find": ["\t\t\t\t\tskillPaths: scopedSkillPaths(settings, agentDir, fallbackCwd),"],
+			"replace": ["\t\t\t\t\tskillPaths: settings.getSkillPaths(),"],
+			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:PI-DURABLE-PROMPT-SKILL-SCOPE-BASE]",
+			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
+		},
+		{
+			"claim": "PI-DURABLE-RESUME-OPENS-CHOSEN",
+			"title": "the runtime drops the chosen session id: --resume opens a new session instead of the conversation the operator picked",
+			"subject": "pi/pi-durable/carrier/runtime.js",
+			"find": ["\t\toptions.continueSession ?? false,\n\t\toptions.session,\n\t);"],
+			"replace": ["\t\toptions.continueSession ?? false,\n\t);"],
+			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:PI-DURABLE-RESUME-OPENS-CHOSEN]",
+			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
+		},
+		{
+			"claim": "PI-DURABLE-RESUME-CANCEL-OPENS-NOTHING",
+			"title": "a cancelled --resume falls back to the newest session: the operator said no and a conversation opens anyway",
+			"subject": "pi/pi-durable/bootstrap.mjs",
+			"find": ["\t\t\tprocess.stderr.write(\"[pi-durable] resume-cancelled: nothing was opened\\n\");\n\t\t\treturn;"],
+			"replace": ["\t\t\targs.continueSession = true;"],
+			"gate": ["bash", "run.sh", "check-pi-durable-beside"],
+			"timeoutSeconds": 300,
+			"signature": "[QK:PI-DURABLE-RESUME-CANCEL-OPENS-NOTHING]",
+			"signatureSource": "pi-extensions/lib/pi-durable-carrier.test.ts",
+			"build": { "argv": ["bash", "scripts/build-bridge.sh"], "output": "mcp/entwurf-bridge/dist" }
 		}
 	]
 }