reasonix 0.12.16 → 0.12.19

package/dist/cli/index.js

@@ -666,6 +666,7 @@ function matchesTool(hook, toolName) {
     return false;
   }
 }
+var HOOK_OUTPUT_CAP_BYTES = 256 * 1024;
 function defaultSpawner(input) {
   return new Promise((resolve13) => {
     const child = spawn(input.command, {
@@ -673,8 +674,11 @@ function defaultSpawner(input) {
       shell: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    let stdout3 = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let truncated = false;
     let timedOut = false;
     const timer = setTimeout(() => {
       timedOut = true;
@@ -686,29 +690,46 @@ function defaultSpawner(input) {
         }
       }, 500);
     }, input.timeoutMs);
-    child.stdout.on("data", (chunk) => {
-      stdout3 += chunk.toString("utf8");
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf8");
-    });
+    const onChunk = (kind, chunk) => {
+      const target = kind === "stdout" ? stdoutChunks : stderrChunks;
+      const seen = kind === "stdout" ? stdoutBytes : stderrBytes;
+      if (seen >= HOOK_OUTPUT_CAP_BYTES) {
+        truncated = true;
+        return;
+      }
+      const remaining = HOOK_OUTPUT_CAP_BYTES - seen;
+      if (chunk.length > remaining) {
+        target.push(chunk.subarray(0, remaining));
+        if (kind === "stdout") stdoutBytes = HOOK_OUTPUT_CAP_BYTES;
+        else stderrBytes = HOOK_OUTPUT_CAP_BYTES;
+        truncated = true;
+      } else {
+        target.push(chunk);
+        if (kind === "stdout") stdoutBytes += chunk.length;
+        else stderrBytes += chunk.length;
+      }
+    };
+    child.stdout.on("data", (chunk) => onChunk("stdout", chunk));
+    child.stderr.on("data", (chunk) => onChunk("stderr", chunk));
     child.once("error", (err) => {
       clearTimeout(timer);
       resolve13({
         exitCode: null,
-        stdout: stdout3,
-        stderr,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
         timedOut: false,
-        spawnError: err
+        spawnError: err,
+        truncated: truncated || void 0
       });
     });
     child.once("close", (code) => {
       clearTimeout(timer);
       resolve13({
         exitCode: code,
-        stdout: stdout3.trim(),
-        stderr: stderr.trim(),
-        timedOut
+        stdout: Buffer.concat(stdoutChunks).toString("utf8").trim(),
+        stderr: Buffer.concat(stderrChunks).toString("utf8").trim(),
+        timedOut,
+        truncated: truncated || void 0
       });
     });
     try {
@@ -723,7 +744,8 @@ function formatHookOutcomeMessage(outcome) {
   const detail = (outcome.stderr || outcome.stdout || "").trim();
   const tag = `${outcome.hook.scope}/${outcome.hook.event}`;
   const cmd = outcome.hook.command.length > 60 ? `${outcome.hook.command.slice(0, 60)}\u2026` : outcome.hook.command;
-  const head = `hook ${tag} \`${cmd}\` ${outcome.decision}`;
+  const truncTag = outcome.truncated ? " (output truncated at 256KB)" : "";
+  const head = `hook ${tag} \`${cmd}\` ${outcome.decision}${truncTag}`;
   return detail ? `${head}: ${detail}` : head;
 }
 function decideOutcome(event, raw) {
@@ -754,7 +776,8 @@ async function runHooks(opts) {
       exitCode: raw.exitCode,
       stdout: raw.stdout,
       stderr: raw.stderr || (raw.spawnError ? raw.spawnError.message : "") || (raw.timedOut ? `hook timed out after ${timeoutMs}ms` : ""),
-      durationMs: Date.now() - start
+      durationMs: Date.now() - start,
+      truncated: raw.truncated
     });
     if (decision === "block") {
       blocked = true;
@@ -1302,6 +1325,23 @@ var ImmutablePrefix = class {
    */
   _toolSpecs;
   fewShots;
+  /**
+   * Cached SHA-256 of the prefix payload. Computed lazily on first
+   * `fingerprint` access, invalidated only by mutations that go
+   * through `addTool` (the one legitimate post-construction mutation
+   * path). The TUI reads `fingerprint` on every render — without the
+   * cache, that means a fresh `JSON.stringify` + sha256 over the
+   * full prefix (system prompt + tools list + few-shots, typically
+   * 5-10KB) on every keystroke.
+   *
+   * The lazy-init also acts as a cheap drift guard: if some future
+   * code path mutates `_toolSpecs` directly without going through
+   * `addTool`, `fingerprint` will return the stale cached value
+   * while the actual prefix sent to DeepSeek diverges — the cache
+   * miss would be the first symptom. {@link verifyFingerprint}
+   * lets dev / test code assert the cache matches reality.
+   */
+  _fingerprintCache = null;
   constructor(opts) {
     this.system = opts.system;
     this._toolSpecs = [...opts.toolSpecs ?? []];
@@ -1327,9 +1367,33 @@ var ImmutablePrefix = class {
     if (!name) return false;
     if (this._toolSpecs.some((t2) => t2.function?.name === name)) return false;
     this._toolSpecs.push(spec);
+    this._fingerprintCache = null;
     return true;
   }
   get fingerprint() {
+    if (this._fingerprintCache !== null) return this._fingerprintCache;
+    this._fingerprintCache = this.computeFingerprint();
+    return this._fingerprintCache;
+  }
+  /**
+   * Recompute the fingerprint from scratch and assert it matches the
+   * cached value. Returns the freshly-computed hash on success; throws
+   * with a diff if the cache drifted, which always indicates a bug —
+   * either a non-`addTool` mutation path was added, or `addTool`
+   * forgot to invalidate the cache. Dev / test only; the live loop
+   * doesn't call this on the hot path.
+   */
+  verifyFingerprint() {
+    const fresh = this.computeFingerprint();
+    if (this._fingerprintCache !== null && this._fingerprintCache !== fresh) {
+      throw new Error(
+        `ImmutablePrefix fingerprint drift: cached=${this._fingerprintCache}, fresh=${fresh}. A mutation path bypassed addTool's cache invalidation \u2014 DeepSeek will see prefix churn that the TUI / transcript log don't know about.`
+      );
+    }
+    this._fingerprintCache = fresh;
+    return fresh;
+  }
+  computeFingerprint() {
     const blob = JSON.stringify({
       system: this.system,
       tools: this._toolSpecs,
@@ -1748,15 +1812,25 @@ function listSessions() {
     const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
     return files.map((file) => {
       const path5 = join4(dir, file);
-      const stat = statSync(path5);
+      const stat2 = statSync(path5);
       const name = file.replace(/\.jsonl$/, "");
       const messageCount = countLines(path5);
-      return { name, path: path5, size: stat.size, messageCount, mtime: stat.mtime };
+      return { name, path: path5, size: stat2.size, messageCount, mtime: stat2.mtime };
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
   } catch {
     return [];
   }
 }
+function pruneStaleSessions(daysOld = 90) {
+  const cutoff = Date.now() - daysOld * 24 * 60 * 60 * 1e3;
+  const deleted = [];
+  for (const s of listSessions()) {
+    if (s.mtime.getTime() < cutoff) {
+      if (deleteSession(s.name)) deleted.push(s.name);
+    }
+  }
+  return deleted;
+}
 function deleteSession(name) {
   const path5 = sessionPath(name);
   try {
@@ -3252,6 +3326,7 @@ function extractDeepSeekErrorMessage(body) {
 
 // src/at-mentions.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { readdir, stat } from "fs/promises";
 import { isAbsolute, join as join5, relative, resolve } from "path";
 var DEFAULT_AT_MENTION_MAX_BYTES = 64 * 1024;
 var DEFAULT_PICKER_IGNORE_DIRS = [
@@ -3306,6 +3381,58 @@ function listFilesWithStatsSync(root, opts = {}) {
   walk3(rootAbs, "");
   return out;
 }
+async function listFilesWithStatsAsync(root, opts = {}) {
+  const maxResults = Math.max(1, opts.maxResults ?? 500);
+  const ignore = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
+  const rootAbs = resolve(root);
+  const out = [];
+  const walk3 = async (dirAbs, dirRel) => {
+    if (out.length >= maxResults) return;
+    let entries;
+    try {
+      entries = await readdir(dirAbs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    const fileEnts = [];
+    for (const ent of entries) {
+      if (out.length >= maxResults) break;
+      if (ent.isDirectory()) {
+        if (ent.name.startsWith(".") || ignore.has(ent.name)) continue;
+        if (fileEnts.length > 0) {
+          await statBatch(fileEnts, dirAbs, dirRel, out, maxResults);
+          fileEnts.length = 0;
+          if (out.length >= maxResults) return;
+        }
+        await walk3(join5(dirAbs, ent.name), dirRel ? `${dirRel}/${ent.name}` : ent.name);
+      } else if (ent.isFile()) {
+        fileEnts.push(ent);
+      }
+    }
+    if (fileEnts.length > 0 && out.length < maxResults) {
+      await statBatch(fileEnts, dirAbs, dirRel, out, maxResults);
+    }
+  };
+  await walk3(rootAbs, "");
+  return out;
+}
+async function statBatch(ents, dirAbs, dirRel, out, maxResults) {
+  const remaining = Math.max(0, maxResults - out.length);
+  const batch = ents.slice(0, remaining);
+  const stats2 = await Promise.all(
+    batch.map(
+      (e) => stat(join5(dirAbs, e.name)).then((s) => s.mtimeMs).catch(() => 0)
+    )
+  );
+  for (let i = 0; i < batch.length; i++) {
+    const ent = batch[i];
+    out.push({
+      path: dirRel ? `${dirRel}/${ent.name}` : ent.name,
+      mtimeMs: stats2[i] ?? 0
+    });
+  }
+}
 var AT_PICKER_PREFIX = /(?:^|\s)@([a-zA-Z0-9_./\\-]*)$/;
 function detectAtPicker(input) {
   const m = AT_PICKER_PREFIX.exec(input);
@@ -3666,8 +3793,8 @@ When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_L
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      const stat = await fs.stat(abs);
-      if (stat.isDirectory()) {
+      const stat2 = await fs.stat(abs);
+      if (stat2.isDirectory()) {
         throw new Error(`not a file: ${args.path} (it's a directory)`);
       }
       const raw = await fs.readFile(abs);
@@ -3936,13 +4063,13 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
           if (nameFilter && !e.name.toLowerCase().includes(nameFilter)) continue;
           if (isLikelyBinaryByName(e.name)) continue;
           const full = pathMod.join(dir, e.name);
-          let stat;
+          let stat2;
           try {
-            stat = await fs.stat(full);
+            stat2 = await fs.stat(full);
           } catch {
             continue;
           }
-          if (stat.size > 2 * 1024 * 1024) continue;
+          if (stat2.size > 2 * 1024 * 1024) continue;
           let raw;
           try {
             raw = await fs.readFile(full);
@@ -4923,6 +5050,8 @@ var JobRegistry = class {
     };
     this.jobs.set(id, job);
     let readyMatched = false;
+    let recentForReady = "";
+    const READY_WINDOW = 1024;
     const onData = (chunk) => {
       const s = chunk.toString();
       job.totalBytesWritten += s.length;
@@ -4935,8 +5064,9 @@ var JobRegistry = class {
 ${job.output.slice(start)}`;
       }
       if (!readyMatched) {
+        recentForReady = (recentForReady + s).slice(-READY_WINDOW);
         for (const re of READY_SIGNALS) {
-          if (re.test(s) || re.test(job.output)) {
+          if (re.test(recentForReady)) {
             readyMatched = true;
             job.signalReady();
             break;
@@ -5620,6 +5750,7 @@ ${r.output}` : header2;
 var DEFAULT_FETCH_MAX_CHARS = 32e3;
 var DEFAULT_FETCH_TIMEOUT_MS = 15e3;
 var DEFAULT_TOPK = 5;
+var FETCH_MAX_BYTES = 10 * 1024 * 1024;
 var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
 var MOJEEK_ENDPOINT = "https://www.mojeek.com/search";
 async function webSearch(query, opts = {}) {
@@ -5699,7 +5830,13 @@ async function webFetch(url, opts = {}) {
   }
   if (!resp.ok) throw new Error(`web_fetch ${resp.status} for ${url}`);
   const contentType = resp.headers.get("content-type") ?? "";
-  const raw = await resp.text();
+  const declaredLen = Number(resp.headers.get("content-length") ?? "");
+  if (Number.isFinite(declaredLen) && declaredLen > FETCH_MAX_BYTES) {
+    throw new Error(
+      `web_fetch refused: content-length ${declaredLen} bytes exceeds ${FETCH_MAX_BYTES}-byte cap (${url})`
+    );
+  }
+  const raw = await readBodyCapped(resp, FETCH_MAX_BYTES);
   const title = extractTitle(raw);
   const text = contentType.includes("text/html") ? htmlToText(raw) : raw;
   const truncated = text.length > maxChars;
@@ -5708,6 +5845,37 @@ async function webFetch(url, opts = {}) {
 [\u2026 truncated ${text.length - maxChars} chars \u2026]` : text;
   return { url, title, text: finalText, truncated };
 }
+async function readBodyCapped(resp, maxBytes) {
+  if (!resp.body) return await resp.text();
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let total = 0;
+  let out = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        throw new Error(
+          `web_fetch refused: response body exceeded ${maxBytes}-byte cap (${total} bytes seen)`
+        );
+      }
+      out += decoder.decode(value, { stream: true });
+    }
+    out += decoder.decode();
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  return out;
+}
 function htmlToText(html) {
   let s = html;
   s = s.replace(/<script[\s\S]*?<\/script>/gi, "");
@@ -6352,6 +6520,107 @@ function truncate(s, n) {
   return s.length > n ? `${s.slice(0, n)}\u2026` : s;
 }
 
+// src/version.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
+var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var LATEST_FETCH_TIMEOUT_MS = 2e3;
+function readPackageVersion() {
+  try {
+    let dir = dirname5(fileURLToPath2(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const p = join7(dir, "package.json");
+      if (existsSync6(p)) {
+        const pkg = JSON.parse(readFileSync8(p, "utf8"));
+        if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      }
+      const parent = dirname5(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return "0.0.0-dev";
+}
+var VERSION = readPackageVersion();
+function cachePath(homeDirOverride) {
+  return join7(homeDirOverride ?? homedir4(), ".reasonix", "version-cache.json");
+}
+function readCache(homeDirOverride) {
+  try {
+    const raw = readFileSync8(cachePath(homeDirOverride), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCache(entry, homeDirOverride) {
+  try {
+    const p = cachePath(homeDirOverride);
+    mkdirSync3(dirname5(p), { recursive: true });
+    writeFileSync3(p, JSON.stringify(entry), "utf8");
+  } catch {
+  }
+}
+async function getLatestVersion(opts = {}) {
+  const ttl = opts.ttlMs ?? LATEST_CACHE_TTL_MS;
+  if (!opts.force) {
+    const cached2 = readCache(opts.homeDir);
+    if (cached2 && Date.now() - cached2.checkedAt < ttl) return cached2.version;
+  }
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) return null;
+  const url = opts.registryUrl ?? REGISTRY_URL;
+  const timeout = opts.timeoutMs ?? LATEST_FETCH_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetchImpl(url, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (typeof body.version !== "string") return null;
+    writeCache({ version: body.version, checkedAt: Date.now() }, opts.homeDir);
+    return body.version;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function compareVersions(a, b) {
+  const [aCore = "0", aPre = ""] = a.split("-", 2);
+  const [bCore = "0", bPre = ""] = b.split("-", 2);
+  const aParts = aCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
+  const bParts = bCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const diff = (aParts[i] ?? 0) - (bParts[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  if (!aPre && !bPre) return 0;
+  if (!aPre) return 1;
+  if (!bPre) return -1;
+  return aPre < bPre ? -1 : aPre > bPre ? 1 : 0;
+}
+function isNpxInstall() {
+  const bin = process.argv[1] ?? "";
+  if (/[/\\]_npx[/\\]/.test(bin)) return true;
+  if (/[/\\]\.pnpm[/\\]/.test(bin) && /dlx/i.test(bin)) return true;
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.includes("npx/")) return true;
+  return false;
+}
+
 // src/mcp/types.ts
 var MCP_PROTOCOL_VERSION = "2024-11-05";
 function isJsonRpcError(msg) {
@@ -6380,7 +6649,7 @@ var McpClient = class {
   nextProgressToken = 1;
   constructor(opts) {
     this.transport = opts.transport;
-    this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: "0.3.0-dev" };
+    this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: VERSION };
     this.requestTimeoutMs = opts.requestTimeoutMs ?? 6e4;
   }
   /** Server's advertised capabilities, available after initialize(). */
@@ -7120,8 +7389,8 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname5, resolve as resolve6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, resolve as resolve6 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -7149,7 +7418,7 @@ function applyEditBlock(block, rootDir) {
     };
   }
   const searchEmpty = block.search.length === 0;
-  const exists = existsSync6(absTarget);
+  const exists = existsSync7(absTarget);
   try {
     if (!exists) {
       if (!searchEmpty) {
@@ -7159,11 +7428,11 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync3(dirname5(absTarget), { recursive: true });
-      writeFileSync3(absTarget, block.replace, "utf8");
+      mkdirSync4(dirname6(absTarget), { recursive: true });
+      writeFileSync4(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync8(absTarget, "utf8");
+    const content = readFileSync9(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -7180,7 +7449,7 @@ function applyEditBlock(block, rootDir) {
       };
     }
     const replaced = `${content.slice(0, idx)}${block.replace}${content.slice(idx + block.search.length)}`;
-    writeFileSync3(absTarget, replaced, "utf8");
+    writeFileSync4(absTarget, replaced, "utf8");
     return { path: block.path, status: "applied" };
   } catch (err) {
     return { path: block.path, status: "error", message: err.message };
@@ -7192,9 +7461,9 @@ function applyEditBlocks(blocks, rootDir) {
 function toWholeFileEditBlock(path5, content, rootDir) {
   const abs = resolve6(rootDir, path5);
   let search = "";
-  if (existsSync6(abs)) {
+  if (existsSync7(abs)) {
     try {
-      search = readFileSync8(abs, "utf8");
+      search = readFileSync9(abs, "utf8");
     } catch {
       search = "";
     }
@@ -7209,12 +7478,12 @@ function snapshotBeforeEdits(blocks, rootDir) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
     const abs = resolve6(absRoot, b.path);
-    if (!existsSync6(abs)) {
+    if (!existsSync7(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync8(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync9(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -7234,14 +7503,14 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync6(abs)) unlinkSync2(abs);
+        if (existsSync7(abs)) unlinkSync2(abs);
         return {
           path: snap.path,
           status: "applied",
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync3(abs, snap.prevContent, "utf8");
+      writeFileSync4(abs, snap.prevContent, "utf8");
       return {
         path: snap.path,
         status: "applied",
@@ -7256,114 +7525,54 @@ function sep() {
   return process.platform === "win32" ? "\\" : "/";
 }
 
-// src/version.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname6, join as join7 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
-var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var LATEST_FETCH_TIMEOUT_MS = 2e3;
-function readPackageVersion() {
-  try {
-    let dir = dirname6(fileURLToPath2(import.meta.url));
-    for (let i = 0; i < 6; i++) {
-      const p = join7(dir, "package.json");
-      if (existsSync7(p)) {
-        const pkg = JSON.parse(readFileSync9(p, "utf8"));
-        if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
-          return pkg.version;
-        }
-      }
-      const parent = dirname6(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  } catch {
-  }
-  return "0.0.0-dev";
-}
-var VERSION = readPackageVersion();
-function cachePath(homeDirOverride) {
-  return join7(homeDirOverride ?? homedir4(), ".reasonix", "version-cache.json");
+// src/usage.ts
+import {
+  appendFileSync as appendFileSync2,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync10,
+  statSync as statSync4,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname7, join as join8 } from "path";
+function defaultUsageLogPath(homeDirOverride) {
+  return join8(homeDirOverride ?? homedir5(), ".reasonix", "usage.jsonl");
 }
-function readCache(homeDirOverride) {
+var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
+var USAGE_RETENTION_DAYS = 365;
+function compactUsageLogIfLarge(path5, now) {
+  let size;
   try {
-    const raw = readFileSync9(cachePath(homeDirOverride), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
-      return parsed;
-    }
+    size = statSync4(path5).size;
   } catch {
+    return;
   }
-  return null;
-}
-function writeCache(entry, homeDirOverride) {
+  if (size < USAGE_COMPACTION_THRESHOLD_BYTES) return;
+  const cutoff = now - USAGE_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+  let raw;
   try {
-    const p = cachePath(homeDirOverride);
-    mkdirSync4(dirname6(p), { recursive: true });
-    writeFileSync4(p, JSON.stringify(entry), "utf8");
+    raw = readFileSync10(path5, "utf8");
   } catch {
+    return;
   }
-}
-async function getLatestVersion(opts = {}) {
-  const ttl = opts.ttlMs ?? LATEST_CACHE_TTL_MS;
-  if (!opts.force) {
-    const cached2 = readCache(opts.homeDir);
-    if (cached2 && Date.now() - cached2.checkedAt < ttl) return cached2.version;
+  const lines = raw.split(/\r?\n/);
+  const kept = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const rec = JSON.parse(line);
+      if (isValidRecord(rec) && rec.ts >= cutoff) kept.push(line);
+    } catch {
+    }
   }
-  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
-  if (!fetchImpl) return null;
-  const url = opts.registryUrl ?? REGISTRY_URL;
-  const timeout = opts.timeoutMs ?? LATEST_FETCH_TIMEOUT_MS;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeout);
+  if (kept.length === lines.filter((l) => l.trim()).length) return;
   try {
-    const res = await fetchImpl(url, {
-      signal: controller.signal,
-      headers: { accept: "application/json" }
-    });
-    if (!res.ok) return null;
-    const body = await res.json();
-    if (typeof body.version !== "string") return null;
-    writeCache({ version: body.version, checkedAt: Date.now() }, opts.homeDir);
-    return body.version;
+    writeFileSync5(path5, kept.length > 0 ? `${kept.join("\n")}
+` : "", "utf8");
   } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
   }
 }
-function compareVersions(a, b) {
-  const [aCore = "0", aPre = ""] = a.split("-", 2);
-  const [bCore = "0", bPre = ""] = b.split("-", 2);
-  const aParts = aCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
-  const bParts = bCore.split(".").map((p) => Number.parseInt(p, 10) || 0);
-  for (let i = 0; i < 3; i++) {
-    const diff = (aParts[i] ?? 0) - (bParts[i] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  if (!aPre && !bPre) return 0;
-  if (!aPre) return 1;
-  if (!bPre) return -1;
-  return aPre < bPre ? -1 : aPre > bPre ? 1 : 0;
-}
-function isNpxInstall() {
-  const bin = process.argv[1] ?? "";
-  if (/[/\\]_npx[/\\]/.test(bin)) return true;
-  if (/[/\\]\.pnpm[/\\]/.test(bin) && /dlx/i.test(bin)) return true;
-  const ua = process.env.npm_config_user_agent ?? "";
-  if (ua.includes("npx/")) return true;
-  return false;
-}
-
-// src/usage.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname7, join as join8 } from "path";
-function defaultUsageLogPath(homeDirOverride) {
-  return join8(homeDirOverride ?? homedir5(), ".reasonix", "usage.jsonl");
-}
 function appendUsage(input) {
   const record = {
     ts: input.now ?? Date.now(),
@@ -7383,6 +7592,7 @@ function appendUsage(input) {
     mkdirSync5(dirname7(path5), { recursive: true });
     appendFileSync2(path5, `${JSON.stringify(record)}
 `, "utf8");
+    compactUsageLogIfLarge(path5, record.ts);
   } catch {
   }
   return record;
@@ -7521,7 +7731,7 @@ import { Box as Box22, Static, Text as Text20, useStdout as useStdout8 } from "i
 import React24, { useCallback as useCallback4, useEffect as useEffect6, useMemo as useMemo3, useRef as useRef6, useState as useState10 } from "react";
 
 // src/code/pending-edits.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname8, join as join9 } from "path";
 function pendingEditsPath(sessionName) {
   return join9(sessionsDir(), `${sanitizeName(sessionName)}.pending.json`);
@@ -7535,7 +7745,7 @@ function savePendingEdits(sessionName, blocks) {
       return;
     }
     mkdirSync6(dirname8(path5), { recursive: true });
-    writeFileSync5(path5, JSON.stringify(blocks, null, 2), "utf8");
+    writeFileSync6(path5, JSON.stringify(blocks, null, 2), "utf8");
   } catch {
   }
 }
@@ -7581,7 +7791,7 @@ import {
   renameSync,
   statSync as statSync5,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { dirname as dirname9, join as join10 } from "path";
 function planStatePath(sessionName) {
@@ -7638,7 +7848,7 @@ function savePlanState(sessionName, steps, completedStepIds, extras) {
     };
     if (extras?.body) state.body = extras.body;
     if (extras?.summary) state.summary = extras.summary;
-    writeFileSync6(path5, `${JSON.stringify(state, null, 2)}
+    writeFileSync7(path5, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   } catch (err) {
     process.stderr.write(
@@ -7906,7 +8116,7 @@ import {
   readFileSync as readFileSync14,
   readSync,
   statSync as statSync6,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
 import { dirname as dirname11, isAbsolute as isAbsolute4, resolve as resolve7, sep as sep2 } from "path";
 var MAX_BYTES = 4 * 1024 * 1024;
@@ -7986,14 +8196,14 @@ async function handleFile(method, rest, body, ctx) {
     if (!existsSync11(target)) {
       return { status: 404, body: { error: "file not found" } };
     }
-    const stat = statSync6(target);
-    if (stat.isDirectory()) {
+    const stat2 = statSync6(target);
+    if (stat2.isDirectory()) {
       return { status: 400, body: { error: "path is a directory" } };
     }
-    if (stat.size > MAX_BYTES) {
+    if (stat2.size > MAX_BYTES) {
       return {
         status: 413,
-        body: { error: `file too large (${stat.size} bytes; cap ${MAX_BYTES})` }
+        body: { error: `file too large (${stat2.size} bytes; cap ${MAX_BYTES})` }
       };
     }
     if (looksBinary(target)) {
@@ -8008,8 +8218,8 @@ async function handleFile(method, rest, body, ctx) {
       body: {
         path: requested,
         absolute: target,
-        size: stat.size,
-        mtime: stat.mtime.getTime(),
+        size: stat2.size,
+        mtime: stat2.mtime.getTime(),
         content
       }
     };
@@ -8029,20 +8239,20 @@ async function handleFile(method, rest, body, ctx) {
     if (!existsSync11(parent)) {
       mkdirSync8(parent, { recursive: true });
     }
-    writeFileSync7(target, content, "utf8");
+    writeFileSync8(target, content, "utf8");
     ctx.audit?.({
       ts: Date.now(),
       action: "save-file",
       payload: { path: requested, bytes: Buffer.byteLength(content, "utf8") }
     });
-    const stat = statSync6(target);
+    const stat2 = statSync6(target);
     return {
       status: 200,
       body: {
         saved: true,
         path: requested,
-        size: stat.size,
-        mtime: stat.mtime.getTime()
+        size: stat2.size,
+        mtime: stat2.mtime.getTime()
       }
     };
   }
@@ -8139,7 +8349,7 @@ async function handleHealth(method, _rest, _body, ctx) {
 }
 
 // src/server/api/hooks.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname12 } from "path";
 function parseBody3(raw) {
   if (!raw) return {};
@@ -8164,7 +8374,7 @@ function writeSettingsFile(path5, hooksBlock) {
   const existing = readSettingsFile2(path5);
   existing.hooks = hooksBlock;
   mkdirSync9(dirname12(path5), { recursive: true });
-  writeFileSync8(path5, `${JSON.stringify(existing, null, 2)}
+  writeFileSync9(path5, `${JSON.stringify(existing, null, 2)}
 `, "utf8");
 }
 async function handleHooks(method, rest, body, ctx) {
@@ -8345,7 +8555,7 @@ import {
   readdirSync as readdirSync5,
   statSync as statSync8,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir7 } from "os";
 import { dirname as dirname13, join as join13, resolve as resolvePath } from "path";
@@ -8372,11 +8582,11 @@ function listMemoryFiles(dir) {
   if (!existsSync14(dir)) return [];
   try {
     return readdirSync5(dir).filter((f) => f.endsWith(".md")).map((f) => {
-      const stat = statSync8(join13(dir, f));
+      const stat2 = statSync8(join13(dir, f));
       return {
         name: f.replace(/\.md$/, ""),
-        size: stat.size,
-        mtime: stat.mtime.getTime()
+        size: stat2.size,
+        mtime: stat2.mtime.getTime()
       };
     }).sort((a, b) => b.mtime - a.mtime);
   } catch {
@@ -8436,7 +8646,7 @@ async function handleMemory(method, rest, body, ctx) {
       if (!cwd2) return { status: 503, body: { error: "no active project" } };
       const path5 = join13(cwd2, PROJECT_MEMORY_FILE);
       mkdirSync10(dirname13(path5), { recursive: true });
-      writeFileSync9(path5, contents, "utf8");
+      writeFileSync10(path5, contents, "utf8");
       ctx.audit?.({ ts: Date.now(), action: "save-memory", payload: { scope, path: path5 } });
       return { status: 200, body: { saved: true, path: path5 } };
     }
@@ -8445,7 +8655,7 @@ async function handleMemory(method, rest, body, ctx) {
       if (!dir) return { status: 503, body: { error: "no project root for project-mem" } };
       mkdirSync10(dir, { recursive: true });
       const path5 = join13(dir, `${name}.md`);
-      writeFileSync9(path5, contents, "utf8");
+      writeFileSync10(path5, contents, "utf8");
       ctx.audit?.({ ts: Date.now(), action: "save-memory", payload: { scope, name, path: path5 } });
       return { status: 200, body: { saved: true, path: path5 } };
     }
@@ -8783,13 +8993,13 @@ async function* walkChunks(root, opts = {}) {
       const ext = path.extname(name).toLowerCase();
       if (BINARY_EXTS.has(ext)) continue;
       const abs = path.join(dir, name);
-      let stat;
+      let stat2;
       try {
-        stat = await fs2.stat(abs);
+        stat2 = await fs2.stat(abs);
       } catch {
         continue;
       }
-      if (stat.size > maxFileBytes) continue;
+      if (stat2.size > maxFileBytes) continue;
       let text;
       try {
         text = await fs2.readFile(abs, "utf8");
@@ -9165,8 +9375,8 @@ async function buildIndex(root, opts = {}) {
       const abs = path3.join(root, chunk.path);
       let mtimeMs = 0;
       try {
-        const stat = await fs4.stat(abs);
-        mtimeMs = stat.mtimeMs;
+        const stat2 = await fs4.stat(abs);
+        mtimeMs = stat2.mtimeMs;
       } catch {
         continue;
       }
@@ -9969,7 +10179,7 @@ import {
   readdirSync as readdirSync6,
   rmSync,
   statSync as statSync9,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname14, join as join14 } from "path";
@@ -10008,14 +10218,14 @@ function listSkills(dir, scope) {
       const skillPath = join14(dir, entry, SKILL_FILE);
       if (!existsSync16(skillPath)) continue;
       try {
-        const stat = statSync9(skillPath);
+        const stat2 = statSync9(skillPath);
         const raw = readFileSync18(skillPath, "utf8");
         const item = {
           name: entry,
           scope,
           path: skillPath,
-          size: stat.size,
-          mtime: stat.mtime.getTime()
+          size: stat2.size,
+          mtime: stat2.mtime.getTime()
         };
         const desc = parseFrontmatterDescription(raw);
         if (desc) item.description = desc;
@@ -10084,7 +10294,7 @@ async function handleSkills(method, rest, body, ctx) {
       return { status: 400, body: { error: "body (string) required" } };
     }
     mkdirSync11(dirname14(skillPath), { recursive: true });
-    writeFileSync10(skillPath, contents, "utf8");
+    writeFileSync11(skillPath, contents, "utf8");
     ctx.audit?.({
       ts: Date.now(),
       action: "save-skill",
@@ -11640,26 +11850,26 @@ function validateCitation(url, projectRoot) {
     ...siblings.map((ext) => baseFullPath.replace(/\.[^./\\]+$/, ext))
   ];
   let fullPath = baseFullPath;
-  let stat = null;
+  let stat2 = null;
   for (const candidate of candidates) {
     try {
-      stat = statSync11(candidate);
+      stat2 = statSync11(candidate);
       fullPath = candidate;
       break;
     } catch {
     }
   }
-  if (!stat) return { ok: false, reason: "file not found" };
-  if (!stat.isFile()) return { ok: false, reason: "not a file" };
+  if (!stat2) return { ok: false, reason: "file not found" };
+  if (!stat2.isFile()) return { ok: false, reason: "not a file" };
   if (parts.startLine === void 0) return { ok: true };
-  let lineCount = getCachedLineCount(fullPath, stat.mtimeMs);
+  let lineCount = getCachedLineCount(fullPath, stat2.mtimeMs);
   if (lineCount === null) {
     try {
       lineCount = readFileSync19(fullPath, "utf8").split("\n").length;
     } catch {
       return { ok: false, reason: "unreadable" };
     }
-    setCachedLineCount(fullPath, stat.mtimeMs, lineCount);
+    setCachedLineCount(fullPath, stat2.mtimeMs, lineCount);
   }
   if (parts.startLine < 1 || parts.startLine > lineCount) {
     return { ok: false, reason: `line ${parts.startLine} > ${lineCount}` };
@@ -12454,7 +12664,7 @@ var EventRow = React11.memo(function EventRow2({
       event.branch ? /* @__PURE__ */ React11.createElement(BranchBlock, { branch: event.branch }) : null,
       event.reasoning ? /* @__PURE__ */ React11.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null,
       !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React11.createElement(PlanStateBlock, { planState: event.planState }) : null,
-      event.text ? /* @__PURE__ */ React11.createElement(Markdown, { text: event.text, projectRoot }) : /* @__PURE__ */ React11.createElement(Text8, { dimColor: true }, "(no content)"),
+      event.text ? /* @__PURE__ */ React11.createElement(Markdown, { text: event.text, projectRoot }) : /* @__PURE__ */ React11.createElement(Text8, { dimColor: true }, "(empty body \u2014 likely tool-call only)"),
       event.stats ? /* @__PURE__ */ React11.createElement(StatsLine, { stats: event.stats }) : null,
       event.repair ? /* @__PURE__ */ React11.createElement(Text8, { color: COLOR.accent }, event.repair) : null
     ));
@@ -14195,7 +14405,7 @@ function describeRepair(repair) {
 }
 
 // src/cli/ui/hash-memory.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir9 } from "os";
 import { dirname as dirname15, join as join17 } from "path";
 var PROJECT_HEADER = `# Reasonix project memory
@@ -14246,7 +14456,7 @@ function appendBulletToFile(path5, note, newFileHeader) {
 `;
   if (!existsSync18(path5)) {
     mkdirSync12(dirname15(path5), { recursive: true });
-    writeFileSync11(path5, `${newFileHeader}${bullet}`, "utf8");
+    writeFileSync12(path5, `${newFileHeader}${bullet}`, "utf8");
     return { path: path5, created: true };
   }
   let prefix = "";
@@ -14692,6 +14902,11 @@ var SLASH_COMMANDS = [
   },
   { cmd: "sessions", summary: "list saved sessions (current marked with \u25B8)" },
   { cmd: "forget", summary: "delete the current session from disk" },
+  {
+    cmd: "prune-sessions",
+    summary: "delete sessions idle \u2265N days (default 90) \u2014 frees disk on long-time installs",
+    argsHint: "[days]"
+  },
   { cmd: "setup", summary: "reminds you to exit and run `reasonix setup`" },
   {
     cmd: "semantic",
@@ -16661,9 +16876,9 @@ async function indexFileExists(rootDir) {
 async function readIndexMeta(rootDir) {
   const dataPath = path4.join(rootDir, ".reasonix", "semantic", "index.jsonl");
   try {
-    const stat = await fs5.stat(dataPath);
-    if (stat.size > 10 * 1024 * 1024) {
-      return { chunks: Math.round(stat.size / 500), files: 0 };
+    const stat2 = await fs5.stat(dataPath);
+    if (stat2.size > 10 * 1024 * 1024) {
+      return { chunks: Math.round(stat2.size / 500), files: 0 };
     }
     const raw = await fs5.readFile(dataPath, "utf8");
     const seenPaths = /* @__PURE__ */ new Set();
@@ -16687,6 +16902,7 @@ var handlers13 = {
 };
 
 // src/cli/ui/slash/handlers/sessions.ts
+var STALE_THRESHOLD_DAYS = 90;
 var sessions = (_args, loop2) => {
   const items = listSessions();
   if (items.length === 0) {
@@ -16694,17 +16910,28 @@ var sessions = (_args, loop2) => {
       info: "no saved sessions yet \u2014 chat normally and your messages will be saved automatically"
     };
   }
+  const now = Date.now();
   const lines = ["Saved sessions:"];
+  let staleCount = 0;
   for (const s of items) {
     const sizeKb = (s.size / 1024).toFixed(1);
     const when = s.mtime.toISOString().replace("T", " ").slice(0, 16);
     const marker = s.name === loop2.sessionName ? "\u25B8" : " ";
+    const ageDays = Math.floor((now - s.mtime.getTime()) / (24 * 60 * 60 * 1e3));
+    const isStale = ageDays >= STALE_THRESHOLD_DAYS;
+    const ageTag = isStale ? `  (${ageDays}d \u2014 stale)` : "";
+    if (isStale) staleCount++;
     lines.push(
-      `  ${marker} ${s.name.padEnd(22)} ${String(s.messageCount).padStart(5)} msgs  ${sizeKb.padStart(7)} KB  ${when}`
+      `  ${marker} ${s.name.padEnd(22)} ${String(s.messageCount).padStart(5)} msgs  ${sizeKb.padStart(7)} KB  ${when}${ageTag}`
     );
   }
   lines.push("");
   lines.push("Resume with: reasonix chat --session <name>");
+  if (staleCount > 0) {
+    lines.push(
+      `${staleCount} session${staleCount === 1 ? "" : "s"} idle \u2265${STALE_THRESHOLD_DAYS} days \u2014 /prune-sessions to remove`
+    );
+  }
   return { info: lines.join("\n") };
 };
 var forget = (_args, loop2) => {
@@ -16717,9 +16944,26 @@ var forget = (_args, loop2) => {
     info: ok ? `\u25B8 deleted session "${name}" \u2014 current screen still shows the conversation, but next launch starts fresh` : `could not delete session "${name}" (already gone?)`
   };
 };
+var pruneSessions = (args) => {
+  const raw = args?.[0];
+  const days = raw ? Number.parseInt(raw, 10) : STALE_THRESHOLD_DAYS;
+  if (!Number.isFinite(days) || days < 1) {
+    return {
+      info: `\u25B8 usage: /prune-sessions [days]   \u2014 defaults to ${STALE_THRESHOLD_DAYS}, must be \u22651`
+    };
+  }
+  const removed = pruneStaleSessions(days);
+  if (removed.length === 0) {
+    return { info: `\u25B8 nothing to prune \u2014 no sessions idle \u2265${days} days` };
+  }
+  return {
+    info: `\u25B8 pruned ${removed.length} session${removed.length === 1 ? "" : "s"} idle \u2265${days} days: ${removed.join(", ")}`
+  };
+};
 var handlers14 = {
   sessions,
-  forget
+  forget,
+  "prune-sessions": pruneSessions
 };
 
 // src/cli/ui/slash/handlers/skill.ts
@@ -16845,13 +17089,21 @@ function useCompletionPickers({
     });
   }, [slashMatches]);
   const [atSelected, setAtSelected] = useState6(0);
-  const atFiles = useMemo2(() => {
-    if (!codeMode) return [];
-    try {
-      return listFilesWithStatsSync(rootDir, { maxResults: 500 });
-    } catch {
-      return [];
+  const [atFiles, setAtFiles] = useState6([]);
+  useEffect3(() => {
+    if (!codeMode) {
+      setAtFiles([]);
+      return;
     }
+    let cancelled = false;
+    listFilesWithStatsAsync(rootDir, { maxResults: 500 }).then((files) => {
+      if (!cancelled) setAtFiles(files);
+    }).catch(() => {
+      if (!cancelled) setAtFiles([]);
+    });
+    return () => {
+      cancelled = true;
+    };
   }, [codeMode, rootDir]);
   const recentFilesRef = useRef3([]);
   const recordRecentFile = useCallback((p) => {
@@ -20237,7 +20489,7 @@ async function codeCommand(opts = {}) {
 }
 
 // src/cli/commands/diff.ts
-import { writeFileSync as writeFileSync12 } from "fs";
+import { writeFileSync as writeFileSync13 } from "fs";
 import { basename as basename3 } from "path";
 import { render as render2 } from "ink";
 import React30 from "react";
@@ -20384,7 +20636,7 @@ async function diffCommand(opts) {
   if (wantMarkdown) {
     console.log(renderSummaryTable(report));
     const md = renderMarkdown(report);
-    writeFileSync12(opts.mdPath, md, "utf8");
+    writeFileSync13(opts.mdPath, md, "utf8");
     console.log(`
 markdown report written to ${opts.mdPath}`);
     return;