@agentproto/runtime 2.6.0 → 2.8.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
+import { join, resolve, dirname, basename, isAbsolute, normalize, relative, extname, delimiter, sep } from 'path';
 import { createReadStream, promises, readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, renameSync, chmodSync, openSync, closeSync, realpathSync, statSync, createWriteStream } from 'fs';
 import { homedir, hostname, tmpdir } from 'os';
-import { join, resolve, dirname, basename, isAbsolute, normalize, relative, extname, sep } from 'path';
 import { createInterface } from 'readline';
 import { timingSafeEqual, createHmac, randomBytes, randomUUID, createHash } from 'crypto';
 import { mkdir, writeFile, unlink, readdir, readFile, stat, chmod, rename, rm, appendFile, mkdtemp, realpath, access } from 'fs/promises';
@@ -198,6 +198,127 @@ var init_tool_call_record = __esm({
   "src/tool-call-record.ts"() {
   }
 });
+function cwdLabel(cwd, workspaceSlug) {
+  const leaf = basename(cwd);
+  if (!workspaceSlug || workspaceSlug === leaf) return workspaceSlug ?? leaf;
+  return `${workspaceSlug}/${leaf}`;
+}
+function sessionFooterProvenance(session, options = {}) {
+  const prov = {
+    sessionId: session.id,
+    label: session.label,
+    adapter: session.harness ?? session.adapterSlug,
+    model: session.model,
+    authProfile: session.accessProfile?.label ?? session.accessProfile?.profileRef,
+    parentSessionId: options.supervisor?.id,
+    costUsd: session.costUsd,
+    tokensIn: session.tokensIn,
+    tokensOut: session.tokensOut,
+    source: options.source ?? "daemon",
+    host: options.host,
+    cwd: session.cwd,
+    workspaceSlug: session.workspaceSlug
+  };
+  return { prov, authMode: session.auth?.mode };
+}
+function buildSessionPrFooter(session, options = {}) {
+  const { prov, authMode } = sessionFooterProvenance(session, options);
+  return buildFooter({ prov, authMode, sha: options.sha, kind: "PR" });
+}
+function appendFooterOnce(body, footer) {
+  if (hasProvenanceFooter(body)) return body;
+  return `${body}${footer}`;
+}
+function hasProvenanceFooter(body) {
+  return new RegExp(`<sub>[^\\n]*${MARKER}`).test(body);
+}
+function parseGhPrCreate(command, args, stdout) {
+  if (basename(command) !== "gh") return null;
+  const positionals = args.filter((a) => !a.startsWith("-"));
+  if (positionals[0] !== "pr" || positionals[1] !== "create") return null;
+  const re = /https?:\/\/\S+?\/pull\/(\d+)/g;
+  let match;
+  let last = null;
+  while ((match = re.exec(stdout)) !== null) {
+    last = { url: match[0], number: Number(match[1]) };
+  }
+  return last;
+}
+function detectShellPrCreate(command, resultText) {
+  if (!command || !resultText) return null;
+  const unquoted = command.replace(/'[^']*'/g, " ").replace(/"(?:[^"\\]|\\.)*"/g, " ");
+  if (!/(^|[\s;&|({])gh\s+pr\s+create(\s|$)/.test(unquoted)) return null;
+  const re = /https?:\/\/\S+?\/pull\/(\d+)/g;
+  let match;
+  let last = null;
+  while ((match = re.exec(resultText)) !== null) {
+    last = { url: match[0], number: Number(match[1]) };
+  }
+  return last;
+}
+function cwdRelated(sessionCwd, cwd) {
+  if (sessionCwd === cwd) return true;
+  const sep2 = "/";
+  return cwd.startsWith(sessionCwd + sep2) || sessionCwd.startsWith(cwd + sep2);
+}
+function pickExecutorSession(sessions, cwd) {
+  const candidates = sessions.filter(
+    (s) => s.kind === "agent-cli" && typeof s.cwd === "string" && cwdRelated(s.cwd, cwd)
+  );
+  if (candidates.length === 0) return void 0;
+  const alive = (s) => s.status === "running" || s.status === "starting";
+  const byRecency = (a, b) => (b.startedAt ?? "").localeCompare(a.startedAt ?? "");
+  const live = candidates.filter(alive).sort(byRecency);
+  if (live.length > 0) return live[0];
+  return [...candidates].sort(byRecency)[0];
+}
+var MARKER, fmtTokens, buildFooter;
+var init_pr_provenance = __esm({
+  "src/pr-provenance.ts"() {
+    MARKER = "@agentproto-bot";
+    fmtTokens = (n) => {
+      if (typeof n !== "number" || !Number.isFinite(n)) return null;
+      return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+    };
+    buildFooter = ({
+      prov,
+      authMode,
+      runId,
+      runUrl,
+      sha,
+      kind = "review"
+    }) => {
+      const parts = [`\u{1F916} **${MARKER}** \u2014 ${kind}`];
+      if (prov?.sessionId) {
+        parts.push(`session \`${prov.sessionId}\`${prov.label ? ` (\`${prov.label}\`)` : ""}`);
+      }
+      if (prov?.adapter) parts.push([prov.adapter, authMode].filter(Boolean).join(" / "));
+      else if (!prov?.sessionId) parts.push(`legacy fallback${authMode ? ` (${authMode})` : ""}`);
+      else if (authMode) parts.push(authMode);
+      if (prov?.authProfile) parts.push(`auth-profile \`${prov.authProfile}\``);
+      if (prov?.model) parts.push(`model \`${prov.model}\``);
+      if (prov?.sandboxId) parts.push(`e2b \`${prov.sandboxId}\``);
+      if (prov?.parentSessionId) parts.push(`supervisor \`${prov.parentSessionId}\``);
+      const tin = fmtTokens(prov?.tokensIn);
+      const tout = fmtTokens(prov?.tokensOut);
+      if (tin || tout) parts.push(`${tin ?? "?"} in / ${tout ?? "?"} out`);
+      if (typeof prov?.costUsd === "number") {
+        parts.push(`$${prov.costUsd.toFixed(4)}${prov.source && prov.source !== "adapter" ? ` (${prov.source})` : ""}`);
+      }
+      const showLocalHostCwd = prov?.source === "local" || prov?.source === "daemon" || !runId;
+      if (runId && !showLocalHostCwd) parts.push(`run [${runId}](${runUrl})`);
+      if (showLocalHostCwd) {
+        if (prov?.host) parts.push(`host \`${prov.host}\``);
+        if (prov?.cwd) parts.push(`cwd \`${cwdLabel(prov.cwd, prov.workspaceSlug)}\``);
+      }
+      if (sha) parts.push(`sha \`${sha.slice(0, 7)}\``);
+      return `
+
+---
+<sub>${parts.join(" \xB7 ")}</sub>`;
+    };
+  }
+});
 function sessionTranscriptDir(sessionId, baseDir) {
   return join(baseDir ?? join(homedir(), ".agentproto", "sessions"), sessionId);
 }
@@ -390,6 +511,10 @@ function createTranscriptWriter(opts) {
           const meta = evt.toolCallId ? state.toolCallMeta.get(evt.toolCallId) : void 0;
           if (evt.toolCallId) state.toolCallMeta.delete(evt.toolCallId);
           const { command, args } = extractCommandArgs(meta?.arguments);
+          const createdPr = evt.isError ?? false ? null : detectShellPrCreate(
+            command ?? meta?.toolName,
+            typeof evt.result === "string" ? evt.result : void 0
+          );
           writeRecord(sessionId, state, {
             kind: "tool-call-record",
             sessionId,
@@ -397,7 +522,8 @@ function createTranscriptWriter(opts) {
             ...command !== void 0 ? { command } : {},
             ...args !== void 0 ? { args } : {},
             isError: evt.isError ?? false,
-            ...meta ? { durationMs: Date.now() - meta.startedAt } : {}
+            ...meta ? { durationMs: Date.now() - meta.startedAt } : {},
+            ...createdPr ? { createdPrUrl: createdPr.url, createdPrNumber: createdPr.number } : {}
           });
           break;
         }
@@ -487,8 +613,8 @@ function createTranscriptWriter(opts) {
       if (!state) return Promise.resolve();
       flushBuffers(sessionId, state);
       states.delete(sessionId);
-      return new Promise((resolve26) => {
-        state.stream.end(() => resolve26());
+      return new Promise((resolve27) => {
+        state.stream.end(() => resolve27());
       });
     },
     closeAll() {
@@ -497,7 +623,7 @@ function createTranscriptWriter(opts) {
         const state = states.get(sessionId);
         if (!state) continue;
         flushBuffers(sessionId, state);
-        closings.push(new Promise((resolve26) => state.stream.end(() => resolve26())));
+        closings.push(new Promise((resolve27) => state.stream.end(() => resolve27())));
       }
       states.clear();
       return Promise.all(closings).then(() => void 0);
@@ -522,6 +648,7 @@ var DEBOUNCE_MS;
 var init_transcript_writer = __esm({
   "src/transcript-writer.ts"() {
     init_tool_call_record();
+    init_pr_provenance();
     DEBOUNCE_MS = 250;
   }
 });
@@ -634,20 +761,19 @@ function renderMarkdown(session, opts = {}) {
 function renderJson(session) {
   return JSON.stringify(session, null, 2);
 }
-async function exportClaudeCodeSession(adapterSessionId, cwd) {
+async function exportClaudeCodeSession(adapterSessionId, cwd, configDir) {
   if (!cwd) {
     throw new Error(
       "claude-code exporter: cwd is required to locate the JSONL file.\nPass cwd explicitly or use a session id that is in the registry."
     );
   }
-  const encoded = claudeProjectSlug(cwd);
-  const filePath = join(homedir(), ".claude", "projects", encoded, `${adapterSessionId}.jsonl`);
+  const filePath = join(claudeCodeProjectDir(cwd, configDir), `${adapterSessionId}.jsonl`);
   let stream;
   try {
     stream = createReadStream(filePath, { encoding: "utf8" });
-    await new Promise((resolve26, reject) => {
+    await new Promise((resolve27, reject) => {
       stream.once("error", reject);
-      stream.once("open", resolve26);
+      stream.once("open", resolve27);
     });
   } catch (err) {
     const code = err.code;
@@ -921,7 +1047,7 @@ async function discoverHermesSessions(cwd, since, expectedId) {
 }
 async function defaultHermesRunner(adapterSessionId) {
   const { spawn: spawn7 } = await import('child_process');
-  return new Promise((resolve26, reject) => {
+  return new Promise((resolve27, reject) => {
     const chunks = [];
     const errChunks = [];
     const proc = spawn7(
@@ -940,7 +1066,7 @@ async function defaultHermesRunner(adapterSessionId) {
           )
         );
       } else {
-        resolve26(Buffer.concat(chunks).toString("utf8"));
+        resolve27(Buffer.concat(chunks).toString("utf8"));
       }
     });
   });
@@ -977,9 +1103,9 @@ async function exportDaemonEventsSession(sessionId, desc) {
   let stream;
   try {
     stream = createReadStream(filePath, { encoding: "utf8" });
-    await new Promise((resolve26, reject) => {
+    await new Promise((resolve27, reject) => {
       stream.once("error", reject);
-      stream.once("open", resolve26);
+      stream.once("open", resolve27);
     });
   } catch (err) {
     const code = err.code;
@@ -1735,6 +1861,7 @@ async function exportAgentSession(input) {
   let adapterSlug = input.adapter;
   let cwd = input.cwd;
   let adapterSessionId = sessionId;
+  let configDir;
   const err = (msg) => ({
     sessionId,
     adapter: adapterSlug ?? "unknown",
@@ -1747,6 +1874,7 @@ async function exportAgentSession(input) {
   if (desc) {
     adapterSlug = adapterSlug ?? desc.adapterSlug;
     cwd = cwd ?? desc.cwd;
+    configDir = desc.adapterConfigDir;
     if (desc.adapterSessionId) adapterSessionId = desc.adapterSessionId;
   }
   const tryNative = async () => {
@@ -1764,7 +1892,7 @@ Pass adapter explicitly or use a known session id (sess_xxx or name).`
 Only sessions spawned via claude-code or hermes can be exported.`
       );
     }
-    return exporter.exportSession(adapterSessionId, cwd);
+    return exporter.exportSession(adapterSessionId, cwd, configDir);
   };
   const tryDaemon = () => exportDaemonEventsSession(daemonSessionId, desc);
   let session;
@@ -1844,8 +1972,9 @@ var init_transcript_export = __esm({
 function claudeProjectSlug(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
-function claudeCodeProjectDir(cwd) {
-  return resolve(homedir(), ".claude", "projects", claudeProjectSlug(cwd));
+function claudeCodeProjectDir(cwd, configDir) {
+  const base = configDir ?? resolve(homedir(), ".claude");
+  return resolve(base, "projects", claudeProjectSlug(cwd));
 }
 function extractFirstText(content) {
   if (typeof content === "string") {
@@ -1906,8 +2035,8 @@ function claudeEntrypointFor(mode) {
   return mode === "native" ? "cli" : "sdk-ts";
 }
 async function discoverClaudeCode(input) {
-  const { cwd, since, until, attachmentMode, expectedId } = input;
-  const dir = claudeCodeProjectDir(cwd);
+  const { cwd, since, until, attachmentMode, configDir, expectedId } = input;
+  const dir = claudeCodeProjectDir(cwd, configDir);
   if (expectedId) {
     const filePath = join(dir, `${expectedId}.jsonl`);
     try {
@@ -1952,9 +2081,9 @@ async function discoverClaudeCode(input) {
   scored.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return scored.map((s) => s.candidate);
 }
-async function readClaudeCode(conversationId, cwd) {
+async function readClaudeCode(conversationId, cwd, configDir) {
   const { exportClaudeCodeSession: exportClaudeCodeSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
-  return exportClaudeCodeSession2(conversationId, cwd);
+  return exportClaudeCodeSession2(conversationId, cwd, configDir);
 }
 async function discoverHermes(input) {
   const { discoverHermesSessions: discoverHermesSessions2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
@@ -2045,6 +2174,108 @@ var init_conversation_store = __esm({
     };
   }
 });
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_FILE_PATH: () => CONFIG_FILE_PATH,
+  CONFIG_VERSION: () => CONFIG_VERSION,
+  getConfigKey: () => getConfigKey,
+  loadConfig: () => loadConfig,
+  saveConfig: () => saveConfig,
+  setConfigKey: () => setConfigKey
+});
+function sanitizeAcpAgents(raw, target) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    console.warn(
+      `[runtime/config] ${target}: 'acpAgents' is not an object \u2014 ignoring`
+    );
+    return void 0;
+  }
+  const out = {};
+  for (const [slug, value] of Object.entries(raw)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.bin === "string" && value.bin.length > 0) {
+      out[slug] = value;
+    } else {
+      console.warn(
+        `[runtime/config] ${target}: acpAgents.${slug} is missing a string 'bin' \u2014 ignoring`
+      );
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+async function loadConfig(path) {
+  const target = path ?? CONFIG_FILE_PATH();
+  try {
+    const raw = await promises.readFile(target, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const cfg = parsed;
+      if (cfg.acpAgents !== void 0) {
+        cfg.acpAgents = sanitizeAcpAgents(cfg.acpAgents, target);
+      }
+      return cfg;
+    }
+    console.warn(
+      `[runtime/config] ${target}: top-level value is not an object \u2014 ignoring`
+    );
+    return {};
+  } catch (err) {
+    const code = err.code;
+    if (code && code !== "ENOENT") {
+      console.warn(
+        `[runtime/config] failed to read ${target}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return {};
+  }
+}
+async function saveConfig(next, path) {
+  const target = path ?? CONFIG_FILE_PATH();
+  const payload = { ...next, version: CONFIG_VERSION };
+  const dir = dirname(target);
+  await promises.mkdir(dir, { recursive: true });
+  const tmp = `${target}.tmp`;
+  await promises.writeFile(tmp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await promises.rename(tmp, target);
+}
+function getConfigKey(cfg, dotted) {
+  let cur = cfg;
+  for (const part of dotted.split(".")) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setConfigKey(cfg, dotted, value) {
+  const parts = dotted.split(".");
+  const out = { ...cfg };
+  let cur = out;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    const next = cur[k];
+    if (next && typeof next === "object" && !Array.isArray(next)) {
+      cur[k] = { ...next };
+    } else {
+      cur[k] = {};
+    }
+    cur = cur[k];
+  }
+  const leaf = parts[parts.length - 1];
+  if (value === void 0) {
+    delete cur[leaf];
+  } else {
+    cur[leaf] = value;
+  }
+  return out;
+}
+var CONFIG_VERSION, CONFIG_FILE_PATH;
+var init_config = __esm({
+  "src/config.ts"() {
+    CONFIG_VERSION = 1;
+    CONFIG_FILE_PATH = () => join(homedir(), ".agentproto", "config.json");
+  }
+});
 async function writeRuntimeMeta(workspace, meta) {
   const dir = join(workspace, ".agentproto");
   try {
@@ -2172,11 +2403,12 @@ var RESUME_STRATEGIES = Object.fromEntries(
       {
         outputHint: store.outputHint,
         storeAs: store.storeAs,
-        fsProbe: async (cwd, prevStartedAt, expectedId) => {
+        fsProbe: async (cwd, prevStartedAt, expectedId, configDir) => {
           const candidates = await s.discover({
             cwd,
             since: prevStartedAt,
-            expectedId
+            expectedId,
+            configDir
           });
           return candidates[0]?.conversationId ?? null;
         },
@@ -2220,7 +2452,10 @@ async function augmentWithFsResume(prev) {
   const id = await strategy.fsProbe(
     prev.cwd,
     prev.startedAt,
-    prev.adapterSessionId
+    prev.adapterSessionId,
+    // A config-dir-isolated session (#824) persisted its transcript under
+    // its own CLAUDE_CONFIG_DIR — probe there, not the global ~/.claude.
+    prev.adapterConfigDir
   );
   if (!id) return prev;
   return {
@@ -3075,8 +3310,8 @@ async function enrichWithRemainingQuota(rollup, opts) {
     })
   );
   const capMs = opts.timeoutMs ?? DEFAULT_ENRICH_CAP_MS;
-  const cap = new Promise((resolve26) => {
-    setTimeout(() => resolve26(null), capMs);
+  const cap = new Promise((resolve27) => {
+    setTimeout(() => resolve27(null), capMs);
   });
   const settled = await Promise.race([work, cap]);
   if (settled === null) return rollup;
@@ -3140,8 +3375,8 @@ async function enrichWithAccountCredits(rollup, opts) {
     })
   );
   const capMs = opts.timeoutMs ?? DEFAULT_ENRICH_CAP_MS;
-  const cap = new Promise((resolve26) => {
-    setTimeout(() => resolve26(null), capMs);
+  const cap = new Promise((resolve27) => {
+    setTimeout(() => resolve27(null), capMs);
   });
   const settled = await Promise.race([work, cap]);
   if (settled === null) return rollup;
@@ -3480,52 +3715,9 @@ function normalizeConfig(parsed) {
   if (active !== void 0) out.active = active;
   return out;
 }
-var CONFIG_FILE_PATH = () => join(homedir(), ".agentproto", "config.json");
-function sanitizeAcpAgents(raw, target) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    console.warn(
-      `[runtime/config] ${target}: 'acpAgents' is not an object \u2014 ignoring`
-    );
-    return void 0;
-  }
-  const out = {};
-  for (const [slug, value] of Object.entries(raw)) {
-    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.bin === "string" && value.bin.length > 0) {
-      out[slug] = value;
-    } else {
-      console.warn(
-        `[runtime/config] ${target}: acpAgents.${slug} is missing a string 'bin' \u2014 ignoring`
-      );
-    }
-  }
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-async function loadConfig(path) {
-  const target = path ?? CONFIG_FILE_PATH();
-  try {
-    const raw = await promises.readFile(target, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const cfg = parsed;
-      if (cfg.acpAgents !== void 0) {
-        cfg.acpAgents = sanitizeAcpAgents(cfg.acpAgents, target);
-      }
-      return cfg;
-    }
-    console.warn(
-      `[runtime/config] ${target}: top-level value is not an object \u2014 ignoring`
-    );
-    return {};
-  } catch (err) {
-    const code = err.code;
-    if (code && code !== "ENOENT") {
-      console.warn(
-        `[runtime/config] failed to read ${target}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    return {};
-  }
-}
+
+// src/session-spawn.ts
+init_config();
 var markerSchema = z.object({ worktreeId: z.string() });
 function statOrUndefined(path) {
   try {
@@ -4111,6 +4303,7 @@ function resolveContextContinuityPolicy(globalDefault, harnessDefault, modelDefa
 function computeContextPct(contextSize, contextUsed) {
   if (contextSize === void 0 || contextSize <= 0) return null;
   if (contextUsed === void 0 || contextUsed < 0) return null;
+  if (contextUsed === contextSize) return null;
   const used = Math.min(contextUsed, contextSize);
   return Math.round(used / contextSize * 100);
 }
@@ -4420,6 +4613,9 @@ function composeRoleContext(role, promptAppend, registry) {
   return [role.disposition, spawnLine, promptAppend].filter((p) => !!p).join("\n\n");
 }
 
+// src/role-registry.ts
+init_config();
+
 // src/role-pack.ts
 var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
 function parseFields(raw) {
@@ -4642,7 +4838,7 @@ function createSandboxAgentSessionProxy(opts) {
                 `sandbox proxy: ${consecutivePollFailures} consecutive poll failures against the box daemon (session "${remoteSessionId}") \u2014 giving up. Last error: ${pollErr instanceof Error ? pollErr.message : String(pollErr)}`
               );
             }
-            await new Promise((resolve26) => setTimeout(resolve26, POLL_RETRY_DELAY_MS));
+            await new Promise((resolve27) => setTimeout(resolve27, POLL_RETRY_DELAY_MS));
             continue;
           }
           if (result.timedOut) continue;
@@ -4703,6 +4899,7 @@ function createSandboxAgentSessionProxy(opts) {
 }
 
 // src/worktree-isolation.ts
+init_config();
 var WORKTREE_ISOLATION_ENV = "AGENTPROTO_WORKTREES_ISOLATION";
 var DEFAULT_WORKTREE_ISOLATION = "on-request";
 function normalizeWorktreeField(field) {
@@ -4762,6 +4959,7 @@ async function loadWorktreeIsolation(loadCfg = loadConfig) {
 }
 
 // src/spawn-attach.ts
+init_config();
 var SPAWN_ATTACH_ENV = "AGENTPROTO_SPAWN_ATTACH";
 var DEFAULT_SPAWN_ATTACH = "always";
 function normalizeAttachField(field) {
@@ -4799,6 +4997,9 @@ async function loadSpawnAttach(loadCfg = loadConfig) {
   }
   return DEFAULT_SPAWN_ATTACH;
 }
+
+// src/spawn-dedupe.ts
+init_config();
 var SPAWN_DEDUPE_ENV = "AGENTPROTO_SPAWN_DEDUPE";
 var DEFAULT_SPAWN_DEDUPE = "always";
 var IMPLICIT_KEY_PREFIX = "\0implicit";
@@ -4823,6 +5024,205 @@ async function loadSpawnDedupe(loadCfg = loadConfig) {
   return DEFAULT_SPAWN_DEDUPE;
 }
 
+// src/gh-provenance-shim.ts
+init_pr_provenance();
+var PROVENANCE_WRAP_GH_ENV = "AGENTPROTO_PROVENANCE_WRAP_GH";
+var DEFAULT_WRAP_GH = false;
+var GH_PROVENANCE_ENABLE_ENV = "AGENTPROTO_GH_PROVENANCE";
+var GH_PROVENANCE_ADAPTER_ENV = "AGENTPROTO_ADAPTER";
+var GH_PROVENANCE_MODEL_ENV = "AGENTPROTO_MODEL";
+function parseWrapGh(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "yes" || v === "on") return true;
+  if (v === "0" || v === "false" || v === "no" || v === "off") return false;
+  return void 0;
+}
+async function loadProvenanceWrapGh(loadCfg = defaultLoadConfig) {
+  const fromEnv = parseWrapGh(process.env[PROVENANCE_WRAP_GH_ENV]);
+  if (fromEnv !== void 0) return fromEnv;
+  try {
+    const cfg = await loadCfg();
+    if (typeof cfg.provenance?.wrapGh === "boolean") return cfg.provenance.wrapGh;
+  } catch {
+  }
+  return DEFAULT_WRAP_GH;
+}
+async function defaultLoadConfig() {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  return loadConfig2();
+}
+function assembleShimPath(shimDir, basePath, sep2 = delimiter) {
+  const base = basePath ?? "";
+  const entries = base.length > 0 ? base.split(sep2) : [];
+  if (entries[0] === shimDir) return base;
+  return [shimDir, ...entries].join(sep2);
+}
+function buildGhShimEnv(input) {
+  const env = {
+    PATH: assembleShimPath(input.shimDir, input.basePath, input.sep),
+    [GH_PROVENANCE_ENABLE_ENV]: "1"
+  };
+  if (input.adapter) env[GH_PROVENANCE_ADAPTER_ENV] = input.adapter;
+  if (input.model) env[GH_PROVENANCE_MODEL_ENV] = input.model;
+  return env;
+}
+function renderGhShimScript(opts) {
+  return `#!${opts.nodePath}
+"use strict"
+// GENERATED by @agentproto/runtime (gh-provenance-shim.ts). Do not edit by
+// hand \u2014 the daemon rewrites this on boot. See that module for the rationale.
+const { spawnSync } = require("node:child_process")
+const { statSync, realpathSync } = require("node:fs")
+const path = require("node:path")
+const os = require("node:os")
+
+// The real filesystem location of this shim, so we can skip it while scanning
+// PATH \u2014 compared by realpath so a symlinked temp/home dir (macOS /var ->
+// /private/var) can't fool the equality check into an infinite recursion.
+function realOf(p) {
+  try { return realpathSync(p) } catch { return p }
+}
+
+const MARKER = ${JSON.stringify(MARKER)}
+const SESSION_ID_ENV = ${JSON.stringify(SESSION_ID_ENV)}
+const WORKSPACE_SLUG_ENV = ${JSON.stringify(WORKSPACE_SLUG_ENV)}
+const ADAPTER_ENV = ${JSON.stringify(GH_PROVENANCE_ADAPTER_ENV)}
+const MODEL_ENV = ${JSON.stringify(GH_PROVENANCE_MODEL_ENV)}
+
+const args = process.argv.slice(2)
+const shimDir = __dirname
+
+// Resolve the REAL gh: the first executable \`gh\` on PATH that is NOT this
+// shim's own directory (guarding against infinite recursion).
+function findRealGh() {
+  const selfReal = realOf(shimDir)
+  const dirs = (process.env.PATH || "").split(path.delimiter)
+  for (const d of dirs) {
+    if (!d) continue
+    const candidate = path.join(d, "gh")
+    try { if (!statSync(candidate).isFile()) continue } catch { continue }
+    if (realOf(d) === selfReal) continue
+    return candidate
+  }
+  return null
+}
+
+const realGh = findRealGh()
+if (!realGh) {
+  // No real gh anywhere \u2014 behave exactly as its absence would: not found.
+  process.stderr.write("agentproto gh-provenance shim: real 'gh' not found on PATH\\n")
+  process.exit(127)
+}
+
+// Only \`gh pr create\` is targeted (v1). Everything else passes straight
+// through to the real gh, exit code and all.
+const positionals = args.filter(a => !a.startsWith("-"))
+const isPrCreate = positionals[0] === "pr" && positionals[1] === "create"
+
+function exitFrom(result) {
+  if (result.error) {
+    process.stderr.write(String(result.error && result.error.message) + "\\n")
+    return 127
+  }
+  return typeof result.status === "number" ? result.status : 1
+}
+
+if (!isPrCreate) {
+  const passthrough = spawnSync(realGh, args, { stdio: "inherit" })
+  process.exit(exitFrom(passthrough))
+}
+
+// Targeted: run the real create, capture stdout while echoing it through so
+// the user still sees gh's own output (it prints the PR URL there).
+const run = spawnSync(realGh, args, { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"] })
+const stdout = run.stdout || ""
+if (stdout) process.stdout.write(stdout)
+const exitCode = exitFrom(run)
+
+// Footer step is COSMETIC: any failure here must never change the exit code.
+try {
+  if (exitCode === 0) {
+    const parsed = parsePrUrl(stdout)
+    if (parsed) stampFooter(parsed)
+  }
+} catch { /* swallow \u2014 stamping never fails the underlying gh */ }
+process.exit(exitCode)
+
+// --- pure-ish helpers (mirrors pr-provenance.ts's parseGhPrCreate/buildFooter) ---
+
+function parsePrUrl(text) {
+  // Take the LAST match so an advisory "Warning: \u2026/pull/\u2026" can't shadow the
+  // real URL gh prints on its own line.
+  const re = /https?:\\/\\/([^\\/\\s]+)\\/([^\\/\\s]+)\\/([^\\/\\s]+)\\/pull\\/(\\d+)/g
+  let m
+  let last = null
+  while ((m = re.exec(text)) !== null) {
+    last = { host: m[1], owner: m[2], repo: m[3], number: Number(m[4]), url: m[0] }
+  }
+  return last
+}
+
+function cwdLabel(cwd, ws) {
+  const leaf = path.basename(cwd)
+  if (!ws || ws === leaf) return ws || leaf
+  return ws + "/" + leaf
+}
+
+function buildFooter() {
+  const parts = ["\u{1F916} **" + MARKER + "** \u2014 PR"]
+  const sid = process.env[SESSION_ID_ENV]
+  if (sid) parts.push("session \`" + sid + "\`")
+  const adapter = process.env[ADAPTER_ENV]
+  if (adapter) parts.push(adapter)
+  const model = process.env[MODEL_ENV]
+  if (model) parts.push("model \`" + model + "\`")
+  const host = os.hostname()
+  if (host) parts.push("host \`" + host + "\`")
+  parts.push("cwd \`" + cwdLabel(process.cwd(), process.env[WORKSPACE_SLUG_ENV]) + "\`")
+  return "\\n\\n---\\n<sub>" + parts.join(" \xB7 ") + "</sub>"
+}
+
+function stampFooter(parsed) {
+  // Read the current body via the real gh; append the footer once (idempotent
+  // by MARKER, so a retry never stacks a second one).
+  const view = spawnSync(realGh, ["pr", "view", parsed.url, "--json", "body", "-q", ".body"], { encoding: "utf8" })
+  if (view.status !== 0) return
+  let body = typeof view.stdout === "string" ? view.stdout : ""
+  if (body.endsWith("\\n")) body = body.slice(0, -1)
+  if (body.includes(MARKER)) return
+  const newBody = body + buildFooter()
+  // Post-create PATCH via \`gh api\` \u2014 never touches the create's own args.
+  const apiPath = "repos/" + parsed.owner + "/" + parsed.repo + "/pulls/" + parsed.number
+  const apiArgs = ["api"]
+  if (parsed.host && parsed.host !== "github.com") apiArgs.push("--hostname", parsed.host)
+  apiArgs.push(apiPath, "-X", "PATCH", "-f", "body=" + newBody)
+  spawnSync(realGh, apiArgs, { stdio: "ignore" })
+}
+`;
+}
+function defaultGhShimBaseDir() {
+  return join(homedir(), ".agentproto", "shims");
+}
+var shimDirCache = /* @__PURE__ */ new Map();
+function ensureGhShimDir(opts = {}) {
+  const baseDir = opts.baseDir ?? defaultGhShimBaseDir();
+  const nodePath = opts.nodePath ?? process.execPath;
+  const key = `${baseDir}\0${nodePath}`;
+  const cached = shimDirCache.get(key);
+  if (cached) return cached;
+  const task = (async () => {
+    await mkdir(baseDir, { recursive: true });
+    const shimPath = join(baseDir, "gh");
+    await writeFile(shimPath, renderGhShimScript({ nodePath }), "utf8");
+    await chmod(shimPath, 493);
+    return resolve(baseDir);
+  })();
+  shimDirCache.set(key, task);
+  task.catch(() => shimDirCache.delete(key));
+  return task;
+}
+
 // src/session-spawn.ts
 var SPAWN_CLAIM_WINDOW_MS = 6e5;
 var IMPLICIT_SPAWN_CLAIM_WINDOW_MS = 12e4;
@@ -4997,6 +5397,11 @@ async function resolveAccessProfileAuth(input) {
     }
   };
 }
+function shouldInjectDaemonSelfMount(adapter, sandbox) {
+  if (adapter === "hermes") return true;
+  if (adapter === "claude-code") return sandbox === void 0;
+  return false;
+}
 function cleanAgentLines(lines) {
   return lines.map((l) => l.replace(/\x1b\[[0-9;]*m/g, "")).filter((l) => {
     const t = l.trim();
@@ -5053,7 +5458,8 @@ async function spawnAgentSession(deps2, input) {
     provisionWorktree,
     resolveWorktreeIsolation,
     resolveSpawnAttach,
-    resolveSpawnDedupe
+    resolveSpawnDedupe,
+    resolveProvenanceWrapGh
   } = deps2;
   const explicitCwd = input.cwd !== void 0;
   const explicitWorkspaceSlug = input.workspaceSlug !== void 0;
@@ -5266,7 +5672,7 @@ async function spawnAgentSession(deps2, input) {
   const delegationDenied = role.toolPolicy.delegation === "deny";
   let mcpServers = input.mcpServers;
   const mintedSessionId = mintSessionId();
-  if (!mcpServers && input.adapter === "hermes" && daemonMcpUrl) {
+  if (!mcpServers && shouldInjectDaemonSelfMount(input.adapter, input.sandbox) && daemonMcpUrl) {
     let ref = delegationDenied ? `${daemonMcpUrl}${daemonMcpUrl.includes("?") ? "&" : "?"}denyTools=${DELEGATION_TOOL_NAMES.join(",")}` : daemonMcpUrl;
     ref += `${ref.includes("?") ? "&" : "?"}callerSessionId=${encodeURIComponent(mintedSessionId)}`;
     mcpServers = [{ name: "agentproto", transport: "http", ref }];
@@ -5511,8 +5917,8 @@ async function spawnAgentSession(deps2, input) {
     }
     let resolveClaim;
     claims.set(key, {
-      result: new Promise((resolve26) => {
-        resolveClaim = resolve26;
+      result: new Promise((resolve27) => {
+        resolveClaim = resolve27;
       }),
       // An implicit claim expires sooner than an explicit one — see
       // `IMPLICIT_SPAWN_CLAIM_WINDOW_MS`'s docblock.
@@ -5541,6 +5947,7 @@ async function spawnAgentSession(deps2, input) {
         workspaceSlug: resolvedSlug,
         cwd,
         adapterSlug: input.adapter,
+        adapterConfigDir: adapterConfigDirFor(mintedSessionId),
         harness: input.harness ?? input.adapter,
         ...resolved?.routeSelection !== void 0 ? { routeSelection: resolved.routeSelection } : {},
         ...resolved?.authDescriptor?.provider !== void 0 ? { adapterProvider: resolved.authDescriptor.provider } : {},
@@ -5615,6 +6022,11 @@ async function spawnAgentSession(deps2, input) {
           const agentSession2 = await resolved.startSession({
             cwd: finalCwd,
             ...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {},
+            // Persistent isolated-config dir, keyed by this session's id —
+            // recorded on the pending descriptor above so restart/lazy-resume
+            // can hand the respawned adapter the same dir (native-resume
+            // store). Adapters that don't isolate a config dir ignore it.
+            configDir: adapterConfigDirFor(mintedSessionId),
             ...input.mode ? { mode: input.mode } : {},
             ...launchConfig.options ? { options: launchConfig.options } : {},
             ...launchConfig.wireModel ? { model: launchConfig.wireModel } : {},
@@ -5723,9 +6135,29 @@ ${asyncPrompt}`;
       sandboxId = booted.sandboxId;
       sandboxTeardown = booted.sandboxTeardown;
     } else {
+      let ghProvenanceEnv = {};
+      try {
+        const wrapGh = await (resolveProvenanceWrapGh ?? loadProvenanceWrapGh)();
+        if (wrapGh) {
+          const shimDir = await ensureGhShimDir();
+          ghProvenanceEnv = buildGhShimEnv({
+            shimDir,
+            basePath: process.env.PATH ?? "",
+            adapter: input.harness ?? input.adapter,
+            ...input.model ?? resolved?.defaultModel ? { model: input.model ?? resolved?.defaultModel } : {}
+          });
+        }
+      } catch {
+        ghProvenanceEnv = {};
+      }
       agentSession = await resolved.startSession({
         cwd,
         ...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {},
+        // Persistent isolated-config dir, keyed by this session's id —
+        // recorded on the descriptor below so restart/lazy-resume can hand
+        // the respawned adapter the same dir (native-resume store).
+        // Adapters that don't isolate a config dir ignore it.
+        configDir: adapterConfigDirFor(mintedSessionId),
         ...input.mode ? { mode: input.mode } : {},
         ...launchConfig.options ? { options: launchConfig.options } : {},
         ...launchConfig.wireModel ? { model: launchConfig.wireModel } : {},
@@ -5742,6 +6174,10 @@ ${asyncPrompt}`;
         // exec's. `agent_start` has no caller-facing `env` passthrough to
         // collide with, so this is the entire env for this spawn.
         env: {
+          // Provenance shim env FIRST (PATH + adapter/model) so the identity
+          // vars below always win — they must never be forgeable or shadowed,
+          // and `ghProvenanceEnv` never carries an identity var anyway.
+          ...ghProvenanceEnv,
           [SESSION_ID_ENV]: mintedSessionId,
           [WORKSPACE_SLUG_ENV]: resolvedSlug,
           // Lineage (PARENT_SESSION_ID_ENV's doc, sessions.ts) — mirrors
@@ -5780,6 +6216,7 @@ ${effectivePrompt}`;
       cwd,
       agentSession,
       adapterSlug: input.adapter,
+      adapterConfigDir: adapterConfigDirFor(mintedSessionId),
       ...resolved?.resumable !== void 0 ? { resumable: resolved.resumable } : {},
       ...resolved?.nativeTerminalResume !== void 0 ? { nativeTerminalResume: resolved.nativeTerminalResume } : {},
       harness: input.harness ?? input.adapter,
@@ -5898,13 +6335,13 @@ async function isSharedDirtyCwd(cwd) {
   const identity = resolveWorktreeIdentity(cwd);
   if (identity?.worktreeId !== void 0) return false;
   const { spawn: spawn7 } = await import('child_process');
-  return await new Promise((resolve26) => {
+  return await new Promise((resolve27) => {
     let stdout = "";
     let settled = false;
     const done = (v) => {
       if (!settled) {
         settled = true;
-        resolve26(v);
+        resolve27(v);
       }
     };
     const child = spawn7("git", ["-C", cwd, "status", "--porcelain"], {
@@ -5919,15 +6356,15 @@ async function isSharedDirtyCwd(cwd) {
 }
 async function resolveMcpCredentialHeaders(mcpServers) {
   if (!mcpServers || mcpServers.length === 0) return mcpServers;
-  const { resolveMcpCredentialHeaders: resolve26 } = getMcpCredentialDeps();
-  if (!resolve26) return mcpServers;
+  const { resolveMcpCredentialHeaders: resolve27 } = getMcpCredentialDeps();
+  if (!resolve27) return mcpServers;
   return Promise.all(
     mcpServers.map(async (entry) => {
       const ref = entry.credentialRef;
       if (!ref) return entry;
       let brokered;
       try {
-        brokered = await resolve26({ credentialRef: ref });
+        brokered = await resolve27({ credentialRef: ref });
       } catch (err) {
         console.warn(
           `[agent_start] credentialRef resolution failed for "${entry.name}" (${ref}): ${err instanceof Error ? err.message : String(err)}`
@@ -6034,10 +6471,10 @@ function sandboxAuthFromResolved(auth) {
   };
 }
 async function resolveSandboxSecret(slug) {
-  const { resolveSandboxSecret: resolve26 } = getMcpCredentialDeps();
-  if (!resolve26) return null;
+  const { resolveSandboxSecret: resolve27 } = getMcpCredentialDeps();
+  if (!resolve27) return null;
   try {
-    return await resolve26(slug);
+    return await resolve27(slug);
   } catch (err) {
     console.warn(
       `[agent_start] sandbox secret resolution failed for "${slug}": ${err instanceof Error ? err.message : String(err)}`
@@ -6491,6 +6928,7 @@ ${contextBlocks.join("\n\n")}` : "";
         const judgeSessionId = mintSessionId();
         const agentSession = await resolved.startSession({
           cwd,
+          configDir: adapterConfigDirFor(judgeSessionId),
           ...spec.model ? { model: spec.model } : {},
           env: {
             [SESSION_ID_ENV]: judgeSessionId,
@@ -6505,6 +6943,7 @@ ${contextBlocks.join("\n\n")}` : "";
           cwd,
           agentSession,
           adapterSlug: spec.adapter,
+          adapterConfigDir: adapterConfigDirFor(judgeSessionId),
           label: `judge:${state.policyId}`,
           // PR #800: groups machine-run gate sessions in the VS Code tree.
           origin: "gate",
@@ -7067,11 +7506,13 @@ function listBuckets(root) {
   }
 }
 var serialize = (snapshot) => JSON.stringify(snapshot, null, 2) + "\n";
+var tmpSeq = 0;
+var tmpPathFor = (target) => `${target}.tmp.${process.pid}.${++tmpSeq}`;
 async function writeBucketSnapshot(root, slug, snapshot) {
   const dir = bucketDir(root, slug);
   await promises.mkdir(dir, { recursive: true });
   const target = bucketSessionsFile(root, slug);
-  const tmp = `${target}.tmp.${process.pid}`;
+  const tmp = tmpPathFor(target);
   await promises.writeFile(tmp, serialize(snapshot), "utf8");
   await promises.rename(tmp, target);
 }
@@ -7079,7 +7520,7 @@ function writeBucketSnapshotSync(root, slug, snapshot) {
   const dir = bucketDir(root, slug);
   mkdirSync(dir, { recursive: true });
   const target = bucketSessionsFile(root, slug);
-  const tmp = `${target}.tmp.${process.pid}`;
+  const tmp = tmpPathFor(target);
   writeFileSync(tmp, serialize(snapshot), "utf8");
   renameSync(tmp, target);
 }
@@ -7184,9 +7625,9 @@ async function listClaudeSubagents(projectDir, adapterSessionId) {
   return entries.filter((e) => e.startsWith("agent-") && e.endsWith(".jsonl")).map((e) => join(dir, e)).sort();
 }
 async function resolveNativeLink(input) {
-  const { cwd, adapterSlug, adapterSessionId } = input;
+  const { cwd, adapterSlug, adapterSessionId, adapterConfigDir } = input;
   if (adapterSlug === "claude-code") {
-    const dir = claudeCodeProjectDir(cwd);
+    const dir = claudeCodeProjectDir(cwd, adapterConfigDir);
     const path = join(dir, `${adapterSessionId}.jsonl`);
     const subagents = await listClaudeSubagents(dir, adapterSessionId);
     return { kind: "claude-jsonl", path, subagents };
@@ -7293,8 +7734,8 @@ function createTerminalTranscriptWriter(opts) {
       const stream = streams.get(sessionId);
       if (!stream) return Promise.resolve();
       streams.delete(sessionId);
-      return new Promise((resolve26) => {
-        stream.end(() => resolve26());
+      return new Promise((resolve27) => {
+        stream.end(() => resolve27());
       });
     },
     closeAll() {
@@ -7303,8 +7744,8 @@ function createTerminalTranscriptWriter(opts) {
         const stream = streams.get(sessionId);
         if (!stream) continue;
         closings.push(
-          new Promise((resolve26) => {
-            stream.end(() => resolve26());
+          new Promise((resolve27) => {
+            stream.end(() => resolve27());
           })
         );
       }
@@ -7322,7 +7763,7 @@ var defaultResolver = (model) => resolvePricing(model);
 function tokenCost(tokens, pricePer1M) {
   return tokens === void 0 ? 0 : tokens * pricePer1M / 1e6;
 }
-function deriveSessionUsage(input, resolve26 = defaultResolver) {
+function deriveSessionUsage(input, resolve27 = defaultResolver) {
   const contextUsed = plausibleContextUsed(input.contextSize, input.contextUsed);
   const base = {
     ...input.model !== void 0 ? { model: input.model } : {},
@@ -7336,7 +7777,7 @@ function deriveSessionUsage(input, resolve26 = defaultResolver) {
   }
   const hasTokens = input.tokensIn !== void 0 || input.tokensOut !== void 0;
   if (hasTokens) {
-    const pricing = input.model !== void 0 ? resolve26(input.model) : void 0;
+    const pricing = input.model !== void 0 ? resolve27(input.model) : void 0;
     if (!pricing) {
       return { ...base, source: "no-pricing" };
     }
@@ -7404,14 +7845,14 @@ async function buildRecentDigest(sessionId) {
 }
 async function captureGitStatus(cwd) {
   if (!cwd) return void 0;
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     execFile("git", ["status", "--porcelain"], { cwd }, (err, stdout) => {
       if (err) {
-        resolve26(void 0);
+        resolve27(void 0);
         return;
       }
       const trimmed = stdout.trim();
-      resolve26(trimmed || "(working tree clean)");
+      resolve27(trimmed || "(working tree clean)");
     });
   });
 }
@@ -7536,6 +7977,21 @@ function formatAccessForSpawn(desc) {
   if (!desc.accessProfile?.profileRef) return void 0;
   return { profileRef: desc.accessProfile.profileRef };
 }
+function stripOwnCallerStamp(servers, prevId) {
+  if (!servers) return servers;
+  return servers.map((entry) => {
+    if (entry.transport !== "http" || typeof entry.ref !== "string") return entry;
+    let url;
+    try {
+      url = new URL(entry.ref);
+    } catch {
+      return entry;
+    }
+    if (url.searchParams.get("callerSessionId") !== prevId) return entry;
+    url.searchParams.delete("callerSessionId");
+    return { ...entry, ref: url.toString() };
+  });
+}
 function formatPostureForSpawn(desc) {
   return desc.posture;
 }
@@ -7565,7 +8021,7 @@ async function continueAgentSessionFresh(deps2, prev, opts = {}) {
     access: formatAccessForSpawn(prev),
     posture: formatPostureForSpawn(prev),
     contextProfile: prev.contextProfile,
-    mcpServers: prev.mcpServers,
+    mcpServers: stripOwnCallerStamp(prev.mcpServers, prev.id),
     label: prev.label ? `${prev.label} (continued)` : void 0,
     title: prev.title ? `${prev.title} (continued)` : void 0,
     contextContinuity: opts.contextContinuity ?? prev.contextContinuity,
@@ -7665,6 +8121,9 @@ var SESSIONS_FILE_PATH = () => resolve(homedir(), ".agentproto", "sessions.json"
 function mintSessionId() {
   return `sess_${randomUUID().slice(0, 8)}`;
 }
+function adapterConfigDirFor(sessionId) {
+  return resolve(homedir(), ".agentproto", "adapter-config", sessionId);
+}
 var SESSION_ID_ENV = "AGENTPROTO_SESSION_ID";
 var WORKSPACE_SLUG_ENV = "AGENTPROTO_WORKSPACE_SLUG";
 var PARENT_SESSION_ID_ENV = "AGENTPROTO_PARENT_SESSION_ID";
@@ -7704,6 +8163,7 @@ function toSessionSummary(desc) {
     activitySummary: desc.activitySummary,
     archived: desc.archived,
     keepAlive: desc.keepAlive,
+    pinned: desc.pinned,
     pty: desc.pty,
     name: desc.name,
     argv: desc.argv,
@@ -7727,6 +8187,7 @@ function toSessionSummary(desc) {
     blockedOn: desc.blockedOn,
     stalledSinceMs: desc.stalledSinceMs,
     pendingBgTasks: desc.pendingBgTasks,
+    lastTurnErroredAt: desc.lastTurnErroredAt,
     origin: desc.origin,
     parentSessionId: desc.parentSessionId,
     depth: desc.depth,
@@ -7769,6 +8230,14 @@ function stampProcessAlive(desc) {
     desc.processAlive = false;
   }
 }
+function killChildIfSpawned(child, signal) {
+  if (!child) return;
+  if (typeof child.pid !== "number" || child.pid <= 0) return;
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
 function stampInterrupted(desc) {
   if (desc.killedMidTurn === true && desc.endedReason === "daemon-restart") {
     desc.interrupted = true;
@@ -7894,8 +8363,10 @@ function createSessionsRegistry(opts) {
     desc.currentPhase = desc.busy ? "thinking" : "idle";
   };
   const watchersById = /* @__PURE__ */ new Map();
+  const watcherDetailsById = /* @__PURE__ */ new Map();
   const stampWatchers = (desc) => {
     desc.watchers = watchersById.get(desc.id) ?? 0;
+    desc.watcherDetails = [...watcherDetailsById.get(desc.id) ?? []];
   };
   const childrenBusyCounts = () => {
     const all = Array.from(sessions.values());
@@ -8136,7 +8607,14 @@ function createSessionsRegistry(opts) {
     if (!adapterSlug || !adapterSessionId || !cwd) return;
     void (async () => {
       try {
-        const native = await resolveNativeLink({ cwd, adapterSlug, adapterSessionId });
+        const native = await resolveNativeLink({
+          cwd,
+          adapterSlug,
+          adapterSessionId,
+          // Config-dir-isolated session (#824): the native transcript lives
+          // under the session's own CLAUDE_CONFIG_DIR, not ~/.claude.
+          ...desc.adapterConfigDir ? { adapterConfigDir: desc.adapterConfigDir } : {}
+        });
         const registered = readRegisteredSlugs(workspacesConfigPath);
         const slug = resolveBucketSlug(desc.workspaceSlug, registered);
         const record2 = {
@@ -8145,6 +8623,7 @@ function createSessionsRegistry(opts) {
           cwd,
           adapterSlug,
           adapterSessionId,
+          ...desc.adapterConfigDir ? { adapterConfigDir: desc.adapterConfigDir } : {},
           ...native ? { native } : {},
           agentprotoTranscript: sessionEventsPath(desc.id, transcriptBaseDir),
           ...desc.title ? { title: desc.title } : {},
@@ -8160,7 +8639,7 @@ function createSessionsRegistry(opts) {
     })();
   };
   const schedulePersist = () => {
-    if (!persist) return;
+    if (!persist || shutdownDone) return;
     if (persistTimer) clearTimeout(persistTimer);
     persistTimer = setTimeout(() => {
       void persistSnapshot();
@@ -8196,11 +8675,13 @@ function createSessionsRegistry(opts) {
     rows,
     heldIdsByBucket.get(slug) ?? EMPTY_ID_SET
   );
-  const persistSnapshot = async () => {
+  const persistOnce = async () => {
     try {
+      if (shutdownDone) return;
       const savedAt = (/* @__PURE__ */ new Date()).toISOString();
       if (partitioned) {
         for (const [slug, rows] of groupRowsByBucket()) {
+          if (shutdownDone) return;
           await writeBucketSnapshot(bucketsRoot, slug, {
             savedAt,
             sessions: rowsToWrite(slug, rows)
@@ -8217,6 +8698,24 @@ function createSessionsRegistry(opts) {
       );
     }
   };
+  let persistRunning = false;
+  let persistRerun = false;
+  const persistSnapshot = async () => {
+    if (shutdownDone) return;
+    if (persistRunning) {
+      persistRerun = true;
+      return;
+    }
+    persistRunning = true;
+    try {
+      do {
+        persistRerun = false;
+        await persistOnce();
+      } while (persistRerun && !shutdownDone);
+    } finally {
+      persistRunning = false;
+    }
+  };
   const appendLine = (rt, line, stream) => {
     rt.recentLines.push(line);
     if (rt.recentLines.length > RECENT_LINES_CAP) {
@@ -8510,11 +9009,11 @@ function createSessionsRegistry(opts) {
   };
   const waitForTurnSettled = (rt, id, caller) => {
     if (!rt.busy) return Promise.resolve();
-    return new Promise((resolve26, reject) => {
+    return new Promise((resolve27, reject) => {
       const onBusy = (busy) => {
         if (busy) return;
         cleanup();
-        resolve26();
+        resolve27();
       };
       const cleanup = () => {
         clearTimeout(timer);
@@ -8547,6 +9046,30 @@ function createSessionsRegistry(opts) {
     }
     await waitForTurnSettled(rt, id, caller);
   };
+  const dispatchQueuedPrompt = (rt) => {
+    const queue = rt.desc.promptQueue;
+    const next = queue?.[0];
+    if (!queue || !next) return;
+    rt.desc.promptQueue = queue.slice(1);
+    schedulePersist();
+    void (async () => {
+      try {
+        await maybeResumeAgent(rt);
+        const liveRt = validateAgentTurn(rt.desc.id, "queue-drain");
+        await runAgentTurn(
+          liveRt,
+          next.message,
+          next.source ? { promptSource: next.source } : void 0
+        );
+      } catch (err) {
+        appendLine(
+          rt,
+          `[error] queued prompt dropped \u2014 ${err instanceof Error ? err.message : String(err)}`,
+          "stderr"
+        );
+      }
+    })();
+  };
   const recordFailedResume = (rt) => {
     rt.desc.resumeAttempts = (rt.desc.resumeAttempts ?? 0) + 1;
     rt.desc.lastResumeAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -8942,6 +9465,13 @@ ${message}`;
           delete rt.desc.nextRestartAt;
           delete rt.desc.recentRestartAts;
         }
+        if (turnEndReason === "error") {
+          rt.desc.lastTurnErroredAt = (/* @__PURE__ */ new Date()).toISOString();
+          schedulePersist();
+        } else if (rt.desc.lastTurnErroredAt !== void 0) {
+          delete rt.desc.lastTurnErroredAt;
+          schedulePersist();
+        }
         if (rt.readUsage) {
           try {
             const usage2 = await rt.readUsage();
@@ -9048,6 +9578,7 @@ ${message}`;
           });
         }
       }
+      dispatchQueuedPrompt(rt);
     }
   };
   const wireOutputStreams = (rt) => {
@@ -9218,6 +9749,9 @@ ${message}`;
         // Persist the spawn-time MCP mounts so resume re-mounts the same
         // toolset (orchestrator WP1). Reference-only shape — no secrets.
         ...input.mcpServers ? { mcpServers: input.mcpServers } : {},
+        // Persist the isolated-config location so restart/lazy-resume can
+        // hand the respawned adapter the SAME dir (native-resume store).
+        ...input.adapterConfigDir ? { adapterConfigDir: input.adapterConfigDir } : {},
         // Parent attribution + depth (orchestrator WP4). Depth is always
         // recorded (defaults to 0) so subtree/depth logic never has to
         // distinguish "absent" from "root".
@@ -9324,6 +9858,7 @@ ${message}`;
         ...input.title ? { title: input.title } : {},
         ...input.label ? { renamedByUser: false } : {},
         ...input.mcpServers ? { mcpServers: input.mcpServers } : {},
+        ...input.adapterConfigDir ? { adapterConfigDir: input.adapterConfigDir } : {},
         ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
         ...input.notifyParentOnCrash ? { notifyParentOnCrash: true } : {},
         ...input.origin ? { origin: input.origin } : {},
@@ -9695,6 +10230,17 @@ ${message}`;
       if (opts2?.interrupt && rtPre.busy) {
         await interruptInFlightTurn(rtPre, id, "enqueuePrompt");
       }
+      if (opts2?.queue && rtPre.busy) {
+        const item = {
+          id: opts2.queueId ?? `q_${randomUUID().slice(0, 8)}`,
+          message,
+          queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...opts2.source ? { source: opts2.source } : {}
+        };
+        rtPre.desc.promptQueue = opts2.force ? [item, ...rtPre.desc.promptQueue ?? []] : [...rtPre.desc.promptQueue ?? [], item];
+        schedulePersist();
+        return;
+      }
       await maybeResumeAgent(rtPre);
       const rt = validateAgentTurn(id, "enqueuePrompt");
       void runAgentTurn(rt, message, opts2?.source ? { promptSource: opts2.source } : void 0).catch((err) => {
@@ -9705,6 +10251,17 @@ ${message}`;
         );
       });
     },
+    removeQueuedPrompt(id, queueId) {
+      const rt = sessions.get(id);
+      if (!rt?.desc.promptQueue?.length) return { removed: false };
+      const next = rt.desc.promptQueue.filter((p) => p.id !== queueId);
+      const removed = next.length !== rt.desc.promptQueue.length;
+      if (removed) {
+        rt.desc.promptQueue = next;
+        schedulePersist();
+      }
+      return { removed };
+    },
     async resumeOnBoot(id) {
       const rt = sessions.get(id);
       if (!rt) return { status: "skipped", reason: "unknown" };
@@ -9934,13 +10491,26 @@ ${message}`;
       }
       return desc;
     },
-    incWatchers(id) {
+    incWatchers(id, detail) {
       watchersById.set(id, (watchersById.get(id) ?? 0) + 1);
+      if (detail) {
+        const list = watcherDetailsById.get(id);
+        if (list) list.push(detail);
+        else watcherDetailsById.set(id, [detail]);
+      }
     },
-    decWatchers(id) {
+    decWatchers(id, detail) {
       const next = (watchersById.get(id) ?? 0) - 1;
       if (next > 0) watchersById.set(id, next);
       else watchersById.delete(id);
+      if (detail) {
+        const list = watcherDetailsById.get(id);
+        if (list) {
+          const idx = list.indexOf(detail);
+          if (idx >= 0) list.splice(idx, 1);
+          if (list.length === 0) watcherDetailsById.delete(id);
+        }
+      }
     },
     attach(id, onLine) {
       const rt = sessions.get(id);
@@ -10045,7 +10615,7 @@ ${message}`;
         }
         void terminalTranscriptWriter.close(rt.desc.id);
       }
-      rt.child?.kill(signal);
+      killChildIfSpawned(rt.child, signal);
       if (rt.browserStop) {
         void rt.browserStop().catch(() => void 0);
       }
@@ -10070,7 +10640,7 @@ ${message}`;
         tracedSessions.delete(rt.desc.id);
         rt.agentSession = void 0;
       }
-      rt.child?.kill("SIGTERM");
+      killChildIfSpawned(rt.child, "SIGTERM");
       schedulePersist();
       const banner = "\u2500\u2500 reaped after being idle past the threshold; the adapter process was freed. Re-prompt to resume this session in place. \u2500\u2500";
       appendLine(rt, banner, "stdout");
@@ -10255,6 +10825,44 @@ ${message}`;
       stampProcessAlive(rt.desc);
       return rt.desc;
     },
+    setPinned(id, pinned) {
+      const rt = sessions.get(id);
+      if (!rt) throw new Error(`setPinned: no session "${id}"`);
+      rt.desc.pinned = pinned;
+      schedulePersist();
+      sessionEvents?.emit({
+        type: "session:pinned-changed",
+        sessionId: id,
+        pinned,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      stampProcessAlive(rt.desc);
+      return rt.desc;
+    },
+    flagAwaitingInput(id, patch) {
+      const rt = sessions.get(id);
+      if (!rt) throw new Error(`flagAwaitingInput: no session "${id}"`);
+      const isAlive = rt.desc.status === "running" || rt.desc.status === "starting";
+      if (!isAlive) {
+        throw new Error(
+          `flagAwaitingInput: session "${id}" is ${rt.desc.status}, not live \u2014 only a running/starting session's awaiting-input classification can be corrected.`
+        );
+      }
+      rt.desc.awaitingInput = patch.awaitingInput;
+      rt.desc.awaitingQuestion = patch.awaitingInput && patch.question !== void 0 ? { text: patch.question, source: "structured" } : void 0;
+      schedulePersist();
+      sessionEvents?.emit({
+        type: "session:awaiting-input-flagged",
+        sessionId: id,
+        awaitingInput: patch.awaitingInput,
+        reason: patch.reason,
+        ...rt.desc.awaitingQuestion ? { question: rt.desc.awaitingQuestion } : {},
+        ...rt.desc.label ? { label: rt.desc.label } : {},
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      stampProcessAlive(rt.desc);
+      return rt.desc;
+    },
     listPendingPermissions(filter) {
       const all = Array.from(pendingPermissions.values());
       const scoped = filter?.sessionId ? all.filter((p) => p.sessionId === filter.sessionId) : all;
@@ -10313,7 +10921,7 @@ ${message}`;
           } catch {
           }
         }
-        rt.child?.kill("SIGTERM");
+        killChildIfSpawned(rt.child, "SIGTERM");
         emitExited(rt);
       }
     }
@@ -10359,9 +10967,17 @@ function loadHistorySnapshot(persistPath, sessions, sessionEvents, bucketSlug, s
   try {
     parsed = JSON.parse(raw);
   } catch {
-    console.warn(
-      `[sessions] history file ${persistPath} is malformed \u2014 ignoring`
-    );
+    const quarantine = `${persistPath}.corrupt-${Date.now()}`;
+    try {
+      renameSync(persistPath, quarantine);
+      console.warn(
+        `[sessions] history file ${persistPath} is malformed \u2014 quarantined to ${quarantine} and starting this bucket empty`
+      );
+    } catch {
+      console.warn(
+        `[sessions] history file ${persistPath} is malformed and could not be quarantined \u2014 ignoring`
+      );
+    }
     return;
   }
   if (!Array.isArray(parsed.sessions)) return;
@@ -10422,109 +11038,9 @@ function quoteArg(arg) {
   if (/^[a-zA-Z0-9._/=:@,+-]+$/.test(arg)) return arg;
   return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
 }
-var MARKER = "@agentproto-bot";
-var fmtTokens = (n) => {
-  if (typeof n !== "number" || !Number.isFinite(n)) return null;
-  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
-};
-function cwdLabel(cwd, workspaceSlug) {
-  const leaf = basename(cwd);
-  if (!workspaceSlug || workspaceSlug === leaf) return workspaceSlug ?? leaf;
-  return `${workspaceSlug}/${leaf}`;
-}
-var buildFooter = ({
-  prov,
-  authMode,
-  runId,
-  runUrl,
-  sha,
-  kind = "review"
-}) => {
-  const parts = [`\u{1F916} **${MARKER}** \u2014 ${kind}`];
-  if (prov?.sessionId) {
-    parts.push(`session \`${prov.sessionId}\`${prov.label ? ` (\`${prov.label}\`)` : ""}`);
-  }
-  if (prov?.adapter) parts.push([prov.adapter, authMode].filter(Boolean).join(" / "));
-  else if (!prov?.sessionId) parts.push(`legacy fallback${authMode ? ` (${authMode})` : ""}`);
-  else if (authMode) parts.push(authMode);
-  if (prov?.authProfile) parts.push(`auth-profile \`${prov.authProfile}\``);
-  if (prov?.model) parts.push(`model \`${prov.model}\``);
-  if (prov?.sandboxId) parts.push(`e2b \`${prov.sandboxId}\``);
-  if (prov?.parentSessionId) parts.push(`supervisor \`${prov.parentSessionId}\``);
-  const tin = fmtTokens(prov?.tokensIn);
-  const tout = fmtTokens(prov?.tokensOut);
-  if (tin || tout) parts.push(`${tin ?? "?"} in / ${tout ?? "?"} out`);
-  if (typeof prov?.costUsd === "number") {
-    parts.push(`$${prov.costUsd.toFixed(4)}${prov.source && prov.source !== "adapter" ? ` (${prov.source})` : ""}`);
-  }
-  const showLocalHostCwd = prov?.source === "local" || prov?.source === "daemon" || !runId;
-  if (runId && !showLocalHostCwd) parts.push(`run [${runId}](${runUrl})`);
-  if (showLocalHostCwd) {
-    if (prov?.host) parts.push(`host \`${prov.host}\``);
-    if (prov?.cwd) parts.push(`cwd \`${cwdLabel(prov.cwd, prov.workspaceSlug)}\``);
-  }
-  if (sha) parts.push(`sha \`${sha.slice(0, 7)}\``);
-  return `
-
----
-<sub>${parts.join(" \xB7 ")}</sub>`;
-};
-function sessionFooterProvenance(session, options = {}) {
-  const prov = {
-    sessionId: session.id,
-    label: session.label,
-    adapter: session.harness ?? session.adapterSlug,
-    model: session.model,
-    authProfile: session.accessProfile?.label ?? session.accessProfile?.profileRef,
-    parentSessionId: options.supervisor?.id,
-    costUsd: session.costUsd,
-    tokensIn: session.tokensIn,
-    tokensOut: session.tokensOut,
-    source: options.source ?? "daemon",
-    host: options.host,
-    cwd: session.cwd,
-    workspaceSlug: session.workspaceSlug
-  };
-  return { prov, authMode: session.auth?.mode };
-}
-function buildSessionPrFooter(session, options = {}) {
-  const { prov, authMode } = sessionFooterProvenance(session, options);
-  return buildFooter({ prov, authMode, sha: options.sha, kind: "PR" });
-}
-function appendFooterOnce(body, footer) {
-  if (body.includes(MARKER)) return body;
-  return `${body}${footer}`;
-}
-function parseGhPrCreate(command, args, stdout) {
-  if (basename(command) !== "gh") return null;
-  const positionals = args.filter((a) => !a.startsWith("-"));
-  if (positionals[0] !== "pr" || positionals[1] !== "create") return null;
-  const re = /https?:\/\/\S+?\/pull\/(\d+)/g;
-  let match;
-  let last = null;
-  while ((match = re.exec(stdout)) !== null) {
-    last = { url: match[0], number: Number(match[1]) };
-  }
-  return last;
-}
-function cwdRelated(sessionCwd, cwd) {
-  if (sessionCwd === cwd) return true;
-  const sep2 = "/";
-  return cwd.startsWith(sessionCwd + sep2) || sessionCwd.startsWith(cwd + sep2);
-}
-function pickExecutorSession(sessions, cwd) {
-  const candidates = sessions.filter(
-    (s) => s.kind === "agent-cli" && typeof s.cwd === "string" && cwdRelated(s.cwd, cwd)
-  );
-  if (candidates.length === 0) return void 0;
-  const alive = (s) => s.status === "running" || s.status === "starting";
-  const byRecency = (a, b) => (b.startedAt ?? "").localeCompare(a.startedAt ?? "");
-  const live = candidates.filter(alive).sort(byRecency);
-  if (live.length > 0) return live[0];
-  return [...candidates].sort(byRecency)[0];
-}
 
 // src/pr-provenance-stamp.ts
+init_pr_provenance();
 async function stampPrProvenance(input) {
   try {
     if (input.exitCode !== 0) return { stamped: false, reason: "command failed" };
@@ -10558,19 +11074,19 @@ async function stampFooterOnPr(input) {
     const view = await run(["pr", "view", input.prUrl, "--json", "body", "--jq", ".body"], input.cwd);
     if (view.exitCode !== 0) return { stamped: false, reason: `gh pr view exit ${view.exitCode}` };
     const body = view.stdout.replace(/\n+$/, "");
-    const alreadyStamped = body.includes(MARKER);
+    const alreadyStamped = hasProvenanceFooter(body);
     if (!alreadyStamped) {
       const newBody = appendFooterOnce(body, footer);
       const edit = await run(["pr", "edit", input.prUrl, "--body", newBody], input.cwd);
       if (edit.exitCode !== 0) {
         return { stamped: false, reason: `gh pr edit exit ${edit.exitCode}` };
       }
+      input.registry.recordOpenedPr(input.session.id, {
+        adapter: input.session.harness ?? input.session.adapterSlug ?? "gh",
+        number: input.prNumber,
+        url: input.prUrl
+      });
     }
-    input.registry.recordOpenedPr(input.session.id, {
-      adapter: input.session.harness ?? input.session.adapterSlug ?? "gh",
-      number: input.prNumber,
-      url: input.prUrl
-    });
     return {
       stamped: true,
       url: input.prUrl,
@@ -10584,14 +11100,14 @@ async function stampFooterOnPr(input) {
 }
 var defaultGhRunner = async (args, cwd) => {
   const { spawn: spawn7 } = await import('child_process');
-  return await new Promise((resolve26) => {
+  return await new Promise((resolve27) => {
     let stdout = "";
     const child = spawn7("gh", [...args], { cwd, shell: false });
     child.stdout?.on("data", (d) => {
       stdout += d.toString("utf8");
     });
-    child.on("error", () => resolve26({ exitCode: 1, stdout }));
-    child.on("close", (code) => resolve26({ exitCode: code ?? 1, stdout }));
+    child.on("error", () => resolve27({ exitCode: 1, stdout }));
+    child.on("close", (code) => resolve27({ exitCode: code ?? 1, stdout }));
   });
 };
 var ALLOWLIST_REL = ".agentproto/allowed-commands.json";
@@ -12690,6 +13206,7 @@ function stringifyValues(raw) {
   }
   return out;
 }
+init_config();
 var RestartOverrideError = class extends Error {
   code = "restart_override_invalid";
   status = 400;
@@ -12960,9 +13477,11 @@ async function restartAgentSession(registry, resolveAgentAdapter, prev, opts = {
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(message);
     }
+    const restartConfigDir = prev.adapterConfigDir ?? adapterConfigDirFor(restartedSessionId);
     const agentSession = await resolved.startSession({
       cwd,
       ...resumeSessionId ? { resumeSessionId } : {},
+      configDir: restartConfigDir,
       ...launchConfig.wireModel ? { model: launchConfig.wireModel } : {},
       ...effEffort ? { effort: effEffort } : {},
       ...effPosture !== void 0 ? { posture: effPosture } : {},
@@ -12988,6 +13507,7 @@ async function restartAgentSession(registry, resolveAgentAdapter, prev, opts = {
       cwd,
       agentSession,
       adapterSlug,
+      adapterConfigDir: restartConfigDir,
       ...resolved.resumable !== void 0 ? { resumable: resolved.resumable } : {},
       ...resolved.nativeTerminalResume !== void 0 ? { nativeTerminalResume: resolved.nativeTerminalResume } : {},
       harness: effHarness,
@@ -13301,7 +13821,10 @@ async function resolveConversationId(desc) {
     // A live/ongoing session has no endedAt yet and must keep matching
     // with no upper bound — only a dead session's endedAt narrows.
     ...desc.endedAt ? { until: desc.endedAt } : {},
-    ...attachmentMode ? { attachmentMode } : {}
+    ...attachmentMode ? { attachmentMode } : {},
+    // A config-dir-isolated session's store lives under its own
+    // CLAUDE_CONFIG_DIR (#824), not the provider's global dir.
+    ...desc.adapterConfigDir ? { configDir: desc.adapterConfigDir } : {}
   });
   if (candidates.length === 0) {
     return {
@@ -13360,7 +13883,7 @@ async function readConversation(registry, input) {
     });
   }
   try {
-    const session = await store.read(resolved.conversationId, desc.cwd);
+    const session = await store.read(resolved.conversationId, desc.cwd, desc.adapterConfigDir);
     const content = format === "json" ? renderJson(session) : renderMarkdown(session);
     return {
       conversation: session,
@@ -15000,6 +15523,91 @@ function registerSessionTools(rawServer, opts) {
       }
     }
   );
+  server.tool(
+    "session_flag_status",
+    "Manually correct a session's `awaitingInput`/`awaitingQuestion` classification. This is the ONLY write path for that pair besides the daemon's own internal heuristic (which guesses from the tail of the transcript) and a driver-reported structured prompt \u2014 use this when the heuristic missed a real question (set `awaitingInput:true`, optionally attaching `question`) or flagged a false positive (set `awaitingInput:false`, which also clears any attached `awaitingQuestion` \u2014 a question can't outlive its awaiting-input flag). `reason` is required \u2014 a short justification that rides on the emitted `session:awaiting-input-flagged` event, visible via `session_events_poll`, for audit. Only allowed on a LIVE session (running/starting) \u2014 mirrors the inverse of `session_archive`'s terminal-only guard: a terminal session has no turn left to be awaiting anything. The override itself is NOT sticky \u2014 it's cleared automatically like any other awaiting-input signal on the session's next prompt/turn start.",
+    {
+      idOrName: z.string().min(1).describe("Session id or name to flag \u2014 from `session_list`, must be live."),
+      awaitingInput: z.boolean().describe(
+        "New value for the session's awaiting-input classification \u2014 true if it's actually blocked on a question/decision the heuristic missed, false to clear a false positive."
+      ),
+      question: z.string().min(1).optional().describe(
+        'The question text to attach when `awaitingInput:true` \u2014 stored as `awaitingQuestion` (`source:"structured"`). Only meaningful alongside `awaitingInput:true`; passing it with `awaitingInput:false` is a validation error.'
+      ),
+      reason: z.string().min(1).describe(
+        "Required short justification for this override \u2014 audit/log only, rides on the emitted `session:awaiting-input-flagged` event."
+      )
+    },
+    async (input) => {
+      if (!input.awaitingInput && input.question !== void 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "session_flag_status: `question` is only meaningful when `awaitingInput:true` (got `awaitingInput:false` with a `question` set)."
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const prev = registry.findByIdOrName(input.idOrName);
+      if (!prev) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: `no session "${input.idOrName}" found` })
+            }
+          ],
+          isError: true
+        };
+      }
+      if (callerScope) {
+        const subtree = collectSubtree(
+          callerScope.ownerSessionId,
+          registry.list({ includeArchived: true })
+        );
+        if (!subtree.has(prev.id)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "orchestrator_session_out_of_scope",
+                  message: `session_flag_status: session "${prev.id}" is not in your subtree \u2014 a scoped orchestrator can only flag sessions it (transitively) spawned.`,
+                  ok: false,
+                  sessionId: prev.id
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      try {
+        const desc = registry.flagAwaitingInput(prev.id, {
+          awaitingInput: input.awaitingInput,
+          ...input.question !== void 0 ? { question: input.question } : {},
+          reason: input.reason
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(desc, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `session_flag_status: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "session_rename",
     "Set or clear a session's user-facing name \u2014 the label the sessions tree, transcript header, and tab show. `label` out-ranks `title` in that display chain, so a user rename should write `label` (the default a UI picks) to be sure it shows; `title` is the auto-derived first-sentence fallback. For EACH of `title`/`label`: a non-empty string sets it (trimmed + length-capped), an empty string clears it (reverting to the derived title / a friendly `adapter \xB7 id` fallback), and omitting it leaves that field untouched. Persists across daemon restarts. Does NOT rename the adapter-native session or touch the running agent.",
@@ -15146,6 +15754,68 @@ function registerSessionTools(rawServer, opts) {
       }
     }
   );
+  server.tool(
+    "session_set_pinned",
+    "Set or clear a session's list-visibility pin. When `pinned` is true, the session sorts to the top of `agentproto sessions` and the VS Code sessions webview's dedicated Pinned group. Set false to clear it. Persists across daemon restarts. Purely a sort/display flag \u2014 does NOT touch the idle-reaper, keepAlive, or emit any notification, and does NOT touch the running agent.",
+    {
+      idOrName: z.string().min(1).describe("Session id or name to update \u2014 from `session_list`."),
+      pinned: mcpBool2.describe(
+        "true to pin this session to the top of the list, false to unpin it."
+      )
+    },
+    async (input) => {
+      const prev = registry.findByIdOrName(input.idOrName);
+      if (!prev) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: `no session "${input.idOrName}" found` })
+            }
+          ],
+          isError: true
+        };
+      }
+      if (callerScope) {
+        const subtree = collectSubtree(
+          callerScope.ownerSessionId,
+          registry.list({ includeArchived: true })
+        );
+        if (!subtree.has(prev.id)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "orchestrator_session_out_of_scope",
+                  message: `session_set_pinned: session "${prev.id}" is not in your subtree \u2014 a scoped orchestrator can only update sessions it (transitively) spawned.`,
+                  ok: false,
+                  sessionId: prev.id
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      try {
+        const desc = registry.setPinned(prev.id, input.pinned);
+        return {
+          content: [{ type: "text", text: JSON.stringify(desc, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `session_set_pinned: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "terminal_start",
     "Spawn a process under a real PTY (node-pty) on the host. Bytes (including ANSI escapes, alt-screen sequences) flow through the daemon's byte ring buffer; subscribers attach via the WS at /sessions/:id/pty. Use for interactive TUIs (claude, vim, htop) or to orchestrate shells from another agent. Returns the session descriptor.",
@@ -15441,7 +16111,7 @@ function registerBrainTools(server, opts) {
   );
   server.tool(
     "workspace_brain_status",
-    "Report how current a workspace's brain is: how many sessions are indexed, how many known-but-pending remain, total bytes, and whether the index is query-ready. Resolves the workspace as the explicit `workspace` argument, else the calling session's own workspace.",
+    "Report how current a workspace's brain is: how many sessions are indexed, how many known-but-pending remain, how many were skipped as permanently unavailable (no transcript ever reachable \u2014 bash PTYs, GC'd transcripts; retry one explicitly with `workspace_brain_ingest`'s `sessionId`), total bytes, and whether the index is query-ready. Resolves the workspace as the explicit `workspace` argument, else the calling session's own workspace.",
     {
       workspace: z.string().optional().describe("Workspace slug. Omit to use the calling session's workspace.")
     },
@@ -15523,7 +16193,7 @@ async function readSessionForBrain(sessionId) {
     const store = CONVERSATION_STORES[record2.adapterSlug];
     if (store) {
       try {
-        const exported = await store.read(record2.adapterSessionId, record2.cwd);
+        const exported = await store.read(record2.adapterSessionId, record2.cwd, record2.adapterConfigDir);
         if (exported?.messages?.length) return exported;
       } catch {
       }
@@ -18846,9 +19516,11 @@ ${panelBridgeScript("agentproto-live-session")}
 // ============================================================
 // INLINED REDUCER COPY \u2014 hand-kept mirror of live-session-app.logic.ts.
 // Plain JS, same semantics: coalesce consecutive text-delta of the same
-// session, pair tool-call/tool-result by toolCallId, pass through
-// turn-end/usage_update, ignore unknown kinds. Keep in sync with the
-// TS module; the TS module is the one the test suite imports.
+// session (and rejoin an unterminated mid-line fragment split by an
+// interleaved record \u2014 see the TS module's text-delta arm), pair
+// tool-call/tool-result by toolCallId, pass through turn-end/usage_update,
+// ignore unknown kinds. Keep in sync with the TS module; the TS module is
+// the one the test suite imports.
 // ============================================================
 
 function initialTimelineState() {
@@ -18859,22 +19531,50 @@ function rowId(record, rows) {
   return record.seq != null ? (record.kind + '-' + record.seq) : (record.kind + '-' + rows.length);
 }
 
+// Fold a text-delta record into an existing row (fresh object), keeping the
+// row's "partial" hint in step with the latest record \u2014 see mergeTextDelta in
+// the TS module.
+function mergeTextDelta(row, record) {
+  var merged = Object.assign({}, row, {
+    text: row.text + (record.text || ''),
+    seq: record.seq,
+    ts: record.ts,
+  });
+  if (record.partial === true) merged.partial = true;
+  else delete merged.partial;
+  return merged;
+}
+
 function reduceEvent(state, record) {
   switch (record.kind) {
     case 'text-delta': {
       var last = state.rows[state.rows.length - 1];
       if (last && last.kind === 'text' && last.sessionId === record.sessionId) {
-        var merged = Object.assign({}, last, {
-          text: last.text + (record.text || ''),
-          seq: record.seq,
-          ts: record.ts,
-        });
-        return { rows: state.rows.slice(0, -1).concat([merged]) };
+        return { rows: state.rows.slice(0, -1).concat([mergeTextDelta(last, record)]) };
+      }
+      // Debounce can flush an unterminated mid-word fragment, let a tool-call
+      // land, then flush the continuation. Terminated lines carry their
+      // trailing newline (transcript-writer contract) \u2014 look back within the
+      // same turn (bounded by this session's last turn-end) for that
+      // session's most recent text row; if unterminated (or flagged
+      // partial), continue it in place instead of splitting the sentence.
+      for (var i = state.rows.length - 1; i >= 0; i--) {
+        var prior = state.rows[i];
+        if (prior.sessionId !== record.sessionId) continue;
+        if (prior.kind === 'turn-end') break;
+        if (prior.kind !== 'text') continue;
+        if (prior.partial === true || !prior.text.endsWith('\\n')) {
+          var patched = state.rows.slice();
+          patched[i] = mergeTextDelta(prior, record);
+          return { rows: patched };
+        }
+        break;
       }
       var row = {
         kind: 'text', id: rowId(record, state.rows), seq: record.seq, ts: record.ts,
         sessionId: record.sessionId, text: record.text || '',
       };
+      if (record.partial === true) row.partial = true;
       return { rows: state.rows.concat([row]) };
     }
     case 'tool-call': {
@@ -19715,7 +20415,7 @@ async function waitForSessionTerminal(registry, sessionId) {
   for (let attempt = 0; attempt < MAX_SEQUENTIAL_POLLS; attempt++) {
     const status = registry.get(sessionId)?.status;
     if (isSessionTerminal(status)) return;
-    await new Promise((resolve26) => setTimeout(resolve26, SEQUENTIAL_POLL_INTERVAL_MS));
+    await new Promise((resolve27) => setTimeout(resolve27, SEQUENTIAL_POLL_INTERVAL_MS));
   }
 }
 function resolveAgentRefsForWorkflow(appRegistry, workflowId) {
@@ -21205,14 +21905,14 @@ function createSupervisorTaskGateRunner(opts) {
   const { supervisor, registry, workspace } = opts;
   const exec = opts.runCommand ?? runCommand;
   const settleTimeoutMs = opts.settleTimeoutMs ?? DEFAULT_VERIFY_SETTLE_TIMEOUT_MS;
-  const waitForSettle = (policyId) => new Promise((resolve26) => {
+  const waitForSettle = (policyId) => new Promise((resolve27) => {
     let settled = false;
     const finish = (outcome) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
       unsub();
-      resolve26(outcome);
+      resolve27(outcome);
     };
     const read = () => {
       const state = supervisor.getStatus(policyId);
@@ -22357,17 +23057,26 @@ async function monitorSessionWait(opts) {
       };
     }
   }
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     const unsubs = [];
     let settled = false;
+    const watcherLabel = callerScope?.ownerSessionId ? registry.get(callerScope.ownerSessionId)?.label ?? registry.get(callerScope.ownerSessionId)?.title : void 0;
+    const watcherDetail = {
+      ...callerScope?.ownerSessionId ? { watcherSessionId: callerScope.ownerSessionId } : {},
+      ...watcherLabel ? { watcherLabel } : {},
+      event: targetEvent,
+      ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+      since: (/* @__PURE__ */ new Date()).toISOString()
+    };
     for (const id of resolvedIds) {
-      registry.incWatchers(id);
+      registry.incWatchers(id, watcherDetail);
       const watchers = registry.get(id)?.watchers ?? 0;
       sessionEvents.emit({
         type: "session:watcher-attached",
         sessionId: id,
         watchers,
         ...callerScope?.ownerSessionId ? { watcherSessionId: callerScope.ownerSessionId } : {},
+        ...watcherLabel ? { label: watcherLabel } : {},
         ts: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
@@ -22377,17 +23086,18 @@ async function monitorSessionWait(opts) {
       clearTimeout(timer);
       for (const u of unsubs) u();
       for (const id of resolvedIds) {
-        registry.decWatchers(id);
+        registry.decWatchers(id, watcherDetail);
         const watchers = registry.get(id)?.watchers ?? 0;
         sessionEvents.emit({
           type: "session:watcher-detached",
           sessionId: id,
           watchers,
           ...callerScope?.ownerSessionId ? { watcherSessionId: callerScope.ownerSessionId } : {},
+          ...watcherLabel ? { label: watcherLabel } : {},
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
-      resolve26(result);
+      resolve27(result);
     };
     const relevantTypes = targetEvent === "any" ? ["session:turn-end", "session:awaiting-input", "session:exited"] : targetEvent === "turn-end" ? ["session:turn-end", "session:awaiting-input"] : targetEvent === "awaiting-input" ? ["session:awaiting-input"] : ["session:exited"];
     const idSet = new Set(resolvedIds);
@@ -22424,13 +23134,13 @@ async function monitorPolicyWait(opts) {
   if (isSettledStatus(initial.status)) {
     return { timedOut: false, state: initial };
   }
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
       unsub();
-      resolve26({ timedOut: true });
+      resolve27({ timedOut: true });
     }, timeoutMs);
     const unsub = supervisor.onSettle((id) => {
       if (id !== policyId) return;
@@ -22440,7 +23150,7 @@ async function monitorPolicyWait(opts) {
       settled = true;
       clearTimeout(timer);
       unsub();
-      resolve26({ timedOut: false, state });
+      resolve27({ timedOut: false, state });
     });
   });
 }
@@ -23804,6 +24514,15 @@ async function startHttpServer(opts) {
         workspace: opts.meta.workspace,
         registered: opts.meta.registered,
         uptimeMs: Date.now() - startedAt,
+        startedAt: new Date(startedAt).toISOString(),
+        // What is actually running — version, process, and the exact
+        // node+entry pair launchd (or the shell) exec'd. Lifecycle tooling
+        // (`agentproto daemon start/stop/status`) reports these.
+        version: opts.meta.version ?? null,
+        build: opts.meta.build ?? null,
+        pid: process.pid,
+        node: process.execPath,
+        entry: process.argv[1] ?? null,
         resumeSessionsOnBoot: opts.meta.resumeSessionsOnBoot === true,
         idleReapAfterMs: opts.meta.idleReapAfterMs ?? 0,
         crashDetectIntervalMs: opts.meta.crashDetectIntervalMs ?? 0,
@@ -24880,16 +25599,16 @@ async function startHttpServer(opts) {
     });
   });
   const bind = opts.bind ?? "127.0.0.1";
-  await new Promise((resolve26, reject) => {
+  await new Promise((resolve27, reject) => {
     server.once("error", reject);
-    server.listen(opts.port, bind, () => resolve26());
+    server.listen(opts.port, bind, () => resolve27());
   });
   return {
     url: `http://${bind}:${opts.port}`,
     async stop() {
       wss.close();
       server.closeAllConnections();
-      await new Promise((resolve26) => server.close(() => resolve26()));
+      await new Promise((resolve27) => server.close(() => resolve27()));
     }
   };
 }
@@ -25539,6 +26258,8 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     const body = await readJsonBody(req);
     const prompt = body?.prompt;
     const interrupt = body?.interrupt === true;
+    const queue = body?.queue === true;
+    const force = body?.force === true;
     const validPrompt = typeof prompt === "string" && prompt.length > 0 || Array.isArray(prompt) && prompt.length > 0 && prompt.every((b) => b !== null && typeof b === "object") || prompt !== null && typeof prompt === "object" && !Array.isArray(prompt);
     if (!validPrompt) {
       json(400, {
@@ -25553,8 +26274,20 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     const fireAndForget = wait === "false" || wait === "0";
     try {
       if (fireAndForget) {
-        await registry.enqueuePrompt(id2, prompt, { interrupt });
-        json(202, { ok: true, id: id2, queued: true });
+        const queueId = queue ? `q_${randomUUID().slice(0, 8)}` : void 0;
+        await registry.enqueuePrompt(id2, prompt, { interrupt, queue, force, queueId });
+        const promptQueue = queueId ? registry.get(id2)?.promptQueue : void 0;
+        const queuePosition = promptQueue?.findIndex((p) => p.id === queueId) ?? -1;
+        json(202, {
+          ok: true,
+          id: id2,
+          queued: true,
+          // Present only when this prompt actually landed in the FIFO
+          // (busy + `queue: true`) rather than dispatching immediately —
+          // an idle session's `queueId` never appears in `promptQueue`,
+          // so `queuePosition` stays -1 and this is omitted.
+          ...queuePosition >= 0 ? { pending: true, queueId, queuePosition: queuePosition + 1 } : {}
+        });
       } else {
         await registry.sendPrompt(id2, prompt, { interrupt });
         json(200, { ok: true, id: id2 });
@@ -25570,6 +26303,15 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     }
     return true;
   }
+  const queueItemMatch = path.match(/^\/sessions\/([^/]+)\/queue\/([^/]+)$/);
+  if (queueItemMatch && req.method === "DELETE") {
+    const id2 = queueItemMatch[1];
+    const queueId = queueItemMatch[2];
+    if (!id2 || !queueId) return false;
+    const { removed } = registry.removeQueuedPrompt(id2, queueId);
+    json(200, { ok: true, id: id2, queueId, removed });
+    return true;
+  }
   const interruptMatch = path.match(/^\/sessions\/([^/]+)\/interrupt$/);
   if (interruptMatch && req.method === "POST") {
     const id2 = interruptMatch[1];
@@ -25829,7 +26571,7 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     return true;
   }
   const idMatch = path.match(
-    /^\/sessions\/([^/]+)(\/events\/stream|\/stream|\/kill|\/preview|\/export|\/conversation|\/events|\/wait)?$/
+    /^\/sessions\/([^/]+)(\/events\/stream|\/stream|\/kill|\/pin|\/preview|\/export|\/conversation|\/events|\/wait)?$/
   );
   if (!idMatch) return false;
   const [, rawIdOrName, suffix] = idMatch;
@@ -25904,9 +26646,9 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     let fileStream;
     try {
       fileStream = createReadStream(filePath, { encoding: "utf8" });
-      await new Promise((resolve26, reject) => {
+      await new Promise((resolve27, reject) => {
         fileStream.once("error", reject);
-        fileStream.once("open", resolve26);
+        fileStream.once("open", resolve27);
       });
     } catch (err) {
       const code = err.code;
@@ -25962,9 +26704,9 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     let fileStream;
     try {
       fileStream = createReadStream(filePath, { encoding: "utf8" });
-      await new Promise((resolve26, reject) => {
+      await new Promise((resolve27, reject) => {
         fileStream.once("error", reject);
-        fileStream.once("open", resolve26);
+        fileStream.once("open", resolve27);
       });
     } catch (err) {
       const code = err.code;
@@ -26127,6 +26869,27 @@ async function handleSessions(req, res, path, registry, resolveAgentAdapter, pty
     json(ok ? 200 : 404, { ok, sessionId: id });
     return true;
   }
+  if (suffix === "/pin" && req.method === "POST") {
+    if (!resolvedDesc) {
+      json(404, { error: "session_not_found", id: rawIdOrName });
+      return true;
+    }
+    const body = await readJsonBody(req);
+    const b = body && typeof body === "object" ? body : {};
+    const pinned = typeof b.pinned === "boolean" ? b.pinned : b.pinned === "true" ? true : b.pinned === "false" ? false : void 0;
+    if (pinned === void 0) {
+      json(400, { error: "invalid_body", message: "`pinned` must be a boolean" });
+      return true;
+    }
+    try {
+      registry.setPinned(id, pinned);
+      json(200, { ok: true, sessionId: id, pinned });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      json(msg.includes("no session") ? 404 : 500, { error: "set_pinned_failed", message: msg });
+    }
+    return true;
+  }
   if (!suffix && req.method === "GET") {
     if (!resolvedDesc) {
       json(404, { error: "session_not_found", id: rawIdOrName });
@@ -27470,6 +28233,9 @@ async function runRestartSweepPass(opts) {
   }
   return summary;
 }
+
+// src/index.ts
+init_config();
 var BINDINGS_FILE_PATH = () => resolve(homedir(), ".agentproto", "transmitter-bindings.json");
 var PERSIST_DEBOUNCE_MS4 = 1500;
 var keyOf = (alias, source, contactRef) => `${alias}:${source}:${contactRef}`;
@@ -28791,6 +29557,7 @@ var SessionsRegistryAgentHost = class {
     const stepSessionId = mintSessionId();
     const agentSession = await resolved.startSession({
       cwd,
+      configDir: adapterConfigDirFor(stepSessionId),
       env: {
         [SESSION_ID_ENV]: stepSessionId,
         [WORKSPACE_SLUG_ENV]: workspaceSlug
@@ -28803,6 +29570,7 @@ var SessionsRegistryAgentHost = class {
       cwd,
       agentSession,
       adapterSlug: adapter,
+      adapterConfigDir: adapterConfigDirFor(stepSessionId),
       label: `agent-step:${adapter}`,
       ...resolved.commandPreview ? { commandPreview: resolved.commandPreview } : {}
     });
@@ -28892,11 +29660,11 @@ var SessionsRegistryAgentHost = class {
   }
   // ── Internal helpers ──────────────────────────────────────────────────
   waitTurnEnd(sessionId) {
-    return new Promise((resolve26, reject) => {
+    return new Promise((resolve27, reject) => {
       const unsubs = [];
       const done = () => {
         for (const u of unsubs) u();
-        resolve26();
+        resolve27();
       };
       const fail = (reason) => {
         for (const u of unsubs) u();
@@ -29140,7 +29908,7 @@ function createOnEscalate(state, persist) {
     state.run.status = "awaiting-input";
     persist();
     try {
-      return await new Promise((resolve26, reject) => {
+      return await new Promise((resolve27, reject) => {
         const timeoutMs = policy.timeoutMs ?? 3e5;
         const timer = setTimeout(() => {
           state.pendingResolve = void 0;
@@ -29152,7 +29920,7 @@ function createOnEscalate(state, persist) {
           resolver: (response) => {
             clearTimeout(timer);
             state.pendingResolve = void 0;
-            resolve26(response);
+            resolve27(response);
           }
         };
       });
@@ -29516,25 +30284,38 @@ function createPrProvenanceReconciler(opts) {
       if (last !== void 0 && Date.now() - last < POLL_THROTTLE_MS) return;
       lastPollAt.set(sessionId, Date.now());
     }
+    const shouldStamp = (url) => {
+      if (stampedPrUrls.has(url)) return false;
+      if (desc.openedPrs && desc.openedPrs.some((recorded) => recorded.url === url)) {
+        stampedPrUrls.add(url);
+        return false;
+      }
+      return true;
+    };
+    const supervisor = desc.parentSessionId != null ? opts.registry.get(desc.parentSessionId) ?? { id: desc.parentSessionId } : null;
+    const stamp = async (pr2) => {
+      const outcome = await stampFooterOnPr({
+        registry: opts.registry,
+        session: desc,
+        supervisor,
+        prNumber: pr2.number,
+        prUrl: pr2.url,
+        cwd,
+        ...opts.run ? { run: opts.run } : {},
+        ...opts.host ? { host: opts.host } : {}
+      });
+      if (outcome.stamped) stampedPrUrls.add(pr2.url);
+    };
+    const records = await (opts.listToolCalls ?? readToolCallRecords)(sessionId);
+    for (const record2 of records) {
+      if (!record2.createdPrUrl || record2.createdPrNumber === void 0) continue;
+      if (!shouldStamp(record2.createdPrUrl)) continue;
+      await stamp({ number: record2.createdPrNumber, url: record2.createdPrUrl });
+    }
     const pr = await opts.resolveOpenPr(cwd);
     if (!pr) return;
-    if (stampedPrUrls.has(pr.url)) return;
-    if (desc.openedPrs && desc.openedPrs.some((recorded) => recorded.url === pr.url)) {
-      stampedPrUrls.add(pr.url);
-      return;
-    }
-    const supervisor = desc.parentSessionId != null ? opts.registry.get(desc.parentSessionId) ?? { id: desc.parentSessionId } : null;
-    const outcome = await stampFooterOnPr({
-      registry: opts.registry,
-      session: desc,
-      supervisor,
-      prNumber: pr.number,
-      prUrl: pr.url,
-      cwd,
-      ...opts.run ? { run: opts.run } : {},
-      ...opts.host ? { host: opts.host } : {}
-    });
-    if (outcome.stamped) stampedPrUrls.add(pr.url);
+    if (!shouldStamp(pr.url)) return;
+    await stamp(pr);
   };
   const safeReconcile = (sessionId, terminal) => {
     void reconcile(sessionId, terminal).catch(() => {
@@ -29706,14 +30487,14 @@ function createActivityProjector(opts) {
       if (current && isTerminalActivityState(current.state)) {
         return Promise.resolve(current);
       }
-      return new Promise((resolve26) => {
+      return new Promise((resolve27) => {
         let settled = false;
         const finish = (value) => {
           if (settled) return;
           settled = true;
           clearTimeout(timer);
           unsubscribeWait();
-          resolve26(value);
+          resolve27(value);
         };
         const timer = setTimeout(() => finish(null), timeoutMs);
         const unsubscribeWait = opts.sessionEvents.on("activity:changed", (ev) => {
@@ -29828,6 +30609,7 @@ function createInboundWatcher(opts) {
       const contactSessionId = mintSessionId();
       const agentSession = await resolved.startSession({
         cwd: state.input.cwd,
+        configDir: adapterConfigDirFor(contactSessionId),
         ...mcpServers ? { mcpServers } : {},
         env: {
           [SESSION_ID_ENV]: contactSessionId,
@@ -29842,6 +30624,7 @@ function createInboundWatcher(opts) {
         cwd: state.input.cwd,
         agentSession,
         adapterSlug: state.input.adapter,
+        adapterConfigDir: adapterConfigDirFor(contactSessionId),
         origin: "webhook",
         initialPrompt: prompt,
         label: labelParts.join(":"),
@@ -30215,6 +30998,7 @@ function createCronScheduler(opts) {
     const agentSessionId = mintSessionId();
     const agentSession = await resolved.startSession({
       cwd,
+      configDir: adapterConfigDirFor(agentSessionId),
       ...action.model ? { model: action.model } : {},
       ...action.mode ? { mode: action.mode } : {},
       ...action.permissionHold ? { permissionHold: true } : {},
@@ -30230,6 +31014,7 @@ function createCronScheduler(opts) {
       cwd,
       agentSession,
       adapterSlug: action.adapter,
+      adapterConfigDir: adapterConfigDirFor(agentSessionId),
       origin: "cron",
       label: `cron:${job.id}`,
       ...action.mode ? { mode: action.mode } : {},
@@ -30777,7 +31562,7 @@ async function registerBuiltinRoutes(opts) {
     console.log(`[runtime] loaded custom routes: ${loadedIds.join(", ")}`);
   }
 }
-function makeBrowserHandle(entry, resolve26) {
+function makeBrowserHandle(entry, resolve27) {
   return {
     slug: entry.id,
     name: entry.name,
@@ -30788,7 +31573,7 @@ function makeBrowserHandle(entry, resolve26) {
     // check() is available for on-demand health probes but is never called
     // by the lister (kit invariant OQ-5). Returns true when the adapter
     // is present in the injected resolver map, false otherwise.
-    check: async () => resolve26 ? resolve26(entry.id) != null : true
+    check: async () => resolve27 ? resolve27(entry.id) != null : true
   };
 }
 var noopLedger = {
@@ -30860,7 +31645,7 @@ var localSandboxProvider = {
   }
 };
 async function getFreePort() {
-  return new Promise((resolve26, reject) => {
+  return new Promise((resolve27, reject) => {
     const srv = createServer$1();
     srv.once("error", reject);
     srv.listen(0, "127.0.0.1", () => {
@@ -30870,7 +31655,7 @@ async function getFreePort() {
         return;
       }
       const { port } = address;
-      srv.close(() => resolve26(port));
+      srv.close(() => resolve27(port));
     });
   });
 }
@@ -30883,7 +31668,7 @@ async function probeHealth(url, timeoutMs) {
     } catch {
     }
     if (Date.now() >= deadline) return false;
-    await new Promise((resolve26) => setTimeout(resolve26, POLL_INTERVAL_MS));
+    await new Promise((resolve27) => setTimeout(resolve27, POLL_INTERVAL_MS));
   }
 }
 
@@ -31291,7 +32076,7 @@ async function spawnCloudflaredUntil(argv, opts) {
   };
   let settled = false;
   let forwardedLen = 0;
-  return await new Promise((resolve26, reject) => {
+  return await new Promise((resolve27, reject) => {
     const poll = setInterval(() => {
       const text10 = readAll();
       if (opts.onLog) {
@@ -31309,7 +32094,7 @@ async function spawnCloudflaredUntil(argv, opts) {
       if (m) {
         settled = true;
         clearTimeout(timer);
-        resolve26({ proc, match: m[0], stopTail: () => clearInterval(poll) });
+        resolve27({ proc, match: m[0], stopTail: () => clearInterval(poll) });
       }
     }, POLL_INTERVAL_MS2);
     if (poll.unref) poll.unref();
@@ -31443,15 +32228,15 @@ function quickTunnelProvider() {
         }
       }, 3e3);
       timer.unref();
-      await new Promise((resolve26) => {
+      await new Promise((resolve27) => {
         if (proc.exitCode !== null) {
           clearTimeout(timer);
-          resolve26();
+          resolve27();
           return;
         }
         proc.once("exit", () => {
           clearTimeout(timer);
-          resolve26();
+          resolve27();
         });
       });
     }
@@ -31788,7 +32573,9 @@ function registerDaemonHealthTools(server, opts) {
         idleReapAfterMs: opts.idleReapAfterMs,
         crashDetectIntervalMs: opts.crashDetectIntervalMs ?? 0,
         restartSweepIntervalMs: opts.restartSweepIntervalMs ?? 0,
-        turnStallAfterMs: opts.turnStallAfterMs ?? 0
+        turnStallAfterMs: opts.turnStallAfterMs ?? 0,
+        version: opts.version ?? null,
+        build: opts.build ?? null
       });
     }
   );
@@ -31923,15 +32710,15 @@ function namedTunnelProvider(cfg) {
         }
       }, 3e3);
       timer.unref();
-      await new Promise((resolve26) => {
+      await new Promise((resolve27) => {
         if (proc.exitCode !== null) {
           clearTimeout(timer);
-          resolve26();
+          resolve27();
           return;
         }
         proc.once("exit", () => {
           clearTimeout(timer);
-          resolve26();
+          resolve27();
         });
       });
     }
@@ -32055,7 +32842,7 @@ function ngrokTunnelProvider(opts) {
       };
       proc.stderr?.on("data", forwardLogs);
       proc.stdout?.on("data", forwardLogs);
-      const url = await new Promise((resolve26, reject) => {
+      const url = await new Promise((resolve27, reject) => {
         let settled = false;
         const timer = setTimeout(() => {
           if (settled) return;
@@ -32083,7 +32870,7 @@ function ngrokTunnelProvider(opts) {
                 settled = true;
                 clearTimeout(timer);
                 if (apiPollHandle) clearInterval(apiPollHandle);
-                resolve26(pubUrl);
+                resolve27(pubUrl);
               }
             } catch {
             }
@@ -32098,7 +32885,7 @@ function ngrokTunnelProvider(opts) {
             settled = true;
             clearTimeout(timer);
             if (apiPollHandle) clearInterval(apiPollHandle);
-            resolve26(reMatch[1]);
+            resolve27(reMatch[1]);
             return;
           }
           for (const line of text10.split(/\r?\n/)) {
@@ -32109,7 +32896,7 @@ function ngrokTunnelProvider(opts) {
                 settled = true;
                 clearTimeout(timer);
                 if (apiPollHandle) clearInterval(apiPollHandle);
-                resolve26(parsed.url);
+                resolve27(parsed.url);
                 return;
               }
             } catch {
@@ -32156,15 +32943,15 @@ function ngrokTunnelProvider(opts) {
         }
       }, 3e3);
       timer.unref();
-      await new Promise((resolve26) => {
+      await new Promise((resolve27) => {
         if (proc.exitCode !== null) {
           clearTimeout(timer);
-          resolve26();
+          resolve27();
           return;
         }
         proc.once("exit", () => {
           clearTimeout(timer);
-          resolve26();
+          resolve27();
         });
       });
     }
@@ -33827,16 +34614,16 @@ function dialUrl(rendezvousUrl, token) {
   return `${rendezvousUrl}${sep2}side=daemon&t=${encodeURIComponent(token)}`;
 }
 function waitClosed(sink, signal) {
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     if (!sink.isOpen) {
-      resolve26();
+      resolve27();
       return;
     }
     let settled = false;
     const finish = () => {
       if (settled) return;
       settled = true;
-      resolve26();
+      resolve27();
     };
     sink.onClose(() => finish());
     signal.addEventListener("abort", () => {
@@ -33846,13 +34633,13 @@ function waitClosed(sink, signal) {
   });
 }
 function sleep(ms, signal) {
-  return new Promise((resolve26) => {
-    if (signal.aborted) return resolve26();
-    const timer = setTimeout(resolve26, ms);
+  return new Promise((resolve27) => {
+    if (signal.aborted) return resolve27();
+    const timer = setTimeout(resolve27, ms);
     if (typeof timer.unref === "function") timer.unref();
     signal.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve26();
+      resolve27();
     });
   });
 }
@@ -33907,6 +34694,9 @@ function composeMode(cfg, modes) {
 
 // src/index.ts
 init_conversation_store();
+
+// src/auth-probe.ts
+init_config();
 async function isAgentCliAuthConfigured(slug, descriptor, model) {
   const config = await loadConfig();
   const spawnDefaults = resolveSpawnDefaults(config.defaults, slug, {});
@@ -34062,6 +34852,14 @@ async function createGateway(opts) {
           return await adapter.startSession({
             cwd,
             resumeSessionId,
+            // Point the respawned adapter at the SAME persistent
+            // isolated-config dir the original spawn used — the
+            // provider's conversation store lives inside it, so this is
+            // what makes `resumeSessionId` restore full context instead
+            // of degrading to the daemon-transcript digest. Absent on
+            // legacy rows spawned before adapterConfigDir existed (those
+            // keep today's digest-fallback behaviour).
+            ...descriptor.adapterConfigDir ? { configDir: descriptor.adapterConfigDir } : {},
             // Re-mount the persisted spawn-time toolset on resume
             // (orchestrator WP1) — closes the gap where re-spawn
             // dropped mcpServers.
@@ -34283,7 +35081,9 @@ async function createGateway(opts) {
       idleReapAfterMs,
       crashDetectIntervalMs,
       restartSweepIntervalMs,
-      turnStallAfterMs
+      turnStallAfterMs,
+      ...opts.version ? { version: opts.version } : {},
+      ...opts.build ? { build: opts.build } : {}
     });
     registerCommandTools(server, {
       workspace,
@@ -34586,6 +35386,8 @@ async function createGateway(opts) {
       workspace,
       registered,
       startedAt,
+      ...opts.version ? { version: opts.version } : {},
+      ...opts.build ? { build: opts.build } : {},
       resumeSessionsOnBoot: opts.resumeSessionsOnBoot === true,
       idleReapAfterMs,
       crashDetectIntervalMs,