autopilot-ai 1.25.0 → 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 = {};
@@ -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");
   }
 });
@@ -2994,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);
@@ -3006,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 {
     }
   }
@@ -3575,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 = resolve20(dir);
-      if (prebuild) return prebuild;
-      var nearby = resolve20(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 resolve20(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";
@@ -3820,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());
@@ -3836,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 } }
     );
   }
@@ -3933,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";
@@ -4663,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.
@@ -5131,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 {
@@ -5139,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;
@@ -5441,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: readFile37, stat: stat14 } = await import("fs/promises");
-      const { join: join58 } = 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 = join58(cwd, file);
-          const size = (await stat14(path)).size;
+          const path = join59(cwd, file);
+          const size = (await stat15(path)).size;
           if (size > 0 && size <= 1024 * 1024) {
-            const text = await readFile37(path, "utf8");
+            const text = await readFile38(path, "utf8");
             lines = text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
           }
         } catch {
@@ -5818,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: {
@@ -6538,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,
@@ -6559,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);
@@ -7667,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.",
@@ -7694,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;
@@ -7726,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.",
@@ -7747,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}.`;
+        });
       }
     };
   }
@@ -7766,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") {
@@ -7968,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}
@@ -8109,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) => {
@@ -8219,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;
@@ -8244,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 {
@@ -8286,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;
@@ -8294,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 {
@@ -8453,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 {
@@ -8500,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 {
@@ -9103,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);
@@ -9136,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;
@@ -9438,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}
@@ -9453,7 +9329,7 @@ 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((resolve20) => {
@@ -9529,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(() => {
@@ -9592,19 +9468,19 @@ var init_open_browser = __esm({
 });
 
 // src/tools/html-artifact.ts
-import { chmod as chmod2, lstat as lstat2, mkdir as mkdir9, mkdtemp, readFile as readFile11, readdir as readdir4, realpath as realpath2, rm as rm2, stat as stat5, writeFile as writeFile10 } from "fs/promises";
+import { 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 join20, relative as relative3, resolve as resolve3, sep as sep2 } from "path";
+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 realpath2(workspaceRoot);
+  const workspaceReal = await realpath3(workspaceRoot);
   const inputPath = resolvePath(cwd, args.sourcePath);
   let inputReal;
   try {
-    inputReal = await realpath2(inputPath);
+    inputReal = await realpath3(inputPath);
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new ToolError({
@@ -9622,34 +9498,34 @@ async function createHtmlArtifactFromFile(args, cwd, options = {}) {
       suggestion: "Write the HTML file inside the workspace and retry with its workspace-relative path."
     });
   }
-  const info = await stat5(inputReal);
+  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 readFile11(inputReal, "utf8");
+  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 ?? join20(tmpdir3(), ARTIFACT_ROOT);
+  const rootDir = options.rootDir ?? join21(tmpdir3(), ARTIFACT_ROOT);
   const workspaceRoot = await getWorkspaceRoot(cwd);
-  const workspaceReal = await realpath2(workspaceRoot);
+  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 realpath2(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(join20(rootDir, ARTIFACT_PREFIX));
-  await chmod2(artifactDir, 448);
-  const filePath = join20(artifactDir, "index.html");
-  await writeFile10(filePath, buildArtifactHtml(args.title, args.html), {
+  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
@@ -9667,7 +9543,7 @@ async function cleanupOldArtifacts(rootDir, now2 = Date.now()) {
   }
   for (const entry of entries) {
     if (!entry.name.startsWith(ARTIFACT_PREFIX) || !entry.isDirectory() || entry.isSymbolicLink()) continue;
-    const path = join20(rootDir, entry.name);
+    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;
@@ -9785,7 +9661,7 @@ async function ensureSecureRoot(rootDir) {
   if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
     throw new Error("Artifact storage directory is not owned by the current user: " + rootDir);
   }
-  if ((info.mode & 63) !== 0) await chmod2(rootDir, 448);
+  if ((info.mode & 63) !== 0) await chmod3(rootDir, 448);
 }
 async function getWorkspaceRoot(cwd) {
   try {
@@ -9861,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.",
@@ -10068,7 +9944,7 @@ var init_memory = __esm({
 import { execFile as execFile4 } from "child_process";
 import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { promisify as promisify4 } from "util";
 async function git(args, cwd, env2) {
   const { stdout } = await execFileAsync2("git", args, {
@@ -10116,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 mkdtemp2(join21(tmpdir4(), "autopilot-snapshot-"));
+  const scratch = await mkdtemp2(join22(tmpdir4(), "autopilot-snapshot-"));
   try {
-    const env2 = { GIT_INDEX_FILE: join21(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();
@@ -10143,9 +10019,9 @@ async function getRepositorySnapshot(cwd) {
 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 mkdtemp2(join21(tmpdir4(), "autopilot-archive-"));
+  const scratch = await mkdtemp2(join22(tmpdir4(), "autopilot-archive-"));
   try {
-    const env2 = { GIT_INDEX_FILE: join21(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);
@@ -10193,23 +10069,23 @@ var init_hotcell_snapshot = __esm({
 });
 
 // src/tools/hotcell-worker-cache.ts
-import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } 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 join22 } from "path";
+import { dirname as dirname10, join as join23 } from "path";
 function workerCachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join22(homedir11(), ".config");
-  return join22(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 readFile12(workerCachePath(), "utf8"));
+    return JSON.parse(await readFile13(workerCachePath(), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeCache2(cache) {
-  await mkdir10(dirname9(workerCachePath()), { recursive: true });
-  await writeFile11(workerCachePath(), JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
+  await mkdir10(dirname10(workerCachePath()), { recursive: true });
+  await writeFile10(workerCachePath(), JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
 }
 function ensureWorkerBackup(opts2) {
   const existing = inflight.get(opts2.packageSpec);
@@ -10815,17 +10691,17 @@ var init_worker_registry = __esm({
 });
 
 // src/tools/subagent-stats.ts
-import { appendFile as appendFile2, mkdir as mkdir11, readFile as readFile13 } 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 join23 } from "path";
+import { dirname as dirname11, join as join24 } from "path";
 function subagentStatsPath() {
-  const xdg = process.env.XDG_DATA_HOME || join23(homedir12(), ".local", "share");
-  return join23(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 mkdir11(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) });
@@ -10845,7 +10721,7 @@ function failureReason(error) {
 async function readSubagentStats(days = 7, now2 = Date.now()) {
   let raw = "";
   try {
-    raw = await readFile13(subagentStatsPath(), "utf8");
+    raw = await readFile14(subagentStatsPath(), "utf8");
   } catch {
   }
   const since = now2 - days * 24 * 60 * 60 * 1e3;
@@ -11742,11 +11618,11 @@ import Database from "better-sqlite3";
 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 join24 } 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 || join24(homedir13(), ".local", "state");
-  return process.env.AUTOPILOT_JOBS_DB || join24(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 {
@@ -11776,8 +11652,8 @@ function waitForProcessStartTime(pid, jobId, exitPath) {
 function readProcessStartTime(pid) {
   if (process.platform === "linux") {
     try {
-      const stat14 = readFileSync4(`/proc/${pid}/stat`, "utf8");
-      const fieldsAfterCommand = stat14.slice(stat14.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;
@@ -11889,8 +11765,8 @@ child.on('close', (code, signal) => {
       db;
       jobsDir;
       constructor(dbPath = defaultJobDbPath()) {
-        mkdirSync5(dirname11(dbPath), { recursive: true, mode: 448 });
-        this.jobsDir = join24(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");
@@ -11941,13 +11817,13 @@ child.on('close', (code, signal) => {
           if (existing) return toJobRecord(existing);
         }
         const id = randomUUID4();
-        const jobDir = join24(this.jobsDir, id);
+        const jobDir = join25(this.jobsDir, id);
         mkdirSync5(jobDir, { recursive: true, mode: 448 });
         const paths = {
-          stdoutPath: join24(jobDir, "stdout.log"),
-          stderrPath: join24(jobDir, "stderr.log"),
-          exitPath: join24(jobDir, "exit.json"),
-          pidPath: join24(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 {
@@ -12228,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 join25 } from "path";
+import { dirname as dirname13, join as join26 } from "path";
 function defaultRunsDbPath() {
-  const root = process.env.XDG_STATE_HOME || join25(homedir14(), ".local", "state");
-  return process.env.AUTOPILOT_RUNS_DB || join25(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)) {
@@ -12319,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");
@@ -12841,7 +12717,7 @@ var init_wait_for = __esm({
 });
 
 // src/tools/executor.ts
-import { realpath as realpath3 } from "fs/promises";
+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;
@@ -12863,11 +12739,11 @@ 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 realpath3(cwd);
+  const root = await realpath4(cwd);
   const candidate = resolve5(root, pathValue);
   assertInsideResearchRoot(candidate, root);
   assertNoSensitivePath(candidate, root);
-  const actual = await realpath3(candidate);
+  const actual = await realpath4(candidate);
   assertInsideResearchRoot(actual, root);
   assertNoSensitivePath(actual, root);
 }
@@ -13415,12 +13291,12 @@ __export(sessions_exports, {
   saveSession: () => saveSession,
   sessionsDir: () => sessionsDir
 });
-import { readFile as readFile14, writeFile as writeFile12, mkdir as mkdir12, readdir as readdir5, stat as stat6 } 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 join26 } from "path";
+import { join as join27 } from "path";
 function sessionsDir() {
-  const xdg = process.env.XDG_DATA_HOME || join26(homedir15(), ".local", "share");
-  return join26(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);
@@ -13440,8 +13316,8 @@ function makeSessionId(firstPrompt) {
 async function saveSession(file) {
   const dir = sessionsDir();
   await mkdir12(dir, { recursive: true });
-  const path = join26(dir, `${file.id}.json`);
-  await writeFile12(path, JSON.stringify(file, null, 2), "utf8");
+  const path = join27(dir, `${file.id}.json`);
+  await writeFile11(path, JSON.stringify(file, null, 2), "utf8");
   return path;
 }
 async function pruneSessions() {
@@ -13460,9 +13336,9 @@ async function listSessions(limit = 30, cwd) {
   const summaries = [];
   for (const name of entries) {
     if (!name.endsWith(".json")) continue;
-    const path = join26(dir, name);
+    const path = join27(dir, name);
     try {
-      const [s, raw] = await Promise.all([stat6(path), readFile14(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");
@@ -13484,7 +13360,7 @@ async function listSessions(limit = 30, cwd) {
   return summaries.slice(0, limit);
 }
 async function loadSession(filePath) {
-  const raw = await readFile14(filePath, "utf8");
+  const raw = await readFile15(filePath, "utf8");
   const file = JSON.parse(raw);
   if (Array.isArray(file.messages)) repairDanglingToolCalls(file.messages);
   return file;
@@ -13534,10 +13410,10 @@ var init_sessions = __esm({
 });
 
 // src/util/image.ts
-import { readFile as readFile15 } 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 readFile15(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`
@@ -13547,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}`
   };
@@ -13699,17 +13575,17 @@ __export(retention_exports, {
   listTraceSessions: () => listTraceSessions,
   pruneTraces: () => pruneTraces
 });
-import { readdir as readdir6, rm as rm4, stat as stat7 } from "fs/promises";
-import { join as join27 } 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 readdir6(path, { withFileTypes: true });
   for (const entry of entries) {
-    const p = join27(path, entry.name);
+    const p = join28(path, entry.name);
     if (entry.isDirectory()) total += await dirSize(p);
     else if (entry.isFile()) {
       try {
-        total += (await stat7(p)).size;
+        total += (await stat8(p)).size;
       } catch {
       }
     }
@@ -13726,13 +13602,13 @@ async function listTraceSessions(root) {
   }
   const sessions = [];
   for (const name of names) {
-    const path = join27(base, name);
+    const path = join28(base, name);
     try {
-      const s = await stat7(path);
+      const s = await stat8(path);
       if (!s.isDirectory()) continue;
       let mtime = s.mtime;
       try {
-        mtime = (await stat7(join27(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) });
@@ -13786,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 join28 } 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) {
@@ -13799,9 +13675,9 @@ async function git2(args, cwd) {
   }
 }
 function harnessCheckoutDir() {
-  const here = dirname13(fileURLToPath4(import.meta.url));
-  for (const candidate of [join28(here, "..", ".."), join28(here, "..")]) {
-    if (existsSync5(join28(candidate, "package.json")) && existsSync5(join28(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;
 }
@@ -13939,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 join29, 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 || join29(homedir17(), ".config");
-  return join29(xdg, "kimiflare", "settings.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join30(homedir17(), ".config");
+  return join30(xdg, "kimiflare", "settings.json");
 }
 function projectSettingsPath(cwd) {
-  return join29(cwd, ".kimiflare", "settings.json");
+  return join30(cwd, ".kimiflare", "settings.json");
 }
 function readSettingsFile(path) {
   if (!existsSync6(path)) return null;
@@ -14022,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;
 }
@@ -14048,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;
     }
@@ -14269,18 +14145,18 @@ var init_manager2 = __esm({
 });
 
 // src/eval/config.ts
-import { readFile as readFile17 } from "fs/promises";
-import { basename as basename4, resolve as resolve8 } from "path";
+import { readFile as readFile18 } from "fs/promises";
+import { basename as basename5, resolve as resolve8 } from "path";
 async function loadEvalConfig(file) {
   const path = resolve8(file);
-  const raw = JSON.parse(await readFile17(path, "utf8"));
+  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
@@ -14293,8 +14169,8 @@ var init_config2 = __esm({
 });
 
 // src/eval/tasks.ts
-import { readdir as readdir7, readFile as readFile18, stat as stat8 } from "fs/promises";
-import { basename as basename5, join as join30, resolve as resolve9 } from "path";
+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;
 }
@@ -14327,9 +14203,9 @@ async function loadTasks(dir, filter) {
   const tasks = [];
   const seen = /* @__PURE__ */ new Set();
   for (const name of names) {
-    const file = join30(root, name);
-    const task = validateTask(JSON.parse(await readFile18(file, "utf8")), name);
-    if (task.id !== basename5(name, ".json")) throw new Error(`${name}: "id" (${task.id}) must match the file name`);
+    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;
@@ -14337,7 +14213,7 @@ async function loadTasks(dir, filter) {
     for (const [dest, src] of Object.entries(task.files ?? {})) {
       const abs = resolve9(root, src);
       if (!abs.startsWith(root)) throw new Error(`${name}: files["${dest}"] escapes the task directory`);
-      await stat8(abs).catch(() => {
+      await stat9(abs).catch(() => {
         throw new Error(`${name}: files["${dest}"] -> ${src} does not exist`);
       });
       resolvedFiles[dest] = abs;
@@ -14358,8 +14234,8 @@ var init_tasks2 = __esm({
 // src/eval/workspace.ts
 import { execFile as execFile7 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { mkdir as mkdir13, rm as rm5, stat as stat9 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join31, resolve as resolve10 } from "path";
+import { 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 });
@@ -14384,9 +14260,9 @@ async function prepareSourceRepoUncached(repo, cacheDir) {
     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 = join31(cacheDir, slug);
+  const dir = join32(cacheDir, slug);
   await mkdir13(cacheDir, { recursive: true });
-  const exists = await stat9(join31(dir, ".git")).then(() => true).catch(() => false);
+  const exists = await stat10(join32(dir, ".git")).then(() => true).catch(() => false);
   if (!exists) {
     await git3(["clone", "--quiet", "--no-checkout", repo, dir], cacheDir);
   } else {
@@ -14405,7 +14281,7 @@ async function ensureCommit(sourceRepo, commit) {
 async function createWorktree(sourceRepo, commit, path) {
   await ensureCommit(sourceRepo, commit);
   await removeWorktree({ sourceRepo, path }).catch(() => void 0);
-  await mkdir13(join31(path, ".."), { recursive: true });
+  await mkdir13(join32(path, ".."), { recursive: true });
   await git3(["worktree", "add", "--quiet", "--detach", path, commit], sourceRepo);
   return { sourceRepo, path };
 }
@@ -14461,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(`
@@ -14546,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");
@@ -14882,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)) {
@@ -16510,12 +16386,12 @@ __export(openrouter_catalog_exports, {
   loadOpenRouterCatalog: () => loadOpenRouterCatalog,
   mapOpenRouterModel: () => mapOpenRouterModel
 });
-import { readFile as readFile19, writeFile as writeFile13, mkdir as mkdir14 } 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 join33, dirname as dirname16 } from "path";
+import { join as join34, dirname as dirname17 } from "path";
 function catalogCachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join33(homedir18(), ".config");
