reasonix 0.22.0 → 0.23.1

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
@@ -1311,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();
@@ -1331,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 {
   }
 }
@@ -1348,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,
@@ -1379,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 {
@@ -1395,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;
@@ -1573,7 +1573,7 @@ var StormBreaker = class {
     if (count >= this.threshold - 1) {
       return {
         suppress: true,
-        reason: `call-storm suppressed: ${name} called with identical args ${count + 1} times within window=${this.windowSize}`
+        reason: `${name} called with identical args ${count + 1} times \u2014 repeat-loop guard tripped`
       };
     }
     this.recent.push({ name, args, readOnly });
@@ -1858,6 +1858,7 @@ var CacheFirstLoop = class {
   _escalateThisTurn = false;
   _turnFailureCount = 0;
   _turnFailureTypes = {};
+  _turnSelfCorrected = false;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1902,7 +1903,12 @@ var CacheFirstLoop = class {
       }
       return def.readOnly !== true;
     };
-    this.repair = new ToolCallRepair({ allowedToolNames: allowedNames, isMutating });
+    this.repair = new ToolCallRepair({
+      allowedToolNames: allowedNames,
+      isMutating,
+      stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
+      stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
+    });
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
@@ -1984,6 +1990,21 @@ var CacheFirstLoop = class {
       }
     }
   }
