autopilot-ai 1.24.2 → 1.25.1

package/dist/index.js

@@ -1,9 +1,5 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -18,33 +14,10 @@ var __esm = (fn, res, err) => function __init() {
     throw err = [e], e;
   }
 };
-var __commonJS = (cb, mod) => function __require2() {
-  try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  } catch (e) {
-    throw mod = 0, e;
-  }
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 
 // src/util/log-sink.ts
 var log_sink_exports = {};
@@ -102,8 +75,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() {
@@ -1289,13 +1262,13 @@ async function checkDeployStatus() {
   }
   return { wrangler, wranglerAuth, docker, workerUrl };
 }
-var __dirname2, REMOTE_DIR, WORKER_DIR;
+var __dirname, REMOTE_DIR, WORKER_DIR;
 var init_deploy = __esm({
   "src/remote/deploy.ts"() {
     "use strict";
     init_config();
-    __dirname2 = dirname4(fileURLToPath3(import.meta.url));
-    REMOTE_DIR = join7(__dirname2, "..", "..", "..", "remote");
+    __dirname = dirname4(fileURLToPath3(import.meta.url));
+    REMOTE_DIR = join7(__dirname, "..", "..", "..", "remote");
     WORKER_DIR = join7(REMOTE_DIR, "worker");
   }
 });
@@ -1342,10 +1315,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 +2755,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 +2824,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);
@@ -2993,7 +2967,7 @@ async function pruneFiles(files, maxAgeDays, maxCount) {
   return removed;
 }
 async function rotateJsonl(path, maxBytes, rotations) {
-  const { rename: rename3 } = await import("fs/promises");
+  const { rename: rename4 } = await import("fs/promises");
   let s;
   try {
     s = await stat2(path);
@@ -3005,7 +2979,7 @@ async function rotateJsonl(path, maxBytes, rotations) {
     const src = i === 1 ? path : `${path}.${i - 1}`;
     const dst = `${path}.${i}`;
     try {
-      await rename3(src, dst);
+      await rename4(src, dst);
     } catch {
     }
   }
@@ -3574,197 +3548,6 @@ var init_api_generator = __esm({
   }
 });
 
-// node_modules/node-gyp-build/node-gyp-build.js
-var require_node_gyp_build = __commonJS({
-  "node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs");
-    var path = __require("path");
-    var os2 = __require("os");
-    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
-    var vars = process.config && process.config.variables || {};
-    var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
-    var abi = process.versions.modules;
-    var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-    var arch = process.env.npm_config_arch || os2.arch();
-    var platform8 = process.env.npm_config_platform || os2.platform();
-    var libc = process.env.LIBC || (isAlpine(platform8) ? "musl" : "glibc");
-    var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
-    var uv = (process.versions.uv || "").split(".")[0];
-    module.exports = load;
-    function load(dir) {
-      return runtimeRequire(load.resolve(dir));
-    }
-    load.resolve = load.path = function(dir) {
-      dir = path.resolve(dir || ".");
-      try {
-        var name = runtimeRequire(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
-        if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
-      } catch (err) {
-      }
-      if (!prebuildsOnly) {
-        var release2 = getFirst(path.join(dir, "build/Release"), matchBuild);
-        if (release2) return release2;
-        var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
-        if (debug) return debug;
-      }
-      var prebuild = resolve19(dir);
-      if (prebuild) return prebuild;
-      var nearby = resolve19(path.dirname(process.execPath));
-      if (nearby) return nearby;
-      var target = [
-        "platform=" + platform8,
-        "arch=" + arch,
-        "runtime=" + runtime,
-        "abi=" + abi,
-        "uv=" + uv,
-        armv ? "armv=" + armv : "",
-        "libc=" + libc,
-        "node=" + process.versions.node,
-        process.versions.electron ? "electron=" + process.versions.electron : "",
-        typeof __webpack_require__ === "function" ? "webpack=true" : ""
-        // eslint-disable-line
-      ].filter(Boolean).join(" ");
-      throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
-      function resolve19(dir2) {
-        var tuples = readdirSync2(path.join(dir2, "prebuilds")).map(parseTuple);
-        var tuple = tuples.filter(matchTuple(platform8, arch)).sort(compareTuples)[0];
-        if (!tuple) return;
-        var prebuilds = path.join(dir2, "prebuilds", tuple.name);
-        var parsed = readdirSync2(prebuilds).map(parseTags);
-        var candidates = parsed.filter(matchTags(runtime, abi));
-        var winner = candidates.sort(compareTags(runtime))[0];
-        if (winner) return path.join(prebuilds, winner.file);
-      }
-    };
-    function readdirSync2(dir) {
-      try {
-        return fs.readdirSync(dir);
-      } catch (err) {
-        return [];
-      }
-    }
-    function getFirst(dir, filter) {
-      var files = readdirSync2(dir).filter(filter);
-      return files[0] && path.join(dir, files[0]);
-    }
-    function matchBuild(name) {
-      return /\.node$/.test(name);
-    }
-    function parseTuple(name) {
-      var arr = name.split("-");
-      if (arr.length !== 2) return;
-      var platform9 = arr[0];
-      var architectures = arr[1].split("+");
-      if (!platform9) return;
-      if (!architectures.length) return;
-      if (!architectures.every(Boolean)) return;
-      return { name, platform: platform9, architectures };
-    }
-    function matchTuple(platform9, arch2) {
-      return function(tuple) {
-        if (tuple == null) return false;
-        if (tuple.platform !== platform9) return false;
-        return tuple.architectures.includes(arch2);
-      };
-    }
-    function compareTuples(a, b) {
-      return a.architectures.length - b.architectures.length;
-    }
-    function parseTags(file) {
-      var arr = file.split(".");
-      var extension = arr.pop();
-      var tags = { file, specificity: 0 };
-      if (extension !== "node") return;
-      for (var i = 0; i < arr.length; i++) {
-        var tag2 = arr[i];
-        if (tag2 === "node" || tag2 === "electron" || tag2 === "node-webkit") {
-          tags.runtime = tag2;
-        } else if (tag2 === "napi") {
-          tags.napi = true;
-        } else if (tag2.slice(0, 3) === "abi") {
-          tags.abi = tag2.slice(3);
-        } else if (tag2.slice(0, 2) === "uv") {
-          tags.uv = tag2.slice(2);
-        } else if (tag2.slice(0, 4) === "armv") {
-          tags.armv = tag2.slice(4);
-        } else if (tag2 === "glibc" || tag2 === "musl") {
-          tags.libc = tag2;
-        } else {
-          continue;
-        }
-        tags.specificity++;
-      }
-      return tags;
-    }
-    function matchTags(runtime2, abi2) {
-      return function(tags) {
-        if (tags == null) return false;
-        if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
-        if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
-        if (tags.uv && tags.uv !== uv) return false;
-        if (tags.armv && tags.armv !== armv) return false;
-        if (tags.libc && tags.libc !== libc) return false;
-        return true;
-      };
-    }
-    function runtimeAgnostic(tags) {
-      return tags.runtime === "node" && tags.napi;
-    }
-    function compareTags(runtime2) {
-      return function(a, b) {
-        if (a.runtime !== b.runtime) {
-          return a.runtime === runtime2 ? -1 : 1;
-        } else if (a.abi !== b.abi) {
-          return a.abi ? -1 : 1;
-        } else if (a.specificity !== b.specificity) {
-          return a.specificity > b.specificity ? -1 : 1;
-        } else {
-          return 0;
-        }
-      };
-    }
-    function isNwjs() {
-      return !!(process.versions && process.versions.nw);
-    }
-    function isElectron() {
-      if (process.versions && process.versions.electron) return true;
-      if (process.env.ELECTRON_RUN_AS_NODE) return true;
-      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
-    }
-    function isAlpine(platform9) {
-      return platform9 === "linux" && fs.existsSync("/etc/alpine-release");
-    }
-    load.parseTags = parseTags;
-    load.matchTags = matchTags;
-    load.compareTags = compareTags;
-    load.parseTuple = parseTuple;
-    load.matchTuple = matchTuple;
-    load.compareTuples = compareTuples;
-  }
-});
-
-// node_modules/node-gyp-build/index.js
-var require_node_gyp_build2 = __commonJS({
-  "node_modules/node-gyp-build/index.js"(exports, module) {
-    "use strict";
-    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
-    if (typeof runtimeRequire.addon === "function") {
-      module.exports = runtimeRequire.addon.bind(runtimeRequire);
-    } else {
-      module.exports = require_node_gyp_build();
-    }
-  }
-});
-
-// node_modules/isolated-vm/isolated-vm.js
-var require_isolated_vm = __commonJS({
-  "node_modules/isolated-vm/isolated-vm.js"(exports, module) {
-    "use strict";
-    module.exports = require_node_gyp_build2()(__dirname).ivm;
-  }
-});
-
 // src/code-mode/sandbox.ts
 import { join as join12, dirname as dirname5 } from "path";
 import { pathToFileURL } from "url";
@@ -3819,9 +3602,38 @@ async function transpileOrStrip(code, cwd) {
     warnings: ["TypeScript not found in node_modules. Using fallback parser; install typescript for reliable transpilation."]
   };
 }
+async function loadIsolatedVm() {
+  const mod = await import("isolated-vm");
+  const ivm = mod.default?.Isolate ? mod.default : mod;
+  if (typeof ivm.Isolate !== "function") throw new Error("isolated-vm loaded but exposes no Isolate constructor");
+  return ivm;
+}
+function makeToolBridge(opts2, toolCalls) {
+  let mutationTail = Promise.resolve();
+  return (tool) => async (args) => {
+    const invoke = async () => {
+      const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return opts2.executor.run(
+        { id: toolCallId, name: tool.name, arguments: JSON.stringify(args ?? {}) },
+        opts2.askPermission,
+        opts2.ctx
+      );
+    };
+    let result2;
+    if (tool.isReadOnly === true || tool.concurrent === true) {
+      result2 = await invoke();
+    } else {
+      const run = mutationTail.then(invoke, invoke);
+      mutationTail = run.catch(() => void 0);
+      result2 = await run;
+    }
+    toolCalls.push({ name: tool.name, args, result: result2.content, ok: result2.ok });
+    return result2.content;
+  };
+}
 async function runWithIsolatedVm(opts2) {
-  const { Isolate } = await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1));
-  const isolate = new Isolate({ memoryLimit: opts2.memoryLimitMB ?? 128 });
+  const ivm = await loadIsolatedVm();
+  const isolate = new ivm.Isolate({ memoryLimit: opts2.memoryLimitMB ?? 128 });
   const context = await isolate.createContext();
   const jail = context.global;
   await jail.set("global", jail.derefInto());
@@ -3835,30 +3647,15 @@ async function runWithIsolatedVm(opts2) {
     { arguments: { reference: true } }
   );
   await context.eval(`var console = { log: function(...args) { _log(args.map(String).join(" ")); } };`);
-  const toolMap = new Map(opts2.tools.map((t) => [t.name, t]));
+  const bridge = makeToolBridge(opts2, toolCalls);
   for (const tool of opts2.tools) {
-    const ref = new (await Promise.resolve().then(() => __toESM(require_isolated_vm(), 1))).Reference(
-      async (argsJson) => {
-        const args = JSON.parse(argsJson);
-        const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const result2 = await opts2.executor.run(
-          { id: toolCallId, name: tool.name, arguments: JSON.stringify(args) },
-          opts2.askPermission,
-          opts2.ctx
-        );
-        toolCalls.push({
-          name: tool.name,
-          args,
-          result: result2.content
-        });
-        return result2.content;
-      }
-    );
+    const call = bridge(tool);
+    const host = async (argsJson) => call(JSON.parse(argsJson));
     await context.evalClosure(
       `globalThis["_api_${tool.name}"] = function(argsJson) {
         return $0.applySyncPromise(undefined, [argsJson], { arguments: { copy: true } });
       };`,
-      [ref],
+      [host],
       { arguments: { reference: true } }
     );
   }
