reasonix 0.21.0 → 0.23.0

package/dist/index.js

@@ -477,10 +477,10 @@ function globalSettingsPath(homeDirOverride) {
 function projectSettingsPath(projectRoot) {
   return join(projectRoot, HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
 }
-function readSettingsFile(path) {
-  if (!existsSync(path)) return null;
+function readSettingsFile(path2) {
+  if (!existsSync(path2)) return null;
   try {
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -890,14 +890,14 @@ function collect(prefix, schema, out, required, isRootRequired) {
   out[prefix] = schema;
   if (isRootRequired) required.push(prefix);
 }
-function setByPath(target, path, value) {
+function setByPath(target, path2, value) {
   let cur = target;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
+  for (let i = 0; i < path2.length - 1; i++) {
+    const key = path2[i];
     if (typeof cur[key] !== "object" || cur[key] === null) cur[key] = {};
     cur = cur[key];
   }
-  cur[path[path.length - 1]] = value;
+  cur[path2[path2.length - 1]] = value;
 }
 
 // src/tools.ts
@@ -1065,6 +1065,26 @@ function computeP95(samples) {
 // src/mcp/registry.ts
 var DEFAULT_MAX_RESULT_CHARS = 32e3;
 var DEFAULT_MAX_RESULT_TOKENS = 8e3;
+function registerSingleMcpTool(mcpTool, env) {
+  if (!mcpTool.name) return "";
+  const registeredName = `${env.prefix}${mcpTool.name}`;
+  env.registry.register({
+    name: registeredName,
+    description: mcpTool.description ?? "",
+    parameters: mcpTool.inputSchema,
+    fn: async (args, ctx) => {
+      const t0 = env.tracker ? Date.now() : 0;
+      const live = env.host.client;
+      const toolResult = await live.callTool(mcpTool.name, args, {
+        onProgress: env.onProgress ? (info) => env.onProgress({ toolName: registeredName, ...info }) : void 0,
+        signal: ctx?.signal
+      });
+      if (env.tracker) env.tracker.record(Date.now() - t0);
+      return flattenMcpResult(toolResult, { maxChars: env.maxResultChars });
+    }
+  });
+  return registeredName;
+}
 async function bridgeMcpTools(client, opts = {}) {
   const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
   const prefix = opts.namePrefix ?? "";
@@ -1072,39 +1092,25 @@ async function bridgeMcpTools(client, opts = {}) {
   const result = { registry, registeredNames: [], skipped: [] };
   const serverName = opts.serverName ?? prefix.replace(/_$/, "") ?? "anon";
   const tracker = opts.onSlow ? new LatencyTracker(serverName, { thresholdMs: opts.slowThresholdMs, onSlow: opts.onSlow }) : null;
+  const host = opts.host ?? { client };
+  const env = {
+    registry,
+    host,
+    prefix,
+    maxResultChars,
+    tracker,
+    onProgress: opts.onProgress
+  };
   const listed = await client.listTools();
   for (const mcpTool of listed.tools) {
     if (!mcpTool.name) {
       result.skipped.push({ name: "?", reason: "empty tool name" });
       continue;
     }
-    const registeredName = `${prefix}${mcpTool.name}`;
-    registry.register({
-      name: registeredName,
-      description: mcpTool.description ?? "",
-      parameters: mcpTool.inputSchema,
-      fn: async (args, ctx) => {
-        const t0 = tracker ? Date.now() : 0;
-        const toolResult = await client.callTool(mcpTool.name, args, {
-          // Forward server-side progress frames to the bridge caller,
-          // tagged with the registered name so multi-server UIs can
-          // disambiguate. No-op when `onProgress` isn't configured —
-          // the client then also omits the _meta.progressToken and
-          // the server won't emit progress.
-          onProgress: opts.onProgress ? (info) => opts.onProgress({ toolName: registeredName, ...info }) : void 0,
-          // Thread the tool-dispatch AbortSignal all the way down to
-          // the MCP request so Esc truly cancels in flight — the
-          // client will emit notifications/cancelled AND reject the
-          // pending promise immediately, no "wait for subprocess".
-          signal: ctx?.signal
-        });
-        if (tracker) tracker.record(Date.now() - t0);
-        return flattenMcpResult(toolResult, { maxChars: maxResultChars });
-      }
-    });
-    result.registeredNames.push(registeredName);
+    const registeredName = registerSingleMcpTool(mcpTool, env);
+    if (registeredName) result.registeredNames.push(registeredName);
   }
-  return result;
+  return { ...result, env };
 }
 function flattenMcpResult(result, opts = {}) {
   const parts = result.content.map(blockToString);
@@ -1305,10 +1311,10 @@ function sanitizeName(name) {
   return cleaned || "default";
 }
 function loadSessionMessages(name) {
-  const path = sessionPath(name);
-  if (!existsSync3(path)) return [];
+  const path2 = sessionPath(name);
+  if (!existsSync3(path2)) return [];
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync3(path2, "utf8");
     const out = [];
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -1325,12 +1331,12 @@ function loadSessionMessages(name) {
   }
 }
 function appendSessionMessage(name, message) {
-  const path = sessionPath(name);
-  mkdirSync(dirname2(path), { recursive: true });
-  appendFileSync(path, `${JSON.stringify(message)}
+  const path2 = sessionPath(name);
+  mkdirSync(dirname2(path2), { recursive: true });
+  appendFileSync(path2, `${JSON.stringify(message)}
 `, "utf8");
   try {
-    chmodSync(path, 384);
+    chmodSync(path2, 384);
   } catch {
   }
 }
@@ -1342,13 +1348,13 @@ function listSessions() {
       (f) => f.endsWith(".jsonl") && !f.endsWith(".events.jsonl")
     );
     return files.map((file) => {
-      const path = join3(dir, file);
-      const stat2 = statSync(path);
+      const path2 = join3(dir, file);
+      const stat2 = statSync(path2);
       const name = file.replace(/\.jsonl$/, "");
-      const messageCount = countLines(path);
+      const messageCount = countLines(path2);
       return {
         name,
-        path,
+        path: path2,
         size: stat2.size,
         messageCount,
         mtime: stat2.mtime,
@@ -1373,11 +1379,11 @@ function loadSessionMeta(name) {
   }
 }
 function deleteSession(name) {
-  const path = sessionPath(name);
+  const path2 = sessionPath(name);
   try {
-    unlinkSync(path);
+    unlinkSync(path2);
     for (const ext of [".events.jsonl", ".pending.json", ".meta.json", ".plan.json"]) {
-      const sidecar = path.replace(/\.jsonl$/, ext);
+      const sidecar = path2.replace(/\.jsonl$/, ext);
       try {
         unlinkSync(sidecar);
       } catch {
@@ -1389,19 +1395,19 @@ function deleteSession(name) {
   }
 }
 function rewriteSession(name, messages) {
-  const path = sessionPath(name);
-  mkdirSync(dirname2(path), { recursive: true });
+  const path2 = sessionPath(name);
+  mkdirSync(dirname2(path2), { recursive: true });
   const body = messages.map((m) => JSON.stringify(m)).join("\n");
-  writeFileSync(path, body ? `${body}
+  writeFileSync(path2, body ? `${body}
 ` : "", "utf8");
   try {
-    chmodSync(path, 384);
+    chmodSync(path2, 384);
   } catch {
   }
 }
-function countLines(path) {
+function countLines(path2) {
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync3(path2, "utf8");
     return raw.split(/\r?\n/).filter((l) => l.trim()).length;
   } catch {
     return 0;
@@ -2976,9 +2982,39 @@ function extractDeepSeekErrorMessage(body) {
 }
 
 // src/at-mentions.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+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 join4, relative, resolve } from "path";
+
+// src/gitignore.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+import ignore from "ignore";
+async function loadGitignoreAt(dirAbs) {
+  try {
+    return ignore().add(await readFile(path.join(dirAbs, ".gitignore"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function loadGitignoreAtSync(dirAbs) {
+  try {
+    return ignore().add(readFileSync4(path.join(dirAbs, ".gitignore"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ignoredByLayers(layers, abs, isDir) {
+  for (const layer of layers) {
+    const rel = path.relative(layer.dirAbs, abs).split(path.sep).join("/");
+    if (!rel || rel.startsWith("..")) continue;
+    if (layer.ig.ignores(isDir ? `${rel}/` : rel)) return true;
+  }
+  return false;
+}
+
+// src/at-mentions.ts
 var DEFAULT_AT_MENTION_MAX_BYTES = 64 * 1024;
 var DEFAULT_PICKER_IGNORE_DIRS = [
   "node_modules",
@@ -3000,12 +3036,18 @@ function listFilesSync(root, opts = {}) {
   return listFilesWithStatsSync(root, opts).map((e) => e.path);
 }
 function listFilesWithStatsSync(root, opts = {}) {
-  const maxResults = Math.max(1, opts.maxResults ?? 500);
-  const ignore = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
+  const maxResults = Math.max(1, opts.maxResults ?? 2e3);
+  const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const rootAbs = resolve(root);
+  const respectGi = opts.respectGitignore !== false;
   const out = [];
-  const walk2 = (dirAbs, dirRel) => {
+  const walk2 = (dirAbs, dirRel, layers) => {
     if (out.length >= maxResults) return;
+    let effectiveLayers = layers;
+    if (respectGi) {
+      const ig = loadGitignoreAtSync(dirAbs);
+      if (ig) effectiveLayers = [...layers, { dirAbs, ig }];
+    }
     let entries;
     try {
       entries = readdirSync2(dirAbs, { withFileTypes: true });
@@ -3016,29 +3058,38 @@ function listFilesWithStatsSync(root, opts = {}) {
     for (const ent of entries) {
       if (out.length >= maxResults) return;
       const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
+      const absPath = join4(dirAbs, ent.name);
       if (ent.isDirectory()) {
-        if (ent.name.startsWith(".") || ignore.has(ent.name)) continue;
-        walk2(join4(dirAbs, ent.name), relPath);
+        if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
+        if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
+        walk2(absPath, relPath, effectiveLayers);
       } else if (ent.isFile()) {
+        if (ignoredByLayers(effectiveLayers, absPath, false)) continue;
         let mtimeMs = 0;
         try {
-          mtimeMs = statSync2(join4(dirAbs, ent.name)).mtimeMs;
+          mtimeMs = statSync2(absPath).mtimeMs;
         } catch {
         }
         out.push({ path: relPath, mtimeMs });
       }
     }
   };
-  walk2(rootAbs, "");
+  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 maxResults = Math.max(1, opts.maxResults ?? 2e3);
+  const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const rootAbs = resolve(root);
+  const respectGi = opts.respectGitignore !== false;
   const out = [];
-  const walk2 = async (dirAbs, dirRel) => {
+  const walk2 = async (dirAbs, dirRel, layers) => {
     if (out.length >= maxResults) return;
+    let effectiveLayers = layers;
+    if (respectGi) {
+      const ig = await loadGitignoreAt(dirAbs);
+      if (ig) effectiveLayers = [...layers, { dirAbs, ig }];
+    }
     let entries;
     try {
       entries = await readdir(dirAbs, { withFileTypes: true });
@@ -3049,35 +3100,42 @@ async function listFilesWithStatsAsync(root, opts = {}) {
     const fileEnts = [];
     for (const ent of entries) {
       if (out.length >= maxResults) break;
+      const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
+      const absPath = join4(dirAbs, ent.name);
       if (ent.isDirectory()) {
-        if (ent.name.startsWith(".") || ignore.has(ent.name)) continue;
+        if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
+        if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
         if (fileEnts.length > 0) {
-          await statBatch(fileEnts, dirAbs, dirRel, out, maxResults);
+          await statBatch(fileEnts, dirAbs, dirRel, out, maxResults, effectiveLayers);
           fileEnts.length = 0;
           if (out.length >= maxResults) return;
         }
-        await walk2(join4(dirAbs, ent.name), dirRel ? `${dirRel}/${ent.name}` : ent.name);
+        await walk2(absPath, relPath, effectiveLayers);
       } else if (ent.isFile()) {
         fileEnts.push(ent);
       }
     }
     if (fileEnts.length > 0 && out.length < maxResults) {
-      await statBatch(fileEnts, dirAbs, dirRel, out, maxResults);
+      await statBatch(fileEnts, dirAbs, dirRel, out, maxResults, effectiveLayers);
     }
   };
-  await walk2(rootAbs, "");
+  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);
+async function statBatch(ents, dirAbs, dirRel, out, maxResults, layers) {
+  const accepted = [];
+  for (const e of ents) {
+    if (out.length + accepted.length >= maxResults) break;
+    if (ignoredByLayers(layers, join4(dirAbs, e.name), false)) continue;
+    accepted.push(e);
+  }
   const stats = await Promise.all(
-    batch.map(
+    accepted.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];
+  for (let i = 0; i < accepted.length; i++) {
+    const ent = accepted[i];
     out.push({
       path: dirRel ? `${dirRel}/${ent.name}` : ent.name,
       mtimeMs: stats[i] ?? 0
@@ -3218,20 +3276,20 @@ var defaultFs = {
       return 0;
     }
   },
-  read: (p) => readFileSync4(p, "utf8")
+  read: (p) => readFileSync5(p, "utf8")
 };
 
 // src/memory/project.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { join as join5 } from "path";
 var PROJECT_MEMORY_FILE = "REASONIX.md";
 var PROJECT_MEMORY_MAX_CHARS = 8e3;
 function readProjectMemory(rootDir) {
-  const path = join5(rootDir, PROJECT_MEMORY_FILE);
-  if (!existsSync5(path)) return null;
+  const path2 = join5(rootDir, PROJECT_MEMORY_FILE);
+  if (!existsSync5(path2)) return null;
   let raw;
   try {
-    raw = readFileSync5(path, "utf8");
+    raw = readFileSync6(path2, "utf8");
   } catch {
     return null;
   }
@@ -3241,7 +3299,7 @@ function readProjectMemory(rootDir) {
   const truncated = originalChars > PROJECT_MEMORY_MAX_CHARS;
   const content = truncated ? `${trimmed.slice(0, PROJECT_MEMORY_MAX_CHARS)}
 \u2026 (truncated ${originalChars - PROJECT_MEMORY_MAX_CHARS} chars)` : trimmed;
-  return { path, content, originalChars, truncated };
+  return { path: path2, content, originalChars, truncated };
 }
 function memoryEnabled() {
   const env = process.env.REASONIX_MEMORY;
@@ -3269,7 +3327,7 @@ import { createHash as createHash2 } from "crypto";
 import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
@@ -3278,7 +3336,7 @@ import { homedir as homedir4 } from "os";
 import { join as join7, resolve as resolve3 } from "path";
 
 // src/skills.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join6, resolve as resolve2 } from "path";
 
@@ -3415,10 +3473,10 @@ var SkillStore = class {
     }
     return null;
   }
-  parse(path, stem, scope) {
+  parse(path2, stem, scope) {
     let raw;
     try {
-      raw = readFileSync6(path, "utf8");
+      raw = readFileSync7(path2, "utf8");
     } catch {
       return null;
     }
@@ -3429,7 +3487,7 @@ var SkillStore = class {
       description: (data.description ?? "").trim(),
       body: body.trim(),
       scope,
-      path,
+      path: path2,
       allowedTools: data["allowed-tools"],
       runAs: parseRunAs(data.runAs),
       model: data.model?.startsWith("deepseek-") ? data.model : void 0
@@ -3752,7 +3810,7 @@ var MemoryStore = class {
     if (!existsSync7(file)) return null;
     let raw;
     try {
-      raw = readFileSync7(file, "utf8");
+      raw = readFileSync8(file, "utf8");
     } catch {
       return null;
     }
@@ -3770,7 +3828,7 @@ var MemoryStore = class {
     if (!existsSync7(file)) {
       throw new Error(`memory not found: scope=${scope} name=${name}`);
     }
-    const raw = readFileSync7(file, "utf8");
+    const raw = readFileSync8(file, "utf8");
     const { data, body } = parseFrontmatter2(raw);
     return {
       name: data.name ?? name,
@@ -3872,11 +3930,11 @@ var MemoryStore = class {
   }
 };
 function readGlobalReasonixMemory(homeDir = join7(homedir4(), ".reasonix")) {
-  const path = join7(homeDir, "REASONIX.md");
-  if (!existsSync7(path)) return null;
+  const path2 = join7(homeDir, "REASONIX.md");
+  if (!existsSync7(path2)) return null;
   let raw;
   try {
-    raw = readFileSync7(path, "utf8");
+    raw = readFileSync8(path2, "utf8");
   } catch {
     return null;
   }
@@ -3886,7 +3944,7 @@ function readGlobalReasonixMemory(homeDir = join7(homedir4(), ".reasonix")) {
   const truncated = originalChars > 8e3;
   const content = truncated ? `${trimmed.slice(0, 8e3)}
 \u2026 (truncated ${originalChars - 8e3} chars)` : trimmed;
-  return { path, content, originalChars, truncated };
+  return { path: path2, content, originalChars, truncated };
 }
 function applyGlobalReasonixMemory(basePrompt, homeDir) {
   if (!memoryEnabled()) return basePrompt;
@@ -4607,7 +4665,7 @@ function registerMemoryTools(registry, opts = {}) {
         });
       }
       try {
-        const path = store.write({
+        const path2 = store.write({
           name: args.name,
           type: args.type,
           scope: args.scope,
@@ -4620,7 +4678,7 @@ function registerMemoryTools(registry, opts = {}) {
           "",
           "TREAT THIS AS ESTABLISHED FACT for the rest of this session.",
           "The user just told you \u2014 don't re-explore the filesystem to re-derive it.",
-          `(Saved to ${path}; pins into the system prompt on next /new or launch.)`
+          `(Saved to ${path2}; pins into the system prompt on next /new or launch.)`
         ].join("\n");
       } catch (err) {
         return JSON.stringify({ error: `remember failed: ${err.message}` });
@@ -6349,12 +6407,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { resolve as resolve7 } from "path";
-function loadDotenv(path = ".env") {
+function loadDotenv(path2 = ".env") {
   let raw;
   try {
-    raw = readFileSync8(resolve7(process.cwd(), path), "utf8");
+    raw = readFileSync9(resolve7(process.cwd(), path2), "utf8");
   } catch {
     return;
   }
@@ -6373,7 +6431,7 @@ function loadDotenv(path = ".env") {
 }
 
 // src/transcript/log.ts
-import { createWriteStream, readFileSync as readFileSync9 } from "fs";
+import { createWriteStream, readFileSync as readFileSync10 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6418,13 +6476,13 @@ function writeMeta(stream, meta) {
   stream.write(`${JSON.stringify(line)}
 `);
 }
-function openTranscriptFile(path, meta) {
-  const stream = createWriteStream(path, { flags: "a" });
+function openTranscriptFile(path2, meta) {
+  const stream = createWriteStream(path2, { flags: "a" });
   writeMeta(stream, meta);
   return stream;
 }
-function readTranscript(path) {
-  const raw = readFileSync9(path, "utf8");
+function readTranscript(path2) {
+  const raw = readFileSync10(path2, "utf8");
   return parseTranscript(raw);
 }
 function isPlanStateEmptyShape(s) {
@@ -6455,8 +6513,8 @@ function parseTranscript(raw) {
 }
 
 // src/transcript/replay.ts
-function replayFromFile(path) {
-  const parsed = readTranscript(path);
+function replayFromFile(path2) {
+  const parsed = readTranscript(path2);
   return { parsed, stats: computeReplayStats(parsed.records) };
 }
 function computeReplayStats(records) {
@@ -6871,7 +6929,7 @@ function truncate(s, n) {
 }
 
 // src/version.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync11, 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";
@@ -6884,7 +6942,7 @@ function readPackageVersion() {
     for (let i = 0; i < 6; i++) {
       const p = join9(dir, "package.json");
       if (existsSync9(p)) {
-        const pkg = JSON.parse(readFileSync10(p, "utf8"));
+        const pkg = JSON.parse(readFileSync11(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
           return pkg.version;
         }
@@ -6903,7 +6961,7 @@ function cachePath(homeDirOverride) {
 }
 function readCache(homeDirOverride) {
   try {
-    const raw = readFileSync10(cachePath(homeDirOverride), "utf8");
+    const raw = readFileSync11(cachePath(homeDirOverride), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
       return parsed;
@@ -7709,7 +7767,7 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync12, 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) {
@@ -7752,7 +7810,7 @@ function applyEditBlock(block, rootDir) {
       writeFileSync4(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync11(absTarget, "utf8");
+    const content = readFileSync12(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -7791,7 +7849,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync11(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync12(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -7834,7 +7892,7 @@ function sep() {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } 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.
 
@@ -8042,7 +8100,7 @@ function codeSystemPrompt(rootDir, opts = {}) {
   if (existsSync11(gitignorePath)) {
     let content;
     try {
-      content = readFileSync12(gitignorePath, "utf8");
+      content = readFileSync13(gitignorePath, "utf8");
     } catch {
     }
     if (content !== void 0) {
@@ -8073,37 +8131,37 @@ ${appendParts.join("\n\n")}`;
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join11 } from "path";
 function defaultConfigPath() {
   return join11(homedir6(), ".reasonix", "config.json");
 }
-function readConfig(path = defaultConfigPath()) {
+function readConfig(path2 = defaultConfigPath()) {
   try {
-    const raw = readFileSync13(path, "utf8");
+    const raw = readFileSync14(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
   }
   return {};
 }
-function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync5(dirname6(path), { recursive: true });
-  writeFileSync5(path, JSON.stringify(cfg, null, 2), "utf8");
+function writeConfig(cfg, path2 = defaultConfigPath()) {
+  mkdirSync5(dirname6(path2), { recursive: true });
+  writeFileSync5(path2, JSON.stringify(cfg, null, 2), "utf8");
   try {
-    chmodSync2(path, 384);
+    chmodSync2(path2, 384);
   } catch {
   }
 }
-function loadApiKey(path = defaultConfigPath()) {
+function loadApiKey(path2 = defaultConfigPath()) {
   if (process.env.DEEPSEEK_API_KEY) return process.env.DEEPSEEK_API_KEY;
-  return readConfig(path).apiKey;
+  return readConfig(path2).apiKey;
 }
-function saveApiKey(key, path = defaultConfigPath()) {
-  const cfg = readConfig(path);
+function saveApiKey(key, path2 = defaultConfigPath()) {
+  const cfg = readConfig(path2);
   cfg.apiKey = key.trim();
-  writeConfig(cfg, path);
+  writeConfig(cfg, path2);
 }
 function isPlausibleKey(key) {
   const trimmed = key.trim();
@@ -8120,7 +8178,7 @@ import {
   appendFileSync as appendFileSync2,
   existsSync as existsSync12,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "fs";
@@ -8131,10 +8189,10 @@ function defaultUsageLogPath(homeDirOverride) {
 }
 var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
 var USAGE_RETENTION_DAYS = 365;
-function compactUsageLogIfLarge(path, now) {
+function compactUsageLogIfLarge(path2, now) {
   let size;
   try {
-    size = statSync5(path).size;
+    size = statSync5(path2).size;
   } catch {
     return;
   }
@@ -8142,7 +8200,7 @@ function compactUsageLogIfLarge(path, now) {
   const cutoff = now - USAGE_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
   let raw;
   try {
-    raw = readFileSync14(path, "utf8");
+    raw = readFileSync15(path2, "utf8");
   } catch {
     return;
   }
@@ -8158,7 +8216,7 @@ function compactUsageLogIfLarge(path, now) {
   }
   if (kept.length === lines.filter((l) => l.trim()).length) return;
   try {
-    writeFileSync6(path, kept.length > 0 ? `${kept.join("\n")}
+    writeFileSync6(path2, kept.length > 0 ? `${kept.join("\n")}
 ` : "", "utf8");
   } catch {
   }
@@ -8177,21 +8235,21 @@ function appendUsage(input) {
   };
   if (input.kind === "subagent") record.kind = "subagent";
   if (input.subagent) record.subagent = input.subagent;
-  const path = input.path ?? defaultUsageLogPath();
+  const path2 = input.path ?? defaultUsageLogPath();
   try {
-    mkdirSync6(dirname7(path), { recursive: true });
-    appendFileSync2(path, `${JSON.stringify(record)}
+    mkdirSync6(dirname7(path2), { recursive: true });
+    appendFileSync2(path2, `${JSON.stringify(record)}
 `, "utf8");
-    compactUsageLogIfLarge(path, record.ts);
+    compactUsageLogIfLarge(path2, record.ts);
   } catch {
   }
   return record;
 }
-function readUsageLog(path = defaultUsageLogPath()) {
-  if (!existsSync12(path)) return [];
+function readUsageLog(path2 = defaultUsageLogPath()) {
+  if (!existsSync12(path2)) return [];
   let raw;
   try {
-    raw = readFileSync14(path, "utf8");
+    raw = readFileSync15(path2, "utf8");
   } catch {
     return [];
   }
@@ -8297,10 +8355,10 @@ function aggregateUsage(records, opts = {}) {
     subagents
   };
 }
-function formatLogSize(path = defaultUsageLogPath()) {
-  if (!existsSync12(path)) return "";
+function formatLogSize(path2 = defaultUsageLogPath()) {
+  if (!existsSync12(path2)) return "";
   try {
-    const s = statSync5(path);
+    const s = statSync5(path2);
     const bytes = s.size;
     if (bytes < 1024) return `${bytes} B`;
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;