@alanwchat/coder 0.1.108 → 0.1.112

package/dist/index.cjs

@@ -1,3471 +0,0 @@
-#!/usr/bin/env node
-/**
- * Coder CLI — AI-powered coding assistant
- * Bundled with esbuild
- */
-
-"use strict";
-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/config/index.ts
-var config_exports = {};
-__export(config_exports, {
-  getConfigDirPath: () => getConfigDirPath,
-  getConfigFilePathExplicit: () => getConfigFilePathExplicit,
-  loadConfig: () => loadConfig,
-  resolveApiKey: () => resolveApiKey,
-  resolveProviderConfig: () => resolveProviderConfig,
-  resolveTavilyApiKey: () => resolveTavilyApiKey,
-  saveConfig: () => saveConfig
-});
-function getConfigDir() {
-  const home = (0, import_node_os.homedir)();
-  return (0, import_node_path10.join)(home, ".coder", "cli");
-}
-function createDefaultProviderSettings(provider) {
-  const isCustom = provider === "custom";
-  return {
-    apiKeySource: "env",
-    apiKey: "",
-    apiKeyEnvVar: isCustom ? "CUSTOM_API_KEY" : PRESET_PROVIDERS[provider]?.defaultApiKeyEnvVar ?? "API_KEY",
-    customBaseUrl: isCustom ? "https://api.example.com/v1" : ""
-  };
-}
-function createDefaultConfig() {
-  const providers = {};
-  for (const id of PROVIDER_IDS) {
-    providers[id] = createDefaultProviderSettings(id);
-  }
-  return {
-    activeProvider: "deepseek",
-    providers,
-    lastModel: "deepseek-v4-flash",
-    tavilyApiKey: ""
-  };
-}
-function getConfigFilePath() {
-  return (0, import_node_path10.join)(getConfigDir(), CONFIG_FILE);
-}
-function ensureConfigDir() {
-  const dir = getConfigDir();
-  if (!(0, import_node_fs9.existsSync)(dir)) {
-    (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
-  }
-}
-function loadConfig() {
-  const configPath = getConfigFilePath();
-  if (!(0, import_node_fs9.existsSync)(configPath)) {
-    const defaults = createDefaultConfig();
-    saveConfig(defaults);
-    return defaults;
-  }
-  try {
-    const raw = (0, import_node_fs9.readFileSync)(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return mergeWithDefaults(parsed);
-  } catch {
-    const defaults = createDefaultConfig();
-    saveConfig(defaults);
-    return defaults;
-  }
-}
-function mergeWithDefaults(raw) {
-  const defaults = createDefaultConfig();
-  return {
-    activeProvider: PROVIDER_IDS.includes(String(raw.activeProvider ?? "")) ? raw.activeProvider : defaults.activeProvider,
-    providers: mergeProviders(raw.providers, defaults.providers),
-    lastModel: typeof raw.lastModel === "string" ? raw.lastModel : defaults.lastModel,
-    tavilyApiKey: typeof raw.tavilyApiKey === "string" ? raw.tavilyApiKey : defaults.tavilyApiKey
-  };
-}
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function mergeProviders(raw, defaults) {
-  const result = { ...defaults };
-  if (!raw || typeof raw !== "object") {
-    return result;
-  }
-  for (const id of PROVIDER_IDS) {
-    const p = raw[id];
-    if (p && typeof p === "object") {
-      result[id] = {
-        apiKeySource: p.apiKeySource === "manual" ? "manual" : "env",
-        apiKey: typeof p.apiKey === "string" ? p.apiKey : result[id].apiKey,
-        apiKeyEnvVar: typeof p.apiKeyEnvVar === "string" ? p.apiKeyEnvVar : result[id].apiKeyEnvVar,
-        customBaseUrl: typeof p.customBaseUrl === "string" ? p.customBaseUrl : result[id].customBaseUrl,
-        ...typeof p.supportsThinking === "boolean" ? { supportsThinking: p.supportsThinking } : {},
-        ...isPlainObject(p.thinkingEnabledParams) ? { thinkingEnabledParams: p.thinkingEnabledParams } : {},
-        ...isPlainObject(p.thinkingDisabledParams) ? { thinkingDisabledParams: p.thinkingDisabledParams } : {}
-      };
-    }
-  }
-  return result;
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  const configPath = getConfigFilePath();
-  (0, import_node_fs9.writeFileSync)(configPath, JSON.stringify(config, null, 2), "utf-8");
-}
-function resolveProviderConfig(config, providerId) {
-  const provider = providerId ?? config.activeProvider;
-  const settings = config.providers[provider];
-  if (provider === "custom") {
-    if (!settings.customBaseUrl.trim()) {
-      throw new Error(
-        "Custom provider selected but no base URL configured. Run `coder config` or manually edit the config file."
-      );
-    }
-    return {
-      provider,
-      baseUrl: settings.customBaseUrl.trim(),
-      apiKeySource: settings.apiKeySource,
-      apiKey: settings.apiKey,
-      apiKeyEnvVar: settings.apiKeyEnvVar.trim(),
-      models: []
-    };
-  }
-  const preset = PRESET_PROVIDERS[provider];
-  if (!preset) {
-    throw new Error(`Unknown provider: ${provider}`);
-  }
-  return {
-    provider,
-    baseUrl: settings.customBaseUrl.trim() || preset.baseUrl,
-    apiKeySource: settings.apiKeySource,
-    apiKey: settings.apiKey,
-    apiKeyEnvVar: settings.apiKeyEnvVar.trim() || preset.defaultApiKeyEnvVar,
-    models: settings.customBaseUrl.trim() ? [] : PRESET_MODELS[provider] ?? []
-  };
-}
-function resolveApiKey(resolved) {
-  if (resolved.apiKeySource === "manual") {
-    if (!resolved.apiKey.trim()) {
-      throw new Error(
-        `API key for ${resolved.provider} is not configured. Set it with: coder config providers.<provider>.apiKey <key>`
-      );
-    }
-    return resolved.apiKey.trim();
-  }
-  const envVar = resolved.apiKeyEnvVar;
-  const envValue = process.env[envVar]?.trim();
-  if (!envValue) {
-    throw new Error(
-      `Environment variable ${envVar} is not set. Set it with: export ${envVar}=<your-api-key>`
-    );
-  }
-  return envValue;
-}
-function resolveTavilyApiKey(config) {
-  if (config.tavilyApiKey.trim()) {
-    return config.tavilyApiKey.trim();
-  }
-  return process.env.TAVILY_API_KEY?.trim() ?? "";
-}
-function getConfigDirPath() {
-  return getConfigDir();
-}
-function getConfigFilePathExplicit() {
-  return getConfigFilePath();
-}
-var import_node_os, import_node_path10, import_node_fs9, PRESET_PROVIDERS, PRESET_MODELS, PROVIDER_IDS, CONFIG_FILE;
-var init_config = __esm({
-  "src/config/index.ts"() {
-    "use strict";
-    import_node_os = require("node:os");
-    import_node_path10 = require("node:path");
-    import_node_fs9 = require("node:fs");
-    PRESET_PROVIDERS = {
-      deepseek: { baseUrl: "https://api.deepseek.com", defaultApiKeyEnvVar: "DEEPSEEK_API_KEY" },
-      glm: { baseUrl: "https://open.bigmodel.cn/api/paas/v4", defaultApiKeyEnvVar: "GLM_API_KEY" },
-      agnes: { baseUrl: "https://api.agnesai.com", defaultApiKeyEnvVar: "AGNES_API_KEY" },
-      nvidia: { baseUrl: "https://integrate.api.nvidia.com/v1", defaultApiKeyEnvVar: "NVIDIA_API_KEY" },
-      minimax: { baseUrl: "https://api.minimax.chat/v1", defaultApiKeyEnvVar: "MINIMAX_API_KEY" }
-    };
-    PRESET_MODELS = {
-      deepseek: [
-        { id: "deepseek-v4-flash", label: "DeepSeek V4 Flash", contextWindow: 1e6, supportsThinking: true, supportsMultimodal: false },
-        { id: "deepseek-chat", label: "DeepSeek Chat", contextWindow: 1e6, supportsThinking: false, supportsMultimodal: true }
-      ],
-      glm: [
-        { id: "glm-4", label: "GLM-4", contextWindow: 128e3, supportsThinking: false, supportsMultimodal: true },
-        { id: "glm-4-plus", label: "GLM-4 Plus", contextWindow: 128e3, supportsThinking: true, supportsMultimodal: true }
-      ],
-      agnes: [
-        { id: "agnes-v3", label: "Agnes V3", contextWindow: 128e3, supportsThinking: false, supportsMultimodal: true }
-      ],
-      nvidia: [],
-      minimax: [
-        { id: "minimax-m1", label: "MiniMax M1", contextWindow: 2e5, supportsThinking: true, supportsMultimodal: false }
-      ]
-    };
-    PROVIDER_IDS = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
-    CONFIG_FILE = "settings.json";
-  }
-});
-
-// src/handlers/list-dir.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
-
-// src/handlers/result.ts
-function toolSuccess(tool, data) {
-  return { ok: true, tool, data };
-}
-function toolFailure(tool, code, message) {
-  return {
-    ok: false,
-    tool,
-    error: { code, message }
-  };
-}
-
-// src/handlers/list-dir.ts
-var listDirHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("list_dir", "workspace_required", "No workspace directory set");
-  }
-  const dirPath = (0, import_node_path.resolve)(context.workspaceDir, args.path);
-  const maxDepth = args.recursive ? args.max_depth ?? 1 : 1;
-  try {
-    const entries = walkDirectory(dirPath, 0, maxDepth, args.show_hidden ?? false);
-    return toolSuccess("list_dir", {
-      path: (0, import_node_path.relative)(context.workspaceDir, dirPath),
-      entries
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("list_dir", "read_error", message);
-  }
-};
-function walkDirectory(dirPath, currentDepth, maxDepth, showHidden) {
-  const results = [];
-  let entries;
-  try {
-    entries = (0, import_node_fs.readdirSync)(dirPath);
-  } catch {
-    return results;
-  }
-  for (const name of entries) {
-    if (!showHidden && name.startsWith(".")) {
-      continue;
-    }
-    const fullPath = (0, import_node_path.resolve)(dirPath, name);
-    let stats;
-    try {
-      stats = (0, import_node_fs.statSync)(fullPath);
-    } catch {
-      continue;
-    }
-    results.push({
-      name,
-      path: fullPath,
-      isDir: stats.isDirectory(),
-      size: stats.isFile() ? stats.size : void 0
-    });
-    if (stats.isDirectory() && currentDepth < maxDepth) {
-      results.push(...walkDirectory(fullPath, currentDepth + 1, maxDepth, showHidden));
-    }
-  }
-  return results;
-}
-
-// src/handlers/read-file.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
-var readFileHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("read_file", "workspace_required", "No workspace directory set");
-  }
-  const filePath = (0, import_node_path2.resolve)(context.workspaceDir, args.path);
-  const startLine = args.start_line ?? 1;
-  const maxLines = args.max_lines ?? 500;
-  try {
-    (0, import_node_fs2.statSync)(filePath);
-    const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    const endLine = Math.min(startLine + maxLines - 1, totalLines);
-    const paginatedContent = lines.slice(startLine - 1, endLine).join("\n");
-    return toolSuccess("read_file", {
-      path: filePath,
-      encoding: "utf-8",
-      mimeType: "text/plain",
-      content: paginatedContent,
-      totalLines,
-      startLine,
-      endLine,
-      truncated: endLine < totalLines
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    if (message.includes("ENOENT")) {
-      return toolFailure("read_file", "not_found", `File not found: ${filePath}`);
-    }
-    return toolFailure("read_file", "read_error", message);
-  }
-};
-
-// src/handlers/write-file.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path3 = require("node:path");
-var writeFileHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("write_file", "workspace_required", "No workspace directory set");
-  }
-  const filePath = (0, import_node_path3.resolve)(context.workspaceDir, args.path);
-  if (!filePath.startsWith(context.workspaceDir.replace(/\\/g, "/").replace(/\\/g, "/"))) {
-    return toolFailure("write_file", "path_escape", "Path escapes workspace directory");
-  }
-  if ((0, import_node_fs3.existsSync)(filePath)) {
-    return toolFailure("write_file", "file_exists", `File already exists: ${args.path}. Use replace_file to overwrite.`);
-  }
-  try {
-    if (args.create_parent_dirs !== false) {
-      const parentDir = (0, import_node_path3.dirname)(filePath);
-      if (!(0, import_node_fs3.existsSync)(parentDir)) {
-        (0, import_node_fs3.mkdirSync)(parentDir, { recursive: true });
-      }
-    }
-    const lines = args.content.split("\n");
-    (0, import_node_fs3.writeFileSync)(filePath, args.content, "utf-8");
-    return toolSuccess("write_file", {
-      path: args.path,
-      action: "created",
-      bytesWritten: Buffer.byteLength(args.content, "utf-8"),
-      linesAdded: lines.length,
-      linesRemoved: 0
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("write_file", "write_error", message);
-  }
-};
-
-// src/handlers/replace-file.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = require("node:path");
-var import_node_crypto = require("node:crypto");
-var replaceFileHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("replace_file", "workspace_required", "No workspace directory set");
-  }
-  const filePath = (0, import_node_path4.resolve)(context.workspaceDir, args.path);
-  if (!(0, import_node_fs4.existsSync)(filePath)) {
-    return toolFailure("replace_file", "not_found", `File not found: ${args.path}`);
-  }
-  try {
-    const oldContent = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
-    const oldLines = oldContent.split("\n");
-    const newLines = args.content.split("\n");
-    if (args.expected_sha256) {
-      const actualHash = (0, import_node_crypto.createHash)("sha256").update(oldContent).digest("hex");
-      if (actualHash !== args.expected_sha256) {
-        return toolFailure(
-          "replace_file",
-          "content_changed",
-          `File content changed since last read. Expected SHA256: ${args.expected_sha256}, got: ${actualHash}. Read the file again to get the latest content.`
-        );
-      }
-    }
-    (0, import_node_fs4.writeFileSync)(filePath, args.content, "utf-8");
-    return toolSuccess("replace_file", {
-      path: args.path,
-      action: "replaced",
-      bytesWritten: Buffer.byteLength(args.content, "utf-8"),
-      linesAdded: newLines.length,
-      linesRemoved: oldLines.length
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("replace_file", "write_error", message);
-  }
-};
-
-// src/handlers/edit-file.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path5 = require("node:path");
-var import_node_crypto2 = require("node:crypto");
-var editFileHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("edit_file", "workspace_required", "No workspace directory set");
-  }
-  const filePath = (0, import_node_path5.resolve)(context.workspaceDir, args.path);
-  if (!(0, import_node_fs5.existsSync)(filePath)) {
-    return toolFailure("edit_file", "not_found", `File not found: ${args.path}`);
-  }
-  try {
-    const oldContent = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
-    const oldLines = oldContent.split("\n");
-    if (args.expected_sha256) {
-      const actualHash = (0, import_node_crypto2.createHash)("sha256").update(oldContent).digest("hex");
-      if (actualHash !== args.expected_sha256) {
-        return toolFailure(
-          "edit_file",
-          "content_changed",
-          `File content changed since last read. Expected SHA256: ${args.expected_sha256}, got: ${actualHash}.`
-        );
-      }
-    }
-    let newContent;
-    if (args.replace_all) {
-      newContent = oldContent.split(args.old_string).join(args.new_string);
-    } else {
-      const index = oldContent.indexOf(args.old_string);
-      if (index === -1) {
-        return toolFailure(
-          "edit_file",
-          "string_not_found",
-          `Could not find the exact text to replace in ${args.path}. The text must match exactly.`
-        );
-      }
-      newContent = oldContent.slice(0, index) + args.new_string + oldContent.slice(index + args.old_string.length);
-    }
-    const newLines = newContent.split("\n");
-    (0, import_node_fs5.writeFileSync)(filePath, newContent, "utf-8");
-    const linesAdded = newLines.length - oldLines.length;
-    const linesRemoved = oldLines.length - newLines.length;
-    return toolSuccess("edit_file", {
-      path: args.path,
-      action: "modified",
-      bytesWritten: Buffer.byteLength(newContent, "utf-8"),
-      linesAdded: linesAdded > 0 ? linesAdded : 0,
-      linesRemoved: linesRemoved > 0 ? linesRemoved : 0
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("edit_file", "write_error", message);
-  }
-};
-
-// src/handlers/replace-lines.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path6 = require("node:path");
-var import_node_crypto3 = require("node:crypto");
-var replaceLinesHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("replace_lines", "workspace_required", "No workspace directory set");
-  }
-  const filePath = (0, import_node_path6.resolve)(context.workspaceDir, args.path);
-  if (!(0, import_node_fs6.existsSync)(filePath)) {
-    return toolFailure("replace_lines", "not_found", `File not found: ${args.path}`);
-  }
-  try {
-    const oldContent = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
-    const oldLines = oldContent.split("\n");
-    if (args.expected_sha256) {
-      const actualHash = (0, import_node_crypto3.createHash)("sha256").update(oldContent).digest("hex");
-      if (actualHash !== args.expected_sha256) {
-        return toolFailure(
-          "replace_lines",
-          "content_changed",
-          `File content changed since last read. Expected SHA256: ${args.expected_sha256}, got: ${actualHash}.`
-        );
-      }
-    }
-    if (args.start_line < 1 || args.end_line < args.start_line || args.start_line > oldLines.length) {
-      return toolFailure(
-        "replace_lines",
-        "invalid_range",
-        `Invalid line range: ${args.start_line}-${args.end_line}. File has ${oldLines.length} lines.`
-      );
-    }
-    const endLine = Math.min(args.end_line, oldLines.length);
-    const replacementLines = args.content === "" ? [] : args.content.split("\n");
-    const before = oldLines.slice(0, args.start_line - 1);
-    const after = oldLines.slice(endLine);
-    const newContent = [...before, ...replacementLines, ...after].join("\n");
-    (0, import_node_fs6.writeFileSync)(filePath, newContent, "utf-8");
-    return toolSuccess("replace_lines", {
-      path: args.path,
-      action: "modified",
-      bytesWritten: Buffer.byteLength(newContent, "utf-8"),
-      linesAdded: replacementLines.length,
-      linesRemoved: endLine - args.start_line + 1,
-      warning: "Rows may have shifted \u2014 re-read the file with read_file before your next edit."
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("replace_lines", "write_error", message);
-  }
-};
-
-// src/handlers/glob.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path7 = require("node:path");
-var globHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("glob", "workspace_required", "No workspace directory set");
-  }
-  const searchDir = args.target_directory ? (0, import_node_path7.resolve)(context.workspaceDir, args.target_directory) : context.workspaceDir;
-  const headLimit = args.head_limit ?? 100;
-  const pattern = args.glob_pattern;
-  try {
-    const matches = simpleGlob(searchDir, pattern, context.workspaceDir, headLimit);
-    return toolSuccess("glob", {
-      pattern,
-      targetDirectory: (0, import_node_path7.relative)(context.workspaceDir, searchDir),
-      matches: matches.slice(0, headLimit),
-      totalMatches: matches.length,
-      truncated: matches.length > headLimit
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("glob", "search_error", message);
-  }
-};
-function simpleGlob(rootDir, pattern, workspaceDir, limit) {
-  const results = [];
-  function walk(dir) {
-    if (results.length >= limit) return;
-    let entries;
-    try {
-      entries = (0, import_node_fs7.readdirSync)(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (results.length >= limit) return;
-      if (name.startsWith(".")) continue;
-      const fullPath = (0, import_node_path7.resolve)(dir, name);
-      const relPath = (0, import_node_path7.relative)(workspaceDir, fullPath).replace(/\\/g, "/");
-      let stats;
-      try {
-        stats = (0, import_node_fs7.statSync)(fullPath);
-      } catch {
-        continue;
-      }
-      const regex = globToRegex(pattern);
-      if (regex.test(relPath)) {
-        results.push(relPath);
-      }
-      if (stats.isDirectory()) {
-        walk(fullPath);
-      }
-    }
-  }
-  walk(rootDir);
-  results.sort();
-  return results;
-}
-function globToRegex(pattern) {
-  let regexStr = "^";
-  let i = 0;
-  while (i < pattern.length) {
-    const ch = pattern[i];
-    if (ch === "*") {
-      if (i + 1 < pattern.length && pattern[i + 1] === "*") {
-        regexStr += ".*";
-        i += 2;
-        if (i < pattern.length && pattern[i] === "/") {
-          regexStr += "/?";
-          i++;
-        }
-      } else {
-        regexStr += "[^/]*";
-        i++;
-      }
-    } else if (ch === "?") {
-      regexStr += "[^/]";
-      i++;
-    } else if (ch === "." || ch === "+" || ch === "(" || ch === ")" || ch === "[" || ch === "]" || ch === "{" || ch === "}" || ch === "\\" || ch === "^" || ch === "$" || ch === "|") {
-      regexStr += "\\" + ch;
-      i++;
-    } else {
-      regexStr += ch;
-      i++;
-    }
-  }
-  regexStr += "$";
-  return new RegExp(regexStr, "i");
-}
-
-// src/handlers/grep.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
-var grepHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("grep", "workspace_required", "No workspace directory set");
-  }
-  const searchPath = args.path ? (0, import_node_path8.resolve)(context.workspaceDir, args.path) : context.workspaceDir;
-  const headLimit = args.head_limit ?? 200;
-  const offset = args.offset ?? 0;
-  const ctxBefore = args.context_before ?? args.context ?? 0;
-  const ctxAfter = args.context_after ?? args.context ?? 0;
-  const flags = args.case_insensitive ? "gi" : "g";
-  const outputMode = args.output_mode ?? "content";
-  const multiline = args.multiline ?? false;
-  try {
-    let searchRegex;
-    try {
-      const regexFlags = multiline ? `${flags}s` : flags;
-      searchRegex = new RegExp(args.pattern, regexFlags);
-    } catch {
-      return toolFailure("grep", "invalid_pattern", `Invalid regex pattern: ${args.pattern}`);
-    }
-    const files = collectFiles(searchPath);
-    const matches = [];
-    const fileMatchSet = /* @__PURE__ */ new Set();
-    const fileCountMap = {};
-    let totalMatches = 0;
-    let skippedFiles = 0;
-    for (const file of files) {
-      if (totalMatches >= headLimit + offset) break;
-      let content;
-      try {
-        content = (0, import_node_fs8.readFileSync)(file, "utf-8");
-      } catch {
-        skippedFiles++;
-        continue;
-      }
-      const relativePath = (0, import_node_path8.relative)(context.workspaceDir, file);
-      let fileHasMatch = false;
-      let fileMatchCount = 0;
-      if (multiline) {
-        const lines = content.split("\n");
-        searchRegex.lastIndex = 0;
-        const fullMatch = searchRegex.exec(content);
-        if (fullMatch) {
-          fileHasMatch = true;
-          do {
-            totalMatches++;
-            fileMatchCount++;
-            searchRegex.lastIndex = fullMatch.index + 1;
-          } while (searchRegex.exec(content));
-          searchRegex.lastIndex = 0;
-          if (outputMode === "content") {
-            matches.push({
-              path: relativePath,
-              lineNumber: 1,
-              line: fullMatch[0].slice(0, 200)
-            });
-          }
-        }
-      } else {
-        const lines = content.split("\n");
-        for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-          searchRegex.lastIndex = 0;
-          if (searchRegex.test(lines[lineNum])) {
-            totalMatches++;
-            fileMatchCount++;
-            if (outputMode === "files_with_matches") {
-              fileMatchSet.add(relativePath);
-              fileHasMatch = true;
-              continue;
-            }
-            if (outputMode === "count") {
-              fileHasMatch = true;
-              continue;
-            }
-            if (totalMatches > offset && totalMatches <= offset + headLimit) {
-              const contextBeforeLines = ctxBefore > 0 ? lines.slice(Math.max(0, lineNum - ctxBefore), lineNum) : void 0;
-              const contextAfterLines = ctxAfter > 0 ? lines.slice(lineNum + 1, lineNum + 1 + ctxAfter) : void 0;
-              matches.push({
-                path: relativePath,
-                lineNumber: lineNum + 1,
-                line: lines[lineNum],
-                contextBefore: contextBeforeLines?.length ? contextBeforeLines : void 0,
-                contextAfter: contextAfterLines?.length ? contextAfterLines : void 0
-              });
-            }
-          }
-        }
-      }
-      if (fileHasMatch || fileMatchCount > 0) {
-        fileMatchSet.add(relativePath);
-        fileCountMap[relativePath] = fileMatchCount;
-      }
-      if (outputMode === "files_with_matches" && fileMatchSet.size >= headLimit) {
-        break;
-      }
-    }
-    const result = {
-      pattern: args.pattern,
-      path: (0, import_node_path8.relative)(context.workspaceDir, searchPath),
-      outputMode,
-      totalMatches,
-      truncated: totalMatches > headLimit
-    };
-    if (outputMode === "content") {
-      result.matches = matches;
-    } else if (outputMode === "files_with_matches") {
-      result.files = [...fileMatchSet];
-    } else if (outputMode === "count") {
-      result.files = [...fileMatchSet];
-      result.fileCounts = fileCountMap;
-    }
-    if (skippedFiles > 0) {
-      result.skippedFiles = skippedFiles;
-    }
-    return toolSuccess("grep", result);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("grep", "search_error", message);
-  }
-};
-function collectFiles(dirPath) {
-  try {
-    const stats = (0, import_node_fs8.statSync)(dirPath);
-    if (stats.isFile()) {
-      return [dirPath];
-    }
-  } catch {
-    return [];
-  }
-  const results = [];
-  function walk(dir) {
-    let entries;
-    try {
-      entries = (0, import_node_fs8.readdirSync)(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (name === ".git" || name === "node_modules") continue;
-      const fullPath = (0, import_node_path8.resolve)(dir, name);
-      let stats;
-      try {
-        stats = (0, import_node_fs8.statSync)(fullPath);
-      } catch {
-        continue;
-      }
-      if (stats.isDirectory()) {
-        walk(fullPath);
-      } else if (stats.isFile() && stats.size > 0) {
-        results.push(fullPath);
-      }
-    }
-  }
-  walk(dirPath);
-  return results;
-}
-
-// src/handlers/shell-manager.ts
-var import_node_child_process = require("node:child_process");
-var import_node_path9 = require("node:path");
-var shells = /* @__PURE__ */ new Map();
-var shellCounter = 0;
-function generateShellId() {
-  shellCounter++;
-  return `shell-${Date.now()}-${shellCounter}`;
-}
-async function executeShell(command, options) {
-  const shellId = generateShellId();
-  const cwd = options.workspaceDir ? options.workingDirectory ? (0, import_node_path9.resolve)(options.workspaceDir, options.workingDirectory) : options.workspaceDir : process.cwd();
-  const startTime = Date.now();
-  const blockMs = options.blockUntilMs ?? 3e4;
-  const isWindows = process.platform === "win32";
-  const shellCmd = isWindows ? "cmd.exe" : "/bin/sh";
-  const shellArgs = isWindows ? ["/c", command] : ["-c", command];
-  return new Promise((resolvePromise) => {
-    const child = (0, import_node_child_process.spawn)(shellCmd, shellArgs, {
-      cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      shell: false,
-      env: { ...process.env }
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const shell = {
-      shellId,
-      command,
-      description: options.description,
-      process: child,
-      status: "running",
-      stdout,
-      stderr,
-      workingDirectory: cwd,
-      startedAtMs: startTime,
-      taskId: options.taskId
-    };
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-      shell.stdout = stdout;
-    });
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-      shell.stderr = stderr;
-    });
-    const finish = (status, code) => {
-      if (settled) return;
-      settled = true;
-      shell.status = status;
-      shell.exitCode = code;
-      const duration = Date.now() - startTime;
-      const stdoutBytes = Buffer.byteLength(stdout);
-      const stderrBytes = Buffer.byteLength(stderr);
-      if (blockMs <= 0) {
-        shells.set(shellId, shell);
-      } else {
-        shells.delete(shellId);
-      }
-      resolvePromise({
-        command,
-        description: options.description,
-        workingDirectory: cwd,
-        stdout,
-        stderr,
-        stdoutTruncated: stdoutBytes > 65536,
-        stderrTruncated: stderrBytes > 65536,
-        stdoutTotalBytes: stdoutBytes,
-        stderrTotalBytes: stderrBytes,
-        exitCode: code,
-        durationMs: duration,
-        status,
-        shellId: blockMs <= 0 ? shellId : void 0
-      });
-    };
-    child.on("error", (err) => {
-      stderr += err.message;
-      finish("failed", 1);
-    });
-    child.on("close", (code) => {
-      finish(code === 0 ? "completed" : "failed", code ?? void 0);
-    });
-    if (blockMs > 0) {
-      const timeout = setTimeout(() => {
-        if (!settled) {
-          child.kill();
-          finish("timeout", void 0);
-        }
-      }, blockMs);
-      child.on("close", () => clearTimeout(timeout));
-    }
-    if (blockMs <= 0) {
-      shells.set(shellId, shell);
-      const stdoutBytes = Buffer.byteLength(stdout);
-      const stderrBytes = Buffer.byteLength(stderr);
-      resolvePromise({
-        command,
-        description: options.description,
-        workingDirectory: cwd,
-        stdout: "",
-        stderr: "",
-        stdoutTruncated: false,
-        stderrTruncated: false,
-        stdoutTotalBytes: 0,
-        stderrTotalBytes: 0,
-        exitCode: void 0,
-        durationMs: 0,
-        status: "running",
-        shellId
-      });
-    }
-  });
-}
-async function awaitShell(shellId, blockUntilMs = 3e4) {
-  const shell = shells.get(shellId);
-  if (!shell) {
-    return {
-      command: "",
-      workingDirectory: "",
-      stdout: "",
-      stderr: "",
-      stdoutTruncated: false,
-      stderrTruncated: false,
-      stdoutTotalBytes: 0,
-      stderrTotalBytes: 0,
-      durationMs: 0,
-      status: "completed",
-      shellId
-    };
-  }
-  return new Promise((resolvePromise) => {
-    const startTime = Date.now();
-    const checkProcess = () => {
-      if (shell.exitCode !== void 0 || shell.status !== "running") {
-        const duration = Date.now() - startTime;
-        const stdoutBytes = Buffer.byteLength(shell.stdout);
-        const stderrBytes = Buffer.byteLength(shell.stderr);
-        resolvePromise({
-          command: shell.command,
-          description: shell.description,
-          workingDirectory: shell.workingDirectory,
-          stdout: shell.stdout,
-          stderr: shell.stderr,
-          stdoutTruncated: stdoutBytes > 65536,
-          stderrTruncated: stderrBytes > 65536,
-          stdoutTotalBytes: stdoutBytes,
-          stderrTotalBytes: stderrBytes,
-          exitCode: shell.exitCode,
-          durationMs: duration,
-          status: shell.status,
-          shellId
-        });
-        return;
-      }
-      if (Date.now() - startTime > blockUntilMs) {
-        const duration = Date.now() - startTime;
-        const stdoutBytes = Buffer.byteLength(shell.stdout);
-        const stderrBytes = Buffer.byteLength(shell.stderr);
-        resolvePromise({
-          command: shell.command,
-          description: shell.description,
-          workingDirectory: shell.workingDirectory,
-          stdout: shell.stdout,
-          stderr: shell.stderr,
-          stdoutTruncated: stdoutBytes > 65536,
-          stderrTruncated: stderrBytes > 65536,
-          stdoutTotalBytes: stdoutBytes,
-          stderrTotalBytes: stderrBytes,
-          exitCode: shell.exitCode,
-          durationMs: duration,
-          status: shell.status,
-          shellId
-        });
-        return;
-      }
-      setTimeout(checkProcess, 50);
-    };
-    shell.process.on("close", () => {
-      checkProcess();
-    });
-    checkProcess();
-  });
-}
-function listShells(statusFilter) {
-  const result = [];
-  for (const shell of shells.values()) {
-    if (statusFilter && shell.status !== statusFilter && statusFilter !== "all") {
-      continue;
-    }
-    result.push({
-      shellId: shell.shellId,
-      command: shell.command,
-      description: shell.description,
-      workingDirectory: shell.workingDirectory,
-      status: shell.status,
-      exitCode: shell.exitCode,
-      startedAtMs: shell.startedAtMs,
-      taskId: shell.taskId,
-      stdout: shell.stdout,
-      stderr: shell.stderr,
-      stdoutTruncated: Buffer.byteLength(shell.stdout) > 65536,
-      stderrTruncated: Buffer.byteLength(shell.stderr) > 65536
-    });
-  }
-  return result;
-}
-function killShell(shellId) {
-  const shell = shells.get(shellId);
-  if (!shell) return false;
-  try {
-    shell.process.kill("SIGTERM");
-    shell.status = "cancelled";
-    setTimeout(() => {
-      try {
-        shell.process.kill("SIGKILL");
-      } catch {
-      }
-    }, 2e3);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function readShellLogs(shellId, stream, offset = 0, limit = 4096) {
-  const shell = shells.get(shellId);
-  if (!shell) {
-    return { data: "", offset: 0, totalBytes: 0, truncated: false };
-  }
-  const content = stream === "stdout" ? shell.stdout : shell.stderr;
-  const totalBytes = Buffer.byteLength(content);
-  const sliced = content.slice(offset, offset + limit);
-  return {
-    data: sliced,
-    offset: offset + sliced.length,
-    totalBytes,
-    truncated: offset + limit < totalBytes
-  };
-}
-function killAllShells() {
-  for (const shell of shells.values()) {
-    if (shell.status === "running") {
-      try {
-        shell.process.kill("SIGTERM");
-      } catch {
-      }
-    }
-  }
-  shells.clear();
-}
-function killShellsByTask(taskId) {
-  for (const [id, shell] of shells) {
-    if (shell.taskId === taskId && shell.status === "running") {
-      try {
-        shell.process.kill("SIGTERM");
-      } catch {
-      }
-    }
-  }
-}
-
-// src/handlers/shell.ts
-var shellHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!args.command?.trim()) {
-    return toolFailure("shell", "invalid_arguments", "Command is required");
-  }
-  try {
-    const result = await executeShell(args.command.trim(), {
-      workingDirectory: args.working_directory,
-      description: args.description,
-      blockUntilMs: args.block_until_ms ?? 3e4,
-      taskId: context.taskId,
-      workspaceDir: context.workspaceDir
-    });
-    return toolSuccess("shell", result);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("shell", "execution_error", message);
-  }
-};
-
-// src/handlers/await-shell.ts
-var awaitShellHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.shell_id?.trim()) {
-    return toolFailure("await", "invalid_arguments", "shell_id is required");
-  }
-  try {
-    const result = await awaitShell(args.shell_id.trim(), args.block_until_ms ?? 3e4);
-    return toolSuccess("await", result);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("await", "error", message);
-  }
-};
-
-// src/handlers/list-shells.ts
-var listShellsHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  const shells2 = listShells(args.status_filter);
-  return toolSuccess("list_shells", {
-    shells: shells2,
-    total: shells2.length
-  });
-};
-
-// src/handlers/kill-shell.ts
-var killShellHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.shell_id?.trim()) {
-    return toolFailure("kill_shell", "invalid_arguments", "shell_id is required");
-  }
-  const killed = killShell(args.shell_id.trim());
-  return toolSuccess("kill_shell", {
-    shellId: args.shell_id.trim(),
-    killed
-  });
-};
-
-// src/handlers/read-shell-logs.ts
-var readShellLogsHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.shell_id?.trim()) {
-    return toolFailure("read_shell_logs", "invalid_arguments", "shell_id is required");
-  }
-  const result = readShellLogs(
-    args.shell_id.trim(),
-    args.stream ?? "stdout",
-    args.offset ?? 0,
-    args.limit ?? 4096
-  );
-  return toolSuccess("read_shell_logs", {
-    shellId: args.shell_id.trim(),
-    stream: args.stream ?? "stdout",
-    data: result.data,
-    offset: result.offset,
-    totalBytes: result.totalBytes,
-    truncated: result.truncated
-  });
-};
-
-// src/handlers/web-search.ts
-init_config();
-var webSearchHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.search_term?.trim()) {
-    return toolFailure("web_search", "invalid_arguments", "search_term is required");
-  }
-  const config = loadConfig();
-  const tavilyKey = resolveTavilyApiKey(config);
-  try {
-    const results = await performWebSearch(args.search_term, args.max_results ?? 5, tavilyKey);
-    return toolSuccess("web_search", {
-      query: args.search_term,
-      results
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("web_search", "search_error", message);
-  }
-};
-async function performWebSearch(query, maxResults, tavilyKey) {
-  if (tavilyKey) {
-    try {
-      const response = await fetch("https://api.tavily.com/search", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          api_key: tavilyKey,
-          query,
-          max_results: maxResults,
-          search_depth: "basic"
-        }),
-        signal: AbortSignal.timeout(15e3)
-      });
-      if (response.ok) {
-        const data = await response.json();
-        if (data.results && data.results.length > 0) {
-          return data.results.map((r) => ({
-            title: r.title,
-            url: r.url,
-            snippet: r.content
-          }));
-        }
-      }
-    } catch {
-    }
-  }
-  try {
-    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
-    const response = await fetch(url, {
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    const data = await response.json();
-    const results = [];
-    if (data.AbstractText) {
-      results.push({
-        title: data.AbstractSource ?? "Result",
-        url: data.AbstractURL ?? "",
-        snippet: data.AbstractText
-      });
-    }
-    if (data.RelatedTopics) {
-      for (const topic of data.RelatedTopics.slice(0, maxResults)) {
-        if (topic.Text && topic.FirstURL) {
-          results.push({
-            title: topic.Text.split(" - ")[0] ?? "Result",
-            url: topic.FirstURL,
-            snippet: topic.Text
-          });
-        }
-      }
-    }
-    if (results.length === 0) {
-      throw new Error("No results");
-    }
-    return results.slice(0, maxResults);
-  } catch {
-    throw new Error(
-      "Web search is currently unavailable. Configure a Tavily API key via `coder config tavilyApiKey <key>` or set the TAVILY_API_KEY environment variable."
-    );
-  }
-}
-
-// src/handlers/browse-page.ts
-var browsePageHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.url?.trim()) {
-    return toolFailure("browse_page", "invalid_arguments", "url is required");
-  }
-  try {
-    const response = await fetch(args.url.trim(), {
-      headers: {
-        "User-Agent": "Mozilla/5.0 (compatible; CoderCLI/1.0)",
-        Accept: "text/html,text/plain,*/*"
-      },
-      signal: AbortSignal.timeout(15e3)
-    });
-    const contentType = response.headers.get("content-type") ?? "text/plain";
-    const finalUrl = response.url;
-    const title = extractTitleFromUrl(finalUrl);
-    let content = await response.text();
-    const startLine = args.start_line ?? 1;
-    const maxLines = args.max_lines ?? 500;
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    const endLine = Math.min(startLine + maxLines - 1, totalLines);
-    const paginatedContent = lines.slice(startLine - 1, endLine).join("\n");
-    return toolSuccess("browse_page", {
-      url: args.url,
-      finalUrl,
-      title,
-      content: paginatedContent,
-      truncated: endLine < totalLines,
-      statusCode: response.status,
-      contentType
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    if (message.includes("fetch")) {
-      return toolFailure("browse_page", "network_error", `Failed to fetch URL: ${message}`);
-    }
-    return toolFailure("browse_page", "error", message);
-  }
-};
-function extractTitleFromUrl(url) {
-  try {
-    const parsed = new URL(url);
-    return parsed.hostname;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/handlers/todos.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path11 = require("node:path");
-init_config();
-function getTodosFilePath(sessionId) {
-  const dir = (0, import_node_path11.join)(getConfigDirPath(), "todos");
-  if (!(0, import_node_fs10.existsSync)(dir)) {
-    (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
-  }
-  const safeSessionId = (sessionId ?? "default").replace(/[^a-z0-9-]/gi, "");
-  return (0, import_node_path11.join)(dir, `${safeSessionId}.json`);
-}
-function readTodos(sessionId) {
-  const filePath = getTodosFilePath(sessionId);
-  if (!(0, import_node_fs10.existsSync)(filePath)) return [];
-  try {
-    return JSON.parse((0, import_node_fs10.readFileSync)(filePath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function writeTodos(todos, sessionId) {
-  (0, import_node_fs10.writeFileSync)(getTodosFilePath(sessionId), JSON.stringify(todos, null, 2), "utf-8");
-}
-var todoReadHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  const sessionId = args.session_id ?? context.sessionId;
-  const todos = readTodos(sessionId);
-  const snapshot = todos.sort((a, b) => a.order - b.order).map((t) => ({
-    id: t.id,
-    content: t.content,
-    status: t.status
-  }));
-  return toolSuccess("todo_read", {
-    sessionId: sessionId ?? null,
-    todos: snapshot,
-    total: snapshot.length,
-    active: snapshot.filter((t) => t.status === "pending" || t.status === "in_progress").length,
-    completed: snapshot.filter((t) => t.status === "completed").length
-  });
-};
-var todoWriteHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  const sessionId = args.session_id ?? context.sessionId;
-  if (!args.todos || !Array.isArray(args.todos)) {
-    return toolFailure("todo_write", "invalid_arguments", "todos array is required");
-  }
-  const existing = readTodos(sessionId);
-  const existingMap = new Map(existing.map((t) => [t.id, t]));
-  for (let i = 0; i < args.todos.length; i++) {
-    const input = args.todos[i];
-    const existingRecord = existingMap.get(input.id);
-    if (existingRecord) {
-      existingRecord.content = input.content;
-      existingRecord.status = input.status;
-      existingRecord.updatedAt = Date.now();
-    } else {
-      existing.push({
-        id: input.id,
-        content: input.content,
-        status: input.status,
-        order: i,
-        createdAt: Date.now(),
-        updatedAt: Date.now()
-      });
-    }
-  }
-  writeTodos(existing, sessionId);
-  return toolSuccess("todo_write", {
-    total: existing.length,
-    updated: args.todos.length
-  });
-};
-
-// src/handlers/workspace-tree.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path12 = require("node:path");
-var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "target",
-  ".next",
-  "out",
-  ".cache",
-  ".turbo",
-  "coverage",
-  ".nyc_output",
-  "__pycache__",
-  ".venv",
-  "venv",
-  ".history"
-]);
-var getWorkspaceTreeHandler = async (rawArgs, context) => {
-  const args = rawArgs;
-  if (!context.workspaceDir) {
-    return toolFailure("get_workspace_tree", "workspace_required", "No workspace directory set");
-  }
-  try {
-    const rootDir = context.workspaceDir;
-    const treeLines = buildTree(rootDir, rootDir, 0);
-    const fullText = treeLines.join("\n");
-    const totalLines = treeLines.length;
-    const startLine = args.start_line ?? 1;
-    const maxLines = args.max_lines ?? 500;
-    const endLine = Math.min(startLine + maxLines - 1, totalLines);
-    const paginatedText = treeLines.slice(startLine - 1, endLine).join("\n");
-    return toolSuccess("get_workspace_tree", {
-      treeText: paginatedText,
-      totalLines,
-      startLine,
-      endLine,
-      truncated: endLine < totalLines
-    });
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("get_workspace_tree", "error", message);
-  }
-};
-function buildTree(rootDir, currentDir, depth) {
-  const lines = [];
-  const relPath = (0, import_node_path12.relative)(rootDir, currentDir);
-  if (depth === 0) {
-    lines.push((0, import_node_path12.relative)(rootDir, currentDir) || ".");
-  }
-  let entries;
-  try {
-    entries = (0, import_node_fs11.readdirSync)(currentDir);
-  } catch {
-    return lines;
-  }
-  const dirs = [];
-  const files = [];
-  for (const name of entries) {
-    if (name.startsWith(".") && depth === 0 && name === ".git") continue;
-    if (EXCLUDED_DIRS.has(name)) continue;
-    if (name.startsWith(".") && depth > 0) continue;
-    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
-    try {
-      const stats = (0, import_node_fs11.statSync)(fullPath);
-      if (stats.isDirectory()) {
-        dirs.push(name);
-      } else {
-        files.push(name);
-      }
-    } catch {
-    }
-  }
-  dirs.sort();
-  files.sort();
-  const allEntries = [...dirs, ...files];
-  for (let i = 0; i < allEntries.length; i++) {
-    const name = allEntries[i];
-    const isLast = i === allEntries.length - 1;
-    const prefix = depth === 0 ? isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : "";
-    const childPrefix = depth === 0 ? isLast ? "    " : "\u2502   " : "";
-    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
-    lines.push(`${prefix}${name}`);
-    try {
-      const stats = (0, import_node_fs11.statSync)(fullPath);
-      if (stats.isDirectory()) {
-        const childLines = buildTreeFromDepth(rootDir, fullPath, depth + 1, prefix || "", childPrefix);
-        lines.push(...childLines);
-      }
-    } catch {
-    }
-  }
-  return lines;
-}
-function buildTreeFromDepth(rootDir, currentDir, depth, parentPrefix, prefix) {
-  const lines = [];
-  let entries;
-  try {
-    entries = (0, import_node_fs11.readdirSync)(currentDir);
-  } catch {
-    return lines;
-  }
-  const dirs = [];
-  const files = [];
-  for (const name of entries) {
-    if (EXCLUDED_DIRS.has(name)) continue;
-    if (name.startsWith(".")) continue;
-    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
-    try {
-      const stats = (0, import_node_fs11.statSync)(fullPath);
-      if (stats.isDirectory()) {
-        dirs.push(name);
-      } else {
-        files.push(name);
-      }
-    } catch {
-    }
-  }
-  dirs.sort();
-  files.sort();
-  const allEntries = [...dirs, ...files];
-  for (let i = 0; i < allEntries.length; i++) {
-    const name = allEntries[i];
-    const isLast = i === allEntries.length - 1;
-    const linePrefix = `${prefix}${isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}`;
-    const childPrefix = `${prefix}${isLast ? "    " : "\u2502   "}`;
-    lines.push(`${linePrefix}${name}`);
-    const fullPath = (0, import_node_path12.resolve)(currentDir, name);
-    try {
-      const stats = (0, import_node_fs11.statSync)(fullPath);
-      if (stats.isDirectory()) {
-        const childLines = buildTreeFromDepth(rootDir, fullPath, depth + 1, "", childPrefix);
-        lines.push(...childLines);
-      }
-    } catch {
-    }
-  }
-  return lines;
-}
-
-// src/handlers/ask-question.ts
-var import_node_readline = require("node:readline");
-var askQuestionHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.question?.trim()) {
-    return toolFailure("ask_question", "invalid_arguments", "question is required");
-  }
-  const rl = (0, import_node_readline.createInterface)({
-    input: process.stdin,
-    output: process.stderr
-  });
-  const answer = await new Promise((resolve12) => {
-    process.stderr.write(`
-\x1B[33m\u2753 ${args.question}\x1B[0m
-> `);
-    rl.once("line", (line) => {
-      resolve12(line.trim());
-    });
-  });
-  rl.close();
-  if (!answer) {
-    return toolFailure("ask_question", "no_answer", "User did not provide an answer");
-  }
-  return toolSuccess("ask_question", {
-    question: args.question,
-    answer
-  });
-};
-
-// src/handlers/spawn-subagent.ts
-var spawnAgentFunction = null;
-var spawnSubAgentHandler = async (rawArgs, _context) => {
-  const args = rawArgs;
-  if (!args.task?.trim()) {
-    return toolFailure("spawn_subagent", "invalid_arguments", "task is required");
-  }
-  if (!spawnAgentFunction) {
-    return toolFailure(
-      "spawn_subagent",
-      "not_available",
-      "Sub-agent spawning is not available in the current configuration."
-    );
-  }
-  try {
-    const result = await spawnAgentFunction(args.task, args.context, args.tools);
-    return toolSuccess("spawn_subagent", result);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return toolFailure("spawn_subagent", "execution_error", message);
-  }
-};
-
-// src/handlers/index.ts
-var AGENT_TOOL_DEFINITIONS = [
-  {
-    type: "function",
-    function: {
-      name: "list_dir",
-      description: "List files and directories under a path. Relative paths are resolved against the workspace root.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Relative or absolute path within the workspace." },
-          recursive: { type: "boolean", description: "Whether to list entries recursively.", default: false },
-          max_depth: { type: "integer", description: "Maximum recursion depth when recursive is true.", default: 1 },
-          show_hidden: { type: "boolean", description: "Whether to include dotfiles and dot-directories.", default: false }
-        },
-        required: ["path"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "read_file",
-      description: "Read a text file with line numbers and pagination. Relative paths are resolved against the workspace root.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
-          start_line: { type: "integer", description: "First line to read (1-based).", default: 1 },
-          max_lines: { type: "integer", description: "Maximum number of lines to return.", default: 500 },
-          respect_gitignore: { type: "boolean", description: "Whether to refuse reading paths ignored by .gitignore.", default: true }
-        },
-        required: ["path"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "write_file",
-      description: "Create a new text file. Fails if the file already exists. Use edit_file or replace_lines to modify existing files.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Relative or absolute path to the new file within the workspace." },
-          content: { type: "string", description: "Full file content to write." },
-          create_parent_dirs: { type: "boolean", description: "Whether to create missing parent directories.", default: true }
-        },
-        required: ["path", "content"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "replace_file",
-      description: "Replace an existing text file with new content. Use as a last resort \u2014 prefer edit_file or replace_lines first.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
-          content: { type: "string", description: "Full replacement file content." },
-          expected_sha256: { type: "string", description: "SHA256 hash from read_file. Rejects the write if the file changed." },
-          create_backup: { type: "boolean", description: "Whether to save a backup copy under .history before writing.", default: false },
-          respect_gitignore: { type: "boolean", description: "Whether to refuse editing paths ignored by .gitignore.", default: true }
-        },
-        required: ["path", "content"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "edit_file",
-      description: "Apply a search-and-replace edit to an existing text file. The primary file editing tool \u2014 use this first.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
-          old_string: { type: "string", description: "Exact text to replace. Must match uniquely unless replace_all is true." },
-          new_string: { type: "string", description: "Replacement text." },
-          expected_sha256: { type: "string", description: "SHA256 hash from read_file. Rejects the edit if the file changed." },
-          replace_all: { type: "boolean", description: "Whether to replace every occurrence of old_string.", default: false },
-          create_backup: { type: "boolean", description: "Whether to save a backup copy under .history before writing.", default: false },
-          respect_gitignore: { type: "boolean", description: "Whether to refuse editing paths ignored by .gitignore.", default: true }
-        },
-        required: ["path", "old_string", "new_string"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "replace_lines",
-      description: "Replace a range of lines in an existing text file by line number. Read the file with read_file first to see line numbers.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Relative or absolute path to the file within the workspace." },
-          start_line: { type: "integer", description: "First line to replace (1-based)." },
-          end_line: { type: "integer", description: "Last line to replace (inclusive, 1-based)." },
-          content: { type: "string", description: "Replacement content for the specified line range." },
-          expected_sha256: { type: "string", description: "SHA256 hash from read_file. Rejects the edit if the file changed." },
-          create_backup: { type: "boolean", description: "Whether to save a backup copy under .history before writing.", default: false },
-          respect_gitignore: { type: "boolean", description: "Whether to refuse editing paths ignored by .gitignore.", default: true }
-        },
-        required: ["path", "start_line", "end_line", "content"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "glob",
-      description: "Find files by glob pattern under a directory. Relative paths are resolved against the workspace root.",
-      parameters: {
-        type: "object",
-        properties: {
-          glob_pattern: { type: "string", description: "Glob pattern such as **/*.tsx or src/**/*.rs." },
-          target_directory: { type: "string", description: "Directory to search from. Defaults to the workspace root." },
-          head_limit: { type: "integer", description: "Maximum number of matching paths to return.", default: 100 },
-          respect_gitignore: { type: "boolean", description: "Whether to skip paths ignored by .gitignore.", default: true }
-        },
-        required: ["glob_pattern"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "grep",
-      description: "Search file contents with a regex pattern. Relative paths are resolved against the workspace root.",
-      parameters: {
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "Regular expression pattern to search for." },
-          path: { type: "string", description: "File or directory to search. Defaults to the workspace root." },
-          glob: { type: "string", description: "Optional glob filter to limit searched files." },
-          output_mode: { type: "string", enum: ["content", "files_with_matches", "count"], default: "content" },
-          case_insensitive: { type: "boolean", description: "Whether to ignore letter case while matching.", default: false },
-          context_before: { type: "integer", description: "Number of lines to include before each match." },
-          context_after: { type: "integer", description: "Number of lines to include after each match." },
-          context: { type: "integer", description: "Number of lines to include before and after each match." },
-          head_limit: { type: "integer", description: "Maximum number of results to return.", default: 200 },
-          offset: { type: "integer", description: "Number of results to skip in content mode.", default: 0 },
-          multiline: { type: "boolean", description: "Whether . should match newlines.", default: false },
-          respect_gitignore: { type: "boolean", description: "Whether to skip paths ignored by .gitignore.", default: true }
-        },
-        required: ["pattern"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "shell",
-      description: "Execute a shell command in the workspace. Use for builds, tests, git, and other CLI tasks.",
-      parameters: {
-        type: "object",
-        properties: {
-          command: { type: "string", description: "The shell command to execute." },
-          description: { type: "string", description: "Short human-readable description for display only." },
-          working_directory: { type: "string", description: "Directory to run the command in, relative to workspace root." },
-          block_until_ms: { type: "integer", description: "Max wait time in ms. Default 30000. Use 0 for background mode.", default: 3e4 }
-        },
-        required: ["command"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "await",
-      description: "Poll a background shell started with shell(block_until_ms=0) until it completes or times out.",
-      parameters: {
-        type: "object",
-        properties: {
-          shell_id: { type: "string", description: "The shell_id returned from a background shell invocation." },
-          block_until_ms: { type: "integer", description: "Max wait time in ms before returning current output.", default: 3e4 }
-        },
-        required: ["shell_id"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "list_shells",
-      description: "List background shell processes started by the agent.",
-      parameters: {
-        type: "object",
-        properties: {
-          status_filter: { type: "string", description: 'Filter by status. Default "running". Use "all" to include completed and failed shells.' }
-        },
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "kill_shell",
-      description: "Kill a running background shell process by shell_id.",
-      parameters: {
-        type: "object",
-        properties: {
-          shell_id: { type: "string", description: "The shell_id to terminate." }
-        },
-        required: ["shell_id"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "read_shell_logs",
-      description: "Read logs from a shell process in batches.",
-      parameters: {
-        type: "object",
-        properties: {
-          shell_id: { type: "string", description: "The shell_id to read logs from." },
-          stream: { type: "string", enum: ["stdout", "stderr"], default: "stdout" },
-          offset: { type: "integer", description: "Byte offset to start reading from.", default: 0 },
-          limit: { type: "integer", description: "Maximum bytes to return.", default: 4096 }
-        },
-        required: ["shell_id"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "web_search",
-      description: "Search the web for real-time information outside training data.",
-      parameters: {
-        type: "object",
-        properties: {
-          search_term: { type: "string", description: "The search term to look up on the web." },
-          max_results: { type: "integer", description: "Maximum number of search results to return.", default: 5 },
-          explanation: { type: "string", description: "One sentence explanation of why this search is being used." }
-        },
-        required: ["search_term"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "browse_page",
-      description: "Fetch a public web page and return readable Markdown content.",
-      parameters: {
-        type: "object",
-        properties: {
-          url: { type: "string", description: "The URL to fetch. Must be http or https." },
-          max_lines: { type: "integer", description: "Maximum number of lines to return.", default: 500 },
-          start_line: { type: "integer", description: "First line to read (1-based).", default: 1 },
-          explanation: { type: "string", description: "One sentence explanation of why this page is being fetched." }
-        },
-        required: ["url"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "todo_read",
-      description: "Read the current structured todo list for the session.",
-      parameters: {
-        type: "object",
-        properties: {
-          session_id: { type: "string", description: "Optional session ID." }
-        },
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "todo_write",
-      description: "Create and update a structured todo list for the session.",
-      parameters: {
-        type: "object",
-        properties: {
-          todos: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                id: { type: "string" },
-                content: { type: "string" },
-                status: { type: "string", enum: ["pending", "in_progress", "completed", "cancelled"] }
-              },
-              required: ["id", "content", "status"]
-            }
-          },
-          session_id: { type: "string", description: "Optional session ID." }
-        },
-        required: ["todos"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "get_workspace_tree",
-      description: "Display the workspace directory tree structure with depth recursion.",
-      parameters: {
-        type: "object",
-        properties: {
-          max_lines: { type: "integer", description: "Maximum number of lines to return.", default: 500 },
-          start_line: { type: "integer", description: "First line to return (1-based).", default: 1 }
-        },
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "spawn_subagent",
-      description: "Spawn a sub-agent to complete an independent sub-task.",
-      parameters: {
-        type: "object",
-        properties: {
-          task: { type: "string", description: "The task description for the sub-agent." },
-          context: { type: "string", description: "Optional additional context or constraints." },
-          tools: { type: "array", items: { type: "string" }, description: "Optional whitelist of tool names." }
-        },
-        required: ["task"],
-        additionalProperties: false
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "ask_question",
-      description: "Ask the user a question when you need additional information to proceed.",
-      parameters: {
-        type: "object",
-        properties: {
-          question: { type: "string", description: "The question to ask the user." }
-        },
-        required: ["question"],
-        additionalProperties: false
-      }
-    }
-  }
-];
-var HANDLER_MAP = {
-  list_dir: listDirHandler,
-  read_file: readFileHandler,
-  write_file: writeFileHandler,
-  replace_file: replaceFileHandler,
-  edit_file: editFileHandler,
-  replace_lines: replaceLinesHandler,
-  glob: globHandler,
-  grep: grepHandler,
-  shell: shellHandler,
-  await: awaitShellHandler,
-  list_shells: listShellsHandler,
-  kill_shell: killShellHandler,
-  read_shell_logs: readShellLogsHandler,
-  web_search: webSearchHandler,
-  browse_page: browsePageHandler,
-  todo_read: todoReadHandler,
-  todo_write: todoWriteHandler,
-  get_workspace_tree: getWorkspaceTreeHandler,
-  spawn_subagent: spawnSubAgentHandler,
-  ask_question: askQuestionHandler
-};
-var ASK_QUESTION_TOOL_NAME = "ask_question";
-var AGENT_MODE_EXCLUDED_TOOL_NAMES = /* @__PURE__ */ new Set([
-  ASK_QUESTION_TOOL_NAME
-]);
-var ASK_MODE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "list_dir",
-  "read_file",
-  "glob",
-  "grep",
-  "web_search",
-  "browse_page",
-  "todo_read",
-  "list_shells",
-  "read_shell_logs",
-  "get_workspace_tree"
-]);
-function getToolDefinitions(agentMode) {
-  if (agentMode === "ask") {
-    return AGENT_TOOL_DEFINITIONS.filter(
-      (t) => ASK_MODE_TOOL_NAMES.has(t.function.name)
-    );
-  }
-  return AGENT_TOOL_DEFINITIONS.filter(
-    (t) => !AGENT_MODE_EXCLUDED_TOOL_NAMES.has(t.function.name)
-  );
-}
-function getToolHandler(name) {
-  return HANDLER_MAP[name];
-}
-async function executeToolCall(name, rawArguments, context) {
-  const handler = getToolHandler(name);
-  if (!handler) {
-    return {
-      ok: false,
-      tool: name,
-      error: {
-        code: "unknown_tool",
-        message: `Unknown tool: ${name}`
-      }
-    };
-  }
-  let parsedArgs;
-  try {
-    parsedArgs = rawArguments.trim() ? JSON.parse(rawArguments) : {};
-  } catch {
-    return {
-      ok: false,
-      tool: name,
-      error: {
-        code: "invalid_arguments",
-        message: "Tool arguments must be valid JSON"
-      }
-    };
-  }
-  return handler(parsedArgs, context);
-}
-
-// src/agent/thinking-config.ts
-function resolveThinkingParams(provider, thinkingEnabled, override) {
-  if (override) {
-    return thinkingEnabled ? override.enabled : override.disabled;
-  }
-  const preset = THINKING_PRESETS[provider];
-  if (!preset) return void 0;
-  return thinkingEnabled ? preset.enabled : preset.disabled;
-}
-var THINKING_PRESETS = {
-  deepseek: {
-    // @see https://api-docs.deepseek.com/guides/thinking_mode
-    enabled: {
-      thinking: { type: "enabled" },
-      reasoning_effort: "high"
-    },
-    disabled: { thinking: { type: "disabled" } }
-  },
-  glm: {
-    enabled: { thinking: { type: "enabled" } },
-    disabled: { thinking: { type: "disabled" } }
-  },
-  agnes: {
-    enabled: { chat_template_kwargs: { enable_thinking: true } },
-    disabled: {}
-  },
-  nvidia: {
-    enabled: { chat_template_kwargs: { enable_thinking: true } },
-    disabled: { chat_template_kwargs: { enable_thinking: false } }
-  },
-  minimax: {
-    enabled: {
-      thinking: { type: "adaptive" },
-      reasoning_split: true
-    },
-    disabled: { thinking: { type: "disabled" } }
-  }
-};
-
-// src/agent/llm-stream.ts
-function chatCompletionsUrl(baseUrl) {
-  const trimmed = baseUrl.trim().replace(/\/+$/, "");
-  if (trimmed.endsWith("/v1")) {
-    return `${trimmed}/chat/completions`;
-  }
-  return `${trimmed}/v1/chat/completions`;
-}
-async function startLLMStream(options, callbacks) {
-  const url = chatCompletionsUrl(options.baseUrl);
-  const body = {
-    model: options.model,
-    messages: options.messages.map(formatMessage),
-    stream: true,
-    stream_options: { include_usage: true }
-  };
-  if (options.tools && options.tools.length > 0) {
-    body.tools = options.tools;
-    body.tool_choice = "auto";
-  }
-  if (options.thinkingEnabled !== void 0 && options.thinkingProvider) {
-    const thinkingParams = resolveThinkingParams(
-      options.thinkingProvider,
-      options.thinkingEnabled,
-      options.thinkingOverride
-    );
-    if (thinkingParams) {
-      Object.assign(body, thinkingParams);
-    }
-  }
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${options.apiKey}`,
-        "Content-Type": "application/json",
-        Accept: "text/event-stream"
-      },
-      body: JSON.stringify(body),
-      signal: options.signal
-    });
-    if (!response.ok) {
-      const errorBody = await response.text().catch(() => "");
-      throw new Error(`API error (${response.status}): ${errorBody || response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is empty");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const toolCallAccumulator = new ToolCallAccumulator({
-      onIdentified: (id, name) => {
-      }
-    });
-    let hasToolCalls = false;
-    const onAbort = () => {
-      reader.cancel().catch(() => {
-      });
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    while (true) {
-      if (options.signal?.aborted) {
-        break;
-      }
-      let chunk;
-      try {
-        chunk = await reader.read();
-      } catch {
-        break;
-      }
-      const { done, value } = chunk;
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      while (true) {
-        const lineBreak = buffer.indexOf("\n");
-        if (lineBreak === -1) break;
-        const line = buffer.slice(0, lineBreak).trim();
-        buffer = buffer.slice(lineBreak + 1);
-        processLine(line, callbacks, toolCallAccumulator);
-      }
-    }
-    if (buffer.trim()) {
-      processLine(buffer.trim(), callbacks, toolCallAccumulator);
-    }
-    const finalToolCalls = toolCallAccumulator.finalize();
-    for (const call of finalToolCalls) {
-      callbacks.onToolCall(call.id, call.name, call.arguments);
-    }
-    callbacks.onDone();
-  } catch (error2) {
-    if (error2 instanceof Error) {
-      callbacks.onError(error2);
-    } else {
-      callbacks.onError(new Error(String(error2)));
-    }
-  }
-}
-function processLine(line, callbacks, toolCalls) {
-  if (!line || line.startsWith(":")) return;
-  const payload = line.startsWith("data:") ? line.slice(5).trim() : line;
-  if (payload === "[DONE]") return;
-  let parsed;
-  try {
-    parsed = JSON.parse(payload);
-  } catch {
-    return;
-  }
-  const choices = parsed.choices;
-  const choice = choices?.[0];
-  const delta = choice?.delta;
-  if (delta) {
-    if (delta.reasoning_content) {
-      callbacks.onReasoning(delta.reasoning_content);
-    }
-    if (delta.content) {
-      callbacks.onContent(delta.content);
-    }
-    const toolCallDeltas = delta.tool_calls;
-    if (toolCallDeltas) {
-      for (const tcDelta of toolCallDeltas) {
-        const index = tcDelta.index;
-        const fn = tcDelta.function;
-        const id = tcDelta.id;
-        if (id) {
-          toolCalls.startToolCall(index, id, fn?.name);
-        } else if (fn?.arguments) {
-          toolCalls.appendArguments(index, fn.arguments);
-        }
-      }
-    }
-  }
-  const usage = parsed.usage;
-  if (usage?.prompt_tokens !== void 0) {
-    callbacks.onUsage({
-      promptTokens: usage.prompt_tokens,
-      completionTokens: usage.completion_tokens,
-      totalTokens: usage.total_tokens
-    });
-  }
-}
-var ToolCallAccumulator = class {
-  pending = /* @__PURE__ */ new Map();
-  finalized = false;
-  onIdentified;
-  constructor(opts) {
-    this.onIdentified = opts.onIdentified;
-  }
-  startToolCall(index, id, name) {
-    this.pending.set(index, { index, id, name, arguments: "" });
-  }
-  appendArguments(index, args) {
-    const existing = this.pending.get(index);
-    if (existing) {
-      existing.arguments += args;
-    }
-  }
-  finalize() {
-    if (this.finalized) return [];
-    this.finalized = true;
-    const calls = Array.from(this.pending.values()).sort((a, b) => a.index - b.index).map((c) => ({
-      id: c.id,
-      name: c.name,
-      arguments: c.arguments
-    }));
-    return calls;
-  }
-};
-function formatMessage(msg) {
-  const formatted = {
-    role: msg.role
-  };
-  if (msg.content !== void 0) {
-    formatted.content = msg.content;
-  }
-  if (msg.reasoning_content) {
-    formatted.reasoning_content = msg.reasoning_content;
-  }
-  if (msg.tool_calls) {
-    formatted.tool_calls = msg.tool_calls;
-  }
-  if (msg.tool_call_id) {
-    formatted.tool_call_id = msg.tool_call_id;
-  }
-  if (msg.name) {
-    formatted.name = msg.name;
-  }
-  return formatted;
-}
-
-// src/agent/runner.ts
-async function runAgentWithTools(input, toolContext, onEvent) {
-  let messages = [...input.messages];
-  let cumulativeUsage;
-  while (true) {
-    if (input.signal?.aborted) {
-      killShellsByTask(input.taskId);
-      onEvent({ type: "status", taskId: input.taskId, status: "cancelled" });
-      onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage });
-      return messages;
-    }
-    let turn;
-    try {
-      turn = await runSingleAgentTurn(input, messages, onEvent);
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        killShellsByTask(input.taskId);
-        onEvent({ type: "status", taskId: input.taskId, status: "cancelled" });
-        onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage });
-        return messages;
-      }
-      throw err;
-    }
-    if (turn.usage) {
-      cumulativeUsage = cumulativeUsage ? {
-        promptTokens: cumulativeUsage.promptTokens + turn.usage.promptTokens,
-        completionTokens: cumulativeUsage.completionTokens + turn.usage.completionTokens,
-        totalTokens: cumulativeUsage.totalTokens + turn.usage.totalTokens
-      } : turn.usage;
-    }
-    if (turn.toolCalls.length === 0) {
-      if (turn.content || turn.reasoningContent) {
-        const assistantMessage = { role: "assistant" };
-        if (turn.content.trim()) {
-          assistantMessage.content = turn.content;
-        }
-        if (turn.reasoningContent.trim()) {
-          assistantMessage.reasoning_content = turn.reasoningContent;
-        }
-        messages = [...messages, assistantMessage];
-      }
-      onEvent({ type: "done", taskId: input.taskId, usage: cumulativeUsage ?? turn.usage });
-      onEvent({ type: "status", taskId: input.taskId, status: "completed" });
-      return messages;
-    }
-    messages = await appendToolResults(messages, turn, toolContext, onEvent);
-  }
-}
-async function runSingleAgentTurn(input, messages, onEvent) {
-  return new Promise((resolve12, reject) => {
-    let content = "";
-    let reasoningContent = "";
-    const toolCalls = [];
-    let turnUsage;
-    startLLMStream(
-      {
-        baseUrl: input.baseUrl,
-        apiKey: input.apiKey,
-        model: input.model,
-        messages,
-        tools: getToolDefinitions(input.agentMode),
-        thinkingProvider: input.provider,
-        thinkingEnabled: input.thinkingEnabled,
-        thinkingOverride: input.thinkingParams,
-        signal: input.signal
-      },
-      {
-        onContent: (delta) => {
-          content += delta;
-          onEvent({ type: "content_delta", taskId: input.taskId, delta });
-        },
-        onReasoning: (delta) => {
-          reasoningContent += delta;
-          onEvent({ type: "thinking_delta", taskId: input.taskId, delta });
-        },
-        onToolCall: (id, name, args) => {
-          toolCalls.push({ id, name, arguments: args });
-          onEvent({ type: "tool_call_pending", taskId: input.taskId, toolCallId: id, name });
-        },
-        onUsage: (usage) => {
-          turnUsage = usage;
-        },
-        onDone: () => {
-          if (toolCalls.length > 0) {
-            for (const call of toolCalls) {
-              let parsedInput;
-              try {
-                parsedInput = call.arguments.trim() ? JSON.parse(call.arguments) : {};
-              } catch {
-                parsedInput = {};
-              }
-              onEvent({
-                type: "tool_call_started",
-                taskId: input.taskId,
-                toolCallId: call.id,
-                name: call.name,
-                input: parsedInput
-              });
-            }
-          }
-          resolve12({ toolCalls, content, reasoningContent, usage: turnUsage });
-        },
-        onError: (error2) => {
-          reject(error2);
-        }
-      }
-    );
-  });
-}
-async function appendToolResults(messages, turn, context, onEvent) {
-  const assistantMessage = {
-    role: "assistant",
-    content: turn.content || void 0,
-    reasoning_content: turn.reasoningContent || void 0,
-    tool_calls: turn.toolCalls.map((tc) => ({
-      id: tc.id,
-      type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
-    }))
-  };
-  const nextMessages = [...messages, assistantMessage];
-  const results = await Promise.all(
-    turn.toolCalls.map(async (call) => {
-      try {
-        const result = await executeToolCall(call.name, call.arguments, context);
-        if (result.ok) {
-          onEvent({
-            type: "tool_call_finished",
-            taskId: context.taskId ?? "",
-            toolCallId: call.id,
-            output: result.data
-          });
-        } else {
-          onEvent({
-            type: "tool_call_finished",
-            taskId: context.taskId ?? "",
-            toolCallId: call.id,
-            errorText: result.error?.message
-          });
-        }
-        return { id: call.id, result };
-      } catch (error2) {
-        const errorText = error2 instanceof Error ? error2.message : String(error2);
-        onEvent({
-          type: "tool_call_finished",
-          taskId: context.taskId ?? "",
-          toolCallId: call.id,
-          errorText
-        });
-        return {
-          id: call.id,
-          result: {
-            ok: false,
-            tool: call.name,
-            error: { code: "execution_error", message: errorText }
-          }
-        };
-      }
-    })
-  );
-  for (const { id, result } of results) {
-    const content = result.ok ? JSON.stringify(result.data, null, 2) : JSON.stringify({ error: result.error }, null, 2);
-    nextMessages.push({
-      role: "tool",
-      tool_call_id: id,
-      content
-    });
-  }
-  return nextMessages;
-}
-
-// src/agent/environment/index.ts
-var import_node_os2 = require("node:os");
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs12 = require("node:fs");
-var import_node_path13 = require("node:path");
-
-// ../src/features/skills/system/registry.ts
-var OPERATING_PRINCIPLES_CONTENT = `# Agent Operating Principles
-
-Your job is to understand the user's intent, make correct changes, verify the result, and communicate accurately.
-
-### Core rules
-
-- Follow the user's request. Do not expand scope without a clear reason.
-- When the request has multiple valid interpretations, state your assumption
-  explicitly and proceed. Only ask when the decision is costly to reverse.
-- Prefer evidence over confidence. Tool output is more reliable than assumptions.
-- Never present guesses as facts. Mark uncertainty plainly when evidence is incomplete.
-- Optimize for user-visible outcomes, not internal activity.
-- Keep changes correct, readable, maintainable, testable, and secure.
-- Do not push commits, rewrite history, or perform destructive actions unless explicitly instructed.
-
-### Decision order
-
-0. Determine whether this is a question, an exploration, or a change request.
-   Answer questions directly; act only on clear instructions.
-1. Understand the request.
-2. Gather only the context needed to act safely.
-3. Plan when the work has meaningful phases.
-4. Modify the smallest surface that solves the problem.
-5. Verify before claiming success.
-6. Report the outcome, verification, and any remaining risk.
-`;
-var CONTEXT_AND_EVIDENCE_CONTENT = `# Context and Evidence
-
-Treat provided context as useful signal, not guaranteed truth.
-
-Do not assume:
-
-- file contents
-- repository structure
-- command output
-- test results
-- git state
-- API behavior
-- web content
-
-Use tools to confirm facts whenever the answer or change depends on them.
-
-### Evidence handling
-
-- Read the relevant file before editing it.
-- Use search results to decide what to inspect, not as a substitute for inspection.
-- Treat shell output, linter output, test output, and git output as source-of-truth for the current workspace state.
-- If evidence contradicts your expectation, update your understanding immediately.
-- If required evidence is unavailable, say what is missing and avoid pretending the task is fully verified.
-`;
-var TOOL_USAGE_CONTENT = `# Tool Usage
-
-Use tools when they provide evidence that would otherwise be guessed.
-
-### Local tools
-
-- Use glob to find files by name pattern.
-- Use grep to search file contents by unique strings, symbols, paths, routes, config keys, or errors.
-- Use shell for builds, tests, git operations, package commands, and repository inspection.
-- Commands run non-interactively. Avoid commands that require interactive input.
-- For long-running commands such as dev servers or watch mode, run shell with \`block_until_ms=0\`, then await the returned \`shell_id\` when needed.
-- Use \`get_workspace_tree\` for a bird's-eye view of the project structure. It respects \`.gitignore\`, excludes large directories (\`node_modules\`, \`.git\`, \`dist\`, etc.) automatically, and paginates like \`read_file\` via \`start_line\` and \`max_lines\`. Prefer this over manually calling \`list_dir\` on every subdirectory.
-- **File editing workflow:** \`edit_file\` (search-and-replace, text-anchored) is the most common file editing tool \u2014 highest priority. If escaping issues arise, fall back to \`replace_lines\` (by line number, read the file again first to avoid line number drift). Last resort: \`replace_file\` (supports both partial and full replacement, but full replacement consumes many tokens \u2014 use sparingly). Use \`write_file\` to create new files. Use \`read_file\`'s \`sha256\` as \`expected_sha256\` for concurrent safety.
-
-### Web and skills
-
-- Use web_search for current or external information, such as version-specific behavior or recent documentation.
-- Use browse_page to read a specific URL after web_search finds a promising primary source.
-- browse_page may not render JavaScript-heavy pages. Quote retrieved content instead of inventing details.
-- Use list_skills to inspect available skills.
-- Use read_skill before following a skill's instructions.
-- Use create_skill only when the user asks to save reusable instructions.
-
-### Failure handling
-
-When a tool fails:
-
-1. Read the error code and message.
-2. Form a new hypothesis.
-3. Adjust the approach.
-
-Do not repeat the same failing action without learning from the failure.
-
-### Shell tools
-
-You have 5 shell tools. Use them together:
-
-- **shell** \u2014 run a command. Set \`block_until_ms=0\` for background mode; returns a \`shell_id\`.
-- **await** \u2014 poll a background shell to completion. Pass the \`shell_id\` from shell.
-- **list_shells** \u2014 list active shells. Default shows running only; use \`status_filter="all"\` to see all states.
-- **read_shell_logs** \u2014 read stdout/stderr from any shell. Paginate with \`offset\` and \`limit\`.
-- **kill_shell** \u2014 kill a running shell by \`shell_id\`. Cannot kill human terminals.
-
-Workflows:
-1. **background + await**: \`shell(cmd, {block_until_ms: 0})\` \u2192 do other work \u2192 \`await({shell_id})\`
-2. **monitor progress**: \`shell(background)\` \u2192 \`read_shell_logs\` to peek \u2192 \`await\` when done
-3. **clean up**: \`list_shells({status_filter: "all"})\` \u2192 \`read_shell_logs\` \u2192 \`kill_shell\` if stuck
-
-**Remote target limitation:** When using \`shell(target: "<alias>")\`, background mode does NOT return a usable \`shell_id\`, so companion tools (\`await\`, \`list_shells\`, \`kill_shell\`, \`read_shell_logs\`) are not supported. Only blocking mode works for remote commands.
-
-### spawn_subagent
-
-Use spawn_subagent for independent tasks that require multi-step exploration, verification, or research.
-
-Do not use it for simple lookups, single-file reads, or tasks that can be completed with a few direct tool calls.
-
-Before spawning, ask:
-1. Is the task independent?
-2. Does it require significant exploration?
-3. Would delegation improve focus?
-
-If not, do the work yourself.
-
-Provide a clear task description and expected output. Sub-agents should return findings, evidence, and uncertainties.
-`;
-var CODE_NAVIGATION_CONTENT = `# Code Navigation
-
-Prefer direct signals over dependency wandering.
-
-### Default flow
-
-\`\`\`text
-search -> inspect -> modify
-\`\`\`
-
-Avoid manually tracing long chains from entry point to imports unless direct search is insufficient.
-
-### Search signals
-
-Search for the most unique signal the target code would contain:
-
-- function or method names: \`calculateTotal\`, \`handleSubmit\`
-- constants or variables: \`MAX_RETRY_COUNT\`, \`workspaceName\`
-- route strings: \`"/api/users"\`, \`"/login"\`
-- framework annotations: \`@RestController\`, \`@Service\`
-- trait, interface, or class names: \`UserRepository\`, \`impl Iterator\`
-- test descriptions: \`"should return 401"\`, \`testShould\`
-- config keys: \`database.url\`, \`logging.level\`
-- model, table, or schema names: \`users\`, \`class User\`
-- exact error messages from logs, tests, or users
-
-### Reading discipline
-
-- Read only files needed to understand or modify the target behavior.
-- Prefer narrow reads around relevant code when files are large.
-- Expand outward only when the local context is insufficient.
-`;
-var TASK_PLANNING_CONTENT = `# Task Planning
-
-Use the task-progress list to make meaningful multi-step work legible.
-
-### Create a task list when
-
-- implementing a feature across exploration, edits, and verification
-- debugging with multiple hypotheses
-- refactoring or migrating several files or layers
-- finishing work with clear phases such as design, implement, test, polish
-- running long work where the user may return later
-
-### Skip a task list for
-
-- short answers or explanations
-- one-command requests
-- a single obvious edit
-- pure exploration questions
-- trivial follow-ups
-
-When unsure, prefer no list over a noisy one.
-
-### Task design
-
-- Write outcome-oriented tasks: "Add OAuth callback validation", not "Read auth file".
-- Keep tasks coarse enough for the user to follow, usually 3-5 items.
-- Keep at most one task in progress.
-- Mark tasks complete as soon as they are actually complete.
-- Rename, add, cancel, or remove tasks when scope changes.
-`;
-var CODE_MODIFICATION_CONTENT = `# Code Modification
-
-Make changes as a maintainer, not as a patch generator.
-
-### Before editing
-
-1. Locate the relevant implementation.
-2. Understand surrounding context.
-3. Identify the smallest change that solves the requested problem.
-
-### Editing rules
-
-- Prefer minimal, targeted changes.
-- Follow existing naming, architecture, formatting, testing, and error-handling patterns.
-- Do not rewrite working code unnecessarily.
-- Do not change unrelated behavior.
-- Do not introduce style-only edits unless requested.
-- Do not remove functionality without a clear reason.
-- Do not overwrite user changes. If the working tree is dirty, work with existing changes instead of reverting them.
-- Use structured APIs or parsers for structured data when available.
-
-### High-risk areas
-
-Be extra careful with authentication, authorization, persistence, migrations, production configuration, secrets, and destructive operations.
-`;
-var VERIFICATION_CONTENT = `# Verification
-
-Do not claim success solely because code was changed.
-
-### After changing code
-
-1. Re-read the changed area when practical.
-2. Review the diff to confirm only intended changes are included.
-3. Before running any verification command, call list_shells first to check whether the user already has a running dev server or relevant process. If one exists, prefer telling the user to reload over starting a new instance. Only run a new verification command when no relevant process is already running.
-4. Run the most relevant verification available.
-5. Report what was verified and what was not.
-
-### Prefer relevant checks
-
-- TypeScript: \`tsc --noEmit\`, framework type checks, or project scripts.
-- Tests: focused tests first, broader suites when risk is high.
-- Builds: run when the change can affect packaging, routing, generated output, or runtime wiring.
-- Linters: run or inspect diagnostics for changed files.
-
-If verification fails, read the error, fix what is in scope, and rerun the relevant check. If verification cannot be run, state that clearly.
-`;
-var GIT_WORKFLOW_CONTENT = `# Git Workflow
-
-Git operations must reflect actual repository state.
-
-### Before committing
-
-- Review \`git status\`.
-- Review \`git diff\` and \`git diff --staged\` as appropriate.
-- Do not assume staged content matches the current task.
-- Do not commit secrets or credentials.
-
-### Staging
-
-- Stage only files related to the intended change.
-- Avoid \`git add .\` and \`git add -A\` unless the user explicitly wants all changes included.
-- Leave unrelated modifications unstaged.
-
-### Commits
-
-- Generate commit messages from staged changes only.
-- Use Conventional Commits: \`type(scope): summary\`.
-- Keep the subject under 72 characters.
-- Keep commits logically coherent.
-
-### Push behavior
-
-- "commit" means commit only.
-- "push" means push only.
-- "commit and push" means both.
-- Never push unless explicitly instructed.
-`;
-var COMMUNICATION_CONTENT = `# Communication
-
-Communicate conclusions, decisions, blockers, and verification results.
-
-### Style
-
-- Be concise and direct.
-- Do not narrate every tool call.
-- Do not reveal hidden chain-of-thought.
-- Do not frame internal activity as an accomplishment.
-- Explain uncertainty and blockers honestly.
-- When reporting completion, include the user-visible result and verification performed.
-
-### Reviews
-
-When the user asks for a review, prioritize findings first:
-
-- correctness bugs
-- security risks
-- behavioral regressions
-- missing tests for meaningful risk
-
-Order findings by severity. If no issues are found, say so and mention residual risk or unrun checks.
-`;
-var CODE_REVIEW_CONTENT = `# Code Review Workflow
-
-Use this workflow when reviewing code rather than implementing changes.
-
-### Review focus
-
-1. Correctness and edge cases.
-2. Security issues such as injection, XSS, authorization gaps, and leaked secrets.
-3. Behavioral regressions.
-4. Error handling and failure modes.
-5. Test coverage for meaningful behavior.
-6. Readability and maintainability when it affects future correctness.
-
-### Feedback format
-
-- Lead with findings, ordered by severity.
-- Cite the specific file or symbol involved.
-- Explain the impact, not just the preference.
-- Keep summaries brief and secondary.
-- If there are no findings, say that clearly and list any verification gaps.
-`;
-var SYSTEM_SKILLS = [
-  {
-    id: "agent-operating-principles",
-    slug: "agent-operating-principles",
-    name: "Agent Operating Principles",
-    description: "Core identity, priorities, and decision order for software engineering agent work.",
-    content: OPERATING_PRINCIPLES_CONTENT,
-    defaultEnabled: true,
-    category: "core"
-  },
-  {
-    id: "context-and-evidence",
-    slug: "context-and-evidence",
-    name: "Context and Evidence",
-    description: "How to treat workspace context, tool output, uncertainty, and evidence before acting.",
-    content: CONTEXT_AND_EVIDENCE_CONTENT,
-    defaultEnabled: true,
-    category: "core"
-  },
-  {
-    id: "tool-usage",
-    slug: "tool-usage",
-    name: "Tool Usage",
-    description: "When and how to use filesystem, shell, web, and skill tools for reliable evidence.",
-    content: TOOL_USAGE_CONTENT,
-    defaultEnabled: true,
-    category: "core"
-  },
-  {
-    id: "code-navigation",
-    slug: "code-navigation",
-    name: "Code Navigation",
-    description: "Search-first navigation rules for locating relevant code without wasting context.",
-    content: CODE_NAVIGATION_CONTENT,
-    defaultEnabled: true,
-    category: "development"
-  },
-  {
-    id: "task-planning",
-    slug: "task-planning",
-    name: "Task Planning",
-    description: "When and how to use the session task-progress list for multi-step work.",
-    content: TASK_PLANNING_CONTENT,
-    defaultEnabled: true,
-    category: "workflow"
-  },
-  {
-    id: "code-modification",
-    slug: "code-modification",
-    name: "Code Modification",
-    description: "Rules for making minimal, maintainable, and project-consistent code changes.",
-    content: CODE_MODIFICATION_CONTENT,
-    defaultEnabled: true,
-    category: "development"
-  },
-  {
-    id: "verification",
-    slug: "verification",
-    name: "Verification",
-    description: "How to validate changes before claiming success and how to report unverified work.",
-    content: VERIFICATION_CONTENT,
-    defaultEnabled: true,
-    category: "workflow"
-  },
-  {
-    id: "git-workflow",
-    slug: "git-workflow",
-    name: "Git Workflow",
-    description: "Safe staging, commit, and push boundaries based on actual git state.",
-    content: GIT_WORKFLOW_CONTENT,
-    defaultEnabled: true,
-    category: "workflow"
-  },
-  {
-    id: "communication",
-    slug: "communication",
-    name: "Communication",
-    description: "How to communicate outcomes, uncertainty, blockers, verification, and review findings.",
-    content: COMMUNICATION_CONTENT,
-    defaultEnabled: true,
-    category: "core"
-  },
-  {
-    id: "code-review",
-    slug: "code-review",
-    name: "Code Review Workflow",
-    description: "Specialized workflow for reviewing code for correctness, security, regressions, and tests.",
-    content: CODE_REVIEW_CONTENT,
-    defaultEnabled: false,
-    category: "review"
-  }
-];
-var slugSet = /* @__PURE__ */ new Set();
-for (const skill of SYSTEM_SKILLS) {
-  if (slugSet.has(skill.slug)) {
-    throw new Error(`Duplicate system skill slug: ${skill.slug}`);
-  }
-  slugSet.add(skill.slug);
-}
-
-// src/agent/environment/index.ts
-function resolveAgentEnvironment(workspaceDir) {
-  const os = `${(0, import_node_os2.platform)()} (${(0, import_node_os2.release)()})`;
-  const shell = resolveShell();
-  const isGitRepository = workspaceDir ? checkIsGitRepository(workspaceDir) : false;
-  const today = formatToday(/* @__PURE__ */ new Date());
-  let agentsMd = null;
-  if (workspaceDir) {
-    const agentsMdPath = (0, import_node_path13.resolve)(workspaceDir, "AGENTS.md");
-    if ((0, import_node_fs12.existsSync)(agentsMdPath)) {
-      const content = (0, import_node_fs12.readFileSync)(agentsMdPath, "utf-8");
-      agentsMd = {
-        path: agentsMdPath,
-        content: content.length > 32e3 ? content.slice(0, 32e3) + "\n... [truncated]" : content,
-        truncated: content.length > 32e3
-      };
-    }
-  }
-  const enabledSystemSkills = SYSTEM_SKILLS.filter(
-    (skill) => skill.defaultEnabled
-  ).map((skill) => ({
-    slug: skill.slug,
-    name: skill.name,
-    content: skill.content
-  }));
-  return {
-    workspaceDir,
-    os,
-    shell,
-    isGitRepository,
-    today,
-    agentsMd,
-    enabledSystemSkills
-  };
-}
-function buildSystemPrompt(env, agentMode) {
-  const workspaceLine = env.workspaceDir ?? "not selected";
-  const gitLine = env.isGitRepository ? "yes" : env.workspaceDir ? "no" : "unknown";
-  const modeLine = buildModeLine(agentMode);
-  const modeGuidance = buildModeGuidance(agentMode, env.workspaceDir);
-  const allBlocks = [];
-  allBlocks.push(
-    [
-      "You are Coder, a helpful terminal AI assistant.",
-      "",
-      "## Environment",
-      "",
-      `- workspaceDir: ${workspaceLine}`,
-      `- os: ${env.os}`,
-      `- shell: ${env.shell}`,
-      `- gitRepository: ${gitLine}`,
-      `- date: ${env.today}`,
-      `- mode: ${modeLine}`
-    ].join("\n")
-  );
-  allBlocks.push(
-    [
-      "## Communication Rules",
-      "",
-      "1. Reply in the same language the user uses. Be concise, accurate, and friendly.",
-      "2. Do not act unless the user has clearly asked you to. Answering questions, explaining, and analyzing do not require action \u2014 stop before reaching for tools."
-    ].join("\n")
-  );
-  for (const skill of env.enabledSystemSkills) {
-    allBlocks.push(
-      `## ${skill.name}
-
-${stripLeadingMarkdownH1(skill.content)}`
-    );
-  }
-  if (env.agentsMd?.content.trim()) {
-    allBlocks.push(buildProjectInstructionsSection(env.agentsMd));
-  }
-  if (modeGuidance.length > 0) {
-    allBlocks.push(modeGuidance.join("\n"));
-  }
-  return allBlocks.join("\n\n---\n\n");
-}
-function buildModeLine(agentMode) {
-  switch (agentMode) {
-    case "ask":
-      return "ask (read-only: can read files, search code, browse the web, and list skills \u2014 cannot modify files or run shell commands)";
-    default:
-      return "agent (full tool access)";
-  }
-}
-function buildModeGuidance(agentMode, _workspaceDir) {
-  if (agentMode === "ask") {
-    return buildAskModeGuidance();
-  }
-  return [];
-}
-function buildAskModeGuidance() {
-  return [
-    "## Mode Guidance",
-    "",
-    "You are in Ask mode \u2014 you can only read files, search, and browse.",
-    "When the user asks you to modify files, run commands, or perform any write operation:",
-    "  - Explain that the task requires write access.",
-    "  - Tell the user they can switch to Agent mode by using `coder run` instead of `coder ask` to give you full tool access.",
-    `Do NOT silently refuse or just say "I can't do that." Always provide a clear path forward.`
-  ];
-}
-function buildProjectInstructionsSection(agentsMd) {
-  const lines = [
-    "## Project instructions (AGENTS.md)",
-    "",
-    "Follow these project-specific rules when they do not conflict with the user's current message.",
-    agentsMd.content.trimEnd()
-  ];
-  if (agentsMd.truncated) {
-    lines.push(
-      "",
-      `Note: ${agentsMd.path} was truncated to 32 KB. Use read_file on ${agentsMd.path} to read the full file if needed.`
-    );
-  }
-  return lines.join("\n");
-}
-function stripLeadingMarkdownH1(content) {
-  return content.replace(/^#\s+[^\n]+\n+/, "").trim();
-}
-function formatToday(date) {
-  return new Intl.DateTimeFormat("en-CA", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    weekday: "long",
-    timeZoneName: "longOffset"
-  }).format(date);
-}
-function resolveShell() {
-  const p = (0, import_node_os2.platform)();
-  if (p === "win32") {
-    return process.env.COMSPEC || "cmd.exe";
-  }
-  return process.env.SHELL || "/bin/sh";
-}
-function checkIsGitRepository(dir) {
-  try {
-    (0, import_node_child_process2.execSync)("git rev-parse --is-inside-work-tree", {
-      cwd: dir,
-      stdio: "pipe",
-      timeout: 3e3
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/agent/session.ts
-init_config();
-
-// src/ui/index.ts
-var import_node_tty = require("node:tty");
-var stdoutIsTTY = (0, import_node_tty.isatty)(process.stdout.fd);
-var stderrIsTTY = (0, import_node_tty.isatty)(process.stderr.fd);
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  italic: "\x1B[3m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  gray: "\x1B[90m"
-};
-function colorize(text, color) {
-  if (!stdoutIsTTY) return text;
-  return `${colors[color]}${text}${colors.reset}`;
-}
-function dim(text) {
-  return colorize(text, "dim");
-}
-function bold(text) {
-  if (!stdoutIsTTY) return text;
-  return `${colors.bold}${text}${colors.reset}`;
-}
-function error(text) {
-  return colorize(text, "red");
-}
-function success(text) {
-  return colorize(text, "green");
-}
-function warning(text) {
-  return colorize(text, "yellow");
-}
-function info(text) {
-  return colorize(text, "cyan");
-}
-function writeStream(text) {
-  process.stdout.write(text);
-}
-function writeLine(text) {
-  process.stdout.write(text + "\n");
-}
-function writeError(text) {
-  process.stderr.write(text + "\n");
-}
-
-// src/agent/session.ts
-async function runAgentSession(prompt, options) {
-  const config = loadConfig();
-  const workspaceDir = options.workspaceDir || null;
-  const providerId = options.provider ?? config.activeProvider;
-  const resolvedConfig = resolveProviderConfig(config, providerId);
-  const apiKey = resolveApiKey(resolvedConfig);
-  const modelId = options.model ?? config.lastModel;
-  const modelDef = resolvedConfig.models.find((m) => m.id === modelId);
-  const supportsThinking = modelDef?.supportsThinking === true || config.providers[resolvedConfig.provider]?.supportsThinking === true;
-  const thinkingEnabled = options.thinking !== void 0 && supportsThinking ? options.thinking : void 0;
-  let thinkingParamsOverride;
-  if (thinkingEnabled !== void 0) {
-    const settings = config.providers[resolvedConfig.provider];
-    if (settings?.thinkingEnabledParams && settings?.thinkingDisabledParams) {
-      thinkingParamsOverride = {
-        enabled: settings.thinkingEnabledParams,
-        disabled: settings.thinkingDisabledParams
-      };
-    }
-  }
-  let messages;
-  if (options.existingMessages && options.existingMessages.length > 0) {
-    messages = [
-      ...sanitizeMessages(options.existingMessages),
-      { role: "user", content: prompt }
-    ];
-  } else {
-    const env = resolveAgentEnvironment(workspaceDir);
-    const systemPrompt = buildSystemPrompt(env, options.agentMode);
-    messages = [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: prompt }
-    ];
-  }
-  const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const isStreaming = options.stream !== false;
-  let currentContent = "";
-  let currentThinking = "";
-  let hasContent = false;
-  let streamStarted = false;
-  const toolContext = {
-    workspaceDir,
-    sessionId: taskId,
-    taskId,
-    agentMode: options.agentMode
-  };
-  if (!isStreaming) {
-    writeLine(`${info("\u2139")} Running agent in ${bold(options.agentMode)} mode...
-`);
-  }
-  try {
-    const finalMessages = await runAgentWithTools(
-      {
-        taskId,
-        baseUrl: resolvedConfig.baseUrl,
-        apiKey,
-        apiKeySource: resolvedConfig.apiKeySource,
-        apiKeyEnvVar: resolvedConfig.apiKeyEnvVar,
-        model: modelId,
-        messages,
-        agentMode: options.agentMode,
-        provider: providerId,
-        thinkingEnabled,
-        thinkingParams: thinkingParamsOverride,
-        signal: options.signal
-      },
-      toolContext,
-      (event) => {
-        switch (event.type) {
-          case "thinking_delta": {
-            currentThinking += event.delta;
-            if (isStreaming && !hasContent) {
-              if (!streamStarted) {
-                streamStarted = true;
-                writeLine("");
-              }
-              writeStream(dim(event.delta));
-            }
-            break;
-          }
-          case "content_delta": {
-            if (isStreaming) {
-              if (!streamStarted) {
-                streamStarted = true;
-              }
-              if (!hasContent && currentThinking) {
-                writeLine("");
-              }
-              hasContent = true;
-              currentContent += event.delta;
-              writeStream(event.delta);
-            }
-            break;
-          }
-          case "tool_call_started": {
-            if (isStreaming) {
-              if (!streamStarted) {
-                streamStarted = true;
-                writeLine("");
-              } else if (hasContent || currentThinking) {
-                writeLine("");
-              }
-              writeLine(`${dim("\u{1F527}")} ${bold(event.name)}${dim("...")}`);
-            }
-            break;
-          }
-          case "tool_call_finished": {
-            if (event.errorText) {
-              writeLine(`  ${error("\u2717")} ${dim(event.errorText.slice(0, 200))}`);
-            } else if (isStreaming) {
-              writeLine(`  ${success("\u2713")} ${dim("done")}`);
-            }
-            break;
-          }
-          case "status": {
-            if (event.status === "completed") {
-              if (isStreaming) {
-                writeLine("");
-                writeLine(success("\u2713 Task completed"));
-              } else {
-                writeLine(success("\u2713 Task completed"));
-                if (currentContent) {
-                  writeLine("\n" + currentContent);
-                }
-              }
-            } else if (event.status === "failed") {
-              writeLine(error(`\u2717 Task failed`));
-            } else if (event.status === "cancelled") {
-              writeLine(warning(`\u26A0 Task cancelled`));
-            }
-            break;
-          }
-          case "done": {
-            break;
-          }
-          case "error": {
-            writeLine(error(`\u2717 Error: ${event.message}`));
-            break;
-          }
-        }
-      }
-    );
-    return finalMessages;
-  } catch (err) {
-    killAllShells();
-    const message = err instanceof Error ? err.message : String(err);
-    writeError(error(`Fatal error: ${message}`));
-    process.exit(1);
-  }
-}
-function sanitizeMessages(messages) {
-  return messages.filter((msg) => {
-    if (msg.role !== "assistant") return true;
-    const text = typeof msg.content === "string" ? msg.content : void 0;
-    return Boolean(text?.trim()) || Boolean(msg.reasoning_content?.trim()) || Boolean(msg.tool_calls?.length);
-  });
-}
-
-// src/commands/run.ts
-async function runCommand(prompt, options) {
-  await runAgentSession(prompt, {
-    ...options,
-    agentMode: "agent",
-    workspaceDir: options.workspace ?? process.cwd(),
-    interactive: false
-  });
-}
-
-// src/commands/ask.ts
-async function askCommand(prompt, options) {
-  await runAgentSession(prompt, {
-    ...options,
-    agentMode: "ask",
-    workspaceDir: options.workspace ?? process.cwd(),
-    interactive: false
-  });
-}
-
-// src/commands/repl.ts
-var import_node_readline2 = require("node:readline");
-init_config();
-async function replCommand(options) {
-  const config = loadConfig();
-  const workspaceDir = options.workspace ?? process.cwd();
-  writeLine("");
-  writeLine(bold("Coder CLI \u2014 Interactive REPL"));
-  writeLine(dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  writeLine(dim(`  Model: ${config.lastModel || "not set"}`));
-  writeLine(dim(`  Provider: ${config.activeProvider}`));
-  writeLine(dim(`  Workspace: ${workspaceDir}`));
-  writeLine(dim(`  Type '/help' for commands, '/exit' or Ctrl+C to quit`));
-  writeLine(dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  writeLine("");
-  let conversationMessages;
-  let thinkingEnabled = true;
-  let abortController = new AbortController();
-  let agentRunning = false;
-  const rl = (0, import_node_readline2.createInterface)({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: `${bold("coder")}> `,
-    terminal: true
-  });
-  rl.prompt();
-  rl.on("line", async (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      rl.prompt();
-      return;
-    }
-    if (agentRunning) {
-      rl.prompt();
-      return;
-    }
-    if (trimmed === "/exit" || trimmed === "/quit") {
-      rl.close();
-      return;
-    }
-    if (trimmed === "/clear") {
-      console.clear();
-      rl.prompt();
-      return;
-    }
-    if (trimmed === "/new") {
-      conversationMessages = void 0;
-      abortController = new AbortController();
-      writeLine(info("Started a new session. Context has been cleared."));
-      rl.prompt();
-      return;
-    }
-    if (trimmed === "/help") {
-      writeLine(bold("\nREPL Commands:"));
-      writeLine("  <prompt>             Ask the agent anything");
-      writeLine("  /exit, /quit         Exit REPL");
-      writeLine("  /clear               Clear screen");
-      writeLine("  /new                 Clear context, start a new session");
-      writeLine("  /help                Show this help");
-      writeLine("  /model <id>          Switch model");
-      writeLine(`  /thinking <on|off>   Toggle deep thinking (currently: ${thinkingEnabled ? "on" : "off"})`);
-      writeLine("");
-      rl.prompt();
-      return;
-    }
-    if (trimmed.startsWith("/model ")) {
-      const modelId = trimmed.slice(7).trim();
-      if (modelId) {
-        config.lastModel = modelId;
-        const { saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-        saveConfig2(config);
-        writeLine(info(`Model set to: ${modelId}`));
-      }
-      rl.prompt();
-      return;
-    }
-    if (trimmed.startsWith("/thinking ")) {
-      const value = trimmed.slice(10).trim().toLowerCase();
-      if (value === "on" || value === "true") {
-        thinkingEnabled = true;
-        writeLine(info("Deep thinking: on"));
-      } else if (value === "off" || value === "false") {
-        thinkingEnabled = false;
-        writeLine(info("Deep thinking: off"));
-      } else {
-        writeLine(error(`Usage: /thinking <on|off>  (currently: ${thinkingEnabled ? "on" : "off"})`));
-      }
-      rl.prompt();
-      return;
-    }
-    agentRunning = true;
-    try {
-      conversationMessages = await runAgentSession(trimmed, {
-        agentMode: "agent",
-        workspaceDir,
-        interactive: true,
-        thinking: thinkingEnabled,
-        existingMessages: conversationMessages,
-        signal: abortController.signal
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      writeError(error(`Error: ${message}`));
-    }
-    agentRunning = false;
-    abortController = new AbortController();
-    writeLine("");
-    rl.prompt();
-  });
-  rl.on("close", () => {
-    killAllShells();
-    writeLine(dim("\nGoodbye! \u{1F44B}"));
-    process.exit(0);
-  });
-  rl.on("SIGINT", () => {
-    if (agentRunning) {
-      abortController.abort();
-      writeLine("");
-      writeLine(warning("\u26A0 Cancelled"));
-    } else {
-      rl.close();
-    }
-  });
-}
-
-// src/commands/config.ts
-init_config();
-var PROVIDER_IDS2 = ["deepseek", "glm", "agnes", "nvidia", "minimax", "custom"];
-async function configCommand(key, value) {
-  const config = loadConfig();
-  if (!key) {
-    showConfig(config);
-    return;
-  }
-  if (key && value !== void 0) {
-    await setConfigValue(config, key, value);
-    return;
-  }
-  showConfigValue(config, key);
-}
-function showConfig(config) {
-  writeLine(bold("\nCoder CLI Configuration"));
-  writeLine(dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  writeLine(`Config directory: ${getConfigDirPath()}`);
-  writeLine(`Config file: ${getConfigFilePathExplicit()}`);
-  writeLine("");
-  writeLine(bold("Active Settings:"));
-  writeLine(`  Active provider: ${config.activeProvider}`);
-  writeLine(`  Last model:      ${config.lastModel}`);
-  const tavilyKey = resolveTavilyApiKey(config);
-  writeLine(`  Web search:      ${tavilyKey ? "configured" : "not configured (set via coder config tavilyApiKey <key> or TAVILY_API_KEY env var)"}`);
-  writeLine("");
-  for (const providerId of PROVIDER_IDS2) {
-    const p = config.providers[providerId];
-    writeLine(bold(`Provider: ${providerId}`));
-    writeLine(`  API Key Source: ${p.apiKeySource}`);
-    writeLine(`  API Key Env Var: ${p.apiKeyEnvVar}`);
-    writeLine(`  API Key (stored): ${p.apiKey ? "***" : "(not set)"}`);
-    writeLine(`  Custom Base URL: ${p.customBaseUrl || "(default)"}`);
-    if (providerId === "custom") {
-      writeLine(`  Deep Thinking:   ${p.supportsThinking ? "supported" : "not declared"}`);
-      if (p.thinkingEnabledParams) {
-        writeLine(`  Thinking (on):   ${JSON.stringify(p.thinkingEnabledParams)}`);
-      }
-      if (p.thinkingDisabledParams) {
-        writeLine(`  Thinking (off):  ${JSON.stringify(p.thinkingDisabledParams)}`);
-      }
-    }
-    writeLine("");
-  }
-  writeLine(dim("To change a value: coder config <key> <value>"));
-  writeLine(dim(""));
-  writeLine(dim("Quick start \u2014 custom provider:"));
-  writeLine(dim("  coder config activeProvider custom"));
-  writeLine(dim('  coder config providers.custom.customBaseUrl "https://api.openai.com/v1"'));
-  writeLine(dim("  coder config providers.custom.supportsThinking true"));
-  writeLine(dim('  coder config lastModel "gpt-4o"'));
-  writeLine(dim(""));
-  writeLine(dim("  # Way 1: env var (recommended)"));
-  writeLine(dim("  coder config providers.custom.apiKeySource env"));
-  writeLine(dim('  coder config providers.custom.apiKeyEnvVar "OPENAI_API_KEY"'));
-  writeLine(dim("  export OPENAI_API_KEY=sk-xxx"));
-  writeLine(dim(""));
-  writeLine(dim("  # Way 2: stored in config"));
-  writeLine(dim("  coder config providers.custom.apiKeySource manual"));
-  writeLine(dim('  coder config providers.custom.apiKey "sk-xxx"'));
-  writeLine(dim(""));
-  writeLine(dim("View a value:"));
-  writeLine(dim("  coder config activeProvider"));
-  writeLine(dim("  coder config providers.deepseek.customBaseUrl"));
-  writeLine(dim("  coder config providers.custom.thinkingEnabledParams"));
-  writeLine("");
-}
-function showConfigValue(config, key) {
-  const value = getNestedValue(config, key);
-  if (value === void 0) {
-    writeLine(warning(`Config key not found: ${key}`));
-    return;
-  }
-  writeLine(String(value));
-}
-async function setConfigValue(config, key, value) {
-  if (key === "activeProvider" && !PROVIDER_IDS2.includes(value)) {
-    writeLine(error(`Invalid provider "${value}". Valid providers: ${PROVIDER_IDS2.join(", ")}`));
-    return;
-  }
-  if (key.endsWith(".apiKeySource") || key === "apiKeySource") {
-    if (value !== "env" && value !== "manual") {
-      writeLine(error(`Invalid apiKeySource "${value}". Must be "env" or "manual".`));
-      return;
-    }
-  }
-  setNestedValue(config, key, parseValue(value));
-  saveConfig(config);
-  writeLine(info(`Config updated: ${key} = ${value}`));
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function setNestedValue(obj, path, value) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (!(parts[i] in current)) {
-      current[parts[i]] = {};
-    }
-    current = current[parts[i]];
-  }
-  current[parts[parts.length - 1]] = value;
-}
-function parseValue(value) {
-  if (value === "true") return true;
-  if (value === "false") return false;
-  const num = Number(value);
-  if (!isNaN(num) && value.trim() !== "") return num;
-  return value;
-}
-
-// src/commands/common.ts
-var _globalOptions = {};
-function setGlobalOptions(opts) {
-  _globalOptions = opts;
-}
-
-// src/index.ts
-var VERSION = "0.1.108";
-async function main() {
-  const rawArgs = process.argv.slice(2);
-  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-    printHelp();
-    return;
-  }
-  if (rawArgs.includes("--version") || rawArgs.includes("-v")) {
-    console.log(VERSION);
-    return;
-  }
-  const globalOpts = extractGlobalOptions(rawArgs);
-  setGlobalOptions(globalOpts);
-  if (rawArgs.length === 0) {
-    await replCommand({});
-    return;
-  }
-  const firstNonFlag = rawArgs.find((a) => !a.startsWith("-"));
-  const knownSubcommands = {
-    ask: async (args, opts) => {
-      await askCommand(args.join(" "), opts);
-    },
-    run: async (args, opts) => {
-      await runCommand(args.join(" "), opts);
-    },
-    config: async (args) => {
-      await configCommand(args[0], args[1]);
-    }
-  };
-  if (firstNonFlag && knownSubcommands[firstNonFlag]) {
-    const cmdArgs = rawArgs.slice(rawArgs.indexOf(firstNonFlag) + 1).filter((a) => !a.startsWith("-"));
-    await knownSubcommands[firstNonFlag](cmdArgs, globalOpts);
-    return;
-  }
-  writeLine(error(`Unknown subcommand "${firstNonFlag}".`));
-  writeLine("");
-  writeLine(info("Usage: coder <command> [options] [prompt...]"));
-  writeLine(info("Run 'coder --help' for available commands."));
-  process.exit(1);
-}
-function extractGlobalOptions(args) {
-  const opts = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "-w" || arg === "--workspace") {
-      opts.workspace = args[++i] ?? "";
-    } else if (arg === "--no-stream") {
-      opts.stream = false;
-    } else if (arg === "--stream") {
-      opts.stream = true;
-    } else if (arg === "--thinking") {
-      opts.thinking = true;
-    } else if (arg === "--no-thinking") {
-      opts.thinking = false;
-    }
-  }
-  return opts;
-}
-function printHelp() {
-  console.log(`
-Usage: coder <command> [options] [prompt...]
-
-Coder CLI \u2014 AI-powered coding assistant in the terminal
-
-Options:
-  -v, --version              output the version number
-  -w, --workspace <path>     Workspace directory
-      --no-stream            Disable streaming output
-      --thinking             Enable deep thinking (for supported models)
-      --no-thinking          Disable deep thinking
-  -h, --help                 display help for command
-
-Commands:
-  ask [prompt...]            Ask a question (read-only mode)
-  run [prompt...]            Run in full agent mode (can modify files, run commands)
-  config [key] [value]       View or edit configuration
-`);
-}
-main().catch((err) => {
-  const message = err instanceof Error ? err.message : String(err);
-  writeError(error(`Fatal: ${message}`));
-  process.exit(1);
-});
-//# sourceMappingURL=index.cjs.map