@@ -3932,22 +3729,10 @@ async function runWithNodeVm(opts2) {
     NaN: NaN,
     undefined: void 0
   };
+  const bridge = makeToolBridge(opts2, toolCalls);
   for (const tool of opts2.tools) {
-    sandbox.api[tool.name] = async (input) => {
-      const args = input ?? {};
-      const toolCallId = `code_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const result2 = await opts2.executor.run(
-        { id: toolCallId, name: tool.name, arguments: JSON.stringify(args) },
-        opts2.askPermission,
-        opts2.ctx
-      );
-      toolCalls.push({
-        name: tool.name,
-        args,
-        result: result2.content
-      });
-      return result2.content;
-    };
+    const call = bridge(tool);
+    sandbox.api[tool.name] = (input) => call(input ?? {});
   }
   const { js: jsCode, warnings } = await transpileOrStrip(opts2.code, opts2.ctx.cwd);
   const wrapped = `"use strict";
@@ -4047,7 +3832,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;
@@ -4662,7 +4447,8 @@ How to work:
 - Prefer calling tools over guessing. Read files before editing them. Use \`glob\` and \`grep\` to explore code before assuming structure.
 - Before any mutating tool call (write, edit, bash), state in one short sentence what you're about to do, then call the tool. The user will be asked to approve each mutating call.
 - When the user asks for a change, make the change. Do not paste code in chat that you could apply with \`edit\` or \`write\`.
-- When working through a multi-step task list, you MUST call \`tasks_set\` **immediately before starting each new step** and **immediately after completing each step**. Do not execute mutating tools (\`write\`, \`edit\`, \`bash\`) without updating task progress first. Skip \`tasks_set\` for trivial single-step requests.
+- For any request that needs two or more distinct steps, proactively create a visible checklist with \`tasks_set\` before doing work; do not wait for the user to ask. Keep it high-level (about 2\u20136 steps) and skip it only for a genuinely quick single-action request.
+- When working through a task list, call \`tasks_set\` **immediately before starting each new step** and **immediately after completing each step**. Pass the full list and show exactly one active step. Do not execute mutating tools (\`write\`, \`edit\`, \`bash\`) without updating task progress first.
 - Keep responses concise, but make them useful: the user sees tool calls inline, so do not re-summarize routine progress.
 - Treat blockers as problems to work through, not as a stopping point. After an error or failed attempt, diagnose the cause and try a safe, materially different recovery or verification path when possible; do not repeat the same failed attempt blindly.
 - Prefer resolving a blocker yourself with available tools over shifting diagnosis to the user. If you still cannot finish after reasonable attempts, say what remains undone, why it is blocked, and the single most useful next action. Make that action concrete (for example, an exact command, setting to check, or specific input you need). Ask the user to act only when their access, choice, or interactive participation is genuinely required, and never imply unverified work succeeded.
@@ -4699,6 +4485,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 +4528,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);
@@ -5128,7 +4916,7 @@ function shouldCheckCompletion(input, tier) {
 }
 function createJevCompletionCheck(apiKey, ask = askJev) {
   return async (input, signal) => {
-    const clip2 = (text, max) => redactPrompt(text.replace(/\s+/g, " ").trim()).slice(0, max);
+    const clip3 = (text, max) => redactPrompt(text.replace(/\s+/g, " ").trim()).slice(0, max);
     const used = input.toolsUsed.length ? `${input.toolsUsed.length} tool calls (${[...new Set(input.toolsUsed)].join(", ")}); ${input.toolsUsed.some((t) => WRITE_TOOLS.has(t)) ? "it ran commands or edited files" : "it only read or searched"}` : "no tool calls";
     const timeout = AbortSignal.timeout(COMPLETION_CHECK_TIMEOUT_MS);
     try {
@@ -5136,9 +4924,9 @@ function createJevCompletionCheck(apiKey, ask = askJev) {
         kind: "yes",
         prompt: [
           "Did the assistant end its turn legitimately \u2014 either by fully completing the user's request, or by clearly explaining a blocker or question that needs the user \u2014 as opposed to stopping early, only planning, or announcing next steps it has not done?",
-          `User asked: ${clip2(input.userRequest, 1200)}`,
+          `User asked: ${clip3(input.userRequest, 1200)}`,
           `During the turn the assistant made ${used}.`,
-          `Assistant's final message: ${clip2(input.finalText, 1500)}`
+          `Assistant's final message: ${clip3(input.finalText, 1500)}`
         ].join("\n")
       }, { signal: AbortSignal.any([timeout, signal]) });
       return answer.type === "noul" && typeof answer.noul === "number" ? answer.noul : null;
