@cydm/pie 2.6.12 → 2.7.1

package/dist/chunks/{chunk-AAEBH6KX.js → chunk-W74NRSRV.js}

@@ -1,27 +1,196 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   classifyShellCommand,
-  createCodeIntelTool,
-  createLightweightCodeIntelProvider,
   createSharedWebFetchTool,
   createSharedWebResearchTool,
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-PPEWRUMQ.js";
+} from "./chunk-M44CWVDZ.js";
 import {
-  getBuiltinDir,
-  getConfigDir
-} from "./chunk-5353DEEC.js";
+  getLogger
+} from "./chunk-XUROMYTT.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
 
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var isBunRuntime = !!process.versions.bun;
+function getPackageDir() {
+  const envDir = process.env.PIE_PACKAGE_DIR;
+  if (envDir) {
+    if (envDir === "~") return homedir();
+    if (envDir.startsWith("~/")) return homedir() + envDir.slice(1);
+    return envDir;
+  }
+  let dir = __dirname;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return __dirname;
+}
+function getThemesDir() {
+  const packageDir = getPackageDir();
+  const srcOrDist = existsSync(join(packageDir, "src")) ? "src" : "dist";
+  return join(packageDir, srcOrDist, "theme");
+}
+function getBuiltinDir() {
+  const packageDir = getPackageDir();
+  const distBuiltinDir = join(packageDir, "dist", "builtin");
+  if (existsSync(distBuiltinDir)) {
+    return distBuiltinDir;
+  }
+  return join(packageDir, "builtin");
+}
+function getPackageJsonPath() {
+  return join(getPackageDir(), "package.json");
+}
+var pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+var CONFIG_DIR_NAME = ".pie";
+var VERSION = pkg.version;
+var ENV_AGENT_DIR = "PIE_CODING_AGENT_DIR";
+function getConfigDir() {
+  const envDir = process.env[ENV_AGENT_DIR];
+  if (envDir) {
+    if (envDir === "~") return homedir();
+    if (envDir.startsWith("~/")) return homedir() + envDir.slice(1);
+    return envDir;
+  }
+  return join(homedir(), CONFIG_DIR_NAME);
+}
+function getAgentDir() {
+  return getConfigDir();
+}
+function getCustomThemesDir() {
+  return join(getConfigDir(), "themes");
+}
+function getSettingsPath() {
+  return join(getConfigDir(), "settings.json");
+}
+function getProjectSettingsPath(cwd) {
+  return join(cwd, CONFIG_DIR_NAME, "settings.json");
+}
+function getSessionsDir() {
+  return join(getConfigDir(), "sessions");
+}
+function getLogsDir() {
+  return join(getConfigDir(), "logs");
+}
+function getRuntimeLogPath() {
+  return join(getLogsDir(), "pie-cli.log");
+}
+function migrateConfigFromAgentDir() {
+  const oldAgentDir = join(homedir(), CONFIG_DIR_NAME, "agent");
+  const newConfigDir = getConfigDir();
+  if (!existsSync(oldAgentDir)) {
+    return;
+  }
+  if (!existsSync(newConfigDir)) {
+    mkdirSync(newConfigDir, { recursive: true });
+  }
+  const filesToMigrate = [
+    "keybindings.json",
+    "settings.json",
+    "pie-debug.log"
+  ];
+  for (const file of filesToMigrate) {
+    const oldPath = join(oldAgentDir, file);
+    const newPath = file === "pie-debug.log" ? getRuntimeLogPath() : join(newConfigDir, file);
+    if (existsSync(oldPath) && !existsSync(newPath)) {
+      try {
+        if (file === "pie-debug.log") {
+          mkdirSync(getLogsDir(), { recursive: true });
+        }
+        renameSync(oldPath, newPath);
+        console.log(`[Config] Migrated ${file} to ${newPath}`);
+      } catch (e) {
+      }
+    }
+  }
+  const oldThemesDir = join(oldAgentDir, "themes");
+  const newThemesDir = getCustomThemesDir();
+  if (existsSync(oldThemesDir) && !existsSync(newThemesDir)) {
+    try {
+      renameSync(oldThemesDir, newThemesDir);
+      console.log(`[Config] Migrated themes to ${newThemesDir}`);
+    } catch (e) {
+    }
+  }
+}
+
+// src/runtime/transport-diagnostics.ts
+function numberOrDash(value) {
+  return typeof value === "number" ? String(value) : "-";
+}
+function formatTransportLifecycle(event) {
+  const parts = [
+    `transport=${event.transport}`,
+    `id=${event.localRequestId}`,
+    `phase=${event.phase}`,
+    `gen=${event.requestGeneration}${event.connectionGeneration !== void 0 ? `/c${event.connectionGeneration}` : ""}`,
+    `reused=${event.reusedConnection ? "yes" : "no"}`,
+    `ageMs=${numberOrDash(event.requestAgeMs)}`,
+    `lastReceiveAgeMs=${numberOrDash(event.lastReceiveAgeMs)}`
+  ];
+  if (event.timeoutKind) parts.push(`timeoutKind=${event.timeoutKind}`);
+  if (event.budgets) {
+    const budgets = Object.entries(event.budgets).filter(([, value]) => typeof value === "number").map(([key, value]) => `${key}=${value}`);
+    if (budgets.length > 0) parts.push(`budgets(${budgets.join(",")})`);
+  }
+  if (event.receivedMessageCount !== void 0) parts.push(`messages=${event.receivedMessageCount}`);
+  if (event.sawResponseCreated !== void 0) parts.push(`sawCreated=${event.sawResponseCreated ? "yes" : "no"}`);
+  if (event.sawModelContent !== void 0) parts.push(`sawContent=${event.sawModelContent ? "yes" : "no"}`);
+  if (event.submissionAttempted !== void 0) parts.push(`submitted=${event.submissionAttempted ? "yes" : "no"}`);
+  if (event.terminalAccepted !== void 0) parts.push(`terminal=${event.terminalAccepted ? "yes" : "no"}`);
+  if (event.retryAllowed !== void 0) parts.push(`retryAllowed=${event.retryAllowed ? "yes" : "no"}`);
+  if (event.retryDecision) parts.push(`retryDecision=${event.retryDecision}`);
+  if (event.cancelSource) parts.push(`cancelSource=${event.cancelSource}`);
+  if (event.cleanupOutcome) parts.push(`cleanup=${event.cleanupOutcome}`);
+  if (event.singleAttempt) parts.push(`singleAttempt=${event.singleAttempt}`);
+  return `[transport] ${parts.join(" ")}`;
+}
+function createTransportDiagnosticsStreamFn(base, sink) {
+  return (model, context, options) => base(model, context, {
+    ...options,
+    onTransportLifecycle: (event) => {
+      try {
+        options?.onTransportLifecycle?.(event);
+        sink(event);
+      } catch {
+      }
+    }
+  });
+}
+var logTransportLifecycle = (event) => {
+  const logger = getLogger().child({ module: "cli.transport" });
+  const line = formatTransportLifecycle(event);
+  if (event.phase === "timeout" || event.cleanupOutcome === "request_abandoned") {
+    logger.warn(line, { transportLifecycle: event });
+  } else {
+    logger.debug(line, { transportLifecycle: event });
+  }
+};
+function createTraceTransportSink(noteRuntimeEvent) {
+  return (event) => {
+    noteRuntimeEvent("transport_lifecycle", event);
+    logTransportLifecycle(event);
+  };
+}
+
 // src/capabilities/bash/index.ts
 import { spawn } from "child_process";
