@pikaa-ai/pikaa 0.3.27 → 0.4.0

package/dist/index.js

@@ -1356,6 +1356,7 @@ class DefaultModelClientSession {
       systemMessage.cache_control = { type: "ephemeral" };
     }
     const messages = [systemMessage];
+    const declaredToolCallIds = new Set;
     for (let i = 0;i < params.history.length; i++) {
       const item = params.history[i];
       if (item.type === "user_message") {
@@ -1380,6 +1381,9 @@ class DefaultModelClientSession {
           j++;
         }
         if (toolCalls.length > 0) {
+          for (const tc of toolCalls) {
+            declaredToolCallIds.add(tc.id);
+          }
           messages.push({
             role: "assistant",
             content: cleanedContent || null,
@@ -1416,6 +1420,9 @@ class DefaultModelClientSession {
           });
           j++;
         }
+        for (const tc of toolCalls) {
+          declaredToolCallIds.add(tc.id);
+        }
         messages.push({
           role: "assistant",
           content: null,
@@ -1423,11 +1430,13 @@ class DefaultModelClientSession {
         });
         i = j - 1;
       } else if (item.type === "function_call_output") {
-        messages.push({
-          role: "tool",
-          tool_call_id: item.callId,
-          content: item.output
-        });
+        if (declaredToolCallIds.has(item.callId)) {
+          messages.push({
+            role: "tool",
+            tool_call_id: item.callId,
+            content: item.output
+          });
+        }
       }
     }
     const toolsPayload = typeof params.tools?.toModelToolsSchema === "function" ? params.tools.toModelToolsSchema() : typeof params.tools?.toOpenAISpec === "function" ? params.tools.toOpenAISpec() : Array.isArray(params.tools) ? params.tools : [];
@@ -1821,6 +1830,7 @@ var applyPatchTool = {
       try {
         mkdirSync3(dirname2(filePath), { recursive: true });
         writeFileSync2(filePath, replacementContent, "utf8");
+        ctx.onFileModified?.(rawPath);
         return { output: `Successfully created new file '${rawPath}'` };
       } catch (err) {
         return {
@@ -1841,7 +1851,31 @@ var applyPatchTool = {
           isError: true
         };
       }
-      const firstIndex = originalFileContent.indexOf(targetContent);
+      let targetToFind = targetContent;
+      let replacementToUse = replacementContent;
+      const fileHasCrlf = originalFileContent.includes(`\r
+`);
+      let firstIndex = originalFileContent.indexOf(targetToFind);
+      if (firstIndex === -1 && fileHasCrlf) {
+        const crlfTarget = targetContent.replace(/\r?\n/g, `\r
+`);
+        firstIndex = originalFileContent.indexOf(crlfTarget);
+        if (firstIndex !== -1) {
+          targetToFind = crlfTarget;
+          replacementToUse = replacementContent.replace(/\r?\n/g, `\r
+`);
+        }
+      } else if (firstIndex === -1 && !fileHasCrlf && targetContent.includes(`\r
+`)) {
+        const lfTarget = targetContent.replace(/\r\n/g, `
+`);
+        firstIndex = originalFileContent.indexOf(lfTarget);
+        if (firstIndex !== -1) {
+          targetToFind = lfTarget;
+          replacementToUse = replacementContent.replace(/\r\n/g, `
+`);
+        }
+      }
       if (firstIndex === -1) {
         return {
           output: `Error: targetContent was not found in '${rawPath}'.
@@ -1852,7 +1886,7 @@ var applyPatchTool = {
           isError: true
         };
       }
-      const secondIndex = originalFileContent.indexOf(targetContent, firstIndex + 1);
+      const secondIndex = originalFileContent.indexOf(targetToFind, firstIndex + 1);
       if (secondIndex !== -1) {
         return {
           output: `Error: targetContent matched multiple locations in '${rawPath}'.
@@ -1863,8 +1897,9 @@ var applyPatchTool = {
           isError: true
         };
       }
-      const newFileContent = originalFileContent.slice(0, firstIndex) + replacementContent + originalFileContent.slice(firstIndex + targetContent.length);
+      const newFileContent = originalFileContent.slice(0, firstIndex) + replacementToUse + originalFileContent.slice(firstIndex + targetToFind.length);
       writeFileSync2(filePath, newFileContent, "utf8");
+      ctx.onFileModified?.(rawPath);
       return {
         output: `Successfully applied patch to '${rawPath}'`
       };
@@ -1876,8 +1911,133 @@ var applyPatchTool = {
     }
   }
 };
+// src/security/shell-parser.ts
+function parseShellCommand(commandLine) {
+  const commands = [];
+  const subshellCommands = [];
+  let hasPipes = false;
+  let currentSegment = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let isEscaped = false;
+  const len = commandLine.length;
+  for (let i = 0;i < len; i++) {
+    const char = commandLine[i];
+    if (isEscaped) {
+      currentSegment += char;
+      isEscaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      isEscaped = true;
+      currentSegment += char;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      currentSegment += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      currentSegment += char;
+      continue;
+    }
+    if (inSingleQuote) {
+      currentSegment += char;
+      continue;
+    }
+    if (char === "`") {
+      let endIdx = -1;
+      for (let j = i + 1;j < len; j++) {
+        if (commandLine[j] === "\\" && j + 1 < len) {
+          j++;
+          continue;
+        }
+        if (commandLine[j] === "`") {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx !== -1) {
+        const innerCmd = commandLine.slice(i + 1, endIdx);
+        if (innerCmd.trim()) {
+          subshellCommands.push(innerCmd.trim());
+        }
+        currentSegment += commandLine.slice(i, endIdx + 1);
+        i = endIdx;
+        continue;
+      }
+    }
+    if (char === "$" && i + 1 < len && commandLine[i + 1] === "(") {
+      let depth = 1;
+      let endIdx = -1;
+      for (let j = i + 2;j < len; j++) {
+        if (commandLine[j] === "\\" && j + 1 < len) {
+          j++;
+          continue;
+        }
+        if (commandLine[j] === "(")
+          depth++;
+        else if (commandLine[j] === ")") {
+          depth--;
+          if (depth === 0) {
+            endIdx = j;
+            break;
+          }
+        }
+      }
+      if (endIdx !== -1) {
+        const innerCmd = commandLine.slice(i + 2, endIdx);
+        if (innerCmd.trim()) {
+          subshellCommands.push(innerCmd.trim());
+        }
+        currentSegment += commandLine.slice(i, endIdx + 1);
+        i = endIdx;
+        continue;
+      }
+    }
+    if (!inDoubleQuote) {
+      if (char === "&" && commandLine[i + 1] === "&" || char === "|" && commandLine[i + 1] === "|") {
+        if (currentSegment.trim()) {
+          commands.push(currentSegment.trim());
+        }
+        currentSegment = "";
+        i++;
+        continue;
+      }
+      if (char === "|") {
+        hasPipes = true;
+        if (currentSegment.trim()) {
+          commands.push(currentSegment.trim());
+        }
+        currentSegment = "";
+        continue;
+      }
+      if (char === ";" || char === `
+` || char === "&") {
+        if (currentSegment.trim()) {
+          commands.push(currentSegment.trim());
+        }
+        currentSegment = "";
+        continue;
+      }
+    }
+    currentSegment += char;
+  }
+  if (currentSegment.trim()) {
+    commands.push(currentSegment.trim());
+  }
+  return {
+    commands: commands.filter(Boolean),
+    subshellCommands: subshellCommands.filter(Boolean),
+    hasPipes
+  };
+}
+
 // src/security/exec-policy.ts
 class ExecPolicy {
+  denyRules = [];
   rules = [];
   mode = "auto";
   constructor(initialMode = "auto") {
@@ -1891,12 +2051,24 @@ class ExecPolicy {
     this.mode = mode;
   }
   initDefaultRules() {
-    this.addRule(/^(git\s+(status|log|diff|branch|show|rev-parse))/i, "allow", "Safe git query");
-    this.addRule(/^(ls|dir|cat|type|grep|rg|find|pwd|echo|head|tail|wc|which|where)\b/i, "allow", "Safe read-only shell command");
-    this.addRule(/^(bun\s+(test|--version|-v)|npm\s+(test|--version|-v)|node\s+-v)\b/i, "allow", "Testing & runtime check");
-    this.addRule(/^(rm|del|rmdir|format|mkfs)\b/i, "prompt", "Destructive file removal");
-    this.addRule(/^(git\s+(push|reset\s+--hard|clean\s+-fd|rebase))\b/i, "prompt", "Destructive git operation");
-    this.addRule(/^(curl|wget|fetch|ssh|scp|ftp)\b/i, "prompt", "Network / remote transfer");
+    this.addDenyRule(/(?:^|[/\\])(mkfs|format|fdisk|parted)\b/i, "Destructive filesystem formatting operation");
+    this.addDenyRule(/^dd\s+.*(of=\/dev\/|\/dev\/sd|\/dev\/nvme)/i, "Raw block device write attempt");
+    this.addDenyRule(/(?:^|[/\\])(reboot|shutdown|poweroff|init\s+0)\b/i, "System power manipulation");
+    this.addRule(/^(sudo|su|doas|runas)\b/i, "prompt", "Privilege escalation attempt");
+    this.addRule(/^(rm|del|rmdir|shred|unlink)\b/i, "prompt", "Destructive file removal");
+    this.addRule(/^(chmod|chown|kill|pkill|killall|systemctl|service|crontab)\b/i, "prompt", "System administration & process control");
+    this.addRule(/^(git\s+(push|reset\s+--hard|clean\s+-fd|rebase|branch\s+-D|checkout\s+-f))\b/i, "prompt", "Destructive git operation");
+    this.addRule(/^(curl|wget|fetch|ssh|scp|sftp|ftp|rsync|nc|ncat|netcat|socat|telnet)\b/i, "prompt", "Network & remote transfer");
+    this.addRule(/^(bash|sh|zsh|dash|ksh|cmd(\.exe)?|powershell(\.exe)?|pwsh)\s+(-c|-command|\/c)\b/i, "prompt", "Arbitrary subshell command execution");
+    this.addRule(/^(python|python3|node|bun|perl|ruby)\s+(-c|-e)\b/i, "prompt", "Inline arbitrary code evaluation");
+    this.addRule(/^(eval|exec)\b/i, "prompt", "Dynamic code execution");
+    this.addRule(/^(npm\s+publish|bun\s+publish|cargo\s+publish)\b/i, "prompt", "Package registry publication");
+    this.addRule(/^(git\s+(status|log|diff|branch|show|rev-parse|tag|remote|describe))\b/i, "allow", "Safe git query");
+    this.addRule(/^(ls|dir|cat|type|grep|rg|find|pwd|echo|head|tail|wc|which|where|stat|file|du|df)\b/i, "allow", "Safe read-only shell command");
+    this.addRule(/^(bun\s+(test|run|--version|-v)|npm\s+(test|run|--version|-v)|npx\s+(tsc|eslint|oxlint)|tsc|cargo\s+(check|test|build)|go\s+(test|vet|build)|pytest|python\s+-m\s+unittest|node\s+(-v|--version|--test))\b/i, "allow", "Testing, typechecking & build verification");
+  }
+  addDenyRule(pattern, description) {
+    this.denyRules.push({ pattern, decision: "deny", description });
   }
   addRule(pattern, decision, description) {
     this.rules.unshift({ pattern, decision, description });
@@ -1919,8 +2091,49 @@ class ExecPolicy {
   }
   evaluate(command) {
     const trimmed = command.trim();
+    if (!trimmed) {
+      return { decision: "allow" };
+    }
+    const parsed = parseShellCommand(trimmed);
+    const subCommands = [...parsed.commands, ...parsed.subshellCommands].map((c) => c.trim()).filter(Boolean);
+    if (subCommands.length > 1 || parsed.subshellCommands.length > 0) {
+      for (const subCmd of subCommands) {
+        const subResult = this.evaluateSingle(subCmd);
+        if (subResult.decision === "deny") {
+          return {
+            decision: "deny",
+            reason: `Chained command contains denied operation: '${subCmd}' (${subResult.reason || "Forbidden"})`
+          };
+        }
+        if (subResult.decision === "prompt") {
+          return {
+            decision: "prompt",
+            reason: `Chained command contains operation requiring confirmation: '${subCmd}' (${subResult.reason || "Requires approval"})`
+          };
+        }
+      }
+      if (parsed.hasPipes && /\|\s*(ba|z|k|c)?sh\b/i.test(trimmed)) {
+        return {
+          decision: "prompt",
+          reason: "Pipeline executes piped input directly into shell interpreter (| sh)"
+        };
+      }
+      return { decision: "allow", reason: "All chained sub-commands are permitted" };
+    }
+    return this.evaluateSingle(trimmed);
+  }
+  evaluateSingle(command) {
+    const trimmed = command.trim();
+    for (const rule of this.denyRules) {
+      if (rule.pattern.test(trimmed)) {
+        return {
+          decision: "deny",
+          reason: rule.description
+        };
+      }
+    }
     if (this.mode === "plan") {
-      const isReadOnly = /^(git\s+(status|log|diff|branch|show|rev-parse)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show|rev-parse|tag|remote)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
       if (isReadOnly) {
         return { decision: "allow", reason: "Read-only inspection allowed in Plan mode" };
       }
@@ -1936,7 +2149,7 @@ class ExecPolicy {
       };
     }
     if (this.mode === "accept-edits") {
-      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|bun\s+test|npm\s+test)\b/i.test(trimmed);
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show|rev-parse)|ls|dir|cat|type|grep|rg|find|pwd|bun\s+test|npm\s+test)\b/i.test(trimmed);
       if (isReadOnly) {
         return { decision: "allow", reason: "Safe read-only command in accept-edits mode" };
       }
@@ -1953,11 +2166,21 @@ class ExecPolicy {
         };
       }
     }
+    if (this.isRecognizedSafeDevCommand(trimmed)) {
+      return {
+        decision: "allow",
+        reason: "Safe development workspace command"
+      };
+    }
+    const firstWord = trimmed.split(/\s+/)[0] || trimmed;
     return {
-      decision: "allow",
-      reason: "Auto mode allows execution"
+      decision: "prompt",
+      reason: `Command '${firstWord}' is unclassified and requires confirmation in auto mode`
     };
   }
+  isRecognizedSafeDevCommand(command) {
+    return /^(git\s+(checkout|add|commit|stash|merge|pull|init)|bun\s+(install|add|remove)|npm\s+(install|i|add|remove)|yarn\s+(add|remove)|pnpm\s+(add|remove|install)|mkdir|touch|cp|copy|mv|move|clear|cls|echo|printf|node|bun|python|python3|cargo|go)\b/i.test(command);
+  }
 }
 
 // src/security/kernel/windows.ts
@@ -2060,8 +2283,12 @@ class LinuxSandbox {
     }
     this.hasBwrap = existsSync4("/usr/bin/bwrap") || existsSync4("/bin/bwrap") || existsSync4("/usr/local/bin/bwrap");
   }
-  wrapCommand(cmd, profile) {
-    if (!this.hasBwrap || profile.kind === "danger-unrestricted") {
+  wrapCommand(cmd, profile, onWarning) {
+    if (profile.kind === "danger-unrestricted") {
+      return cmd;
+    }
+    if (!this.hasBwrap) {
+      onWarning?.("Linux kernel sandbox (Bubblewrap / bwrap) is not available. Command will execute without OS-level namespace isolation.");
       return cmd;
     }
     const bwrapArgs = [
@@ -2077,6 +2304,23 @@ class LinuxSandbox {
       "--tmpfs",
       "/tmp"
     ];
+    const homeDir = process.env.HOME || "/root";
+    const sensitivePaths = [
+      `${homeDir}/.ssh`,
+      `${homeDir}/.aws`,
+      `${homeDir}/.gnupg`,
+      `${homeDir}/.azure`,
+      `${homeDir}/.kube`,
+      `${homeDir}/.docker`,
+      `${homeDir}/.netrc`,
+      "/etc/shadow",
+      "/etc/sudoers"
+    ];
+    for (const sensitive of sensitivePaths) {
+      if (existsSync4(sensitive)) {
+        bwrapArgs.push("--tmpfs", sensitive);
+      }
+    }
     for (const writableRoot of profile.writableRoots) {
       bwrapArgs.push("--bind", writableRoot, writableRoot);
     }
@@ -2126,11 +2370,21 @@ class MacOSSandbox {
     } else {
       rules.push("(deny network*)");
     }
+    const home = process.env.HOME || "/Users/Shared";
+    rules.push(`(deny file-read* (subpath "${home}/.ssh"))`);
+    rules.push(`(deny file-read* (subpath "${home}/.aws"))`);
+    rules.push(`(deny file-read* (subpath "${home}/.gnupg"))`);
+    rules.push(`(deny file-read* (subpath "${home}/.kube"))`);
+    rules.push(`(deny file-read* (subpath "${home}/.docker"))`);
     return rules.join(`
 `);
   }
-  wrapCommand(cmd, profile) {
-    if (!this.hasSandboxExec || profile.kind === "danger-unrestricted") {
+  wrapCommand(cmd, profile, onWarning) {
+    if (profile.kind === "danger-unrestricted") {
+      return cmd;
+    }
+    if (!this.hasSandboxExec) {
+      onWarning?.("macOS Seatbelt (sandbox-exec) is not available. Command will execute without OS-level namespace isolation.");
       return cmd;
     }
     const policy = this.generateProfile(profile);
@@ -2163,7 +2417,7 @@ class KernelSandboxManager {
       isSandboxingActive: this.windowsSandbox.isSupported() || this.linuxSandbox.isSupported() || this.macOsSandbox.isSupported()
     };
   }
-  buildDefaultProfile(cwd, allowNetwork = true) {
+  buildDefaultProfile(cwd, allowNetwork = false) {
     const normCwd = normalize(resolve4(cwd));
     return {
       kind: "workspace-write",
@@ -2178,11 +2432,15 @@ class KernelSandboxManager {
       }
     };
   }
-  wrapCommand(cmd, profile) {
+  wrapCommand(cmd, profile, onWarning) {
     if (process.platform === "linux") {
-      return this.linuxSandbox.wrapCommand(cmd, profile);
+      return this.linuxSandbox.wrapCommand(cmd, profile, onWarning);
     } else if (process.platform === "darwin") {
-      return this.macOsSandbox.wrapCommand(cmd, profile);
+      return this.macOsSandbox.wrapCommand(cmd, profile, onWarning);
+    } else if (process.platform === "win32") {
+      if (!this.windowsSandbox.isSupported() && profile.kind !== "danger-unrestricted") {
+        onWarning?.("Windows JobObject isolation is not available in this environment. Command will execute without OS-level process limits.");
+      }
     }
     return cmd;
   }
@@ -2314,6 +2572,12 @@ class PrefixRulesStore {
   matchesPrefix(cmdTokens, prefixTokens) {
     if (prefixTokens.length > cmdTokens.length)
       return false;
+    const SHELL_OPERATORS = new Set([";", "&&", "||", "|", "&", ";;", "&|"]);
+    for (const token of cmdTokens) {
+      if (SHELL_OPERATORS.has(token) || token.includes(";") || token.includes("&&") || token.includes("||")) {
+        return false;
+      }
+    }
     for (let i = 0;i < prefixTokens.length; i++) {
       const cmd = cmdTokens[i];
       const prefix = prefixTokens[i];
@@ -2439,11 +2703,29 @@ function createShellTool(policy = new ExecPolicy) {
       }
       const args = rawArgs;
       const rulesStore = ctx.prefixRulesStore || globalPrefixRulesStore;
-      const cmdTokens = command.split(/\s+/).filter(Boolean);
+      const activePolicy = ctx.execPolicy || policy;
+      const policyDecision = activePolicy.evaluate(command);
+      if (policyDecision.decision === "deny") {
+        return {
+          output: `Error: Command execution denied by policy: ${policyDecision.reason}`,
+          isError: true
+        };
+      }
+      const parsed = parseShellCommand(command);
+      const isCompound = parsed.commands.length > 1 || parsed.subshellCommands.length > 0 || parsed.hasPipes;
       let isEscalated = false;
-      if (rulesStore.isApproved(ctx.cwd, cmdTokens)) {
-        isEscalated = true;
-      } else if (args.sandbox_permissions === "require_escalated") {
+      if (!isCompound) {
+        const cmdTokens = command.split(/\s+/).filter(Boolean);
+        if (rulesStore.isApproved(ctx.cwd, cmdTokens)) {
+          isEscalated = true;
+        }
+      } else {
+        const allSubCommands = [...parsed.commands, ...parsed.subshellCommands];
+        if (allSubCommands.length > 0 && allSubCommands.every((sub) => rulesStore.isApproved(ctx.cwd, sub.split(/\s+/).filter(Boolean)))) {
+          isEscalated = true;
+        }
+      }
+      if (!isEscalated && args.sandbox_permissions === "require_escalated") {
         if (ctx.requestApproval) {
           const promptDesc = args.justification || "Executing command with escalated permissions";
           const approvalResult = await ctx.requestApproval(promptDesc, command, args.prefix_rule);
@@ -2461,16 +2743,8 @@ function createShellTool(policy = new ExecPolicy) {
           isEscalated = true;
         }
       }
-      if (!isEscalated) {
-        const activePolicy = ctx.execPolicy || policy;
-        const policyDecision = activePolicy.evaluate(command);
-        if (policyDecision.decision === "deny") {
-          return {
-            output: `Error: Command execution denied by policy: ${policyDecision.reason}`,
-            isError: true
-          };
-        }
-        if (policyDecision.decision === "prompt" && ctx.requestApproval) {
+      if (policyDecision.decision === "prompt" && !isEscalated) {
+        if (ctx.requestApproval) {
           const approvalResult = await ctx.requestApproval(policyDecision.reason || "Executing external command", command);
           const isAllowed = typeof approvalResult === "boolean" ? approvalResult : approvalResult?.allowed;
           if (!isAllowed) {
@@ -2479,17 +2753,22 @@ function createShellTool(policy = new ExecPolicy) {
               isError: true
             };
           }
+        } else {
+          return {
+            output: `Error: Command execution requires user confirmation: '${command}' (${policyDecision.reason || "Requires approval"})`,
+            isError: true
+          };
         }
       }
       const timeoutMs = typeof args.timeoutMs === "number" ? args.timeoutMs : 30000;
       const isWindows = process.platform === "win32";
       const baseCmd = isWindows ? ["cmd.exe", "/d", "/s", "/c", command] : ["/bin/sh", "-c", command];
       const ephemeralScratchpad = globalEphemeralWorkspace.createScratchpad(ctx.turnId);
-      const sandboxProfile = globalKernelSandbox.buildDefaultProfile(ctx.cwd);
-      if (isEscalated) {
-        sandboxProfile.allowNetwork = true;
-      }
-      const wrappedCmd = globalKernelSandbox.wrapCommand(baseCmd, sandboxProfile);
+      const sandboxProfile = globalKernelSandbox.buildDefaultProfile(ctx.cwd, isEscalated);
+      let sandboxNotice = null;
+      const wrappedCmd = globalKernelSandbox.wrapCommand(baseCmd, sandboxProfile, (w) => {
+        sandboxNotice = w;
+      });
       try {
         const proc = Bun.spawn(wrappedCmd, {
           cwd: ctx.cwd,
@@ -2543,10 +2822,38 @@ ${result.stderr.trim()}`);
 2. If this is a test failure, trace the failure in source code and fix the root cause before re-running.
 3. If this is a missing command/module, install or configure the prerequisite.`);
         }
-        const output = outputParts.join(`
+        let rawOutput = outputParts.join(`
 `) || "[Command completed with no output]";
+        const lines = rawOutput.split(`
+`);
+        const MAX_LINES = 250;
+        const MAX_CHARS = 30000;
+        if (lines.length > MAX_LINES) {
+          const headLines = lines.slice(0, 125).join(`
+`);
+          const tailLines = lines.slice(-100).join(`
+`);
+          rawOutput = `${headLines}
+
+... [${lines.length - 225} lines truncated for context efficiency] ...
+
+${tailLines}`;
+        }
+        if (rawOutput.length > MAX_CHARS) {
+          const headChars = rawOutput.slice(0, 16000);
+          const tailChars = rawOutput.slice(-12000);
+          rawOutput = `${headChars}
+
+... [${rawOutput.length - 28000} characters truncated for context efficiency] ...
+
+${tailChars}`;
+        }
+        if (sandboxNotice) {
+          rawOutput = `[Sandbox Notice]: ${sandboxNotice}
+${rawOutput}`;
+        }
         return {
-          output,
+          output: rawOutput,
           isError: result.code !== 0
         };
       } catch (err) {
@@ -2565,31 +2872,119 @@ ${result.stderr.trim()}`);
 }
 var shellTool = createShellTool();
 // src/tools/handlers/file-ops.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync8, statSync as statSync3, mkdirSync as mkdirSync6 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync8, statSync as statSync3, lstatSync, mkdirSync as mkdirSync6 } from "fs";
 import { resolve as resolve6, dirname as dirname4 } from "path";
+var DEFAULT_MAX_UNPAGINATED_LINES = 250;
 var readFileTool = {
   name: "read_file",
-  description: "Read the full text content of a file.",
+  description: "Read file content with surgical line-range support. Supports start_line and end_line to inspect specific sections of large files without exhausting token context.",
   parameters: {
     type: "object",
     properties: {
-      path: { type: "string", description: "Relative or absolute path to the file." }
+      path: {
+        type: "string",
+        description: "Relative or absolute path to the file."
+      },
+      start_line: {
+        type: "number",
+        description: "Optional 1-indexed line number to start reading from (e.g. 120)."
+      },
+      end_line: {
+        type: "number",
+        description: "Optional 1-indexed line number to end reading at, inclusive (e.g. 180)."
+      },
+      offset: {
+        type: "number",
+        description: "Alias for start_line (1-indexed)."
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read."
+      },
+      line_numbers: {
+        type: "boolean",
+        description: "Whether to include line number prefixes ('<line>: <content>'). Defaults to true for range reads."
+      }
     },
     required: ["path"]
   },
   async execute(args, ctx) {
-    const filePath = resolve6(ctx.cwd, String(args.path || ""));
+    const rawPath = String(args.path || "");
+    const filePath = resolve6(ctx.cwd, rawPath);
     if (!existsSync8(filePath)) {
-      return { output: `Error: File not found: '${args.path}'`, isError: true };
+      return { output: `Error: File not found: '${rawPath}'`, isError: true };
     }
     try {
       const content = readFileSync3(filePath, "utf8");
-      return { output: content };
+      const lines = content.split(/\r?\n/);
+      const totalLines = lines.length;
+      const hasRange = args.start_line !== undefined || args.end_line !== undefined || args.startLine !== undefined || args.endLine !== undefined || args.offset !== undefined || args.limit !== undefined;
+      if (!hasRange) {
+        if (args.line_numbers === true) {
+          const formatted = lines.map((l, idx) => `${idx + 1}: ${l}`).join(`
+`);
+          return { output: formatted };
+        }
+        if (totalLines <= DEFAULT_MAX_UNPAGINATED_LINES) {
+          return { output: content };
+        }
+        const truncated = lines.slice(0, DEFAULT_MAX_UNPAGINATED_LINES);
+        const formatted = truncated.map((l, idx) => `${idx + 1}: ${l}`).join(`
+`);
+        return {
+          output: `[Showing lines 1 to ${DEFAULT_MAX_UNPAGINATED_LINES} of ${totalLines} in '${rawPath}']
+${formatted}
+
+[Truncated: ${totalLines - DEFAULT_MAX_UNPAGINATED_LINES} more lines. Use start_line=${DEFAULT_MAX_UNPAGINATED_LINES + 1} to continue reading.]`
+        };
+      }
+      const startArg = args.start_line ?? args.startLine ?? args.offset;
+      const start = Math.max(1, typeof startArg === "number" ? Math.floor(startArg) : 1);
+      let end;
+      const endArg = args.end_line ?? args.endLine;
+      if (typeof endArg === "number") {
+        end = Math.min(totalLines, Math.floor(endArg));
+      } else if (typeof args.limit === "number") {
+        end = Math.min(totalLines, start + Math.floor(args.limit) - 1);
+      } else {
+        end = Math.min(totalLines, start + DEFAULT_MAX_UNPAGINATED_LINES - 1);
+      }
+      if (start > totalLines) {
+        return {
+          output: `Error: start_line (${start}) exceeds total lines in file (${totalLines}).`,
+          isError: true
+        };
+      }
+      if (end < start) {
+        return {
+          output: `Error: end_line (${end}) cannot be less than start_line (${start}).`,
+          isError: true
+        };
+      }
+      const sliced = lines.slice(start - 1, end);
+      const withNums = args.line_numbers !== false;
+      const rendered = withNums ? sliced.map((l, idx) => `${start + idx}: ${l}`).join(`
+`) : sliced.join(`
+`);
+      let notice = `[Showing lines ${start} to ${end} of ${totalLines} in '${rawPath}']
+${rendered}`;
+      if (end < totalLines) {
+        notice += `
+
+[File has ${totalLines} lines. To read further, use start_line=${end + 1}.]`;
+      }
+      return { output: notice };
     } catch (err) {
       return { output: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
     }
   }
 };
+var viewFileTool = {
+  ...readFileTool,
+  name: "view_file",
+  description: "View file content with surgical line-range support. Alias for read_file matching Antigravity & Claude Code conventions."
+};
+var DEFAULT_MAX_DIR_ENTRIES = 500;
 var listDirTool = {
   name: "list_dir",
   description: "List contents of a directory with file names and types.",
@@ -2606,13 +3001,31 @@ var listDirTool = {
     }
     try {
       const entries = readdirSync3(dirPath);
-      const formatted = entries.map((entry) => {
+      const totalEntries = entries.length;
+      const displayEntries = entries.slice(0, DEFAULT_MAX_DIR_ENTRIES);
+      const formatted = displayEntries.map((entry) => {
         const full = resolve6(dirPath, entry);
-        const isDir = statSync3(full).isDirectory();
+        let isDir = false;
+        try {
+          isDir = statSync3(full).isDirectory();
+        } catch {
+          try {
+            const lst = lstatSync(full);
+            if (lst.isSymbolicLink())
+              return `[SYMLINK] ${entry}`;
+          } catch {}
+          return `[FILE] ${entry}`;
+        }
         return `${isDir ? "[DIR]" : "[FILE]"} ${entry}`;
       });
-      return { output: formatted.join(`
-`) || "[Empty directory]" };
+      let output = formatted.join(`
+`) || "[Empty directory]";
+      if (totalEntries > DEFAULT_MAX_DIR_ENTRIES) {
+        output += `
+
+... [Truncated: ${totalEntries - DEFAULT_MAX_DIR_ENTRIES} more entries. Showing first ${DEFAULT_MAX_DIR_ENTRIES} of ${totalEntries}]`;
+      }
+      return { output };
     } catch (err) {
       return { output: `Failed to list directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
     }
@@ -2653,6 +3066,7 @@ var writeFileTool = {
     try {
       mkdirSync6(dirname4(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
+      ctx.onFileModified?.(rawPath);
       return { output: `Successfully wrote to '${args.path}'` };
     } catch (err) {
       return {
@@ -3103,7 +3517,13 @@ function createFileSearchTools(engine = new FileSearchEngine) {
 `) };
     }
   };
-  return [grepSearchTool, findFilesTool];
+  const findByNameTool = {
+    name: "find_by_name",
+    description: "Search for files and directories across the workspace matching a name or glob pattern. Alias for find_files matching Antigravity & Claude Code conventions.",
+    parameters: findFilesTool.parameters,
+    execute: findFilesTool.execute
+  };
+  return [grepSearchTool, findFilesTool, findByNameTool];
 }
 
 // src/code-mode/tools-proxy.ts
@@ -3140,6 +3560,12 @@ class CodeModeToolsProxy {
           if (result.isError) {
             throw new Error(`Tool '${tool.name}' failed: ${result.output}`);
           }
+          if (normalizedName === "write_file" || normalizedName === "apply_patch" || tool.name === "write_file" || tool.name === "apply_patch") {
+            const pathArg = String(args?.path || "");
+            if (pathArg) {
+              this.context.onFileModified?.(pathArg);
+            }
+          }
           return result.output;
         };
       }
@@ -3213,6 +3639,9 @@ class SandboxedWorkerHost {
       const fetch = undefined;
       const XMLHttpRequest = undefined;
       const WebSocket = undefined;
+      const globalThis = Object.freeze(Object.create(null));
+      const global = undefined;
+      const window = undefined;
       
       return (async () => {
         ${cleanCode}
@@ -3622,6 +4051,7 @@ function createDefaultTools(options = {}) {
   router2.register(applyPatchTool);
   router2.register(shellTool);
   router2.register(readFileTool);
+  router2.register(viewFileTool);
   router2.register(writeFileTool);
   router2.register(listDirTool);
   router2.register(requestUserInputTool);
@@ -4222,14 +4652,39 @@ function compactHistory(history, retainedRecentItems = 6) {
   if (history.length <= retainedRecentItems) {
     return [...history];
   }
-  const itemsToCompact = history.slice(0, history.length - retainedRecentItems);
-  const recentItems = history.slice(history.length - retainedRecentItems);
+  const targetCutoff = history.length - retainedRecentItems;
+  let bestCutoff = -1;
+  for (let i = targetCutoff;i >= 0; i--) {
+    if (history[i]?.type === "user_message") {
+      bestCutoff = i;
+      break;
+    }
+  }
+  if (bestCutoff <= 0) {
+    for (let i = targetCutoff + 1;i < history.length; i++) {
+      if (history[i]?.type === "user_message") {
+        bestCutoff = i;
+        break;
+      }
+    }
+  }
+  let cutoffIndex = bestCutoff > 0 ? bestCutoff : targetCutoff;
+  while (cutoffIndex < history.length && history[cutoffIndex]?.type === "function_call_output") {
+    cutoffIndex++;
+  }
+  if (cutoffIndex <= 0 || cutoffIndex >= history.length) {
+    return [...history];
+  }
+  const itemsToCompact = history.slice(0, cutoffIndex);
+  const recentItems = history.slice(cutoffIndex);
   const summaryParts = ["### Summary of previous conversation context:"];
   for (const item of itemsToCompact) {
     if (item.type === "user_message") {
       summaryParts.push(`- User: ${item.content.slice(0, 200)}`);
     } else if (item.type === "function_call") {
       summaryParts.push(`- Executed tool: ${item.name}`);
+    } else if (item.type === "function_call_output") {
+      summaryParts.push(`  Tool output: ${item.output.slice(0, 100)}`);
     } else if (item.type === "agent_message") {
       summaryParts.push(`- Assistant: ${item.content.slice(0, 200)}`);
     }
@@ -4268,7 +4723,741 @@ class TurnContext {
     this.abortController.abort(new Error(reason));
   }
 }
+// src/verification/verifier.ts
+import { spawn, spawnSync } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
 
+// src/init/project-analyzer.ts
+import { existsSync as existsSync13, readFileSync as readFileSync8, readdirSync as readdirSync6 } from "fs";
+import { join as join7, basename } from "path";
+
+class ProjectAnalyzer {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  analyze() {
+    const readmeInfo = this.extractReadmeMetadata();
+    const projectName = readmeInfo.title || this.detectProjectName();
+    const languages = this.detectLanguages();
+    const packageManager = this.detectPackageManager();
+    const frameworks = [];
+    const infrastructure = [];
+    const commands = {};
+    const architectureNotes = [];
+    const codeConventions = [];
+    let description = readmeInfo.description;
+    const pkgPath = join7(this.cwd, "package.json");
+    if (existsSync13(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+        if (!description && pkg.description)
+          description = pkg.description;
+        const pm = packageManager || "npm";
+        const runPrefix = pm === "bun" || pm === "yarn" || pm === "pnpm" ? `${pm} run` : "npm run";
+        const testPrefix = pm === "bun" ? "bun test" : pm === "pnpm" ? "pnpm test" : pm === "yarn" ? "yarn test" : "npm test";
+        if (pkg.scripts) {
+          if (pkg.scripts.dev)
+            commands.dev = `${runPrefix} dev`;
+          else if (pkg.scripts.start)
+            commands.dev = `${runPrefix} start`;
+          if (pkg.scripts.build)
+            commands.build = `${runPrefix} build`;
+          if (pkg.scripts.test)
+            commands.test = pkg.scripts.test === "bun test" ? "bun test" : testPrefix;
+          if (pkg.scripts.typecheck)
+            commands.typecheck = `${runPrefix} typecheck`;
+          else if (pkg.scripts.check)
+            commands.typecheck = `${runPrefix} check`;
+          if (pkg.scripts.lint)
+            commands.lint = `${runPrefix} lint`;
+          if (pkg.scripts.format)
+            commands.format = `${runPrefix} format`;
+        }
+        const allDeps = {
+          ...pkg.dependencies || {},
+          ...pkg.devDependencies || {}
+        };
+        if (allDeps.next)
+          frameworks.push("Next.js");
+        if (allDeps.react)
+          frameworks.push("React");
+        if (allDeps.vue)
+          frameworks.push("Vue.js");
+        if (allDeps.svelte || allDeps["@sveltejs/kit"])
+          frameworks.push("Svelte");
+        if (allDeps.astro)
+          frameworks.push("Astro");
+        if (allDeps.vite)
+          frameworks.push("Vite");
+        if (allDeps.express)
+          frameworks.push("Express");
+        if (allDeps.hono)
+          frameworks.push("Hono");
+        if (allDeps.fastify)
+          frameworks.push("Fastify");
+        if (allDeps["@nestjs/core"])
+          frameworks.push("NestJS");
+        if (allDeps.tailwindcss)
+          frameworks.push("TailwindCSS");
+        if (allDeps["lucide-react"] || allDeps.lucide)
+          frameworks.push("Lucide Icons");
+        if (allDeps.zustand)
+          frameworks.push("Zustand");
+        if (allDeps["@tanstack/react-query"])
+          frameworks.push("TanStack Query");
+        if (allDeps.oxlint)
+          frameworks.push("Oxlint");
+        if (allDeps.eslint)
+          frameworks.push("ESLint");
+        if (allDeps.vitest)
+          frameworks.push("Vitest");
+        if (allDeps.jest)
+          frameworks.push("Jest");
+        if (allDeps.playwright || allDeps["@playwright/test"])
+          frameworks.push("Playwright");
+        if (pkg.type === "module") {
+          codeConventions.push("Use ES modules (`import/export`), not CommonJS (`require`).");
+        }
+      } catch {}
+    }
+    const tsconfigPath = join7(this.cwd, "tsconfig.json");
+    if (existsSync13(tsconfigPath)) {
+      try {
+        const tsconfig = JSON.parse(readFileSync8(tsconfigPath, "utf8"));
+        if (tsconfig.compilerOptions?.strict) {
+          codeConventions.push("TypeScript strict mode enabled.");
+        }
+        if (!commands.typecheck) {
+          commands.typecheck = "tsc --noEmit";
+        }
+      } catch {}
+    }
+    const cargoPath = join7(this.cwd, "Cargo.toml");
+    if (existsSync13(cargoPath)) {
+      try {
+        commands.dev = commands.dev || "cargo run";
+        commands.build = commands.build || "cargo build";
+        commands.test = commands.test || "cargo test";
+        commands.lint = commands.lint || "cargo clippy";
+        frameworks.push("Rust Cargo");
+      } catch {}
+    }
+    const goModPath = join7(this.cwd, "go.mod");
+    if (existsSync13(goModPath)) {
+      try {
+        commands.dev = commands.dev || "go run .";
+        commands.build = commands.build || "go build ./...";
+        commands.test = commands.test || "go test ./...";
+        commands.lint = commands.lint || "golangci-lint run";
+        frameworks.push("Go Modules");
+      } catch {}
+    }
+    const pyprojectPath = join7(this.cwd, "pyproject.toml");
+    const requirementsPath = join7(this.cwd, "requirements.txt");
+    if (existsSync13(pyprojectPath) || existsSync13(requirementsPath)) {
+      commands.test = commands.test || "pytest";
+      commands.lint = commands.lint || "ruff check .";
+      if (existsSync13(join7(this.cwd, "uv.lock"))) {
+        frameworks.push("uv");
+        commands.test = "uv run pytest";
+      } else if (existsSync13(join7(this.cwd, "poetry.lock"))) {
+        frameworks.push("Poetry");
+        commands.test = "poetry run pytest";
+      }
+    }
+    if (existsSync13(join7(this.cwd, "Dockerfile"))) {
+      infrastructure.push("Docker");
+      const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
+      commands.dockerBuild = `docker build -t ${sanitizedName || "app"} .`;
+    }
+    if (existsSync13(join7(this.cwd, "nginx.conf"))) {
+      infrastructure.push("Nginx");
+    }
+    if (existsSync13(join7(this.cwd, "src/api.ts")) || existsSync13(join7(this.cwd, "src/api"))) {
+      architectureNotes.push("Backend API endpoints and network client logic are centralized in `src/api`.");
+    }
+    if (existsSync13(join7(this.cwd, "src/components"))) {
+      architectureNotes.push("Reusable UI presentation components live in `src/components/`.");
+    }
+    if (existsSync13(join7(this.cwd, "src/types.ts")) || existsSync13(join7(this.cwd, "src/types"))) {
+      architectureNotes.push("Shared TypeScript data models and interfaces are defined in `src/types`.");
+    }
+    if (existsSync13(join7(this.cwd, ".env.example"))) {
+      architectureNotes.push("Environment configuration template is in `.env.example`.");
+    }
+    if (commands.typecheck || commands.lint || commands.test) {
+      const checks = [];
+      if (commands.typecheck)
+        checks.push(`typecheck (\`${commands.typecheck}\`)`);
+      if (commands.lint)
+        checks.push(`lint (\`${commands.lint}\`)`);
+      if (commands.test)
+        checks.push(`tests (\`${commands.test}\`)`);
+      codeConventions.push(`Run ${checks.join(" and ")} before concluding any major code edits.`);
+    }
+    const instructionFiles = ["AGENTS.md", "CLAUDE.md", ".agents.md", "AGENTS.override.md"];
+    let hasExistingInstructions = false;
+    let existingInstructionFile;
+    for (const f of instructionFiles) {
+      if (existsSync13(join7(this.cwd, f))) {
+        hasExistingInstructions = true;
+        existingInstructionFile = f;
+        break;
+      }
+    }
+    return {
+      projectName,
+      description,
+      languages,
+      packageManager,
+      frameworks,
+      infrastructure,
+      commands,
+      architectureNotes,
+      codeConventions,
+      hasExistingInstructions,
+      existingInstructionFile
+    };
+  }
+  generateAgentsMarkdown(analysis) {
+    const lines = [];
+    lines.push(`# ${analysis.projectName}`);
+    lines.push("");
+    if (analysis.description) {
+      lines.push(`> ${analysis.description}`);
+      lines.push("");
+    }
+    lines.push("## Commands");
+    lines.push("");
+    if (Object.keys(analysis.commands).length > 0) {
+      if (analysis.commands.dev)
+        lines.push(`- **Dev Server**: \`${analysis.commands.dev}\``);
+      if (analysis.commands.build)
+        lines.push(`- **Build**: \`${analysis.commands.build}\``);
+      if (analysis.commands.test)
+        lines.push(`- **Test**: \`${analysis.commands.test}\``);
+      if (analysis.commands.typecheck)
+        lines.push(`- **Typecheck**: \`${analysis.commands.typecheck}\``);
+      if (analysis.commands.lint)
+        lines.push(`- **Lint**: \`${analysis.commands.lint}\``);
+      if (analysis.commands.format)
+        lines.push(`- **Format**: \`${analysis.commands.format}\``);
+      if (analysis.commands.dockerBuild)
+        lines.push(`- **Docker Build**: \`${analysis.commands.dockerBuild}\``);
+    } else {
+      lines.push("- *No standard build/test commands detected.*");
+    }
+    lines.push("");
+    lines.push("## Architecture & Stack");
+    lines.push("");
+    const stackItems = [];
+    if (analysis.languages.length > 0)
+      stackItems.push(analysis.languages.join(", "));
+    if (analysis.frameworks.length > 0)
+      stackItems.push(analysis.frameworks.join(", "));
+    if (analysis.infrastructure.length > 0)
+      stackItems.push(analysis.infrastructure.join(", "));
+    if (stackItems.length > 0) {
+      lines.push(`- **Core Stack**: ${stackItems.join(" \u2022 ")}`);
+    }
+    for (const note of analysis.architectureNotes) {
+      lines.push(`- ${note}`);
+    }
+    lines.push("");
+    lines.push("## Workflow & Code Guidelines");
+    lines.push("");
+    if (analysis.codeConventions.length > 0) {
+      for (const conv of analysis.codeConventions) {
+        lines.push(`- ${conv}`);
+      }
+    }
+    lines.push("- Prefer targeted edits over whole-file rewrites.");
+    lines.push("- When fixing errors, address the root cause rather than suppressing compiler warnings.");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  extractReadmeMetadata() {
+    const readmeFiles = ["README.md", "readme.md", "README.MD"];
+    for (const file of readmeFiles) {
+      const fullPath = join7(this.cwd, file);
+      if (existsSync13(fullPath)) {
+        try {
+          const content = readFileSync8(fullPath, "utf8");
+          const lines = content.split(`
+`);
+          let title;
+          let description;
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!title && trimmed.startsWith("# ")) {
+              title = trimmed.replace(/^#\s+/, "").trim();
+              continue;
+            }
+            if (title && !description && trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("```") && !trimmed.startsWith("[")) {
+              description = trimmed;
+              break;
+            }
+          }
+          return { title, description };
+        } catch {}
+      }
+    }
+    return {};
+  }
+  detectProjectName() {
+    const pkgPath = join7(this.cwd, "package.json");
+    if (existsSync13(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+        if (pkg.name && pkg.name !== "frontend" && pkg.name !== "backend" && pkg.name !== "app") {
+          return pkg.name.startsWith("@") ? pkg.name.split("/")[1] || pkg.name : pkg.name;
+        }
+      } catch {}
+    }
+    const cargoPath = join7(this.cwd, "Cargo.toml");
+    if (existsSync13(cargoPath)) {
+      try {
+        const match = readFileSync8(cargoPath, "utf8").match(/name\s*=\s*"([^"]+)"/);
+        if (match?.[1])
+          return match[1];
+      } catch {}
+    }
+    const goModPath = join7(this.cwd, "go.mod");
+    if (existsSync13(goModPath)) {
+      try {
+        const match = readFileSync8(goModPath, "utf8").match(/module\s+([^\s]+)/);
+        if (match?.[1])
+          return basename(match[1]);
+      } catch {}
+    }
+    return basename(this.cwd);
+  }
+  detectLanguages() {
+    const langs = new Set;
+    if (existsSync13(join7(this.cwd, "tsconfig.json")) || this.hasFileWithExtension(".ts", ".tsx")) {
+      langs.add("TypeScript");
+    }
+    if (existsSync13(join7(this.cwd, "package.json")) || this.hasFileWithExtension(".js", ".jsx", ".mjs")) {
+      langs.add("JavaScript");
+    }
+    if (existsSync13(join7(this.cwd, "Cargo.toml")) || this.hasFileWithExtension(".rs")) {
+      langs.add("Rust");
+    }
+    if (existsSync13(join7(this.cwd, "go.mod")) || this.hasFileWithExtension(".go")) {
+      langs.add("Go");
+    }
+    if (existsSync13(join7(this.cwd, "pyproject.toml")) || existsSync13(join7(this.cwd, "requirements.txt")) || this.hasFileWithExtension(".py")) {
+      langs.add("Python");
+    }
+    if (existsSync13(join7(this.cwd, "pom.xml")) || existsSync13(join7(this.cwd, "build.gradle")) || this.hasFileWithExtension(".java")) {
+      langs.add("Java");
+    }
+    if (existsSync13(join7(this.cwd, "CMakeLists.txt")) || this.hasFileWithExtension(".cpp", ".c", ".h", ".hpp")) {
+      langs.add("C/C++");
+    }
+    return Array.from(langs);
+  }
+  detectPackageManager() {
+    if (existsSync13(join7(this.cwd, "bun.lockb")) || existsSync13(join7(this.cwd, "bun.lock")))
+      return "bun";
+    if (existsSync13(join7(this.cwd, "pnpm-lock.yaml")))
+      return "pnpm";
+    if (existsSync13(join7(this.cwd, "yarn.lock")))
+      return "yarn";
+    if (existsSync13(join7(this.cwd, "package-lock.json")))
+      return "npm";
+    if (existsSync13(join7(this.cwd, "Cargo.lock")) || existsSync13(join7(this.cwd, "Cargo.toml")))
+      return "cargo";
+    if (existsSync13(join7(this.cwd, "uv.lock")))
+      return "uv";
+    if (existsSync13(join7(this.cwd, "poetry.lock")))
+      return "poetry";
+    if (existsSync13(join7(this.cwd, "go.sum")) || existsSync13(join7(this.cwd, "go.mod")))
+      return "go";
+    if (existsSync13(join7(this.cwd, "package.json")))
+      return "npm";
+    return;
+  }
+  hasFileWithExtension(...exts) {
+    try {
+      const entries = readdirSync6(this.cwd);
+      return entries.some((e) => exts.some((ext) => e.endsWith(ext)));
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/verification/verifier.ts
+class AutoVerifier {
+  cwd;
+  customCommand;
+  timeoutMs;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.customCommand = options.customCommand;
+    this.timeoutMs = options.timeoutMs ?? 30000;
+  }
+  findTargetedTests(modifiedFiles = []) {
+    const matchedTests = new Set;
+    for (const rawFile of modifiedFiles) {
+      const normalized = rawFile.replace(/\\/g, "/").replace(/^\.\//, "");
+      if (/\.(test|spec)\.[jt]sx?$/i.test(normalized) || /(^|\/)test_[^/]+\.py$/i.test(normalized) || /_test\.py$/i.test(normalized) || /_test\.go$/i.test(normalized)) {
+        if (existsSync14(join8(this.cwd, normalized))) {
+          matchedTests.add(normalized);
+        }
+        continue;
+      }
+      const extMatch = normalized.match(/\.[^.]+$/);
+      if (!extMatch)
+        continue;
+      const withoutExt = normalized.slice(0, -extMatch[0].length);
+      const parts = withoutExt.split("/");
+      const baseName = parts[parts.length - 1];
+      const subPath = normalized.startsWith("src/") ? normalized.slice(4, -extMatch[0].length) : normalized.startsWith("lib/") ? normalized.slice(4, -extMatch[0].length) : withoutExt;
+      const candidatePaths = [
+        `tests/${subPath}.test.ts`,
+        `tests/${subPath}.test.js`,
+        `tests/${subPath}.test.tsx`,
+        `tests/${subPath}.spec.ts`,
+        `tests/${subPath}.spec.js`,
+        `tests/${baseName}.test.ts`,
+        `tests/${baseName}.test.js`,
+        `tests/${baseName}.spec.ts`,
+        `test/${subPath}.test.ts`,
+        `test/${subPath}.test.js`,
+        `test/${baseName}.test.ts`,
+        `test/${baseName}.test.js`,
+        `src/${subPath}.test.ts`,
+        `src/${subPath}.spec.ts`,
+        `${withoutExt}.test.ts`,
+        `${withoutExt}.spec.ts`,
+        `tests/test_${baseName}.py`,
+        `test_${baseName}.py`,
+        `tests/${baseName}_test.go`
+      ];
+      for (const candidate of candidatePaths) {
+        if (existsSync14(join8(this.cwd, candidate))) {
+          matchedTests.add(candidate);
+        }
+      }
+    }
+    return Array.from(matchedTests);
+  }
+  resolveTargetedTestCommand(testFiles) {
+    if (testFiles.length === 0)
+      return null;
+    const quotedFiles = testFiles.map((f) => f.includes(" ") ? `"${f}"` : f).join(" ");
+    if (existsSync14(join8(this.cwd, "bun.lockb")) || existsSync14(join8(this.cwd, "bun.lock"))) {
+      return `bun test ${quotedFiles}`;
+    }
+    const pkgPath = join8(this.cwd, "package.json");
+    if (existsSync14(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+        const allDeps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+        if (allDeps.vitest) {
+          return `npx vitest run ${quotedFiles}`;
+        }
+        if (allDeps.jest) {
+          return `npx jest ${quotedFiles}`;
+        }
+        const pm = existsSync14(join8(this.cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync14(join8(this.cwd, "yarn.lock")) ? "yarn" : "npm";
+        if (pkg.scripts?.test) {
+          if (pkg.scripts.test.includes("bun test")) {
+            return `bun test ${quotedFiles}`;
+          }
+          return `${pm} test -- ${quotedFiles}`;
+        }
+      } catch (err) {
+        console.warn(`[AutoVerifier] Failed to parse package.json for test runner:`, err);
+      }
+    }
+    if (existsSync14(join8(this.cwd, "pyproject.toml")) || existsSync14(join8(this.cwd, "requirements.txt"))) {
+      if (existsSync14(join8(this.cwd, "uv.lock"))) {
+        return `uv run pytest ${quotedFiles}`;
+      }
+      return `pytest ${quotedFiles}`;
+    }
+    if (existsSync14(join8(this.cwd, "go.mod"))) {
+      return `go test ${quotedFiles}`;
+    }
+    if (existsSync14(join8(this.cwd, "Cargo.toml"))) {
+      return `cargo test ${quotedFiles}`;
+    }
+    return null;
+  }
+  resolveStaticCommand() {
+    try {
+      const analyzer = new ProjectAnalyzer(this.cwd);
+      const analysis = analyzer.analyze();
+      if (analysis.commands.typecheck) {
+        return analysis.commands.typecheck;
+      }
+    } catch (err) {
+      console.warn(`[AutoVerifier] ProjectAnalyzer analysis error:`, err);
+    }
+    const pkgPath = join8(this.cwd, "package.json");
+    if (existsSync14(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+        if (pkg.scripts) {
+          const pm = existsSync14(join8(this.cwd, "bun.lockb")) || existsSync14(join8(this.cwd, "bun.lock")) ? "bun" : existsSync14(join8(this.cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync14(join8(this.cwd, "yarn.lock")) ? "yarn" : "npm";
+          const runCmd = pm === "bun" || pm === "pnpm" || pm === "yarn" ? `${pm} run` : "npm run";
+          if (pkg.scripts.typecheck)
+            return `${runCmd} typecheck`;
+          if (pkg.scripts.check)
+            return `${runCmd} check`;
+        }
+      } catch (err) {
+        console.warn(`[AutoVerifier] Failed to parse package.json for static check:`, err);
+      }
+    }
+    if (existsSync14(join8(this.cwd, "tsconfig.json"))) {
+      return "npx tsc --noEmit";
+    }
+    if (existsSync14(join8(this.cwd, "Cargo.toml"))) {
+      return "cargo check";
+    }
+    if (existsSync14(join8(this.cwd, "go.mod"))) {
+      return "go vet ./...";
+    }
+    if (existsSync14(join8(this.cwd, "mypy.ini")) || existsSync14(join8(this.cwd, ".mypy.ini"))) {
+      return "mypy .";
+    }
+    return null;
+  }
+  resolveVerificationCommand(modifiedFiles = []) {
+    if (this.customCommand && this.customCommand.trim()) {
+      return this.customCommand.trim();
+    }
+    const targetedTests = this.findTargetedTests(modifiedFiles);
+    const targetedTestCmd = this.resolveTargetedTestCommand(targetedTests);
+    const staticCmd = this.resolveStaticCommand();
+    if (targetedTestCmd && staticCmd) {
+      return `${staticCmd} && ${targetedTestCmd}`;
+    }
+    if (targetedTestCmd) {
+      return targetedTestCmd;
+    }
+    if (staticCmd) {
+      return staticCmd;
+    }
+    try {
+      const analyzer = new ProjectAnalyzer(this.cwd);
+      const analysis = analyzer.analyze();
+      if (analysis.commands.test)
+        return analysis.commands.test;
+      if (analysis.commands.lint)
+        return analysis.commands.lint;
+    } catch {}
+    const pkgPath = join8(this.cwd, "package.json");
+    if (existsSync14(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+        if (pkg.scripts?.test) {
+          const pm = existsSync14(join8(this.cwd, "bun.lockb")) || existsSync14(join8(this.cwd, "bun.lock")) ? "bun" : "npm";
+          return pm === "bun" ? "bun test" : "npm test";
+        }
+        if (pkg.scripts?.lint) {
+          return "npm run lint";
+        }
+      } catch {}
+    }
+    return null;
+  }
+  resolveVerificationStages(modifiedFiles = []) {
+    if (this.customCommand && this.customCommand.trim()) {
+      return [this.customCommand.trim()];
+    }
+    const stages = [];
+    const staticCmd = this.resolveStaticCommand();
+    const targetedTests = this.findTargetedTests(modifiedFiles);
+    const targetedTestCmd = this.resolveTargetedTestCommand(targetedTests);
+    if (staticCmd) {
+      stages.push(staticCmd);
+    }
+    if (targetedTestCmd) {
+      stages.push(targetedTestCmd);
+    }
+    if (stages.length === 0) {
+      const fallback = this.resolveVerificationCommand(modifiedFiles);
+      if (fallback) {
+        stages.push(fallback);
+      }
+    }
+    return stages;
+  }
+  async verify(modifiedFiles = [], signal) {
+    const stages = this.resolveVerificationStages(modifiedFiles);
+    const startTime = performance.now();
+    if (stages.length === 0) {
+      return {
+        command: "none",
+        success: true,
+        exitCode: 0,
+        output: "No automated verification command configured or detected for this workspace.",
+        durationMs: 0,
+        reason: "NO_VERIFIER_DETECTED"
+      };
+    }
+    const combinedOutputs = [];
+    let executedCommands = [];
+    for (const cmd of stages) {
+      if (signal?.aborted) {
+        return {
+          command: cmd,
+          success: false,
+          exitCode: 1,
+          output: "Verification was aborted.",
+          durationMs: Math.round(performance.now() - startTime),
+          reason: "ABORTED"
+        };
+      }
+      executedCommands.push(cmd);
+      const stageResult = await this.executeCommandAsync(cmd, signal);
+      combinedOutputs.push(`[${cmd}]
+${stageResult.output}`);
+      if (!stageResult.success) {
+        return {
+          command: cmd,
+          success: false,
+          exitCode: stageResult.exitCode,
+          output: this.truncateOutput(combinedOutputs.join(`
+
+`)),
+          durationMs: Math.round(performance.now() - startTime)
+        };
+      }
+    }
+    return {
+      command: executedCommands.join(" && "),
+      success: true,
+      exitCode: 0,
+      output: this.truncateOutput(combinedOutputs.join(`
+
+`)),
+      durationMs: Math.round(performance.now() - startTime)
+    };
+  }
+  executeCommandAsync(command, signal) {
+    return new Promise((resolve) => {
+      let proc = null;
+      let stdoutData = "";
+      let stderrData = "";
+      let isSettled = false;
+      const finish = (success, exitCode, output) => {
+        if (isSettled)
+          return;
+        isSettled = true;
+        cleanup();
+        resolve({ success, exitCode, output: output.trim() });
+      };
+      const killProcessTree = () => {
+        if (!proc || !proc.pid)
+          return;
+        try {
+          if (process.platform === "win32") {
+            spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { stdio: "ignore" });
+          } else {
+            proc.kill("SIGTERM");
+            setTimeout(() => {
+              try {
+                proc?.kill("SIGKILL");
+              } catch {}
+            }, 500);
+          }
+        } catch {}
+      };
+      const onAbort = () => {
+        killProcessTree();
+        finish(false, 1, "Verification command aborted by user or session signal.");
+      };
+      if (signal?.aborted) {
+        return finish(false, 1, "Verification aborted before launch.");
+      }
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      const timer = setTimeout(() => {
+        killProcessTree();
+        const partial = (stdoutData + `
+` + stderrData).trim();
+        const timeoutMsg = `[Verification Timeout Error]: Verification command '${command}' exceeded timeout limit of ${this.timeoutMs}ms and was terminated.`;
+        finish(false, 1, partial ? `${partial}
+
+${timeoutMsg}` : timeoutMsg);
+      }, this.timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (signal) {
+          signal.removeEventListener("abort", onAbort);
+        }
+      };
+      try {
+        proc = spawn(command, {
+          cwd: this.cwd,
+          shell: true,
+          env: {
+            ...process.env,
+            CI: "true",
+            FORCE_COLOR: "0"
+          }
+        });
+        proc.stdout?.on("data", (chunk) => {
+          stdoutData += chunk.toString();
+        });
+        proc.stderr?.on("data", (chunk) => {
+          stderrData += chunk.toString();
+        });
+        proc.on("error", (err) => {
+          const partial = (stdoutData + `
+` + stderrData).trim();
+          const spawnMsg = `[Verification Process Spawn Error]: Failed to spawn command '${command}': ${err.message}`;
+          finish(false, 1, partial ? `${partial}
+
+${spawnMsg}` : spawnMsg);
+        });
+        proc.on("close", (code) => {
+          const exitCode = code ?? 0;
+          const combined = (stdoutData + `
+` + stderrData).trim();
+          if (exitCode === 0) {
+            finish(true, 0, combined || "Verification passed cleanly.");
+          } else {
+            const errorFallback = `[Verification Failure]: Command '${command}' exited with code ${exitCode} and produced no output.`;
+            finish(false, exitCode, combined ? `${combined}
+
+[Process exited with non-zero code ${exitCode}]` : errorFallback);
+          }
+        });
+      } catch (err) {
+        finish(false, 1, `[Verification Execution Exception]: ${err.message || String(err)}`);
+      }
+    });
+  }
+  truncateOutput(output) {
+    if (output.length > 4000) {
+      const lines = output.split(`
+`);
+      if (lines.length > 70) {
+        const head = lines.slice(0, 35).join(`
+`);
+        const tail = lines.slice(-30).join(`
+`);
+        return `${head}
+
+... [${lines.length - 65} lines truncated for context efficiency] ...
+
+${tail}`;
+      }
+    }
+    return output;
+  }
+}
 // src/session/turn.ts
 async function runTurn(session, turnContext, input) {
   const { turnId, signal } = turnContext;
@@ -4319,6 +5508,9 @@ async function runTurn(session, turnContext, input) {
   let accumulatedOutputTokens = 0;
   let accumulatedCachedTokens = 0;
   const clientSession = session.modelClient.newSession();
+  const modifiedFiles = new Set;
+  let selfHealingAttempts = 0;
+  let hasRunVerification = false;
   try {
     while (iteration < turnContext.maxIterations) {
       if (signal.aborted) {
@@ -4387,6 +5579,7 @@ async function runTurn(session, turnContext, input) {
         });
       }
       if (toolCallRequests.length > 0) {
+        const validCalls = [];
         for (const toolCall of toolCallRequests) {
           if (!toolCall.name || !toolCall.name.trim())
             continue;
@@ -4410,6 +5603,14 @@ async function runTurn(session, turnContext, input) {
             toolName: toolCall.name,
             arguments: toolCall.arguments
           });
+          validCalls.push({
+            callId: toolCall.callId,
+            name: toolCall.name,
+            arguments: toolCall.arguments,
+            functionCallItem
+          });
+        }
+        for (const toolCall of validCalls) {
           const toolResult = await turnContext.tools.execute(toolCall.name, toolCall.arguments, {
             cwd: turnContext.environment.cwd,
             turnId,
@@ -4417,6 +5618,12 @@ async function runTurn(session, turnContext, input) {
             execPolicy: session.execPolicy,
             mode: session.collaborationMode,
             permissionMode: session.permissionMode,
+            onFileModified: (p) => {
+              if (p) {
+                modifiedFiles.add(p);
+                hasRunVerification = false;
+              }
+            },
             onPlanUpdate: (plan, explanation) => {
               session.emitEvent({
                 type: "PlanUpdated",
@@ -4432,7 +5639,8 @@ async function runTurn(session, turnContext, input) {
                 turnId,
                 toolName: toolCall.name,
                 description,
-                command
+                command,
+                prefixRule
               });
             },
             requestInput: async (question, options) => {
@@ -4453,6 +5661,15 @@ async function runTurn(session, turnContext, input) {
             isError: toolResult.isError,
             createdAt: Date.now()
           };
+          if (!toolResult.isError) {
+            if (toolCall.name === "apply_patch" || toolCall.name === "write_file") {
+              const p = String(toolCall.arguments?.path || "");
+              if (p) {
+                modifiedFiles.add(p);
+                hasRunVerification = false;
+              }
+            }
+          }
           session.addHistoryItem(functionOutputItem);
           session.emitEvent({
             type: "ToolCallFinished",
@@ -4469,6 +5686,70 @@ async function runTurn(session, turnContext, input) {
         }
         continue;
       }
+      if (session.autoVerification && modifiedFiles.size > 0 && !hasRunVerification && iteration < turnContext.maxIterations) {
+        const verifier = new AutoVerifier({
+          cwd,
+          customCommand: session.autoVerificationCommand
+        });
+        const command = verifier.resolveVerificationCommand(Array.from(modifiedFiles));
+        if (command) {
+          session.emitEvent({
+            type: "VerificationStarted",
+            turnId,
+            command,
+            modifiedFiles: Array.from(modifiedFiles)
+          });
+          const vResult = await verifier.verify(Array.from(modifiedFiles), signal);
+          session.emitEvent({
+            type: "VerificationCompleted",
+            turnId,
+            command: vResult.command,
+            success: vResult.success,
+            output: vResult.output,
+            durationMs: vResult.durationMs
+          });
+          if (!vResult.success) {
+            if (selfHealingAttempts < session.maxSelfHealingAttempts) {
+              selfHealingAttempts++;
+              session.emitEvent({
+                type: "SelfHealingStarted",
+                turnId,
+                attempt: selfHealingAttempts,
+                maxAttempts: session.maxSelfHealingAttempts,
+                command: vResult.command,
+                error: vResult.output
+              });
+              const feedbackMsg = `[Automated Self-Verification Failure]
+Verification command '${vResult.command}' failed with exit code ${vResult.exitCode}.
+
+Error trace / compiler output:
+${vResult.output}
+
+Modified file(s) in this turn: ${Array.from(modifiedFiles).join(", ")}
+
+Self-Healing Directive (Attempt ${selfHealingAttempts} of ${session.maxSelfHealingAttempts}):
+1. Review the error trace above carefully and locate the exact root cause.
+2. Formulate and apply the necessary surgical fix using 'apply_patch' or 'write_file'.
+3. Do NOT conclude the turn or report to the user until this error is resolved and verification passes cleanly.`;
+              session.addHistoryItem({
+                id: `msg_heal_${Date.now()}`,
+                type: "user_message",
+                content: feedbackMsg,
+                createdAt: Date.now()
+              });
+              continue;
+            } else {
+              session.emitEvent({
+                type: "Warning",
+                message: `Auto-verification failed after ${selfHealingAttempts} self-healing attempts for command: ${vResult.command}`
+              });
+              hasRunVerification = true;
+            }
+          } else {
+            hasRunVerification = true;
+          }
+        }
+      }
       if (!currentAgentText.trim() && toolCallRequests.length === 0) {
         if (iteration === 1 && iteration < turnContext.maxIterations) {
           session.addHistoryItem({
@@ -4594,6 +5875,9 @@ class Session {
   mcpManager;
   execPolicy;
   collaborationMode = "default";
+  autoVerification;
+  autoVerificationCommand;
+  maxSelfHealingAttempts;
   get permissionMode() {
     return this.execPolicy.getMode();
   }
@@ -4626,6 +5910,9 @@ class Session {
     this.mcpManager = options.mcpManager;
     this.execPolicy = options.execPolicy || new ExecPolicy;
     this.collaborationMode = options.collaborationMode || "default";
+    this.autoVerification = options.autoVerification ?? (process.env.PIKAA_AUTO_VERIFY !== "0" && process.env.PIKAA_AUTO_VERIFY !== "false");
+    this.autoVerificationCommand = options.autoVerificationCommand;
+    this.maxSelfHealingAttempts = options.maxSelfHealingAttempts ?? 3;
     this.history = options.initialHistory ? [...options.initialHistory] : [];
     if (options.onEvent) {
       this.eventListeners.push(options.onEvent);
@@ -4705,7 +5992,8 @@ class Session {
       turnId: params.turnId,
       toolName: params.toolName,
       description: params.description,
-      command: params.command
+      command: params.command,
+      prefixRule: params.prefixRule
     });
     this.emitEvent({
       type: "StatusChanged",
@@ -4873,7 +6161,7 @@ class ThreadManager {
   }
 }
 // src/mcp/process-killer.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 
 class GlobalProcessRegistry {
   static trackedProcesses = new Map;
@@ -4883,7 +6171,7 @@ class GlobalProcessRegistry {
       return;
     if (process.platform === "win32") {
       try {
-        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+        spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], {
           stdio: "ignore",
           windowsHide: true
         });
@@ -5450,8 +6738,8 @@ class McpClient {
   }
 }
 // src/mcp/manager.ts
-import { existsSync as existsSync13, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
-import { resolve as resolve12, dirname as dirname6, join as join7 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync4, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve12, dirname as dirname6, join as join9 } from "path";
 class McpManager {
   clients = new Map;
   serverConfigs = new Map;
@@ -5486,11 +6774,11 @@ class McpManager {
   }
   async loadConfigFile(filePath) {
     const fullPath = resolve12(filePath);
-    if (!existsSync13(fullPath))
+    if (!existsSync15(fullPath))
       return;
     this.loadedConfigFiles.add(fullPath);
     try {
-      const content = readFileSync8(fullPath, "utf8");
+      const content = readFileSync10(fullPath, "utf8");
       const parsed = JSON.parse(content);
       if (parsed.mcpServers) {
         await this.loadConfig(parsed);
@@ -5741,13 +7029,13 @@ class McpManager {
   saveServerToConfigFile(filePath, name, config) {
     const fullPath = resolve12(filePath);
     const dir = dirname6(fullPath);
-    if (!existsSync13(dir)) {
+    if (!existsSync15(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
     let existing = { mcpServers: {} };
-    if (existsSync13(fullPath)) {
+    if (existsSync15(fullPath)) {
       try {
-        const content = readFileSync8(fullPath, "utf8");
+        const content = readFileSync10(fullPath, "utf8");
         existing = JSON.parse(content);
         if (!existing.mcpServers)
           existing.mcpServers = {};
@@ -5760,10 +7048,10 @@ class McpManager {
   }
   removeServerFromConfigFile(filePath, name) {
     const fullPath = resolve12(filePath);
-    if (!existsSync13(fullPath))
+    if (!existsSync15(fullPath))
       return false;
     try {
-      const content = readFileSync8(fullPath, "utf8");
+      const content = readFileSync10(fullPath, "utf8");
       const existing = JSON.parse(content);
       if (existing.mcpServers && existing.mcpServers[name]) {
         delete existing.mcpServers[name];
@@ -5790,11 +7078,11 @@ class McpManager {
     }
   }
   getDefaultConfigFile(cwd = process.cwd()) {
-    const workspaceConfig = join7(cwd, ".mcp.json");
-    if (existsSync13(workspaceConfig))
+    const workspaceConfig = join9(cwd, ".mcp.json");
+    if (existsSync15(workspaceConfig))
       return workspaceConfig;
-    const altConfig = join7(cwd, "mcp_config.json");
-    if (existsSync13(altConfig))
+    const altConfig = join9(cwd, "mcp_config.json");
+    if (existsSync15(altConfig))
       return altConfig;
     return workspaceConfig;
   }
@@ -5816,8 +7104,8 @@ class McpManager {
 import { resolve as resolve14 } from "path";
 
 // src/mcp/servers/chrome-devtools/launcher.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, rmSync as rmSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, rmSync as rmSync2 } from "fs";
+import { join as join10 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 class BrowserLauncher {
   proc = null;
@@ -5825,21 +7113,21 @@ class BrowserLauncher {
   wsDebuggerUrl = null;
   port = 0;
   static findBrowserExecutable() {
-    if (process.env.CHROME_PATH && existsSync14(process.env.CHROME_PATH)) {
+    if (process.env.CHROME_PATH && existsSync16(process.env.CHROME_PATH)) {
       return process.env.CHROME_PATH;
     }
     if (process.platform === "win32") {
       const candidates = [
         "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
         "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-        join8(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
+        join10(process.env.LOCALAPPDATA || "", "Google\\Chrome\\Application\\chrome.exe"),
         "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
         "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-        join8(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
+        join10(process.env.LOCALAPPDATA || "", "BraveSoftware\\Brave-Browser\\Application\\brave.exe")
       ];
       for (const path of candidates) {
-        if (path && existsSync14(path))
+        if (path && existsSync16(path))
           return path;
       }
     } else if (process.platform === "darwin") {
@@ -5850,7 +7138,7 @@ class BrowserLauncher {
         "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
       ];
       for (const path of candidates) {
-        if (existsSync14(path))
+        if (existsSync16(path))
           return path;
       }
     } else {
@@ -5863,7 +7151,7 @@ class BrowserLauncher {
         "/usr/bin/microsoft-edge"
       ];
       for (const path of candidates) {
-        if (existsSync14(path))
+        if (existsSync16(path))
           return path;
       }
     }
@@ -5875,7 +7163,7 @@ class BrowserLauncher {
       throw new Error("No supported browser (Google Chrome, Chromium, MS Edge, Brave) found on this machine. Please install Chrome or specify CHROME_PATH.");
     }
     this.port = options.port || 9200 + Math.floor(Math.random() * 500);
-    this.tempUserDataDir = options.userDataDir || join8(tmpdir2(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+    this.tempUserDataDir = options.userDataDir || join10(tmpdir2(), `groupy_chrome_${Date.now()}_${Math.random().toString(36).slice(2)}`);
     mkdirSync8(this.tempUserDataDir, { recursive: true });
     const isHeadless = options.headless ?? true;
     const launchArgs = [
@@ -5953,7 +7241,7 @@ class BrowserLauncher {
       }
       this.proc = null;
     }
-    if (this.tempUserDataDir && existsSync14(this.tempUserDataDir)) {
+    if (this.tempUserDataDir && existsSync16(this.tempUserDataDir)) {
       try {
         rmSync2(this.tempUserDataDir, { recursive: true, force: true });
       } catch {}
@@ -7793,7 +9081,7 @@ import { resolve as resolve17 } from "path";
 // src/mcp/servers/sqlite/db-engine.ts
 import { Database as Database2 } from "bun:sqlite";
 import { resolve as resolve16, isAbsolute } from "path";
-import { readdirSync as readdirSync6 } from "fs";
+import { readdirSync as readdirSync7 } from "fs";
 
 class SqliteEngine {
   connections = new Map;
@@ -7823,7 +9111,7 @@ class SqliteEngine {
   }
   autoDiscoverDatabase() {
     try {
-      const files = readdirSync6(process.cwd());
+      const files = readdirSync7(process.cwd());
       const dbFile = files.find((f) => f.endsWith(".sqlite") || f.endsWith(".sqlite3") || f.endsWith(".db"));
       return dbFile ? resolve16(process.cwd(), dbFile) : null;
     } catch {
@@ -8327,8 +9615,8 @@ function verifyTaskAction(assertion, payload) {
   }
 }
 // src/agents/roles.ts
-import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve18, join as join9 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve18, join as join11 } from "path";
 
 class AgentRoleRegistry {
   roles = new Map;
@@ -8413,13 +9701,13 @@ class AgentRoleRegistry {
   }
   loadRolesFromDir(dirPath) {
     const fullPath = resolve18(dirPath);
-    if (!existsSync16(fullPath))
+    if (!existsSync18(fullPath))
       return;
-    const entries = readdirSync7(fullPath);
+    const entries = readdirSync8(fullPath);
     for (const entry of entries) {
       if (entry.endsWith(".json")) {
         try {
-          const content = readFileSync9(join9(fullPath, entry), "utf8");
+          const content = readFileSync11(join11(fullPath, entry), "utf8");
           const parsed = JSON.parse(content);
           if (parsed.name && parsed.systemPrompt) {
             this.registerRole(parsed);
@@ -8449,7 +9737,7 @@ class AgentRoleRegistry {
 // src/agents/graph-store.ts
 import { Database as Database3 } from "bun:sqlite";
 import { resolve as resolve19 } from "path";
-import { existsSync as existsSync17, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10 } from "fs";
 class AgentGraphStore {
   db;
   constructor(dbPathOrDb) {
@@ -8459,8 +9747,12 @@ class AgentGraphStore {
       const dbPath = dbPathOrDb || getAgentGraphDbPath();
       if (dbPath !== ":memory:") {
         const dir = resolve19(dbPath, "..");
-        if (!existsSync17(dir)) {
-          mkdirSync10(dir, { recursive: true });
+        if (!existsSync19(dir)) {
+          try {
+            mkdirSync10(dir, { recursive: true });
+          } catch (err) {
+            console.warn(`[AgentGraphStore] Failed to create database directory '${dir}':`, err);
+          }
         }
       }
       this.db = new Database3(dbPath);
@@ -8542,24 +9834,44 @@ class AgentGraphStore {
   close() {
     try {
       this.db.close();
-    } catch {}
+    } catch (err) {
+      console.warn("[AgentGraphStore] Failed to close database cleanly:", err);
+    }
   }
 }
 // src/agents/spawner.ts
 class AgentSpawner {
   parentSession;
+  depth;
   subAgents = new Map;
   nextAgentId = 1;
   roleRegistry;
   parentIdentity;
   graphStore;
-  constructor(parentSession, roleRegistry, parentIdentity, graphStore) {
+  maxConcurrentAgents;
+  maxDepth;
+  maxRetainedCompleted;
+  defaultTokenBudget;
+  constructor(parentSession, roleRegistry, parentIdentity, graphStore, options, depth = 0) {
     this.parentSession = parentSession;
+    this.depth = depth;
     this.roleRegistry = roleRegistry || new AgentRoleRegistry;
     this.parentIdentity = parentIdentity || createAgentIdentity(undefined, "groupy-main");
     this.graphStore = graphStore || new AgentGraphStore;
+    const envMax = process.env.PIKAA_MAX_SUBAGENTS ? parseInt(process.env.PIKAA_MAX_SUBAGENTS, 10) : NaN;
+    this.maxConcurrentAgents = options?.maxConcurrentAgents ?? (!isNaN(envMax) && envMax > 0 ? envMax : 5);
+    this.maxDepth = options?.maxDepth ?? 2;
+    this.maxRetainedCompleted = options?.maxRetainedCompleted ?? 20;
+    this.defaultTokenBudget = options?.defaultTokenBudget ?? 50000;
   }
   async spawnAgent(params) {
+    if (this.depth >= this.maxDepth) {
+      throw new GroupyError(`Recursion limit exceeded: Maximum sub-agent nesting depth (${this.maxDepth}) reached.`);
+    }
+    const activeRunningCount = Array.from(this.subAgents.values()).filter((h) => h.status === "running").length;
+    if (activeRunningCount >= this.maxConcurrentAgents) {
+      throw new GroupyError(`Resource limit exceeded: Maximum concurrent sub-agents limit (${this.maxConcurrentAgents}) reached. Please wait for running sub-agents to complete or close them.`);
+    }
     const roleName = params.role || "default";
     const roleConfig = this.roleRegistry.getRole(roleName);
     const agentIndex = this.nextAgentId++;
@@ -8571,7 +9883,18 @@ class AgentSpawner {
 
 Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus strictly on this task.` : `You are a specialized sub-agent named ${nickname} tasked with: '${params.taskName}'. Focus strictly on this task.`);
     const baseTools = params.tools || this.parentSession.tools;
-    const effectiveTools = this.roleRegistry.filterRouterForRole(baseTools, roleName);
+    let effectiveTools = this.roleRegistry.filterRouterForRole(baseTools, roleName);
+    if (this.depth + 1 >= this.maxDepth) {
+      const sanitizedRouter = new ToolRouter;
+      for (const t of effectiveTools.list()) {
+        if (t.name !== "spawn_agent") {
+          sanitizedRouter.register(t);
+        }
+      }
+      effectiveTools = sanitizedRouter;
+    }
+    const tokenBudget = params.maxTokens ?? this.defaultTokenBudget;
+    let accumulatedTokens = 0;
     const childSession = new Session({
       threadId: agentId,
       model: effectiveModel,
@@ -8595,45 +9918,87 @@ Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus
       createdAt: Date.now(),
       identity: childIdentity,
       session: childSession,
-      promise: taskPromise
+      promise: taskPromise,
+      depth: this.depth + 1,
+      tokenBudget,
+      totalTokens: 0
     };
     try {
       this.graphStore.upsertEdge(this.parentSession.threadId, agentId, "open");
-    } catch {}
+    } catch (err) {
+      console.warn(`[AgentSpawner] Failed to record edge in graph store for agent '${agentId}':`, err);
+    }
     let collectedAgentText = "";
     childSession.onEvent((event) => {
       if (event.msg.type === "AgentMessageDelta") {
         collectedAgentText += event.msg.delta;
+        accumulatedTokens += Math.ceil(event.msg.delta.length / 4);
+        handle.totalTokens = accumulatedTokens;
+        if (accumulatedTokens > tokenBudget && handle.status === "running") {
+          handle.status = "error";
+          handle.error = `Token budget limit exceeded (${tokenBudget} tokens).`;
+          childSession.interrupt();
+          try {
+            this.graphStore.setEdgeStatus(agentId, "closed");
+          } catch (err) {
+            console.warn(`[AgentSpawner] Failed to update edge status for agent '${agentId}':`, err);
+          }
+          rejectPromise(new Error(handle.error));
+        }
       } else if (event.msg.type === "TurnCompleted") {
-        handle.status = "completed";
-        handle.lastOutput = collectedAgentText.trim();
-        try {
-          this.graphStore.setEdgeStatus(agentId, "closed");
-        } catch {}
-        resolvePromise(handle.lastOutput);
+        if (handle.status === "running") {
+          handle.status = "completed";
+          handle.lastOutput = collectedAgentText.trim();
+          handle.totalTokens = accumulatedTokens;
+          try {
+            this.graphStore.setEdgeStatus(agentId, "closed");
+          } catch (err) {
+            console.warn(`[AgentSpawner] Failed to update edge status for agent '${agentId}':`, err);
+          }
+          this.pruneCompletedAgents();
+          resolvePromise(handle.lastOutput);
+        }
       } else if (event.msg.type === "Error") {
-        handle.status = "error";
-        handle.error = event.msg.message;
-        try {
-          this.graphStore.setEdgeStatus(agentId, "closed");
-        } catch {}
-        rejectPromise(new Error(event.msg.message));
+        if (handle.status === "running") {
+          handle.status = "error";
+          handle.error = event.msg.message;
+          handle.totalTokens = accumulatedTokens;
+          try {
+            this.graphStore.setEdgeStatus(agentId, "closed");
+          } catch (err) {
+            console.warn(`[AgentSpawner] Failed to update edge status for agent '${agentId}':`, err);
+          }
+          this.pruneCompletedAgents();
+          rejectPromise(new Error(event.msg.message));
+        }
       } else if (event.msg.type === "StatusChanged" && event.msg.status === "interrupted") {
-        handle.status = "interrupted";
-        try {
-          this.graphStore.setEdgeStatus(agentId, "closed");
-        } catch {}
-        resolvePromise(collectedAgentText.trim() || "[Task was interrupted]");
+        if (handle.status === "running") {
+          handle.status = "interrupted";
+          handle.totalTokens = accumulatedTokens;
+          try {
+            this.graphStore.setEdgeStatus(agentId, "closed");
+          } catch (err) {
+            console.warn(`[AgentSpawner] Failed to update edge status for agent '${agentId}':`, err);
+          }
+          this.pruneCompletedAgents();
+          resolvePromise(collectedAgentText.trim() || "[Task was interrupted]");
+        }
       }
     });
     this.subAgents.set(agentId, handle);
     childSession.prompt(params.message).catch((err) => {
-      handle.status = "error";
-      handle.error = err instanceof Error ? err.message : String(err);
-      try {
-        this.graphStore.setEdgeStatus(agentId, "closed");
-      } catch {}
-      rejectPromise(err);
+      if (handle.status === "running") {
+        handle.status = "error";
+        handle.error = err instanceof Error ? err.message : String(err);
+        handle.totalTokens = accumulatedTokens;
+        try {
+          this.graphStore.setEdgeStatus(agentId, "closed");
+        } catch (storeErr) {
+          console.warn(`[AgentSpawner] Failed to update edge status for agent '${agentId}':`, storeErr);
+        }
+        this.pruneCompletedAgents();
+        rejectPromise(err);
+      }
     });
     return {
       id: handle.id,
@@ -8642,9 +10007,22 @@ Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus
       role: handle.role,
       status: handle.status,
       createdAt: handle.createdAt,
-      agentRuntimeId: childIdentity.agentRuntimeId
+      agentRuntimeId: childIdentity.agentRuntimeId,
+      depth: handle.depth,
+      tokenBudget: handle.tokenBudget,
+      totalTokens: handle.totalTokens
     };
   }
+  pruneCompletedAgents() {
+    const finishedHandles = Array.from(this.subAgents.values()).filter((h) => h.status !== "running");
+    if (finishedHandles.length > this.maxRetainedCompleted) {
+      finishedHandles.sort((a, b) => a.createdAt - b.createdAt);
+      const toRemove = finishedHandles.slice(0, finishedHandles.length - this.maxRetainedCompleted);
+      for (const h of toRemove) {
+        this.subAgents.delete(h.id);
+      }
+    }
+  }
   async waitAgent(agentIdOrTaskName, timeoutMs = 60000) {
     if (!agentIdOrTaskName) {
       const handles = Array.from(this.subAgents.values());
@@ -8698,9 +10076,36 @@ Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus
     handle.status = "interrupted";
     try {
       this.graphStore.setEdgeStatus(agentId, "closed");
-    } catch {}
+    } catch (err) {
+      console.warn(`[AgentSpawner] Failed to close edge for agent '${agentId}':`, err);
+    }
+    this.pruneCompletedAgents();
     return `Sub-agent ${handle.nickname} (${agentId}) interrupted and closed.`;
   }
+  removeAgent(agentId) {
+    const handle = this.subAgents.get(agentId);
+    if (!handle)
+      return false;
+    if (handle.status === "running") {
+      handle.session.interrupt();
+    }
+    try {
+      this.graphStore.setEdgeStatus(agentId, "closed");
+    } catch (err) {
+      console.warn(`[AgentSpawner] Failed to close edge on removal for '${agentId}':`, err);
+    }
+    return this.subAgents.delete(agentId);
+  }
+  clearCompleted() {
+    let cleared = 0;
+    for (const [id, handle] of this.subAgents.entries()) {
+      if (handle.status !== "running") {
+        this.subAgents.delete(id);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
   listAgents() {
     const list = [];
     for (const handle of this.subAgents.values()) {
@@ -8712,7 +10117,10 @@ Your nickname is ${nickname}. Your assigned task is: '${params.taskName}'. Focus
         status: handle.status,
         createdAt: handle.createdAt,
         agentRuntimeId: handle.identity.agentRuntimeId,
-        lastOutput: handle.lastOutput
+        lastOutput: handle.lastOutput,
+        depth: handle.depth,
+        tokenBudget: handle.tokenBudget,
+        totalTokens: handle.totalTokens
       });
     }
     return list;
@@ -8745,6 +10153,10 @@ function createMultiAgentTools(spawner) {
         model: {
           type: "string",
           description: "Optional model override. Defaults to inheriting parent model."
+        },
+        max_tokens: {
+          type: "number",
+          description: "Optional token budget limit for the sub-agent (default: 50000)."
         }
       },
       required: ["task_name", "message"]
@@ -8754,8 +10166,9 @@ function createMultiAgentTools(spawner) {
       const message = String(args.message || "");
       const role = args.role ? String(args.role) : undefined;
       const model = args.model ? String(args.model) : undefined;
+      const maxTokens = typeof args.max_tokens === "number" ? args.max_tokens : undefined;
       try {
-        const handle = await spawner.spawnAgent({ taskName, message, role, model });
+        const handle = await spawner.spawnAgent({ taskName, message, role, model, maxTokens });
         return {
           output: `Successfully spawned sub-agent '${handle.id}' with role '${handle.role}' for task '${handle.taskName}' (status: ${handle.status}). Use 'wait_agent' to collect results.`
         };
@@ -8882,7 +10295,7 @@ function registerMultiAgentTools(router, spawner) {
 }
 // src/storage/sqlite-store.ts
 import { Database as Database4 } from "bun:sqlite";
-import { existsSync as existsSync18, mkdirSync as mkdirSync11 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11 } from "fs";
 import { dirname as dirname8 } from "path";
 class SqliteThreadStore {
   db;
@@ -8890,7 +10303,7 @@ class SqliteThreadStore {
     const effectivePath = dbPath || this.getDefaultDbPath();
     if (effectivePath !== ":memory:") {
       const dir = dirname8(effectivePath);
-      if (!existsSync18(dir)) {
+      if (!existsSync20(dir)) {
         mkdirSync11(dir, { recursive: true });
       }
     }
@@ -9102,7 +10515,8 @@ class SessionPersistenceManager {
   loadSession(threadId) {
     try {
       return this.store.restoreSession(threadId);
-    } catch {
+    } catch (err) {
+      console.warn(`[SessionPersistenceManager] Failed to restore session '${threadId}':`, err);
       return null;
     }
   }
@@ -9110,7 +10524,9 @@ class SessionPersistenceManager {
     for (const unsub of this.unsubscribers) {
       try {
         unsub();
-      } catch {}
+      } catch (err) {
+        console.warn("[SessionPersistenceManager] Error in unbindSession callback:", err);
+      }
     }
     this.unsubscribers = [];
   }
@@ -9137,15 +10553,17 @@ class SessionPersistenceManager {
     for (const unsub of this.unsubscribers) {
       try {
         unsub();
-      } catch {}
+      } catch (err) {
+        console.warn("[SessionPersistenceManager] Error closing session persistence listener:", err);
+      }
     }
     this.unsubscribers = [];
     this.store.close();
   }
 }
 // src/skills/loader.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve20, join as join10 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync9, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve20, join as join12 } from "path";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
 class SkillsLoader {
@@ -9215,7 +10633,7 @@ class SkillsLoader {
         resolve20(cwd, "skills")
       ];
       for (const cand of candidates) {
-        if (existsSync19(cand) && !roots.includes(cand)) {
+        if (existsSync21(cand) && !roots.includes(cand)) {
           roots.push(cand);
         }
       }
@@ -9224,7 +10642,7 @@ class SkillsLoader {
       roots.push(getGlobalSkillsDir());
     }
     roots.push(...this.customRoots.map((r) => resolve20(r)));
-    return roots.filter((r) => existsSync19(r));
+    return roots.filter((r) => existsSync21(r));
   }
   discoverSkills(cwd, options) {
     return this.listSkills(cwd, options);
@@ -9240,12 +10658,12 @@ class SkillsLoader {
     const discovered = new Map;
     for (const root of roots) {
       try {
-        const entries = readdirSync8(root, { withFileTypes: true });
+        const entries = readdirSync9(root, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const skillDir = join10(root, entry.name);
-            const skillFilePath = join10(skillDir, "SKILL.md");
-            if (existsSync19(skillFilePath)) {
+            const skillDir = join12(root, entry.name);
+            const skillFilePath = join12(skillDir, "SKILL.md");
+            if (existsSync21(skillFilePath)) {
               const meta = this.parseSkillFrontmatter(skillFilePath, entry.name, root, cwd);
               if (meta && !discovered.has(meta.name)) {
                 meta.enabled = !this.isSkillDisabled(meta.name);
@@ -9274,7 +10692,7 @@ class SkillsLoader {
     if (!meta)
       return null;
     try {
-      const raw = readFileSync10(meta.path, "utf8");
+      const raw = readFileSync12(meta.path, "utf8");
       const { body } = this.extractFrontmatterAndBody(raw);
       return {
         ...meta,
@@ -9286,7 +10704,7 @@ class SkillsLoader {
   }
   parseSkillFrontmatter(filePath, dirName, root, cwd) {
     try {
-      const raw = readFileSync10(filePath, "utf8");
+      const raw = readFileSync12(filePath, "utf8");
       const { attributes } = this.extractFrontmatterAndBody(raw);
       let scope = "global";
       const normPath = filePath.toLowerCase().replace(/\\/g, "/");
@@ -9367,8 +10785,8 @@ When tackling complex specialized tasks that match any of these skills, autonomo
   }
 }
 // src/memories/store.ts
-import { existsSync as existsSync20, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync12, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve21, join as join11, basename, dirname as dirname9 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync13, writeFileSync as writeFileSync6, mkdirSync as mkdirSync12, readdirSync as readdirSync10 } from "fs";
+import { resolve as resolve21, join as join13, basename as basename2, dirname as dirname9 } from "path";
 import { createHash } from "crypto";
 class MemoryStore {
   globalPath;
@@ -9380,7 +10798,7 @@ class MemoryStore {
   findProjectRoot(cwd) {
     let current = resolve21(cwd);
     while (true) {
-      if (existsSync20(join11(current, ".git"))) {
+      if (existsSync22(join13(current, ".git"))) {
         return current;
       }
       const parent = dirname9(current);
@@ -9392,31 +10810,35 @@ class MemoryStore {
   }
   getProjectSlug(cwd) {
     const root = this.findProjectRoot(cwd);
-    const folderName = basename(root).toLowerCase().replace(/[^a-z0-9_-]/g, "-") || "project";
+    const folderName = basename2(root).toLowerCase().replace(/[^a-z0-9_-]/g, "-") || "project";
     const hash = createHash("sha256").update(resolve21(root)).digest("hex").slice(0, 6);
     return `${folderName}-${hash}`;
   }
   getProjectMemoryDir(cwd) {
     if (this.customWorkspacePath) {
       const dir = resolve21(this.customWorkspacePath);
-      if (!existsSync20(dir)) {
+      if (!existsSync22(dir)) {
         try {
           mkdirSync12(dir, { recursive: true });
-        } catch {}
+        } catch (err) {
+          console.warn(`[MemoryStore] Failed to create custom memory directory '${dir}':`, err);
+        }
       }
       return dir;
     }
     const slug = this.getProjectSlug(cwd);
-    const dir = join11(getProjectsDir(), slug, "memory");
-    if (!existsSync20(dir)) {
+    const dir = join13(getProjectsDir(), slug, "memory");
+    if (!existsSync22(dir)) {
       try {
         mkdirSync12(dir, { recursive: true });
-      } catch {}
+      } catch (err) {
+        console.warn(`[MemoryStore] Failed to create project memory directory '${dir}':`, err);
+      }
     }
     return dir;
   }
   getMemoryIndexPath(cwd) {
-    return join11(this.getProjectMemoryDir(cwd), "MEMORY.md");
+    return join13(this.getProjectMemoryDir(cwd), "MEMORY.md");
   }
   normalizeCategory(raw) {
     const cat = raw.toLowerCase().trim();
@@ -9435,7 +10857,7 @@ class MemoryStore {
     const sanitizedName = params.name.toLowerCase().trim().replace(/[^a-z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || `note_${Date.now()}`;
     const memoryDir = this.getProjectMemoryDir(params.cwd);
     const fileName = `${type}_${sanitizedName}.md`;
-    const filePath = join11(memoryDir, fileName);
+    const filePath = join13(memoryDir, fileName);
     const nowIso = new Date().toISOString();
     const cleanContent = params.content.trim();
     const desc = (params.description || cleanContent.split(`
@@ -9470,23 +10892,23 @@ class MemoryStore {
   }
   readTopicMemory(topicNameOrFile, cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    let targetPath = join11(memoryDir, topicNameOrFile);
-    if (!existsSync20(targetPath)) {
+    let targetPath = join13(memoryDir, topicNameOrFile);
+    if (!existsSync22(targetPath)) {
       if (!topicNameOrFile.endsWith(".md")) {
-        targetPath = join11(memoryDir, `${topicNameOrFile}.md`);
+        targetPath = join13(memoryDir, `${topicNameOrFile}.md`);
       }
     }
-    if (!existsSync20(targetPath)) {
-      const files = readdirSync9(memoryDir);
+    if (!existsSync22(targetPath)) {
+      const files = readdirSync10(memoryDir);
       const match = files.find((f) => f.includes(topicNameOrFile));
       if (match) {
-        targetPath = join11(memoryDir, match);
+        targetPath = join13(memoryDir, match);
       } else {
         return null;
       }
     }
     try {
-      const raw = readFileSync11(targetPath, "utf8");
+      const raw = readFileSync13(targetPath, "utf8");
       return this.parseTopicFile(raw, targetPath);
     } catch {
       return null;
@@ -9497,7 +10919,7 @@ class MemoryStore {
 `);
     let inFm = false;
     let type = "project";
-    let name = basename(filePath, ".md");
+    let name = basename2(filePath, ".md");
     let description;
     let modified = new Date().toISOString();
     const bodyLines = [];
@@ -9541,13 +10963,13 @@ class MemoryStore {
   }
   syncMemoryIndex(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    const indexPath = join11(memoryDir, "MEMORY.md");
-    const files = existsSync20(memoryDir) ? readdirSync9(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const indexPath = join13(memoryDir, "MEMORY.md");
+    const files = existsSync22(memoryDir) ? readdirSync10(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
     const items = [];
     for (const f of files) {
       try {
-        const full = join11(memoryDir, f);
-        const parsed = this.parseTopicFile(readFileSync11(full, "utf8"), full);
+        const full = join13(memoryDir, f);
+        const parsed = this.parseTopicFile(readFileSync13(full, "utf8"), full);
         items.push({
           type: parsed.type,
           name: parsed.name,
@@ -9555,7 +10977,9 @@ class MemoryStore {
 `)[0] || parsed.name,
           file: f
         });
-      } catch {}
+      } catch (err) {
+        console.warn(`[MemoryStore] Failed to parse topic memory file '${f}':`, err);
+      }
     }
     const indexLines = [
       "# Project Auto-Memory Index",
@@ -9573,10 +10997,10 @@ class MemoryStore {
   }
   loadMemoryIndex(cwd) {
     const indexPath = this.getMemoryIndexPath(cwd);
-    if (!existsSync20(indexPath))
+    if (!existsSync22(indexPath))
       return "";
     try {
-      const raw = readFileSync11(indexPath, "utf8");
+      const raw = readFileSync13(indexPath, "utf8");
       const byteLimit = 25 * 1024;
       const sliced = raw.length > byteLimit ? raw.slice(0, byteLimit) : raw;
       const lines = sliced.split(`
@@ -9589,15 +11013,17 @@ class MemoryStore {
   }
   listProjectMemories(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    if (!existsSync20(memoryDir))
+    if (!existsSync22(memoryDir))
       return [];
-    const files = readdirSync9(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+    const files = readdirSync10(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
     const list = [];
     for (const f of files) {
       try {
-        const full = join11(memoryDir, f);
-        list.push(this.parseTopicFile(readFileSync11(full, "utf8"), full));
-      } catch {}
+        const full = join13(memoryDir, f);
+        list.push(this.parseTopicFile(readFileSync13(full, "utf8"), full));
+      } catch (err) {
+        console.warn(`[MemoryStore] Failed to read topic memory file '${f}':`, err);
+      }
     }
     return list;
   }
@@ -9773,8 +11199,8 @@ async function removeWorktreeGit(repoRoot, worktreePath, deleteBranch = false) {
   return { success: true };
 }
 // src/worktree/manager.ts
-import { resolve as resolve23, join as join12 } from "path";
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve23, join as join14 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, writeFileSync as writeFileSync7, readFileSync as readFileSync14 } from "fs";
 var DEFAULT_WORKTREE_KEEP_COUNT = 15;
 
 class WorktreeManager {
@@ -9798,7 +11224,7 @@ class WorktreeManager {
     const branchName = options.branch || `groupy/${taskId}`;
     const targetDir = options.worktreePath || (this.baseStorageDir ? resolve23(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve23(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
     const worktreeParent = resolve23(targetDir, "..");
-    if (!existsSync21(worktreeParent)) {
+    if (!existsSync23(worktreeParent)) {
       mkdirSync13(worktreeParent, { recursive: true });
     }
     const baseBranch = options.baseBranch || await getCurrentBranch(repoRoot);
@@ -9806,7 +11232,7 @@ class WorktreeManager {
     if (!result.success) {
       throw new Error(`Failed to create git worktree: ${result.error}`);
     }
-    const metaPath = join12(targetDir, "groupy-thread.json");
+    const metaPath = join14(targetDir, "groupy-thread.json");
     try {
       writeFileSync7(metaPath, JSON.stringify({
         version: 1,
@@ -9832,10 +11258,10 @@ class WorktreeManager {
       return [];
     const worktrees = await listWorktreesGit(repoRoot);
     return worktrees.map((wt) => {
-      const metaPath = join12(wt.path, "groupy-thread.json");
-      if (existsSync21(metaPath)) {
+      const metaPath = join14(wt.path, "groupy-thread.json");
+      if (existsSync23(metaPath)) {
         try {
-          const raw = JSON.parse(readFileSync12(metaPath, "utf8"));
+          const raw = JSON.parse(readFileSync14(metaPath, "utf8"));
           return { ...wt, threadId: raw.ownerThreadId || raw.threadId };
         } catch {}
       }
@@ -10117,7 +11543,7 @@ function ClaudeLogo({
   }, undefined, false, undefined, this);
 }
 function ClaudeHeader({
-  version = "v0.3.2",
+  version = "v0.4.0",
   user = "Developer",
   model = "Claude 3.7 Sonnet (Thinking)",
   plan = "Pro",
@@ -11544,6 +12970,7 @@ export {
   AgentRoleRegistry,
   AgentSpawner,
   AuthClient,
+  AutoVerifier,
   BrowserLauncher,
   CHROME_DEVTOOLS_MCP_SERVER_PATH,
   CLAUDE_GLYPHS,
@@ -11565,6 +12992,8 @@ export {
   CredentialsStore,
   DEFAULT_AUTO_COMPACT_THRESHOLD_TOKENS,
   DEFAULT_MAX_CONTEXT_TOKENS,
+  DEFAULT_MAX_DIR_ENTRIES,
+  DEFAULT_MAX_UNPAGINATED_LINES,
   DEFAULT_WORKTREE_KEEP_COUNT,
   DefaultModelClientSession,
   DomSnapshotEngine,
@@ -11660,5 +13089,6 @@ export {
   submissionLoop,
   updatePlanTool,
   verifyTaskAction,
+  viewFileTool,
   writeFileTool
 };