reasonix 0.32.0 → 0.33.0

package/dist/index.js

@@ -1032,7 +1032,10 @@ var EN = {
       restoreInfo: '\u25B8 restored "{name}" ({id}) from {when}',
       restoreWrote: "  \xB7 wrote back {count} file{s}",
       restoreRemoved: "  \xB7 removed {count} file{s} (didn't exist at checkpoint time)",
-      restoreSkipped: "  \u2717 {count} file{s} skipped:"
+      restoreSkipped: "  \u2717 {count} file{s} skipped:",
+      cwdCodeOnly: "/cwd is only available inside `reasonix code`.",
+      cwdUsage: "usage: /cwd <path>   (current root: {current}). Re-points filesystem / shell / memory tools to <path>.",
+      cwdUsageNoCurrent: "usage: /cwd <path>   re-points the workspace root to <path>."
     },
     model: {
       modelHint: "try deepseek-v4-flash or deepseek-v4-pro \u2014 run /models to fetch the live list",
@@ -1726,7 +1729,10 @@ var zhCN = {
       restoreInfo: '\u25B8 \u5DF2\u6062\u590D "{name}"\uFF08{id}\uFF09\uFF0C\u6765\u81EA {when}',
       restoreWrote: "  \xB7 \u5199\u56DE\u4E86 {count} \u4E2A\u6587\u4EF6",
       restoreRemoved: "  \xB7 \u79FB\u9664\u4E86 {count} \u4E2A\u6587\u4EF6\uFF08\u68C0\u67E5\u70B9\u65F6\u4E0D\u5B58\u5728\uFF09",
-      restoreSkipped: "  \u2717 \u8DF3\u8FC7\u4E86 {count} \u4E2A\u6587\u4EF6\uFF1A"
+      restoreSkipped: "  \u2717 \u8DF3\u8FC7\u4E86 {count} \u4E2A\u6587\u4EF6\uFF1A",
+      cwdCodeOnly: "/cwd \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      cwdUsage: "\u7528\u6CD5\uFF1A/cwd <path>   \uFF08\u5F53\u524D\u6839\u76EE\u5F55\uFF1A{current}\uFF09\u3002\u91CD\u65B0\u6307\u5411 filesystem / shell / memory \u5DE5\u5177\u5230 <path>\u3002",
+      cwdUsageNoCurrent: "\u7528\u6CD5\uFF1A/cwd <path>   \u5C06\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\u5207\u6362\u5230 <path>\u3002"
     },
     model: {
       modelHint: "\u5C1D\u8BD5 deepseek-v4-flash \u6216 deepseek-v4-pro \u2014 \u8FD0\u884C /models \u83B7\u53D6\u5B9E\u65F6\u5217\u8868",
@@ -4873,15 +4879,25 @@ function rankPickerCandidates(files, query, limitOrOpts) {
   for (const e of entries) {
     const lower = e.path.toLowerCase();
     const hit = lower.indexOf(needle);
-    if (hit < 0) continue;
-    const slash = lower.lastIndexOf("/");
-    const base = slash >= 0 ? lower.slice(slash + 1) : lower;
-    let score = 2;
-    if (base.startsWith(needle)) score = 0;
-    else if (lower.startsWith(needle)) score = 1;
+    if (hit >= 0) {
+      const slash = lower.lastIndexOf("/");
+      const base = slash >= 0 ? lower.slice(slash + 1) : lower;
+      let cls = 2;
+      if (base.startsWith(needle)) cls = 0;
+      else if (lower.startsWith(needle)) cls = 1;
+      scored.push({
+        path: e.path,
+        score: cls * 1e4 + Math.min(hit, 9999),
+        mtimeMs: e.mtimeMs,
+        recent: recent.has(e.path)
+      });
+      continue;
+    }
+    const fuzzy = fuzzySubseqScore(needle, lower);
+    if (fuzzy === null) continue;
     scored.push({
       path: e.path,
-      score: score * 1e4 + hit,
+      score: 3e4 + fuzzy,
       mtimeMs: e.mtimeMs,
       recent: recent.has(e.path)
     });
@@ -4893,11 +4909,33 @@ function rankPickerCandidates(files, query, limitOrOpts) {
   });
   return scored.slice(0, limit).map((s) => s.path);
 }
+function fuzzySubseqScore(needle, target) {
+  if (needle.length === 0) return 0;
+  const slashIdx = target.lastIndexOf("/");
+  const basenameStart = slashIdx >= 0 ? slashIdx + 1 : 0;
+  let qi = 0;
+  let lastMatchIdx = -2;
+  let consecutive = 0;
+  let basenameMatches = 0;
+  let totalGap = 0;
+  for (let ti = 0; ti < target.length && qi < needle.length; ti++) {
+    if (target[ti] !== needle[qi]) continue;
+    if (ti === lastMatchIdx + 1) consecutive++;
+    else if (lastMatchIdx >= 0) totalGap += ti - lastMatchIdx - 1;
+    if (ti >= basenameStart) basenameMatches++;
+    lastMatchIdx = ti;
+    qi++;
+  }
+  if (qi < needle.length) return null;
+  const quality = Math.max(0, totalGap - consecutive * 10 - basenameMatches * 5);
+  const lengthPenalty = Math.floor(target.length / 4);
+  return quality + lengthPenalty;
+}
 var AT_MENTION_PATTERN = /(?<=^|\s)@([a-zA-Z0-9_./\\-]+)/g;
 function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
   const maxDirEntries = Math.max(1, opts.maxDirEntries ?? DEFAULT_AT_DIR_MAX_ENTRIES);
-  const fs4 = opts.fs ?? defaultFs;
+  const fs5 = opts.fs ?? defaultFs;
   const root = resolve(rootDir);
   const seen = /* @__PURE__ */ new Map();
   const expansions = [];
@@ -4910,7 +4948,7 @@ function expandAtMentions(text, rootDir, opts = {}) {
     if (!cleaned) continue;
     const token = `@${cleaned}`;
     if (seen.has(token)) continue;
-    const expansion = resolveMention(cleaned, root, maxBytes, maxDirEntries, fs4, dirListings);
+    const expansion = resolveMention(cleaned, root, maxBytes, maxDirEntries, fs5, dirListings);
     seen.set(token, expansion);
     expansions.push(expansion);
   }
@@ -4927,7 +4965,7 @@ ${files.join("\n")}
         `<directory path="${ex.path}" entries="${ex.entries ?? files.length}"${truncAttr}>${body}</directory>`
       );
     } else if (ex.ok) {
-      const content = readSafe(root, ex.path, fs4);
+      const content = readSafe(root, ex.path, fs5);
       blocks.push(`<file path="${ex.path}">
 ${content}
 </file>`);
@@ -4941,7 +4979,7 @@ ${content}
 ${blocks.join("\n\n")}`;
   return { text: augmented, expansions };
 }
-function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs4, dirListings) {
+function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs5, dirListings) {
   if (isAbsolute(rawPath)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
@@ -4950,18 +4988,18 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs4, dirListings
   if (rel.startsWith("..") || isAbsolute(rel)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
-  if (!fs4.exists(resolved)) {
+  if (!fs5.exists(resolved)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "missing" };
   }
-  if (fs4.isFile(resolved)) {
-    const size = fs4.size(resolved);
+  if (fs5.isFile(resolved)) {
+    const size = fs5.size(resolved);
     if (size > maxBytes) {
       return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "too-large", bytes: size };
     }
     return { token: `@${rawPath}`, path: rawPath, ok: true, bytes: size };
   }
-  if (fs4.isDir?.(resolved) && fs4.listDir) {
-    const { files, truncated } = fs4.listDir(resolved, root, maxDirEntries);
+  if (fs5.isDir?.(resolved) && fs5.listDir) {
+    const { files, truncated } = fs5.listDir(resolved, root, maxDirEntries);
     dirListings.set(rawPath, files);
     return {
       token: `@${rawPath}`,
@@ -4974,10 +5012,10 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs4, dirListings
   }
   return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
 }
-function readSafe(root, rawPath, fs4) {
+function readSafe(root, rawPath, fs5) {
   const resolved = resolve(root, rawPath);
   try {
-    return fs4.read(resolved);
+    return fs5.read(resolved);
   } catch {
     return "(read failed)";
   }
@@ -5790,9 +5828,9 @@ function applyMemoryStack(basePrompt, rootDir) {
 }
 
 // src/tools/filesystem.ts
-import { promises as fs3 } from "fs";
-import * as pathMod3 from "path";
-import picomatch2 from "picomatch";
+import { promises as fs4 } from "fs";
+import * as pathMod4 from "path";
+import picomatch3 from "picomatch";
 
 // src/tools/fs/edit.ts
 import { promises as fs } from "fs";
@@ -5827,6 +5865,83 @@ async function applyEdit(rootDir, abs, args) {
   return `${header}
 ${diff}`;
 }
+async function applyMultiEdit(rootDir, edits) {
+  if (edits.length === 0) {
+    throw new Error("multi_edit: edits must contain at least one entry");
+  }
+  const filesByPath = /* @__PURE__ */ new Map();
+  for (let i = 0; i < edits.length; i++) {
+    const e = edits[i];
+    if (typeof e.abs !== "string" || e.abs.length === 0) {
+      throw new Error(`multi_edit: edit #${i + 1} requires a string \`path\` (no edits applied)`);
+    }
+    if (typeof e.search !== "string") {
+      throw new Error(`multi_edit: edit #${i + 1} requires a string \`search\` (no edits applied)`);
+    }
+    if (typeof e.replace !== "string") {
+      throw new Error(
+        `multi_edit: edit #${i + 1} requires a string \`replace\` (no edits applied)`
+      );
+    }
+    const rel = displayRel(rootDir, e.abs);
+    if (e.search.length === 0) {
+      throw new Error(
+        `multi_edit: edit #${i + 1} (${rel}) search cannot be empty (no edits applied)`
+      );
+    }
+    let state = filesByPath.get(e.abs);
+    if (!state) {
+      let before;
+      try {
+        before = await fs.readFile(e.abs, "utf8");
+      } catch (err) {
+        throw new Error(
+          `multi_edit: edit #${i + 1} cannot read ${rel}: ${err.message} (no edits applied)`
+        );
+      }
+      const le = before.includes("\r\n") ? "\r\n" : "\n";
+      state = { buf: before, le, hunks: [], deltaChars: 0, touched: 0 };
+      filesByPath.set(e.abs, state);
+    }
+    const adaptedSearch = e.search.replace(/\r?\n/g, state.le);
+    const adaptedReplace = e.replace.replace(/\r?\n/g, state.le);
+    const firstIdx = state.buf.indexOf(adaptedSearch);
+    if (firstIdx < 0) {
+      throw new Error(
+        `multi_edit: edit #${i + 1} search text not found in ${rel} \u2014 no edits applied (multi_edit is atomic)`
+      );
+    }
+    const nextIdx = state.buf.indexOf(adaptedSearch, firstIdx + 1);
+    if (nextIdx >= 0) {
+      throw new Error(
+        `multi_edit: edit #${i + 1} search text appears multiple times in ${rel} \u2014 include more context to disambiguate (no edits applied)`
+      );
+    }
+    const startLine = state.buf.slice(0, firstIdx).split(/\r?\n/).length;
+    state.buf = state.buf.slice(0, firstIdx) + adaptedReplace + state.buf.slice(firstIdx + adaptedSearch.length);
+    state.hunks.push(`# ${rel}
+${renderEditDiff(adaptedSearch, adaptedReplace, startLine)}`);
+    state.deltaChars += adaptedReplace.length - adaptedSearch.length;
+    state.touched++;
+  }
+  for (const [abs, state] of filesByPath) {
+    await fs.writeFile(abs, state.buf, "utf8");
+  }
+  const fileCount = filesByPath.size;
+  const editCount = edits.length;
+  let totalDelta = 0;
+  const allHunks = [];
+  for (const state of filesByPath.values()) {
+    totalDelta += state.deltaChars;
+    allHunks.push(...state.hunks);
+  }
+  const sign = totalDelta >= 0 ? "+" : "";
+  const editNoun = editCount === 1 ? "edit" : "edits";
+  const fileNoun = fileCount === 1 ? "file" : "files";
+  const header = `multi_edit: applied ${editCount} ${editNoun} across ${fileCount} ${fileNoun} (${sign}${totalDelta} chars)`;
+  return `${header}
+${allHunks.join("\n")}`;
+}
 function renderEditDiff(search, replace, startLine) {
   const a = search.split(/\r?\n/);
   const b = replace.split(/\r?\n/);
@@ -5873,15 +5988,78 @@ function lineDiff(a, b) {
   return out;
 }
 
-// src/tools/fs/search.ts
+// src/tools/fs/glob.ts
 import { promises as fs2 } from "fs";
 import * as pathMod2 from "path";
+import picomatch2 from "picomatch";
+function displayRel2(rootDir, full) {
+  return pathMod2.relative(rootDir, full).replaceAll("\\", "/");
+}
+async function globFiles(ctx, startAbs, args) {
+  if (args.signal?.aborted) {
+    throw new DOMException("glob aborted by user", "AbortError");
+  }
+  const includeDeps = args.include_deps === true;
+  const sortBy = args.sort_by ?? "mtime";
+  const limit = Math.max(1, Math.min(1e3, Math.floor(args.limit ?? 200)));
+  const isMatch = picomatch2(args.pattern, { dot: true, nocase: true });
+  const hits = [];
+  const walk2 = async (dir) => {
+    if (args.signal?.aborted) {
+      throw new DOMException("glob aborted by user", "AbortError");
+    }
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = pathMod2.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
+        await walk2(full);
+        continue;
+      }
+      if (!e.isFile() && !e.isSymbolicLink()) continue;
+      const rel = displayRel2(ctx.rootDir, full);
+      if (!isMatch(rel)) continue;
+      let mtimeMs = 0;
+      if (sortBy === "mtime") {
+        try {
+          const st = await fs2.stat(full);
+          mtimeMs = st.mtimeMs;
+        } catch {
+          continue;
+        }
+      }
+      hits.push({ rel, mtimeMs });
+    }
+  };
+  await walk2(startAbs);
+  if (hits.length === 0) return "(no matches)";
+  if (sortBy === "mtime") hits.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  else hits.sort((a, b) => a.rel.localeCompare(b.rel));
+  const truncated = hits.length > limit;
+  const shown = hits.slice(0, limit);
+  const lines = shown.map((h) => h.rel);
+  if (truncated) {
+    lines.push(
+      `[\u2026 ${hits.length - limit} more matches \u2014 refine pattern or raise limit (max 1000) \u2026]`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/tools/fs/search.ts
+import { promises as fs3 } from "fs";
+import * as pathMod3 from "path";
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   throw new DOMException("search aborted by user", "AbortError");
 }
-function displayRel2(rootDir, full) {
-  return pathMod2.relative(rootDir, full).replaceAll("\\", "/");
+function displayRel3(rootDir, full) {
+  return pathMod3.relative(rootDir, full).replaceAll("\\", "/");
 }
 async function searchFiles(ctx, startAbs, args) {
   throwIfAborted(args.signal);
@@ -5899,17 +6077,17 @@ async function searchFiles(ctx, startAbs, args) {
     throwIfAborted(args.signal);
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs3.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       throwIfAborted(args.signal);
-      const full = pathMod2.join(dir, e.name);
+      const full = pathMod3.join(dir, e.name);
       const lower = e.name.toLowerCase();
       const hit = re ? re.test(e.name) : lower.includes(needle);
       if (hit) {
-        const rel = displayRel2(ctx.rootDir, full);
+        const rel = displayRel3(ctx.rootDir, full);
         if (totalBytes + rel.length + 1 > ctx.maxListBytes) {
           matches.push("[\u2026 search truncated \u2014 refine pattern \u2026]");
           return;
@@ -5930,6 +6108,7 @@ async function searchContent(ctx, startAbs, args) {
   throwIfAborted(args.signal);
   const caseSensitive = args.case_sensitive === true;
   const includeDeps = args.include_deps === true;
+  const ctxLines = Math.max(0, Math.min(20, Math.floor(args.context ?? 0)));
   let re = null;
   try {
     re = new RegExp(args.pattern, caseSensitive ? "" : "i");
@@ -5941,12 +6120,22 @@ async function searchContent(ctx, startAbs, args) {
   let totalBytes = 0;
   let scanned = 0;
   let truncated = false;
+  const pushLine = (out) => {
+    if (totalBytes + out.length + 1 > ctx.maxListBytes) {
+      matches.push(`[\u2026 truncated at ${ctx.maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
+      truncated = true;
+      return false;
+    }
+    matches.push(out);
+    totalBytes += out.length + 1;
+    return true;
+  };
   const walk2 = async (dir) => {
     if (truncated) return;
     throwIfAborted(args.signal);
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs3.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5955,16 +6144,16 @@ async function searchContent(ctx, startAbs, args) {
       throwIfAborted(args.signal);
       if (e.isDirectory()) {
         if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
-        await walk2(pathMod2.join(dir, e.name));
+        await walk2(pathMod3.join(dir, e.name));
         continue;
       }
       if (!e.isFile()) continue;
-      const full = pathMod2.join(dir, e.name);
-      if (ctx.nameMatch && !ctx.nameMatch(e.name, displayRel2(ctx.rootDir, full))) continue;
+      const full = pathMod3.join(dir, e.name);
+      if (ctx.nameMatch && !ctx.nameMatch(e.name, displayRel3(ctx.rootDir, full))) continue;
       if (ctx.isBinaryByName(e.name)) continue;
       let fh;
       try {
-        fh = await fs2.open(full, "r");
+        fh = await fs3.open(full, "r");
       } catch {
         continue;
       }
@@ -5987,25 +6176,45 @@ async function searchContent(ctx, startAbs, args) {
       const firstNul = raw.indexOf(0);
       if (firstNul !== -1 && firstNul < 8 * 1024) continue;
       const text = raw.toString("utf8");
-      const rel = displayRel2(ctx.rootDir, full);
+      const rel = displayRel3(ctx.rootDir, full);
       const lines = text.split(/\r?\n/);
+      const hits = [];
       for (let li = 0; li < lines.length; li++) {
         throwIfAborted(args.signal);
         const line = lines[li];
         const lineForCheck = caseSensitive ? line : line.toLowerCase();
         const hit = re ? re.test(line) : lineForCheck.includes(needle);
-        if (!hit) continue;
-        const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
-        const out = `${rel}:${li + 1}: ${display}`;
-        if (totalBytes + out.length + 1 > ctx.maxListBytes) {
-          matches.push(`[\u2026 truncated at ${ctx.maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
-          truncated = true;
-          return;
-        }
-        matches.push(out);
-        totalBytes += out.length + 1;
+        if (hit) hits.push(li);
       }
       scanned++;
+      if (hits.length === 0) continue;
+      if (ctxLines === 0) {
+        for (const li of hits) {
+          if (truncated) return;
+          const line = lines[li];
+          const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
+          if (!pushLine(`${rel}:${li + 1}: ${display}`)) return;
+        }
+        continue;
+      }
+      const hitSet = new Set(hits);
+      let prevWindowEnd = -2;
+      for (const li of hits) {
+        if (truncated) return;
+        const winStart = Math.max(0, li - ctxLines);
+        const winEnd = Math.min(lines.length - 1, li + ctxLines);
+        if (winStart > prevWindowEnd + 1 && prevWindowEnd >= 0) {
+          if (!pushLine("--")) return;
+        }
+        const realStart = winStart > prevWindowEnd + 1 ? winStart : prevWindowEnd + 1;
+        for (let i = realStart; i <= winEnd; i++) {
+          const line = lines[i];
+          const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
+          const sep2 = hitSet.has(i) ? ":" : "-";
+          if (!pushLine(`${rel}:${i + 1}${sep2} ${display}`)) return;
+        }
+        prevWindowEnd = winEnd;
+      }
     }
   };
   await walk2(startAbs);
@@ -6023,8 +6232,8 @@ var AUTO_PREVIEW_HEAD_LINES = 80;
 var AUTO_PREVIEW_TAIL_LINES = 40;
 var SKIP_DIR_NAMES = new Set(DEFAULT_INDEX_EXCLUDES.dirs);
 var BINARY_EXTENSIONS = new Set(DEFAULT_INDEX_EXCLUDES.exts);
-function displayRel3(rootDir, full) {
-  return pathMod3.relative(rootDir, full).replaceAll("\\", "/");
+function displayRel4(rootDir, full) {
+  return pathMod4.relative(rootDir, full).replaceAll("\\", "/");
 }
 var GLOB_METACHARS = /[*?{[]/;
 function compileNameFilter(filter) {
@@ -6034,7 +6243,7 @@ function compileNameFilter(filter) {
     return (name) => name.toLowerCase().includes(needle);
   }
   const matchPath = filter.includes("/");
-  const isMatch = picomatch2(filter, { dot: true, nocase: true });
+  const isMatch = picomatch3(filter, { dot: true, nocase: true });
   return matchPath ? (_n, rel) => isMatch(rel) : (name) => isMatch(name);
 }
 function isLikelyBinaryByName(name) {
@@ -6043,7 +6252,7 @@ function isLikelyBinaryByName(name) {
   return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
 function registerFilesystemTools(registry, opts) {
-  const rootDir = pathMod3.resolve(opts.rootDir);
+  const rootDir = pathMod4.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
   const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
   const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
@@ -6056,10 +6265,10 @@ function registerFilesystemTools(registry, opts) {
       normalized = normalized.slice(1);
     }
     if (normalized.length === 0) normalized = ".";
-    const resolved = pathMod3.resolve(rootDir, normalized);
-    const normRoot = pathMod3.resolve(rootDir);
-    const rel = pathMod3.relative(normRoot, resolved);
-    if (rel.startsWith("..") || pathMod3.isAbsolute(rel)) {
+    const resolved = pathMod4.resolve(rootDir, normalized);
+    const normRoot = pathMod4.resolve(rootDir);
+    const rel = pathMod4.relative(normRoot, resolved);
+    if (rel.startsWith("..") || pathMod4.isAbsolute(rel)) {
       throw new Error(
         `path escapes sandbox root (${normRoot}): ${raw} \u2014 workspace is pinned at launch; quit and relaunch with \`reasonix code --dir <path>\` to work in a different folder`
       );
@@ -6091,7 +6300,7 @@ 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 fh = await fs3.open(abs, "r");
+      const fh = await fs4.open(abs, "r");
       let raw;
       try {
         const stat2 = await fh.stat();
@@ -6165,7 +6374,7 @@ ${slice.join("\n")}`;
     },
     fn: async (args) => {
       const abs = safePath(args.path ?? ".");
-      const entries = await fs3.readdir(abs, { withFileTypes: true });
+      const entries = await fs4.readdir(abs, { withFileTypes: true });
       const lines = [];
       for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         lines.push(e.isDirectory() ? `${e.name}/` : e.name);
@@ -6209,7 +6418,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
         if (depth > maxDepth) return;
         let entries;
         try {
-          entries = await fs3.readdir(dir, { withFileTypes: true });
+          entries = await fs4.readdir(dir, { withFileTypes: true });
         } catch {
           return;
         }
@@ -6244,7 +6453,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
           lines.push(line);
           emitted++;
           if (e.isDirectory() && !skip) {
-            await walk2(pathMod3.join(dir, e.name), depth + 1);
+            await walk2(pathMod4.join(dir, e.name), depth + 1);
           }
         }
       };
@@ -6305,6 +6514,10 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
         include_deps: {
           type: "boolean",
           description: "When true, also search inside node_modules / .git / dist / build / etc. Off by default \u2014 most exploration questions are about the user's own code."
+        },
+        context: {
+          type: "integer",
+          description: "Lines of context to show around each match (both before and after). Default 0 (just the matching line). Capped at 20. Output uses ripgrep style: `:` after the line number on the matching line, `-` on context lines, `--` separating non-adjacent windows."
         }
       },
       required: ["pattern"]
@@ -6321,6 +6534,43 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
       { ...args, signal: toolCtx?.signal }
     )
   });
+  registry.register({
+    name: "glob",
+    parallelSafe: true,
+    description: "List files matching a glob pattern, sorted by mtime (most-recently-modified first) by default. Use this for 'what changed lately', 'find all *.test.ts', 'all configs under src/'. Glob syntax matches the cross-tool standard: `*` (any chars in one segment), `**` (any segments), `?` (one char), `{a,b}` (alternation). Pattern matches against the path RELATIVE to the search root (e.g. 'src/**/*.ts' from project root). Skips node_modules / .git / dist / build / etc by default. Default limit 200; raise via `limit` (max 1000). Different from `search_files` (substring on basename) and `search_content` (matches inside file contents).",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Glob pattern, e.g. 'src/**/*.ts', '**/*.{md,mdx}', 'tests/*.test.ts'."
+        },
+        path: {
+          type: "string",
+          description: "Base directory to walk (default: sandbox root). The pattern matches relative to this path."
+        },
+        sort_by: {
+          type: "string",
+          enum: ["mtime", "name"],
+          description: "Sort order. 'mtime' (default) shows most-recently-modified first \u2014 useful for 'what did I change today'. 'name' is alphabetical."
+        },
+        include_deps: {
+          type: "boolean",
+          description: "When true, also walk node_modules / .git / dist / build / etc. Off by default."
+        },
+        limit: {
+          type: "integer",
+          description: "Cap on returned matches. Default 200; clamped to [1, 1000]."
+        }
+      },
+      required: ["pattern"]
+    },
+    fn: async (args, toolCtx) => globFiles({ rootDir, skipDirNames: SKIP_DIR_NAMES }, safePath(args.path ?? "."), {
+      ...args,
+      signal: toolCtx?.signal
+    })
+  });
   registry.register({
     name: "get_file_info",
     parallelSafe: true,
@@ -6335,7 +6585,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      const st = await fs3.lstat(abs);
+      const st = await fs4.lstat(abs);
       const type = st.isDirectory() ? "directory" : st.isSymbolicLink() ? "symlink" : "file";
       return JSON.stringify({
         type,
@@ -6358,9 +6608,9 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      await fs3.mkdir(pathMod3.dirname(abs), { recursive: true });
-      await fs3.writeFile(abs, args.content, "utf8");
-      return `wrote ${args.content.length} chars to ${displayRel3(rootDir, abs)}`;
+      await fs4.mkdir(pathMod4.dirname(abs), { recursive: true });
+      await fs4.writeFile(abs, args.content, "utf8");
+      return `wrote ${args.content.length} chars to ${displayRel4(rootDir, abs)}`;
     }
   });
   registry.register({
@@ -6377,6 +6627,43 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args) => applyEdit(rootDir, safePath(args.path), args)
   });
+  registry.register({
+    name: "multi_edit",
+    description: "Apply N SEARCH/REPLACE edits across ONE OR MORE files in a single atomic call. Edits run sequentially in array order; for edits that touch the same file, a later edit can match text inserted by an earlier one. If ANY edit fails (search not found, ambiguous match, empty search, file unreadable), NO files are written \u2014 atomic at the validation layer. Same per-edit rules as edit_file: `search` is exact text (whitespace sensitive, no regex) and must be unique in its target file at the moment that edit applies. Use this for renames spanning multiple files, cross-file refactors, or any batch where you'd otherwise loop edit_file.",
+    parameters: {
+      type: "object",
+      properties: {
+        edits: {
+          type: "array",
+          description: "Edits to apply in order. Length \u2265 1. Each edit names its own target file.",
+          items: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "File the edit targets (sandbox-relative or absolute)."
+              },
+              search: {
+                type: "string",
+                description: "Exact text to find (must be unique in the file)."
+              },
+              replace: { type: "string", description: "Text to substitute in place of `search`." }
+            },
+            required: ["path", "search", "replace"]
+          }
+        }
+      },
+      required: ["edits"]
+    },
+    fn: async (args) => {
+      const resolved = (args.edits ?? []).map((e) => ({
+        abs: safePath(e?.path),
+        search: e?.search,
+        replace: e?.replace
+      }));
+      return applyMultiEdit(rootDir, resolved);
+    }
+  });
   registry.register({
     name: "create_directory",
     description: "Create a directory (and any missing parents) under the sandbox root.",
@@ -6387,8 +6674,8 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     },
     fn: async (args) => {
       const abs = safePath(args.path);
-      await fs3.mkdir(abs, { recursive: true });
-      return `created ${displayRel3(rootDir, abs)}/`;
+      await fs4.mkdir(abs, { recursive: true });
+      return `created ${displayRel4(rootDir, abs)}/`;
     }
   });
   registry.register({
@@ -6405,9 +6692,9 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
     fn: async (args) => {
       const src = safePath(args.source);
       const dst = safePath(args.destination);
-      await fs3.mkdir(pathMod3.dirname(dst), { recursive: true });
-      await fs3.rename(src, dst);
-      return `moved ${displayRel3(rootDir, src)} \u2192 ${displayRel3(rootDir, dst)}`;
+      await fs4.mkdir(pathMod4.dirname(dst), { recursive: true });
+      await fs4.rename(src, dst);
+      return `moved ${displayRel4(rootDir, src)} \u2192 ${displayRel4(rootDir, dst)}`;
     }
   });
   return registry;
@@ -6886,6 +7173,108 @@ function registerPlanTool(registry, opts = {}) {
   return registry;
 }
 
+// src/tools/todo.ts
+var DESCRIPTION = 'In-session task tracker for multi-step work. NOT a plan \u2014 no approval gate, no checkpoint pauses, doesn\'t touch any files. The tool replaces the entire todo list every call (set semantics, NOT append). Pass the FULL list every time.\n\nWhen to use:\n\u2022 The task has 3+ distinct steps and you want to keep them straight as you work.\n\u2022 The user gave you a multi-part request ("do A, then B, then C").\n\u2022 You\'re partway through a long task and want to record where you are so a future you doesn\'t lose the thread.\n\nWhen NOT to use:\n\u2022 One-shot edits, single-question answers, single-tool tasks.\n\u2022 User-facing approval gates \u2192 that\'s `submit_plan`.\n\u2022 Branching choices \u2192 that\'s `ask_choice`.\n\nRules:\n\u2022 Exactly ONE todo may have status:"in_progress" at a time (or zero \u2014 between steps).\n\u2022 Mark a todo "completed" the moment it\'s actually done \u2014 don\'t batch.\n\u2022 Each todo: `content` (imperative, e.g. "Add tests"), `activeForm` (gerund shown while running, e.g. "Adding tests"), `status`.\n\u2022 Empty `todos:[]` is allowed \u2014 it clears the list when work is fully done.';
+function validateTodos(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("todo_write: `todos` must be an array");
+  }
+  const out = [];
+  let inProgressCount = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const entry = raw[i];
+    if (!entry || typeof entry !== "object") {
+      throw new Error(`todo_write: todo #${i + 1} must be an object`);
+    }
+    const e = entry;
+    const content = typeof e.content === "string" ? e.content.trim() : "";
+    const activeForm = typeof e.activeForm === "string" ? e.activeForm.trim() : "";
+    const status = e.status;
+    if (!content) {
+      throw new Error(`todo_write: todo #${i + 1} \`content\` must be a non-empty string`);
+    }
+    if (!activeForm) {
+      throw new Error(`todo_write: todo #${i + 1} \`activeForm\` must be a non-empty string`);
+    }
+    if (status !== "pending" && status !== "in_progress" && status !== "completed") {
+      throw new Error(
+        `todo_write: todo #${i + 1} \`status\` must be one of pending|in_progress|completed (got ${JSON.stringify(status)})`
+      );
+    }
+    if (status === "in_progress") {
+      inProgressCount++;
+      if (inProgressCount > 1) {
+        throw new Error(
+          "todo_write: at most one todo may be in_progress at a time \u2014 mark the previous one completed first"
+        );
+      }
+    }
+    out.push({ content, status, activeForm });
+  }
+  return out;
+}
+function renderTodos(todos) {
+  if (todos.length === 0) return "todos cleared (0 items)";
+  let done = 0;
+  let inProgress = 0;
+  let pending = 0;
+  for (const t2 of todos) {
+    if (t2.status === "completed") done++;
+    else if (t2.status === "in_progress") inProgress++;
+    else pending++;
+  }
+  const header = `todos updated \xB7 ${done} done \xB7 ${inProgress} in progress \xB7 ${pending} pending`;
+  const lines = todos.map((t2) => {
+    if (t2.status === "completed") return `[x] ${t2.content}`;
+    if (t2.status === "in_progress") return `[>] ${t2.activeForm}`;
+    return `[ ] ${t2.content}`;
+  });
+  return `${header}
+${lines.join("\n")}`;
+}
+function registerTodoTool(registry, opts = {}) {
+  registry.register({
+    name: "todo_write",
+    description: DESCRIPTION,
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        todos: {
+          type: "array",
+          description: "The COMPLETE new todo list. Replaces whatever was there before. Pass [] to clear.",
+          items: {
+            type: "object",
+            properties: {
+              content: {
+                type: "string",
+                description: 'Imperative step description, e.g. "Add tests for parser".'
+              },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed"],
+                description: "Current state. Exactly one item may be in_progress."
+              },
+              activeForm: {
+                type: "string",
+                description: 'Gerund form shown while in_progress, e.g. "Adding tests for parser".'
+              }
+            },
+            required: ["content", "status", "activeForm"]
+          }
+        }
+      },
+      required: ["todos"]
+    },
+    fn: async (args) => {
+      const todos = validateTodos(args?.todos);
+      opts.onTodosUpdated?.(todos);
+      return renderTodos(todos);
+    }
+  });
+  return registry;
+}
+
 // src/tools/subagent-types.ts
 var EXPLORE_SYSTEM = `You are an exploration subagent. Wide-net read-only investigation; return one distilled answer.
 
@@ -7255,11 +7644,11 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 }
 
 // src/tools/shell.ts
-import * as pathMod7 from "path";
+import * as pathMod8 from "path";
 
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
-import * as pathMod4 from "path";
+import * as pathMod5 from "path";
 function killProcessTree(pid, signal) {
   if (process.platform === "win32") {
     const args = ["/pid", String(pid), "/T"];
@@ -7319,7 +7708,7 @@ var JobRegistry = class {
     const maxBytes = opts.maxBufferBytes ?? DEFAULT_OUTPUT_CAP_BYTES;
     const { bin, args, spawnOverrides } = prepareSpawn(argv);
     const spawnOpts = {
-      cwd: pathMod4.resolve(opts.cwd),
+      cwd: pathMod5.resolve(opts.cwd),
       shell: false,
       windowsHide: true,
       env: process.env,
@@ -7605,12 +7994,12 @@ function latestOutputSince(before, after) {
 // src/tools/shell/exec.ts
 import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync8, statSync as statSync4 } from "fs";
-import * as pathMod6 from "path";
+import * as pathMod7 from "path";
 
 // src/tools/shell-chain.ts
 import { spawn as spawn3 } from "child_process";
 import { closeSync, openSync } from "fs";
-import * as pathMod5 from "path";
+import * as pathMod6 from "path";
 var UnsupportedSyntaxError = class extends Error {
   constructor(detail) {
     super(`run_command: ${detail}`);
@@ -7877,7 +8266,7 @@ function openRedirects(redirects, cwd) {
   let bothFd = null;
   const toClose = [];
   const open = (target, flags) => {
-    const resolved = pathMod5.resolve(cwd, target);
+    const resolved = pathMod6.resolve(cwd, target);
     const fd = openSync(resolved, flags);
     toClose.push(fd);
     return fd;
@@ -8373,16 +8762,16 @@ function resolveExecutable(cmd, opts = {}) {
   const platform = opts.platform ?? process.platform;
   if (platform !== "win32") return cmd;
   if (!cmd) return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || pathMod6.isAbsolute(cmd)) return cmd;
-  if (pathMod6.extname(cmd)) return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod7.isAbsolute(cmd)) return cmd;
+  if (pathMod7.extname(cmd)) return cmd;
   const env = opts.env ?? process.env;
   const pathExt = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
-  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod6.delimiter);
+  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod7.delimiter);
   const pathDirs = (env.PATH ?? "").split(delimiter2).filter(Boolean);
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod6.win32.join(dir, cmd + ext);
+      const full = pathMod7.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -8452,8 +8841,8 @@ function withUtf8Codepage(cmdline) {
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
-  if (pathMod6.isAbsolute(s)) return false;
-  if (pathMod6.extname(s)) return false;
+  if (pathMod7.isAbsolute(s)) return false;
+  if (pathMod7.extname(s)) return false;
   return true;
 }
 function quoteForCmdExe(arg) {
@@ -8474,7 +8863,7 @@ var NeedsConfirmationError = class extends Error {
   }
 };
 function registerShellTools(registry, opts) {
-  const rootDir = pathMod7.resolve(opts.rootDir);
+  const rootDir = pathMod8.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const jobs = opts.jobs ?? new JobRegistry();
@@ -9519,7 +9908,7 @@ function truncate(s, n) {
 // src/version.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname6, join as join11 } from "path";
+import { dirname as dirname6, join as join12 } 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;
@@ -9528,7 +9917,7 @@ function readPackageVersion() {
   try {
     let dir = dirname6(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const p = join11(dir, "package.json");
+      const p = join12(dir, "package.json");
       if (existsSync9(p)) {
         const pkg = JSON.parse(readFileSync12(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
@@ -9545,7 +9934,7 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join11(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
+  return join12(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
 }
 function readCache(homeDirOverride) {
   try {
@@ -10539,8 +10928,8 @@ function lineEndingOf(text) {
 
 // src/code/prompt.ts
 import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
-import { join as join12 } 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.
+import { join as join13 } from "path";
+var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, edit_file, multi_edit, list_directory, directory_tree, search_files, search_content, glob, get_file_info) rooted at the user's working directory, plus run_command / run_background for shell, plus \`todo_write\` for in-session multi-step tracking.
 
 # Cite or shut up \u2014 non-negotiable
 
@@ -10588,10 +10977,23 @@ Skip it when one option is clearly correct (just do it, or submit_plan) or a fre
 
 Each option: short stable id (A/B/C), one-line title, optional summary. \`allowCustom: true\` when their real answer might not fit. Max 6. A ~1-sentence lead-in before the call is fine ("I see three directions \u2014 letting you pick"); don't repeat the options in it. After the call, STOP.
 
+# When to track multi-step intent (todo_write)
+
+\`todo_write\` is a lightweight in-session task tracker \u2014 NOT a plan. No approval gate, no checkpoint pauses, doesn't touch files. Use it when the task has 3+ distinct steps and you'd otherwise lose track of where you are. Each call REPLACES the entire list (set semantics). Exactly one item may be \`in_progress\` at a time \u2014 flip it to \`completed\` the moment that step's done, before starting the next.
+
+Use it for:
+- Multi-part user requests ("do A, then B, then C") \u2014 record the parts so you don't drop one.
+- Long refactors where you've finished step 2 of 5 and want a visible record.
+- Any moment where you'd otherwise enumerate "1. ... 2. ... 3. ..." in prose \u2014 the tool is strictly better, the UI shows progress live.
+
+Skip it for: one-shot edits, single-question answers, anything that fits in one tool call. Don't \`todo_write\` and \`submit_plan\` for the same work \u2014 \`submit_plan\` is for tasks that need a review gate; \`todo_write\` is for personal bookkeeping after the user has already given you the green light.
+
+Call shape: \`{ todos: [{ content, activeForm, status }, ...] }\` \u2014 \`content\` is imperative ("Add tests"), \`activeForm\` is gerund ("Adding tests") shown while \`in_progress\`. Pass the FULL list every call, not a delta. Pass \`todos: []\` to clear when work's done.
+
 # Plan mode (/plan)
 
 The user can ALSO enter "plan mode" via /plan, which is a stronger, explicit constraint:
-- Write tools (edit_file, write_file, create_directory, move_file) and non-allowlisted run_command calls are BOUNCED at dispatch \u2014 you'll get a tool result like "unavailable in plan mode". Don't retry them.
+- Write tools (edit_file, multi_edit, write_file, create_directory, move_file) and non-allowlisted run_command calls are BOUNCED at dispatch \u2014 you'll get a tool result like "unavailable in plan mode". Don't retry them.
 - Read tools (read_file, list_directory, search_files, directory_tree, get_file_info) and allowlisted read-only / test shell commands still work \u2014 use them to investigate.
 - You MUST call submit_plan before anything will execute. Approve exits plan mode; Refine stays in; Cancel exits without implementing.
 
@@ -10660,6 +11062,7 @@ Rules:
     >>>>>>> REPLACE
 - Do NOT use write_file to change existing files \u2014 the user reviews your edits as SEARCH/REPLACE. write_file is only for files you explicitly want to overwrite wholesale (rare).
 - Paths are relative to the working directory. Don't use absolute paths.
+- For multi-site changes \u2014 same file or across files \u2014 prefer \`multi_edit\` over N \`edit_file\` calls. Shape: \`{ edits: [{ path, search, replace }, ...] }\`. All edits validate before any file is written; any failure \u2192 ALL files untouched. Per-file edits run in array order, so a later edit can match text inserted by an earlier one.
 
 # Trust what you already know
 
@@ -10669,7 +11072,7 @@ Before exploring the filesystem to answer a factual question, check whether the
 
 - Skip dependency, build, and VCS directories unless the user explicitly asks. The pinned .gitignore block (if any, below) is your authoritative denylist.
 - Prefer \`search_files\` over \`list_directory\` when you know roughly what you're looking for \u2014 it saves context and avoids enumerating huge trees. Note: \`search_files\` matches file NAMES; for searching file CONTENTS use \`search_content\`.
-- Available exploration tools: \`read_file\`, \`list_directory\`, \`directory_tree\`, \`search_files\` (filename match), \`search_content\` (content grep \u2014 use for "where is X called", "find all references to Y"), \`get_file_info\`. Don't call \`grep\` or other tools that aren't in this list \u2014 they don't exist as functions.
+- Available exploration tools: \`read_file\`, \`list_directory\`, \`directory_tree\`, \`search_files\` (filename match), \`glob\` (mtime-sorted glob \u2014 use for "what changed lately", "all *.ts under src/"), \`search_content\` (content grep \u2014 use for "where is X called", "find all references to Y"; pass \`context:N\` for grep -C N around hits), \`get_file_info\`. Don't call \`grep\` or other tools that aren't in this list \u2014 they don't exist as functions.
 
 # Path conventions
 
@@ -10742,7 +11145,7 @@ 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 = join12(rootDir, ".gitignore");
+  const gitignorePath = join13(rootDir, ".gitignore");
   let result = withMemory;
   if (existsSync11(gitignorePath)) {
     let content;
@@ -10793,9 +11196,9 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname8, join as join13 } from "path";
+import { dirname as dirname8, join as join14 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
-  return join13(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
+  return join14(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
 var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
 var USAGE_RETENTION_DAYS = 365;
@@ -11112,6 +11515,7 @@ export {
   registerPlanTool,
   registerShellTools,
   registerSubagentTool,
+  registerTodoTool,
   registerWebTools,
   renderMarkdown as renderDiffMarkdown,
   renderSummaryTable as renderDiffSummary,