@@ -5438,15 +5226,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: readFile38, stat: stat15 } = await import("fs/promises");
+      const { join: join59 } = 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 = join59(cwd, file);
+          const size = (await stat15(path)).size;
           if (size > 0 && size <= 1024 * 1024) {
-            const text = await readFile36(path, "utf8");
+            const text = await readFile38(path, "utf8");
             lines = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
           }
         } catch {
@@ -5815,7 +5603,9 @@ ${codeModeApiString}
 
 Use console.log() to return results. Only console.log output is sent back to you.
 
-IMPORTANT \u2014 explore through code, not direct tools: to read files, run shell commands, grep, or glob, call api.read(...), api.bash(...), api.grep(...), api.glob(...) INSIDE this code block and console.log only what you need. Do NOT call read/bash/grep/glob as separate tools \u2014 their full output floods your context, while here only what you log returns. Batch multiple reads/greps/commands into a single execute_code call.` + (directTools.length > 0 ? `
+IMPORTANT \u2014 explore through code, not direct tools: to read files, run shell commands, grep, or glob, call api.read(...), api.bash(...), api.grep(...), api.glob(...) INSIDE this code block and console.log only what you need. Do NOT call read/bash/grep/glob as separate tools \u2014 their full output floods your context, while here only what you log returns. Batch multiple reads/greps/commands into a single execute_code call.
+
+Mutating calls (edit, write, bash, \u2026) run one at a time in call order even inside Promise.all; apply edits to the same file sequentially and re-read the file before editing it again.` + (directTools.length > 0 ? `
 
 Not in this API \u2014 call these as separate tools instead: ${directTools.map((t) => t.name).join(", ")}.` : ""),
           parameters: {
@@ -6048,11 +5838,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);
@@ -6535,6 +6325,7 @@ Not in this API \u2014 call these as separate tools instead: ${directTools.map((
               turnId
             );
           }
+          logger.debug("turn:code_mode_start", { sessionId: opts2.sessionId, toolCallId: tc.id, codeChars: code.length });
           const sandboxResult = await runInSandbox({
             code,
             tools: sandboxTools,
@@ -6556,12 +6347,23 @@ Not in this API \u2014 call these as separate tools instead: ${directTools.map((
             timeoutMs: 3e4,
             memoryLimitMB: 128
           });
+          logger.debug("turn:code_mode_end", {
+            sessionId: opts2.sessionId,
+            toolCallId: tc.id,
+            durationMs: Math.round(performance.now() - sandboxStartedAt),
+            error: sandboxResult.error ?? null,
+            calls: sandboxResult.toolCalls.map((c) => ({
+              name: c.name,
+              ok: c.ok,
+              path: typeof c.args?.path === "string" ? c.args.path : void 0
+            }))
+          });
           for (const stc of sandboxResult.toolCalls) {
             const toolResult = {
               tool_call_id: tc.id,
               name: stc.name,
               content: stc.result,
-              ok: true
+              ok: stc.ok
             };
             toolResults.push(toolResult);
             opts2.callbacks.onToolResult?.(toolResult);
@@ -6901,14 +6703,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 {
@@ -7649,14 +7466,79 @@ var init_read = __esm({
   }
 });
 
+// src/util/file-lock.ts
+import { realpath } from "fs/promises";
+async function lockKeyFor(absPath) {
+  try {
+    return await realpath(absPath);
+  } catch {
+    return absPath;
+  }
+}
+async function withFileLock2(absPath, fn) {
+  const key = await lockKeyFor(absPath);
+  const prev = tails.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.then(
+    () => void 0,
+    () => void 0
+  );
+  tails.set(key, tail);
+  try {
+    return await run;
+  } finally {
+    if (tails.get(key) === tail) tails.delete(key);
+  }
+}
+var tails;
+var init_file_lock = __esm({
+  "src/util/file-lock.ts"() {
+    "use strict";
+    tails = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/util/safe-write.ts
+import { chmod as chmod2, readFile as readFile7, rename as rename3, stat as stat5, unlink as unlink2, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename2, dirname as dirname7, join as join16 } from "path";
+async function writeFileVerified(absPath, content) {
+  const target = await lockKeyFor(absPath);
+  let mode;
+  try {
+    mode = (await stat5(target)).mode & 511;
+  } catch {
+  }
+  const tmp = join16(dirname7(target), `.${basename2(target)}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`);
+  try {
+    await writeFile6(tmp, content, "utf8");
+    if (mode !== void 0) await chmod2(tmp, mode);
+    await rename3(tmp, target);
+  } catch {
+    await unlink2(tmp).catch(() => void 0);
+    await writeFile6(target, content, "utf8");
+  }
+  const onDisk = await readFile7(target, "utf8");
+  if (onDisk !== content) {
+    throw new Error(`write verification failed for ${absPath}: file on disk does not match the intended content`);
+  }
+}
+var init_safe_write = __esm({
+  "src/util/safe-write.ts"() {
+    "use strict";
+    init_file_lock();
+  }
+});
+
 // src/tools/write.ts
-import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { mkdir as mkdir7, readFile as readFile8 } from "fs/promises";
+import { dirname as dirname8 } from "path";
 var writeTool;
 var init_write = __esm({
   "src/tools/write.ts"() {
     "use strict";
     init_paths2();
+    init_file_lock();
+    init_safe_write();
     writeTool = {
       name: "write",
       description: "Create a file or overwrite an existing one with the given contents. Prompts the user for permission first and shows a diff preview.",
@@ -7676,22 +7558,30 @@ var init_write = __esm({
       }),
       async run(args, ctx) {
         const abs = resolvePath(ctx.cwd, args.path);
-        let before = "";
-        try {
-          before = await readFile7(abs, "utf8");
-        } catch {
-        }
-        await mkdir7(dirname7(abs), { recursive: true });
-        await writeFile6(abs, args.content, "utf8");
-        const verb = before ? "Overwrote" : "Created";
-        return `${verb} ${args.path} (${args.content.length} chars).`;
+        return withFileLock2(abs, async () => {
+          let before = "";
+          try {
+            before = await readFile8(abs, "utf8");
+          } catch {
+          }
+          await mkdir7(dirname8(abs), { recursive: true });
+          await writeFileVerified(abs, args.content);
+          const verb = before ? "Overwrote" : "Created";
+          return `${verb} ${args.path} (${args.content.length} chars).`;
+        });
       }
     };
   }
 });
 
 // src/tools/edit.ts
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
+function replaceLiteral(haystack, needle, replacement, all) {
+  if (all) return haystack.split(needle).join(replacement);
+  const i = haystack.indexOf(needle);
+  if (i === -1) return haystack;
+  return haystack.slice(0, i) + replacement + haystack.slice(i + needle.length);
+}
 function countOccurrences(haystack, needle) {
   if (!needle) return 0;
   let count = 0;
@@ -7708,6 +7598,8 @@ var init_edit = __esm({
   "src/tools/edit.ts"() {
     "use strict";
     init_paths2();
+    init_file_lock();
+    init_safe_write();
     editTool = {
       name: "edit",
       description: "Replace an exact string in a file. If replace_all is false (default), the old_string must appear exactly once or the call fails. Prompts the user for permission first and shows a diff preview.",
@@ -7729,17 +7621,19 @@ var init_edit = __esm({
       }),
       async run(args, ctx) {
         const abs = resolvePath(ctx.cwd, args.path);
-        const orig = await readFile8(abs, "utf8");
-        const occurrences = countOccurrences(orig, args.old_string);
-        if (occurrences === 0) throw new Error(`old_string not found in ${args.path}`);
-        if (occurrences > 1 && !args.replace_all) {
-          throw new Error(
-            `old_string appears ${occurrences} times in ${args.path}; pass replace_all=true or include more surrounding context`
-          );
-        }
-        const next = args.replace_all ? orig.split(args.old_string).join(args.new_string) : orig.replace(args.old_string, args.new_string);
-        await writeFile7(abs, next, "utf8");
-        return `Replaced ${occurrences} occurrence(s) in ${args.path}.`;
+        return withFileLock2(abs, async () => {
+          const orig = await readFile9(abs, "utf8");
+          const occurrences = countOccurrences(orig, args.old_string);
+          if (occurrences === 0) throw new Error(`old_string not found in ${args.path}`);
+          if (occurrences > 1 && !args.replace_all) {
+            throw new Error(
+              `old_string appears ${occurrences} times in ${args.path}; pass replace_all=true or include more surrounding context`
+            );
+          }
+          const next = replaceLiteral(orig, args.old_string, args.new_string, args.replace_all === true);
+          await writeFileVerified(abs, next);
+          return `Replaced ${occurrences} occurrence(s) in ${args.path}.`;
+        });
       }
     };
   }
@@ -7748,7 +7642,7 @@ var init_edit = __esm({
 // src/tools/bash.ts
 import { spawn } from "child_process";
 import { tmpdir, platform as platform2 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function getShellCommand(override) {
   const raw = override?.trim();
   if (raw && raw !== "auto") {
@@ -7813,15 +7707,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);
     });
   });
 }
@@ -7950,7 +7844,7 @@ function injectCoauthor(command, coauthor) {
   if (movesHeadOnly) return unchanged;
   const env2 = {
     [COAUTHOR_TRAILER_ENV]: trailer,
-    [COAUTHOR_MSG_ENV]: join16(tmpdir(), `kf-coauthor-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`)
+    [COAUTHOR_MSG_ENV]: join17(tmpdir(), `kf-coauthor-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`)
   };
   if (createsCommit || isRebaseContinue) {
     return { command: `(${command}) && { ${AMEND_BLOCK}
@@ -7975,7 +7869,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 +7934,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"),
@@ -8091,8 +7985,8 @@ var init_bash = __esm({
 });
 
 // src/util/glob.ts
-import { readdir as readdir3, lstat, realpath } from "fs/promises";
-import { join as join17, relative as relative2, resolve as resolve2 } from "path";
+import { readdir as readdir3, lstat, realpath as realpath2 } from "fs/promises";
+import { join as join18, relative as relative2, resolve as resolve2 } from "path";
 function parsePattern(pattern) {
   const parts = pattern.split(/\//g);
   return parts.map((p) => {
@@ -8201,7 +8095,7 @@ async function* walk(root, pattern, options) {
         if (!dot && name.startsWith(".")) continue;
         const matched = seg.type === "literal" ? seg.value === name : matchSegment(name, seg.value);
         if (!matched) continue;
-        const childPath = join17(dirPath, name);
+        const childPath = join18(dirPath, name);
         const childRel = [...relativeParts, name];
         const childRelStr = childRel.join("/");
         if (shouldIgnore(childRelStr, ignorePatterns)) continue;
@@ -8226,14 +8120,14 @@ async function* walk(root, pattern, options) {
       if (!dot && name.startsWith(".")) continue;
       const matched = seg.type === "literal" ? seg.value === name : matchSegment(name, seg.value);
       if (!matched) continue;
-      const childPath = join17(dirPath, name);
+      const childPath = join18(dirPath, name);
       const childRel = [...relativeParts, name];
       const childRelStr = childRel.join("/");
       if (shouldIgnore(childRelStr, ignorePatterns)) continue;
       let isDir = ent.isDirectory();
       if (!isDir && followSymbolicLinks && ent.isSymbolicLink()) {
         try {
-          const rp = await realpath(childPath);
+          const rp = await realpath2(childPath);
           const s = await lstat(rp);
           isDir = s.isDirectory();
         } catch {
@@ -8268,7 +8162,7 @@ async function* walk(root, pattern, options) {
         const name = String(ent.name);
         if (name === "." || name === "..") continue;
         if (!dot && name.startsWith(".")) continue;
-        const childPath = join17(dirPath, name);
+        const childPath = join18(dirPath, name);
         const childRel = [...relativeParts, name];
         const childRelStr = childRel.join("/");
         if (shouldIgnore(childRelStr, ignorePatterns)) continue;
@@ -8276,7 +8170,7 @@ async function* walk(root, pattern, options) {
           let isDir = ent.isDirectory();
           if (!isDir && followSymbolicLinks && ent.isSymbolicLink()) {
             try {
-              const rp = await realpath(childPath);
+              const rp = await realpath2(childPath);
               const s = await lstat(rp);
               isDir = s.isDirectory();
             } catch {
@@ -8435,7 +8329,7 @@ var init_glob2 = __esm({
 // src/tools/grep.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 async function hasRipgrep() {
   if (cachedHasRg !== null) return cachedHasRg;
   try {
@@ -8482,7 +8376,7 @@ async function runJsFallback(args, root, mode, signal) {
     if (signal?.aborted) throw new DOMException("aborted", "AbortError");
     const file = files[fi];
     try {
-      const content = await readFile9(file, "utf8");
+      const content = await readFile10(file, "utf8");
       if (mode === "files") {
         if (re.test(content)) out.push(file);
       } else {
@@ -9085,9 +8979,9 @@ var changelog_image_exports = {};
 __export(changelog_image_exports, {
   changelogImageTool: () => changelogImageTool
 });
-import { readFile as readFile10 } from "fs/promises";
-import { writeFile as writeFile8 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { writeFile as writeFile7 } from "fs/promises";
+import { join as join19 } from "path";
 async function githubFetch2(path, token) {
   const controller = new AbortController();
   const timer3 = setTimeout(() => controller.abort(), TIMEOUT_MS4);
@@ -9118,7 +9012,7 @@ function escapeXml(str) {
 }
 async function loadLogoBase64() {
   try {
-    const buf = await readFile10(join18(process.cwd(), "docs", "logo.png"));
+    const buf = await readFile11(join19(process.cwd(), "docs", "logo.png"));
     return `data:image/png;base64,${buf.toString("base64")}`;
   } catch {
     return null;
@@ -9420,7 +9314,7 @@ Format your response as plain text bullet points, one per line, starting with "\
         setTask("4", "completed");
         setTask("5", "in_progress");
         const outputPath = args.output ?? `./changelog-${args.repo}-${version.replace(/[^a-zA-Z0-9._-]/g, "_")}.png`;
-        await writeFile8(outputPath, pngBuffer);
+        await writeFile7(outputPath, pngBuffer);
         setTask("5", "completed");
         const periodLabel = days === 1 ? "past day" : `past ${days} days`;
         const content = `\u2713 Changelog image saved to ${outputPath}
@@ -9435,10 +9329,10 @@ Format your response as plain text bullet points, one per line, starting with "\
 // src/tools/browser.ts
 import { mkdir as mkdir8 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join19, dirname as dirname8 } from "path";
+import { join as join20, dirname as dirname9 } 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 +9341,12 @@ async function autoScroll(page) {
         totalHeight += distance;
         if (totalHeight >= scrollHeight) {
           clearInterval(timer3);
-          resolve19();
+          resolve20();
         }
       }, 100);
       setTimeout(() => {
         clearInterval(timer3);
-        resolve19();
+        resolve20();
       }, 1e4);
     });
   });
@@ -9511,8 +9405,8 @@ var init_browser = __esm({
           }
           let screenshotPath;
           if (args.screenshot) {
-            screenshotPath = join19(tmpdir2(), `kimiflare-browser-${Date.now()}.png`);
-            await mkdir8(dirname8(screenshotPath), { recursive: true });
+            screenshotPath = join20(tmpdir2(), `kimiflare-browser-${Date.now()}.png`);
+            await mkdir8(dirname9(screenshotPath), { recursive: true });
             await page.screenshot({ path: screenshotPath, fullPage: true });
           }
           const text = await page.evaluate(() => {
@@ -9551,6 +9445,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 chmod3, lstat as lstat2, mkdir as mkdir9, mkdtemp, readFile as readFile12, readdir as readdir4, realpath as realpath3, rm as rm2, stat as stat6, writeFile as writeFile9 } from "fs/promises";
+import { execFileSync } from "child_process";
+import { tmpdir as tmpdir3 } from "os";
+import { isAbsolute as isAbsolute2, join as join21, 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 realpath3(workspaceRoot);
+  const inputPath = resolvePath(cwd, args.sourcePath);
+  let inputReal;
+  try {
+    inputReal = await realpath3(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 stat6(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 readFile12(inputReal, "utf8");
+  return createHtmlArtifact({ title: args.title, html }, cwd, options);
+}
+async function createHtmlArtifact(args, cwd, options = {}) {
+  assertArtifactHtmlArgs(args);
+  const rootDir = options.rootDir ?? join21(tmpdir3(), ARTIFACT_ROOT);
+  const workspaceRoot = await getWorkspaceRoot(cwd);
+  const workspaceReal = await realpath3(workspaceRoot);
+  if (isWithin(workspaceReal, resolve3(rootDir))) {
+    throw new Error("Refusing to store an artifact inside the workspace: " + rootDir);
+  }
+  await ensureSecureRoot(rootDir);
+  const rootReal = await realpath3(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(join21(rootDir, ARTIFACT_PREFIX));
+  await chmod3(artifactDir, 448);
+  const filePath = join21(artifactDir, "index.html");
+  await writeFile9(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 = join21(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 chmod3(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({
@@ -9561,8 +9737,8 @@ var init_tasks = __esm({
       name: "tasks_set",
       description: [
         "Set the visible task list shown to the user during this turn.",
-        "Call this when the user has given you a multi-step job, or whenever progress changes:",
-        "at the start (all tasks pending, with exactly one in_progress), and after each step completes",
+        "Call this proactively for any request that needs two or more distinct steps, before starting work, and whenever progress changes:",
+        "at the start (all tasks pending except exactly one in_progress), and after each step completes",
         "(flip that task to completed and the next to in_progress).",
         "Pass the ENTIRE task list each call \u2014 this replaces the panel.",
         "Keep tasks short (one imperative clause). Only one should be in_progress at a time.",
@@ -9766,9 +9942,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 join22 } from "path";
 import { promisify as promisify4 } from "util";
 async function git(args, cwd, env2) {
   const { stdout } = await execFileAsync2("git", args, {
@@ -9816,9 +9992,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(join22(tmpdir4(), "autopilot-snapshot-"));
   try {
-    const env2 = { GIT_INDEX_FILE: join20(scratch, "index") };
+    const env2 = { GIT_INDEX_FILE: join22(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 +10013,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(join22(tmpdir4(), "autopilot-archive-"));
   try {
-    const env2 = { GIT_INDEX_FILE: join20(scratch, "index") };
+    const env2 = { GIT_INDEX_FILE: join22(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 +10035,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,22 +10069,22 @@ 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 readFile13, writeFile as writeFile10 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname9, join as join21 } from "path";
+import { dirname as dirname10, join as join23 } 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 || join23(homedir11(), ".config");
+  return join23(xdg, "kimiflare", "hotcell-worker-cache.json");
 }
 async function readCache2() {
   try {
-    return JSON.parse(await readFile11(workerCachePath(), "utf8"));
+    return JSON.parse(await readFile13(workerCachePath(), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeCache2(cache) {
-  await mkdir9(dirname9(workerCachePath()), { recursive: true });
+  await mkdir10(dirname10(workerCachePath()), { recursive: true });
   await writeFile10(workerCachePath(), JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
 }
 function ensureWorkerBackup(opts2) {
@@ -9969,13 +10145,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 +10459,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 +10691,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 readFile14 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname10, join as join22 } from "path";
+import { dirname as dirname11, join as join24 } 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 || join24(homedir12(), ".local", "share");
+  return join24(xdg, "kimiflare", "subagents.jsonl");
 }
 async function recordSubagentEvent(event) {
   const path = subagentStatsPath();
   try {
-    await mkdir10(dirname10(path), { recursive: true });
+    await mkdir11(dirname11(path), { recursive: true });
     await appendFile2(path, JSON.stringify(event) + "\n");
   } catch (error) {
     logger.debug("subagents:stats_write_failed", { error: String(error) });
@@ -10545,7 +10721,7 @@ function failureReason(error) {
 async function readSubagentStats(days = 7, now2 = Date.now()) {
   let raw = "";
   try {
-    raw = await readFile12(subagentStatsPath(), "utf8");
+    raw = await readFile14(subagentStatsPath(), "utf8");
   } catch {
   }
   const since = now2 - days * 24 * 60 * 60 * 1e3;
@@ -11439,18 +11615,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 dirname12, join as join25 } 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 || join25(homedir13(), ".local", "state");
+  return process.env.AUTOPILOT_JOBS_DB || join25(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 +11652,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 stat15 = readFileSync4(`/proc/${pid}/stat`, "utf8");
+      const fieldsAfterCommand = stat15.slice(stat15.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;
@@ -11589,8 +11765,8 @@ child.on('close', (code, signal) => {
       db;
       jobsDir;
       constructor(dbPath = defaultJobDbPath()) {
-        mkdirSync5(dirname11(dbPath), { recursive: true, mode: 448 });
-        this.jobsDir = join23(dirname11(dbPath), "jobs");
+        mkdirSync5(dirname12(dbPath), { recursive: true, mode: 448 });
+        this.jobsDir = join25(dirname12(dbPath), "jobs");
         mkdirSync5(this.jobsDir, { recursive: true, mode: 448 });
         this.db = new Database(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -11641,13 +11817,13 @@ child.on('close', (code, signal) => {
           if (existing) return toJobRecord(existing);
         }
         const id = randomUUID4();
-        const jobDir = join23(this.jobsDir, id);
+        const jobDir = join25(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: join25(jobDir, "stdout.log"),
+          stderrPath: join25(jobDir, "stderr.log"),
+          exitPath: join25(jobDir, "exit.json"),
+          pidPath: join25(jobDir, "pid")
         };
         const now2 = Date.now();
         try {
@@ -11671,7 +11847,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 +12104,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 dirname13, join as join26 } 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 || join26(homedir14(), ".local", "state");
+  return process.env.AUTOPILOT_RUNS_DB || join26(root, "autopilot", "runs.db");
 }
 function validateOptionalPositiveInteger(name, value, minimum = 1) {
   if (value !== null && (!Number.isSafeInteger(value) || value < minimum)) {
@@ -12019,7 +12195,7 @@ var init_store = __esm({
     RunStore = class {
       db;
       constructor(dbPath = defaultRunsDbPath()) {
-        mkdirSync6(dirname12(dbPath), { recursive: true, mode: 448 });
+        mkdirSync6(dirname13(dbPath), { recursive: true, mode: 448 });
         this.db = new Database2(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("foreign_keys = ON");
@@ -12541,8 +12717,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 realpath4 } 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 +12739,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 realpath4(cwd);
+  const candidate = resolve5(root, pathValue);
   assertInsideResearchRoot(candidate, root);
   assertNoSensitivePath(candidate, root);
-  const actual = await realpath2(candidate);
+  const actual = await realpath4(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 +12813,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 +12831,7 @@ var init_executor = __esm({
     init_github();
     init_changelog_image();
     init_browser();
+    init_html_artifact();
     init_tasks();
     init_memory();
     init_subagent();
@@ -12685,6 +12859,7 @@ var init_executor = __esm({
       githubCreatePrTool,
       { ...changelogImageTool, isReadOnly: true },
       { ...browserFetchTool, isReadOnly: true },
+      htmlArtifactTool,
       tasksSetTool,
       memoryRememberTool,
       { ...memoryRecallTool, isReadOnly: true },
@@ -12783,17 +12958,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 +13291,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 readFile15, writeFile as writeFile11, mkdir as mkdir12, readdir as readdir5, stat as stat7 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join25 } from "path";
+import { join as join27 } 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 || join27(homedir15(), ".local", "share");
+  return join27(xdg, "kimiflare", "sessions");
 }
 function sanitize(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -13134,8 +13315,8 @@ function makeSessionId(firstPrompt) {
 }
 async function saveSession(file) {
   const dir = sessionsDir();
-  await mkdir11(dir, { recursive: true });
-  const path = join25(dir, `${file.id}.json`);
+  await mkdir12(dir, { recursive: true });
+  const path = join27(dir, `${file.id}.json`);
   await writeFile11(path, JSON.stringify(file, null, 2), "utf8");
   return path;
 }
@@ -13148,16 +13329,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 = join27(dir, name);
     try {
-      const [s, raw] = await Promise.all([stat5(path), readFile13(path, "utf8")]);
+      const [s, raw] = await Promise.all([stat7(path), readFile15(path, "utf8")]);
       const parsed = JSON.parse(raw);
       if (cwd && parsed.cwd !== cwd) continue;
       const firstUser = parsed.messages.find((m) => m.role === "user");
@@ -13179,7 +13360,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 readFile15(filePath, "utf8");
   const file = JSON.parse(raw);
   if (Array.isArray(file.messages)) repairDanglingToolCalls(file.messages);
   return file;
@@ -13229,10 +13410,10 @@ var init_sessions = __esm({
 });
 
 // src/util/image.ts
-import { readFile as readFile14 } from "fs/promises";
-import { basename as basename2 } from "path";
+import { readFile as readFile16 } from "fs/promises";
+import { basename as basename3 } from "path";
 async function encodeImageFile(filePath) {
-  const buf = await readFile14(filePath);
+  const buf = await readFile16(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`
@@ -13242,7 +13423,7 @@ async function encodeImageFile(filePath) {
   const mime = EXT_TO_MIME[ext] ?? "image/jpeg";
   const b64 = buf.toString("base64");
   return {
-    filename: basename2(filePath),
+    filename: basename3(filePath),
     mime,
     dataUrl: `data:${mime};base64,${b64}`
   };
@@ -13268,7 +13449,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 +13466,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 +13477,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 +13486,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 +13502,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 +13575,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 stat8 } from "fs/promises";
+import { join as join28 } 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 = join28(path, entry.name);
     if (entry.isDirectory()) total += await dirSize(p);
     else if (entry.isFile()) {
       try {
-        total += (await stat6(p)).size;
+        total += (await stat8(p)).size;
       } catch {
       }
     }
@@ -13415,19 +13596,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 = join28(base, name);
     try {
-      const s = await stat6(path);
+      const s = await stat8(path);
       if (!s.isDirectory()) continue;
       let mtime = s.mtime;
       try {
-        mtime = (await stat6(join26(path, TRACE_FILE_NAME))).mtime;
+        mtime = (await stat8(join28(path, TRACE_FILE_NAME))).mtime;
       } catch {
       }
       sessions.push({ sessionId: name, path, mtime, bytes: await dirSize(path) });
@@ -13452,7 +13633,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 +13662,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 dirname14, join as join29 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { promisify as promisify6 } from "util";
 async function git2(args, cwd) {
@@ -13494,9 +13675,9 @@ 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;
+  const here = dirname14(fileURLToPath4(import.meta.url));
+  for (const candidate of [join29(here, "..", ".."), join29(here, "..")]) {
+    if (existsSync5(join29(candidate, "package.json")) && existsSync5(join29(candidate, ".git"))) return candidate;
   }
   return null;
 }
@@ -13634,14 +13815,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 join30, dirname as dirname15 } 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 || join30(homedir17(), ".config");
+  return join30(xdg, "kimiflare", "settings.json");
 }
 function projectSettingsPath(cwd) {
-  return join28(cwd, ".kimiflare", "settings.json");
+  return join30(cwd, ".kimiflare", "settings.json");
 }
 function readSettingsFile(path) {
   if (!existsSync6(path)) return null;
@@ -13717,7 +13898,7 @@ function appendHook(scope, cwd, event, hook) {
     return rest;
   });
   existing.hooks = hooks;
-  mkdirSync7(dirname14(path), { recursive: true });
+  mkdirSync7(dirname15(path), { recursive: true });
   writeFileSync4(path, JSON.stringify(existing, null, 2) + "\n", "utf8");
   return path;
 }
@@ -13743,7 +13924,7 @@ function setHookEnabled(cwd, id, enabled2) {
       }
     }
     if (changed) {
-      mkdirSync7(dirname14(path), { recursive: true });
+      mkdirSync7(dirname15(path), { recursive: true });
       writeFileSync4(path, JSON.stringify(existing, null, 2) + "\n", "utf8");
       return path;
     }
@@ -13759,7 +13940,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 +14057,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 +14072,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,18 +14145,18 @@ 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 readFile18 } from "fs/promises";
+import { basename as basename5, 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 readFile18(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`);
   if (raw.model !== void 0 && typeof raw.model !== "string") throw new Error(`${file}: "model" must be a string`);
   if (raw.temperature !== void 0 && typeof raw.temperature !== "number") throw new Error(`${file}: "temperature" must be a number`);
   return {
-    name: typeof raw.name === "string" && raw.name ? raw.name : basename4(path).replace(/\.json$/, ""),
+    name: typeof raw.name === "string" && raw.name ? raw.name : basename5(path).replace(/\.json$/, ""),
     ...raw.model ? { model: raw.model } : {},
     ...raw.temperature !== void 0 ? { temperature: raw.temperature } : {},
     config: config2
@@ -13988,8 +14169,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 readFile19, stat as stat9 } from "fs/promises";
+import { basename as basename6, join as join31, resolve as resolve9 } from "path";
 function isNonEmptyString(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
@@ -14017,22 +14198,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);
-    if (task.id !== basename5(name, ".json")) throw new Error(`${name}: "id" (${task.id}) must match the file name`);
+    const file = join31(root, name);
+    const task = validateTask(JSON.parse(await readFile19(file, "utf8")), name);
+    if (task.id !== basename6(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 stat9(abs).catch(() => {
         throw new Error(`${name}: files["${dest}"] -> ${src} does not exist`);
       });
       resolvedFiles[dest] = abs;
@@ -14053,15 +14234,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 stat10 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join32, 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 +14255,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 = join32(cacheDir, slug);
+  await mkdir13(cacheDir, { recursive: true });
+  const exists = await stat10(join32(dir, ".git")).then(() => true).catch(() => false);
   if (!exists) {
     await git3(["clone", "--quiet", "--no-checkout", repo, dir], cacheDir);
   } else {
@@ -14100,13 +14281,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(join32(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;
@@ -14156,7 +14337,7 @@ __export(db_exports, {
   updateMemoryEmbedding: () => updateMemoryEmbedding
 });
 import Database3 from "better-sqlite3";
-import { dirname as dirname15 } from "path";
+import { dirname as dirname16 } from "path";
 import { mkdirSync as mkdirSync8, statSync as statSync4 } from "fs";
 function initSchema(db) {
   db.exec(`
@@ -14241,7 +14422,7 @@ function openMemoryDb(dbPath) {
   if (dbInstance) {
     dbInstance.close();
   }
-  mkdirSync8(dirname15(dbPath), { recursive: true });
+  mkdirSync8(dirname16(dbPath), { recursive: true });
   dbInstance = new Database3(dbPath);
   dbInstance.pragma("journal_mode = WAL");
   dbInstance.pragma("foreign_keys = ON");
@@ -14577,8 +14758,8 @@ function computeExactScore(memory, queryText, cwd) {
   let score = 0;
   const lowerQuery = queryText.toLowerCase();
   for (const file of memory.relatedFiles) {
-    const basename11 = file.split("/").pop() ?? file;
-    if (lowerQuery.includes(basename11.toLowerCase()) || basename11.toLowerCase().includes(lowerQuery)) {
+    const basename12 = file.split("/").pop() ?? file;
+    if (lowerQuery.includes(basename12.toLowerCase()) || basename12.toLowerCase().includes(lowerQuery)) {
       score += 0.3;
     }
     if (cwd && file.startsWith(cwd)) {
@@ -15201,7 +15382,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 +15404,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 +15412,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 +15443,7 @@ var init_connection = __esm({
               if (child.pid) {
                 clearTimeout(spawnTimer);
                 this.child = child;
-                resolve19();
+                resolve20();
               }
             });
           } catch (err) {
@@ -15277,12 +15458,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 +15556,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 +16027,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 +16067,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 +16087,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 +16112,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 +16120,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 +16386,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 readFile20, writeFile as writeFile12, mkdir as mkdir14 } from "fs/promises";
 import { homedir as homedir18 } from "os";
-import { join as join32, dirname as dirname16 } from "path";
+import { join as join34, dirname as dirname17 } 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 || join34(homedir18(), ".config");
+  return join34(xdg, "kimiflare", "openrouter-models.json");
 }
 function perMtok(perToken) {
   const n = Number(perToken);
@@ -16261,7 +16442,7 @@ async function fetchOpenRouterCatalog(fetchImpl2 = fetch) {
 }
 async function readCache3() {
   try {
-    const raw = await readFile18(catalogCachePath(), "utf8");
+    const raw = await readFile20(catalogCachePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version === CACHE_VERSION ? parsed : null;
   } catch {
@@ -16271,7 +16452,7 @@ async function readCache3() {
 async function writeCache3(models) {
   const path = catalogCachePath();
   try {
-    await mkdir13(dirname16(path), { recursive: true });
+    await mkdir14(dirname17(path), { recursive: true });
     const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
     await writeFile12(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
@@ -16320,12 +16501,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 readFile21, writeFile as writeFile13, mkdir as mkdir15 } from "fs/promises";
 import { homedir as homedir19 } from "os";
-import { join as join33, dirname as dirname17 } from "path";
+import { join as join35, dirname as dirname18 } 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 || join35(homedir19(), ".config");
+  return join35(xdg, "kimiflare", "requesty-models.json");
 }
 function isSafeModelId(id) {
   return typeof id === "string" && id.length > 0 && !CONTROL_CHARS.test(id);
@@ -16381,7 +16562,7 @@ async function fetchRequestyCatalog(fetchImpl2 = fetch) {
 }
 async function readCache4() {
   try {
-    const raw = await readFile19(catalogCachePath2(), "utf8");
+    const raw = await readFile21(catalogCachePath2(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION2) return null;
     return {
@@ -16396,7 +16577,7 @@ async function readCache4() {
 async function writeCache4(catalog) {
   const path = catalogCachePath2();
   try {
-    await mkdir14(dirname17(path), { recursive: true });
+    await mkdir15(dirname18(path), { recursive: true });
     const cache = { version: CACHE_VERSION2, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ...catalog };
     await writeFile13(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
@@ -16491,15 +16672,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 join36 } 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 +16691,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 ?? join36(homedir20(), ".local", "share", "kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       ...llmAuthFromConfig(config2),
@@ -16540,7 +16721,7 @@ async function createAgentSession(opts2) {
   }
   let sessionFile;
   if (opts2.sessionId) {
-    const filePath = join34(sessionsDir(), `${opts2.sessionId}.json`);
+    const filePath = join36(sessionsDir(), `${opts2.sessionId}.json`);
     try {
       sessionFile = await loadSession(filePath);
     } catch {
@@ -16739,8 +16920,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: readFile38 } = await import("fs/promises");
+              const data = await readFile38(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 +17180,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 +17244,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: readFile38 }) => readFile38(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(join36(this.cwd, name)))) {
           this.messages[0] = {
             role: "system",
             content: buildSystemPrompt({
@@ -17094,13 +17275,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 readFile22, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname19, join as join37, 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 +17310,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 = join37(worktree, dest);
+    await mkdir16(dirname19(target), { recursive: true });
     await copyFile(src, target);
   }
 }
@@ -17138,7 +17319,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 readFile22(traceFile, "utf8");
   } catch {
     return out;
   }
@@ -17170,7 +17351,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 = join37(ctx.tracesRoot, sessionId);
   const base = {
     task_id: task.id,
     sample,
@@ -17195,15 +17376,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, join37(ctx.out, "cache"));
+    worktree = await createWorktree(sourceRepo, task.base_commit, join37(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 writeFile14(join37(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 +17418,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 writeFile14(join37(traceDir, "test.log"), test.log, "utf8").catch(() => void 0);
     if (session.trace.enabled) {
       session.trace.emit(
         "outcome",
@@ -17256,7 +17437,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(join37(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 +17455,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 +17466,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 = join37(out, "traces");
   const runName = evalConfig.name;
-  const resultsFile = join35(out, "results.jsonl");
+  const resultsFile = join37(out, "results.jsonl");
   await writeFile14(
-    join35(out, "config.json"),
+    join37(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 +17515,9 @@ __export(compare_exports, {
   perTask: () => perTask,
   summarizeArm: () => summarizeArm
 });
-import { readFile as readFile21 } from "fs/promises";
+import { readFile as readFile23 } from "fs/promises";
 async function loadResults(file) {
-  const raw = await readFile21(file, "utf8");
+  const raw = await readFile23(file, "utf8");
   return raw.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function median(values) {
@@ -17469,16 +17650,16 @@ __export(cost_verify_exports, {
   verifySession: () => verifySession,
   verifyTurn: () => verifyTurn
 });
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 import { homedir as homedir21 } from "os";
-import { join as join36 } from "path";
+import { join as join38 } 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 || join38(homedir21(), ".local", "share");
+  return join38(xdg, "kimiflare", "usage.json");
 }
 async function loadSessions() {
   try {
-    return JSON.parse(await readFile22(usagePath2(), "utf8")).sessions ?? [];
+    return JSON.parse(await readFile24(usagePath2(), "utf8")).sessions ?? [];
   } catch {
     return [];
   }
@@ -17797,12 +17978,12 @@ function extOf(path) {
   const idx = path.lastIndexOf(".");
   return idx >= 0 ? path.slice(idx).toLowerCase() : "";
 }
-function basename6(path) {
+function basename7(path) {
   const idx = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   return idx >= 0 ? path.slice(idx + 1) : path;
 }
 function classifyFile(path) {
-  const base = basename6(path);
+  const base = basename7(path);
   const ext = extOf(path);
   if (TEST_PATTERNS.test(base)) return "writing-tests";
   if (base.toLowerCase().startsWith("readme")) return "reading-documentation";
@@ -17813,7 +17994,7 @@ function classifyFile(path) {
   return null;
 }
 function classifyWriteFile(path) {
-  const base = basename6(path);
+  const base = basename7(path);
   const ext = extOf(path);
   if (TEST_PATTERNS.test(base)) return "writing-tests";
   if (base.toLowerCase().startsWith("readme") || DOC_EXTS.has(ext)) return "writing-documentation";
@@ -17822,7 +18003,7 @@ function classifyWriteFile(path) {
   return null;
 }
 function classifyEditFile(path) {
-  const base = basename6(path);
+  const base = basename7(path);
   const ext = extOf(path);
   if (base.toLowerCase().startsWith("readme") || DOC_EXTS.has(ext)) return "editing-documentation";
   if (CONFIG_EXTS.has(ext)) return "editing-configuration";
@@ -18009,12 +18190,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 readFile25 } from "fs/promises";
+import { join as join39 } 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 || join39(homedir22(), ".local", "share");
+  return join39(xdg, "kimiflare", "sessions");
 }
 function parseToolCalls(calls) {
   return calls.map((c) => {
@@ -18028,7 +18209,7 @@ function parseToolCalls(calls) {
 }
 async function classifyFromSessionFile(sessionId) {
   try {
-    const raw = await readFile23(join37(sessionsDir2(), `${sessionId}.json`), "utf8");
+    const raw = await readFile25(join39(sessionsDir2(), `${sessionId}.json`), "utf8");
     const session = JSON.parse(raw);
     const messages = session.messages ?? [];
     const turns = [];
@@ -18061,15 +18242,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 readFile26 } from "fs/promises";
+import { join as join40 } 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 || join40(homedir23(), ".local", "share");
+  return join40(xdg, "kimiflare");
 }
 function usagePath3() {
-  return join38(usageDir2(), "usage.json");
+  return join40(usageDir2(), "usage.json");
 }
 function today2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -18081,7 +18262,7 @@ function daysAgo(n) {
 }
 async function loadLog2() {
   try {
-    const raw = await readFile24(usagePath3(), "utf8");
+    const raw = await readFile26(usagePath3(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -18171,12 +18352,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 readFile27, realpath as realpath5, stat as stat11 } 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 readFile27(configPath3, "utf8"));
   } catch {
     throw new AsterConfigError();
   }
@@ -18209,15 +18390,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 realpath5(workspace.rootPath);
+      if (!(await stat11(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 +18410,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 +18436,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 dirname20, join as join41 } 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 || join41(homedir24(), ".local", "state");
+  return process.env.AUTOPILOT_ASTER_DB || join41(root, "autopilot", "aster.db");
 }
 function hashToken(token) {
   return createHash5("sha256").update(token).digest("hex");
@@ -18309,9 +18490,9 @@ var init_aster_store = __esm({
     AsterStore = class {
       db;
       constructor(dbPath = defaultAsterDbPath()) {
-        mkdirSync9(dirname19(dbPath), { recursive: true, mode: 448 });
+        mkdirSync9(dirname20(dbPath), { recursive: true, mode: 448 });
         try {
-          chmodSync2(dirname19(dbPath), 448);
+          chmodSync2(dirname20(dbPath), 448);
         } catch {
         }
         this.db = new Database4(dbPath);
@@ -18612,7 +18793,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 +19364,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 chmod4, mkdir as mkdir17, realpath as realpath6 } 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 join42, 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 || join42(homedir25(), ".local", "share");
+  return join42(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 +19403,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 realpath6(sourceCwd);
         const repositoryRoot = (await runGit(["rev-parse", "--show-toplevel"], source)).trim();
-        const repository = await realpath4(repositoryRoot);
-        const sourceRelativePath = relative8(repository, source);
+        const repository = await realpath6(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 realpath6(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 chmod4(worktreesRoot, 448);
+        const worktreePath = join42(worktreesRoot, runId);
         try {
           await access2(worktreePath);
           throw new Error(`worktree path already exists for run ${runId}`);
@@ -19253,16 +19434,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 realpath6(this.rootDir);
+        const target = await realpath6(worktree.worktreePath);
+        const repository = await realpath6(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 +19588,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 realpath7 } 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 +19601,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 realpath7(workspaceRoot);
   const candidate = resolvePath(root, value);
   assertInside(root, candidate);
   assertNotSensitive(root, candidate);
   let actual;
   try {
-    actual = await realpath5(candidate);
+    actual = await realpath7(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 realpath7(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 +19641,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");
   }
@@ -19498,8 +19679,8 @@ 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 { unlink as unlink3 } from "fs/promises";
+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 +19993,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 unlink3(resolve14(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           await worktreeManager.discard(worktree).catch(() => {
           });
@@ -19837,7 +20018,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 +20336,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 readFile28 } from "fs/promises";
 import { promisify as promisify8 } from "util";
 import { randomUUID as randomUUID8 } from "crypto";
 async function writeCellFileChunked(cell, path, content) {
@@ -20185,7 +20366,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 readFile28(url, "utf8");
     } catch {
     }
   }
@@ -20238,7 +20419,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 +20862,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 stat15 = await cell.exec(`[ -f ${file} ] && [ ! -L ${file} ] && stat -c %s -- ${file}`);
+        if (stat15.exitCode !== 0) throw new Error("artifact_not_found");
+        if (Number(stat15.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 +21161,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 readFile29, unlink as unlink4 } from "fs/promises";
+import { resolve as resolve15, basename as basename8 } from "path";
 function createHotcellAsterRuntime() {
   try {
     const idlePauseMs = Number(process.env.AUTOPILOT_ASTER_IDLE_PAUSE_MS ?? 15 * 60 * 1e3);
@@ -21064,9 +21245,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 stat15 = await import("fs/promises").then((m) => m.stat(resolve15(cwd, pattern)));
+      if (stat15.isFile()) {
+        resolved.add(resolve15(cwd, pattern));
         continue;
       }
     } catch {
@@ -21089,12 +21270,12 @@ async function buildUserMessage2(prompt, files, cwd) {
         imageParts.push({ type: "image_url", image_url: { url: img.dataUrl } });
       } catch (e) {
         fileContents.push(`
-<!-- failed to attach image ${basename7(filePath)}: ${e.message} -->
+<!-- failed to attach image ${basename8(filePath)}: ${e.message} -->
 `);
       }
     } else {
       try {
-        const content = await readFile27(filePath, "utf8");
+        const content = await readFile29(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -21103,7 +21284,7 @@ ${content}
 `);
       } catch (e) {
         fileContents.push(`
-<!-- failed to read ${basename7(filePath)}: ${e.message} -->
+<!-- failed to read ${basename8(filePath)}: ${e.message} -->
 `);
       }
     }
@@ -21123,7 +21304,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 +21439,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 +21552,7 @@ function setupRoutes(config2, options = {}) {
             store.close();
           }
         } catch (error) {
-          await unlink3(resolve14(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          await unlink4(resolve15(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           if (worktree) {
             await worktreeManager.discard(worktree).catch((cleanupError) => {
@@ -21506,7 +21687,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,
@@ -21525,8 +21706,8 @@ function setupRoutes(config2, options = {}) {
         const sessionId = sessionMatch[1];
         activeSessions.delete(sessionId);
         try {
-          const { unlink: unlink6 } = await import("fs/promises");
-          await unlink6(resolve14(sessionsDir(), `${sessionId}.json`));
+          const { unlink: unlink7 } = await import("fs/promises");
+          await unlink7(resolve15(sessionsDir(), `${sessionId}.json`));
         } catch {
         }
         json2(res, 200, { deleted: sessionId });
@@ -21977,13 +22158,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 +22469,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 +22607,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 +22743,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 +22790,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 +22803,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 +22829,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 +22866,7 @@ async function streamSseJson(url, sessionId) {
                 2
               ) + "\n"
             );
-            resolve19(void 0);
+            resolve20(void 0);
             break;
           case "error":
             eventSource.close();
@@ -22693,7 +22874,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 +23603,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 join43 } from "path";
 function replaceQueuedPrompt(queue2, key, full, display) {
   const index = queue2.findIndex((item) => item.key === key);
   if (index >= 0) {
@@ -23532,7 +23712,7 @@ function buildFilePickerIgnoreList(cwd) {
   ];
   const gitignorePatterns = [];
   try {
-    const gitignorePath = join41(cwd, ".gitignore");
+    const gitignorePath = join43(cwd, ".gitignore");
     const stats = statSync5(gitignorePath);
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
@@ -23563,19 +23743,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 +23861,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 +23878,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 readFile30, rm as rm6 } from "fs/promises";
+import { tmpdir as tmpdir5, platform as platform4 } from "os";
+import { join as join44 } from "path";
 function registerInkInstance(instance) {
   inkInstance = instance;
 }
@@ -23720,13 +23888,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 +23962,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 +23983,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(join44(tmpdir5(), "autopilot-bang-"));
+  const logPath = logDir2 ? join44(logDir2, "out.log") : null;
   const viaScript = logPath ? scriptInvocation(command, shell, logPath) : null;
   inkInstance?.clear();
   origOut.call(stdout, `
@@ -23858,9 +24026,9 @@ $ ${command}
   }
   let output = spawnError ? `failed to start: ${spawnError}` : null;
   if (captured && logPath) {
-    output = cleanTerminalOutput(await readFile28(logPath, "utf8").catch(() => ""));
+    output = cleanTerminalOutput(await readFile30(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 };
 }
@@ -26039,6 +26207,7 @@ var init_activity = __esm({
 var camouflage_view_exports = {};
 __export(camouflage_view_exports, {
   CamouflageUnavailable: () => CamouflageUnavailable,
+  executeCodeSummary: () => executeCodeSummary,
   helpOptions: () => helpOptions,
   listMentionDir: () => listMentionDir,
   modelOptions: () => modelOptions,
@@ -26050,10 +26219,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 join45, 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 +26311,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 +26401,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("~") ? join45(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 {
@@ -26270,8 +26439,26 @@ function toolRow(name, title, rawArgs) {
     const rest = title.toLowerCase().startsWith(`${name.toLowerCase()} `) ? title.slice(name.length + 1) : title;
     return { label, args: rest.trim() };
   }
+  if (name === "execute_code") {
+    return { label: "Code", args: clip(executeCodeSummary(rawArgs)) };
+  }
   const args = (rawArgs ?? "").replace(/\s+/g, " ").trim();
-  return { label, args: args.length > 120 ? `${args.slice(0, 119)}\u2026` : args };
+  return { label, args: clip(args) };
+}
+function clip(s) {
+  return s.length > 120 ? `${s.slice(0, 119)}\u2026` : s;
+}
+function executeCodeSummary(rawArgs) {
+  let parsed = {};
+  try {
+    parsed = rawArgs ? JSON.parse(rawArgs) : {};
+  } catch {
+    return "running a code batch";
+  }
+  if (typeof parsed.reasoning === "string" && parsed.reasoning.trim()) return parsed.reasoning.replace(/\s+/g, " ").trim();
+  const code = typeof parsed.code === "string" ? parsed.code : "";
+  const first = code.split("\n").map((l) => l.trim()).find((l) => l && !l.startsWith("//"));
+  return first ? first.replace(/\s+/g, " ") : "running a code batch";
 }
 function toolSummary(name, ok, declined, content) {
   if (declined) return "You declined this \xB7 tell autopilot what to do instead";
@@ -26318,14 +26505,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 +29411,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 +29768,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 readFile31 } from "fs/promises";
+import { basename as basename9, join as join46, 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 +29781,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 readFile31(join46(root, "package.json"), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const pkg = parsed;
     const metadata = {};
@@ -29622,7 +29809,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 readFile31(join46(root, name), "utf8")).trim();
       if (content) return { source: `project license (${name})`, content: content.slice(0, 700) };
     } catch {
     }
@@ -29655,13 +29842,13 @@ async function buildJevContext(question, messages, cwd = process.cwd()) {
       conversationRemaining -= source.length + content.length + 2;
     }
   }
-  const currentDirectory = basename8(resolve16(cwd));
+  const currentDirectory = basename9(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) {
     const root = projectRoot(cwd);
     const metadata = await readPackageMetadata(root);
-    if (!metadata.name) metadata.name = basename8(root);
+    if (!metadata.name) metadata.name = basename9(root);
     add("project metadata (package.json or directory)", JSON.stringify(metadata));
     if (LICENSE_QUESTION.test(question)) {
       const license = await readLicenseEvidence(root);
@@ -30704,8 +30891,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 readFile32, readdir as readdir9, stat as stat12 } from "fs/promises";
+import { join as join47, 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 +30906,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 readFile32(filePath, "utf-8");
   const parsed = parseFrontmatter(raw);
   const manifest = normalizeManifest(parsed.data, filePath);
   const body = parsed.content.trim();
@@ -30738,11 +30925,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 = join47(dirPath, entry);
+      const s = await stat12(full);
       if (s.isFile() && extname(entry) === ".md") {
         files.push(full);
       }
@@ -30769,12 +30956,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 writeFile15, unlink as unlink5, readFile as readFile33 } from "fs/promises";
+import { join as join48 } from "path";
 function getSkillDirs(cwd) {
   return {
-    projectDir: join46(cwd, ".kimiflare", "skills"),
-    globalDir: join46(process.env.HOME ?? "", ".config", "kimiflare", "skills")
+    projectDir: join48(cwd, ".kimiflare", "skills"),
+    globalDir: join48(process.env.HOME ?? "", ".config", "kimiflare", "skills")
   };
 }
 async function listAllSkills(cwd) {
@@ -30788,7 +30975,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 = join48(dir, `${opts2.name}.md`);
   const frontmatter = {
     name: opts2.name,
     enabled: true,
@@ -30809,7 +30996,7 @@ ${yaml}
 
 Add your instructions here.
 `;
-  await mkdir17(dir, { recursive: true });
+  await mkdir18(dir, { recursive: true });
   await writeFile15(filepath, content, "utf8");
   return { filepath };
 }
@@ -30817,14 +31004,14 @@ async function deleteSkill(name, 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`);
-  await unlink4(skill.filePath);
+  await unlink5(skill.filePath);
   return { filepath: skill.filePath };
 }
 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 readFile33(skill.filePath, "utf-8");
   const parsed = parseFrontmatter(raw);
   parsed.data.enabled = enabled2;
   const yaml = Object.entries(parsed.data).map(([k, v]) => {
@@ -31096,15 +31283,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 readFile34 } from "fs/promises";
+import { join as join49 } 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 || join49(homedir27(), ".local", "share");
+  return join49(xdg, "kimiflare");
 }
 function usagePath4() {
-  return join47(usageDir3(), "usage.json");
+  return join49(usageDir3(), "usage.json");
 }
 function today3() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -31116,7 +31303,7 @@ function daysAgo2(n) {
 }
 async function loadLog3() {
   try {
-    const raw = await readFile32(usagePath4(), "utf8");
+    const raw = await readFile34(usagePath4(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -31173,7 +31360,7 @@ var init_tui_report = __esm({
 });
 
 // src/ui/slash-commands.ts
-import { join as join48 } from "path";
+import { join as join50 } from "path";
 import QRCode from "qrcode";
 function executeFreshStart(ctx, planText, overrideMode, opts2 = {}) {
   const oldSessionId = ctx.sessionIdRef.current;
@@ -31644,7 +31831,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 +32292,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(join50(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 +32337,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 = join50(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
           await addCheckpoint(filePath, cp);
           setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: `checkpoint saved: "${label}"` }]);
         } catch (e) {
@@ -32875,9 +33062,9 @@ async function triageIncoming(text, context, opts2 = {}) {
       "steer = it adjusts or adds to the current task and should be folded in at the next step;",
       "queue = it is separate work that should run after the current task;",
       "aside = it is a question about progress that can be answered without changing the work.",
-      `Current task: ${clip(context.currentTask)}`,
-      context.activity ? `Doing now: ${clip(context.activity, 200)}` : "",
-      `New message: ${clip(text)}`
+      `Current task: ${clip2(context.currentTask)}`,
+      context.activity ? `Doing now: ${clip2(context.activity, 200)}` : "",
+      `New message: ${clip2(text)}`
     ].filter(Boolean).join("\n"),
     options: [...OPTIONS2]
   };
@@ -32905,7 +33092,7 @@ async function triageIncoming(text, context, opts2 = {}) {
 function unsure(reason, confidence) {
   return { kind: "queue", source: "default", reason, ...confidence === void 0 ? {} : { confidence } };
 }
-function clip(text, max = MAX_CHARS) {
+function clip2(text, max = MAX_CHARS) {
   const single = text.replace(/\s+/g, " ").trim();
   return single.length > max ? `${single.slice(0, max - 1)}\u2026` : single;
 }
@@ -32952,7 +33139,7 @@ var init_inbox_triage = __esm({
 
 // src/agent/aside.ts
 async function answerAside(question, context, opts2) {
-  const clip2 = (text2, max) => (text2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
+  const clip3 = (text2, max) => (text2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
   const messages = [
     {
       role: "system",
@@ -32961,11 +33148,11 @@ async function answerAside(question, context, opts2) {
     {
       role: "user",
       content: [
-        `Task: ${clip2(context.currentTask, 600)}`,
-        context.progress ? `Progress: ${clip2(context.progress, 600)}` : "",
-        context.activity ? `Running now: ${clip2(context.activity, 300)}` : "",
-        context.recentAssistantText ? `Latest agent message: ${clip2(context.recentAssistantText, 800)}` : "",
-        `Question: ${clip2(question, 400)}`
+        `Task: ${clip3(context.currentTask, 600)}`,
+        context.progress ? `Progress: ${clip3(context.progress, 600)}` : "",
+        context.activity ? `Running now: ${clip3(context.activity, 300)}` : "",
+        context.recentAssistantText ? `Latest agent message: ${clip3(context.recentAssistantText, 800)}` : "",
+        `Question: ${clip3(question, 400)}`
       ].filter(Boolean).join("\n")
     }
   ];
@@ -33206,9 +33393,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 +33821,15 @@ var init_frontmatter2 = __esm({
 });
 
 // src/commands/loader.ts
-import { open, realpath as realpath6 } from "fs/promises";
+import { open, realpath as realpath8 } from "fs/promises";
 import { homedir as homedir28 } from "os";
-import { join as join49, relative as relative10, sep as sep6 } from "path";
+import { join as join51, relative as relative11, sep as sep7 } from "path";
 function projectCommandsDir(cwd = process.cwd()) {
-  return join49(cwd, ".kimiflare", "commands");
+  return join51(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 || join51(homedir28(), ".config");
+  return join51(xdg, "kimiflare", "commands");
 }
 async function loadCustomCommands(cwd = process.cwd()) {
   const warnings = [];
@@ -33681,7 +33868,7 @@ async function loadCustomCommands(cwd = process.cwd()) {
 async function resolveSafeDir(dir, source, cwd, warnings) {
   let realDir;
   try {
-    realDir = await realpath6(dir);
+    realDir = await realpath8(dir);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -33692,11 +33879,11 @@ async function resolveSafeDir(dir, source, cwd, warnings) {
   if (source === "project") {
     let realCwd;
     try {
-      realCwd = await realpath6(cwd);
+      realCwd = await realpath8(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 +33958,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 +33981,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 realpath9 } 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 +34073,7 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
       return "" + trailing;
     });
   }
-  const realCwd = await realpath7(cwd).catch(() => cwd);
+  const realCwd = await realpath9(cwd).catch(() => cwd);
   const replacements = await Promise.all(
     matches.map(async (match) => {
       const rawPath = match[1] ?? "";
@@ -33895,23 +34082,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 realpath9(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 +34211,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 readFile35, readdir as readdir10 } from "fs/promises";
+import { join as join52 } from "path";
 import { homedir as homedir29 } from "os";
 function projectThemesDir(cwd = process.cwd()) {
-  return join50(cwd, ".kimiflare", "themes");
+  return join52(cwd, ".kimiflare", "themes");
 }
 function isHexColor(c) {
   return /^#[0-9a-fA-F]{6}$/.test(c);
@@ -34112,15 +34299,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 = join52(dir, file);
     let raw;
     try {
-      raw = await readFile33(path, "utf-8");
+      raw = await readFile35(path, "utf-8");
     } catch (e) {
       errors.push(`${path}: ${e instanceof Error ? e.message : String(e)}`);
       continue;
@@ -34266,8 +34453,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 = join52(
+      process.env.XDG_CONFIG_HOME || join52(homedir29(), ".config"),
       "kimiflare",
       "themes"
     );
@@ -36798,9 +36985,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 readFile36, stat as stat13 } from "fs/promises";
 import { createHash as createHash7 } from "crypto";
-import { resolve as resolve17, join as join51 } from "path";
+import { resolve as resolve18, join as join53 } from "path";
 var TurnSupervisor;
 var init_supervisor = __esm({
   "src/agent/supervisor.ts"() {
@@ -37190,12 +37377,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 join54 } 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 = join54(cwd, sig);
       if (sig.includes("*")) {
         try {
           const parts = sig.split("*");
@@ -37216,14 +37403,14 @@ function detectFlavor(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (existsSync9(join52(cwd, c))) return c;
+    if (existsSync9(join54(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 = join54(cwd, r);
     try {
       const s = statSync6(p);
       if (s.isDirectory()) roots.push(r);
@@ -37234,9 +37421,9 @@ function findSourceRoots(cwd) {
 }
 function findCiConfig(cwd) {
   for (const c of CI_PATHS) {
-    if (existsSync9(join52(cwd, c))) {
+    if (existsSync9(join54(cwd, c))) {
       try {
-        const s = statSync6(join52(cwd, c));
+        const s = statSync6(join54(cwd, c));
         return s.isDirectory() ? c : c;
       } catch {
       }
@@ -37373,7 +37560,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(join54(cwd, ".git"))
   };
 }
 function bashDiscoveryCommands(profile) {
@@ -37536,19 +37723,33 @@ Aim for 100\u2013200 lines total. Use markdown tables where they save space.
    - State management approach
 `.trim();
 }
+function buildInitTasks(targetFilename) {
+  return [
+    { id: "identity", title: "Inspect project identity and configuration", status: "in_progress" },
+    { id: "structure", title: "Discover source structure, tests, and conventions", status: "pending" },
+    { id: "workflow", title: "Identify build and development workflows", status: "pending" },
+    { id: "architecture", title: "Map architecture and project patterns", status: "pending" },
+    { id: "write", title: "Write or refresh " + targetFilename, status: "pending" },
+    { id: "verify", title: "Re-read and verify " + targetFilename, status: "pending" }
+  ];
+}
 function buildInitPrompt(cwd) {
   const existingName = ["AGENTS.md", "KIMI.md", "KIMIFLARE.md", "AGENT.md"].find(
-    (n) => existsSync9(join52(cwd, n))
+    (n) => existsSync9(join54(cwd, n))
   );
   const isRefresh = existingName !== void 0;
   const targetFilename = existingName ?? "AGENTS.md";
   const profile = analyzeProject(cwd);
   const checklist = discoveryChecklist(profile);
   const sections = sectionTemplate();
+  const tasks = buildInitTasks(targetFilename);
   const promptParts = [
     isRefresh ? `Regenerate \`${targetFilename}\` at the repository root to refresh project context. The file already exists \u2014 read it first and preserve anything still accurate, updating only what has changed or is missing.` : `Generate a \`${targetFilename}\` at the repository root so future agents have comprehensive project context.`,
     "",
     "This is a **structured investigation**. Follow the checklist below systematically. Use the `glob`, `read`, `grep`, and `bash` tools to gather information. Do not skip steps.",
+    `Visible task list (already initialized in the UI; keep these IDs and titles):
+${tasks.map((task) => "- " + task.id + ": " + task.status + ": " + task.title).join("\n")}`,
+    "Keep the visible task checklist synchronized with your progress using `tasks_set`: update the current phase and mark the next phase active before moving on. Map the detailed checklist below onto these high-level tasks.",
     "",
     `**Detected project profile:** ${profile.primaryLanguage} (${profile.flavor})`,
     profile.packageFile ? `- Package file: ${profile.packageFile}` : null,
@@ -37570,10 +37771,10 @@ function buildInitPrompt(cwd) {
     "",
     isRefresh ? `After writing the file, re-read \`${targetFilename}\` and verify it is complete and accurate.` : "After writing the file, re-read it and verify all sections are present and accurate.",
     "",
-    "Do not call `tasks_set` for this. Just follow the checklist, gather information, then write the file."
+    "The visible task checklist is already initialized. Mark investigation phases complete as you finish them, and complete the write and verification tasks only after re-reading the generated file."
   ];
   const prompt = promptParts.filter((p) => p !== null).join("\n");
-  return { prompt, targetFilename, isRefresh };
+  return { prompt, targetFilename, isRefresh, tasks };
 }
 var FLAVOR_SIGNATURES, SOURCE_ROOT_CANDIDATES, CI_PATHS;
 var init_context_generator = __esm({
@@ -37622,7 +37823,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 join55 } from "path";
 async function runInit(deps) {
   const {
     cfg,
@@ -37636,6 +37837,7 @@ async function runInit(deps) {
     setUsage,
     setSessionUsage,
     setKimiMdStale,
+    onTasks,
     beginTurn,
     endTurn,
     ensureSessionId,
@@ -37670,7 +37872,8 @@ async function runInit(deps) {
     return;
   }
   const cwd = process.cwd();
-  const { prompt, targetFilename, isRefresh } = buildInitPrompt(cwd);
+  const { prompt, targetFilename, isRefresh, tasks } = buildInitPrompt(cwd);
+  onTasks(tasks);
   setEvents((e) => [
     ...e,
     { kind: "user", key: mkKey2(), text: isRefresh ? `/init (refreshing ${targetFilename})` : "/init" }
@@ -37715,7 +37918,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: readFile38 }) => readFile38(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
             })
           );
         }
@@ -37800,6 +38003,7 @@ async function runInit(deps) {
           void getCostReport(sid).then((report) => setSessionUsage(report.session));
         },
         onResponseMeta: updateResponseMeta,
+        onTasks,
         askPermission: (req) => askForPermission(req, { promptOnBlockedBash: true }),
         onGuardrail: (ev) => {
           setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: ev.message }]);
@@ -37820,7 +38024,7 @@ async function runInit(deps) {
         }
       }
     });
-    if (existsSync10(join53(cwd, targetFilename))) {
+    if (existsSync10(join55(cwd, targetFilename))) {
       if (cacheStableRef.current) {
         messagesRef.current[1] = {
           role: "system",
@@ -37885,6 +38089,7 @@ async function runInit(deps) {
   } finally {
     logger.info("runInit:finally");
     setCodeMode(false);
+    onTasks([]);
     const asstId = activeAsstIdRef.current;
     if (asstId !== null) updateAssistant(asstId, () => ({ streaming: false }));
     endTurn();
@@ -37912,11 +38117,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 stat14, readFile as readFile37 } from "fs/promises";
+import { join as join56, extname as extname2 } from "path";
 async function dirExists(path) {
   try {
-    const s = await stat12(path);
+    const s = await stat14(path);
     return s.isDirectory();
   } catch {
     return false;
@@ -37924,7 +38129,7 @@ async function dirExists(path) {
 }
 async function fileExists(path) {
   try {
-    const s = await stat12(path);
+    const s = await stat14(path);
     return s.isFile();
   } catch {
     return false;
@@ -37932,25 +38137,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: join56(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(join56(cwd, ".agents", "skills"), "agents");
+  const agentsMd = await fileExists(join56(cwd, "AGENTS.md")) ? [{ filePath: join56(cwd, "AGENTS.md"), source: "agents-md" }] : [];
+  const githubSkills = await scanSkillDir(join56(cwd, ".github", "skills"), "github");
+  const kimiflareSkills = await scanSkillDir(join56(cwd, ".kimiflare", "skills"), "kimiflare");
   const ordered = [...agentsSkills, ...agentsMd, ...githubSkills, ...kimiflareSkills];
   return ordered;
 }
 async function readSkillFile(filePath) {
-  const bytes = await readFile35(filePath);
+  const bytes = await readFile37(filePath);
   return { bytes, text: bytes.toString("utf-8") };
 }
 var SKILL_EXTENSIONS;
@@ -38156,7 +38361,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 join57 } from "path";
 function runStartupTasks(deps) {
   const {
     cfg,
@@ -38179,7 +38384,7 @@ function runStartupTasks(deps) {
     }
   });
   if (cfg.memoryEnabled) {
-    const dbPath = cfg.memoryDbPath ?? join55(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = cfg.memoryDbPath ?? join57(process.cwd(), ".kimiflare", "memory.db");
     const manager = new MemoryManager({
       dbPath,
       ...auth,
@@ -38211,7 +38416,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(join57(cwd, name)))) {
       const lastRefresh = manager.getLastKimiMdRefreshTime(cwd);
       const driftCount = manager.countHighSignalMemoriesSince(cwd, lastRefresh);
       if (driftCount >= 5) {
@@ -38222,7 +38427,7 @@ function runStartupTasks(deps) {
     memoryManagerRef.current?.close();
     memoryManagerRef.current = null;
   }
-  const skillDbPath = cfg.memoryDbPath ?? join55(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = cfg.memoryDbPath ?? join57(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -38579,8 +38784,8 @@ var init_run_compact = __esm({
 });
 
 // src/commands/save.ts
-import { mkdir as mkdir18, writeFile as writeFile16, unlink as unlink5 } from "fs/promises";
-import { dirname as dirname21 } from "path";
+import { mkdir as mkdir19, writeFile as writeFile16, unlink as unlink6 } from "fs/promises";
+import { dirname as dirname22 } from "path";
 async function saveCustomCommand(opts2) {
   const dir = opts2.source === "project" ? projectCommandsDir(opts2.cwd) : globalCommandsDir();
   const filepath = `${dir}/${opts2.name}.md`;
@@ -38591,12 +38796,12 @@ 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 mkdir19(dirname22(filepath), { recursive: true });
   await writeFile16(filepath, content, "utf8");
   return { filepath };
 }
 async function deleteCustomCommand(cmd) {
-  await unlink5(cmd.filepath);
+  await unlink6(cmd.filepath);
 }
 var init_save = __esm({
   "src/commands/save.ts"() {
@@ -38715,7 +38920,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 join58, resolve as resolve19 } from "path";
 import { homedir as homedir30 } from "os";
 import { jsx as jsx42, jsxs as jsxs39 } from "react/jsx-runtime";
 function App({
@@ -38950,6 +39155,21 @@ ${wcagWarnings.join("\n")}` }
   const effortRef = useRef9(effort);
   const usageRef = useRef9(null);
   const responseMetaRef = useRef9(null);
+  const updateTaskTracking = useCallback8((nextTasks) => {
+    const previousTasks = tasksRef.current;
+    const prevEmpty = previousTasks.length === 0;
+    const prevAllDone = previousTasks.length > 0 && previousTasks.every((task) => task.status === "completed");
+    tasksRef.current = nextTasks;
+    setTasks(nextTasks);
+    if ((prevEmpty || prevAllDone) && nextTasks.length > 0) {
+      setTasksStartedAt(Date.now());
+      setTasksStartTokens(usageRef.current?.prompt_tokens ?? 0);
+    }
+    if (nextTasks.length === 0) {
+      setTasksStartedAt(null);
+      setTasksStartTokens(0);
+    }
+  }, [tasksRef, setTasks, setTasksStartedAt, setTasksStartTokens]);
   const lastApiErrorRef = useRef9(null);
   const updateCheckedRef = useRef9(false);
   const sessionStateRef = useRef9(emptySessionState());
@@ -39043,8 +39263,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("~") ? join58(homedir30(), directory.slice(1)) : directory;
+      const target = resolve19(cwd, expanded || ".");
       const entries2 = await glob("*", {
         cwd: target,
         dot: false,
@@ -39543,6 +39763,7 @@ ${wcagWarnings.join("\n")}` }
       setUsage,
       setSessionUsage,
       setKimiMdStale,
+      onTasks: updateTaskTracking,
       beginTurn,
       endTurn,
       ensureSessionId,
@@ -39572,7 +39793,7 @@ ${wcagWarnings.join("\n")}` }
       lastApiErrorRef,
       supervisorRef
     });
-  }, [cfg, busy, updateAssistant, updateTool, updateResponseMeta]);
+  }, [cfg, busy, updateAssistant, updateTool, updateResponseMeta, updateTaskTracking]);
   const handleThemePick = useCallback8(
     (picked) => {
       setShowThemePicker(false);
@@ -40026,7 +40247,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(join58(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 +40271,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 = join58(sessionsDir3(), `${sessionIdRef.current}.json`);
                 await addCheckpoint(filePath, cp);
               }
               const summary = await generateContinuationSummary({
@@ -40201,24 +40422,16 @@ ${result2.output ?? "(output not captured)"}`,
           void getCostReport(sid).then((report) => setSessionUsage(report.session));
         },
         onResponseMeta: updateResponseMeta,
-        onTasks: (nextTasks) => {
-          const prevEmpty = tasksRef.current.length === 0;
-          const prevAllDone = tasksRef.current.length > 0 && tasksRef.current.every((t) => t.status === "completed");
-          tasksRef.current = nextTasks;
-          setTasks(nextTasks);
-          if ((prevEmpty || prevAllDone) && nextTasks.length > 0) {
-            setTasksStartedAt(Date.now());
-            setTasksStartTokens(usageRef.current?.prompt_tokens ?? 0);
-          }
-          if (nextTasks.length === 0) {
-            setTasksStartedAt(null);
-            setTasksStartTokens(0);
-          }
-        },
+        onTasks: updateTaskTracking,
         onPlanOptions: (options) => {
           planOptionsRef.current = options;
         },
         askPermission: askForPermission,
+        // Sandbox/memory warnings (e.g. Code Mode falling back to the plain
+        // node:vm sandbox) were previously dropped on the floor in the TUI.
+        onWarning: (msg) => {
+          setEvents((e) => [...e, { kind: "info", key: mkKey(), text: msg }]);
+        },
         onGuardrail: (ev) => {
           if (ev.kind === "loop_recovery" || ev.kind === "loop_stopped") return;
           setEvents((e) => [...e, { kind: "info", key: mkKey(), text: ev.message }]);
@@ -40381,7 +40594,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: readFile38 }) => readFile38(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
                 })
               );
             }
@@ -40574,7 +40787,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 = join58(sessionsDir3(), `${sessionIdRef.current}.json`);
                       await addCheckpoint(filePath, cp);
                     }
                     const summary = await generateContinuationSummary({
@@ -40650,7 +40863,7 @@ ${result2.output ?? "(output not captured)"}`,
         }
       );
     },
-    [cfg, handleSlash, updateAssistant, updateTool, saveSessionSafe, updateResponseMeta, setShowPlanCompletePicker, runUserShellCommand, ensureTraceStarted]
+    [cfg, handleSlash, updateAssistant, updateTool, saveSessionSafe, updateResponseMeta, setShowPlanCompletePicker, runUserShellCommand, ensureTraceStarted, updateTaskTracking]
   );
   useEffect11(() => {
     if (canDrainQueue({
@@ -41141,7 +41354,7 @@ ${result2.output ?? "(output not captured)"}`,
       lsp: {
         servers: cfg?.lspServers ?? {},
         scope: lspScope,
-        hasProjectDir: existsSync12(join56(process.cwd(), ".kimiflare"))
+        hasProjectDir: existsSync12(join58(process.cwd(), ".kimiflare"))
       }
     });
   });
@@ -41198,7 +41411,7 @@ ${result2.output ?? "(output not captured)"}`,
         onCommandDelete: handleCommandDelete2,
         lspServers: cfg?.lspServers ?? {},
         lspScope,
-        hasProjectDir: existsSync12(join56(process.cwd(), ".kimiflare")),
+        hasProjectDir: existsSync12(join58(process.cwd(), ".kimiflare")),
         onLspSave: handleLspSave2,
         themes: themeList(),
         onPickTheme: handleThemePick,
@@ -41685,11 +41898,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 readFile17 } from "fs/promises";
+import { resolve as resolve7, basename as basename4 } 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 +41910,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 +41923,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 +41937,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 stat15 = await import("fs/promises").then((m) => m.stat(resolve7(cwd, pattern)));
+      if (stat15.isFile()) {
+        resolved.add(resolve7(cwd, pattern));
         continue;
       }
     } catch {
@@ -41749,12 +41962,12 @@ async function buildUserMessage(prompt, files, cwd) {
         imageParts.push({ type: "image_url", image_url: { url: img.dataUrl } });
       } catch (e) {
         fileContents.push(`
-<!-- failed to attach image ${basename3(filePath)}: ${e.message} -->
+<!-- failed to attach image ${basename4(filePath)}: ${e.message} -->
 `);
       }
     } else {
       try {
-        const content = await readFile15(filePath, "utf8");
+        const content = await readFile17(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -41763,7 +41976,7 @@ ${content}
 `);
       } catch (e) {
         fileContents.push(`
-<!-- failed to read ${basename3(filePath)}: ${e.message} -->
+<!-- failed to read ${basename4(filePath)}: ${e.message} -->
 `);
       }
     }
@@ -41789,7 +42002,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 +42682,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;
   });