@cydm/pie 1.0.5 → 1.0.6

package/dist/chunks/chunk-TBJ25UWB.js

@@ -0,0 +1,3657 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  Agent,
+  FileSystemGateway,
+  detectPlatform,
+  getFileSystem,
+  getPlatformConfig,
+  streamSimple
+} from "./chunk-MWFBYJOI.js";
+import {
+  Type
+} from "./chunk-RID3574D.js";
+import {
+  __require
+} from "./chunk-TG2EQLX2.js";
+
+// ../../packages/shared-headless-capabilities/src/capability.ts
+function defineSharedCapability(definition) {
+  return definition;
+}
+function collectSharedCapabilityPromptAdditions(definitions, activeToolNames) {
+  const activeTools = activeToolNames ? new Set(activeToolNames) : null;
+  const additions = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    if (!definition.systemPromptAdditions?.length) continue;
+    if (activeTools && definition.tools?.length) {
+      const hasActiveTool = definition.tools.some((tool) => {
+        return typeof tool?.name === "string" && activeTools.has(tool.name);
+      });
+      if (!hasActiveTool) continue;
+    }
+    for (const addition of definition.systemPromptAdditions) {
+      const trimmed = addition.trim();
+      if (trimmed) additions.add(trimmed);
+    }
+  }
+  return [...additions];
+}
+
+// ../../packages/shared-headless-capabilities/src/plan.ts
+var PLAN_MODE_TOOL_NAMES = ["read", "bash", "grep", "find", "ls", "ask_user_multi", "manage_todo_list"];
+var SAFE_PREFIXES = [
+  "cat ",
+  "ls ",
+  "find ",
+  "grep ",
+  "head ",
+  "tail ",
+  "echo ",
+  "pwd",
+  "cd ",
+  "which ",
+  "git status",
+  "git log",
+  "git diff",
+  "git show",
+  "git branch -a",
+  "git remote -v",
+  "git config --list",
+  "npm list",
+  "npm view"
+];
+var DANGEROUS_PATTERNS = [
+  /\brm\s+-[rf]*/i,
+  />[\s]*\/dev\//,
+  /\|.*\brm\b/,
+  /git\s+push/i,
+  /git\s+reset/i,
+  /git\s+checkout\s+-/,
+  /git\s+revert/i,
+  /npm\s+publish/i,
+  /npm\s+uninstall/i,
+  /npm\s+rm/i
+];
+function extractPlanTodoItems(text) {
+  const items = [];
+  const planMatch = text.match(/Plan:\s*\n?([\s\S]*?)(?=\n\n|\n[A-Z]|$)/i);
+  if (!planMatch) return items;
+  const lines = planMatch[1].split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^(?:\d+[.):\s]+|[\-*]\s+)(.+)$/);
+    if (!match) continue;
+    items.push({
+      step: items.length + 1,
+      text: match[1].trim(),
+      completed: false
+    });
+  }
+  return items;
+}
+function isPlanModeSafeCommand(command) {
+  const trimmed = command.trim();
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return false;
+    }
+  }
+  for (const prefix of SAFE_PREFIXES) {
+    if (trimmed.startsWith(prefix)) {
+      return true;
+    }
+  }
+  if (/^[a-z]+$/.test(trimmed)) {
+    return ["pwd", "ls", "clear", "whoami"].includes(trimmed);
+  }
+  return false;
+}
+function extractDoneSteps(text) {
+  const steps = [];
+  const matches = text.matchAll(/\[DONE:\s*(\d+)\]/gi);
+  for (const match of matches) {
+    const step = Number.parseInt(match[1], 10);
+    if (Number.isFinite(step)) {
+      steps.push(step);
+    }
+  }
+  return steps;
+}
+function markCompletedPlanSteps(text, todoItems) {
+  let markedCount = 0;
+  for (const stepNum of extractDoneSteps(text)) {
+    const item = todoItems.find((todo) => todo.step === stepNum);
+    if (item && !item.completed) {
+      item.completed = true;
+      markedCount++;
+    }
+  }
+  return markedCount;
+}
+function createPlanCapability() {
+  return defineSharedCapability({
+    id: "plan",
+    description: "Shared headless plan/execution capability with plan extraction, read-only filtering, and execution progress tracking helpers.",
+    commands: [{
+      id: "tools.plan",
+      name: "plan",
+      path: ["tools", "plan"],
+      description: "Toggle plan mode and coordinate plan execution."
+    }],
+    extensions: [{ name: "plan-mode", description: "Provides plan-mode event handling and execution state tracking." }],
+    requiredInteractions: ["notify", "select_one", "multiline_input"]
+  });
+}
+
+// ../../packages/shared-headless-capabilities/src/read-skill.ts
+var ReadSkillParamsSchema = Type.Object({
+  name: Type.String({ description: "Exact skill name from the available_skills list." })
+});
+function createReadSkillCapability(deps) {
+  async function resolveSkill(name) {
+    if (deps.resolveSkill) {
+      return deps.resolveSkill(name);
+    }
+    const skill = deps.skillLoader?.getSkill?.(name) ?? deps.skillLoader?.loadSkill?.(name);
+    if (!skill) {
+      return null;
+    }
+    return {
+      name: skill.name,
+      source: skill.filePath || "skill-registry",
+      content: skill.prompt
+    };
+  }
+  const tool = {
+    name: "read_skill",
+    label: "read_skill",
+    description: "Load the full contents of a builtin or project skill by exact name.",
+    parameters: ReadSkillParamsSchema,
+    async execute(toolCallIdOrArgs, maybeArgs) {
+      const args = typeof toolCallIdOrArgs === "string" ? maybeArgs : toolCallIdOrArgs;
+      const skillName = String(args?.name || "").trim();
+      const skill = await resolveSkill(skillName);
+      if (!skill?.content) {
+        return {
+          content: [{ type: "text", text: `Skill not found: ${skillName || "(empty)"}` }],
+          details: { found: false, name: skillName || void 0 },
+          isError: true
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `# ${skill.name}
+source: ${skill.source}
+
+${skill.content}`
+        }],
+        details: { found: true, name: skill.name, source: skill.source }
+      };
+    }
+  };
+  return {
+    ...defineSharedCapability({
+      id: "read-skill",
+      description: "Shared capability for loading full skill contents through a host-provided skill resolver.",
+      tools: [tool]
+    }),
+    tool
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/subagent.ts
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatSkillsForPrompt(skills) {
+  if (skills.length === 0) return "";
+  const lines = [
+    "\n\nThe following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of skills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join("\n");
+}
+function collectLastAssistantText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "assistant") {
+      continue;
+    }
+    if (Array.isArray(message.content)) {
+      const textContent = message.content.filter((content) => content?.type === "text" && typeof content.text === "string").map((content) => content.text).join("\n");
+      if (textContent.trim()) {
+        return textContent;
+      }
+    }
+    if (typeof message.content === "string" && message.content.trim()) {
+      return message.content;
+    }
+  }
+  return "";
+}
+function createAgentInstance(deps, systemPrompt, tools) {
+  if (deps.createAgent) {
+    return deps.createAgent({
+      systemPrompt,
+      model: deps.model,
+      tools,
+      apiKey: deps.apiKey
+    });
+  }
+  return new Agent({
+    initialState: {
+      systemPrompt,
+      model: deps.model,
+      tools,
+      thinkingLevel: "off"
+    },
+    apiKey: deps.apiKey
+  });
+}
+async function runSubagentWithProgress(deps, task, reportProgress) {
+  const startTime = Date.now();
+  task.status = "running";
+  deps.debugLog?.("run", "runSubagentWithProgress START", { taskName: task.name, yoloMode: deps.yoloMode });
+  try {
+    reportProgress({ message: `[${task.name}] \u{1F680} Starting...`, increment: 5 });
+    const tools = deps.createRuntimeTools();
+    const parentToolDefs = deps.getParentTools();
+    deps.log(`[Subagent ${task.name}] Sandbox: ${deps.yoloMode ? "disabled" : "enabled"}`);
+    deps.log(`[Subagent ${task.name}] Inheriting ${parentToolDefs.length} tools from parent`);
+    deps.debugLog?.("run", "getAllTools called", { toolCount: parentToolDefs.length });
+    const systemPrompt = `You are a specialized subagent focused on completing one specific task.
+
+Guidelines:
+- Work independently using available tools
+- Focus only on the assigned task
+- Return a structured summary when done
+- Be concise - you have limited turns${formatSkillsForPrompt(deps.skills ?? [])}`;
+    deps.debugLog?.("agent", "Creating Agent", { toolCount: tools.length, hasApiKey: !!deps.apiKey });
+    const subagent = createAgentInstance(deps, systemPrompt, tools);
+    const unsubscribe = subagent.subscribe((event) => {
+      if (event.type === "tool_execution_start") {
+        reportProgress({ message: `[${task.name}] \u{1F527} Using ${event.toolName}...` });
+      }
+    });
+    let prompt = task.prompt;
+    if (!prompt.includes("return") && !prompt.includes("summary")) {
+      prompt += "\n\nPlease provide a concise summary of your findings.";
+    }
+    reportProgress({ message: `[${task.name}] \u{1F4AD} Thinking...`, increment: 10 });
+    reportProgress({ message: `[${task.name}]  Sending prompt to AI...`, increment: 15 });
+    deps.debugLog?.("agent", "Calling prompt", { promptLength: prompt.length });
+    await subagent.prompt(prompt);
+    deps.debugLog?.("agent", "prompt completed");
+    reportProgress({ message: `[${task.name}]  Collecting response...`, increment: 20 });
+    const messages = subagent.state.messages;
+    deps.log(`[Subagent ${task.name}] Total messages: ${messages.length}`);
+    const response = collectLastAssistantText(messages) || "[No response]";
+    unsubscribe();
+    const durationMs = Date.now() - startTime;
+    const toolCalls = messages.filter(
+      (message) => message.role === "assistant" && Array.isArray(message.content) && message.content.some((content) => content.type === "toolCall")
+    ).length;
+    task.status = "completed";
+    task.result = response;
+    task.details = {
+      turns: Math.floor(messages.length / 2),
+      toolCalls,
+      durationMs
+    };
+    task.completedAt = Date.now();
+    reportProgress({ message: `[${task.name}] \u2705 Completed (${durationMs}ms, ${toolCalls} tools)`, increment: 100 });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const stackTrace = error instanceof Error ? error.stack : void 0;
+    deps.debugLog?.("run", "EXCEPTION caught", {
+      error: errorMessage,
+      stack: stackTrace,
+      errorType: error instanceof Error ? error.constructor.name : typeof error,
+      taskName: task.name
+    });
+    task.status = "failed";
+    task.error = stackTrace ? `${errorMessage}
+
+Stack:
+${stackTrace}` : errorMessage;
+    task.completedAt = Date.now();
+    reportProgress({ message: `[${task.name}] \u274C Failed: ${errorMessage.slice(0, 100)}`, increment: 100 });
+  }
+}
+function buildParallelResult(tasks, totalDuration) {
+  let resultText = `\u{1F4CA} Parallel Subagent Results (${tasks.length} tasks, ${totalDuration}ms)
+`;
+  resultText += `${"=".repeat(60)}
+
+`;
+  for (const task of tasks) {
+    const statusEmoji = task.status === "completed" ? "\u2705" : "\u274C";
+    resultText += `${statusEmoji} **${task.name}**`;
+    if (task.details) {
+      resultText += ` (${task.details.durationMs}ms, ${task.details.toolCalls} tools)`;
+    }
+    resultText += "\n";
+    if (task.status === "completed" && task.result) {
+      resultText += `${task.result}
+`;
+    } else if (task.status === "failed" && task.error) {
+      resultText += `Error: ${task.error}
+`;
+    }
+    resultText += "\n";
+  }
+  const completed = tasks.filter((task) => task.status === "completed").length;
+  const failed = tasks.filter((task) => task.status === "failed").length;
+  resultText += `${"=".repeat(60)}
+`;
+  resultText += `Summary: ${completed} completed, ${failed} failed, ${totalDuration}ms total
+`;
+  return resultText;
+}
+function createSubagentCapability(deps) {
+  const spawnParallelTool = {
+    name: "spawn_subagents_parallel",
+    label: "Spawn Subagents (Parallel + Transparent)",
+    description: `Spawns multiple child AI agents that run IN PARALLEL with full transparency.
+
+KEY FEATURES:
+1. All subagents run simultaneously using Promise.all
+2. Each subagent's progress is visible in the tool output (Ctrl+O to expand)
+3. Subagents can run host-provided runtime tools
+4. No context pollution - results are merged into a single response`,
+    parameters: Type.Object({
+      tasks: Type.Array(
+        Type.Object({
+          name: Type.String({ description: "Short name for this subagent (shown in progress updates)" }),
+          prompt: Type.String({ description: "The task/prompt for this subagent. Be specific." })
+        }),
+        { description: "Array of tasks to run in parallel", minItems: 1, maxItems: 10 }
+      ),
+      max_turns: Type.Optional(Type.Number({ description: "Max turns per subagent (default: 15)", default: 15 }))
+    }),
+    async execute(args, toolContext) {
+      if (!deps.apiKey) {
+        return {
+          content: [{ type: "text", text: "Error: No API key available for subagent execution." }],
+          isError: true
+        };
+      }
+      const taskDefs = args.tasks ?? [];
+      const tasks = taskDefs.map((def, index) => ({
+        id: `subagent-${Date.now()}-${index}`,
+        name: def.name || `Task-${index + 1}`,
+        status: "pending",
+        prompt: def.prompt,
+        createdAt: Date.now()
+      }));
+      toolContext.log?.(`Spawning ${tasks.length} parallel subagents: ${tasks.map((task) => task.name).join(", ")}`);
+      toolContext.reportProgress?.({ message: `\u{1F680} Launching ${tasks.length} parallel subagents...`, increment: 5 });
+      const startTime = Date.now();
+      await Promise.all(tasks.map((task) => runSubagentWithProgress(deps, task, toolContext.reportProgress ?? (() => void 0))));
+      const totalDuration = Date.now() - startTime;
+      const completed = tasks.filter((task) => task.status === "completed").length;
+      const failed = tasks.filter((task) => task.status === "failed").length;
+      deps.notify?.(`\u2705 ${completed}/${tasks.length} subagents completed (${totalDuration}ms)`, failed > 0 ? "warning" : "success");
+      return {
+        content: [{ type: "text", text: buildParallelResult(tasks, totalDuration) }],
+        details: {
+          tasks: tasks.map((task) => ({
+            name: task.name,
+            status: task.status,
+            details: task.details
+          })),
+          totalDuration,
+          completed,
+          failed
+        }
+      };
+    }
+  };
+  return {
+    ...defineSharedCapability({
+      id: "subagent",
+      description: "Shared headless subagent capability for spawning child agents in parallel using host-provided runtime tools.",
+      tools: [spawnParallelTool],
+      extensions: [{ name: "subagent", description: "Provides subagent task orchestration and result aggregation." }]
+    }),
+    tools: [spawnParallelTool]
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/todo.ts
+var TodoItemSchema = Type.Object({
+  id: Type.Number({ description: "Unique identifier for the todo. Use sequential numbers starting from 1." }),
+  title: Type.String({ description: "Concise action-oriented todo label (3-7 words)." }),
+  description: Type.String({ description: "Detailed context or implementation notes." }),
+  status: Type.String({
+    description: "Progress state. Preferred values: not-started, in-progress, completed. Also accepts aliases like pending, todo, doing, done."
+  })
+});
+var ManageTodoListParamsSchema = Type.Object({
+  operation: Type.Union([Type.Literal("write"), Type.Literal("read")], {
+    description: "write: Replace the entire todo list. read: Return the current todo list."
+  }),
+  todoList: Type.Optional(
+    Type.Array(TodoItemSchema, {
+      description: "Required for write. Must include the full todo list with sequential ids starting from 1."
+    })
+  )
+});
+function cloneTodos(todos) {
+  return todos.map((todo) => ({ ...todo }));
+}
+function normalizeStatus(status) {
+  const value = String(status || "").trim().toLowerCase();
+  if (!value) return null;
+  if (value === "not-started" || value === "not_started" || value === "pending" || value === "todo" || value === "not started") {
+    return "not-started";
+  }
+  if (value === "in-progress" || value === "in_progress" || value === "in progress" || value === "doing" || value === "active" || value === "working") {
+    return "in-progress";
+  }
+  if (value === "completed" || value === "complete" || value === "done" || value === "finished") {
+    return "completed";
+  }
+  return null;
+}
+function normalizeTodos(todos) {
+  return todos.map((todo) => ({
+    ...todo,
+    status: normalizeStatus(todo.status) ?? todo.status
+  }));
+}
+function validateTodos(todos) {
+  const errors = [];
+  const validStatuses = /* @__PURE__ */ new Set(["not-started", "in-progress", "completed"]);
+  for (let index = 0; index < todos.length; index++) {
+    const item = todos[index];
+    const prefix = `Item ${index + 1}`;
+    if (typeof item?.id !== "number" || !Number.isInteger(item.id) || item.id < 1) {
+      errors.push(`${prefix}: 'id' must be a positive integer`);
+    }
+    if (item?.id !== index + 1) {
+      errors.push(`${prefix}: ids must be sequential starting from 1`);
+    }
+    if (typeof item?.title !== "string" || item.title.trim().length === 0) {
+      errors.push(`${prefix}: 'title' is required`);
+    }
+    if (typeof item?.description !== "string") {
+      errors.push(`${prefix}: 'description' must be a string`);
+    }
+    if (!validStatuses.has(item?.status)) {
+      errors.push(`${prefix}: 'status' must be one of: not-started, in-progress, completed`);
+    }
+  }
+  return errors;
+}
+function getTodoValidation(todos) {
+  const errors = validateTodos(todos);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function getTodoStats(todos) {
+  const total = todos.length;
+  const completed = todos.filter((todo) => todo.status === "completed").length;
+  const inProgress = todos.filter((todo) => todo.status === "in-progress").length;
+  return {
+    total,
+    completed,
+    inProgress,
+    notStarted: total - completed - inProgress
+  };
+}
+function buildTodoSuccessMessage(todos) {
+  const { completed, total } = getTodoStats(todos);
+  if (total > 0 && completed === total) {
+    return `Todos updated successfully. ${completed}/${total} completed. All todos are complete, so the list was cleared.`;
+  }
+  return `Todos updated successfully. ${completed}/${total} completed. Continue updating the list until all items are completed; it will clear automatically when done.`;
+}
+function executeManageTodoList(args, currentTodos) {
+  const safeCurrentTodos = cloneTodos(currentTodos);
+  if (args.operation === "read") {
+    return {
+      nextTodos: safeCurrentTodos,
+      result: {
+        content: [
+          {
+            type: "text",
+            text: safeCurrentTodos.length ? JSON.stringify(safeCurrentTodos, null, 2) : "No todos. Use write operation to create a todo list."
+          }
+        ],
+        details: { operation: "read", todos: safeCurrentTodos }
+      }
+    };
+  }
+  if (!Array.isArray(args.todoList)) {
+    return {
+      nextTodos: safeCurrentTodos,
+      result: {
+        content: [{ type: "text", text: "Error: todoList is required for write operation." }],
+        details: { operation: "write", todos: safeCurrentTodos, error: "todoList required" },
+        isError: true
+      }
+    };
+  }
+  const nextTodos = normalizeTodos(cloneTodos(args.todoList));
+  const errors = validateTodos(nextTodos);
+  if (errors.length > 0) {
+    return {
+      nextTodos: safeCurrentTodos,
+      result: {
+        content: [{ type: "text", text: `Validation failed:
+${errors.map((error) => `  - ${error}`).join("\n")}` }],
+        details: { operation: "write", todos: safeCurrentTodos, error: errors.join("; ") },
+        isError: true
+      }
+    };
+  }
+  const stats = getTodoStats(nextTodos);
+  const autoCleared = stats.total > 0 && stats.completed === stats.total;
+  const storedTodos = autoCleared ? [] : nextTodos;
+  return {
+    nextTodos: storedTodos,
+    result: {
+      content: [{ type: "text", text: buildTodoSuccessMessage(nextTodos) }],
+      details: {
+        operation: "write",
+        todos: cloneTodos(storedTodos),
+        autoCleared,
+        completedTodos: autoCleared ? cloneTodos(nextTodos) : void 0
+      }
+    }
+  };
+}
+function restoreTodoState(state) {
+  if (!Array.isArray(state)) {
+    return [];
+  }
+  const normalized = normalizeTodos(cloneTodos(state));
+  return validateTodos(normalized).length === 0 ? normalized : [];
+}
+function restoreTodosFromMessages(messages) {
+  let todos = [];
+  for (const message of messages || []) {
+    const toolResultMessage = message;
+    if (toolResultMessage.role !== "toolResult" || toolResultMessage.toolName !== "manage_todo_list") {
+      continue;
+    }
+    const details = toolResultMessage.details;
+    if (details?.todos) {
+      todos = restoreTodoState(details.todos);
+    }
+  }
+  return todos;
+}
+function createTodoStore(initialState) {
+  let todos = restoreTodoState(initialState);
+  return {
+    read() {
+      return cloneTodos(todos);
+    },
+    write(nextTodos) {
+      todos = restoreTodoState(nextTodos);
+    },
+    clear() {
+      todos = [];
+    },
+    restore(state) {
+      todos = restoreTodoState(state);
+    },
+    restoreFromMessages(messages) {
+      todos = restoreTodosFromMessages(messages);
+    },
+    getStats() {
+      return getTodoStats(todos);
+    },
+    validate(nextTodos) {
+      if (!Array.isArray(nextTodos)) {
+        return { valid: false, errors: ["todoList must be an array"] };
+      }
+      return getTodoValidation(normalizeTodos(cloneTodos(nextTodos)));
+    }
+  };
+}
+function createManageTodoCapability() {
+  const store = createTodoStore();
+  const tool = {
+    name: "manage_todo_list",
+    label: "manage_todo_list",
+    description: "Read or replace the shared todo checklist for the current session. Use this to actually create and update todo tracking when the user asks for a todo demonstration or progress checklist, not just to describe how todo tracking works.",
+    parameters: ManageTodoListParamsSchema,
+    async execute(args) {
+      const { nextTodos, result } = executeManageTodoList(args, store.read());
+      store.write(nextTodos);
+      return result;
+    }
+  };
+  return {
+    ...defineSharedCapability({
+      id: "todo",
+      description: "Shared headless todo/checklist capability.",
+      tools: [tool],
+      extensions: [{ name: "todo-state", description: "Provides capability-local todo state storage." }],
+      systemPromptAdditions: [
+        "When the user asks you to demonstrate or use todo tracking, call `manage_todo_list` instead of only describing how it works.",
+        "When you start using manage_todo_list for a task, keep the checklist updated whenever step status changes.",
+        "Maintain exactly one in-progress item while work is active, continue updating the checklist until every item is completed, and do not abandon a started checklist.",
+        "A todo demonstration is not complete until `manage_todo_list` has been updated through all steps and the list auto-clears.",
+        "manage_todo_list clears itself automatically when all items are completed, so drive the checklist to completion instead of leaving completed items behind."
+      ]
+    }),
+    tool,
+    createStore: createTodoStore
+  };
+}
+
+// ../../packages/agent-framework/src/session/compaction.ts
+var COMPACT_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
+
+Include:
+- Current progress and key decisions made
+- Important context, constraints, or user preferences
+- What remains to be done (clear next steps)
+- Any critical data, examples, or references needed to continue
+
+Be concise, structured, and focused on helping the next LLM seamlessly continue the work.`;
+var SUMMARY_PREFIX = `Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:`;
+var DEFAULT_COMPACTION_CONFIG = {
+  maxMessages: 100,
+  maxTokens: 8e3,
+  keepRecentUserMessages: 3,
+  maxRetainedUserTokens: 2e4,
+  autoCompact: true,
+  autoCompactTokenLimit: void 0,
+  compactPrompt: COMPACT_PROMPT,
+  summaryPrefix: SUMMARY_PREFIX
+};
+function estimateTokens(message) {
+  const text = getMessageText(message);
+  return Math.ceil(text.length / 4);
+}
+function calculateTotalTokens(messages) {
+  return messages.reduce((sum, m) => sum + estimateTokens(m), 0);
+}
+function isCompactSummaryMessage(message, summaryPrefix = SUMMARY_PREFIX) {
+  return message.startsWith(`${summaryPrefix}
+`);
+}
+function formatCompactSummaryText(summaryText, summaryPrefix = SUMMARY_PREFIX) {
+  const compactSummary = summaryText.trim() || "(no summary available)";
+  return `${summaryPrefix}
+${compactSummary}`;
+}
+function collectRealUserMessages(messages, summaryPrefix = SUMMARY_PREFIX) {
+  return messages.filter((message) => message.role === "user").map((message) => getUserMessageText(message)).filter((text) => Boolean(text)).filter((text) => !isCompactSummaryMessage(text, summaryPrefix)).filter((text) => !isSyntheticUserEnvelope(text));
+}
+function findFirstKeptUserEntryId(entries, options = {}) {
+  const fullConfig = { ...DEFAULT_COMPACTION_CONFIG, ...options };
+  const keepCount = Math.max(0, fullConfig.keepRecentUserMessages);
+  if (keepCount <= 0 || entries.length === 0) {
+    return null;
+  }
+  const userEntries = entries.filter((entry) => entry.type === "message" && !!entry.message && entry.message.role === "user").map((entry) => ({ entryId: entry.id, text: getUserMessageText(entry.message) })).filter((entry) => Boolean(entry.text)).filter((entry) => !isCompactSummaryMessage(entry.text, fullConfig.summaryPrefix ?? SUMMARY_PREFIX)).filter((entry) => !isSyntheticUserEnvelope(entry.text));
+  if (userEntries.length === 0) {
+    return null;
+  }
+  const recentEntries = userEntries.slice(-keepCount);
+  const retainedEntries = applyUserEntryTokenBudget(recentEntries, fullConfig.maxRetainedUserTokens);
+  return retainedEntries[0]?.entryId ?? null;
+}
+async function createCompactionSummary(messages, options = {}) {
+  const { model, apiKey, systemPrompt, compactPrompt, signal } = options;
+  if (!model) {
+    return createSimpleSummary(messages);
+  }
+  try {
+    const response = await streamSimple(
+      model,
+      {
+        systemPrompt,
+        messages: [
+          ...messages.filter(isCompactionCompatibleMessage),
+          {
+            role: "user",
+            content: [{ type: "text", text: compactPrompt ?? COMPACT_PROMPT }],
+            timestamp: Date.now()
+          }
+        ]
+      },
+      {
+        apiKey,
+        signal
+      }
+    ).result();
+    return getAssistantText(response) || createSimpleSummary(messages);
+  } catch (error) {
+    console.warn("[Compaction] Failed to create Codex-style summary:", error);
+    return createSimpleSummary(messages);
+  }
+}
+function getMessageText(message) {
+  if (message.role === "user") {
+    return getUserMessageText(message);
+  }
+  if (message.role === "assistant") {
+    return message.content.filter((c) => c.type === "text").map((c) => c.text).join(" ");
+  }
+  if (message.role === "toolResult") {
+    return message.content.filter((c) => c.type === "text").map((c) => c.text).join(" ");
+  }
+  return "";
+}
+function getUserMessageText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.filter((c) => c.type === "text").map((c) => c.text).join(" ");
+}
+function getAssistantText(message) {
+  return message.content.filter((c) => c.type === "text").map((c) => c.text).join("").trim();
+}
+function createSimpleSummary(messages) {
+  const userMessages = collectRealUserMessages(messages);
+  const lastUserMessage = userMessages.at(-1);
+  const assistantCount = messages.filter((m) => m.role === "assistant").length;
+  const toolCount = messages.filter((m) => m.role === "toolResult").length;
+  return [
+    `- Conversation turns: ${messages.length}`,
+    `- Assistant responses: ${assistantCount}`,
+    `- Tool results: ${toolCount}`,
+    lastUserMessage ? `- Latest user request: ${lastUserMessage}` : ""
+  ].filter(Boolean).join("\n");
+}
+function applyUserEntryTokenBudget(entries, maxTokens) {
+  if (maxTokens <= 0 || entries.length === 0) {
+    return [];
+  }
+  const selected = [];
+  let remaining = maxTokens;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    const messageTokens = approximateTextTokens(entry.text);
+    if (messageTokens <= remaining) {
+      selected.unshift(entry);
+      remaining -= messageTokens;
+      continue;
+    }
+    if (selected.length === 0) {
+      selected.unshift({
+        entryId: entry.entryId,
+        text: truncateTextToTokenBudget(entry.text, remaining)
+      });
+    }
+    break;
+  }
+  return selected;
+}
+function truncateTextToTokenBudget(text, maxTokens) {
+  if (maxTokens <= 0) {
+    return "[truncated]";
+  }
+  const maxChars = Math.max(16, maxTokens * 4);
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxChars - 15)).trimEnd()}... [truncated]`;
+}
+function approximateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function isSyntheticUserEnvelope(text) {
+  const trimmed = text.trimStart();
+  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<turn_aborted>") || trimmed.startsWith("# AGENTS.md instructions");
+}
+function isCompactionCompatibleMessage(message) {
+  if (message.role === "user") return true;
+  if (message.role === "assistant") return true;
+  if (message.role === "toolResult") return true;
+  return false;
+}
+
+// ../../packages/agent-framework/src/session/types.ts
+function generateEntryId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `entry-${timestamp}-${random}`;
+}
+function buildTree(entries, activeEntryId) {
+  const byId = /* @__PURE__ */ new Map();
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    byId.set(entry.id, entry);
+    if (entry.parentId) {
+      const siblings = childrenMap.get(entry.parentId) ?? [];
+      siblings.push(entry.id);
+      childrenMap.set(entry.parentId, siblings);
+    }
+  }
+  const rootIds = entries.filter((e) => e.parentId === null).map((e) => e.id);
+  const activePath = /* @__PURE__ */ new Set();
+  if (activeEntryId) {
+    let current = activeEntryId;
+    while (current) {
+      activePath.add(current);
+      const entry = byId.get(current);
+      current = entry?.parentId ?? null;
+    }
+  }
+  function buildNode(entryId, depth) {
+    const entry = byId.get(entryId);
+    const childIds = childrenMap.get(entryId) ?? [];
+    return {
+      id: entryId,
+      parentId: entry.parentId,
+      entry,
+      children: childIds.map((id) => buildNode(id, depth + 1)),
+      depth,
+      isActive: activePath.has(entryId)
+    };
+  }
+  return rootIds.map((id) => buildNode(id, 0));
+}
+function flattenTreeToMessages(entries, activeEntryId) {
+  const byId = new Map(entries.map((e) => [e.id, e]));
+  const messages = [];
+  const path = [];
+  let current = activeEntryId;
+  while (current) {
+    path.unshift(current);
+    const entry = byId.get(current);
+    current = entry?.parentId ?? null;
+  }
+  const pathEntries = path.map((entryId) => byId.get(entryId)).filter((entry) => Boolean(entry));
+  const latestCompactionIndex = findLatestCompactionIndex(pathEntries);
+  if (latestCompactionIndex === -1) {
+    for (const entry of pathEntries) {
+      if (entry.type === "message" && entry.message) {
+        messages.push(entry.message);
+      }
+    }
+    return messages;
+  }
+  const compactionEntry = pathEntries[latestCompactionIndex];
+  const compactionData = compactionEntry.compactionData;
+  if (!compactionData) {
+    for (const entry of pathEntries) {
+      if (entry.type === "message" && entry.message) {
+        messages.push(entry.message);
+      }
+    }
+    return messages;
+  }
+  messages.push(createCompactionSummaryMessage(compactionData.summary, compactionEntry.timestamp));
+  let foundFirstKept = false;
+  for (let i = 0; i < latestCompactionIndex; i++) {
+    const entry = pathEntries[i];
+    if (entry.id === compactionData.firstKeptEntryId) {
+      foundFirstKept = true;
+    }
+    if (foundFirstKept && entry.type === "message" && entry.message) {
+      messages.push(entry.message);
+    }
+  }
+  for (let i = latestCompactionIndex + 1; i < pathEntries.length; i++) {
+    const entry = pathEntries[i];
+    if (entry.type === "message" && entry.message) {
+      messages.push(entry.message);
+    }
+  }
+  return messages;
+}
+function findLatestCompactionIndex(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].type === "compaction" && entries[i].compactionData) {
+      return i;
+    }
+  }
+  return -1;
+}
+function createCompactionSummaryMessage(summary, timestamp) {
+  return {
+    role: "user",
+    content: [{ type: "text", text: formatCompactSummaryText(summary) }],
+    timestamp
+  };
+}
+
+// ../../packages/agent-framework/src/session/store.ts
+var SESSION_VERSION = 2;
+function isSessionEntry(value) {
+  return !!value && typeof value === "object" && "id" in value && "type" in value;
+}
+function normalizeEntriesInput(entriesOrMessages) {
+  if (entriesOrMessages.every(isSessionEntry)) {
+    return entriesOrMessages;
+  }
+  const entries = [];
+  let parentId = null;
+  for (const message of entriesOrMessages) {
+    const entry = {
+      id: generateEntryId(),
+      parentId,
+      type: "message",
+      timestamp: Date.now(),
+      message
+    };
+    entries.push(entry);
+    parentId = entry.id;
+  }
+  return entries;
+}
+var LEGACY_VERSION = 1;
+function getDefaultSessionsDir() {
+  return getPlatformConfig().sessionsPath;
+}
+function migrateV1ToV2(data) {
+  console.log(`[SessionStore] Migrating session ${data.metadata.id} from v1 to v2`);
+  const messages = data.messages ?? [];
+  const entries = [];
+  let parentId = null;
+  for (const message of messages) {
+    const entry = {
+      id: generateEntryId(),
+      parentId,
+      type: "message",
+      timestamp: Date.now(),
+      message
+    };
+    entries.push(entry);
+    parentId = entry.id;
+  }
+  const activeEntryId = entries.length > 0 ? entries[entries.length - 1].id : null;
+  const rootEntryId = entries.length > 0 ? entries[0].id : null;
+  return {
+    version: SESSION_VERSION,
+    metadata: {
+      ...data.metadata,
+      entryCount: entries.length,
+      messageCount: messages.length,
+      activeEntryId,
+      rootEntryId
+    },
+    entries,
+    messages
+    // Keep for backward compatibility
+  };
+}
+function writeFileAtomic(gateway, filePath, content) {
+  const tempPath = filePath + ".tmp";
+  gateway.writeFile(tempPath, content, "utf-8");
+  try {
+    const req = globalThis.require;
+    if (typeof req === "function") {
+      req("fs").renameSync(tempPath, filePath);
+    } else {
+      gateway.writeFile(filePath, content, "utf-8");
+      try {
+        gateway.deleteFile(tempPath);
+      } catch {
+      }
+    }
+  } catch {
+    gateway.writeFile(filePath, content, "utf-8");
+    try {
+      gateway.deleteFile(tempPath);
+    } catch {
+    }
+  }
+}
+var FileSessionStore = class {
+  sessionsDir;
+  gateway;
+  constructor(sessionsDir) {
+    this.sessionsDir = sessionsDir || getDefaultSessionsDir();
+    this.gateway = new FileSystemGateway({
+      allowedRoots: [this.sessionsDir, getPlatformConfig().dataPath]
+    });
+    this.ensureDirectory();
+  }
+  /**
+   * Ensure the sessions directory exists
+   */
+  ensureDirectory() {
+    try {
+      if (!this.gateway.exists(this.sessionsDir)) {
+        this.gateway.mkdir(this.sessionsDir, { recursive: true });
+      }
+    } catch (e) {
+      console.warn(`[FileSessionStore] Could not create sessions directory: ${e}`);
+    }
+  }
+  /**
+   * Get the full path for a session file
+   */
+  getSessionPath(sessionId) {
+    const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return this.gateway.join(this.sessionsDir, `${safeId}.json`);
+  }
+  /**
+   * Save a session to disk (v2 format)
+   */
+  async save(sessionId, entries, metadata) {
+    const normalizedEntries = normalizeEntriesInput(entries);
+    const now = Date.now();
+    const existing = await this.load(sessionId);
+    const messageCount = normalizedEntries.filter((e) => e.type === "message" && e.message).length;
+    const rootEntry = normalizedEntries.find((e) => e.parentId === null);
+    const activeEntryId = metadata?.activeEntryId ?? existing?.metadata.activeEntryId ?? normalizedEntries[normalizedEntries.length - 1]?.id ?? null;
+    const sessionData = {
+      version: SESSION_VERSION,
+      metadata: {
+        id: sessionId,
+        name: metadata?.name ?? existing?.metadata.name ?? `Session ${sessionId.slice(0, 8)}`,
+        createdAt: existing?.metadata.createdAt ?? now,
+        updatedAt: now,
+        entryCount: normalizedEntries.length,
+        messageCount,
+        activeEntryId: activeEntryId ?? rootEntry?.id ?? null,
+        rootEntryId: rootEntry?.id ?? null,
+        tags: metadata?.tags ?? existing?.metadata.tags,
+        ...metadata
+      },
+      entries: normalizedEntries,
+      messages: flattenTreeToMessages(normalizedEntries, activeEntryId ?? null)
+    };
+    const json = JSON.stringify(sessionData, null, 2);
+    const filePath = this.getSessionPath(sessionId);
+    writeFileAtomic(this.gateway, filePath, json);
+  }
+  /**
+   * Legacy save method for backward compatibility
+   * @deprecated Use save() with entries instead
+   */
+  async saveLegacy(sessionId, messages, metadata) {
+    console.warn("[FileSessionStore] Using deprecated saveLegacy() - consider migrating to v2");
+    const entries = [];
+    let parentId = null;
+    for (const message of messages) {
+      const entry = {
+        id: generateEntryId(),
+        parentId,
+        type: "message",
+        timestamp: Date.now(),
+        message
+      };
+      entries.push(entry);
+      parentId = entry.id;
+    }
+    await this.save(sessionId, entries, metadata);
+  }
+  /**
+   * Load a session from disk
+   */
+  async load(sessionId) {
+    const filePath = this.getSessionPath(sessionId);
+    if (!this.gateway.exists(filePath)) {
+      return null;
+    }
+    try {
+      const json = this.gateway.readFile(filePath, "utf-8");
+      if (!json || json.trim().length === 0) {
+        console.warn(`[SessionStore] Empty session file: ${sessionId}, removing`);
+        this.gateway.deleteFile(filePath);
+        return null;
+      }
+      const data = JSON.parse(json);
+      if (data.version === LEGACY_VERSION || !data.version) {
+        const migrated = migrateV1ToV2(data);
+        const migratedJson = JSON.stringify(migrated, null, 2);
+        writeFileAtomic(this.gateway, filePath, migratedJson);
+        return migrated;
+      }
+      if (data.version !== SESSION_VERSION) {
+        console.warn(
+          `[SessionStore] Session version mismatch: ${data.version} vs ${SESSION_VERSION}`
+        );
+      }
+      if (!data.entries) {
+        data.entries = [];
+      }
+      return data;
+    } catch (e) {
+      console.error(`[SessionStore] Failed to load session: ${sessionId}`, e);
+      return null;
+    }
+  }
+  /**
+   * Delete a session
+   */
+  async delete(sessionId) {
+    const filePath = this.getSessionPath(sessionId);
+    if (!this.gateway.exists(filePath)) {
+      return false;
+    }
+    try {
+      this.gateway.deleteFile(filePath);
+      return true;
+    } catch (e) {
+      console.error(`[SessionStore] Failed to delete session: ${sessionId}`, e);
+      return false;
+    }
+  }
+  /**
+   * Check if a session exists
+   */
+  async exists(sessionId) {
+    const filePath = this.getSessionPath(sessionId);
+    return this.gateway.exists(filePath);
+  }
+  /**
+   * List all session IDs
+   */
+  async list() {
+    if (!this.gateway.exists(this.sessionsDir)) {
+      return [];
+    }
+    const files = this.gateway.readdir(this.sessionsDir);
+    return files.filter((f) => f.endsWith(".json")).filter((f) => !f.endsWith("-files.json")).map((f) => f.replace(/\.json$/i, ""));
+  }
+  /**
+   * List all session metadata
+   */
+  async listMetadata() {
+    const sessionIds = await this.list();
+    const metadata = [];
+    for (const id of sessionIds) {
+      const meta = await this.getMetadata(id);
+      if (meta) {
+        metadata.push(meta);
+      }
+    }
+    return metadata.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /**
+   * Get session metadata without loading full entries
+   */
+  async getMetadata(sessionId) {
+    const data = await this.load(sessionId);
+    return data?.metadata ?? null;
+  }
+};
+
+// ../../packages/agent-framework/src/session/manager.ts
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${random}`;
+}
+var SessionManager = class {
+  store;
+  activeSession = null;
+  options;
+  autoSaveTimer = null;
+  gateway;
+  constructor(options = {}) {
+    this.options = {
+      sessionsDir: options.sessionsDir ?? getDefaultSessionsDir(),
+      autoSaveInterval: options.autoSaveInterval ?? 0,
+      maxSessions: options.maxSessions ?? 100,
+      version: options.version ?? 2
+    };
+    this.gateway = new FileSystemGateway({
+      allowedRoots: [this.options.sessionsDir, getPlatformConfig().dataPath]
+    });
+    if (!this.gateway.exists(this.options.sessionsDir)) {
+      this.gateway.mkdir(this.options.sessionsDir, { recursive: true });
+    }
+    this.store = new FileSessionStore(this.options.sessionsDir);
+    if (this.options.autoSaveInterval > 0) {
+      this.startAutoSave();
+    }
+  }
+  /**
+   * Get the session store
+   */
+  getStore() {
+    return this.store;
+  }
+  /**
+   * Start auto-save timer
+   */
+  startAutoSave() {
+    if (this.autoSaveTimer) {
+      clearInterval(this.autoSaveTimer);
+    }
+    this.autoSaveTimer = setInterval(() => {
+      if (this.activeSession?.isDirty) {
+        this.save().catch((e) => {
+        });
+      }
+    }, this.options.autoSaveInterval);
+  }
+  /**
+   * Stop auto-save timer
+   */
+  stopAutoSave() {
+    if (this.autoSaveTimer) {
+      clearInterval(this.autoSaveTimer);
+      this.autoSaveTimer = null;
+    }
+  }
+  /**
+   * Create a new session with tree structure
+   */
+  async createSession(name, tags, sessionId) {
+    const id = sessionId || generateSessionId();
+    this.activeSession = {
+      id,
+      metadata: {
+        id,
+        name: name ?? `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        entryCount: 0,
+        messageCount: 0,
+        activeEntryId: null,
+        rootEntryId: null,
+        tags
+      },
+      isDirty: true,
+      entries: [],
+      activeEntryId: null
+    };
+    await this.save();
+    return id;
+  }
+  /**
+   * Load an existing session
+   */
+  async loadSession(sessionId) {
+    const data = await this.store.load(sessionId);
+    if (!data) {
+      console.warn(`[SessionManager] Session not found: ${sessionId}`);
+      return false;
+    }
+    if (!data.entries) {
+      data.entries = [];
+    }
+    this.activeSession = {
+      id: sessionId,
+      metadata: data.metadata,
+      isDirty: false,
+      lastSavedAt: data.metadata.updatedAt,
+      entries: data.entries,
+      activeEntryId: data.metadata.activeEntryId ?? null
+    };
+    return true;
+  }
+  /**
+   * Save the current session
+   */
+  async save() {
+    if (!this.activeSession) {
+      throw new Error("No active session to save");
+    }
+    this.activeSession.metadata.entryCount = this.activeSession.entries.length;
+    this.activeSession.metadata.messageCount = this.activeSession.entries.filter(
+      (e) => e.type === "message" && e.message
+    ).length;
+    if (this.activeSession.metadata.messageCount === 0) {
+      if (await this.store.exists(this.activeSession.id)) {
+        await this.store.delete(this.activeSession.id);
+      }
+      this.activeSession.isDirty = false;
+      return;
+    }
+    this.activeSession.metadata.updatedAt = Date.now();
+    this.activeSession.metadata.activeEntryId = this.activeSession.activeEntryId;
+    this.activeSession.metadata.rootEntryId = this.activeSession.entries.find(
+      (e) => e.parentId === null
+    )?.id ?? null;
+    await this.store.save(
+      this.activeSession.id,
+      this.activeSession.entries,
+      this.activeSession.metadata
+    );
+    this.activeSession.isDirty = false;
+    this.activeSession.lastSavedAt = Date.now();
+  }
+  /**
+   * Add a new entry to the session
+   */
+  addEntry(entryType, message) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    const entry = {
+      id: generateEntryId(),
+      parentId: this.activeSession.activeEntryId,
+      type: entryType,
+      timestamp: Date.now(),
+      message
+    };
+    this.activeSession.entries.push(entry);
+    this.activeSession.activeEntryId = entry.id;
+    this.activeSession.isDirty = true;
+    return entry;
+  }
+  /**
+   * Add a message entry to the session
+   */
+  addMessage(message) {
+    return this.addEntry("message", message);
+  }
+  /**
+   * Append a compaction checkpoint to the current active path.
+   * Full history remains in entries; active messages are reconstructed from this checkpoint onward.
+   */
+  appendCompaction(summary, firstKeptEntryId, tokensBefore) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    const entry = {
+      id: generateEntryId(),
+      parentId: this.activeSession.activeEntryId,
+      type: "compaction",
+      timestamp: Date.now(),
+      compactionData: {
+        summary,
+        firstKeptEntryId,
+        tokensBefore
+      }
+    };
+    this.activeSession.entries.push(entry);
+    this.activeSession.activeEntryId = entry.id;
+    this.activeSession.isDirty = true;
+    return entry;
+  }
+  /**
+   * Update messages (legacy compatibility - rebuilds tree)
+   * @deprecated Use addMessage() instead
+   */
+  updateMessages(messages) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    const newEntries = [];
+    let parentId = null;
+    for (const message of messages) {
+      const entry = {
+        id: generateEntryId(),
+        parentId,
+        type: "message",
+        timestamp: Date.now(),
+        message
+      };
+      newEntries.push(entry);
+      parentId = entry.id;
+    }
+    this.activeSession.entries = newEntries;
+    this.activeSession.activeEntryId = newEntries.length > 0 ? newEntries[newEntries.length - 1].id : null;
+    this.activeSession.isDirty = true;
+  }
+  /**
+   * Get current messages (linear path from root to active leaf)
+   */
+  getMessages() {
+    if (!this.activeSession) {
+      return [];
+    }
+    return flattenTreeToMessages(this.activeSession.entries, this.activeSession.activeEntryId);
+  }
+  /**
+   * Get current entries
+   */
+  getEntries() {
+    return this.activeSession?.entries ?? [];
+  }
+  /**
+   * Get active session info
+   */
+  getActiveSession() {
+    return this.activeSession;
+  }
+  /**
+   * Get active session ID
+   */
+  getActiveSessionId() {
+    return this.activeSession?.id ?? null;
+  }
+  /**
+   * Get current active entry ID
+   */
+  getActiveEntryId() {
+    return this.activeSession?.activeEntryId ?? null;
+  }
+  /**
+   * Set active entry (for navigation)
+   */
+  setActiveEntry(entryId) {
+    if (!this.activeSession) {
+      return false;
+    }
+    if (entryId === null) {
+      this.activeSession.activeEntryId = null;
+      this.activeSession.isDirty = true;
+      return true;
+    }
+    const entry = this.activeSession.entries.find((e) => e.id === entryId);
+    if (!entry) {
+      console.warn(`[SessionManager] Entry not found: ${entryId}`);
+      return false;
+    }
+    this.activeSession.activeEntryId = entryId;
+    this.activeSession.isDirty = true;
+    return true;
+  }
+  /**
+   * Get entry by ID
+   */
+  getEntry(entryId) {
+    if (!this.activeSession) {
+      return null;
+    }
+    return this.activeSession.entries.find((e) => e.id === entryId) ?? null;
+  }
+  /**
+   * Get children of an entry
+   */
+  getChildren(parentId) {
+    if (!this.activeSession) {
+      return [];
+    }
+    return this.activeSession.entries.filter((e) => e.parentId === parentId);
+  }
+  /**
+   * Get tree structure
+   */
+  getTree() {
+    if (!this.activeSession) {
+      return [];
+    }
+    return buildTree(this.activeSession.entries, this.activeSession.activeEntryId);
+  }
+  /**
+   * Branch from a specific entry (in-session branching)
+   * Moves the active entry pointer to the specified entry.
+   * Next addMessage() will create a child of that entry, forming a new branch.
+   * Existing entries are not modified or deleted.
+   */
+  branch(entryId) {
+    if (!this.activeSession) {
+      return false;
+    }
+    if (entryId === null) {
+      this.activeSession.activeEntryId = null;
+      this.activeSession.isDirty = true;
+      return true;
+    }
+    const entry = this.activeSession.entries.find((e) => e.id === entryId);
+    if (!entry) {
+      console.warn(`[SessionManager] Branch target not found: ${entryId}`);
+      return false;
+    }
+    this.activeSession.activeEntryId = entryId;
+    this.activeSession.isDirty = true;
+    return true;
+  }
+  /**
+   * Get all branch paths (all leaf nodes) in the session
+   * Returns array of entry IDs representing branch tips
+   */
+  getBranchTips() {
+    if (!this.activeSession) {
+      return [];
+    }
+    const hasChildren = /* @__PURE__ */ new Set();
+    for (const entry of this.activeSession.entries) {
+      if (entry.parentId) {
+        hasChildren.add(entry.parentId);
+      }
+    }
+    const leaves = this.activeSession.entries.filter((e) => !hasChildren.has(e.id)).map((e) => e.id);
+    return leaves;
+  }
+  /**
+   * Get the path from root to a specific entry
+   */
+  getPathToEntry(entryId) {
+    if (!this.activeSession) {
+      return [];
+    }
+    const path = [];
+    const byId = new Map(this.activeSession.entries.map((e) => [e.id, e]));
+    let current = entryId;
+    while (current) {
+      const entry = byId.get(current);
+      if (!entry) break;
+      path.unshift(entry);
+      current = entry.parentId;
+    }
+    return path;
+  }
+  /**
+   * Get the timestamp of the latest compaction entry on the active path.
+   */
+  getLatestCompactionTimestamp() {
+    if (!this.activeSession?.activeEntryId) {
+      return null;
+    }
+    const path = this.getPathToEntry(this.activeSession.activeEntryId);
+    for (let i = path.length - 1; i >= 0; i--) {
+      const entry = path[i];
+      if (entry.type === "compaction" && entry.compactionData) {
+        return entry.timestamp;
+      }
+    }
+    return null;
+  }
+  /**
+   * Rename the active session
+   */
+  async rename(name) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    this.activeSession.metadata.name = name;
+    this.activeSession.isDirty = true;
+    await this.save();
+  }
+  /**
+   * Close the current session
+   */
+  async close() {
+    if (this.activeSession?.isDirty) {
+      await this.save();
+    }
+    this.activeSession = null;
+  }
+  /**
+   * Delete a session (active or inactive)
+   */
+  async deleteSession(sessionId) {
+    if (this.activeSession?.id === sessionId) {
+      await this.close();
+    }
+    return await this.store.delete(sessionId);
+  }
+  /**
+   * List all available sessions
+   */
+  async listSessions() {
+    return await this.store.listMetadata();
+  }
+  /**
+   * Check if a session exists
+   */
+  async hasSession(sessionId) {
+    return await this.store.exists(sessionId);
+  }
+  /**
+   * Fork the current session at a specific entry point
+   */
+  async forkAtEntry(entryId, newName) {
+    if (!this.activeSession) {
+      throw new Error("No active session to fork");
+    }
+    const sourceEntry = this.activeSession.entries.find((e) => e.id === entryId);
+    if (!sourceEntry) {
+      throw new Error(`Entry not found: ${entryId}`);
+    }
+    const newSessionId = generateSessionId();
+    const now = Date.now();
+    const subtreeEntries = [];
+    const forkEntry = {
+      id: generateEntryId(),
+      parentId: null,
+      type: "fork",
+      timestamp: now,
+      forkData: {
+        sourceEntryId: entryId,
+        sessionId: this.activeSession.id,
+        name: this.activeSession.metadata.name
+      }
+    };
+    subtreeEntries.push(forkEntry);
+    let currentId = entryId;
+    let newParentId = forkEntry.id;
+    while (currentId) {
+      const entry = this.activeSession.entries.find((e) => e.id === currentId);
+      if (!entry) break;
+      const newEntry = {
+        ...entry,
+        id: generateEntryId(),
+        parentId: newParentId,
+        timestamp: now
+      };
+      subtreeEntries.push(newEntry);
+      newParentId = newEntry.id;
+      const children = this.activeSession.entries.filter((e) => e.parentId === currentId);
+      if (children.length === 0) break;
+      const activePathChild = children.find((c) => {
+        let checkId = this.activeSession?.activeEntryId ?? null;
+        while (checkId) {
+          if (checkId === c.id) return true;
+          const checkEntry = this.activeSession?.entries.find((e) => e.id === checkId);
+          checkId = checkEntry?.parentId ?? null;
+        }
+        return false;
+      });
+      currentId = activePathChild?.id ?? children[0]?.id ?? null;
+    }
+    await this.store.save(
+      newSessionId,
+      subtreeEntries,
+      {
+        name: newName ?? `${this.activeSession.metadata.name} (Branch)`,
+        createdAt: now,
+        updatedAt: now,
+        tags: this.activeSession.metadata.tags
+      }
+    );
+    return newSessionId;
+  }
+  /**
+   * Fork the current session (create a copy with current state)
+   */
+  async fork(newName) {
+    if (!this.activeSession) {
+      throw new Error("No active session to fork");
+    }
+    const newSessionId = generateSessionId();
+    const now = Date.now();
+    const idMap = /* @__PURE__ */ new Map();
+    const newEntries = [];
+    for (const entry of this.activeSession.entries) {
+      idMap.set(entry.id, generateEntryId());
+    }
+    for (const entry of this.activeSession.entries) {
+      const newEntry = {
+        ...entry,
+        id: idMap.get(entry.id),
+        parentId: entry.parentId ? idMap.get(entry.parentId) : null,
+        timestamp: now
+      };
+      newEntries.push(newEntry);
+    }
+    const newActiveEntryId = this.activeSession.activeEntryId ? idMap.get(this.activeSession.activeEntryId) ?? null : null;
+    await this.store.save(
+      newSessionId,
+      newEntries,
+      {
+        name: newName ?? `${this.activeSession.metadata.name} (Copy)`,
+        createdAt: now,
+        updatedAt: now,
+        activeEntryId: newActiveEntryId,
+        tags: this.activeSession.metadata.tags
+      }
+    );
+    return newSessionId;
+  }
+  /**
+   * Clean up old sessions if exceeding maxSessions
+   */
+  async cleanup() {
+    if (this.options.maxSessions <= 0) {
+      return 0;
+    }
+    const sessions = await this.store.listMetadata();
+    if (sessions.length <= this.options.maxSessions) {
+      return 0;
+    }
+    const sorted = sessions.sort((a, b) => a.updatedAt - b.updatedAt);
+    const toDelete = sorted.slice(0, sessions.length - this.options.maxSessions);
+    let deleted = 0;
+    for (const session of toDelete) {
+      if (session.id !== this.activeSession?.id) {
+        await this.store.delete(session.id);
+        deleted++;
+      }
+    }
+    if (deleted > 0) {
+    }
+    return deleted;
+  }
+  /**
+   * Dispose the manager
+   */
+  dispose() {
+    this.stopAutoSave();
+  }
+};
+function createSessionManager(options) {
+  return new SessionManager(options);
+}
+
+// ../../packages/agent-framework/src/extensions/runtime-registry.ts
+var typeBoxKind = Symbol.for("TypeBox.Kind");
+
+// ../../packages/agent-framework/src/interaction.ts
+var InteractionUnavailableError = class extends Error {
+  request;
+  constructor(message, request) {
+    super(message);
+    this.name = "InteractionUnavailableError";
+    this.request = request;
+  }
+};
+var currentInteractionHandler = null;
+function registerInteractionHandler(handler) {
+  currentInteractionHandler = handler;
+}
+function hasInteractionHandler() {
+  return currentInteractionHandler !== null;
+}
+async function requestInteraction(request) {
+  if (!currentInteractionHandler) {
+    throw new InteractionUnavailableError(
+      `No interaction handler registered for request type: ${request.type}`,
+      request
+    );
+  }
+  return await currentInteractionHandler(request);
+}
+
+// ../../packages/shared-headless-capabilities/src/ask-user.ts
+var OTHER_OPTION = "\u270F\uFE0F Other (type your own)";
+var BACK_OPTION = "\u2190 Back";
+var REVIEW_OPTION = "\u2630 Review all answers";
+var CONFIRM_OPTION = "\u2713 Confirm and continue";
+var RESTART_OPTION = "\u21BA Restart all";
+var DEFAULT_ASK_TIMEOUT_MS = 6e4;
+var AskUserParamsSchema = Type.Object({
+  question: Type.String({
+    description: "REQUIRED: The question text to ask the user"
+  }),
+  options: Type.Optional(Type.Array(
+    Type.String({ description: "An option label" })
+  )),
+  allowOther: Type.Optional(Type.Boolean({
+    description: "Whether to show 'Other' option (default: true when options provided)",
+    default: true
+  })),
+  allowBack: Type.Optional(Type.Boolean({
+    description: "Whether to allow going back (adds '\u2190 Back' option)",
+    default: false
+  })),
+  placeholder: Type.Optional(Type.String({
+    description: "Placeholder text for input field"
+  }))
+});
+var AskUserMultiParamsSchema = Type.Object({
+  prompt: Type.Optional(Type.String({
+    description: "Legacy-compatible shortcut for a single question. Equivalent to `question`."
+  })),
+  question: Type.Optional(Type.String({
+    description: "Preferred shortcut for a single question. Use this for the common case."
+  })),
+  options: Type.Optional(Type.Array(
+    Type.String({ description: "Shortcut options for the single-question form." })
+  )),
+  placeholder: Type.Optional(Type.String({
+    description: "Shortcut placeholder for the single-question form."
+  })),
+  questions: Type.Optional(Type.Array(
+    Type.Union([
+      Type.String({
+        description: "Lightweight question syntax. Use `Question text|Option A|Option B` for single choice, or just `Question text` for free text."
+      }),
+      Type.Object({
+        id: Type.Optional(Type.String({ description: "Question identifier; optional and auto-generated if omitted." })),
+        question: Type.String({ description: "Question text" }),
+        options: Type.Optional(Type.Array(Type.String())),
+        allowOther: Type.Optional(Type.Boolean()),
+        placeholder: Type.Optional(Type.String())
+      })
+    ]),
+    { description: "Questions to ask sequentially. Can be strings or lightweight objects." }
+  )),
+  allowReview: Type.Optional(Type.Boolean({
+    description: "Allow user to review and modify answers at the end",
+    default: true
+  }))
+});
+function buildUnsupportedResult(error) {
+  const message = error instanceof InteractionUnavailableError ? error.message : error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text", text: `Interaction unavailable: ${message}` }],
+    details: { unsupported: true, error: message },
+    isError: true
+  };
+}
+function validateQuestions(questions) {
+  if (!Array.isArray(questions) || questions.length === 0) {
+    return "'questions' must be a non-empty array";
+  }
+  for (let index = 0; index < questions.length; index++) {
+    const question = questions[index];
+    if (!question || typeof question !== "object") {
+      return `questions[${index}] must be an object`;
+    }
+    const candidate = question;
+    if (typeof candidate.id !== "string" || candidate.id.trim().length === 0) {
+      return `questions[${index}].id must be a non-empty string`;
+    }
+    if (typeof candidate.question !== "string" || candidate.question.trim().length === 0) {
+      return `questions[${index}].question must be a non-empty string`;
+    }
+    if (candidate.options !== void 0) {
+      if (!Array.isArray(candidate.options) || candidate.options.length === 0) {
+        return `questions[${index}].options must be a non-empty array when provided`;
+      }
+      for (let optionIndex = 0; optionIndex < candidate.options.length; optionIndex++) {
+        const option = candidate.options[optionIndex];
+        if (typeof option !== "string" || option.trim().length === 0) {
+          return `questions[${index}].options[${optionIndex}] must be a non-empty string`;
+        }
+      }
+    }
+  }
+  return null;
+}
+function normalizeStringQuestion(value, index) {
+  const parts = value.split("|").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length === 0) return null;
+  const [question, ...options] = parts;
+  return {
+    id: `q${index + 1}`,
+    question,
+    options: options.length > 0 ? options : void 0
+  };
+}
+function normalizeQuestionObject(value, index) {
+  const options = Array.isArray(value.options) ? value.options.filter((option) => typeof option === "string").map((option) => option.trim()).filter((option) => option.length > 0) : void 0;
+  return {
+    id: typeof value.id === "string" && value.id.trim().length > 0 ? value.id.trim() : `q${index + 1}`,
+    question: typeof value.question === "string" ? value.question.trim() : "",
+    options: options && options.length > 0 ? options : void 0,
+    allowOther: typeof value.allowOther === "boolean" ? value.allowOther : void 0,
+    placeholder: typeof value.placeholder === "string" ? value.placeholder : void 0
+  };
+}
+function normalizeAskUserArgs(args) {
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      const preview = args.length > 200 ? `${args.slice(0, 200)}...` : args;
+      return { error: `Tool arguments must be an object or valid JSON object string (received string: ${preview})` };
+    }
+  }
+  const allowReview = args?.allowReview ?? true;
+  const singleQuestionText = typeof args?.question === "string" && args.question.trim().length > 0 ? args.question.trim() : typeof args?.prompt === "string" && args.prompt.trim().length > 0 ? args.prompt.trim() : void 0;
+  const normalizedSingleQuestion = singleQuestionText ? {
+    id: "q1",
+    question: singleQuestionText,
+    options: Array.isArray(args.options) ? args.options.filter((option) => typeof option === "string").map((option) => option.trim()).filter((option) => option.length > 0) : void 0,
+    placeholder: typeof args?.placeholder === "string" ? args.placeholder : void 0
+  } : void 0;
+  if (normalizedSingleQuestion && Array.isArray(args?.questions) && args.questions.length === 0) {
+    return { questions: [normalizedSingleQuestion], allowReview };
+  }
+  if (!Array.isArray(args?.questions)) {
+    if (normalizedSingleQuestion) {
+      return { questions: [normalizedSingleQuestion], allowReview };
+    }
+    return { error: "Provide `question` or `prompt` for a single question, or provide a non-empty `questions` array" };
+  }
+  const normalizedQuestions = args.questions.map((question, index) => {
+    if (typeof question === "string") {
+      return normalizeStringQuestion(question, index);
+    }
+    if (question && typeof question === "object") {
+      return normalizeQuestionObject(question, index);
+    }
+    return null;
+  }).filter((question) => {
+    if (question === null) return false;
+    return typeof question.question === "string" && question.question.trim().length > 0;
+  });
+  if (normalizedQuestions.length > 0) {
+    return { questions: normalizedQuestions, allowReview };
+  }
+  if (normalizedSingleQuestion) {
+    return { questions: [normalizedSingleQuestion], allowReview };
+  }
+  return { error: "Provide `question` or `prompt` for a single question, or provide a non-empty `questions` array" };
+}
+function buildSkippedResult(question, timedOut = false) {
+  return {
+    content: [{ type: "text", text: "(skipped)" }],
+    details: {
+      answer: "(skipped)",
+      skipped: true,
+      timedOut,
+      question,
+      cancelled: false
+    }
+  };
+}
+async function askSingleQuestion(args) {
+  const { question, options, allowOther = true, allowBack = false, allowReview = false, placeholder } = args;
+  if (!question || typeof question !== "string") {
+    return {
+      content: [{ type: "text", text: "Error: 'question' parameter is required" }],
+      isError: true
+    };
+  }
+  if (!options || options.length === 0) {
+    const response = await requestInteraction({
+      type: "multiline_input",
+      id: `ask-user:${Date.now()}`,
+      prompt: question,
+      timeoutMs: DEFAULT_ASK_TIMEOUT_MS
+    });
+    if (response.type === "multiline_input" && (response.skipped || response.timedOut)) {
+      return buildSkippedResult(question, response.timedOut === true);
+    }
+    const answer = response.type === "multiline_input" ? response.value : void 0;
+    if (answer === void 0) {
+      return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
+    }
+    return {
+      content: [{ type: "text", text: answer }],
+      details: { answer, cancelled: false }
+    };
+  }
+  const displayOptions = [...options];
+  if (allowOther !== false) displayOptions.push(OTHER_OPTION);
+  if (allowBack) displayOptions.push(BACK_OPTION);
+  if (allowReview) displayOptions.push(REVIEW_OPTION);
+  const selection = await requestInteraction({
+    type: "select_one",
+    id: `ask-user:select:${Date.now()}`,
+    prompt: question,
+    options: displayOptions,
+    timeoutMs: DEFAULT_ASK_TIMEOUT_MS
+  });
+  if (selection.type === "select_one" && (selection.skipped || selection.timedOut)) {
+    return buildSkippedResult(question, selection.timedOut === true);
+  }
+  if (selection.type !== "select_one" || selection.selection === void 0) {
+    return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
+  }
+  if (selection.selection === BACK_OPTION) {
+    return { content: [{ type: "text", text: "BACK" }], details: { goBack: true, cancelled: false } };
+  }
+  if (selection.selection === REVIEW_OPTION) {
+    return { content: [{ type: "text", text: "REVIEW" }], details: { goReview: true, cancelled: false } };
+  }
+  if (selection.selection === OTHER_OPTION) {
+    const response = await requestInteraction({
+      type: "text_input",
+      id: `ask-user:${Date.now()}`,
+      prompt: `${question} (Other)`,
+      placeholder,
+      timeoutMs: DEFAULT_ASK_TIMEOUT_MS
+    });
+    if (response.type === "text_input" && (response.skipped || response.timedOut)) {
+      return buildSkippedResult(question, response.timedOut === true);
+    }
+    const customAnswer = response.type === "text_input" ? response.value : void 0;
+    if (customAnswer === void 0) {
+      return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
+    }
+    return {
+      content: [{ type: "text", text: `Other: ${customAnswer}` }],
+      details: { answer: customAnswer, isOther: true, cancelled: false }
+    };
+  }
+  const selectedIndex = displayOptions.indexOf(selection.selection);
+  return {
+    content: [{ type: "text", text: `${String.fromCharCode(65 + selectedIndex)}. ${selection.selection}` }],
+    details: {
+      answer: selection.selection,
+      selectedIndex,
+      isOther: false,
+      cancelled: false
+    }
+  };
+}
+function createAskUserCapability() {
+  const tools = [
+    {
+      name: "ask_user_multi",
+      label: "Ask User",
+      description: `Ask one or more questions with review and back navigation. Use this for all user questioning flows, including demonstrations that should actually ask the user instead of only describing the questionnaire. When you decide to use this tool, invoke it immediately. Do not print explanatory preambles, numbered plans, or example JSON in chat before calling it. For a generic demo such as '\u6F14\u793A\u4E00\u4E0B ask \u5DE5\u5177', '\u6F14\u793A\u4E00\u4E0B\u63D0\u95EE\u5DE5\u5177', or 'ask me', ask exactly one simple single-choice question with 3-5 explicit options so the user sees a selector instead of a free-text editor. Do not switch to an open-ended or multi-question flow unless the user explicitly asks for it. Prefer the shortest valid shape. For a single question, use {"question":"Choose a color","options":["Red","Blue","Green"]}. You may also use {"prompt":"Choose a color","options":[...]} for compatibility. For multiple questions, use \`questions\`. Question ids are optional and will be auto-generated.`,
+      parameters: AskUserMultiParamsSchema,
+      async execute(toolCallIdOrArgs, maybeArgs) {
+        try {
+          const args = typeof toolCallIdOrArgs === "string" && maybeArgs !== void 0 ? maybeArgs : toolCallIdOrArgs;
+          const normalized = normalizeAskUserArgs(args);
+          if ("error" in normalized) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${normalized.error}. Use one of these shapes: {"question":"Choose a color","options":["Red","Blue","Green"]} or {"prompt":"Choose a color","options":["Red","Blue","Green"]} or {"questions":[{"question":"Choose a color","options":["Red","Blue","Green"]},{"question":"Describe why"}],"allowReview":true}`
+                }
+              ],
+              isError: true
+            };
+          }
+          const { questions, allowReview } = normalized;
+          const validationError = validateQuestions(questions);
+          if (validationError) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${validationError}. Use one of these shapes: {"question":"Choose a color","options":["Red","Blue","Green"]} or {"prompt":"Choose a color","options":["Red","Blue","Green"]} or {"questions":["Choose a color|Red|Blue|Green","Describe why"],"allowReview":true}`
+                }
+              ],
+              isError: true
+            };
+          }
+          const answers = {};
+          let currentIndex = 0;
+          while (currentIndex < questions.length) {
+            const q = questions[currentIndex];
+            const result = await askSingleQuestion({
+              question: `${currentIndex + 1}/${questions.length}: ${q.question}`,
+              options: q.options,
+              allowOther: q.allowOther,
+              allowBack: currentIndex > 0,
+              allowReview: allowReview && Object.keys(answers).length > 0,
+              placeholder: q.placeholder
+            });
+            if (result.details?.cancelled) {
+              return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
+            }
+            if (result.details?.goBack) {
+              currentIndex = Math.max(0, currentIndex - 1);
+              delete answers[questions[currentIndex].id];
+              continue;
+            }
+            if (result.details?.goReview) {
+              break;
+            }
+            answers[q.id] = {
+              question: q.question,
+              answer: result.details?.answer || result.content[0].text,
+              ...result.details
+            };
+            currentIndex++;
+          }
+          if (allowReview && Object.keys(answers).length > 0) {
+            while (true) {
+              const reviewOptions = [
+                CONFIRM_OPTION,
+                ...questions.map((q2, i) => {
+                  const answer = answers[q2.id]?.answer || "(not answered)";
+                  const displayAnswer = answer.length > 20 ? `${answer.substring(0, 20)}...` : answer;
+                  return `\u270F\uFE0F Q${i + 1}: ${displayAnswer}`;
+                }),
+                RESTART_OPTION
+              ];
+              const review = await requestInteraction({
+                type: "select_one",
+                id: `ask-user:review:${Date.now()}`,
+                prompt: "\u2630 Review your answers (select to edit):",
+                options: reviewOptions,
+                timeoutMs: DEFAULT_ASK_TIMEOUT_MS
+              });
+              if (review.type === "select_one" && (review.skipped || review.timedOut)) {
+                break;
+              }
+              if (review.type !== "select_one" || review.selection === void 0) {
+                return { content: [{ type: "text", text: "User cancelled during review" }], details: { cancelled: true } };
+              }
+              const reviewIndex = reviewOptions.indexOf(review.selection);
+              if (review.selection === CONFIRM_OPTION) {
+                break;
+              }
+              if (review.selection === RESTART_OPTION) {
+                Object.keys(answers).forEach((key) => delete answers[key]);
+                currentIndex = 0;
+                break;
+              }
+              const questionIndex = reviewIndex - 1;
+              if (questionIndex < 0 || questionIndex >= questions.length) {
+                continue;
+              }
+              const q = questions[questionIndex];
+              const result = await askSingleQuestion({
+                question: `\u270F\uFE0F Edit Q${questionIndex + 1}/${questions.length}: ${q.question}`,
+                options: q.options,
+                allowOther: q.allowOther,
+                allowBack: questionIndex > 0,
+                allowReview: true,
+                placeholder: q.placeholder
+              });
+              if (result.details?.cancelled) {
+                return { content: [{ type: "text", text: "User cancelled" }], details: { cancelled: true } };
+              }
+              if (result.details?.goBack && questionIndex > 0) {
+                delete answers[q.id];
+                currentIndex = questionIndex - 1;
+                break;
+              }
+              if (result.details?.goReview) {
+                continue;
+              }
+              answers[q.id] = {
+                question: q.question,
+                answer: result.details?.answer || result.content[0].text,
+                ...result.details
+              };
+            }
+          }
+          const summary = Object.entries(answers).map(([id, data]) => `${id}: ${data.answer}`).join("\n");
+          return {
+            content: [{ type: "text", text: summary }],
+            details: { answers, cancelled: false }
+          };
+        } catch (error) {
+          return buildUnsupportedResult(error);
+        }
+      }
+    }
+  ];
+  return {
+    ...defineSharedCapability({
+      id: "ask-user",
+      description: "Ask the user one or more questions through the shared interaction protocol.",
+      tools,
+      requiredInteractions: ["select_one", "confirm", "text_input", "multiline_input"],
+      systemPromptAdditions: [
+        "When the user asks you to ask questions, collect choices, or gather structured input, call `ask_user_multi` instead of describing the questions in plain text.",
+        "When demonstrating `ask_user_multi`, call it immediately instead of first printing explanations, plans, or example JSON.",
+        "When the user asks for a generic ask-tool demo, such as '\u6F14\u793A\u4E00\u4E0B ask \u5DE5\u5177', '\u6F14\u793A\u4E00\u4E0B\u63D0\u95EE\u5DE5\u5177', or 'ask me', ask exactly one simple single-choice question with explicit options so the interaction opens as a selector.",
+        "For a single question, prefer the shortest valid argument shape such as `question` plus optional `options`."
+      ]
+    }),
+    tools
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/path-utils.ts
+function isInAllowlist(path, allowlistedDirs) {
+  const normalized = normalizeForComparison(path);
+  for (const dir of allowlistedDirs) {
+    const normalizedDir = normalizeForComparison(dir);
+    const dirWithSlash = withTrailingSep(normalizedDir);
+    if (normalized === normalizedDir || normalized.startsWith(dirWithSlash)) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeForComparison(path) {
+  const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (normalized === "/") return normalized;
+  return normalized.replace(/\/+$/, "");
+}
+function withTrailingSep(path) {
+  return path.endsWith("/") ? path : `${path}/`;
+}
+function isWithinRoot(path, root) {
+  const normalizedPath = normalizeForComparison(path);
+  const normalizedRoot = normalizeForComparison(root);
+  return normalizedPath === normalizedRoot || normalizedPath.startsWith(withTrailingSep(normalizedRoot));
+}
+function normalizePrefix(prefix) {
+  const normalized = normalizeForComparison(prefix);
+  return normalized.startsWith("/") ? normalized.slice(1) : normalized;
+}
+function getAvailableRoots(options) {
+  if (!options?.roots || options.roots.length === 0) {
+    return [];
+  }
+  const fs = getFileSystem();
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const root of options.roots) {
+    if (!root || typeof root.name !== "string" || typeof root.path !== "string") {
+      continue;
+    }
+    const name = root.name.trim();
+    const path = root.path.trim();
+    if (!name || !path || seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    results.push({
+      name,
+      path: fs.normalize(path),
+      description: root.description?.trim() || void 0,
+      defaultPrefixes: Array.isArray(root.defaultPrefixes) ? root.defaultPrefixes.map((prefix) => String(prefix || "").trim()).filter((prefix) => prefix.length > 0) : void 0
+    });
+  }
+  return results;
+}
+function getDefaultRootName(sandboxRoot, options) {
+  const roots = getAvailableRoots(options);
+  if (roots.length === 0) {
+    return void 0;
+  }
+  const configured = (options?.defaultRoot || "").trim();
+  if (configured && roots.some((root) => root.name === configured)) {
+    return configured;
+  }
+  const normalizedSandboxRoot = normalizeForComparison(sandboxRoot);
+  const sandboxMatch = roots.find(
+    (root) => normalizeForComparison(root.path) === normalizedSandboxRoot
+  );
+  if (sandboxMatch) {
+    return sandboxMatch.name;
+  }
+  return roots[0]?.name;
+}
+function getRootByName(name, sandboxRoot, options) {
+  const roots = getAvailableRoots(options);
+  if (roots.length === 0) {
+    return void 0;
+  }
+  const resolvedName = (name || "").trim() || getDefaultRootName(sandboxRoot, options);
+  if (!resolvedName) {
+    return void 0;
+  }
+  return roots.find((root) => root.name === resolvedName);
+}
+function findPrefixMatchedRoot(filePath, options) {
+  const normalizedPath = normalizeForComparison(filePath);
+  for (const root of getAvailableRoots(options)) {
+    for (const prefix of root.defaultPrefixes ?? []) {
+      const normalizedPrefix = normalizePrefix(prefix);
+      if (normalizedPath === normalizedPrefix || normalizedPath.startsWith(withTrailingSep(normalizedPrefix))) {
+        return root;
+      }
+    }
+  }
+  return void 0;
+}
+function getResolutionRoot(filePath, sandboxRoot, options, rootName) {
+  if (rootName) {
+    return getRootByName(rootName, sandboxRoot, options);
+  }
+  return findPrefixMatchedRoot(filePath, options) ?? getRootByName(void 0, sandboxRoot, options);
+}
+function resolveInSandbox(filePath, sandboxRoot, options, rootName) {
+  const fs = getFileSystem();
+  const allowlistedDirs = options?.allowlistedDirs ?? [];
+  if (!filePath) {
+    throw new Error("Path cannot be empty");
+  }
+  const cleaned = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+  if (fs.isAbsolute(cleaned)) {
+    const normalized = fs.normalize(cleaned);
+    const selectedRoot2 = rootName ? getRootByName(rootName, sandboxRoot, options) : void 0;
+    if (rootName && !selectedRoot2) {
+      const available = getAvailableRoots(options).map((root) => root.name).join(", ");
+      throw new Error(
+        available ? `Unknown root '${rootName}'. Available roots: ${available}` : `Unknown root '${rootName}'. No named roots are configured.`
+      );
+    }
+    if (selectedRoot2) {
+      if (!isWithinRoot(normalized, selectedRoot2.path)) {
+        throw new Error(`Absolute path outside root '${selectedRoot2.name}': ${filePath}`);
+      }
+      return normalized;
+    }
+    for (const root of getAvailableRoots(options)) {
+      if (isWithinRoot(normalized, root.path)) {
+        return normalized;
+      }
+    }
+    if (isInAllowlist(normalized, allowlistedDirs)) {
+      return normalized;
+    }
+    if (!isWithinRoot(normalized, sandboxRoot)) {
+      throw new Error(`Absolute path outside sandbox: ${filePath}`);
+    }
+    return normalized;
+  }
+  const selectedRoot = getResolutionRoot(cleaned, sandboxRoot, options, rootName);
+  if (rootName && !selectedRoot) {
+    const available = getAvailableRoots(options).map((root) => root.name).join(", ");
+    throw new Error(
+      available ? `Unknown root '${rootName}'. Available roots: ${available}` : `Unknown root '${rootName}'. No named roots are configured.`
+    );
+  }
+  const resolvedBase = selectedRoot?.path ?? sandboxRoot;
+  const resolved = fs.resolve(resolvedBase, cleaned);
+  if (selectedRoot) {
+    if (!isWithinRoot(resolved, selectedRoot.path)) {
+      throw new Error(`Path escapes root '${selectedRoot.name}': ${filePath}`);
+    }
+    return resolved;
+  }
+  if (!isWithinRoot(resolved, sandboxRoot) && !isInAllowlist(resolved, allowlistedDirs)) {
+    throw new Error(`Path escapes sandbox: ${filePath}`);
+  }
+  return resolved;
+}
+var resolveToCwd = resolveInSandbox;
+var resolveReadPath = resolveInSandbox;
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/schema-utils.ts
+function formatPrefixes(prefixes) {
+  if (!prefixes || prefixes.length === 0) {
+    return "";
+  }
+  return prefixes.map((prefix) => {
+    const trimmed = prefix.trim();
+    return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+  }).join(", ");
+}
+function buildRootParameterSchema(sandboxRoot, options) {
+  const roots = getAvailableRoots(options);
+  if (roots.length === 0) {
+    return void 0;
+  }
+  const defaultRoot = getDefaultRootName(sandboxRoot, options);
+  const description = [
+    `Optional root name to resolve the path against. Available roots: ${roots.map((root) => root.name).join(", ")}.`,
+    defaultRoot ? `When omitted, the default root is '${defaultRoot}' unless a prefix rule matches first.` : ""
+  ].filter(Boolean).join(" ");
+  if (roots.length === 1) {
+    return Type.Optional(Type.Literal(roots[0].name, { description }));
+  }
+  return Type.Optional(
+    Type.Union(
+      roots.map((root) => Type.Literal(root.name)),
+      { description }
+    )
+  );
+}
+function buildPathResolutionDescription(sandboxRoot, options) {
+  const roots = getAvailableRoots(options);
+  if (roots.length === 0) {
+    return "Relative paths resolve against the workspace root.";
+  }
+  const rootSummaries = roots.map((root) => {
+    const pieces = [`'${root.name}'`];
+    if (root.description) {
+      pieces.push(root.description);
+    }
+    const prefixes = formatPrefixes(root.defaultPrefixes);
+    if (prefixes) {
+      pieces.push(`prefixes: ${prefixes}`);
+    }
+    return pieces.join(" - ");
+  });
+  const defaultRoot = getDefaultRootName(sandboxRoot, options);
+  const hasPrefixRules = roots.some((root) => (root.defaultPrefixes?.length ?? 0) > 0);
+  const defaultSentence = defaultRoot ? hasPrefixRules ? `When root is omitted, prefix-matched roots win first; otherwise '${defaultRoot}' is used.` : `When root is omitted, '${defaultRoot}' is used.` : "";
+  return `Available roots: ${rootSummaries.join("; ")}. ${defaultSentence}`.trim();
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/truncate.ts
+var DEFAULT_MAX_LINES = 2e3;
+var DEFAULT_MAX_BYTES = 50 * 1024;
+var GREP_MAX_LINE_LENGTH = 500;
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes}B`;
+  } else if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  } else {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+}
+function truncateHead(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+  if (firstLineBytes > maxBytes) {
+    return {
+      content: "",
+      truncated: true,
+      truncatedBy: "bytes",
+      totalLines,
+      totalBytes,
+      outputLines: 0,
+      outputBytes: 0,
+      lastLinePartial: false,
+      firstLineExceedsLimit: true,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  for (let i = 0; i < lines.length && i < maxLines; i++) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      break;
+    }
+    outputLinesArr.push(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join("\n");
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial: false,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateTail(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  let lastLinePartial = false;
+  for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      if (outputLinesArr.length === 0) {
+        const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+        outputLinesArr.unshift(truncatedLine);
+        outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+        lastLinePartial = true;
+      }
+      break;
+    }
+    outputLinesArr.unshift(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join("\n");
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateStringToBytesFromEnd(str, maxBytes) {
+  const buf = Buffer.from(str, "utf-8");
+  if (buf.length <= maxBytes) {
+    return str;
+  }
+  let start = buf.length - maxBytes;
+  while (start < buf.length && (buf[start] & 192) === 128) {
+    start++;
+  }
+  return buf.slice(start).toString("utf-8");
+}
+function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+  if (line.length <= maxChars) {
+    return { text: line, wasTruncated: false };
+  }
+  return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/read.ts
+function createReadTool(cwd, options) {
+  const fs = getFileSystem();
+  const rootSchema = buildRootParameterSchema(cwd, options);
+  const readSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to read. Example: 'Scripts/PlayerController.cs' or 'Assets/Gen/config.json'." }),
+    ...rootSchema ? { root: rootSchema } : {},
+    offset: Type.Optional(Type.Number({ description: "Line number to start reading from, 1-indexed. Example: 201." })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read. Example: 120." }))
+  });
+  const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
+  return {
+    name: "read",
+    label: "read",
+    description: `Read a file's contents. Use this before editing, and use offset/limit for large files. Example: read_file path='Scripts/PlayerController.cs' or read_file path='Data/config.json'. ${pathResolutionDescription} For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). When you need the full file, continue with a larger offset until complete.`,
+    parameters: readSchema,
+    execute: async (_toolCallId, params, signal) => {
+      const { path, root, offset, limit } = params;
+      const absolutePath = resolveReadPath(path, cwd, options, root);
+      return new Promise(
+        (resolve, reject) => {
+          if (signal?.aborted) {
+            reject(new Error("Operation aborted"));
+            return;
+          }
+          let aborted = false;
+          const onAbort = () => {
+            aborted = true;
+            reject(new Error("Operation aborted"));
+          };
+          if (signal) {
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+          (async () => {
+            try {
+              await fs.access(absolutePath);
+              if (aborted) return;
+              const content = String(await fs.readFile(absolutePath, "utf-8"));
+              const allLines = content.split("\n");
+              const totalFileLines = allLines.length;
+              const startLine = offset ? Math.max(0, offset - 1) : 0;
+              const startLineDisplay = startLine + 1;
+              if (startLine >= allLines.length) {
+                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+              }
+              let selectedContent;
+              let userLimitedLines;
+              if (limit !== void 0) {
+                const endLine = Math.min(startLine + limit, allLines.length);
+                selectedContent = allLines.slice(startLine, endLine).join("\n");
+                userLimitedLines = endLine - startLine;
+              } else {
+                selectedContent = allLines.slice(startLine).join("\n");
+              }
+              const truncation = truncateHead(selectedContent);
+              let outputText;
+              let details;
+              if (truncation.firstLineExceedsLimit) {
+                const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
+                outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit.]`;
+                details = { truncation };
+              } else if (truncation.truncated) {
+                const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+                const nextOffset = endLineDisplay + 1;
+                outputText = truncation.content;
+                if (truncation.truncatedBy === "lines") {
+                  outputText += `
+
+[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
+                } else {
+                  outputText += `
+
+[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
+                }
+                details = { truncation };
+              } else if (userLimitedLines !== void 0 && startLine + userLimitedLines < allLines.length) {
+                const remaining = allLines.length - (startLine + userLimitedLines);
+                const nextOffset = startLine + userLimitedLines + 1;
+                outputText = truncation.content;
+                outputText += `
+
+[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+              } else {
+                outputText = truncation.content;
+              }
+              const textContent = [{ type: "text", text: outputText }];
+              if (aborted) return;
+              if (signal) {
+                signal.removeEventListener("abort", onAbort);
+              }
+              resolve({ content: textContent, details });
+            } catch (error) {
+              if (signal) {
+                signal.removeEventListener("abort", onAbort);
+              }
+              if (!aborted) {
+                reject(error);
+              }
+            }
+          })();
+        }
+      );
+    }
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/write.ts
+function createWriteTool(cwd, options) {
+  const fs = getFileSystem();
+  const rootSchema = buildRootParameterSchema(cwd, options);
+  const writeSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to write." }),
+    ...rootSchema ? { root: rootSchema } : {},
+    content: Type.String({ description: "Content to write to the file" })
+  });
+  const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
+  return {
+    name: "write",
+    label: "write",
+    description: `Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories. ${pathResolutionDescription}`,
+    parameters: writeSchema,
+    execute: async (_toolCallId, params, signal) => {
+      const { path: filePath, root, content } = params;
+      const absolutePath = resolveToCwd(filePath, cwd, options, root);
+      const dir = fs.dirname(absolutePath);
+      return new Promise(
+        (resolve, reject) => {
+          if (signal?.aborted) {
+            reject(new Error("Operation aborted"));
+            return;
+          }
+          let aborted = false;
+          const onAbort = () => {
+            aborted = true;
+            reject(new Error("Operation aborted"));
+          };
+          if (signal) {
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+          (async () => {
+            try {
+              await fs.mkdir(dir, { recursive: true });
+              if (aborted) return;
+              await fs.writeFile(absolutePath, content, "utf-8");
+              if (aborted) return;
+              if (signal) {
+                signal.removeEventListener("abort", onAbort);
+              }
+              resolve({
+                content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${filePath}` }],
+                details: void 0
+              });
+            } catch (error) {
+              if (signal) {
+                signal.removeEventListener("abort", onAbort);
+              }
+              if (!aborted) {
+                reject(error);
+              }
+            }
+          })();
+        }
+      );
+    }
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/edit-diff.ts
+function detectLineEnding(content) {
+  const crlfIdx = content.indexOf("\r\n");
+  const lfIdx = content.indexOf("\n");
+  if (lfIdx === -1) return "\n";
+  if (crlfIdx === -1) return "\n";
+  return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+function normalizeToLF(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function restoreLineEndings(text, ending) {
+  return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+function normalizeForFuzzyMatch(text) {
+  return text.split("\n").map((line) => line.trimEnd()).join("\n").replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+function fuzzyFindText(content, oldText) {
+  const exactIndex = content.indexOf(oldText);
+  if (exactIndex !== -1) {
+    return {
+      found: true,
+      index: exactIndex,
+      matchLength: oldText.length,
+      usedFuzzyMatch: false,
+      contentForReplacement: content
+    };
+  }
+  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+  if (fuzzyIndex === -1) {
+    return {
+      found: false,
+      index: -1,
+      matchLength: 0,
+      usedFuzzyMatch: false,
+      contentForReplacement: content
+    };
+  }
+  return {
+    found: true,
+    index: fuzzyIndex,
+    matchLength: fuzzyOldText.length,
+    usedFuzzyMatch: true,
+    contentForReplacement: fuzzyContent
+  };
+}
+function stripBom(content) {
+  return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function generateDiffString(oldContent, newContent, _contextLines = 4) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  let firstChangedLine;
+  for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
+    if (oldLines[i] !== newLines[i]) {
+      firstChangedLine = i + 1;
+      break;
+    }
+  }
+  const diff = `--- old
++++ new
+@@ -1,${oldLines.length} +1,${newLines.length} @@
+[Diff: ${oldLines.length} lines -> ${newLines.length} lines]`;
+  return { diff, firstChangedLine };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/edit.ts
+function createEditTool(cwd, options) {
+  const fs = getFileSystem();
+  const rootSchema = buildRootParameterSchema(cwd, options);
+  const editSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to edit." }),
+    ...rootSchema ? { root: rootSchema } : {},
+    oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
+    newText: Type.String({ description: "New text to replace the old text with" })
+  });
+  const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
+  return {
+    name: "edit",
+    label: "edit",
+    description: `Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits. ${pathResolutionDescription}`,
+    parameters: editSchema,
+    execute: async (_toolCallId, params, signal) => {
+      const { path, root, oldText, newText } = params;
+      const absolutePath = resolveToCwd(path, cwd, options, root);
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let aborted = false;
+        const onAbort = () => {
+          aborted = true;
+          reject(new Error("Operation aborted"));
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        (async () => {
+          try {
+            try {
+              await fs.access(absolutePath);
+            } catch {
+              if (signal) signal.removeEventListener("abort", onAbort);
+              reject(new Error(`File not found: ${path}`));
+              return;
+            }
+            if (aborted) return;
+            const rawContent = await fs.readFile(absolutePath, "utf-8");
+            if (aborted) return;
+            const { bom, text: content } = stripBom(rawContent);
+            const originalEnding = detectLineEnding(content);
+            const normalizedContent = normalizeToLF(content);
+            const normalizedOldText = normalizeToLF(oldText);
+            const normalizedNewText = normalizeToLF(newText);
+            const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+            if (!matchResult.found) {
+              if (signal) signal.removeEventListener("abort", onAbort);
+              reject(
+                new Error(
+                  `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`
+                )
+              );
+              return;
+            }
+            const fuzzyContent = normalizedContent.replace(/\s+/g, " ");
+            const fuzzyOldText = normalizedOldText.replace(/\s+/g, " ");
+            const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+            if (occurrences > 1) {
+              if (signal) signal.removeEventListener("abort", onAbort);
+              reject(
+                new Error(
+                  `Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`
+                )
+              );
+              return;
+            }
+            if (aborted) return;
+            const baseContent = matchResult.contentForReplacement;
+            const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
+            if (baseContent === newContent) {
+              if (signal) signal.removeEventListener("abort", onAbort);
+              reject(
+                new Error(
+                  `No changes made to ${path}. The replacement produced identical content.`
+                )
+              );
+              return;
+            }
+            const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+            await fs.writeFile(absolutePath, finalContent, "utf-8");
+            if (aborted) return;
+            if (signal) {
+              signal.removeEventListener("abort", onAbort);
+            }
+            const diffResult = generateDiffString(content, finalContent);
+            resolve({
+              content: [
+                {
+                  type: "text",
+                  text: `Successfully replaced text in ${path}.`
+                },
+                { type: "text", text: diffResult.diff }
+              ],
+              details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
+            });
+          } catch (error) {
+            if (signal) {
+              signal.removeEventListener("abort", onAbort);
+            }
+            if (!aborted) {
+              reject(error);
+            }
+          }
+        })();
+      });
+    }
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/ls.ts
+var DEFAULT_LIMIT = 500;
+function createLsTool(cwd, options) {
+  const fs = getFileSystem();
+  const rootSchema = buildRootParameterSchema(cwd, options);
+  const lsSchema = Type.Object({
+    path: Type.Optional(Type.String({ description: "Directory to list (default: workspace root). Example: 'Scripts' or 'Data'." })),
+    ...rootSchema ? { root: rootSchema } : {},
+    limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)." }))
+  });
+  const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
+  return {
+    name: "ls",
+    label: "ls",
+    description: `List directory contents. Use this to inspect folders before reading or writing files. Example: list_directory path='Scripts' or list_directory path='Data'. ${pathResolutionDescription} Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
+    parameters: lsSchema,
+    execute: async (_toolCallId, params, signal) => {
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        const onAbort = () => reject(new Error("Operation aborted"));
+        signal?.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            const { path: dirPath, root, limit } = params;
+            const targetPath = resolveToCwd(dirPath || ".", cwd, options, root);
+            const effectiveLimit = limit ?? DEFAULT_LIMIT;
+            if (!await fs.exists(targetPath)) {
+              reject(new Error(`Path not found: ${targetPath}`));
+              return;
+            }
+            let entries;
+            try {
+              entries = await fs.readdir(targetPath);
+            } catch (e) {
+              const message = String(e?.message || e || "Unknown error");
+              if (/scandir/i.test(message) || /not a directory/i.test(message)) {
+                reject(new Error(`Not a directory: ${targetPath}`));
+                return;
+              }
+              reject(new Error(`Cannot read directory: ${message}`));
+              return;
+            }
+            entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            const results = [];
+            let entryLimitReached = false;
+            for (const entry of entries) {
+              if (results.length >= effectiveLimit) {
+                entryLimitReached = true;
+                break;
+              }
+              const fullPath = fs.join(targetPath, entry);
+              let suffix = "";
+              try {
+                const entryStat = await fs.stat(fullPath);
+                if (entryStat.isDirectory) {
+                  suffix = "/";
+                }
+              } catch {
+                continue;
+              }
+              results.push(entry + suffix);
+            }
+            signal?.removeEventListener("abort", onAbort);
+            if (results.length === 0) {
+              resolve({ content: [{ type: "text", text: "(empty directory)" }], details: void 0 });
+              return;
+            }
+            const rawOutput = results.join("\n");
+            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+            let output = truncation.content;
+            const details = {};
+            const notices = [];
+            if (entryLimitReached) {
+              notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+              details.entryLimitReached = effectiveLimit;
+            }
+            if (truncation.truncated) {
+              notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+              details.truncation = truncation;
+            }
+            if (notices.length > 0) {
+              output += `
+
+[${notices.join(". ")}]`;
+            }
+            resolve({
+              content: [{ type: "text", text: output }],
+              details: Object.keys(details).length > 0 ? details : void 0
+            });
+          } catch (e) {
+            signal?.removeEventListener("abort", onAbort);
+            reject(e);
+          }
+        })();
+      });
+    }
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/grep.ts
+var DEFAULT_LIMIT2 = 100;
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", ".svn", ".hg"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot"
+]);
+function getNativeFileBridge() {
+  try {
+    return typeof CS !== "undefined" && CS?.Pie?.PieFileBridge ? CS.Pie.PieFileBridge : null;
+  } catch {
+    return null;
+  }
+}
+function getFileCompletionStore() {
+  const g = globalThis;
+  if (!g.__pieFileCompletionStore) {
+    g.__pieFileCompletionStore = {
+      completions: /* @__PURE__ */ new Map(),
+      waiters: /* @__PURE__ */ new Map()
+    };
+  }
+  if (!g._pieFileComplete) {
+    g._pieFileComplete = (requestId, resultJson, error) => {
+      const store = getFileCompletionStore();
+      const payload = { resultJson, error };
+      store.completions.set(requestId, payload);
+      const waiter = store.waiters.get(requestId);
+      if (waiter) {
+        store.waiters.delete(requestId);
+        waiter(payload);
+      }
+    };
+  }
+  return g.__pieFileCompletionStore;
+}
+function waitForFileCompletion(requestId) {
+  const store = getFileCompletionStore();
+  const existing = store.completions.get(requestId);
+  if (existing) {
+    return Promise.resolve(existing);
+  }
+  return new Promise((resolve) => {
+    store.waiters.set(requestId, resolve);
+  });
+}
+async function runNativeGrep(searchPath, pattern, globPattern, ignoreCase, literal, contextLines, limit, signal) {
+  const bridge = getNativeFileBridge();
+  if (!bridge) {
+    throw new Error("CS.Pie.PieFileBridge not available");
+  }
+  const requestId = bridge.StartGrep(
+    searchPath,
+    pattern,
+    globPattern ?? "",
+    !!ignoreCase,
+    !!literal,
+    contextLines,
+    limit
+  );
+  const onAbort = () => bridge.CancelRequest(requestId);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    if (signal?.aborted) {
+      bridge.CancelRequest(requestId);
+      throw new Error("Operation aborted");
+    }
+    const completion = await waitForFileCompletion(requestId);
+    if (completion.error) {
+      throw new Error(completion.error);
+    }
+    if (!completion.resultJson) {
+      return {};
+    }
+    return JSON.parse(completion.resultJson);
+  } finally {
+    const store = getFileCompletionStore();
+    store.completions.delete(requestId);
+    store.waiters.delete(requestId);
+    signal?.removeEventListener("abort", onAbort);
+    bridge.ReleaseRequest(requestId);
+  }
+}
+async function collectFiles(dirPath, globPattern, fs) {
+  const files = [];
+  const queue = [dirPath];
+  while (queue.length > 0) {
+    const dir = queue.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = fs.join(dir, entry);
+      let stat;
+      try {
+        stat = await fs.stat(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory) {
+        if (!SKIP_DIRS.has(entry)) {
+          queue.push(fullPath);
+        }
+      } else if (stat.isFile) {
+        const ext = fs.extname(entry).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext)) continue;
+        if (globPattern) {
+          if (globPattern.startsWith("*.")) {
+            const globExt = globPattern.slice(1);
+            if (ext !== globExt) continue;
+          } else if (globPattern.startsWith("**/*.")) {
+            const globExt = globPattern.slice(3);
+            if (ext !== globExt) continue;
+          }
+        }
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function createGrepTool(cwd, options) {
+  const fs = getFileSystem();
+  const platform = detectPlatform();
+  const rootSchema = buildRootParameterSchema(cwd, options);
+  const grepSchema = Type.Object({
+    pattern: Type.String({ description: "Search pattern (regex or literal string)" }),
+    path: Type.Optional(Type.String({ description: "Directory or file to search (default: workspace root)" })),
+    ...rootSchema ? { root: rootSchema } : {},
+    glob: Type.Optional(Type.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.js'" })),
+    ignoreCase: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
+    literal: Type.Optional(
+      Type.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" })
+    ),
+    context: Type.Optional(
+      Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })
+    ),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" }))
+  });
+  const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
+  return {
+    name: "grep",
+    label: "grep",
+    description: `Search file contents for a pattern. ${pathResolutionDescription} Returns matching lines with file paths and line numbers. Output is truncated to ${DEFAULT_LIMIT2} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+    parameters: grepSchema,
+    execute: async (_toolCallId, params, signal) => {
+      const {
+        pattern,
+        path: searchDir,
+        root,
+        glob: globPattern,
+        ignoreCase,
+        literal,
+        context: contextLines,
+        limit
+      } = params;
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        const onAbort = () => reject(new Error("Operation aborted"));
+        signal?.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            const searchPath = resolveToCwd(searchDir || ".", cwd, options, root);
+            const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT2);
+            const ctx = contextLines && contextLines > 0 ? contextLines : 0;
+            let isDir;
+            try {
+              const stat = await fs.stat(searchPath);
+              isDir = stat.isDirectory;
+            } catch {
+              reject(new Error(`Path not found: ${searchPath}`));
+              return;
+            }
+            let regex;
+            try {
+              const flags = ignoreCase ? "gi" : "g";
+              if (literal) {
+                const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                regex = new RegExp(escaped, flags);
+              } else {
+                regex = new RegExp(pattern, flags);
+              }
+            } catch (e) {
+              reject(new Error(`Invalid regex pattern: ${e.message}`));
+              return;
+            }
+            let outputLines = [];
+            let matchCount = 0;
+            let matchLimitReached = false;
+            let linesTruncated = false;
+            if (platform === "puerts" && getNativeFileBridge()) {
+              const nativeResult = await runNativeGrep(
+                searchPath,
+                pattern,
+                globPattern,
+                !!ignoreCase,
+                !!literal,
+                ctx,
+                effectiveLimit,
+                signal
+              );
+              outputLines = nativeResult.Lines ?? [];
+              matchCount = nativeResult.MatchCount ?? 0;
+              matchLimitReached = !!nativeResult.MatchLimitReached;
+              linesTruncated = !!nativeResult.LinesTruncated;
+              globalThis.pieBridge?.log?.(
+                "info",
+                `[grep] path=${searchPath} pattern=${pattern} matches=${matchCount} files=${nativeResult.FilesScanned ?? 0}`
+              );
+            } else {
+              let filePaths;
+              if (isDir) {
+                filePaths = await collectFiles(searchPath, globPattern, fs);
+                filePaths.sort();
+              } else {
+                filePaths = [searchPath];
+              }
+              for (const filePath of filePaths) {
+                if (matchCount >= effectiveLimit) {
+                  matchLimitReached = true;
+                  break;
+                }
+                if (signal?.aborted) {
+                  reject(new Error("Operation aborted"));
+                  return;
+                }
+                let content;
+                try {
+                  content = await fs.readFile(filePath, "utf-8");
+                } catch {
+                  continue;
+                }
+                const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+                const relativePath = isDir ? fs.relative(searchPath, filePath) : fs.basename(filePath);
+                for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+                  if (matchCount >= effectiveLimit) {
+                    matchLimitReached = true;
+                    break;
+                  }
+                  regex.lastIndex = 0;
+                  if (regex.test(lines[lineIdx])) {
+                    matchCount++;
+                    const start = ctx > 0 ? Math.max(0, lineIdx - ctx) : lineIdx;
+                    const end = ctx > 0 ? Math.min(lines.length - 1, lineIdx + ctx) : lineIdx;
+                    for (let c = start; c <= end; c++) {
+                      const lineText = lines[c];
+                      const { text: truncatedText, wasTruncated } = truncateLine(lineText);
+                      if (wasTruncated) linesTruncated = true;
+                      const currentLineNum = c + 1;
+                      if (c === lineIdx) {
+                        outputLines.push(`${relativePath}:${currentLineNum}: ${truncatedText}`);
+                      } else {
+                        outputLines.push(`${relativePath}-${currentLineNum}- ${truncatedText}`);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            signal?.removeEventListener("abort", onAbort);
+            if (matchCount === 0) {
+              resolve({
+                content: [{ type: "text", text: "No matches found" }],
+                details: { noMatches: true }
+              });
+              return;
+            }
+            const rawOutput = outputLines.join("\n");
+            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+            let output = truncation.content;
+            const details = {};
+            const notices = [];
+            if (matchLimitReached) {
+              notices.push(
+                `${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`
+              );
+              details.matchLimitReached = effectiveLimit;
+            }
+            if (truncation.truncated) {
+              notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+              details.truncation = truncation;
+            }
+            if (linesTruncated) {
+              notices.push(
+                `Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`
+              );
+              details.linesTruncated = true;
+            }
+            if (notices.length > 0) {
+              output += `
+
+[${notices.join(". ")}]`;
+            }
+            resolve({
+              content: [{ type: "text", text: output }],
+              details: Object.keys(details).length > 0 ? details : void 0
+            });
+          } catch (err) {
+            signal?.removeEventListener("abort", onAbort);
+            reject(err);
+          }
+        })();
+      });
+    }
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/find.ts
+var DEFAULT_LIMIT3 = 1e3;
+var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "__pycache__", ".svn", ".hg"]);
+function globToRegex(pattern) {
+  let regexPattern = pattern.replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "__STAR__").replace(/\?/g, "__QMARK__").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/__GLOBSTAR__/g, ".*").replace(/__STAR__/g, "[^/]*").replace(/__QMARK__/g, ".");
+  regexPattern = regexPattern.replace(/\//g, "[/\\\\]");
+  return new RegExp("^" + regexPattern + "$", "i");
+}
+function matchesGlob(filePath, pattern) {
+  const regex = globToRegex(pattern);
+  return regex.test(filePath);
+}
+function getNativeFileBridge2() {
+  try {
+    return typeof CS !== "undefined" && CS?.Pie?.PieFileBridge ? CS.Pie.PieFileBridge : null;
+  } catch {
+    return null;
+  }
+}
+function getFileCompletionStore2() {
+  const g = globalThis;
+  if (!g.__pieFileCompletionStore) {
+    g.__pieFileCompletionStore = {
+      completions: /* @__PURE__ */ new Map(),
+      waiters: /* @__PURE__ */ new Map()
+    };
+  }
+  if (!g._pieFileComplete) {
+    g._pieFileComplete = (requestId, resultJson, error) => {
+      const store = getFileCompletionStore2();
+      const payload = { resultJson, error };
+      store.completions.set(requestId, payload);
+      const waiter = store.waiters.get(requestId);
+      if (waiter) {
+        store.waiters.delete(requestId);
+        waiter(payload);
+      }
+    };
+  }
+  return g.__pieFileCompletionStore;
+}
+function waitForFileCompletion2(requestId) {
+  const store = getFileCompletionStore2();
+  const existing = store.completions.get(requestId);
+  if (existing) {
+    return Promise.resolve(existing);
+  }
+  return new Promise((resolve) => {
+    store.waiters.set(requestId, resolve);
+  });
+}
+async function runNativeFind(searchPath, pattern, limit, signal) {
+  const bridge = getNativeFileBridge2();
+  if (!bridge) {
+    throw new Error("CS.Pie.PieFileBridge not available");
+  }
+  const requestId = bridge.StartFind(searchPath, pattern, limit);
+  const onAbort = () => bridge.CancelRequest(requestId);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    if (signal?.aborted) {
+      bridge.CancelRequest(requestId);
+      throw new Error("Operation aborted");
+    }
+    const completion = await waitForFileCompletion2(requestId);
+    if (completion.error) {
+      throw new Error(completion.error);
+    }
+    if (!completion.resultJson) {
+      return {};
+    }
+    return JSON.parse(completion.resultJson);
+  } finally {
+    const store = getFileCompletionStore2();
+    store.completions.delete(requestId);
+    store.waiters.delete(requestId);
+    signal?.removeEventListener("abort", onAbort);
+    bridge.ReleaseRequest(requestId);
+  }
+}
+async function globFiles(rootPath, pattern, fs, limit, signal) {
+  const results = [];
+  const queue = [{ dir: rootPath, relPrefix: "" }];
+  while (queue.length > 0 && results.length < limit) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    const { dir, relPrefix } = queue.shift();
+    let entries;
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (results.length >= limit) break;
+      const fullPath = fs.join(dir, entry);
+      const relPath = relPrefix ? relPrefix + "/" + entry : entry;
+      let stat;
+      try {
+        stat = await fs.stat(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory) {
+        if (SKIP_DIRS2.has(entry)) continue;
+        queue.push({ dir: fullPath, relPrefix: relPath });
+      } else if (stat.isFile) {
+        if (matchesGlob(relPath, pattern) || matchesGlob(entry, pattern)) {
+          results.push(relPath);
+        }
+      }
+    }
+  }
+  return results;
+}
+function createFindTool(cwd, options) {
+  const fs = getFileSystem();
+  const platform = detectPlatform();
+  const rootSchema = buildRootParameterSchema(cwd, options);
+  const findSchema = Type.Object({
+    pattern: Type.String({
+      description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'"
+    }),
+    path: Type.Optional(Type.String({ description: "Directory to search in (default: workspace root)" })),
+    ...rootSchema ? { root: rootSchema } : {},
+    limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" }))
+  });
+  const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
+  return {
+    name: "find",
+    label: "find",
+    description: `Search for files by glob pattern. ${pathResolutionDescription} Returns matching file paths relative to the search directory. Output is truncated to ${DEFAULT_LIMIT3} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
+    parameters: findSchema,
+    execute: async (_toolCallId, params, signal) => {
+      const { pattern, path: searchDir, root, limit } = params;
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        const onAbort = () => reject(new Error("Operation aborted"));
+        signal?.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            const searchPath = resolveToCwd(searchDir || ".", cwd, options, root);
+            const effectiveLimit = limit ?? DEFAULT_LIMIT3;
+            if (!await fs.exists(searchPath)) {
+              reject(new Error(`Path not found: ${searchPath}`));
+              return;
+            }
+            let results;
+            if (platform === "puerts" && getNativeFileBridge2()) {
+              const nativeResult = await runNativeFind(searchPath, pattern, effectiveLimit, signal);
+              results = nativeResult.Results ?? [];
+              globalThis.pieBridge?.log?.(
+                "info",
+                `[find] path=${searchPath} pattern=${pattern} matches=${results.length} dirs=${nativeResult.ScannedDirectories ?? 0} files=${nativeResult.ScannedFiles ?? 0}`
+              );
+            } else if (platform === "node") {
+              try {
+                const _require = globalThis.require || __require;
+                const { globSync } = _require("glob");
+                results = globSync(pattern, {
+                  cwd: searchPath,
+                  ignore: ["**/node_modules/**", "**/.git/**"],
+                  nodir: false,
+                  absolute: false,
+                  dot: true
+                }).slice(0, effectiveLimit);
+              } catch {
+                results = await globFiles(searchPath, pattern, fs, effectiveLimit, signal);
+              }
+            } else {
+              results = await globFiles(searchPath, pattern, fs, effectiveLimit, signal);
+            }
+            signal?.removeEventListener("abort", onAbort);
+            if (results.length === 0) {
+              resolve({
+                content: [{ type: "text", text: "No files found matching pattern" }],
+                details: { noMatches: true }
+              });
+              return;
+            }
+            const resultLimitReached = results.length >= effectiveLimit;
+            const rawOutput = results.join("\n");
+            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+            let resultOutput = truncation.content;
+            const details = {};
+            const notices = [];
+            if (resultLimitReached) {
+              notices.push(`${effectiveLimit} results limit reached`);
+              details.resultLimitReached = effectiveLimit;
+            }
+            if (truncation.truncated) {
+              notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+              details.truncation = truncation;
+            }
+            if (notices.length > 0) {
+              resultOutput += "\n\n[" + notices.join(". ") + "]";
+            }
+            resolve({
+              content: [{ type: "text", text: resultOutput }],
+              details: Object.keys(details).length > 0 ? details : void 0
+            });
+          } catch (e) {
+            signal?.removeEventListener("abort", onAbort);
+            reject(e);
+          }
+        })();
+      });
+    }
+  };
+}
+
+// ../../packages/shared-headless-capabilities/src/builtin/fs/index.ts
+function createSharedFileSystemTools(sandboxRoot, options) {
+  return [
+    createReadTool(sandboxRoot, options),
+    createWriteTool(sandboxRoot, options),
+    createEditTool(sandboxRoot, options),
+    createLsTool(sandboxRoot, options),
+    createGrepTool(sandboxRoot, options),
+    createFindTool(sandboxRoot, options)
+  ];
+}
+function createSharedReadOnlyTools(sandboxRoot, options) {
+  return [
+    createReadTool(sandboxRoot, options),
+    createLsTool(sandboxRoot, options),
+    createGrepTool(sandboxRoot, options),
+    createFindTool(sandboxRoot, options)
+  ];
+}
+var createFileSystemTools = createSharedFileSystemTools;
+var createReadOnlyTools = createSharedReadOnlyTools;
+
+// ../../packages/shared-headless-capabilities/src/index.ts
+function getSharedCapabilityPromptAdditionsForToolNames(toolNames) {
+  const definitions = [
+    createManageTodoCapability(),
+    createAskUserCapability()
+  ];
+  return collectSharedCapabilityPromptAdditions(
+    definitions,
+    toolNames
+  );
+}
+
+export {
+  defineSharedCapability,
+  collectSharedCapabilityPromptAdditions,
+  PLAN_MODE_TOOL_NAMES,
+  extractPlanTodoItems,
+  isPlanModeSafeCommand,
+  extractDoneSteps,
+  markCompletedPlanSteps,
+  createPlanCapability,
+  ReadSkillParamsSchema,
+  createReadSkillCapability,
+  formatSkillsForPrompt,
+  collectLastAssistantText,
+  createSubagentCapability,
+  TodoItemSchema,
+  ManageTodoListParamsSchema,
+  cloneTodos,
+  normalizeStatus,
+  normalizeTodos,
+  validateTodos,
+  getTodoValidation,
+  getTodoStats,
+  buildTodoSuccessMessage,
+  executeManageTodoList,
+  restoreTodoState,
+  restoreTodosFromMessages,
+  createTodoStore,
+  createManageTodoCapability,
+  calculateTotalTokens,
+  findFirstKeptUserEntryId,
+  createCompactionSummary,
+  createSessionManager,
+  registerInteractionHandler,
+  hasInteractionHandler,
+  requestInteraction,
+  AskUserParamsSchema,
+  AskUserMultiParamsSchema,
+  createAskUserCapability,
+  getAvailableRoots,
+  getDefaultRootName,
+  resolveInSandbox,
+  resolveToCwd,
+  resolveReadPath,
+  buildRootParameterSchema,
+  buildPathResolutionDescription,
+  DEFAULT_MAX_LINES,
+  DEFAULT_MAX_BYTES,
+  GREP_MAX_LINE_LENGTH,
+  formatSize,
+  truncateHead,
+  truncateTail,
+  truncateLine,
+  createReadTool,
+  createWriteTool,
+  detectLineEnding,
+  normalizeToLF,
+  restoreLineEndings,
+  normalizeForFuzzyMatch,
+  fuzzyFindText,
+  stripBom,
+  generateDiffString,
+  createEditTool,
+  createLsTool,
+  createGrepTool,
+  createFindTool,
+  createSharedFileSystemTools,
+  createSharedReadOnlyTools,
+  createFileSystemTools,
+  createReadOnlyTools,
+  getSharedCapabilityPromptAdditionsForToolNames
+};