pybao-cli 1.5.29 → 1.5.32

package/dist/chunk-KULZBCG2.js

@@ -1,4510 +0,0 @@
-import { createRequire as __pybCreateRequire } from "node:module";
-const require = __pybCreateRequire(import.meta.url);
-import {
-  AskUserQuestionTool,
-  BashTool,
-  Cost,
-  FileEditTool,
-  FileReadTool,
-  FileWriteTool,
-  GlobTool,
-  GrepTool,
-  KillShellTool,
-  NotebookEditTool,
-  SkillTool,
-  SlashCommandTool,
-  TASK_FORK_CONTEXT_POLICY,
-  WebFetchTool,
-  WebSearchTool,
-  applyMarkdown,
-  buildTaskAsyncPolicy,
-  buildTaskGraph,
-  countTokens,
-  createTask,
-  findTaskCycles,
-  generateTaskListId,
-  getAgentMemoryDir,
-  getAgentPrompt,
-  getMaxThinkingTokens,
-  getProjectMemoryDir,
-  getTask,
-  getTaskListPaths,
-  hasPermissionsToUseTool,
-  hasReadPermission,
-  hasWritePermission,
-  listTasks,
-  query,
-  recordFileEdit,
-  resolveAutoMemoryFlags,
-  resolveMemoryPath,
-  resolveProjectId,
-  runWithTaskListEnv,
-  runWithTaskListId,
-  updateTask
-} from "./chunk-ANFFZEQ4.js";
-import {
-  getCurrentSessionId
-} from "./chunk-XKYHFZEC.js";
-import {
-  queryLLM
-} from "./chunk-6RLACN3L.js";
-import {
-  FallbackToolUseRejectedMessage,
-  MCPTool,
-  getClients,
-  getMCPTools
-} from "./chunk-S2BNVKP7.js";
-import {
-  emitReminderEvent
-} from "./chunk-QV6RSIUH.js";
-import {
-  getActiveAgents,
-  getAgentByType,
-  getAvailableAgentTypes
-} from "./chunk-UKI67LME.js";
-import {
-  INTERRUPT_MESSAGE,
-  createAssistantMessage,
-  createUserMessageFromBlocks,
-  createUserMessageFromText,
-  getLastAssistantMessageId
-} from "./chunk-GZF3L435.js";
-import {
-  formatDuration,
-  formatNumber
-} from "./chunk-OUXHGDLH.js";
-import {
-  getAbsolutePath
-} from "./chunk-3T43I32F.js";
-import {
-  LspFacade,
-  formatDiagnosticsPretty
-} from "./chunk-X475W4F6.js";
-import {
-  getModelManager
-} from "./chunk-S6PNHDVA.js";
-import {
-  getContext
-} from "./chunk-ZD4WAFPC.js";
-import {
-  getTheme
-} from "./chunk-F3Z46DHI.js";
-import {
-  debug
-} from "./chunk-VTTBOI63.js";
-import {
-  BunShell,
-  MEMORY_DIR,
-  getCwd,
-  getMessagesPath,
-  getNextAvailableLogSidechainNumber,
-  getSessionRoot,
-  logError,
-  overwriteLog,
-  readTaskOutput,
-  resolveXdgDataPath
-} from "./chunk-VUSYHIJA.js";
-
-// src/tools/index.ts
-import { memoize as memoize2 } from "lodash-es";
-
-// src/tools/ai/AskExpertModelTool/AskExpertModelTool.tsx
-import * as React from "react";
-import { Box, Text } from "ink";
-import { z } from "zod";
-
-// src/utils/session/expertChatStorage.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { randomUUID } from "crypto";
-function getExpertChatDirectory() {
-  const override = process.env.ANYKODE_CONFIG_DIR?.trim();
-  const expertChatDir = override ? join(override, "expert-chats") : resolveXdgDataPath("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 || [];
-}
-
-// src/tools/ai/AskExpertModelTool/AskExpertModelTool.tsx
-var inputSchema = z.strictObject({
-  question: z.string().describe(
-    "COMPLETE SELF-CONTAINED QUESTION: Must include full background context, relevant details, and a clear independent question. The expert model will receive ONLY this content with no access to previous conversation or external context. Structure as: 1) Background/Context 2) Specific situation/problem 3) Clear question. Ensure the expert can fully understand and respond without needing additional information."
-  ),
-  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(
-    'Chat session ID: use "new" for new session or existing session ID'
-  )
-});
-var AskExpertModelTool = {
-  name: "AskExpertModel",
-  async description() {
-    return "Consult external AI models for expert opinions and analysis";
-  },
-  async prompt() {
-    return `Ask a question to a specific external AI model for expert analysis.
-
-This tool allows you to consult different AI models for their unique perspectives and expertise.
-
-CRITICAL REQUIREMENT FOR QUESTION PARAMETER:
-The question MUST be completely self-contained and include:
-1. FULL BACKGROUND CONTEXT - All relevant information the expert needs
-2. SPECIFIC SITUATION - Clear description of the current scenario/problem
-3. INDEPENDENT QUESTION - What exactly you want the expert to analyze/answer
-
-The expert model receives ONLY your question content with NO access to:
-- Previous conversation history (unless using existing session)  
-- Current codebase or file context
-- User's current task or project details
-
-IMPORTANT: This tool is for asking questions to models, not for task execution.
-- Use when you need a specific model's opinion or analysis
-- Use when you want to compare different models' responses
-- Use the @ask-[model] format when available
-
-The expert_model parameter accepts:
-- OpenAI: gpt-4, gpt-5, o1-preview
-- Messages API: claude-3-5-sonnet, claude-3-opus  
-- Others: kimi, gemini-pro, mixtral
-
-Example of well-structured question:
-"Background: I'm working on a React TypeScript application with performance issues. The app renders a large list of 10,000 items using a simple map() function, causing UI freezing.
-
-Current situation: Users report 3-5 second delays when scrolling through the list. The component re-renders the entire list on every state change.
-
-Question: What are the most effective React optimization techniques for handling large lists, and how should I prioritize implementing virtualization vs memoization vs other approaches?"`;
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  inputSchema,
-  userFacingName() {
-    return "AskExpertModel";
-  },
-  async isEnabled() {
-    return true;
-  },
-  needsPermissions() {
-    return false;
-  },
-  async validateInput({ question, expert_model, chat_session_id }, context) {
-    if (!question.trim()) {
-      return { result: false, message: "Question cannot be empty" };
-    }
-    if (!expert_model.trim()) {
-      return { result: false, message: "Expert model must be specified" };
-    }
-    if (!chat_session_id.trim()) {
-      return {
-        result: false,
-        message: 'Chat session ID must be specified (use "new" for new session)'
-      };
-    }
-    try {
-      const modelManager = getModelManager();
-      let currentModel;
-      if (context?.agentId && context?.options?.model) {
-        currentModel = context.options.model;
-      } else {
-        currentModel = modelManager.getModelName("main") || "";
-      }
-      const normalizedExpert = expert_model.toLowerCase().replace(/[^a-z0-9]/g, "");
-      const normalizedCurrent = currentModel.toLowerCase().replace(/[^a-z0-9]/g, "");
-      if (normalizedExpert === normalizedCurrent) {
-        return {
-          result: false,
-          message: `You are already running as ${currentModel}. Consulting the same model would be redundant. Please choose a different model or handle the task directly.`
-        };
-      }
-    } catch (e) {
-      debug.error("AskExpertModel", {
-        message: "Could not determine current model",
-        error: e
-      });
-    }
-    try {
-      const modelManager = getModelManager();
-      const modelResolution = modelManager.resolveModelWithInfo(expert_model);
-      if (!modelResolution.success) {
-        const availableModels = modelManager.getAllAvailableModelNames();
-        if (availableModels.length > 0) {
-          return {
-            result: false,
-            message: `Model '${expert_model}' is not configured. Available models: ${availableModels.join(", ")}. Check if any available model closely matches the user's request (e.g., 'kimi' matches 'kimi-k2-0711-preview'). If there's a strong match, auto retry using the correct model name. If no close match exists, inform the user that '${expert_model}' needs to be configured using /model command.`
-          };
-        } else {
-          return {
-            result: false,
-            message: `Model '${expert_model}' not found and no models are currently configured in the system. Inform the user that models need to be configured first using the /model command.`
-          };
-        }
-      }
-    } catch (error) {
-      logError(error);
-      return {
-        result: false,
-        message: `Failed to validate expert model '${expert_model}'. Please check your model configuration.`
-      };
-    }
-    return { result: true };
-  },
-  renderToolUseMessage({ question, expert_model, chat_session_id }, { verbose }) {
-    if (!question || !expert_model) return null;
-    const isNewSession = chat_session_id === "new";
-    const sessionDisplay = isNewSession ? "new session" : `session ${chat_session_id.substring(0, 5)}...`;
-    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 }, sessionDisplay), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.text }, question.length > 300 ? question.substring(0, 300) + "..." : 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, dimColor: true }, "(", sessionDisplay, ")"));
-  },
-  renderToolResultMessage(content) {
-    const verbose = true;
-    const theme = getTheme();
-    if (typeof content === "object" && content && "expertAnswer" in content) {
-      const expertResult = content;
-      const isError = expertResult.expertAnswer.startsWith("Error") || expertResult.expertAnswer.includes("failed");
-      const isInterrupted = expertResult.chatSessionId === "interrupted";
-      if (isInterrupted) {
-        return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "Consultation interrupted"));
-      }
-      const answerText = verbose ? expertResult.expertAnswer.trim() : expertResult.expertAnswer.length > 500 ? expertResult.expertAnswer.substring(0, 500) + "..." : expertResult.expertAnswer.trim();
-      if (isError) {
-        return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: "red" }, answerText));
-      }
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: theme.text }, "Response from ", expertResult.expertModelName, ":"), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.text }, applyMarkdown(answerText))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText, dimColor: true }, "Session: ", expertResult.chatSessionId.substring(0, 8))));
-    }
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "Consultation completed"));
-  },
-  renderResultForAssistant(output) {
-    return `[Expert consultation completed]
-Expert Model: ${output.expertModelName}
-Session ID: ${output.chatSessionId}
-To continue this conversation with context preservation, use this Session ID in your next AskExpertModel call to maintain the full conversation history and context.
-
-${output.expertAnswer}`;
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  async *call({ question, expert_model, chat_session_id }, { abortController, readFileTimestamps }) {
-    const expertModel = expert_model;
-    let sessionId;
-    let isInterrupted = false;
-    const abortListener = () => {
-      isInterrupted = true;
-    };
-    abortController.signal.addEventListener("abort", abortListener);
-    try {
-      if (abortController.signal.aborted) {
-        return yield* this.handleInterrupt();
-      }
-      if (chat_session_id === "new") {
-        try {
-          const session = createExpertChatSession(expertModel);
-          sessionId = session.sessionId;
-        } catch (error) {
-          logError(error);
-          throw new Error("Failed to create new chat session");
-        }
-      } else {
-        sessionId = chat_session_id;
-        try {
-          const session = loadExpertChatSession(sessionId);
-          if (!session) {
-            const newSession = createExpertChatSession(expertModel);
-            sessionId = newSession.sessionId;
-          }
-        } catch (error) {
-          logError(error);
-          try {
-            const newSession = createExpertChatSession(expertModel);
-            sessionId = newSession.sessionId;
-          } catch (createError) {
-            logError(createError);
-            throw new Error("Unable to create or load chat session");
-          }
-        }
-      }
-      if (isInterrupted || abortController.signal.aborted) {
-        return yield* this.handleInterrupt();
-      }
-      let historyMessages;
-      try {
-        historyMessages = getSessionMessages(sessionId);
-      } catch (error) {
-        logError(error);
-        historyMessages = [];
-      }
-      const messages = [...historyMessages, { role: "user", content: question }];
-      let systemMessages;
-      try {
-        systemMessages = messages.map(
-          (msg) => msg.role === "user" ? createUserMessageFromText(msg.content) : createAssistantMessage(msg.content)
-        );
-      } catch (error) {
-        logError(error);
-        throw new Error("Failed to prepare conversation messages");
-      }
-      if (isInterrupted || abortController.signal.aborted) {
-        return yield* this.handleInterrupt();
-      }
-      yield {
-        type: "progress",
-        content: createAssistantMessage(
-          `Connecting to ${expertModel}... (timeout: 5 minutes)`
-        )
-      };
-      let response;
-      try {
-        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 timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(
-              new Error(
-                `Expert model query timed out after ${timeoutMs / 1e3}s`
-              )
-            );
-          }, timeoutMs);
-        });
-        response = await Promise.race([
-          queryLLM(
-            systemMessages,
-            [],
-            0,
-            [],
-            abortController.signal,
-            {
-              safeMode: false,
-              model: expertModel,
-              prependCLISysprompt: false
-            }
-          ),
-          timeoutPromise
-        ]);
-      } catch (error) {
-        logError(error);
-        if (error.name === "AbortError" || abortController.signal?.aborted || isInterrupted) {
-          return yield* this.handleInterrupt();
-        }
-        if (error.message?.includes("timed out")) {
-          throw new Error(
-            `Expert model '${expertModel}' timed out after 5 minutes.
-
-Suggestions:
-  - The model might be experiencing high load
-  - Try a different model or retry later
-  - Consider breaking down your question into smaller parts`
-          );
-        }
-        if (error.message?.includes("rate limit")) {
-          throw new Error(
-            `Rate limit exceeded for ${expertModel}.
-
-Please wait a moment and try again, or use a different model.`
-          );
-        }
-        if (error.message?.includes("invalid api key")) {
-          throw new Error(
-            `Invalid API key for ${expertModel}.
-
-Please check your model configuration with /model command.`
-          );
-        }
-        if (error.message?.includes("model not found") || error.message?.includes("Failed to resolve model")) {
-          try {
-            const modelManager = getModelManager();
-            const availableModels = modelManager.getAllAvailableModelNames();
-            if (availableModels.length > 0) {
-              throw new Error(
-                `Model '${expertModel}' is not configured. Available models: ${availableModels.join(", ")}. Check if any available model closely matches the user's request (e.g., 'kimi' matches 'kimi-k2-0711-preview'). If there's a strong match, auto retry using the correct model name. If no close match exists, inform the user that '${expertModel}' needs to be configured using /model command.`
-              );
-            } else {
-              throw new Error(
-                `Model '${expertModel}' not found and no models are currently configured in the system. Inform the user that models need to be configured first using the /model command.`
-              );
-            }
-          } catch (modelError) {
-            throw new Error(
-              `Model '${expertModel}' not found. Please check model configuration or inform user about the issue.`
-            );
-          }
-        }
-        throw new Error(
-          `Expert model query failed: ${error.message || "Unknown error"}`
-        );
-      }
-      let expertAnswer;
-      try {
-        if (!response?.message?.content) {
-          throw new Error("No content in expert response");
-        }
-        expertAnswer = response.message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-        if (!expertAnswer.trim()) {
-          throw new Error("Expert response was empty");
-        }
-      } catch (error) {
-        logError(error);
-        throw new Error("Failed to process expert response");
-      }
-      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: this.renderResultForAssistant(result)
-      };
-    } catch (error) {
-      if (error.name === "AbortError" || abortController.signal?.aborted || isInterrupted) {
-        return yield* this.handleInterrupt();
-      }
-      logError(error);
-      const errorSessionId = sessionId || "error-session";
-      const errorMessage = error.message || "Expert consultation failed with unknown error";
-      const result = {
-        chatSessionId: errorSessionId,
-        expertModelName: expertModel,
-        expertAnswer: `\u274C ${errorMessage}`
-      };
-      yield {
-        type: "result",
-        data: result,
-        resultForAssistant: this.renderResultForAssistant(result)
-      };
-    } finally {
-      abortController.signal.removeEventListener("abort", abortListener);
-    }
-  },
-  async *handleInterrupt() {
-    yield {
-      type: "result",
-      data: {
-        chatSessionId: "interrupted",
-        expertModelName: "cancelled",
-        expertAnswer: INTERRUPT_MESSAGE
-      },
-      resultForAssistant: INTERRUPT_MESSAGE
-    };
-  }
-};
-
-// src/tools/system/TaskOutputTool/TaskOutputTool.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import React2 from "react";
-import { z as z2 } from "zod";
-
-// src/utils/session/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);
-}
-
-// src/utils/tooling/toolOutputDisplay.ts
-function isTruthyEnv(value) {
-  if (!value) return false;
-  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
-}
-function isPackagedRuntime() {
-  if (isTruthyEnv(process.env.PYB_PACKAGED)) return true;
-  try {
-    const exec = (process.execPath || "").split(/[\\/]/).pop()?.toLowerCase();
-    if (!exec) return false;
-    if (exec === "bun" || exec === "bun.exe") return false;
-    if (exec === "node" || exec === "node.exe") return false;
-    return true;
-  } catch {
-    return false;
-  }
-}
-function truncateTextForDisplay(text, options) {
-  const maxLines = options?.maxLines ?? 120;
-  const maxChars = options?.maxChars ?? 12e3;
-  const normalized = String(text ?? "");
-  const lines = normalized.split(/\r?\n/);
-  let workingLines = lines;
-  let omittedLines = 0;
-  if (maxLines > 0 && lines.length > maxLines) {
-    workingLines = lines.slice(0, maxLines);
-    omittedLines = lines.length - maxLines;
-  }
-  let workingText = workingLines.join("\n");
-  let omittedChars = 0;
-  if (maxChars > 0 && workingText.length > maxChars) {
-    omittedChars = workingText.length - maxChars;
-    workingText = workingText.slice(0, maxChars);
-  }
-  const truncated = omittedLines > 0 || omittedChars > 0;
-  if (!truncated) {
-    return {
-      text: workingText,
-      truncated: false,
-      omittedLines: 0,
-      omittedChars: 0
-    };
-  }
-  const suffixParts = [];
-  if (omittedLines > 0) {
-    suffixParts.push(`${omittedLines} lines`);
-  }
-  if (omittedChars > 0) {
-    suffixParts.push(`${omittedChars} chars`);
-  }
-  const suffix = `
-
-... [truncated ${suffixParts.join(" \xB7 ")}] ...`;
-  return {
-    text: workingText + suffix,
-    truncated: true,
-    omittedLines,
-    omittedChars
-  };
-}
-function maybeTruncateVerboseToolOutput(text, options) {
-  const maxLinesEnv = Number(process.env.PYB_TOOL_OUTPUT_MAX_LINES ?? "");
-  const maxCharsEnv = Number(process.env.PYB_TOOL_OUTPUT_MAX_CHARS ?? "");
-  const envOverrides = {
-    maxLines: Number.isFinite(maxLinesEnv) && maxLinesEnv > 0 ? maxLinesEnv : void 0,
-    maxChars: Number.isFinite(maxCharsEnv) && maxCharsEnv > 0 ? maxCharsEnv : void 0
-  };
-  const effective = {
-    maxLines: envOverrides.maxLines ?? options?.maxLines,
-    maxChars: envOverrides.maxChars ?? options?.maxChars
-  };
-  const fullAllowed = isTruthyEnv(process.env.PYB_TOOL_OUTPUT_FULL);
-  if (!isPackagedRuntime() || fullAllowed) {
-    return { text: String(text ?? ""), truncated: false };
-  }
-  const result = truncateTextForDisplay(String(text ?? ""), effective);
-  return { text: result.text, truncated: result.truncated };
-}
-
-// src/tools/system/TaskOutputTool/prompt.ts
-var TOOL_NAME_FOR_PROMPT = "TaskOutput";
-var DESCRIPTION = "Retrieves output from a running or completed task";
-var PROMPT = `- 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`;
-
-// src/tools/system/TaskOutputTool/TaskOutputTool.tsx
-var TOOL_PROGRESS_OPEN_TAG = ["<tool", "-progress>"].join("");
-var TOOL_PROGRESS_CLOSE_TAG = ["</tool", "-progress>"].join("");
-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"),
-  analyze: z2.boolean().optional().describe("Analyze the output for errors and warnings")
-});
-function isTaskOutputLspAnalysisEnabled() {
-  const raw = String(process.env.PYB_TASKOUTPUT_LSP_ANALYSIS ?? "").trim().toLowerCase();
-  if (!raw) return false;
-  if (raw === "1" || raw === "true" || raw === "on" || raw === "yes")
-    return true;
-  if (raw === "0" || raw === "false" || raw === "off" || raw === "no")
-    return false;
-  return false;
-}
-function normalizeTaskOutputInput(input) {
-  const task_id = typeof input.task_id === "string" && input.task_id || typeof input.agentId === "string" && String(input.agentId) || typeof input.bash_id === "string" && String(input.bash_id) || "";
-  const block = typeof input.block === "boolean" ? input.block : true;
-  const analyze = typeof input.analyze === "boolean" ? input.analyze : false;
-  const timeout = typeof input.timeout === "number" ? input.timeout : typeof input.wait_up_to === "number" ? Number(input.wait_up_to) * 1e3 : 3e4;
-  return { task_id, block, timeout, analyze };
-}
-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 analyzeOutputWithLsp(output, exitCode) {
-  const errorCount = (output.match(/Error:/gi) || []).length;
-  const warningCount = (output.match(/Warning:/gi) || []).length;
-  let summary = "";
-  if (exitCode === 0) {
-    summary = "Success";
-  } else if (exitCode !== void 0 && exitCode !== null) {
-    summary = `Failed (Exit Code: ${exitCode})`;
-  } else {
-    summary = "Completed";
-  }
-  const parts = [summary];
-  if (errorCount > 0) parts.push(`${errorCount} Error${errorCount === 1 ? "" : "s"}`);
-  if (warningCount > 0) parts.push(`${warningCount} Warning${warningCount === 1 ? "" : "s"}`);
-  if (!isTaskOutputLspAnalysisEnabled()) {
-    parts.push("LSP Analysis: disabled");
-    return parts.join(", ");
-  }
-  if (exitCode === 0 && errorCount === 0 && warningCount === 0) {
-    parts.push("LSP Analysis: skipped");
-    return parts.join(", ");
-  }
-  if (exitCode !== 0 || errorCount > 0 || warningCount > 0) {
-    try {
-      const { isAbsolute: isAbsolute2, resolve: resolve3 } = await import("path");
-      const { getSessionRoot: getSessionRoot2 } = await import("./state-PQJJ3JAM.js");
-      const lines = output.split("\n");
-      const uniqueFiles = /* @__PURE__ */ new Set();
-      const lspSuggestions = [];
-      const pathRegex = /(?:[a-zA-Z]:\\|(?:\/|\\))?[\w\-\.]+(?:(?:\/|\\)[\w\-\.]+)+\.(?:ts|tsx|js|jsx|py|java|cs|cpp|c|rs|go)(?::\d+|:\d+:\d+|\(\d+,\d+\))/g;
-      for (const line of lines) {
-        const matches = line.match(pathRegex);
-        if (matches) {
-          for (const match of matches) {
-            let cleanPath = match;
-            if (cleanPath.includes("(")) {
-              cleanPath = cleanPath.split("(")[0];
-            } else {
-              cleanPath = cleanPath.replace(/:\d+(?::\d+)?$/, "");
-            }
-            uniqueFiles.add(cleanPath);
-          }
-        }
-      }
-      if (uniqueFiles.size === 0) {
-        parts.push("LSP Analysis: no files detected");
-        return parts.join(", ");
-      }
-      for (const file of uniqueFiles) {
-        try {
-          const absPath = isAbsolute2(file) ? file : resolve3(getSessionRoot2(), file);
-          await LspFacade.run({
-            operation: "diagnostics",
-            filePath: absPath,
-            waitForDiagnostics: true,
-            timeoutMs: 2e3,
-            rootPath: getSessionRoot2()
-          });
-          const diagnostics = await LspFacade.diagnostics(absPath, {
-            rootPath: getSessionRoot2()
-          });
-          if (diagnostics && diagnostics.length > 0) {
-            const pretty = formatDiagnosticsPretty(diagnostics, { maxItems: 3 });
-            if (pretty) {
-              lspSuggestions.push(`LSP Diagnostics for ${file}:`);
-              lspSuggestions.push(pretty);
-            }
-          }
-        } catch (e) {
-          console.error("LSP Analysis Error:", e);
-        }
-      }
-      if (lspSuggestions.length > 0) {
-        parts.push("\nLSP Analysis:\n" + lspSuggestions.join("\n"));
-      } else {
-        parts.push("LSP Analysis: no diagnostics");
-      }
-    } catch (e) {
-      console.error("LSP Analysis Setup Error:", e);
-    }
-  }
-  return parts.join(", ");
-}
-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((resolve3) => setTimeout(resolve3, 100));
-  }
-  return buildTaskSummary(taskId);
-}
-var TaskOutputTool = {
-  name: TOOL_NAME_FOR_PROMPT,
-  async description() {
-    return DESCRIPTION;
-  },
-  userFacingName() {
-    return "Task Output";
-  },
-  inputSchema: inputSchema2,
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  async isEnabled() {
-    return true;
-  },
-  needsPermissions() {
-    return false;
-  },
-  async prompt() {
-    return PROMPT;
-  },
-  renderToolUseMessage(input) {
-    const normalized = normalizeTaskOutputInput(input);
-    if (!normalized.block) return "non-blocking";
-    return "";
-  },
-  renderToolUseRejectedMessage() {
-    return null;
-  },
-  renderToolResultMessage(output, { verbose }) {
-    const theme = getTheme();
-    if (output.retrieval_status === "timeout" || output.retrieval_status === "not_ready") {
-      return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, "Task is still running\u2026"));
-    }
-    if (!output.task) {
-      return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, "No task output available"));
-    }
-    if (output.task.task_type === "local_agent") {
-      const lines = output.task.result ? output.task.result.split("\n").length : 0;
-      if (!verbose) {
-        return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, "Read output (ctrl+o to expand)"));
-      }
-      return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, null, output.task.description, " (", lines, " lines)"), output.task.prompt ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: 2 }, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, output.task.prompt)) : null, output.task.result ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, maybeTruncateVerboseToolOutput(output.task.result, {
-        maxLines: 200,
-        maxChars: 4e4
-      }).text)) : null, output.task.error ? /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1, paddingLeft: 2 }, /* @__PURE__ */ React2.createElement(Text2, { color: theme.error, bold: true }, "Error:"), /* @__PURE__ */ React2.createElement(Text2, { color: theme.error }, output.task.error)) : null);
-    }
-    const content = output.task.output?.trimEnd() ?? "";
-    if (!verbose) {
-      return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, content.length > 0 ? "Read output (ctrl+o to expand)" : "(No content)"));
-    }
-    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, output.task.description), content ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, maybeTruncateVerboseToolOutput(content, {
-      maxLines: 200,
-      maxChars: 4e4
-    }).text)) : 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>`);
-      }
-      if (output.task.analysis) {
-        parts.push(`<analysis>${output.task.analysis}</analysis>`);
-      }
-    }
-    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 analyze = normalized.analyze;
-    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";
-      if (analyze) {
-        initial.analysis = await analyzeOutputWithLsp(initial.output || "", initial.exitCode);
-      }
-      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_OPEN_TAG}${initial.description ? `  ${initial.description}
-` : ""}     Waiting for task (esc to give additional instructions)${TOOL_PROGRESS_CLOSE_TAG}`
-      )
-    };
-    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;
-    }
-    if (analyze) {
-      finalTask.analysis = await analyzeOutputWithLsp(finalTask.output || "", finalTask.exitCode);
-    }
-    const out = { retrieval_status: "success", task: finalTask };
-    yield {
-      type: "result",
-      data: out,
-      resultForAssistant: this.renderResultForAssistant(out)
-    };
-  }
-};
-
-// src/tools/filesystem/DeleteTool/DeleteTool.tsx
-import { rmSync, existsSync as existsSync2, statSync } from "fs";
-import { Box as Box3, Text as Text3 } from "ink";
-import * as React3 from "react";
-import { z as z3 } from "zod";
-import { isAbsolute, relative, resolve } from "path";
-
-// src/tools/filesystem/DeleteTool/prompt.ts
-var PROMPT2 = `You can use this tool to delete files (regular file or directory), you can delete multi files in one toolcall, and you MUST make sure the files is exist before deleting.
-When you need to delete file, you MUST use this tool to delete file instead of using shell.
-
-Usage:
-- The file_paths parameter must be an array of absolute paths.
-- Supports recursive deletion for directories (be careful!).
-- Safe and cross-platform (works on Windows/Linux/Mac).
-- Do NOT use BashTool/RunCommand with 'rm', 'del', or 'rmdir'.
-
-Examples:
-
-<example_single>
-// Deleting a single file
-Delete({
-  file_paths: ["/absolute/path/to/file.txt"]
-})
-</example_single>
-
-<example_force>
-// Deleting a file that might be referenced
-Delete({
-  file_paths: ["/absolute/path/to/shared.ts"],
-  force: true
-})
-</example_force>
-
-<example_directory>
-// Deleting a directory recursively
-Delete({
-  file_paths: ["/absolute/path/to/directory"]
-})
-</example_directory>
-
-<example_batch>
-// Deleting multiple files and directories in one go
-Delete({
-  file_paths: [
-    "/absolute/path/to/file1.txt",
-    "/absolute/path/to/file2.log",
-    "/absolute/path/to/temp_directory"
-  ]
-})
-</example_batch>
-`.trim();
-
-// src/tools/filesystem/DeleteTool/DeleteTool.tsx
-var inputSchema3 = z3.strictObject({
-  file_paths: z3.array(z3.string()).describe(
-    "The list of file paths you want to delete, you MUST set file path to absolute path."
-  ),
-  force: z3.boolean().optional().describe(
-    "Force deletion even if the file is referenced by other files (LSP check)."
-  )
-});
-var DeleteTool = {
-  name: "Delete",
-  async description() {
-    return "Use this tool to delete files or directories. ALWAYS use this tool instead of running shell commands (like 'rm', 'del') to ensure cross-platform compatibility and safety. Supports deleting multiple paths at once.";
-  },
-  userFacingName: () => "Delete",
-  async prompt() {
-    return PROMPT2;
-  },
-  inputSchema: inputSchema3,
-  async isEnabled() {
-    return true;
-  },
-  isReadOnly() {
-    return false;
-  },
-  isConcurrencySafe() {
-    return false;
-  },
-  needsPermissions({ file_paths }) {
-    return file_paths.some((path) => !hasWritePermission(path));
-  },
-  renderToolUseMessage(input, { verbose }) {
-    const paths = input.file_paths.map(
-      (p) => verbose ? p : relative(getCwd(), p)
-    ).join(", ");
-    return `Deleting: ${paths}`;
-  },
-  renderToolResultMessage(output) {
-    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, output.deleted.length > 0 && /* @__PURE__ */ React3.createElement(Text3, null, "Deleted: ", output.deleted.join(", ")), output.failed.length > 0 && /* @__PURE__ */ React3.createElement(Text3, { color: getTheme().warning }, "Failed to delete: ", output.failed.join(", ")));
-  },
-  renderResultForAssistant(output) {
-    const parts = [];
-    if (output.deleted.length > 0) parts.push(`Deleted files: ${output.deleted.join(", ")}`);
-    if (output.failed.length > 0) parts.push(`Failed to delete files: ${output.failed.join(", ")}`);
-    return parts.join("\n");
-  },
-  renderToolUseRejectedMessage({ file_paths } = {}, { columns, verbose } = {}) {
-    if (!file_paths || file_paths.length === 0) {
-      return /* @__PURE__ */ React3.createElement(FallbackToolUseRejectedMessage, null);
-    }
-    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, null, "  ", "\u23BF", " ", /* @__PURE__ */ React3.createElement(Text3, { color: getTheme().error }, "User rejected deletion of ", file_paths.length, " items")));
-  },
-  async *call({ file_paths, force }, context) {
-    const verbose = context.options?.verbose || false;
-    const deletedItems = [];
-    const failedItems = [];
-    for (const rawPath of file_paths) {
-      const fullPath = isAbsolute(rawPath) ? rawPath : resolve(getCwd(), rawPath);
-      try {
-        if (!existsSync2(fullPath)) {
-          failedItems.push(`${rawPath} (not found)`);
-          continue;
-        }
-        if (!force) {
-          try {
-            const { LspFacade: LspFacade2 } = await import("./lsp-SQBHGEL7.js");
-            const referenceDetail = await LspFacade2.checkFileReferences(fullPath);
-            if (referenceDetail) {
-              failedItems.push(
-                `${rawPath} (Safety Check Failed: ${referenceDetail}. Use 'force: true' to override.)`
-              );
-              continue;
-            }
-          } catch (e) {
-            if (!force) {
-              failedItems.push(
-                `${rawPath} (Safety Check Failed: Internal LSP Error. Use 'force: true' to override.)`
-              );
-              continue;
-            }
-          }
-        }
-        const root = resolve(fullPath, "/");
-        if (fullPath === root) {
-          throw new Error("Cannot delete filesystem root");
-        }
-        const stats = statSync(fullPath);
-        const type = stats.isDirectory() ? "directory" : "file";
-        rmSync(fullPath, { recursive: true, force: true });
-        deletedItems.push(`${rawPath} (${type})`);
-      } catch (err) {
-        logError(err);
-        failedItems.push(`${rawPath} (${err.message})`);
-      }
-    }
-    const result = {
-      deleted: deletedItems,
-      failed: failedItems
-    };
-    if (deletedItems.length > 0 || failedItems.length > 0) {
-      yield {
-        type: "result",
-        data: result,
-        resultForAssistant: this.renderResultForAssistant(result)
-      };
-    }
-    return;
-  }
-};
-
-// src/tools/mcp/ListMcpResourcesTool/ListMcpResourcesTool.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import React4 from "react";
-import { z as z4 } from "zod";
-import { ListResourcesResultSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// src/tools/mcp/ListMcpResourcesTool/prompt.ts
-var TOOL_NAME = "ListMcpResourcesTool";
-var DESCRIPTION2 = `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 PROMPT3 = `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.`;
-
-// src/tools/mcp/ListMcpResourcesTool/ListMcpResourcesTool.tsx
-var inputSchema4 = z4.strictObject({
-  server: z4.string().optional().describe("Optional server name to filter resources by")
-});
-var ListMcpResourcesTool = {
-  name: TOOL_NAME,
-  async description() {
-    return DESCRIPTION2;
-  },
-  async prompt() {
-    return PROMPT3;
-  },
-  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 = context?.options?.mcpClients ?? await getClients();
-    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";
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React4.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  renderToolResultMessage(output) {
-    return /* @__PURE__ */ React4.createElement(Box4, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text4, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React4.createElement(Text4, { bold: true }, output.length), /* @__PURE__ */ React4.createElement(Text4, null, " resources")), /* @__PURE__ */ React4.createElement(Cost, { costUSD: 0, durationMs: 0, debug: false }));
-  },
-  renderResultForAssistant(output) {
-    return JSON.stringify(output);
-  },
-  async *call({ server }, context) {
-    const clients = context.options?.mcpClients ?? await getClients();
-    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();
-          } 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)
-    };
-  }
-};
-
-// src/tools/search/LspTool/LspTool.tsx
-import { existsSync as existsSync3, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { Box as Box5, Text as Text5 } from "ink";
-import { relative as relative2, resolve as resolve2 } from "path";
-import React5 from "react";
-import { z as z5 } from "zod";
-
-// src/tools/search/LspTool/prompt.ts
-var TOOL_NAME_FOR_PROMPT2 = "LSP";
-var PROMPT4 = `Interact with Language Server Protocol (LSP) servers to get code intelligence features.Supports all languages.
-
-## Capabilities & Scenarios
-This tool acts as your "Code Analyst". Use it to understand the codebase semantically, rather than just matching text.
-
-### 1. Tracing Logic (Where does this go?)
-- **Scenario**: You see a function call \`calculateTax(amount)\` and need to know its formula.
-- **Action**: Use \`goToDefinition\` on the function name.
-- **Why**: It jumps directly to the implementation, even if it's imported from another file.
-
-### 2. Impact Analysis (What uses this?)
-- **Scenario**: You are planning to rename or modify the \`User\` class.
-- **Action**: Use \`findReferences\` at the symbol position (line + character) in the file where \`User\` is declared or used.
-- **Why**: It lists every file and line where \`User\` is referenced, ensuring you don't break dependents.
-
-### 3. Exploring New Files (What's in here?)
-- **Scenario**: You just opened a large file \`utils.ts\` and want a quick overview.
-- **Action**: Use \`documentSymbol\`.
-- **Why**: It returns a structured outline (Classes, Functions, Variables) using LspFacade policy: LSP-first for accuracy, Tree-Sitter fallback for speed when needed.
-
-### 4. Interface Implementation (Who implements this?)
-- **Scenario**: You see an interface \`IStorage\` and want to find the concrete class (e.g., \`S3Storage\`).
-- **Action**: Use \`goToImplementation\`.
-- **Why**: Grep might just find the import; LSP finds the actual code that implements the interface.
-
-### 5. Scope Analysis (What is visible here?)
-- **Scenario**: You are debugging a closure or nested function and want to know which variables are captured or locally defined.
-- **Action**: Use \`getScope\`.
-- **Why**: It returns the local variables and closure captures at the current position. Essential for debugging Python closures or JavaScript lexical scopes.
-
-### 6. Real-time Diagnostics (Is this correct?)
-- **Scenario**: You just edited a file and want to verify if you introduced any syntax errors.
-- **Action**: Use \`diagnostics\` with \`waitForDiagnostics: true\`.
-- **Why**: It waits for the language server to re-analyze the file and returns fresh errors/warnings. This is your "Self-Correction" mechanism.
-
-### 7. Workspace Symbol Search (Where is this symbol?)
-- **Scenario**: You need to find a class or function across the entire project.
-- **Action**: Use \`workspaceSymbol\` with a query string and a scoped filePath (module or directory).
-- **Why**: It searches across all files in the scope. **Important**: Must provide a scoped path to avoid unbounded full-repo queries.
-
-## Supported Operations
-
-### Location-Based Operations (require line + character)
-These 8 operations require precise symbol position:
-- \`goToDefinition\`: Find where a symbol is defined
-- \`findReferences\`: Find all references to a symbol
-- \`hover\`: Get hover information (documentation, type info) for a symbol
-- \`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
-- \`getScope\`: Get local variables and closure captures at a position
-
-### Document-Level Operations (no position required)
-- \`documentSymbol\`: Get all symbols (functions, classes, variables) in a document
-- \`diagnostics\`: Get validation errors and warnings for a file (supports waiting for fresh results)
-
-### Workspace-Level Operations
-- \`workspaceSymbol\`: Search for symbols across the entire workspace (requires query + scoped filePath)
-
-## Parameters
-
-All operations require:
-- \`filePath\`: The file or directory to operate on
-
-Location-based operations require:
-- \`line\`: The line number (1-based, as shown in editors)
-- \`character\`: The character offset (1-based, as shown in editors)
-
-\`workspaceSymbol\` requires:
-- \`query\`: The symbol name or keyword to search for
-
-Optional:
-- \`waitForDiagnostics\`: If true, wait for fresh diagnostics (used with "diagnostics" operation)
-- \`timeout\`: Timeout in milliseconds for waiting operations (default: 5000)
-
-## Intelligent Position Handling
-
-**Do not pass a symbol name.** LSPTool works on positions, not names. Use Read to locate the symbol and derive line + character first.
-
-### Auto-Adjustment Mechanism
-If the specified position is not on a valid symbol, the tool automatically searches for the nearest valid token:
-- **Search scope**: Current line, then previous line, then next line
-- **Priority**: Current line tokens are preferred (lower score)
-- **Skipped tokens**: Keywords (function, class, if, for, return, etc.) and operators (=, =>, +, -, &&, ||, etc.) are automatically skipped
-- **If no valid token found**: Returns an error message
-
-### Best Practice for Position
-1. Use Read to open the file and locate the symbol
-2. Provide accurate 1-based line and character offset
-3. Position should be on the symbol name itself, not on keywords/operators
-4. If unsure, position at the start of the symbol name
-
-## Workflow & Scope Guidelines
-- **Priority order**: documentSymbol \u2192 hotspot detection \u2192 Read \u2192 LSP (ensure line + character)
-- **workspaceSymbol**: Must provide scoped filePath (module or directory), avoid unbounded full-repo queries
-- **documentSymbol**: Uses LspFacade policy (LSP-first for accuracy, Tree-Sitter fallback for speed)
-
-Note: LSP servers are automatically managed and installed for most languages. For system-level languages (like C++, Java), ensure the corresponding tools (clangd, jdtls) are in your PATH.`;
-var DESCRIPTION3 = PROMPT4;
-
-// src/tools/search/LspTool/LspTool.tsx
-var inputSchema5 = z5.strictObject({
-  operation: z5.enum([
-    "goToDefinition",
-    "findReferences",
-    "hover",
-    "documentSymbol",
-    "workspaceSymbol",
-    "goToImplementation",
-    "prepareCallHierarchy",
-    "incomingCalls",
-    "outgoingCalls",
-    "getScope",
-    "diagnostics"
-  ]).describe("The LSP operation to perform"),
-  filePath: z5.string().describe("The absolute or relative path to the file"),
-  line: z5.number().int().positive().optional().describe("The line number (1-based, as shown in editors). Required for location-based operations."),
-  character: z5.number().int().positive().optional().describe("The character offset (1-based, as shown in editors). Required for location-based operations."),
-  query: z5.string().optional().describe('The query string for workspaceSymbol. Required when operation is "workspaceSymbol".'),
-  waitForDiagnostics: z5.boolean().optional().describe('If true, wait for fresh diagnostics from the server (used with "diagnostics" operation)'),
-  timeout: z5.number().optional().describe("Timeout in milliseconds for waiting operations (default: 5000)")
-});
-var outputSchema = z5.object({
-  operation: z5.enum([
-    "goToDefinition",
-    "findReferences",
-    "hover",
-    "documentSymbol",
-    "workspaceSymbol",
-    "goToImplementation",
-    "prepareCallHierarchy",
-    "incomingCalls",
-    "outgoingCalls",
-    "getScope",
-    "diagnostics"
-  ]).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 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" },
-  getScope: { singular: "scope", plural: "scopes" },
-  diagnostics: { singular: "diagnostic", plural: "diagnostics" }
-};
-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 getTokensForLine(line) {
-  const tokenRe = /[\w$'!]+|[+\-*/%&|^~<>=]+/g;
-  const tokens = [];
-  let match;
-  while ((match = tokenRe.exec(line)) !== null) {
-    tokens.push({
-      token: match[0],
-      start: match.index,
-      end: match.index + match[0].length
-    });
-  }
-  return tokens;
-}
-function isValidToken(token) {
-  const lowered = token.toLowerCase();
-  if (KEYWORD_TOKENS.has(lowered)) return false;
-  if (OPERATOR_TOKENS.has(token)) return false;
-  return true;
-}
-function findNearestValidTokenPosition(lines, zeroBasedLine, zeroBasedCharacter) {
-  const offsets = [0, -1, 1];
-  let best = null;
-  for (const offset of offsets) {
-    const lineIndex = zeroBasedLine + offset;
-    if (lineIndex < 0 || lineIndex >= lines.length) continue;
-    const lineText = lines[lineIndex];
-    if (!lineText || lineText.length === 0) continue;
-    const clampedChar = Math.min(
-      Math.max(zeroBasedCharacter, 0),
-      Math.max(lineText.length - 1, 0)
-    );
-    const tokens = getTokensForLine(lineText).filter(
-      (token) => isValidToken(token.token)
-    );
-    for (const token of tokens) {
-      const distance = clampedChar >= token.start && clampedChar < token.end ? 0 : Math.min(
-        Math.abs(clampedChar - token.start),
-        Math.abs(clampedChar - (token.end - 1))
-      );
-      const score = distance + Math.abs(offset) * 1e3;
-      if (!best || score < best.score) {
-        best = {
-          line: lineIndex,
-          character: token.start,
-          token: token.token,
-          score
-        };
-      }
-    }
-  }
-  if (!best) return null;
-  return { line: best.line, character: best.character, token: best.token };
-}
-var KEYWORD_TOKENS = /* @__PURE__ */ new Set([
-  "export",
-  "import",
-  "from",
-  "as",
-  "return",
-  "if",
-  "else",
-  "for",
-  "while",
-  "switch",
-  "case",
-  "break",
-  "continue",
-  "function",
-  "class",
-  "interface",
-  "type",
-  "enum",
-  "const",
-  "let",
-  "var",
-  "new",
-  "extends",
-  "implements",
-  "try",
-  "catch",
-  "finally",
-  "throw",
-  "await",
-  "async",
-  "yield",
-  "default",
-  "in",
-  "of",
-  "do",
-  "this",
-  "super",
-  "private",
-  "public",
-  "protected",
-  "static",
-  "get",
-  "set",
-  "readonly",
-  "abstract",
-  "declare",
-  "namespace",
-  "module",
-  "package",
-  "true",
-  "false",
-  "null",
-  "undefined"
-]);
-var OPERATOR_TOKENS = /* @__PURE__ */ new Set([
-  "=",
-  "==",
-  "===",
-  "!=",
-  "!==",
-  "=>",
-  "+",
-  "-",
-  "*",
-  "/",
-  "%",
-  "&&",
-  "||",
-  "!",
-  "<",
-  ">",
-  "<=",
-  ">=",
-  "??",
-  "?.",
-  "::",
-  ":",
-  ";",
-  ",",
-  ".",
-  "..."
-]);
-function getPositionGuardMessage(token, line, character) {
-  if (!token) {
-    if (line !== void 0 && character !== void 0) {
-      return `Invalid position: no symbol at ${line}:${character}.`;
-    }
-    return "Invalid position: no symbol detected.";
-  }
-  const lowered = token.toLowerCase();
-  if (KEYWORD_TOKENS.has(lowered)) {
-    return `Invalid position: keyword "${token}".`;
-  }
-  if (OPERATOR_TOKENS.has(token)) {
-    return `Invalid position: operator "${token}".`;
-  }
-  return null;
-}
-function toProjectRelativeIfPossible(filePath) {
-  const cwd = getCwd();
-  try {
-    const rel = relative2(cwd, filePath);
-    if (!rel || rel === "") return filePath;
-    if (rel.startsWith("..")) return filePath;
-    return rel;
-  } catch {
-    return filePath;
-  }
-}
-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__ */ React5.createElement(Text5, null, "Hover info ", label.special);
-  }
-  return /* @__PURE__ */ React5.createElement(Text5, null, "Found ", /* @__PURE__ */ React5.createElement(Text5, { bold: true }, resultCount), " ", noun, fileCount > 1 ? /* @__PURE__ */ React5.createElement(React5.Fragment, null, " ", "across ", /* @__PURE__ */ React5.createElement(Text5, { bold: true }, fileCount), " files") : null);
-}
-var LspTool = {
-  name: TOOL_NAME_FOR_PROMPT2,
-  async description() {
-    return DESCRIPTION3;
-  },
-  async prompt() {
-    return PROMPT4;
-  },
-  inputSchema: inputSchema5,
-  userFacingName() {
-    return "LSP";
-  },
-  async isEnabled() {
-    return true;
-  },
-  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 needsLocation = input.operation === "goToDefinition" || input.operation === "findReferences" || input.operation === "hover" || input.operation === "goToImplementation" || input.operation === "prepareCallHierarchy" || input.operation === "incomingCalls" || input.operation === "outgoingCalls" || input.operation === "getScope";
-    if (needsLocation && (input.line === void 0 || input.character === void 0)) {
-      return {
-        result: false,
-        message: `Operation ${input.operation} requires line and character`,
-        errorCode: 5
-      };
-    }
-    const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
-    if (input.operation === "workspaceSymbol") {
-      const scopedPath = resolve2(absPath);
-      const cwd = getCwd();
-      if (scopedPath === cwd) {
-        return {
-          result: false,
-          message: "workspaceSymbol requires a scoped path (module or directory)",
-          errorCode: 6
-        };
-      }
-    }
-    if (!existsSync3(absPath)) {
-      return {
-        result: false,
-        message: `File does not exist: ${input.filePath}`,
-        errorCode: 1
-      };
-    }
-    try {
-      if (input.operation !== "workspaceSymbol" && !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(", ");
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React5.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  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__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text5, null, "\xA0\xA0\u23BF \xA0"), summarizeToolResult(
-        output.operation,
-        output.resultCount,
-        output.fileCount
-      )), display ? /* @__PURE__ */ React5.createElement(Box5, { marginLeft: 5 }, /* @__PURE__ */ React5.createElement(Text5, null, display.text)) : null);
-    }
-    return /* @__PURE__ */ React5.createElement(Box5, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text5, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React5.createElement(Text5, null, output.result)));
-  },
-  renderResultForAssistant(output) {
-    return output.result;
-  },
-  async *call(input, _context) {
-    const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
-    const needsLocation = input.operation === "goToDefinition" || input.operation === "findReferences" || input.operation === "hover" || input.operation === "goToImplementation" || input.operation === "prepareCallHierarchy" || input.operation === "incomingCalls" || input.operation === "outgoingCalls" || input.operation === "getScope";
-    let adjustedLine = input.line;
-    let adjustedCharacter = input.character;
-    if (needsLocation && (input.line === void 0 || input.character === void 0)) {
-      const out2 = {
-        operation: input.operation,
-        result: "Missing line/character. Use Read to locate the symbol and provide 1-based line + character.",
-        filePath: input.filePath
-      };
-      yield { type: "result", data: out2, resultForAssistant: out2.result };
-      return;
-    }
-    if (needsLocation && input.line !== void 0 && input.character !== void 0) {
-      try {
-        const content = readFileSync2(absPath, "utf8");
-        const lines = content.split("\n");
-        const token = extractSymbolAtPosition(
-          lines,
-          input.line - 1,
-          input.character - 1
-        );
-        const guardMessage = getPositionGuardMessage(
-          token,
-          input.line,
-          input.character
-        );
-        if (guardMessage) {
-          const fallback = findNearestValidTokenPosition(
-            lines,
-            input.line - 1,
-            input.character - 1
-          );
-          if (!fallback) {
-            const out2 = {
-              operation: input.operation,
-              result: guardMessage,
-              filePath: input.filePath
-            };
-            yield { type: "result", data: out2, resultForAssistant: out2.result };
-            return;
-          }
-          adjustedLine = fallback.line + 1;
-          adjustedCharacter = fallback.character + 1;
-        }
-      } catch {
-      }
-    }
-    if (input.operation === "workspaceSymbol") {
-      if (!input.query || input.query.trim() === "") {
-        const out2 = {
-          operation: input.operation,
-          result: "Missing query. Provide a workspaceSymbol query string.",
-          filePath: input.filePath
-        };
-        yield { type: "result", data: out2, resultForAssistant: out2.result };
-        return;
-      }
-    }
-    const workspaceRoot = input.operation === "workspaceSymbol" ? statSync2(absPath).isDirectory() ? absPath : getSessionRoot() : void 0;
-    const targetPath = input.operation === "workspaceSymbol" ? absPath : absPath;
-    const formattedResult = await LspFacade.run({
-      operation: input.operation,
-      filePath: targetPath,
-      line: adjustedLine,
-      character: adjustedCharacter,
-      waitForDiagnostics: input.waitForDiagnostics,
-      timeoutMs: input.timeout,
-      query: input.operation === "workspaceSymbol" ? input.query : void 0,
-      rootPath: workspaceRoot
-    });
-    const out = {
-      operation: input.operation,
-      result: formattedResult.formatted,
-      filePath: input.filePath,
-      resultCount: formattedResult.resultCount,
-      fileCount: formattedResult.fileCount
-    };
-    yield { type: "result", data: out, resultForAssistant: out.result };
-  }
-};
-
-// src/tools/mcp/ReadMcpResourceTool/ReadMcpResourceTool.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import React6 from "react";
-import { z as z6 } from "zod";
-import { ReadResourceResultSchema } from "@modelcontextprotocol/sdk/types.js";
-
-// src/tools/mcp/ReadMcpResourceTool/prompt.ts
-var TOOL_NAME2 = "ReadMcpResourceTool";
-var DESCRIPTION4 = `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 PROMPT5 = `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`;
-
-// src/tools/mcp/ReadMcpResourceTool/ReadMcpResourceTool.tsx
-var inputSchema6 = z6.strictObject({
-  server: z6.string().describe("The MCP server name"),
-  uri: z6.string().describe("The resource URI to read")
-});
-var ReadMcpResourceTool = {
-  name: TOOL_NAME2,
-  async description() {
-    return DESCRIPTION4;
-  },
-  async prompt() {
-    return PROMPT5;
-  },
-  inputSchema: inputSchema6,
-  userFacingName() {
-    return "readMcpResource";
-  },
-  async isEnabled() {
-    return true;
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  needsPermissions() {
-    return false;
-  },
-  async validateInput({ server }, context) {
-    const clients = context?.options?.mcpClients ?? await getClients();
-    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();
-      } 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}"`;
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React6.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  renderToolResultMessage(output) {
-    const count = output.contents?.length ?? 0;
-    return /* @__PURE__ */ React6.createElement(Box6, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React6.createElement(Box6, { 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"})` : "")), /* @__PURE__ */ React6.createElement(Cost, { costUSD: 0, durationMs: 0, debug: false }));
-  },
-  renderResultForAssistant(output) {
-    return JSON.stringify(output);
-  },
-  async *call({ server, uri }, context) {
-    const clients = context.options?.mcpClients ?? await getClients();
-    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();
-      } 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)
-    };
-  }
-};
-
-// src/tools/agent/TaskTool/TaskTool.tsx
-import { last, memoize } from "lodash-es";
-import React7 from "react";
-import { Box as Box7, Text as Text7 } from "ink";
-import { z as z7 } from "zod";
-import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-
-// src/utils/agent/storage.ts
-import { randomUUID as randomUUID2 } from "crypto";
-function getDefaultAgentId() {
-  return "default";
-}
-function resolveAgentId(agentId) {
-  return agentId || getDefaultAgentId();
-}
-function generateAgentId() {
-  return randomUUID2();
-}
-
-// src/utils/agent/transcripts.ts
-var transcripts = /* @__PURE__ */ new Map();
-function saveAgentTranscript(agentId, messages) {
-  transcripts.set(agentId, messages);
-}
-function getAgentTranscript(agentId) {
-  return transcripts.get(agentId);
-}
-
-// src/tools/agent/TaskTool/prompt.ts
-var SUBAGENT_DISALLOWED_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "Task",
-  "TaskOutput",
-  "KillShell",
-  "AskUserQuestion",
-  "MemoryRead",
-  "MemoryWrite"
-]);
-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>`;
-}
-
-// src/tools/agent/TaskTool/constants.ts
-var TOOL_NAME3 = "Task";
-
-// src/tools/agent/TaskTool/TaskTool.tsx
-var inputSchema7 = z7.object({
-  description: z7.string().describe("A short (3-5 word) description of the task"),
-  prompt: z7.string().describe("The task for the agent to perform"),
-  subagent_type: z7.string().describe("The type of specialized agent to use for this task"),
-  model: z7.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: z7.string().optional().describe(
-    "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
-  ),
-  run_in_background: z7.boolean().optional().describe(
-    "Set to true to run this agent in the background. Use TaskOutput to read the output later."
-  )
-});
-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;
-}
-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;
-}
-function asyncLaunchMessage(agentId) {
-  return buildTaskAsyncPolicy(agentId);
-}
-var FORK_CONTEXT_TOOL_RESULT_TEXT = TASK_FORK_CONTEXT_POLICY;
-var TOOL_PROGRESS_OPEN_TAG2 = ["<tool", "-progress>"].join("");
-var TOOL_PROGRESS_CLOSE_TAG2 = ["</tool", "-progress>"].join("");
-function resolveParentSessionId(toolUseContext) {
-  const direct = typeof toolUseContext?.sessionId === "string" ? toolUseContext.sessionId.trim() : "";
-  if (direct) return direct;
-  const active = getCurrentSessionId();
-  if (typeof active === "string" && active.trim()) {
-    return active.trim();
-  }
-  return void 0;
-}
-function normalizeAgentPermissionMode(mode) {
-  if (typeof mode !== "string") return void 0;
-  const trimmed = mode.trim();
-  if (!trimmed) return void 0;
-  if (trimmed === "delegate") return "default";
-  if (trimmed === "default" || trimmed === "acceptEdits" || trimmed === "plan" || trimmed === "bypassPermissions" || trimmed === "dontAsk") {
-    return trimmed;
-  }
-  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 };
-}
-function readJsonArrayFile(path) {
-  if (!existsSync4(path)) return null;
-  try {
-    const raw = readFileSync3(path, "utf8");
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function buildForkContextForAgent(options) {
-  const userPromptMessage = createUserMessageFromText(options.prompt);
-  if (!options.enabled || !options.toolUseId) {
-    return {
-      forkContextMessages: [],
-      promptMessages: [userPromptMessage]
-    };
-  }
-  const mainPath = getMessagesPath(options.messageLogName, options.forkNumber, 0);
-  const mainMessages = readJsonArrayFile(mainPath);
-  if (!mainMessages || 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) => b && b.type === "tool_use" && 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 = {
-    ...toolUseMessage,
-    uuid: randomUUID3(),
-    message: {
-      ...toolUseMessage.message,
-      content: [taskToolUseBlock]
-    }
-  };
-  const forkContextToolResult = createUserMessageFromBlocks(
-    [
-      {
-        type: "tool_result",
-        tool_use_id: taskToolUseBlock.id,
-        content: FORK_CONTEXT_TOOL_RESULT_TEXT
-      }
-    ],
-    {
-      data: {
-        status: "sub_agent_entered",
-        description: "Entered sub-agent context",
-        message: FORK_CONTEXT_TOOL_RESULT_TEXT
-      },
-      resultForAssistant: FORK_CONTEXT_TOOL_RESULT_TEXT
-    }
-  );
-  return {
-    forkContextMessages,
-    promptMessages: [toolUseOnlyAssistant, forkContextToolResult, userPromptMessage]
-  };
-}
-var TaskTool = {
-  name: TOOL_NAME3,
-  inputSchema: inputSchema7,
-  async description() {
-    return "Delegate complex, multi-step work to specialized agents";
-  },
-  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({ description, prompt }) {
-    if (!description || !prompt) return "";
-    return description;
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React7.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  renderToolResultMessage(output, { verbose }) {
-    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(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "row" }, /* @__PURE__ */ React7.createElement(Text7, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React7.createElement(Text7, null, "Backgrounded agent", !verbose && /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, hint))), verbose && output.prompt && /* @__PURE__ */ React7.createElement(
-        Box7,
-        {
-          paddingLeft: 2,
-          borderLeftStyle: "single",
-          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(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "row" }, /* @__PURE__ */ React7.createElement(Text7, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, "Done (", summary.join(" \xB7 "), ")")));
-  },
-  renderResultForAssistant(output) {
-    if (output.status === "async_launched")
-      return asyncLaunchMessage(output.agentId);
-    return output.content.map((b) => b.text).join("\n");
-  },
-  async *call(input, toolUseContext) {
-    const startTime = Date.now();
-    const {
-      abortController,
-      toolUseId,
-      options: {
-        safeMode = false,
-        forkNumber,
-        messageLogName,
-        verbose,
-        model: parentModel,
-        mcpClients
-      },
-      readFileTimestamps
-    } = toolUseContext;
-    const queryFn = typeof toolUseContext?.__testQuery === "function" ? toolUseContext.__testQuery : query;
-    const agentConfig = await getAgentByType(input.subagent_type);
-    if (!agentConfig) {
-      const available = await getAvailableAgentTypes();
-      throw 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.PYB_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 parentSessionId = resolveParentSessionId(toolUseContext);
-    const childSessionId = agentId;
-    const taskListId = generateTaskListId();
-    const baseTranscript = input.resume ? getAgentTranscript(input.resume)?.filter((m) => m.type !== "progress") ?? null : [];
-    if (input.resume && baseTranscript === null) {
-      throw Error(`No transcript found for agent ID: ${input.resume}`);
-    }
-    const { forkContextMessages, promptMessages } = buildForkContextForAgent({
-      enabled: agentConfig.forkContext === true,
-      prompt: effectivePrompt,
-      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(
-      toolUseContext.options?.toolPermissionContext,
-      { agentPermissionMode, safeMode }
-    );
-    const queryOptions = {
-      safeMode,
-      forkNumber,
-      messageLogName,
-      tools,
-      commands: [],
-      verbose,
-      permissionMode: "dontAsk",
-      toolPermissionContext,
-      maxThinkingTokens,
-      model: modelToUse,
-      mcpClients
-    };
-    if (input.run_in_background) {
-      const bgAbortController = new AbortController();
-      const taskRecord = {
-        type: "async_agent",
-        agentId,
-        description: input.description,
-        prompt: effectivePrompt,
-        status: "running",
-        startedAt: Date.now(),
-        messages: [...transcriptMessages],
-        abortController: bgAbortController,
-        done: Promise.resolve()
-      };
-      taskRecord.done = (async () => {
-        return runWithTaskListId(taskListId, async () => {
-          return runWithTaskListEnv(
-            { ...process.env, PYB_TASK_LIST_ID: taskListId },
-            async () => {
-              try {
-                const bgMessages = [...messagesForQuery];
-                const bgTranscriptMessages = [...transcriptMessages];
-                for await (const msg of queryFn(
-                  bgMessages,
-                  systemPrompt,
-                  context,
-                  hasPermissionsToUseTool,
-                  {
-                    abortController: bgAbortController,
-                    options: queryOptions,
-                    messageId: getLastAssistantMessageId(bgMessages),
-                    sessionId: childSessionId,
-                    parentSessionId,
-                    childSessionId,
-                    agentId,
-                    agentType: input.subagent_type,
-                    readFileTimestamps,
-                    setToolJSX: () => {
-                    }
-                  }
-                )) {
-                  bgMessages.push(msg);
-                  bgTranscriptMessages.push(msg);
-                  taskRecord.messages = [...bgTranscriptMessages];
-                  upsertBackgroundAgentTask(taskRecord);
-                }
-                const lastAssistant2 = last(
-                  bgTranscriptMessages.filter((m) => m.type === "assistant")
-                );
-                const content2 = lastAssistant2?.message?.content?.filter(
-                  (b) => b.type === "text"
-                );
-                taskRecord.status = "completed";
-                taskRecord.completedAt = Date.now();
-                taskRecord.resultText = (content2 || []).map((b) => b.text).join("\n");
-                taskRecord.messages = [...bgTranscriptMessages];
-                upsertBackgroundAgentTask(taskRecord);
-                saveAgentTranscript(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 output2 = {
-        status: "async_launched",
-        agentId,
-        description: input.description,
-        prompt: effectivePrompt
-      };
-      yield {
-        type: "result",
-        data: output2,
-        resultForAssistant: asyncLaunchMessage(agentId)
-      };
-      return;
-    }
-    const getSidechainNumber = memoize(
-      () => getNextAvailableLogSidechainNumber(messageLogName, forkNumber)
-    );
-    const PROGRESS_THROTTLE_MS = 200;
-    let lastProgressEmitAt = 0;
-    let lastEmittedToolUseCount = 0;
-    const renderProgressText = (toolUseCount2) => {
-      return `${input.description || "Task"}\u2026 (${toolUseCount2} tool${toolUseCount2 === 1 ? "" : "s"})`;
-    };
-    yield {
-      type: "progress",
-      content: createAssistantMessage(
-        `${TOOL_PROGRESS_OPEN_TAG2}${renderProgressText(0)}${TOOL_PROGRESS_CLOSE_TAG2}`
-      )
-    };
-    lastProgressEmitAt = Date.now();
-    let toolUseCount = 0;
-    const queryStream = runWithTaskListId(
-      taskListId,
-      () => runWithTaskListEnv(
-        { ...process.env, PYB_TASK_LIST_ID: taskListId },
-        () => queryFn(
-          messagesForQuery,
-          systemPrompt,
-          context,
-          hasPermissionsToUseTool,
-          {
-            abortController,
-            options: queryOptions,
-            messageId: getLastAssistantMessageId(messagesForQuery),
-            sessionId: childSessionId,
-            parentSessionId,
-            childSessionId,
-            agentId,
-            agentType: input.subagent_type,
-            readFileTimestamps,
-            setToolJSX: () => {
-            }
-          }
-        )
-      )
-    );
-    for await (const message of queryStream) {
-      messagesForQuery.push(message);
-      transcriptMessages.push(message);
-      overwriteLog(
-        getMessagesPath(messageLogName, forkNumber, getSidechainNumber()),
-        transcriptMessages.filter((_) => _.type !== "progress"),
-        { conversationKey: `${messageLogName}:${forkNumber}` }
-      );
-      if (message.type === "assistant") {
-        for (const block of message.message.content) {
-          if (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use") {
-            toolUseCount += 1;
-          }
-        }
-      }
-      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_OPEN_TAG2}${renderProgressText(toolUseCount)}${TOOL_PROGRESS_CLOSE_TAG2}`
-          )
-        };
-        lastEmittedToolUseCount = toolUseCount;
-        lastProgressEmitAt = now;
-      }
-    }
-    const lastAssistant = last(
-      transcriptMessages.filter((m) => m.type === "assistant")
-    );
-    if (!lastAssistant || lastAssistant.type !== "assistant") {
-      throw Error("No assistant messages found");
-    }
-    const content = lastAssistant.message.content.filter(
-      (b) => b.type === "text"
-    );
-    saveAgentTranscript(agentId, transcriptMessages);
-    const totalDurationMs = Date.now() - startTime;
-    const totalTokens = countTokens(transcriptMessages);
-    const usage = lastAssistant.message.usage;
-    const output = {
-      status: "completed",
-      agentId,
-      prompt: effectivePrompt,
-      content,
-      totalToolUseCount: toolUseCount,
-      totalDurationMs,
-      totalTokens,
-      usage
-    };
-    const agentIdBlock = {
-      type: "text",
-      text: `agentId: ${agentId} (for resuming to continue this agent's work if needed)`,
-      citations: []
-    };
-    yield {
-      type: "result",
-      data: output,
-      resultForAssistant: [...content, agentIdBlock]
-    };
-  }
-};
-
-// src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
-import { z as z9 } from "zod";
-
-// src/utils/session/taskToolUtils.ts
-import { z as z8 } from "zod";
-var jsonValueSchema = z8.lazy(
-  () => z8.union([
-    z8.string(),
-    z8.number(),
-    z8.boolean(),
-    z8.null(),
-    z8.array(jsonValueSchema),
-    z8.record(jsonValueSchema)
-  ])
-);
-var metadataSchema = z8.record(jsonValueSchema);
-function mapStatusToOutput(status) {
-  if (status === "done") return "completed";
-  if (status === "deleted") return "deleted";
-  return status;
-}
-function toTaskListItem(task) {
-  const projection = getTaskCollaborationProjection(task);
-  const item = {
-    id: task.id,
-    subject: task.subject,
-    status: mapStatusToOutput(task.status),
-    blockedBy: task.blockedBy ?? []
-  };
-  if (projection.owner) item.owner = projection.owner;
-  if (projection.worktree) item.worktree = projection.worktree;
-  if (projection.lane) item.lane = projection.lane;
-  if (projection.agent) item.agent = projection.agent;
-  if (projection.created_at !== void 0) item.created_at = projection.created_at;
-  if (projection.updated_at !== void 0) item.updated_at = projection.updated_at;
-  return item;
-}
-function toTaskDetail(task) {
-  return {
-    id: task.id,
-    subject: task.subject,
-    description: task.description,
-    activeForm: task.activeForm,
-    status: mapStatusToOutput(task.status),
-    metadata: task.metadata,
-    blocks: task.blocks ?? [],
-    blockedBy: task.blockedBy ?? []
-  };
-}
-function toTaskGetDetail(task) {
-  const projection = getTaskCollaborationProjection(task);
-  const detail = {
-    subject: task.subject,
-    description: task.description,
-    activeForm: task.activeForm,
-    status: mapStatusToOutput(task.status),
-    metadata: task.metadata,
-    blocks: task.blocks ?? [],
-    blockedBy: task.blockedBy ?? []
-  };
-  if (projection.owner) detail.owner = projection.owner;
-  if (projection.worktree) detail.worktree = projection.worktree;
-  if (projection.lane) detail.lane = projection.lane;
-  if (projection.agent) detail.agent = projection.agent;
-  if (projection.created_at !== void 0) detail.created_at = projection.created_at;
-  if (projection.updated_at !== void 0) detail.updated_at = projection.updated_at;
-  return detail;
-}
-function getTaskCollaborationProjection(task) {
-  const metadata = task.metadata ?? {};
-  const owner = typeof metadata.owner === "string" ? metadata.owner : void 0;
-  const worktree = typeof metadata.worktree === "string" ? metadata.worktree : void 0;
-  const lane = typeof metadata.lane === "string" ? metadata.lane : void 0;
-  const agent = typeof metadata.agent === "string" ? metadata.agent : void 0;
-  const created_at = typeof metadata.created_at === "number" || typeof metadata.created_at === "string" ? metadata.created_at : void 0;
-  const updated_at = typeof metadata.updated_at === "number" || typeof metadata.updated_at === "string" ? metadata.updated_at : void 0;
-  return { owner, worktree, lane, agent, created_at, updated_at };
-}
-function createTaskToolError(params) {
-  return {
-    error: {
-      type: params.type,
-      message: params.message,
-      code: params.code,
-      details: params.details
-    }
-  };
-}
-
-// src/tools/interaction/TaskCreateTool/prompt.ts
-var DESCRIPTION5 = "Plan and create tasks for complex multi-step work";
-var PROMPT6 = `Use this tool to create a new task in the current task list. It is the entry point for planning multi-step work.
-
-## When to Use This Tool
-
-Use this tool proactively in these scenarios:
-
-1. **Complex multi-step tasks** - When a task requires 2 or more distinct steps or actions
-2. **Non-trivial and complex tasks** - Tasks that require careful planning or multiple operations
-3. **User explicitly requests task list** - When the user directly asks you to use the task 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 structured a task list or plan with structured fields
-
-## When NOT to Use This Tool
-
-Skip using this tool only when:
-
-1. The request is truly trivial and one-step
-2. It can be completed safely in less than 2 trivial steps with no follow-up work
-3. The interaction is purely conversational/informational
-4. You are only updating status or details of an existing task (use TaskUpdate)
-
-## Trigger Timing
-- Use TaskCreate when starting implementation work.
-- Use TaskCreate when the user adds new requirements.
-- Use TaskCreate when scope changes during execution.
-- Use TaskCreate when a milestone is completed and the next concrete work unit begins.
-
-## Core Workflow
-
-**The Two-Phase Pattern (IMPORTANT):**
-- **Phase 1 - Create**: Create all tasks one by one WITHOUT dependencies (blockedBy=[]).
-- **Phase 2 - Link**: Use TaskUpdate to add blockedBy AFTER all related tasks exist.
-
-This pattern ensures clean dependency graph construction and prevents reference errors.
-
-## Input Notes
-- subject is required.
-- listId is optional; omit to use the default list.
-- TaskCreate only supports single-task creation; create multiple tasks one by one.
-- For multi-step plans, create the structured task list without dependencies and add blockedBy later via TaskUpdate.
-- activeForm is required.
-- metadata is optional and should only include stable coordination fields you want to persist.
-- blockedBy is always stored as an array (empty when not used).
-- description and blockedBy are kept separate in JSON; any joining is only for terminal rendering.
-- Task ordering relies on task id; 
-- Use metadata.planFinalized="true" in TaskUpdate when dependencies are ready to be validated globally.
-- Do not mention tool names or tool usage in user-facing messages.
-- When uncertain whether to track, prefer tracking.
-
-## Field Guidance
-- subject: concise task name that reads like a goal.
-- activeForm: short verb phrase that describes the in-progress action, not a full sentence.
-- description: prefer a one-line overview that introduces the bullets with "Including:" plus bullet points for multi-step tasks; for very simple tasks a short sentence is fine.
-
-Preferred single-task template:
-{
-  "subject": "Requirements clarification and scope definition",
-  "description": "Clarify the business goals, functional scope, and technical boundaries. Including:
-- Confirm supported languages
-- Define summary output format and quality bar
-- Specify performance targets (latency, throughput)
-- Identify stakeholders and acceptance criteria",
-  "activeForm": "Clarifying requirements and defining scope"
-}
-
-## Status Notes
-- Use pending when dependencies prevent work and fill blockedBy.
-
-## Task Lifecycle Overview
-
-Tasks flow through these states:
-
-- pending --(start work)--> in_progress --(complete)--> done
-- pending --(cancel)--> deleted
-- in_progress --(cancel)--> deleted
-
-**State Definitions:**
-- **pending**: Not started, may be blocked by dependencies
-- **in_progress**: Currently being worked on (only ONE task at a time)
-- **done**: Successfully completed (triggers unlock propagation)
-- **deleted**: Cancelled or no longer needed
-
-**Ready vs Blocked:**
-- A task is **ready** when: status=pending AND blockedBy=[] (all dependencies satisfied)
-- A task is **blocked** when: blockedBy contains task IDs that are not yet done/deleted
-
-## Dependency Relationships
-
-Tasks can have dependencies on other tasks:
-
-- **blockedBy**: List of task IDs that must complete before this task can start
-- **blocks**: List of task IDs that are waiting for this task (auto-synced, do not set manually)
-
-**How it works:**
-
-Task A (blockedBy: [])
-Task B (blockedBy: ["A"])  \u2190 B waits for A
-Task C (blockedBy: ["A"])  \u2190 C waits for A
-
-When Task A completes:
-  - blockedBy is cleared from B and C
-  - Both B and C become ready (can run in parallel)
-
-**Important:** When you set blockedBy via TaskUpdate, the reverse blocks relationship is automatically synchronized. Never manually set blocks.
-
-## Handling Natural Language Requests
-
-When users provide vague or high-level requests (e.g., "build a user auth module"), you must:
-1. **Decompose** the request into logical subtasks based on software engineering best practices
-2. **Identify dependencies** between subtasks (what must complete before what can start)
-3. **Create tasks first** with blockedBy=[] for all tasks
-4. **Add dependencies second** using TaskUpdate.addBlockedBy
-
-Common decomposition patterns:
-- **Database/API pattern**: Schema design \u2192 Table implementation \u2192 API endpoints \u2192 Tests
-- **Frontend pattern**: Design \u2192 Components \u2192 Integration \u2192 Testing
-- **Full-stack pattern**: Backend \u2192 API \u2192 Frontend \u2192 Integration tests
-
-## Examples of When to Use TaskCreate
-
-### Category A: No Explicit Dependencies or Order (Most Common)
-
-User provides a high-level request without specifying how to break it down or what should be done first.
-
-<example>
-User: Build a user authentication module
-
-Assistant: This is a complex feature that requires multiple components. Let me plan the implementation steps.
-
-*Creates tasks (Phase 1):*
-TaskCreate(subject="Design auth database schema", activeForm="Designing auth database schema")
-TaskCreate(subject="Implement users table", activeForm="Implementing users table")
-TaskCreate(subject="Implement sessions table", activeForm="Implementing sessions table")
-TaskCreate(subject="Build auth API endpoints", activeForm="Building auth API endpoints")
-TaskCreate(subject="Write unit tests", activeForm="Writing unit tests")
-TaskCreate(subject="Write integration tests", activeForm="Writing integration tests")
-
-*Adds dependencies (Phase 2):*
-TaskUpdate(taskId="2", addBlockedBy=["1"])
-TaskUpdate(taskId="3", addBlockedBy=["1"])
-TaskUpdate(taskId="4", addBlockedBy=["2", "3"])
-TaskUpdate(taskId="5", addBlockedBy=["4"])
-TaskUpdate(taskId="6", addBlockedBy=["4"])
-
-Auth module planned: 6 tasks with dependency graph established. Starting with database design.
-
-<reasoning>
-The assistant used TaskCreate because:
-1. User provided a high-level feature request without task breakdown
-2. Authentication module requires multiple components (database, tables, API, tests)
-3. The assistant inferred dependencies based on software engineering practices: schema before tables, tables before API, API before tests
-4. Two-phase pattern: create all tasks first, then link dependencies
-</reasoning>
-</example>
-
-<example>
-User: I want to add a dark mode toggle to the application settings. Make sure you run the tests when you're done!
-
-Assistant: I'll help add a dark mode toggle. Let me plan the implementation steps.
-
-*Creates tasks (Phase 1):*
-TaskCreate(subject="Create dark mode toggle component", activeForm="Creating dark mode toggle component")
-TaskCreate(subject="Add dark mode state management", activeForm="Adding dark mode state management")
-TaskCreate(subject="Implement dark theme styles", activeForm="Implementing dark theme styles")
-TaskCreate(subject="Update components for theme switching", activeForm="Updating components for theme switching")
-TaskCreate(subject="Run tests and fix failures", activeForm="Running tests and fixing failures")
-
-*Adds dependencies (Phase 2):*
-TaskUpdate(taskId="3", addBlockedBy=["2"])
-TaskUpdate(taskId="4", addBlockedBy=["1", "3"])
-TaskUpdate(taskId="5", addBlockedBy=["4"])
-
-Dark mode toggle planned: 5 tasks. Starting with the toggle component.
-
-<reasoning>
-The assistant used TaskCreate because:
-1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
-2. User explicitly requested tests be run afterward - this becomes the final task
-3. Dependencies inferred: styles depend on state management, components depend on toggle and styles, tests run last
-</reasoning>
-</example>
-
-<example>
-User: Help optimize my React app performance, rendering is slow
-
-Assistant: Let me first examine the codebase to identify performance bottlenecks.
-
-*Examines component structure, render patterns, state management*
-
-After analyzing the codebase, I've identified several performance issues. Let me plan the optimizations.
-
-*Creates tasks (Phase 1):*
-TaskCreate(subject="Add memoization to ProductList calculations", activeForm="Adding memoization to ProductList")
-TaskCreate(subject="Implement virtualization for Dashboard lists", activeForm="Implementing list virtualization")
-TaskCreate(subject="Optimize image loading in Gallery", activeForm="Optimizing image loading")
-TaskCreate(subject="Fix state update loops in ShoppingCart", activeForm="Fixing state update loops")
-
-*Dependencies: These can be done at the same time, no specific order needed*
-
-React performance optimization planned: 4 tasks. Starting with ProductList memoization.
-
-<reasoning>
-The assistant used TaskCreate because:
-1. First examined the codebase to identify specific performance issues
-2. Multiple independent optimizations were identified - each becomes a task
-3. These tasks have NO dependencies - they can run in parallel
-4. Todo list helps track which optimizations have been addressed
-</reasoning>
-</example>
-
-### Category B: Explicit Order Specified by User
-
-User clearly indicates what should be done first, second, etc. using words like "first... then... finally..." or numbered lists.
-
-<example>
-User: First design the database, then create the users table and sessions table, then write the API, and finally test
-
-Assistant: User has explicitly specified the order. Let me plan tasks according to this sequence.
-
-*Creates tasks (Phase 1):*
-TaskCreate(subject="Design database schema", activeForm="Designing database schema")
-TaskCreate(subject="Implement users table", activeForm="Implementing users table")
-TaskCreate(subject="Implement sessions table", activeForm="Implementing sessions table")
-TaskCreate(subject="Build API endpoints", activeForm="Building API endpoints")
-TaskCreate(subject="Write tests", activeForm="Writing tests")
-
-*Adds dependencies based on user's explicit order (Phase 2):*
-TaskUpdate(taskId="2", addBlockedBy=["1"])  // users table waits for database
-TaskUpdate(taskId="3", addBlockedBy=["1"])  // sessions table waits for database
-TaskUpdate(taskId="4", addBlockedBy=["2", "3"])  // API waits for both tables
-TaskUpdate(taskId="5", addBlockedBy=["4"])  // tests wait for API
-
-Tasks planned in your specified order: database \u2192 users/sessions tables \u2192 API \u2192 tests
-
-<reasoning>
-The assistant used TaskCreate because:
-1. User explicitly specified the order: database first, then tables, then API, finally tests
-2. This order translates directly into dependency relationships
-3. Users table and sessions table can run in parallel after database (both depend only on task 1)
-4. Two-phase pattern: create all tasks, then add dependencies matching user's specified order
-</reasoning>
-</example>
-
-<example>
-User: I need to add a character limit to the bio field. First, add the validation logic to the backend, then update the frontend form.
-
-Assistant: I'll plan this with the order you specified.
-
-*Creates tasks (Phase 1):*
-TaskCreate(subject="Add backend validation for bio character limit", activeForm="Adding backend validation")
-TaskCreate(subject="Update frontend form to enforce character limit", activeForm="Updating frontend form")
-
-*Adds dependencies (Phase 2):*
-TaskUpdate(taskId="2", addBlockedBy=["1"])  // frontend waits for backend
-
-Bio character limit planned: backend validation first, then frontend update.
-
-<reasoning>
-The assistant used TaskCreate because:
-1. User used "First... then..." which explicitly defines the order
-2. Backend must be done before frontend - this is a dependency relationship
-3. Two tasks with one dependency
-</reasoning>
-</example>
-
-<example>
-User: I need to implement user registration, product catalog, shopping cart, and checkout flow
-
-Assistant: These are core e-commerce features. Let me plan tasks for each module.
-
-*Creates tasks for each feature (Phase 1):*
-TaskCreate(subject="Implement user registration", activeForm="Implementing user registration")
-TaskCreate(subject="Implement product catalog", activeForm="Implementing product catalog")
-TaskCreate(subject="Implement shopping cart", activeForm="Implementing shopping cart")
-TaskCreate(subject="Implement checkout flow", activeForm="Implementing checkout flow")
-
-*Adds dependencies (Phase 2):*
-TaskUpdate(taskId="3", addBlockedBy=["2"])  // cart depends on product catalog
-TaskUpdate(taskId="4", addBlockedBy=["1", "3"])  // checkout depends on registration and cart
-
-E-commerce features planned: user registration and product catalog can start together, cart waits for catalog, checkout waits for registration and cart.
-
-<reasoning>
-The assistant used TaskCreate because:
-1. User provided multiple complex features in a comma-separated list
-2. These features have natural dependencies: cart needs products, checkout needs user and cart
-3. Registration and catalog can run in parallel (no dependency between them)
-4. Todo list helps organize these large features into manageable tasks
-</reasoning>
-</example>
-
-### Category C: Simple or Single Task
-
-User's request is straightforward and doesn't require complex planning.
-
-<example>
-User: Just fix the typo in the documentation
-
-Assistant: This is a straightforward fix. I'll create a single task to track it.
-
-*Creates one task:*
-TaskCreate(subject="Fix typo in documentation", activeForm="Fixing documentation typo")
-
-<reasoning>
-The assistant used TaskCreate because:
-1. This is a single task that can be tracked
-2. No complex breakdown needed
-3. Still useful to track for completeness and progress visibility
-</reasoning>
-</example>
-
-<example>
-User: Add a comment to the calculateTotal function explaining what it does
-
-Assistant: This is a simple single-step task.
-
-*Creates one task:*
-TaskCreate(subject="Add comment to calculateTotal function", activeForm="Adding function comment")
-
-<reasoning>
-The assistant used TaskCreate because:
-1. Single straightforward task in one location
-2. Creating a task helps track completion
-</reasoning>
-</example>
-
-### Category D: Adding Forgotten Tasks
-
-User realizes something was missed after the initial plan.
-
-<example>
-User: I forgot, we also need logging for the auth module
-
-Assistant: Let me add the logging task and link it appropriately.
-
-TaskCreate(subject="Add auth logging", activeForm="Adding auth logging")
-
-*The logging task depends on API endpoints being ready:*
-TaskUpdate(taskId="7", addBlockedBy=["4"])  // logging depends on API
-
-Auth logging added. It will be done after the API endpoints are complete.
-
-<reasoning>
-The assistant used TaskCreate because:
-1. User added a new requirement after initial planning
-2. New task was created first with TaskCreate
-3. Then linked to existing tasks via TaskUpdate.addBlockedBy
-4. Logging logically depends on API endpoints existence
-</reasoning>
-</example>
-`.trim();
-
-// src/tools/interaction/TaskCreateTool/TaskCreateTool.tsx
-var inputSchema8 = z9.strictObject({
-  listId: z9.string().min(1).optional(),
-  subject: z9.string().min(1),
-  description: z9.string().min(1),
-  activeForm: z9.string().min(1),
-  metadata: metadataSchema.optional()
-});
-var TaskCreateTool = {
-  name: "TaskCreate",
-  cachedDescription: DESCRIPTION5,
-  async description() {
-    return DESCRIPTION5;
-  },
-  async prompt() {
-    return PROMPT6;
-  },
-  inputSchema: inputSchema8,
-  userFacingName() {
-    return "";
-  },
-  async isEnabled() {
-    return true;
-  },
-  isReadOnly() {
-    return false;
-  },
-  isConcurrencySafe() {
-    return false;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(output) {
-    return JSON.stringify(output, null, 2);
-  },
-  renderToolResultMessage(output) {
-    return null;
-  },
-  renderToolUseMessage() {
-    return null;
-  },
-  async *call(input) {
-    try {
-      const subject = input.subject;
-      const task = createTask({
-        subject,
-        description: input.description,
-        activeForm: input.activeForm,
-        metadata: input.metadata
-      }, { listId: input.listId });
-      const { listId } = getTaskListPaths(input.listId);
-      const timestamp = Date.now();
-      const payload = {
-        listId,
-        taskId: task.id,
-        task,
-        timestamp
-      };
-      emitReminderEvent("task.created", payload);
-      emitReminderEvent("task.created.v1", payload);
-      yield {
-        type: "result",
-        data: {
-          listId,
-          item: toTaskDetail(task)
-        }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Task create failed";
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "unknown",
-          message
-        })
-      };
-    }
-  }
-};
-
-// src/tools/interaction/TaskGetTool/TaskGetTool.tsx
-import { z as z10 } from "zod";
-
-// src/tools/interaction/TaskGetTool/prompt.ts
-var DESCRIPTION6 = "Review planned task details";
-var PROMPT7 = `Use this tool to fetch a single task by id.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. You need details for one task to confirm its fields, status, or dependencies.
-2. You need the latest task details before updating a task.
-
-## When NOT to Use This Tool
-
-Skip using this tool when:
-1. You need multiple tasks or readiness info (use TaskList).
-2. You need to modify a task (use TaskUpdate) or create one (use TaskCreate).
-
-NOTE that TaskGet returns a single task only; use TaskList for summaries or readiness.
-
-## Input Notes
-- taskId is required.
-- listId is optional; omit to use the default list.
-- Do not mention tool names or tool usage in user-facing messages.
-
-## Examples of When to Use TaskGet
-
-<example>
-User: Can you check the status of task t-17 before updating it?
-Assistant: I'll fetch the task details first.
-*Fetches task t-17*
-</example>
-`.trim();
-
-// src/tools/interaction/TaskGetTool/TaskGetTool.tsx
-var inputSchema9 = z10.strictObject({
-  listId: z10.string().min(1).optional(),
-  taskId: z10.string().min(1)
-});
-var TaskGetTool = {
-  name: "TaskGet",
-  cachedDescription: DESCRIPTION6,
-  async description() {
-    return DESCRIPTION6;
-  },
-  async prompt() {
-    return PROMPT7;
-  },
-  inputSchema: inputSchema9,
-  userFacingName() {
-    return "";
-  },
-  async isEnabled() {
-    return true;
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(output) {
-    return JSON.stringify(output, null, 2);
-  },
-  renderToolResultMessage() {
-    return null;
-  },
-  renderToolUseMessage() {
-    return null;
-  },
-  async *call(input) {
-    const { listId } = getTaskListPaths(input.listId);
-    const task = getTask(input.taskId, { listId: input.listId });
-    if (!task) {
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "not_found",
-          code: "TASK_NOT_FOUND",
-          message: `Task ${input.taskId} not found`,
-          details: { taskId: input.taskId, listId }
-        })
-      };
-      return;
-    }
-    yield {
-      type: "result",
-      data: {
-        listId,
-        item: toTaskGetDetail(task)
-      }
-    };
-  }
-};
-
-// src/tools/interaction/TaskListTool/TaskListTool.tsx
-import { z as z11 } from "zod";
-
-// src/tools/interaction/TaskListTool/prompt.ts
-var DESCRIPTION7 = "Review planned tasks, readiness, and blockers";
-var PROMPT8 = `Use this tool to list tasks and understand readiness. It returns ready and blocked groupings to help prioritize work. TaskList only returns id/subject/status/blockedBy for summaries; use TaskGet for details.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. You need a list of tasks for a listId (or default list).
-2. You need ready/blocked calculations to prioritize work.
-3. You need to filter by status.
-4. You want a quick summary of what can be started now.
-
-## When NOT to Use This Tool
-
-Skip using this tool when:
-1. You need a single task by id (use TaskGet).
-2. You need to create or update tasks (use TaskCreate or TaskUpdate).
-
-NOTE that TaskList is for summaries and readiness; use TaskGet for details.
-
-## Input Notes
-- listId is optional; omit to use the default list.
-- status filters the returned items; omit to exclude deleted tasks by default.
-- blockedBy may be empty early in planning and will appear as dependencies are added.
-- Do not mention tool names or tool usage in user-facing messages.
-
-## Examples of When to Use TaskList
-
-<example>
-User: What should we work on next?
-Assistant: I'll list tasks and check readiness.
-*Lists tasks with ready/blocked breakdown*
-</example>
-
-<example>
-User: Show only in-progress items.
-Assistant: I'll list tasks filtered by status.
-*Lists tasks with status filter*
-</example>
-
-<example>
-User: We just added dependencies, can we see what's blocked now?
-Assistant: I'll list tasks to show the updated ready/blocked breakdown.
-*Lists tasks with ready/blocked breakdown*
-</example>
-`.trim();
-
-// src/tools/interaction/TaskListTool/TaskListTool.tsx
-var inputSchema10 = z11.strictObject({
-  listId: z11.string().min(1).optional(),
-  status: z11.enum(["pending", "in_progress", "completed", "deleted"]).optional()
-});
-var filterByStatus = (tasks, statuses) => {
-  if (!statuses || statuses.length === 0) {
-    return tasks.filter((item) => item.status !== "deleted");
-  }
-  const allowed = new Set(statuses);
-  return tasks.filter((item) => allowed.has(item.status));
-};
-var mapStatusFilterInput = (input) => {
-  if (!input) return void 0;
-  if (input === "completed") return ["done"];
-  if (input === "deleted") return ["deleted"];
-  if (input === "pending") return ["pending"];
-  return ["in_progress"];
-};
-var getActiveBlockers = (task, tasksById) => {
-  const blockers = task.blockedBy ?? [];
-  const active = [];
-  for (const blockerId of blockers) {
-    const blocker = tasksById.get(blockerId);
-    if (!blocker) {
-      active.push(blockerId);
-      continue;
-    }
-    if (blocker.status !== "done" && blocker.status !== "deleted") {
-      active.push(blockerId);
-    }
-  }
-  return active;
-};
-var TaskListTool = {
-  name: "TaskList",
-  cachedDescription: DESCRIPTION7,
-  async description() {
-    return DESCRIPTION7;
-  },
-  async prompt() {
-    return PROMPT8;
-  },
-  inputSchema: inputSchema10,
-  userFacingName() {
-    return "";
-  },
-  async isEnabled() {
-    return true;
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(output) {
-    return JSON.stringify(output, null, 2);
-  },
-  renderToolResultMessage() {
-    return null;
-  },
-  renderToolUseMessage() {
-    return null;
-  },
-  async *call(input) {
-    try {
-      const { listId } = getTaskListPaths(input.listId);
-      const tasks = listTasks({ listId: input.listId });
-      const filtered = filterByStatus(tasks, mapStatusFilterInput(input.status));
-      const tasksById = new Map(tasks.map((task) => [task.id, task]));
-      const items = filtered.map((task) => {
-        const base = toTaskListItem(task);
-        const activeBlockers = getActiveBlockers(task, tasksById);
-        return {
-          ...base,
-          ready: task.status === "pending" && activeBlockers.length === 0,
-          activeBlockers
-        };
-      });
-      yield {
-        type: "result",
-        data: {
-          listId,
-          items
-        }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Task list failed";
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "unknown",
-          message
-        })
-      };
-    }
-  }
-};
-
-// src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
-import { z as z12 } from "zod";
-
-// src/tools/interaction/TaskUpdateTool/prompt.ts
-var DESCRIPTION8 = "Manage task progress, status, and dependencies";
-var PROMPT9 = `Use this tool to update an existing task. It is the primary way to track progress and adjust task details.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. You need to change task fields (subject/description/status).
-2. You need to adjust dependencies (blockedBy).
-3. You need to move a task across states (pending \u2192 in_progress \u2192 completed).
-4. You are moving a task across states (pending \u2192 in_progress \u2192 completed).
-
-## When NOT to Use This Tool
-
-Skip using this tool when:
-1. You need to create a new task (use TaskCreate).
-2. You only need to read tasks (use TaskGet or TaskList).
-
-NOTE that TaskUpdate should be used when you need to persist task changes.
-
-## Input Notes
-- taskId is required.
-- listId is optional; omit to use the default list.
-- Dependencies are validated for cycles; invalid cycles will be rejected.
-- Use TaskUpdate to add blockedBy after tasks are created.
-- Use addBlocks when the current task should block other tasks; the reverse blockedBy relation is synchronized.
-- You can set metadata.planFinalized="true" to trigger a full dependency validation pass.
-- activeForm is optional in updates; when omitted, existing value is preserved.
-- blockedBy is always stored as an array (empty when not used).
-- description and blockedBy are kept separate in JSON; any joining is only for terminal rendering.
-- Task ordering relies on task id; do not use priority fields.
-- Do not mention tool names or tool usage in user-facing messages.
-
-## The Two Usage Patterns
-
-### Pattern 1: Dependency Linking (After TaskCreate)
-Use TaskUpdate to establish dependencies AFTER all tasks are created:
-- Create tasks with TaskCreate (blockedBy=[])
-- Link dependencies with TaskUpdate.addBlockedBy or TaskUpdate.addBlocks
-- This ensures reference validity and clean graph construction
-
-### Pattern 2: Status Progression
-Use TaskUpdate to move tasks through the execution lifecycle:
-- pending \u2192 in_progress: When starting work on a task
-- in_progress \u2192 completed: When task is done (triggers unlock propagation)
-- Any \u2192 deleted: When task is obsolete or cancelled
-
-## Update Patterns
-- Simple status-only update: update one task status directly (pending \u2192 in_progress \u2192 completed) when no dependency change is needed.
-- Complex dependency and unlock update: update blockedBy/addBlocks and status together, then consume unlockResult.readyNow immediately.
-- Cancel or retire path: use deleted when a task is intentionally retired and should no longer appear in default lists.
-
-## Field Guidance
-- activeForm: short verb phrase describing the in-progress action.
-- description: prefer a one-line overview plus bullet points for multi-step tasks; for very simple tasks a short sentence is fine.
-- collaboration metadata keys:
-  - metadata.owner for task owner identity
-  - metadata.worktree for bound worktree name
-  - metadata.lane for collaboration lane
-  - metadata.agent for agent role or identifier
-  - metadata.created_at for creation timestamp
-  - metadata.updated_at for update timestamp
-
-## Status Notes
-- Use in_progress for the task you are actively working on.
-- Use pending when dependencies prevent progress and set blockedBy.
-- Use completed only when all dependencies are satisfied.
-- When status becomes completed, consume unlockResult.readyNow immediately.
-- If readyNow is returned, continue with those tasks without calling TaskList.
-
-## Task Lifecycle Overview
-
-Tasks flow through these states:
-
-- pending --(start work)--> in_progress --(complete)--> done
-- pending --(cancel)--> deleted
-- in_progress --(cancel)--> deleted
-
-**State Definitions:**
-- **pending**: Not started, may be blocked by dependencies
-- **in_progress**: Currently being worked on (only ONE task at a time)
-- **done**: Successfully completed (triggers unlock propagation)
-- **deleted**: Cancelled or no longer needed
-
-**Ready vs Blocked:**
-- A task is **ready** when: status=pending AND blockedBy=[] (all dependencies satisfied)
-- A task is **blocked** when: blockedBy contains task IDs that are not yet done/deleted
-
-## Dependency Relationships
-
-Tasks can have dependencies on other tasks:
-
-- **blockedBy**: List of task IDs that must complete before this task can start
-- **blocks**: List of task IDs that are waiting for this task (auto-synced, do not set manually)
-
-**How it works:**
-
-Task A (blockedBy: [])
-Task B (blockedBy: ["A"])  \u2190 B waits for A
-Task C (blockedBy: ["A"])  \u2190 C waits for A
-
-When Task A completes:
-  - blockedBy is cleared from B and C
-  - Both B and C become ready (can run in parallel)
-
-**Important:** When you set blockedBy via TaskUpdate, the reverse blocks relationship is automatically synchronized. Never manually set blocks.
-
-## Understanding Unlock Propagation
-
-When a task is marked as completed:
-1. It is removed from the blockedBy list of all tasks it was blocking
-2. Any tasks that become unblocked (blockedBy becomes empty) appear in unlockResult.readyNow
-3. You should immediately continue with those readyNow tasks without calling TaskList
-
-This enables efficient "chain execution" without redundant status checks.
-
-## Examples of When to Use TaskUpdate
-
-### Category A: Status Progression (Moving Tasks Forward)
-
-<example>
-User: The database design is done, let's start on the users table
-
-Assistant: Database design is complete. Let me update the task status and continue to the next step.
-
-TaskUpdate(taskId="1", status="completed")
-*Result shows readyNow: ["2", "3"]*
-
-Both the users table and sessions table are now ready. I'll start with the users table.
-
-TaskUpdate(taskId="2", status="in_progress")
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User indicated the database design is done
-2. Completing task 1 triggers unlock - tasks 2 and 3 become ready
-3. User said to start the users table
-4. The unlockResult.readyNow tells us what tasks are now unblocked
-</reasoning>
-</example>
-
-<example>
-User: I've finished the API endpoints. What should I work on next?
-
-Assistant: Let me mark the API task complete and see what's unblocked.
-
-TaskUpdate(taskId="4", status="completed")
-*Result shows readyNow: ["5", "6"]*
-
-The unit tests and integration tests are now ready. Would you like to start with unit tests?
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User said they finished the API endpoints
-2. Completing this task triggers unlock propagation
-3. The readyNow field shows which tasks can now start
-4. This enables efficient "chain execution" without calling TaskList
-</reasoning>
-</example>
-
-<example>
-User: Start writing the tests
-
-Assistant: I'll mark the test task as in progress.
-
-TaskUpdate(taskId="5", status="in_progress")
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User wants to start working on tests
-2. Simple status progression: pending \u2192 in_progress
-</reasoning>
-</example>
-
-### Category B: Task Completion and Chain Execution
-
-<example>
-User: The database design is complete
-
-Assistant: Database design task is complete. Let me check what tasks are now ready.
-
-TaskUpdate(taskId="1", status="completed")
-*Result shows unlockResult.readyNow: ["2", "3"]*
-
-The users table and sessions table can now be done together. I'll continue with the users table.
-
-TaskUpdate(taskId="2", status="in_progress")
-*Continuing with unblocked task without calling TaskList*
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User reported completion of database design
-2. unlockResult.readyNow shows tasks 2 and 3 are now unblocked and can run in parallel
-3. Assistant immediately continues with task 2 - efficient chain execution
-4. No need to call TaskList to check status
-</reasoning>
-</example>
-
-### Category C: Task Obsolescence or Cancellation
-
-<example>
-User: This feature is no longer needed, let's skip it for now
-
-Assistant: I'll mark this task as deleted.
-
-TaskUpdate(taskId="3", status="deleted")
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User said the feature is no longer needed
-2. "deleted" status removes it from active task flow
-3. This may unblock other tasks that were waiting on this one
-</reasoning>
-</example>
-
-<example>
-User: Actually, we don't need the session table anymore. We're using JWT instead.
-
-Assistant: I'll mark the session table task as deleted since we're switching to JWT.
-
-TaskUpdate(taskId="3", status="deleted")
-
-*If task 3 was blocking other tasks, they may now be unblocked*
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User indicated a change in approach (JWT instead of sessions)
-2. The session table task is now obsolete
-3. Marking as deleted removes it from active work
-</reasoning>
-</example>
-
-### Category D: Adding New Requirements During Execution
-
-<example>
-User: The auth module also needs a password reset feature
-
-Assistant: Adding password reset functionality. Let me create a new task and add it to the existing plan.
-
-TaskCreate(subject="Implement password reset", activeForm="Implementing password reset")
-
-*This new task may need to be linked to existing tasks:*
-TaskUpdate(taskId="7", addBlockedBy=["4"])  // password reset depends on API endpoints
-
-Password reset feature added to task list, depends on API endpoints completion.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User added a new requirement during execution
-2. New task was created first
-3. Then dependency was added using TaskUpdate
-4. Password reset logically depends on the API endpoints being ready
-</reasoning>
-</example>
-
-<example>
-User: We need to add rate limiting to the auth endpoints too
-
-Assistant: I'll add a rate limiting task and link it appropriately.
-
-TaskCreate(subject="Add rate limiting to auth endpoints", activeForm="Adding rate limiting")
-TaskUpdate(taskId="8", addBlockedBy=["4"])  // rate limiting depends on API
-
-Rate limiting task added. It will start after the API endpoints are complete.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User added a new requirement
-2. Create task first, then add dependency
-3. Rate limiting applies to API endpoints, so it depends on task 4
-</reasoning>
-</example>
-
-### Category E: Dependency Adjustment
-
-<example>
-User: The users table doesn't need to wait for database design, we can do it at the same time
-
-Assistant: I'll remove this dependency.
-
-TaskUpdate(taskId="2", blockedBy=[])
-
-The users table can now start immediately, no need to wait for database design.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User said the users table no longer needs to wait for database design
-2. Setting blockedBy=[] removes all blockers
-3. Task 2 is now ready to start immediately
-</reasoning>
-</example>
-
-<example>
-User: Tests should wait until all development tasks are complete
-
-Assistant: I'll set the test task to wait for all development tasks.
-
-TaskUpdate(taskId="5", addBlockedBy=["1", "2", "3", "4"])
-
-The test task will now wait for tasks 1-4 to all complete before starting.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User specified that tests should wait for all development tasks
-2. addBlockedBy adds new dependencies without removing existing ones
-3. Task 5 will only be ready after all four development tasks complete
-</reasoning>
-</example>
-
-<example>
-User: The API doesn't need to wait for the sessions table anymore, just the users table
-
-Assistant: I'll adjust the API's dependencies.
-
-TaskUpdate(taskId="4", blockedBy=["2"])  // only keep users table dependency
-
-The API now only needs to wait for the users table to complete.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User specified a change in dependencies
-2. Sessions table is no longer a blocker for API
-3. Setting the full blockedBy list replaces the previous one
-</reasoning>
-</example>
-
-### Category F: Changing Execution Order
-
-User wants to change the planned execution order.
-
-<example>
-User: Wait, let's do the users table first, then the database
-
-Assistant: I understand you want to change the execution order. Let me adjust the dependencies.
-
-*Current state: users table (task 2) depends on database (task 1)*
-
-TaskUpdate(taskId="2", blockedBy=[])  // users table no longer waits for database
-TaskUpdate(taskId="1", addBlockedBy=["2"])  // database now waits for users table
-
-Order adjusted: users table first, then database. The users table can start immediately.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User requested a reversal of execution order
-2. First, remove the existing dependency from task 2
-3. Then, create a reverse dependency where database waits for users table
-4. Task 2 is now unblocked and ready to start immediately
-</reasoning>
-</example>
-
-<example>
-User: Actually, let's do the users table and sessions table first, before the database design
-
-Assistant: I'll reverse the dependency chain so both tables come before database design.
-
-TaskUpdate(taskId="2", blockedBy=[])  // users table no longer blocked
-TaskUpdate(taskId="3", blockedBy=[])  // sessions table no longer blocked
-TaskUpdate(taskId="1", addBlockedBy=["2", "3"])  // database waits for both tables
-
-Both tables can now start immediately. Database design will wait for both to complete.
-
-<reasoning>
-The assistant used TaskUpdate because:
-1. User wanted to completely reverse the execution order
-2. Multiple dependencies needed to be cleared first
-3. Then reverse dependencies were added via addBlockedBy
-4. Tasks 2 and 3 are now unblocked and can run in parallel
-</reasoning>
-</example>
-`.trim();
-
-// src/tools/interaction/TaskUpdateTool/TaskUpdateTool.tsx
-var normalizeDeps = (items) => [...items ?? []].filter(Boolean).sort();
-var mergeDeps = (current, additions) => {
-  const merged = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const id of current ?? []) {
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    merged.push(id);
-  }
-  for (const id of additions ?? []) {
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    merged.push(id);
-  }
-  return merged;
-};
-var mergeMetadata = (existing, updates) => {
-  if (!updates) return existing;
-  const next = { ...existing ?? {} };
-  for (const [key, value] of Object.entries(updates)) {
-    if (value === null) {
-      delete next[key];
-    } else {
-      next[key] = value;
-    }
-  }
-  return Object.keys(next).length > 0 ? next : void 0;
-};
-var mapStatusInput = (status) => {
-  if (!status) return void 0;
-  if (status === "completed") return "done";
-  if (status === "deleted") return "deleted";
-  return status;
-};
-var depsChanged = (prev, next) => {
-  const prevBlockedBy = normalizeDeps(prev.blockedBy);
-  const nextBlockedBy = normalizeDeps(next.blockedBy);
-  if (prevBlockedBy.length !== nextBlockedBy.length) return true;
-  for (let i = 0; i < prevBlockedBy.length; i += 1) {
-    if (prevBlockedBy[i] !== nextBlockedBy[i]) return true;
-  }
-  const prevBlocks = normalizeDeps(prev.blocks);
-  const nextBlocks = normalizeDeps(next.blocks);
-  if (prevBlocks.length !== nextBlocks.length) return true;
-  for (let i = 0; i < prevBlocks.length; i += 1) {
-    if (prevBlocks[i] !== nextBlocks[i]) return true;
-  }
-  return false;
-};
-var getDepsSnapshot = (task) => ({
-  blocks: task.blocks ?? [],
-  blockedBy: task.blockedBy ?? []
-});
-var getMissingBlockedBy = (blockedBy, ids) => (blockedBy ?? []).filter((id) => !ids.has(id));
-var isPlanFinalized = (metadata) => {
-  const value = metadata?.planFinalized;
-  return value === true || value === "true";
-};
-var compareTaskId = (left, right) => {
-  const leftValue = Number(left.id);
-  const rightValue = Number(right.id);
-  const leftIsNumber = !Number.isNaN(leftValue);
-  const rightIsNumber = !Number.isNaN(rightValue);
-  if (leftIsNumber && rightIsNumber) return leftValue - rightValue;
-  if (leftIsNumber) return -1;
-  if (rightIsNumber) return 1;
-  return left.id.localeCompare(right.id);
-};
-var inputSchema11 = z12.strictObject({
-  listId: z12.string().min(1).optional(),
-  taskId: z12.string().min(1),
-  subject: z12.string().optional(),
-  description: z12.string().optional(),
-  activeForm: z12.string().optional(),
-  status: z12.enum(["pending", "in_progress", "completed", "deleted"]).optional(),
-  metadata: metadataSchema.optional(),
-  addBlockedBy: z12.array(z12.string()).optional(),
-  addBlocks: z12.array(z12.string()).optional()
-});
-var TaskUpdateTool = {
-  name: "TaskUpdate",
-  cachedDescription: DESCRIPTION8,
-  async description() {
-    return DESCRIPTION8;
-  },
-  async prompt() {
-    return PROMPT9;
-  },
-  inputSchema: inputSchema11,
-  userFacingName() {
-    return "";
-  },
-  async isEnabled() {
-    return true;
-  },
-  isReadOnly() {
-    return false;
-  },
-  isConcurrencySafe() {
-    return false;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(output) {
-    return JSON.stringify(output, null, 2);
-  },
-  renderToolResultMessage(output) {
-    return null;
-  },
-  renderToolUseMessage() {
-    return null;
-  },
-  async *call(input) {
-    const { listId } = getTaskListPaths(input.listId);
-    const existing = getTask(input.taskId, { listId: input.listId });
-    if (!existing) {
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "not_found",
-          code: "TASK_NOT_FOUND",
-          message: `Task ${input.taskId} not found`,
-          details: { taskId: input.taskId, listId }
-        })
-      };
-      return;
-    }
-    const tasks = listTasks({ listId: input.listId });
-    const subject = input.subject ?? existing.subject;
-    const mergedBlockedBy = mergeDeps(existing.blockedBy, input.addBlockedBy);
-    const mappedStatus = mapStatusInput(input.status);
-    const mergedMetadata = mergeMetadata(existing.metadata, input.metadata);
-    const metadataUpdate = input.metadata;
-    const addBlocksTargets = new Set(
-      (input.addBlocks ?? []).filter((id) => id && id !== existing.id)
-    );
-    const updatedTask = {
-      ...existing,
-      subject,
-      description: input.description ?? existing.description,
-      activeForm: input.activeForm ?? existing.activeForm,
-      status: mappedStatus ?? existing.status,
-      metadata: mergedMetadata ?? existing.metadata,
-      blockedBy: mergedBlockedBy
-    };
-    const candidateTasks = tasks.map((task) => {
-      if (task.id === existing.id) {
-        return updatedTask;
-      }
-      if (addBlocksTargets.has(task.id)) {
-        return {
-          ...task,
-          blockedBy: mergeDeps(task.blockedBy, [existing.id])
-        };
-      }
-      return task;
-    });
-    const candidateIds = new Set(candidateTasks.map((task) => task.id));
-    const missingBlockedBy = getMissingBlockedBy(
-      updatedTask.blockedBy,
-      candidateIds
-    );
-    if (missingBlockedBy.length > 0) {
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "validation",
-          code: "TASK_BLOCKEDBY_NOT_FOUND",
-          message: "BlockedBy tasks must exist in the same list",
-          details: {
-            taskId: updatedTask.id,
-            listId,
-            missingBlockedBy
-          }
-        })
-      };
-      return;
-    }
-    const missingBlocks = (input.addBlocks ?? []).filter(
-      (id) => id && !candidateIds.has(id)
-    );
-    if (missingBlocks.length > 0) {
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "validation",
-          code: "TASK_BLOCKEDBY_NOT_FOUND",
-          message: "Blocked tasks must exist in the same list",
-          details: {
-            taskId: updatedTask.id,
-            listId,
-            missingBlocks
-          }
-        })
-      };
-      return;
-    }
-    const cycles = findTaskCycles(buildTaskGraph(candidateTasks));
-    if (cycles.length > 0) {
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "validation",
-          code: "TASK_CYCLE_DETECTED",
-          message: "Task dependency cycle detected",
-          details: { cycles }
-        })
-      };
-      return;
-    }
-    const nextMetadata = mergedMetadata ?? existing.metadata;
-    if (isPlanFinalized(nextMetadata) && !isPlanFinalized(existing.metadata)) {
-      const activeTasks = candidateTasks.filter((task) => task.status !== "deleted");
-      const ordered = [...activeTasks].sort(compareTaskId);
-      const firstTaskId = ordered[0]?.id;
-      for (const task of activeTasks) {
-        const missing = getMissingBlockedBy(task.blockedBy, candidateIds);
-        if (missing.length > 0) {
-          yield {
-            type: "result",
-            data: createTaskToolError({
-              type: "validation",
-              code: "TASK_BLOCKEDBY_NOT_FOUND",
-              message: "BlockedBy tasks must exist in the same list",
-              details: { taskId: task.id, listId, missingBlockedBy: missing }
-            })
-          };
-          return;
-        }
-        if (task.id !== firstTaskId && (task.blockedBy?.length ?? 0) === 0) {
-          yield {
-            type: "result",
-            data: createTaskToolError({
-              type: "validation",
-              code: "TASK_DEPENDENCY_FINALIZE_REQUIRED",
-              message: "Task dependency chain required before planFinalized",
-              details: { taskId: task.id, listId }
-            })
-          };
-          return;
-        }
-      }
-    }
-    try {
-      for (const task of tasks) {
-        if (!addBlocksTargets.has(task.id)) continue;
-        const merged = mergeDeps(task.blockedBy, [existing.id]);
-        const current = normalizeDeps(task.blockedBy);
-        const next = normalizeDeps(merged);
-        let same = current.length === next.length;
-        if (same) {
-          for (let i = 0; i < current.length; i += 1) {
-            if (current[i] !== next[i]) {
-              same = false;
-              break;
-            }
-          }
-        }
-        if (same) continue;
-        updateTask(task.id, { blockedBy: merged }, { listId: input.listId });
-      }
-      const result = updateTask(
-        input.taskId,
-        {
-          subject: input.subject,
-          description: input.description,
-          activeForm: input.activeForm,
-          status: mappedStatus,
-          metadata: metadataUpdate,
-          blockedBy: mergedBlockedBy
-        },
-        { listId: input.listId }
-      );
-      const didDepsChange = depsChanged(existing, result.task);
-      const updatedTimestamp = Date.now();
-      const updatedPayload = {
-        listId,
-        taskId: result.task.id,
-        task: result.task,
-        timestamp: updatedTimestamp
-      };
-      emitReminderEvent("task.updated", updatedPayload);
-      emitReminderEvent("task.updated.v1", updatedPayload);
-      if (existing.status !== result.task.status) {
-        const statusTimestamp = Date.now();
-        const statusPayload = {
-          listId,
-          taskId: result.task.id,
-          previousStatus: existing.status,
-          status: result.task.status,
-          timestamp: statusTimestamp
-        };
-        emitReminderEvent("task.status_changed", statusPayload);
-        emitReminderEvent("task.status_changed.v1", statusPayload);
-      }
-      if (didDepsChange) {
-        emitReminderEvent("task.deps_changed", {
-          listId,
-          taskId: result.task.id,
-          previousDeps: getDepsSnapshot(existing),
-          deps: getDepsSnapshot(result.task),
-          timestamp: Date.now()
-        });
-      }
-      if (result.unlockResult) {
-        emitReminderEvent("task.unblocked.v1", {
-          listId,
-          taskId: result.task.id,
-          unblocked: result.unlockResult.unblocked.map((task) => task.id),
-          readyNow: result.unlockResult.readyNow.map((task) => task.id),
-          touchedTaskIds: result.unlockResult.unlockSummary.touchedTaskIds,
-          timestamp: Date.now()
-        });
-      }
-      yield {
-        type: "result",
-        data: {
-          listId,
-          item: toTaskDetail(result.task),
-          depsChanged: didDepsChange,
-          unlockResult: result.unlockResult ? {
-            unblocked: result.unlockResult.unblocked.map(toTaskDetail),
-            partiallyUnblocked: result.unlockResult.partiallyUnblocked.map(
-              (item) => ({
-                task: toTaskDetail(item.task),
-                remainingBlockers: item.remainingBlockers
-              })
-            ),
-            readyNow: result.unlockResult.readyNow.map(toTaskDetail),
-            unlockSummary: result.unlockResult.unlockSummary
-          } : void 0
-        }
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Task update failed";
-      yield {
-        type: "result",
-        data: createTaskToolError({
-          type: "unknown",
-          message
-        })
-      };
-    }
-  }
-};
-
-// src/tools/memory/MemoryReadTool/MemoryReadTool.tsx
-import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync4 } from "fs";
-import { Box as Box8, Text as Text8 } from "ink";
-import { join as join2 } from "path";
-import * as React8 from "react";
-import { z as z13 } from "zod";
-
-// src/tools/memory/MemoryReadTool/prompt.ts
-var DESCRIPTION9 = "Read agent memory files from the local filesystem.";
-var PROMPT10 = `Reads agent memory files from the local filesystem.
-
-Usage:
-- The file_path parameter must be a path relative to the agent's memory directory
-- By default, it reads a specific memory file if file_path is provided
-- If no file_path is specified, it returns an index of all memory files for the current agent
-- Memory files are stored under ~/.pyb/memory/projects/{projectId}/memory
-- Use this tool to access previously stored agent memories and task execution details
-
-Examples:
-- To read a specific memory file: {"file_path": "task-123-summary.md"}
-- To get memory index: {} (empty input)
-
-Security:
-- File paths are validated to ensure they are within the agent's memory directory
-- Only files within the agent's designated memory space can be accessed
-`;
-
-// src/tools/memory/MemoryReadTool/MemoryReadTool.tsx
-var inputSchema12 = z13.strictObject({
-  file_path: z13.string().optional().describe("Optional path to a specific memory file to read")
-});
-var MemoryReadTool = {
-  name: "MemoryRead",
-  async description() {
-    return DESCRIPTION9;
-  },
-  async prompt() {
-    return PROMPT10;
-  },
-  inputSchema: inputSchema12,
-  userFacingName() {
-    return "Read Memory";
-  },
-  async isEnabled() {
-    return resolveAutoMemoryFlags().enabled;
-  },
-  isReadOnly() {
-    return true;
-  },
-  isConcurrencySafe() {
-    return true;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant({ content }) {
-    return content;
-  },
-  renderToolUseMessage(input) {
-    return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React8.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  renderToolResultMessage(output) {
-    return /* @__PURE__ */ React8.createElement(Box8, { justifyContent: "space-between", overflowX: "hidden", width: "100%" }, /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "row" }, /* @__PURE__ */ React8.createElement(Text8, null, "\xA0\xA0\uFFFD?\xA0"), /* @__PURE__ */ React8.createElement(Text8, null, output.content)));
-  },
-  async validateInput({ file_path }, context) {
-    const cwd = getCwd();
-    const projectId = await resolveProjectId(cwd);
-    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
-    const agentId = resolveAgentId(context?.agentId);
-    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
-      agentId,
-      agentType: context?.agentType
-    });
-    if (file_path) {
-      const resolved = resolveMemoryPath(agentMemoryDir, file_path);
-      if (!resolved.ok) {
-        return { result: false, message: "Invalid memory file path" };
-      }
-      if (!existsSync5(resolved.fullPath)) {
-        return { result: false, message: "Memory file does not exist" };
-      }
-    }
-    return { result: true };
-  },
-  async *call({ file_path }, context) {
-    const cwd = getCwd();
-    const projectId = await resolveProjectId(cwd);
-    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
-    const agentId = resolveAgentId(context?.agentId);
-    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
-      agentId,
-      agentType: context?.agentType
-    });
-    mkdirSync2(agentMemoryDir, { recursive: true });
-    if (file_path) {
-      const resolved = resolveMemoryPath(agentMemoryDir, file_path);
-      if (!resolved.ok) {
-        throw new Error("Invalid memory file path");
-      }
-      const fullPath = resolved.fullPath;
-      if (!existsSync5(fullPath)) {
-        throw new Error("Memory file does not exist");
-      }
-      const content2 = readFileSync4(fullPath, "utf-8");
-      yield {
-        type: "result",
-        data: {
-          content: content2
-        },
-        resultForAssistant: this.renderResultForAssistant({ content: content2 })
-      };
-      return;
-    }
-    const files = readdirSync(agentMemoryDir, { recursive: true }).map((f) => join2(agentMemoryDir, f.toString())).filter((f) => !lstatSync(f).isDirectory()).map((f) => `- ${f}`).join("\n");
-    const indexPath = join2(agentMemoryDir, "index.md");
-    const index = existsSync5(indexPath) ? readFileSync4(indexPath, "utf-8") : "";
-    const quotes = "'''";
-    const content = `Here are the contents of the agent memory file, \`${indexPath}\`:
-${quotes}
-${index}
-${quotes}
-
-Files in the agent memory directory:
-${files}`;
-    yield {
-      type: "result",
-      data: { content },
-      resultForAssistant: this.renderResultForAssistant({ content })
-    };
-  }
-};
-
-// src/tools/memory/MemoryWriteTool/MemoryWriteTool.tsx
-import { Box as Box9, Text as Text9 } from "ink";
-import * as React9 from "react";
-import { z as z14 } from "zod";
-
-// src/services/memory/write.ts
-import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync5,
-  renameSync,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { dirname as dirname2 } from "path";
-var defaultFsDeps = {
-  mkdirSync: mkdirSync3,
-  existsSync: existsSync6,
-  readFileSync: readFileSync5,
-  writeFileSync: writeFileSync2,
-  renameSync,
-  rmSync: rmSync2
-};
-function mergeContent(existing, incoming, mode) {
-  if (mode === "replace") return incoming;
-  if (!existing) return incoming;
-  if (!incoming) return existing;
-  return `${existing}
-${incoming}`;
-}
-function writeMemoryFile(input, deps) {
-  const fs = { ...defaultFsDeps, ...deps || {} };
-  const mode = input.mode || "replace";
-  const filePath = input.filePath;
-  const tempPath = `${filePath}.tmp`;
-  fs.mkdirSync(dirname2(filePath), { recursive: true });
-  const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
-  const nextContent = mergeContent(existing, input.content, mode);
-  fs.writeFileSync(tempPath, nextContent, "utf8");
-  try {
-    fs.renameSync(tempPath, filePath);
-  } catch {
-    fs.writeFileSync(filePath, nextContent, "utf8");
-    if (fs.existsSync(tempPath)) {
-      fs.rmSync(tempPath, { force: true });
-    }
-  }
-}
-
-// src/tools/memory/MemoryWriteTool/prompt.ts
-var DESCRIPTION10 = "Write agent memory files to the local filesystem.";
-var PROMPT11 = `Write agent memory files to the local filesystem.
-
-Usage:
-- The file_path parameter is required and specifies the memory file to write
-- The content parameter is required and contains the content to write
-- The optional mode parameter supports append or replace (default replace)
-- Memory files are stored under ~/.pyb/memory/projects/{projectId}/memory
-- Use this tool to store agent memories and task execution details
-- In replace mode existing file content is overwritten
-- In append mode content is appended to the existing file
-
-Security:
-- File paths are validated to ensure they are within the agent's memory directory
-- Only files within the agent's designated memory space can be written
-- Directory structure is automatically created if it doesn't exist
-
-Example:
-{
-  "file_path": "task-123-summary.md",
-  "content": "# Task Summary
-
-This is the summary of the task execution...",
-  "mode": "append"
-}
-`;
-
-// src/tools/memory/MemoryWriteTool/MemoryWriteTool.tsx
-var inputSchema13 = z14.strictObject({
-  file_path: z14.string().describe("Path to the memory file to write"),
-  content: z14.string().describe("Content to write to the file"),
-  mode: z14.enum(["append", "replace"]).optional().describe("Write mode: append adds to existing content, replace overwrites")
-});
-var MemoryWriteTool = {
-  name: "MemoryWrite",
-  async description() {
-    return DESCRIPTION10;
-  },
-  async prompt() {
-    return PROMPT11;
-  },
-  inputSchema: inputSchema13,
-  userFacingName() {
-    return "Write Memory";
-  },
-  async isEnabled() {
-    return resolveAutoMemoryFlags().enabled;
-  },
-  isReadOnly() {
-    return false;
-  },
-  isConcurrencySafe() {
-    return false;
-  },
-  needsPermissions() {
-    return false;
-  },
-  renderResultForAssistant(content) {
-    return content;
-  },
-  renderToolUseMessage(input) {
-    return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
-  },
-  renderToolUseRejectedMessage() {
-    return /* @__PURE__ */ React9.createElement(FallbackToolUseRejectedMessage, null);
-  },
-  renderToolResultMessage() {
-    return /* @__PURE__ */ React9.createElement(Box9, { justifyContent: "space-between", overflowX: "hidden", width: "100%" }, /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "row" }, /* @__PURE__ */ React9.createElement(Text9, null, "  ", "\uFFFD?Updated memory")));
-  },
-  async validateInput({ file_path }, context) {
-    const cwd = getCwd();
-    const projectId = await resolveProjectId(cwd);
-    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
-    const agentId = resolveAgentId(context?.agentId);
-    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
-      agentId,
-      agentType: context?.agentType
-    });
-    const resolved = resolveMemoryPath(agentMemoryDir, file_path);
-    if (!resolved.ok) {
-      return { result: false, message: "Invalid memory file path" };
-    }
-    return { result: true };
-  },
-  async *call({ file_path, content, mode }, context) {
-    const cwd = getCwd();
-    const projectId = await resolveProjectId(cwd);
-    const projectMemoryDir = getProjectMemoryDir(MEMORY_DIR, projectId);
-    const agentId = resolveAgentId(context?.agentId);
-    const agentMemoryDir = getAgentMemoryDir(projectMemoryDir, {
-      agentId,
-      agentType: context?.agentType
-    });
-    const resolved = resolveMemoryPath(agentMemoryDir, file_path);
-    if (!resolved.ok) {
-      throw new Error("Invalid memory file path");
-    }
-    const fullPath = resolved.fullPath;
-    writeMemoryFile({ filePath: fullPath, content, mode });
-    recordFileEdit(fullPath, content);
-    yield {
-      type: "result",
-      data: "Saved",
-      resultForAssistant: "Saved"
-    };
-  }
-};
-
-// src/tools/index.ts
-var getAllTools = () => [
-  TaskTool,
-  AskExpertModelTool,
-  BashTool,
-  TaskOutputTool,
-  KillShellTool,
-  GlobTool,
-  GrepTool,
-  LspTool,
-  FileReadTool,
-  FileEditTool,
-  FileWriteTool,
-  DeleteTool,
-  NotebookEditTool,
-  TaskCreateTool,
-  TaskGetTool,
-  TaskUpdateTool,
-  TaskListTool,
-  WebFetchTool,
-  WebSearchTool,
-  AskUserQuestionTool,
-  SlashCommandTool,
-  SkillTool,
-  MemoryReadTool,
-  MemoryWriteTool,
-  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 {
-  toTaskListItem,
-  toTaskDetail,
-  getAllTools,
-  getTools,
-  getReadOnlyTools
-};