reasonix 0.12.16 → 0.12.20

package/dist/index.js

@@ -532,6 +532,7 @@ function matchesTool(hook, toolName) {
     return false;
   }
 }
+var HOOK_OUTPUT_CAP_BYTES = 256 * 1024;
 function defaultSpawner(input) {
   return new Promise((resolve9) => {
     const child = spawn(input.command, {
@@ -539,8 +540,11 @@ function defaultSpawner(input) {
       shell: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    let stdout = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let truncated = false;
     let timedOut = false;
     const timer = setTimeout(() => {
       timedOut = true;
@@ -552,29 +556,46 @@ function defaultSpawner(input) {
         }
       }, 500);
     }, input.timeoutMs);
-    child.stdout.on("data", (chunk) => {
-      stdout += 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);
       resolve9({
         exitCode: null,
-        stdout,
-        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);
       resolve9({
         exitCode: code,
-        stdout: stdout.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 {
@@ -589,7 +610,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) {
@@ -620,7 +642,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;
@@ -1168,6 +1191,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 ?? []];
@@ -1193,9 +1233,33 @@ var ImmutablePrefix = class {
     if (!name) return false;
     if (this._toolSpecs.some((t) => t.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,
@@ -1614,10 +1678,10 @@ function listSessions() {
     const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
     return files.map((file) => {
       const path = join3(dir, file);
-      const stat = statSync(path);
+      const stat2 = statSync(path);
       const name = file.replace(/\.jsonl$/, "");
       const messageCount = countLines(path);
-      return { name, path, size: stat.size, messageCount, mtime: stat.mtime };
+      return { name, path, size: stat2.size, messageCount, mtime: stat2.mtime };
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
   } catch {
     return [];
@@ -1791,6 +1855,19 @@ var CacheFirstLoop = class {
    * flip it live alongside `model`.
    */
   autoEscalate = true;
+  /**
+   * Soft USD budget — see {@link CacheFirstLoopOptions.budgetUsd}.
+   * Mutable so `/budget` slash can set / change / clear it mid-session.
+   * `null` (the default) disables all budget checks.
+   */
+  budgetUsd;
+  /**
+   * Set the first time a turn crosses 80% of the budget so the warning
+   * doesn't repeat every turn afterwards. Cleared by `setBudget` (any
+   * change re-arms the warning, including raising the cap above the
+   * current spend).
+   */
+  _budgetWarned = false;
   sessionName;
   /**
    * Hook list, mutable so `/hooks reload` can swap it without
@@ -1856,6 +1933,7 @@ var CacheFirstLoop = class {
     this.model = opts.model ?? "deepseek-v4-flash";
     this.reasoningEffort = opts.reasoningEffort ?? "max";
     if (opts.autoEscalate !== void 0) this.autoEscalate = opts.autoEscalate;
+    this.budgetUsd = typeof opts.budgetUsd === "number" && opts.budgetUsd > 0 ? opts.budgetUsd : null;
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
@@ -2095,6 +2173,16 @@ var CacheFirstLoop = class {
     }
     this.stream = this.branchEnabled ? false : this._streamPreference;
   }
+  /**
+   * Set / change / clear the soft USD budget. `null` (or any non-
+   * positive number) disables the cap entirely. Re-arms the 80%
+   * warning so a user who bumps the cap mid-session sees a fresh
+   * threshold message at the new boundary.
+   */
+  setBudget(usd) {
+    this.budgetUsd = typeof usd === "number" && usd > 0 ? usd : null;
+    this._budgetWarned = false;
+  }
   /**
    * Arm pro for the next turn (consumed at turn start). Called by
    * `/pro`. Idempotent — repeated calls stay armed, `disarmPro()`
@@ -2256,6 +2344,26 @@ var CacheFirstLoop = class {
     return userText;
   }
   async *step(userInput) {
+    if (this.budgetUsd !== null) {
+      const spent = this.stats.totalCost;
+      if (spent >= this.budgetUsd) {
+        yield {
+          turn: this._turn,
+          role: "error",
+          content: "",
+          error: `session budget exhausted \u2014 spent $${spent.toFixed(4)} \u2265 cap $${this.budgetUsd.toFixed(2)}. Bump the cap with /budget <usd>, clear it with /budget off, or end the session.`
+        };
+        return;
+      }
+      if (!this._budgetWarned && spent >= this.budgetUsd * 0.8) {
+        this._budgetWarned = true;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `\u25B2 budget 80% used \u2014 $${spent.toFixed(4)} of $${this.budgetUsd.toFixed(2)}. Next turn or two likely trips the cap.`
+        };
+      }
+    }
     this._turn++;
     this.scratch.reset();
     this.repair.resetStorm();
@@ -3118,6 +3226,7 @@ function extractDeepSeekErrorMessage(body) {
 
 // src/at-mentions.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { readdir, stat } from "fs/promises";
 import { isAbsolute, join as join4, relative, resolve } from "path";
 var DEFAULT_AT_MENTION_MAX_BYTES = 64 * 1024;
 var DEFAULT_PICKER_IGNORE_DIRS = [
@@ -3172,6 +3281,58 @@ function listFilesWithStatsSync(root, opts = {}) {
   walk2(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 walk2 = 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 walk2(join4(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 walk2(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 stats = await Promise.all(
+    batch.map(
+      (e) => stat(join4(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: stats[i] ?? 0
+    });
+  }
+}
 var AT_PICKER_PREFIX = /(?:^|\s)@([a-zA-Z0-9_./\\-]*)$/;
 function detectAtPicker(input) {
   const m = AT_PICKER_PREFIX.exec(input);
@@ -4180,8 +4341,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);
@@ -4450,13 +4611,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);
@@ -5491,6 +5652,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;
@@ -5503,8 +5666,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;
@@ -6188,6 +6352,7 @@ ${r.output}` : header;
 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 = {}) {
@@ -6267,7 +6432,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;
@@ -6276,6 +6447,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, "");
@@ -6889,6 +7091,107 @@ function truncate(s, n) {
   return s.length > n ? `${s.slice(0, n)}\u2026` : s;
 }
 
+// src/version.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname4, join as join9 } 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 = dirname4(fileURLToPath2(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const p = join9(dir, "package.json");
+      if (existsSync9(p)) {
+        const pkg = JSON.parse(readFileSync10(p, "utf8"));
+        if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      }
+      const parent = dirname4(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return "0.0.0-dev";
+}
+var VERSION = readPackageVersion();
+function cachePath(homeDirOverride) {
+  return join9(homeDirOverride ?? homedir5(), ".reasonix", "version-cache.json");
+}
+function readCache(homeDirOverride) {
+  try {
+    const raw = readFileSync10(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(dirname4(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) {
@@ -6917,7 +7220,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(). */
@@ -7657,8 +7960,8 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, resolve as resolve8 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, resolve as resolve8 } 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 = [];
@@ -7686,7 +7989,7 @@ function applyEditBlock(block, rootDir) {
     };
   }
   const searchEmpty = block.search.length === 0;
-  const exists = existsSync9(absTarget);
+  const exists = existsSync10(absTarget);
   try {
     if (!exists) {
       if (!searchEmpty) {
@@ -7696,11 +7999,11 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync3(dirname4(absTarget), { recursive: true });
-      writeFileSync3(absTarget, block.replace, "utf8");
+      mkdirSync4(dirname5(absTarget), { recursive: true });
+      writeFileSync4(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync10(absTarget, "utf8");
+    const content = readFileSync11(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -7717,7 +8020,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 };
@@ -7734,12 +8037,12 @@ function snapshotBeforeEdits(blocks, rootDir) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
     const abs = resolve8(absRoot, b.path);
-    if (!existsSync9(abs)) {
+    if (!existsSync10(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync10(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync11(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -7759,14 +8062,14 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync9(abs)) unlinkSync3(abs);
+        if (existsSync10(abs)) unlinkSync3(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",
@@ -7782,8 +8085,8 @@ function sep() {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
+import { join as join10 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, edit_file, list_directory, directory_tree, search_files, search_content, get_file_info) rooted at the user's working directory, plus run_command / run_background for shell.
 
 # Cite or shut up \u2014 non-negotiable
@@ -7989,11 +8292,11 @@ If \`semantic_search\` returns nothing useful (low scores, off-topic), THEN fall
 function codeSystemPrompt(rootDir, opts = {}) {
   const base = opts.hasSemanticSearch ? `${CODE_SYSTEM_PROMPT}${SEMANTIC_SEARCH_ROUTING}` : CODE_SYSTEM_PROMPT;
   const withMemory = applyMemoryStack(base, rootDir);
-  const gitignorePath = join9(rootDir, ".gitignore");
-  if (!existsSync10(gitignorePath)) return withMemory;
+  const gitignorePath = join10(rootDir, ".gitignore");
+  if (!existsSync11(gitignorePath)) return withMemory;
   let content;
   try {
-    content = readFileSync11(gitignorePath, "utf8");
+    content = readFileSync12(gitignorePath, "utf8");
   } catch {
     return withMemory;
   }
@@ -8013,15 +8316,15 @@ ${truncated}
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname5, join as join10 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname6, join as join11 } from "path";
 function defaultConfigPath() {
-  return join10(homedir5(), ".reasonix", "config.json");
+  return join11(homedir6(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync12(path, "utf8");
+    const raw = readFileSync13(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -8029,8 +8332,8 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync4(dirname5(path), { recursive: true });
-  writeFileSync4(path, JSON.stringify(cfg, null, 2), "utf8");
+  mkdirSync5(dirname6(path), { recursive: true });
+  writeFileSync5(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
   } catch {
@@ -8055,113 +8358,53 @@ function redactKey(key) {
   return `${key.slice(0, 6)}\u2026${key.slice(-4)}`;
 }
 
-// src/version.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname6, join as join11 } 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 = join11(dir, "package.json");
-      if (existsSync11(p)) {
-        const pkg = JSON.parse(readFileSync13(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 join11(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
+// src/usage.ts
+import {
+  appendFileSync as appendFileSync2,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync14,
+  statSync as statSync5,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname7, join as join12 } from "path";
+function defaultUsageLogPath(homeDirOverride) {
+  return join12(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
-function readCache(homeDirOverride) {
+var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
+var USAGE_RETENTION_DAYS = 365;
+function compactUsageLogIfLarge(path, now) {
+  let size;
   try {
-    const raw = readFileSync13(cachePath(homeDirOverride), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
-      return parsed;
-    }
+    size = statSync5(path).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);
-    mkdirSync5(dirname6(p), { recursive: true });
-    writeFileSync5(p, JSON.stringify(entry), "utf8");
+    raw = readFileSync14(path, "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;
+    writeFileSync6(path, 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 existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync14, statSync as statSync5 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname7, join as join12 } from "path";
-function defaultUsageLogPath(homeDirOverride) {
-  return join12(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
 function appendUsage(input) {
   const record = {
@@ -8182,6 +8425,7 @@ function appendUsage(input) {
     mkdirSync6(dirname7(path), { recursive: true });
     appendFileSync2(path, `${JSON.stringify(record)}
 `, "utf8");
+    compactUsageLogIfLarge(path, record.ts);
   } catch {
   }
   return record;
@@ -8401,6 +8645,7 @@ export {
   isPlanStateEmpty,
   isPlausibleKey,
   listFilesSync,
+  listFilesWithStatsAsync,
   listFilesWithStatsSync,
   listSessions,
   loadApiKey,