crewswarm-cli 0.1.0

package/dist/engine.mjs

@@ -0,0 +1,3381 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/worker/autonomous-loop.ts
+async function executeAutonomous(task, executeLLM, executeTool, config) {
+  const maxTurns = config.maxTurns || DEFAULT_MAX_TURNS;
+  const repeatThreshold = config.repeatThreshold || DEFAULT_REPEAT_THRESHOLD;
+  const history = [];
+  let lastResponseText = "";
+  let staleCount = 0;
+  for (let turn = 0; turn < maxTurns; turn++) {
+    config.onProgress?.(turn + 1, "THINKING");
+    const response = await executeLLM(task, config.tools, history);
+    if (response.status === "COMPLETE" || !response.toolCalls || response.toolCalls.length === 0) {
+      return {
+        success: true,
+        turns: turn + 1,
+        history,
+        finalResponse: response.response
+      };
+    }
+    if (response.response && response.response.length > 20) {
+      if (response.response === lastResponseText) {
+        staleCount++;
+        if (staleCount >= 2) {
+          return {
+            success: true,
+            turns: turn + 1,
+            history,
+            finalResponse: response.response,
+            reason: "Detected stale response (same output repeated), treating as complete"
+          };
+        }
+      } else {
+        staleCount = 0;
+      }
+      lastResponseText = response.response;
+    }
+    if (response.toolCalls.length === 1) {
+      const call = response.toolCalls[0];
+      config.onProgress?.(turn + 1, `EXECUTING: ${call.tool}`);
+      try {
+        const result = await executeTool(call.tool, call.params);
+        history.push({ turn: turn + 1, tool: call.tool, params: call.params, result });
+      } catch (error) {
+        history.push({ turn: turn + 1, tool: call.tool, params: call.params, result: null, error: error.message });
+      }
+    } else {
+      config.onProgress?.(turn + 1, `EXECUTING ${response.toolCalls.length} tools in parallel`);
+      const results = await Promise.allSettled(
+        response.toolCalls.map(async (call) => {
+          config.onProgress?.(turn + 1, `EXECUTING: ${call.tool}`);
+          return { call, result: await executeTool(call.tool, call.params) };
+        })
+      );
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const call = response.toolCalls[i];
+        if (r.status === "fulfilled") {
+          history.push({ turn: turn + 1, tool: r.value.call.tool, params: r.value.call.params, result: r.value.result });
+        } else {
+          history.push({ turn: turn + 1, tool: call.tool, params: call.params, result: null, error: r.reason?.message || "parallel execution failed" });
+        }
+      }
+    }
+    if (turn > repeatThreshold && isRepeating(history, 3)) {
+      return {
+        success: false,
+        turns: turn + 1,
+        history,
+        reason: "Detected repeated actions, stopping to prevent infinite loop"
+      };
+    }
+  }
+  return {
+    success: false,
+    turns: maxTurns,
+    history,
+    reason: "Maximum turns exceeded without completing task"
+  };
+}
+function isRepeating(history, windowSize = 3) {
+  if (history.length < windowSize * 2) return false;
+  const recentActions = history.slice(-windowSize).map((h) => `${h.tool}:${JSON.stringify(h.params)}`);
+  const previousActions = history.slice(-windowSize * 2, -windowSize).map((h) => `${h.tool}:${JSON.stringify(h.params)}`);
+  return JSON.stringify(recentActions) === JSON.stringify(previousActions);
+}
+var DEFAULT_MAX_TURNS, DEFAULT_REPEAT_THRESHOLD;
+var init_autonomous_loop = __esm({
+  "src/worker/autonomous-loop.ts"() {
+    "use strict";
+    DEFAULT_MAX_TURNS = 25;
+    DEFAULT_REPEAT_THRESHOLD = 10;
+  }
+});
+
+// src/tools/gemini/definitions/base-declarations.ts
+var GLOB_TOOL_NAME, GREP_TOOL_NAME, LS_TOOL_NAME, READ_FILE_TOOL_NAME, SHELL_TOOL_NAME, WRITE_FILE_TOOL_NAME, EDIT_TOOL_NAME, WEB_SEARCH_TOOL_NAME, WRITE_TODOS_TOOL_NAME, WEB_FETCH_TOOL_NAME, READ_MANY_FILES_TOOL_NAME, MEMORY_TOOL_NAME, GET_INTERNAL_DOCS_TOOL_NAME, ACTIVATE_SKILL_TOOL_NAME, ASK_USER_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME;
+var init_base_declarations = __esm({
+  "src/tools/gemini/definitions/base-declarations.ts"() {
+    "use strict";
+    GLOB_TOOL_NAME = "glob";
+    GREP_TOOL_NAME = "grep_search";
+    LS_TOOL_NAME = "list_directory";
+    READ_FILE_TOOL_NAME = "read_file";
+    SHELL_TOOL_NAME = "run_shell_command";
+    WRITE_FILE_TOOL_NAME = "write_file";
+    EDIT_TOOL_NAME = "replace";
+    WEB_SEARCH_TOOL_NAME = "google_web_search";
+    WRITE_TODOS_TOOL_NAME = "write_todos";
+    WEB_FETCH_TOOL_NAME = "web_fetch";
+    READ_MANY_FILES_TOOL_NAME = "read_many_files";
+    MEMORY_TOOL_NAME = "save_memory";
+    GET_INTERNAL_DOCS_TOOL_NAME = "get_internal_docs";
+    ACTIVATE_SKILL_TOOL_NAME = "activate_skill";
+    ASK_USER_TOOL_NAME = "ask_user";
+    EXIT_PLAN_MODE_TOOL_NAME = "exit_plan_mode";
+    ENTER_PLAN_MODE_TOOL_NAME = "enter_plan_mode";
+  }
+});
+
+// src/lsp/index.ts
+var lsp_exports = {};
+__export(lsp_exports, {
+  getCompletions: () => getCompletions,
+  getDefinitions: () => getDefinitions,
+  getDocumentSymbols: () => getDocumentSymbols,
+  getReferences: () => getReferences,
+  typeCheckProject: () => typeCheckProject
+});
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+async function ensureTs() {
+  if (!_ts) {
+    _ts = await import("typescript").then((m) => m.default ?? m);
+  }
+  return _ts;
+}
+function categoryToText(cat) {
+  if (cat === 1) return "error";
+  if (cat === 0) return "warning";
+  if (cat === 2) return "suggestion";
+  return "message";
+}
+function loadProject(projectDir, ts) {
+  const root = resolve(projectDir);
+  const configPath = ts.findConfigFile(root, ts.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    throw new Error(`No tsconfig.json found at or above ${root}`);
+  }
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  if (configFile.error) {
+    throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
+  }
+  const parsed = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    dirname(configPath)
+  );
+  if (parsed.errors.length > 0) {
+    const first = parsed.errors[0];
+    throw new Error(ts.flattenDiagnosticMessageText(first.messageText, "\n"));
+  }
+  return {
+    root,
+    options: parsed.options,
+    fileNames: parsed.fileNames
+  };
+}
+async function typeCheckProject(projectDir, includeFiles = []) {
+  const ts = await ensureTs();
+  const project = loadProject(projectDir, ts);
+  const includeAbs = new Set(includeFiles.map((x) => resolve(project.root, x)));
+  const shouldFilter = includeAbs.size > 0;
+  const host = ts.createCompilerHost(project.options, true);
+  const program = ts.createProgram(project.fileNames, project.options, host);
+  const diagnostics = ts.getPreEmitDiagnostics(program);
+  const out = [];
+  for (const diagnostic of diagnostics) {
+    const sourceFile = diagnostic.file;
+    if (!sourceFile) continue;
+    const absFile = resolve(sourceFile.fileName);
+    if (shouldFilter && !includeAbs.has(absFile)) continue;
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+    out.push({
+      file: absFile,
+      line: line + 1,
+      column: character + 1,
+      code: diagnostic.code,
+      category: categoryToText(diagnostic.category),
+      message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+    });
+  }
+  return out;
+}
+function kindToText(kind) {
+  return String(kind || "unknown");
+}
+function createLanguageService(projectDir, ts) {
+  const project = loadProject(projectDir, ts);
+  const sourceTexts = /* @__PURE__ */ new Map();
+  for (const file of project.fileNames) {
+    const text = ts.sys.readFile(file) || "";
+    sourceTexts.set(resolve(file), { version: 1, text });
+  }
+  const serviceHost = {
+    getCompilationSettings: () => project.options,
+    getScriptFileNames: () => Array.from(sourceTexts.keys()),
+    getScriptVersion: (fileName) => String(sourceTexts.get(resolve(fileName))?.version || 1),
+    getScriptSnapshot: (fileName) => {
+      const resolved = resolve(fileName);
+      const entry = sourceTexts.get(resolved);
+      if (!entry) return void 0;
+      return ts.ScriptSnapshot.fromString(entry.text);
+    },
+    getCurrentDirectory: () => project.root,
+    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories
+  };
+  const service = ts.createLanguageService(serviceHost);
+  return { service, project, sourceTexts };
+}
+function lineColToPosition(text, line, column) {
+  const lines = text.split("\n");
+  const lineIndex = Math.max(0, line - 1);
+  const offset = lines.slice(0, lineIndex).reduce((sum, x) => sum + x.length + 1, 0) + Math.max(0, column - 1);
+  return Math.min(offset, text.length);
+}
+async function getCompletions(projectDir, filePath, line, column, limit = 50, prefix = "") {
+  const ts = await ensureTs();
+  const { service, project, sourceTexts } = createLanguageService(projectDir, ts);
+  try {
+    const absFile = resolve(project.root, filePath);
+    if (!existsSync(absFile)) {
+      throw new Error(`File not found: ${absFile}`);
+    }
+    if (!sourceTexts.has(absFile)) {
+      sourceTexts.set(absFile, { version: 1, text: ts.sys.readFile(absFile) || "" });
+    }
+    const fileText = sourceTexts.get(absFile)?.text || "";
+    const lines = fileText.split("\n");
+    const lineIndex = Math.max(0, line - 1);
+    const safeLine = lines[lineIndex] || "";
+    const offset = lines.slice(0, lineIndex).reduce((sum, x) => sum + x.length + 1, 0) + Math.max(0, column - 1);
+    const position = Math.min(offset, fileText.length);
+    const completions = service.getCompletionsAtPosition(absFile, position, {
+      includeCompletionsWithInsertText: true,
+      includeCompletionsForModuleExports: true
+    });
+    const items = (completions?.entries || []).filter((entry) => {
+      if (!prefix) return true;
+      return entry.name.toLowerCase().startsWith(prefix.toLowerCase());
+    });
+    return items.slice(0, Math.max(1, limit)).map((entry) => ({
+      name: entry.name,
+      kind: kindToText(entry.kind),
+      sortText: entry.sortText
+    }));
+  } finally {
+    service.dispose();
+  }
+}
+async function getDefinitions(projectDir, filePath, line, column) {
+  const ts = await ensureTs();
+  const { service, project, sourceTexts } = createLanguageService(projectDir, ts);
+  try {
+    const absFile = resolve(project.root, filePath);
+    const fileText = sourceTexts.get(absFile)?.text || ts.sys.readFile(absFile) || "";
+    const position = lineColToPosition(fileText, line, column);
+    const defs = service.getDefinitionAtPosition(absFile, position) || [];
+    return defs.map((def) => {
+      const sf = service.getProgram()?.getSourceFile(def.fileName);
+      const lc = sf?.getLineAndCharacterOfPosition(def.textSpan.start) || { line: 0, character: 0 };
+      return {
+        file: resolve(def.fileName),
+        line: lc.line + 1,
+        column: lc.character + 1
+      };
+    });
+  } finally {
+    service.dispose();
+  }
+}
+async function getReferences(projectDir, filePath, line, column) {
+  const ts = await ensureTs();
+  const { service, project, sourceTexts } = createLanguageService(projectDir, ts);
+  try {
+    const absFile = resolve(project.root, filePath);
+    const fileText = sourceTexts.get(absFile)?.text || ts.sys.readFile(absFile) || "";
+    const position = lineColToPosition(fileText, line, column);
+    const refs = service.getReferencesAtPosition(absFile, position) || [];
+    return refs.map((ref) => {
+      const sf = service.getProgram()?.getSourceFile(ref.fileName);
+      const lc = sf?.getLineAndCharacterOfPosition(ref.textSpan.start) || { line: 0, character: 0 };
+      return {
+        file: resolve(ref.fileName),
+        line: lc.line + 1,
+        column: lc.character + 1
+      };
+    });
+  } finally {
+    service.dispose();
+  }
+}
+async function getDocumentSymbols(projectDir, filePath) {
+  const ts = await ensureTs();
+  const { service, project } = createLanguageService(projectDir, ts);
+  try {
+    const absFile = resolve(project.root, filePath);
+    const nav = service.getNavigationTree(absFile);
+    const out = [];
+    const walk = (node) => {
+      for (const span of node.spans || []) {
+        const sf = service.getProgram()?.getSourceFile(absFile);
+        const lc = sf?.getLineAndCharacterOfPosition(span.start) || { line: 0, character: 0 };
+        if (node.text && node.text !== "<global>") {
+          out.push({
+            name: node.text,
+            kind: String(node.kind || "unknown"),
+            line: lc.line + 1,
+            column: lc.character + 1
+          });
+        }
+      }
+      for (const child of node.childItems || []) walk(child);
+    };
+    walk(nav);
+    return out;
+  } finally {
+    service.dispose();
+  }
+}
+var _ts;
+var init_lsp = __esm({
+  "src/lsp/index.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/docker-sandbox.ts
+var docker_sandbox_exports = {};
+__export(docker_sandbox_exports, {
+  DockerSandbox: () => DockerSandbox
+});
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+var DockerSandbox;
+var init_docker_sandbox = __esm({
+  "src/tools/docker-sandbox.ts"() {
+    "use strict";
+    DockerSandbox = class {
+      constructor() {
+        this.defaultImage = "node:20-slim";
+        this.defaultTimeout = 3e4;
+      }
+      // 30 seconds
+      /**
+       * Check if Docker is available and running
+       */
+      async isDockerAvailable() {
+        try {
+          execSync("docker info", {
+            stdio: "ignore",
+            timeout: 5e3
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Copy staged files from sandbox to temp directory
+       */
+      async prepareTempDir(sandbox, tempDir) {
+        const pendingPaths = sandbox.getPendingPaths();
+        const branch = sandbox.state?.branches?.[sandbox.getActiveBranch()];
+        if (!branch) return 0;
+        let fileCount = 0;
+        for (const filePath of pendingPaths) {
+          const fileData = branch[filePath];
+          if (!fileData?.modified) continue;
+          const fullPath = path.join(tempDir, filePath);
+          const dir = path.dirname(fullPath);
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          fs.writeFileSync(fullPath, fileData.modified, "utf8");
+          fileCount++;
+        }
+        return fileCount;
+      }
+      /**
+       * Run command in Docker container with staged files
+       */
+      async runCommand(command, sandbox, options = {}) {
+        const startTime = Date.now();
+        const tempDir = path.join("/tmp", `crew-sandbox-${randomUUID()}`);
+        const image = options.image || this.defaultImage;
+        const timeout = options.timeout || this.defaultTimeout;
+        const workDir = options.workDir || process.cwd();
+        try {
+          fs.mkdirSync(tempDir, { recursive: true });
+          console.log(`[Docker] Created temp dir: ${tempDir}`);
+          const fileCount = await this.prepareTempDir(sandbox, tempDir);
+          console.log(`[Docker] Copied ${fileCount} staged file(s) to sandbox`);
+          const pkgPath = path.join(workDir, "package.json");
+          if (fs.existsSync(pkgPath)) {
+            fs.copyFileSync(pkgPath, path.join(tempDir, "package.json"));
+            console.log(`[Docker] Copied package.json`);
+          }
+          const needsNodeModules = /\b(npm|node|npx)\b/.test(command);
+          if (needsNodeModules) {
+            const nodeModulesPath = path.join(workDir, "node_modules");
+            if (fs.existsSync(nodeModulesPath)) {
+              console.log(`[Docker] Copying node_modules (this may take a few seconds)...`);
+              execSync(`cp -r "${nodeModulesPath}" "${tempDir}/"`, {
+                stdio: "ignore",
+                timeout: 1e4
+              });
+            }
+          }
+          const envFlags = options.env ? Object.entries(options.env).map(([k, v]) => `-e ${k}="${v}"`).join(" ") : "";
+          console.log(`[Docker] Running: ${command}`);
+          const dockerCmd = `docker run --rm -v "${tempDir}":/work -w /work ${envFlags} ${image} sh -c "${command.replace(/"/g, '\\"')}"`;
+          const output = execSync(dockerCmd, {
+            encoding: "utf8",
+            timeout,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          const duration = Date.now() - startTime;
+          console.log(`[Docker] \u2713 Command completed in ${duration}ms`);
+          return {
+            success: true,
+            output,
+            exitCode: 0,
+            duration
+          };
+        } catch (err) {
+          const duration = Date.now() - startTime;
+          console.log(`[Docker] \u2717 Command failed after ${duration}ms`);
+          return {
+            success: false,
+            output: err.stdout || err.stderr || err.message,
+            exitCode: err.status || 1,
+            duration
+          };
+        } finally {
+          try {
+            if (fs.existsSync(tempDir)) {
+              fs.rmSync(tempDir, { recursive: true, force: true });
+              console.log(`[Docker] Cleaned up temp dir`);
+            }
+          } catch (cleanupErr) {
+            console.warn(`[Docker] Failed to cleanup ${tempDir}:`, cleanupErr);
+          }
+        }
+      }
+      /**
+       * Pull Docker image if not present (with progress)
+       */
+      async ensureImage(image = this.defaultImage) {
+        try {
+          execSync(`docker image inspect ${image}`, {
+            stdio: "ignore",
+            timeout: 5e3
+          });
+          return true;
+        } catch {
+          console.log(`[Docker] Pulling image ${image}...`);
+          try {
+            execSync(`docker pull ${image}`, {
+              stdio: "inherit",
+              // Show progress
+              timeout: 12e4
+              // 2 minutes for image pull
+            });
+            console.log(`[Docker] \u2713 Image pulled successfully`);
+            return true;
+          } catch (pullErr) {
+            console.error(`[Docker] Failed to pull image:`, pullErr);
+            return false;
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/tools/gemini/crew-adapter.ts
+import { execSync as execSync2 } from "node:child_process";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join, resolve as resolve2 } from "node:path";
+function getShellTimeout() {
+  const envVal = parseInt(process.env.CREW_SHELL_TIMEOUT || "", 10);
+  if (envVal > 0) return Math.min(envVal * 1e3, 6e5);
+  return 12e4;
+}
+var CrewConfig, CrewMessageBus, DANGEROUS_SHELL_PATTERNS, _backgroundProcesses, GeminiToolAdapter;
+var init_crew_adapter = __esm({
+  "src/tools/gemini/crew-adapter.ts"() {
+    "use strict";
+    init_base_declarations();
+    CrewConfig = class {
+      constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+      }
+      getWorkspaceRoot() {
+        return this.workspaceRoot;
+      }
+      getTargetDir() {
+        return this.workspaceRoot;
+      }
+    };
+    CrewMessageBus = class {
+      async requestConfirmation() {
+        return { status: "approved" };
+      }
+    };
+    DANGEROUS_SHELL_PATTERNS = [
+      /\brm\s+-rf?\s/,
+      // rm -r / rm -rf
+      /\bgit\s+push\s+.*--force/,
+      // force push
+      /\bgit\s+reset\s+--hard/,
+      // hard reset
+      /\bgit\s+clean\s+-f/,
+      // clean untracked
+      /\bdrop\s+table\b/i,
+      // SQL drop
+      /\bdrop\s+database\b/i,
+      // SQL drop database
+      /\bkill\s+-9\b/,
+      // kill -9
+      /\bmkfs\b/,
+      // format filesystem
+      /\bdd\s+if=/
+      // dd (disk destroyer)
+    ];
+    _backgroundProcesses = /* @__PURE__ */ new Map();
+    GeminiToolAdapter = class _GeminiToolAdapter {
+      // Track reads for read-before-edit guard
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+        this._filesRead = /* @__PURE__ */ new Set();
+        const workspaceRoot = sandbox.baseDir || process.cwd();
+        this.config = new CrewConfig(workspaceRoot);
+        this.messageBus = new CrewMessageBus();
+      }
+      buildDynamicDeclarations() {
+        const staticDecls = this.getStaticToolDeclarations();
+        const staticByName = new Map(staticDecls.map((d) => [d.name, d]));
+        const canonicalNames = [
+          READ_FILE_TOOL_NAME,
+          WRITE_FILE_TOOL_NAME,
+          EDIT_TOOL_NAME,
+          GLOB_TOOL_NAME,
+          GREP_TOOL_NAME,
+          LS_TOOL_NAME,
+          SHELL_TOOL_NAME,
+          WEB_SEARCH_TOOL_NAME,
+          WEB_FETCH_TOOL_NAME,
+          READ_MANY_FILES_TOOL_NAME,
+          MEMORY_TOOL_NAME,
+          WRITE_TODOS_TOOL_NAME,
+          GET_INTERNAL_DOCS_TOOL_NAME,
+          ACTIVATE_SKILL_TOOL_NAME,
+          ASK_USER_TOOL_NAME,
+          ENTER_PLAN_MODE_TOOL_NAME,
+          EXIT_PLAN_MODE_TOOL_NAME,
+          "grep_search_ripgrep",
+          "tracker_create_task",
+          "tracker_update_task",
+          "tracker_get_task",
+          "tracker_list_tasks",
+          "tracker_add_dependency",
+          "tracker_visualize",
+          "spawn_agent",
+          "check_background_task"
+        ];
+        const canonical = canonicalNames.map((name) => {
+          const found = staticByName.get(name);
+          if (found) return found;
+          return {
+            name,
+            description: `${name} tool`,
+            parameters: { type: "object", properties: {} }
+          };
+        });
+        const aliases = [
+          { alias: "read_file", target: "read_file" },
+          { alias: "write_file", target: "write_file" },
+          { alias: "append_file", target: "write_file" },
+          { alias: "edit", target: "replace" },
+          { alias: "replace", target: "replace" },
+          { alias: "glob", target: "glob" },
+          { alias: "grep", target: "grep_search" },
+          { alias: "grep_search", target: "grep_search" },
+          { alias: "grep_search_ripgrep", target: "grep_search_ripgrep" },
+          { alias: "list", target: "list_directory" },
+          { alias: "list_directory", target: "list_directory" },
+          { alias: "shell", target: "run_shell_command" },
+          { alias: "run_cmd", target: "run_shell_command" },
+          { alias: "run_shell_command", target: "run_shell_command" },
+          { alias: "web_search", target: "google_web_search" },
+          { alias: "google_web_search", target: "google_web_search" },
+          { alias: "web_fetch", target: "web_fetch" },
+          { alias: "save_memory", target: "save_memory" },
+          { alias: "write_todos", target: "write_todos" },
+          { alias: "get_internal_docs", target: "get_internal_docs" },
+          { alias: "ask_user", target: "ask_user" },
+          { alias: "enter_plan_mode", target: "enter_plan_mode" },
+          { alias: "exit_plan_mode", target: "exit_plan_mode" },
+          { alias: "activate_skill", target: "activate_skill" },
+          { alias: "tracker_create_task", target: "tracker_create_task" },
+          { alias: "tracker_update_task", target: "tracker_update_task" },
+          { alias: "tracker_get_task", target: "tracker_get_task" },
+          { alias: "tracker_list_tasks", target: "tracker_list_tasks" },
+          { alias: "tracker_add_dependency", target: "tracker_add_dependency" },
+          { alias: "tracker_visualize", target: "tracker_visualize" },
+          { alias: "mkdir", target: "write_file" },
+          { alias: "git", target: "run_shell_command" }
+          // LSP is not yet implemented — don't alias to read_file (misleads the model)
+          // { alias: 'lsp', target: 'read_file' }
+        ];
+        const byName = /* @__PURE__ */ new Map();
+        for (const decl of canonical) byName.set(decl.name, decl);
+        for (const a of aliases) {
+          const target = byName.get(a.target);
+          if (!target) continue;
+          if (!byName.has(a.alias)) {
+            byName.set(a.alias, { ...target, name: a.alias });
+          }
+        }
+        byName.set("mkdir", {
+          name: "mkdir",
+          description: "Create a directory path (staged via sandbox).",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", description: "Directory path to create" },
+              dir_path: { type: "string", description: "Alternative directory path field" }
+            }
+          }
+        });
+        byName.set("git", {
+          name: "git",
+          description: "Run limited git subcommands (status/diff/log/add/commit/show/branch).",
+          parameters: {
+            type: "object",
+            properties: {
+              command: { type: "string", description: "Git subcommand and args" }
+            },
+            required: ["command"]
+          }
+        });
+        byName.set("lsp", {
+          name: "lsp",
+          description: "Run code-intel queries (symbols/refs/goto/diagnostics/complete).",
+          parameters: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "LSP query string" }
+            },
+            required: ["query"]
+          }
+        });
+        return Array.from(byName.values());
+      }
+      getStaticToolDeclarations() {
+        return [
+          { name: "read_file", description: "Read file", parameters: { type: "object", properties: { file_path: { type: "string" } }, required: ["file_path"] } },
+          { name: "write_file", description: "Write file", parameters: { type: "object", properties: { file_path: { type: "string" }, content: { type: "string" } }, required: ["file_path", "content"] } },
+          { name: "replace", description: "Replace text in file. old_string must uniquely match one location (use replace_all:true for all occurrences). You MUST read_file before editing.", parameters: { type: "object", properties: { file_path: { type: "string" }, old_string: { type: "string" }, new_string: { type: "string" }, replace_all: { type: "boolean", description: "Replace ALL occurrences (useful for renames). Default: false (unique match required)" } }, required: ["file_path", "old_string", "new_string"] } },
+          { name: "glob", description: "Glob search", parameters: { type: "object", properties: { pattern: { type: "string" } }, required: ["pattern"] } },
+          { name: "grep_search", description: "Search for regex/text in files. Supports output modes (content/files/count), context lines, case insensitivity, file type filters.", parameters: { type: "object", properties: { pattern: { type: "string" }, path: { type: "string" }, dir_path: { type: "string" }, output_mode: { type: "string", description: "content (matching lines), files (file paths only), count (match counts)" }, context: { type: "number", description: "Lines of context around matches" }, before: { type: "number" }, after: { type: "number" }, case_insensitive: { type: "boolean" }, type: { type: "string", description: "File type filter (js, py, ts, go, etc.)" }, max_results: { type: "number" } }, required: ["pattern"] } },
+          { name: "grep_search_ripgrep", description: "Alias for grep_search with same capabilities", parameters: { type: "object", properties: { pattern: { type: "string" }, path: { type: "string" }, dir_path: { type: "string" }, output_mode: { type: "string" }, context: { type: "number" }, case_insensitive: { type: "boolean" }, type: { type: "string" }, max_results: { type: "number" } }, required: ["pattern"] } },
+          { name: "list_directory", description: "List directory", parameters: { type: "object", properties: { dir_path: { type: "string" }, path: { type: "string" } } } },
+          { name: "run_shell_command", description: "Run shell command (configurable timeout, Docker isolation when staged files exist). Use run_in_background:true for long-running commands.", parameters: { type: "object", properties: { command: { type: "string" }, run_in_background: { type: "boolean", description: "Run in background and return task ID. Use check_background_task to get result." }, description: { type: "string", description: "Brief description of what the command does" } }, required: ["command"] } },
+          { name: "google_web_search", description: "Web search", parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] } },
+          { name: "web_fetch", description: "Fetch URL", parameters: { type: "object", properties: { url: { type: "string" }, prompt: { type: "string" } } } },
+          { name: "read_many_files", description: "Read many files", parameters: { type: "object", properties: { include: { type: "string" }, exclude: { type: "string" }, recursive: { type: "boolean" } } } },
+          { name: "save_memory", description: "Save memory fact", parameters: { type: "object", properties: { fact: { type: "string" } }, required: ["fact"] } },
+          { name: "write_todos", description: "Write todos", parameters: { type: "object", properties: { todos: { type: "array", items: { type: "object", properties: { text: { type: "string" }, done: { type: "boolean" } } } } }, required: ["todos"] } },
+          { name: "get_internal_docs", description: "Read internal docs", parameters: { type: "object", properties: { path: { type: "string" } } } },
+          { name: "ask_user", description: "Ask user placeholder", parameters: { type: "object", properties: { questions: { type: "array", items: { type: "object", properties: { question: { type: "string" } } } } } } },
+          { name: "enter_plan_mode", description: "Enter plan mode", parameters: { type: "object", properties: { reason: { type: "string" } } } },
+          { name: "exit_plan_mode", description: "Exit plan mode", parameters: { type: "object", properties: { plan_path: { type: "string" } } } },
+          { name: "activate_skill", description: "Activate skill", parameters: { type: "object", properties: { name: { type: "string" } }, required: ["name"] } },
+          { name: "tracker_create_task", description: "Create tracker task", parameters: { type: "object", properties: { title: { type: "string" }, description: { type: "string" }, type: { type: "string" }, parentId: { type: "string" }, dependencies: { type: "array", items: { type: "string" } } }, required: ["title", "description", "type"] } },
+          { name: "tracker_update_task", description: "Update tracker task", parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"] } },
+          { name: "tracker_get_task", description: "Get tracker task", parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"] } },
+          { name: "tracker_list_tasks", description: "List tracker tasks", parameters: { type: "object", properties: { status: { type: "string" }, type: { type: "string" }, parentId: { type: "string" } } } },
+          { name: "tracker_add_dependency", description: "Add tracker dependency", parameters: { type: "object", properties: { taskId: { type: "string" }, dependencyId: { type: "string" } }, required: ["taskId", "dependencyId"] } },
+          { name: "tracker_visualize", description: "Visualize tracker graph", parameters: { type: "object", properties: {} } },
+          { name: "spawn_agent", description: "Spawn a sub-agent to handle a task autonomously in parallel. Use for independent research, file analysis, or coding subtasks. Returns the sub-agent result when complete.", parameters: { type: "object", properties: { task: { type: "string", description: "Clear task description for the sub-agent" }, model: { type: "string", description: "Optional model override (default: use cheap model for workers)" }, max_turns: { type: "number", description: "Max turns for sub-agent (default: 15)" } }, required: ["task"] } },
+          { name: "check_background_task", description: "Check the status/result of a background shell command. Returns result if done, or elapsed time if still running.", parameters: { type: "object", properties: { task_id: { type: "string", description: "Task ID returned by run_shell_command with run_in_background:true" } }, required: ["task_id"] } }
+        ];
+      }
+      /**
+       * Execute a tool call from LLM
+       */
+      async executeTool(toolName, params) {
+        try {
+          switch (toolName) {
+            // Canonical Gemini names + local aliases
+            case "write_file":
+              return await this.writeFile(params);
+            case "replace":
+              return await this.editFile({
+                file_path: params.file_path,
+                old_string: params.old_string,
+                new_string: params.new_string,
+                replace_all: params.replace_all
+              });
+            case "append_file":
+              return await this.appendFile(params);
+            case "read_file":
+              return await this.readFile(params);
+            case "edit":
+              return await this.editFile(params);
+            case "read_many_files":
+              return await this.readManyFilesTool(params);
+            case "save_memory":
+              return await this.saveMemoryTool(params);
+            case "write_todos":
+              return await this.writeTodosTool(params);
+            case "get_internal_docs":
+              return await this.getInternalDocsTool(params);
+            case "ask_user":
+              return await this.askUserTool(params);
+            case "enter_plan_mode":
+              return await this.enterPlanModeTool(params);
+            case "exit_plan_mode":
+              return await this.exitPlanModeTool(params);
+            case "activate_skill":
+              return await this.activateSkillTool(params);
+            case "mkdir":
+              return await this.mkdirTool(params);
+            case "list":
+              return await this.listTool(params);
+            case "list_directory":
+              return await this.listTool({ dir_path: params.dir_path || params.path });
+            case "glob":
+              return await this.globTool(params);
+            case "grep":
+              return await this.grepTool(params);
+            case "grep_search":
+            case "grep_search_ripgrep":
+              return await this.grepTool({
+                pattern: params.pattern,
+                path: params.dir_path || params.path,
+                output_mode: params.output_mode,
+                context: params.context,
+                before: params.before,
+                after: params.after,
+                case_insensitive: params.case_insensitive,
+                type: params.type,
+                max_results: params.max_results
+              });
+            case "git":
+              return await this.gitTool(params);
+            case "shell":
+            case "run_cmd":
+            case "run_shell_command":
+              return await this.shellTool(params);
+            case "lsp":
+              return await this.lspTool(params);
+            case "web_search":
+            case "google_web_search":
+              return await this.webSearchTool(params);
+            case "web_fetch":
+              return await this.webFetchTool(params);
+            case "tracker_create_task":
+              return await this.trackerCreateTaskTool(params);
+            case "tracker_update_task":
+              return await this.trackerUpdateTaskTool(params);
+            case "tracker_get_task":
+              return await this.trackerGetTaskTool(params);
+            case "tracker_list_tasks":
+              return await this.trackerListTasksTool(params);
+            case "tracker_add_dependency":
+              return await this.trackerAddDependencyTool(params);
+            case "tracker_visualize":
+              return await this.trackerVisualizeTool();
+            case "spawn_agent":
+              return await this.spawnAgentTool(params);
+            case "check_background_task":
+              return await this.checkBackgroundTask(params);
+            default:
+              return {
+                success: false,
+                error: `Unknown tool: ${toolName}`
+              };
+          }
+        } catch (err) {
+          return {
+            success: false,
+            error: err.message
+          };
+        }
+      }
+      async writeFile(params) {
+        const fullPath = resolve2(this.config.getWorkspaceRoot(), params.file_path);
+        const wsRoot = resolve2(this.config.getWorkspaceRoot());
+        if (!fullPath.startsWith(wsRoot + "/") && fullPath !== wsRoot) {
+          return { success: false, error: `Access denied: path "${params.file_path}" resolves outside workspace root.` };
+        }
+        await this.sandbox.addChange(params.file_path, params.content);
+        return {
+          success: true,
+          output: `Staged ${params.file_path} (${params.content.length} bytes)`
+        };
+      }
+      async appendFile(params) {
+        const filePath = resolve2(this.config.getWorkspaceRoot(), params.file_path);
+        let existing = "";
+        try {
+          const stagedContent = this.sandbox.getStagedContent?.(params.file_path) || this.sandbox.getStagedContent?.(filePath);
+          existing = stagedContent ?? await readFile(filePath, "utf8");
+        } catch {
+          existing = "";
+        }
+        const combined = `${existing}${params.content || ""}`;
+        await this.sandbox.addChange(params.file_path, combined);
+        return {
+          success: true,
+          output: `Appended ${params.file_path} (${(params.content || "").length} bytes)`
+        };
+      }
+      async readFile(params) {
+        const filePath = resolve2(this.config.getWorkspaceRoot(), params.file_path);
+        const wsRoot = resolve2(this.config.getWorkspaceRoot());
+        if (!filePath.startsWith(wsRoot + "/") && filePath !== wsRoot) {
+          return { success: false, error: `Access denied: path "${params.file_path}" resolves outside workspace root.` };
+        }
+        this._filesRead.add(params.file_path);
+        this._filesRead.add(filePath);
+        const stagedContent = this.sandbox.getStagedContent?.(params.file_path) || this.sandbox.getStagedContent?.(filePath);
+        const content = stagedContent ?? await readFile(filePath, "utf8");
+        if (params.start_line || params.end_line) {
+          const lines = content.split("\n");
+          const start = (params.start_line || 1) - 1;
+          const end = params.end_line || lines.length;
+          const slice = lines.slice(start, end).join("\n");
+          return { success: true, output: slice };
+        }
+        return { success: true, output: content };
+      }
+      async editFile(params) {
+        const filePath = resolve2(this.config.getWorkspaceRoot(), params.file_path);
+        const wsRoot = resolve2(this.config.getWorkspaceRoot());
+        if (!filePath.startsWith(wsRoot + "/") && filePath !== wsRoot) {
+          return { success: false, error: `Access denied: path "${params.file_path}" resolves outside workspace root.` };
+        }
+        if (!this._filesRead.has(params.file_path) && !this._filesRead.has(filePath)) {
+          return {
+            success: false,
+            error: `You must read_file "${params.file_path}" before editing it. Never guess at file contents.`
+          };
+        }
+        const stagedContent = this.sandbox.getStagedContent?.(params.file_path) || this.sandbox.getStagedContent?.(filePath);
+        const content = stagedContent ?? await readFile(filePath, "utf8");
+        if (!content.includes(params.old_string)) {
+          return {
+            success: false,
+            error: `String not found in ${params.file_path}`
+          };
+        }
+        const occurrences = content.split(params.old_string).length - 1;
+        if (params.replace_all) {
+          const updated2 = content.split(params.old_string).join(params.new_string);
+          await this.sandbox.addChange(params.file_path, updated2);
+          const diagnostics2 = await this.shadowValidate(params.file_path);
+          return {
+            success: true,
+            output: `Edited ${params.file_path} (${occurrences} replacements)${diagnostics2}`
+          };
+        }
+        if (occurrences > 1) {
+          return {
+            success: false,
+            error: `old_string matches ${occurrences} locations in ${params.file_path}. Provide more context to make it unique, or use replace_all:true to replace all occurrences.`
+          };
+        }
+        const updated = content.replace(params.old_string, params.new_string);
+        await this.sandbox.addChange(params.file_path, updated);
+        const diagnostics = await this.shadowValidate(params.file_path);
+        return {
+          success: true,
+          output: `Edited ${params.file_path}${diagnostics}`
+        };
+      }
+      /**
+       * Shadow validation: after an edit, check for type/lint errors using LSP.
+       * Returns empty string if clean, or diagnostic summary if errors found.
+       * Non-fatal — silently returns empty on any failure.
+       */
+      async shadowValidate(filePath) {
+        if (!/\.(ts|tsx|js|jsx|mjs|mts)$/.test(filePath)) return "";
+        try {
+          const lsp = await Promise.resolve().then(() => (init_lsp(), lsp_exports));
+          const diags = await lsp.typeCheckProject(this.config.getWorkspaceRoot(), [filePath]);
+          const fileErrors = diags.filter(
+            (d) => d.category === "error" && d.file?.endsWith(filePath)
+          );
+          if (fileErrors.length === 0) return "";
+          const errorLines = fileErrors.slice(0, 5).map(
+            (d) => `  ${d.file}:${d.line} \u2014 ${d.message}`
+          );
+          return `
+
+\u26A0\uFE0F Shadow validation found ${fileErrors.length} error(s) after edit:
+${errorLines.join("\n")}${fileErrors.length > 5 ? `
+  ... and ${fileErrors.length - 5} more` : ""}
+Fix these before moving on.`;
+        } catch {
+          return "";
+        }
+      }
+      async mkdirTool(params) {
+        const dir = (params.path || params.dir_path || "").trim();
+        if (!dir) return { success: false, error: "mkdir requires path" };
+        const keep = join(dir, ".gitkeep");
+        await this.sandbox.addChange(keep, "");
+        return { success: true, output: `Staged directory ${dir}` };
+      }
+      async listTool(params) {
+        const target = (params.path || params.dir_path || ".").trim();
+        const abs = resolve2(process.cwd(), target);
+        const items = await readdir(abs, { withFileTypes: true });
+        const lines = items.map((i) => `${i.isDirectory() ? "d" : "f"} ${i.name}`);
+        return { success: true, output: lines.join("\n") };
+      }
+      async globTool(params) {
+        const pattern = String(params.pattern || "").trim();
+        if (!pattern) return { success: false, error: "glob requires pattern" };
+        try {
+          const out = execSync2(`rg --files -g ${JSON.stringify(pattern)}`, { cwd: process.cwd(), stdio: "pipe", encoding: "utf8" });
+          return { success: true, output: out.trim() };
+        } catch (err) {
+          return { success: false, error: err?.stderr?.toString?.() || err?.message || "glob failed" };
+        }
+      }
+      async grepTool(params) {
+        const pattern = String(params.pattern || "").trim();
+        const searchPath = String(params.path || ".").trim();
+        if (!pattern) return { success: false, error: "grep requires pattern" };
+        const args = ["rg"];
+        const mode = params.output_mode || "content";
+        if (mode === "files") {
+          args.push("-l");
+        } else if (mode === "count") {
+          args.push("-c");
+        } else {
+          args.push("-n");
+        }
+        if (params.context) args.push(`-C${params.context}`);
+        else {
+          if (params.before) args.push(`-B${params.before}`);
+          if (params.after) args.push(`-A${params.after}`);
+        }
+        if (params.case_insensitive) args.push("-i");
+        if (params.type) args.push(`--type=${params.type}`);
+        if (params.max_results) args.push(`-m${params.max_results}`);
+        args.push(JSON.stringify(pattern), JSON.stringify(searchPath));
+        try {
+          const out = execSync2(args.join(" "), {
+            cwd: process.cwd(),
+            stdio: "pipe",
+            encoding: "utf8"
+          });
+          return { success: true, output: out.trim() };
+        } catch (err) {
+          const text = `${err?.stdout?.toString?.() || ""}
+${err?.stderr?.toString?.() || ""}`.trim();
+          if (err?.status === 1 && !text) return { success: true, output: "(no matches)" };
+          return { success: false, error: text || err?.message || "grep failed" };
+        }
+      }
+      async gitTool(params) {
+        const command = String(params.command || "").trim();
+        if (!command) return { success: false, error: "git requires command" };
+        const allowed = ["status", "diff", "log", "add", "commit", "show", "branch", "stash", "tag", "blame", "checkout", "switch", "restore", "rev-parse", "remote", "fetch", "pull", "push", "merge", "rebase", "reset", "cherry-pick", "worktree"];
+        const verb = command.split(/\s+/)[0];
+        if (!allowed.includes(verb)) {
+          return { success: false, error: `git subcommand not allowed: ${verb}. Allowed: ${allowed.join(", ")}` };
+        }
+        if (/--force|--force-with-lease/.test(command) && verb === "push") {
+          return { success: false, error: "Force push is not allowed. Use a regular push or create a new branch." };
+        }
+        if (/--no-verify/.test(command)) {
+          return { success: false, error: "Skipping hooks (--no-verify) is not allowed. Fix the hook issue instead." };
+        }
+        if (verb === "reset" && /--hard/.test(command)) {
+          return { success: false, error: "git reset --hard is destructive. Use git stash or git checkout <file> instead." };
+        }
+        if (/[;&|`$(){}\\!<>]/.test(command)) {
+          return { success: false, error: "git command contains disallowed shell characters. Use only git arguments." };
+        }
+        try {
+          const args = command.split(/\s+/).filter(Boolean);
+          const { execFileSync } = await import("node:child_process");
+          const out = execFileSync("git", args, {
+            cwd: this.config.getWorkspaceRoot(),
+            stdio: "pipe",
+            encoding: "utf8",
+            timeout: 3e4
+          });
+          return { success: true, output: out.trim() };
+        } catch (err) {
+          const text = `${err?.stdout?.toString?.() || ""}
+${err?.stderr?.toString?.() || ""}`.trim();
+          return { success: false, error: text || err?.message || "git failed" };
+        }
+      }
+      async shellTool(params) {
+        const command = String(params.command || "").trim();
+        if (!command) return { success: false, error: "shell requires command" };
+        for (const pat of DANGEROUS_SHELL_PATTERNS) {
+          if (pat.test(command)) {
+            return { success: false, error: `Blocked: destructive command detected (${command.slice(0, 60)}). Use a safer alternative.` };
+          }
+        }
+        if (params.run_in_background) {
+          const taskId = `bg_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+          const bgPromise = (async () => {
+            try {
+              const { spawn } = await import("node:child_process");
+              return new Promise((resolve4) => {
+                const proc = spawn("sh", ["-c", command], {
+                  cwd: this.config.getWorkspaceRoot(),
+                  stdio: "pipe"
+                });
+                let stdout = "", stderr = "";
+                proc.stdout?.on("data", (d) => {
+                  stdout += d.toString();
+                });
+                proc.stderr?.on("data", (d) => {
+                  stderr += d.toString();
+                });
+                const timeout = setTimeout(() => {
+                  proc.kill("SIGTERM");
+                  resolve4({ success: false, error: "Background task timed out" });
+                }, getShellTimeout());
+                proc.on("close", (code) => {
+                  clearTimeout(timeout);
+                  resolve4(code === 0 ? { success: true, output: stdout.trim() } : { success: false, error: (stderr || stdout).trim() || `exit code ${code}` });
+                });
+              });
+            } catch (err) {
+              return { success: false, error: err.message };
+            }
+          })();
+          _backgroundProcesses.set(taskId, { promise: bgPromise, startedAt: Date.now() });
+          return { success: true, output: `Background task started: ${taskId}
+Use check_background_task with this ID to get the result.` };
+        }
+        try {
+          const hasStagedFiles = this.sandbox.getPendingPaths().length > 0;
+          if (hasStagedFiles) {
+            const { DockerSandbox: DockerSandbox2 } = await Promise.resolve().then(() => (init_docker_sandbox(), docker_sandbox_exports));
+            const docker = new DockerSandbox2();
+            const dockerAvailable = await docker.isDockerAvailable();
+            if (dockerAvailable) {
+              console.log(`[GeminiAdapter] Running command in Docker with ${this.sandbox.getPendingPaths().length} staged file(s)`);
+              const result = await docker.runCommand(command, this.sandbox, {
+                workDir: this.config.getWorkspaceRoot(),
+                timeout: getShellTimeout()
+              });
+              return {
+                success: result.success,
+                output: result.output,
+                error: result.success ? void 0 : result.output
+              };
+            } else {
+              console.warn("[GeminiAdapter] Docker unavailable - running natively (staged files not available to command)");
+            }
+          }
+          const out = execSync2(command, {
+            cwd: this.config.getWorkspaceRoot(),
+            stdio: "pipe",
+            encoding: "utf8",
+            timeout: getShellTimeout()
+          });
+          return { success: true, output: out.trim() };
+        } catch (err) {
+          const text = `${err?.stdout?.toString?.() || ""}
+${err?.stderr?.toString?.() || ""}`.trim();
+          return { success: false, error: text || err?.message || "shell failed" };
+        }
+      }
+      async webSearchTool(params) {
+        const query = String(params.query || "").trim();
+        if (!query) return { success: false, error: "web_search requires query" };
+        const braveKey = process.env.BRAVE_API_KEY || process.env.BRAVE_SEARCH_API_KEY;
+        if (!braveKey) return { success: false, error: "web_search unavailable (missing BRAVE_API_KEY)" };
+        try {
+          const res = await fetch(
+            `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=5`,
+            {
+              headers: {
+                "Accept": "application/json",
+                "X-Subscription-Token": braveKey
+              },
+              signal: AbortSignal.timeout(1e4)
+            }
+          );
+          if (!res.ok) return { success: false, error: `web_search failed: HTTP ${res.status}` };
+          const data = await res.json();
+          const hits = (data?.web?.results || []).slice(0, 5);
+          const formatted = hits.map(
+            (r, i) => `${i + 1}. ${r.title || "(untitled)"}
+${r.url || ""}
+${r.description || ""}`
+          ).join("\n\n");
+          return { success: true, output: formatted || "No results" };
+        } catch (err) {
+          return { success: false, error: err?.message || "web_search failed" };
+        }
+      }
+      async webFetchTool(params) {
+        const url = String(params.url || "").trim();
+        if (!url || !/^https?:\/\//i.test(url)) {
+          return { success: false, error: "web_fetch requires valid http(s) url" };
+        }
+        try {
+          const res = await fetch(url, {
+            headers: { "User-Agent": "CrewSwarm-CLI/1.0" },
+            signal: AbortSignal.timeout(12e3)
+          });
+          if (!res.ok) return { success: false, error: `web_fetch failed: HTTP ${res.status}` };
+          const ct = String(res.headers.get("content-type") || "");
+          let text = await res.text();
+          if (ct.includes("html")) {
+            text = text.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s{2,}/g, " ").trim();
+          }
+          return { success: true, output: text.slice(0, 12e3) };
+        } catch (err) {
+          return { success: false, error: err?.message || "web_fetch failed" };
+        }
+      }
+      async readManyFilesTool(params) {
+        const include = String(params.include || "**/*").trim();
+        try {
+          const out = execSync2(`rg --files -g ${JSON.stringify(include)}`, {
+            cwd: this.config.getWorkspaceRoot(),
+            stdio: "pipe",
+            encoding: "utf8"
+          });
+          const files = out.split("\n").filter(Boolean).slice(0, 20);
+          const chunks = [];
+          for (const rel of files) {
+            const full = resolve2(this.config.getWorkspaceRoot(), rel);
+            try {
+              const content = await readFile(full, "utf8");
+              chunks.push(`--- ${rel} ---
+${content.slice(0, 2e3)}`);
+            } catch {
+            }
+          }
+          return { success: true, output: chunks.join("\n\n") || "No readable files matched" };
+        } catch (err) {
+          return { success: false, error: err?.message || "read_many_files failed" };
+        }
+      }
+      async saveMemoryTool(params) {
+        const fact = String(params.fact || "").trim();
+        if (!fact) return { success: false, error: "save_memory requires fact" };
+        const memDir = resolve2(this.config.getWorkspaceRoot(), ".crew");
+        await mkdir(memDir, { recursive: true });
+        const memFile = resolve2(memDir, "memory-facts.log");
+        let prior = "";
+        try {
+          prior = await readFile(memFile, "utf8");
+        } catch {
+        }
+        await writeFile(memFile, `${prior}${(/* @__PURE__ */ new Date()).toISOString()} ${fact}
+`, "utf8");
+        return { success: true, output: "Memory saved" };
+      }
+      async writeTodosTool(params) {
+        const todos = Array.isArray(params.todos) ? params.todos : [];
+        const memDir = resolve2(this.config.getWorkspaceRoot(), ".crew");
+        await mkdir(memDir, { recursive: true });
+        const todoFile = resolve2(memDir, "todos.json");
+        await writeFile(todoFile, JSON.stringify(todos, null, 2), "utf8");
+        return { success: true, output: `Saved ${todos.length} todos` };
+      }
+      async getInternalDocsTool(params) {
+        const target = String(params.path || "AGENTS.md").trim();
+        const abs = resolve2(this.config.getWorkspaceRoot(), target);
+        try {
+          const content = await readFile(abs, "utf8");
+          return { success: true, output: content.slice(0, 12e3) };
+        } catch (err) {
+          return { success: false, error: `get_internal_docs failed: ${err?.message || target}` };
+        }
+      }
+      async askUserTool(params) {
+        const qs = Array.isArray(params.questions) ? params.questions : [];
+        if (qs.length === 0) {
+          return { success: false, error: "ask_user requires at least one question" };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const request = {
+          id: `ask-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+          ts: now,
+          status: "pending",
+          questions: qs
+        };
+        const crewDir = this.crewDirPath();
+        await mkdir(crewDir, { recursive: true });
+        await this.appendJsonLine(this.askUserRequestsPath(), request);
+        await writeFile(this.askUserLatestPath(), JSON.stringify(request, null, 2), "utf8");
+        const summary = qs.map((q, i) => `${i + 1}. ${q?.question || "question"}`).join("\n");
+        return {
+          success: true,
+          output: `User input required (non-interactive runtime).
+Saved request: ${this.relativeCrewPath(this.askUserLatestPath())}
+Questions:
+${summary}`
+        };
+      }
+      async enterPlanModeTool(params) {
+        const crewDir = this.crewDirPath();
+        await mkdir(crewDir, { recursive: true });
+        const state = {
+          active: true,
+          enteredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          exitedAt: null,
+          reason: String(params?.reason || "").trim() || null,
+          planPath: null
+        };
+        await writeFile(this.planModeStatePath(), JSON.stringify(state, null, 2), "utf8");
+        return {
+          success: true,
+          output: `Plan mode entered${state.reason ? `: ${state.reason}` : ""} (${this.relativeCrewPath(this.planModeStatePath())})`
+        };
+      }
+      async exitPlanModeTool(params) {
+        const crewDir = this.crewDirPath();
+        await mkdir(crewDir, { recursive: true });
+        let prior = {};
+        try {
+          prior = JSON.parse(await readFile(this.planModeStatePath(), "utf8"));
+        } catch {
+          prior = {};
+        }
+        const state = {
+          ...prior,
+          active: false,
+          exitedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          planPath: String(params?.plan_path || "").trim() || prior?.planPath || null
+        };
+        await writeFile(this.planModeStatePath(), JSON.stringify(state, null, 2), "utf8");
+        return {
+          success: true,
+          output: `Plan mode exited${state.planPath ? `: ${state.planPath}` : ""} (${this.relativeCrewPath(this.planModeStatePath())})`
+        };
+      }
+      async activateSkillTool(params) {
+        const name = String(params?.name || "").trim();
+        if (!name) return { success: false, error: "activate_skill requires name" };
+        const crewDir = this.crewDirPath();
+        await mkdir(crewDir, { recursive: true });
+        let state = { active: [] };
+        try {
+          state = JSON.parse(await readFile(this.activeSkillsPath(), "utf8"));
+        } catch {
+          state = { active: [] };
+        }
+        const active = new Set(Array.isArray(state?.active) ? state.active : []);
+        active.add(name);
+        const next = {
+          active: Array.from(active).sort(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await writeFile(this.activeSkillsPath(), JSON.stringify(next, null, 2), "utf8");
+        return { success: true, output: `Skill activated: ${name} (${this.relativeCrewPath(this.activeSkillsPath())})` };
+      }
+      crewDirPath() {
+        return resolve2(this.config.getWorkspaceRoot(), ".crew");
+      }
+      askUserRequestsPath() {
+        return resolve2(this.crewDirPath(), "ask-user-requests.jsonl");
+      }
+      askUserLatestPath() {
+        return resolve2(this.crewDirPath(), "ask-user-latest.json");
+      }
+      planModeStatePath() {
+        return resolve2(this.crewDirPath(), "plan-mode.json");
+      }
+      activeSkillsPath() {
+        return resolve2(this.crewDirPath(), "active-skills.json");
+      }
+      relativeCrewPath(absPath) {
+        return absPath.replace(this.config.getWorkspaceRoot(), ".");
+      }
+      async appendJsonLine(filePath, data) {
+        let prior = "";
+        try {
+          prior = await readFile(filePath, "utf8");
+        } catch {
+          prior = "";
+        }
+        const line = `${JSON.stringify(data)}
+`;
+        await writeFile(filePath, `${prior}${line}`, "utf8");
+      }
+      trackerFilePath() {
+        return resolve2(this.config.getWorkspaceRoot(), ".crew", "tracker.json");
+      }
+      async readTracker() {
+        try {
+          const raw = await readFile(this.trackerFilePath(), "utf8");
+          const parsed = JSON.parse(raw);
+          return Array.isArray(parsed) ? parsed : [];
+        } catch {
+          return [];
+        }
+      }
+      async writeTracker(tasks) {
+        const dir = resolve2(this.config.getWorkspaceRoot(), ".crew");
+        await mkdir(dir, { recursive: true });
+        await writeFile(this.trackerFilePath(), JSON.stringify(tasks, null, 2), "utf8");
+      }
+      mkTrackerId() {
+        return Math.random().toString(16).slice(2, 8);
+      }
+      async trackerCreateTaskTool(params) {
+        const tasks = await this.readTracker();
+        const task = {
+          id: this.mkTrackerId(),
+          title: String(params?.title || "Untitled"),
+          description: String(params?.description || ""),
+          type: String(params?.type || "task"),
+          status: "open",
+          parentId: params?.parentId || null,
+          dependencies: Array.isArray(params?.dependencies) ? params.dependencies : []
+        };
+        tasks.push(task);
+        await this.writeTracker(tasks);
+        return { success: true, output: JSON.stringify(task, null, 2) };
+      }
+      async trackerUpdateTaskTool(params) {
+        const tasks = await this.readTracker();
+        const id = String(params?.id || "");
+        const idx = tasks.findIndex((t) => t.id === id);
+        if (idx < 0) return { success: false, error: `Task not found: ${id}` };
+        tasks[idx] = { ...tasks[idx], ...params };
+        await this.writeTracker(tasks);
+        return { success: true, output: JSON.stringify(tasks[idx], null, 2) };
+      }
+      async trackerGetTaskTool(params) {
+        const tasks = await this.readTracker();
+        const id = String(params?.id || "");
+        const task = tasks.find((t) => t.id === id);
+        if (!task) return { success: false, error: `Task not found: ${id}` };
+        return { success: true, output: JSON.stringify(task, null, 2) };
+      }
+      async trackerListTasksTool(params) {
+        const tasks = await this.readTracker();
+        const filtered = tasks.filter((t) => {
+          if (params?.status && t.status !== params.status) return false;
+          if (params?.type && t.type !== params.type) return false;
+          if (params?.parentId && t.parentId !== params.parentId) return false;
+          return true;
+        });
+        return { success: true, output: JSON.stringify(filtered, null, 2) };
+      }
+      async trackerAddDependencyTool(params) {
+        const tasks = await this.readTracker();
+        const taskId = String(params?.taskId || "");
+        const depId = String(params?.dependencyId || "");
+        const idx = tasks.findIndex((t) => t.id === taskId);
+        if (idx < 0) return { success: false, error: `Task not found: ${taskId}` };
+        const deps = new Set(Array.isArray(tasks[idx].dependencies) ? tasks[idx].dependencies : []);
+        deps.add(depId);
+        tasks[idx].dependencies = Array.from(deps);
+        await this.writeTracker(tasks);
+        return { success: true, output: JSON.stringify(tasks[idx], null, 2) };
+      }
+      async trackerVisualizeTool() {
+        const tasks = await this.readTracker();
+        const lines = tasks.map((t) => {
+          const deps = Array.isArray(t.dependencies) && t.dependencies.length ? ` -> [${t.dependencies.join(", ")}]` : "";
+          return `${t.id} [${t.status}] ${t.title}${deps}`;
+        });
+        return { success: true, output: lines.join("\n") || "(no tasks)" };
+      }
+      async lspTool(params) {
+        const query = String(params.query || "").trim();
+        if (!query) return { success: false, error: "lsp requires query" };
+        const lower = query.toLowerCase();
+        const lsp = await Promise.resolve().then(() => (init_lsp(), lsp_exports));
+        if (lower.startsWith("symbols")) {
+          const file = query.slice("symbols".length).trim();
+          if (!file) return { success: false, error: "lsp symbols requires file path" };
+          const symbols = await lsp.getDocumentSymbols(process.cwd(), file);
+          return { success: true, output: symbols.map((s) => `${file}:${s.line}:${s.column} ${s.kind} ${s.name}`).join("\n") };
+        }
+        if (lower.startsWith("refs")) {
+          const target = query.slice("refs".length).trim();
+          const match = target.match(/^(.+):(\d+)(?::(\d+))?$/);
+          if (match) {
+            const refs = await lsp.getReferences(process.cwd(), match[1], Number(match[2]), Number(match[3] || "1"));
+            return { success: true, output: refs.map((r) => `${r.file}:${r.line}:${r.column}`).join("\n") };
+          }
+          if (target) return this.grepTool({ pattern: `\\b${target}\\b`, path: "." });
+          return { success: false, error: "lsp refs requires symbol or file:line[:col]" };
+        }
+        if (lower.startsWith("goto")) {
+          const target = query.slice("goto".length).trim();
+          const match = target.match(/^(.+):(\d+)(?::(\d+))?$/);
+          if (!match) return { success: false, error: "lsp goto format: file:line[:col]" };
+          const defs = await lsp.getDefinitions(process.cwd(), match[1], Number(match[2]), Number(match[3] || "1"));
+          return { success: true, output: defs.map((d) => `${d.file}:${d.line}:${d.column}`).join("\n") };
+        }
+        if (lower.startsWith("diagnostics") || lower === "check") {
+          const diags = await lsp.typeCheckProject(process.cwd(), []);
+          return { success: true, output: diags.map((d) => `${d.file}:${d.line}:${d.column} [${d.category}] ${d.message}`).join("\n") };
+        }
+        if (lower.startsWith("complete")) {
+          const target = query.slice("complete".length).trim();
+          const match = target.match(/^(.+):(\d+):(\d+)(?:\s+(.+))?$/);
+          if (!match) return { success: false, error: "lsp complete format: file:line:col [prefix]" };
+          const items = await lsp.getCompletions(process.cwd(), match[1], Number(match[2]), Number(match[3]), 50, match[4] || "");
+          return { success: true, output: items.map((i) => `${i.name} (${i.kind})`).join("\n") };
+        }
+        return { success: false, error: `Unsupported lsp query: ${query}` };
+      }
+      async checkBackgroundTask(params) {
+        const taskId = String(params.task_id || "").trim();
+        if (!taskId) return { success: false, error: "check_background_task requires task_id" };
+        const bg = _backgroundProcesses.get(taskId);
+        if (!bg) return { success: false, error: `No background task found with ID: ${taskId}` };
+        const done = await Promise.race([
+          bg.promise.then((r) => ({ done: true, result: r })),
+          new Promise((resolve4) => setTimeout(() => resolve4({ done: false }), 50))
+        ]);
+        if (!done.done) {
+          const elapsed = Math.round((Date.now() - bg.startedAt) / 1e3);
+          return { success: true, output: `Task ${taskId} still running (${elapsed}s elapsed). Check again later.` };
+        }
+        _backgroundProcesses.delete(taskId);
+        return done.result;
+      }
+      static {
+        // Track sub-agent depth to prevent infinite recursion
+        this._spawnDepth = 0;
+      }
+      static {
+        this.MAX_SPAWN_DEPTH = 3;
+      }
+      async spawnAgentTool(params) {
+        const task = String(params.task || "").trim();
+        if (!task) return { success: false, error: "spawn_agent requires task" };
+        if (_GeminiToolAdapter._spawnDepth >= _GeminiToolAdapter.MAX_SPAWN_DEPTH) {
+          return { success: false, error: `Sub-agent depth limit reached (max ${_GeminiToolAdapter.MAX_SPAWN_DEPTH}). Complete this task directly instead.` };
+        }
+        const maxTurns = Math.min(params.max_turns || 15, 25);
+        const model = params.model || process.env.CREW_WORKER_MODEL || process.env.CREW_EXECUTION_MODEL || "";
+        const branchName = `sub-agent-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        try {
+          await this.sandbox.createBranch(branchName);
+          _GeminiToolAdapter._spawnDepth++;
+          const { runAgenticWorker: runAgenticWorker2 } = await Promise.resolve().then(() => (init_agentic_executor(), agentic_executor_exports));
+          const result = await runAgenticWorker2(task, this.sandbox, {
+            model,
+            maxTurns,
+            stream: false,
+            // Sub-agents don't stream to stdout
+            verbose: Boolean(process.env.CREW_DEBUG),
+            tier: "fast"
+            // Default to cheap model for sub-agents
+          });
+          _GeminiToolAdapter._spawnDepth--;
+          const parentBranch = this.sandbox.getActiveBranch();
+          if (parentBranch !== branchName) {
+            await this.sandbox.mergeBranch(branchName, parentBranch);
+          } else {
+            const branches = this.sandbox.getBranches();
+            const parent = branches.find((b) => b !== branchName) || "main";
+            await this.sandbox.switchBranch(parent);
+            await this.sandbox.mergeBranch(branchName, parent);
+          }
+          try {
+            await this.sandbox.deleteBranch(branchName);
+          } catch {
+          }
+          const output = [
+            `Sub-agent completed in ${result.turns || 0} turns (${result.modelUsed || "unknown"})`,
+            result.cost ? `Cost: $${result.cost.toFixed(4)}` : "",
+            `Status: ${result.success ? "SUCCESS" : "FAILED"}`,
+            "",
+            result.output?.slice(0, 3e3) || "(no output)"
+          ].filter(Boolean).join("\n");
+          return { success: result.success, output };
+        } catch (err) {
+          _GeminiToolAdapter._spawnDepth = Math.max(0, _GeminiToolAdapter._spawnDepth - 1);
+          try {
+            await this.sandbox.switchBranch("main");
+          } catch {
+          }
+          try {
+            await this.sandbox.deleteBranch(branchName);
+          } catch {
+          }
+          return { success: false, error: `Sub-agent failed: ${err.message}` };
+        }
+      }
+      /**
+       * Get tool declarations for LLM function calling
+       */
+      getToolDeclarations() {
+        const dynamicEnabled = process.env.CREW_GEMINI_DYNAMIC_DECLARATIONS !== "false";
+        if (dynamicEnabled) {
+          try {
+            const decls = this.buildDynamicDeclarations();
+            if (decls.length > 0) return decls;
+          } catch {
+          }
+        }
+        return [
+          {
+            name: "read_file",
+            description: "Read the contents of a file. ALWAYS read files before editing them. Use start_line/end_line for large files.",
+            parameters: {
+              type: "object",
+              properties: {
+                file_path: { type: "string", description: "Relative path from project root" },
+                start_line: { type: "number", description: "Start line number (1-based, optional)" },
+                end_line: { type: "number", description: "End line number (inclusive, optional)" }
+              },
+              required: ["file_path"]
+            }
+          },
+          {
+            name: "glob",
+            description: 'Find files matching a glob pattern. Use this to discover file structure. Examples: "**/*.ts", "src/**/*.tsx", "*.json"',
+            parameters: {
+              type: "object",
+              properties: {
+                pattern: { type: "string", description: 'Glob pattern (e.g. "src/**/*.ts")' }
+              },
+              required: ["pattern"]
+            }
+          },
+          {
+            name: "grep",
+            description: "Search for text/regex patterns in files. Returns matching lines with file paths and line numbers.",
+            parameters: {
+              type: "object",
+              properties: {
+                pattern: { type: "string", description: "Regex or text pattern to search for" },
+                path: { type: "string", description: 'Directory or file to search in (default: ".")' }
+              },
+              required: ["pattern"]
+            }
+          },
+          {
+            name: "grep_search",
+            description: "Canonical alias for grep. Search for regex/text in files.",
+            parameters: {
+              type: "object",
+              properties: {
+                pattern: { type: "string", description: "Regex/text pattern" },
+                dir_path: { type: "string", description: "Path to search (default: .)" }
+              },
+              required: ["pattern"]
+            }
+          },
+          {
+            name: "grep_search_ripgrep",
+            description: "Ripgrep-optimized canonical name. Routed to grep tool in this adapter.",
+            parameters: {
+              type: "object",
+              properties: {
+                pattern: { type: "string", description: "Regex/text pattern" },
+                dir_path: { type: "string", description: "Path to search (default: .)" },
+                path: { type: "string", description: "Alternative path field" }
+              },
+              required: ["pattern"]
+            }
+          },
+          {
+            name: "write_file",
+            description: "Write content to a file (creates or overwrites). Changes are staged in sandbox. Use for new files or full rewrites.",
+            parameters: {
+              type: "object",
+              properties: {
+                file_path: { type: "string", description: "Relative path from project root" },
+                content: { type: "string", description: "Complete file content" }
+              },
+              required: ["file_path", "content"]
+            }
+          },
+          {
+            name: "append_file",
+            description: "Append content to an existing file. Creates file if it does not exist. Changes are staged in sandbox.",
+            parameters: {
+              type: "object",
+              properties: {
+                file_path: { type: "string", description: "Relative path from project root" },
+                content: { type: "string", description: "Content to append" }
+              },
+              required: ["file_path", "content"]
+            }
+          },
+          {
+            name: "edit",
+            description: "Edit a file by replacing an exact string match. ALWAYS read the file first to get the exact string. Use for targeted changes.",
+            parameters: {
+              type: "object",
+              properties: {
+                file_path: { type: "string", description: "Relative path from project root" },
+                old_string: { type: "string", description: "Exact string to find (must match precisely)" },
+                new_string: { type: "string", description: "Replacement string" }
+              },
+              required: ["file_path", "old_string", "new_string"]
+            }
+          },
+          {
+            name: "replace",
+            description: "Canonical alias for edit. Replace exact old_string with new_string.",
+            parameters: {
+              type: "object",
+              properties: {
+                file_path: { type: "string", description: "Relative path from project root" },
+                old_string: { type: "string", description: "Exact string to replace" },
+                new_string: { type: "string", description: "Replacement string" }
+              },
+              required: ["file_path", "old_string", "new_string"]
+            }
+          },
+          {
+            name: "shell",
+            description: "Run a shell command (e.g. npm test, node script.js, cat, ls). Use for build verification, running tests, or commands not covered by other tools.",
+            parameters: {
+              type: "object",
+              properties: {
+                command: { type: "string", description: "Shell command to execute" }
+              },
+              required: ["command"]
+            }
+          },
+          {
+            name: "run_cmd",
+            description: "Alias for shell. Run a shell command. Prefer this for compatibility with existing prompts.",
+            parameters: {
+              type: "object",
+              properties: {
+                command: { type: "string", description: "Shell command to execute" }
+              },
+              required: ["command"]
+            }
+          },
+          {
+            name: "run_shell_command",
+            description: "Canonical alias for shell/run_cmd.",
+            parameters: {
+              type: "object",
+              properties: {
+                command: { type: "string", description: "Shell command to execute" }
+              },
+              required: ["command"]
+            }
+          },
+          {
+            name: "mkdir",
+            description: "Create a directory (staged via .gitkeep in sandbox).",
+            parameters: {
+              type: "object",
+              properties: {
+                path: { type: "string", description: "Directory path to create" },
+                dir_path: { type: "string", description: "Alternate directory path field" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "list",
+            description: "List files and directories for a path.",
+            parameters: {
+              type: "object",
+              properties: {
+                path: { type: "string", description: "Path to list (default: .)" },
+                dir_path: { type: "string", description: "Alternate path field" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "list_directory",
+            description: "Canonical alias for list.",
+            parameters: {
+              type: "object",
+              properties: {
+                dir_path: { type: "string", description: "Directory path to list (default: .)" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "git",
+            description: "Run git subcommands (status, diff, log, show, branch). Use to understand repo state and recent changes.",
+            parameters: {
+              type: "object",
+              properties: {
+                command: { type: "string", description: 'Git subcommand (e.g. "diff HEAD~3", "log --oneline -10")' }
+              },
+              required: ["command"]
+            }
+          },
+          {
+            name: "lsp",
+            description: 'Code intelligence: "symbols <file>" for outline, "refs <file:line:col>" for references, "goto <file:line:col>" for definition, "diagnostics" for type errors.',
+            parameters: {
+              type: "object",
+              properties: {
+                query: { type: "string", description: 'LSP query (e.g. "symbols src/app.ts", "goto src/app.ts:42:5")' }
+              },
+              required: ["query"]
+            }
+          },
+          {
+            name: "web_search",
+            description: "Search the web via Brave Search API (requires BRAVE_API_KEY).",
+            parameters: {
+              type: "object",
+              properties: {
+                query: { type: "string", description: "Search query" }
+              },
+              required: ["query"]
+            }
+          },
+          {
+            name: "google_web_search",
+            description: "Canonical alias for web_search.",
+            parameters: {
+              type: "object",
+              properties: {
+                query: { type: "string", description: "Search query" }
+              },
+              required: ["query"]
+            }
+          },
+          {
+            name: "web_fetch",
+            description: "Fetch content from a URL and return cleaned text for analysis.",
+            parameters: {
+              type: "object",
+              properties: {
+                url: { type: "string", description: "http(s) URL to fetch" }
+              },
+              required: ["url"]
+            }
+          },
+          {
+            name: "read_many_files",
+            description: "Read multiple files by include glob and return concatenated excerpts.",
+            parameters: {
+              type: "object",
+              properties: {
+                include: { type: "string", description: "Glob include pattern (default: **/*)" },
+                exclude: { type: "string", description: "Optional exclude glob" },
+                recursive: { type: "boolean", description: "Recursive search (optional)" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "save_memory",
+            description: "Save a memory fact to local project memory log.",
+            parameters: {
+              type: "object",
+              properties: {
+                fact: { type: "string", description: "Memory fact to persist" }
+              },
+              required: ["fact"]
+            }
+          },
+          {
+            name: "write_todos",
+            description: "Persist todo items for the current project.",
+            parameters: {
+              type: "object",
+              properties: {
+                todos: { type: "array", description: "Todo items array" }
+              },
+              required: ["todos"]
+            }
+          },
+          {
+            name: "get_internal_docs",
+            description: "Read internal docs by relative path (default AGENTS.md).",
+            parameters: {
+              type: "object",
+              properties: {
+                path: { type: "string", description: "Relative doc path" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "ask_user",
+            description: "Non-interactive placeholder for ask-user; returns summarized questions.",
+            parameters: {
+              type: "object",
+              properties: {
+                questions: { type: "array", description: "Question descriptors" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "enter_plan_mode",
+            description: "Enter plan mode (no-op marker in CLI adapter).",
+            parameters: {
+              type: "object",
+              properties: {
+                reason: { type: "string", description: "Plan mode reason" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "exit_plan_mode",
+            description: "Exit plan mode (no-op marker in CLI adapter).",
+            parameters: {
+              type: "object",
+              properties: {
+                plan_path: { type: "string", description: "Optional plan file path" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "activate_skill",
+            description: "Activate a named skill (adapter acknowledgment).",
+            parameters: {
+              type: "object",
+              properties: {
+                name: { type: "string", description: "Skill name" }
+              },
+              required: ["name"]
+            }
+          },
+          {
+            name: "tracker_create_task",
+            description: "Create tracker task in local .crew/tracker.json.",
+            parameters: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                description: { type: "string" },
+                type: { type: "string" },
+                parentId: { type: "string" },
+                dependencies: { type: "array" }
+              },
+              required: ["title", "description", "type"]
+            }
+          },
+          {
+            name: "tracker_update_task",
+            description: "Update tracker task by id.",
+            parameters: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                title: { type: "string" },
+                description: { type: "string" },
+                status: { type: "string" },
+                dependencies: { type: "array" }
+              },
+              required: ["id"]
+            }
+          },
+          {
+            name: "tracker_get_task",
+            description: "Get tracker task by id.",
+            parameters: {
+              type: "object",
+              properties: {
+                id: { type: "string" }
+              },
+              required: ["id"]
+            }
+          },
+          {
+            name: "tracker_list_tasks",
+            description: "List tracker tasks with optional filters.",
+            parameters: {
+              type: "object",
+              properties: {
+                status: { type: "string" },
+                type: { type: "string" },
+                parentId: { type: "string" }
+              },
+              required: []
+            }
+          },
+          {
+            name: "tracker_add_dependency",
+            description: "Add dependency between tracker tasks.",
+            parameters: {
+              type: "object",
+              properties: {
+                taskId: { type: "string" },
+                dependencyId: { type: "string" }
+              },
+              required: ["taskId", "dependencyId"]
+            }
+          },
+          {
+            name: "tracker_visualize",
+            description: "Visualize tracker tasks as ASCII list.",
+            parameters: {
+              type: "object",
+              properties: {},
+              required: []
+            }
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/learning/corrections.ts
+import { access, copyFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join as join2 } from "node:path";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function pathExists(path2) {
+  try {
+    await access(path2, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var CorrectionStore;
+var init_corrections = __esm({
+  "src/learning/corrections.ts"() {
+    "use strict";
+    CorrectionStore = class {
+      constructor(baseDir = process.cwd()) {
+        this.baseDir = baseDir;
+        this.stateDir = join2(baseDir, ".crew");
+        this.dataPath = join2(this.stateDir, "training-data.jsonl");
+      }
+      async ensureReady() {
+        if (!await pathExists(this.stateDir)) {
+          await mkdir2(this.stateDir, { recursive: true });
+        }
+        if (!await pathExists(this.dataPath)) {
+          await writeFile2(this.dataPath, "", "utf8");
+        }
+      }
+      async record(entry) {
+        await this.ensureReady();
+        const payload = {
+          timestamp: nowIso(),
+          ...entry
+        };
+        await writeFile2(this.dataPath, `${JSON.stringify(payload)}
+`, {
+          encoding: "utf8",
+          flag: "a"
+        });
+        return payload;
+      }
+      async loadAll() {
+        await this.ensureReady();
+        const raw = await readFile2(this.dataPath, "utf8");
+        const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
+        return lines.map((line) => JSON.parse(line));
+      }
+      async summary() {
+        const all = await this.loadAll();
+        return {
+          count: all.length,
+          latest: all.length > 0 ? all[all.length - 1] : void 0
+        };
+      }
+      async exportTo(path2) {
+        await this.ensureReady();
+        await copyFile(this.dataPath, path2);
+      }
+    };
+  }
+});
+
+// src/collections/index.ts
+var collections_exports = {};
+__export(collections_exports, {
+  buildCollectionIndex: () => buildCollectionIndex,
+  searchCollection: () => searchCollection
+});
+import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { extname, join as join3, relative, resolve as resolve3 } from "node:path";
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+}
+function hashToken(token, dim) {
+  let h = 2166136261;
+  for (let i = 0; i < token.length; i++) {
+    h ^= token.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return Math.abs(h) % dim;
+}
+function toHashedVector(text, dim = 256) {
+  const vec = new Float64Array(dim);
+  const toks = tokenize(text);
+  for (const t of toks) {
+    vec[hashToken(t, dim)] += 1;
+  }
+  let norm = 0;
+  for (let i = 0; i < dim; i++) norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < dim; i++) vec[i] /= norm;
+  }
+  return vec;
+}
+function cosineSimilarity(a, b) {
+  const dim = Math.min(a.length, b.length);
+  let dot = 0;
+  for (let i = 0; i < dim; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function chunkFile(content, source) {
+  const lines = content.split("\n");
+  const chunks = [];
+  let currentLines = [];
+  let currentStart = 1;
+  const flush = () => {
+    const text = currentLines.join("\n").trim();
+    if (text.length > 0) {
+      chunks.push({ source, startLine: currentStart, text, score: 0 });
+    }
+    currentLines = [];
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#{1,4}\s/.test(line) && currentLines.length > 0) {
+      flush();
+      currentStart = i + 1;
+    }
+    currentLines.push(line);
+    if (currentLines.length >= 40 && !/^#{1,4}\s/.test(line)) {
+      flush();
+      currentStart = i + 2;
+    }
+  }
+  flush();
+  return chunks;
+}
+async function walkDocs(rootDir, includeCode = false) {
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir2(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry)) continue;
+      const fullPath = join3(dir, entry);
+      let st;
+      try {
+        st = await stat2(fullPath);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        const ext = extname(entry).toLowerCase();
+        if (DOC_EXTENSIONS.has(ext) || includeCode && CODE_EXTENSIONS.has(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+async function buildCollectionIndex(paths, options = {}) {
+  const allChunks = [];
+  const roots = paths.map((p) => resolve3(p));
+  let fileCount = 0;
+  for (const rootPath of roots) {
+    let st;
+    try {
+      st = await stat2(rootPath);
+    } catch {
+      continue;
+    }
+    const files = st.isDirectory() ? await walkDocs(rootPath, Boolean(options.includeCode)) : [rootPath];
+    for (const file of files) {
+      let content;
+      try {
+        content = await readFile3(file, "utf8");
+      } catch {
+        continue;
+      }
+      fileCount++;
+      const rel = relative(resolve3(rootPath, st.isDirectory() ? "." : ".."), file);
+      const chunks = chunkFile(content, rel);
+      allChunks.push(...chunks);
+    }
+  }
+  const terms = /* @__PURE__ */ new Map();
+  for (let i = 0; i < allChunks.length; i++) {
+    const tokens = tokenize(allChunks[i].text);
+    for (const token of tokens) {
+      if (!terms.has(token)) terms.set(token, /* @__PURE__ */ new Set());
+      terms.get(token).add(i);
+    }
+  }
+  return {
+    root: roots[0] || ".",
+    fileCount,
+    chunkCount: allChunks.length,
+    terms,
+    chunks: allChunks
+  };
+}
+function searchCollection(index, query, maxResults = 10) {
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) {
+    return { query, hits: [], totalChunks: index.chunkCount };
+  }
+  const scores = new Float64Array(index.chunkCount);
+  for (const token of queryTokens) {
+    const matchingChunks = index.terms.get(token);
+    if (!matchingChunks) continue;
+    const idf = Math.log(1 + index.chunkCount / matchingChunks.size);
+    for (const idx of matchingChunks) {
+      scores[idx] += idf;
+    }
+  }
+  const candidates = [];
+  for (let i = 0; i < scores.length; i++) {
+    if (scores[i] > 0) {
+      candidates.push({ idx: i, score: scores[i] });
+    }
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const queryVector = toHashedVector(query);
+  const maxTfidf = candidates.length > 0 ? candidates[0].score : 1;
+  const tfidfWeight = 0.7;
+  const vectorWeight = 0.3;
+  const hybrid = candidates.map((c) => {
+    const chunk = index.chunks[c.idx];
+    const chunkVector = toHashedVector(chunk.text);
+    const cosine = Math.max(0, cosineSimilarity(queryVector, chunkVector));
+    const tfidfNorm = maxTfidf > 0 ? c.score / maxTfidf : 0;
+    const hybridScore = tfidfNorm * tfidfWeight + cosine * vectorWeight;
+    return { idx: c.idx, score: hybridScore };
+  });
+  hybrid.sort((a, b) => b.score - a.score);
+  const hits = hybrid.slice(0, maxResults).map((c) => ({
+    ...index.chunks[c.idx],
+    score: Math.round(c.score * 1e3) / 1e3
+  }));
+  return { query, hits, totalChunks: index.chunkCount };
+}
+var DOC_EXTENSIONS, CODE_EXTENSIONS, IGNORED_DIRS;
+var init_collections = __esm({
+  "src/collections/index.ts"() {
+    "use strict";
+    DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst", ".adoc"]);
+    CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".json",
+      ".py",
+      ".go",
+      ".rs",
+      ".java",
+      ".kt",
+      ".swift",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".yaml",
+      ".yml",
+      ".toml"
+    ]);
+    IGNORED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      ".crew",
+      ".next",
+      ".turbo",
+      "coverage",
+      "__pycache__"
+    ]);
+  }
+});
+
+// src/executor/agentic-executor.ts
+var agentic_executor_exports = {};
+__export(agentic_executor_exports, {
+  runAgenticWorker: () => runAgenticWorker
+});
+function repairJson(raw) {
+  if (!raw || raw.trim() === "") return "{}";
+  let s = raw.trim();
+  s = s.replace(/,\s*([}\]])/g, "$1");
+  if (!s.includes('"') && s.includes("'")) {
+    s = s.replace(/'/g, '"');
+  }
+  s = s.replace(/([{,])\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g, '$1"$2":');
+  const openBraces = (s.match(/{/g) || []).length;
+  const closeBraces = (s.match(/}/g) || []).length;
+  for (let i = 0; i < openBraces - closeBraces; i++) s += "}";
+  const openBrackets = (s.match(/\[/g) || []).length;
+  const closeBrackets = (s.match(/]/g) || []).length;
+  for (let i = 0; i < openBrackets - closeBrackets; i++) s += "]";
+  return s;
+}
+async function loadCorrectionsContext(projectDir) {
+  try {
+    const store = new CorrectionStore(projectDir);
+    const entries = await store.loadAll();
+    if (entries.length === 0) return "";
+    const recent = entries.slice(-10);
+    const lines = recent.map((c) => {
+      const tags = c.tags?.length ? ` [${c.tags.join(", ")}]` : "";
+      return `- ${c.prompt.slice(0, 100)}${tags}: ${c.corrected.slice(0, 200)}`;
+    });
+    return `
+
+## Past Corrections (avoid repeating these mistakes)
+${lines.join("\n")}`;
+  } catch {
+    return "";
+  }
+}
+function compressTurnHistory(history) {
+  return history.map((h) => {
+    const paramStr = JSON.stringify(h.params);
+    const keyParam = h.params.file_path || h.params.pattern || h.params.command || h.params.query || h.params.path || h.params.dir_path || "";
+    const action = `${h.tool}(${String(keyParam).slice(0, 80)})`;
+    const isError = Boolean(h.error);
+    const resultText = isError ? h.error : typeof h.result === "object" && h.result && "output" in h.result ? String(h.result.output ?? "") : String(h.result ?? "");
+    const outcome = isError ? `FAIL: ${resultText.slice(0, 120)}` : `OK: ${resultText.slice(0, 120)}`;
+    const topic = h.params.file_path ? String(h.params.file_path).split("/").pop() || "file" : h.tool;
+    return { turn: h.turn, topic, action, outcome };
+  });
+}
+function formatToolResult(h, maxLen = 1500) {
+  const res = h.error ? `ERROR: ${h.error}` : typeof h.result === "object" && h.result && "output" in h.result ? String(h.result.output ?? "") : String(h.result ?? "");
+  return res.slice(0, maxLen);
+}
+function historyToGeminiContents(history) {
+  if (history.length === 0) return [];
+  const contents = [];
+  const firstN = 3;
+  const lastN = 5;
+  const needsCompression = history.length > firstN + lastN;
+  const headDetailed = needsCompression ? history.slice(0, firstN) : [];
+  const middleTurns = needsCompression ? history.slice(firstN, -lastN) : [];
+  const structuredTurns = needsCompression ? history.slice(-lastN) : history;
+  for (const h of headDetailed) {
+    contents.push({
+      role: "model",
+      parts: [{ functionCall: { name: h.tool, args: h.params } }]
+    });
+    const resultObj = h.error ? { error: h.error } : typeof h.result === "object" && h.result ? h.result : { output: formatToolResult(h) };
+    contents.push({
+      role: "user",
+      parts: [{ functionResponse: { name: h.tool, response: resultObj } }]
+    });
+  }
+  if (middleTurns.length > 0) {
+    const compressed = compressTurnHistory(middleTurns);
+    const summary = compressed.map((c) => `[${c.turn}] ${c.action} \u2192 ${c.outcome}`).join("\n");
+    contents.push(
+      { role: "model", parts: [{ text: `[Earlier execution summary]
+${summary}` }] },
+      { role: "user", parts: [{ text: "Acknowledged. Continue with the task." }] }
+    );
+  }
+  for (const h of structuredTurns) {
+    contents.push({
+      role: "model",
+      parts: [{ functionCall: { name: h.tool, args: h.params } }]
+    });
+    const resultObj = h.error ? { error: h.error } : typeof h.result === "object" && h.result ? h.result : { output: formatToolResult(h) };
+    contents.push({
+      role: "user",
+      parts: [{ functionResponse: { name: h.tool, response: resultObj } }]
+    });
+  }
+  return contents;
+}
+function historyToOpenAIMessages(history) {
+  if (history.length === 0) return [];
+  const messages = [];
+  const firstN = 3;
+  const lastN = 5;
+  const needsCompression = history.length > firstN + lastN;
+  const headDetailed = needsCompression ? history.slice(0, firstN) : [];
+  const middleTurns = needsCompression ? history.slice(firstN, -lastN) : [];
+  const structuredTurns = needsCompression ? history.slice(-lastN) : history;
+  for (const h of headDetailed) {
+    const callId = `call_${h.turn}_${h.tool}`;
+    messages.push({
+      role: "assistant",
+      tool_calls: [{
+        id: callId,
+        type: "function",
+        function: { name: h.tool, arguments: JSON.stringify(h.params) }
+      }]
+    });
+    messages.push({
+      role: "tool",
+      tool_call_id: callId,
+      content: formatToolResult(h)
+    });
+  }
+  if (middleTurns.length > 0) {
+    const compressed = compressTurnHistory(middleTurns);
+    const summary = compressed.map((c) => `[${c.turn}] ${c.action} \u2192 ${c.outcome}`).join("\n");
+    messages.push(
+      { role: "assistant", content: `[Earlier execution summary]
+${summary}` },
+      { role: "user", content: "Acknowledged. Continue with the task." }
+    );
+  }
+  for (const h of structuredTurns) {
+    const callId = `call_${h.turn}_${h.tool}`;
+    messages.push({
+      role: "assistant",
+      tool_calls: [{
+        id: callId,
+        type: "function",
+        function: { name: h.tool, arguments: JSON.stringify(h.params) }
+      }]
+    });
+    messages.push({
+      role: "tool",
+      tool_call_id: callId,
+      content: formatToolResult(h)
+    });
+  }
+  return messages;
+}
+function historyToAnthropicMessages(history) {
+  if (history.length === 0) return [];
+  const messages = [];
+  const firstN = 3;
+  const lastN = 5;
+  const needsCompression = history.length > firstN + lastN;
+  const headDetailed = needsCompression ? history.slice(0, firstN) : [];
+  const middleTurns = needsCompression ? history.slice(firstN, -lastN) : [];
+  const structuredTurns = needsCompression ? history.slice(-lastN) : history;
+  for (const h of headDetailed) {
+    const useId = `tu_${h.turn}_${h.tool}`;
+    messages.push({
+      role: "assistant",
+      content: [{
+        type: "tool_use",
+        id: useId,
+        name: h.tool,
+        input: h.params
+      }]
+    });
+    messages.push({
+      role: "user",
+      content: [{
+        type: "tool_result",
+        tool_use_id: useId,
+        content: formatToolResult(h)
+      }]
+    });
+  }
+  if (middleTurns.length > 0) {
+    const compressed = compressTurnHistory(middleTurns);
+    const summary = compressed.map((c) => `[${c.turn}] ${c.action} \u2192 ${c.outcome}`).join("\n");
+    messages.push(
+      { role: "assistant", content: `[Earlier execution summary]
+${summary}` },
+      { role: "user", content: "Acknowledged. Continue with the task." }
+    );
+  }
+  for (const h of structuredTurns) {
+    const useId = `tu_${h.turn}_${h.tool}`;
+    messages.push({
+      role: "assistant",
+      content: [{
+        type: "tool_use",
+        id: useId,
+        name: h.tool,
+        input: h.params
+      }]
+    });
+    messages.push({
+      role: "user",
+      content: [{
+        type: "tool_result",
+        tool_use_id: useId,
+        content: formatToolResult(h)
+      }]
+    });
+  }
+  return messages;
+}
+function resolveProvider(modelOverride, preferTier) {
+  const effectiveModel = (modelOverride || process.env.CREW_EXECUTION_MODEL || "").trim().toLowerCase();
+  if (effectiveModel) {
+    for (const p of PROVIDER_ORDER) {
+      const key = process.env[p.envKey];
+      if (!key || key.length < 5) continue;
+      if (p.envKey === "GOOGLE_API_KEY" && process.env.GEMINI_API_KEY) continue;
+      if (p.modelPrefix && effectiveModel.includes(p.modelPrefix)) {
+        return { key, model: modelOverride || process.env.CREW_EXECUTION_MODEL || p.model, driver: p.driver, apiUrl: p.apiUrl, id: p.id };
+      }
+    }
+  }
+  const targetTier = preferTier || "standard";
+  const tieredOrder = [
+    ...PROVIDER_ORDER.filter((p) => p.tier === targetTier),
+    ...PROVIDER_ORDER.filter((p) => p.tier !== targetTier)
+  ];
+  for (const p of tieredOrder) {
+    const key = process.env[p.envKey];
+    if (!key || key.length < 5) continue;
+    if (p.envKey === "GOOGLE_API_KEY" && process.env.GEMINI_API_KEY) continue;
+    return { key, model: p.model, driver: p.driver, apiUrl: p.apiUrl, id: p.id };
+  }
+  return null;
+}
+async function executeStreamingGeminiTurn(fullTask, tools, key, model, systemPrompt, stream, images, historyMessages) {
+  const functionDeclarations = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  }));
+  const userParts = [{ text: `${systemPrompt}
+
+Task:
+${fullTask}` }];
+  if (images?.length) {
+    for (const img of images) {
+      userParts.push({ inlineData: { mimeType: img.mimeType, data: img.data } });
+    }
+  }
+  const contents = [
+    { role: "user", parts: userParts },
+    // Insert structured history (tool call/result pairs)
+    ...historyMessages || [],
+    // Continuation prompt if we have history
+    ...historyMessages?.length ? [{ role: "user", parts: [{ text: "Continue executing the task based on the results above." }] }] : []
+  ];
+  const endpoint = stream ? "streamGenerateContent" : "generateContent";
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:${endpoint}?key=${encodeURIComponent(key)}${stream ? "&alt=sse" : ""}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    signal: AbortSignal.timeout(12e4),
+    body: JSON.stringify({
+      contents,
+      tools: [{ functionDeclarations }],
+      generationConfig: { temperature: 0.3, maxOutputTokens: 8192 }
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Gemini API ${res.status}: ${err.slice(0, 300)}`);
+  }
+  if (stream && res.body) {
+    let fullText = "";
+    const toolCalls2 = [];
+    let totalCost = 0;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const jsonStr = line.slice(6).trim();
+          if (!jsonStr || jsonStr === "[DONE]") continue;
+          try {
+            const chunk = JSON.parse(jsonStr);
+            const parts2 = chunk?.candidates?.[0]?.content?.parts ?? [];
+            for (const part of parts2) {
+              if (part.text) {
+                process.stdout.write(part.text);
+                fullText += part.text;
+              }
+              if (part.functionCall) {
+                toolCalls2.push({
+                  tool: part.functionCall.name || "",
+                  params: part.functionCall.args || {}
+                });
+              }
+            }
+            const usage2 = chunk?.usageMetadata;
+            if (usage2) {
+              totalCost = (usage2.promptTokenCount || 0) * 0.075 / 1e6 + (usage2.candidatesTokenCount || 0) * 0.3 / 1e6;
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (fullText) process.stdout.write("\n");
+    if (toolCalls2.length > 0) {
+      return { toolCalls: toolCalls2, response: fullText, cost: totalCost };
+    }
+    return { response: fullText, status: "COMPLETE", cost: totalCost };
+  }
+  const data = await res.json();
+  const parts = data?.candidates?.[0]?.content?.parts ?? [];
+  const usage = data?.usageMetadata ?? {};
+  const cost = (usage.promptTokenCount || 0) * 0.075 / 1e6 + (usage.candidatesTokenCount || 0) * 0.3 / 1e6;
+  const toolCalls = [];
+  for (const part of parts) {
+    if (part.functionCall) {
+      toolCalls.push({ tool: part.functionCall.name || "", params: part.functionCall.args || {} });
+    }
+  }
+  if (toolCalls.length > 0) return { toolCalls, response: "", cost };
+  const textPart = parts.find((p) => p.text);
+  return { response: textPart?.text ?? "", status: "COMPLETE", cost };
+}
+async function executeStreamingOpenAITurn(fullTask, tools, apiUrl, apiKey, model, systemPrompt, stream, images, historyMessages) {
+  let userContent = fullTask;
+  if (images?.length) {
+    const parts = [{ type: "text", text: fullTask }];
+    for (const img of images) {
+      parts.push({
+        type: "image_url",
+        image_url: { url: `data:${img.mimeType};base64,${img.data}` }
+      });
+    }
+    userContent = parts;
+  }
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userContent },
+    // Insert structured history (assistant tool_calls + tool results)
+    ...historyMessages || []
+  ];
+  const openaiTools = tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+  const temp = model?.startsWith?.("gpt-5") || model?.startsWith?.("gpt-6") ? 1 : 0.3;
+  const body = {
+    model,
+    messages,
+    tools: openaiTools,
+    temperature: temp,
+    max_tokens: 8192,
+    stream
+  };
+  const res = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    signal: AbortSignal.timeout(12e4),
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`OpenAI API ${res.status}: ${err.slice(0, 300)}`);
+  }
+  if (stream && res.body) {
+    let fullText = "";
+    const toolCallAccumulator = /* @__PURE__ */ new Map();
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const jsonStr = line.slice(6).trim();
+          if (!jsonStr || jsonStr === "[DONE]") continue;
+          try {
+            const chunk = JSON.parse(jsonStr);
+            const delta = chunk?.choices?.[0]?.delta;
+            if (!delta) continue;
+            if (delta.content) {
+              process.stdout.write(delta.content);
+              fullText += delta.content;
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                if (!toolCallAccumulator.has(idx)) {
+                  toolCallAccumulator.set(idx, { name: "", args: "" });
+                }
+                const acc = toolCallAccumulator.get(idx);
+                if (tc.function?.name) acc.name += tc.function.name;
+                if (tc.function?.arguments) acc.args += tc.function.arguments;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (fullText) process.stdout.write("\n");
+    const toolCalls = [];
+    for (const [, tc] of toolCallAccumulator) {
+      if (tc.name) {
+        let params = {};
+        try {
+          params = JSON.parse(repairJson(tc.args));
+        } catch {
+        }
+        toolCalls.push({ tool: tc.name, params });
+      }
+    }
+    if (toolCalls.length > 0) return { toolCalls, response: fullText, cost: 0 };
+    return { response: fullText, status: "COMPLETE", cost: 0 };
+  }
+  const data = await res.json();
+  const choice = data?.choices?.[0];
+  const msg = choice?.message;
+  if (msg?.tool_calls?.length > 0) {
+    const toolCalls = msg.tool_calls.map((tc) => {
+      let params = {};
+      try {
+        params = JSON.parse(repairJson(tc.function?.arguments || "{}"));
+      } catch {
+      }
+      return { tool: tc.function?.name || "", params };
+    });
+    return { toolCalls, response: msg?.content || "", cost: 0 };
+  }
+  return { response: msg?.content || "", status: "COMPLETE", cost: 0 };
+}
+async function executeStreamingAnthropicTurn(fullTask, tools, apiKey, model, systemPrompt, stream, images, historyMessages) {
+  let userContent = fullTask;
+  if (images?.length) {
+    const parts = [{ type: "text", text: fullTask }];
+    for (const img of images) {
+      parts.push({
+        type: "image",
+        source: { type: "base64", media_type: img.mimeType, data: img.data }
+      });
+    }
+    userContent = parts;
+  }
+  const anthropicTools = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+  const body = {
+    model,
+    max_tokens: 8192,
+    system: systemPrompt,
+    messages: [
+      { role: "user", content: userContent },
+      // Insert structured history (assistant tool_use + user tool_result)
+      ...historyMessages || []
+    ],
+    temperature: 0.3,
+    tools: anthropicTools,
+    stream
+  };
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    signal: AbortSignal.timeout(12e4),
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Anthropic API ${res.status}: ${err.slice(0, 300)}`);
+  }
+  if (stream && res.body) {
+    let fullText = "";
+    const toolBlocks = /* @__PURE__ */ new Map();
+    let totalCost = 0;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const jsonStr = line.slice(6).trim();
+          if (!jsonStr) continue;
+          try {
+            const event = JSON.parse(jsonStr);
+            if (event.type === "content_block_start") {
+              if (event.content_block?.type === "tool_use") {
+                toolBlocks.set(event.index, {
+                  name: event.content_block.name || "",
+                  inputJson: ""
+                });
+              }
+            }
+            if (event.type === "content_block_delta") {
+              if (event.delta?.type === "text_delta" && event.delta.text) {
+                process.stdout.write(event.delta.text);
+                fullText += event.delta.text;
+              }
+              if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+                const block = toolBlocks.get(event.index);
+                if (block) block.inputJson += event.delta.partial_json;
+              }
+            }
+            if (event.type === "message_delta" && event.usage) {
+              totalCost = (event.usage.input_tokens || 0) * 3 / 1e6 + (event.usage.output_tokens || 0) * 15 / 1e6;
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (fullText) process.stdout.write("\n");
+    const toolCalls = [];
+    for (const [, block] of toolBlocks) {
+      if (block.name) {
+        let params = {};
+        try {
+          params = JSON.parse(repairJson(block.inputJson));
+        } catch {
+        }
+        toolCalls.push({ tool: block.name, params });
+      }
+    }
+    if (toolCalls.length > 0) return { toolCalls, response: fullText, cost: totalCost };
+    return { response: fullText, status: "COMPLETE", cost: totalCost };
+  }
+  const data = await res.json();
+  const usage = data?.usage || {};
+  const cost = (usage.input_tokens || 0) * 3 / 1e6 + (usage.output_tokens || 0) * 15 / 1e6;
+  const content = data?.content || [];
+  const toolUseBlocks = content.filter((b) => b.type === "tool_use");
+  const textBlocks = content.filter((b) => b.type === "text");
+  const textResponse = textBlocks.map((b) => b.text).join("\n");
+  if (toolUseBlocks.length > 0) {
+    const toolCalls = toolUseBlocks.map((b) => ({ tool: b.name, params: b.input || {} }));
+    return { toolCalls, response: textResponse, cost };
+  }
+  return { response: textResponse, status: "COMPLETE", cost };
+}
+async function executeLLMTurn(task, tools, history, model, systemPrompt, stream, images) {
+  const resolved = resolveProvider(model);
+  if (!resolved) {
+    throw new Error(
+      'No LLM providers available. Set at least one API key:\n  \u2192 GEMINI_API_KEY (free tier \u2014 https://aistudio.google.com/apikey)\n  \u2192 GROQ_API_KEY   (free \u2014 https://console.groq.com/keys)\n  \u2192 XAI_API_KEY    ($5/mo free credits \u2014 https://console.x.ai)\nOr any of: OPENAI_API_KEY, ANTHROPIC_API_KEY, DEEPSEEK_API_KEY, OPENROUTER_API_KEY\nRun "crew doctor" to check your setup.'
+    );
+  }
+  const { key, model: effectiveModel, driver, apiUrl, id } = resolved;
+  if (driver === "gemini") {
+    const historyMsgs = historyToGeminiContents(history);
+    return executeStreamingGeminiTurn(task, tools, key, effectiveModel, systemPrompt, stream, images, historyMsgs);
+  }
+  if (driver === "anthropic") {
+    const historyMsgs = historyToAnthropicMessages(history);
+    return executeStreamingAnthropicTurn(task, tools, key, effectiveModel, systemPrompt, stream, images, historyMsgs);
+  }
+  if (driver === "openai" || driver === "openrouter") {
+    const historyMsgs = historyToOpenAIMessages(history);
+    return executeStreamingOpenAITurn(task, tools, apiUrl, key, effectiveModel, systemPrompt, stream, images, historyMsgs);
+  }
+  throw new Error(`Unsupported driver: ${driver}`);
+}
+async function buildRepoMapContext(task, projectDir) {
+  try {
+    const { buildCollectionIndex: buildCollectionIndex2, searchCollection: searchCollection2 } = await Promise.resolve().then(() => (init_collections(), collections_exports));
+    const index = await buildCollectionIndex2([projectDir], { includeCode: true });
+    if (index.chunkCount === 0) return "";
+    const results = searchCollection2(index, task, 5);
+    if (results.hits.length === 0) return "";
+    const chunks = results.hits.map(
+      (h) => `--- ${h.source}:${h.startLine} (score: ${h.score}) ---
+${h.text.slice(0, 600)}`
+    );
+    return `
+
+Relevant codebase context (${index.fileCount} files indexed, ${index.chunkCount} chunks):
+${chunks.join("\n\n")}`;
+  } catch {
+    return "";
+  }
+}
+async function executeToolWithRetry(adapter, name, params, verbose) {
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    const result = await adapter.executeTool(name, params);
+    if (result.success) {
+      return { output: result.output ?? "", success: true };
+    }
+    if (attempt < MAX_RETRIES) {
+      if (verbose) {
+        console.log(`  \u27F3 Retry ${attempt}/${MAX_RETRIES - 1} for ${name}: ${(result.error || "").slice(0, 80)}`);
+      }
+      if (result.error?.includes("String not found") && params.old_string) {
+        if (params.file_path) {
+          try {
+            const freshRead = await adapter.executeTool("read_file", { file_path: params.file_path });
+            if (freshRead.success && freshRead.output) {
+              return {
+                output: `File content has changed. Current content of ${params.file_path}:
+${freshRead.output.slice(0, 3e3)}`,
+                success: false,
+                error: `String not found in ${params.file_path}. File was re-read \u2014 content returned above for correction.`
+              };
+            }
+          } catch {
+          }
+        }
+        params.old_string = params.old_string.trim();
+      } else if (result.error?.includes("No such file") && params.file_path) {
+        params.file_path = params.file_path.replace(/^\.\//, "");
+      } else {
+        return { output: result.output ?? "", success: false, error: result.error };
+      }
+    } else {
+      return { output: result.output ?? "", success: false, error: result.error };
+    }
+  }
+  return { output: "", success: false, error: "Max retries exceeded" };
+}
+async function runAgenticWorker(task, sandbox, options = {}) {
+  const adapter = new GeminiToolAdapter(sandbox);
+  const allTools = adapter.getToolDeclarations();
+  const systemPrompt = options.systemPrompt || L3_SYSTEM_PROMPT;
+  const model = options.model || process.env.CREW_EXECUTION_MODEL || "";
+  const maxTurns = options.maxTurns ?? 25;
+  const projectDir = options.projectDir || sandbox.baseDir || process.cwd();
+  const verbose = options.verbose ?? Boolean(process.env.CREW_DEBUG);
+  const stream = options.stream ?? !process.env.CREW_NO_STREAM;
+  const jit = options.priorDiscoveredFiles?.length ? JITContextTracker.fromPrior(options.priorDiscoveredFiles) : new JITContextTracker();
+  const resolvedProvider = resolveProvider(model, options.tier);
+  if (verbose) {
+    const prov = resolvedProvider ? `${resolvedProvider.id}/${resolvedProvider.model}` : "none";
+    console.log(`[AgenticExecutor] Provider: ${prov} | Stream: ${stream} | Tools: ${allTools.length}`);
+  }
+  let enrichedTask = task;
+  try {
+    const repoContext = await buildRepoMapContext(task, projectDir);
+    if (repoContext) {
+      enrichedTask = `${task}${repoContext}`;
+      if (verbose) {
+        console.log(`[AgenticExecutor] Repo-map: ${repoContext.length} chars injected`);
+      }
+    }
+  } catch {
+  }
+  try {
+    const correctionsContext = await loadCorrectionsContext(projectDir);
+    if (correctionsContext) {
+      enrichedTask = `${enrichedTask}${correctionsContext}`;
+      if (verbose) {
+        console.log(`[AgenticExecutor] Corrections context injected`);
+      }
+    }
+  } catch {
+  }
+  if (verbose) {
+    console.log(`[AgenticExecutor] ${allTools.length} tools: ${allTools.map((t) => t.name).join(", ")}`);
+  }
+  let totalCost = 0;
+  const toolsUsed = /* @__PURE__ */ new Set();
+  const executeTool = async (name, params) => {
+    toolsUsed.add(name);
+    options.onToolCall?.(name, params);
+    if (verbose) {
+      const paramStr = JSON.stringify(params).slice(0, 120);
+      process.stdout.write(`  \u{1F527} ${name}(${paramStr})...`);
+    }
+    const result2 = await executeToolWithRetry(adapter, name, params, verbose);
+    if (name === "read_file" && result2.success && result2.output) {
+      const outputLen = result2.output.length;
+      if (outputLen > 8e3 && (result2.output.includes("... (truncated)") || result2.output.includes("content truncated"))) {
+        result2.output += "\n\n[NOTE: File output was truncated. Use line_start and line_end parameters to read specific sections.]";
+      }
+    }
+    jit.trackFromToolResult(name, params, result2);
+    if (verbose) {
+      const status = result2.success ? "\u2713" : "\u2717";
+      const preview = (result2.output || result2.error || "").slice(0, 80).replace(/\n/g, " ");
+      console.log(` ${status} ${preview}`);
+    }
+    return result2;
+  };
+  let turnCount = 0;
+  const result = await executeAutonomous(
+    enrichedTask,
+    async (prompt, tools, history) => {
+      turnCount++;
+      let taskWithJIT = enrichedTask;
+      if (turnCount > 1 && turnCount % 3 === 0 && jit.fileCount > 0) {
+        try {
+          const jitContext = await jit.buildJITContext(projectDir);
+          if (jitContext) {
+            taskWithJIT = `${enrichedTask}${jitContext}`;
+            if (verbose) {
+              console.log(`  [JIT] Injected context from ${jit.fileCount} discovered files`);
+            }
+          }
+        } catch {
+        }
+      }
+      const turnImages = turnCount === 1 ? options.images : void 0;
+      const turnResult = await executeLLMTurn(taskWithJIT, allTools, history, model, systemPrompt, stream, turnImages);
+      totalCost += turnResult.cost || 0;
+      return {
+        toolCalls: turnResult.toolCalls,
+        response: turnResult.response,
+        status: turnResult.status
+      };
+    },
+    async (name, params) => {
+      return await executeTool(name, params);
+    },
+    {
+      maxTurns,
+      tools: allTools,
+      onProgress: verbose ? (turn, action) => {
+        console.log(`  [Turn ${turn}] ${action}`);
+      } : void 0
+    }
+  );
+  return {
+    success: result.success ?? false,
+    output: result.finalResponse ?? result.history?.map((h) => String(h.result)).join("\n") ?? "",
+    cost: totalCost,
+    turns: result.turns,
+    toolsUsed: Array.from(toolsUsed),
+    providerId: resolvedProvider?.id,
+    modelUsed: resolvedProvider?.model,
+    filesDiscovered: jit.fileCount,
+    discoveredFiles: jit.toFileList(),
+    history: result.history,
+    stopReason: result.reason
+  };
+}
+var L3_SYSTEM_PROMPT, PROVIDER_ORDER, JITContextTracker, MAX_RETRIES;
+var init_agentic_executor = __esm({
+  "src/executor/agentic-executor.ts"() {
+    "use strict";
+    init_autonomous_loop();
+    init_crew_adapter();
+    init_corrections();
+    L3_SYSTEM_PROMPT = `You are a senior AI engineer executing coding tasks autonomously.
+
+## Cognitive Loop: THINK \u2192 ACT \u2192 OBSERVE
+
+Every turn, follow this exact pattern:
+
+**THINK** (internal reasoning, 1-3 sentences):
+- What is the current state? What do I know from previous tool results?
+- What is the minimal next action to make progress?
+- Am I done? If so, summarize and stop.
+
+**ACT** (one or more tool calls):
+- Choose the most targeted tool for the job.
+- Prefer small, verifiable steps over large changes.
+- When multiple independent lookups are needed, call multiple tools in parallel.
+
+**OBSERVE** (after tools return):
+- Did the tool succeed or fail? What does the output tell me?
+- Do I need to adjust my approach?
+
+## Operating Principles
+
+- Match the request. Do what was asked \u2014 nothing more. A bug fix is just a bug fix. Don't refactor adjacent code, add docstrings to unchanged functions, or suggest rewrites beyond the task scope.
+- Simplest approach first. Don't over-engineer. Three similar lines are better than a premature abstraction. Only add error handling, validation, or fallbacks at system boundaries (user input, external APIs), not for internal guarantees.
+- Own mistakes. If a tool call fails or your approach is wrong, say so briefly and try a different approach. Don't repeat the same failing action. If the same failure pattern repeats twice, switch strategy.
+- Be security-conscious. Don't introduce injection, XSS, or hardcoded secrets. Validate at trust boundaries.
+
+## Available Tools
+
+**Files**: read_file, write_file, replace (edit with replace_all flag), read_many_files, glob, grep_search (output_mode: content/files/count, context, type filter), list_directory, mkdir
+**Shell**: run_shell_command (Docker isolation when staged files exist; run_in_background for long commands; configurable timeout via CREW_SHELL_TIMEOUT, default 120s, max 600s), check_background_task
+**Git**: git (status, diff, log, add, commit, show, branch, stash, tag, blame, checkout, fetch, pull, merge, rebase, cherry-pick, worktree \u2014 force-push and --no-verify blocked)
+**Web**: google_web_search, web_fetch
+**Memory**: save_memory (persist facts across sessions), write_todos
+**Docs**: get_internal_docs (read project documentation)
+**Agents**: spawn_agent (spawn autonomous sub-agent for independent subtasks \u2014 isolated sandbox branch, cheap model by default, merges changes on completion)
+
+## File Reading Strategy
+
+1. ALWAYS read a file before editing it. Never guess at file contents.
+2. For large files (500+ lines): read specific line ranges instead of the whole file.
+3. If a read_file result looks truncated, re-read with a narrower range around the area of interest.
+4. Use grep_search to locate exact strings before attempting replace/edit.
+
+## Edit Strategy
+
+1. ALWAYS read_file before editing. Edits on unread files will be rejected.
+2. Use replace (edit) for surgical changes \u2014 provide exact old_string that uniquely matches.
+3. Use replace_all:true when renaming a variable/function across the file.
+4. For new files, use write_file.
+5. Never rewrite an entire existing file \u2014 always use targeted edits.
+6. If an edit fails with "not unique", provide more surrounding context or use replace_all:true.
+7. If an edit fails with "String not found", re-read the file and retry with current content.
+
+## Shell Strategy
+
+1. For long-running commands (builds, tests, installs), use run_in_background:true.
+2. Use check_background_task to poll for results.
+3. Prefer dedicated tools over shell: use read_file not cat, grep_search not rg, glob not find.
+4. Never use destructive commands (rm -rf, git reset --hard) without explicit task instruction.
+
+## Verification
+
+1. After code changes: run the build command (usually "npm run build" or "tsc --noEmit").
+2. After logic changes: run relevant tests ("npm test", or specific test file).
+3. Check git diff to confirm only intended changes were made.
+
+## Output
+
+- Lead with what you did, not how you thought about it. Skip preamble.
+- For informational queries (listing files, reading code, checking status): include the actual tool output in your response so the user sees the data.
+- For code changes: concise summary of files modified, what changed, verification result.
+- When you used a tool to answer a question, show the results \u2014 don't just say "I listed the files" without showing them.
+
+## Stop Conditions \u2014 When to Finish
+
+- The task is fully complete and verified.
+- You have confirmed the changes work (via build, test, or diagnostic check).
+- Do NOT keep reading files or running tools after the work is done.
+- Do NOT repeat yourself or restate your work \u2014 just give a concise summary.
+
+## Anti-Patterns to Avoid
+
+- Do NOT read every file in the project to "understand context" \u2014 read only what's needed.
+- Do NOT make speculative changes to files you haven't read.
+- Do NOT run the same command twice if it already succeeded.
+- Do NOT apologize or explain failures at length \u2014 just fix them and move on.
+- Do NOT add features, refactor, or "improve" code beyond what the task asks.
+- Do NOT add comments, docstrings, or type annotations to code you didn't change.`;
+    PROVIDER_ORDER = [
+      // Heavy tier — L2 brain (complex multi-file tasks, planning)
+      { id: "openai", envKey: "OPENAI_API_KEY", model: "gpt-4.1", driver: "openai", apiUrl: "https://api.openai.com/v1/chat/completions", modelPrefix: "gpt", tier: "heavy" },
+      { id: "anthropic", envKey: "ANTHROPIC_API_KEY", model: "claude-sonnet-4-20250514", driver: "anthropic", modelPrefix: "claude", tier: "heavy" },
+      { id: "grok", envKey: "XAI_API_KEY", model: "grok-3-mini-beta", driver: "openai", apiUrl: "https://api.x.ai/v1/chat/completions", modelPrefix: "grok", tier: "heavy" },
+      // Standard tier — L3 workers (execution, parallel tasks)
+      { id: "gemini", envKey: "GEMINI_API_KEY", model: "gemini-2.5-flash", driver: "gemini", modelPrefix: "gemini", tier: "standard" },
+      { id: "gemini", envKey: "GOOGLE_API_KEY", model: "gemini-2.5-flash", driver: "gemini", modelPrefix: "gemini", tier: "standard" },
+      { id: "deepseek", envKey: "DEEPSEEK_API_KEY", model: "deepseek-chat", driver: "openai", apiUrl: "https://api.deepseek.com/v1/chat/completions", modelPrefix: "deepseek", tier: "standard" },
+      { id: "kimi", envKey: "MOONSHOT_API_KEY", model: "moonshot-v1-128k", driver: "openai", apiUrl: "https://api.moonshot.cn/v1/chat/completions", modelPrefix: "kimi", tier: "standard" },
+      // Fast tier — L1 routing (classification, cheap)
+      { id: "groq", envKey: "GROQ_API_KEY", model: "llama-3.3-70b-versatile", driver: "openai", apiUrl: "https://api.groq.com/openai/v1/chat/completions", modelPrefix: "llama", tier: "fast" },
+      // Fallback — free tier
+      { id: "openrouter", envKey: "OPENROUTER_API_KEY", model: "google/gemini-2.0-flash-exp:free", driver: "openrouter", apiUrl: "https://openrouter.ai/api/v1/chat/completions", modelPrefix: "openrouter", tier: "standard" },
+      // Additional providers (OpenAI-compatible, cheap workers)
+      { id: "together", envKey: "TOGETHER_API_KEY", model: "Qwen/Qwen3.5-397B-A17B", driver: "openai", apiUrl: "https://api.together.xyz/v1/chat/completions", modelPrefix: "qwen", tier: "standard" },
+      { id: "fireworks", envKey: "FIREWORKS_API_KEY", model: "accounts/fireworks/models/qwen3.5-397b-a17b", driver: "openai", apiUrl: "https://api.fireworks.ai/inference/v1/chat/completions", modelPrefix: "fireworks", tier: "standard" }
+    ];
+    JITContextTracker = class _JITContextTracker {
+      constructor() {
+        this.discoveredFiles = /* @__PURE__ */ new Set();
+        this.contextCache = "";
+      }
+      /** Hydrate from a prior session's discovered files */
+      static fromPrior(files) {
+        const tracker = new _JITContextTracker();
+        for (const f of files) tracker.discoveredFiles.add(f);
+        return tracker;
+      }
+      /** Serialize discovered files for session persistence */
+      toFileList() {
+        return Array.from(this.discoveredFiles);
+      }
+      /** Track a file that was read/written/grepped during tool execution */
+      trackFile(filePath) {
+        if (filePath && !this.discoveredFiles.has(filePath)) {
+          this.discoveredFiles.add(filePath);
+        }
+      }
+      /** Extract file paths from tool calls and results */
+      trackFromToolResult(toolName, params, result) {
+        for (const key of ["file_path", "path", "dir_path"]) {
+          if (params[key]) this.trackFile(String(params[key]));
+        }
+        if ((toolName === "glob" || toolName === "grep_search" || toolName === "grep_search_ripgrep") && result?.output) {
+          const lines = String(result.output).split("\n");
+          for (const line of lines) {
+            const match = line.match(/^([^\s:]+\.[a-zA-Z]+)/);
+            if (match) this.trackFile(match[1]);
+          }
+        }
+        if (toolName === "list_directory" && result?.output) {
+          const lines = String(result.output).split("\n");
+          const dir = params.dir_path || params.path || ".";
+          for (const line of lines) {
+            const match = line.match(/^[fd]\s+(.+)/);
+            if (match && match[1].includes(".")) {
+              this.trackFile(`${dir}/${match[1]}`);
+            }
+          }
+        }
+      }
+      /** Build enriched context from discovered files for next turn */
+      async buildJITContext(projectDir) {
+        if (this.discoveredFiles.size === 0) return "";
+        try {
+          const { buildCollectionIndex: buildCollectionIndex2, searchCollection: searchCollection2 } = await Promise.resolve().then(() => (init_collections(), collections_exports));
+          const uniqueDirs = /* @__PURE__ */ new Set();
+          for (const f of this.discoveredFiles) {
+            const parts = f.split("/");
+            if (parts.length > 1) {
+              uniqueDirs.add(parts.slice(0, -1).join("/"));
+            }
+          }
+          const dirsToIndex = Array.from(uniqueDirs).slice(0, 5);
+          if (dirsToIndex.length === 0) return "";
+          const { resolve: resolvePath } = await import("node:path");
+          const paths = dirsToIndex.map((d) => resolvePath(projectDir, d));
+          const index = await buildCollectionIndex2(paths, { includeCode: true });
+          if (index.chunkCount === 0) return "";
+          const query = Array.from(this.discoveredFiles).slice(0, 10).join(" ");
+          const results = searchCollection2(index, query, 3);
+          if (results.hits.length === 0) return "";
+          const newContext = results.hits.map(
+            (h) => `--- JIT: ${h.source}:${h.startLine} ---
+${h.text.slice(0, 400)}`
+          ).join("\n\n");
+          this.contextCache = newContext;
+          return `
+
+JIT-discovered context:
+${newContext}`;
+        } catch {
+          return "";
+        }
+      }
+      get fileCount() {
+        return this.discoveredFiles.size;
+      }
+    };
+    MAX_RETRIES = 3;
+  }
+});
+
+// src/engine-api.ts
+init_agentic_executor();
+
+// src/sandbox/index.ts
+import { createTwoFilesPatch } from "diff";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3, access as access2 } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { join as join4, dirname as dirname3 } from "node:path";
+var Sandbox = class {
+  constructor(baseDir = process.cwd()) {
+    this.state = {
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      activeBranch: "main",
+      branches: { main: {} }
+    };
+    this.baseDir = baseDir;
+    this.stateFilePath = join4(baseDir, ".crew", "sandbox.json");
+  }
+  async exists(path2) {
+    try {
+      await access2(path2, constants2.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async load() {
+    if (await this.exists(this.stateFilePath)) {
+      try {
+        const data = await readFile4(this.stateFilePath, "utf8");
+        const parsed = JSON.parse(data);
+        this.state = {
+          ...this.state,
+          ...parsed,
+          branches: parsed.branches || { main: {} },
+          activeBranch: parsed.activeBranch || "main"
+        };
+      } catch (err) {
+        console.error(`Failed to load sandbox state: ${err.message}`);
+      }
+    }
+  }
+  async persist() {
+    this.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const dir = dirname3(this.stateFilePath);
+    if (!await this.exists(dir)) {
+      await mkdir3(dir, { recursive: true });
+    }
+    await writeFile3(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
+  }
+  /** Alias for persist() to match external API expectations */
+  async save() {
+    await this.persist();
+  }
+  async addChange(filePath, modifiedContent) {
+    const fullPath = join4(this.baseDir, filePath);
+    let original = "";
+    if (!this.state.branches[this.state.activeBranch] || Array.isArray(this.state.branches[this.state.activeBranch])) {
+      this.state.branches[this.state.activeBranch] = {};
+    }
+    const activeChanges = this.state.branches[this.state.activeBranch];
+    if (activeChanges[filePath]) {
+      original = activeChanges[filePath].original;
+    } else if (await this.exists(fullPath)) {
+      original = await readFile4(fullPath, "utf8");
+    }
+    activeChanges[filePath] = {
+      path: filePath,
+      original,
+      modified: modifiedContent,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.persist();
+  }
+  preview(branchName = this.state.activeBranch) {
+    const branch = this.state.branches[branchName];
+    if (!branch) return `Branch "${branchName}" not found.`;
+    let diff = "";
+    for (const [path2, change] of Object.entries(branch)) {
+      diff += createTwoFilesPatch(
+        `a/${path2}`,
+        `b/${path2}`,
+        change.original,
+        change.modified,
+        void 0,
+        void 0,
+        { context: 3 }
+      );
+    }
+    return diff || "No pending changes.";
+  }
+  async apply(branchName = this.state.activeBranch) {
+    const branch = this.state.branches[branchName];
+    if (!branch) throw new Error(`Branch "${branchName}" not found.`);
+    for (const [path2, change] of Object.entries(branch)) {
+      const fullPath = join4(this.baseDir, path2);
+      const dir = dirname3(fullPath);
+      if (!await this.exists(dir)) {
+        await mkdir3(dir, { recursive: true });
+      }
+      await writeFile3(fullPath, change.modified, "utf8");
+    }
+    await this.rollback(branchName);
+  }
+  async rollback(branchName = this.state.activeBranch) {
+    if (this.state.branches[branchName]) {
+      this.state.branches[branchName] = {};
+      await this.persist();
+    }
+  }
+  async createBranch(name, fromBranch = this.state.activeBranch) {
+    if (this.state.branches[name]) {
+      throw new Error(`Branch "${name}" already exists.`);
+    }
+    const sourceBranch = this.state.branches[fromBranch] || {};
+    this.state.branches[name] = JSON.parse(JSON.stringify(sourceBranch));
+    this.state.activeBranch = name;
+    await this.persist();
+  }
+  async switchBranch(name) {
+    if (!this.state.branches[name]) {
+      throw new Error(`Branch "${name}" does not exist.`);
+    }
+    this.state.activeBranch = name;
+    await this.persist();
+  }
+  async deleteBranch(name) {
+    if (name === "main") throw new Error("Cannot delete main branch.");
+    if (this.state.activeBranch === name) {
+      this.state.activeBranch = "main";
+    }
+    delete this.state.branches[name];
+    await this.persist();
+  }
+  async mergeBranch(source, target = this.state.activeBranch) {
+    if (!this.state.branches[source]) throw new Error(`Source branch "${source}" not found.`);
+    if (!this.state.branches[target]) throw new Error(`Target branch "${target}" not found.`);
+    const sourceChanges = this.state.branches[source];
+    const targetChanges = this.state.branches[target];
+    for (const [path2, change] of Object.entries(sourceChanges)) {
+      targetChanges[path2] = JSON.parse(JSON.stringify(change));
+    }
+    await this.persist();
+  }
+  getActiveBranch() {
+    return this.state.activeBranch;
+  }
+  getBranches() {
+    return Object.keys(this.state.branches);
+  }
+  getPendingPaths(branchName = this.state.activeBranch) {
+    return Object.keys(this.state.branches[branchName] || {});
+  }
+  hasChanges(branchName = this.state.activeBranch) {
+    return Object.keys(this.state.branches[branchName] || {}).length > 0;
+  }
+  /**
+   * Get staged content for a file path (returns undefined if not staged).
+   * Used by tool adapter so agentic workers can read their own staged files.
+   */
+  getStagedContent(filePath, branchName = this.state.activeBranch) {
+    const branch = this.state.branches[branchName];
+    if (!branch) return void 0;
+    const change = branch[filePath];
+    if (change) return change.modified;
+    return void 0;
+  }
+};
+export {
+  Sandbox,
+  runAgenticWorker
+};
+/**
+ * Autonomous Worker Loop
+ * Implements OpenOrca-style THINK → ACT → OBSERVE pattern
+ * 
+ * @license
+ * Copyright 2026 CrewSwarm
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=engine.mjs.map