@cydm/pie 1.0.7 → 1.0.9

package/dist/cli.js

@@ -1,17 +1,29 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
-  createCliHostCapabilities
-} from "./chunks/chunk-GDTN4UPJ.js";
+  createCliHostCapabilities,
+  createCliWebResearchHealthStore,
+  getAgentDir,
+  getBuiltinDir,
+  getConfigDir,
+  getCustomThemesDir,
+  getLogsDir,
+  getPackageDir,
+  getRuntimeLogPath,
+  getSessionsDir,
+  getSettingsPath,
+  getThemesDir,
+  migrateConfigFromAgentDir
+} from "./chunks/chunk-XHZP5EK4.js";
 import {
+  AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
   BUILTIN_TOOL_CAPABILITY_METADATA,
   SessionTraceSnapshotWriter,
   abortExecutionState,
   attachAgentEventsToSessionTrace,
   buildExecutionReminder,
-  buildKnowledgeIndexEntry,
-  buildKnowledgeIndexSection,
+  buildProjectContextSection,
   buildToolsPromptSection,
   calculateTotalTokens,
   continueExecutionState,
@@ -21,11 +33,9 @@ import {
   createExecutionStateStore,
   createPolicyEnforcedTools,
   createReadFileUnderstandingHandler,
-  createReadResourceCapability,
-  createReadSkillCapability,
-  createResolveResourceCapability,
   createSessionManager,
   createSharedFileSystemTools,
+  createSharedWebSearchTool,
   createTodoWidgetView,
   evaluateTodoClosureAfterAbort,
   evaluateTodoClosureAfterCompletedTurn,
@@ -35,13 +45,14 @@ import {
   hasInteractionHandler,
   maybeAdvanceTodoExecutionState,
   modalityForReadFileUnderstandingKind,
+  pauseExecutionState,
   registerInteractionHandler,
   requestInteraction,
   restoreExecutionState,
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-BHNULR7U.js";
+} from "./chunks/chunk-EJGQAAKS.js";
 import {
   Deref,
   Errors,
@@ -76,6 +87,9 @@ import {
   sortToolModelCandidatesByCapability,
   type_exports
 } from "./chunks/chunk-A5JSJAPK.js";
+import {
+  resolveCliProjectRoot
+} from "./chunks/chunk-NTYHFBUA.js";
 import {
   __commonJS,
   __require,
@@ -1883,7 +1897,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join20(regexps, separator = "|") {
+    function join19(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex) => {
         numCaptures += 1;
@@ -2187,7 +2201,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join20(terminators), true);
+          this.matcherRe = langRe(join19(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -14049,7 +14063,7 @@ var require_http = __commonJS({
       return joined;
     }
     function http(hljs) {
-      const VERSION2 = "HTTP/(2|1\\.[01])";
+      const VERSION = "HTTP/(2|1\\.[01])";
       const HEADER_NAME = /[A-Za-z][A-Za-z0-9-]*/;
       const HEADER = {
         className: "attribute",
@@ -14082,12 +14096,12 @@ var require_http = __commonJS({
         contains: [
           // response
           {
-            begin: "^(?=" + VERSION2 + " \\d{3})",
+            begin: "^(?=" + VERSION + " \\d{3})",
             end: /$/,
             contains: [
               {
                 className: "meta",
-                begin: VERSION2
+                begin: VERSION
               },
               {
                 className: "number",
@@ -14102,7 +14116,7 @@ var require_http = __commonJS({
           },
           // request
           {
-            begin: "(?=^[A-Z]+ (.*?) " + VERSION2 + "$)",
+            begin: "(?=^[A-Z]+ (.*?) " + VERSION + "$)",
             end: /$/,
             contains: [
               {
@@ -14114,7 +14128,7 @@ var require_http = __commonJS({
               },
               {
                 className: "meta",
-                begin: VERSION2
+                begin: VERSION
               },
               {
                 className: "keyword",
@@ -50554,7 +50568,7 @@ var ProcessTerminal = class {
         const timeLeft = endTime - now;
         if (timeLeft <= 0) break;
         if (now - lastDataTime >= idleMs) break;
-        await new Promise((resolve6) => setTimeout(resolve6, Math.min(idleMs, timeLeft)));
+        await new Promise((resolve4) => setTimeout(resolve4, Math.min(idleMs, timeLeft)));
       }
     } finally {
       process.stdin.removeListener("data", onData);
@@ -50629,120 +50643,8 @@ var ProcessTerminal = class {
 };
 
 // src/keybindings.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
-
-// src/config.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync, renameSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
-var isBunRuntime = !!process.versions.bun;
-function getPackageDir() {
-  const envDir = process.env.PIE_PACKAGE_DIR;
-  if (envDir) {
-    if (envDir === "~") return homedir2();
-    if (envDir.startsWith("~/")) return homedir2() + envDir.slice(1);
-    return envDir;
-  }
-  let dir = __dirname;
-  while (dir !== dirname2(dir)) {
-    if (existsSync(join2(dir, "package.json"))) {
-      return dir;
-    }
-    dir = dirname2(dir);
-  }
-  return __dirname;
-}
-function getThemesDir() {
-  const packageDir = getPackageDir();
-  const srcOrDist = existsSync(join2(packageDir, "src")) ? "src" : "dist";
-  return join2(packageDir, srcOrDist, "theme");
-}
-function getBuiltinDir() {
-  const packageDir = getPackageDir();
-  const distBuiltinDir = join2(packageDir, "dist", "builtin");
-  if (existsSync(distBuiltinDir)) {
-    return distBuiltinDir;
-  }
-  return join2(packageDir, "builtin");
-}
-function getPackageJsonPath() {
-  return join2(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 homedir2();
-    if (envDir.startsWith("~/")) return homedir2() + envDir.slice(1);
-    return envDir;
-  }
-  return join2(homedir2(), CONFIG_DIR_NAME);
-}
-function getAgentDir() {
-  return getConfigDir();
-}
-function getCustomThemesDir() {
-  return join2(getConfigDir(), "themes");
-}
-function getSettingsPath() {
-  return join2(getConfigDir(), "settings.json");
-}
-function getSessionsDir() {
-  return join2(getConfigDir(), "sessions");
-}
-function getLogsDir() {
-  return join2(getConfigDir(), "logs");
-}
-function getRuntimeLogPath() {
-  return join2(getLogsDir(), "pie-cli.log");
-}
-function migrateConfigFromAgentDir() {
-  const oldAgentDir = join2(homedir2(), CONFIG_DIR_NAME, "agent");
-  const newConfigDir = getConfigDir();
-  if (!existsSync(oldAgentDir)) {
-    return;
-  }
-  if (!existsSync(newConfigDir)) {
-    mkdirSync2(newConfigDir, { recursive: true });
-  }
-  const filesToMigrate = [
-    "keybindings.json",
-    "settings.json",
-    "pie-debug.log"
-  ];
-  for (const file of filesToMigrate) {
-    const oldPath = join2(oldAgentDir, file);
-    const newPath = file === "pie-debug.log" ? getRuntimeLogPath() : join2(newConfigDir, file);
-    if (existsSync(oldPath) && !existsSync(newPath)) {
-      try {
-        if (file === "pie-debug.log") {
-          mkdirSync2(getLogsDir(), { recursive: true });
-        }
-        renameSync(oldPath, newPath);
-        console.log(`[Config] Migrated ${file} to ${newPath}`);
-      } catch (e) {
-      }
-    }
-  }
-  const oldThemesDir = join2(oldAgentDir, "themes");
-  const newThemesDir = getCustomThemesDir();
-  if (existsSync(oldThemesDir) && !existsSync(newThemesDir)) {
-    try {
-      renameSync(oldThemesDir, newThemesDir);
-      console.log(`[Config] Migrated themes to ${newThemesDir}`);
-    } catch (e) {
-    }
-  }
-}
-
-// src/keybindings.ts
+import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
 var DEFAULT_APP_KEYBINDINGS = {
   interrupt: "escape",
   clear: "ctrl+c",
@@ -50804,7 +50706,7 @@ var KeybindingsManager = class _KeybindingsManager {
    * Create from config file and set up editor keybindings.
    */
   static create(agentDir = getAgentDir()) {
-    const configPath = join3(agentDir, "keybindings.json");
+    const configPath = join2(agentDir, "keybindings.json");
     const config = _KeybindingsManager.loadFromFile(configPath);
     const manager = new _KeybindingsManager(config);
     const editorConfig = {};
@@ -50823,9 +50725,9 @@ var KeybindingsManager = class _KeybindingsManager {
     return new _KeybindingsManager(config);
   }
   static loadFromFile(path26) {
-    if (!existsSync2(path26)) return {};
+    if (!existsSync(path26)) return {};
     try {
-      return JSON.parse(readFileSync2(path26, "utf-8"));
+      return JSON.parse(readFileSync(path26, "utf-8"));
     } catch {
       return {};
     }
@@ -50876,21 +50778,70 @@ var KeybindingsManager = class _KeybindingsManager {
 // src/project-knowledge.ts
 import fs3 from "node:fs";
 import path2 from "node:path";
-function buildCliKnowledgeIndexSection(cwd) {
-  const agentsPath = path2.join(cwd, ".pie", "agents.md");
-  if (!fs3.existsSync(agentsPath)) return "";
-  try {
-    const content = fs3.readFileSync(agentsPath, "utf-8");
-    const entry = buildKnowledgeIndexEntry(".pie/agents.md", content);
-    return buildKnowledgeIndexSection(entry ? [entry] : []);
-  } catch {
-    return "";
+function collectAncestorAgentsFiles(cwd) {
+  const resolvedCwd = path2.resolve(cwd || process.cwd());
+  const projectRoot = resolveCliProjectRoot(resolvedCwd);
+  const candidates = [];
+  let current = resolvedCwd;
+  while (true) {
+    candidates.unshift(path2.join(current, AGENTS_CONTEXT_FILE_NAME));
+    if (current === projectRoot) {
+      break;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const files = [];
+  for (const candidate of candidates) {
+    if (!fs3.existsSync(candidate)) {
+      continue;
+    }
+    try {
+      files.push({
+        path: path2.relative(resolvedCwd, candidate) || AGENTS_CONTEXT_FILE_NAME,
+        content: fs3.readFileSync(candidate, "utf-8")
+      });
+    } catch {
+    }
+  }
+  return files;
+}
+function buildCliProjectContextSection(cwd) {
+  return buildProjectContextSection(collectAncestorAgentsFiles(cwd));
+}
+
+// src/file-access-context.ts
+import * as path3 from "node:path";
+function uniqueNormalizedPaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of paths) {
+    const trimmed = String(entry || "").trim();
+    if (!trimmed) continue;
+    const normalized = path3.normalize(trimmed);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
   }
+  return result;
+}
+function buildCliFileAccessOptions(params) {
+  return {
+    accessRoots: uniqueNormalizedPaths([
+      resolveCliProjectRoot(params.cwd),
+      params.configDir,
+      ...params.skills.map((skill) => skill.baseDir)
+    ]),
+    allowlistedDirs: params.allowlistedDirs
+  };
 }
 
 // src/theme/theme.ts
 import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // ../../node_modules/@sinclair/typebox/build/esm/compiler/compiler.mjs
 var TypeCheck = class {
@@ -51777,8 +51728,8 @@ var BUILTIN_THEMES;
 function getBuiltinThemes() {
   if (!BUILTIN_THEMES) {
     const themesDir = getThemesDir();
-    const darkPath = path3.join(themesDir, "dark.json");
-    const lightPath = path3.join(themesDir, "light.json");
+    const darkPath = path4.join(themesDir, "dark.json");
+    const lightPath = path4.join(themesDir, "light.json");
     BUILTIN_THEMES = {
       dark: JSON.parse(fs4.readFileSync(darkPath, "utf-8")),
       light: JSON.parse(fs4.readFileSync(lightPath, "utf-8"))
@@ -51858,7 +51809,7 @@ function loadThemeJson(name) {
     throw new Error(`Theme "${name}" does not have a source path for export`);
   }
   const customThemesDir = getCustomThemesDir();
-  const themePath = path3.join(customThemesDir, `${name}.json`);
+  const themePath = path4.join(customThemesDir, `${name}.json`);
   if (!fs4.existsSync(themePath)) {
     throw new Error(`Theme not found: ${name}`);
   }
@@ -51975,7 +51926,7 @@ function startThemeWatcher() {
     return;
   }
   const customThemesDir = getCustomThemesDir();
-  const themeFile = path3.join(customThemesDir, `${currentThemeName}.json`);
+  const themeFile = path4.join(customThemesDir, `${currentThemeName}.json`);
   if (!fs4.existsSync(themeFile)) {
     return;
   }
@@ -52165,36 +52116,7 @@ function getEditorTheme() {
 
 // src/skills/loader.ts
 import * as fs5 from "fs";
-import * as path4 from "path";
-function inferResourceKind(resourcePath) {
-  const lower = resourcePath.toLowerCase();
-  if (lower.endsWith(".md")) return "document";
-  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".sh") || lower.endsWith(".py")) return "script";
-  return void 0;
-}
-function extractResourceRefs(content) {
-  const refs = /* @__PURE__ */ new Map();
-  const patterns = [
-    /`((?:references|scripts|assets|examples)\/[^`\n]+)`/g,
-    /\b((?:references|scripts|assets|examples)\/[A-Za-z0-9._/-]+)/g,
-    /`(\.?\/[A-Za-z0-9._/-]+\.[A-Za-z0-9]+)`/g
-  ];
-  for (const pattern of patterns) {
-    for (const match of content.matchAll(pattern)) {
-      const rawPath = String(match[1] || "").trim().replace(/\\/g, "/");
-      if (!rawPath) continue;
-      const normalizedPath = rawPath.replace(/^\.\/+/, "");
-      if (!normalizedPath || normalizedPath.startsWith("/") || normalizedPath.includes("..")) continue;
-      if (!refs.has(normalizedPath)) {
-        refs.set(normalizedPath, {
-          path: normalizedPath,
-          kind: inferResourceKind(normalizedPath)
-        });
-      }
-    }
-  }
-  return Array.from(refs.values());
-}
+import * as path5 from "path";
 function parseSkillDescription(content) {
   const frontmatterMatch = content.match(/^---\n[\s\S]*?description:\s*["']?(.+?)["']?(?:\n|$)/m);
   if (frontmatterMatch) return frontmatterMatch[1].trim();
@@ -52218,9 +52140,9 @@ function loadSkillsFromDir(dir, source) {
   const entries = fs5.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path5.join(dir, entry.name);
     if (entry.isDirectory()) {
-      const skillMdPath = path4.join(fullPath, "SKILL.md");
+      const skillMdPath = path5.join(fullPath, "SKILL.md");
       if (fs5.existsSync(skillMdPath)) {
         try {
           const content = fs5.readFileSync(skillMdPath, "utf-8");
@@ -52231,8 +52153,7 @@ function loadSkillsFromDir(dir, source) {
             content,
             filePath: skillMdPath,
             source,
-            baseDir: fullPath,
-            resourceRefs: extractResourceRefs(content)
+            baseDir: fullPath
           });
         } catch (e) {
           diagnostics.push({
@@ -52253,8 +52174,7 @@ function loadSkillsFromDir(dir, source) {
           content,
           filePath: fullPath,
           source,
-          baseDir: dir,
-          resourceRefs: extractResourceRefs(content)
+          baseDir: dir
         });
       } catch (e) {
         diagnostics.push({
@@ -52441,84 +52361,8 @@ function validateSkillName(name) {
   return { valid: true };
 }
 
-// src/skills/runtime.ts
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
-function resolveSkill(skills, name) {
-  return skills.find((entry) => entry.name === name) ?? null;
-}
-function resolveSkillResource(skill, resourcePath) {
-  const trimmed = String(resourcePath || "").trim().replace(/\\/g, "/");
-  if (!trimmed || trimmed.startsWith("/") || /^[A-Za-z]:\//.test(trimmed)) {
-    return null;
-  }
-  const segments = trimmed.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === "..")) {
-    return null;
-  }
-  const absolutePath = path5.resolve(skill.baseDir, ...segments);
-  const relativePath = path5.relative(skill.baseDir, absolutePath).replace(/\\/g, "/");
-  if (relativePath.startsWith("../") || relativePath === "..") {
-    return null;
-  }
-  return absolutePath;
-}
-function createCliReadSkillTool(skills) {
-  return createReadSkillCapability({
-    resolveSkill(name) {
-      const skill = resolveSkill(skills, name);
-      if (!skill) {
-        return null;
-      }
-      return {
-        name: skill.name,
-        content: skill.content,
-        resources: skill.resourceRefs
-      };
-    }
-  }).tool;
-}
-function createCliReadResourceTool(skills) {
-  return createReadResourceCapability({
-    resolveResource(owner, resourcePath) {
-      const skill = resolveSkill(skills, owner);
-      if (!skill) {
-        return null;
-      }
-      const absolutePath = resolveSkillResource(skill, resourcePath);
-      if (!absolutePath || !fs6.existsSync(absolutePath) || !fs6.statSync(absolutePath).isFile()) {
-        return null;
-      }
-      return {
-        owner: skill.name,
-        path: resourcePath.replace(/\\/g, "/").replace(/^\.\/+/, ""),
-        content: fs6.readFileSync(absolutePath, "utf8")
-      };
-    }
-  }).tool;
-}
-function createCliResolveResourceTool(skills) {
-  return createResolveResourceCapability({
-    resolveResource(owner, resourcePath) {
-      const skill = resolveSkill(skills, owner);
-      if (!skill) {
-        return null;
-      }
-      const absolutePath = resolveSkillResource(skill, resourcePath);
-      if (!absolutePath || !fs6.existsSync(absolutePath) || !fs6.statSync(absolutePath).isFile()) {
-        return null;
-      }
-      return {
-        owner: skill.name,
-        path: resourcePath.replace(/\\/g, "/").replace(/^\.\/+/, ""),
-        resolvedPath: absolutePath
-      };
-    }
-  }).tool;
-}
-
 // src/debug/file-logger.ts
-import * as fs7 from "fs";
+import * as fs6 from "fs";
 import * as path6 from "path";
 var FileLogger = class {
   config = {
@@ -52560,8 +52404,8 @@ var FileLogger = class {
       this.config.filePath = filePath;
     }
     const dir = path6.dirname(this.config.filePath);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
     this.log("file-logger", `File logging enabled: ${this.config.filePath}`);
   }
@@ -52599,8 +52443,8 @@ var FileLogger = class {
     this.buffer = [];
     this.bufferIndex = 0;
     this.totalLines = 0;
-    if (fs7.existsSync(this.config.filePath)) {
-      fs7.writeFileSync(this.config.filePath, "");
+    if (fs6.existsSync(this.config.filePath)) {
+      fs6.writeFileSync(this.config.filePath, "");
     }
   }
   /**
@@ -52641,8 +52485,8 @@ var FileLogger = class {
    */
   getStats() {
     let size = 0;
-    if (fs7.existsSync(this.config.filePath)) {
-      const stats = fs7.statSync(this.config.filePath);
+    if (fs6.existsSync(this.config.filePath)) {
+      const stats = fs6.statSync(this.config.filePath);
       size = stats.size;
     }
     return {
@@ -52656,11 +52500,11 @@ var FileLogger = class {
    * Read last N lines from file (fallback when buffer is not enough)
    */
   readLastLines(count) {
-    if (!fs7.existsSync(this.config.filePath)) {
+    if (!fs6.existsSync(this.config.filePath)) {
       return [];
     }
     try {
-      const content = fs7.readFileSync(this.config.filePath, "utf-8");
+      const content = fs6.readFileSync(this.config.filePath, "utf-8");
       const lines = content.split("\n").filter(Boolean);
       return lines.slice(-count);
     } catch {
@@ -52678,10 +52522,10 @@ var FileLogger = class {
     const entry = this.formatEntry(level, module, message, data);
     try {
       const dir = path6.dirname(this.config.filePath);
-      if (!fs7.existsSync(dir)) {
-        fs7.mkdirSync(dir, { recursive: true });
+      if (!fs6.existsSync(dir)) {
+        fs6.mkdirSync(dir, { recursive: true });
       }
-      fs7.appendFileSync(this.config.filePath, entry + "\n");
+      fs6.appendFileSync(this.config.filePath, entry + "\n");
     } catch {
       return;
     }
@@ -52770,7 +52614,7 @@ function flushEarlyLogs() {
 
 // src/capabilities/read-file-understanding.ts
 import * as path15 from "node:path";
-import * as fs15 from "node:fs/promises";
+import * as fs14 from "node:fs/promises";
 
 // src/core/provider-capabilities.ts
 var PLATFORM_DISPLAY_NAMES = {
@@ -52796,7 +52640,7 @@ function getProviderDisplayName(platform2) {
 }
 
 // src/files/adapters/kimi-adapter.ts
-import * as fs8 from "node:fs";
+import * as fs7 from "node:fs";
 import * as path7 from "node:path";
 
 // src/files/errors.ts
@@ -52937,14 +52781,14 @@ var KimiFileAdapter = class {
     const fileName = options.sourceName || path7.basename(filePath);
     const mimeType = options.mimeType || this.guessMimeType(fileName);
     const purpose = this.detectPurpose(filePath, options.purpose, mimeType);
-    const stats = fs8.statSync(filePath);
+    const stats = fs7.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
         `File size ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds Kimi limit of 100MB`
       );
     }
-    const fileBuffer = fs8.readFileSync(filePath);
+    const fileBuffer = fs7.readFileSync(filePath);
     const file = new File([fileBuffer], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
@@ -53158,7 +53002,7 @@ var KimiFileAdapter = class {
 };
 
 // src/files/adapters/gemini-adapter.ts
-import * as fs9 from "node:fs";
+import * as fs8 from "node:fs";
 import * as path8 from "node:path";
 import { Readable } from "node:stream";
 var GeminiFileAdapter = class {
@@ -53216,7 +53060,7 @@ var GeminiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const stats = fs9.statSync(filePath);
+    const stats = fs8.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
@@ -53255,7 +53099,7 @@ var GeminiFileAdapter = class {
         "No upload URL received"
       );
     }
-    const fileStream = Readable.toWeb(fs9.createReadStream(filePath));
+    const fileStream = Readable.toWeb(fs8.createReadStream(filePath));
     const uploadResponse = await fetch(uploadUrl, {
       method: "POST",
       headers: {
@@ -53459,7 +53303,7 @@ var GeminiFileAdapter = class {
 };
 
 // src/files/adapters/openai-compatible-files-adapter.ts
-import * as fs10 from "node:fs";
+import * as fs9 from "node:fs";
 import * as path9 from "node:path";
 var OpenAICompatibleFilesAdapter = class {
   constructor(apiKey, baseUrl, extraHeaders = {}) {
@@ -53488,14 +53332,14 @@ var OpenAICompatibleFilesAdapter = class {
   async upload(filePath, options = {}) {
     const fileName = options.sourceName || path9.basename(filePath);
     const mimeType = options.mimeType || guessMimeType(fileName);
-    const stats = fs10.statSync(filePath);
+    const stats = fs9.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
         `File size ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds OpenAI-compatible Files limit of ${this.capabilities.maxFileSize / 1024 / 1024}MB`
       );
     }
-    const file = new File([fs10.readFileSync(filePath)], fileName, { type: mimeType });
+    const file = new File([fs9.readFileSync(filePath)], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
     formData.append("purpose", options.purpose && options.purpose !== "auto" ? options.purpose : "file-extract");
@@ -53628,12 +53472,12 @@ function guessMimeType(filename) {
 }
 
 // src/files/file-manager.ts
-import * as fs14 from "node:fs";
+import * as fs13 from "node:fs";
 import * as path14 from "node:path";
 import * as crypto2 from "node:crypto";
 
 // src/files/file-cache.ts
-import * as fs11 from "node:fs";
+import * as fs10 from "node:fs";
 import * as path11 from "node:path";
 import * as crypto from "node:crypto";
 
@@ -53730,6 +53574,17 @@ var DEFAULT_PIC_OPTIONS = {
 
 // src/files/utils.ts
 import * as path10 from "node:path";
+import { homedir as homedir2 } from "node:os";
+var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[a-zA-Z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/;
+function isWindowsAbsolutePath(filePath) {
+  return WINDOWS_ABSOLUTE_PATH_RE.test(filePath);
+}
+function getHomeDirectory() {
+  return homedir2() || process.env.USERPROFILE || process.env.HOME || ".";
+}
+function looksLikeFilePath(inputPath) {
+  return inputPath.startsWith("/") || inputPath.startsWith("~") || inputPath.startsWith("./") || inputPath.startsWith("../") || inputPath.startsWith(".\\") || inputPath.startsWith("..\\") || isWindowsAbsolutePath(inputPath);
+}
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
@@ -53739,7 +53594,10 @@ function formatBytes(bytes) {
 }
 function resolvePath(inputPath) {
   if (inputPath.startsWith("~")) {
-    return path10.join(process.env.HOME || ".", inputPath.slice(1));
+    return path10.join(getHomeDirectory(), inputPath.slice(1));
+  }
+  if (isWindowsAbsolutePath(inputPath)) {
+    return inputPath;
   }
   if (!path10.isAbsolute(inputPath)) {
     return path10.resolve(process.cwd(), inputPath);
@@ -53780,22 +53638,22 @@ var FileCache = class _FileCache {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs11.existsSync(this.baseDir)) {
-      fs11.mkdirSync(this.baseDir, { recursive: true });
+    if (!fs10.existsSync(this.baseDir)) {
+      fs10.mkdirSync(this.baseDir, { recursive: true });
     }
-    if (!fs11.existsSync(this.dataDir)) {
-      fs11.mkdirSync(this.dataDir, { recursive: true });
+    if (!fs10.existsSync(this.dataDir)) {
+      fs10.mkdirSync(this.dataDir, { recursive: true });
     }
   }
   // ============================================================================
   // Index Management
   // ============================================================================
   loadIndex() {
-    if (!fs11.existsSync(this.indexPath)) {
+    if (!fs10.existsSync(this.indexPath)) {
       return { version: CACHE_VERSION, files: {}, pathHints: {} };
     }
     try {
-      const data = JSON.parse(fs11.readFileSync(this.indexPath, "utf-8"));
+      const data = JSON.parse(fs10.readFileSync(this.indexPath, "utf-8"));
       if (data.version !== CACHE_VERSION) {
         cacheLogger.warn(`Index version mismatch: ${data.version} vs ${CACHE_VERSION}`);
       }
@@ -53811,7 +53669,7 @@ var FileCache = class _FileCache {
   }
   saveIndex() {
     try {
-      fs11.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+      fs10.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
     } catch (err) {
       cacheLogger.error(" Failed to save index:", err);
       throw err;
@@ -53821,11 +53679,11 @@ var FileCache = class _FileCache {
   // Hash Computation
   // ============================================================================
   async computeHash(filePath) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve4, reject) => {
       const hash = crypto.createHash("sha256");
-      const stream = fs11.createReadStream(filePath);
+      const stream = fs10.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
-      stream.on("end", () => resolve6(hash.digest("hex")));
+      stream.on("end", () => resolve4(hash.digest("hex")));
       stream.on("error", reject);
     });
   }
@@ -53838,8 +53696,8 @@ var FileCache = class _FileCache {
   getStoragePath(hash) {
     const subdir = hash.slice(0, 2);
     const fullDir = path11.join(this.dataDir, subdir);
-    if (!fs11.existsSync(fullDir)) {
-      fs11.mkdirSync(fullDir, { recursive: true });
+    if (!fs10.existsSync(fullDir)) {
+      fs10.mkdirSync(fullDir, { recursive: true });
     }
     return path11.join(fullDir, hash);
   }
@@ -53851,11 +53709,11 @@ var FileCache = class _FileCache {
     const hash = await this.computeHash(sourcePath);
     const storagePath = this.getStoragePath(hash);
     this.rememberPathHint(sourcePath, hash, name);
-    if (fs11.existsSync(storagePath)) {
+    if (fs10.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs11.copyFileSync(sourcePath, storagePath);
-    const stat2 = fs11.statSync(storagePath);
+    fs10.copyFileSync(sourcePath, storagePath);
+    const stat2 = fs10.statSync(storagePath);
     this.index.files[hash] = {
       hash,
       name,
@@ -53872,10 +53730,10 @@ var FileCache = class _FileCache {
   async storeBuffer(data, name, mimeType) {
     const hash = this.computeHashSync(data);
     const storagePath = this.getStoragePath(hash);
-    if (fs11.existsSync(storagePath)) {
+    if (fs10.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs11.writeFileSync(storagePath, data);
+    fs10.writeFileSync(storagePath, data);
     this.index.files[hash] = {
       hash,
       name,
@@ -53947,7 +53805,7 @@ var FileCache = class _FileCache {
   getPathHint(filePath) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs11.statSync(resolvedPath);
+      const stat2 = fs10.statSync(resolvedPath);
       if (!stat2.isFile()) return void 0;
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
       const key = this.getPathHintKey(resolvedPath);
@@ -53977,7 +53835,7 @@ var FileCache = class _FileCache {
   rememberPathHint(filePath, hash, name) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs11.statSync(resolvedPath);
+      const stat2 = fs10.statSync(resolvedPath);
       if (!stat2.isFile()) return;
       const entry = this.index.files[hash];
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
@@ -54036,8 +53894,8 @@ var FileCache = class _FileCache {
     entry = entry || this.index.files[hash];
     if (!entry) return;
     const localPath = path11.join(this.dataDir, entry.localPath);
-    if (fs11.existsSync(localPath)) {
-      fs11.unlinkSync(localPath);
+    if (fs10.existsSync(localPath)) {
+      fs10.unlinkSync(localPath);
     }
     delete this.index.files[hash];
     if (this.index.pathHints) {
@@ -54052,8 +53910,8 @@ var FileCache = class _FileCache {
   clear() {
     for (const entry of Object.values(this.index.files)) {
       const localPath = path11.join(this.dataDir, entry.localPath);
-      if (fs11.existsSync(localPath)) {
-        fs11.unlinkSync(localPath);
+      if (fs10.existsSync(localPath)) {
+        fs10.unlinkSync(localPath);
       }
     }
     this.index = { version: CACHE_VERSION, files: {}, pathHints: {} };
@@ -54141,7 +53999,7 @@ var FileCache = class _FileCache {
   getResolvedHintPath(filePath) {
     const resolvedPath = resolvePath(filePath);
     try {
-      return fs11.realpathSync.native ? fs11.realpathSync.native(resolvedPath) : fs11.realpathSync(resolvedPath);
+      return fs10.realpathSync.native ? fs10.realpathSync.native(resolvedPath) : fs10.realpathSync(resolvedPath);
     } catch {
       return resolvedPath;
     }
@@ -54149,7 +54007,7 @@ var FileCache = class _FileCache {
 };
 
 // src/files/session-file-manager.ts
-import * as fs12 from "node:fs";
+import * as fs11 from "node:fs";
 import * as path12 from "node:path";
 var INITIAL_REFRESH_BACKOFF_MS = 6e4;
 var MAX_REFRESH_BACKOFF_MS = 60 * 60 * 1e3;
@@ -54174,15 +54032,15 @@ var SessionFileManager = class {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs12.existsSync(this.sessionsDir)) {
-      fs12.mkdirSync(this.sessionsDir, { recursive: true });
+    if (!fs11.existsSync(this.sessionsDir)) {
+      fs11.mkdirSync(this.sessionsDir, { recursive: true });
     }
   }
   // ============================================================================
   // State Management
   // ============================================================================
   loadState() {
-    if (!fs12.existsSync(this.statePath)) {
+    if (!fs11.existsSync(this.statePath)) {
       return {
         sessionId: this.sessionId,
         lastSyncedAt: 0,
@@ -54190,7 +54048,7 @@ var SessionFileManager = class {
       };
     }
     try {
-      return JSON.parse(fs12.readFileSync(this.statePath, "utf-8"));
+      return JSON.parse(fs11.readFileSync(this.statePath, "utf-8"));
     } catch (err) {
       sessionLogger.error(" Failed to load state:", err);
       return {
@@ -54203,12 +54061,12 @@ var SessionFileManager = class {
   saveState() {
     try {
       if (Object.keys(this.state.files).length === 0) {
-        if (fs12.existsSync(this.statePath)) {
-          fs12.unlinkSync(this.statePath);
+        if (fs11.existsSync(this.statePath)) {
+          fs11.unlinkSync(this.statePath);
         }
         return;
       }
-      fs12.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+      fs11.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
     } catch (err) {
       sessionLogger.error(" Failed to save state:", err);
     }
@@ -54354,7 +54212,7 @@ var SessionFileManager = class {
       return { success: false, coolingDown: true };
     }
     const localPath = this.fileCache.getLocalPath(entry.hash);
-    if (!localPath || !fs12.existsSync(localPath)) {
+    if (!localPath || !fs11.existsSync(localPath)) {
       sessionLogger.warn(`Local file not found for ${fileId}`);
       entry.status = "expired";
       entry.error = "Local file missing";
@@ -54505,15 +54363,15 @@ var SessionFileManager = class {
   // Static Utilities
   // ============================================================================
   static cleanupOldSessions(sessionsDir, maxAge = 30 * 24 * 60 * 60 * 1e3) {
-    if (!fs12.existsSync(sessionsDir)) return;
+    if (!fs11.existsSync(sessionsDir)) return;
     const now = Date.now();
-    const files = fs12.readdirSync(sessionsDir);
+    const files = fs11.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       const filePath = path12.join(sessionsDir, file);
-      const stat2 = fs12.statSync(filePath);
+      const stat2 = fs11.statSync(filePath);
       if (now - stat2.mtime.getTime() > maxAge) {
-        fs12.unlinkSync(filePath);
+        fs11.unlinkSync(filePath);
         sessionLogger.debug(`Cleaned up old session: ${file}`);
       }
     }
@@ -54521,7 +54379,7 @@ var SessionFileManager = class {
 };
 
 // src/files/ffmpeg-processor.ts
-import * as fs13 from "node:fs";
+import * as fs12 from "node:fs";
 import * as path13 from "node:path";
 import { spawn } from "node:child_process";
 var FFmpegProcessor = class {
@@ -54535,17 +54393,17 @@ var FFmpegProcessor = class {
   // Detection
   // ============================================================================
   async checkAvailability() {
-    return new Promise((resolve6) => {
+    return new Promise((resolve4) => {
       const proc = spawn(this.ffmpegPath, ["-version"]);
-      proc.on("error", () => resolve6(false));
-      proc.on("exit", (code) => resolve6(code === 0));
+      proc.on("error", () => resolve4(false));
+      proc.on("exit", (code) => resolve4(code === 0));
     });
   }
   // ============================================================================
   // Video Analysis
   // ============================================================================
   async analyzeVideo(videoPath) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve4, reject) => {
       const args = [
         "-v",
         "error",
@@ -54574,7 +54432,7 @@ var FFmpegProcessor = class {
         }
         try {
           const info = this.parseProbeOutput(stdout, videoPath);
-          resolve6(info);
+          resolve4(info);
         } catch (err) {
           reject(err);
         }
@@ -54657,7 +54515,7 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    const outputStat = fs13.statSync(outputPath);
+    const outputStat = fs12.statSync(outputPath);
     return {
       type: "video",
       output: outputPath,
@@ -54689,7 +54547,7 @@ var FFmpegProcessor = class {
   async extractKeyframes(inputPath, outputDir, info, opts, onProgress) {
     const interval = Math.floor(info.duration / opts.keyframeCount);
     const framesDir = path13.join(outputDir, `keyframes_${Date.now()}`);
-    fs13.mkdirSync(framesDir, { recursive: true });
+    fs12.mkdirSync(framesDir, { recursive: true });
     const outputPattern = path13.join(framesDir, "frame_%03d.jpg");
     const args = [
       "-i",
@@ -54708,10 +54566,10 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    let frames = fs13.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path13.join(framesDir, f));
+    let frames = fs12.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path13.join(framesDir, f));
     if (frames.length < opts.keyframeCount / 2) {
-      fs13.rmSync(framesDir, { recursive: true, force: true });
-      fs13.mkdirSync(framesDir, { recursive: true });
+      fs12.rmSync(framesDir, { recursive: true, force: true });
+      fs12.mkdirSync(framesDir, { recursive: true });
       const uniformArgs = [
         "-i",
         inputPath,
@@ -54727,10 +54585,10 @@ var FFmpegProcessor = class {
           onProgress?.(percent);
         }
       });
-      frames = fs13.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path13.join(framesDir, f));
+      frames = fs12.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path13.join(framesDir, f));
     }
     const totalOutputSize = frames.reduce(
-      (sum, f) => sum + fs13.statSync(f).size,
+      (sum, f) => sum + fs12.statSync(f).size,
       0
     );
     return {
@@ -54769,7 +54627,7 @@ var FFmpegProcessor = class {
   // FFmpeg Execution
   // ============================================================================
   runFFmpeg(args) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve4, reject) => {
       const proc = spawn(this.ffmpegPath, args);
       let stderr = "";
       proc.stderr.on("data", (data) => {
@@ -54784,7 +54642,7 @@ var FFmpegProcessor = class {
             )
           );
         } else {
-          resolve6();
+          resolve4();
         }
       });
       proc.on("error", (err) => {
@@ -54801,7 +54659,7 @@ var FFmpegProcessor = class {
   // Progress Monitoring (for future use)
   // ============================================================================
   async runWithProgress(args, onProgress) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve4, reject) => {
       const progressArgs = [
         ...args,
         "-progress",
@@ -54831,7 +54689,7 @@ var FFmpegProcessor = class {
             )
           );
         } else {
-          resolve6();
+          resolve4();
         }
       });
     });
@@ -54950,8 +54808,8 @@ var FileManager = class {
   directoryListingCache = /* @__PURE__ */ new Map();
   authFingerprint;
   ensureDirectories() {
-    if (!fs14.existsSync(this.tempDir)) {
-      fs14.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs13.existsSync(this.tempDir)) {
+      fs13.mkdirSync(this.tempDir, { recursive: true });
     }
   }
   // ============================================================================
@@ -54982,7 +54840,7 @@ var FileManager = class {
   async stageLocal(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
     const sourceName = options.sourceName || path14.basename(resolvedPath);
-    if (!fs14.existsSync(resolvedPath)) {
+    if (!fs13.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -54997,7 +54855,7 @@ var FileManager = class {
     this.fileCache.rememberPathHint(resolvedPath, hash, sourceName);
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     const entry = this.fileCache.getByHash(hash);
-    const size = entry?.size ?? fs14.statSync(resolvedPath).size;
+    const size = entry?.size ?? fs13.statSync(resolvedPath).size;
     return {
       success: true,
       hash,
@@ -55012,7 +54870,7 @@ var FileManager = class {
   async upload(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
     const sourceName = options.sourceName || path14.basename(resolvedPath);
-    if (!fs14.existsSync(resolvedPath)) {
+    if (!fs13.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -55093,7 +54951,7 @@ var FileManager = class {
   // ============================================================================
   async uploadPic(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
-    if (!fs14.existsSync(resolvedPath)) {
+    if (!fs13.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -55123,7 +54981,7 @@ var FileManager = class {
     this.fileCache.rememberPathHint(resolvedPath, result.hash, path14.basename(resolvedPath));
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     try {
-      fs14.unlinkSync(optimizedPath);
+      fs13.unlinkSync(optimizedPath);
     } catch {
     }
     return result;
@@ -55133,7 +54991,7 @@ var FileManager = class {
   // ============================================================================
   async uploadVideo(filePath, options = {}) {
     const resolvedPath = resolvePath(filePath);
-    if (!fs14.existsSync(resolvedPath)) {
+    if (!fs13.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -55527,13 +55385,13 @@ var FileManager = class {
   cleanupTempFiles(output) {
     try {
       if (typeof output === "string") {
-        if (fs14.existsSync(output)) {
-          fs14.unlinkSync(output);
+        if (fs13.existsSync(output)) {
+          fs13.unlinkSync(output);
         }
       } else {
         for (const file of output) {
-          if (fs14.existsSync(file)) {
-            fs14.unlinkSync(file);
+          if (fs13.existsSync(file)) {
+            fs13.unlinkSync(file);
           }
         }
       }
@@ -55565,7 +55423,7 @@ var FileManager = class {
         }];
       }
       const localPath = this.fileCache.getLocalPath(entry.hash);
-      if (localPath && fs14.existsSync(localPath)) {
+      if (localPath && fs13.existsSync(localPath)) {
         return [{
           fileId,
           name: cacheEntry.name,
@@ -55662,7 +55520,7 @@ var FileManager = class {
       directories: []
     };
     try {
-      const entries = fs14.readdirSync(resolvedDir, { withFileTypes: true });
+      const entries = fs13.readdirSync(resolvedDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.name || entry.name.startsWith(".")) {
           continue;
@@ -55676,7 +55534,7 @@ var FileManager = class {
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
           try {
-            const targetStat = fs14.statSync(fullPath);
+            const targetStat = fs13.statSync(fullPath);
             isDirectory = targetStat.isDirectory();
             isFile = targetStat.isFile();
           } catch {
@@ -55694,7 +55552,7 @@ var FileManager = class {
         if (!type) {
           continue;
         }
-        const stat2 = fs14.statSync(fullPath);
+        const stat2 = fs13.statSync(fullPath);
         listing.files.push({
           name: entry.name,
           path: fullPath,
@@ -55793,7 +55651,7 @@ function isInlineMediaRequest(request) {
   return request.kind === "image" || request.kind === "video";
 }
 async function prepareInlineMediaContent(params) {
-  const stat2 = await fs15.stat(params.request.absolutePath);
+  const stat2 = await fs14.stat(params.request.absolutePath);
   const limitMb = getCapabilityLimitMb(params.model, params.request.kind);
   const limitBytes = limitMb * 1024 * 1024;
   if (stat2.size > limitBytes) {
@@ -55801,7 +55659,7 @@ async function prepareInlineMediaContent(params) {
       `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path15.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
     );
   }
-  const data = await fs15.readFile(params.request.absolutePath, "base64");
+  const data = await fs14.readFile(params.request.absolutePath, "base64");
   const content = params.request.kind === "video" ? [{ type: "video", data, mimeType: params.request.mimeType }] : [{ type: "image", data, mimeType: params.request.mimeType }];
   return {
     content,
@@ -55821,7 +55679,7 @@ async function waitForReady(params) {
     if (status.status === "error" || status.status === "expired") {
       throw new Error(`Uploaded file is not ready: ${status.status}${status.error ? ` (${status.error})` : ""}`);
     }
-    await new Promise((resolve6) => setTimeout(resolve6, 1500));
+    await new Promise((resolve4) => setTimeout(resolve4, 1500));
   }
   throw new Error("Timed out waiting for uploaded file to become ready");
 }
@@ -55957,7 +55815,7 @@ var ExecutionStateManager = class {
       case "aborted":
         return "Todo run aborted. Cleared the remaining todo list.";
       case "failed_turn":
-        return "Todo run failed during the latest turn. Cleared the remaining todo list.";
+        return "Todo run failed during the latest turn. Preserved the todo list and paused automatic continuation.";
       case "max_attempts":
         return "Todo run reached the maximum follow-up attempts and was cleared as failed.";
       case "stagnated":
@@ -56075,6 +55933,18 @@ var ExecutionStateManager = class {
       return { changed: false };
     }
     const decision = evaluateTodoClosureAfterFailedTurn(previous.loop);
+    if (decision.action === "pause_failed") {
+      const paused = pauseExecutionState({
+        ...previous,
+        loop: decision.loop
+      }, this.summarizeFailure(decision.reason));
+      this.store.replace(paused);
+      return {
+        changed: true,
+        terminalStatus: "paused",
+        terminalSummary: paused.failureSummary || void 0
+      };
+    }
     if (decision.action === "clear_failed") {
       this.clearWithSummary(this.summarizeFailure(decision.reason));
       return {
@@ -56086,6 +55956,14 @@ var ExecutionStateManager = class {
     }
     return { changed: false };
   }
+  resumePausedTodo() {
+    const previous = this.store.read();
+    if (previous.mode !== "todo" || previous.lifecycle !== "paused" || previous.steps.length === 0) {
+      return { changed: false };
+    }
+    const next = this.store.replace(continueExecutionState(previous));
+    return { changed: !this.unchanged(previous, next) };
+  }
   markAwaitingContinuationStalled() {
     const previous = this.store.read();
     if (previous.mode !== "todo" || !previous.awaitingContinuation) {
@@ -56123,7 +56001,7 @@ var ExecutionStateManager = class {
       return null;
     }
     if (shouldPreserveExecutionStateForUserText(text)) {
-      if (state.lifecycle === "aborted") {
+      if (state.lifecycle === "paused" || state.lifecycle === "aborted") {
         this.store.replace(continueExecutionState(state));
         return "continued";
       }
@@ -56151,7 +56029,7 @@ var ExecutionStateManager = class {
 };
 
 // src/session-trace.ts
-import * as fs16 from "node:fs";
+import * as fs15 from "node:fs";
 import * as path16 from "node:path";
 var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
   constructor(sessionsDir, sessionManager) {
@@ -56159,9 +56037,9 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
       getSessionId: () => sessionManager.getActiveSessionId(),
       loadTrace: (sessionId) => {
         const tracePath = path16.join(sessionsDir, `${sessionId}.trace.json`);
-        if (!fs16.existsSync(tracePath)) return null;
+        if (!fs15.existsSync(tracePath)) return null;
         try {
-          return JSON.parse(fs16.readFileSync(tracePath, "utf8"));
+          return JSON.parse(fs15.readFileSync(tracePath, "utf8"));
         } catch {
           return null;
         }
@@ -56169,8 +56047,8 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
       saveTrace: (trace) => {
         const tracePath = path16.join(sessionsDir, `${trace.sessionId}.trace.json`);
         const tempPath = `${tracePath}.tmp`;
-        fs16.writeFileSync(tempPath, JSON.stringify(trace, null, 2), "utf8");
-        fs16.renameSync(tempPath, tracePath);
+        fs15.writeFileSync(tempPath, JSON.stringify(trace, null, 2), "utf8");
+        fs15.renameSync(tempPath, tracePath);
       }
     });
     this.sessionsDir = sessionsDir;
@@ -56777,7 +56655,7 @@ async function handleCacheTest(host) {
     host.chatContainer.addChild(new Text(theme.fg("dim", `  ${summarizeUsage(result1.usage)}`), 1, 0));
     host.chatContainer.addChild(new Text(theme.fg("dim", "  Waiting 2s before replaying identical request..."), 1, 0));
     host.ui.requestRender();
-    await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+    await new Promise((resolve4) => setTimeout(resolve4, 2e3));
     host.chatContainer.addChild(new Text(theme.fg("accent", "Request 2/2: replaying identical request..."), 1, 0));
     host.ui.requestRender();
     result2 = await completeSimple(model, context, options);
@@ -58860,7 +58738,7 @@ async function handleForkCommand(host) {
 }
 
 // src/commands/interactive-skill-commands.ts
-import * as fs17 from "fs";
+import * as fs16 from "fs";
 import * as os3 from "os";
 import * as path17 from "path";
 
@@ -59204,7 +59082,7 @@ function expandSkillCommand(host, text) {
   const skill = host.skills.find((s) => s.name === skillName);
   if (!skill) return text;
   try {
-    const content = fs17.readFileSync(skill.filePath, "utf-8");
+    const content = fs16.readFileSync(skill.filePath, "utf-8");
     const body = host.stripFrontmatter(content).trim();
     const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
 References are relative to ${skill.baseDir}.
@@ -59274,13 +59152,13 @@ async function handleSkillsCreate(host, args) {
     const skillDir = path17.join(skillsDir, name);
     const skillFile = path17.join(skillDir, "SKILL.md");
     console.error(`[SkillsCreate] Creating at: ${skillFile}`);
-    if (fs17.existsSync(skillDir)) {
+    if (fs16.existsSync(skillDir)) {
       host.showError(`Skill "${name}" already exists at ${skillDir}`);
       return;
     }
-    fs17.mkdirSync(skillDir, { recursive: true });
+    fs16.mkdirSync(skillDir, { recursive: true });
     const template = createSkillTemplate(name, description);
-    fs17.writeFileSync(skillFile, template, "utf-8");
+    fs16.writeFileSync(skillFile, template, "utf-8");
     console.error(`[SkillsCreate] Successfully created skill`);
     host.chatContainer.addChild(new Spacer(1));
     host.chatContainer.addChild(new Text(theme.fg("accent", `\u2713 Created skill: ${name}`), 1, 0));
@@ -60024,6 +59902,29 @@ async function handleCompactCommand(host) {
   }
 }
 
+// src/runtime/footer-lifecycle.ts
+function messageRole(event) {
+  return String(event.message.role);
+}
+function formatFooterLifecycleEvent(event) {
+  switch (event.type) {
+    case "message_start":
+      return `message_start(${messageRole(event)})`;
+    case "message_end":
+      return `message_end(${messageRole(event)})`;
+    case "message_update":
+      return event.message.role === "assistant" ? event.assistantMessageEvent.type : "message_update";
+    case "tool_execution_start":
+      return `tool_execution_start(${event.toolName})`;
+    case "tool_execution_update":
+      return `tool_execution_update(${event.toolName})`;
+    case "tool_execution_end":
+      return `tool_execution_end(${event.toolName})`;
+    default:
+      return event.type;
+  }
+}
+
 // src/runtime/interactive-runtime-events.ts
 function bindInteractiveRuntimeEvents(host) {
   host.agent.subscribe((event) => {
@@ -60046,7 +59947,7 @@ function bindInteractiveRuntimeEvents(host) {
         break;
       case "message_end":
         if (process.env.PIE_DEBUG_FOOTER) {
-          console.error(`[Footer Debug] message_end fired, setting status: ready`);
+          console.error(`[Footer Debug] ${formatFooterLifecycleEvent(event)}`);
         }
         host.logDebug("message:end", { stopReason: event.message.role === "assistant" ? event.message.stopReason : void 0 });
         handleMessageEnd(host, event);
@@ -60248,7 +60149,7 @@ function handleMessageStart(host, event) {
     host.chatContainer.addChild(host.streamingComponent);
     host.sessionTrace.updateAssistantMessage(event.message);
   }
-  host.footer.setState({ lifecycleEvent: "message_start" });
+  host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   host.emitExtensionEvent({ type: "message:start", message: event.message });
   host.safeRequestRender();
 }
@@ -60259,7 +60160,7 @@ function handleMessageUpdate(host, event) {
     host.pendingRender = true;
     return;
   }
-  host.footer.setState({ lifecycleEvent: "message_update" });
+  host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   const message = event.message;
   let textContent = "";
   let thinkingContent = "";
@@ -60333,7 +60234,7 @@ function handleToolStart(host, event) {
     if (toolComponent) {
     }
   }
-  host.footer.setState({ lifecycleEvent: "tool_execution_start" });
+  host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   host.emitExtensionEvent({
     type: "tool:execution:start",
     toolCallId: event.toolCallId,
@@ -60358,7 +60259,7 @@ function handleToolUpdate(host, event) {
       host.ui.requestRender();
     }
   }
-  host.footer.setState({ lifecycleEvent: "tool_execution_update" });
+  host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   host.emitExtensionEvent({
     type: "tool:execution:update",
     toolCallId: event.toolCallId,
@@ -60391,7 +60292,7 @@ function handleToolEnd(host, event) {
       void host.refreshTodoWidget();
     }
   }
-  host.footer.setState({ lifecycleEvent: "tool_execution_end" });
+  host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   host.emitExtensionEvent({
     type: "tool:execution:end",
     toolCallId: event.toolCallId,
@@ -60403,7 +60304,7 @@ function handleToolEnd(host, event) {
 }
 function handleMessageEnd(host, event) {
   host.streamingComponent = void 0;
-  host.footer.setState({ lifecycleEvent: "message_end" });
+  host.footer.setState({ lifecycleEvent: formatFooterLifecycleEvent(event) });
   host.emitExtensionEvent({ type: "message:end", message: event.message });
   host.safeRequestRender();
 }
@@ -60668,7 +60569,7 @@ function setupInteractiveEditorSubmitHandler(host) {
     host.chatContainer.addChild(userMsg);
     host.editor.setText("");
     host.ui.requestRender();
-    await new Promise((resolve6) => setImmediate(resolve6));
+    await new Promise((resolve4) => setImmediate(resolve4));
     let finalContent = messageContent;
     const reminderPrefix = host.executionReminder;
     const combinedPrefix = [reminderPrefix].filter((value) => Boolean(value)).join("");
@@ -60704,7 +60605,7 @@ function setupInteractiveEditorSubmitHandler(host) {
 }
 
 // src/input/interactive-file-pipeline.ts
-import * as fs20 from "fs";
+import * as fs19 from "fs";
 import * as path20 from "path";
 
 // src/components/file-picker.ts
@@ -60926,7 +60827,7 @@ var FilePickerComponent = class extends Container {
 };
 
 // src/files/commands/file-commands.ts
-import * as fs18 from "node:fs";
+import * as fs17 from "node:fs";
 import * as path18 from "node:path";
 var FileCommands = class {
   context;
@@ -60943,7 +60844,7 @@ var FileCommands = class {
       return;
     }
     const filePath = resolvePath(parsed.path);
-    if (!fs18.existsSync(filePath)) {
+    if (!fs17.existsSync(filePath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
@@ -60982,7 +60883,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath(filePath);
-    if (!fs18.existsSync(resolvedPath)) {
+    if (!fs17.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${filePath}`);
       return;
     }
@@ -61013,7 +60914,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath(parsed.path);
-    if (!fs18.existsSync(resolvedPath)) {
+    if (!fs17.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
@@ -61491,7 +61392,7 @@ var FileStatusMonitor = class {
 };
 
 // src/files/mention/mention-handler.ts
-import * as fs19 from "node:fs";
+import * as fs18 from "node:fs";
 import * as path19 from "node:path";
 var MentionHandler = class {
   fileManager;
@@ -61861,8 +61762,8 @@ var MentionHandler = class {
     }
     if (this.isPath(query)) {
       const resolvedPath = resolvePath(query);
-      if (fs19.existsSync(resolvedPath)) {
-        const stats = fs19.statSync(resolvedPath);
+      if (fs18.existsSync(resolvedPath)) {
+        const stats = fs18.statSync(resolvedPath);
         if (stats.isFile()) {
           const type = FileCache.getFileTypeFromName(resolvedPath);
           const name = path19.basename(resolvedPath);
@@ -61886,7 +61787,7 @@ var MentionHandler = class {
       return void 0;
     }
     const queryPath = this.isPath(query) ? resolvePath(query) : void 0;
-    const filter = queryPath ? fs19.existsSync(queryPath) && fs19.statSync(queryPath).isDirectory() ? "" : path19.basename(queryPath) : query;
+    const filter = queryPath ? fs18.existsSync(queryPath) && fs18.statSync(queryPath).isDirectory() ? "" : path19.basename(queryPath) : query;
     const entries = this.fileManager.listPathEntries(currentDir, filter);
     const options = [];
     const homeDir = process.env.HOME || "";
@@ -61927,7 +61828,7 @@ var MentionHandler = class {
   getBrowserDirectory(query = this.currentQuery) {
     if (this.isPath(query)) {
       const resolvedPath = resolvePath(query);
-      if (fs19.existsSync(resolvedPath) && fs19.statSync(resolvedPath).isDirectory()) {
+      if (fs18.existsSync(resolvedPath) && fs18.statSync(resolvedPath).isDirectory()) {
         return resolvedPath;
       }
       return path19.dirname(resolvedPath);
@@ -62004,7 +61905,7 @@ var MentionHandler = class {
     this.pendingStatusMessages.delete(key);
   }
   isPath(query) {
-    return query.startsWith("/") || query.startsWith("~") || query.startsWith("./") || query.startsWith("../");
+    return looksLikeFilePath(query);
   }
 };
 
@@ -62291,13 +62192,13 @@ function convertPreparedAttachmentItems(items) {
         break;
       case "image": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs20.readFileSync(item.path, "base64");
+        const data = item.data ?? fs19.readFileSync(item.path, "base64");
         converted.push({ type: "image", data, mimeType: item.mimeType });
         break;
       }
       case "video": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs20.readFileSync(item.path, "base64");
+        const data = item.data ?? fs19.readFileSync(item.path, "base64");
         converted.push({ type: "video", data, mimeType: item.mimeType });
         break;
       }
@@ -62688,6 +62589,7 @@ function buildCodingAgentGuidelinesSection(tools = []) {
   const hasGrep = toolNames.has("grep_text");
   const hasFind = toolNames.has("find_files");
   const hasBash = toolNames.has("bash");
+  const hasWebResearch = toolNames.has("web_research");
   const hasWebSearch = toolNames.has("web_search");
   const hasWebFetch = toolNames.has("web_fetch");
   const hasCodeIntel = toolNames.has("code_intel");
@@ -62702,11 +62604,17 @@ function buildCodingAgentGuidelinesSection(tools = []) {
   if (hasGrep || hasFind || hasList) {
     guidelines.push("Prefer grep_text, find_files, and list_dir for workspace exploration when they are sufficient.");
   }
-  if (hasWebSearch) {
+  if (hasWebResearch) {
+    guidelines.push("Use web_research for general public web research, current information, official docs, news, releases, issues, or webpage summaries; it searches, fetches, and returns cited sources.");
+    guidelines.push("When web_research returns fetched sources that answer the request, synthesize the answer from that pack instead of calling web_search or web_fetch again.");
+  }
+  if (hasWebSearch && !hasWebResearch) {
     guidelines.push("Use web_search for public web research and grep_text/find_files/list_dir for local workspace search.");
   }
-  if (hasWebFetch) {
+  if (hasWebFetch && !hasWebResearch) {
     guidelines.push("After web_search identifies a public source, use web_fetch to read the chosen URL before relying on it; also use web_fetch for user-supplied URLs.");
+  } else if (hasWebResearch && hasWebSearch && hasWebFetch) {
+    guidelines.push("Use web_search and web_fetch directly only when you need low-level control over exact queries or URLs.");
   }
   if (hasCodeIntel) {
     guidelines.push("Use code_intel for JS/TS diagnostics, definitions, references, symbols, or hover when type or symbol information matters before editing.");
@@ -63537,8 +63445,21 @@ function createInteractiveAgentSessionController(host) {
       } else if (event.type === "retry_start") {
         host.showStatus(`Retrying request (attempt ${event.attempt}/${event.maxRetries})...`);
       } else if (event.type === "retry_succeeded") {
+        const outcome = host.executionState.resumePausedTodo();
+        if (outcome.changed) {
+          host.sessionTrace.noteRuntimeEvent("todo_resumed_after_retry", {
+            lifecycle: host.executionState.read().lifecycle,
+            currentStepId: host.executionState.read().currentStepId
+          });
+          host.persistExecutionState();
+          void host.refreshTodoWidget();
+        }
         host.showStatus("Retry succeeded");
       } else if (event.type === "retry_exhausted") {
+        const state = host.executionState.read();
+        if (state.mode === "todo" && state.lifecycle === "paused" && state.steps.length > 0) {
+          host.showStatus("Todo list preserved. Send 'continue' when you want to resume it.");
+        }
         host.showError(`Request failed after ${event.maxRetries} retries: ${event.errorMessage}`);
       } else if (event.type === "runtime_guard_triggered") {
         host.sessionTrace.noteStalled("runtime_guard_triggered", {
@@ -63770,7 +63691,7 @@ async function handleDirectBash(host, command) {
     }
     host.ui.requestRender();
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve4) => {
     child.on("close", (code) => {
       if (code !== 0) {
         outputContainer.addChild(new Spacer(1));
@@ -63778,7 +63699,7 @@ async function handleDirectBash(host, command) {
       }
       host.chatContainer.addChild(new Spacer(1));
       host.ui.requestRender();
-      resolve6();
+      resolve4();
     });
   });
 }
@@ -63854,11 +63775,11 @@ function installInteractiveInteractionHandler(host) {
       if (!("timeoutMs" in request) || !request.timeoutMs || request.timeoutMs <= 0) {
         return { value: await promise, timedOut: false };
       }
-      return await new Promise((resolve6, reject) => {
-        const timer = setTimeout(() => resolve6({ timedOut: true }), request.timeoutMs);
+      return await new Promise((resolve4, reject) => {
+        const timer = setTimeout(() => resolve4({ timedOut: true }), request.timeoutMs);
         promise.then((value) => {
           clearTimeout(timer);
-          resolve6({ value, timedOut: false });
+          resolve4({ value, timedOut: false });
         }).catch((error) => {
           clearTimeout(timer);
           reject(error);
@@ -63958,15 +63879,15 @@ function showExtensionNotification(host, message, type = "info") {
   host.ui.requestRender();
 }
 function showExtensionSelector(host, title, options, opts) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve4) => {
     host.showStatus(`Waiting for selection: ${title}`);
     if (opts?.signal?.aborted) {
-      resolve6(void 0);
+      resolve4(void 0);
       return;
     }
     const onAbort = () => {
       host.restoreEditor();
-      resolve6(void 0);
+      resolve4(void 0);
     };
     opts?.signal?.addEventListener("abort", onAbort, { once: true });
     const selector = new ExtensionSelectorComponent(
@@ -63975,12 +63896,12 @@ function showExtensionSelector(host, title, options, opts) {
       (option) => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(option);
+        resolve4(option);
       },
       () => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(void 0);
+        resolve4(void 0);
       }
     );
     host.editorContainer.clear();
@@ -63996,15 +63917,15 @@ ${message}`, ["Yes", "No"], opts);
   return result === "Yes";
 }
 function showExtensionInput(host, title, placeholder, opts) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve4) => {
     host.showStatus(`Waiting for input: ${title}`);
     if (opts?.signal?.aborted) {
-      resolve6(void 0);
+      resolve4(void 0);
       return;
     }
     const onAbort = () => {
       host.restoreEditor();
-      resolve6(void 0);
+      resolve4(void 0);
     };
     opts?.signal?.addEventListener("abort", onAbort, { once: true });
     const input = new ExtensionInputComponent(
@@ -64013,12 +63934,12 @@ function showExtensionInput(host, title, placeholder, opts) {
       (value) => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(value);
+        resolve4(value);
       },
       () => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(void 0);
+        resolve4(void 0);
       }
     );
     host.editorContainer.clear();
@@ -64029,7 +63950,7 @@ function showExtensionInput(host, title, placeholder, opts) {
   });
 }
 function showExtensionEditor(host, title, prefill) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve4) => {
     host.showStatus(`Waiting for input: ${title}`);
     const container = new Container();
     container.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
@@ -64051,12 +63972,12 @@ function showExtensionEditor(host, title, prefill) {
         preview: value.slice(0, 120)
       });
       host.restoreEditor();
-      resolve6(value);
+      resolve4(value);
     };
     editor.onEscape = () => {
       host.logDebug("extension:editor:cancel", { title });
       host.restoreEditor();
-      resolve6(void 0);
+      resolve4(void 0);
     };
     container.addChild(editor);
     container.addChild(new Spacer(1));
@@ -64070,14 +63991,14 @@ function showExtensionEditor(host, title, prefill) {
 }
 function showExtensionCustom(host, factory, options) {
   const savedText = host.editor.getText();
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve4, reject) => {
     let closed = false;
     const close = (result) => {
       if (closed) return;
       closed = true;
       host.restoreEditor();
       host.editor.setText(savedText);
-      resolve6(result);
+      resolve4(result);
     };
     Promise.resolve(factory(host.ui, theme, close)).then((component) => {
       if (closed) return;
@@ -64151,7 +64072,7 @@ var AttachmentResolver = class {
 };
 
 // src/extensions/loader.ts
-import * as fs21 from "node:fs";
+import * as fs20 from "node:fs";
 import * as os4 from "os";
 import * as path21 from "path";
 import { pathToFileURL } from "node:url";
@@ -64335,7 +64256,7 @@ function normalizeExtensionImportPath(extensionPath) {
 }
 async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, hasUI, actions) {
   const resolvedPath = resolvePath2(extensionPath, cwd);
-  if (!fs21.existsSync(resolvedPath)) {
+  if (!fs20.existsSync(resolvedPath)) {
     return { extension: null, error: `Extension not found: ${extensionPath}` };
   }
   try {
@@ -64356,12 +64277,12 @@ async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, h
   }
 }
 function discoverExtensionsInDir(dir) {
-  if (!fs21.existsSync(dir)) {
+  if (!fs20.existsSync(dir)) {
     return [];
   }
   const discovered = [];
   try {
-    const entries = fs21.readdirSync(dir, { withFileTypes: true });
+    const entries = fs20.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const entryPath = path21.join(dir, entry.name);
       if (entry.isFile() && (entry.name.endsWith(".cjs") || entry.name.endsWith(".js") || entry.name.endsWith(".ts"))) {
@@ -64370,16 +64291,16 @@ function discoverExtensionsInDir(dir) {
       }
       if (entry.isDirectory()) {
         const packageJsonPath = path21.join(entryPath, "package.json");
-        if (fs21.existsSync(packageJsonPath)) {
+        if (fs20.existsSync(packageJsonPath)) {
           try {
-            const pkg2 = JSON.parse(fs21.readFileSync(packageJsonPath, "utf-8"));
-            const manifest = pkg2.pie;
+            const pkg = JSON.parse(fs20.readFileSync(packageJsonPath, "utf-8"));
+            const manifest = pkg.pie;
             if (manifest?.main) {
               const mainPath = path21.resolve(entryPath, manifest.main);
-              if (fs21.existsSync(mainPath)) {
+              if (fs20.existsSync(mainPath)) {
                 discovered.push({
                   entryPath: mainPath,
-                  manifestName: manifest.name || pkg2.name
+                  manifestName: manifest.name || pkg.name
                 });
                 continue;
               }
@@ -64388,17 +64309,17 @@ function discoverExtensionsInDir(dir) {
           }
         }
         const indexCjs = path21.join(entryPath, "index.cjs");
-        if (fs21.existsSync(indexCjs)) {
+        if (fs20.existsSync(indexCjs)) {
           discovered.push({ entryPath: indexCjs });
           continue;
         }
         const indexJs = path21.join(entryPath, "index.js");
-        if (fs21.existsSync(indexJs)) {
+        if (fs20.existsSync(indexJs)) {
           discovered.push({ entryPath: indexJs });
           continue;
         }
         const indexTs = path21.join(entryPath, "index.ts");
-        if (fs21.existsSync(indexTs)) {
+        if (fs20.existsSync(indexTs)) {
           discovered.push({ entryPath: indexTs });
           continue;
         }
@@ -64447,11 +64368,11 @@ async function loadExtensions(configuredPaths, cwd, uiContext, abortFn, isIdleFn
   }
   for (const p of configuredPaths) {
     const resolved = resolvePath2(p, cwd);
-    if (!fs21.existsSync(resolved)) {
+    if (!fs20.existsSync(resolved)) {
       errors.push({ path: p, error: `Extension path not found: ${p}` });
       continue;
     }
-    if (!fs21.statSync(resolved).isDirectory()) {
+    if (!fs20.statSync(resolved).isDirectory()) {
       errors.push({ path: p, error: `Extension path must be a directory: ${p}` });
       continue;
     }
@@ -65200,7 +65121,7 @@ var InteractiveMode = class {
     this.skills = options.skills;
     this.originalTools = [...options.tools];
     this.skillsSection = formatSkillsForPrompt(options.skills);
-    this.knowledgeSection = buildCliKnowledgeIndexSection(options.cwd);
+    this.knowledgeSection = buildCliProjectContextSection(options.cwd);
   }
   options;
   get runtimeEventHost() {
@@ -65241,10 +65162,15 @@ var InteractiveMode = class {
   }
   rebuildSkillAwareTools(sourceTools) {
     const preservedTools = sourceTools.filter(
-      (tool) => !CLI_FILESYSTEM_TOOL_NAMES.includes(tool.name) && tool.name !== "read_skill" && tool.name !== "read_resource" && tool.name !== "resolve_resource"
+      (tool) => !CLI_FILESYSTEM_TOOL_NAMES.includes(tool.name)
     );
     const fileSystemToolOptions = (allowlistedDirs) => ({
-      allowlistedDirs,
+      ...buildCliFileAccessOptions({
+        cwd: this.options.cwd,
+        configDir: this.options.configDir,
+        skills: this.skills,
+        allowlistedDirs
+      }),
       configDir: this.options.configDir,
       getAgentModel: () => this.options.model,
       getSessionId: () => this.sessionManager.getActiveSessionId() || void 0,
@@ -65257,9 +65183,6 @@ var InteractiveMode = class {
     });
     const normalFsTools = createCliFileSystemTools(this.options.cwd, fileSystemToolOptions([this.options.configDir]));
     const currentFsTools = this.yoloMode ? createCliFileSystemTools(this.options.cwd, fileSystemToolOptions(["/"])) : normalFsTools;
-    const readSkillTool = createCliReadSkillTool(this.skills);
-    const readResourceTool = createCliReadResourceTool(this.skills);
-    const resolveResourceTool = createCliResolveResourceTool(this.skills);
     const getPolicyContext = () => ({
       mode: this.planModeEnabled ? "plan" : "normal",
       yoloMode: this.yoloMode,
@@ -65267,11 +65190,11 @@ var InteractiveMode = class {
     });
     return {
       currentTools: createPolicyEnforcedTools(
-        [...currentFsTools, readSkillTool, readResourceTool, resolveResourceTool, ...preservedTools],
+        [...currentFsTools, ...preservedTools],
         { getContext: getPolicyContext }
       ),
       originalTools: createPolicyEnforcedTools(
-        [...normalFsTools, readSkillTool, readResourceTool, resolveResourceTool, ...preservedTools],
+        [...normalFsTools, ...preservedTools],
         { getContext: getPolicyContext }
       )
     };
@@ -65765,8 +65688,8 @@ function parseCliInvocation(args) {
 }
 
 // src/cli.ts
-import { mkdirSync as mkdirSync12, existsSync as existsSync19 } from "fs";
-import * as fs26 from "fs";
+import { mkdirSync as mkdirSync11, existsSync as existsSync17 } from "fs";
+import * as fs25 from "fs";
 import * as path25 from "path";
 
 // src/logging/runtime-logger.ts
@@ -65904,7 +65827,7 @@ var AuthStorage = class {
 };
 
 // src/core/settings-manager.ts
-import * as fs22 from "fs";
+import * as fs21 from "fs";
 var SettingsManager = class {
   settingsPath;
   legacyConfigPath;
@@ -65918,9 +65841,9 @@ var SettingsManager = class {
     this.legacyConfig = this.loadLegacyConfigFile();
   }
   readJson(filePath) {
-    if (!fs22.existsSync(filePath)) return null;
+    if (!fs21.existsSync(filePath)) return null;
     try {
-      return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs21.readFileSync(filePath, "utf-8"));
     } catch {
       return null;
     }
@@ -65932,15 +65855,15 @@ var SettingsManager = class {
     return this.readJson(this.legacyConfigPath) || {};
   }
   ensureDir() {
-    fs22.mkdirSync(getConfigDir(), { recursive: true });
+    fs21.mkdirSync(getConfigDir(), { recursive: true });
   }
   writeSettings() {
     this.ensureDir();
-    fs22.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
+    fs21.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
   }
   writeLegacyConfig() {
     this.ensureDir();
-    fs22.writeFileSync(this.legacyConfigPath, JSON.stringify(this.legacyConfig, null, 2));
+    fs21.writeFileSync(this.legacyConfigPath, JSON.stringify(this.legacyConfig, null, 2));
   }
   getLegacyApiKey() {
     return this.legacyConfig.apiKey;
@@ -65992,7 +65915,7 @@ var SettingsManager = class {
 };
 
 // src/core/model-registry.ts
-import * as fs23 from "fs";
+import * as fs22 from "fs";
 import * as path22 from "path";
 function validateProfileConfig(profileId, profileConfig) {
   const missing = [];
@@ -66055,11 +65978,11 @@ var ModelRegistry = class {
     this.modelOrder = [];
     this.configDefaults = void 0;
     this.usingExternalProviders = false;
-    if (!fs23.existsSync(this.modelsPath)) {
+    if (!fs22.existsSync(this.modelsPath)) {
       return;
     }
     try {
-      const raw = JSON.parse(fs23.readFileSync(this.modelsPath, "utf-8"));
+      const raw = JSON.parse(fs22.readFileSync(this.modelsPath, "utf-8"));
       if (raw && typeof raw === "object" && "providers" in raw) {
         throw new Error('Legacy models.json format is no longer supported. Use top-level "profiles".');
       }
@@ -66308,11 +66231,12 @@ var ModelRegistry = class {
 // src/doctor.ts
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
-import * as fs24 from "node:fs";
+import * as fs23 from "node:fs";
 import * as os5 from "node:os";
 import * as path23 from "node:path";
 import { delimiter } from "node:path";
 var require2 = createRequire(import.meta.url);
+var UNITY_INSTANCE_MAX_AGE_SEC = 120;
 function checkStatus(checks) {
   return {
     pass: checks.filter((check) => check.status === "pass").length,
@@ -66344,19 +66268,19 @@ function checkShell() {
 }
 function canWriteDirectory(dir) {
   try {
-    fs24.mkdirSync(dir, { recursive: true });
+    fs23.mkdirSync(dir, { recursive: true });
     const probe = path23.join(dir, `.pie-doctor-${process.pid}-${Date.now()}`);
-    fs24.writeFileSync(probe, "ok", "utf8");
-    fs24.rmSync(probe, { force: true });
+    fs23.writeFileSync(probe, "ok", "utf8");
+    fs23.rmSync(probe, { force: true });
     return { ok: true };
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
 function isExecutable(candidate) {
-  if (!candidate || !fs24.existsSync(candidate)) return false;
+  if (!candidate || !fs23.existsSync(candidate)) return false;
   try {
-    fs24.accessSync(candidate, fs24.constants.X_OK);
+    fs23.accessSync(candidate, fs23.constants.X_OK);
     return true;
   } catch {
     return os5.platform() === "win32";
@@ -66434,7 +66358,7 @@ function checkPlaywrightBrowser() {
   } catch {
     executablePath = void 0;
   }
-  if (executablePath && fs24.existsSync(executablePath)) {
+  if (executablePath && fs23.existsSync(executablePath)) {
     return {
       id: "playwright_browser",
       label: "Playwright browser",
@@ -66452,37 +66376,98 @@ function checkPlaywrightBrowser() {
     details: { expectedExecutablePath: executablePath, skillWrapper }
   };
 }
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasRequiredUnityIdentityFields(instance) {
+  return typeof instance.instanceId === "string" && instance.instanceId.trim().length > 0 && typeof instance.projectPath === "string" && instance.projectPath.trim().length > 0 && Number(instance.port || 0) > 0 && Number(instance.pid || 0) > 0 && Number(instance.lastSeenUnix || 0) > 0;
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+function isLiveUnityInstance(instance, nowUnix = Math.floor(Date.now() / 1e3)) {
+  if (!hasRequiredUnityIdentityFields(instance)) return false;
+  const lastSeenUnix = Number(instance.lastSeenUnix || 0);
+  if (nowUnix - lastSeenUnix > UNITY_INSTANCE_MAX_AGE_SEC) return false;
+  return isProcessAlive(Number(instance.pid || 0));
+}
 function checkUnityRegistry() {
-  const registryPath = path23.join(os5.homedir(), ".pie-unity", "registry.json");
-  if (!fs24.existsSync(registryPath)) {
+  const registryDir = path23.join(os5.homedir(), ".pie-unity", "instances");
+  if (!fs23.existsSync(registryDir)) {
     return {
       id: "unity_bridge",
       label: "Unity bridge",
       status: "warn",
-      message: "No pie-unity registry found. This is fine unless you plan to control Unity from Pie.",
-      details: { registryPath }
+      message: "No pie-unity instance registry directory found. This is fine unless you plan to control Unity from Pie.",
+      details: { registryDir }
     };
   }
   try {
-    const raw = JSON.parse(fs24.readFileSync(registryPath, "utf8"));
-    const instances = Array.isArray(raw?.instances) ? raw.instances : [];
+    const nowUnix = Math.floor(Date.now() / 1e3);
+    const files = fs23.readdirSync(registryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path23.join(registryDir, entry.name));
+    let malformedFiles = 0;
+    let invalidFiles = 0;
+    const liveInstances = files.map((filePath) => {
+      try {
+        const parsed = JSON.parse(fs23.readFileSync(filePath, "utf8").replace(/^\uFEFF/, ""));
+        if (!isRecord2(parsed)) {
+          invalidFiles += 1;
+          return null;
+        }
+        if (!isLiveUnityInstance(parsed, nowUnix)) {
+          invalidFiles += 1;
+          return null;
+        }
+        return parsed;
+      } catch {
+        malformedFiles += 1;
+        return null;
+      }
+    }).filter((item) => Boolean(item));
     return {
       id: "unity_bridge",
       label: "Unity bridge",
-      status: instances.length > 0 ? "pass" : "warn",
-      message: instances.length > 0 ? `Found ${instances.length} registered pie-unity instance(s).` : "pie-unity registry exists but has no instances.",
-      details: { registryPath, instances: instances.length }
+      status: liveInstances.length > 0 ? "pass" : "warn",
+      message: liveInstances.length > 0 ? `Found ${liveInstances.length} live pie-unity instance(s).` : "pie-unity instance registry directory exists but has no live readable instances.",
+      details: {
+        registryDir,
+        liveInstances: liveInstances.length,
+        totalFiles: files.length,
+        malformedFiles,
+        invalidOrStaleFiles: invalidFiles
+      }
     };
   } catch (error) {
     return {
       id: "unity_bridge",
       label: "Unity bridge",
       status: "warn",
-      message: `Could not read pie-unity registry: ${error instanceof Error ? error.message : String(error)}`,
-      details: { registryPath }
+      message: `Could not read pie-unity instance registry directory: ${error instanceof Error ? error.message : String(error)}`,
+      details: { registryDir }
     };
   }
 }
+function checkPieUnityRpcSkill() {
+  return {
+    id: "pie_unity_rpc_skill",
+    label: "Pie Unity RPC skill",
+    status: "pass",
+    message: "pie-unity-rpc is package-contained. Use the helper from the current Unity project's resolved com.pie.agent package.",
+    details: {
+      lookupOrder: [
+        "Packages/com.pie.agent/Skills/pie-unity-rpc",
+        "Library/PackageCache/com.pie.agent@*/Skills/pie-unity-rpc",
+        "Library/PackageCache/com.pie.agent*/Skills/pie-unity-rpc"
+      ]
+    }
+  };
+}
 async function runDoctor() {
   const checks = [];
   const settings = new SettingsManager();
@@ -66506,7 +66491,7 @@ async function runDoctor() {
   let lockPath;
   while (dir !== path23.dirname(dir)) {
     const candidate = path23.join(dir, "package-lock.json");
-    if (fs24.existsSync(candidate)) {
+    if (fs23.existsSync(candidate)) {
       lockPath = candidate;
       break;
     }
@@ -66571,6 +66556,26 @@ async function runDoctor() {
       preferredWebSearchCapability: webSearchCandidates[0]?.model?.webSearch?.type
     }
   });
+  const webResearchHealth = createCliWebResearchHealthStore(getConfigDir()).loadProviderHealth();
+  checks.push({
+    id: "web_research_health",
+    label: "Web research provider health",
+    status: webResearchHealth.length > 0 ? "pass" : "warn",
+    message: webResearchHealth.length > 0 ? `Loaded health for ${webResearchHealth.length} web research route(s).` : "No web research provider health has been recorded yet. Run verify:web or use web_research once to populate route quality data.",
+    details: {
+      routes: webResearchHealth.slice(0, 8).map((entry) => ({
+        routeKey: entry.routeKey,
+        attempts: entry.attempts,
+        successRate: entry.attempts ? entry.successes / entry.attempts : 0,
+        lowQualityRate: entry.attempts ? entry.lowQuality / entry.attempts : 0,
+        rateLimited: entry.rateLimited,
+        timeouts: entry.timeouts,
+        averageLatencyMs: entry.attempts ? Math.round(entry.totalDurationMs / entry.attempts) : 0,
+        averageSourceCount: entry.attempts ? entry.totalSources / entry.attempts : 0,
+        updatedAt: entry.updatedAt
+      }))
+    }
+  });
   checks.push({
     id: "tool_model_routes",
     label: "Tool model routes",
@@ -66596,6 +66601,7 @@ async function runDoctor() {
   checks.push(checkPlaywrightCli());
   checks.push(checkPlaywrightBrowser());
   checks.push(checkUnityRegistry());
+  checks.push(checkPieUnityRpcSkill());
   const runtimeLog = getRuntimeLogPath();
   checks.push({
     id: "runtime_log",
@@ -66652,7 +66658,7 @@ Disable or narrow capabilities:
 }
 
 // src/commands/models-config.ts
-import * as fs25 from "node:fs";
+import * as fs24 from "node:fs";
 import * as path24 from "node:path";
 function getDefaultModelsPath() {
   return path24.join(getConfigDir(), "models.json");
@@ -66758,16 +66764,16 @@ function initModelsConfig(options = {}) {
   if (options.stdout) {
     return { path: targetPath, content, wrote: false };
   }
-  if (fs25.existsSync(targetPath) && !options.force) {
+  if (fs24.existsSync(targetPath) && !options.force) {
     throw new Error(`models.json already exists: ${targetPath}. Use --force to overwrite, or --stdout to print the template.`);
   }
-  fs25.mkdirSync(path24.dirname(targetPath), { recursive: true });
-  fs25.writeFileSync(targetPath, content, "utf8");
+  fs24.mkdirSync(path24.dirname(targetPath), { recursive: true });
+  fs24.writeFileSync(targetPath, content, "utf8");
   return { path: targetPath, content, wrote: true };
 }
 function validateModelsConfig(options = {}) {
   const modelsPath = resolveModelsPath(options.path);
-  if (!fs25.existsSync(modelsPath)) {
+  if (!fs24.existsSync(modelsPath)) {
     return {
       ok: false,
       path: modelsPath,
@@ -66822,6 +66828,73 @@ function validateModelsConfig(options = {}) {
     toolModelRoutes
   };
 }
+async function probeModelsConfig(options) {
+  const registry = new ModelRegistry(new AuthStorage(), resolveModelsPath(options.path));
+  const loadError = registry.getLoadError();
+  if (loadError) {
+    return {
+      purpose: options.probe,
+      status: "failed",
+      attempts: [],
+      message: `Cannot probe invalid models.json: ${loadError}`
+    };
+  }
+  if (options.probe !== "web_search") {
+    return {
+      purpose: options.probe,
+      status: "skipped",
+      attempts: [],
+      message: `Unsupported probe: ${options.probe}`
+    };
+  }
+  const candidates = registry.resolveToolModelCandidates("web_search").filter((route) => route.model);
+  if (candidates.length === 0) {
+    return {
+      purpose: options.probe,
+      status: "failed",
+      attempts: [],
+      message: "No configured model declares webSearch capability."
+    };
+  }
+  const attempts = [];
+  for (const candidate of candidates.slice(0, 3)) {
+    const route = `${candidate.model?.provider}/${candidate.model?.id}:${candidate.model?.webSearch?.type}:${candidate.routeSource}`;
+    const tool = createSharedWebSearchTool({
+      getModel: () => candidate.model,
+      getApiKey: () => candidate.apiKey,
+      getMode: () => "live",
+      resolveToolModelCandidates: () => [candidate]
+    });
+    try {
+      const result = await tool.execute("models_probe_web_search", { query: "Pie web search capability probe current official source" });
+      const details = result.details;
+      attempts.push({
+        route,
+        status: result.isError ? "failed" : "passed",
+        sourceCount: Number(details?.sourceCount || 0),
+        failureCategory: details?.failureCategory,
+        durationSeconds: details?.durationSeconds,
+        message: result.content.find((item) => item.type === "text")?.text?.slice(0, 240)
+      });
+      if (!result.isError && Number(details?.sourceCount || 0) > 0) break;
+    } catch (error) {
+      attempts.push({
+        route,
+        status: "failed",
+        sourceCount: 0,
+        failureCategory: "provider_compat",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const passed = attempts.some((attempt) => attempt.status === "passed" && attempt.sourceCount > 0);
+  return {
+    purpose: options.probe,
+    status: passed ? "passed" : "failed",
+    attempts,
+    message: passed ? `web_search probe passed using ${attempts.find((attempt) => attempt.status === "passed")?.route}.` : "web_search probe failed for all configured candidate routes."
+  };
+}
 function parseModelsCommandArgs(args) {
   const parsed = { force: false, stdout: false };
   for (let i = 0; i < args.length; i += 1) {
@@ -66830,6 +66903,12 @@ function parseModelsCommandArgs(args) {
       parsed.force = true;
     } else if (arg === "--stdout") {
       parsed.stdout = true;
+    } else if (arg === "--probe" && args[i + 1]) {
+      parsed.probe = args[i + 1] === "web_search" ? "web_search" : void 0;
+      i += 1;
+    } else if (arg.startsWith("--probe=")) {
+      const value = arg.slice("--probe=".length);
+      parsed.probe = value === "web_search" ? "web_search" : void 0;
     } else if (arg === "--path" && args[i + 1]) {
       parsed.path = args[i + 1];
       i += 1;
@@ -66846,8 +66925,8 @@ var logError = (msg, err) => {
   const logPath = getRuntimeLogPath();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const stack = err instanceof Error ? err.stack || "" : "";
-  fs26.mkdirSync(path25.dirname(logPath), { recursive: true });
-  fs26.appendFileSync(logPath, `[${timestamp}] ${msg}
+  fs25.mkdirSync(path25.dirname(logPath), { recursive: true });
+  fs25.appendFileSync(logPath, `[${timestamp}] ${msg}
 ${stack}
 
 `);
@@ -66860,8 +66939,8 @@ var SKILLS_DIR = path25.join(CONFIG_DIR, "skills");
 var BUILTIN_DIR = getBuiltinDir();
 var BUILTIN_SKILLS_DIR = path25.join(BUILTIN_DIR, "skills");
 var BUILTIN_EXTENSIONS_DIR = path25.join(BUILTIN_DIR, "extensions");
-if (!existsSync19(SKILLS_DIR)) {
-  mkdirSync12(SKILLS_DIR, { recursive: true });
+if (!existsSync17(SKILLS_DIR)) {
+  mkdirSync11(SKILLS_DIR, { recursive: true });
 }
 function maskApiKey2(key) {
   if (key.length <= 6) return "***";
@@ -66916,7 +66995,7 @@ async function runDoctorCommand(args) {
     process.exitCode = 1;
   }
 }
-function runModelsCommand(args) {
+async function runModelsCommand(args) {
   const subcommand = args[0] || "help";
   const parsed = parseModelsCommandArgs(args.slice(1));
   if (subcommand === "init") {
@@ -66958,11 +67037,19 @@ function runModelsCommand(args) {
     if (result.toolModelRoutes && result.toolModelRoutes.length > 0) {
       console.log(`Tool model routes: ${result.toolModelRoutes.join(", ")}`);
     }
+    if (parsed.probe) {
+      const probe = await probeModelsConfig({ path: parsed.path, probe: parsed.probe });
+      console.log(`Probe ${probe.purpose}: ${probe.message}`);
+      for (const attempt of probe.attempts) {
+        console.log(`- ${attempt.status} ${attempt.route} sources=${attempt.sourceCount}${attempt.failureCategory ? ` failure=${attempt.failureCategory}` : ""}`);
+      }
+      if (probe.status === "failed") process.exitCode = 1;
+    }
     return;
   }
   console.log(`Usage:
   pie models init [--path <path>] [--force] [--stdout]
-  pie models validate [--path <path>]`);
+  pie models validate [--path <path>] [--probe web_search]`);
 }
 function createNoOpExtensionUIContext() {
   return {
@@ -67174,24 +67261,19 @@ async function startChat(initialPrompt, testCommand) {
     getApiKey: () => interactiveOptions?.apiKey ?? apiKey,
     getWebSearchMode: () => settingsManager.getWebSearchMode(),
     resolveToolModel: (purpose) => modelRegistry.resolveToolModel(purpose, interactiveOptions?.model ?? model),
-    resolveToolModelCandidates: (purpose) => modelRegistry.resolveToolModelCandidates(purpose, interactiveOptions?.model ?? model)
+    resolveToolModelCandidates: (purpose) => modelRegistry.resolveToolModelCandidates(purpose, interactiveOptions?.model ?? model),
+    configDir: CONFIG_DIR
   });
   const fileSystemToolOptions = {
-    allowlistedDirs: [CONFIG_DIR],
+    ...buildCliFileAccessOptions({ cwd, configDir: CONFIG_DIR, skills, allowlistedDirs: [CONFIG_DIR] }),
     configDir: CONFIG_DIR,
     getAgentModel: () => interactiveOptions?.model ?? model,
     getSessionId: () => sessionManager.getActiveSessionId() || void 0,
     resolveToolModel: (purpose) => modelRegistry.resolveToolModel(purpose, interactiveOptions?.model ?? model),
     getPolicyContext: () => ({ mode: "normal", confirmationPolicy: "allow" })
   };
-  const readSkillTool = createCliReadSkillTool(skills);
-  const readResourceTool = createCliReadResourceTool(skills);
-  const resolveResourceTool = createCliResolveResourceTool(skills);
   const tools = createPolicyEnforcedTools([
     ...createCliFileSystemTools(cwd, fileSystemToolOptions),
-    readSkillTool,
-    readResourceTool,
-    resolveResourceTool,
     ...cliHostCapabilities.tools
   ], {
     getContext: () => ({ mode: "normal", confirmationPolicy: "allow" })
@@ -67201,7 +67283,7 @@ async function startChat(initialPrompt, testCommand) {
     console.log(`[CLI] ${diag.message}`);
   }
   const skillsSection = formatSkillsForPrompt(skills);
-  const knowledgeSection = buildCliKnowledgeIndexSection(cwd);
+  const knowledgeSection = buildCliProjectContextSection(cwd);
   if (initialPrompt) {
     if (initialModel.unconfigured) {
       const errorText = initialModel.warning || "No models are configured. Add one in ~/.pie/models.json before sending messages.";
@@ -67353,9 +67435,9 @@ async function startChat(initialPrompt, testCommand) {
     flushEarlyLogs();
     if (testCommand) {
       console.log(`[TEST] Auto-executing command: ${testCommand}`);
-      await new Promise((resolve6) => setTimeout(resolve6, 500));
+      await new Promise((resolve4) => setTimeout(resolve4, 500));
       await interactive.executeCommand(testCommand);
-      await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+      await new Promise((resolve4) => setTimeout(resolve4, 2e3));
       console.log("[TEST] Command executed, exiting...");
       process.exit(0);
       return;
@@ -67378,7 +67460,7 @@ async function main() {
   }
   if (args[0] === "models") {
     try {
-      runModelsCommand(args.slice(1));
+      await runModelsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
       process.exitCode = 1;