autopilot-ai 1.24.2 → 1.25.0

package/dist/index.js

@@ -102,8 +102,8 @@ async function flushAndCloseForTesting() {
   const s = currentStream;
   currentStream = null;
   currentDate = null;
-  await new Promise((resolve19) => {
-    s.end(() => resolve19());
+  await new Promise((resolve20) => {
+    s.end(() => resolve20());
   });
 }
 function isLogSinkEnabled() {
@@ -1342,10 +1342,10 @@ async function* readSSE(stream, signal, idleTimeoutMs, postFirstByteIdleTimeoutM
       gotFirstByte = true;
       buffer += decoder.decode(value, { stream: true });
       buffer = buffer.replace(/\r\n/g, "\n");
-      let sep7;
-      while ((sep7 = buffer.indexOf("\n\n")) !== -1) {
-        const event = buffer.slice(0, sep7);
-        buffer = buffer.slice(sep7 + 2);
+      let sep8;
+      while ((sep8 = buffer.indexOf("\n\n")) !== -1) {
+        const event = buffer.slice(0, sep8);
+        buffer = buffer.slice(sep8 + 2);
         const data = extractData(event);
         if (data !== null) yield data;
       }
@@ -2782,7 +2782,8 @@ async function* parseStream(body, signal, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_M
       index: idx,
       id: buf.id,
       name: buf.name,
-      arguments: buf.args
+      arguments: buf.args,
+      finishReason
     };
   }
   yield { type: "done", finishReason, usage: lastUsage };
@@ -2850,11 +2851,11 @@ function extractApiError(parsed, rawText) {
   return null;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     if (signal?.aborted) return reject(new DOMException("aborted", "AbortError"));
     const t = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve19();
+      resolve20();
     }, ms);
     const onAbort = () => {
       clearTimeout(t);
@@ -3608,9 +3609,9 @@ var require_node_gyp_build = __commonJS({
         var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
-      var prebuild = resolve19(dir);
+      var prebuild = resolve20(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve19(path.dirname(process.execPath));
+      var nearby = resolve20(path.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform8,
@@ -3626,7 +3627,7 @@ var require_node_gyp_build = __commonJS({
         // eslint-disable-line
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
-      function resolve19(dir2) {
+      function resolve20(dir2) {
         var tuples = readdirSync2(path.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform8, arch)).sort(compareTuples)[0];
         if (!tuple) return;
@@ -4047,7 +4048,7 @@ function truncateForEmbedding(text) {
   return text.slice(0, MAX_EMBED_CHARS);
 }
 async function sleep2(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 async function fetchWithRetry(url, init, retries = 3) {
   let lastError;
@@ -4699,6 +4700,8 @@ If the user asks what model you are, answer with exactly: \`${opts2.model}\`. Th
 - Today: ${date}`;
   const hasLsp = opts2.tools.some((t) => t.name.startsWith("lsp_"));
   const lspBlock = hasLsp ? "\n\nLSP tools are available for semantic code intelligence. Prefer `lsp_definition` over `grep` when looking for the source of a symbol. Prefer `lsp_references` over `grep` when finding usages. Use `lsp_hover` to confirm types before refactoring." : "";
+  const hasArtifactTool = opts2.tools.some((t) => t.name === "create_artifact");
+  const artifactGuidance = hasArtifactTool ? "\n\n## Choosing when to create an artifact\nUse `create_artifact` when the user would benefit from a visual, interactive, or polished standalone deliverable (for example, a dashboard, chart, diagram, prototype, or long structured report). Prefer a normal terminal response for brief answers, explanations, code snippets, and routine repository changes. For an artifact, first use `write` to save the complete HTML document as a local `.html` file in the workspace; then call `create_artifact` with a concise title and that file's workspace-relative `sourcePath`. Never put the full HTML document in `create_artifact` arguments. After it opens, summarize the result briefly in the terminal." : "";
   const tools = `Tools available:
 ${toolsBlock}`;
   const userShellBlock = userShellCommandsEnabled() ? `
@@ -4740,7 +4743,7 @@ ${opts2.lspContext}` : "";
 The following MCP server information was pre-computed by the coordinator.
 
 ${opts2.mcpContext}` : "";
-  return identity + "\n\n" + env2 + "\n\n" + tools + lspBlock + userShellBlock + contextBlock + modeBlock + skillsBlock + memoryBlock + lspContextBlock + mcpContextBlock;
+  return identity + "\n\n" + env2 + "\n\n" + tools + artifactGuidance + lspBlock + userShellBlock + contextBlock + modeBlock + skillsBlock + memoryBlock + lspContextBlock + mcpContextBlock;
 }
 function buildSystemPrompt(opts2) {
   return buildStaticPrefix(opts2) + "\n\n" + buildSessionPrefix(opts2);
@@ -5438,15 +5441,15 @@ async function gitNumstat(cwd, opts2 = {}) {
   if (opts2.includeUntracked) {
     try {
       const { stdout } = await execFileAsync("git", ["ls-files", "--others", "--exclude-standard"], { cwd, timeout: 5e3 });
-      const { readFile: readFile36, stat: stat13 } = await import("fs/promises");
-      const { join: join57 } = await import("path");
+      const { readFile: readFile37, stat: stat14 } = await import("fs/promises");
+      const { join: join58 } = await import("path");
       for (const file of stdout.split("\n").filter(Boolean)) {
         let lines = 0;
         try {
-          const path = join57(cwd, file);
-          const size = (await stat13(path)).size;
+          const path = join58(cwd, file);
+          const size = (await stat14(path)).size;
           if (size > 0 && size <= 1024 * 1024) {
-            const text = await readFile36(path, "utf8");
+            const text = await readFile37(path, "utf8");
             lines = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
           }
         } catch {
@@ -6048,11 +6051,11 @@ Not in this API \u2014 call these as separate tools instead: ${directTools.map((
           opts2.callbacks.onToolCallArgs?.(ev.index, ev.argsDelta);
           break;
         case "tool_call_complete": {
-          const safeArgs = validateToolArguments(ev.arguments);
+          const callArgs = validateToolArguments(ev.arguments, ev.name, ev.id, ev.finishReason, opts2.sessionId);
           const call = {
             id: ev.id,
             type: "function",
-            function: { name: normalizeToolName(ev.name, opts2.tools), arguments: safeArgs }
+            function: { name: normalizeToolName(ev.name, opts2.tools), arguments: callArgs }
           };
           toolCalls.push(call);
           tr.toolsUsed.push(call.function.name);
@@ -6901,14 +6904,29 @@ function replaceMessagesInPlace(target, next) {
 function normalizeToolName(name, tools) {
   return name === "spawn_worker" && tools.some((t) => t.name === "subagent") ? "subagent" : name;
 }
-function validateToolArguments(raw) {
-  if (!raw || !raw.trim()) return "{}";
-  try {
-    JSON.parse(raw);
-    return raw;
-  } catch {
-    return "{}";
+function validateToolArguments(raw, name, id, finishReason, sessionId) {
+  let issue = null;
+  if (!raw.trim()) {
+    issue = "empty arguments";
+  } else {
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) issue = "arguments must be a JSON object";
+    } catch (error) {
+      issue = error instanceof Error ? error.message : "invalid JSON";
+    }
+  }
+  if (issue) {
+    logger.warn("turn:tool_arguments_invalid", {
+      sessionId,
+      tool: name,
+      toolCallId: id,
+      argumentBytes: Buffer.byteLength(raw, "utf8"),
+      finishReason,
+      issue
+    });
   }
+  return raw;
 }
 function llmAuthOf(opts2) {
   return {
@@ -7813,15 +7831,15 @@ function makeErrorOutput(message2) {
   return { content: message2, rawBytes: bytes, reducedBytes: bytes };
 }
 async function execOnce(command, cwd) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const child = spawn("bash", ["-lc", command], { cwd });
     let out = "";
     child.stdout.on("data", (d) => {
       out += d.toString("utf8");
     });
     child.on("close", (code) => {
-      if (code !== 0) return resolve19(void 0);
-      resolve19(out.trim() || void 0);
+      if (code !== 0) return resolve20(void 0);
+      resolve20(out.trim() || void 0);
     });
   });
 }
@@ -7975,7 +7993,7 @@ async function runBash(args, ctx) {
   if (pushGuard) return pushGuard;
   const { shell, args: shellArgs, isPosix } = getShellCommand(ctx.shell);
   const { command, env: coauthorEnv } = isPosix ? injectCoauthor(args.command, ctx.coauthor) : { command: args.command, env: {} };
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     logger.debug("bash:spawn", { command: args.command.slice(0, 200), cwd: ctx.cwd, shell });
     const child = spawn(shell, [...shellArgs, command], {
       cwd: ctx.cwd,
@@ -8040,7 +8058,7 @@ ${stderr}`
         if (hint) parts.push(hint);
       }
       const raw = parts.join("\n");
-      resolve19({
+      resolve20({
         content: raw,
         rawBytes: Buffer.byteLength(raw, "utf8"),
         reducedBytes: Buffer.byteLength(raw, "utf8"),
@@ -9438,7 +9456,7 @@ import { tmpdir as tmpdir2 } from "os";
 import { join as join19, dirname as dirname8 } from "path";
 async function autoScroll(page) {
   await page.evaluate(async () => {
-    await new Promise((resolve19) => {
+    await new Promise((resolve20) => {
       let totalHeight = 0;
       const distance = 300;
       const timer3 = setInterval(() => {
@@ -9447,12 +9465,12 @@ async function autoScroll(page) {
         totalHeight += distance;
         if (totalHeight >= scrollHeight) {
           clearInterval(timer3);
-          resolve19();
+          resolve20();
         }
       }, 100);
       setTimeout(() => {
         clearInterval(timer3);
-        resolve19();
+        resolve20();
       }, 1e4);
     });
   });
@@ -9551,6 +9569,288 @@ var init_browser = __esm({
   }
 });
 
+// src/util/open-browser.ts
+import { spawn as spawn2 } from "child_process";
+import { platform as platform3 } from "os";
+function openBrowser(url) {
+  if (process.env.KIMIFLARE_NO_BROWSER === "1" || process.env.BROWSER === "none") return false;
+  try {
+    const os2 = platform3();
+    const [cmd, args] = os2 === "darwin" ? ["open", [url]] : os2 === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+    const child = spawn2(cmd, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => void 0);
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_open_browser = __esm({
+  "src/util/open-browser.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/html-artifact.ts
+import { chmod as chmod2, lstat as lstat2, mkdir as mkdir9, mkdtemp, readFile as readFile11, readdir as readdir4, realpath as realpath2, rm as rm2, stat as stat5, writeFile as writeFile10 } from "fs/promises";
+import { execFileSync } from "child_process";
+import { tmpdir as tmpdir3 } from "os";
+import { isAbsolute as isAbsolute2, join as join20, relative as relative3, resolve as resolve3, sep as sep2 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function createHtmlArtifactFromFile(args, cwd, options = {}) {
+  assertArtifactSourceArgs(args);
+  const workspaceRoot = await getWorkspaceRoot(cwd);
+  const workspaceReal = await realpath2(workspaceRoot);
+  const inputPath = resolvePath(cwd, args.sourcePath);
+  let inputReal;
+  try {
+    inputReal = await realpath2(inputPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ToolError({
+        code: "not_found",
+        message: `Artifact source file not found: ${args.sourcePath}`,
+        suggestion: "Use the write tool to create the complete HTML file first, then pass its path as sourcePath."
+      });
+    }
+    throw error;
+  }
+  if (!isWithin(workspaceReal, inputReal)) {
+    throw new ToolError({
+      code: "policy_rejection",
+      message: "Artifact sourcePath must resolve to a file inside the current workspace.",
+      suggestion: "Write the HTML file inside the workspace and retry with its workspace-relative path."
+    });
+  }
+  const info = await stat5(inputReal);
+  if (!info.isFile()) {
+    throw new ToolError({ code: "invalid_args", message: "Artifact sourcePath must be a regular HTML file." });
+  }
+  if (info.size > MAX_ARTIFACT_HTML_LENGTH * 4) {
+    throw new ToolError({ code: "invalid_args", message: `Artifact HTML exceeds ${MAX_ARTIFACT_HTML_LENGTH} characters.` });
+  }
+  const html = await readFile11(inputReal, "utf8");
+  return createHtmlArtifact({ title: args.title, html }, cwd, options);
+}
+async function createHtmlArtifact(args, cwd, options = {}) {
+  assertArtifactHtmlArgs(args);
+  const rootDir = options.rootDir ?? join20(tmpdir3(), ARTIFACT_ROOT);
+  const workspaceRoot = await getWorkspaceRoot(cwd);
+  const workspaceReal = await realpath2(workspaceRoot);
+  if (isWithin(workspaceReal, resolve3(rootDir))) {
+    throw new Error("Refusing to store an artifact inside the workspace: " + rootDir);
+  }
+  await ensureSecureRoot(rootDir);
+  const rootReal = await realpath2(rootDir);
+  if (isWithin(workspaceReal, rootReal)) {
+    throw new Error("Refusing to store an artifact inside the workspace: " + rootReal);
+  }
+  await cleanupOldArtifacts(rootDir, (options.now ?? Date.now)());
+  const artifactDir = await mkdtemp(join20(rootDir, ARTIFACT_PREFIX));
+  await chmod2(artifactDir, 448);
+  const filePath = join20(artifactDir, "index.html");
+  await writeFile10(filePath, buildArtifactHtml(args.title, args.html), {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  const opened = (options.open ?? openBrowser)(pathToFileURL2(filePath).href);
+  const status = opened ? "Opened in your browser." : "Could not open a browser automatically.";
+  return "Artifact: " + args.title + "\n" + status + "\nTemporary file: " + filePath;
+}
+async function cleanupOldArtifacts(rootDir, now2 = Date.now()) {
+  let entries;
+  try {
+    entries = await readdir4(rootDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.name.startsWith(ARTIFACT_PREFIX) || !entry.isDirectory() || entry.isSymbolicLink()) continue;
+    const path = join20(rootDir, entry.name);
+    try {
+      const info = await lstat2(path);
+      if (!info.isDirectory() || info.isSymbolicLink() || now2 - info.mtimeMs < ARTIFACT_MAX_AGE_MS) continue;
+      await rm2(path, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function buildArtifactHtml(title, html) {
+  assertArtifactHtmlArgs({ title, html });
+  const safeTitle = escapeHtml(title);
+  const safeSrcdoc = escapeAttribute(html);
+  const lines = [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '  <meta charset="utf-8">',
+    '  <meta name="viewport" content="width=device-width, initial-scale=1">',
+    '  <meta name="theme-color" content="#090909">',
+    "  <title>" + safeTitle + " \xB7 Autopilot</title>",
+    "  <style>",
+    '    :root { color-scheme: dark; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }',
+    "    * { box-sizing: border-box; }",
+    "    html, body { width: 100%; height: 100%; margin: 0; }",
+    "    body { display: grid; grid-template-rows: auto minmax(0, 1fr); overflow: hidden; background: #090909; color: #f4f4f5; }",
+    "    .autopilot-bar { position: sticky; top: 0; z-index: 10; display: flex; min-height: 54px; align-items: center; justify-content: space-between; gap: 16px; padding: 0 22px; border-bottom: 1px solid #262626; background: rgba(9, 9, 9, .96); backdrop-filter: blur(12px); }",
+    "    .autopilot-brand { display: inline-flex; align-items: center; gap: 9px; color: #f5f5f5; font-size: 14px; font-weight: 650; letter-spacing: -.025em; text-decoration: none; }",
+    "    .autopilot-mark { width: 20px; height: 20px; flex: none; }",
+    "    .autopilot-actions { display: flex; align-items: center; gap: 16px; }",
+    "    .autopilot-actions a { color: #a3a3a3; font-size: 12px; text-decoration: none; transition: color .15s ease; }",
+    "    .autopilot-actions a:hover { color: #fff; }",
+    "    .autopilot-actions .star { padding: 7px 11px; border: 1px solid #343434; border-radius: 7px; color: #f0f0f0; }",
+    "    .autopilot-actions .star:hover { border-color: #ff9933; color: #ffb15c; }",
+    "    main { min-width: 0; min-height: 0; }",
+    "    iframe { display: block; width: 100%; height: 100%; border: 0; background: #fff; }",
+    "    @media (max-width: 520px) { .autopilot-bar { min-height: 48px; padding: 0 14px; } .autopilot-actions { gap: 10px; } .autopilot-actions a { font-size: 11px; } }",
+    "  </style>",
+    "</head>",
+    "<body>",
+    '  <header class="autopilot-bar">',
+    '    <a class="autopilot-brand" href="' + AUTOPILOT_URL + '" target="_blank" rel="noopener noreferrer" aria-label="Autopilot on GitHub">',
+    '      <svg class="autopilot-mark" viewBox="0 0 24 24" role="img" aria-label="Autopilot logo" xmlns="http://www.w3.org/2000/svg">',
+    '        <path fill="#ff9933" d="M12 1.8a10.2 10.2 0 1 0 10.2 10.2A10.21 10.21 0 0 0 12 1.8Zm0 2.3a7.9 7.9 0 1 1 0 15.8 7.9 7.9 0 0 1 0-15.8Z"/>',
+    '        <path fill="#ff9933" d="m6.9 16.8 4.3-9.6c.3-.7 1.3-.7 1.6 0l4.3 9.6h-2.5l-2.6-6-2.6 6H6.9Z"/>',
+    "      </svg>",
+    "      <span>autopilot</span>",
+    "    </a>",
+    '    <nav class="autopilot-actions" aria-label="Autopilot links">',
+    '      <a href="' + AUTOPILOT_URL + '" target="_blank" rel="noopener noreferrer">About Autopilot \u2197</a>',
+    '      <a class="star" href="' + AUTOPILOT_URL + '" target="_blank" rel="noopener noreferrer" aria-label="Star Autopilot on GitHub">\u2606 Star on GitHub</a>',
+    "    </nav>",
+    "  </header>",
+    '  <main><iframe title="' + escapeAttribute(title) + '" sandbox="allow-scripts" srcdoc="' + safeSrcdoc + '"></iframe></main>',
+    "</body>",
+    "</html>"
+  ];
+  return lines.join("\n") + "\n";
+}
+function assertArtifactSourceArgs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ToolError({
+      code: "invalid_args",
+      recoverable: true,
+      message: "Invalid create_artifact arguments: expected an object with a title and sourcePath.",
+      suggestion: "Use write to save the complete HTML file in the workspace, then pass its path as sourcePath."
+    });
+  }
+  const args = value;
+  const issues = [];
+  if (typeof args.title !== "string" || args.title.trim().length === 0 || args.title.length > MAX_ARTIFACT_TITLE_LENGTH) {
+    issues.push(`title must be a non-empty string of at most ${MAX_ARTIFACT_TITLE_LENGTH} characters`);
+  }
+  if (typeof args.sourcePath !== "string" || args.sourcePath.trim().length === 0) {
+    issues.push("sourcePath must be a non-empty path to an HTML file created with write");
+  }
+  if (issues.length > 0) {
+    throw new ToolError({
+      code: "invalid_args",
+      recoverable: true,
+      message: `Invalid create_artifact arguments: ${issues.join("; ")}.`,
+      suggestion: "Use write to save the complete HTML file in the workspace, then call create_artifact with its title and sourcePath."
+    });
+  }
+}
+function assertArtifactHtmlArgs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ToolError({
+      code: "invalid_args",
+      recoverable: true,
+      message: "Invalid artifact content: expected an object with a title and HTML document.",
+      suggestion: "Provide a non-empty title and complete HTML content."
+    });
+  }
+  const args = value;
+  const issues = [];
+  if (typeof args.title !== "string" || args.title.trim().length === 0 || args.title.length > MAX_ARTIFACT_TITLE_LENGTH) {
+    issues.push(`title must be a non-empty string of at most ${MAX_ARTIFACT_TITLE_LENGTH} characters`);
+  }
+  if (typeof args.html !== "string" || args.html.trim().length === 0 || args.html.length > MAX_ARTIFACT_HTML_LENGTH) {
+    issues.push(`html must be a non-empty string of at most ${MAX_ARTIFACT_HTML_LENGTH} characters`);
+  }
+  if (issues.length > 0) {
+    throw new ToolError({
+      code: "invalid_args",
+      recoverable: true,
+      message: `Invalid artifact content: ${issues.join("; ")}.`,
+      suggestion: "Supply a non-empty title and complete HTML document."
+    });
+  }
+}
+async function ensureSecureRoot(rootDir) {
+  await mkdir9(rootDir, { recursive: true, mode: 448 });
+  const info = await lstat2(rootDir);
+  if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Artifact storage path is not a real directory: " + rootDir);
+  if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
+    throw new Error("Artifact storage directory is not owned by the current user: " + rootDir);
+  }
+  if ((info.mode & 63) !== 0) await chmod2(rootDir, 448);
+}
+async function getWorkspaceRoot(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return cwd;
+  }
+}
+function isWithin(parent, candidate) {
+  const rel = relative3(parent, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(".." + sep2) && !isAbsolute2(rel);
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttribute(value) {
+  return escapeHtml(value).replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+var ARTIFACT_ROOT, ARTIFACT_PREFIX, ARTIFACT_MAX_AGE_MS, AUTOPILOT_URL, MAX_ARTIFACT_TITLE_LENGTH, MAX_ARTIFACT_HTML_LENGTH, htmlArtifactTool;
+var init_html_artifact = __esm({
+  "src/tools/html-artifact.ts"() {
+    "use strict";
+    init_paths2();
+    init_open_browser();
+    init_tool_error();
+    ARTIFACT_ROOT = "autopilot-artifacts";
+    ARTIFACT_PREFIX = "artifact-";
+    ARTIFACT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+    AUTOPILOT_URL = "https://github.com/sinameraji/autopilot";
+    MAX_ARTIFACT_TITLE_LENGTH = 160;
+    MAX_ARTIFACT_HTML_LENGTH = 1e6;
+    htmlArtifactTool = {
+      name: "create_artifact",
+      description: "Open a polished standalone HTML artifact in the user's browser. First use the normal write tool to save the complete HTML document as a local .html file in the workspace. Then call create_artifact with its title and sourcePath; do not pass the full HTML as a tool argument. The source file is kept in the workspace, and a branded, sandboxed browser copy is stored outside the project. Use for visual or interactive deliverables, dashboards, diagrams, prototypes, and substantial structured reports\u2014not short answers, explanations, code snippets, or routine code changes.",
+      parameters: {
+        type: "object",
+        properties: {
+          title: {
+            type: "string",
+            description: "Non-empty, short human-readable artifact title."
+          },
+          sourcePath: {
+            type: "string",
+            description: "Workspace-relative path to the complete HTML file already created with the write tool."
+          }
+        },
+        required: ["title", "sourcePath"],
+        additionalProperties: false
+      },
+      needsPermission: true,
+      render: (args) => ({
+        title: "create artifact: " + String(args.title ?? "Missing title").slice(0, 80),
+        body: `Read ${String(args.sourcePath ?? "Missing sourcePath")} \xB7 opens in your browser`
+      }),
+      async run(args, ctx) {
+        return createHtmlArtifactFromFile(args, ctx.cwd);
+      }
+    };
+  }
+});
+
 // src/tools/tasks.ts
 var tasksSetTool;
 var init_tasks = __esm({
@@ -9766,9 +10066,9 @@ var init_memory = __esm({
 
 // src/tools/hotcell-snapshot.ts
 import { execFile as execFile4 } from "child_process";
-import { mkdtemp, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join20 } from "path";
+import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join21 } from "path";
 import { promisify as promisify4 } from "util";
 async function git(args, cwd, env2) {
   const { stdout } = await execFileAsync2("git", args, {
@@ -9816,9 +10116,9 @@ async function getRepositorySnapshot(cwd) {
   if (!ref) {
     throw new Error("Could not find an origin branch containing the base commit. Run git fetch, then retry.");
   }
-  const scratch = await mkdtemp(join20(tmpdir3(), "autopilot-snapshot-"));
+  const scratch = await mkdtemp2(join21(tmpdir4(), "autopilot-snapshot-"));
   try {
-    const env2 = { GIT_INDEX_FILE: join20(scratch, "index") };
+    const env2 = { GIT_INDEX_FILE: join21(scratch, "index") };
     await git(["read-tree", "HEAD"], root, env2);
     await git(["add", "-A", "--", ".", ...SECRET_EXCLUDES], root, env2);
     const tree = (await git(["write-tree"], root, env2)).trim();
@@ -9837,15 +10137,15 @@ async function getRepositorySnapshot(cwd) {
     }
     return { url, ref, commit, patch: patch.toString("base64"), changedFiles: names.length };
   } finally {
-    await rm2(scratch, { recursive: true, force: true });
+    await rm3(scratch, { recursive: true, force: true });
   }
 }
 async function getWorkingTreeArchive(cwd, limitBytes = MAX_ARCHIVE_BYTES) {
   const root = (await git(["rev-parse", "--show-toplevel"], cwd).catch(() => "")).trim();
   if (!root) throw new Error("Subagents need to run inside a Git repository.");
-  const scratch = await mkdtemp(join20(tmpdir3(), "autopilot-archive-"));
+  const scratch = await mkdtemp2(join21(tmpdir4(), "autopilot-archive-"));
   try {
-    const env2 = { GIT_INDEX_FILE: join20(scratch, "index") };
+    const env2 = { GIT_INDEX_FILE: join21(scratch, "index") };
     const hasHead = await git(["rev-parse", "--verify", "-q", "HEAD"], root).then(() => true, () => false);
     await git(hasHead ? ["read-tree", "HEAD"] : ["read-tree", "--empty"], root, env2);
     await git(["add", "-A", "--", ".", ...SECRET_EXCLUDES], root, env2);
@@ -9859,7 +10159,7 @@ async function getWorkingTreeArchive(cwd, limitBytes = MAX_ARCHIVE_BYTES) {
       bytes: tarball.byteLength
     };
   } finally {
-    await rm2(scratch, { recursive: true, force: true });
+    await rm3(scratch, { recursive: true, force: true });
   }
 }
 function chunkPayload(base64, chunkSize = PAYLOAD_CHUNK_CHARS) {
@@ -9893,23 +10193,23 @@ var init_hotcell_snapshot = __esm({
 });
 
 // src/tools/hotcell-worker-cache.ts
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname9, join as join21 } from "path";
+import { dirname as dirname9, join as join22 } from "path";
 function workerCachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join21(homedir11(), ".config");
-  return join21(xdg, "kimiflare", "hotcell-worker-cache.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join22(homedir11(), ".config");
+  return join22(xdg, "kimiflare", "hotcell-worker-cache.json");
 }
 async function readCache2() {
   try {
-    return JSON.parse(await readFile11(workerCachePath(), "utf8"));
+    return JSON.parse(await readFile12(workerCachePath(), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeCache2(cache) {
-  await mkdir9(dirname9(workerCachePath()), { recursive: true });
-  await writeFile10(workerCachePath(), JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
+  await mkdir10(dirname9(workerCachePath()), { recursive: true });
+  await writeFile11(workerCachePath(), JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
 }
 function ensureWorkerBackup(opts2) {
   const existing = inflight.get(opts2.packageSpec);
@@ -9969,13 +10269,13 @@ var init_hotcell_worker_cache = __esm({
 });
 
 // src/tools/hotcell-worker.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { execFile as execFile5 } from "child_process";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 async function runHotcellWorker(options) {
   const workerId = `hotcell-${crypto.randomUUID().slice(0, 8)}`;
-  const cwd = resolve3(options.cwd ?? process.cwd());
+  const cwd = resolve4(options.cwd ?? process.cwd());
   const model = options.model.trim();
   if (!model) throw new Error("Hotcell workers require the coordinator's explicit model ID.");
   validateModelId(model);
@@ -10283,7 +10583,7 @@ function parsePrintOutput(stdout) {
 async function runProcess(executable, args, options) {
   if (options.signal?.aborted) return { code: 130, stdout: "", stderr: "", aborted: true };
   return await new Promise((resolvePromise, reject) => {
-    const child = spawn2(executable, args, { cwd: options.cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn3(executable, args, { cwd: options.cwd, stdio: ["ignore", "pipe", "pipe"] });
     const stdout = [];
     const stderr = [];
     let bytes = 0;
@@ -10515,17 +10815,17 @@ var init_worker_registry = __esm({
 });
 
 // src/tools/subagent-stats.ts
-import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile12 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir11, readFile as readFile13 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname10, join as join22 } from "path";
+import { dirname as dirname10, join as join23 } from "path";
 function subagentStatsPath() {
-  const xdg = process.env.XDG_DATA_HOME || join22(homedir12(), ".local", "share");
-  return join22(xdg, "kimiflare", "subagents.jsonl");
+  const xdg = process.env.XDG_DATA_HOME || join23(homedir12(), ".local", "share");
+  return join23(xdg, "kimiflare", "subagents.jsonl");
 }
 async function recordSubagentEvent(event) {
   const path = subagentStatsPath();
   try {
-    await mkdir10(dirname10(path), { recursive: true });
+    await mkdir11(dirname10(path), { recursive: true });
     await appendFile2(path, JSON.stringify(event) + "\n");
   } catch (error) {
     logger.debug("subagents:stats_write_failed", { error: String(error) });
@@ -10545,7 +10845,7 @@ function failureReason(error) {
 async function readSubagentStats(days = 7, now2 = Date.now()) {
   let raw = "";
   try {
-    raw = await readFile12(subagentStatsPath(), "utf8");
+    raw = await readFile13(subagentStatsPath(), "utf8");
   } catch {
   }
   const since = now2 - days * 24 * 60 * 60 * 1e3;
@@ -11439,18 +11739,18 @@ var init_expand_artifact = __esm({
 
 // src/jobs/manager.ts
 import Database from "better-sqlite3";
-import { spawn as spawn3, execFileSync } from "child_process";
+import { spawn as spawn4, execFileSync as execFileSync2 } from "child_process";
 import { mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync4, readSync, existsSync as existsSync4, statSync as statSync3, closeSync, rmSync } from "fs";
 import { homedir as homedir13 } from "os";
-import { dirname as dirname11, join as join23 } from "path";
+import { dirname as dirname11, join as join24 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function defaultJobDbPath() {
-  const root = process.env.XDG_STATE_HOME || join23(homedir13(), ".local", "state");
-  return process.env.AUTOPILOT_JOBS_DB || join23(root, "autopilot", "jobs.db");
+  const root = process.env.XDG_STATE_HOME || join24(homedir13(), ".local", "state");
+  return process.env.AUTOPILOT_JOBS_DB || join24(root, "autopilot", "jobs.db");
 }
 function isProcessGroupAlive(pgid) {
   try {
-    const rows = execFileSync("ps", ["-axo", "pgid=,state="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const rows = execFileSync2("ps", ["-axo", "pgid=,state="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     return rows.split("\n").some((line) => {
       const match = line.trim().match(/^(\d+)\s+(\S+)/);
       return match?.[1] === String(pgid) && !match[2].startsWith("Z");
@@ -11476,22 +11776,22 @@ function waitForProcessStartTime(pid, jobId, exitPath) {
 function readProcessStartTime(pid) {
   if (process.platform === "linux") {
     try {
-      const stat13 = readFileSync4(`/proc/${pid}/stat`, "utf8");
-      const fieldsAfterCommand = stat13.slice(stat13.lastIndexOf(")") + 1).trim().split(/\s+/);
+      const stat14 = readFileSync4(`/proc/${pid}/stat`, "utf8");
+      const fieldsAfterCommand = stat14.slice(stat14.lastIndexOf(")") + 1).trim().split(/\s+/);
       return fieldsAfterCommand[19] ? `linux:${fieldsAfterCommand[19]}` : null;
     } catch {
       return null;
     }
   }
   try {
-    return execFileSync("ps", ["-o", "lstart=", "-o", "command=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+    return execFileSync2("ps", ["-o", "lstart=", "-o", "command=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
   } catch {
     return null;
   }
 }
 function isZombie(pid) {
   try {
-    const state = execFileSync("ps", ["-o", "state=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const state = execFileSync2("ps", ["-o", "state=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     return state.startsWith("Z");
   } catch {
     return true;
@@ -11590,7 +11890,7 @@ child.on('close', (code, signal) => {
       jobsDir;
       constructor(dbPath = defaultJobDbPath()) {
         mkdirSync5(dirname11(dbPath), { recursive: true, mode: 448 });
-        this.jobsDir = join23(dirname11(dbPath), "jobs");
+        this.jobsDir = join24(dirname11(dbPath), "jobs");
         mkdirSync5(this.jobsDir, { recursive: true, mode: 448 });
         this.db = new Database(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -11641,13 +11941,13 @@ child.on('close', (code, signal) => {
           if (existing) return toJobRecord(existing);
         }
         const id = randomUUID4();
-        const jobDir = join23(this.jobsDir, id);
+        const jobDir = join24(this.jobsDir, id);
         mkdirSync5(jobDir, { recursive: true, mode: 448 });
         const paths = {
-          stdoutPath: join23(jobDir, "stdout.log"),
-          stderrPath: join23(jobDir, "stderr.log"),
-          exitPath: join23(jobDir, "exit.json"),
-          pidPath: join23(jobDir, "pid")
+          stdoutPath: join24(jobDir, "stdout.log"),
+          stderrPath: join24(jobDir, "stderr.log"),
+          exitPath: join24(jobDir, "exit.json"),
+          pidPath: join24(jobDir, "pid")
         };
         const now2 = Date.now();
         try {
@@ -11671,7 +11971,7 @@ child.on('close', (code, signal) => {
           timeoutMs: options.timeoutMs ?? null,
           ...paths
         });
-        const child = spawn3(process.execPath, ["--input-type=module", "-e", JOB_WRAPPER, spec], {
+        const child = spawn4(process.execPath, ["--input-type=module", "-e", JOB_WRAPPER, spec], {
           cwd: options.cwd,
           detached: true,
           stdio: "ignore",
@@ -11928,10 +12228,10 @@ import Database2 from "better-sqlite3";
 import { createHash as createHash2, randomUUID as randomUUID5 } from "crypto";
 import { chmodSync, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir14 } from "os";
-import { dirname as dirname12, join as join24 } from "path";
+import { dirname as dirname12, join as join25 } from "path";
 function defaultRunsDbPath() {
-  const root = process.env.XDG_STATE_HOME || join24(homedir14(), ".local", "state");
-  return process.env.AUTOPILOT_RUNS_DB || join24(root, "autopilot", "runs.db");
+  const root = process.env.XDG_STATE_HOME || join25(homedir14(), ".local", "state");
+  return process.env.AUTOPILOT_RUNS_DB || join25(root, "autopilot", "runs.db");
 }
 function validateOptionalPositiveInteger(name, value, minimum = 1) {
   if (value !== null && (!Number.isSafeInteger(value) || value < minimum)) {
@@ -12541,8 +12841,8 @@ var init_wait_for = __esm({
 });
 
 // src/tools/executor.ts
-import { realpath as realpath2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolve4, sep as sep2 } from "path";
+import { realpath as realpath3 } from "fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve5, sep as sep3 } from "path";
 function getWorkerTools(profile) {
   return profile === "research" ? ALL_TOOLS.filter((tool) => RESEARCH_WORKER_TOOL_NAMES.has(tool.name) && tool.isReadOnly === true).map(restrictResearchTool) : ALL_TOOLS;
 }
@@ -12563,28 +12863,28 @@ function restrictResearchTool(tool) {
 }
 async function assertResearchPath(pathValue, cwd) {
   if (typeof pathValue !== "string" || !pathValue) throw new Error("Research worker paths must be non-empty strings.");
-  const root = await realpath2(cwd);
-  const candidate = resolve4(root, pathValue);
+  const root = await realpath3(cwd);
+  const candidate = resolve5(root, pathValue);
   assertInsideResearchRoot(candidate, root);
   assertNoSensitivePath(candidate, root);
-  const actual = await realpath2(candidate);
+  const actual = await realpath3(candidate);
   assertInsideResearchRoot(actual, root);
   assertNoSensitivePath(actual, root);
 }
 function assertInsideResearchRoot(path, root) {
-  const rel = relative3(root, path);
-  if (rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) {
+  const rel = relative4(root, path);
+  if (rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute3(rel)) {
     throw new Error("Research workers may only inspect paths inside their cloned repository.");
   }
 }
 function assertNoSensitivePath(path, root) {
-  const parts = relative3(root, path).split(sep2).filter(Boolean).map((part) => part.toLowerCase());
+  const parts = relative4(root, path).split(sep3).filter(Boolean).map((part) => part.toLowerCase());
   if (parts.some((part) => part === ".env" || part.startsWith(".env.") || SENSITIVE_RESEARCH_PATHS.has(part))) {
     throw new Error("Research worker access to environment, credential, and VCS metadata paths is blocked.");
   }
 }
 function assertSafePattern(value) {
-  if (typeof value !== "string" || !value || isAbsolute2(value)) {
+  if (typeof value !== "string" || !value || isAbsolute3(value)) {
     throw new Error("Research worker glob patterns must be relative to the repository.");
   }
   const parts = value.replaceAll("\\\\", "/").split("/");
@@ -12637,9 +12937,6 @@ function normalizeToolOutput(result2) {
   }
   return result2;
 }
-function truncateForError(s) {
-  return s.length <= 200 ? s : `${s.slice(0, 200)}... [${s.length - 200} more chars]`;
-}
 var ALL_TOOLS, RESEARCH_WORKER_TOOL_NAMES, SENSITIVE_RESEARCH_PATHS, HOOK_RESULT_CONTENT_CAP_BYTES, ToolExecutor, TRACE_ARGS_INLINE_MAX, ToolTrace;
 var init_executor = __esm({
   "src/tools/executor.ts"() {
@@ -12658,6 +12955,7 @@ var init_executor = __esm({
     init_github();
     init_changelog_image();
     init_browser();
+    init_html_artifact();
     init_tasks();
     init_memory();
     init_subagent();
@@ -12685,6 +12983,7 @@ var init_executor = __esm({
       githubCreatePrTool,
       { ...changelogImageTool, isReadOnly: true },
       { ...browserFetchTool, isReadOnly: true },
+      htmlArtifactTool,
       tasksSetTool,
       memoryRememberTool,
       { ...memoryRecallTool, isReadOnly: true },
@@ -12783,17 +13082,23 @@ var init_executor = __esm({
         }
         let args;
         try {
-          args = call.arguments.trim() ? JSON.parse(call.arguments) : {};
+          if (!call.arguments.trim()) throw new SyntaxError("tool arguments were empty");
+          const parsed = JSON.parse(call.arguments);
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new SyntaxError("tool arguments must be a JSON object");
+          }
+          args = parsed;
         } catch (e) {
           tr?.call(null, tool.needsPermission);
+          const artifactSuggestion = call.name === "create_artifact" ? "Use write to save the complete HTML document as a workspace .html file, then call create_artifact with its title and sourcePath." : "Retry with valid JSON object arguments for this tool.";
           return {
             tool_call_id: call.id,
             name: call.name,
-            content: `Error: invalid JSON arguments for ${call.name}: ${e.message}. Arguments received: ${truncateForError(call.arguments)}`,
+            content: `Error: invalid JSON arguments for ${call.name}: ${e.message}. No tool action was performed (${Buffer.byteLength(call.arguments, "utf8")} argument bytes).`,
             ok: false,
             errorCode: "invalid_args",
-            recoverable: false,
-            suggestion: "reformulate the tool call with valid JSON arguments"
+            recoverable: true,
+            suggestion: artifactSuggestion
           };
         }
         tr?.call(args, tool.needsPermission);
@@ -13110,12 +13415,12 @@ __export(sessions_exports, {
   saveSession: () => saveSession,
   sessionsDir: () => sessionsDir
 });
-import { readFile as readFile13, writeFile as writeFile11, mkdir as mkdir11, readdir as readdir4, stat as stat5 } from "fs/promises";
+import { readFile as readFile14, writeFile as writeFile12, mkdir as mkdir12, readdir as readdir5, stat as stat6 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function sessionsDir() {
-  const xdg = process.env.XDG_DATA_HOME || join25(homedir15(), ".local", "share");
-  return join25(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join26(homedir15(), ".local", "share");
+  return join26(xdg, "kimiflare", "sessions");
 }
 function sanitize(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -13134,9 +13439,9 @@ function makeSessionId(firstPrompt) {
 }
 async function saveSession(file) {
   const dir = sessionsDir();
-  await mkdir11(dir, { recursive: true });
-  const path = join25(dir, `${file.id}.json`);
-  await writeFile11(path, JSON.stringify(file, null, 2), "utf8");
+  await mkdir12(dir, { recursive: true });
+  const path = join26(dir, `${file.id}.json`);
+  await writeFile12(path, JSON.stringify(file, null, 2), "utf8");
   return path;
 }
 async function pruneSessions() {
@@ -13148,16 +13453,16 @@ async function listSessions(limit = 30, cwd) {
   const dir = sessionsDir();
   let entries;
   try {
-    entries = await readdir4(dir);
+    entries = await readdir5(dir);
   } catch {
     return [];
   }
   const summaries = [];
   for (const name of entries) {
     if (!name.endsWith(".json")) continue;
-    const path = join25(dir, name);
+    const path = join26(dir, name);
     try {
-      const [s, raw] = await Promise.all([stat5(path), readFile13(path, "utf8")]);
+      const [s, raw] = await Promise.all([stat6(path), readFile14(path, "utf8")]);
       const parsed = JSON.parse(raw);
       if (cwd && parsed.cwd !== cwd) continue;
       const firstUser = parsed.messages.find((m) => m.role === "user");
@@ -13179,7 +13484,7 @@ async function listSessions(limit = 30, cwd) {
   return summaries.slice(0, limit);
 }
 async function loadSession(filePath) {
-  const raw = await readFile13(filePath, "utf8");
+  const raw = await readFile14(filePath, "utf8");
   const file = JSON.parse(raw);
   if (Array.isArray(file.messages)) repairDanglingToolCalls(file.messages);
   return file;
@@ -13229,10 +13534,10 @@ var init_sessions = __esm({
 });
 
 // src/util/image.ts
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile15 } from "fs/promises";
 import { basename as basename2 } from "path";
 async function encodeImageFile(filePath) {
-  const buf = await readFile14(filePath);
+  const buf = await readFile15(filePath);
   if (buf.byteLength > MAX_IMAGE_BYTES) {
     throw new Error(
       `image too large (${(buf.byteLength / 1024 / 1024).toFixed(1)} MB); max is ${MAX_IMAGE_BYTES / 1024 / 1024} MB`
@@ -13268,7 +13573,7 @@ var init_image = __esm({
 });
 
 // src/permissions-evaluator.ts
-import { resolve as resolve5, relative as relative4 } from "path";
+import { resolve as resolve6, relative as relative5 } from "path";
 import { homedir as homedir16 } from "os";
 function evaluatePermissionRules(req, rules) {
   const toolRules = rules[req.tool];
@@ -13285,7 +13590,7 @@ function evaluatePermissionRules(req, rules) {
 }
 function expandHome(path) {
   if (path.startsWith("~/")) {
-    return resolve5(homedir16(), path.slice(2));
+    return resolve6(homedir16(), path.slice(2));
   }
   return path;
 }
@@ -13296,7 +13601,7 @@ function extractTarget(tool, args, cwd) {
     case "read":
     case "glob":
     case "grep":
-      return typeof args.path === "string" ? resolve5(cwd, expandHome(args.path)) : null;
+      return typeof args.path === "string" ? resolve6(cwd, expandHome(args.path)) : null;
     case "bash":
       return typeof args.command === "string" ? args.command : null;
     case "browser_fetch":
@@ -13305,13 +13610,13 @@ function extractTarget(tool, args, cwd) {
     case "search_web":
       return typeof args.query === "string" ? args.query : null;
     default:
-      return (typeof args.path === "string" ? resolve5(cwd, expandHome(args.path)) : null) ?? (typeof args.url === "string" ? args.url : null) ?? (typeof args.command === "string" ? args.command : null);
+      return (typeof args.path === "string" ? resolve6(cwd, expandHome(args.path)) : null) ?? (typeof args.url === "string" ? args.url : null) ?? (typeof args.command === "string" ? args.command : null);
   }
 }
 function matchPattern(target, pattern, cwd) {
   let expandedPattern = pattern;
   if (pattern.startsWith("~/")) {
-    expandedPattern = resolve5(homedir16(), pattern.slice(2));
+    expandedPattern = resolve6(homedir16(), pattern.slice(2));
   }
   if (target.startsWith(expandedPattern)) {
     return true;
@@ -13321,7 +13626,7 @@ function matchPattern(target, pattern, cwd) {
     return true;
   }
   try {
-    const relTarget = relative4(cwd, target);
+    const relTarget = relative5(cwd, target);
     if (regex.test(relTarget)) {
       return true;
     }
@@ -13394,17 +13699,17 @@ __export(retention_exports, {
   listTraceSessions: () => listTraceSessions,
   pruneTraces: () => pruneTraces
 });
-import { readdir as readdir5, rm as rm3, stat as stat6 } from "fs/promises";
-import { join as join26 } from "path";
+import { readdir as readdir6, rm as rm4, stat as stat7 } from "fs/promises";
+import { join as join27 } from "path";
 async function dirSize(path) {
   let total = 0;
-  const entries = await readdir5(path, { withFileTypes: true });
+  const entries = await readdir6(path, { withFileTypes: true });
   for (const entry of entries) {
-    const p = join26(path, entry.name);
+    const p = join27(path, entry.name);
     if (entry.isDirectory()) total += await dirSize(p);
     else if (entry.isFile()) {
       try {
-        total += (await stat6(p)).size;
+        total += (await stat7(p)).size;
       } catch {
       }
     }
@@ -13415,19 +13720,19 @@ async function listTraceSessions(root) {
   const base = traceRoot(root);
   let names;
   try {
-    names = await readdir5(base);
+    names = await readdir6(base);
   } catch {
     return [];
   }
   const sessions = [];
   for (const name of names) {
-    const path = join26(base, name);
+    const path = join27(base, name);
     try {
-      const s = await stat6(path);
+      const s = await stat7(path);
       if (!s.isDirectory()) continue;
       let mtime = s.mtime;
       try {
-        mtime = (await stat6(join26(path, TRACE_FILE_NAME))).mtime;
+        mtime = (await stat7(join27(path, TRACE_FILE_NAME))).mtime;
       } catch {
       }
       sessions.push({ sessionId: name, path, mtime, bytes: await dirSize(path) });
@@ -13452,7 +13757,7 @@ async function pruneTraces(opts2 = {}) {
   }
   const remove = async (s) => {
     try {
-      await rm3(s.path, { recursive: true, force: true });
+      await rm4(s.path, { recursive: true, force: true });
       removed.push(s.sessionId);
     } catch {
     }
@@ -13481,7 +13786,7 @@ var init_retention = __esm({
 // src/trace/session-start.ts
 import { execFile as execFile6 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { dirname as dirname13, join as join27 } from "path";
+import { dirname as dirname13, join as join28 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { promisify as promisify6 } from "util";
 async function git2(args, cwd) {
@@ -13495,8 +13800,8 @@ async function git2(args, cwd) {
 }
 function harnessCheckoutDir() {
   const here = dirname13(fileURLToPath4(import.meta.url));
-  for (const candidate of [join27(here, "..", ".."), join27(here, "..")]) {
-    if (existsSync5(join27(candidate, "package.json")) && existsSync5(join27(candidate, ".git"))) return candidate;
+  for (const candidate of [join28(here, "..", ".."), join28(here, "..")]) {
+    if (existsSync5(join28(candidate, "package.json")) && existsSync5(join28(candidate, ".git"))) return candidate;
   }
   return null;
 }
@@ -13634,14 +13939,14 @@ var init_types2 = __esm({
 // src/hooks/settings.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir17 } from "os";
-import { join as join28, dirname as dirname14 } from "path";
+import { join as join29, dirname as dirname14 } from "path";
 import { createHash as createHash3 } from "crypto";
 function globalSettingsPath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join28(homedir17(), ".config");
-  return join28(xdg, "kimiflare", "settings.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join29(homedir17(), ".config");
+  return join29(xdg, "kimiflare", "settings.json");
 }
 function projectSettingsPath(cwd) {
-  return join28(cwd, ".kimiflare", "settings.json");
+  return join29(cwd, ".kimiflare", "settings.json");
 }
 function readSettingsFile(path) {
   if (!existsSync6(path)) return null;
@@ -13759,7 +14064,7 @@ var init_settings = __esm({
 });
 
 // src/hooks/runner.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 function isVetoEvent(event) {
   return event === "PreToolUse" || event === "UserPromptSubmit";
 }
@@ -13876,8 +14181,8 @@ var init_runner = __esm({
     init_logger();
     DEFAULT_TIMEOUT_MS = 3e4;
     STREAM_CAP_BYTES = 4 * 1024;
-    defaultSpawn = (command, payloadJson, env2, cwd, timeoutMs, signal) => new Promise((resolve19) => {
-      const child = spawn4(command, {
+    defaultSpawn = (command, payloadJson, env2, cwd, timeoutMs, signal) => new Promise((resolve20) => {
+      const child = spawn5(command, {
         shell: true,
         cwd,
         env: env2,
@@ -13891,7 +14196,7 @@ var init_runner = __esm({
         settled = true;
         clearTimeout(timer3);
         signal?.removeEventListener("abort", onAbort);
-        resolve19({ exitCode, stdout, stderr, timedOut });
+        resolve20({ exitCode, stdout, stderr, timedOut });
       };
       const onAbort = () => {
         child.kill("SIGTERM");
@@ -13964,11 +14269,11 @@ var init_manager2 = __esm({
 });
 
 // src/eval/config.ts
-import { readFile as readFile16 } from "fs/promises";
-import { basename as basename4, resolve as resolve7 } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { basename as basename4, resolve as resolve8 } from "path";
 async function loadEvalConfig(file) {
-  const path = resolve7(file);
-  const raw = JSON.parse(await readFile16(path, "utf8"));
+  const path = resolve8(file);
+  const raw = JSON.parse(await readFile17(path, "utf8"));
   if (!raw || typeof raw !== "object") throw new Error(`${file}: config must be a JSON object`);
   const config2 = raw.config ?? {};
   if (typeof config2 !== "object" || Array.isArray(config2)) throw new Error(`${file}: "config" must be an object`);
@@ -13988,8 +14293,8 @@ var init_config2 = __esm({
 });
 
 // src/eval/tasks.ts
-import { readdir as readdir6, readFile as readFile17, stat as stat7 } from "fs/promises";
-import { basename as basename5, join as join29, resolve as resolve8 } from "path";
+import { readdir as readdir7, readFile as readFile18, stat as stat8 } from "fs/promises";
+import { basename as basename5, join as join30, resolve as resolve9 } from "path";
 function isNonEmptyString(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
@@ -14017,22 +14322,22 @@ function matchesTaskFilter(id, filter) {
   return filter.split(",").map((g) => g.trim()).filter(Boolean).some((g) => matchGlob(id, g));
 }
 async function loadTasks(dir, filter) {
-  const root = resolve8(dir);
-  const names = (await readdir6(root)).filter((n) => n.endsWith(".json")).sort();
+  const root = resolve9(dir);
+  const names = (await readdir7(root)).filter((n) => n.endsWith(".json")).sort();
   const tasks = [];
   const seen = /* @__PURE__ */ new Set();
   for (const name of names) {
-    const file = join29(root, name);
-    const task = validateTask(JSON.parse(await readFile17(file, "utf8")), name);
+    const file = join30(root, name);
+    const task = validateTask(JSON.parse(await readFile18(file, "utf8")), name);
     if (task.id !== basename5(name, ".json")) throw new Error(`${name}: "id" (${task.id}) must match the file name`);
     if (seen.has(task.id)) throw new Error(`duplicate task id ${task.id}`);
     seen.add(task.id);
     if (!matchesTaskFilter(task.id, filter)) continue;
     const resolvedFiles = {};
     for (const [dest, src] of Object.entries(task.files ?? {})) {
-      const abs = resolve8(root, src);
+      const abs = resolve9(root, src);
       if (!abs.startsWith(root)) throw new Error(`${name}: files["${dest}"] escapes the task directory`);
-      await stat7(abs).catch(() => {
+      await stat8(abs).catch(() => {
         throw new Error(`${name}: files["${dest}"] -> ${src} does not exist`);
       });
       resolvedFiles[dest] = abs;
@@ -14053,15 +14358,15 @@ var init_tasks2 = __esm({
 // src/eval/workspace.ts
 import { execFile as execFile7 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { mkdir as mkdir12, rm as rm4, stat as stat8 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join30, resolve as resolve9 } from "path";
+import { mkdir as mkdir13, rm as rm5, stat as stat9 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join31, resolve as resolve10 } from "path";
 import { promisify as promisify7 } from "util";
 async function git3(args, cwd, timeoutMs = 6e5) {
   const { stdout } = await execFileAsync5("git", args, { cwd, timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
   return stdout.trim();
 }
 function isLocalRepo(repo) {
-  return isAbsolute3(repo) || repo.startsWith(".") || repo.startsWith("~");
+  return isAbsolute4(repo) || repo.startsWith(".") || repo.startsWith("~");
 }
 function prepareSourceRepo(repo, cacheDir) {
   const key = `${cacheDir}\0${repo}`;
@@ -14074,14 +14379,14 @@ function prepareSourceRepo(repo, cacheDir) {
 }
 async function prepareSourceRepoUncached(repo, cacheDir) {
   if (isLocalRepo(repo)) {
-    const path = resolve9(repo.replace(/^~/, process.env.HOME ?? ""));
+    const path = resolve10(repo.replace(/^~/, process.env.HOME ?? ""));
     await git3(["rev-parse", "--git-dir"], path);
     return path;
   }
   const slug = `${repo.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(-60)}-${createHash4("sha1").update(repo).digest("hex").slice(0, 8)}`;
-  const dir = join30(cacheDir, slug);
-  await mkdir12(cacheDir, { recursive: true });
-  const exists = await stat8(join30(dir, ".git")).then(() => true).catch(() => false);
+  const dir = join31(cacheDir, slug);
+  await mkdir13(cacheDir, { recursive: true });
+  const exists = await stat9(join31(dir, ".git")).then(() => true).catch(() => false);
   if (!exists) {
     await git3(["clone", "--quiet", "--no-checkout", repo, dir], cacheDir);
   } else {
@@ -14100,13 +14405,13 @@ async function ensureCommit(sourceRepo, commit) {
 async function createWorktree(sourceRepo, commit, path) {
   await ensureCommit(sourceRepo, commit);
   await removeWorktree({ sourceRepo, path }).catch(() => void 0);
-  await mkdir12(join30(path, ".."), { recursive: true });
+  await mkdir13(join31(path, ".."), { recursive: true });
   await git3(["worktree", "add", "--quiet", "--detach", path, commit], sourceRepo);
   return { sourceRepo, path };
 }
 async function removeWorktree(wt) {
   await git3(["worktree", "remove", "--force", wt.path], wt.sourceRepo).catch(() => void 0);
-  await rm4(wt.path, { recursive: true, force: true });
+  await rm5(wt.path, { recursive: true, force: true });
   await git3(["worktree", "prune"], wt.sourceRepo).catch(() => void 0);
 }
 var execFileAsync5, preparing;
@@ -15201,7 +15506,7 @@ Context: This memory was explicitly provided by the user during a conversation.`
 });
 
 // src/lsp/connection.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 var LspConnection;
 var init_connection = __esm({
@@ -15223,7 +15528,7 @@ var init_connection = __esm({
         if (this.child) {
           throw new Error("LSP connection already started");
         }
-        return new Promise((resolve19, reject) => {
+        return new Promise((resolve20, reject) => {
           const abortController = new AbortController();
           const spawnTimer = setTimeout(() => {
             abortController.abort();
@@ -15231,7 +15536,7 @@ var init_connection = __esm({
             reject(new Error(`LSP server spawn timed out after ${spawnTimeoutMs}ms`));
           }, spawnTimeoutMs);
           try {
-            const child = spawn5(command[0], command.slice(1), {
+            const child = spawn6(command[0], command.slice(1), {
               env: { ...process.env, ...env2 },
               stdio: ["pipe", "pipe", "pipe"]
             });
@@ -15262,7 +15567,7 @@ var init_connection = __esm({
               if (child.pid) {
                 clearTimeout(spawnTimer);
                 this.child = child;
-                resolve19();
+                resolve20();
               }
             });
           } catch (err) {
@@ -15277,12 +15582,12 @@ var init_connection = __esm({
         }
         const id = this.nextId++;
         const msg = { jsonrpc: "2.0", id, method, params };
-        return new Promise((resolve19, reject) => {
+        return new Promise((resolve20, reject) => {
           const timer3 = setTimeout(() => {
             this.pending.delete(id);
             reject(toolTimeoutError(`LSP request '${method}'`, this.requestTimeoutMs));
           }, this.requestTimeoutMs);
-          const pending = { resolve: resolve19, reject, signal, timer: timer3 };
+          const pending = { resolve: resolve20, reject, signal, timer: timer3 };
           this.pending.set(id, pending);
           if (signal) {
             const onAbort = () => {
@@ -15375,9 +15680,9 @@ var init_connection = __esm({
 });
 
 // src/lsp/protocol.ts
-import { pathToFileURL as pathToFileURL2, fileURLToPath as fileURLToPath5 } from "url";
+import { pathToFileURL as pathToFileURL3, fileURLToPath as fileURLToPath5 } from "url";
 function toUri(path) {
-  return pathToFileURL2(path).href;
+  return pathToFileURL3(path).href;
 }
 function fromUri(uri) {
   return fileURLToPath5(uri);
@@ -15846,10 +16151,10 @@ var init_manager4 = __esm({
 });
 
 // src/lsp/adapter.ts
-import { relative as relative5 } from "path";
+import { relative as relative6 } from "path";
 function formatLocation(loc, cwd) {
   const path = fromUri(loc.uri);
-  const rel = relative5(cwd, path) || path;
+  const rel = relative6(cwd, path) || path;
   return `${rel}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
 }
 function formatLocations(locs, cwd) {
@@ -15886,7 +16191,7 @@ function formatWorkspaceSymbols(symbols, cwd) {
   if (!symbols || symbols.length === 0) return "No symbols found.";
   return symbols.map((s) => {
     const path = fromUri(s.location.uri);
-    const rel = relative5(cwd, path) || path;
+    const rel = relative6(cwd, path) || path;
     const container = s.containerName ? ` in ${s.containerName}` : "";
     return `${s.name} (${symbolKindName(s.kind)})${container} \u2014 ${rel}:${s.location.range.start.line + 1}:${s.location.range.start.character + 1}`;
   }).join("\n");
@@ -15906,7 +16211,7 @@ function formatWorkspaceEdit(edit, cwd) {
   if (edit.changes) {
     for (const [uri, edits] of Object.entries(edit.changes)) {
       const path = fromUri(uri);
-      const rel = relative5(cwd, path) || path;
+      const rel = relative6(cwd, path) || path;
       lines.push(`File: ${rel}`);
       for (const e of edits) {
         lines.push(`  ${e.range.start.line + 1}:${e.range.start.character + 1}-${e.range.end.line + 1}:${e.range.end.character + 1}: ${e.newText}`);
@@ -15931,7 +16236,7 @@ var init_adapter = __esm({
 });
 
 // src/tools/lsp.ts
-import { relative as relative6 } from "path";
+import { relative as relative7 } from "path";
 function makeOutput2(content) {
   const bytes = Buffer.byteLength(content, "utf8");
   return { content, rawBytes: bytes, reducedBytes: bytes };
@@ -15939,7 +16244,7 @@ function makeOutput2(content) {
 function resolveLspPath(args, ctx) {
   const raw = typeof args.path === "string" ? args.path : "";
   const resolved = resolvePath(ctx.cwd, raw);
-  const rel = relative6(ctx.cwd, resolved);
+  const rel = relative7(ctx.cwd, resolved);
   if (isPathOutside(rel)) {
     throw new Error(`Path outside workspace: ${raw}`);
   }
@@ -16205,12 +16510,12 @@ __export(openrouter_catalog_exports, {
   loadOpenRouterCatalog: () => loadOpenRouterCatalog,
   mapOpenRouterModel: () => mapOpenRouterModel
 });
-import { readFile as readFile18, writeFile as writeFile12, mkdir as mkdir13 } from "fs/promises";
+import { readFile as readFile19, writeFile as writeFile13, mkdir as mkdir14 } from "fs/promises";
 import { homedir as homedir18 } from "os";
-import { join as join32, dirname as dirname16 } from "path";
+import { join as join33, dirname as dirname16 } from "path";
 function catalogCachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join32(homedir18(), ".config");
-  return join32(xdg, "kimiflare", "openrouter-models.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join33(homedir18(), ".config");
+  return join33(xdg, "kimiflare", "openrouter-models.json");
 }
 function perMtok(perToken) {
   const n = Number(perToken);
@@ -16261,7 +16566,7 @@ async function fetchOpenRouterCatalog(fetchImpl2 = fetch) {
 }
 async function readCache3() {
   try {
-    const raw = await readFile18(catalogCachePath(), "utf8");
+    const raw = await readFile19(catalogCachePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version === CACHE_VERSION ? parsed : null;
   } catch {
@@ -16271,9 +16576,9 @@ async function readCache3() {
 async function writeCache3(models) {
   const path = catalogCachePath();
   try {
-    await mkdir13(dirname16(path), { recursive: true });
+    await mkdir14(dirname16(path), { recursive: true });
     const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
-    await writeFile12(path, JSON.stringify(cache, null, 2), "utf8");
+    await writeFile13(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
   }
 }
@@ -16320,12 +16625,12 @@ __export(requesty_catalog_exports, {
   loadRequestyCatalog: () => loadRequestyCatalog,
   mapRequestyModel: () => mapRequestyModel
 });
-import { readFile as readFile19, writeFile as writeFile13, mkdir as mkdir14 } from "fs/promises";
+import { readFile as readFile20, writeFile as writeFile14, mkdir as mkdir15 } from "fs/promises";
 import { homedir as homedir19 } from "os";
-import { join as join33, dirname as dirname17 } from "path";
+import { join as join34, dirname as dirname17 } from "path";
 function catalogCachePath2() {
-  const xdg = process.env.XDG_CONFIG_HOME || join33(homedir19(), ".config");
-  return join33(xdg, "kimiflare", "requesty-models.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join34(homedir19(), ".config");
+  return join34(xdg, "kimiflare", "requesty-models.json");
 }
 function isSafeModelId(id) {
   return typeof id === "string" && id.length > 0 && !CONTROL_CHARS.test(id);
@@ -16381,7 +16686,7 @@ async function fetchRequestyCatalog(fetchImpl2 = fetch) {
 }
 async function readCache4() {
   try {
-    const raw = await readFile19(catalogCachePath2(), "utf8");
+    const raw = await readFile20(catalogCachePath2(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION2) return null;
     return {
@@ -16396,9 +16701,9 @@ async function readCache4() {
 async function writeCache4(catalog) {
   const path = catalogCachePath2();
   try {
-    await mkdir14(dirname17(path), { recursive: true });
+    await mkdir15(dirname17(path), { recursive: true });
     const cache = { version: CACHE_VERSION2, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ...catalog };
-    await writeFile13(path, JSON.stringify(cache, null, 2), "utf8");
+    await writeFile14(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
   }
 }
@@ -16491,15 +16796,15 @@ var session_exports = {};
 __export(session_exports, {
   createAgentSession: () => createAgentSession
 });
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 import { homedir as homedir20 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { existsSync as existsSync7 } from "fs";
 async function createAgentSession(opts2) {
   const config2 = await resolveSdkConfig(opts2);
   if (usesRequesty(llmAuthFromConfig(config2))) await ensureRequestyCatalog();
   else if (!resolveCustomEndpoint(config2)) await ensureOpenRouterCatalog();
-  const cwd = resolve10(opts2.cwd ?? process.cwd());
+  const cwd = resolve11(opts2.cwd ?? process.cwd());
   const tools = opts2.tools ?? ALL_TOOLS;
   let hooks;
   if (opts2.enableHooks) {
@@ -16510,7 +16815,7 @@ async function createAgentSession(opts2) {
   let memoryManager = null;
   const memoryEnabled = opts2.memoryEnabled ?? config2.memoryEnabled ?? false;
   if (memoryEnabled) {
-    const dbPath = config2.memoryDbPath ?? join34(homedir20(), ".local", "share", "kimiflare", "memory.db");
+    const dbPath = config2.memoryDbPath ?? join35(homedir20(), ".local", "share", "kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       ...llmAuthFromConfig(config2),
@@ -16540,7 +16845,7 @@ async function createAgentSession(opts2) {
   }
   let sessionFile;
   if (opts2.sessionId) {
-    const filePath = join34(sessionsDir(), `${opts2.sessionId}.json`);
+    const filePath = join35(sessionsDir(), `${opts2.sessionId}.json`);
     try {
       sessionFile = await loadSession(filePath);
     } catch {
@@ -16739,8 +17044,8 @@ var init_session = __esm({
           const parts = [{ type: "text", text }];
           for (const img of options.images) {
             if ("path" in img) {
-              const { readFile: readFile36 } = await import("fs/promises");
-              const data = await readFile36(img.path, "base64");
+              const { readFile: readFile37 } = await import("fs/promises");
+              const data = await readFile37(img.path, "base64");
               const mimeType = img.path.endsWith(".png") ? "image/png" : img.path.endsWith(".jpg") || img.path.endsWith(".jpeg") ? "image/jpeg" : "image/webp";
               parts.push({ type: "image_url", image_url: { url: `data:${mimeType};base64,${data}` } });
             } else {
@@ -16999,12 +17304,12 @@ var init_session = __esm({
               toolName: req.tool.name,
               args: req.args
             });
-            const decision = await new Promise((resolve19) => {
-              this.permissionResolvers.set(requestId, resolve19);
+            const decision = await new Promise((resolve20) => {
+              this.permissionResolvers.set(requestId, resolve20);
               setTimeout(() => {
                 if (this.permissionResolvers.has(requestId)) {
                   this.permissionResolvers.delete(requestId);
-                  resolve19("deny");
+                  resolve20("deny");
                 }
               }, 3e5);
             });
@@ -17063,14 +17368,14 @@ var init_session = __esm({
               this.lspManager?.notifyChange(path, content);
             } else {
               void import("fs/promises").then(
-                ({ readFile: readFile36 }) => readFile36(path, "utf8").then((c) => this.lspManager?.notifyChange(path, c)).catch(() => {
+                ({ readFile: readFile37 }) => readFile37(path, "utf8").then((c) => this.lspManager?.notifyChange(path, c)).catch(() => {
                 })
               ).catch(() => {
               });
             }
           }
         });
-        if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync7(join34(this.cwd, name)))) {
+        if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync7(join35(this.cwd, name)))) {
           this.messages[0] = {
             role: "system",
             content: buildSystemPrompt({
@@ -17094,13 +17399,13 @@ __export(run_exports, {
   runShell: () => runShell,
   summarizeTrace: () => summarizeTrace
 });
-import { spawn as spawn6 } from "child_process";
-import { appendFile as appendFile3, copyFile, mkdir as mkdir15, readFile as readFile20, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname18, join as join35, resolve as resolve11 } from "path";
+import { spawn as spawn7 } from "child_process";
+import { appendFile as appendFile3, copyFile, mkdir as mkdir16, readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
+import { dirname as dirname18, join as join36, resolve as resolve12 } from "path";
 import { performance as performance2 } from "perf_hooks";
 function runShell(command, cwd, timeoutMs) {
   return new Promise((resolveShell) => {
-    const child = spawn6(process.platform === "win32" ? process.env.COMSPEC || "cmd.exe" : "bash", [process.platform === "win32" ? "/c" : "-lc", command], {
+    const child = spawn7(process.platform === "win32" ? process.env.COMSPEC || "cmd.exe" : "bash", [process.platform === "win32" ? "/c" : "-lc", command], {
       cwd,
       env: { ...process.env, CI: "1", GIT_EDITOR: "true" }
     });
@@ -17129,8 +17434,8 @@ ${err.message}`, timedOut });
 }
 async function copyTaskFiles(task, worktree) {
   for (const [dest, src] of Object.entries(task.resolvedFiles)) {
-    const target = join35(worktree, dest);
-    await mkdir15(dirname18(target), { recursive: true });
+    const target = join36(worktree, dest);
+    await mkdir16(dirname18(target), { recursive: true });
     await copyFile(src, target);
   }
 }
@@ -17138,7 +17443,7 @@ async function summarizeTrace(traceFile) {
   const out = { cost_usd: 0, prompt_tokens: 0, completion_tokens: 0, turns: 0, tool_calls: 0, overflow: false };
   let raw;
   try {
-    raw = await readFile20(traceFile, "utf8");
+    raw = await readFile21(traceFile, "utf8");
   } catch {
     return out;
   }
@@ -17170,7 +17475,7 @@ function sessionIdFor(runName, task, sample) {
 async function runOne(task, sample, ctx) {
   const startedAt2 = performance2.now();
   const sessionId = sessionIdFor(ctx.runName, task, sample);
-  const traceDir = join35(ctx.tracesRoot, sessionId);
+  const traceDir = join36(ctx.tracesRoot, sessionId);
   const base = {
     task_id: task.id,
     sample,
@@ -17195,15 +17500,15 @@ async function runOne(task, sample, ctx) {
   });
   let worktree = null;
   try {
-    const sourceRepo = await prepareSourceRepo(task.repo, join35(ctx.out, "cache"));
-    worktree = await createWorktree(sourceRepo, task.base_commit, join35(ctx.out, "work", task.id, String(sample)));
+    const sourceRepo = await prepareSourceRepo(task.repo, join36(ctx.out, "cache"));
+    worktree = await createWorktree(sourceRepo, task.base_commit, join36(ctx.out, "work", task.id, String(sample)));
     await copyTaskFiles(task, worktree.path);
     const timeoutMs = (task.timeout_s ?? DEFAULT_TASK_TIMEOUT_S) * 1e3;
     if (task.setup) {
       ctx.log(`[${task.id}#${sample}] setup`);
       const setup = await runShell(task.setup, worktree.path, timeoutMs);
       if (setup.exitCode !== 0) {
-        await writeFile14(join35(worktree.path, ".eval-setup.log"), setup.log, "utf8").catch(() => void 0);
+        await writeFile15(join36(worktree.path, ".eval-setup.log"), setup.log, "utf8").catch(() => void 0);
         return finish({ error: `setup failed (exit ${setup.exitCode}${setup.timedOut ? ", timed out" : ""}): ${setup.log.slice(-500)}` });
       }
     }
@@ -17237,8 +17542,8 @@ async function runOne(task, sample, ctx) {
     const test = await runShell(task.test, worktree.path, timeoutMs);
     const testMs = Math.round(performance2.now() - testStartedAt);
     const passed = test.exitCode === 0 && !test.timedOut;
-    await mkdir15(traceDir, { recursive: true }).catch(() => void 0);
-    await writeFile14(join35(traceDir, "test.log"), test.log, "utf8").catch(() => void 0);
+    await mkdir16(traceDir, { recursive: true }).catch(() => void 0);
+    await writeFile15(join36(traceDir, "test.log"), test.log, "utf8").catch(() => void 0);
     if (session.trace.enabled) {
       session.trace.emit(
         "outcome",
@@ -17256,7 +17561,7 @@ async function runOne(task, sample, ctx) {
     }
     session.dispose({ traceEndReason: "eval_done" });
     await session.trace.flush();
-    const stats = await summarizeTrace(join35(traceDir, "trace.jsonl"));
+    const stats = await summarizeTrace(join36(traceDir, "trace.jsonl"));
     ctx.log(`[${task.id}#${sample}] ${passed ? "PASS" : "FAIL"} in ${agentMs + testMs} ms${agentError ? ` (${agentError.slice(0, 120)})` : ""}`);
     return finish({
       passed,
@@ -17274,7 +17579,7 @@ async function runOne(task, sample, ctx) {
   }
 }
 async function runEval(opts2) {
-  const out = resolve11(opts2.out);
+  const out = resolve12(opts2.out);
   const log2 = opts2.log ?? ((line) => process.stderr.write(`${line}
 `));
   const evalConfig = await loadEvalConfig(opts2.configFile);
@@ -17285,12 +17590,12 @@ async function runEval(opts2) {
   const samples = Math.max(1, Math.floor(opts2.samples ?? 1));
   const concurrency = Math.max(1, Math.floor(opts2.concurrency ?? 1));
   const createSession = opts2.createSession ?? (await Promise.resolve().then(() => (init_session(), session_exports))).createAgentSession;
-  await mkdir15(out, { recursive: true });
-  const tracesRoot = join35(out, "traces");
+  await mkdir16(out, { recursive: true });
+  const tracesRoot = join36(out, "traces");
   const runName = evalConfig.name;
-  const resultsFile = join35(out, "results.jsonl");
-  await writeFile14(
-    join35(out, "config.json"),
+  const resultsFile = join36(out, "results.jsonl");
+  await writeFile15(
+    join36(out, "config.json"),
     JSON.stringify({ name: evalConfig.name, model, temperature: evalConfig.temperature ?? null, config: redactConfig(evalConfig.config), tasks: opts2.tasksDir, samples, started_at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
     "utf8"
   );
@@ -17334,9 +17639,9 @@ __export(compare_exports, {
   perTask: () => perTask,
   summarizeArm: () => summarizeArm
 });
-import { readFile as readFile21 } from "fs/promises";
+import { readFile as readFile22 } from "fs/promises";
 async function loadResults(file) {
-  const raw = await readFile21(file, "utf8");
+  const raw = await readFile22(file, "utf8");
   return raw.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function median(values) {
@@ -17469,16 +17774,16 @@ __export(cost_verify_exports, {
   verifySession: () => verifySession,
   verifyTurn: () => verifyTurn
 });
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile23 } from "fs/promises";
 import { homedir as homedir21 } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function usagePath2() {
-  const xdg = process.env.XDG_DATA_HOME || join36(homedir21(), ".local", "share");
-  return join36(xdg, "kimiflare", "usage.json");
+  const xdg = process.env.XDG_DATA_HOME || join37(homedir21(), ".local", "share");
+  return join37(xdg, "kimiflare", "usage.json");
 }
 async function loadSessions() {
   try {
-    return JSON.parse(await readFile22(usagePath2(), "utf8")).sessions ?? [];
+    return JSON.parse(await readFile23(usagePath2(), "utf8")).sessions ?? [];
   } catch {
     return [];
   }
@@ -18009,12 +18314,12 @@ var init_heuristic = __esm({
 });
 
 // src/cost-attribution/classify-from-session.ts
-import { readFile as readFile23 } from "fs/promises";
-import { join as join37 } from "path";
+import { readFile as readFile24 } from "fs/promises";
+import { join as join38 } from "path";
 import { homedir as homedir22 } from "os";
 function sessionsDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join37(homedir22(), ".local", "share");
-  return join37(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join38(homedir22(), ".local", "share");
+  return join38(xdg, "kimiflare", "sessions");
 }
 function parseToolCalls(calls) {
   return calls.map((c) => {
@@ -18028,7 +18333,7 @@ function parseToolCalls(calls) {
 }
 async function classifyFromSessionFile(sessionId) {
   try {
-    const raw = await readFile23(join37(sessionsDir2(), `${sessionId}.json`), "utf8");
+    const raw = await readFile24(join38(sessionsDir2(), `${sessionId}.json`), "utf8");
     const session = JSON.parse(raw);
     const messages = session.messages ?? [];
     const turns = [];
@@ -18061,15 +18366,15 @@ var cli_exports = {};
 __export(cli_exports, {
   runCostCommand: () => runCostCommand
 });
-import { readFile as readFile24 } from "fs/promises";
-import { join as join38 } from "path";
+import { readFile as readFile25 } from "fs/promises";
+import { join as join39 } from "path";
 import { homedir as homedir23 } from "os";
 function usageDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join38(homedir23(), ".local", "share");
-  return join38(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join39(homedir23(), ".local", "share");
+  return join39(xdg, "kimiflare");
 }
 function usagePath3() {
-  return join38(usageDir2(), "usage.json");
+  return join39(usageDir2(), "usage.json");
 }
 function today2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -18081,7 +18386,7 @@ function daysAgo(n) {
 }
 async function loadLog2() {
   try {
-    const raw = await readFile24(usagePath3(), "utf8");
+    const raw = await readFile25(usagePath3(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -18171,12 +18476,12 @@ __export(aster_workspaces_exports, {
   findAsterWorkspace: () => findAsterWorkspace,
   loadAsterServerConfig: () => loadAsterServerConfig
 });
-import { readFile as readFile25, realpath as realpath3, stat as stat9 } from "fs/promises";
-import { isAbsolute as isAbsolute4, relative as relative7, sep as sep3 } from "path";
+import { readFile as readFile26, realpath as realpath4, stat as stat10 } from "fs/promises";
+import { isAbsolute as isAbsolute5, relative as relative8, sep as sep4 } from "path";
 async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_CONFIG || "/etc/autopilot/aster.json") {
   let raw;
   try {
-    raw = JSON.parse(await readFile25(configPath3, "utf8"));
+    raw = JSON.parse(await readFile26(configPath3, "utf8"));
   } catch {
     throw new AsterConfigError();
   }
@@ -18209,15 +18514,15 @@ async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_C
     if (typeof workspace.displayName !== "string" || !workspace.displayName.trim() || workspace.displayName.length > 100) {
       throw new AsterConfigError();
     }
-    if (typeof workspace.rootPath !== "string" || !isAbsolute4(workspace.rootPath)) throw new AsterConfigError();
+    if (typeof workspace.rootPath !== "string" || !isAbsolute5(workspace.rootPath)) throw new AsterConfigError();
     let rootPath;
     try {
-      rootPath = await realpath3(workspace.rootPath);
-      if (!(await stat9(rootPath)).isDirectory()) throw new Error("not a directory");
+      rootPath = await realpath4(workspace.rootPath);
+      if (!(await stat10(rootPath)).isDirectory()) throw new Error("not a directory");
     } catch {
       throw new AsterConfigError();
     }
-    if (roots.some((root) => isWithin(root, rootPath) || isWithin(rootPath, root))) {
+    if (roots.some((root) => isWithin2(root, rootPath) || isWithin2(rootPath, root))) {
       throw new AsterConfigError();
     }
     ids.add(workspace.id);
@@ -18229,9 +18534,9 @@ async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_C
 function findAsterWorkspace(config2, workspaceId) {
   return config2.workspaces.find((workspace) => workspace.id === workspaceId);
 }
-function isWithin(parent, candidate) {
-  const rel = relative7(parent, candidate);
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute4(rel);
+function isWithin2(parent, candidate) {
+  const rel = relative8(parent, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep4}`) && !isAbsolute5(rel);
 }
 var AsterConfigError;
 var init_aster_workspaces = __esm({
@@ -18255,10 +18560,10 @@ import Database4 from "better-sqlite3";
 import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID6 } from "crypto";
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync9 } from "fs";
 import { homedir as homedir24 } from "os";
-import { dirname as dirname19, join as join39 } from "path";
+import { dirname as dirname19, join as join40 } from "path";
 function defaultAsterDbPath() {
-  const root = process.env.XDG_STATE_HOME || join39(homedir24(), ".local", "state");
-  return process.env.AUTOPILOT_ASTER_DB || join39(root, "autopilot", "aster.db");
+  const root = process.env.XDG_STATE_HOME || join40(homedir24(), ".local", "state");
+  return process.env.AUTOPILOT_ASTER_DB || join40(root, "autopilot", "aster.db");
 }
 function hashToken(token) {
   return createHash5("sha256").update(token).digest("hex");
@@ -18612,7 +18917,7 @@ __export(tui_auth_exports, {
   authGitHubForTui: () => authGitHubForTui
 });
 function sleep3(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 async function* authGitHubForTui() {
   yield { message: "Starting GitHub OAuth device flow..." };
@@ -19183,18 +19488,18 @@ var init_openapi = __esm({
 
 // src/runs/worktrees.ts
 import { execFile as execFile8 } from "child_process";
-import { access as access2, chmod as chmod2, mkdir as mkdir16, realpath as realpath4 } from "fs/promises";
+import { access as access2, chmod as chmod3, mkdir as mkdir17, realpath as realpath5 } from "fs/promises";
 import { homedir as homedir25 } from "os";
-import { isAbsolute as isAbsolute5, join as join40, parse, relative as relative8, resolve as resolve12, sep as sep4 } from "path";
+import { isAbsolute as isAbsolute6, join as join41, parse, relative as relative9, resolve as resolve13, sep as sep5 } from "path";
 function defaultWorktreesDir() {
-  const dataHome = process.env.XDG_DATA_HOME || join40(homedir25(), ".local", "share");
-  return join40(dataHome, "autopilot", "worktrees");
+  const dataHome = process.env.XDG_DATA_HOME || join41(homedir25(), ".local", "share");
+  return join41(dataHome, "autopilot", "worktrees");
 }
 function isOutside(path) {
-  return path === ".." || path.startsWith(`..${sep4}`) || isAbsolute5(path);
+  return path === ".." || path.startsWith(`..${sep5}`) || isAbsolute6(path);
 }
-function isWithin2(parent, candidate) {
-  const path = relative8(parent, candidate);
+function isWithin3(parent, candidate) {
+  const path = relative9(parent, candidate);
   return path === "" || !isOutside(path);
 }
 function runGit(args, cwd) {
@@ -19222,24 +19527,24 @@ var init_worktrees = __esm({
         if (runId === "." || runId === ".." || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(runId)) {
           throw new Error("runId must contain only letters, numbers, dots, underscores, or hyphens");
         }
-        const source = await realpath4(sourceCwd);
+        const source = await realpath5(sourceCwd);
         const repositoryRoot = (await runGit(["rev-parse", "--show-toplevel"], source)).trim();
-        const repository = await realpath4(repositoryRoot);
-        const sourceRelativePath = relative8(repository, source);
+        const repository = await realpath5(repositoryRoot);
+        const sourceRelativePath = relative9(repository, source);
         if (isOutside(sourceRelativePath)) {
           throw new Error("sourceCwd must be inside the Git repository");
         }
-        const configuredRoot = resolve12(this.rootDir);
-        if (configuredRoot === parse(configuredRoot).root || isWithin2(repository, configuredRoot)) {
+        const configuredRoot = resolve13(this.rootDir);
+        if (configuredRoot === parse(configuredRoot).root || isWithin3(repository, configuredRoot)) {
           throw new Error("worktree root must be outside the source repository and not the filesystem root");
         }
-        await mkdir16(configuredRoot, { recursive: true, mode: 448 });
-        const worktreesRoot = await realpath4(configuredRoot);
-        if (isWithin2(repository, worktreesRoot)) {
+        await mkdir17(configuredRoot, { recursive: true, mode: 448 });
+        const worktreesRoot = await realpath5(configuredRoot);
+        if (isWithin3(repository, worktreesRoot)) {
           throw new Error("worktree root must be outside the source repository");
         }
-        await chmod2(worktreesRoot, 448);
-        const worktreePath = join40(worktreesRoot, runId);
+        await chmod3(worktreesRoot, 448);
+        const worktreePath = join41(worktreesRoot, runId);
         try {
           await access2(worktreePath);
           throw new Error(`worktree path already exists for run ${runId}`);
@@ -19253,16 +19558,16 @@ var init_worktrees = __esm({
           repositoryRoot: repository,
           sourceCwd: source,
           worktreePath,
-          cwd: resolve12(worktreePath, sourceRelativePath),
+          cwd: resolve13(worktreePath, sourceRelativePath),
           branch
         };
       }
       /** Remove a newly-created, still-clean worktree when run initialization fails. */
       async discard(worktree) {
-        const root = await realpath4(this.rootDir);
-        const target = await realpath4(worktree.worktreePath);
-        const repository = await realpath4(worktree.repositoryRoot);
-        if (target === root || !isWithin2(root, target)) {
+        const root = await realpath5(this.rootDir);
+        const target = await realpath5(worktree.worktreePath);
+        const repository = await realpath5(worktree.repositoryRoot);
+        if (target === root || !isWithin3(root, target)) {
           throw new Error("worktree path is outside the configured worktree root");
         }
         if (worktree.branch !== `autopilot/run/${worktree.runId}`) {
@@ -19407,8 +19712,8 @@ var init_wake_scheduler = __esm({
 });
 
 // src/server/aster-tools.ts
-import { realpath as realpath5 } from "fs/promises";
-import { isAbsolute as isAbsolute6, relative as relative9, sep as sep5 } from "path";
+import { realpath as realpath6 } from "fs/promises";
+import { isAbsolute as isAbsolute7, relative as relative10, sep as sep6 } from "path";
 function createAsterTools(workspaceRoot) {
   return ASTR_TOOLS.map((tool) => ({
     ...tool,
@@ -19420,25 +19725,25 @@ function createAsterTools(workspaceRoot) {
 }
 async function assertAsterWorkspacePath(workspaceRoot, value, allowMissing = false) {
   if (typeof value !== "string" || !value.trim()) throw new Error("workspace_path_invalid");
-  const root = await realpath5(workspaceRoot);
+  const root = await realpath6(workspaceRoot);
   const candidate = resolvePath(root, value);
   assertInside(root, candidate);
   assertNotSensitive(root, candidate);
   let actual;
   try {
-    actual = await realpath5(candidate);
+    actual = await realpath6(candidate);
   } catch (error) {
     if (!allowMissing || error.code !== "ENOENT") throw new Error("workspace_path_unavailable");
     let ancestor = candidate;
     while (true) {
       try {
-        actual = await realpath5(ancestor);
+        actual = await realpath6(ancestor);
         break;
       } catch (ancestorError) {
         if (ancestorError.code !== "ENOENT") throw new Error("workspace_path_unavailable");
-        const parent = relative9(root, ancestor);
+        const parent = relative10(root, ancestor);
         if (!parent || parent === ".") throw new Error("workspace_path_unavailable");
-        ancestor = ancestor.slice(0, ancestor.lastIndexOf(sep5));
+        ancestor = ancestor.slice(0, ancestor.lastIndexOf(sep6));
       }
     }
   }
@@ -19460,11 +19765,11 @@ function redactLikelySecrets(value) {
   return value.replace(SK_CANDIDATE_RE, (match) => isLikelySkKey(match) ? "[REDACTED_PROVIDER_SECRET]" : match).replace(/\bgh[pousr]_[A-Za-z0-9]{20,}/g, "[REDACTED_PROVIDER_SECRET]").replace(/\bgithub_pat_[A-Za-z0-9_]{20,}/g, "[REDACTED_PROVIDER_SECRET]");
 }
 function assertInside(root, candidate) {
-  const rel = relative9(root, candidate);
-  if (rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute6(rel)) throw new Error("workspace_path_forbidden");
+  const rel = relative10(root, candidate);
+  if (rel === ".." || rel.startsWith(`..${sep6}`) || isAbsolute7(rel)) throw new Error("workspace_path_forbidden");
 }
 function assertNotSensitive(root, candidate) {
-  const parts = relative9(root, candidate).split(sep5).filter(Boolean).map((part) => part.toLowerCase());
+  const parts = relative10(root, candidate).split(sep6).filter(Boolean).map((part) => part.toLowerCase());
   if (parts.some((part) => part === ".env" || part.startsWith(".env.") || SENSITIVE_NAMES.has(part))) {
     throw new Error("workspace_sensitive_path_forbidden");
   }
@@ -19499,7 +19804,7 @@ var init_aster_tools = __esm({
 // src/server/aster-api.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { unlink as unlink2 } from "fs/promises";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 function parseCursor(header, query) {
   const value = (Array.isArray(header) ? header[0] : header) ?? query ?? "0";
   if (!/^\d{1,16}$/.test(value)) return void 0;
@@ -19812,7 +20117,7 @@ var init_aster_api = __esm({
           store.appendEvent(id, null, "conversation.created", { conversationId: id, workspaceId: workspace.id, model });
           json(res, 201, publicConversation(conversation));
         } catch {
-          await unlink2(resolve13(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          await unlink2(resolve14(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           await worktreeManager.discard(worktree).catch(() => {
           });
@@ -19837,7 +20142,7 @@ var init_aster_api = __esm({
           sendError(res, 409, "conversation_busy", "A turn is already active for this conversation");
           return;
         }
-        const sessionPath = resolve13(sessionsDir(), conversation.sessionId + ".json");
+        const sessionPath = resolve14(sessionsDir(), conversation.sessionId + ".json");
         let sessionFile;
         try {
           sessionFile = await loadSession(sessionPath);
@@ -20155,7 +20460,7 @@ data: ${JSON.stringify(event.data)}
 
 // src/server/aster-cell-runtime.ts
 import { execFile as execFile9 } from "child_process";
-import { readFile as readFile26 } from "fs/promises";
+import { readFile as readFile27 } from "fs/promises";
 import { promisify as promisify8 } from "util";
 import { randomUUID as randomUUID8 } from "crypto";
 async function writeCellFileChunked(cell, path, content) {
@@ -20185,7 +20490,7 @@ async function writeCellFileChunked(cell, path, content) {
 async function readBundledCellSdkBundle() {
   for (const url of [new URL("./sdk/index.js", import.meta.url), new URL("../sdk/index.js", import.meta.url)]) {
     try {
-      return await readFile26(url, "utf8");
+      return await readFile27(url, "utf8");
     } catch {
     }
   }
@@ -20238,7 +20543,7 @@ function boundedToolText(text, limit) {
 ${redacted.slice(-half)}`;
 }
 function sleep4(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 var execFileAsync6, CELL_WORKSPACE, CELL_STATE_DIR, CHECKPOINT_MESSAGE_FILE, CELL_RUNTIME_DIR, INSTALLED_RUNTIME_PACKAGE, CELL_RUNTIME_SDK_ENTRY, NOTES_FILE, MEMORY_FILE, MEMORY_EXTRACTION_TIMEOUT_MS, LIVENESS_CHECK_MS, ARTIFACTS_DIR, MAX_ARTIFACTS, MAX_ARTIFACT_BYTES, BRANCH_RE, REPOSITORY_RE, GIT, COMMIT_SHA_RE, MAX_TOOL_OUTPUT_CHARS, MAX_TOOL_INPUT_CHARS, MAX_CHECKPOINTS, CELL_CONTROL_DIR, BRIDGE_MARKER, CONTROL_RUNNER, BRIDGE_RUNNER, HEALTH_TIMEOUT_MS, EVENT_POLL_MS, AsterHotcellRuntime, CELL_FILE_WRITE_CHUNK_CHARS, ARTIFACT_MIME_TYPES;
 var init_aster_cell_runtime = __esm({
@@ -20681,9 +20986,9 @@ ${turn.userText}` : turn.userText;
         if (!isSafeArtifactPath(path)) throw new Error("invalid_artifact_path");
         const cell = await this.provider.getCell(cellId);
         const file = shellQuote2(`${ARTIFACTS_DIR}/${path}`);
-        const stat13 = await cell.exec(`[ -f ${file} ] && [ ! -L ${file} ] && stat -c %s -- ${file}`);
-        if (stat13.exitCode !== 0) throw new Error("artifact_not_found");
-        if (Number(stat13.stdout.trim()) > MAX_ARTIFACT_BYTES) throw new Error("artifact_too_large");
+        const stat14 = await cell.exec(`[ -f ${file} ] && [ ! -L ${file} ] && stat -c %s -- ${file}`);
+        if (stat14.exitCode !== 0) throw new Error("artifact_not_found");
+        if (Number(stat14.stdout.trim()) > MAX_ARTIFACT_BYTES) throw new Error("artifact_too_large");
         const encoded = await cell.exec(`base64 -w0 -- ${file}`);
         if (encoded.exitCode !== 0) throw new Error("artifact_not_found");
         return { data: Buffer.from(encoded.stdout.trim(), "base64"), mimeType: artifactMimeType(path), name: path.split("/").pop() ?? path };
@@ -20980,8 +21285,8 @@ var init_hotcell_provider = __esm({
 // src/server/routes.ts
 import { randomUUID as randomUUID9 } from "crypto";
 import { URL as URL2 } from "url";
-import { readFile as readFile27, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve14, basename as basename7 } from "path";
+import { readFile as readFile28, unlink as unlink3 } from "fs/promises";
+import { resolve as resolve15, basename as basename7 } from "path";
 function createHotcellAsterRuntime() {
   try {
     const idlePauseMs = Number(process.env.AUTOPILOT_ASTER_IDLE_PAUSE_MS ?? 15 * 60 * 1e3);
@@ -21064,9 +21369,9 @@ async function resolveFiles2(filePatterns, cwd) {
   const resolved = /* @__PURE__ */ new Set();
   for (const pattern of filePatterns) {
     try {
-      const stat13 = await import("fs/promises").then((m) => m.stat(resolve14(cwd, pattern)));
-      if (stat13.isFile()) {
-        resolved.add(resolve14(cwd, pattern));
+      const stat14 = await import("fs/promises").then((m) => m.stat(resolve15(cwd, pattern)));
+      if (stat14.isFile()) {
+        resolved.add(resolve15(cwd, pattern));
         continue;
       }
     } catch {
@@ -21094,7 +21399,7 @@ async function buildUserMessage2(prompt, files, cwd) {
       }
     } else {
       try {
-        const content = await readFile27(filePath, "utf8");
+        const content = await readFile28(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -21123,7 +21428,7 @@ function setupRoutes(config2, options = {}) {
     if (!run.sessionId) throw new Error("Cannot restore run without a session id: " + run.id);
     const existing = activeRuns.get(run.id) ?? activeSessions.get(run.sessionId);
     if (existing) return existing;
-    const sessionFile = await loadSession(resolve14(sessionsDir(), run.sessionId + ".json"));
+    const sessionFile = await loadSession(resolve15(sessionsDir(), run.sessionId + ".json"));
     const allowedTools = new Set(run.allowedTools);
     allowedTools.add("wait_for");
     const tools = ALL_TOOLS.filter((tool) => allowedTools.has(tool.name));
@@ -21258,7 +21563,7 @@ function setupRoutes(config2, options = {}) {
         const task = typeof body.task === "string" ? body.task.trim() : "";
         let cwd;
         try {
-          cwd = typeof body.cwd === "string" ? resolve14(body.cwd) : process.cwd();
+          cwd = typeof body.cwd === "string" ? resolve15(body.cwd) : process.cwd();
         } catch {
           badRequest(res, "cwd must be a valid path");
           return;
@@ -21371,7 +21676,7 @@ function setupRoutes(config2, options = {}) {
             store.close();
           }
         } catch (error) {
-          await unlink3(resolve14(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          await unlink3(resolve15(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           if (worktree) {
             await worktreeManager.discard(worktree).catch((cleanupError) => {
@@ -21506,7 +21811,7 @@ function setupRoutes(config2, options = {}) {
           return;
         }
         try {
-          const file = await loadSession(resolve14(sessionsDir(), `${sessionId}.json`));
+          const file = await loadSession(resolve15(sessionsDir(), `${sessionId}.json`));
           json2(res, 200, {
             id: file.id,
             cwd: file.cwd,
@@ -21526,7 +21831,7 @@ function setupRoutes(config2, options = {}) {
         activeSessions.delete(sessionId);
         try {
           const { unlink: unlink6 } = await import("fs/promises");
-          await unlink6(resolve14(sessionsDir(), `${sessionId}.json`));
+          await unlink6(resolve15(sessionsDir(), `${sessionId}.json`));
         } catch {
         }
         json2(res, 200, { deleted: sessionId });
@@ -21977,13 +22282,13 @@ async function startServer(opts2) {
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     server.listen(opts2.port, opts2.hostname, () => {
       logger.info("server: listening", { hostname: opts2.hostname, port: opts2.port });
       console.log(`kimiflare serve: http://${opts2.hostname}:${opts2.port}`);
       console.log(`  API docs: http://${opts2.hostname}:${opts2.port}/doc`);
       console.log(`  SSE stream: http://${opts2.hostname}:${opts2.port}/event`);
-      resolve19(server);
+      resolve20(server);
     });
     server.on("error", reject);
   });
@@ -22288,8 +22593,8 @@ async function runEmitMode(opts2) {
   async function nextFollowUp() {
     if (followUpQueue.length > 0) return followUpQueue.shift();
     if (stdinClosed) return null;
-    return new Promise((resolve19) => {
-      followUpResolver = resolve19;
+    return new Promise((resolve20) => {
+      followUpResolver = resolve20;
     });
   }
   const cwd = process.cwd();
@@ -22426,8 +22731,8 @@ async function runEmitMode(opts2) {
               return "allow";
             }
             if (opts2.multiTurn) {
-              const choice = await new Promise((resolve19) => {
-                pendingPermissions.set(reqId, resolve19);
+              const choice = await new Promise((resolve20) => {
+                pendingPermissions.set(reqId, resolve20);
               });
               if (choice === "allow" || choice === "allow_session") {
                 emit("PermissionGranted", { request_id: reqId });
@@ -22562,7 +22867,7 @@ async function runAttachMode(opts2) {
 async function streamSse(url, sessionId, format) {
   const eventSource = new EventSource(`${url}/event`);
   let done = false;
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     eventSource.onmessage = (event) => {
       try {
         const data = JSON.parse(event.data);
@@ -22609,7 +22914,7 @@ async function streamSse(url, sessionId, format) {
             done = true;
             eventSource.close();
             if (format === "text") process.stdout.write("\n");
-            resolve19(void 0);
+            resolve20(void 0);
             break;
           case "error":
             done = true;
@@ -22622,7 +22927,7 @@ async function streamSse(url, sessionId, format) {
               process.stdout.write(JSON.stringify({ event: "error", message: data.message }) + "\n");
             }
             process.exitCode = 1;
-            resolve19(void 0);
+            resolve20(void 0);
             break;
         }
       } catch {
@@ -22648,7 +22953,7 @@ async function streamSseJson(url, sessionId) {
   const toolResults = [];
   let usage;
   const eventSource = new EventSource(`${url}/event`);
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     eventSource.onmessage = (event) => {
       try {
         const data = JSON.parse(event.data);
@@ -22685,7 +22990,7 @@ async function streamSseJson(url, sessionId) {
                 2
               ) + "\n"
             );
-            resolve19(void 0);
+            resolve20(void 0);
             break;
           case "error":
             eventSource.close();
@@ -22693,7 +22998,7 @@ async function streamSseJson(url, sessionId) {
               JSON.stringify({ error: data.message, sessionId }, null, 2) + "\n"
             );
             process.exitCode = 1;
-            resolve19(void 0);
+            resolve20(void 0);
             break;
         }
       } catch {
@@ -23422,10 +23727,9 @@ __export(app_helpers_exports, {
   replaceUserPromptEvent: () => replaceUserPromptEvent,
   trackRecentFile: () => trackRecentFile
 });
-import { execSync as execSync3, spawn as spawn7 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
-import { join as join41 } from "path";
-import { platform as platform3 } from "os";
+import { join as join42 } from "path";
 function replaceQueuedPrompt(queue2, key, full, display) {
   const index = queue2.findIndex((item) => item.key === key);
   if (index >= 0) {
@@ -23532,7 +23836,7 @@ function buildFilePickerIgnoreList(cwd) {
   ];
   const gitignorePatterns = [];
   try {
-    const gitignorePath = join41(cwd, ".gitignore");
+    const gitignorePath = join42(cwd, ".gitignore");
     const stats = statSync5(gitignorePath);
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
@@ -23563,19 +23867,6 @@ function costLookupFromConfig(cfg, meta) {
   if (resolveCustomEndpoint(cfg)) return void 0;
   return { apiKey: cfg.openrouterApiKey, meta };
 }
-function openBrowser(url) {
-  if (process.env.KIMIFLARE_NO_BROWSER === "1" || process.env.BROWSER === "none") return false;
-  try {
-    const os2 = platform3();
-    const [cmd, args] = os2 === "darwin" ? ["open", [url]] : os2 === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-    const child = spawn7(cmd, args, { detached: true, stdio: "ignore" });
-    child.on("error", () => void 0);
-    child.unref();
-    return true;
-  } catch {
-    return false;
-  }
-}
 function detectGitHubRepo(cachedRepo) {
   if (cachedRepo) {
     const parts = cachedRepo.split("/");
@@ -23694,6 +23985,7 @@ var init_app_helpers = __esm({
     init_system_prompt();
     init_image();
     init_queue_batch();
+    init_open_browser();
     MAX_GITIGNORE_SIZE = 1 * 1024 * 1024;
     CONTEXT_LIMIT = 262e3;
     AUTO_COMPACT_THRESHOLD = 0.8;
@@ -23710,9 +24002,9 @@ var init_app_helpers = __esm({
 
 // src/ui/bang-command.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp2, readFile as readFile28, rm as rm5 } from "fs/promises";
-import { tmpdir as tmpdir4, platform as platform4 } from "os";
-import { join as join42 } from "path";
+import { mkdtemp as mkdtemp3, readFile as readFile29, rm as rm6 } from "fs/promises";
+import { tmpdir as tmpdir5, platform as platform4 } from "os";
+import { join as join43 } from "path";
 function registerInkInstance(instance) {
   inkInstance = instance;
 }
@@ -23720,13 +24012,13 @@ function registerTerminalHandoff(h) {
   terminalHandoff = h;
 }
 function runCaptured(inv, cwd) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const child = spawn8(inv.file, inv.args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: inv.env ?? process.env });
     let output = "";
     child.stdout?.on("data", (c) => output += c.toString("utf8"));
     child.stderr?.on("data", (c) => output += c.toString("utf8"));
-    child.once("error", (e) => resolve19({ code: 127, signal: null, output: `failed to start: ${e.message}` }));
-    child.once("exit", (code, signal) => resolve19({ code, signal, output }));
+    child.once("error", (e) => resolve20({ code: 127, signal: null, output: `failed to start: ${e.message}` }));
+    child.once("exit", (code, signal) => resolve20({ code, signal, output }));
   });
 }
 function isTerminalHandedOff() {
@@ -23794,10 +24086,10 @@ function swallow() {
   });
 }
 function spawnInherit(inv, cwd) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const child = spawn8(inv.file, inv.args, { cwd, stdio: "inherit", env: inv.env ?? process.env });
     child.once("error", reject);
-    child.once("exit", (code, signal) => resolve19({ code, signal }));
+    child.once("exit", (code, signal) => resolve20({ code, signal }));
   });
 }
 async function runBangCommand(command, cwd) {
@@ -23815,8 +24107,8 @@ async function runBangCommand(command, cwd) {
   const origErr = stderr.write;
   const readable = stdin.listeners("readable");
   const wasRaw = stdin.isTTY ? stdin.isRaw : false;
-  const logDir2 = isWindows ? null : await mkdtemp2(join42(tmpdir4(), "autopilot-bang-"));
-  const logPath = logDir2 ? join42(logDir2, "out.log") : null;
+  const logDir2 = isWindows ? null : await mkdtemp3(join43(tmpdir5(), "autopilot-bang-"));
+  const logPath = logDir2 ? join43(logDir2, "out.log") : null;
   const viaScript = logPath ? scriptInvocation(command, shell, logPath) : null;
   inkInstance?.clear();
   origOut.call(stdout, `
@@ -23858,9 +24150,9 @@ $ ${command}
   }
   let output = spawnError ? `failed to start: ${spawnError}` : null;
   if (captured && logPath) {
-    output = cleanTerminalOutput(await readFile28(logPath, "utf8").catch(() => ""));
+    output = cleanTerminalOutput(await readFile29(logPath, "utf8").catch(() => ""));
   }
-  if (logDir2) await rm5(logDir2, { recursive: true, force: true }).catch(() => {
+  if (logDir2) await rm6(logDir2, { recursive: true, force: true }).catch(() => {
   });
   return { command, exitCode: result2.code, signal: result2.signal, output };
 }
@@ -26050,10 +26342,10 @@ __export(camouflage_view_exports, {
   toolSummary: () => toolSummary,
   validateCommandName: () => validateCommandName
 });
-import { execFileSync as execFileSync2, spawn as spawn10 } from "child_process";
-import { readdir as readdir7 } from "fs/promises";
+import { execFileSync as execFileSync3, spawn as spawn10 } from "child_process";
+import { readdir as readdir8 } from "fs/promises";
 import { homedir as homedir26 } from "os";
-import { join as join43, resolve as resolve15 } from "path";
+import { join as join44, resolve as resolve16 } from "path";
 async function loadSdk() {
   const sdk = await import("camouflage-tui").catch((err) => {
     throw new CamouflageUnavailable(`camouflage-tui is not installed (${err.message})`);
@@ -26142,14 +26434,14 @@ async function runCamouflageView(opts2) {
   }
 }
 function runShell2(command) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const { shell, args } = getShellCommand();
     const child = spawn10(shell, [...args, command], { env: process.env });
     let out = "";
     child.stdout?.on("data", (c) => out += c.toString("utf8"));
     child.stderr?.on("data", (c) => out += c.toString("utf8"));
-    child.on("close", (code) => resolve19({ ok: code === 0, output: out || (code === 0 ? "" : `Exit code: ${code}`) }));
-    child.on("error", (err) => resolve19({ ok: false, output: err.message }));
+    child.on("close", (code) => resolve20({ ok: code === 0, output: out || (code === 0 ? "" : `Exit code: ${code}`) }));
+    child.on("error", (err) => resolve20({ ok: false, output: err.message }));
   });
 }
 function syncSlashCommands(custom, lastKey, send) {
@@ -26232,10 +26524,10 @@ function truncateText(s, max) {
 async function listMentionDir(cwd, query) {
   const exact = query === "~" || query === "." || query === ".." || query.endsWith("/..");
   const dir = exact ? `${query}/` : query.slice(0, query.lastIndexOf("/") + 1);
-  const expanded = dir.startsWith("~") ? join43(homedir26(), dir.slice(1)) : dir;
-  const target = resolve15(cwd, expanded || ".");
+  const expanded = dir.startsWith("~") ? join44(homedir26(), dir.slice(1)) : dir;
+  const target = resolve16(cwd, expanded || ".");
   try {
-    const items = await readdir7(target, { withFileTypes: true });
+    const items = await readdir8(target, { withFileTypes: true });
     const entries = items.filter((d) => !d.name.startsWith(".")).map((d) => ({ name: d.name, isDir: d.isDirectory() })).sort((a, b) => a.isDir !== b.isDir ? a.isDir ? -1 : 1 : a.name.localeCompare(b.name)).slice(0, 300).map((d) => `${dir}${d.name}${d.isDir ? "/" : ""}`);
     return { dir, entries };
   } catch {
@@ -26318,14 +26610,14 @@ function shortPath(p) {
 }
 function gitBranch(cwd) {
   try {
-    return execFileSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8", timeout: 500, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return execFileSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8", timeout: 500, stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
     return "";
   }
 }
 function listFiles(cwd) {
   try {
-    const out = execFileSync2("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+    const out = execFileSync3("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
       cwd,
       encoding: "utf8",
       timeout: 2e3,
@@ -29224,19 +29516,19 @@ function usePermissionController(getMode, onPlanModeBlocked) {
   const onPlanModeBlockedRef = useRef3(onPlanModeBlocked);
   onPlanModeBlockedRef.current = onPlanModeBlocked;
   const askPermission = useCallback2(
-    (req, askOpts) => new Promise((resolve19) => {
+    (req, askOpts) => new Promise((resolve20) => {
       const outcome = decidePermission(req, getModeRef.current(), askOpts);
       if (outcome.kind === "resolve") {
-        resolve19(outcome.decision);
+        resolve20(outcome.decision);
         return;
       }
       if (outcome.kind === "plan_blocked") {
         onPlanModeBlockedRef.current(outcome.toolName);
-        resolve19(AUTO_DENY);
+        resolve20(AUTO_DENY);
         return;
       }
-      resolveRef.current = resolve19;
-      setPending({ tool: req.tool, args: req.args, resolve: resolve19 });
+      resolveRef.current = resolve20;
+      setPending({ tool: req.tool, args: req.args, resolve: resolve20 });
     }),
     []
   );
@@ -29581,9 +29873,9 @@ var init_queue_plan_picker = __esm({
 });
 
 // src/agent/jev-context.ts
-import { execFileSync as execFileSync3 } from "child_process";
-import { readFile as readFile29 } from "fs/promises";
-import { basename as basename8, join as join44, resolve as resolve16 } from "path";
+import { execFileSync as execFileSync4 } from "child_process";
+import { readFile as readFile30 } from "fs/promises";
+import { basename as basename8, join as join45, resolve as resolve17 } from "path";
 function messageText(message2) {
   if (typeof message2.content === "string") return message2.content.trim();
   if (!Array.isArray(message2.content)) return "";
@@ -29594,18 +29886,18 @@ function redactCommonSecrets(text) {
 }
 function projectRoot(cwd) {
   try {
-    return execFileSync3("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+    return execFileSync4("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 1e3
     }).trim();
   } catch {
-    return resolve16(cwd);
+    return resolve17(cwd);
   }
 }
 async function readPackageMetadata(root) {
   try {
-    const parsed = JSON.parse(await readFile29(join44(root, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile30(join45(root, "package.json"), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const pkg = parsed;
     const metadata = {};
@@ -29622,7 +29914,7 @@ async function readPackageMetadata(root) {
 async function readLicenseEvidence(root) {
   for (const name of ["LICENSE", "LICENSE.md", "LICENSE.txt", "LICENCE", "COPYING"]) {
     try {
-      const content = (await readFile29(join44(root, name), "utf8")).trim();
+      const content = (await readFile30(join45(root, name), "utf8")).trim();
       if (content) return { source: `project license (${name})`, content: content.slice(0, 700) };
     } catch {
     }
@@ -29655,7 +29947,7 @@ async function buildJevContext(question, messages, cwd = process.cwd()) {
       conversationRemaining -= source.length + content.length + 2;
     }
   }
-  const currentDirectory = basename8(resolve16(cwd));
+  const currentDirectory = basename8(resolve17(cwd));
   const escapedDirectory = currentDirectory.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const namesCurrentDirectory = currentDirectory.length >= 5 && !/^(?:agent|app|code|lib|project|repo|src|test|tests|workspace)$/i.test(currentDirectory) && new RegExp(`\\b${escapedDirectory}\\b`, "i").test(question);
   if (CURRENT_PROJECT_REFERENCE.test(question) || namesCurrentDirectory) {
@@ -30704,8 +30996,8 @@ var init_frontmatter = __esm({
 });
 
 // src/skills/loader.ts
-import { readFile as readFile30, readdir as readdir8, stat as stat10 } from "fs/promises";
-import { join as join45, extname } from "path";
+import { readFile as readFile31, readdir as readdir9, stat as stat11 } from "fs/promises";
+import { join as join46, extname } from "path";
 function normalizeManifest(raw, filePath) {
   const name = typeof raw.name === "string" ? raw.name : "";
   const description = typeof raw.description === "string" ? raw.description : "";
@@ -30719,7 +31011,7 @@ function normalizeManifest(raw, filePath) {
   return { name, description, match, scope, priority, enabled: enabled2 };
 }
 async function loadSkillFile(filePath) {
-  const raw = await readFile30(filePath, "utf-8");
+  const raw = await readFile31(filePath, "utf-8");
   const parsed = parseFrontmatter(raw);
   const manifest = normalizeManifest(parsed.data, filePath);
   const body = parsed.content.trim();
@@ -30738,11 +31030,11 @@ async function loadSkillFile(filePath) {
 }
 async function loadSkillsFromDir(dirPath) {
   try {
-    const entries = await readdir8(dirPath);
+    const entries = await readdir9(dirPath);
     const files = [];
     for (const entry of entries) {
-      const full = join45(dirPath, entry);
-      const s = await stat10(full);
+      const full = join46(dirPath, entry);
+      const s = await stat11(full);
       if (s.isFile() && extname(entry) === ".md") {
         files.push(full);
       }
@@ -30769,12 +31061,12 @@ var init_loader = __esm({
 });
 
 // src/skills/manager.ts
-import { mkdir as mkdir17, writeFile as writeFile15, unlink as unlink4, readFile as readFile31 } from "fs/promises";
-import { join as join46 } from "path";
+import { mkdir as mkdir18, writeFile as writeFile16, unlink as unlink4, readFile as readFile32 } from "fs/promises";
+import { join as join47 } from "path";
 function getSkillDirs(cwd) {
   return {
-    projectDir: join46(cwd, ".kimiflare", "skills"),
-    globalDir: join46(process.env.HOME ?? "", ".config", "kimiflare", "skills")
+    projectDir: join47(cwd, ".kimiflare", "skills"),
+    globalDir: join47(process.env.HOME ?? "", ".config", "kimiflare", "skills")
   };
 }
 async function listAllSkills(cwd) {
@@ -30788,7 +31080,7 @@ async function listAllSkills(cwd) {
 async function createSkill(opts2) {
   const dirs = getSkillDirs(opts2.cwd);
   const dir = opts2.scope === "project" ? dirs.projectDir : dirs.globalDir;
-  const filepath = join46(dir, `${opts2.name}.md`);
+  const filepath = join47(dir, `${opts2.name}.md`);
   const frontmatter = {
     name: opts2.name,
     enabled: true,
@@ -30809,8 +31101,8 @@ ${yaml}
 
 Add your instructions here.
 `;
-  await mkdir17(dir, { recursive: true });
-  await writeFile15(filepath, content, "utf8");
+  await mkdir18(dir, { recursive: true });
+  await writeFile16(filepath, content, "utf8");
   return { filepath };
 }
 async function deleteSkill(name, cwd) {
@@ -30824,7 +31116,7 @@ async function setSkillEnabled(name, enabled2, cwd) {
   const all = await listAllSkills(cwd);
   const skill = all.project.find((s) => s.name === name) ?? all.global.find((s) => s.name === name);
   if (!skill) throw new Error(`skill "${name}" not found`);
-  const raw = await readFile31(skill.filePath, "utf-8");
+  const raw = await readFile32(skill.filePath, "utf-8");
   const parsed = parseFrontmatter(raw);
   parsed.data.enabled = enabled2;
   const yaml = Object.entries(parsed.data).map(([k, v]) => {
@@ -30836,7 +31128,7 @@ ${v.map((item) => `  - ${item}`).join("\n")}`;
 ${yaml}
 ---
 ${parsed.content}`;
-  await writeFile15(skill.filePath, content, "utf8");
+  await writeFile16(skill.filePath, content, "utf8");
   return { filepath: skill.filePath };
 }
 async function findSkillFile(name, cwd) {
@@ -31096,15 +31388,15 @@ var tui_report_exports = {};
 __export(tui_report_exports, {
   getCategoryReportText: () => getCategoryReportText
 });
-import { readFile as readFile32 } from "fs/promises";
-import { join as join47 } from "path";
+import { readFile as readFile33 } from "fs/promises";
+import { join as join48 } from "path";
 import { homedir as homedir27 } from "os";
 function usageDir3() {
-  const xdg = process.env.XDG_DATA_HOME || join47(homedir27(), ".local", "share");
-  return join47(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join48(homedir27(), ".local", "share");
+  return join48(xdg, "kimiflare");
 }
 function usagePath4() {
-  return join47(usageDir3(), "usage.json");
+  return join48(usageDir3(), "usage.json");
 }
 function today3() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -31116,7 +31408,7 @@ function daysAgo2(n) {
 }
 async function loadLog3() {
   try {
-    const raw = await readFile32(usagePath4(), "utf8");
+    const raw = await readFile33(usagePath4(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -31173,7 +31465,7 @@ var init_tui_report = __esm({
 });
 
 // src/ui/slash-commands.ts
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 import QRCode from "qrcode";
 function executeFreshStart(ctx, planText, overrideMode, opts2 = {}) {
   const oldSessionId = ctx.sessionIdRef.current;
@@ -31644,7 +31936,7 @@ auto (default) lets the coordinator assess substantial tasks and delegate indepe
         const context = noContext ? [] : await buildJevContext(question.prompt, ctx.messagesRef.current, process.cwd());
         const receipt = formatJevContextReceipt(context, showContext);
         setResult(eventKey, { kind: "info", key: eventKey, text: `Jev is evaluating \xB7 ${receipt}`, pending: true });
-        await new Promise((resolve19) => setTimeout(resolve19, 0));
+        await new Promise((resolve20) => setTimeout(resolve20, 0));
         const answer = await askJev(apiKey, question, { context });
         const presentation = presentJevAnswer(question, answer);
         setResult(eventKey, {
@@ -32105,7 +32397,7 @@ ${lines.join("\n")}` }]);
         void (async () => {
           try {
             const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-            const file = await loadSession(join48(sessionsDir3(), `${currentId}.json`));
+            const file = await loadSession(join49(sessionsDir3(), `${currentId}.json`));
             const cps = file.checkpoints ?? [];
             if (cps.length === 0) {
               setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: "no checkpoints in this session" }]);
@@ -32150,7 +32442,7 @@ ${lines.join("\n")}` }]);
         try {
           ctx.ensureSessionId();
           const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-          const filePath = join48(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
+          const filePath = join49(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
           await addCheckpoint(filePath, cp);
           setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: `checkpoint saved: "${label}"` }]);
         } catch (e) {
@@ -33206,9 +33498,9 @@ async function startLoopbackListener(opts2 = {}) {
     rejectCode(e);
     finish();
   }
-  await new Promise((resolve19, reject) => {
+  await new Promise((resolve20, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve19());
+    server.listen(0, "127.0.0.1", () => resolve20());
   });
   const address = server.address();
   const port = typeof address === "object" && address ? address.port : 0;
@@ -33634,15 +33926,15 @@ var init_frontmatter2 = __esm({
 });
 
 // src/commands/loader.ts
-import { open, realpath as realpath6 } from "fs/promises";
+import { open, realpath as realpath7 } from "fs/promises";
 import { homedir as homedir28 } from "os";
-import { join as join49, relative as relative10, sep as sep6 } from "path";
+import { join as join50, relative as relative11, sep as sep7 } from "path";
 function projectCommandsDir(cwd = process.cwd()) {
-  return join49(cwd, ".kimiflare", "commands");
+  return join50(cwd, ".kimiflare", "commands");
 }
 function globalCommandsDir() {
-  const xdg = process.env.XDG_CONFIG_HOME || join49(homedir28(), ".config");
-  return join49(xdg, "kimiflare", "commands");
+  const xdg = process.env.XDG_CONFIG_HOME || join50(homedir28(), ".config");
+  return join50(xdg, "kimiflare", "commands");
 }
 async function loadCustomCommands(cwd = process.cwd()) {
   const warnings = [];
@@ -33681,7 +33973,7 @@ async function loadCustomCommands(cwd = process.cwd()) {
 async function resolveSafeDir(dir, source, cwd, warnings) {
   let realDir;
   try {
-    realDir = await realpath6(dir);
+    realDir = await realpath7(dir);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -33692,11 +33984,11 @@ async function resolveSafeDir(dir, source, cwd, warnings) {
   if (source === "project") {
     let realCwd;
     try {
-      realCwd = await realpath6(cwd);
+      realCwd = await realpath7(cwd);
     } catch {
       return null;
     }
-    const rel = relative10(realCwd, realDir);
+    const rel = relative11(realCwd, realDir);
     if (rel !== "" && isPathOutside(rel)) {
       warnings.push(`commands dir ${dir} escapes workspace via symlink \u2014 skipped`);
       return null;
@@ -33771,10 +34063,10 @@ async function loadOne(file, rootDir, source, warnings) {
   return cmd;
 }
 function filenameToCommandName(file, rootDir) {
-  const rel = relative10(rootDir, file);
+  const rel = relative11(rootDir, file);
   if (!rel || isPathOutside(rel)) return null;
   const noExt = rel.replace(/\.md$/i, "");
-  const parts = noExt.split(sep6).filter((p) => p.length > 0);
+  const parts = noExt.split(sep7).filter((p) => p.length > 0);
   if (parts.length === 0) return null;
   if (parts.some((p) => !/^[\w.-]+$/.test(p))) return null;
   return parts.join("/");
@@ -33794,8 +34086,8 @@ var init_loader2 = __esm({
 
 // src/commands/renderer.ts
 import { exec } from "child_process";
-import { open as open2, realpath as realpath7 } from "fs/promises";
-import { isAbsolute as isAbsolute7, relative as relative11, resolve as resolvePathJoin, basename as pathBasename } from "path";
+import { open as open2, realpath as realpath8 } from "fs/promises";
+import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolvePathJoin, basename as pathBasename } from "path";
 import { promisify as promisify9 } from "util";
 function tokenizeArgs(s) {
   return [...s.matchAll(ARG_TOKEN_RE)].map((match) => {
@@ -33886,7 +34178,7 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
       return "" + trailing;
     });
   }
-  const realCwd = await realpath7(cwd).catch(() => cwd);
+  const realCwd = await realpath8(cwd).catch(() => cwd);
   const replacements = await Promise.all(
     matches.map(async (match) => {
       const rawPath = match[1] ?? "";
@@ -33895,23 +34187,23 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
         warnings.push(`file inclusion blocked: @${rawPath} \u2014 secret file pattern`);
         return "";
       }
-      if (isAbsolute7(rawPath) || rawPath.startsWith("~")) {
+      if (isAbsolute8(rawPath) || rawPath.startsWith("~")) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 outside workspace`);
         return "";
       }
       const resolved = resolvePathJoin(cwd, rawPath);
-      if (isPathOutside(relative11(cwd, resolved))) {
+      if (isPathOutside(relative12(cwd, resolved))) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 outside workspace`);
         return "";
       }
       let real;
       try {
-        real = await realpath7(resolved);
+        real = await realpath8(resolved);
       } catch (error) {
         warnings.push(`file inclusion failed: @${rawPath} \u2014 ${message(error)}`);
         return "";
       }
-      if (isPathOutside(relative11(realCwd, real))) {
+      if (isPathOutside(relative12(realCwd, real))) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 symlink escapes workspace`);
         return "";
       }
@@ -34024,11 +34316,11 @@ var init_wcag = __esm({
 });
 
 // src/ui/theme-loader.ts
-import { readFile as readFile33, readdir as readdir9 } from "fs/promises";
-import { join as join50 } from "path";
+import { readFile as readFile34, readdir as readdir10 } from "fs/promises";
+import { join as join51 } from "path";
 import { homedir as homedir29 } from "os";
 function projectThemesDir(cwd = process.cwd()) {
-  return join50(cwd, ".kimiflare", "themes");
+  return join51(cwd, ".kimiflare", "themes");
 }
 function isHexColor(c) {
   return /^#[0-9a-fA-F]{6}$/.test(c);
@@ -34112,15 +34404,15 @@ async function loadThemesFromDir(dir, source) {
   const errors = [];
   let files;
   try {
-    files = await readdir9(dir);
+    files = await readdir10(dir);
   } catch {
     return { themes, errors };
   }
   for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const path = join50(dir, file);
+    const path = join51(dir, file);
     let raw;
     try {
-      raw = await readFile33(path, "utf-8");
+      raw = await readFile34(path, "utf-8");
     } catch (e) {
       errors.push(`${path}: ${e instanceof Error ? e.message : String(e)}`);
       continue;
@@ -34266,8 +34558,8 @@ var init_theme_loader = __esm({
     "use strict";
     init_wcag();
     init_theme();
-    USER_THEMES_DIR = join50(
-      process.env.XDG_CONFIG_HOME || join50(homedir29(), ".config"),
+    USER_THEMES_DIR = join51(
+      process.env.XDG_CONFIG_HOME || join51(homedir29(), ".config"),
       "kimiflare",
       "themes"
     );
@@ -36798,9 +37090,9 @@ var init_resume_progress = __esm({
 });
 
 // src/agent/supervisor.ts
-import { readdir as readdir10, readFile as readFile34, stat as stat11 } from "fs/promises";
+import { readdir as readdir11, readFile as readFile35, stat as stat12 } from "fs/promises";
 import { createHash as createHash7 } from "crypto";
-import { resolve as resolve17, join as join51 } from "path";
+import { resolve as resolve18, join as join52 } from "path";
 var TurnSupervisor;
 var init_supervisor = __esm({
   "src/agent/supervisor.ts"() {
@@ -37190,12 +37482,12 @@ var init_input_handlers = __esm({
 
 // src/init/context-generator.ts
 import { existsSync as existsSync9, statSync as statSync6 } from "fs";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 function detectFlavor(cwd) {
   for (const [flavor, signatures] of Object.entries(FLAVOR_SIGNATURES)) {
     if (flavor === "generic") continue;
     for (const sig of signatures) {
-      const path = join52(cwd, sig);
+      const path = join53(cwd, sig);
       if (sig.includes("*")) {
         try {
           const parts = sig.split("*");
@@ -37216,14 +37508,14 @@ function detectFlavor(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (existsSync9(join52(cwd, c))) return c;
+    if (existsSync9(join53(cwd, c))) return c;
   }
   return null;
 }
 function findSourceRoots(cwd) {
   const roots = [];
   for (const r of SOURCE_ROOT_CANDIDATES) {
-    const p = join52(cwd, r);
+    const p = join53(cwd, r);
     try {
       const s = statSync6(p);
       if (s.isDirectory()) roots.push(r);
@@ -37234,9 +37526,9 @@ function findSourceRoots(cwd) {
 }
 function findCiConfig(cwd) {
   for (const c of CI_PATHS) {
-    if (existsSync9(join52(cwd, c))) {
+    if (existsSync9(join53(cwd, c))) {
       try {
-        const s = statSync6(join52(cwd, c));
+        const s = statSync6(join53(cwd, c));
         return s.isDirectory() ? c : c;
       } catch {
       }
@@ -37373,7 +37665,7 @@ function analyzeProject(cwd) {
     ciConfig: findCiConfig(cwd),
     readme: findFile(cwd, ["README.md", "README.rst", "README.txt", "Readme.md"]),
     sourceRoots: findSourceRoots(cwd),
-    hasGit: existsSync9(join52(cwd, ".git"))
+    hasGit: existsSync9(join53(cwd, ".git"))
   };
 }
 function bashDiscoveryCommands(profile) {
@@ -37538,7 +37830,7 @@ Aim for 100\u2013200 lines total. Use markdown tables where they save space.
 }
 function buildInitPrompt(cwd) {
   const existingName = ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].find(
-    (n) => existsSync9(join52(cwd, n))
+    (n) => existsSync9(join53(cwd, n))
   );
   const isRefresh = existingName !== void 0;
   const targetFilename = existingName ?? "AGENTS.md";
@@ -37622,7 +37914,7 @@ var init_context_generator = __esm({
 
 // src/init/run-init.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 async function runInit(deps) {
   const {
     cfg,
@@ -37715,7 +38007,7 @@ async function runInit(deps) {
           lspManagerRef.current.notifyChange(path, content);
         } else {
           void import("fs/promises").then(
-            ({ readFile: readFile36 }) => readFile36(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
+            ({ readFile: readFile37 }) => readFile37(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
             })
           );
         }
@@ -37820,7 +38112,7 @@ async function runInit(deps) {
         }
       }
     });
-    if (existsSync10(join53(cwd, targetFilename))) {
+    if (existsSync10(join54(cwd, targetFilename))) {
       if (cacheStableRef.current) {
         messagesRef.current[1] = {
           role: "system",
@@ -37912,11 +38204,11 @@ var init_run_init = __esm({
 });
 
 // src/skills/discovery.ts
-import { readdir as readdir11, stat as stat12, readFile as readFile35 } from "fs/promises";
-import { join as join54, extname as extname2 } from "path";
+import { readdir as readdir12, stat as stat13, readFile as readFile36 } from "fs/promises";
+import { join as join55, extname as extname2 } from "path";
 async function dirExists(path) {
   try {
-    const s = await stat12(path);
+    const s = await stat13(path);
     return s.isDirectory();
   } catch {
     return false;
@@ -37924,7 +38216,7 @@ async function dirExists(path) {
 }
 async function fileExists(path) {
   try {
-    const s = await stat12(path);
+    const s = await stat13(path);
     return s.isFile();
   } catch {
     return false;
@@ -37932,25 +38224,25 @@ async function fileExists(path) {
 }
 async function scanSkillDir(dirPath, source) {
   if (!await dirExists(dirPath)) return [];
-  const entries = await readdir11(dirPath, { withFileTypes: true });
+  const entries = await readdir12(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!SKILL_EXTENSIONS.has(extname2(entry.name))) continue;
-    files.push({ filePath: join54(dirPath, entry.name), source });
+    files.push({ filePath: join55(dirPath, entry.name), source });
   }
   return files;
 }
 async function discoverSkills(cwd) {
-  const agentsSkills = await scanSkillDir(join54(cwd, ".agents", "skills"), "agents");
-  const agentsMd = await fileExists(join54(cwd, "AGENTS.md")) ? [{ filePath: join54(cwd, "AGENTS.md"), source: "agents-md" }] : [];
-  const githubSkills = await scanSkillDir(join54(cwd, ".github", "skills"), "github");
-  const kimiflareSkills = await scanSkillDir(join54(cwd, ".kimiflare", "skills"), "kimiflare");
+  const agentsSkills = await scanSkillDir(join55(cwd, ".agents", "skills"), "agents");
+  const agentsMd = await fileExists(join55(cwd, "AGENTS.md")) ? [{ filePath: join55(cwd, "AGENTS.md"), source: "agents-md" }] : [];
+  const githubSkills = await scanSkillDir(join55(cwd, ".github", "skills"), "github");
+  const kimiflareSkills = await scanSkillDir(join55(cwd, ".kimiflare", "skills"), "kimiflare");
   const ordered = [...agentsSkills, ...agentsMd, ...githubSkills, ...kimiflareSkills];
   return ordered;
 }
 async function readSkillFile(filePath) {
-  const bytes = await readFile35(filePath);
+  const bytes = await readFile36(filePath);
   return { bytes, text: bytes.toString("utf-8") };
 }
 var SKILL_EXTENSIONS;
@@ -38156,7 +38448,7 @@ var init_skills = __esm({
 
 // src/ui/run-startup-tasks.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 function runStartupTasks(deps) {
   const {
     cfg,
@@ -38179,7 +38471,7 @@ function runStartupTasks(deps) {
     }
   });
   if (cfg.memoryEnabled) {
-    const dbPath = cfg.memoryDbPath ?? join55(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = cfg.memoryDbPath ?? join56(process.cwd(), ".kimiflare", "memory.db");
     const manager = new MemoryManager({
       dbPath,
       ...auth,
@@ -38211,7 +38503,7 @@ function runStartupTasks(deps) {
     });
     const cwd = process.cwd();
     sessionStartRecallRef.current = manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
-    if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync11(join55(cwd, name)))) {
+    if (["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync11(join56(cwd, name)))) {
       const lastRefresh = manager.getLastKimiMdRefreshTime(cwd);
       const driftCount = manager.countHighSignalMemoriesSince(cwd, lastRefresh);
       if (driftCount >= 5) {
@@ -38222,7 +38514,7 @@ function runStartupTasks(deps) {
     memoryManagerRef.current?.close();
     memoryManagerRef.current = null;
   }
-  const skillDbPath = cfg.memoryDbPath ?? join55(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = cfg.memoryDbPath ?? join56(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -38579,7 +38871,7 @@ var init_run_compact = __esm({
 });
 
 // src/commands/save.ts
-import { mkdir as mkdir18, writeFile as writeFile16, unlink as unlink5 } from "fs/promises";
+import { mkdir as mkdir19, writeFile as writeFile17, unlink as unlink5 } from "fs/promises";
 import { dirname as dirname21 } from "path";
 async function saveCustomCommand(opts2) {
   const dir = opts2.source === "project" ? projectCommandsDir(opts2.cwd) : globalCommandsDir();
@@ -38591,8 +38883,8 @@ async function saveCustomCommand(opts2) {
   if (opts2.effort) data.effort = opts2.effort;
   const frontmatter = serializeFrontmatter(data);
   const content = frontmatter + opts2.template;
-  await mkdir18(dirname21(filepath), { recursive: true });
-  await writeFile16(filepath, content, "utf8");
+  await mkdir19(dirname21(filepath), { recursive: true });
+  await writeFile17(filepath, content, "utf8");
   return { filepath };
 }
 async function deleteCustomCommand(cmd) {
@@ -38715,7 +39007,7 @@ __export(app_exports, {
 import React25, { useState as useState27, useRef as useRef9, useEffect as useEffect11, useCallback as useCallback8, useMemo as useMemo6 } from "react";
 import { Box as Box40, Text as Text41, useApp, useInput as useInput19, useWindowSize as useWindowSize2, render } from "ink";
 import { existsSync as existsSync12 } from "fs";
-import { join as join56, resolve as resolve18 } from "path";
+import { join as join57, resolve as resolve19 } from "path";
 import { homedir as homedir30 } from "os";
 import { jsx as jsx42, jsxs as jsxs39 } from "react/jsx-runtime";
 function App({
@@ -39043,8 +39335,8 @@ ${wcagWarnings.join("\n")}` }
       const exactDirectory = query === "~" || query === "." || query === ".." || query.endsWith("/..");
       const prefix = exactDirectory ? `${query.replace(/\/$/, "")}/` : slash >= 0 ? query.slice(0, slash + 1) : "";
       const directory = exactDirectory ? query : slash >= 0 ? query.slice(0, slash + 1) : query;
-      const expanded = directory.startsWith("~") ? join56(homedir30(), directory.slice(1)) : directory;
-      const target = resolve18(cwd, expanded || ".");
+      const expanded = directory.startsWith("~") ? join57(homedir30(), directory.slice(1)) : directory;
+      const target = resolve19(cwd, expanded || ".");
       const entries2 = await glob("*", {
         cwd: target,
         dot: false,
@@ -40026,7 +40318,7 @@ ${result2.output ?? "(output not captured)"}`,
         }
       }
       turnCounterRef.current += 1;
-      if (turnCounterRef.current % 15 === 0 && ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync12(join56(process.cwd(), name))) && !kimiMdStale) {
+      if (turnCounterRef.current % 15 === 0 && ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].some((name) => existsSync12(join57(process.cwd(), name))) && !kimiMdStale) {
         setEvents((e) => [
           ...e,
           { kind: "info", key: mkKey(), text: "Tip: Rerunning /init occasionally helps autopilot (formerly kimiflare) stay accurate as your project evolves." }
@@ -40050,7 +40342,7 @@ ${result2.output ?? "(output not captured)"}`,
                 };
                 ensureSessionId();
                 const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                const filePath = join56(sessionsDir3(), `${sessionIdRef.current}.json`);
+                const filePath = join57(sessionsDir3(), `${sessionIdRef.current}.json`);
                 await addCheckpoint(filePath, cp);
               }
               const summary = await generateContinuationSummary({
@@ -40381,7 +40673,7 @@ ${result2.output ?? "(output not captured)"}`,
               lspManagerRef.current.notifyChange(path, content2);
             } else {
               void import("fs/promises").then(
-                ({ readFile: readFile36 }) => readFile36(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
+                ({ readFile: readFile37 }) => readFile37(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
                 })
               );
             }
@@ -40574,7 +40866,7 @@ ${result2.output ?? "(output not captured)"}`,
                       };
                       ensureSessionId();
                       const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                      const filePath = join56(sessionsDir3(), `${sessionIdRef.current}.json`);
+                      const filePath = join57(sessionsDir3(), `${sessionIdRef.current}.json`);
                       await addCheckpoint(filePath, cp);
                     }
                     const summary = await generateContinuationSummary({
@@ -41141,7 +41433,7 @@ ${result2.output ?? "(output not captured)"}`,
       lsp: {
         servers: cfg?.lspServers ?? {},
         scope: lspScope,
-        hasProjectDir: existsSync12(join56(process.cwd(), ".kimiflare"))
+        hasProjectDir: existsSync12(join57(process.cwd(), ".kimiflare"))
       }
     });
   });
@@ -41198,7 +41490,7 @@ ${result2.output ?? "(output not captured)"}`,
         onCommandDelete: handleCommandDelete2,
         lspServers: cfg?.lspServers ?? {},
         lspScope,
-        hasProjectDir: existsSync12(join56(process.cwd(), ".kimiflare")),
+        hasProjectDir: existsSync12(join57(process.cwd(), ".kimiflare")),
         onLspSave: handleLspSave2,
         themes: themeList(),
         onPickTheme: handleThemePick,
@@ -41685,11 +41977,11 @@ init_classify();
 init_subagent_policy();
 init_trace();
 init_registry2();
-import { readFile as readFile15 } from "fs/promises";
-import { resolve as resolve6, basename as basename3 } from "path";
+import { readFile as readFile16 } from "fs/promises";
+import { resolve as resolve7, basename as basename3 } from "path";
 async function resolveSession(opts2) {
   if (opts2.sessionId) {
-    const filePath = resolve6(sessionsDir(), `${opts2.sessionId}.json`);
+    const filePath = resolve7(sessionsDir(), `${opts2.sessionId}.json`);
     try {
       const file = await loadSession(filePath);
       return { sessionFile: file, isNew: false };
@@ -41697,7 +41989,7 @@ async function resolveSession(opts2) {
     }
   }
   if (opts2.continueSession) {
-    const cwd = opts2.dir ? resolve6(opts2.dir) : process.cwd();
+    const cwd = opts2.dir ? resolve7(opts2.dir) : process.cwd();
     const sessions = await listSessions(1, cwd);
     if (sessions.length > 0) {
       const filePath = sessions[0].filePath;
@@ -41710,7 +42002,7 @@ async function resolveSession(opts2) {
   return {
     sessionFile: {
       id,
-      cwd: opts2.dir ? resolve6(opts2.dir) : process.cwd(),
+      cwd: opts2.dir ? resolve7(opts2.dir) : process.cwd(),
       model: opts2.model,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -41724,9 +42016,9 @@ async function resolveFiles(filePatterns, cwd) {
   const resolved = /* @__PURE__ */ new Set();
   for (const pattern of filePatterns) {
     try {
-      const stat13 = await import("fs/promises").then((m) => m.stat(resolve6(cwd, pattern)));
-      if (stat13.isFile()) {
-        resolved.add(resolve6(cwd, pattern));
+      const stat14 = await import("fs/promises").then((m) => m.stat(resolve7(cwd, pattern)));
+      if (stat14.isFile()) {
+        resolved.add(resolve7(cwd, pattern));
         continue;
       }
     } catch {
@@ -41754,7 +42046,7 @@ async function buildUserMessage(prompt, files, cwd) {
       }
     } else {
       try {
-        const content = await readFile15(filePath, "utf8");
+        const content = await readFile16(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -41789,7 +42081,7 @@ async function runPrintMode(opts2) {
 `
     );
   }
-  const cwd = opts2.dir ? resolve6(opts2.dir) : process.cwd();
+  const cwd = opts2.dir ? resolve7(opts2.dir) : process.cwd();
   const baseWorkerTools = getWorkerTools(opts2.workerProfile);
   const { HooksManager: HooksManager2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports));
   const hooks = new HooksManager2(cwd);
@@ -42469,11 +42761,11 @@ async function promptHidden(question) {
     }
   });
   const rl = createInterface4({ input: process.stdin, output, terminal: true });
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     rl.question(question, (answer) => {
       rl.close();
       process.stdout.write("\n");
-      resolve19(answer);
+      resolve20(answer);
     });
     muted = true;
   });