@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/chunk-77XDJMBP.js

@@ -0,0 +1,3326 @@
+import {
+  AskUserQuestionTool,
+  BashTool,
+  EnterPlanModeTool,
+  ExitPlanModeTool,
+  FileEditTool,
+  FileReadTool,
+  FileWriteTool,
+  GlobTool,
+  GrepTool,
+  NotebookEditTool,
+  OutputLine,
+  SkillTool,
+  SlashCommandTool,
+  WebFetchTool,
+  applyMarkdown,
+  maybeTruncateVerboseToolOutput
+} from "./chunk-7RRW4NTB.js";
+import {
+  getClients,
+  getMCPTools
+} from "./chunk-ZBVLKZ5V.js";
+import {
+  getActiveAgents,
+  getAgentByType,
+  getAvailableAgentTypes
+} from "./chunk-BTA7SZ26.js";
+import {
+  hasPermissionsToUseTool,
+  hasReadPermission
+} from "./chunk-PPHLQVL7.js";
+import {
+  countTokens,
+  getAbsolutePath,
+  query,
+  startWatchingTodoFile
+} from "./chunk-TNWB3U5Y.js";
+import {
+  getTheme
+} from "./chunk-T7RB5V5J.js";
+import {
+  getMaxThinkingTokens
+} from "./chunk-53M46S5I.js";
+import {
+  getAgentPrompt,
+  getContext
+} from "./chunk-HPYNW6TT.js";
+import {
+  emitReminderEvent,
+  generateAgentId,
+  getTodos,
+  setTodos
+} from "./chunk-LOD5ZHCI.js";
+import {
+  formatDuration,
+  formatNumber
+} from "./chunk-GELCZWMB.js";
+import {
+  queryLLM
+} from "./chunk-BHDHXOXB.js";
+import {
+  INTERRUPT_MESSAGE,
+  createAssistantMessage,
+  createUserMessage,
+  getLastAssistantMessageId
+} from "./chunk-HRJ3ICQK.js";
+import {
+  getModelManager
+} from "./chunk-6ZWEOSEI.js";
+import {
+  debug
+} from "./chunk-YIO5EBMQ.js";
+import {
+  getMessagesPath,
+  getNextAvailableLogSidechainNumber,
+  logError,
+  overwriteLog
+} from "./chunk-3OEJVB5A.js";
+import {
+  getCwd
+} from "./chunk-BBJFHTBC.js";
+import {
+  BunShell,
+  readTaskOutput
+} from "./chunk-B3MW3YGY.js";
+
+// packages/tools/src/registry.ts
+import { memoize as memoize2 } from "lodash-es";
+
+// packages/tools/src/tools/ai/AskExpertModelTool/AskExpertModelTool.tsx
+import { Box, Text } from "ink";
+import React from "react";
+import { z } from "zod";
+
+// packages/core/src/utils/expertChatStorage.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+function getExpertChatDirectory() {
+  const configDir = process.env.KODE_CONFIG_DIR ?? process.env.ANYKODE_CONFIG_DIR ?? join(homedir(), ".kode");
+  const expertChatDir = join(configDir, "expert-chats");
+  if (!existsSync(expertChatDir)) {
+    mkdirSync(expertChatDir, { recursive: true });
+  }
+  return expertChatDir;
+}
+function getSessionFilePath(sessionId) {
+  return join(getExpertChatDirectory(), `${sessionId}.json`);
+}
+function createExpertChatSession(expertModel) {
+  const sessionId = randomUUID().slice(0, 5);
+  const session = {
+    sessionId,
+    expertModel,
+    messages: [],
+    createdAt: Date.now(),
+    lastUpdated: Date.now()
+  };
+  saveExpertChatSession(session);
+  return session;
+}
+function loadExpertChatSession(sessionId) {
+  const filePath = getSessionFilePath(sessionId);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    logError(error);
+    debug.warn("EXPERT_CHAT_SESSION_LOAD_FAILED", {
+      sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function saveExpertChatSession(session) {
+  const filePath = getSessionFilePath(session.sessionId);
+  try {
+    session.lastUpdated = Date.now();
+    writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+  } catch (error) {
+    logError(error);
+    debug.warn("EXPERT_CHAT_SESSION_SAVE_FAILED", {
+      sessionId: session.sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+function addMessageToSession(sessionId, role, content) {
+  const session = loadExpertChatSession(sessionId);
+  if (!session) {
+    return null;
+  }
+  session.messages.push({ role, content });
+  saveExpertChatSession(session);
+  return session;
+}
+function getSessionMessages(sessionId) {
+  const session = loadExpertChatSession(sessionId);
+  return session?.messages || [];
+}
+
+// packages/tools/src/tools/ai/AskExpertModelTool/call.ts
+function isRecord(value) {
+  return !!value && typeof value === "object";
+}
+function extractAssistantText(message) {
+  const content = message?.message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join("\n");
+}
+function isInterrupted(error, abortController, interruptedFlag) {
+  if (interruptedFlag) return true;
+  if (abortController.signal.aborted) return true;
+  if (!isRecord(error)) return false;
+  return error.name === "AbortError";
+}
+async function withTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Expert model query timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    promise.then((value) => resolve(value)).catch((err) => reject(err)).finally(() => clearTimeout(timeoutId));
+  });
+}
+function interruptResult(expertModelName) {
+  return {
+    type: "result",
+    data: {
+      chatSessionId: "interrupted",
+      expertModelName,
+      expertAnswer: INTERRUPT_MESSAGE
+    },
+    resultForAssistant: INTERRUPT_MESSAGE
+  };
+}
+async function* callAskExpertModelTool(input, context, renderResultForAssistant) {
+  const { question, expert_model, chat_session_id } = input;
+  const { abortController } = context;
+  const expertModel = expert_model;
+  let sessionId = "";
+  let interrupted = false;
+  const abortListener = () => {
+    interrupted = true;
+  };
+  abortController.signal.addEventListener("abort", abortListener);
+  try {
+    if (abortController.signal.aborted) {
+      yield interruptResult(expertModel);
+      return;
+    }
+    if (chat_session_id === "new") {
+      sessionId = createExpertChatSession(expertModel).sessionId;
+    } else {
+      sessionId = chat_session_id;
+      const session = loadExpertChatSession(sessionId);
+      if (!session) {
+        sessionId = createExpertChatSession(expertModel).sessionId;
+      }
+    }
+    if (interrupted || abortController.signal.aborted) {
+      yield interruptResult(expertModel);
+      return;
+    }
+    const history = (() => {
+      try {
+        return getSessionMessages(sessionId);
+      } catch (error) {
+        logError(error);
+        return [];
+      }
+    })();
+    const conversation = [...history, { role: "user", content: question }];
+    const llmMessages = conversation.map(
+      (msg) => msg.role === "user" ? createUserMessage(msg.content) : createAssistantMessage(msg.content)
+    );
+    if (interrupted || abortController.signal.aborted) {
+      yield interruptResult(expertModel);
+      return;
+    }
+    yield {
+      type: "progress",
+      content: createAssistantMessage(
+        `Connecting to ${expertModel}... (timeout: 5 minutes)`
+      )
+    };
+    const modelManager = getModelManager();
+    const modelResolution = modelManager.resolveModelWithInfo(expertModel);
+    debug.api("EXPERT_MODEL_RESOLUTION", {
+      requestedModel: expertModel,
+      success: modelResolution.success,
+      profileName: modelResolution.profile?.name,
+      profileModelName: modelResolution.profile?.modelName,
+      provider: modelResolution.profile?.provider,
+      isActive: modelResolution.profile?.isActive,
+      error: modelResolution.error
+    });
+    const timeoutMs = 3e5;
+    const response = await withTimeout(
+      queryLLM(llmMessages, [], 0, [], abortController.signal, {
+        safeMode: false,
+        model: expertModel,
+        prependCLISysprompt: false
+      }),
+      timeoutMs
+    );
+    if (interrupted || abortController.signal.aborted) {
+      yield interruptResult(expertModel);
+      return;
+    }
+    const expertAnswer = extractAssistantText(response).trim();
+    if (!expertAnswer) {
+      throw new Error("Expert response was empty");
+    }
+    try {
+      addMessageToSession(sessionId, "user", question);
+      addMessageToSession(sessionId, "assistant", expertAnswer);
+    } catch (error) {
+      logError(error);
+    }
+    const result = {
+      chatSessionId: sessionId,
+      expertModelName: expertModel,
+      expertAnswer
+    };
+    yield {
+      type: "result",
+      data: result,
+      resultForAssistant: renderResultForAssistant(result)
+    };
+  } catch (error) {
+    if (isInterrupted(error, abortController, interrupted)) {
+      yield interruptResult(expertModel);
+      return;
+    }
+    logError(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const result = {
+      chatSessionId: sessionId || "error-session",
+      expertModelName: expertModel,
+      expertAnswer: `\u274C ${errorMessage || "Expert consultation failed with unknown error"}`
+    };
+    yield {
+      type: "result",
+      data: result,
+      resultForAssistant: renderResultForAssistant(result)
+    };
+  } finally {
+    abortController.signal.removeEventListener("abort", abortListener);
+  }
+}
+
+// packages/tools/src/tools/ai/AskExpertModelTool/prompt.ts
+var DESCRIPTION = "Consult an external AI model for a second opinion or specialized analysis.";
+var PROMPT = `Ask a question to a specific external AI model for expert analysis.
+
+CRITICAL: The expert model receives ONLY your \`question\` (plus the prior messages in the same \`chat_session_id\`).
+It does NOT have access to the user\u2019s current repository context unless you include it in the question.
+
+The \`question\` MUST be self-contained:
+1) Background / context
+2) Current situation / constraints
+3) A clear, independent question
+
+Use this tool when you want a different model\u2019s perspective, not for task execution.`;
+
+// packages/tools/src/tools/ai/AskExpertModelTool/AskExpertModelTool.tsx
+var inputSchema = z.strictObject({
+  question: z.string().describe(
+    "A fully self-contained question (include all background context, constraints, and a clear ask)."
+  ),
+  expert_model: z.string().describe(
+    "The expert model to use (e.g., gpt-5, claude-3-5-sonnet-20241022)"
+  ),
+  chat_session_id: z.string().describe('Use "new" for a new session, or an existing session ID.')
+});
+function normalizeModelName(modelName) {
+  return modelName.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function getCurrentModelName(context) {
+  if (typeof context?.options?.model === "string") return context.options.model;
+  const modelName = getModelManager().getModelName("main");
+  return modelName ?? "";
+}
+async function validateInput(input, context) {
+  const question = input.question.trim();
+  const expertModel = input.expert_model.trim();
+  const sessionId = input.chat_session_id.trim();
+  if (!question) return { result: false, message: "Question cannot be empty" };
+  if (!expertModel)
+    return { result: false, message: "Expert model must be specified" };
+  if (!sessionId) {
+    return {
+      result: false,
+      message: 'Chat session ID must be specified (use "new" for new session)'
+    };
+  }
+  const currentModel = getCurrentModelName(context);
+  if (currentModel && normalizeModelName(currentModel) === normalizeModelName(expertModel)) {
+    return {
+      result: false,
+      message: `You are already running as ${currentModel}. Please choose a different model to consult.`
+    };
+  }
+  const modelManager = getModelManager();
+  const resolved = modelManager.resolveModelWithInfo(expertModel);
+  if (!resolved.success) {
+    const available = modelManager.getAllAvailableModelNames();
+    return {
+      result: false,
+      message: available.length > 0 ? `Model '${expertModel}' is not configured. Available models: ${available.join(", ")}. Configure it via /model.` : `Model '${expertModel}' is not configured and no models are currently available. Configure a model via /model first.`
+    };
+  }
+  return { result: true };
+}
+var AskExpertModelTool = {
+  name: "AskExpertModel",
+  async description() {
+    return DESCRIPTION;
+  },
+  async prompt() {
+    return PROMPT;
+  },
+  inputSchema,
+  userFacingName() {
+    return "AskExpertModel";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  validateInput,
+  renderToolUseMessage({ question, expert_model, chat_session_id }, { verbose }) {
+    if (!expert_model) return null;
+    const isNewSession = chat_session_id === "new";
+    const sessionLabel = isNewSession ? "new session" : `session ${chat_session_id.slice(0, 8)}\u2026`;
+    const theme = getTheme();
+    if (!verbose) {
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "yellow" }, expert_model, " "), /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText, dimColor: true }, "(", sessionLabel, ")"));
+    }
+    const preview = question.length > 300 ? `${question.slice(0, 300)}\u2026` : question;
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "yellow" }, expert_model), /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, sessionLabel), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.text }, preview)));
+  },
+  renderToolResultMessage(output, { verbose }) {
+    const theme = getTheme();
+    const answer = (output.expertAnswer ?? "").trim();
+    const shown = verbose ? answer : answer.length > 800 ? `${answer.slice(0, 800)}\u2026` : answer;
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: theme.text }, "Response from ", output.expertModelName, ":"), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.text }, applyMarkdown(shown))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText, dimColor: true }, "Session: ", output.chatSessionId.slice(0, 8))));
+  },
+  renderToolUseRejectedMessage() {
+    const theme = getTheme();
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText, dimColor: true }, "Expert consultation cancelled"));
+  },
+  renderResultForAssistant(output) {
+    return `[Expert consultation completed]
+Expert Model: ${output.expertModelName}
+Session ID: ${output.chatSessionId}
+To continue this conversation, reuse this Session ID in the next AskExpertModel call.
+
+${output.expertAnswer}`;
+  },
+  async *call(input, { abortController, readFileTimestamps }) {
+    const normalizedInput = {
+      question: String(input.question ?? ""),
+      expert_model: String(input.expert_model ?? ""),
+      chat_session_id: String(input.chat_session_id ?? "")
+    };
+    yield* callAskExpertModelTool(
+      normalizedInput,
+      { abortController, readFileTimestamps },
+      (output) => this.renderResultForAssistant(output)
+    );
+  }
+};
+
+// packages/tools/src/tools/system/TaskOutputTool/TaskOutputTool.tsx
+import { z as z2 } from "zod";
+
+// packages/core/src/utils/backgroundTasks.ts
+var backgroundTasks = /* @__PURE__ */ new Map();
+function getBackgroundAgentTaskSnapshot(agentId) {
+  const task = backgroundTasks.get(agentId);
+  if (!task) return void 0;
+  const { abortController: _abortController, done: _done, ...snapshot } = task;
+  return snapshot;
+}
+function upsertBackgroundAgentTask(task) {
+  backgroundTasks.set(task.agentId, task);
+}
+async function waitForBackgroundAgentTask(agentId, waitUpToMs, signal) {
+  const task = backgroundTasks.get(agentId);
+  if (!task) return void 0;
+  if (task.status !== "running") return task;
+  const timeoutPromise = new Promise((_, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error("Request timed out"));
+    }, waitUpToMs);
+    timeoutId.unref?.();
+  });
+  const abortPromise = new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(new Error("Request aborted"));
+      return;
+    }
+    const onAbort = () => reject(new Error("Request aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  await Promise.race([task.done, timeoutPromise, abortPromise]);
+  return backgroundTasks.get(agentId);
+}
+
+// packages/tools/src/tools/system/TaskOutputTool/prompt.ts
+var TOOL_NAME_FOR_PROMPT = "TaskOutput";
+var DESCRIPTION2 = "Retrieves output from a running or completed task";
+var PROMPT2 = `- Retrieves output from a running or completed task (background shell, agent, or remote session)
+- Takes a task_id parameter identifying the task
+- Returns the task output along with status information
+- Use block=true (default) to wait for task completion
+- Use block=false for non-blocking check of current status
+- Task IDs can be found using the /tasks command
+- Works with all task types: background shells, async agents, and remote sessions`;
+
+// packages/tools/src/tools/system/TaskOutputTool/TaskOutputTool.tsx
+var inputSchema2 = z2.strictObject({
+  task_id: z2.string().describe("The task ID to get output from"),
+  block: z2.boolean().optional().default(true).describe("Whether to wait for completion"),
+  timeout: z2.number().min(0).max(6e5).optional().default(3e4).describe("Max wait time in ms")
+});
+function normalizeTaskOutputInput(input) {
+  const task_id = typeof input.task_id === "string" && input.task_id || typeof input.agentId === "string" && input.agentId || typeof input.bash_id === "string" && input.bash_id || "";
+  const block = typeof input.block === "boolean" ? input.block : true;
+  const timeout = typeof input.timeout === "number" ? input.timeout : typeof input.wait_up_to === "number" ? input.wait_up_to * 1e3 : 3e4;
+  return { task_id, block, timeout };
+}
+function taskStatusFromBash(bg) {
+  if (!bg) return "failed";
+  if (bg.killed) return "killed";
+  if (bg.code === null) return "running";
+  return bg.code === 0 ? "completed" : "failed";
+}
+function buildTaskSummary(taskId) {
+  const bg = BunShell.getInstance().getBackgroundOutput(taskId);
+  if (bg) {
+    return {
+      task_id: taskId,
+      task_type: "local_bash",
+      status: taskStatusFromBash(bg),
+      description: bg.command,
+      output: readTaskOutput(taskId),
+      exitCode: bg.code
+    };
+  }
+  const agent = getBackgroundAgentTaskSnapshot(taskId);
+  if (agent) {
+    const output = readTaskOutput(taskId) || agent.resultText || "";
+    return {
+      task_id: taskId,
+      task_type: "local_agent",
+      status: agent.status,
+      description: agent.description,
+      output,
+      prompt: agent.prompt,
+      result: output,
+      error: agent.error
+    };
+  }
+  return null;
+}
+async function waitForBashTaskCompletion(args) {
+  const { taskId, timeoutMs, signal } = args;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (signal.aborted) return null;
+    const summary = buildTaskSummary(taskId);
+    if (!summary) return null;
+    if (summary.status !== "running" && summary.status !== "pending")
+      return summary;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return buildTaskSummary(taskId);
+}
+var TaskOutputTool = {
+  name: TOOL_NAME_FOR_PROMPT,
+  async description() {
+    return DESCRIPTION2;
+  },
+  userFacingName() {
+    return "Task Output";
+  },
+  inputSchema: inputSchema2,
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  async isEnabled() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async prompt() {
+    return PROMPT2;
+  },
+  renderToolUseMessage(input) {
+    const normalized = normalizeTaskOutputInput(input);
+    if (normalized.block === false) return "non-blocking";
+    return "";
+  },
+  renderToolUseRejectedMessage() {
+    return null;
+  },
+  renderResultForAssistant(output) {
+    const parts = [];
+    parts.push(
+      `<retrieval_status>${output.retrieval_status}</retrieval_status>`
+    );
+    if (output.task) {
+      parts.push(`<task_id>${output.task.task_id}</task_id>`);
+      parts.push(`<task_type>${output.task.task_type}</task_type>`);
+      parts.push(`<status>${output.task.status}</status>`);
+      if (output.task.exitCode !== void 0 && output.task.exitCode !== null) {
+        parts.push(`<exit_code>${output.task.exitCode}</exit_code>`);
+      }
+      if (output.task.output?.trim()) {
+        parts.push(`<output>
+${output.task.output.trimEnd()}
+</output>`);
+      }
+      if (output.task.error) {
+        parts.push(`<error>${output.task.error}</error>`);
+      }
+    }
+    return parts.join("\n\n");
+  },
+  async validateInput(input) {
+    if (!input.task_id) {
+      return { result: false, message: "Task ID is required", errorCode: 1 };
+    }
+    const task = buildTaskSummary(input.task_id);
+    if (!task) {
+      return {
+        result: false,
+        message: `No task found with ID: ${input.task_id}`,
+        errorCode: 2
+      };
+    }
+    return { result: true };
+  },
+  async *call(input, context) {
+    const normalized = normalizeTaskOutputInput(input);
+    const taskId = normalized.task_id;
+    const block = normalized.block;
+    const timeoutMs = normalized.timeout;
+    const initial = buildTaskSummary(taskId);
+    if (!initial) {
+      throw new Error(`No task found with ID: ${taskId}`);
+    }
+    if (!block) {
+      const isDone = initial.status !== "running" && initial.status !== "pending";
+      const out2 = {
+        retrieval_status: isDone ? "success" : "not_ready",
+        task: initial
+      };
+      yield {
+        type: "result",
+        data: out2,
+        resultForAssistant: this.renderResultForAssistant(out2)
+      };
+      return;
+    }
+    yield {
+      type: "progress",
+      content: createAssistantMessage(
+        `<tool-progress>${initial.description ? `  ${initial.description}
+` : ""}     Waiting for task (esc to give additional instructions)</tool-progress>`
+      )
+    };
+    let finalTask = null;
+    if (initial.task_type === "local_agent") {
+      try {
+        const task = await waitForBackgroundAgentTask(
+          taskId,
+          timeoutMs,
+          context.abortController.signal
+        );
+        finalTask = task ? buildTaskSummary(taskId) : null;
+      } catch {
+        finalTask = buildTaskSummary(taskId);
+      }
+    } else {
+      finalTask = await waitForBashTaskCompletion({
+        taskId,
+        timeoutMs,
+        signal: context.abortController.signal
+      });
+    }
+    if (!finalTask) {
+      const out2 = { retrieval_status: "timeout", task: null };
+      yield {
+        type: "result",
+        data: out2,
+        resultForAssistant: this.renderResultForAssistant(out2)
+      };
+      return;
+    }
+    if (finalTask.status === "running" || finalTask.status === "pending") {
+      const out2 = { retrieval_status: "timeout", task: finalTask };
+      yield {
+        type: "result",
+        data: out2,
+        resultForAssistant: this.renderResultForAssistant(out2)
+      };
+      return;
+    }
+    const out = { retrieval_status: "success", task: finalTask };
+    yield {
+      type: "result",
+      data: out,
+      resultForAssistant: this.renderResultForAssistant(out)
+    };
+  }
+};
+
+// packages/tools/src/tools/system/KillShellTool/KillShellTool.tsx
+import { z as z3 } from "zod";
+
+// packages/tools/src/tools/system/KillShellTool/prompt.ts
+var TOOL_NAME_FOR_PROMPT2 = "KillShell";
+var DESCRIPTION3 = "Kill a background bash shell by ID";
+var PROMPT3 = `
+- Kills a running background bash shell by its ID
+- Takes a shell_id parameter identifying the shell to kill
+- Returns a success or failure status 
+- Use this tool when you need to terminate a long-running shell
+- Shell IDs can be found using the /tasks command
+`;
+
+// packages/tools/src/tools/system/KillShellTool/KillShellTool.tsx
+var inputSchema3 = z3.strictObject({
+  shell_id: z3.string().describe("The ID of the background shell to kill")
+});
+var KillShellTool = {
+  name: TOOL_NAME_FOR_PROMPT2,
+  async description() {
+    return DESCRIPTION3;
+  },
+  userFacingName() {
+    return "Kill Shell";
+  },
+  inputSchema: inputSchema3,
+  isReadOnly() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  async isEnabled() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async prompt() {
+    return PROMPT3;
+  },
+  renderToolUseMessage({ shell_id }) {
+    return `Kill shell: ${shell_id}`;
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output);
+  },
+  async validateInput({ shell_id }) {
+    const bg = BunShell.getInstance().getBackgroundOutput(shell_id);
+    if (!bg) {
+      return {
+        result: false,
+        message: `No shell found with ID: ${shell_id}`,
+        errorCode: 1
+      };
+    }
+    return { result: true };
+  },
+  async *call({ shell_id }) {
+    const bg = BunShell.getInstance().getBackgroundOutput(shell_id);
+    if (!bg) {
+      throw new Error(`No shell found with ID: ${shell_id}`);
+    }
+    const status = bg.killed ? "killed" : bg.code === null ? "running" : bg.code === 0 ? "completed" : "failed";
+    if (status !== "running") {
+      throw new Error(
+        `Shell ${shell_id} is not running, so cannot be killed (status: ${status})`
+      );
+    }
+    const killed = BunShell.getInstance().killBackgroundShell(shell_id);
+    const output = {
+      message: killed ? `Successfully killed shell: ${shell_id} (${bg.command})` : `No shell found with ID: ${shell_id}`,
+      shell_id
+    };
+    yield {
+      type: "result",
+      data: output,
+      resultForAssistant: this.renderResultForAssistant(output)
+    };
+  }
+};
+
+// packages/tools/src/tools/mcp/ListMcpResourcesTool/ListMcpResourcesTool.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import React2 from "react";
+import { z as z4 } from "zod";
+import { ListResourcesResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// packages/tools/src/tools/mcp/ListMcpResourcesTool/prompt.ts
+var TOOL_NAME = "ListMcpResourcesTool";
+var DESCRIPTION4 = `Lists available resources from configured MCP servers.
+Each resource object includes a 'server' field indicating which server it's from.
+
+Usage examples:
+- List all resources from all servers: \`listMcpResources\`
+- List resources from a specific server: \`listMcpResources({ server: "myserver" })\``;
+var PROMPT4 = `List available resources from configured MCP servers.
+Each returned resource will include all standard MCP resource fields plus a 'server' field 
+indicating which server the resource belongs to.
+
+Parameters:
+- server (optional): The name of a specific MCP server to get resources from. If not provided,
+  resources from all servers will be returned.`;
+
+// packages/tools/src/tools/mcp/ListMcpResourcesTool/ListMcpResourcesTool.tsx
+var inputSchema4 = z4.strictObject({
+  server: z4.string().optional().describe("Optional server name to filter resources by")
+});
+function isWrappedClient(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (typeof record.name !== "string") return false;
+  if (record.type !== "connected" && record.type !== "failed") return false;
+  if (record.type === "connected") {
+    return typeof record.client === "object" && record.client !== null;
+  }
+  return true;
+}
+async function getMcpClients(context) {
+  const override = context?.options?.mcpClients;
+  if (Array.isArray(override) && override.every(isWrappedClient)) {
+    return override;
+  }
+  return await getClients();
+}
+var ListMcpResourcesTool = {
+  name: TOOL_NAME,
+  async description() {
+    return DESCRIPTION4;
+  },
+  async prompt() {
+    return PROMPT4;
+  },
+  inputSchema: inputSchema4,
+  userFacingName() {
+    return "listMcpResources";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput({ server }, context) {
+    if (!server) return { result: true };
+    const clients = await getMcpClients(context);
+    const found = clients.some((c) => c.name === server);
+    if (!found) {
+      return {
+        result: false,
+        message: `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`,
+        errorCode: 1
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage({ server }) {
+    return server ? `List MCP resources from server "${server}"` : "List all MCP resources";
+  },
+  renderToolResultMessage(output) {
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "row" }, /* @__PURE__ */ React2.createElement(Text2, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React2.createElement(Text2, { bold: true }, output.length), /* @__PURE__ */ React2.createElement(Text2, null, " resources"));
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output);
+  },
+  async *call({ server }, context) {
+    const clients = await getMcpClients(context);
+    const selected = server ? clients.filter((c) => c.name === server) : clients;
+    if (server && selected.length === 0) {
+      throw new Error(
+        `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`
+      );
+    }
+    const resources = [];
+    for (const wrapped of selected) {
+      if (wrapped.type !== "connected") continue;
+      try {
+        let capabilities = wrapped.capabilities ?? null;
+        if (!capabilities) {
+          try {
+            capabilities = wrapped.client.getServerCapabilities() ?? null;
+          } catch {
+            capabilities = null;
+          }
+        }
+        if (!capabilities?.resources) continue;
+        const result = await wrapped.client.request(
+          { method: "resources/list" },
+          ListResourcesResultSchema
+        );
+        if (!result.resources) continue;
+        resources.push(
+          ...result.resources.map((r) => ({
+            ...r,
+            server: wrapped.name
+          }))
+        );
+      } catch {
+      }
+    }
+    yield {
+      type: "result",
+      data: resources,
+      resultForAssistant: this.renderResultForAssistant(resources)
+    };
+  }
+};
+
+// packages/tools/src/tools/system/LspTool/LspTool.tsx
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { Box as Box3, Text as Text4 } from "ink";
+import React4 from "react";
+import { z as z5 } from "zod";
+
+// packages/tools/src/tools/system/LspTool/constants.ts
+var OPERATIONS = [
+  "goToDefinition",
+  "findReferences",
+  "hover",
+  "documentSymbol",
+  "workspaceSymbol",
+  "goToImplementation",
+  "prepareCallHierarchy",
+  "incomingCalls",
+  "outgoingCalls"
+];
+var OPERATION_LABELS = {
+  goToDefinition: { singular: "definition", plural: "definitions" },
+  findReferences: { singular: "reference", plural: "references" },
+  documentSymbol: { singular: "symbol", plural: "symbols" },
+  workspaceSymbol: { singular: "symbol", plural: "symbols" },
+  hover: { singular: "hover info", plural: "hover info", special: "available" },
+  goToImplementation: { singular: "implementation", plural: "implementations" },
+  prepareCallHierarchy: { singular: "call item", plural: "call items" },
+  incomingCalls: { singular: "caller", plural: "callers" },
+  outgoingCalls: { singular: "callee", plural: "callees" }
+};
+
+// packages/tools/src/tools/system/LspTool/format.ts
+import { relative } from "path";
+function extractSymbolAtPosition(lines, zeroBasedLine, zeroBasedCharacter) {
+  try {
+    if (zeroBasedLine < 0 || zeroBasedLine >= lines.length) return null;
+    const line = lines[zeroBasedLine];
+    if (zeroBasedCharacter < 0 || zeroBasedCharacter >= line.length) return null;
+    const tokenRe = /[\w$'!]+|[+\-*/%&|^~<>=]+/g;
+    let match;
+    while ((match = tokenRe.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (zeroBasedCharacter >= start && zeroBasedCharacter < end) {
+        const token = match[0];
+        return token.length > 30 ? `${token.slice(0, 27)}...` : token;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function toProjectRelativeIfPossible(filePath) {
+  const cwd = getCwd();
+  try {
+    const rel = relative(cwd, filePath);
+    if (!rel || rel === "") return filePath;
+    if (rel.startsWith("..")) return filePath;
+    return rel;
+  } catch {
+    return filePath;
+  }
+}
+function formatLocation(fileName, line0, character0) {
+  return `${toProjectRelativeIfPossible(fileName)}:${line0 + 1}:${character0 + 1}`;
+}
+function formatGoToDefinitionResult(locations) {
+  if (!locations || locations.length === 0) {
+    return {
+      formatted: "No definition found. This may occur if the cursor is not on a symbol, or if the definition is in an external library not indexed by the LSP server.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  const fileCount = new Set(locations.map((l) => l.fileName)).size;
+  if (locations.length === 1) {
+    const loc = locations[0];
+    return {
+      formatted: `Defined in ${formatLocation(loc.fileName, loc.line0, loc.character0)}`,
+      resultCount: 1,
+      fileCount
+    };
+  }
+  return {
+    formatted: `Found ${locations.length} definitions:
+${locations.map(
+      (loc) => `  ${formatLocation(loc.fileName, loc.line0, loc.character0)}`
+    ).join("\n")}`,
+    resultCount: locations.length,
+    fileCount
+  };
+}
+function groupLocationsByFile(items) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = toProjectRelativeIfPossible(item.fileName);
+    const existing = grouped.get(key);
+    if (existing) existing.push(item);
+    else grouped.set(key, [item]);
+  }
+  return grouped;
+}
+function formatFindReferencesResult(references) {
+  if (!references || references.length === 0) {
+    return {
+      formatted: "No references found. This may occur if the symbol has no usages, or if the LSP server has not fully indexed the workspace.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  if (references.length === 1) {
+    const ref = references[0];
+    return {
+      formatted: `Found 1 reference:
+  ${formatLocation(ref.fileName, ref.line0, ref.character0)}`,
+      resultCount: 1,
+      fileCount: 1
+    };
+  }
+  const grouped = groupLocationsByFile(references);
+  const lines = [
+    `Found ${references.length} references across ${grouped.size} files:`
+  ];
+  for (const [file, refs] of grouped) {
+    lines.push(`
+${file}:`);
+    for (const ref of refs) {
+      lines.push(`  Line ${ref.line0 + 1}:${ref.character0 + 1}`);
+    }
+  }
+  return {
+    formatted: lines.join("\n"),
+    resultCount: references.length,
+    fileCount: grouped.size
+  };
+}
+function formatHoverResult(hoverText, line0, character0) {
+  if (!hoverText || hoverText.trim() === "") {
+    return {
+      formatted: "No hover information available. This may occur if the cursor is not on a symbol, or if the LSP server has not fully indexed the file.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  return {
+    formatted: `Hover info at ${line0 + 1}:${character0 + 1}:
+
+${hoverText}`,
+    resultCount: 1,
+    fileCount: 1
+  };
+}
+function formatDocumentSymbolsResult(lines, symbolCount) {
+  if (symbolCount === 0) {
+    return {
+      formatted: "No symbols found in document. This may occur if the file is empty, not supported by the LSP server, or if the server has not fully indexed the file.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  return {
+    formatted: ["Document symbols:", ...lines].join("\n"),
+    resultCount: symbolCount,
+    fileCount: 1
+  };
+}
+
+// packages/tools/src/tools/system/LspTool/summary.tsx
+import { Text as Text3 } from "ink";
+import React3 from "react";
+function summarizeToolResult(operation, resultCount, fileCount) {
+  const label = OPERATION_LABELS[operation] ?? {
+    singular: "result",
+    plural: "results"
+  };
+  const noun = resultCount === 1 ? label.singular : label.plural;
+  if (operation === "hover" && resultCount > 0 && label.special) {
+    return /* @__PURE__ */ React3.createElement(Text3, null, "Hover info ", label.special);
+  }
+  return /* @__PURE__ */ React3.createElement(Text3, null, "Found ", /* @__PURE__ */ React3.createElement(Text3, { bold: true }, resultCount), " ", noun, fileCount > 1 ? /* @__PURE__ */ React3.createElement(React3.Fragment, null, " ", "across ", /* @__PURE__ */ React3.createElement(Text3, { bold: true }, fileCount), " files") : null);
+}
+
+// packages/tools/src/tools/system/LspTool/tsProject.ts
+import { statSync } from "fs";
+import { createRequire } from "node:module";
+import { extname, join as join2 } from "path";
+import { pathToFileURL } from "url";
+var cachedTypeScript = null;
+function tryLoadTypeScriptModule(projectCwd) {
+  if (cachedTypeScript?.cwd === projectCwd) return cachedTypeScript.module;
+  try {
+    const requireFromCwd = createRequire(
+      pathToFileURL(join2(projectCwd, "__kode_lsp__.js"))
+    );
+    const mod = requireFromCwd("typescript");
+    cachedTypeScript = { cwd: projectCwd, module: mod };
+    return mod;
+  } catch {
+    cachedTypeScript = { cwd: projectCwd, module: null };
+    return null;
+  }
+}
+var projectCache = /* @__PURE__ */ new Map();
+function getOrCreateTsProject(projectCwd) {
+  const ts = tryLoadTypeScriptModule(projectCwd);
+  if (!ts) return null;
+  const existing = projectCache.get(projectCwd);
+  if (existing) return existing;
+  let compilerOptions = {
+    allowJs: true,
+    checkJs: false,
+    jsx: ts.JsxEmit.ReactJSX,
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext
+  };
+  let rootFileNames = [];
+  try {
+    const configPath = ts.findConfigFile(
+      projectCwd,
+      ts.sys.fileExists,
+      "tsconfig.json"
+    );
+    if (configPath) {
+      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+      if (!configFile.error) {
+        const parsed = ts.parseJsonConfigFileContent(
+          configFile.config,
+          ts.sys,
+          projectCwd
+        );
+        compilerOptions = { ...compilerOptions, ...parsed.options };
+        rootFileNames = parsed.fileNames;
+      }
+    }
+  } catch {
+  }
+  const rootFiles = new Set(rootFileNames);
+  const versions = /* @__PURE__ */ new Map();
+  const host = {
+    getCompilationSettings: () => compilerOptions,
+    getScriptFileNames: () => Array.from(rootFiles),
+    getScriptVersion: (fileName) => {
+      try {
+        const stat = statSync(fileName);
+        const version = String(stat.mtimeMs ?? Date.now());
+        versions.set(fileName, version);
+        return version;
+      } catch {
+        return versions.get(fileName) ?? "0";
+      }
+    },
+    getScriptSnapshot: (fileName) => {
+      try {
+        if (!ts.sys.fileExists(fileName)) return void 0;
+        const content = ts.sys.readFile(fileName);
+        if (content === void 0) return void 0;
+        const stat = statSync(fileName);
+        versions.set(fileName, String(stat.mtimeMs ?? Date.now()));
+        return ts.ScriptSnapshot.fromString(content);
+      } catch {
+        return void 0;
+      }
+    },
+    getCurrentDirectory: () => projectCwd,
+    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+    useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+    getCanonicalFileName: (fileName) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+    getNewLine: () => ts.sys.newLine
+  };
+  const languageService = ts.createLanguageService(
+    host,
+    ts.createDocumentRegistry()
+  );
+  const state = {
+    ts,
+    cwd: projectCwd,
+    rootFiles,
+    compilerOptions,
+    languageService,
+    versions
+  };
+  projectCache.set(projectCwd, state);
+  return state;
+}
+function isFileTypeSupportedByTypescriptBackend(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx" || ext === ".mts" || ext === ".cts" || ext === ".mjs" || ext === ".cjs";
+}
+
+// packages/tools/src/tools/system/LspTool/call.ts
+import { extname as extname2 } from "path";
+
+// packages/tools/src/tools/system/LspTool/operations.ts
+function runLspOperation({
+  input,
+  absPath,
+  pos,
+  ts,
+  program,
+  service,
+  sourceFile
+}) {
+  let formatted;
+  let resultCount = 0;
+  let fileCount = 0;
+  switch (input.operation) {
+    case "goToDefinition": {
+      const defs = service.getDefinitionAtPosition?.(absPath, pos) ?? [];
+      const locations = defs.map((d) => {
+        const defSourceFile = program.getSourceFile(d.fileName);
+        if (!defSourceFile) return null;
+        const lc = ts.getLineAndCharacterOfPosition(
+          defSourceFile,
+          d.textSpan.start
+        );
+        return {
+          fileName: d.fileName,
+          line0: lc.line,
+          character0: lc.character
+        };
+      }).filter(Boolean);
+      const res = formatGoToDefinitionResult(locations);
+      formatted = res.formatted;
+      resultCount = res.resultCount;
+      fileCount = res.fileCount;
+      break;
+    }
+    case "goToImplementation": {
+      const impls = service.getImplementationAtPosition?.(absPath, pos) ?? [];
+      const locations = impls.map((d) => {
+        const defSourceFile = program.getSourceFile(d.fileName);
+        if (!defSourceFile) return null;
+        const lc = ts.getLineAndCharacterOfPosition(
+          defSourceFile,
+          d.textSpan.start
+        );
+        return {
+          fileName: d.fileName,
+          line0: lc.line,
+          character0: lc.character
+        };
+      }).filter(Boolean);
+      const res = formatGoToDefinitionResult(locations);
+      formatted = res.formatted;
+      resultCount = res.resultCount;
+      fileCount = res.fileCount;
+      break;
+    }
+    case "findReferences": {
+      const referencedSymbols = service.findReferences?.(absPath, pos) ?? [];
+      const refs = [];
+      for (const sym of referencedSymbols) {
+        for (const ref of sym.references ?? []) {
+          const refSource = program.getSourceFile(ref.fileName);
+          if (!refSource) continue;
+          const lc = ts.getLineAndCharacterOfPosition(
+            refSource,
+            ref.textSpan.start
+          );
+          refs.push({
+            fileName: ref.fileName,
+            line0: lc.line,
+            character0: lc.character
+          });
+        }
+      }
+      const res = formatFindReferencesResult(refs);
+      formatted = res.formatted;
+      resultCount = res.resultCount;
+      fileCount = res.fileCount;
+      break;
+    }
+    case "hover": {
+      const info = service.getQuickInfoAtPosition?.(absPath, pos);
+      let text = null;
+      let hoverLine0 = input.line - 1;
+      let hoverCharacter0 = input.character - 1;
+      if (info) {
+        const parts = [];
+        const signature = ts.displayPartsToString(info.displayParts ?? []);
+        if (signature) parts.push(signature);
+        const doc = ts.displayPartsToString(info.documentation ?? []);
+        if (doc) parts.push(doc);
+        if (info.tags && info.tags.length > 0) {
+          for (const tag of info.tags) {
+            const tagText = ts.displayPartsToString(tag.text ?? []);
+            parts.push(`@${tag.name}${tagText ? ` ${tagText}` : ""}`);
+          }
+        }
+        text = parts.filter(Boolean).join("\\n\\n");
+        const lc = ts.getLineAndCharacterOfPosition(
+          sourceFile,
+          info.textSpan.start
+        );
+        hoverLine0 = lc.line;
+        hoverCharacter0 = lc.character;
+      }
+      const res = formatHoverResult(text, hoverLine0, hoverCharacter0);
+      formatted = res.formatted;
+      resultCount = res.resultCount;
+      fileCount = res.fileCount;
+      break;
+    }
+    case "documentSymbol": {
+      const tree = service.getNavigationTree?.(absPath);
+      const lines = [];
+      let count = 0;
+      const kindLabel = (kind) => {
+        const m = {
+          class: "Class",
+          interface: "Interface",
+          enum: "Enum",
+          function: "Function",
+          method: "Method",
+          property: "Property",
+          var: "Variable",
+          let: "Variable",
+          const: "Constant",
+          module: "Module",
+          alias: "Alias",
+          type: "Type"
+        };
+        return m[kind] ?? (kind ? kind[0].toUpperCase() + kind.slice(1) : "Unknown");
+      };
+      const walk = (node, depth) => {
+        const children = node?.childItems ?? [];
+        for (const child of children) {
+          const span = child.spans?.[0];
+          if (!span) continue;
+          const lc = ts.getLineAndCharacterOfPosition(sourceFile, span.start);
+          const indent = "  ".repeat(depth);
+          const label = kindLabel(child.kind);
+          const detail = child.kindModifiers ? ` ${child.kindModifiers}` : "";
+          lines.push(
+            `${indent}${child.text} (${label})${detail} - Line ${lc.line + 1}`
+          );
+          count += 1;
+          if (child.childItems && child.childItems.length > 0) {
+            walk(child, depth + 1);
+          }
+        }
+      };
+      walk(tree, 0);
+      const res = formatDocumentSymbolsResult(lines, count);
+      formatted = res.formatted;
+      resultCount = res.resultCount;
+      fileCount = res.fileCount;
+      break;
+    }
+    case "workspaceSymbol": {
+      const items = service.getNavigateToItems?.("", 100, void 0, true, true) ?? [];
+      if (!items || items.length === 0) {
+        formatted = "No symbols found in workspace. This may occur if the workspace is empty, or if the LSP server has not finished indexing the project.";
+        resultCount = 0;
+        fileCount = 0;
+        break;
+      }
+      const lines = [
+        `Found ${items.length} symbol${items.length === 1 ? "" : "s"} in workspace:`
+      ];
+      const wrappedItems = items.map(
+        (it) => ({
+          fileName: it.fileName,
+          item: it
+        })
+      );
+      const grouped = groupLocationsByFile(wrappedItems);
+      for (const [file, itemsInFile] of grouped) {
+        lines.push(`\\n${file}:`);
+        for (const wrapper of itemsInFile) {
+          const it = wrapper.item;
+          const sf = program.getSourceFile(it.fileName);
+          if (!sf) continue;
+          const span = it.textSpan;
+          const lc = span ? ts.getLineAndCharacterOfPosition(sf, span.start) : { line: 0, character: 0 };
+          const label = it.kind ? String(it.kind)[0].toUpperCase() + String(it.kind).slice(1) : "Symbol";
+          let line = `  ${it.name} (${label}) - Line ${lc.line + 1}`;
+          if (it.containerName) line += ` in ${it.containerName}`;
+          lines.push(line);
+        }
+      }
+      formatted = lines.join("\\n");
+      resultCount = items.length;
+      fileCount = grouped.size;
+      break;
+    }
+    case "prepareCallHierarchy":
+    case "incomingCalls":
+    case "outgoingCalls": {
+      const opLabel = input.operation;
+      formatted = `Error performing ${opLabel}: Call hierarchy is not supported by the TypeScript backend`;
+      resultCount = 0;
+      fileCount = 0;
+      break;
+    }
+    default: {
+      formatted = `Error performing ${input.operation}: Unsupported operation`;
+      resultCount = 0;
+      fileCount = 0;
+    }
+  }
+  return { formatted, resultCount, fileCount };
+}
+
+// packages/tools/src/tools/system/LspTool/call.ts
+async function* callLspTool(input, _context) {
+  const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
+  if (!isFileTypeSupportedByTypescriptBackend(absPath)) {
+    const ext = extname2(absPath);
+    const out = {
+      operation: input.operation,
+      result: `No LSP server available for file type: ${ext}`,
+      filePath: input.filePath,
+      resultCount: 0,
+      fileCount: 0
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
+    return;
+  }
+  const project = getOrCreateTsProject(getCwd());
+  if (!project) {
+    const out = {
+      operation: input.operation,
+      result: "LSP server manager not initialized. This may indicate a startup issue.",
+      filePath: input.filePath,
+      resultCount: 0,
+      fileCount: 0
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
+    return;
+  }
+  project.rootFiles.add(absPath);
+  const ts = project.ts;
+  const service = project.languageService;
+  const program = service.getProgram?.();
+  if (!program) {
+    const out = {
+      operation: input.operation,
+      result: `Error performing ${input.operation}: TypeScript program not available`,
+      filePath: input.filePath,
+      resultCount: 0,
+      fileCount: 0
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
+    return;
+  }
+  const sourceFile = program.getSourceFile(absPath);
+  if (!sourceFile) {
+    const out = {
+      operation: input.operation,
+      result: `Error performing ${input.operation}: File is not part of the TypeScript program`,
+      filePath: input.filePath,
+      resultCount: 0,
+      fileCount: 0
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
+    return;
+  }
+  const pos = ts.getPositionOfLineAndCharacter(
+    sourceFile,
+    input.line - 1,
+    input.character - 1
+  );
+  try {
+    const { formatted, resultCount, fileCount } = runLspOperation({
+      input,
+      absPath,
+      pos,
+      program,
+      service,
+      ts,
+      sourceFile
+    });
+    const out = {
+      operation: input.operation,
+      result: formatted,
+      filePath: input.filePath,
+      resultCount,
+      fileCount
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const out = {
+      operation: input.operation,
+      result: `Error performing ${input.operation}: ${message}`,
+      filePath: input.filePath
+    };
+    yield { type: "result", data: out, resultForAssistant: out.result };
+  }
+}
+
+// packages/tools/src/tools/system/LspTool/prompt.ts
+var TOOL_NAME_FOR_PROMPT3 = "LSP";
+var PROMPT5 = `Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: Search for symbols across the entire workspace
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+All operations require:
+- filePath: The file to operate on
+- line: The line number (1-based, as shown in editors)
+- character: The character offset (1-based, as shown in editors)
+
+Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.`;
+var DESCRIPTION5 = PROMPT5;
+
+// packages/tools/src/tools/system/LspTool/LspTool.tsx
+var inputSchema5 = z5.strictObject({
+  operation: z5.enum(OPERATIONS).describe("The LSP operation to perform"),
+  filePath: z5.string().describe("The absolute or relative path to the file"),
+  line: z5.number().int().positive().describe("The line number (1-based, as shown in editors)"),
+  character: z5.number().int().positive().describe("The character offset (1-based, as shown in editors)")
+});
+var outputSchema = z5.object({
+  operation: z5.enum(OPERATIONS).describe("The LSP operation that was performed"),
+  result: z5.string().describe("The formatted result of the LSP operation"),
+  filePath: z5.string().describe("The file path the operation was performed on"),
+  resultCount: z5.number().int().nonnegative().optional().describe("Number of results (definitions, references, symbols)"),
+  fileCount: z5.number().int().nonnegative().optional().describe("Number of files containing results")
+});
+var LspTool = {
+  name: TOOL_NAME_FOR_PROMPT3,
+  async description() {
+    return DESCRIPTION5;
+  },
+  async prompt() {
+    return PROMPT5;
+  },
+  inputSchema: inputSchema5,
+  userFacingName() {
+    return "LSP";
+  },
+  async isEnabled() {
+    return tryLoadTypeScriptModule(getCwd()) !== null;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions({ filePath }) {
+    const abs = getAbsolutePath(filePath) ?? filePath;
+    return !hasReadPermission(abs || getCwd());
+  },
+  async validateInput(input) {
+    const parsed = inputSchema5.safeParse(input);
+    if (!parsed.success) {
+      return {
+        result: false,
+        message: `Invalid input: ${parsed.error.message}`,
+        errorCode: 3
+      };
+    }
+    const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
+    if (!existsSync2(absPath)) {
+      return {
+        result: false,
+        message: `File does not exist: ${input.filePath}`,
+        errorCode: 1
+      };
+    }
+    try {
+      if (!statSync2(absPath).isFile()) {
+        return {
+          result: false,
+          message: `Path is not a file: ${input.filePath}`,
+          errorCode: 2
+        };
+      }
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      return {
+        result: false,
+        message: `Cannot access file: ${input.filePath}. ${e.message}`,
+        errorCode: 4
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage(input, { verbose }) {
+    const abs = getAbsolutePath(input.filePath) ?? input.filePath;
+    const filePathForDisplay = verbose ? abs : toProjectRelativeIfPossible(abs);
+    const parts = [];
+    if ((input.operation === "goToDefinition" || input.operation === "findReferences" || input.operation === "hover" || input.operation === "goToImplementation") && input.filePath && input.line !== void 0 && input.character !== void 0) {
+      try {
+        const content = readFileSync2(abs, "utf8");
+        const symbol = extractSymbolAtPosition(
+          content.split("\n"),
+          input.line - 1,
+          input.character - 1
+        );
+        if (symbol) {
+          parts.push(`operation: "${input.operation}"`);
+          parts.push(`symbol: "${symbol}"`);
+          parts.push(`in: "${filePathForDisplay}"`);
+          return parts.join(", ");
+        }
+      } catch {
+      }
+      parts.push(`operation: "${input.operation}"`);
+      parts.push(`file: "${filePathForDisplay}"`);
+      parts.push(`position: ${input.line}:${input.character}`);
+      return parts.join(", ");
+    }
+    parts.push(`operation: "${input.operation}"`);
+    if (input.filePath) parts.push(`file: "${filePathForDisplay}"`);
+    return parts.join(", ");
+  },
+  renderToolResultMessage(output, { verbose }) {
+    if (output.resultCount !== void 0 && output.fileCount !== void 0) {
+      const display = verbose ? maybeTruncateVerboseToolOutput(output.result, {
+        maxLines: 120,
+        maxChars: 2e4
+      }) : null;
+      return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text4, null, "\xA0\xA0\u23BF \xA0"), summarizeToolResult(
+        output.operation,
+        output.resultCount,
+        output.fileCount
+      )), display ? /* @__PURE__ */ React4.createElement(Box3, { marginLeft: 5 }, /* @__PURE__ */ React4.createElement(Text4, null, display.text)) : null);
+    }
+    return /* @__PURE__ */ React4.createElement(Box3, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text4, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React4.createElement(Text4, null, output.result)));
+  },
+  renderResultForAssistant(output) {
+    return output.result;
+  },
+  async *call(input, context) {
+    yield* callLspTool(input, context);
+  }
+};
+
+// packages/tools/src/tools/mcp/MCPTool/MCPTool.tsx
+import { Box as Box4, Text as Text5 } from "ink";
+import * as React5 from "react";
+import { z as z6 } from "zod";
+
+// packages/tools/src/tools/mcp/MCPTool/prompt.ts
+var PROMPT6 = "";
+var DESCRIPTION6 = "";
+
+// packages/tools/src/tools/mcp/MCPTool/MCPTool.tsx
+var inputSchema6 = z6.object({}).passthrough();
+var MCPTool = {
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  // Overridden in mcpClient.ts
+  name: "mcp",
+  // Overridden in mcpClient.ts
+  async description() {
+    return DESCRIPTION6;
+  },
+  // Overridden in mcpClient.ts
+  async prompt() {
+    return PROMPT6;
+  },
+  inputSchema: inputSchema6,
+  // Overridden in mcpClient.ts
+  async *call() {
+    yield {
+      type: "result",
+      data: "",
+      resultForAssistant: ""
+    };
+  },
+  needsPermissions() {
+    return true;
+  },
+  renderToolUseMessage(input) {
+    return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  },
+  // Overridden in mcpClient.ts
+  userFacingName: () => "mcp",
+  renderToolResultMessage(output) {
+    const verbose = false;
+    if (Array.isArray(output)) {
+      return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, output.map((item, i) => {
+        if (item.type === "image") {
+          return /* @__PURE__ */ React5.createElement(
+            Box4,
+            {
+              key: i,
+              justifyContent: "space-between",
+              overflowX: "hidden",
+              width: "100%"
+            },
+            /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text5, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React5.createElement(Text5, null, "[Image]"))
+          );
+        }
+        const lines2 = item.text.split("\n").length;
+        return /* @__PURE__ */ React5.createElement(
+          OutputLine,
+          {
+            key: i,
+            content: item.text,
+            lines: lines2,
+            verbose
+          }
+        );
+      }));
+    }
+    if (!output) {
+      return /* @__PURE__ */ React5.createElement(Box4, { justifyContent: "space-between", overflowX: "hidden", width: "100%" }, /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text5, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React5.createElement(Text5, { color: getTheme().secondaryText }, "(No content)")));
+    }
+    const lines = output.split("\n").length;
+    return /* @__PURE__ */ React5.createElement(OutputLine, { content: output, lines, verbose });
+  },
+  renderResultForAssistant(content) {
+    return content;
+  }
+};
+
+// packages/tools/src/tools/mcp/ReadMcpResourceTool/ReadMcpResourceTool.tsx
+import { Box as Box5, Text as Text6 } from "ink";
+import React6 from "react";
+import { z as z7 } from "zod";
+import { ReadResourceResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// packages/tools/src/tools/mcp/ReadMcpResourceTool/prompt.ts
+var TOOL_NAME2 = "ReadMcpResourceTool";
+var DESCRIPTION7 = `Reads a specific resource from an MCP server.
+- server: The name of the MCP server to read from
+- uri: The URI of the resource to read
+
+Usage examples:
+- Read a resource from a server: \`readMcpResource({ server: "myserver", uri: "my-resource-uri" })\``;
+var PROMPT7 = `Reads a specific resource from an MCP server, identified by server name and resource URI.
+
+Parameters:
+- server (required): The name of the MCP server from which to read the resource
+- uri (required): The URI of the resource to read`;
+
+// packages/tools/src/tools/mcp/ReadMcpResourceTool/ReadMcpResourceTool.tsx
+var inputSchema7 = z7.strictObject({
+  server: z7.string().describe("The MCP server name"),
+  uri: z7.string().describe("The resource URI to read")
+});
+function isWrappedClient2(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (typeof record.name !== "string") return false;
+  if (record.type !== "connected" && record.type !== "failed") return false;
+  if (record.type === "connected") {
+    return typeof record.client === "object" && record.client !== null;
+  }
+  return true;
+}
+async function getMcpClients2(context) {
+  const override = context?.options?.mcpClients;
+  if (Array.isArray(override) && override.every(isWrappedClient2)) {
+    return override;
+  }
+  return await getClients();
+}
+var ReadMcpResourceTool = {
+  name: TOOL_NAME2,
+  async description() {
+    return DESCRIPTION7;
+  },
+  async prompt() {
+    return PROMPT7;
+  },
+  inputSchema: inputSchema7,
+  userFacingName() {
+    return "readMcpResource";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput({ server }, context) {
+    const clients = await getMcpClients2(context);
+    const match = clients.find((c) => c.name === server);
+    if (!match) {
+      return {
+        result: false,
+        message: `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`,
+        errorCode: 1
+      };
+    }
+    if (match.type !== "connected") {
+      return {
+        result: false,
+        message: `Server "${server}" is not connected`,
+        errorCode: 2
+      };
+    }
+    let capabilities = match.capabilities ?? null;
+    if (!capabilities) {
+      try {
+        capabilities = match.client.getServerCapabilities() ?? null;
+      } catch {
+        capabilities = null;
+      }
+    }
+    if (!capabilities?.resources) {
+      return {
+        result: false,
+        message: `Server "${server}" does not support resources`,
+        errorCode: 3
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage({ server, uri }) {
+    if (!server || !uri) return null;
+    return `Read resource "${uri}" from server "${server}"`;
+  },
+  renderToolResultMessage(output) {
+    const count = output.contents?.length ?? 0;
+    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "row" }, /* @__PURE__ */ React6.createElement(Text6, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, "Read MCP resource"), /* @__PURE__ */ React6.createElement(Text6, null, count ? ` (${count} part${count === 1 ? "" : "s"})` : ""));
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output);
+  },
+  async *call({ server, uri }, context) {
+    const clients = await getMcpClients2(context);
+    const match = clients.find((c) => c.name === server);
+    if (!match) {
+      throw new Error(
+        `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`
+      );
+    }
+    if (match.type !== "connected") {
+      throw new Error(`Server "${server}" is not connected`);
+    }
+    let capabilities = match.capabilities ?? null;
+    if (!capabilities) {
+      try {
+        capabilities = match.client.getServerCapabilities() ?? null;
+      } catch {
+        capabilities = null;
+      }
+    }
+    if (!capabilities?.resources) {
+      throw new Error(`Server "${server}" does not support resources`);
+    }
+    const result = await match.client.request(
+      { method: "resources/read", params: { uri } },
+      ReadResourceResultSchema
+    );
+    yield {
+      type: "result",
+      data: result,
+      resultForAssistant: this.renderResultForAssistant(result)
+    };
+  }
+};
+
+// packages/core/src/utils/agentTranscripts.ts
+var transcripts = /* @__PURE__ */ new Map();
+function saveAgentTranscript(agentId, messages) {
+  transcripts.set(agentId, messages);
+}
+function getAgentTranscript(agentId) {
+  return transcripts.get(agentId);
+}
+
+// packages/tools/src/tools/ai/TaskTool/constants.ts
+var TOOL_NAME3 = "Task";
+
+// packages/tools/src/tools/ai/TaskTool/prompt.ts
+var SUBAGENT_DISALLOWED_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "Task",
+  "TaskOutput",
+  "KillShell",
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "AskUserQuestion"
+]);
+async function getTaskTools(safeMode) {
+  return (await (!safeMode ? getTools() : getReadOnlyTools())).filter(
+    (tool) => !SUBAGENT_DISALLOWED_TOOL_NAMES.has(tool.name)
+  );
+}
+async function getPrompt(safeMode) {
+  const agents = await getActiveAgents();
+  const agentDescriptions = agents.map((agent) => {
+    const toolsStr = Array.isArray(agent.tools) ? agent.tools.join(", ") : "*";
+    return `- ${agent.agentType}: ${agent.whenToUse} (Tools: ${toolsStr})`;
+  }).join("\n");
+  return `Launch a new agent to handle complex, multi-step tasks autonomously. 
+
+Available agent types and the tools they have access to:
+${agentDescriptions}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+When to use the Agent tool:
+- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
+
+When NOT to use the Agent tool:
+- If you want to read a specific file path, use the ${FileReadTool.name} or ${GlobTool.name} tool instead of the Agent tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the ${GlobTool.name} tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the ${FileReadTool.name} tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a signficant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the ${FileWriteTool.name} tool to write a function that checks if a number is prime
+assistant: I'm going to use the ${FileWriteTool.name} tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent 
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>`;
+}
+
+// packages/tools/src/tools/ai/TaskTool/forkContext.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+var FORK_CONTEXT_TOOL_RESULT_TEXT = `### FORKING CONVERSATION CONTEXT ###
+### ENTERING SUB-AGENT ROUTINE ###
+Entered sub-agent context
+
+PLEASE NOTE: 
+- The messages above this point are from the main thread prior to sub-agent execution. They are provided as context only.
+- Context messages may include tool_use blocks for tools that are not available in the sub-agent context. You should only use the tools specifically provided to you in the system prompt.
+- Only complete the specific sub-agent task you have been assigned below.`;
+function isToolUseLikeBlock(block) {
+  if (!block || typeof block !== "object") return false;
+  const type = block.type;
+  if (type !== "tool_use" && type !== "server_tool_use" && type !== "mcp_tool_use") {
+    return false;
+  }
+  const id = block.id;
+  return typeof id === "string" && id.length > 0;
+}
+function isConversationMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const type = value.type;
+  return type === "assistant" || type === "user" || type === "progress";
+}
+function readJsonArrayFile(path) {
+  if (!existsSync3(path)) return null;
+  try {
+    const raw = readFileSync3(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function createForkContextToolResult(options) {
+  const toolResultBlock = {
+    type: "tool_result",
+    tool_use_id: options.toolUseId,
+    content: FORK_CONTEXT_TOOL_RESULT_TEXT
+  };
+  const toolUseResult = {
+    data: {
+      status: "sub_agent_entered",
+      description: "Entered sub-agent context",
+      message: FORK_CONTEXT_TOOL_RESULT_TEXT
+    },
+    resultForAssistant: FORK_CONTEXT_TOOL_RESULT_TEXT
+  };
+  return createUserMessage([toolResultBlock], toolUseResult);
+}
+function createToolUseOnlyAssistantMessage(options) {
+  return {
+    ...options.message,
+    uuid: randomUUID2(),
+    message: {
+      ...options.message.message,
+      content: [options.toolUseBlock]
+    }
+  };
+}
+function buildForkContextForAgent(options) {
+  const userPromptMessage = createUserMessage(options.prompt);
+  if (!options.enabled || !options.toolUseId) {
+    return {
+      forkContextMessages: [],
+      promptMessages: [userPromptMessage]
+    };
+  }
+  const mainPath = getMessagesPath(
+    options.messageLogName,
+    options.forkNumber,
+    0
+  );
+  const raw = readJsonArrayFile(mainPath);
+  const mainMessages = (raw ?? []).filter(isConversationMessage);
+  if (mainMessages.length === 0) {
+    return {
+      forkContextMessages: [],
+      promptMessages: [userPromptMessage]
+    };
+  }
+  let toolUseMessageIndex = -1;
+  let toolUseMessage = null;
+  let taskToolUseBlock = null;
+  for (let i = 0; i < mainMessages.length; i++) {
+    const msg = mainMessages[i];
+    if (msg.type !== "assistant") continue;
+    const blocks = Array.isArray(msg.message?.content) ? msg.message.content : [];
+    const match = blocks.find(
+      (b) => isToolUseLikeBlock(b) && b.id === options.toolUseId
+    );
+    if (!match) continue;
+    toolUseMessageIndex = i;
+    toolUseMessage = msg;
+    taskToolUseBlock = match;
+    break;
+  }
+  if (toolUseMessageIndex === -1 || !toolUseMessage || !taskToolUseBlock) {
+    return {
+      forkContextMessages: [],
+      promptMessages: [userPromptMessage]
+    };
+  }
+  const forkContextMessages = mainMessages.slice(0, toolUseMessageIndex) ?? [];
+  const toolUseOnlyAssistant = createToolUseOnlyAssistantMessage({
+    message: toolUseMessage,
+    toolUseBlock: taskToolUseBlock
+  });
+  const forkContextToolResult = createForkContextToolResult({
+    toolUseId: taskToolUseBlock.id
+  });
+  return {
+    forkContextMessages,
+    promptMessages: [
+      toolUseOnlyAssistant,
+      forkContextToolResult,
+      userPromptMessage
+    ]
+  };
+}
+
+// packages/tools/src/tools/ai/TaskTool/models.ts
+function modelEnumToPointer(model) {
+  if (!model) return void 0;
+  switch (model) {
+    case "haiku":
+      return "quick";
+    case "sonnet":
+      return "task";
+    case "opus":
+      return "main";
+  }
+}
+function normalizeAgentModelName(model) {
+  if (!model) return void 0;
+  if (model === "inherit") return "inherit";
+  if (model === "haiku" || model === "sonnet" || model === "opus") {
+    return modelEnumToPointer(model);
+  }
+  return model;
+}
+
+// packages/tools/src/tools/ai/TaskTool/toolSpec.ts
+function getToolNameFromSpec(spec) {
+  const trimmed = spec.trim();
+  if (!trimmed) return trimmed;
+  const match = trimmed.match(/^([^(]+)\(([^)]+)\)$/);
+  if (!match) return trimmed;
+  const toolName = match[1]?.trim();
+  const ruleContent = match[2]?.trim();
+  if (!toolName || !ruleContent) return trimmed;
+  return toolName;
+}
+
+// packages/tools/src/tools/ai/TaskTool/permissions.ts
+function normalizeAgentPermissionMode(mode) {
+  if (!mode) return void 0;
+  if (mode === "delegate") return "default";
+  if (mode === "default" || mode === "acceptEdits" || mode === "plan" || mode === "bypassPermissions" || mode === "dontAsk") {
+    return mode;
+  }
+  return void 0;
+}
+function applyAgentPermissionMode(base, options) {
+  if (!base) return base;
+  if (!options.agentPermissionMode) return base;
+  if (options.agentPermissionMode === "bypassPermissions" && (options.safeMode || base.isBypassPermissionsModeAvailable !== true)) {
+    return { ...base, mode: "default" };
+  }
+  return { ...base, mode: options.agentPermissionMode };
+}
+
+// packages/tools/src/tools/ai/TaskTool/callBackground.ts
+import { last } from "lodash-es";
+
+// packages/tools/src/tools/ai/TaskTool/assistantText.ts
+function asyncLaunchMessage(agentId) {
+  const toolName = "TaskOutput";
+  return `Async agent launched successfully.
+agentId: ${agentId} (This is an internal ID for your use, do not mention it to the user. Use this ID to retrieve results with ${toolName} when the agent finishes). 
+The agent is currently working in the background. If you have other tasks you you should continue working on them now. Wait to call ${toolName} until either:
+- If you want to check on the agent's progress - call ${toolName} with block=false to get an immediate update on the agent's status
+- If you run out of things to do and the agent is still running - call ${toolName} with block=true to idle and wait for the agent's result (do not use block=true unless you completely run out of things to do as it will waste time).`;
+}
+
+// packages/tools/src/tools/ai/TaskTool/callBackground.ts
+function isTextBlock(block) {
+  return Boolean(block) && typeof block === "object" && block.type === "text" && typeof block.text === "string";
+}
+async function* callTaskToolBackground(input, prepared) {
+  const bgAbortController = new AbortController();
+  const taskRecord = {
+    type: "async_agent",
+    agentId: prepared.agentId,
+    description: input.description,
+    prompt: prepared.effectivePrompt,
+    status: "running",
+    startedAt: Date.now(),
+    messages: [...prepared.transcriptMessages],
+    abortController: bgAbortController,
+    done: Promise.resolve()
+  };
+  taskRecord.done = (async () => {
+    try {
+      const bgMessages = [...prepared.messagesForQuery];
+      const bgTranscriptMessages = [
+        ...prepared.transcriptMessages
+      ];
+      for await (const msg of prepared.queryFn(
+        bgMessages,
+        prepared.systemPrompt,
+        prepared.context,
+        hasPermissionsToUseTool,
+        {
+          abortController: bgAbortController,
+          options: prepared.queryOptions,
+          messageId: getLastAssistantMessageId(bgMessages),
+          agentId: prepared.agentId,
+          readFileTimestamps: prepared.readFileTimestamps,
+          setToolJSX: () => {
+          }
+        }
+      )) {
+        bgMessages.push(msg);
+        bgTranscriptMessages.push(msg);
+        taskRecord.messages = [...bgTranscriptMessages];
+        upsertBackgroundAgentTask(taskRecord);
+      }
+      const lastAssistant = last(
+        bgTranscriptMessages.filter((m) => m.type === "assistant")
+      );
+      const content = lastAssistant?.type === "assistant" ? lastAssistant.message.content.filter(isTextBlock) : [];
+      taskRecord.status = "completed";
+      taskRecord.completedAt = Date.now();
+      taskRecord.resultText = content.map((b) => b.text).join("\n");
+      taskRecord.messages = [...bgTranscriptMessages];
+      upsertBackgroundAgentTask(taskRecord);
+      saveAgentTranscript(prepared.agentId, bgTranscriptMessages);
+    } catch (e) {
+      taskRecord.status = "failed";
+      taskRecord.completedAt = Date.now();
+      taskRecord.error = e instanceof Error ? e.message : String(e);
+      upsertBackgroundAgentTask(taskRecord);
+    }
+  })();
+  upsertBackgroundAgentTask(taskRecord);
+  const output = {
+    status: "async_launched",
+    agentId: prepared.agentId,
+    description: input.description,
+    prompt: prepared.effectivePrompt
+  };
+  yield {
+    type: "result",
+    data: output,
+    resultForAssistant: asyncLaunchMessage(prepared.agentId)
+  };
+}
+
+// packages/tools/src/tools/ai/TaskTool/callForeground.ts
+import { last as last2, memoize } from "lodash-es";
+function isTextBlock2(block) {
+  return Boolean(block) && typeof block === "object" && block.type === "text" && typeof block.text === "string";
+}
+function isToolUseLikeBlock2(block) {
+  if (!block || typeof block !== "object") return false;
+  const type = block.type;
+  if (type !== "tool_use" && type !== "server_tool_use" && type !== "mcp_tool_use") {
+    return false;
+  }
+  const name = block.name;
+  return typeof name === "string";
+}
+function truncate(text, maxLen) {
+  const normalized = text.replace(/\\s+/g, " ").trim();
+  if (normalized.length <= maxLen) return normalized;
+  return `${normalized.slice(0, maxLen - 1)}\u2026`;
+}
+function summarizeToolUse(name, rawInput) {
+  const input = rawInput && typeof rawInput === "object" ? rawInput : {};
+  switch (name) {
+    case "Read": {
+      const filePath = typeof input.file_path === "string" && input.file_path || typeof input.path === "string" && input.path || "";
+      return filePath ? `Read ${filePath}` : "Read";
+    }
+    case "Write": {
+      const filePath = typeof input.file_path === "string" && input.file_path || typeof input.path === "string" && input.path || "";
+      return filePath ? `Write ${filePath}` : "Write";
+    }
+    case "Edit":
+    case "MultiEdit": {
+      const filePath = typeof input.file_path === "string" && input.file_path || typeof input.path === "string" && input.path || "";
+      return filePath ? `${name} ${filePath}` : name;
+    }
+    case "Grep": {
+      const pattern = typeof input.pattern === "string" ? input.pattern : "";
+      return pattern ? `Grep ${truncate(pattern, 80)}` : "Grep";
+    }
+    case "Glob": {
+      const pattern = typeof input.pattern === "string" && input.pattern || typeof input.glob === "string" && input.glob || "";
+      return pattern ? `Glob ${truncate(pattern, 80)}` : "Glob";
+    }
+    case "Bash": {
+      const command = typeof input.command === "string" ? input.command : "";
+      return command ? `Bash ${truncate(command, 80)}` : "Bash";
+    }
+    case "WebFetch":
+    case "WebSearch": {
+      const url = typeof input.url === "string" ? input.url : "";
+      const query2 = typeof input.query === "string" ? input.query : "";
+      if (url) return `${name} ${truncate(url, 100)}`;
+      if (query2) return `${name} ${truncate(query2, 100)}`;
+      return name;
+    }
+    default:
+      return name;
+  }
+}
+async function* callTaskToolForeground(input, prepared) {
+  const getSidechainNumber = memoize(
+    () => getNextAvailableLogSidechainNumber(
+      prepared.messageLogName,
+      prepared.forkNumber
+    )
+  );
+  const PROGRESS_THROTTLE_MS = 200;
+  const MAX_RECENT_ACTIONS = 6;
+  let lastProgressEmitAt = 0;
+  let lastEmittedToolUseCount = 0;
+  const recentActions = [];
+  const addRecentAction = (action) => {
+    const trimmed = action.trim();
+    if (!trimmed) return;
+    recentActions.push(trimmed);
+    if (recentActions.length > MAX_RECENT_ACTIONS) {
+      recentActions.splice(0, recentActions.length - MAX_RECENT_ACTIONS);
+    }
+  };
+  const renderProgressText = (toolUseCount2) => {
+    const header = `${input.description || "Task"}\u2026 (${toolUseCount2} tool${toolUseCount2 === 1 ? "" : "s"})`;
+    if (recentActions.length === 0) return header;
+    const lines = recentActions.map((a) => `- ${a}`);
+    return [header, ...lines].join("\\n");
+  };
+  yield {
+    type: "progress",
+    content: createAssistantMessage(
+      `<tool-progress>${renderProgressText(0)}</tool-progress>`
+    )
+  };
+  lastProgressEmitAt = Date.now();
+  let toolUseCount = 0;
+  for await (const message of prepared.queryFn(
+    prepared.messagesForQuery,
+    prepared.systemPrompt,
+    prepared.context,
+    hasPermissionsToUseTool,
+    {
+      abortController: prepared.abortController,
+      options: prepared.queryOptions,
+      messageId: getLastAssistantMessageId(prepared.messagesForQuery),
+      agentId: prepared.agentId,
+      readFileTimestamps: prepared.readFileTimestamps,
+      setToolJSX: () => {
+      }
+    }
+  )) {
+    prepared.messagesForQuery.push(message);
+    prepared.transcriptMessages.push(message);
+    overwriteLog(
+      getMessagesPath(
+        prepared.messageLogName,
+        prepared.forkNumber,
+        getSidechainNumber()
+      ),
+      prepared.transcriptMessages.filter((m) => m.type !== "progress"),
+      { conversationKey: `${prepared.messageLogName}:${prepared.forkNumber}` }
+    );
+    if (message.type === "assistant") {
+      for (const block of message.message.content) {
+        if (!isToolUseLikeBlock2(block)) continue;
+        toolUseCount += 1;
+        addRecentAction(summarizeToolUse(block.name, block.input));
+      }
+    }
+    const now = Date.now();
+    const hasNewToolUses = toolUseCount > lastEmittedToolUseCount;
+    const shouldEmit = hasNewToolUses && (lastEmittedToolUseCount === 0 || now - lastProgressEmitAt >= PROGRESS_THROTTLE_MS);
+    if (shouldEmit) {
+      yield {
+        type: "progress",
+        content: createAssistantMessage(
+          `<tool-progress>${renderProgressText(toolUseCount)}</tool-progress>`
+        )
+      };
+      lastEmittedToolUseCount = toolUseCount;
+      lastProgressEmitAt = now;
+    }
+  }
+  const lastAssistant = last2(
+    prepared.transcriptMessages.filter((m) => m.type === "assistant")
+  );
+  if (!lastAssistant || lastAssistant.type !== "assistant") {
+    throw new Error("No assistant messages found");
+  }
+  const content = lastAssistant.message.content.filter(isTextBlock2);
+  const totalDurationMs = Date.now() - prepared.startTime;
+  const totalTokens = countTokens(prepared.transcriptMessages);
+  const usage = lastAssistant.message.usage;
+  const output = {
+    status: "completed",
+    agentId: prepared.agentId,
+    prompt: prepared.effectivePrompt,
+    content,
+    totalToolUseCount: toolUseCount,
+    totalDurationMs,
+    totalTokens,
+    usage
+  };
+  const agentIdBlock = {
+    type: "text",
+    text: `agentId: ${prepared.agentId} (for resuming to continue this agent's work if needed)`,
+    citations: []
+  };
+  yield {
+    type: "result",
+    data: output,
+    resultForAssistant: [...content, agentIdBlock]
+  };
+}
+
+// packages/tools/src/tools/ai/TaskTool/call.ts
+async function* callTaskTool(input, toolUseContext) {
+  const startTime = Date.now();
+  const options = toolUseContext.options ?? {};
+  const safeMode = options.safeMode ?? false;
+  const forkNumber = options.forkNumber ?? 0;
+  const messageLogName = options.messageLogName ?? "default";
+  const verbose = options.verbose ?? false;
+  const parentModel = options.model;
+  const queryFn = typeof toolUseContext.__testQuery === "function" ? toolUseContext.__testQuery : query;
+  const agentConfig = await getAgentByType(input.subagent_type);
+  if (!agentConfig) {
+    const available = await getAvailableAgentTypes();
+    throw new Error(
+      `Agent type '${input.subagent_type}' not found. Available agents: ${available.join(", ")}`
+    );
+  }
+  const effectivePrompt = input.prompt;
+  const normalizedAgentModel = normalizeAgentModelName(agentConfig.model);
+  const defaultSubagentModel = "task";
+  const envSubagentModel = process.env.KODE_SUBAGENT_MODEL ?? process.env.CLAUDE_CODE_SUBAGENT_MODEL;
+  const modelToUse = (typeof envSubagentModel === "string" && envSubagentModel.trim() ? envSubagentModel.trim() : void 0) || modelEnumToPointer(input.model) || (normalizedAgentModel === "inherit" ? parentModel || defaultSubagentModel : normalizedAgentModel) || defaultSubagentModel;
+  const toolFilter = agentConfig.tools;
+  let tools = await getTaskTools(safeMode);
+  if (toolFilter) {
+    const isAllArray = Array.isArray(toolFilter) && toolFilter.length === 1 && toolFilter[0] === "*";
+    if (toolFilter === "*" || isAllArray) {
+    } else if (Array.isArray(toolFilter)) {
+      const allowedToolNames = new Set(
+        toolFilter.map(getToolNameFromSpec).filter(Boolean)
+      );
+      tools = tools.filter((t) => allowedToolNames.has(t.name));
+    }
+  }
+  const disallowedTools = Array.isArray(agentConfig.disallowedTools) ? agentConfig.disallowedTools : [];
+  if (disallowedTools.length > 0) {
+    const disallowedToolNames = new Set(
+      disallowedTools.map(getToolNameFromSpec).filter(Boolean)
+    );
+    tools = tools.filter((t) => !disallowedToolNames.has(t.name));
+  }
+  const agentId = input.resume || generateAgentId();
+  const baseTranscript = input.resume ? getAgentTranscript(input.resume)?.filter((m) => m.type !== "progress") ?? null : [];
+  if (input.resume && baseTranscript === null) {
+    throw new Error(`No transcript found for agent ID: ${input.resume}`);
+  }
+  const { forkContextMessages, promptMessages } = buildForkContextForAgent({
+    enabled: agentConfig.forkContext === true,
+    prompt: effectivePrompt,
+    toolUseId: toolUseContext.toolUseId,
+    messageLogName,
+    forkNumber
+  });
+  const transcriptMessages = [...baseTranscript || [], ...promptMessages];
+  const messagesForQuery = [...forkContextMessages, ...transcriptMessages];
+  const [baseSystemPrompt, context, maxThinkingTokens] = await Promise.all([
+    getAgentPrompt(),
+    getContext(),
+    getMaxThinkingTokens(messagesForQuery)
+  ]);
+  const systemPrompt = agentConfig.systemPrompt && agentConfig.systemPrompt.length > 0 ? [...baseSystemPrompt, agentConfig.systemPrompt] : baseSystemPrompt;
+  const agentPermissionMode = normalizeAgentPermissionMode(
+    agentConfig.permissionMode
+  );
+  const toolPermissionContext = applyAgentPermissionMode(
+    options.toolPermissionContext,
+    {
+      agentPermissionMode,
+      safeMode
+    }
+  );
+  const queryOptions = {
+    safeMode,
+    forkNumber,
+    messageLogName,
+    tools,
+    commands: [],
+    verbose,
+    permissionMode: "dontAsk",
+    toolPermissionContext,
+    maxThinkingTokens,
+    model: modelToUse,
+    mcpClients: options.mcpClients
+  };
+  const prepared = {
+    queryFn,
+    agentId,
+    effectivePrompt,
+    systemPrompt,
+    context,
+    messagesForQuery,
+    transcriptMessages,
+    queryOptions,
+    messageLogName,
+    forkNumber,
+    abortController: toolUseContext.abortController,
+    readFileTimestamps: toolUseContext.readFileTimestamps,
+    startTime
+  };
+  if (input.run_in_background) {
+    yield* callTaskToolBackground(input, prepared);
+    return;
+  }
+  for await (const chunk of callTaskToolForeground(input, prepared)) {
+    if (chunk.type === "result") {
+      saveAgentTranscript(prepared.agentId, prepared.transcriptMessages);
+    }
+    yield chunk;
+  }
+}
+
+// packages/tools/src/tools/ai/TaskTool/schema.ts
+import { z as z8 } from "zod";
+var inputSchema8 = z8.object({
+  description: z8.string().describe("A short (3-5 word) description of the task"),
+  prompt: z8.string().describe("The task for the agent to perform"),
+  subagent_type: z8.string().describe("The type of specialized agent to use for this task"),
+  model: z8.enum(["sonnet", "opus", "haiku"]).optional().describe(
+    "Optional model to use for this agent. If not specified, inherits from parent. Prefer haiku for quick, straightforward tasks to minimize cost and latency."
+  ),
+  resume: z8.string().optional().describe(
+    "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
+  ),
+  run_in_background: z8.boolean().optional().describe(
+    "Set to true to run this agent in the background. Use TaskOutput to read the output later."
+  )
+});
+
+// packages/tools/src/tools/ai/TaskTool/render.tsx
+import React7 from "react";
+import { Box as Box6, Text as Text7 } from "ink";
+function renderTaskToolUseMessage(input) {
+  if (!input.description || !input.prompt) return "";
+  return input.description;
+}
+function renderTaskToolResultMessage(output, options) {
+  const theme = getTheme();
+  if (output.status === "async_launched") {
+    const hint = output.prompt ? " (down arrow \u2193 to manage \xB7 ctrl+o to expand)" : " (down arrow \u2193 to manage)";
+    return /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "row" }, /* @__PURE__ */ React7.createElement(Text7, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React7.createElement(Text7, null, "Backgrounded agent", !options.verbose && /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, hint))), options.verbose && output.prompt && /* @__PURE__ */ React7.createElement(
+      Box6,
+      {
+        paddingLeft: 2,
+        borderStyle: "single",
+        borderLeft: true,
+        borderTop: false,
+        borderRight: false,
+        borderBottom: false,
+        borderLeftColor: theme.secondaryBorder
+      },
+      /* @__PURE__ */ React7.createElement(Text7, { color: theme.secondaryText, wrap: "wrap" }, output.prompt)
+    ));
+  }
+  const summary = [
+    output.totalToolUseCount === 1 ? "1 tool use" : `${output.totalToolUseCount} tool uses`,
+    `${formatNumber(output.totalTokens)} tokens`,
+    formatDuration(output.totalDurationMs)
+  ];
+  return /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "column" }, options.verbose && output.prompt && /* @__PURE__ */ React7.createElement(
+    Box6,
+    {
+      paddingLeft: 2,
+      borderStyle: "single",
+      borderLeft: true,
+      borderTop: false,
+      borderRight: false,
+      borderBottom: false,
+      borderLeftColor: theme.secondaryBorder
+    },
+    /* @__PURE__ */ React7.createElement(Text7, { color: theme.secondaryText, wrap: "wrap" }, maybeTruncateVerboseToolOutput(output.prompt, {
+      maxLines: 120,
+      maxChars: 2e4
+    }).text)
+  ), options.verbose && output.content.length > 0 && /* @__PURE__ */ React7.createElement(
+    Box6,
+    {
+      paddingLeft: 2,
+      borderStyle: "single",
+      borderLeft: true,
+      borderTop: false,
+      borderRight: false,
+      borderBottom: false,
+      borderLeftColor: theme.secondaryBorder
+    },
+    /* @__PURE__ */ React7.createElement(Text7, { wrap: "wrap" }, maybeTruncateVerboseToolOutput(
+      output.content.map((b) => b.text).join("\n"),
+      { maxLines: 200, maxChars: 4e4 }
+    ).text)
+  ), /* @__PURE__ */ React7.createElement(Box6, { flexDirection: "row" }, /* @__PURE__ */ React7.createElement(Text7, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, "Done (", summary.join(" \xB7 "), ")")));
+}
+function renderTaskToolResultForAssistant(output) {
+  if (output.status === "async_launched")
+    return asyncLaunchMessage(output.agentId);
+  return output.content.map((b) => b.text).join("\n");
+}
+
+// packages/tools/src/tools/ai/TaskTool/TaskTool.tsx
+var TaskTool = {
+  name: TOOL_NAME3,
+  inputSchema: inputSchema8,
+  async description() {
+    return "Launch a new task";
+  },
+  async prompt({ safeMode }) {
+    return await getPrompt(safeMode);
+  },
+  userFacingName(input) {
+    if (input?.subagent_type && input.subagent_type !== "general-purpose") {
+      return input.subagent_type;
+    }
+    return "Task";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput(input) {
+    if (!input.description || typeof input.description !== "string") {
+      return {
+        result: false,
+        message: "Description is required and must be a string"
+      };
+    }
+    if (!input.prompt || typeof input.prompt !== "string") {
+      return {
+        result: false,
+        message: "Prompt is required and must be a string"
+      };
+    }
+    const availableTypes = await getAvailableAgentTypes();
+    if (!availableTypes.includes(input.subagent_type)) {
+      return {
+        result: false,
+        message: `Agent type '${input.subagent_type}' not found. Available agents: ${availableTypes.join(", ")}`,
+        meta: { subagent_type: input.subagent_type, availableTypes }
+      };
+    }
+    if (input.resume) {
+      const transcript = getAgentTranscript(input.resume);
+      if (!transcript) {
+        return {
+          result: false,
+          message: `No transcript found for agent ID: ${input.resume}`,
+          meta: { resume: input.resume }
+        };
+      }
+    }
+    return { result: true };
+  },
+  renderToolUseMessage: renderTaskToolUseMessage,
+  renderToolResultMessage: renderTaskToolResultMessage,
+  renderResultForAssistant: renderTaskToolResultForAssistant,
+  call: callTaskTool
+};
+
+// packages/tools/src/tools/interaction/TodoWriteTool/TodoWriteTool.tsx
+import { randomUUID as randomUUID3 } from "crypto";
+import { z as z9 } from "zod";
+
+// packages/tools/src/tools/interaction/TodoWriteTool/prompt.ts
+var DESCRIPTION8 = "Update the todo list for the current session. To be used proactively and often to track progress and pending tasks. Make sure that at least one task is in_progress at all times. Always provide both content (imperative) and activeForm (present continuous) for each task.";
+var PROMPT8 = `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Examples of When to Use the Todo List
+
+<example>
+User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
+Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
+*Creates todo list with the following items:*
+1. Creating dark mode toggle component in Settings page
+2. Adding dark mode state management (context/store)
+3. Implementing CSS-in-JS styles for dark theme
+4. Updating existing components to support theme switching
+5. Running tests and build process, addressing any failures or errors that occur
+*Begins working on the first task*
+
+<reasoning>
+The assistant used the todo list because:
+1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
+2. The user explicitly requested tests and build be run afterward
+3. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+</reasoning>
+</example>
+
+<example>
+User: Help me rename the function getCwd to getCurrentWorkingDirectory across my project
+Assistant: Let me first search through your codebase to find all occurrences of 'getCwd'.
+*Uses grep or search tools to locate all instances of getCwd in the codebase*
+Assistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.
+*Creates todo list with specific items for each file that needs updating*
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant searched to understand the scope of the task
+2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps
+3. The todo list helps ensure every instance is tracked and updated systematically
+4. This approach prevents missing any occurrences and maintains code consistency
+</reasoning>
+</example>
+
+
+<example>
+User: I need to implement these features for my e-commerce site: user registration, product catalog, shopping cart, and checkout flow.
+Assistant: I'll help implement these features. First, let's add all the features to the todo list.
+*Creates a todo list breaking down each feature into specific tasks based on the project architecture*
+Assistant: Let's start with user registration. This will involve creating database models, API endpoints, and frontend forms that integrate with your existing authentication system.
+
+<reasoning>
+The assistant used the todo list because:
+1. The user provided multiple complex features to implement in a comma separated list
+2. The todo list helps organize these large features into manageable tasks
+3. This approach allows for tracking progress across the entire implementation
+</reasoning>
+</example>
+
+<example>
+User: Can you help optimize my React application? It's rendering slowly and has performance issues.</user>
+Assistant: I'll help optimize your React application. First, let me examine your codebase to identify potential performance bottlenecks.
+*Reviews component structure, render patterns, state management, and data fetching*
+Assistant: After analyzing your codebase, I've identified several performance issues. Let me create a todo list to track our optimization efforts.
+*Creates todo list with items like: 1) Implementing memoization for expensive calculations in ProductList, 2) Adding virtualization for long lists in Dashboard, 3) Optimizing image loading in Gallery component, 4) Fixing state update loops in ShoppingCart, 5) Reviewing bundle size and implementing code splitting*
+Let's start by implementing memoization for the expensive calculations in your ProductList component.</assistant>
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant examined the codebase to identify specific performance issues
+2. Based on this analysis, it identified multiple optimization opportunities
+3. Performance optimization is a non-trivial task requiring multiple steps
+4. The todo list helps methodically track improvements across different components
+5. This systematic approach ensures all performance bottlenecks are addressed
+</reasoning>
+</example>
+
+## Examples of When NOT to Use the Todo List
+
+<example>
+User: How do I print 'Hello World' in Python?
+Assistant: In Python, you can print "Hello World" with this simple code:
+
+python
+print("Hello World")
+
+This will output the text "Hello World" to the console when executed.</assistant>
+
+<reasoning>
+The assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.
+</reasoning>
+</example>
+
+<example>
+User: What does the git status command do?
+Assistant: The git status command shows the current state of your working directory and staging area. It displays which changes have been staged, which haven't, and which files aren't being tracked by Git. This is a fundamental command for understanding the current state of your repository before making commits.
+
+<reasoning>
+The assistant did not use the todo list because this is an informational request with no actual coding task to complete. The user is simply asking for an explanation, not for the assistant to perform multiple steps or tasks.
+</reasoning>
+</example>
+
+<example>
+User: Can you add a comment to the calculateTotal function to explain what it does?
+Assistant: Sure, let me add a comment to the calculateTotal function to explain what it does.
+* Uses the Edit tool to add a comment to the calculateTotal function *
+
+<reasoning>
+The assistant did not use the todo list because this is a single, straightforward task confined to one location in the code. Adding a comment doesn't require tracking multiple steps or systematic organization.
+</reasoning>
+</example>
+
+<example>
+User: Run npm install for me and tell me what happens.
+Assistant: I'll run the npm install command for you.
+
+*Executes: npm install*
+
+The command completed successfully. Here's the output:
+[Output of npm install command]
+
+All dependencies have been installed according to your package.json file.
+
+<reasoning>
+The assistant did not use the todo list because this is a single command execution with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward task.
+</reasoning>
+</example>
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+   **IMPORTANT**: Task descriptions must have two forms:
+   - content: The imperative form describing what needs to be done (e.g., "Run tests", "Build the project")
+   - activeForm: The present continuous form shown during execution (e.g., "Running tests", "Building the project")
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Exactly ONE task must be in_progress at any time (not less, not more)
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+   - Always provide both forms:
+     - content: "Fix authentication bug"
+     - activeForm: "Fixing authentication bug"
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.
+`;
+
+// packages/tools/src/tools/interaction/TodoWriteTool/TodoWriteTool.tsx
+var TodoItemSchema = z9.object({
+  content: z9.string().min(1, "Content cannot be empty").describe("The task description or content"),
+  status: z9.enum(["pending", "in_progress", "completed"]).describe("Current status of the task"),
+  activeForm: z9.string().min(1, "Active form cannot be empty").describe('The active form of the task (e.g., "Writing tests")')
+});
+var inputSchema9 = z9.strictObject({
+  todos: z9.array(TodoItemSchema).describe("The updated todo list")
+});
+function validateTodos(todos) {
+  const inProgressTasks = todos.filter((todo) => todo.status === "in_progress");
+  if (inProgressTasks.length > 1) {
+    return {
+      result: false,
+      errorCode: 2,
+      message: "Only one task can be in_progress at a time",
+      meta: { inProgressTasks: inProgressTasks.map((t) => t.content) }
+    };
+  }
+  for (const todo of todos) {
+    if (!todo.content?.trim()) {
+      return {
+        result: false,
+        errorCode: 3,
+        message: "Todo has empty content"
+      };
+    }
+    if (!["pending", "in_progress", "completed"].includes(todo.status)) {
+      return {
+        result: false,
+        errorCode: 4,
+        message: `Invalid status "${todo.status}" for todo "${todo.content}"`,
+        meta: { invalidStatus: todo.status }
+      };
+    }
+    if (!todo.activeForm?.trim()) {
+      return {
+        result: false,
+        errorCode: 5,
+        message: "Todo has empty activeForm",
+        meta: { todoContent: todo.content }
+      };
+    }
+  }
+  return { result: true };
+}
+var TodoWriteTool = {
+  name: "TodoWrite",
+  async description() {
+    return DESCRIPTION8;
+  },
+  async prompt() {
+    return PROMPT8;
+  },
+  inputSchema: inputSchema9,
+  userFacingName() {
+    return "";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  needsPermissions() {
+    return false;
+  },
+  renderResultForAssistant() {
+    return "Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable";
+  },
+  renderToolUseMessage(input, { verbose }) {
+    return null;
+  },
+  renderToolResultMessage(_output, _options) {
+    return null;
+  },
+  async validateInput({ todos }) {
+    const validation = validateTodos(todos);
+    if (!validation.result) {
+      return validation;
+    }
+    return { result: true };
+  },
+  async *call({ todos }, context) {
+    const agentId = context?.agentId;
+    if (agentId) {
+      startWatchingTodoFile(agentId);
+    }
+    const previousTodos = getTodos(agentId);
+    const oldTodos = previousTodos.map((todo) => ({
+      content: todo.content,
+      status: todo.status,
+      activeForm: todo.activeForm || todo.content
+    }));
+    const shouldClear = todos.length > 0 && todos.every((todo) => todo.status === "completed");
+    const reusable = /* @__PURE__ */ new Map();
+    for (const todo of previousTodos) {
+      const key = `${todo.content}|||${todo.activeForm || todo.content}`;
+      const list = reusable.get(key) ?? [];
+      list.push(todo);
+      reusable.set(key, list);
+    }
+    const todoItems = shouldClear ? [] : todos.map((todo) => {
+      const key = `${todo.content}|||${todo.activeForm}`;
+      const list = reusable.get(key);
+      const reused = list && list.length > 0 ? list.shift() : void 0;
+      return {
+        id: reused?.id ?? randomUUID3(),
+        content: todo.content,
+        status: todo.status,
+        activeForm: todo.activeForm,
+        priority: reused?.priority ?? "medium",
+        ...reused?.createdAt ? { createdAt: reused.createdAt } : {}
+      };
+    });
+    try {
+      setTodos(todoItems, agentId);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+      emitReminderEvent("todo:error", {
+        error: errorMessage,
+        timestamp: Date.now(),
+        agentId: context?.agentId || "default",
+        context: "TodoWriteTool.call"
+      });
+      throw error instanceof Error ? error : new Error(errorMessage);
+    }
+    const hasChanged = JSON.stringify(previousTodos) !== JSON.stringify(todoItems);
+    if (hasChanged) {
+      emitReminderEvent("todo:changed", {
+        previousTodos,
+        newTodos: todoItems,
+        timestamp: Date.now(),
+        agentId: agentId || "default",
+        changeType: todoItems.length > previousTodos.length ? "added" : todoItems.length < previousTodos.length ? "removed" : "modified"
+      });
+    }
+    yield {
+      type: "result",
+      data: {
+        oldTodos,
+        newTodos: todos,
+        agentId: agentId || void 0
+      },
+      resultForAssistant: this.renderResultForAssistant()
+    };
+  }
+};
+
+// packages/tools/src/tools/search/WebSearchTool/WebSearchTool.tsx
+import { Box as Box7, Text as Text8 } from "ink";
+import React8 from "react";
+import { z as z10 } from "zod";
+
+// packages/tools/src/tools/search/WebSearchTool/prompt.ts
+var TOOL_NAME_FOR_PROMPT4 = "WebSearch";
+function todayISO() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+var PROMPT9 = `
+- Allows the assistant to search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
+- Use this tool for accessing information beyond the model's knowledge cutoff
+- Searches are performed automatically within a single API call
+
+CRITICAL REQUIREMENT - You MUST follow this:
+  - After answering the user's question, you MUST include a "Sources:" section at the end of your response
+  - In the Sources section, list all relevant URLs from the search results as markdown hyperlinks: [Title](URL)
+  - This is MANDATORY - never skip including sources in your response
+  - Example format:
+
+    [Your answer here]
+
+    Sources:
+    - [Source Title 1](https://example.com/1)
+    - [Source Title 2](https://example.com/2)
+
+Usage notes:
+  - Domain filtering is supported to include or block specific websites
+  - Web search is only available in the US
+
+IMPORTANT - Use the correct year in search queries:
+  - Today's date is ${todayISO()}. You MUST use this year when searching for recent information, documentation, or current events.
+  - Example: If today is 2025-07-15 and the user asks for "latest React docs", search for "React documentation 2025", NOT "React documentation 2024"
+`.trim();
+
+// packages/tools/src/tools/search/WebSearchTool/searchProviders.ts
+import { parse } from "node-html-parser";
+var duckDuckGoSearchProvider = {
+  isEnabled: () => true,
+  search: async (query2) => {
+    const response = await fetch(
+      `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query2)}`,
+      {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `DuckDuckGo search failed with status: ${response.status}`
+      );
+    }
+    const html = await response.text();
+    const root = parse(html);
+    const results = [];
+    const resultNodes = root.querySelectorAll(".result.web-result");
+    for (const node of resultNodes) {
+      const titleNode = node.querySelector(".result__a");
+      const snippetNode = node.querySelector(".result__snippet");
+      if (titleNode && snippetNode) {
+        const title = titleNode.text;
+        const link = titleNode.getAttribute("href");
+        const snippet = snippetNode.text;
+        if (title && link && snippet) {
+          let cleanLink = link;
+          if (link.startsWith("https://duckduckgo.com/l/?uddg=")) {
+            try {
+              const url = new URL(link);
+              cleanLink = url.searchParams.get("uddg") || link;
+            } catch {
+              cleanLink = link;
+            }
+          }
+          results.push({
+            title: title.trim(),
+            snippet: snippet.trim(),
+            link: cleanLink
+          });
+        }
+      }
+    }
+    return results;
+  }
+};
+var searchProviders = {
+  duckduckgo: duckDuckGoSearchProvider
+};
+
+// packages/tools/src/tools/search/WebSearchTool/WebSearchTool.tsx
+var inputSchema10 = z10.strictObject({
+  query: z10.string().min(2).describe("The search query to use"),
+  allowed_domains: z10.array(z10.string()).optional().describe("Only include search results from these domains"),
+  blocked_domains: z10.array(z10.string()).optional().describe("Never include search results from these domains")
+});
+function hostnameForUrl(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return null;
+  }
+}
+function summarizeResults(results) {
+  let searchCount = 0;
+  let totalResultCount = 0;
+  for (const item of results) {
+    if (typeof item === "string") continue;
+    searchCount += 1;
+    totalResultCount += item.content.length;
+  }
+  return { searchCount, totalResultCount };
+}
+var WebSearchTool = {
+  name: TOOL_NAME_FOR_PROMPT4,
+  async description(input) {
+    const query2 = input?.query ?? "";
+    return `Requesting web search for: ${query2}`;
+  },
+  userFacingName: () => "Web Search",
+  inputSchema: inputSchema10,
+  isReadOnly: () => true,
+  isConcurrencySafe: () => true,
+  async isEnabled() {
+    return true;
+  },
+  needsPermissions() {
+    return true;
+  },
+  async prompt() {
+    return PROMPT9;
+  },
+  renderToolUseMessage({ query: query2, allowed_domains, blocked_domains }, { verbose }) {
+    let summary = `"${query2}"`;
+    if (verbose) {
+      if (allowed_domains && allowed_domains.length > 0) {
+        summary += `, only allowing domains: ${allowed_domains.join(", ")}`;
+      }
+      if (blocked_domains && blocked_domains.length > 0) {
+        summary += `, blocking domains: ${blocked_domains.join(", ")}`;
+      }
+    }
+    return summary;
+  },
+  renderToolResultMessage(output) {
+    const { searchCount } = summarizeResults(output.results);
+    const duration = output.durationSeconds >= 1 ? `${Math.round(output.durationSeconds)}s` : `${Math.round(output.durationSeconds * 1e3)}ms`;
+    return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "row" }, /* @__PURE__ */ React8.createElement(Text8, null, "\xA0\xA0\u23BF \xA0Did "), /* @__PURE__ */ React8.createElement(Text8, { bold: true }, searchCount, " "), /* @__PURE__ */ React8.createElement(Text8, null, "search", searchCount === 1 ? "" : "es", " in ", duration));
+  },
+  renderResultForAssistant(output) {
+    let result = `Web search results for query: "${output.query}"
+
+`;
+    for (const item of output.results) {
+      if (typeof item === "string") {
+        result += `${item}
+
+`;
+        continue;
+      }
+      if (item.content.length > 0) {
+        result += `Links: ${JSON.stringify(item.content)}
+
+`;
+      } else {
+        result += `No links found.
+
+`;
+      }
+    }
+    result += "\nREMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks.";
+    return result.trim();
+  },
+  async validateInput(input) {
+    if (!input.query || !input.query.length) {
+      return {
+        result: false,
+        message: "Error: Missing query",
+        errorCode: 1
+      };
+    }
+    if (input.allowed_domains?.length && input.blocked_domains?.length) {
+      return {
+        result: false,
+        message: "Error: Cannot specify both allowed_domains and blocked_domains in the same request",
+        errorCode: 2
+      };
+    }
+    return { result: true };
+  },
+  async *call({ query: query2, allowed_domains, blocked_domains }, {}) {
+    const start = Date.now();
+    try {
+      const rawResults = await searchProviders.duckduckgo.search(query2);
+      const allowed = allowed_domains?.map((d) => d.toLowerCase()) ?? null;
+      const blocked = blocked_domains?.map((d) => d.toLowerCase()) ?? null;
+      const results = rawResults.filter((result) => {
+        const host = hostnameForUrl(result.link)?.toLowerCase();
+        if (!host) return false;
+        if (allowed && allowed.length > 0) {
+          return allowed.some(
+            (domain) => host === domain || host.endsWith(`.${domain}`)
+          );
+        }
+        if (blocked && blocked.length > 0) {
+          return !blocked.some(
+            (domain) => host === domain || host.endsWith(`.${domain}`)
+          );
+        }
+        return true;
+      });
+      const hits = results.map((item) => ({
+        title: item.title,
+        url: item.link
+      }));
+      const output = {
+        query: query2,
+        results: [
+          {
+            tool_use_id: "duckduckgo",
+            content: hits
+          }
+        ],
+        durationSeconds: (Date.now() - start) / 1e3
+      };
+      yield {
+        type: "result",
+        resultForAssistant: this.renderResultForAssistant(output),
+        data: output
+      };
+    } catch (error) {
+      const output = {
+        query: query2,
+        results: [
+          `Web search error: ${error instanceof Error ? error.message : String(error)}`
+        ],
+        durationSeconds: (Date.now() - start) / 1e3
+      };
+      yield {
+        type: "result",
+        resultForAssistant: this.renderResultForAssistant(output),
+        data: output
+      };
+    }
+  }
+};
+
+// packages/tools/src/registry.ts
+var getAllTools = () => [
+  TaskTool,
+  AskExpertModelTool,
+  BashTool,
+  TaskOutputTool,
+  KillShellTool,
+  GlobTool,
+  GrepTool,
+  LspTool,
+  FileReadTool,
+  FileEditTool,
+  FileWriteTool,
+  NotebookEditTool,
+  TodoWriteTool,
+  WebSearchTool,
+  WebFetchTool,
+  AskUserQuestionTool,
+  EnterPlanModeTool,
+  ExitPlanModeTool,
+  SlashCommandTool,
+  SkillTool,
+  ListMcpResourcesTool,
+  ReadMcpResourceTool,
+  MCPTool
+];
+var getTools = memoize2(
+  async (_includeOptional) => {
+    const tools = [...getAllTools(), ...await getMCPTools()];
+    const isEnabled = await Promise.all(tools.map((tool) => tool.isEnabled()));
+    return tools.filter((_, i) => isEnabled[i]);
+  }
+);
+var getReadOnlyTools = memoize2(async () => {
+  const tools = getAllTools().filter((tool) => tool.isReadOnly());
+  const isEnabled = await Promise.all(tools.map((tool) => tool.isEnabled()));
+  return tools.filter((_, index) => isEnabled[index]);
+});
+
+export {
+  getAllTools,
+  getTools,
+  getReadOnlyTools
+};