@cydm/pie 2.1.1 → 2.3.0

package/dist/builtin/extensions/ask-user/index.js

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-LU7RKALH.js";
+} from "../../../chunks/chunk-UPPICLVS.js";
 import "../../../chunks/chunk-QJH6YN2W.js";
 import "../../../chunks/chunk-IM43UYVV.js";
 import "../../../chunks/chunk-XXGYUYXI.js";

package/dist/builtin/extensions/computer-use/index.js

@@ -3776,10 +3776,26 @@ function containsEditable(node) {
   if (node.canSetValue || node.role.toLowerCase().includes("text")) return true;
   return node.children.some(containsEditable);
 }
+function wireableInputDescendants(node) {
+  const matches = [];
+  const visit = (current) => {
+    for (const child of current.children) {
+      if (child.isTextInput && child.wireRef && !child.pictureOnly && !child.offscreen) matches.push(child);
+      visit(child);
+    }
+  };
+  visit(node);
+  return matches;
+}
 function recordActionFocus(action, state, node, coordinateFocus = false) {
   if (!["click", "press", "keypress", "typeText"].includes(action.action) || !action.ref && action.action !== "click") return;
   state.currentFocus = Boolean(node?.isTextInput && !node.pictureOnly) || coordinateFocus;
   state.focusRef = node?.isTextInput && node.wireRef && !node.pictureOnly ? node.ref : void 0;
+  if (!state.currentFocus && node && !node.pictureOnly && action.ref && (action.action === "click" || action.action === "press") && containsEditable(node)) {
+    const wireable = wireableInputDescendants(node);
+    state.currentFocus = true;
+    state.focusRef = wireable.length === 1 ? wireable[0].ref : void 0;
+  }
 }
 function editorAtPoint(nodes, x, y) {
   const matches = nodes.filter((node) => node.isTextInput && node.wireRef && !node.pictureOnly && !node.offscreen && node.rect && x >= node.rect.x && x < node.rect.x + node.rect.w && y >= node.rect.y && y < node.rect.y + node.rect.h);
@@ -3790,24 +3806,23 @@ function prepareAction(action, state, env) {
   const focusedKeyboard = !env.headless && state.currentFocus && !action.ref && (operation === "typeText" || operation === "keypress");
   const usesCurrentFocus = focusedKeyboard && !state.focusRef;
   const target = usesCurrentFocus ? focusedTarget(env) : nativeTarget(focusedKeyboard && state.focusRef ? { ...action, ref: state.focusRef } : action, operation, env);
-  const establishesFocus = !env.headless && Boolean(action.ref) && (operation === "click" || operation === "press") && containsEditable(env.node(action.ref));
   const needsForeground = !env.headless && (operation === "click" || operation === "press") && "x" in target;
   switch (operation) {
     case "press":
     case "click":
-      return { action: operation, target, params: { button: mouseButton(action.button), clickCount: clickCount(action.clickCount) }, establishesFocus, usesCurrentFocus: false, needsForeground };
+      return { action: operation, target, params: { button: mouseButton(action.button), clickCount: clickCount(action.clickCount) }, usesCurrentFocus: false, needsForeground };
     case "setText":
-      return { action: operation, target, params: { text: action.text ?? "" }, establishesFocus: false, usesCurrentFocus: false, needsForeground: false };
+      return { action: operation, target, params: { text: action.text ?? "" }, usesCurrentFocus: false, needsForeground: false };
     case "typeText":
-      return { action: operation, target, params: { text: action.text ?? "" }, establishesFocus: false, usesCurrentFocus, needsForeground: false };
+      return { action: operation, target, params: { text: action.text ?? "" }, usesCurrentFocus, needsForeground: false };
     case "keypress":
-      return { action: operation, target, params: { keys: keys(action.keys) }, establishesFocus: false, usesCurrentFocus, needsForeground: false };
+      return { action: operation, target, params: { keys: keys(action.keys) }, usesCurrentFocus, needsForeground: false };
     case "scroll":
-      return { action: operation, target, params: { scrollX: scrollDelta(action.scrollX), scrollY: scrollDelta(action.scrollY) }, establishesFocus: false, usesCurrentFocus: false, needsForeground: false };
+      return { action: operation, target, params: { scrollX: scrollDelta(action.scrollX), scrollY: scrollDelta(action.scrollY) }, usesCurrentFocus: false, needsForeground: false };
     case "drag":
-      return { action: operation, target, params: { path: path(action.path, env) }, establishesFocus: false, usesCurrentFocus: false, needsForeground: false };
+      return { action: operation, target, params: { path: path(action.path, env) }, usesCurrentFocus: false, needsForeground: false };
     case "moveMouse":
-      return { action: operation, target, params: {}, establishesFocus: false, usesCurrentFocus: false, needsForeground: false };
+      return { action: operation, target, params: {}, usesCurrentFocus: false, needsForeground: false };
   }
 }
 function canRetryInForeground(action, outcome, headless) {
@@ -6901,17 +6916,28 @@ async function releaseOwnedBrowser(child, port, profile) {
     if (port) await requestBrowserClose(port).catch(() => void 0);
     if (!await waitForExit(child, 700)) {
       if (process.platform === "win32" && child.pid) {
-        await new Promise((resolve, reject) => execFile("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
-          windowsHide: true,
-          timeout: 2e3
-        }, (error) => {
-          if (error && child.exitCode === null) reject(error);
-          else resolve();
-        }));
+        const pid = child.pid;
+        await new Promise((resolve) => {
+          execFile("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            timeout: 2e3
+          }, () => resolve());
+        });
+        if (!await waitForExit(child, 1500)) {
+          try {
+            process.kill(pid);
+          } catch {
+          }
+          if (!await waitForExit(child, 2e3)) {
+            throw new Error(`Owned browser process ${pid} survived taskkill escalation.`);
+          }
+        }
       } else child.kill("SIGTERM");
-      if (!await waitForExit(child, 2e3)) {
-        if (process.platform !== "win32") child.kill("SIGKILL");
-        if (!await waitForExit(child, 2e3)) throw new Error("Owned browser did not exit.");
+      if (process.platform !== "win32") {
+        if (!await waitForExit(child, 2e3)) {
+          child.kill("SIGKILL");
+          if (!await waitForExit(child, 2e3)) throw new Error("Owned browser did not exit.");
+        }
       }
     }
   }
@@ -7206,16 +7232,24 @@ function shutdownComputerUseSession() {
 }
 async function releaseComputerUseSession() {
   const drain = resourceScheduler.close();
-  await disconnectCdp();
-  await currentPlatformBackend.shutdown?.();
-  await drain;
-  await releaseOwnedBrowserState(runtimeState);
+  const failures = [];
+  const attempt = (step, work) => work().catch((error) => {
+    failures.push(error instanceof Error ? new Error(`${step}: ${error.message}`) : error);
+  });
+  await attempt("disconnect CDP", () => disconnectCdp());
+  await attempt("platform shutdown", async () => {
+    await currentPlatformBackend.shutdown?.();
+  });
+  await attempt("drain scheduler", () => drain);
+  await attempt("release owned browser", () => releaseOwnedBrowserState(runtimeState));
   if (runtimeState.managedBrowserCdpPort && process.env.PIE_COMPUTER_USE_CDP_PORT === runtimeState.managedBrowserCdpPort) {
     if (runtimeState.previousCdpPort === void 0) delete process.env.PIE_COMPUTER_USE_CDP_PORT;
     else process.env.PIE_COMPUTER_USE_CDP_PORT = runtimeState.previousCdpPort;
   }
-  runtimeState.managedBrowserCdpPort = void 0;
   runtimeState.previousCdpPort = void 0;
+  if (runtimeState.managedBrowser === void 0) {
+    runtimeState.managedBrowserCdpPort = void 0;
+  }
   savedStates.clear();
   clearStoredOutputs();
   runtimeState.windowRefs.clear();
@@ -7227,6 +7261,8 @@ async function releaseComputerUseSession() {
   runtimeState.helperDiagnostics = void 0;
   runtimeState.lastPermissionCheckAt = 0;
   resourceScheduler = new ResourceScheduler();
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, "computer-use session release had partial failures (state was reset)");
 }
 function currentRuntimeMode() {
   return isHeadlessMode() ? "stealth" : "default";

package/dist/builtin/extensions/herdr-agent-state/index.js

@@ -0,0 +1,272 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import "../../../chunks/chunk-LZQXQOPJ.js";
+
+// builtin/extensions/herdr-agent-state/index.ts
+import { spawn } from "node:child_process";
+var AGENT_LABEL = "pie";
+var SOURCE_ID = "pie";
+var BLOCKING_TOOL_NAME = "ask_user_multi";
+var REPORT_TIMEOUT_MS = 3e3;
+var MAX_RESUME_ARGS = 64;
+var MAX_RESUME_TOTAL_CHARS = 8192;
+var RESUME_ARG_PATTERN = /^[A-Za-z0-9._:/=@,%+-]+$/;
+var MESSAGE_MAX_CHARS = 120;
+function readHerdrEnvironment(env = process.env) {
+  if (env.HERDR_ENV !== "1") return void 0;
+  const paneId = env.HERDR_PANE_ID;
+  const binPath = env.HERDR_BIN_PATH;
+  if (typeof paneId !== "string" || !paneId) return void 0;
+  if (typeof binPath !== "string" || !binPath) return void 0;
+  return { paneId, binPath };
+}
+function createReportSequencer(now = Date.now) {
+  let seq = now() * 1e3;
+  return () => {
+    seq += 1;
+    return seq;
+  };
+}
+function summarizeAskUserQuestion(args) {
+  if (!args || typeof args !== "object") return void 0;
+  const record = args;
+  let text = record.question;
+  if (typeof text !== "string" || !text.trim()) {
+    const questions = record.questions;
+    if (Array.isArray(questions) && questions.length > 0) {
+      const first = questions[0];
+      if (first && typeof first === "object") {
+        text = first.question;
+      }
+    }
+  }
+  if (typeof text !== "string") return void 0;
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (!cleaned) return void 0;
+  return cleaned.length > MESSAGE_MAX_CHARS ? `${cleaned.slice(0, MESSAGE_MAX_CHARS - 3)}...` : cleaned;
+}
+function buildResumeArgv(sessionId) {
+  const argv = ["pie", "chat", "--session-id", sessionId];
+  if (argv.length > MAX_RESUME_ARGS) return void 0;
+  if (argv.join(" ").length > MAX_RESUME_TOTAL_CHARS) return void 0;
+  for (const arg of argv) {
+    if (!RESUME_ARG_PATTERN.test(arg)) return void 0;
+  }
+  return argv;
+}
+function buildStateReportArgs(params) {
+  const args = [
+    "pane",
+    "report-agent",
+    params.paneId,
+    "--source",
+    params.source,
+    "--agent",
+    params.agent,
+    "--state",
+    params.state,
+    "--seq",
+    String(params.seq)
+  ];
+  if (params.message) {
+    args.push("--message", params.message);
+  }
+  if (params.agentSessionId) {
+    args.push("--agent-session-id", params.agentSessionId);
+  }
+  if (params.resumeArgv && params.resumeArgv.length > 0) {
+    args.push("--", ...params.resumeArgv);
+  }
+  return args;
+}
+function buildSessionReportArgs(params) {
+  const args = [
+    "pane",
+    "report-agent-session",
+    params.paneId,
+    "--source",
+    params.source,
+    "--agent",
+    params.agent,
+    "--seq",
+    String(params.seq),
+    "--agent-session-id",
+    params.agentSessionId
+  ];
+  if (params.resumeArgv?.length) args.push("--", ...params.resumeArgv);
+  return args;
+}
+function buildReleaseReportArgs(params) {
+  return [
+    "pane",
+    "release-agent",
+    params.paneId,
+    "--source",
+    params.source,
+    "--agent",
+    params.agent,
+    "--seq",
+    String(params.seq)
+  ];
+}
+function spawnHerdrReport(binPath, args, timeoutMs = REPORT_TIMEOUT_MS) {
+  try {
+    const child = spawn(binPath, args, { detached: true, stdio: "ignore" });
+    let killTimer;
+    const clearTimers = () => {
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+        killTimer = setTimeout(() => {
+          try {
+            if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+          } catch {
+          }
+        }, 1e3);
+        killTimer.unref?.();
+      } catch {
+      }
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("error", clearTimers);
+    child.on("exit", clearTimers);
+    child.unref();
+  } catch {
+  }
+}
+function attachHerdrReporter(host, herdr, transport = (args) => spawnHerdrReport(herdr.binPath, args), sequencer = createReportSequencer()) {
+  const nextSeq = sequencer;
+  let agentActive = false;
+  const blockingToolCalls = /* @__PURE__ */ new Map();
+  let blockedMessage;
+  let heldPane = false;
+  let lastSessionId;
+  let lastState;
+  let lastMessage;
+  function report(args) {
+    transport(args);
+  }
+  function publishState(options) {
+    const next = desiredState();
+    const unchanged = next.state === lastState && next.message === lastMessage && !options?.force && !options?.resumeArgv;
+    if (unchanged) return;
+    lastState = next.state;
+    lastMessage = next.message;
+    heldPane = true;
+    report(
+      buildStateReportArgs({
+        paneId: herdr.paneId,
+        source: SOURCE_ID,
+        agent: AGENT_LABEL,
+        state: next.state,
+        seq: nextSeq(),
+        message: next.message,
+        agentSessionId: lastSessionId,
+        resumeArgv: options?.resumeArgv
+      })
+    );
+  }
+  function publishSession(sessionId) {
+    const resumeArgv = buildResumeArgv(sessionId);
+    if (!heldPane) {
+      return;
+    }
+    report(
+      buildSessionReportArgs({
+        paneId: herdr.paneId,
+        source: SOURCE_ID,
+        agent: AGENT_LABEL,
+        seq: nextSeq(),
+        agentSessionId: sessionId,
+        resumeArgv
+      })
+    );
+  }
+  function desiredState() {
+    if (blockingToolCalls.size > 0) {
+      return { state: "blocked", message: blockedMessage };
+    }
+    if (agentActive) {
+      return { state: "working" };
+    }
+    return { state: "idle" };
+  }
+  host.on("session:changed", (event) => {
+    const sessionId = typeof event.sessionId === "string" && event.sessionId ? event.sessionId : void 0;
+    const sessionIdChanged = sessionId !== lastSessionId;
+    lastSessionId = sessionId;
+    if (!heldPane) {
+      publishState({
+        force: true,
+        resumeArgv: sessionId ? buildResumeArgv(sessionId) : void 0
+      });
+      return;
+    }
+    if (sessionIdChanged && sessionId) {
+      publishSession(sessionId);
+    }
+  });
+  host.on("turn:start", () => {
+    agentActive = true;
+    publishState();
+  });
+  host.on("agent:end", () => {
+    agentActive = false;
+    blockingToolCalls.clear();
+    blockedMessage = void 0;
+    publishState();
+  });
+  host.on("tool:execution:start", (event) => {
+    if (event.toolName !== BLOCKING_TOOL_NAME) return;
+    const message = summarizeAskUserQuestion(event.args);
+    blockingToolCalls.set(event.toolCallId, message);
+    if (message) {
+      blockedMessage = message;
+    } else if (!blockedMessage) {
+      blockedMessage = "waiting for your answer";
+    }
+    publishState();
+  });
+  host.on("tool:execution:end", (event) => {
+    if (event.toolName !== BLOCKING_TOOL_NAME) return;
+    blockingToolCalls.delete(event.toolCallId);
+    blockedMessage = void 0;
+    for (const message of blockingToolCalls.values()) {
+      if (message) blockedMessage = message;
+    }
+    publishState();
+  });
+  host.registerCleanup?.((reason) => {
+    if (reason !== "shutdown") return;
+    if (!heldPane) return;
+    report(
+      buildReleaseReportArgs({
+        paneId: herdr.paneId,
+        source: SOURCE_ID,
+        agent: AGENT_LABEL,
+        seq: nextSeq()
+      })
+    );
+  });
+}
+function herdrAgentStateExtension(ctx) {
+  const herdr = readHerdrEnvironment();
+  if (!herdr) return;
+  if (!ctx.hasUI) return;
+  ctx.log("herdr agent-state reporter enabled");
+  attachHerdrReporter(ctx, herdr);
+}
+export {
+  attachHerdrReporter,
+  buildReleaseReportArgs,
+  buildResumeArgv,
+  buildSessionReportArgs,
+  buildStateReportArgs,
+  createReportSequencer,
+  herdrAgentStateExtension as default,
+  readHerdrEnvironment,
+  spawnHerdrReport,
+  summarizeAskUserQuestion
+};

package/dist/builtin/extensions/herdr-agent-state/package.json

@@ -0,0 +1,11 @@
+{
+	"name": "herdr-agent-state-extension",
+	"version": "1.0.0",
+	"description": "Report Pie interactive agent lifecycle state (working/idle/blocked), session identity, and resume command to the Herdr terminal workspace manager.",
+	"main": "index.js",
+	"type": "module",
+	"pie": {
+		"name": "herdr-agent-state",
+		"main": "index.js"
+	}
+}

package/dist/builtin/extensions/mcp-adapter/index.js

@@ -544,6 +544,7 @@ function normalizeEntry(name, raw, sourcePath, sourceScope, homeDir) {
   const hasStdio = typeof raw.command === "string" && raw.command.length > 0;
   const hasHttp = typeof raw.url === "string" && raw.url.length > 0;
   if (!hasStdio && !hasHttp) return null;
+  const directTools = normalizeDirectTools(raw.directTools);
   return {
     name,
     command: hasStdio ? expandHome(raw.command, homeDir) : void 0,
@@ -554,8 +555,8 @@ function normalizeEntry(name, raw, sourcePath, sourceScope, homeDir) {
     headers: asStringRecord(raw.headers),
     inheritEnv: raw.inheritEnv !== false,
     connectTimeoutMs: typeof raw.connectTimeoutMs === "number" && Number.isFinite(raw.connectTimeoutMs) && raw.connectTimeoutMs > 0 ? raw.connectTimeoutMs : void 0,
-    directTools: normalizeDirectTools(raw.directTools).mode,
-    directToolsWhitelist: normalizeDirectTools(raw.directTools).whitelist,
+    directTools: directTools.mode,
+    directToolsWhitelist: directTools.whitelist,
     disabled: raw.disabled === true,
     sourcePath,
     sourceScope
@@ -615,8 +616,8 @@ function resolveMcpAdapterConfig(cwd, configDir, homeDir = os.homedir()) {
         continue;
       }
       const existing = merged.get(name);
-      if (existing && raw.disabled === true) {
-        merged.set(name, { ...existing, disabled: true });
+      if (existing && (raw.disabled === true || raw.disabled === false)) {
+        merged.set(name, { ...existing, disabled: raw.disabled });
       }
     }
   }
@@ -24438,6 +24439,7 @@ import * as path2 from "node:path";
 var CONNECT_TIMEOUT_MS = 3e4;
 var PACKAGE_MANAGER_CONNECT_TIMEOUT_MS = 12e4;
 var PACKAGE_MANAGER_COMMANDS = /* @__PURE__ */ new Set(["npx", "npm", "bunx", "uvx", "uv", "pnpm", "pnpmx"]);
+var METADATA_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var CALL_TIMEOUT_MS = 12e4;
 var STDERR_TAIL_LIMIT = 4e3;
 function connectTimeoutFor(definition) {
@@ -24445,6 +24447,17 @@ function connectTimeoutFor(definition) {
   const base = path2.basename(definition.command ?? "");
   return PACKAGE_MANAGER_COMMANDS.has(base) ? PACKAGE_MANAGER_CONNECT_TIMEOUT_MS : CONNECT_TIMEOUT_MS;
 }
+function unpinnedWarnings(definitions) {
+  const commandPattern = new RegExp(`(^|\\s)(?:${[...PACKAGE_MANAGER_COMMANDS].join("|")})\\s`);
+  const warnings = [];
+  for (const definition of definitions) {
+    const spec = [definition.command ?? "", ...definition.args].join(" ");
+    if (commandPattern.test(spec) && /@latest\b/.test(spec)) {
+      warnings.push(`${definition.name}: unpinned "@latest" fetch \u2014 pin an exact version (e.g. pkg@1.2.3).`);
+    }
+  }
+  return warnings;
+}
 function appendTail(tail, chunk) {
   return (tail + String(chunk)).slice(-STDERR_TAIL_LIMIT);
 }
@@ -24487,11 +24500,8 @@ function withTimeout(promise, timeoutMs, label, signal) {
   });
 }
 var McpServerManager = class {
-  runtimes = /* @__PURE__ */ new Map();
-  definitions;
-  cachePath;
-  log;
-  constructor(definitions, cachePath, log) {
+  constructor(definitions, cacheDir, log, now = Date.now) {
+    this.now = now;
     this.definitions = new Map(definitions.map((definition) => [sanitizeName(definition.name), definition]));
     if (this.definitions.size !== definitions.length) {
       const counts = /* @__PURE__ */ new Map();
@@ -24506,9 +24516,22 @@ var McpServerManager = class {
         );
       }
     }
-    this.cachePath = cachePath;
+    this.cacheDir = cacheDir;
     this.log = log;
   }
+  now;
+  runtimes = /* @__PURE__ */ new Map();
+  definitions;
+  // Cache directory holding one <server>.json shard per connected server. A
+  // legacy pre-sharding single file (<configDir>/mcp-metadata.json) is
+  // deliberately ignored — the cache is disposable and shards rebuild on the
+  // next connect.
+  cacheDir;
+  log;
+  /** Set by dispose(); after it, no new connects and no late attach. */
+  disposed = false;
+  /** Prefixed names claimed by more than one server in the last loadCatalog(); callTool fail-closes on them. */
+  conflictedNames = /* @__PURE__ */ new Set();
   getDefinition(server) {
     return this.definitions.get(sanitizeName(server));
   }
@@ -24549,6 +24572,7 @@ var McpServerManager = class {
   }
   /** Connect lazily. Concurrent callers share one in-flight connect. */
   async connect(server, signal) {
+    if (this.disposed) throw new Error("MCP server manager is disposed");
     const key = sanitizeName(server);
     const definition = this.definitions.get(key);
     if (!definition) throw new Error(`unknown MCP server "${server}"`);
@@ -24561,12 +24585,17 @@ var McpServerManager = class {
     runtime.connecting = (async () => {
       this.log(`mcp: connecting to "${key}" (${definition.command ?? definition.url})`);
       const { client, transport } = this.startTransport(definition, runtime);
+      runtime.transport = transport;
       client.onclose = () => {
         this.log(`mcp: server "${key}" connection closed`);
         runtime.client = void 0;
       };
       try {
         await withTimeout(client.connect(transport), connectTimeoutFor(definition), `connect "${key}"`, signal);
+        if (this.disposed) {
+          await transport.close().catch(() => void 0);
+          throw new Error(`MCP manager disposed while connecting to "${key}"`);
+        }
         runtime.client = client;
         await this.refreshTools(runtime, connectTimeoutFor(definition));
         return runtime;
@@ -24576,6 +24605,7 @@ var McpServerManager = class {
       }
     })().finally(() => {
       runtime.connecting = void 0;
+      runtime.transport = void 0;
     });
     try {
       return await runtime.connecting;
@@ -24603,13 +24633,11 @@ var McpServerManager = class {
       }
       seen.add(tool.prefixedName);
     }
-    for (const [otherKey, otherRuntime] of this.runtimes) {
+    for (const otherRuntime of this.runtimes.values()) {
       if (otherRuntime === runtime || !otherRuntime.tools) continue;
       for (const otherTool of otherRuntime.tools) {
         if (seen.has(otherTool.prefixedName)) {
-          throw new Error(
-            `tool name collision between "${runtime.definition.name}" and "${otherKey}": ${otherTool.prefixedName}`
-          );
+          this.log(`mcp: tool name "${otherTool.prefixedName}" is claimed by more than one server \u2014 disabled until the servers are renamed (fail-closed)`);
         }
       }
     }
@@ -24618,16 +24646,45 @@ var McpServerManager = class {
   }
   persistMetadata() {
     try {
-      const snapshot = { ...this.readCacheFile() };
+      fs2.mkdirSync(this.cacheDir, { recursive: true });
       for (const [key, runtime] of this.runtimes) {
-        if (runtime.tools) snapshot[key] = runtime.tools;
+        if (!runtime.tools) continue;
+        const shardPath = path2.join(this.cacheDir, `${key}.json`);
+        const tempPath = `${shardPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+        fs2.writeFileSync(tempPath, JSON.stringify({ updatedAt: this.now(), tools: runtime.tools }, null, 2), "utf8");
+        try {
+          fs2.renameSync(tempPath, shardPath);
+        } catch (error2) {
+          fs2.unlinkSync(tempPath);
+          throw error2;
+        }
       }
-      fs2.mkdirSync(path2.dirname(this.cachePath), { recursive: true });
-      fs2.writeFileSync(this.cachePath, JSON.stringify({ updatedAt: Date.now(), tools: snapshot }, null, 2), "utf8");
+      this.deleteExpiredShards();
     } catch (error2) {
       this.log(`mcp: metadata cache write failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
+  /** Delete shard files older than METADATA_TTL_MS (stale entries of offline servers age out). */
+  deleteExpiredShards() {
+    let names;
+    try {
+      names = fs2.readdirSync(this.cacheDir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      const filePath = path2.join(this.cacheDir, name);
+      try {
+        const mtimeMs = fs2.statSync(filePath).mtimeMs;
+        const parsed = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+        if (typeof parsed.updatedAt !== "number" || this.now() - parsed.updatedAt > METADATA_TTL_MS) {
+          if (fs2.statSync(filePath).mtimeMs === mtimeMs) fs2.unlinkSync(filePath);
+        }
+      } catch {
+      }
+    }
+  }
   /** Cached descriptors for one server (from the metadata cache file). */
   cachedToolsFor(server) {
     return this.loadCatalog().filter((tool) => tool.server === sanitizeName(server));
@@ -24635,47 +24692,98 @@ var McpServerManager = class {
   /** Metadata catalog: live runtimes plus the last persisted snapshot. */
   loadCatalog() {
     const catalog = /* @__PURE__ */ new Map();
-    const cached2 = this.readCacheFile();
-    for (const tools of Object.values(cached2)) {
+    const ownerOf = /* @__PURE__ */ new Map();
+    const conflicts = /* @__PURE__ */ new Set();
+    const claim2 = (tool, live) => {
+      const owner = ownerOf.get(tool.prefixedName);
+      if (owner !== void 0 && owner !== tool.server) {
+        conflicts.add(tool.prefixedName);
+        return;
+      }
+      if (owner !== void 0 && !live) return;
+      catalog.set(tool.prefixedName, tool);
+      ownerOf.set(tool.prefixedName, tool.server);
+    };
+    for (const tools of Object.values(this.readCacheFile())) {
       for (const tool of tools) {
         if (!this.definitions.has(tool.server)) continue;
-        if (catalog.has(tool.prefixedName)) {
-          this.log(`mcp: metadata cache collision on ${tool.prefixedName} (server "${tool.server}", first seen from another server) \u2014 keeping the first entry`);
-          continue;
-        }
-        catalog.set(tool.prefixedName, tool);
+        claim2(tool, false);
       }
     }
     for (const runtime of this.runtimes.values()) {
-      for (const tool of runtime.tools ?? []) catalog.set(tool.prefixedName, tool);
+      for (const tool of runtime.tools ?? []) claim2(tool, true);
+    }
+    for (const name of conflicts) {
+      catalog.delete(name);
+      this.log(`mcp: tool name "${name}" is claimed by more than one server \u2014 disabled until the servers are renamed (fail-closed)`);
     }
+    this.conflictedNames = conflicts;
     return [...catalog.values()].sort((a, b) => a.prefixedName.localeCompare(b.prefixedName));
   }
-  cacheMtime;
+  cacheSignature;
   cacheSnapshot = {};
-  /** Read the metadata cache file, re-reading only when the mtime changed. */
+  cacheUpdatedAt = {};
+  pruneExpiredSnapshot() {
+    for (const [key, updatedAt] of Object.entries(this.cacheUpdatedAt)) {
+      if (this.now() - updatedAt > METADATA_TTL_MS) {
+        delete this.cacheSnapshot[key];
+        delete this.cacheUpdatedAt[key];
+      }
+    }
+    return this.cacheSnapshot;
+  }
+  /**
+   * Read the sharded metadata cache (<cacheDir>/<server>.json), merging every
+   * shard's tools by server key (the file name is the sanitized server key).
+   * Re-reads only when the signature changed; the signature must cover each
+   * shard's name + mtime — the directory's own mtime is NOT enough, because a
+   * rename replacing an existing shard leaves it unchanged.
+   */
   readCacheFile() {
-    let mtime;
+    let names;
     try {
-      mtime = fs2.statSync(this.cachePath).mtimeMs;
+      names = fs2.readdirSync(this.cacheDir).sort();
     } catch {
-      this.cacheMtime = void 0;
+      this.cacheSignature = void 0;
       this.cacheSnapshot = {};
+      this.cacheUpdatedAt = {};
       return this.cacheSnapshot;
     }
-    if (mtime === this.cacheMtime) return this.cacheSnapshot;
-    try {
-      const parsed = JSON.parse(fs2.readFileSync(this.cachePath, "utf8"));
-      this.cacheSnapshot = parsed.tools ?? {};
-      this.cacheMtime = mtime;
-    } catch {
-      this.cacheSnapshot = {};
-      this.cacheMtime = mtime;
+    let signature = "";
+    for (const name of names) {
+      try {
+        signature += `${name}:${fs2.statSync(path2.join(this.cacheDir, name)).mtimeMs};`;
+      } catch {
+      }
+    }
+    if (signature === this.cacheSignature) return this.pruneExpiredSnapshot();
+    const snapshot = {};
+    const updatedAt = {};
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const parsed = JSON.parse(fs2.readFileSync(path2.join(this.cacheDir, name), "utf8"));
+        if (typeof parsed.updatedAt !== "number" || this.now() - parsed.updatedAt > METADATA_TTL_MS) continue;
+        if (!Array.isArray(parsed.tools)) continue;
+        const key = name.slice(0, -".json".length);
+        snapshot[key] = parsed.tools;
+        updatedAt[key] = parsed.updatedAt;
+      } catch {
+      }
     }
+    this.cacheSnapshot = snapshot;
+    this.cacheUpdatedAt = updatedAt;
+    this.cacheSignature = signature;
     return this.cacheSnapshot;
   }
   async callTool(prefixedName, args, signal) {
     const catalog = this.loadCatalog();
+    if (this.conflictedNames.has(prefixedName)) {
+      return {
+        delivery: "not_sent",
+        error: `MCP tool name "${prefixedName}" is claimed by more than one configured server. Rename one of the servers so every tool name is unambiguous; the call was NOT sent.`
+      };
+    }
     const descriptor = catalog.find((tool) => tool.prefixedName === prefixedName);
     let server = descriptor?.server;
     let toolName = descriptor?.tool;
@@ -24746,12 +24854,17 @@ ${tail}` : "")
   }
   /** Close every client and reap every child process. */
   async dispose() {
+    this.disposed = true;
     for (const runtime of this.runtimes.values()) {
       try {
         await runtime.client?.close();
       } catch {
       }
+      if (!runtime.client && runtime.transport) {
+        await runtime.transport.close().catch(() => void 0);
+      }
       runtime.client = void 0;
+      runtime.transport = void 0;
     }
     this.runtimes.clear();
   }
@@ -24820,10 +24933,14 @@ var DEFAULT_OUTPUT_MAX_BYTES = 8192;
 var SEARCH_RESULT_LIMIT = 20;
 function truncate(text, maxBytes) {
   if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
-  const cut = Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8");
-  return `${cut}
+  const notice = `
 
 \u2026[truncated: result exceeded ${maxBytes} bytes. Narrow the call arguments or read the resource directly.]`;
+  const noticeBytes = Buffer.byteLength(notice, "utf8");
+  const bodyBudget = Math.max(1, maxBytes - noticeBytes);
+  let cut = Buffer.from(text, "utf8").subarray(0, bodyBudget).toString("utf8");
+  if (cut.endsWith("\uFFFD")) cut = cut.slice(0, -1);
+  return `${cut}${notice}`;
 }
 function summarizeParams(schema) {
   if (!schema || typeof schema !== "object") return "";
@@ -24915,7 +25032,7 @@ function createMcpProxyTool(getManager, ensureTrusted, options = {}) {
   return {
     name: "mcp",
     label: "MCP",
-    description: 'Call tools on configured MCP servers without loading their definitions. Discover: mcp({ search: "screenshot" }) lists matching <server>_<tool> names with compact parameter hints (cached metadata; servers do not start for search). Inspect: mcp({ tool: "<name>", describe: true }) returns the full input schema. Call: mcp({ tool: "<name>", args: { ... } }) \u2014 the server starts lazily on first use. args may be a JSON object or JSON string. If a result is marked [outcome unknown], the tool may have executed: do not retry automatically \u2014 verify state with a read-only call first.',
+    description: 'Call tools on configured MCP servers without loading their definitions. Discover: mcp({ search: "screenshot" }) lists matching <server>_<tool> names with compact parameter hints (cached metadata; servers do not start for search). Inspect: mcp({ tool: "<name>", describe: true }) returns the full input schema. Call: mcp({ tool: "<name>", args: { ... } }) \u2014 the server starts lazily on first use. args may be a JSON object or JSON string. Tool lists are a snapshot taken when a server connects: tools added or removed by a running server only appear after /reload refreshes the session. If a result is marked [outcome unknown], the tool may have executed: do not retry automatically \u2014 verify state with a read-only call first.',
     parameters: Type.Object({
       search: Type.Optional(Type.String({ description: "Query text to discover MCP tools by name/description" })),
       tool: Type.Optional(Type.String({ description: "Prefixed tool name <server>_<tool> to describe or call" })),
@@ -25115,10 +25232,10 @@ function formatServerForTrustPrompt(definition) {
 function mcpAdapter(ctx) {
   const configDir = resolveConfigDir();
   const trustStore = new McpTrustStore(path4.join(configDir, "mcp-trust.json"));
-  const metadataCachePath = path4.join(configDir, "mcp-metadata.json");
+  const metadataCacheDir = path4.join(configDir, "mcp-metadata");
   let manager = new McpServerManager(
     resolveMcpAdapterConfig(ctx.cwd, configDir).servers,
-    metadataCachePath,
+    metadataCacheDir,
     ctx.log
   );
   async function reloadManager() {
@@ -25126,23 +25243,29 @@ function mcpAdapter(ctx) {
     try {
       manager = new McpServerManager(
         resolveMcpAdapterConfig(ctx.cwd, configDir).servers,
-        metadataCachePath,
+        metadataCacheDir,
         ctx.log
       );
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
       ctx.log(`mcp: config reload failed: ${message}`);
       if (ctx.hasUI) ctx.ui.notify(`MCP adapter config error: ${message}`, "error");
-      manager = new McpServerManager([], metadataCachePath, ctx.log);
+      manager = new McpServerManager([], metadataCacheDir, ctx.log);
     }
   }
-  function writeProjectOverride(serverName, disabled) {
+  ctx.registerCleanup?.(() => manager.dispose().catch(() => void 0));
+  function readProjectOverride() {
     const filePath = path4.join(ctx.cwd, ".pie", "mcp-adapter.json");
     let parsed = {};
     try {
       parsed = JSON.parse(fs4.readFileSync(filePath, "utf8"));
     } catch {
     }
+    return parsed;
+  }
+  function writeProjectOverride(serverName, disabled) {
+    const filePath = path4.join(ctx.cwd, ".pie", "mcp-adapter.json");
+    const parsed = readProjectOverride();
     const servers = parsed.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers) ? { ...parsed.mcpServers } : {};
     if (disabled === null) {
       delete servers[serverName];
@@ -25184,16 +25307,6 @@ function mcpAdapter(ctx) {
   if (eagerRegistered.length > 0) {
     ctx.log(`mcp: registered ${eagerRegistered.length} direct tool(s) from metadata cache: ${eagerRegistered.join(", ")}`);
   }
-  function unpinnedWarnings() {
-    const warnings = [];
-    for (const definition of manager.listDefinitions()) {
-      const spec = [definition.command ?? "", ...definition.args].join(" ");
-      if (/(^|\s)(npx|bunx|uvx)\s/.test(spec) && /@latest\b/.test(spec)) {
-        warnings.push(`${definition.name}: unpinned "@latest" fetch \u2014 pin an exact version (e.g. pkg@1.2.3).`);
-      }
-    }
-    return warnings;
-  }
   ctx.registerCommand({
     name: "mcp",
     description: "MCP adapter: status (default), enable/disable <server>",
@@ -25209,10 +25322,21 @@ function mcpAdapter(ctx) {
           commandCtx.ui.notify(`Unknown MCP server "${target}". Run /mcp for the configured list.`, "warning");
           return;
         }
-        const filePath = writeProjectOverride(definition.name, sub === "disable" ? true : null);
+        const overrides = readProjectOverride().mcpServers;
+        const forceEnabled = overrides?.[definition.name]?.disabled === false;
+        const filePath = writeProjectOverride(
+          definition.name,
+          // enable must lift a source-level disabled:true with an explicit
+          // {disabled:false} force-override: deleting the override alone
+          // would leave the source-level disable in force. Preserve an
+          // existing force-enable on repeated enable commands too.
+          sub === "disable" ? true : definition.disabled || forceEnabled ? false : null
+        );
         await reloadManager();
+        const effectiveDisabled = manager.getDefinition(definition.name)?.disabled ?? false;
+        const stateLabel = effectiveDisabled ? "disabled" : sub === "disable" ? "still enabled" : "enabled";
         commandCtx.ui.notify(
-          `MCP server "${definition.name}" ${sub}d (wrote ${filePath}). ` + (eagerRegistered.length > 0 ? "Restart or /reload to resync direct tools." : "Effective immediately."),
+          `MCP server "${definition.name}" ${stateLabel} (wrote ${filePath}). ` + (eagerRegistered.length > 0 ? "Restart or /reload to resync direct tools." : "Effective immediately."),
           "info"
         );
         return;
@@ -25234,15 +25358,15 @@ function mcpAdapter(ctx) {
           lines.push(`- ${sanitizeName(definition.name)} [${manager.statusOf(definition.name)}, ${scopeLabel}] ${spec}`);
         }
       }
-      const warnings = unpinnedWarnings();
+      const warnings = unpinnedWarnings(manager.listDefinitions());
       if (warnings.length > 0) lines.push("", "Warnings:", ...warnings.map((warning) => `- ${warning}`));
       const config2 = resolveMcpAdapterConfig(commandCtx.cwd, configDir);
       if (config2.problems.length > 0) lines.push("", "Config problems:", ...config2.problems.map((problem) => `- ${problem}`));
       commandCtx.ui.notify(lines.join("\n"), "info");
     }
   });
-  ctx.on("session:changed", () => {
-    void reloadManager().catch(() => void 0);
+  ctx.on("session:changed", async () => {
+    await reloadManager();
   });
 }
 export {

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,7 +7,7 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-LU7RKALH.js";
+} from "../../../chunks/chunk-UPPICLVS.js";
 import "../../../chunks/chunk-QJH6YN2W.js";
 import "../../../chunks/chunk-IM43UYVV.js";
 import {

package/dist/builtin/extensions/subagent/index.js

@@ -1,14 +1,14 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-TJ2F4FL5.js";
-import "../../../chunks/chunk-5353DEEC.js";
+} from "../../../chunks/chunk-P3QPJXS7.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-LU7RKALH.js";
+} from "../../../chunks/chunk-UPPICLVS.js";
 import "../../../chunks/chunk-QJH6YN2W.js";
 import "../../../chunks/chunk-IM43UYVV.js";
+import "../../../chunks/chunk-5353DEEC.js";
 import "../../../chunks/chunk-XXGYUYXI.js";
 import "../../../chunks/chunk-LZQXQOPJ.js";
 

package/dist/builtin/extensions/todo/index.js

@@ -8,7 +8,7 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-LU7RKALH.js";
+} from "../../../chunks/chunk-UPPICLVS.js";
 import "../../../chunks/chunk-QJH6YN2W.js";
 import "../../../chunks/chunk-IM43UYVV.js";
 import "../../../chunks/chunk-XXGYUYXI.js";

package/dist/builtin/skills/tui-use/tui-use-cli.cjs

@@ -9999,6 +9999,16 @@ function validateRequest(value) {
       string("command", true, 32768);
       string("cwd");
       string("label", false, 1024);
+      if (r.env !== void 0) {
+        if (!r.env || typeof r.env !== "object" || Array.isArray(r.env)) throw new Error("Invalid env: expected an object of string to string.");
+        const entries = Object.entries(r.env);
+        if (entries.length > 512) throw new Error("Invalid env: at most 512 variables.");
+        for (const [k, v] of entries) {
+          if (!k.length || k.length > 256 || k.includes("\0") || typeof v !== "string" || v.length > 65536 || v.includes("\0")) {
+            throw new Error(`Invalid env entry ${JSON.stringify(k)}: expected string key and value without NUL bytes.`);
+          }
+        }
+      }
       if (r.argv !== void 0 && (!Array.isArray(r.argv) || r.argv.length < 1 || r.argv.length > 256 || r.argv.some((a) => typeof a !== "string" || a.includes("\0") || a.length > 32768) || !r.argv[0])) throw new Error("Invalid argv: expected a non-empty array of executable and arguments.");
     // Fall through to the shared PTY size limits.
     case "resize":
@@ -10294,6 +10304,13 @@ var SUPPORTED_KEYS = Object.keys(KEY_MAP);
 var import_node_fs2 = require("node:fs");
 var import_node_path3 = __toESM(require("node:path"));
 var program2 = new Command();
+function callerEnv() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  return env;
+}
 program2.name("tui-use").description("TUI automation for AI agents \u2014 like BrowserUse, but for the terminal").option("--session <id>", "Target this session explicitly (safe for concurrent tasks)").version(version);
 program2.command("start [args...]").description("Start an interactive program in a PTY session").option("--cwd <dir>", "Working directory for the command").option("--label <name>", "Human-readable label for this session").option("--cols <n>", "Terminal width (default: 120)", "120").option("--rows <n>", "Terminal height (default: 30)", "30").option("--argv-stdin", "Read a JSON array of executable and arguments from UTF-8 stdin; bypass the shell").action(async (args, opts) => {
   let argv;
@@ -10311,6 +10328,7 @@ program2.command("start [args...]").description("Start an interactive program in
     type: "start",
     command,
     cwd: import_node_path3.default.resolve(opts.cwd ?? process.cwd()),
+    env: callerEnv(),
     label: opts.label,
     cols: Number(opts.cols),
     rows: Number(opts.rows),

package/dist/builtin/skills/tui-use/tui-use-daemon.cjs

@@ -7267,7 +7267,10 @@ var Session = class {
         rows,
         useConptyDll: process.platform === "win32",
         cwd: options.cwd ?? process.cwd(),
-        env: process.env
+        // The caller's env, not the daemon starter's: a persistent daemon
+        // outlives many projects, and each session must see the environment
+        // of the shell that started it (PATH setups, PIE_* overrides, ...).
+        env: options.env ?? process.env
       });
     } catch (error) {
       this.terminal.dispose();
@@ -7606,6 +7609,16 @@ function validateRequest(value) {
       string("command", true, 32768);
       string("cwd");
       string("label", false, 1024);
+      if (r.env !== void 0) {
+        if (!r.env || typeof r.env !== "object" || Array.isArray(r.env)) throw new Error("Invalid env: expected an object of string to string.");
+        const entries = Object.entries(r.env);
+        if (entries.length > 512) throw new Error("Invalid env: at most 512 variables.");
+        for (const [k, v] of entries) {
+          if (!k.length || k.length > 256 || k.includes("\0") || typeof v !== "string" || v.length > 65536 || v.includes("\0")) {
+            throw new Error(`Invalid env entry ${JSON.stringify(k)}: expected string key and value without NUL bytes.`);
+          }
+        }
+      }
       if (r.argv !== void 0 && (!Array.isArray(r.argv) || r.argv.length < 1 || r.argv.length > 256 || r.argv.some((a) => typeof a !== "string" || a.includes("\0") || a.length > 32768) || !r.argv[0])) throw new Error("Invalid argv: expected a non-empty array of executable and arguments.");
     // Fall through to the shared PTY size limits.
     case "resize":

package/dist/chunks/{chunk-TJ2F4FL5.js → chunk-P3QPJXS7.js}

@@ -1,8 +1,4 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  getBuiltinDir,
-  getConfigDir
-} from "./chunk-5353DEEC.js";
 import {
   classifyShellCommand,
   createCodeIntelTool,
@@ -12,7 +8,11 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-LU7RKALH.js";
+} from "./chunk-UPPICLVS.js";
+import {
+  getBuiltinDir,
+  getConfigDir
+} from "./chunk-5353DEEC.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";

package/dist/chunks/{chunk-LU7RKALH.js → chunk-UPPICLVS.js}

@@ -4856,7 +4856,7 @@ var AgentSessionRetryController = class {
       }
       return;
     }
-    const maxRetries = this.retry.maxRetries ?? 3;
+    const maxRetries = this.retry.maxRetriesForFailure?.(failure) ?? this.retry.maxRetries ?? 3;
     this.retryAttempt += 1;
     if (this.retryAttempt > maxRetries) {
       const terminalFailure = asTerminalFailure(failure);
@@ -4869,7 +4869,8 @@ var AgentSessionRetryController = class {
       return;
     }
     const attempt = this.retryAttempt;
-    const delayMs = (this.retry.baseDelayMs ?? 2e3) * 2 ** (attempt - 1);
+    const rawDelayMs = (this.retry.baseDelayMs ?? 2e3) * 2 ** (attempt - 1);
+    const delayMs = this.retry.maxDelayMs !== void 0 ? Math.min(rawDelayMs, this.retry.maxDelayMs) : rawDelayMs;
     this.ensurePending();
     this.setRecoveryState("retry_pending");
     this.emit({ type: "turn_recovery_pending", recovery: "retry", failure, attempt, maxRetries, delayMs });
@@ -4917,7 +4918,7 @@ var AgentSessionRetryController = class {
       userAbort: false,
       terminal: true
     });
-    const maxRetries = this.retry?.maxRetries ?? 3;
+    const maxRetries = (failure !== void 0 ? this.retry?.maxRetriesForFailure?.(failure) : void 0) ?? this.retry?.maxRetries ?? 3;
     this.emit({ type: "retry_exhausted", errorMessage: terminalFailure.message, maxRetries });
     this.emit({ type: "turn_failed_terminal", failure: terminalFailure });
     this.emit({ type: "turn_settled" });

package/dist/cli.js

@@ -7,25 +7,7 @@ import {
   createCliWebResearchHealthStore,
   formatSize,
   truncateHeadTail
-} from "./chunks/chunk-TJ2F4FL5.js";
-import {
-  VERSION,
-  getAgentDir,
-  getBuiltinDir,
-  getConfigDir,
-  getCustomThemesDir,
-  getLogsDir,
-  getPackageDir,
-  getProjectSettingsPath,
-  getRuntimeLogPath,
-  getSessionsDir,
-  getSettingsPath,
-  getThemesDir,
-  migrateConfigFromAgentDir
-} from "./chunks/chunk-5353DEEC.js";
-import {
-  resolveCliProjectRoot
-} from "./chunks/chunk-WLFOBECN.js";
+} from "./chunks/chunk-P3QPJXS7.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -78,7 +60,7 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-LU7RKALH.js";
+} from "./chunks/chunk-UPPICLVS.js";
 import "./chunks/chunk-QJH6YN2W.js";
 import {
   Deref,
@@ -104,6 +86,24 @@ import {
   sortToolModelCandidatesByCapability,
   type_exports
 } from "./chunks/chunk-IM43UYVV.js";
+import {
+  VERSION,
+  getAgentDir,
+  getBuiltinDir,
+  getConfigDir,
+  getCustomThemesDir,
+  getLogsDir,
+  getPackageDir,
+  getProjectSettingsPath,
+  getRuntimeLogPath,
+  getSessionsDir,
+  getSettingsPath,
+  getThemesDir,
+  migrateConfigFromAgentDir
+} from "./chunks/chunk-5353DEEC.js";
+import {
+  resolveCliProjectRoot
+} from "./chunks/chunk-WLFOBECN.js";
 import {
   IsArray,
   IsBigInt,
@@ -77119,7 +77119,7 @@ function stripStaleUsageBeforeCompaction(messages, latestCompactionTimestamp) {
 }
 
 // src/runtime/retry-policy.ts
-var TRANSIENT_NETWORK_ERROR_PATTERN = /sse stream aborted|sse stream closed before end|sse stream ended before response completed|(?:read\s+)?ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|socket hang up|request timeout|client network socket disconnected before secure TLS connection was established|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated/i;
+var TRANSIENT_NETWORK_ERROR_PATTERN = /sse stream aborted|sse stream closed before end|sse stream ended before response completed|(?:read\s+)?ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|(?:read\s+|write\s+)?EPIPE|socket hang up|request timeout|client network socket disconnected before secure TLS connection was established|certificate (?:has )?expired|unable to verify (?:the first certificate|certificate)|self[- ]signed cert|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated/i;
 var PROVIDER_TRANSIENT_ERROR_PATTERN = /overloaded|rate.?limit|too many requests|\b429\b|\b500\b|\b502\b|\b503\b|\b504\b|service.?unavailable|server error|internal error|retry delay/i;
 var USER_ABORT_PATTERN = /request was aborted|local abort signal|user abort|user_interrupt|interrupted by user|esc pressed|ctrl\+c/i;
 var AUTH_CONFIG_PATTERN = /missing api key|invalid api key|api key.*invalid|unauthorized|\b401\b|\b403\b|forbidden|authentication failed|no configured model|no models? are configured/i;
@@ -77127,6 +77127,8 @@ var INVALID_FILE_REFERENCE_PATTERN = /not the owner of this file|owner of this f
 var INVALID_REQUEST_PATTERN = /bad request|\b400\b|invalid request|invalid schema|schema validation|invalid parameter|unsupported parameter|malformed/i;
 var CLI_RETRY_MAX_RETRIES = 3;
 var CLI_RETRY_BASE_DELAY_MS = 2e3;
+var CLI_TRANSIENT_NETWORK_MAX_RETRIES = 10;
+var CLI_RETRY_MAX_DELAY_MS = 6e4;
 function isCliContextOverflowError(errorMessage4) {
   return /context length exceeded|context_length_exceeded|maximum context length|maximum context size|too many tokens|input.*too long|prompt.*too long|context window|token limit exceeded|exceeds.{0,20}context/i.test(
     errorMessage4
@@ -77203,6 +77205,31 @@ function getCliRetryBaseDelayMs() {
   const parsed = Number(override);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : CLI_RETRY_BASE_DELAY_MS;
 }
+function getCliTransientNetworkMaxRetries() {
+  const override = process.env.PIE_RETRY_TRANSIENT_NETWORK_MAX_RETRIES;
+  if (!override) {
+    return CLI_TRANSIENT_NETWORK_MAX_RETRIES;
+  }
+  const parsed = Number(override);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : CLI_TRANSIENT_NETWORK_MAX_RETRIES;
+}
+function getCliRetryMaxDelayMs() {
+  const override = process.env.PIE_RETRY_MAX_DELAY_MS;
+  if (!override) {
+    return CLI_RETRY_MAX_DELAY_MS;
+  }
+  const parsed = Number(override);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : CLI_RETRY_MAX_DELAY_MS;
+}
+function createCliRetryPolicy(isRetryableErrorOverride) {
+  return {
+    isRetryableError: isRetryableErrorOverride ?? isCliRetryableError,
+    maxRetries: CLI_RETRY_MAX_RETRIES,
+    baseDelayMs: getCliRetryBaseDelayMs(),
+    maxDelayMs: getCliRetryMaxDelayMs(),
+    maxRetriesForFailure: (failure) => failure.kind === "transient_network" ? getCliTransientNetworkMaxRetries() : CLI_RETRY_MAX_RETRIES
+  };
+}
 
 // src/runtime/interactive-context-ui.ts
 function calculateContextUsage(host) {
@@ -77921,11 +77948,9 @@ function createInteractiveAgentSessionController(host) {
     },
     getAutoContinueMessage: () => host.getTodoAutoContinueMessage(),
     classifyFailure: (context) => classifyCliFailure(context),
-    retry: {
-      isRetryableError: (errorMessage4) => !host._isContextOverflowError(errorMessage4) && isCliRetryableError(errorMessage4),
-      maxRetries: CLI_RETRY_MAX_RETRIES,
-      baseDelayMs: getCliRetryBaseDelayMs()
-    },
+    retry: createCliRetryPolicy(
+      (errorMessage4) => !host._isContextOverflowError(errorMessage4) && isCliRetryableError(errorMessage4)
+    ),
     compaction: {
       compact: async (context) => {
         const beforeCompact = await host.extensionRunner?.emitSessionBeforeCompact({
@@ -79597,6 +79622,7 @@ var InteractiveMode = class {
     await this.loadExtensions();
     this.applyRuntimeToolMode();
     this.noteRuntimeModeChanged("extension_reload");
+    await this.syncSessionScopedState();
     this.ui.requestRender();
   }
   calculateContextUsage() {
@@ -80152,6 +80178,24 @@ async function composeCliRuntime(params) {
   };
 }
 
+// src/app/print-mode-retry-status.ts
+function createPrintModeRetryStatusReporter() {
+  let exhaustedRetryBudget;
+  return (event) => {
+    if (event.type === "turn_recovery_pending" && event.recovery === "retry") {
+      console.error(`Transient request error: ${event.failure.message}. Retrying in ${(event.delayMs ?? 0) / 1e3}s (${event.attempt}/${event.maxRetries}).`);
+    } else if (event.type === "turn_retry_started") {
+      console.error(`Retrying request (${event.attempt}/${event.maxRetries})...`);
+    } else if (event.type === "turn_retry_succeeded") {
+      console.error(`Retry succeeded after ${event.attempts} attempt${event.attempts === 1 ? "" : "s"}.`);
+    } else if (event.type === "retry_exhausted") {
+      exhaustedRetryBudget = event.maxRetries;
+    } else if (event.type === "turn_failed_terminal" && (event.failure.kind === "transient_network" || event.failure.kind === "provider_transient")) {
+      console.error(`Request failed after ${exhaustedRetryBudget ?? CLI_RETRY_MAX_RETRIES} retries: ${event.failure.message}`);
+    }
+  };
+}
+
 // src/app/print-mode.ts
 function createNoOpExtensionUIContext() {
   return {
@@ -80329,6 +80373,7 @@ async function runPrintMode(params) {
     streamFn: params.streamFn
   });
   const sessionTrace = new SessionTraceWriter(runtime.paths.sessionsDir, runtime.sessionManager);
+  const reportRetryStatus = createPrintModeRetryStatusReporter();
   const agentSessionController = new AgentSessionController({
     agent,
     sessionManager: runtime.sessionManager,
@@ -80349,11 +80394,7 @@ async function runPrintMode(params) {
         messages: result.messages?.length ? [...context.messages, ...result.messages] : context.messages
       };
     },
-    retry: {
-      isRetryableError: isCliRetryableError,
-      maxRetries: CLI_RETRY_MAX_RETRIES,
-      baseDelayMs: getCliRetryBaseDelayMs()
-    },
+    retry: createCliRetryPolicy(),
     getAutoCompactDecision: ({ message, messages }) => createCliAutoCompactDecision({
       message,
       messages,
@@ -80388,20 +80429,14 @@ async function runPrintMode(params) {
     classifyFailure: (context) => classifyCliFailure(context),
     onEvent: (event) => {
       sessionTrace.noteRuntimeEvent(event.type, event);
-      if (event.type === "turn_recovery_pending" && event.recovery === "retry") {
-        console.error(`Transient request error: ${event.failure.message}. Retrying in ${(event.delayMs ?? 0) / 1e3}s (${event.attempt}/${event.maxRetries}).`);
-      } else if (event.type === "turn_recovery_pending" && event.recovery === "compaction") {
+      if (event.type === "turn_recovery_pending" && event.recovery === "compaction") {
         console.error(event.failure.kind === "context_overflow" ? "Context overflow detected, compacting..." : "Auto-compacting context before retry...");
       } else if (event.type === "auto_compaction_start") {
         console.error(event.reason === "overflow" ? "Context overflow detected, compacting..." : "Auto-compacting context...");
       } else if (event.type === "auto_compaction_end" && !event.errorMessage) {
         runtime.fileObservationState.clear();
-      } else if (event.type === "turn_retry_started") {
-        console.error(`Retrying request (${event.attempt}/${event.maxRetries})...`);
-      } else if (event.type === "turn_retry_succeeded") {
-        console.error(`Retry succeeded after ${event.attempts} attempt${event.attempts === 1 ? "" : "s"}.`);
-      } else if (event.type === "turn_failed_terminal" && (event.failure.kind === "transient_network" || event.failure.kind === "provider_transient")) {
-        console.error(`Request failed after ${CLI_RETRY_MAX_RETRIES} retries: ${event.failure.message}`);
+      } else {
+        reportRetryStatus(event);
       }
     }
   });
@@ -81518,11 +81553,7 @@ async function runJsonEventsMode(params) {
           messages: result?.messages?.length ? [...context.messages, ...result.messages] : context.messages
         };
       },
-      retry: {
-        isRetryableError: isCliRetryableError,
-        maxRetries: CLI_RETRY_MAX_RETRIES,
-        baseDelayMs: getCliRetryBaseDelayMs()
-      },
+      retry: createCliRetryPolicy(),
       getAutoCompactDecision: ({ message, messages }) => createCliAutoCompactDecision({
         message,
         messages,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cydm/pie",
-	"version": "2.1.1",
+	"version": "2.3.0",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {
@@ -19,7 +19,7 @@
 		"pretest:offline": "npm run build --workspace @pie/agent-framework && npm run build --workspace @pie/shared-headless-capabilities && npm run build && npm run test:skill-regressions",
 		"test:skill-regressions": "node --test --import tsx test/bash-lifecycle.test.ts test/skill-creator-runner.test.ts test/tui-use-contract.test.ts test/tui-use-runtime.test.ts test/browser-runtime.test.ts test/computer-evidence.test.ts test/interactive-lifecycle.test.ts",
 		"posttest:offline": "node --test --import tsx test/remote-model-catalog.test.ts",
-		"test:offline": "node --test --test-concurrency=4 --import tsx test/builtin-extensions.test.ts test/core-services.test.ts test/cli.test.ts test/cli-auto-compaction.test.ts test/execution-state-manager.test.ts test/queued-steer-execution-state.test.ts test/architecture-boundaries.test.ts test/attachment-resolver.test.ts test/kimi-attachment-provider.test.ts test/document-attachment-extension.test.ts test/auto-compact-overflow.test.ts test/hierarchical-command-system.test.ts test/mcp-adapter.test.ts test/extensions-enablement.test.ts test/extension-selector-shortcuts.test.ts test/skill-tool-enablement.test.ts test/message-queue-unit.test.ts test/evals-harness.test.ts test/session-trace.test.ts test/runtime-mode-context.test.ts test/tool-policy.test.ts test/retry-policy.test.ts test/yolo-command.test.ts test/footer-lifecycle.test.ts test/files-utils.test.ts test/source-size-guard.test.ts test/runtime-logger.test.ts test/release-readiness.test.ts test/package-artifacts.test.ts test/code-intel-typescript-provider.test.ts test/init-extension-contract.test.ts test/skills-runtime.test.ts test/skills-agents-discovery.test.ts test/skills-symlink.test.ts test/model-overrides.test.ts test/auth-storage.test.ts test/extension-register-provider.test.ts test/extension-reload.test.ts test/extension-terminal-input.test.ts test/extension-session-before-events.test.ts test/extension-widgets.test.ts test/extension-render-hint.test.ts test/extension-oauth-restore.test.ts test/cross-host-parity.test.ts test/tool-name-rendering.test.ts test/session-selector.test.ts test/terminal-title.test.ts test/interactive-controller-title.test.ts test/todo-title.terminal.test.ts test/plan-mode-extension.test.ts test/rendered-page-reader.test.ts test/tools-registry.test.ts test/system-prompt-contract.test.ts test/bash-yolo.test.ts test/direct-bash.test.ts test/terminal-bell.test.ts test/ctrl-d-exit.test.ts test/session-display-title.test.ts test/calm-mode.test.ts test/project-root.test.ts test/guard-advisory-context.test.ts test/clear-command-usage.test.ts test/daily-agent-smoke.terminal.test.ts test/slash-menu-toggles.terminal.test.ts test/cli-args.test.ts test/extensions-configured-paths.test.ts test/extensions-loader-path.test.ts test/file-picker.test.ts test/interrupt-recovery.test.ts test/mention-insert-regression.test.ts test/mention-picker-navigation.test.ts test/pie-unity-rpc-skill.test.ts test/skill-creator-scripts.test.ts",
+		"test:offline": "node --test --test-concurrency=4 --import tsx test/builtin-extensions.test.ts test/core-services.test.ts test/cli.test.ts test/cli-auto-compaction.test.ts test/execution-state-manager.test.ts test/queued-steer-execution-state.test.ts test/architecture-boundaries.test.ts test/attachment-resolver.test.ts test/kimi-attachment-provider.test.ts test/document-attachment-extension.test.ts test/auto-compact-overflow.test.ts test/hierarchical-command-system.test.ts test/mcp-adapter.test.ts test/herdr-agent-state.test.ts test/extensions-enablement.test.ts test/extension-selector-shortcuts.test.ts test/skill-tool-enablement.test.ts test/message-queue-unit.test.ts test/evals-harness.test.ts test/session-trace.test.ts test/runtime-mode-context.test.ts test/tool-policy.test.ts test/retry-policy.test.ts test/yolo-command.test.ts test/footer-lifecycle.test.ts test/files-utils.test.ts test/source-size-guard.test.ts test/runtime-logger.test.ts test/release-readiness.test.ts test/package-artifacts.test.ts test/code-intel-typescript-provider.test.ts test/init-extension-contract.test.ts test/skills-runtime.test.ts test/skills-agents-discovery.test.ts test/skills-symlink.test.ts test/model-overrides.test.ts test/auth-storage.test.ts test/extension-register-provider.test.ts test/extension-reload.test.ts test/extension-terminal-input.test.ts test/extension-session-before-events.test.ts test/extension-widgets.test.ts test/extension-render-hint.test.ts test/extension-oauth-restore.test.ts test/cross-host-parity.test.ts test/tool-name-rendering.test.ts test/session-selector.test.ts test/terminal-title.test.ts test/interactive-controller-title.test.ts test/todo-title.terminal.test.ts test/plan-mode-extension.test.ts test/rendered-page-reader.test.ts test/tools-registry.test.ts test/system-prompt-contract.test.ts test/bash-yolo.test.ts test/direct-bash.test.ts test/terminal-bell.test.ts test/ctrl-d-exit.test.ts test/session-display-title.test.ts test/calm-mode.test.ts test/project-root.test.ts test/guard-advisory-context.test.ts test/clear-command-usage.test.ts test/daily-agent-smoke.terminal.test.ts test/slash-menu-toggles.terminal.test.ts test/cli-args.test.ts test/extensions-configured-paths.test.ts test/extensions-loader-path.test.ts test/file-picker.test.ts test/interrupt-recovery.test.ts test/mention-insert-regression.test.ts test/mention-picker-navigation.test.ts test/pie-unity-rpc-skill.test.ts test/skill-creator-scripts.test.ts",
 		"test:all": "npm run test:offline && npm run test:terminal:vitest",
 		"test:terminal:vitest": "vitest run test/mention-file-select.terminal.test.ts test/tool-partial-display.terminal.test.ts test/footer-plan-mode.test.ts test/viewport-position-final.test.ts test/resume-header.terminal.test.ts --no-file-parallelism",
 		"test:todo-tui": "node ../../scripts/run-with-env.mjs PIE_REAL_TODO_TUI=1 -- --test --import tsx test/todo-closure.terminal.test.ts",