-  return join33(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);
@@ -16566,7 +16442,7 @@ async function fetchOpenRouterCatalog(fetchImpl2 = fetch) {
 }
 async function readCache3() {
   try {
-    const raw = await readFile19(catalogCachePath(), "utf8");
+    const raw = await readFile20(catalogCachePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed.version === CACHE_VERSION ? parsed : null;
   } catch {
@@ -16576,9 +16452,9 @@ async function readCache3() {
 async function writeCache3(models) {
   const path = catalogCachePath();
   try {
-    await mkdir14(dirname16(path), { recursive: true });
+    await mkdir14(dirname17(path), { recursive: true });
     const cache = { version: CACHE_VERSION, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
-    await writeFile13(path, JSON.stringify(cache, null, 2), "utf8");
+    await writeFile12(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
   }
 }
@@ -16625,12 +16501,12 @@ __export(requesty_catalog_exports, {
   loadRequestyCatalog: () => loadRequestyCatalog,
   mapRequestyModel: () => mapRequestyModel
 });
-import { readFile as readFile20, writeFile as writeFile14, mkdir as mkdir15 } 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 join34, dirname as dirname17 } from "path";
+import { join as join35, dirname as dirname18 } from "path";
 function catalogCachePath2() {
-  const xdg = process.env.XDG_CONFIG_HOME || join34(homedir19(), ".config");
-  return join34(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);
@@ -16686,7 +16562,7 @@ async function fetchRequestyCatalog(fetchImpl2 = fetch) {
 }
 async function readCache4() {
   try {
-    const raw = await readFile20(catalogCachePath2(), "utf8");
+    const raw = await readFile21(catalogCachePath2(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION2) return null;
     return {
@@ -16701,9 +16577,9 @@ async function readCache4() {
 async function writeCache4(catalog) {
   const path = catalogCachePath2();
   try {
-    await mkdir15(dirname17(path), { recursive: true });
+    await mkdir15(dirname18(path), { recursive: true });
     const cache = { version: CACHE_VERSION2, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ...catalog };
-    await writeFile14(path, JSON.stringify(cache, null, 2), "utf8");
+    await writeFile13(path, JSON.stringify(cache, null, 2), "utf8");
   } catch {
   }
 }
@@ -16798,7 +16674,7 @@ __export(session_exports, {
 });
 import { resolve as resolve11 } from "path";
 import { homedir as homedir20 } from "os";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { existsSync as existsSync7 } from "fs";
 async function createAgentSession(opts2) {
   const config2 = await resolveSdkConfig(opts2);
@@ -16815,7 +16691,7 @@ async function createAgentSession(opts2) {
   let memoryManager = null;
   const memoryEnabled = opts2.memoryEnabled ?? config2.memoryEnabled ?? false;
   if (memoryEnabled) {
-    const dbPath = config2.memoryDbPath ?? join35(homedir20(), ".local", "share", "kimiflare", "memory.db");
+    const dbPath = config2.memoryDbPath ?? join36(homedir20(), ".local", "share", "kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       ...llmAuthFromConfig(config2),
@@ -16845,7 +16721,7 @@ async function createAgentSession(opts2) {
   }
   let sessionFile;
   if (opts2.sessionId) {
-    const filePath = join35(sessionsDir(), `${opts2.sessionId}.json`);
+    const filePath = join36(sessionsDir(), `${opts2.sessionId}.json`);
     try {
       sessionFile = await loadSession(filePath);
     } catch {
@@ -17044,8 +16920,8 @@ var init_session = __esm({
           const parts = [{ type: "text", text }];
           for (const img of options.images) {
             if ("path" in img) {
-              const { readFile: readFile37 } = await import("fs/promises");
-              const data = await readFile37(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 {
@@ -17368,14 +17244,14 @@ var init_session = __esm({
               this.lspManager?.notifyChange(path, content);
             } else {
               void import("fs/promises").then(
-                ({ readFile: readFile37 }) => readFile37(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(join35(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({
@@ -17400,8 +17276,8 @@ __export(run_exports, {
   summarizeTrace: () => summarizeTrace
 });
 import { spawn as spawn7 } from "child_process";
-import { appendFile as appendFile3, copyFile, mkdir as mkdir16, readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
-import { dirname as dirname18, join as join36, resolve as resolve12 } from "path";
+import { 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) => {
@@ -17434,8 +17310,8 @@ ${err.message}`, timedOut });
 }
 async function copyTaskFiles(task, worktree) {
   for (const [dest, src] of Object.entries(task.resolvedFiles)) {
-    const target = join36(worktree, dest);
-    await mkdir16(dirname18(target), { recursive: true });
+    const target = join37(worktree, dest);
+    await mkdir16(dirname19(target), { recursive: true });
     await copyFile(src, target);
   }
 }
@@ -17443,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 readFile21(traceFile, "utf8");
+    raw = await readFile22(traceFile, "utf8");
   } catch {
     return out;
   }
@@ -17475,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 = join36(ctx.tracesRoot, sessionId);
+  const traceDir = join37(ctx.tracesRoot, sessionId);
   const base = {
     task_id: task.id,
     sample,
@@ -17500,15 +17376,15 @@ async function runOne(task, sample, ctx) {
   });
   let worktree = null;
   try {
-    const sourceRepo = await prepareSourceRepo(task.repo, join36(ctx.out, "cache"));
-    worktree = await createWorktree(sourceRepo, task.base_commit, join36(ctx.out, "work", task.id, String(sample)));
+    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 writeFile15(join36(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)}` });
       }
     }
@@ -17543,7 +17419,7 @@ async function runOne(task, sample, ctx) {
     const testMs = Math.round(performance2.now() - testStartedAt);
     const passed = test.exitCode === 0 && !test.timedOut;
     await mkdir16(traceDir, { recursive: true }).catch(() => void 0);
-    await writeFile15(join36(traceDir, "test.log"), test.log, "utf8").catch(() => void 0);
+    await writeFile14(join37(traceDir, "test.log"), test.log, "utf8").catch(() => void 0);
     if (session.trace.enabled) {
       session.trace.emit(
         "outcome",
@@ -17561,7 +17437,7 @@ async function runOne(task, sample, ctx) {
     }
     session.dispose({ traceEndReason: "eval_done" });
     await session.trace.flush();
-    const stats = await summarizeTrace(join36(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,
@@ -17591,11 +17467,11 @@ async function runEval(opts2) {
   const concurrency = Math.max(1, Math.floor(opts2.concurrency ?? 1));
   const createSession = opts2.createSession ?? (await Promise.resolve().then(() => (init_session(), session_exports))).createAgentSession;
   await mkdir16(out, { recursive: true });
-  const tracesRoot = join36(out, "traces");
+  const tracesRoot = join37(out, "traces");
   const runName = evalConfig.name;
-  const resultsFile = join36(out, "results.jsonl");
-  await writeFile15(
-    join36(out, "config.json"),
+  const resultsFile = join37(out, "results.jsonl");
+  await writeFile14(
+    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"
   );
@@ -17639,9 +17515,9 @@ __export(compare_exports, {
   perTask: () => perTask,
   summarizeArm: () => summarizeArm
 });
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile23 } from "fs/promises";
 async function loadResults(file) {
-  const raw = await readFile22(file, "utf8");
+  const raw = await readFile23(file, "utf8");
   return raw.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function median(values) {
@@ -17774,16 +17650,16 @@ __export(cost_verify_exports, {
   verifySession: () => verifySession,
   verifyTurn: () => verifyTurn
 });
-import { readFile as readFile23 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 import { homedir as homedir21 } from "os";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 function usagePath2() {
-  const xdg = process.env.XDG_DATA_HOME || join37(homedir21(), ".local", "share");
-  return join37(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 readFile23(usagePath2(), "utf8")).sessions ?? [];
+    return JSON.parse(await readFile24(usagePath2(), "utf8")).sessions ?? [];
   } catch {
     return [];
   }
@@ -18102,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";
@@ -18118,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";
@@ -18127,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";
@@ -18314,12 +18190,12 @@ var init_heuristic = __esm({
 });
 
 // src/cost-attribution/classify-from-session.ts
-import { readFile as readFile24 } from "fs/promises";
-import { join as join38 } from "path";
+import { readFile as readFile25 } from "fs/promises";
+import { join as join39 } from "path";
 import { homedir as homedir22 } from "os";
 function sessionsDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join38(homedir22(), ".local", "share");
-  return join38(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) => {
@@ -18333,7 +18209,7 @@ function parseToolCalls(calls) {
 }
 async function classifyFromSessionFile(sessionId) {
   try {
-    const raw = await readFile24(join38(sessionsDir2(), `${sessionId}.json`), "utf8");
+    const raw = await readFile25(join39(sessionsDir2(), `${sessionId}.json`), "utf8");
     const session = JSON.parse(raw);
     const messages = session.messages ?? [];
     const turns = [];
@@ -18366,15 +18242,15 @@ var cli_exports = {};
 __export(cli_exports, {
   runCostCommand: () => runCostCommand
 });
-import { readFile as readFile25 } from "fs/promises";
-import { join as join39 } 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 || join39(homedir23(), ".local", "share");
-  return join39(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join40(homedir23(), ".local", "share");
+  return join40(xdg, "kimiflare");
 }
 function usagePath3() {
-  return join39(usageDir2(), "usage.json");
+  return join40(usageDir2(), "usage.json");
 }
 function today2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -18386,7 +18262,7 @@ function daysAgo(n) {
 }
 async function loadLog2() {
   try {
-    const raw = await readFile25(usagePath3(), "utf8");
+    const raw = await readFile26(usagePath3(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -18476,12 +18352,12 @@ __export(aster_workspaces_exports, {
   findAsterWorkspace: () => findAsterWorkspace,
   loadAsterServerConfig: () => loadAsterServerConfig
 });
-import { readFile as readFile26, realpath as realpath4, stat as stat10 } from "fs/promises";
+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 readFile26(configPath3, "utf8"));
+    raw = JSON.parse(await readFile27(configPath3, "utf8"));
   } catch {
     throw new AsterConfigError();
   }
@@ -18517,8 +18393,8 @@ async function loadAsterServerConfig(configPath3 = process.env.AUTOPILOT_ASTER_C
     if (typeof workspace.rootPath !== "string" || !isAbsolute5(workspace.rootPath)) throw new AsterConfigError();
     let rootPath;
     try {
-      rootPath = await realpath4(workspace.rootPath);
-      if (!(await stat10(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();
     }
@@ -18560,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 join40 } from "path";
+import { dirname as dirname20, join as join41 } from "path";
 function defaultAsterDbPath() {
-  const root = process.env.XDG_STATE_HOME || join40(homedir24(), ".local", "state");
-  return process.env.AUTOPILOT_ASTER_DB || join40(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");
@@ -18614,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);
@@ -19488,12 +19364,12 @@ var init_openapi = __esm({
 
 // src/runs/worktrees.ts
 import { execFile as execFile8 } from "child_process";
-import { access as access2, chmod as chmod3, mkdir as mkdir17, realpath as realpath5 } 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 isAbsolute6, join as join41, parse, relative as relative9, resolve as resolve13, sep as sep5 } 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 || join41(homedir25(), ".local", "share");
-  return join41(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(`..${sep5}`) || isAbsolute6(path);
@@ -19527,9 +19403,9 @@ 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 realpath5(sourceCwd);
+        const source = await realpath6(sourceCwd);
         const repositoryRoot = (await runGit(["rev-parse", "--show-toplevel"], source)).trim();
-        const repository = await realpath5(repositoryRoot);
+        const repository = await realpath6(repositoryRoot);
         const sourceRelativePath = relative9(repository, source);
         if (isOutside(sourceRelativePath)) {
           throw new Error("sourceCwd must be inside the Git repository");
@@ -19539,12 +19415,12 @@ var init_worktrees = __esm({
           throw new Error("worktree root must be outside the source repository and not the filesystem root");
         }
         await mkdir17(configuredRoot, { recursive: true, mode: 448 });
-        const worktreesRoot = await realpath5(configuredRoot);
+        const worktreesRoot = await realpath6(configuredRoot);
         if (isWithin3(repository, worktreesRoot)) {
           throw new Error("worktree root must be outside the source repository");
         }
-        await chmod3(worktreesRoot, 448);
-        const worktreePath = join41(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}`);
@@ -19564,9 +19440,9 @@ var init_worktrees = __esm({
       }
       /** Remove a newly-created, still-clean worktree when run initialization fails. */
       async discard(worktree) {
-        const root = await realpath5(this.rootDir);
-        const target = await realpath5(worktree.worktreePath);
-        const repository = await realpath5(worktree.repositoryRoot);
+        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");
         }
@@ -19712,7 +19588,7 @@ var init_wake_scheduler = __esm({
 });
 
 // src/server/aster-tools.ts
-import { realpath as realpath6 } from "fs/promises";
+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) => ({
@@ -19725,19 +19601,19 @@ 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 realpath6(workspaceRoot);
+  const root = await realpath7(workspaceRoot);
   const candidate = resolvePath(root, value);
   assertInside(root, candidate);
   assertNotSensitive(root, candidate);
   let actual;
   try {
-    actual = await realpath6(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 realpath6(ancestor);
+        actual = await realpath7(ancestor);
         break;
       } catch (ancestorError) {
         if (ancestorError.code !== "ENOENT") throw new Error("workspace_path_unavailable");
@@ -19803,7 +19679,7 @@ var init_aster_tools = __esm({
 
 // src/server/aster-api.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { unlink as unlink2 } from "fs/promises";
+import { 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";
@@ -20117,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(resolve14(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          await unlink3(resolve14(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           await worktreeManager.discard(worktree).catch(() => {
           });
@@ -20460,7 +20336,7 @@ data: ${JSON.stringify(event.data)}
 
 // src/server/aster-cell-runtime.ts
 import { execFile as execFile9 } from "child_process";
-import { readFile as readFile27 } 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) {
@@ -20490,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 readFile27(url, "utf8");
+      return await readFile28(url, "utf8");
     } catch {
     }
   }
@@ -20986,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 stat14 = await cell.exec(`[ -f ${file} ] && [ ! -L ${file} ] && stat -c %s -- ${file}`);
-        if (stat14.exitCode !== 0) throw new Error("artifact_not_found");
-        if (Number(stat14.stdout.trim()) > MAX_ARTIFACT_BYTES) throw new Error("artifact_too_large");
+        const 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 };
@@ -21285,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 readFile28, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve15, 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);
@@ -21369,8 +21245,8 @@ async function resolveFiles2(filePatterns, cwd) {
   const resolved = /* @__PURE__ */ new Set();
   for (const pattern of filePatterns) {
     try {
-      const stat14 = await import("fs/promises").then((m) => m.stat(resolve15(cwd, pattern)));
-      if (stat14.isFile()) {
+      const stat15 = await import("fs/promises").then((m) => m.stat(resolve15(cwd, pattern)));
+      if (stat15.isFile()) {
         resolved.add(resolve15(cwd, pattern));
         continue;
       }
@@ -21394,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 readFile28(filePath, "utf8");
+        const content = await readFile29(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -21408,7 +21284,7 @@ ${content}
 `);
       } catch (e) {
         fileContents.push(`
-<!-- failed to read ${basename7(filePath)}: ${e.message} -->
+<!-- failed to read ${basename8(filePath)}: ${e.message} -->
 `);
       }
     }
@@ -21676,7 +21552,7 @@ function setupRoutes(config2, options = {}) {
             store.close();
           }
         } catch (error) {
-          await unlink3(resolve15(sessionsDir(), `${sessionId}.json`)).catch(() => {
+          await unlink4(resolve15(sessionsDir(), `${sessionId}.json`)).catch(() => {
           });
           if (worktree) {
             await worktreeManager.discard(worktree).catch((cleanupError) => {
@@ -21830,8 +21706,8 @@ function setupRoutes(config2, options = {}) {
         const sessionId = sessionMatch[1];
         activeSessions.delete(sessionId);
         try {
-          const { unlink: unlink6 } = await import("fs/promises");
-          await unlink6(resolve15(sessionsDir(), `${sessionId}.json`));
+          const { unlink: unlink7 } = await import("fs/promises");
+          await unlink7(resolve15(sessionsDir(), `${sessionId}.json`));
         } catch {
         }
         json2(res, 200, { deleted: sessionId });
@@ -23729,7 +23605,7 @@ __export(app_helpers_exports, {
 });
 import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 function replaceQueuedPrompt(queue2, key, full, display) {
   const index = queue2.findIndex((item) => item.key === key);
   if (index >= 0) {
@@ -23836,7 +23712,7 @@ function buildFilePickerIgnoreList(cwd) {
   ];
   const gitignorePatterns = [];
   try {
-    const gitignorePath = join42(cwd, ".gitignore");
+    const gitignorePath = join43(cwd, ".gitignore");
     const stats = statSync5(gitignorePath);
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
@@ -24002,9 +23878,9 @@ var init_app_helpers = __esm({
 
 // src/ui/bang-command.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile29, rm as rm6 } from "fs/promises";
+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 join43 } from "path";
+import { join as join44 } from "path";
 function registerInkInstance(instance) {
   inkInstance = instance;
 }
@@ -24107,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 mkdtemp3(join43(tmpdir5(), "autopilot-bang-"));
-  const logPath = logDir2 ? join43(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, `
@@ -24150,7 +24026,7 @@ $ ${command}
   }
   let output = spawnError ? `failed to start: ${spawnError}` : null;
   if (captured && logPath) {
-    output = cleanTerminalOutput(await readFile29(logPath, "utf8").catch(() => ""));
+    output = cleanTerminalOutput(await readFile30(logPath, "utf8").catch(() => ""));
   }
   if (logDir2) await rm6(logDir2, { recursive: true, force: true }).catch(() => {
   });
@@ -26331,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,
@@ -26345,7 +26222,7 @@ __export(camouflage_view_exports, {
 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 join44, resolve as resolve16 } 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})`);
@@ -26524,7 +26401,7 @@ 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("~") ? join44(homedir26(), dir.slice(1)) : dir;
+  const expanded = dir.startsWith("~") ? join45(homedir26(), dir.slice(1)) : dir;
   const target = resolve16(cwd, expanded || ".");
   try {
     const items = await readdir8(target, { withFileTypes: true });
@@ -26562,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";
@@ -29874,8 +29769,8 @@ var init_queue_plan_picker = __esm({
 
 // src/agent/jev-context.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { readFile as readFile30 } from "fs/promises";
-import { basename as basename8, join as join45, resolve as resolve17 } from "path";
+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 "";
@@ -29897,7 +29792,7 @@ function projectRoot(cwd) {
 }
 async function readPackageMetadata(root) {
   try {
-    const parsed = JSON.parse(await readFile30(join45(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 = {};
@@ -29914,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 readFile30(join45(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 {
     }
@@ -29947,13 +29842,13 @@ async function buildJevContext(question, messages, cwd = process.cwd()) {
       conversationRemaining -= source.length + content.length + 2;
     }
   }
-  const currentDirectory = basename8(resolve17(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);
@@ -30996,8 +30891,8 @@ var init_frontmatter = __esm({
 });
 
 // src/skills/loader.ts
-import { readFile as readFile31, readdir as readdir9, stat as stat11 } from "fs/promises";
-import { join as join46, 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 : "";
@@ -31011,7 +30906,7 @@ function normalizeManifest(raw, filePath) {
   return { name, description, match, scope, priority, enabled: enabled2 };
 }
 async function loadSkillFile(filePath) {
-  const raw = await readFile31(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();
@@ -31033,8 +30928,8 @@ async function loadSkillsFromDir(dirPath) {
     const entries = await readdir9(dirPath);
     const files = [];
     for (const entry of entries) {
-      const full = join46(dirPath, entry);
-      const s = await stat11(full);
+      const full = join47(dirPath, entry);
+      const s = await stat12(full);
       if (s.isFile() && extname(entry) === ".md") {
         files.push(full);
       }
@@ -31061,12 +30956,12 @@ var init_loader = __esm({
 });
 
 // src/skills/manager.ts
-import { mkdir as mkdir18, writeFile as writeFile16, unlink as unlink4, readFile as readFile32 } from "fs/promises";
-import { join as join47 } 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: join47(cwd, ".kimiflare", "skills"),
-    globalDir: join47(process.env.HOME ?? "", ".config", "kimiflare", "skills")
+    projectDir: join48(cwd, ".kimiflare", "skills"),
+    globalDir: join48(process.env.HOME ?? "", ".config", "kimiflare", "skills")
   };
 }
 async function listAllSkills(cwd) {
@@ -31080,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 = join47(dir, `${opts2.name}.md`);
+  const filepath = join48(dir, `${opts2.name}.md`);
   const frontmatter = {
     name: opts2.name,
     enabled: true,
@@ -31102,21 +30997,21 @@ ${yaml}
 Add your instructions here.
 `;
   await mkdir18(dir, { recursive: true });
-  await writeFile16(filepath, content, "utf8");
+  await writeFile15(filepath, content, "utf8");
   return { filepath };
 }
 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 readFile32(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]) => {
@@ -31128,7 +31023,7 @@ ${v.map((item) => `  - ${item}`).join("\n")}`;
 ${yaml}
 ---
 ${parsed.content}`;
-  await writeFile16(skill.filePath, content, "utf8");
+  await writeFile15(skill.filePath, content, "utf8");
   return { filepath: skill.filePath };
 }
 async function findSkillFile(name, cwd) {
@@ -31388,15 +31283,15 @@ var tui_report_exports = {};
 __export(tui_report_exports, {
   getCategoryReportText: () => getCategoryReportText
 });
-import { readFile as readFile33 } from "fs/promises";
-import { join as join48 } 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 || join48(homedir27(), ".local", "share");
-  return join48(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join49(homedir27(), ".local", "share");
+  return join49(xdg, "kimiflare");
 }
 function usagePath4() {
-  return join48(usageDir3(), "usage.json");
+  return join49(usageDir3(), "usage.json");
 }
 function today3() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -31408,7 +31303,7 @@ function daysAgo2(n) {
 }
 async function loadLog3() {
   try {
-    const raw = await readFile33(usagePath4(), "utf8");
+    const raw = await readFile34(usagePath4(), "utf8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, days: [], sessions: [] };
@@ -31465,7 +31360,7 @@ var init_tui_report = __esm({
 });
 
 // src/ui/slash-commands.ts
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 import QRCode from "qrcode";
 function executeFreshStart(ctx, planText, overrideMode, opts2 = {}) {
   const oldSessionId = ctx.sessionIdRef.current;
@@ -32397,7 +32292,7 @@ ${lines.join("\n")}` }]);
         void (async () => {
           try {
             const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-            const file = await loadSession(join49(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" }]);
@@ -32442,7 +32337,7 @@ ${lines.join("\n")}` }]);
         try {
           ctx.ensureSessionId();
           const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-          const filePath = join49(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) {
@@ -33167,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]
   };
@@ -33197,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;
 }
@@ -33244,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",
@@ -33253,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")
     }
   ];
@@ -33926,15 +33821,15 @@ var init_frontmatter2 = __esm({
 });
 
 // src/commands/loader.ts
-import { open, realpath as realpath7 } from "fs/promises";
+import { open, realpath as realpath8 } from "fs/promises";
 import { homedir as homedir28 } from "os";
-import { join as join50, relative as relative11, sep as sep7 } from "path";
+import { join as join51, relative as relative11, sep as sep7 } from "path";
 function projectCommandsDir(cwd = process.cwd()) {
-  return join50(cwd, ".kimiflare", "commands");
+  return join51(cwd, ".kimiflare", "commands");
 }
 function globalCommandsDir() {
-  const xdg = process.env.XDG_CONFIG_HOME || join50(homedir28(), ".config");
-  return join50(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 = [];
@@ -33973,7 +33868,7 @@ async function loadCustomCommands(cwd = process.cwd()) {
 async function resolveSafeDir(dir, source, cwd, warnings) {
   let realDir;
   try {
-    realDir = await realpath7(dir);
+    realDir = await realpath8(dir);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -33984,7 +33879,7 @@ async function resolveSafeDir(dir, source, cwd, warnings) {
   if (source === "project") {
     let realCwd;
     try {
-      realCwd = await realpath7(cwd);
+      realCwd = await realpath8(cwd);
     } catch {
       return null;
     }
@@ -34086,7 +33981,7 @@ var init_loader2 = __esm({
 
 // src/commands/renderer.ts
 import { exec } from "child_process";
-import { open as open2, realpath as realpath8 } from "fs/promises";
+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) {
@@ -34178,7 +34073,7 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
       return "" + trailing;
     });
   }
-  const realCwd = await realpath8(cwd).catch(() => cwd);
+  const realCwd = await realpath9(cwd).catch(() => cwd);
   const replacements = await Promise.all(
     matches.map(async (match) => {
       const rawPath = match[1] ?? "";
@@ -34198,7 +34093,7 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
       }
       let real;
       try {
-        real = await realpath8(resolved);
+        real = await realpath9(resolved);
       } catch (error) {
         warnings.push(`file inclusion failed: @${rawPath} \u2014 ${message(error)}`);
         return "";
@@ -34316,11 +34211,11 @@ var init_wcag = __esm({
 });
 
 // src/ui/theme-loader.ts
-import { readFile as readFile34, readdir as readdir10 } from "fs/promises";
-import { join as join51 } 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 join51(cwd, ".kimiflare", "themes");
+  return join52(cwd, ".kimiflare", "themes");
 }
 function isHexColor(c) {
   return /^#[0-9a-fA-F]{6}$/.test(c);
@@ -34409,10 +34304,10 @@ async function loadThemesFromDir(dir, source) {
     return { themes, errors };
   }
   for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const path = join51(dir, file);
+    const path = join52(dir, file);
     let raw;
     try {
-      raw = await readFile34(path, "utf-8");
+      raw = await readFile35(path, "utf-8");
     } catch (e) {
       errors.push(`${path}: ${e instanceof Error ? e.message : String(e)}`);
       continue;
@@ -34558,8 +34453,8 @@ var init_theme_loader = __esm({
     "use strict";
     init_wcag();
     init_theme();
-    USER_THEMES_DIR = join51(
-      process.env.XDG_CONFIG_HOME || join51(homedir29(), ".config"),
+    USER_THEMES_DIR = join52(
+      process.env.XDG_CONFIG_HOME || join52(homedir29(), ".config"),
       "kimiflare",
       "themes"
     );
@@ -37090,9 +36985,9 @@ var init_resume_progress = __esm({
 });
 
 // src/agent/supervisor.ts
-import { readdir as readdir11, readFile as readFile35, stat as stat12 } 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 resolve18, join as join52 } from "path";
+import { resolve as resolve18, join as join53 } from "path";
 var TurnSupervisor;
 var init_supervisor = __esm({
   "src/agent/supervisor.ts"() {
@@ -37482,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 join53 } 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 = join53(cwd, sig);
+      const path = join54(cwd, sig);
       if (sig.includes("*")) {
         try {
           const parts = sig.split("*");
@@ -37508,14 +37403,14 @@ function detectFlavor(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (existsSync9(join53(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 = join53(cwd, r);
+    const p = join54(cwd, r);
     try {
       const s = statSync6(p);
       if (s.isDirectory()) roots.push(r);
@@ -37526,9 +37421,9 @@ function findSourceRoots(cwd) {
 }
 function findCiConfig(cwd) {
   for (const c of CI_PATHS) {
-    if (existsSync9(join53(cwd, c))) {
+    if (existsSync9(join54(cwd, c))) {
       try {
-        const s = statSync6(join53(cwd, c));
+        const s = statSync6(join54(cwd, c));
         return s.isDirectory() ? c : c;
       } catch {
       }
@@ -37665,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(join53(cwd, ".git"))
+    hasGit: existsSync9(join54(cwd, ".git"))
   };
 }
 function bashDiscoveryCommands(profile) {
@@ -37828,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(join53(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,
@@ -37862,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({
@@ -37914,7 +37823,7 @@ var init_context_generator = __esm({
 
 // src/init/run-init.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 async function runInit(deps) {
   const {
     cfg,
@@ -37928,6 +37837,7 @@ async function runInit(deps) {
     setUsage,
     setSessionUsage,
     setKimiMdStale,
+    onTasks,
     beginTurn,
     endTurn,
     ensureSessionId,
@@ -37962,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" }
@@ -38007,7 +37918,7 @@ async function runInit(deps) {
           lspManagerRef.current.notifyChange(path, content);
         } else {
           void import("fs/promises").then(
-            ({ readFile: readFile37 }) => readFile37(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
+            ({ readFile: readFile38 }) => readFile38(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
             })
           );
         }
@@ -38092,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 }]);
@@ -38112,7 +38024,7 @@ async function runInit(deps) {
         }
       }
     });
-    if (existsSync10(join54(cwd, targetFilename))) {
+    if (existsSync10(join55(cwd, targetFilename))) {
       if (cacheStableRef.current) {
         messagesRef.current[1] = {
           role: "system",
@@ -38177,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();
@@ -38204,11 +38117,11 @@ var init_run_init = __esm({
 });
 
 // src/skills/discovery.ts
-import { readdir as readdir12, stat as stat13, readFile as readFile36 } from "fs/promises";
-import { join as join55, 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 stat13(path);
+    const s = await stat14(path);
     return s.isDirectory();
   } catch {
     return false;
@@ -38216,7 +38129,7 @@ async function dirExists(path) {
 }
 async function fileExists(path) {
   try {
-    const s = await stat13(path);
+    const s = await stat14(path);
     return s.isFile();
   } catch {
     return false;
@@ -38229,20 +38142,20 @@ async function scanSkillDir(dirPath, source) {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!SKILL_EXTENSIONS.has(extname2(entry.name))) continue;
-    files.push({ filePath: join55(dirPath, entry.name), source });
+    files.push({ filePath: join56(dirPath, entry.name), source });
   }
   return files;
 }
 async function discoverSkills(cwd) {
-  const agentsSkills = await scanSkillDir(join55(cwd, ".agents", "skills"), "agents");
-  const agentsMd = await fileExists(join55(cwd, "AGENTS.md")) ? [{ filePath: join55(cwd, "AGENTS.md"), source: "agents-md" }] : [];
-  const githubSkills = await scanSkillDir(join55(cwd, ".github", "skills"), "github");
-  const kimiflareSkills = await scanSkillDir(join55(cwd, ".kimiflare", "skills"), "kimiflare");
+  const 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 readFile36(filePath);
+  const bytes = await readFile37(filePath);
   return { bytes, text: bytes.toString("utf-8") };
 }
 var SKILL_EXTENSIONS;
@@ -38448,7 +38361,7 @@ var init_skills = __esm({
 
 // src/ui/run-startup-tasks.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 function runStartupTasks(deps) {
   const {
     cfg,
@@ -38471,7 +38384,7 @@ function runStartupTasks(deps) {
     }
   });
   if (cfg.memoryEnabled) {
-    const dbPath = cfg.memoryDbPath ?? join56(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = cfg.memoryDbPath ?? join57(process.cwd(), ".kimiflare", "memory.db");
     const manager = new MemoryManager({
       dbPath,
       ...auth,
@@ -38503,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(join56(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) {
@@ -38514,7 +38427,7 @@ function runStartupTasks(deps) {
     memoryManagerRef.current?.close();
     memoryManagerRef.current = null;
   }
-  const skillDbPath = cfg.memoryDbPath ?? join56(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = cfg.memoryDbPath ?? join57(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -38871,8 +38784,8 @@ var init_run_compact = __esm({
 });
 
 // src/commands/save.ts
-import { mkdir as mkdir19, writeFile as writeFile17, 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`;
@@ -38883,12 +38796,12 @@ async function saveCustomCommand(opts2) {
   if (opts2.effort) data.effort = opts2.effort;
   const frontmatter = serializeFrontmatter(data);
   const content = frontmatter + opts2.template;
-  await mkdir19(dirname21(filepath), { recursive: true });
-  await writeFile17(filepath, content, "utf8");
+  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"() {
@@ -39007,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 join57, resolve as resolve19 } 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({
@@ -39242,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());
@@ -39335,7 +39263,7 @@ ${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("~") ? join57(homedir30(), directory.slice(1)) : directory;
+      const expanded = directory.startsWith("~") ? join58(homedir30(), directory.slice(1)) : directory;
       const target = resolve19(cwd, expanded || ".");
       const entries2 = await glob("*", {
         cwd: target,
@@ -39835,6 +39763,7 @@ ${wcagWarnings.join("\n")}` }
       setUsage,
       setSessionUsage,
       setKimiMdStale,
+      onTasks: updateTaskTracking,
       beginTurn,
       endTurn,
       ensureSessionId,
@@ -39864,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);
@@ -40318,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(join57(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." }
@@ -40342,7 +40271,7 @@ ${result2.output ?? "(output not captured)"}`,
                 };
                 ensureSessionId();
                 const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                const filePath = join57(sessionsDir3(), `${sessionIdRef.current}.json`);
+                const filePath = join58(sessionsDir3(), `${sessionIdRef.current}.json`);
                 await addCheckpoint(filePath, cp);
               }
               const summary = await generateContinuationSummary({
@@ -40493,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 }]);
@@ -40673,7 +40594,7 @@ ${result2.output ?? "(output not captured)"}`,
               lspManagerRef.current.notifyChange(path, content2);
             } else {
               void import("fs/promises").then(
-                ({ readFile: readFile37 }) => readFile37(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
+                ({ readFile: readFile38 }) => readFile38(path, "utf8").then((c) => lspManagerRef.current.notifyChange(path, c)).catch(() => {
                 })
               );
             }
@@ -40866,7 +40787,7 @@ ${result2.output ?? "(output not captured)"}`,
                       };
                       ensureSessionId();
                       const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-                      const filePath = join57(sessionsDir3(), `${sessionIdRef.current}.json`);
+                      const filePath = join58(sessionsDir3(), `${sessionIdRef.current}.json`);
                       await addCheckpoint(filePath, cp);
                     }
                     const summary = await generateContinuationSummary({
@@ -40942,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({
@@ -41433,7 +41354,7 @@ ${result2.output ?? "(output not captured)"}`,
       lsp: {
         servers: cfg?.lspServers ?? {},
         scope: lspScope,
-        hasProjectDir: existsSync12(join57(process.cwd(), ".kimiflare"))
+        hasProjectDir: existsSync12(join58(process.cwd(), ".kimiflare"))
       }
     });
   });
@@ -41490,7 +41411,7 @@ ${result2.output ?? "(output not captured)"}`,
         onCommandDelete: handleCommandDelete2,
         lspServers: cfg?.lspServers ?? {},
         lspScope,
-        hasProjectDir: existsSync12(join57(process.cwd(), ".kimiflare")),
+        hasProjectDir: existsSync12(join58(process.cwd(), ".kimiflare")),
         onLspSave: handleLspSave2,
         themes: themeList(),
         onPickTheme: handleThemePick,
@@ -41977,8 +41898,8 @@ init_classify();
 init_subagent_policy();
 init_trace();
 init_registry2();
-import { readFile as readFile16 } from "fs/promises";
-import { resolve as resolve7, 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 = resolve7(sessionsDir(), `${opts2.sessionId}.json`);
@@ -42016,8 +41937,8 @@ async function resolveFiles(filePatterns, cwd) {
   const resolved = /* @__PURE__ */ new Set();
   for (const pattern of filePatterns) {
     try {
-      const stat14 = await import("fs/promises").then((m) => m.stat(resolve7(cwd, pattern)));
-      if (stat14.isFile()) {
+      const stat15 = await import("fs/promises").then((m) => m.stat(resolve7(cwd, pattern)));
+      if (stat15.isFile()) {
         resolved.add(resolve7(cwd, pattern));
         continue;
       }
@@ -42041,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 readFile16(filePath, "utf8");
+        const content = await readFile17(filePath, "utf8");
         const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
         fileContents.push(`
 --- ${relPath} ---
@@ -42055,7 +41976,7 @@ ${content}
 `);
       } catch (e) {
         fileContents.push(`
-<!-- failed to read ${basename3(filePath)}: ${e.message} -->
+<!-- failed to read ${basename4(filePath)}: ${e.message} -->
 `);
       }
     }