kimiflare 0.71.0 → 0.72.0

package/dist/index.js

@@ -417,8 +417,8 @@ async function flushAndCloseForTesting() {
   const s = currentStream;
   currentStream = null;
   currentDate = null;
-  await new Promise((resolve3) => {
-    s.end(() => resolve3());
+  await new Promise((resolve4) => {
+    s.end(() => resolve4());
   });
 }
 function isLogSinkEnabled() {
@@ -1297,11 +1297,11 @@ function extractCloudflareError(parsed, rawText) {
   return null;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     if (signal?.aborted) return reject(new DOMException("aborted", "AbortError"));
     const t = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve3();
+      resolve4();
     }, ms);
     const onAbort = () => {
       clearTimeout(t);
@@ -2017,9 +2017,9 @@ var require_node_gyp_build = __commonJS({
         var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
-      var prebuild = resolve3(dir);
+      var prebuild = resolve4(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve3(path.dirname(process.execPath));
+      var nearby = resolve4(path.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform6,
@@ -2035,7 +2035,7 @@ var require_node_gyp_build = __commonJS({
         // eslint-disable-line
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
-      function resolve3(dir2) {
+      function resolve4(dir2) {
         var tuples = readdirSync2(path.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform6, arch)).sort(compareTuples)[0];
         if (!tuple) return;
@@ -2883,7 +2883,7 @@ function truncateForEmbedding(text) {
   return text.slice(0, MAX_EMBED_CHARS);
 }
 async function sleep2(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function fetchWithRetry(url, init, retries = 3) {
   let lastError;
@@ -4693,7 +4693,7 @@ function runBash(args, ctx) {
   const timeout = Math.min(Math.max(1e3, args.timeout_ms ?? DEFAULT_TIMEOUT), MAX_TIMEOUT);
   const { shell, args: shellArgs, isPosix } = getShellCommand(ctx.shell);
   const command = isPosix ? injectCoauthor(args.command, ctx.coauthor) : args.command;
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     logger.debug("bash:spawn", { command: args.command.slice(0, 200), cwd: ctx.cwd, shell });
     const child = spawn(shell, [...shellArgs, command], {
       cwd: ctx.cwd,
@@ -4746,7 +4746,7 @@ ${stdout.trimEnd()}`);
 ${stderr.trimEnd()}`);
       if (!stdout && !stderr) parts.push("(no output)");
       const raw = parts.join("\n");
-      resolve3({
+      resolve4({
         content: raw,
         rawBytes: Buffer.byteLength(raw, "utf8"),
         reducedBytes: Buffer.byteLength(raw, "utf8")
@@ -4785,13 +4785,280 @@ var init_bash = __esm({
   }
 });
 
+// src/util/glob.ts
+import { readdir as readdir2, lstat, realpath } from "fs/promises";
+import { join as join10, relative as relative2, resolve as resolve2 } from "path";
+function parsePattern(pattern) {
+  const parts = pattern.split(/\//g);
+  return parts.map((p) => {
+    if (p === "**") return { type: "doublestar", value: p };
+    if (p.includes("*") || p.includes("?") || p.includes("[")) {
+      return { type: "glob", value: p };
+    }
+    return { type: "literal", value: p };
+  });
+}
+function globToRegex(glob2) {
+  let re = "^";
+  for (let i = 0; i < glob2.length; i++) {
+    const c = glob2[i];
+    if (c === "*") {
+      if (glob2[i + 1] === "*") {
+        re += ".*";
+        i++;
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (c === "[") {
+      const close = glob2.indexOf("]", i + 1);
+      if (close === -1) {
+        re += "\\[";
+      } else {
+        re += glob2.slice(i, close + 1);
+        i = close;
+      }
+    } else if ("\\^$.|+(){}".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function matchSegment(segment, pattern) {
+  return globToRegex(pattern).test(segment);
+}
+function shouldIgnore(relativePath, ignorePatterns) {
+  for (const pat of ignorePatterns) {
+    const segs = parsePattern(pat);
+    const parts = relativePath.split(/\//g);
+    if (matchIgnoreParts(parts, segs, 0, 0)) return true;
+  }
+  return false;
+}
+function matchIgnoreParts(parts, segs, pi, si) {
+  if (si >= segs.length) return pi >= parts.length;
+  const seg = segs[si];
+  if (seg.type === "doublestar") {
+    if (si === segs.length - 1) return true;
+    for (let i = pi; i <= parts.length; i++) {
+      if (matchIgnoreParts(parts, segs, i, si + 1)) return true;
+    }
+    return false;
+  }
+  if (pi >= parts.length) return false;
+  const part = parts[pi];
+  const ok = seg.type === "literal" ? seg.value === part : matchSegment(part, seg.value);
+  return ok && matchIgnoreParts(parts, segs, pi + 1, si + 1);
+}
+async function* walk(root, pattern, options) {
+  const dot = options.dot ?? false;
+  const followSymbolicLinks = options.followSymbolicLinks ?? false;
+  const suppressErrors = options.suppressErrors ?? false;
+  const stats = options.stats ?? false;
+  const onlyFiles = options.onlyFiles ?? false;
+  const onlyDirectories = options.onlyDirectories ?? false;
+  const markDirectories = options.markDirectories ?? false;
+  const ignorePatterns = options.ignore ? Array.isArray(options.ignore) ? options.ignore : [options.ignore] : [];
+  const segs = parsePattern(pattern);
+  async function* yieldEntry(fullPath, relPath, isDir) {
+    if (onlyFiles && isDir) return;
+    if (onlyDirectories && !isDir) return;
+    let path = fullPath;
+    if (markDirectories && isDir) path += "/";
+    const entry = { path };
+    if (stats) {
+      try {
+        const s = await lstat(fullPath);
+        entry.stats = { mtimeMs: s.mtimeMs };
+      } catch {
+      }
+    }
+    yield entry;
+  }
+  async function* processEntries(dirPath, segIdx, relativeParts) {
+    if (segIdx >= segs.length) return;
+    const seg = segs[segIdx];
+    if (segIdx + 1 >= segs.length) {
+      let entries2;
+      try {
+        entries2 = await readdir2(dirPath, { withFileTypes: true, encoding: "utf8" });
+      } catch (err) {
+        if (!suppressErrors) throw err;
+        return;
+      }
+      for (const ent of entries2) {
+        const name = String(ent.name);
+        if (name === "." || name === "..") continue;
+        if (!dot && name.startsWith(".")) continue;
+        const matched = seg.type === "literal" ? seg.value === name : matchSegment(name, seg.value);
+        if (!matched) continue;
+        const childPath = join10(dirPath, name);
+        const childRel = [...relativeParts, name];
+        const childRelStr = childRel.join("/");
+        if (shouldIgnore(childRelStr, ignorePatterns)) continue;
+        const isDir = ent.isDirectory();
+        const isFile = ent.isFile() || ent.isSymbolicLink();
+        if (isDir || isFile) {
+          yield* yieldEntry(childPath, childRelStr, isDir);
+        }
+      }
+      return;
+    }
+    let entries;
+    try {
+      entries = await readdir2(dirPath, { withFileTypes: true, encoding: "utf8" });
+    } catch (err) {
+      if (!suppressErrors) throw err;
+      return;
+    }
+    for (const ent of entries) {
+      const name = String(ent.name);
+      if (name === "." || name === "..") continue;
+      if (!dot && name.startsWith(".")) continue;
+      const matched = seg.type === "literal" ? seg.value === name : matchSegment(name, seg.value);
+      if (!matched) continue;
+      const childPath = join10(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 s = await lstat(rp);
+          isDir = s.isDirectory();
+        } catch {
+          continue;
+        }
+      }
+      if (isDir) {
+        yield* recurse(childPath, segIdx + 1, childRel);
+      }
+    }
+  }
+  async function* recurse(dirPath, segIdx, relativeParts) {
+    if (segIdx >= segs.length) return;
+    const seg = segs[segIdx];
+    if (seg.type === "doublestar") {
+      if (segIdx + 1 >= segs.length) {
+        const rel = relativeParts.join("/");
+        if (!shouldIgnore(rel, ignorePatterns)) {
+          yield* yieldEntry(dirPath, rel, true);
+        }
+        return;
+      }
+      yield* processEntries(dirPath, segIdx + 1, relativeParts);
+      let entries;
+      try {
+        entries = await readdir2(dirPath, { withFileTypes: true, encoding: "utf8" });
+      } catch (err) {
+        if (!suppressErrors) throw err;
+        return;
+      }
+      for (const ent of entries) {
+        const name = String(ent.name);
+        if (name === "." || name === "..") continue;
+        if (!dot && name.startsWith(".")) continue;
+        const childPath = join10(dirPath, name);
+        const childRel = [...relativeParts, name];
+        const childRelStr = childRel.join("/");
+        if (shouldIgnore(childRelStr, ignorePatterns)) continue;
+        if (ent.isDirectory() || followSymbolicLinks && ent.isSymbolicLink()) {
+          let isDir = ent.isDirectory();
+          if (!isDir && followSymbolicLinks && ent.isSymbolicLink()) {
+            try {
+              const rp = await realpath(childPath);
+              const s = await lstat(rp);
+              isDir = s.isDirectory();
+            } catch {
+              continue;
+            }
+          }
+          if (isDir) {
+            if (segIdx + 1 >= segs.length) {
+              yield* yieldEntry(childPath, childRelStr, true);
+            }
+            yield* recurse(childPath, segIdx, childRel);
+          }
+        }
+      }
+      return;
+    }
+    yield* processEntries(dirPath, segIdx, relativeParts);
+  }
+  yield* recurse(root, 0, []);
+}
+async function glob(pattern, options = {}) {
+  const cwd = options.cwd ? resolve2(options.cwd) : process.cwd();
+  const results = [];
+  for await (const entry of walk(cwd, pattern, options)) {
+    let path = entry.path;
+    const isDir = path.endsWith("/");
+    if (!options.absolute) {
+      path = relative2(cwd, path);
+    }
+    if (isDir && !path.endsWith("/")) path += "/";
+    results.push(path);
+  }
+  return results;
+}
+function globStream(pattern, options = {}) {
+  const cwd = options.cwd ? resolve2(options.cwd) : process.cwd();
+  const absolute = options.absolute ?? false;
+  let destroyed = false;
+  let destroyErr;
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      const generator = walk(cwd, pattern, options);
+      return {
+        async next() {
+          if (destroyed) {
+            return { done: true, value: void 0 };
+          }
+          const result = await generator.next();
+          if (destroyed) {
+            return { done: true, value: void 0 };
+          }
+          if (!absolute && result.value) {
+            const isDir = result.value.path.endsWith("/");
+            result.value.path = relative2(cwd, result.value.path);
+            if (isDir && !result.value.path.endsWith("/")) {
+              result.value.path += "/";
+            }
+          }
+          return result;
+        },
+        async return() {
+          await generator.return?.(void 0);
+          return { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+  return Object.assign(iterable, {
+    destroy(err) {
+      destroyed = true;
+      destroyErr = err;
+    }
+  });
+}
+var init_glob = __esm({
+  "src/util/glob.ts"() {
+    "use strict";
+  }
+});
+
 // src/tools/glob.ts
-import fg from "fast-glob";
 var globTool;
-var init_glob = __esm({
+var init_glob2 = __esm({
   "src/tools/glob.ts"() {
     "use strict";
     init_paths();
+    init_glob();
     globTool = {
       name: "glob",
       description: "Find files matching a glob pattern (e.g. `**/*.ts`). Returns up to 200 absolute paths, sorted by mtime descending.",
@@ -4809,7 +5076,7 @@ var init_glob = __esm({
       async run(args, ctx) {
         if (ctx.signal?.aborted) throw new DOMException("aborted", "AbortError");
         const root = args.path ? resolvePath(ctx.cwd, args.path) : ctx.cwd;
-        const stream = fg.stream(args.pattern, {
+        const stream = globStream(args.pattern, {
           cwd: root,
           absolute: true,
           dot: false,
@@ -4844,7 +5111,6 @@ var init_glob = __esm({
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { readFile as readFile6 } from "fs/promises";
-import fg2 from "fast-glob";
 async function hasRipgrep() {
   if (cachedHasRg !== null) return cachedHasRg;
   try {
@@ -4879,7 +5145,7 @@ async function runRipgrep(args, root, mode, signal) {
 async function runJsFallback(args, root, mode, signal) {
   const re = new RegExp(args.pattern, args.case_insensitive ? "i" : "");
   const globPattern = args.glob ? `**/${args.glob}` : "**/*";
-  const files = await fg2(globPattern, {
+  const files = await glob(globPattern, {
     cwd: root,
     absolute: true,
     dot: false,
@@ -4920,6 +5186,7 @@ var init_grep = __esm({
   "src/tools/grep.ts"() {
     "use strict";
     init_paths();
+    init_glob();
     pExecFile = promisify(execFile);
     cachedHasRg = null;
     grepTool = {
@@ -5310,10 +5577,10 @@ var init_github = __esm({
 // src/tools/browser.ts
 import { mkdir as mkdir5 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join10, dirname as dirname5 } from "path";
+import { join as join11, dirname as dirname5 } from "path";
 async function autoScroll(page) {
   await page.evaluate(async () => {
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       let totalHeight = 0;
       const distance = 300;
       const timer2 = setInterval(() => {
@@ -5322,12 +5589,12 @@ async function autoScroll(page) {
         totalHeight += distance;
         if (totalHeight >= scrollHeight) {
           clearInterval(timer2);
-          resolve3();
+          resolve4();
         }
       }, 100);
       setTimeout(() => {
         clearInterval(timer2);
-        resolve3();
+        resolve4();
       }, 1e4);
     });
   });
@@ -5386,7 +5653,7 @@ var init_browser = __esm({
           }
           let screenshotPath;
           if (args.screenshot) {
-            screenshotPath = join10(tmpdir2(), `kimiflare-browser-${Date.now()}.png`);
+            screenshotPath = join11(tmpdir2(), `kimiflare-browser-${Date.now()}.png`);
             await mkdir5(dirname5(screenshotPath), { recursive: true });
             await page.screenshot({ path: screenshotPath, fullPage: true });
           }
@@ -6258,7 +6525,7 @@ var init_executor = __esm({
     init_write();
     init_edit();
     init_bash();
-    init_glob();
+    init_glob2();
     init_grep();
     init_web_fetch();
     init_web_search();
@@ -6500,16 +6767,16 @@ var init_executor = __esm({
 // src/util/update-check.ts
 import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join11, dirname as dirname6 } from "path";
+import { join as join12, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function cachePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join11(homedir6(), ".config");
-  return join11(xdg, "kimiflare", "update-check.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join12(homedir6(), ".config");
+  return join12(xdg, "kimiflare", "update-check.json");
 }
 async function findPackageJson(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = join11(dir, "package.json");
+    const candidate = join12(dir, "package.json");
     try {
       const raw = await readFile7(candidate, "utf8");
       const parsed = JSON.parse(raw);
@@ -6600,22 +6867,22 @@ var init_update_check = __esm({
 });
 
 // src/remote/session-store.ts
-import { readFile as readFile8, writeFile as writeFile7, mkdir as mkdir7, readdir as readdir2 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile7, mkdir as mkdir7, readdir as readdir3 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function remoteDir() {
-  const xdg = process.env.XDG_DATA_HOME || join12(homedir7(), ".config");
-  return join12(xdg, "kimiflare", "remote");
+  const xdg = process.env.XDG_DATA_HOME || join13(homedir7(), ".config");
+  return join13(xdg, "kimiflare", "remote");
 }
 async function saveRemoteSession(session) {
   const dir = remoteDir();
   await mkdir7(dir, { recursive: true });
-  const path = join12(dir, `${session.sessionId}.json`);
+  const path = join13(dir, `${session.sessionId}.json`);
   await writeFile7(path, JSON.stringify(session, null, 2) + "\n", "utf8");
 }
 async function loadRemoteSession(sessionId) {
   try {
-    const path = join12(remoteDir(), `${sessionId}.json`);
+    const path = join13(remoteDir(), `${sessionId}.json`);
     const raw = await readFile8(path, "utf8");
     return JSON.parse(raw);
   } catch {
@@ -6625,12 +6892,12 @@ async function loadRemoteSession(sessionId) {
 async function listRemoteSessions() {
   const dir = remoteDir();
   try {
-    const files = await readdir2(dir);
+    const files = await readdir3(dir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       try {
-        const raw = await readFile8(join12(dir, file), "utf8");
+        const raw = await readFile8(join13(dir, file), "utf8");
         sessions.push(JSON.parse(raw));
       } catch {
       }
@@ -6652,7 +6919,7 @@ var init_session_store = __esm({
 
 // src/remote/deploy.ts
 import { execSync } from "child_process";
-import { join as join13, dirname as dirname7 } from "path";
+import { join as join14, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { randomBytes } from "crypto";
 function generateSecret() {
@@ -6687,7 +6954,7 @@ async function* deployForTui() {
   yield { message: "Docker OK" };
   yield { message: "Building remote agent bundle..." };
   try {
-    runCapture("npm run build:remote-agent", join13(REMOTE_DIR, ".."));
+    runCapture("npm run build:remote-agent", join14(REMOTE_DIR, ".."));
     yield { message: "Agent bundle built" };
   } catch (err) {
     yield { message: `Build failed: ${err instanceof Error ? err.message : String(err)}`, error: true };
@@ -6817,8 +7084,8 @@ var init_deploy = __esm({
     "use strict";
     init_config();
     __dirname2 = dirname7(fileURLToPath3(import.meta.url));
-    REMOTE_DIR = join13(__dirname2, "..", "..", "..", "remote");
-    WORKER_DIR = join13(REMOTE_DIR, "worker");
+    REMOTE_DIR = join14(__dirname2, "..", "..", "..", "remote");
+    WORKER_DIR = join14(REMOTE_DIR, "worker");
   }
 });
 
@@ -7333,11 +7600,11 @@ var init_heuristic = __esm({
 
 // src/cost-attribution/classify-from-session.ts
 import { readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { homedir as homedir8 } from "os";
 function sessionsDir() {
-  const xdg = process.env.XDG_DATA_HOME || join14(homedir8(), ".local", "share");
-  return join14(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join15(homedir8(), ".local", "share");
+  return join15(xdg, "kimiflare", "sessions");
 }
 function parseToolCalls(calls) {
   return calls.map((c) => {
@@ -7351,7 +7618,7 @@ function parseToolCalls(calls) {
 }
 async function classifyFromSessionFile(sessionId) {
   try {
-    const raw = await readFile9(join14(sessionsDir(), `${sessionId}.json`), "utf8");
+    const raw = await readFile9(join15(sessionsDir(), `${sessionId}.json`), "utf8");
     const session = JSON.parse(raw);
     const messages = session.messages ?? [];
     const turns = [];
@@ -7385,14 +7652,14 @@ __export(cli_exports, {
   runCostCommand: () => runCostCommand
 });
 import { readFile as readFile10 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { homedir as homedir9 } from "os";
 function usageDir() {
-  const xdg = process.env.XDG_DATA_HOME || join15(homedir9(), ".local", "share");
-  return join15(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join16(homedir9(), ".local", "share");
+  return join16(xdg, "kimiflare");
 }
 function usagePath() {
-  return join15(usageDir(), "usage.json");
+  return join16(usageDir(), "usage.json");
 }
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -7508,14 +7775,14 @@ __export(auth_exports, {
 import { readFile as readFile11, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
 import { createHash } from "crypto";
 import { homedir as homedir10, hostname, userInfo } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 function cloudCredPath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join16(homedir10(), ".config");
-  return join16(xdg, "kimiflare", "cloud.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join17(homedir10(), ".config");
+  return join17(xdg, "kimiflare", "cloud.json");
 }
 function deviceIdPath() {
-  const xdg = process.env.XDG_DATA_HOME || join16(homedir10(), ".local", "share");
-  return join16(xdg, "kimiflare", "device_id");
+  const xdg = process.env.XDG_DATA_HOME || join17(homedir10(), ".local", "share");
+  return join17(xdg, "kimiflare", "device_id");
 }
 function generateCode() {
   const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
@@ -7562,7 +7829,7 @@ async function getOrCreateDeviceId() {
 }
 async function persistDeviceId(deviceId) {
   const p = deviceIdPath();
-  await mkdir8(join16(p, ".."), { recursive: true });
+  await mkdir8(join17(p, ".."), { recursive: true });
   await writeFile8(p, deviceId, { mode: 384 });
 }
 async function generateDeviceCodes() {
@@ -7644,7 +7911,7 @@ async function loadCloudCredentials() {
 }
 async function saveCloudCredentials(creds) {
   const p = cloudCredPath();
-  await mkdir8(join16(p, ".."), { recursive: true });
+  await mkdir8(join17(p, ".."), { recursive: true });
   await writeFile8(p, JSON.stringify(creds, null, 2), "utf8");
   if (creds.deviceId) {
     await persistDeviceId(creds.deviceId).catch(() => {
@@ -7693,7 +7960,7 @@ __export(tui_auth_exports, {
   authGitHubForTui: () => authGitHubForTui
 });
 function sleep3(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function* authGitHubForTui() {
   yield { message: "Starting GitHub OAuth device flow..." };
@@ -8807,7 +9074,7 @@ var init_connection = __esm({
         if (this.child) {
           throw new Error("LSP connection already started");
         }
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           const abortController = new AbortController();
           const spawnTimer = setTimeout(() => {
             abortController.abort();
@@ -8846,7 +9113,7 @@ var init_connection = __esm({
               if (child.pid) {
                 clearTimeout(spawnTimer);
                 this.child = child;
-                resolve3();
+                resolve4();
               }
             });
           } catch (err) {
@@ -8861,12 +9128,12 @@ var init_connection = __esm({
         }
         const id = this.nextId++;
         const msg = { jsonrpc: "2.0", id, method, params };
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           const timer2 = setTimeout(() => {
             this.pending.delete(id);
             reject(toolTimeoutError(`LSP request '${method}'`, this.requestTimeoutMs));
           }, this.requestTimeoutMs);
-          const pending = { resolve: resolve3, reject, signal, timer: timer2 };
+          const pending = { resolve: resolve4, reject, signal, timer: timer2 };
           this.pending.set(id, pending);
           if (signal) {
             const onAbort = () => {
@@ -9411,10 +9678,10 @@ var init_manager2 = __esm({
 });
 
 // src/lsp/adapter.ts
-import { relative as relative2 } from "path";
+import { relative as relative3 } from "path";
 function formatLocation(loc, cwd) {
   const path = fromUri(loc.uri);
-  const rel = relative2(cwd, path) || path;
+  const rel = relative3(cwd, path) || path;
   return `${rel}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
 }
 function formatLocations(locs, cwd) {
@@ -9451,7 +9718,7 @@ function formatWorkspaceSymbols(symbols, cwd) {
   if (!symbols || symbols.length === 0) return "No symbols found.";
   return symbols.map((s) => {
     const path = fromUri(s.location.uri);
-    const rel = relative2(cwd, path) || path;
+    const rel = relative3(cwd, path) || path;
     const container = s.containerName ? ` in ${s.containerName}` : "";
     return `${s.name} (${symbolKindName(s.kind)})${container} \u2014 ${rel}:${s.location.range.start.line + 1}:${s.location.range.start.character + 1}`;
   }).join("\n");
@@ -9471,7 +9738,7 @@ function formatWorkspaceEdit(edit, cwd) {
   if (edit.changes) {
     for (const [uri, edits] of Object.entries(edit.changes)) {
       const path = fromUri(uri);
-      const rel = relative2(cwd, path) || path;
+      const rel = relative3(cwd, path) || path;
       lines.push(`File: ${rel}`);
       for (const e of edits) {
         lines.push(`  ${e.range.start.line + 1}:${e.range.start.character + 1}-${e.range.end.line + 1}:${e.range.end.character + 1}: ${e.newText}`);
@@ -9496,7 +9763,7 @@ var init_adapter = __esm({
 });
 
 // src/tools/lsp.ts
-import { relative as relative3 } from "path";
+import { relative as relative4 } from "path";
 function makeOutput2(content) {
   const bytes = Buffer.byteLength(content, "utf8");
   return { content, rawBytes: bytes, reducedBytes: bytes };
@@ -9504,7 +9771,7 @@ function makeOutput2(content) {
 function resolveLspPath(args, ctx) {
   const raw = typeof args.path === "string" ? args.path : "";
   const resolved = resolvePath(ctx.cwd, raw);
-  const rel = relative3(ctx.cwd, resolved);
+  const rel = relative4(ctx.cwd, resolved);
   if (isPathOutside(rel)) {
     throw new Error(`Path outside workspace: ${raw}`);
   }
@@ -9766,12 +10033,12 @@ __export(sessions_exports, {
   saveSession: () => saveSession,
   sessionsDir: () => sessionsDir2
 });
-import { readFile as readFile12, writeFile as writeFile9, mkdir as mkdir9, readdir as readdir3, stat as stat4 } from "fs/promises";
+import { readFile as readFile12, writeFile as writeFile9, mkdir as mkdir9, readdir as readdir4, stat as stat4 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function sessionsDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join18(homedir11(), ".local", "share");
-  return join18(xdg, "kimiflare", "sessions");
+  const xdg = process.env.XDG_DATA_HOME || join19(homedir11(), ".local", "share");
+  return join19(xdg, "kimiflare", "sessions");
 }
 function sanitize(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
@@ -9791,7 +10058,7 @@ function makeSessionId(firstPrompt) {
 async function saveSession(file) {
   const dir = sessionsDir2();
   await mkdir9(dir, { recursive: true });
-  const path = join18(dir, `${file.id}.json`);
+  const path = join19(dir, `${file.id}.json`);
   await writeFile9(path, JSON.stringify(file, null, 2), "utf8");
   return path;
 }
@@ -9804,14 +10071,14 @@ async function listSessions(limit = 30, cwd) {
   const dir = sessionsDir2();
   let entries;
   try {
-    entries = await readdir3(dir);
+    entries = await readdir4(dir);
   } catch {
     return [];
   }
   const summaries = [];
   for (const name of entries) {
     if (!name.endsWith(".json")) continue;
-    const path = join18(dir, name);
+    const path = join19(dir, name);
     try {
       const [s, raw] = await Promise.all([stat4(path), readFile12(path, "utf8")]);
       const parsed = JSON.parse(raw);
@@ -9902,18 +10169,18 @@ var init_pricing = __esm({
 // src/usage-tracker.ts
 import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir10 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
 import { randomUUID } from "crypto";
 function usageDir2() {
-  const xdg = process.env.XDG_DATA_HOME || join19(homedir12(), ".local", "share");
-  return join19(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join20(homedir12(), ".local", "share");
+  return join20(xdg, "kimiflare");
 }
 function usagePath2() {
-  return join19(usageDir2(), "usage.json");
+  return join20(usageDir2(), "usage.json");
 }
 function historyPath() {
-  return join19(usageDir2(), "history.jsonl");
+  return join20(usageDir2(), "history.jsonl");
 }
 function today2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -10365,14 +10632,14 @@ var init_types2 = __esm({
 // src/hooks/settings.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join20, dirname as dirname9 } from "path";
+import { join as join21, dirname as dirname9 } from "path";
 import { createHash as createHash2 } from "crypto";
 function globalSettingsPath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join20(homedir13(), ".config");
-  return join20(xdg, "kimiflare", "settings.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join21(homedir13(), ".config");
+  return join21(xdg, "kimiflare", "settings.json");
 }
 function projectSettingsPath(cwd) {
-  return join20(cwd, ".kimiflare", "settings.json");
+  return join21(cwd, ".kimiflare", "settings.json");
 }
 function readSettingsFile(path) {
   if (!existsSync2(path)) return null;
@@ -10607,7 +10874,7 @@ var init_runner = __esm({
     init_logger();
     DEFAULT_TIMEOUT_MS = 3e4;
     STREAM_CAP_BYTES = 4 * 1024;
-    defaultSpawn = (command, payloadJson, env2, cwd, timeoutMs, signal) => new Promise((resolve3) => {
+    defaultSpawn = (command, payloadJson, env2, cwd, timeoutMs, signal) => new Promise((resolve4) => {
       const child = spawn3(command, {
         shell: true,
         cwd,
@@ -10622,7 +10889,7 @@ var init_runner = __esm({
         settled = true;
         clearTimeout(timer2);
         signal?.removeEventListener("abort", onAbort);
-        resolve3({ exitCode, stdout, stderr, timedOut });
+        resolve4({ exitCode, stdout, stderr, timedOut });
       };
       const onAbort = () => {
         child.kill("SIGTERM");
@@ -10695,13 +10962,13 @@ var init_manager3 = __esm({
 });
 
 // src/sdk/session.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 import { homedir as homedir14 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { existsSync as existsSync3 } from "fs";
 async function createAgentSession(opts2) {
   const config2 = await resolveSdkConfig(opts2);
-  const cwd = resolve2(opts2.cwd ?? process.cwd());
+  const cwd = resolve3(opts2.cwd ?? process.cwd());
   const tools = opts2.tools ?? ALL_TOOLS;
   let hooks;
   if (opts2.enableHooks) {
@@ -10712,7 +10979,7 @@ async function createAgentSession(opts2) {
   let memoryManager = null;
   const memoryEnabled = opts2.memoryEnabled ?? config2.memoryEnabled ?? false;
   if (memoryEnabled) {
-    const dbPath = config2.memoryDbPath ?? join21(homedir14(), ".local", "share", "kimiflare", "memory.db");
+    const dbPath = config2.memoryDbPath ?? join22(homedir14(), ".local", "share", "kimiflare", "memory.db");
     memoryManager = new MemoryManager({
       dbPath,
       accountId: config2.accountId,
@@ -10743,7 +11010,7 @@ async function createAgentSession(opts2) {
   }
   let sessionFile;
   if (opts2.sessionId) {
-    const filePath = join21(sessionsDir2(), `${opts2.sessionId}.json`);
+    const filePath = join22(sessionsDir2(), `${opts2.sessionId}.json`);
     try {
       sessionFile = await loadSession(filePath);
     } catch {
@@ -11095,12 +11362,12 @@ var init_session = __esm({
               toolName: req.tool.name,
               args: req.args
             });
-            const decision = await new Promise((resolve3) => {
-              this.permissionResolvers.set(requestId, resolve3);
+            const decision = await new Promise((resolve4) => {
+              this.permissionResolvers.set(requestId, resolve4);
               setTimeout(() => {
                 if (this.permissionResolvers.has(requestId)) {
                   this.permissionResolvers.delete(requestId);
-                  resolve3("deny");
+                  resolve4("deny");
                 }
               }, 3e5);
             });
@@ -11156,7 +11423,7 @@ var init_session = __esm({
             }
           }
         });
-        if (existsSync3(join21(this.cwd, "KIMI.md"))) {
+        if (existsSync3(join22(this.cwd, "KIMI.md"))) {
           this.messages[0] = {
             role: "system",
             content: buildSystemPrompt({
@@ -11638,6 +11905,302 @@ var init_abort_scope = __esm({
   }
 });
 
+// src/util/diff.ts
+function tokenize(value, options = {}) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [];
+  const linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+function removeEmpty(array) {
+  const ret = [];
+  for (let i = 0; i < array.length; i++) {
+    if (array[i]) {
+      ret.push(array[i]);
+    }
+  }
+  return ret;
+}
+function diffLines(oldStr, newStr, options = {}) {
+  const oldTokens = removeEmpty(tokenize(oldStr));
+  const newTokens = removeEmpty(tokenize(newStr));
+  const newLen = newTokens.length;
+  const oldLen = oldTokens.length;
+  let editLength = 1;
+  let maxEditLength = newLen + oldLen;
+  if (options.maxEditLength != null) {
+    maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+  }
+  const maxExecutionTime = options.timeout ?? Infinity;
+  const abortAfterTimestamp = Date.now() + maxExecutionTime;
+  const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+  let newPos = extractCommon(bestPath[0], newTokens, oldTokens, 0);
+  if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+    return buildValues(bestPath[0].lastComponent, newTokens, oldTokens);
+  }
+  let minDiagonalToConsider = -Infinity;
+  let maxDiagonalToConsider = Infinity;
+  while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+    for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+      let basePath;
+      const removePath = bestPath[diagonalPath - 1];
+      const addPath = bestPath[diagonalPath + 1];
+      if (removePath) {
+        bestPath[diagonalPath - 1] = void 0;
+      }
+      let canAdd = false;
+      if (addPath) {
+        const addPathNewPos = addPath.oldPos - diagonalPath;
+        canAdd = 0 <= addPathNewPos && addPathNewPos < newLen;
+      }
+      const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+      if (!canAdd && !canRemove) {
+        bestPath[diagonalPath] = void 0;
+        continue;
+      }
+      if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+        basePath = addToPath(addPath, true, false, 0);
+      } else {
+        basePath = addToPath(removePath, false, true, 1);
+      }
+      newPos = extractCommon(basePath, newTokens, oldTokens, diagonalPath);
+      if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+        return buildValues(basePath.lastComponent, newTokens, oldTokens);
+      }
+      bestPath[diagonalPath] = basePath;
+      if (basePath.oldPos + 1 >= oldLen) {
+        maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+      }
+      if (newPos + 1 >= newLen) {
+        minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+      }
+    }
+    editLength++;
+  }
+  return [];
+}
+function addToPath(path, added, removed, oldPosInc) {
+  const last = path.lastComponent;
+  if (last && last.added === added && last.removed === removed) {
+    return {
+      oldPos: path.oldPos + oldPosInc,
+      lastComponent: {
+        count: last.count + 1,
+        added,
+        removed,
+        previousComponent: last.previousComponent
+      }
+    };
+  } else {
+    return {
+      oldPos: path.oldPos + oldPosInc,
+      lastComponent: {
+        count: 1,
+        added,
+        removed,
+        previousComponent: last
+      }
+    };
+  }
+}
+function extractCommon(basePath, newTokens, oldTokens, diagonalPath) {
+  const newLen = newTokens.length;
+  const oldLen = oldTokens.length;
+  let oldPos = basePath.oldPos;
+  let newPos = oldPos - diagonalPath;
+  let commonCount = 0;
+  while (newPos + 1 < newLen && oldPos + 1 < oldLen && oldTokens[oldPos + 1] === newTokens[newPos + 1]) {
+    newPos++;
+    oldPos++;
+    commonCount++;
+  }
+  if (commonCount) {
+    basePath.lastComponent = {
+      count: commonCount,
+      previousComponent: basePath.lastComponent,
+      added: false,
+      removed: false
+    };
+  }
+  basePath.oldPos = oldPos;
+  return newPos;
+}
+function buildValues(lastComponent, newTokens, oldTokens) {
+  const components = [];
+  let nextComponent;
+  while (lastComponent) {
+    components.push(lastComponent);
+    nextComponent = lastComponent.previousComponent;
+    delete lastComponent.previousComponent;
+    lastComponent = nextComponent;
+  }
+  components.reverse();
+  const result = [];
+  let newPos = 0;
+  let oldPos = 0;
+  for (const component of components) {
+    if (!component.removed) {
+      component.value = newTokens.slice(newPos, newPos + component.count).join("");
+      newPos += component.count;
+      if (!component.added) {
+        oldPos += component.count;
+      }
+    } else {
+      component.value = oldTokens.slice(oldPos, oldPos + component.count).join("");
+      oldPos += component.count;
+    }
+    result.push({ value: component.value, added: component.added, removed: component.removed });
+  }
+  return result;
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    const last = result.pop();
+    if (last !== void 0) {
+      result.push(last.slice(0, -1));
+    }
+  }
+  return result;
+}
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  const optionsObj = options ?? {};
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  const diff = diffLines(oldStr, newStr);
+  return diffLinesResultToPatch(diff);
+  function diffLinesResultToPatch(diffResult) {
+    if (!diffResult) {
+      return void 0;
+    }
+    diffResult.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map((entry) => " " + entry);
+    }
+    const hunks = [];
+    let oldRangeStart = 0;
+    let newRangeStart = 0;
+    let curRange = [];
+    let oldLine = 1;
+    let newLine = 1;
+    for (let i = 0; i < diffResult.length; i++) {
+      const current = diffResult[i];
+      const lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diffResult[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diffResult.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch) {
+  const ret = [];
+  ret.push("Index: " + patch.oldFileName);
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    const oldStart = hunk.oldLines === 0 ? hunk.oldStart - 1 : hunk.oldStart;
+    const newStart = hunk.newLines === 0 ? hunk.newStart - 1 : hunk.newStart;
+    ret.push("@@ -" + oldStart + "," + hunk.oldLines + " +" + newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+  if (!patchObj) {
+    return "";
+  }
+  return formatPatch(patchObj);
+}
+var init_diff = __esm({
+  "src/util/diff.ts"() {
+    "use strict";
+  }
+});
+
 // src/ui/theme-context.tsx
 import { createContext, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -11662,7 +12225,6 @@ var init_theme_context = __esm({
 
 // src/ui/diff-view.tsx
 import { Box, Text } from "ink";
-import { createTwoFilesPatch } from "diff";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 function DiffView({ path, before, after, maxLines = 40 }) {
   const theme = useTheme();
@@ -11709,6 +12271,7 @@ function DiffLine({ line }) {
 var init_diff_view = __esm({
   "src/ui/diff-view.tsx"() {
     "use strict";
+    init_diff();
     init_theme_context();
   }
 });
@@ -13734,19 +14297,19 @@ function usePermissionController(getMode, onPlanModeBlocked) {
   const onPlanModeBlockedRef = useRef2(onPlanModeBlocked);
   onPlanModeBlockedRef.current = onPlanModeBlocked;
   const askPermission = useCallback2(
-    (req, askOpts) => new Promise((resolve3) => {
+    (req, askOpts) => new Promise((resolve4) => {
       const outcome = decidePermission(req, getModeRef.current(), askOpts);
       if (outcome.kind === "resolve") {
-        resolve3(outcome.decision);
+        resolve4(outcome.decision);
         return;
       }
       if (outcome.kind === "plan_blocked") {
         onPlanModeBlockedRef.current(outcome.toolName);
-        resolve3(AUTO_DENY);
+        resolve4(AUTO_DENY);
         return;
       }
-      resolveRef.current = resolve3;
-      setPending({ tool: req.tool, args: req.args, resolve: resolve3 });
+      resolveRef.current = resolve4;
+      setPending({ tool: req.tool, args: req.args, resolve: resolve4 });
     }),
     []
   );
@@ -14811,16 +15374,15 @@ var init_frontmatter = __esm({
 });
 
 // src/commands/loader.ts
-import { open, realpath } from "fs/promises";
+import { open, realpath as realpath2 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join22, relative as relative4, sep as sep2 } from "path";
-import fg3 from "fast-glob";
+import { join as join23, relative as relative5, sep as sep2 } from "path";
 function projectCommandsDir(cwd = process.cwd()) {
-  return join22(cwd, ".kimiflare", "commands");
+  return join23(cwd, ".kimiflare", "commands");
 }
 function globalCommandsDir() {
-  const xdg = process.env.XDG_CONFIG_HOME || join22(homedir15(), ".config");
-  return join22(xdg, "kimiflare", "commands");
+  const xdg = process.env.XDG_CONFIG_HOME || join23(homedir15(), ".config");
+  return join23(xdg, "kimiflare", "commands");
 }
 async function loadCustomCommands(cwd = process.cwd()) {
   const warnings = [];
@@ -14833,11 +15395,10 @@ async function loadCustomCommands(cwd = process.cwd()) {
     sources.map(async ({ dir, source }) => {
       const safeDir = await resolveSafeDir(dir, source, cwd, warnings);
       if (safeDir === null) return [];
-      const files = await fg3("**/*.md", {
+      const files = await glob("**/*.md", {
         cwd: safeDir,
         absolute: true,
         onlyFiles: true,
-        followSymbolicLinks: false,
         suppressErrors: true
       });
       return Promise.all(files.map((file) => loadOne(file, safeDir, source, warnings)));
@@ -14860,7 +15421,7 @@ async function loadCustomCommands(cwd = process.cwd()) {
 async function resolveSafeDir(dir, source, cwd, warnings) {
   let realDir;
   try {
-    realDir = await realpath(dir);
+    realDir = await realpath2(dir);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -14871,11 +15432,11 @@ async function resolveSafeDir(dir, source, cwd, warnings) {
   if (source === "project") {
     let realCwd;
     try {
-      realCwd = await realpath(cwd);
+      realCwd = await realpath2(cwd);
     } catch {
       return null;
     }
-    const rel = relative4(realCwd, realDir);
+    const rel = relative5(realCwd, realDir);
     if (rel !== "" && isPathOutside(rel)) {
       warnings.push(`commands dir ${dir} escapes workspace via symlink \u2014 skipped`);
       return null;
@@ -14950,7 +15511,7 @@ async function loadOne(file, rootDir, source, warnings) {
   return cmd;
 }
 function filenameToCommandName(file, rootDir) {
-  const rel = relative4(rootDir, file);
+  const rel = relative5(rootDir, file);
   if (!rel || isPathOutside(rel)) return null;
   const noExt = rel.replace(/\.md$/i, "");
   const parts = noExt.split(sep2).filter((p) => p.length > 0);
@@ -14963,6 +15524,7 @@ var init_loader = __esm({
   "src/commands/loader.ts"() {
     "use strict";
     init_mode();
+    init_glob();
     init_config();
     init_paths();
     init_frontmatter();
@@ -14972,8 +15534,8 @@ var init_loader = __esm({
 
 // src/commands/renderer.ts
 import { exec } from "child_process";
-import { open as open2, realpath as realpath2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolvePathJoin, basename as pathBasename } from "path";
+import { open as open2, realpath as realpath3 } from "fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative6, resolve as resolvePathJoin, basename as pathBasename } from "path";
 import { promisify as promisify2 } from "util";
 function tokenizeArgs(s) {
   return [...s.matchAll(ARG_TOKEN_RE)].map((match) => {
@@ -15064,7 +15626,7 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
       return "" + trailing;
     });
   }
-  const realCwd = await realpath2(cwd).catch(() => cwd);
+  const realCwd = await realpath3(cwd).catch(() => cwd);
   const replacements = await Promise.all(
     matches.map(async (match) => {
       const rawPath = match[1] ?? "";
@@ -15078,18 +15640,18 @@ async function replaceFiles(prompt, warnings, cmd, cwd, maxFileBytes) {
         return "";
       }
       const resolved = resolvePathJoin(cwd, rawPath);
-      if (isPathOutside(relative5(cwd, resolved))) {
+      if (isPathOutside(relative6(cwd, resolved))) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 outside workspace`);
         return "";
       }
       let real;
       try {
-        real = await realpath2(resolved);
+        real = await realpath3(resolved);
       } catch (error) {
         warnings.push(`file inclusion failed: @${rawPath} \u2014 ${message(error)}`);
         return "";
       }
-      if (isPathOutside(relative5(realCwd, real))) {
+      if (isPathOutside(relative6(realCwd, real))) {
         warnings.push(`file inclusion skipped: @${rawPath} \u2014 symlink escapes workspace`);
         return "";
       }
@@ -16072,11 +16634,11 @@ var init_wcag = __esm({
 });
 
 // src/ui/theme-loader.ts
-import { readFile as readFile15, readdir as readdir4 } from "fs/promises";
-import { join as join23 } from "path";
+import { readFile as readFile15, readdir as readdir5 } from "fs/promises";
+import { join as join24 } from "path";
 import { homedir as homedir16 } from "os";
 function projectThemesDir(cwd = process.cwd()) {
-  return join23(cwd, ".kimiflare", "themes");
+  return join24(cwd, ".kimiflare", "themes");
 }
 function isHexColor(c) {
   return /^#[0-9a-fA-F]{6}$/.test(c);
@@ -16160,12 +16722,12 @@ async function loadThemesFromDir(dir, source) {
   const errors = [];
   let files;
   try {
-    files = await readdir4(dir);
+    files = await readdir5(dir);
   } catch {
     return { themes, errors };
   }
   for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const path = join23(dir, file);
+    const path = join24(dir, file);
     let raw;
     try {
       raw = await readFile15(path, "utf-8");
@@ -16314,8 +16876,8 @@ var init_theme_loader = __esm({
     "use strict";
     init_wcag();
     init_theme();
-    USER_THEMES_DIR = join23(
-      process.env.XDG_CONFIG_HOME || join23(homedir16(), ".config"),
+    USER_THEMES_DIR = join24(
+      process.env.XDG_CONFIG_HOME || join24(homedir16(), ".config"),
       "kimiflare",
       "themes"
     );
@@ -19837,8 +20399,8 @@ var init_frontmatter2 = __esm({
 });
 
 // src/skills/loader.ts
-import { readFile as readFile16, readdir as readdir5, stat as stat5 } from "fs/promises";
-import { join as join24, extname } from "path";
+import { readFile as readFile16, readdir as readdir6, stat as stat5 } from "fs/promises";
+import { join as join25, extname } from "path";
 function normalizeManifest(raw, filePath) {
   const name = typeof raw.name === "string" ? raw.name : "";
   const description = typeof raw.description === "string" ? raw.description : "";
@@ -19871,10 +20433,10 @@ async function loadSkillFile(filePath) {
 }
 async function loadSkillsFromDir(dirPath) {
   try {
-    const entries = await readdir5(dirPath);
+    const entries = await readdir6(dirPath);
     const files = [];
     for (const entry of entries) {
-      const full = join24(dirPath, entry);
+      const full = join25(dirPath, entry);
       const s = await stat5(full);
       if (s.isFile() && extname(entry) === ".md") {
         files.push(full);
@@ -19903,11 +20465,11 @@ var init_loader2 = __esm({
 
 // src/skills/manager.ts
 import { mkdir as mkdir11, writeFile as writeFile11, unlink as unlink2, readFile as readFile17 } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function getSkillDirs(cwd) {
   return {
-    projectDir: join25(cwd, ".kimiflare", "skills"),
-    globalDir: join25(process.env.HOME ?? "", ".config", "kimiflare", "skills")
+    projectDir: join26(cwd, ".kimiflare", "skills"),
+    globalDir: join26(process.env.HOME ?? "", ".config", "kimiflare", "skills")
   };
 }
 async function listAllSkills(cwd) {
@@ -19921,7 +20483,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 = join25(dir, `${opts2.name}.md`);
+  const filepath = join26(dir, `${opts2.name}.md`);
   const frontmatter = {
     name: opts2.name,
     enabled: true,
@@ -20043,7 +20605,7 @@ var init_report2 = __esm({
 // src/ui/app-helpers.ts
 import { execSync as execSync2, spawn as spawn5 } from "child_process";
 import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 import { platform as platform5 } from "os";
 function buildFilePickerIgnoreList(cwd) {
   const hardcoded = [
@@ -20115,7 +20677,7 @@ function buildFilePickerIgnoreList(cwd) {
   ];
   const gitignorePatterns = [];
   try {
-    const gitignorePath = join26(cwd, ".gitignore");
+    const gitignorePath = join27(cwd, ".gitignore");
     const stats = statSync4(gitignorePath);
     if (stats.size > MAX_GITIGNORE_SIZE) {
       return hardcoded;
@@ -20288,14 +20850,14 @@ __export(tui_report_exports, {
   getCategoryReportText: () => getCategoryReportText
 });
 import { readFile as readFile18 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 import { homedir as homedir17 } from "os";
 function usageDir3() {
-  const xdg = process.env.XDG_DATA_HOME || join27(homedir17(), ".local", "share");
-  return join27(xdg, "kimiflare");
+  const xdg = process.env.XDG_DATA_HOME || join28(homedir17(), ".local", "share");
+  return join28(xdg, "kimiflare");
 }
 function usagePath3() {
-  return join27(usageDir3(), "usage.json");
+  return join28(usageDir3(), "usage.json");
 }
 function today3() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -20364,7 +20926,7 @@ var init_tui_report = __esm({
 });
 
 // src/ui/slash-commands.ts
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { unlink as unlink3 } from "fs/promises";
 import QRCode from "qrcode";
 function dispatchSlashCommand(ctx, cmd) {
@@ -20932,7 +21494,7 @@ ${lines.join("\n")}` }]);
         try {
           ctx.ensureSessionId();
           const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-          const filePath = join28(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
+          const filePath = join29(sessionsDir3(), `${ctx.sessionIdRef.current}.json`);
           await addCheckpoint(filePath, cp);
           setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: `checkpoint saved: "${label}"` }]);
         } catch (e) {
@@ -20954,7 +21516,7 @@ ${lines.join("\n")}` }]);
       void (async () => {
         try {
           const { sessionsDir: sessionsDir3 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
-          const file = await loadSession(join28(sessionsDir3(), `${currentId}.json`));
+          const file = await loadSession(join29(sessionsDir3(), `${currentId}.json`));
           const cps = file.checkpoints ?? [];
           if (cps.length === 0) {
             setEvents((e) => [...e, { kind: "info", key: mkKey2(), text: "no checkpoints in this session" }]);
@@ -21531,12 +22093,12 @@ project: ${projectSettingsPath(cwd)}`
 
 // src/init/context-generator.ts
 import { existsSync as existsSync5, statSync as statSync5 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } 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 = join29(cwd, sig);
+      const path = join30(cwd, sig);
       if (sig.includes("*")) {
         try {
           const parts = sig.split("*");
@@ -21557,14 +22119,14 @@ function detectFlavor(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (existsSync5(join29(cwd, c))) return c;
+    if (existsSync5(join30(cwd, c))) return c;
   }
   return null;
 }
 function findSourceRoots(cwd) {
   const roots = [];
   for (const r of SOURCE_ROOT_CANDIDATES) {
-    const p = join29(cwd, r);
+    const p = join30(cwd, r);
     try {
       const s = statSync5(p);
       if (s.isDirectory()) roots.push(r);
@@ -21575,9 +22137,9 @@ function findSourceRoots(cwd) {
 }
 function findCiConfig(cwd) {
   for (const c of CI_PATHS) {
-    if (existsSync5(join29(cwd, c))) {
+    if (existsSync5(join30(cwd, c))) {
       try {
-        const s = statSync5(join29(cwd, c));
+        const s = statSync5(join30(cwd, c));
         return s.isDirectory() ? c : c;
       } catch {
       }
@@ -21714,7 +22276,7 @@ function analyzeProject(cwd) {
     ciConfig: findCiConfig(cwd),
     readme: findFile(cwd, ["README.md", "README.rst", "README.txt", "Readme.md"]),
     sourceRoots: findSourceRoots(cwd),
-    hasGit: existsSync5(join29(cwd, ".git"))
+    hasGit: existsSync5(join30(cwd, ".git"))
   };
 }
 function bashDiscoveryCommands(profile) {
@@ -21879,7 +22441,7 @@ Aim for 100\u2013200 lines total. Use markdown tables where they save space.
 }
 function buildInitPrompt(cwd) {
   const existingName = ["KIMI.md", "KIMIFLARE.md", "AGENT.md"].find(
-    (n) => existsSync5(join29(cwd, n))
+    (n) => existsSync5(join30(cwd, n))
   );
   const isRefresh = existingName !== void 0;
   const targetFilename = existingName ?? "KIMI.md";
@@ -21963,7 +22525,7 @@ var init_context_generator = __esm({
 
 // src/init/run-init.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 async function runInit(deps) {
   const {
     cfg,
@@ -22190,7 +22752,7 @@ async function runInit(deps) {
         }
       }
     });
-    if (existsSync6(join30(cwd, "KIMI.md"))) {
+    if (existsSync6(join31(cwd, "KIMI.md"))) {
       if (cacheStableRef.current) {
         messagesRef.current[1] = {
           role: "system",
@@ -22320,8 +22882,8 @@ var init_run_init = __esm({
 });
 
 // src/skills/discovery.ts
-import { readdir as readdir6, stat as stat6, readFile as readFile19 } from "fs/promises";
-import { join as join31, extname as extname2 } from "path";
+import { readdir as readdir7, stat as stat6, readFile as readFile19 } from "fs/promises";
+import { join as join32, extname as extname2 } from "path";
 async function dirExists(path) {
   try {
     const s = await stat6(path);
@@ -22340,20 +22902,20 @@ async function fileExists(path) {
 }
 async function scanSkillDir(dirPath, source) {
   if (!await dirExists(dirPath)) return [];
-  const entries = await readdir6(dirPath, { withFileTypes: true });
+  const entries = await readdir7(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     if (!SKILL_EXTENSIONS.has(extname2(entry.name))) continue;
-    files.push({ filePath: join31(dirPath, entry.name), source });
+    files.push({ filePath: join32(dirPath, entry.name), source });
   }
   return files;
 }
 async function discoverSkills(cwd) {
-  const agentsSkills = await scanSkillDir(join31(cwd, ".agents", "skills"), "agents");
-  const agentsMd = await fileExists(join31(cwd, "AGENTS.md")) ? [{ filePath: join31(cwd, "AGENTS.md"), source: "agents-md" }] : [];
-  const githubSkills = await scanSkillDir(join31(cwd, ".github", "skills"), "github");
-  const kimiflareSkills = await scanSkillDir(join31(cwd, ".kimiflare", "skills"), "kimiflare");
+  const agentsSkills = await scanSkillDir(join32(cwd, ".agents", "skills"), "agents");
+  const agentsMd = await fileExists(join32(cwd, "AGENTS.md")) ? [{ filePath: join32(cwd, "AGENTS.md"), source: "agents-md" }] : [];
+  const githubSkills = await scanSkillDir(join32(cwd, ".github", "skills"), "github");
+  const kimiflareSkills = await scanSkillDir(join32(cwd, ".kimiflare", "skills"), "kimiflare");
   const ordered = [...agentsSkills, ...agentsMd, ...githubSkills, ...kimiflareSkills];
   return ordered;
 }
@@ -22568,10 +23130,10 @@ var init_skills = __esm({
 // src/util/state.ts
 import { readFile as readFile20, writeFile as writeFile12, mkdir as mkdir12 } from "fs/promises";
 import { homedir as homedir18 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function statePath() {
-  const xdg = process.env.XDG_CONFIG_HOME || join32(homedir18(), ".config");
-  return join32(xdg, "kimiflare", "state.json");
+  const xdg = process.env.XDG_CONFIG_HOME || join33(homedir18(), ".config");
+  return join33(xdg, "kimiflare", "state.json");
 }
 async function readState() {
   try {
@@ -22583,7 +23145,7 @@ async function readState() {
 }
 async function writeState(state) {
   const path = statePath();
-  await mkdir12(join32(path, ".."), { recursive: true });
+  await mkdir12(join33(path, ".."), { recursive: true });
   await writeFile12(path, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 async function markCreatorMessageSeen(version) {
@@ -22603,7 +23165,7 @@ var init_state = __esm({
 
 // src/ui/run-startup-tasks.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function runStartupTasks(deps) {
   const {
     cfg,
@@ -22658,7 +23220,7 @@ function runStartupTasks(deps) {
     }
   });
   if (cfg.memoryEnabled) {
-    const dbPath = cfg.memoryDbPath ?? join33(process.cwd(), ".kimiflare", "memory.db");
+    const dbPath = cfg.memoryDbPath ?? join34(process.cwd(), ".kimiflare", "memory.db");
     const manager = new MemoryManager({
       dbPath,
       accountId: cfg.accountId,
@@ -22692,7 +23254,7 @@ function runStartupTasks(deps) {
     });
     const cwd = process.cwd();
     sessionStartRecallRef.current = manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
-    if (existsSync7(join33(cwd, "KIMI.md"))) {
+    if (existsSync7(join34(cwd, "KIMI.md"))) {
       const lastRefresh = manager.getLastKimiMdRefreshTime(cwd);
       const driftCount = manager.countHighSignalMemoriesSince(cwd, lastRefresh);
       if (driftCount >= 5) {
@@ -22703,7 +23265,7 @@ function runStartupTasks(deps) {
     memoryManagerRef.current?.close();
     memoryManagerRef.current = null;
   }
-  const skillDbPath = cfg.memoryDbPath ?? join33(process.cwd(), ".kimiflare", "memory.db");
+  const skillDbPath = cfg.memoryDbPath ?? join34(process.cwd(), ".kimiflare", "memory.db");
   const skillDb = getMemoryDb() ?? openMemoryDb(skillDbPath);
   initSkillsSchema(skillDb);
   void indexSkills({
@@ -23202,8 +23764,7 @@ __export(app_exports, {
 import React19, { useState as useState20, useRef as useRef7, useEffect as useEffect8, useCallback as useCallback8 } from "react";
 import { Box as Box28, Text as Text29, useApp, useInput as useInput12, render } from "ink";
 import { existsSync as existsSync8 } from "fs";
-import { join as join34 } from "path";
-import fg4 from "fast-glob";
+import { join as join35 } from "path";
 import { jsx as jsx30, jsxs as jsxs28 } from "react/jsx-runtime";
 function App({
   initialCfg,
@@ -23503,7 +24064,7 @@ ${wcagWarnings.join("\n")}` }
   const modalActive = commandWizard !== null || commandPicker !== null || commandToDelete !== null || showCommandList || showLspWizard || resumeSessions !== null || checkpointSession !== null || perm !== null || limitModal !== null || loopModal !== null || showInboxModal;
   const loadFilePickerItems = useCallback8(async () => {
     const cwd = process.cwd();
-    const entries = await fg4("**/*", {
+    const entries = await glob("**/*", {
       cwd,
       ignore: buildFilePickerIgnoreList(cwd),
       dot: false,
@@ -24303,7 +24864,7 @@ ${wcagWarnings.join("\n")}` }
         }
       }
       turnCounterRef.current += 1;
-      if (turnCounterRef.current % 15 === 0 && existsSync8(join34(process.cwd(), "KIMI.md")) && !kimiMdStale) {
+      if (turnCounterRef.current % 15 === 0 && existsSync8(join35(process.cwd(), "KIMI.md")) && !kimiMdStale) {
         setEvents((e) => [
           ...e,
           { kind: "info", key: mkKey(), text: "Tip: Rerunning /init occasionally helps KimiFlare stay accurate as your project evolves." }
@@ -24443,13 +25004,13 @@ ${wcagWarnings.join("\n")}` }
           }
         },
         askPermission: askForPermission,
-        onToolLimitReached: () => new Promise((resolve3) => {
-          limitResolveRef.current = resolve3;
-          setLimitModal({ limit: 50, resolve: resolve3 });
+        onToolLimitReached: () => new Promise((resolve4) => {
+          limitResolveRef.current = resolve4;
+          setLimitModal({ limit: 50, resolve: resolve4 });
         }),
-        onLoopDetected: () => new Promise((resolve3) => {
-          loopResolveRef.current = resolve3;
-          setLoopModal({ resolve: resolve3 });
+        onLoopDetected: () => new Promise((resolve4) => {
+          loopResolveRef.current = resolve4;
+          setLoopModal({ resolve: resolve4 });
         }),
         onKimiMdStale: () => {
           if (!kimiMdStaleNudgedRef.current) {
@@ -24808,7 +25369,7 @@ ${wcagWarnings.join("\n")}` }
         onCommandDelete: handleCommandDelete2,
         lspServers: cfg?.lspServers ?? {},
         lspScope,
-        hasProjectDir: existsSync8(join34(process.cwd(), ".kimiflare")),
+        hasProjectDir: existsSync8(join35(process.cwd(), ".kimiflare")),
         onLspSave: handleLspSave2,
         themes: themeList(),
         onPickTheme: handleThemePick,
@@ -25032,6 +25593,7 @@ var init_app = __esm({
     init_theme();
     init_theme_loader();
     init_lsp_nudge();
+    init_glob();
     init_file_picker();
     init_slash_picker();
     init_use_picker_controller();