-import { closeSync, createWriteStream, existsSync, openSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { closeSync, createWriteStream, existsSync as existsSync2, openSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join, resolve } from "path";
+import { join as join2, resolve as resolve2 } from "path";
 import { createHash, randomBytes } from "crypto";
 
 // src/capabilities/bash/truncate.ts
@@ -275,7 +444,7 @@ async function requestHighRiskConfirmation(request) {
   return response.type === "confirm" && response.confirmed === true;
 }
 function validateWorkingDirectory(cwd) {
-  if (!existsSync(cwd)) {
+  if (!existsSync2(cwd)) {
     throw new Error(`Invalid bash cwd: ${cwd} does not exist. Use the current workspace path or pass an existing directory in cwd.`);
   }
   let stat;
@@ -290,11 +459,11 @@ function validateWorkingDirectory(cwd) {
 }
 function normalizeWorkingDirectory(cwd, defaultCwd) {
   const requestedCwd = typeof cwd === "string" && cwd.trim().length > 0 ? cwd.trim() : void 0;
-  return resolve(requestedCwd ?? defaultCwd ?? process.cwd());
+  return resolve2(requestedCwd ?? defaultCwd ?? process.cwd());
 }
 function getTempFilePath() {
   const id = randomBytes(8).toString("hex");
-  return join(tmpdir(), `pie-bash-${id}.log`);
+  return join2(tmpdir(), `pie-bash-${id}.log`);
 }
 var retainedOutputArtifacts = /* @__PURE__ */ new Set();
 function getErrorCode(error) {
@@ -304,15 +473,15 @@ function getErrorCode(error) {
 }
 function createPrivateOutputArtifact() {
   for (let attempt = 0; attempt < 10; attempt++) {
-    const path4 = getTempFilePath();
+    const path3 = getTempFilePath();
     try {
-      const fd = openSync(path4, "wx", 384);
-      retainedOutputArtifacts.add(path4);
+      const fd = openSync(path3, "wx", 384);
+      retainedOutputArtifacts.add(path3);
       try {
-        return { path: path4, stream: createWriteStream(path4, { fd, autoClose: true }) };
+        return { path: path3, stream: createWriteStream(path3, { fd, autoClose: true }) };
       } catch (error) {
         closeSync(fd);
-        removeOutputArtifact(path4);
+        removeOutputArtifact(path3);
         throw error;
       }
     } catch (error) {
@@ -321,34 +490,34 @@ function createPrivateOutputArtifact() {
   }
   throw new Error("Unable to allocate a private bash output artifact.");
 }
-function removeOutputArtifact(path4) {
-  if (!path4) return;
+function removeOutputArtifact(path3) {
+  if (!path3) return;
   try {
-    unlinkSync(path4);
+    unlinkSync(path3);
   } catch (error) {
     if (getErrorCode(error) !== "ENOENT") throw error;
   }
-  retainedOutputArtifacts.delete(path4);
+  retainedOutputArtifacts.delete(path3);
 }
-function discardOutputArtifact(path4, stream) {
+function discardOutputArtifact(path3, stream) {
   if (stream && !stream.closed) {
     stream.once("close", () => {
       try {
-        removeOutputArtifact(path4);
+        removeOutputArtifact(path3);
       } catch {
       }
     });
     stream.destroy();
   }
   try {
-    removeOutputArtifact(path4);
+    removeOutputArtifact(path3);
   } catch {
   }
 }
 function cleanupBashOutputArtifacts() {
-  for (const path4 of [...retainedOutputArtifacts]) {
+  for (const path3 of [...retainedOutputArtifacts]) {
     try {
-      removeOutputArtifact(path4);
+      removeOutputArtifact(path3);
     } catch {
     }
   }
@@ -356,7 +525,7 @@ function cleanupBashOutputArtifacts() {
 process.once("exit", cleanupBashOutputArtifacts);
 function finishTempFileStream(stream) {
   if (!stream || stream.closed) return Promise.resolve();
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let done = false;
     const timer = setTimeout(() => {
       stream.destroy(new Error("Timed out flushing shell output."));
@@ -370,7 +539,7 @@ function finishTempFileStream(stream) {
       if (done) return;
       done = true;
       cleanup();
-      resolve2();
+      resolve3();
     };
     const onError = (error) => {
       if (done) return;
@@ -549,7 +718,7 @@ function createBashTool(defaultCwd, options) {
       }
       const timeoutPolicy = resolveTimeoutPolicy(timeout, risk.commandClass);
       const timeoutMs = timeoutPolicy.effectiveSeconds * 1e3;
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -599,7 +768,7 @@ function createBashTool(defaultCwd, options) {
         const child = (options?.spawnProcess ?? spawn)(spawnCommand.file, spawnCommand.args, {
           shell: spawnCommand.shell,
           cwd: workingDir,
-          env: process.env,
+          env: { ...process.env, ...options?.getEnv?.() ?? {} },
           detached: process.platform !== "win32",
           windowsHide: true
         });
@@ -763,10 +932,10 @@ ${fullOutput}`;
             }
             let outputText = truncation.content || "(no output)";
             if (truncation.truncated && !tempFilePath) {
-              const path4 = getTempFilePath();
-              const fd = openSync(path4, "wx", 384);
-              tempFilePath = path4;
-              retainedOutputArtifacts.add(path4);
+              const path3 = getTempFilePath();
+              const fd = openSync(path3, "wx", 384);
+              tempFilePath = path3;
+              retainedOutputArtifacts.add(path3);
               try {
                 writeFileSync(fd, fullOutput, "utf-8");
               } finally {
@@ -857,7 +1026,7 @@ ${commandNonzeroHint}`;
               outputText += "\n\n[Repeat hint: this exact command already returned the same result in this session. If it proves the task, stop; otherwise change the command or inspect a different file/range.]";
             }
             const content = [{ type: "text", text: outputText }];
-            resolve2({ content, details, isError: outcome.toolFailure });
+            resolve3({ content, details, isError: outcome.toolFailure });
           } catch (error) {
             discardOutputArtifact(tempFilePath, tempFileStream);
             reject(error);
@@ -883,197 +1052,25 @@ ${commandNonzeroHint}`;
   };
 }
 
-// src/capabilities/code-intel.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Worker } from "node:worker_threads";
-var WORKER_TIMEOUT_MS = 3e4;
-var MAX_ACTIVE_CODE_INTEL_WORKERS = 1;
-var MAX_QUEUED_CODE_INTEL_WORKERS = 16;
-var activeCodeIntelWorkers = 0;
-var codeIntelWorkerWaiters = [];
-function releaseWorkerSlot() {
-  activeCodeIntelWorkers = Math.max(0, activeCodeIntelWorkers - 1);
-  while (activeCodeIntelWorkers < MAX_ACTIVE_CODE_INTEL_WORKERS && codeIntelWorkerWaiters.length > 0) {
-    const waiter = codeIntelWorkerWaiters.shift();
-    waiter.signal?.removeEventListener("abort", waiter.onAbort);
-    if (waiter.timeout) clearTimeout(waiter.timeout);
-    if (waiter.signal?.aborted) continue;
-    activeCodeIntelWorkers++;
-    waiter.resolve();
-  }
-}
-function acquireWorkerSlot(deadline, signal) {
-  if (signal?.aborted) return Promise.reject(new Error("Operation aborted"));
-  if (Date.now() >= deadline) return Promise.reject(new Error(`TypeScript code intelligence queue wait exceeded ${WORKER_TIMEOUT_MS}ms`));
-  if (activeCodeIntelWorkers < MAX_ACTIVE_CODE_INTEL_WORKERS) {
-    activeCodeIntelWorkers++;
-    return Promise.resolve(releaseWorkerSlot);
-  }
-  if (codeIntelWorkerWaiters.length >= MAX_QUEUED_CODE_INTEL_WORKERS) {
-    return Promise.reject(new Error("TypeScript code intelligence queue is full"));
-  }
-  return new Promise((resolve2, reject) => {
-    const waiter = { resolve: () => resolve2(releaseWorkerSlot), reject, signal };
-    waiter.onAbort = () => {
-      const index = codeIntelWorkerWaiters.indexOf(waiter);
-      if (index >= 0) codeIntelWorkerWaiters.splice(index, 1);
-      if (waiter.timeout) clearTimeout(waiter.timeout);
-      reject(new Error("Operation aborted"));
-    };
-    waiter.timeout = setTimeout(() => {
-      const index = codeIntelWorkerWaiters.indexOf(waiter);
-      if (index >= 0) codeIntelWorkerWaiters.splice(index, 1);
-      signal?.removeEventListener("abort", waiter.onAbort);
-      reject(new Error(`TypeScript code intelligence queue wait exceeded ${WORKER_TIMEOUT_MS}ms`));
-    }, Math.max(1, deadline - Date.now()));
-    waiter.timeout.unref?.();
-    signal?.addEventListener("abort", waiter.onAbort, { once: true });
-    codeIntelWorkerWaiters.push(waiter);
-  });
-}
-function resolveWorkerPath() {
-  const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    path.join(moduleDirectory, "code-intel-worker.cjs"),
-    path.join(moduleDirectory, "..", "code-intel-worker.cjs"),
-    path.join(moduleDirectory, "..", "..", "dist", "code-intel-worker.cjs")
-  ];
-  const workerPath = candidates.find((candidate) => fs.existsSync(candidate));
-  if (!workerPath) throw new Error("compiled code-intel worker is unavailable; rebuild the CLI");
-  return workerPath;
-}
-function runWorker(request, timeoutMs, signal) {
-  return new Promise((resolve2, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("Operation aborted"));
-      return;
-    }
-    const worker = new Worker(pathToFileURL(resolveWorkerPath()), {
-      workerData: request,
-      execArgv: [],
-      resourceLimits: { maxOldGenerationSizeMb: 128, maxYoungGenerationSizeMb: 32, stackSizeMb: 4 }
-    });
-    let finishing = false;
-    let exited = false;
-    const finish = (error, result) => {
-      if (finishing) return;
-      finishing = true;
-      clearTimeout(timeout);
-      signal?.removeEventListener("abort", onAbort);
-      void (async () => {
-        if (!exited) {
-          try {
-            await worker.terminate();
-          } catch {
-          }
-        }
-        if (error) reject(error);
-        else resolve2(result);
-      })();
-    };
-    const onAbort = () => finish(new Error("Operation aborted"));
-    const timeout = setTimeout(() => finish(new Error(`TypeScript code intelligence worker timed out after ${WORKER_TIMEOUT_MS}ms`)), Math.max(1, timeoutMs));
-    timeout.unref?.();
-    signal?.addEventListener("abort", onAbort, { once: true });
-    worker.once("message", (message) => {
-      if (!message || typeof message !== "object" || typeof message.ok !== "boolean") {
-        finish(new Error("code-intel worker returned an invalid response"));
-        return;
-      }
-      if ("error" in message) finish(new Error(message.error));
-      else finish(void 0, message.result);
-    });
-    worker.once("error", (error) => finish(error));
-    worker.once("exit", (code) => {
-      exited = true;
-      if (!finishing) finish(new Error(`code-intel worker exited before responding (${code})`));
-    });
-  });
-}
-async function runWorkerBounded(request, signal) {
-  const deadline = Date.now() + WORKER_TIMEOUT_MS;
-  const release = await acquireWorkerSlot(deadline, signal);
-  try {
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) throw new Error(`TypeScript code intelligence exceeded ${WORKER_TIMEOUT_MS}ms including queue wait`);
-    return await runWorker(request, remaining, signal);
-  } finally {
-    release();
-  }
-}
-function createTypeScriptCodeIntelProvider() {
-  return {
-    async run(input, context) {
-      const filePath = context.resolvePath(input.path);
-      if (filePath && !context.isPathAllowed(filePath)) throw new Error(`Path escapes the project root: ${input.path}`);
-      return await runWorkerBounded({ input, projectRoot: context.projectRoot, filePath }, context.signal);
-    }
-  };
-}
-function codeIntelErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function shouldFallbackFromTypeScriptProvider(error) {
-  const message = codeIntelErrorMessage(error);
-  if (/aborted/i.test(message)) return false;
-  if (/outside project root|escapes the project root|path escapes/i.test(message)) return false;
-  if (/\bEACCES\b|\bEPERM\b|permission denied/i.test(message)) return false;
-  if (/queue is full|queue wait exceeded/i.test(message)) return false;
-  return /worker|memory limit|compiled code-intel worker/i.test(message);
-}
-function createFallbackCodeIntelProvider(primary, fallback = createLightweightCodeIntelProvider()) {
-  return {
-    async run(input, context) {
-      try {
-        return await primary.run(input, context);
-      } catch (error) {
-        const fallbackReason = codeIntelErrorMessage(error);
-        if (!shouldFallbackFromTypeScriptProvider(error)) throw error;
-        const result = await fallback.run(input, context);
-        return {
-          ...result,
-          text: `${result.text}
-
-[code_intel used lightweight fallback: ${fallbackReason}]`,
-          details: {
-            ...result.details,
-            provider: "lightweight_fallback",
-            fallbackReason
-          },
-          isError: result.isError
-        };
-      }
-    }
-  };
-}
-function createCodeIntelTool2(options) {
-  return createCodeIntelTool({
-    ...options,
-    provider: options.provider ?? createFallbackCodeIntelProvider(createTypeScriptCodeIntelProvider())
-  });
-}
-
 // src/capabilities/rendered-page-reader.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createRequire } from "node:module";
-import * as fs2 from "node:fs";
+import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path from "node:path";
 var require2 = createRequire(import.meta.url);
 function resolveAxiCli() {
-  const runtime = path2.join(getBuiltinDir(), "skills", "chrome-devtools-axi", "chrome-devtools-axi-runtime.js");
-  if (!fs2.existsSync(runtime)) throw new Error("Pie's packaged browser runtime is missing. Rebuild or reinstall Pie.");
+  const runtime = path.join(getBuiltinDir(), "skills", "chrome-devtools-axi", "chrome-devtools-axi-runtime.js");
+  if (!fs.existsSync(runtime)) throw new Error("Pie's packaged browser runtime is missing. Rebuild or reinstall Pie.");
   return runtime;
 }
 function resolveMcpScript() {
   const packageJson = require2.resolve("chrome-devtools-mcp/package.json");
-  return path2.join(path2.dirname(packageJson), "build", "src", "bin", "chrome-devtools-mcp.js");
+  return path.join(path.dirname(packageJson), "build", "src", "bin", "chrome-devtools-mcp.js");
 }
 function runAxi(args, options = {}) {
   const timeoutMs = options.timeoutMs ?? 6e4;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn2(process.execPath, [resolveAxiCli(), ...args], {
       stdio: ["ignore", "pipe", "pipe"],
       shell: false,
@@ -1100,7 +1097,7 @@ function runAxi(args, options = {}) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (code === 0) resolve2(stdout.trim());
+      if (code === 0) resolve3(stdout.trim());
       else reject(new Error((stderr || stdout || `chrome-devtools-axi exited with ${code}`).trim()));
     });
   });
@@ -1155,11 +1152,11 @@ function cleanStaleScreenshotDirs(retentionMs = 60 * 60 * 1e3) {
   try {
     const tmp = os.tmpdir();
     const cutoff = Date.now() - retentionMs;
-    for (const entry of fs2.readdirSync(tmp)) {
+    for (const entry of fs.readdirSync(tmp)) {
       if (!entry.startsWith("pie-axi-shot-")) continue;
-      const dir = path2.join(tmp, entry);
+      const dir = path.join(tmp, entry);
       try {
-        if (fs2.statSync(dir).mtimeMs < cutoff) fs2.rmSync(dir, { recursive: true, force: true });
+        if (fs.statSync(dir).mtimeMs < cutoff) fs.rmSync(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -1174,7 +1171,7 @@ function createCliRenderedPageReader() {
     if (!env.CHROME_DEVTOOLS_AXI_MCP_PATH?.trim()) env.CHROME_DEVTOOLS_AXI_MCP_PATH = resolveMcpScript();
     if (!env.CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS) env.CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS = "1";
     cleanStaleScreenshotDirs();
-    const screenshotDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "pie-axi-shot-"));
+    const screenshotDir = fs.mkdtempSync(path.join(os.tmpdir(), "pie-axi-shot-"));
     try {
       await runAxi(["open", `data:text/html,<title>pie-warm-${session}</title>`], { env });
       await runAxi(["open", url], { env });
@@ -1183,7 +1180,7 @@ function createCliRenderedPageReader() {
         // --full: eval output is truncated at ~8KB by default, which would
         // break JSON parsing and drop title/finalUrl/text on real pages.
         runAxi(["eval", "() => JSON.stringify({ title: document.title, href: location.href, text: document.body ? document.body.innerText : '' })", "--full"], { env }),
-        runAxi(["screenshot", path2.join(screenshotDir, "page.png")], { env }).catch((error) => `screenshot_failed: ${error instanceof Error ? error.message : String(error)}`),
+        runAxi(["screenshot", path.join(screenshotDir, "page.png")], { env }).catch((error) => `screenshot_failed: ${error instanceof Error ? error.message : String(error)}`),
         runAxi(["console"], { env }).catch((error) => `console_failed: ${error instanceof Error ? error.message : String(error)}`),
         runAxi(["network"], { env }).catch((error) => `network_failed: ${error instanceof Error ? error.message : String(error)}`)
       ]);
@@ -1214,8 +1211,8 @@ function createCliRenderedPageReader() {
 }
 
 // src/capabilities/web-research-health.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -1237,11 +1234,11 @@ function parseHealthEntry(value) {
   };
 }
 function createCliWebResearchHealthStore(configDir) {
-  const filePath = path3.join(configDir, "web-research-health.json");
+  const filePath = path2.join(configDir, "web-research-health.json");
   return {
     loadProviderHealth: () => {
       try {
-        const parsed = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+        const parsed = JSON.parse(fs2.readFileSync(filePath, "utf8"));
         if (!Array.isArray(parsed)) return [];
         return parsed.map(parseHealthEntry).filter((entry) => !!entry);
       } catch {
@@ -1250,8 +1247,8 @@ function createCliWebResearchHealthStore(configDir) {
     },
     saveProviderHealth: (entries) => {
       try {
-        fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
-        fs3.writeFileSync(filePath, JSON.stringify(entries, null, 2));
+        fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+        fs2.writeFileSync(filePath, JSON.stringify(entries, null, 2));
       } catch {
       }
     }
@@ -1260,7 +1257,7 @@ function createCliWebResearchHealthStore(configDir) {
 
 // src/capabilities/index.ts
 function createCliHostCapabilities(cwd, options = {}) {
-  const bashTool = createBashTool(cwd);
+  const bashTool = createBashTool(cwd, options.getBashEnv ? { getEnv: options.getBashEnv } : void 0);
   const healthStore = createCliWebResearchHealthStore(options.configDir ?? getConfigDir());
   const webSearchTool = createSharedWebSearchTool({
     getModel: options.getModel ?? (() => void 0),
@@ -1292,7 +1289,6 @@ function createCliHostCapabilities(cwd, options = {}) {
     loadProviderHealth: healthStore.loadProviderHealth,
     saveProviderHealth: healthStore.saveProviderHealth
   });
-  const codeIntelTool = createCodeIntelTool2({ projectRoot: cwd });
   const capabilities = [
     {
       id: "bash",
@@ -1303,11 +1299,6 @@ function createCliHostCapabilities(cwd, options = {}) {
       id: "web_research",
       description: "Canonical web tool for research, direct URL fetch, and low-level search modes.",
       tools: [webResearchTool]
-    },
-    {
-      id: "code_intel",
-      description: "Read-only JS/TS code intelligence for diagnostics, definitions, references, symbols, and hover.",
-      tools: [codeIntelTool]
     }
   ];
   return {
@@ -1317,10 +1308,27 @@ function createCliHostCapabilities(cwd, options = {}) {
 }
 
 export {
+  getPackageDir,
+  getThemesDir,
+  getBuiltinDir,
+  VERSION,
+  getConfigDir,
+  getAgentDir,
+  getCustomThemesDir,
+  getSettingsPath,
+  getProjectSettingsPath,
+  getSessionsDir,
+  getLogsDir,
+  getRuntimeLogPath,
+  migrateConfigFromAgentDir,
   createCliWebResearchHealthStore,
   truncateHeadTail,
   formatSize,
   cleanupBashOutputArtifacts,
   createBashTool,
+  formatTransportLifecycle,
+  createTransportDiagnosticsStreamFn,
+  logTransportLifecycle,
+  createTraceTransportSink,
   createCliHostCapabilities
 };