+  /** Swap the just-appended assistant entry — used by self-correction to restore the original tool_calls without dropping reasoning_content. */
+  replaceTailAssistantMessage(message) {
+    const entries = this.log.entries;
+    const tail = entries[entries.length - 1];
+    if (!tail || tail.role !== "assistant") return;
+    const kept = entries.slice(0, -1);
+    kept.push(message);
+    this.log.compactInPlace(kept);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, kept);
+      } catch {
+      }
+    }
+  }
   /** "New chat" — drops messages but keeps session + immutable prefix (cache-first invariant). */
   clearLog() {
     const dropped = this.log.length;
@@ -2084,7 +2105,7 @@ var CacheFirstLoop = class {
     if (repair) {
       if (repair.scavenged > 0) bump("scavenged", repair.scavenged);
       if (repair.truncationsFixed > 0) bump("truncated", repair.truncationsFixed);
-      if (repair.stormsBroken > 0) bump("storm-broken", repair.stormsBroken);
+      if (repair.stormsBroken > 0) bump("repeat-loop", repair.stormsBroken);
     }
     if (bumped && !this._escalateThisTurn && this.autoEscalate && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
       this._escalateThisTurn = true;
@@ -2154,6 +2175,7 @@ var CacheFirstLoop = class {
     this.repair.resetStorm();
     this._turnFailureCount = 0;
     this._turnFailureTypes = {};
+    this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     let armedConsumed = false;
     if (this._proArmedForNextTurn) {
@@ -2505,10 +2527,35 @@ var CacheFirstLoop = class {
           content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this.formatFailureBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
         };
       }
+      const allSuppressed = report.stormsBroken > 0 && repairedCalls.length === 0 && toolCalls.length > 0;
+      if (allSuppressed && !this._turnSelfCorrected) {
+        this._turnSelfCorrected = true;
+        this.replaceTailAssistantMessage(
+          this.assistantMessage(
+            assistantContent,
+            toolCalls,
+            this.modelForCurrentCall(),
+            reasoningContent
+          )
+        );
+        for (const call of toolCalls) {
+          this.appendAndPersist({
+            role: "tool",
+            tool_call_id: call.id ?? "",
+            name: call.function?.name ?? "",
+            content: "[repeat-loop guard] this call was suppressed because it was identical to a previous call in this turn. Earlier results for it are above \u2014 try a meaningfully different approach, or stop and answer if you have enough."
+          });
+        }
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: "Caught a repeated tool call \u2014 let the model see the issue and retry with a different approach."
+        };
+        continue;
+      }
       if (report.stormsBroken > 0) {
         const noteTail = report.notes.length ? ` \u2014 ${report.notes[report.notes.length - 1]}` : "";
-        const allSuppressed = repairedCalls.length === 0 && toolCalls.length > 0;
-        const phrase = allSuppressed ? `stopped the model from calling the same tool with identical args repeatedly (all ${toolCalls.length} call(s) this turn were already in the recent-repeat window). Likely a stuck retry \u2014 reword your instruction, rule out the underlying blocker, or try /retry after fixing it` : `suppressed ${report.stormsBroken} repeat tool call(s) that had fired 3+ times with identical args in a sliding window`;
+        const phrase = allSuppressed ? "Stopped a stuck retry loop \u2014 the model kept calling the same tool with identical args after a self-correction nudge. Try /retry, rephrase, or rule out the underlying blocker." : `Suppressed ${report.stormsBroken} repeated tool call(s) \u2014 same name + args fired 3+ times.`;
         yield {
           turn: this._turn,
           role: "warning",
@@ -2516,7 +2563,6 @@ var CacheFirstLoop = class {
         };
       }
       if (repairedCalls.length === 0) {
-        const allSuppressed = report.stormsBroken > 0 && toolCalls.length > 0;
         if (allSuppressed) {
           yield* this.forceSummaryAfterIterLimit({ reason: "stuck" });
           return;
@@ -2741,6 +2787,11 @@ function stripHallucinatedToolMarkup(s) {
   out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
   return out.trim();
 }
+function parsePositiveIntEnv(raw) {
+  if (!raw) return void 0;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
 function safeParseToolArgs(raw) {
   try {
     return JSON.parse(raw);
@@ -2982,9 +3033,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",
@@ -3006,12 +3087,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 });
@@ -3022,29 +3109,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 });
@@ -3055,35 +3151,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
@@ -3224,20 +3327,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;
   }
@@ -3247,7 +3350,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;
@@ -3275,7 +3378,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
@@ -3284,7 +3387,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";
 
@@ -3421,10 +3524,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;
     }
@@ -3435,7 +3538,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
@@ -3758,7 +3861,7 @@ var MemoryStore = class {
     if (!existsSync7(file)) return null;
     let raw;
     try {
-      raw = readFileSync7(file, "utf8");
+      raw = readFileSync8(file, "utf8");
     } catch {
       return null;
     }
@@ -3776,7 +3879,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,
@@ -3878,11 +3981,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;
   }
@@ -3892,7 +3995,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;
@@ -4613,7 +4716,7 @@ function registerMemoryTools(registry, opts = {}) {
         });
       }
       try {
-        const path = store.write({
+        const path2 = store.write({
           name: args.name,
           type: args.type,
           scope: args.scope,
@@ -4626,7 +4729,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}` });
@@ -6355,12 +6458,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;
   }
@@ -6379,7 +6482,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(),
@@ -6424,13 +6527,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) {
@@ -6461,8 +6564,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) {
@@ -6877,7 +6980,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";
@@ -6890,7 +6993,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;
         }
@@ -6909,7 +7012,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;
@@ -7715,7 +7818,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) {
@@ -7758,7 +7861,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,
@@ -7797,7 +7900,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 });
     }
@@ -7840,7 +7943,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.
 
@@ -8048,7 +8151,7 @@ function codeSystemPrompt(rootDir, opts = {}) {
   if (existsSync11(gitignorePath)) {
     let content;
     try {
-      content = readFileSync12(gitignorePath, "utf8");
+      content = readFileSync13(gitignorePath, "utf8");
     } catch {
     }
     if (content !== void 0) {
@@ -8079,37 +8182,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();
@@ -8126,7 +8229,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";
@@ -8137,10 +8240,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;
   }
@@ -8148,7 +8251,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;
   }
@@ -8164,7 +8267,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 {
   }
@@ -8183,21 +8286,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 [];
   }
@@ -8303,10 +8406,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`;