@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/chunk-PQNT34LY.js

@@ -0,0 +1,1247 @@
+#!/usr/bin/env node
+import {
+  colorDiff
+} from "./chunk-4JSUUDFQ.js";
+import {
+  SPECIALIST_SPECS,
+  THINKING_WORDS,
+  callersText,
+  findCallersTool,
+  findReferencesTool,
+  findSymbolText,
+  findSymbolTool,
+  impactAnalysisText,
+  impactAnalysisTool,
+  modelFacts,
+  referencesText,
+  repoMapText,
+  repoMapTool,
+  verifyAuditFile
+} from "./chunk-K7KK7U44.js";
+import {
+  WEB_SEARCH_USD,
+  totalTokens
+} from "./chunk-HRGX53VC.js";
+import {
+  BUILTIN_COMMANDS
+} from "./chunk-23FXBNBB.js";
+import {
+  LSP_LANGUAGES
+} from "./chunk-EU7PA45O.js";
+import {
+  listJobs
+} from "./chunk-KKB5W47S.js";
+
+// src/cli/errors.ts
+function describeError(error) {
+  const parts = [];
+  let current = error;
+  for (let depth = 0; current !== void 0 && current !== null && depth < 5; depth++) {
+    if (current instanceof Error) {
+      const code = current.code;
+      parts.push(typeof code === "string" ? `${current.message} (${code})` : current.message);
+      current = current.cause;
+    } else {
+      parts.push(String(current));
+      break;
+    }
+  }
+  return parts.join("\n  caused by: ");
+}
+
+// src/cli/focus.ts
+var FOCUS_REPORTING_ON = "\x1B[?1004h";
+var FOCUS_REPORTING_OFF = "\x1B[?1004l";
+var REPORTING_TERMINALS = /* @__PURE__ */ new Set(["iTerm.app", "ghostty", "WezTerm", "vscode"]);
+function reportsFocus(env = process.env) {
+  const multiplexer = env.TMUX !== void 0 || (env.TERM ?? "").startsWith("screen");
+  return !multiplexer && REPORTING_TERMINALS.has(env.TERM_PROGRAM ?? "");
+}
+var FocusTracker = class {
+  focused = true;
+  update(focused) {
+    this.focused = focused;
+  }
+};
+function focusEvent(input) {
+  const code = input.startsWith("\x1B") ? input.slice(1) : input;
+  if (code === "[I") return true;
+  if (code === "[O") return false;
+  return void 0;
+}
+
+// src/cli/report.ts
+function formatTokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function formatUsd(usd) {
+  if (usd === void 0) return "cost unknown";
+  return usd < 0.01 ? `$${usd.toFixed(4)}` : `$${usd.toFixed(2)}`;
+}
+function usageLine(result, session, runCostUsd, contextWindow) {
+  const u = result.usage;
+  const input = u.inputTokens + u.cacheReadTokens + u.cacheWriteTokens;
+  const percent = Math.round(session.contextTokens / contextWindow * 100);
+  return [
+    `${result.stopReason} \xB7 ${result.steps} step(s)`,
+    `${formatTokens(input)} in (${formatTokens(u.cacheReadTokens)} cached) / ${formatTokens(u.outputTokens)} out`,
+    formatUsd(runCostUsd),
+    `context ${percent}% of ${formatTokens(contextWindow)}`,
+    `session ${formatTokens(totalTokens(session.usage))} tokens, ${formatUsd(session.costUsd)}`
+  ].join(" \xB7 ");
+}
+function stopMessage(reason, limits) {
+  switch (reason) {
+    case "done":
+      return void 0;
+    case "max_steps":
+      return `Stopped: the run reached the step limit (${limits.maxSteps}). Use --resume to continue, or raise limits.maxSteps in .garuda/settings.json.`;
+    case "token_budget":
+      return `Stopped: the session used its token budget (${formatTokens(limits.tokenBudget)} tokens). Raise limits.tokenBudget in .garuda/settings.json to continue.`;
+    case "repeated_calls":
+      return "Stopped: the agent made the same tool call 3 times in a row, so it may be stuck. Use --resume with a hint to continue.";
+    case "max_tokens":
+      return "Stopped: the response reached the output token limit.";
+    case "refusal":
+      return "Stopped: the model refused the request.";
+  }
+}
+
+// src/cli/turn.ts
+async function runTurnInTerminal(runtime, approver, renderer, prompt, exitNow, watcher) {
+  const started = performance.now();
+  watcher?.turnStarted();
+  let outcome;
+  try {
+    outcome = await runTurn(runtime, approver, renderer, prompt, exitNow);
+    return outcome;
+  } finally {
+    watcher?.turnEnded(outcome, performance.now() - started);
+  }
+}
+async function runTurn(runtime, approver, renderer, prompt, exitNow) {
+  const controller = new AbortController();
+  const stop = () => {
+    if (controller.signal.aborted) exitNow();
+    renderer.warn("\nStopping\u2026 (press Ctrl-C again to exit Garuda)");
+    controller.abort();
+  };
+  process.on("SIGINT", stop);
+  approver.onInterrupt = stop;
+  const costBefore = runtime.session?.costUsd ?? 0;
+  try {
+    const result = await runtime.runTurn(prompt, controller.signal);
+    const session = runtime.session;
+    if (session !== void 0) {
+      const runCost = session.costUsd === void 0 ? void 0 : session.costUsd - costBefore;
+      renderer.info(`
+[${usageLine(result, session, runCost, runtime.limits.contextWindow)}]`);
+    }
+    const message = stopMessage(result.stopReason, runtime.limits);
+    if (message !== void 0) renderer.warn(message);
+    return { kind: "done", result };
+  } catch (error) {
+    if (controller.signal.aborted) {
+      runtime.recordStop("interrupted");
+      renderer.warn("Turn stopped.");
+      return { kind: "interrupted" };
+    }
+    runtime.recordStop("error");
+    const message = describeError(error);
+    renderer.error(`Error: ${message}`);
+    return { kind: "error", message };
+  } finally {
+    process.off("SIGINT", stop);
+    approver.onInterrupt = () => {
+    };
+  }
+}
+
+// src/cli/chat/plan.ts
+var BUILD_PROMPT = "Carry out the plan above.";
+async function planHandoff(runtime, approver, signal = new AbortController().signal) {
+  const request = {
+    tool: "plan",
+    target: { kind: "input", json: "{}" },
+    preview: "Build mode can change files and run commands, with the usual approvals and sandbox. To build it later, unattended, choose No and type /schedule.",
+    isolation: runtime.executor.isolation,
+    title: "The plan is ready.",
+    question: "Build this plan?",
+    labels: {
+      once: "Yes, build it now",
+      session: "Switch to build mode; I will type the task",
+      deny: "No, keep planning"
+    }
+  };
+  const choice = await approver.ask(request, signal);
+  if (choice === "deny") return "stay";
+  runtime.setMode("build");
+  return choice === "once" ? "now" : "later";
+}
+function modeText(runtime) {
+  return runtime.mode === "plan" ? "Plan mode: the agent reads and plans. It cannot change files; commands run read-only in the sandbox. /build (or Shift+Tab) switches back." : "Build mode: the agent can change files and run commands, with the usual approvals.";
+}
+
+// src/cli/chat/commands.ts
+var HELP = [
+  "Type a task and press Enter. @path attaches a file or folder, !command runs a command, Tab completes.",
+  "Commands:",
+  "  /help      show this help",
+  "  /usage     tokens and cost of this session",
+  "  /session   the session id and file",
+  "  /sessions  this project's sessions; /sessions <n|id> continues one; rename, delete",
+  "  /models    the models; /models <n|id|opus|sonnet|haiku> switches for this chat",
+  "  /export    write this conversation as Markdown; /export <file>",
+  "  /compact   summarise the older turns now; /compact <what to keep>",
+  "  /diff      file changes in this session; /diff last (last turn); /diff [last] <path>",
+  "  /schedule  make the last plan a job that runs later: /schedule [HH:MM], then garuda run <id>",
+  "  /jobs      the scheduled jobs of this project; /jobs <id> shows one; /jobs cancel|delete <id>; /jobs cancel night",
+  "  /where X   where symbol X is defined (code index, no model call)",
+  "  /defs X    alias of /where X (definitions of X)",
+  "  /refs X    every use of symbol X (code index, no model call)",
+  "  /callers X who calls symbol X (code index, no model call)",
+  "  /impact X  blast radius and affected tests for file or symbol X",
+  "  /map [dir] what each code file exports and imports",
+  "  /mcp       MCP servers: state, sandbox, network and tool count; /mcp logout <server>",
+  "  /hooks     the active hooks",
+  "  /lsp       language servers for diagnostics; /lsp install <typescript|python|java>",
+  "  /languages registered language plugins and indexed file counts",
+  "  /experts   MoE language specialist subagents and their active status",
+  "  /audit     team security policy and recent audit trail; /audit [n|denials|stats|verify]",
+  "  /commands  your custom commands and skills (~/.garuda, .garuda, .claude)",
+  "  /agents    your custom agents and their tools (~/.garuda, .garuda, .claude)",
+  "  /plan      plan mode: read and plan, change nothing (Shift+Tab toggles); /plan <task> plans it",
+  "  /build     build mode: change files and run commands (the default); /build <task> runs it",
+  "  /undo      take back the last turn: its file changes and its messages",
+  "  /redo      bring back the last undone turn",
+  "  /init      set up this folder: AGENTS.md, and files from other agents (Claude Code, OpenCode \u2026)",
+  "  /editor    write the next prompt in $VISUAL or $EDITOR (also Ctrl-G)",
+  "  /details   show or hide the result line under each tool call; /details on|off",
+  "  /thinking  Claude's thinking: /thinking low|medium|high|xhigh|max|default, show|hide, on|off",
+  "  /search    web search: /search shows it; /search claude|provider|off (this session); /search default <one> (saved)",
+  "  /new       start a new session (the old one stays on disk)",
+  "  /exit      leave (or press Ctrl-D, or Ctrl-C twice)"
+].join("\n");
+async function runCommand(text, { runtime, renderer, sessionPath, output, signal }) {
+  const command = text.split(/\s+/)[0];
+  if (command === "/exit" || command === "/quit") return "exit";
+  if (command === "/help") renderer.info(helpText(runtime));
+  else if (command === "/commands") renderer.info(commandsText(runtime));
+  else if (command === "/agents") renderer.info(agentsText(runtime));
+  else if (command === "/plan" || command === "/build") {
+    runtime.setMode(command === "/plan" ? "plan" : "build");
+    renderer.info(modeText(runtime));
+    const task = text.slice(command.length).trim();
+    if (task !== "") return { prompt: task };
+  } else if (command === "/thinking") {
+    const word = text.slice(command.length).trim();
+    if (word === "") renderer.info(runtime.thinkingStatus());
+    else {
+      const result = runtime.setThinking(word);
+      if (result.ok) renderer.info(result.text);
+      else renderer.warn(result.text);
+    }
+  } else if (command === "/search") {
+    const words = text.slice(command.length).trim().split(/\s+/).filter(Boolean);
+    const save = words[0] === "default";
+    const use = save ? words[1] : words[0];
+    if (use === void 0 && !save) renderer.info(runtime.searchStatus());
+    else if (use === "claude" || use === "provider" || use === "off") {
+      const result = await runtime.setSearch(use, save);
+      if (result.ok) renderer.info(result.text);
+      else renderer.warn(result.text);
+    } else
+      renderer.warn(
+        "Use: /search, /search claude|provider|off, /search default claude|provider|off."
+      );
+  } else if (command === "/details") {
+    detailsCommand(renderer, text.slice(command.length).trim());
+  } else if (command === "/usage") renderer.info(usageSummary(runtime));
+  else if (command === "/session") {
+    const id = runtime.session?.id;
+    if (id === void 0) {
+      renderer.info("No session yet.");
+    } else {
+      const lines = [`Session ${id}`, sessionPath(id)];
+      const sub = runtime.subagentsSummary();
+      if (sub.length > 0) lines.push(`Subagents: ${sub.join(" \xB7 ")} (see /experts)`);
+      const ag = runtime.agentsSummary();
+      if (ag.length > 0) lines.push(`Agents:    ${ag.join(" \xB7 ")} (see /agents)`);
+      const sk = runtime.skillsSummary();
+      if (sk.length > 0) lines.push(`Skills:    ${sk.join(" \xB7 ")} (see /commands)`);
+      const tl = runtime.toolsSummary();
+      if (tl.length > 0) lines.push(`Tools:     ${tl.join(" \xB7 ")}`);
+      renderer.info(lines.join("\n"));
+    }
+  } else if (command === "/sessions") {
+    await sessionsCommand(
+      runtime,
+      renderer,
+      text.slice(command.length).trim(),
+      signal ?? new AbortController().signal
+    );
+  } else if (command === "/models") {
+    const arg = text.slice(command.length).trim();
+    if (arg === "") renderer.info(modelsText(runtime));
+    else {
+      const result = await runtime.setModel(arg);
+      if (result.ok) renderer.info(result.text);
+      else renderer.warn(result.text);
+    }
+  } else if (command === "/compact") {
+    await compactCommand(
+      runtime,
+      renderer,
+      text.slice(command.length).trim(),
+      signal ?? new AbortController().signal
+    );
+  } else if (command === "/diff") {
+    await diffCommand(runtime, renderer, text.slice(command.length).trim(), output);
+  } else if (command === "/schedule") {
+    const at = text.slice(command.length).trim();
+    const result = await runtime.scheduleJob(
+      at === "" ? void 0 : at,
+      new AbortController().signal
+    );
+    if (result.ok) renderer.info(result.text);
+    else renderer.warn(result.text);
+  } else if (command === "/jobs") {
+    await jobsCommand(runtime, renderer, text.slice(command.length).trim());
+  } else if (command === "/export") {
+    await exportCommand(runtime, renderer, text.slice(command.length).trim());
+  } else if (command === "/where" || command === "/defs" || command === "/refs" || command === "/callers" || command === "/impact" || command === "/map") {
+    await lookup(runtime, renderer, command, text.slice(command.length).trim());
+  } else if (command === "/hooks") {
+    const lines = runtime.hookLines();
+    renderer.info(
+      lines.length === 0 ? "No active hooks. They load with the first task. Configure them in ~/.garuda/hooks.json or .garuda/hooks.json." : lines.join("\n")
+    );
+  } else if (command === "/mcp") {
+    const [verb, name] = text.slice(command.length).trim().split(/\s+/);
+    if (verb === "logout" && name !== void 0 && name !== "") {
+      const removed = await runtime.mcpLogout(name);
+      renderer.info(
+        removed > 0 ? `Signed out of MCP server "${name}": its tokens are gone. The next session asks you to sign in again.` : `There are no tokens for MCP server "${name}".`
+      );
+    } else if (verb !== void 0 && verb !== "") {
+      renderer.warn("Use: /mcp, or /mcp logout <server>.");
+    } else {
+      renderer.info(mcpSummary(runtime));
+    }
+  } else if (command === "/lsp") {
+    await lspCommand(runtime, renderer, text.slice(command.length).trim());
+  } else if (command === "/languages") {
+    await languagesCommand(runtime, renderer);
+  } else if (command === "/experts") {
+    await expertsCommand(runtime, renderer);
+  } else if (command === "/audit") {
+    await auditCommand(runtime, renderer, text.slice(command.length).trim());
+  } else if (command === "/undo" || command === "/redo") {
+    const signal2 = new AbortController().signal;
+    renderer.info(await (command === "/undo" ? runtime.undo(signal2) : runtime.redo(signal2)));
+  } else if (command === "/init") {
+    const { report, prompt } = await runtime.init(new AbortController().signal);
+    if (report.length > 0) renderer.info(report.join("\n"));
+    return { prompt };
+  } else if (command === "/editor") {
+    renderer.info("The external editor works in the full chat: Ctrl-G or /editor.");
+  } else if (command === "/new") {
+    runtime.newSession();
+    renderer.info("The next task starts a new session.");
+  } else {
+    const resolved = await runtime.resolveCommand(text, new AbortController().signal);
+    if (resolved.kind === "prompt") return { prompt: resolved.prompt };
+    if (resolved.kind === "denied") renderer.info(resolved.message);
+    else renderer.warn(`Unknown command ${command}. Type /help.`);
+  }
+  return "done";
+}
+async function sessionsCommand(runtime, renderer, arg, signal) {
+  const [verb = "", ref = "", ...rest] = arg.split(/\s+/);
+  if (verb === "rename" || verb === "delete") {
+    const use = `Use: /sessions ${verb} <number or id>${verb === "rename" ? " <title>" : ""}.`;
+    if (ref === "" || verb === "rename" && rest.length === 0 || verb === "delete" && rest.length > 0) {
+      renderer.warn(use);
+      return;
+    }
+    const result = verb === "rename" ? await runtime.renameSession(ref, rest.join(" ")) : await runtime.deleteSession(ref, signal);
+    if (result.ok) renderer.info(result.text);
+    else renderer.warn(result.text);
+    return;
+  }
+  if (arg !== "") {
+    const result = await runtime.switchSession(arg);
+    if (result.ok) renderer.info(result.text);
+    else renderer.warn(result.text);
+    return;
+  }
+  const { sessions, total } = await runtime.listSessions();
+  if (sessions.length === 0) {
+    renderer.info("There are no sessions in this project yet.");
+    return;
+  }
+  const open = runtime.session?.id;
+  const width = String(sessions.length).length;
+  const rows = sessions.flatMap((s, i) => {
+    const facts = [
+      s.id,
+      `${s.turns} turn${s.turns === 1 ? "" : "s"}`,
+      ...s.costUsd === void 0 || s.costUsd === 0 ? [] : [`$${s.costUsd.toFixed(2)}`],
+      ...s.model === void 0 ? [] : [s.model]
+    ].join(" \xB7 ");
+    return [
+      `  ${String(i + 1).padStart(width)}. ${localTime(s.updated)}  ${s.title === "" ? "(no prompt)" : s.title}${s.id === open ? "  (open)" : ""}`,
+      `  ${"".padStart(width)}  ${facts}`
+    ];
+  });
+  renderer.info(
+    [
+      "Sessions in this project, newest first:",
+      ...rows,
+      ...total > sessions.length ? [`  \u2026 ${total - sessions.length} older`] : [],
+      "Continue one with /sessions <number or id>. /new starts a new one.",
+      "/sessions rename <number or id> <title> \xB7 /sessions delete <number or id>"
+    ].join("\n")
+  );
+}
+function localTime(d) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function modelsText(runtime) {
+  const list = runtime.modelList();
+  const width = Math.max(...list.map((m) => m.spec.length));
+  const numbers = String(list.length).length;
+  return [
+    "Models (\u25CF the current one):",
+    ...list.map((m, i) => {
+      const mark = m.spec === runtime.modelId ? "\u25CF" : " ";
+      return `  ${mark} ${String(i + 1).padStart(numbers)}  ${m.spec.padEnd(width + 2)}${modelFacts(m.info.contextWindow, m.info.price)}`;
+    }),
+    "Switch with /models <number, id or opus|sonnet|haiku|fable>. It is for this chat only.",
+    "Add other models (Ollama, OpenRouter \u2026) in ~/.garuda/models.json."
+  ].join("\n");
+}
+var DIFF_LINES = 300;
+async function diffCommand(runtime, renderer, arg, output) {
+  const words = arg === "" ? [] : arg.split(/\s+/);
+  const scope = words[0] === "last" ? "last" : "session";
+  const path = (scope === "last" ? words.slice(1) : words).join(" ");
+  const result = await runtime.diff(
+    scope,
+    path === "" ? void 0 : path,
+    new AbortController().signal
+  );
+  if ("problem" in result) {
+    renderer.warn(result.problem);
+    return;
+  }
+  const since = scope === "last" ? "since the start of the last turn" : "since the first turn of this session";
+  const where = result.path === void 0 ? "" : ` in ${result.path}`;
+  if (result.files.length === 0) {
+    renderer.info(`No file changed${where} ${since}.`);
+    return;
+  }
+  const plus = result.files.reduce((n, f) => n + (f.added ?? 0), 0);
+  const minus = result.files.reduce((n, f) => n + (f.removed ?? 0), 0);
+  const width = Math.max(...result.files.map((f) => f.path.length));
+  const mark = { added: "A", modified: "M", deleted: "D" };
+  const rows = result.files.map((f) => {
+    const counts = f.added === void 0 ? "binary" : [f.added > 0 ? `+${f.added}` : "", f.removed ? `\u2212${f.removed}` : ""].filter(Boolean).join(" ");
+    return `  ${mark[f.status]} ${f.path.padEnd(width + 2)}${counts}`;
+  });
+  const lines = result.patch.replace(/\n$/, "").split("\n");
+  const cut = lines.length > DIFF_LINES;
+  const more = output === void 0 ? "/diff <path> shows one file." : "Ctrl-O shows all; /diff <path> shows one file.";
+  (output ?? ((t) => renderer.info(t)))(
+    [
+      `Changes${where} ${since} (${result.files.length} file${result.files.length === 1 ? "" : "s"}, +${plus} \u2212${minus}). Changes you made yourself count too.`,
+      ...rows,
+      "",
+      colorDiff(lines.slice(0, DIFF_LINES).join("\n")),
+      ...cut ? [`\u2026 ${lines.length - DIFF_LINES} more lines. ${more}`] : []
+    ].join("\n"),
+    cut ? { title: `diff ${since}${where}`, text: colorDiff(result.patch) } : void 0
+  );
+}
+async function jobsCommand(runtime, renderer, id) {
+  const { listJobs: listJobs2, loadJob, JOBS_DIR } = await import("./job-3NYDMP2M.js");
+  const cancel = /^cancel\s+(\S+)$/.exec(id);
+  if (cancel !== null) {
+    renderer.info(await runtime.cancelJob(cancel[1]));
+    return;
+  }
+  const remove = /^delete\s+(\S+)$/.exec(id);
+  if (remove !== null) {
+    renderer.info(await runtime.deleteJob(remove[1], new AbortController().signal));
+    return;
+  }
+  if (id !== "") {
+    try {
+      const job = await loadJob(runtime.root, id);
+      const { jobReport } = await import("./text-J2GD647J.js");
+      renderer.info(jobReport(job));
+    } catch (error) {
+      renderer.warn(error.message);
+    }
+    return;
+  }
+  const jobs = await listJobs2(runtime.root);
+  const { defaultAgentEnv, nightAgentTime } = await import("./launchd-QVHQ3VNN.js");
+  const night = nightAgentTime(runtime.root, defaultAgentEnv());
+  const nightLine = night === void 0 ? [] : [
+    `Night shift: launchd starts the queue at ${night.toTimeString().slice(0, 5)} on ${night.toDateString()} (/jobs cancel night removes it).`
+  ];
+  if (jobs.length === 0) {
+    renderer.info("No jobs in this project. Make a plan (/plan), then /schedule.");
+    return;
+  }
+  renderer.info(
+    [
+      ...nightLine,
+      `Jobs (${JOBS_DIR}), newest first:`,
+      ...jobs.map((j) => {
+        const r = j.result;
+        const facts = [
+          j.status,
+          ...j.status === "scheduled" && j.queue === true && j.launchd === void 0 ? ["in the night queue"] : [],
+          ...j.at === void 0 || j.status !== "scheduled" ? [] : [`at ${j.at}`],
+          ...r?.proof === void 0 ? [] : [r.proof.verdict === "ready" ? "ready to merge" : "needs a look"],
+          ...r === void 0 ? [] : [`${r.files.length} file(s)`],
+          ...r?.costUsd === void 0 ? [] : [`$${r.costUsd.toFixed(2)}`],
+          ...r === void 0 || r.denied.length === 0 ? [] : [`${r.denied.length} denied`]
+        ].join(" \xB7 ");
+        return `  ${j.id}  ${j.title}
+    ${facts}`;
+      }),
+      "Details: /jobs <id>. Run one: garuda run <id> [--at HH:MM]. Run the queue: garuda night [--at HH:MM]."
+    ].join("\n")
+  );
+}
+async function exportCommand(runtime, renderer, file) {
+  const records = await runtime.sessionRecords();
+  const id = runtime.session?.id;
+  if (records === void 0 || id === void 0) {
+    renderer.info("There is no conversation to export yet.");
+    return;
+  }
+  const { sessionMarkdown, writeExport } = await import("./export-HN3CT7AV.js");
+  const result = await writeExport(runtime.root, id, sessionMarkdown(records, id), file);
+  if ("problem" in result) renderer.warn(result.problem);
+  else
+    renderer.info(
+      `Wrote the conversation to ${result.path}. Secrets are redacted as in the session file.`
+    );
+}
+async function lspCommand(runtime, renderer, arg) {
+  if (arg === "") {
+    renderer.info(await runtime.lspStatus());
+    return;
+  }
+  const [verb, language] = arg.split(/\s+/);
+  const lang = LSP_LANGUAGES.find((l) => l === language);
+  if (verb !== "install" || lang === void 0) {
+    renderer.warn(`Use: /lsp, or /lsp install <${LSP_LANGUAGES.join("|")}>.`);
+    return;
+  }
+  renderer.info(`Installing the ${lang} language server (download outside the sandbox) \u2026`);
+  const result = await runtime.installLsp(lang, new AbortController().signal);
+  if (!result.ok) {
+    renderer.warn(`The install failed.
+$ ${result.command}
+${result.output ?? ""}`);
+    return;
+  }
+  renderer.info(
+    runtime.lspEnabled ? `Installed into ${result.dir}. The next edit of a ${lang} file uses it.` : `Installed into ${result.dir}. Diagnostics are off: start with --lsp, or set "lsp": { "enabled": true } in .garuda/settings.json.`
+  );
+}
+function helpText(runtime) {
+  return runtime.commands.length + runtime.skills.length === 0 ? HELP : `${HELP}
+
+${commandsText(runtime)}`;
+}
+function commandsText(runtime) {
+  const skills = runtime.skills;
+  if (runtime.commands.length + skills.length === 0) {
+    return [
+      "No custom commands and no skills.",
+      "Commands: Markdown files in ~/.garuda/commands/ or .garuda/commands/.",
+      "Skills: <name>/SKILL.md folders in ~/.garuda/skills/, .garuda/skills/ (or .claude/skills/)."
+    ].join("\n");
+  }
+  const rows = (list) => list.map((c) => ({
+    usage: `/${c.name}${c.argumentHint === void 0 ? "" : ` ${c.argumentHint}`}`,
+    about: `${c.about}${c.project ? " (project)" : ""}`
+  }));
+  const commandRows = rows(
+    runtime.commands.map((c) => ({
+      name: c.name,
+      ...c.argumentHint === void 0 ? {} : { argumentHint: c.argumentHint },
+      about: c.description ?? "",
+      project: c.source === "project"
+    }))
+  );
+  const skillRows = skills.map((s) => ({
+    usage: s.userInvocable ? `/${s.name}${s.argumentHint === void 0 ? "" : ` ${s.argumentHint}`}` : s.name,
+    about: `${s.description.length > 80 ? `${s.description.slice(0, 79)}\u2026` : s.description} (${s.shown}${s.modelInvocable ? "" : ", you only"}${s.userInvocable ? "" : ", model only"})`
+  }));
+  const width = Math.max(...[...commandRows, ...skillRows].map((r) => r.usage.length));
+  const table = (title, list) => list.length === 0 ? [] : [title, ...list.map((r) => `  ${r.usage.padEnd(width + 2)}${r.about}`.trimEnd())];
+  return [...table("Custom commands:", commandRows), ...table("Skills:", skillRows)].join("\n");
+}
+function agentsText(runtime) {
+  const agents = runtime.agents;
+  if (agents.length === 0) {
+    return "No custom agents. Add Markdown files to ~/.garuda/agents/ or .garuda/agents/ (or .claude/agents/).";
+  }
+  const width = Math.max(...agents.map((a) => a.name.length));
+  return [
+    "Custom agents (the model hands tasks to them with the agent tool):",
+    ...agents.map((a) => {
+      const about = a.description.length > 80 ? `${a.description.slice(0, 79)}\u2026` : a.description;
+      const tools = a.tools === void 0 ? "read-only tools" : a.tools.join(", ");
+      const model = a.model === void 0 ? "" : ` \xB7 model ${a.model}`;
+      return `  ${a.name.padEnd(width + 2)}${about}
+  ${"".padEnd(width + 2)}${tools}${model} \xB7 ${a.shown}`;
+    })
+  ].join("\n");
+}
+async function lookup(runtime, renderer, command, arg) {
+  if (command !== "/map" && arg === "") {
+    renderer.warn(`Usage: ${command} <symbol or file name>`);
+    return;
+  }
+  const context = { knowledge: runtime.knowledge };
+  try {
+    let text;
+    if (command === "/where" || command === "/defs") {
+      text = findSymbolText(await findSymbolTool.run({ name: arg, exact: true }, context));
+    } else if (command === "/refs") {
+      text = referencesText(await findReferencesTool.run({ name: arg }, context));
+    } else if (command === "/callers") {
+      text = callersText(await findCallersTool.run({ name: arg }, context));
+    } else if (command === "/impact") {
+      text = impactAnalysisText(await impactAnalysisTool.run({ target: arg }, context));
+    } else {
+      text = repoMapText(await repoMapTool.run({ path: arg }, context));
+    }
+    renderer.info(text);
+  } catch (error) {
+    renderer.error(error.message);
+  }
+}
+async function languagesCommand(runtime, renderer) {
+  const statuses = await runtime.knowledge.languageStatuses();
+  if (statuses.length === 0) {
+    renderer.info("No language plugins registered.");
+    return;
+  }
+  const lines = ["Language plugins:"];
+  for (const s of statuses) {
+    const extStr = s.extensions.join(", ");
+    const stateStr = s.active ? `${s.indexedFiles} file(s) indexed` : "standby (no matching files)";
+    const sourceBadge = s.source === "built-in" ? "built-in" : `${s.source} plugin`;
+    lines.push(`  \u2022 ${s.id} (${sourceBadge}): ${extStr} \u2014 ${stateStr}`);
+  }
+  const warnings = runtime.knowledge.getWarnings();
+  if (warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const w of warnings) {
+      lines.push(`  \u26A0 ${w}`);
+    }
+  }
+  renderer.info(lines.join("\n"));
+}
+async function expertsCommand(runtime, renderer) {
+  const statuses = await runtime.knowledge.languageStatuses();
+  const lines = ["Mixture-of-Experts (MoE) Language Specialists:"];
+  const specialistEntries = Object.values(SPECIALIST_SPECS);
+  for (const spec of specialistEntries) {
+    const status = statuses.find((s) => s.id === spec.id);
+    const active = status?.active ?? false;
+    const count = status?.indexedFiles ?? 0;
+    const badge = active ? `${count} file(s) active` : "standby";
+    lines.push(`  \u2022 ${spec.name} (${spec.id}): ${badge}`);
+    lines.push(`    test command: ${spec.testCommand}`);
+  }
+  renderer.info(lines.join("\n"));
+}
+async function auditCommand(runtime, renderer, arg) {
+  const policy = runtime.teamPolicy;
+  const lines = [];
+  if (policy === void 0) {
+    lines.push("Team Policy: none (no managed policy file and no ~/.garuda/policy.json)");
+  } else {
+    const from = runtime.teamPolicySources;
+    lines.push(
+      `Team Policy: active (${from.length === 0 ? "given by the caller" : from.join(", ")})`
+    );
+    if (policy.requireSandbox === true) {
+      lines.push("  \u2022 Require Sandbox: enabled (all bash commands must run sandboxed)");
+    }
+    if (policy.disallowedCommands && policy.disallowedCommands.length > 0) {
+      const sample = policy.disallowedCommands.slice(0, 3).join(", ");
+      const extra = policy.disallowedCommands.length > 3 ? "\u2026" : "";
+      lines.push(
+        `  \u2022 Disallowed Commands: ${policy.disallowedCommands.length} pattern(s) (${sample}${extra})`
+      );
+    }
+    if (policy.denyPaths && policy.denyPaths.length > 0) {
+      const sample = policy.denyPaths.slice(0, 3).join(", ");
+      const extra = policy.denyPaths.length > 3 ? "\u2026" : "";
+      lines.push(`  \u2022 Deny Paths: ${policy.denyPaths.length} pattern(s) (${sample}${extra})`);
+    }
+    if (policy.allowedModels && policy.allowedModels.length > 0) {
+      lines.push(`  \u2022 Allowed Models: ${policy.allowedModels.join(", ")}`);
+    }
+    if (policy.network?.blockedHosts && policy.network.blockedHosts.length > 0) {
+      lines.push(`  \u2022 Blocked Hosts: ${policy.network.blockedHosts.join(", ")}`);
+    }
+    if (policy.network?.strictAllowlist === true) {
+      lines.push("  \u2022 Network: strict allowlist enforced (no interactive exceptions)");
+    }
+  }
+  if (arg === "verify") {
+    const files = await runtime.audit.files();
+    lines.push("", `Audit files: ${runtime.audit.dir}`);
+    if (files.length === 0) lines.push("  none yet");
+    let broken = 0;
+    for (const file of files) {
+      const result = await verifyAuditFile(file);
+      const name = file.slice(runtime.audit.dir.length + 1);
+      if (result.ok) {
+        lines.push(`  ok      ${name} (${result.lines} lines)`);
+      } else {
+        broken++;
+        lines.push(`  BROKEN  ${name}: line ${result.line}: ${result.why}`);
+      }
+    }
+    if (broken > 0) lines.push(`${broken} file(s) were changed after Garuda wrote them.`);
+    lines.push("This check cannot see lines cut from the end of a file, or a removed file.");
+    renderer.info(lines.join("\n"));
+    return;
+  }
+  if (arg === "stats") {
+    const stats = await runtime.audit.getStats();
+    lines.push("");
+    lines.push("Audit Statistics:");
+    lines.push(`  Total Events:      ${stats.total}`);
+    lines.push(`  Allowed:           ${stats.allowed}`);
+    lines.push(`  Denied / Blocked:  ${stats.denied}`);
+    lines.push(`  Policy Blocks:     ${stats.policyBlocked}`);
+    lines.push(`  Critical Risk:     ${stats.criticalCount}`);
+    renderer.info(lines.join("\n"));
+    return;
+  }
+  const isDenials = arg === "denials";
+  const limit = /^\d+$/.test(arg) ? Number.parseInt(arg, 10) : 10;
+  const events = await runtime.audit.readEvents({
+    limit,
+    ...isDenials ? { denialsOnly: true } : {}
+  });
+  lines.push("");
+  if (events.length === 0) {
+    lines.push(
+      isDenials ? "No denied or blocked audit events found." : "No audit events recorded yet."
+    );
+  } else {
+    lines.push(
+      isDenials ? `Recent Security Denials / Policy Blocks (last ${events.length}):` : `Recent Audit Events (last ${events.length}):`
+    );
+    for (const e of events) {
+      const time = e.timestamp.slice(11, 19);
+      const badge = e.decision === "deny_policy" ? "BLOCK" : !e.allowed ? "DENY " : e.isError ? "ERROR" : "ALLOW";
+      const targetStr = e.target ? ` \xB7 ${e.target}` : "";
+      const reasonStr = e.reason ? ` (${e.reason})` : "";
+      const durStr = e.durationMs !== void 0 ? ` [${e.durationMs}ms]` : "";
+      lines.push(`  [${time}] ${badge} (${e.risk}) ${e.tool}${targetStr}${durStr}${reasonStr}`);
+    }
+  }
+  renderer.info(lines.join("\n"));
+}
+function usageSummary(runtime) {
+  const session = runtime.session;
+  if (session === void 0) return "No session yet.";
+  const u = session.usage;
+  const cost = session.costUsd === void 0 ? "cost unknown" : `$${session.costUsd.toFixed(4)}`;
+  return [
+    `Session ${session.id}: ${formatTokens(totalTokens(u))} tokens, ${cost}`,
+    `  input ${formatTokens(u.inputTokens)}, cache read ${formatTokens(u.cacheReadTokens)}, cache write ${formatTokens(u.cacheWriteTokens)}, output ${formatTokens(u.outputTokens)}`,
+    `  context ${formatTokens(session.contextTokens)} of ${formatTokens(runtime.limits.contextWindow)}`,
+    ...u.webSearches === void 0 ? [] : [
+      `  Claude web searches: ${u.webSearches} ($${(u.webSearches * WEB_SEARCH_USD).toFixed(2)})`
+    ]
+  ].join("\n");
+}
+function mcpSummary(runtime) {
+  const servers = runtime.mcpStatus();
+  if (servers.length === 0) {
+    return "No MCP servers are running. They start with the first task. Configure them in ~/.garuda/mcp.json or .garuda/mcp.json.";
+  }
+  return servers.map((s) => {
+    const note = s.message === void 0 ? "" : ` (${s.message})`;
+    if (s.transport === "http") {
+      const auth = s.signedIn ? "signed in" : "no sign-in";
+      return `${s.name} [${s.source}] ${s.state}${note} \xB7 ${s.tools} tool(s) \xB7 remote ${s.url ?? ""} \xB7 ${auth}`;
+    }
+    const box = s.sandboxed ? "sandbox" : "NO sandbox";
+    const net = s.network ? "network" : "no network";
+    return `${s.name} [${s.source}] ${s.state}${note} \xB7 ${s.tools} tool(s) \xB7 ${box} \xB7 ${net}`;
+  }).join("\n");
+}
+async function compactCommand(runtime, renderer, focus, signal) {
+  if (runtime.session === void 0) {
+    renderer.info("No session yet: there is nothing to compact.");
+    return;
+  }
+  let result;
+  try {
+    result = await runtime.compact(focus, signal);
+  } catch (error) {
+    renderer.warn(
+      signal.aborted ? "Compaction stopped. The conversation did not change." : `Compaction failed, and the conversation did not change: ${error.message}`
+    );
+    return;
+  }
+  if (result === void 0) {
+    renderer.info(
+      "Too little to compact: the last 4 steps always stay in full. Auto-compaction still runs when the context gets full."
+    );
+    return;
+  }
+  const cost = result.costUsd === void 0 ? "" : ` \xB7 $${result.costUsd.toFixed(4)}`;
+  renderer.info(
+    `Context compacted: ${formatTokens(result.beforeTokens)} \u2192 about ${formatTokens(result.afterTokens)} tokens${cost}. The last 4 steps stay in full; /usage shows the session totals.`
+  );
+}
+function detailsCommand(renderer, arg) {
+  if (renderer.details === void 0) {
+    renderer.info("This view always shows the details.");
+    return;
+  }
+  if (arg !== "" && arg !== "on" && arg !== "off") {
+    renderer.warn("Use: /details, /details on or /details off.");
+    return;
+  }
+  const on = arg === "" ? !renderer.details : arg === "on";
+  renderer.details = on;
+  renderer.info(
+    on ? "Details on: each tool call shows its result line." : "Details off: tool calls show one line; a failed call still shows its result. In the full chat, Ctrl-O shows the last output in full. /details turns them on again."
+  );
+}
+var RUN_AT_ONCE = /* @__PURE__ */ new Set([
+  "help",
+  "usage",
+  "session",
+  "hooks",
+  "languages",
+  "experts",
+  "audit",
+  "commands",
+  "agents",
+  "plan",
+  "build",
+  "undo",
+  "redo",
+  "init",
+  "editor",
+  "details",
+  "new",
+  "exit"
+]);
+function paletteEntries(runtime) {
+  const builtins = [...HELP.matchAll(/^ {2}\/([a-z]+)(?: (?:X|\[dir\]))?\s+(.+)$/gm)].map((m) => ({
+    name: m[1] ?? "",
+    hint: m[2] ?? "",
+    runs: RUN_AT_ONCE.has(m[1] ?? "")
+  }));
+  const custom = runtime.commands.map((c) => ({
+    name: c.name,
+    hint: c.description ?? "custom command",
+    runs: false
+  }));
+  const skills = runtime.skills.filter((s) => s.userInvocable).map((s) => ({ name: s.name, hint: `skill: ${s.description}`, runs: false }));
+  return [...builtins, ...custom, ...skills];
+}
+
+// src/cli/chat/complete.ts
+import { readdirSync, statSync } from "fs";
+import { join, relative, resolve, sep } from "path";
+var MAX_CANDIDATES = 30;
+function complete(text, cursor, sources) {
+  const before = text.slice(0, cursor);
+  const start = before.search(/\S*$/);
+  const word = before.slice(start);
+  if (word.startsWith("/") && start === 0) {
+    return apply(text, cursor, start, "/", word.slice(1), sources.commands, " ");
+  }
+  if (word.startsWith("@")) {
+    const path = word.slice(1);
+    const cut = path.lastIndexOf("/") + 1;
+    const folder = path.slice(0, cut);
+    const prefix = path.slice(cut);
+    const entries = sources.list(folder, prefix.startsWith("."));
+    const exact = apply(text, cursor, start, `@${folder}`, prefix, entries, "");
+    if (exact !== void 0 || sources.files === void 0 || path === "") return exact;
+    const found = fuzzyFiles(path, sources.files(), MAX_FUZZY);
+    if (found.length === 0) return void 0;
+    if (found.length === 1) {
+      const insert = `@${found[0]}`;
+      return {
+        text: text.slice(0, start) + insert + text.slice(cursor),
+        cursor: start + insert.length,
+        candidates: []
+      };
+    }
+    return { text, cursor, candidates: found.map((f) => `@${f}`), lines: true };
+  }
+  if (before.startsWith("/") && start > 0 && sources.args !== void 0) {
+    const [head = "", ...rest] = before.slice(0, start).trim().split(/\s+/);
+    const choices = sources.args(head.slice(1), rest);
+    if (choices.length === 0) return void 0;
+    const hints = new Map(choices.map((c) => [c.value, c.hint]));
+    const result = apply(
+      text,
+      cursor,
+      start,
+      "",
+      word,
+      choices.map((c) => c.value),
+      " "
+    );
+    if (result === void 0 || result.candidates.length === 0 || hints.size === 0) return result;
+    if (![...hints.values()].some((h) => h !== void 0 && h !== "")) return result;
+    return {
+      ...result,
+      lines: true,
+      candidates: result.candidates.map((c) => {
+        const hint = hints.get(c);
+        return hint === void 0 || hint === "" ? c : `${c}  ${hint}`;
+      })
+    };
+  }
+  return void 0;
+}
+function apply(text, cursor, start, lead, prefix, options, after) {
+  const matches = [...new Set(options.filter((o) => o.startsWith(prefix)))].sort();
+  if (matches.length === 0) return void 0;
+  const common = commonStart(matches);
+  const done = matches.length === 1 && !common.endsWith("/");
+  const insert = `${lead}${common}${done ? after : ""}`;
+  const next = text.slice(0, start) + insert + text.slice(cursor);
+  return {
+    text: next,
+    cursor: start + insert.length,
+    candidates: matches.length === 1 ? [] : [
+      ...matches.slice(0, MAX_CANDIDATES).map((m) => `${lead}${m}`),
+      ...matches.length > MAX_CANDIDATES ? [`\u2026 ${matches.length - MAX_CANDIDATES} more`] : []
+    ]
+  };
+}
+function commonStart(words) {
+  let out = words[0] ?? "";
+  for (const w of words) {
+    let i = 0;
+    while (i < out.length && i < w.length && out[i] === w[i]) i++;
+    out = out.slice(0, i);
+  }
+  return out;
+}
+function rootLister(root) {
+  return (folder, withHidden) => {
+    const dir = resolve(root, folder === "" ? "." : folder);
+    if (dir !== root && !dir.startsWith(`${root}${sep}`)) return [];
+    try {
+      return readdirSync(dir).filter((n) => n !== ".git" && n !== "node_modules" && (withHidden || !n.startsWith("."))).slice(0, 2e3).map((n) => {
+        try {
+          return statSync(join(dir, n)).isDirectory() ? `${n}/` : n;
+        } catch {
+          return n;
+        }
+      });
+    } catch {
+      return [];
+    }
+  };
+}
+var MAX_FUZZY = 10;
+function fuzzyFiles(query, files, max) {
+  const q = query.toLowerCase();
+  const scored = [];
+  for (const file of files) {
+    const score = fuzzyScore(q, file);
+    if (score !== void 0) scored.push({ file, score });
+  }
+  return scored.sort(
+    (a, b) => b.score - a.score || a.file.length - b.file.length || (a.file < b.file ? -1 : 1)
+  ).slice(0, max).map((s) => s.file);
+}
+function fuzzyScore(query, file) {
+  const path = file.toLowerCase();
+  const nameStart = path.lastIndexOf("/") + 1;
+  const inName = match(query, path, nameStart);
+  if (inName !== void 0) {
+    const startsName = path[nameStart] === query[0] ? 8 : 0;
+    return inName.score + 20 + startsName - (path.length - nameStart) / 10;
+  }
+  return match(query, path, 0)?.score;
+}
+function match(query, path, from) {
+  let score = 0;
+  let at = from;
+  let last = -1;
+  for (const ch of query) {
+    const i = path.indexOf(ch, at);
+    if (i === -1) return void 0;
+    score += 1;
+    if (last >= 0) score += i === last + 1 ? 5 : -Math.min(i - last - 1, 10);
+    const prev = path[i - 1];
+    if (i === 0 || prev === "/" || prev === "-" || prev === "_" || prev === ".") score += 3;
+    last = i;
+    at = i + 1;
+  }
+  return { score };
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".garuda",
+  "dist",
+  "build",
+  "target",
+  ".venv",
+  "venv",
+  "__pycache__"
+]);
+var MAX_FILES = 2e4;
+var FILES_TTL_MS = 1e4;
+function rootFiles(root, now = Date.now) {
+  let cache;
+  return () => {
+    if (cache !== void 0 && now() - cache.at < FILES_TTL_MS) return cache.files;
+    const files = [];
+    const walk = (dir) => {
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (files.length >= MAX_FILES) return;
+        if (entry.name.startsWith(".")) continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS.has(entry.name)) walk(full);
+        } else if (entry.isFile()) {
+          files.push(relative(root, full).split(sep).join("/"));
+        }
+      }
+    };
+    walk(root);
+    cache = { at: now(), files };
+    return files;
+  };
+}
+
+// src/cli/chat/controller.ts
+async function runChat(runtime, store, sessionPath, exitNow, notifier) {
+  store.onToggleMode = () => {
+    runtime.setMode(runtime.mode === "plan" ? "build" : "plan");
+    return statusOf(runtime);
+  };
+  const list = rootLister(runtime.root);
+  const args = new CommandArgs(runtime);
+  const files = rootFiles(runtime.root);
+  store.paletteSource = () => paletteEntries(runtime);
+  store.completer = (text, cursor) => complete(text, cursor, {
+    commands: commandNames(runtime),
+    list,
+    args: (command, before) => args.choices(command, before),
+    files
+  });
+  for (; ; ) {
+    void args.refresh();
+    const input = await store.nextInput();
+    if (input === void 0) return;
+    const text = input.trim();
+    let prompt = text;
+    if (text.startsWith("!") && text.length > 1) {
+      await runShell(runtime, store, text.slice(1).trim());
+      continue;
+    }
+    if (text === "/editor") {
+      store.openEditor();
+      continue;
+    }
+    if (text.startsWith("/")) {
+      const slow = /^\/compact(\s|$)/.test(text);
+      const controller = new AbortController();
+      if (slow) {
+        store.begin(text);
+        store.onInterrupt = () => controller.abort();
+      } else store.echo(text);
+      let result;
+      try {
+        result = await runCommand(text, {
+          runtime,
+          renderer: store,
+          sessionPath,
+          output: (shown, full) => {
+            store.print(shown);
+            if (full !== void 0) store.keepOutput(full.title, full.text);
+          },
+          signal: controller.signal
+        });
+      } catch (error) {
+        result = "done";
+        if (!controller.signal.aborted) store.error(describeError(error));
+      } finally {
+        if (slow) {
+          store.onInterrupt = () => {
+          };
+          store.end(statusOf(runtime));
+        }
+      }
+      store.refreshStatus(statusOf(runtime));
+      if (result === "exit") return;
+      if (result === "done") continue;
+      prompt = result.prompt;
+    }
+    let display = text;
+    for (; ; ) {
+      const planning = runtime.mode === "plan";
+      store.begin(display, prompt === display);
+      let outcome;
+      try {
+        outcome = await runTurnInTerminal(runtime, store, store, prompt, exitNow, notifier);
+      } finally {
+        store.end(statusOf(runtime));
+      }
+      if (!planning || outcome.kind !== "done" || outcome.result.stopReason !== "done") break;
+      const next = await planHandoff(runtime, store);
+      store.refreshStatus(statusOf(runtime));
+      if (next !== "now") break;
+      prompt = BUILD_PROMPT;
+      display = BUILD_PROMPT;
+    }
+  }
+}
+function commandNames(runtime) {
+  return [
+    ...BUILTIN_COMMANDS,
+    ...runtime.commands.map((c) => c.name),
+    ...runtime.skills.filter((s) => s.userInvocable).map((s) => s.name)
+  ];
+}
+async function runShell(runtime, store, command) {
+  const controller = new AbortController();
+  store.begin(`!${command}`);
+  store.onInterrupt = () => controller.abort();
+  try {
+    const result = await runtime.runUserCommand(command, controller.signal);
+    store.print(result.text);
+    store.info("The output goes to the model with your next message.");
+  } catch (error) {
+    store.warn(controller.signal.aborted ? "Command stopped." : error.message);
+  } finally {
+    store.onInterrupt = () => {
+    };
+    store.end(statusOf(runtime));
+  }
+}
+function statusOf(runtime) {
+  const session = runtime.session;
+  const status = {
+    model: runtime.modelId,
+    sandbox: runtime.executor.isolation === "none" ? "no sandbox" : `sandbox ${runtime.executor.name}`,
+    ...runtime.mode === "plan" ? { mode: "plan" } : {}
+  };
+  if (session !== void 0) {
+    status.contextPercent = Math.round(
+      session.contextTokens / runtime.limits.contextWindow * 100
+    );
+    if (session.costUsd !== void 0) status.costUsd = session.costUsd;
+  }
+  return status;
+}
+var CommandArgs = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  runtime;
+  sessions = [];
+  jobs = [];
+  async refresh() {
+    try {
+      const { sessions } = await this.runtime.listSessions();
+      this.sessions = sessions.map((s) => ({ value: s.id, hint: s.title }));
+      const jobs = await listJobs(this.runtime.root);
+      this.jobs = jobs.map((j) => ({ value: j.id, hint: `${j.status} \xB7 ${j.title}` }));
+    } catch {
+    }
+  }
+  choices(command, before) {
+    const words = (...w) => w.map((value) => ({ value }));
+    const [first, second] = before;
+    switch (command) {
+      case "models":
+        if (first !== void 0) return [];
+        return [
+          ...words("opus", "sonnet", "haiku", "fable"),
+          ...this.runtime.modelList().map((m) => ({ value: m.spec }))
+        ];
+      case "sessions":
+        if (first === void 0) return [...words("rename", "delete"), ...this.sessions];
+        return (first === "rename" || first === "delete") && second === void 0 ? this.sessions : [];
+      case "jobs":
+        if (first === void 0) return [...words("cancel", "delete"), ...this.jobs];
+        return (first === "cancel" || first === "delete") && second === void 0 ? this.jobs : [];
+      case "diff":
+        return first === void 0 ? words("last") : [];
+      case "mcp":
+        if (first === void 0) return words("logout");
+        return first === "logout" && second === void 0 ? this.runtime.mcpStatus().map((s) => ({ value: s.name })) : [];
+      case "details":
+        return first === void 0 ? words("on", "off") : [];
+      case "thinking":
+        return first === void 0 ? words(...THINKING_WORDS) : [];
+      case "search":
+        if (first === void 0) return words("claude", "provider", "off", "default");
+        return first === "default" && second === void 0 ? words("claude", "provider", "off") : [];
+      case "lsp":
+        if (first === void 0) return words("install");
+        return first === "install" && second === void 0 ? words(...LSP_LANGUAGES) : [];
+      default:
+        return [];
+    }
+  }
+};
+
+export {
+  describeError,
+  FOCUS_REPORTING_ON,
+  FOCUS_REPORTING_OFF,
+  reportsFocus,
+  FocusTracker,
+  focusEvent,
+  formatTokens,
+  stopMessage,
+  BUILD_PROMPT,
+  planHandoff,
+  runCommand,
+  complete,
+  rootLister,
+  fuzzyFiles,
+  rootFiles,
+  runTurnInTerminal,
+  runChat,
+  commandNames,
+  statusOf,
+  CommandArgs
+};
+//# sourceMappingURL=chunk-PQNT34LY.js.map