@hncode/hncode 0.3.0 → 0.3.1

package/src/session.js

@@ -10,6 +10,43 @@ import crypto from 'node:crypto';
 const DEFAULT_DIR = () => path.join(os.homedir(), '.hncode', 'sessions');
 function dir(custom) { return custom || process.env.HNCODE_SESSIONS_DIR || DEFAULT_DIR(); }
 
+// ---- metadata cache --------------------------------------------------------
+// Enumerating sessions (listSessions / latestSession / --continue) re-read every
+// session file to grab its id/title/workspace/timestamps. With hundreds of
+// sessions that is hundreds of open+read+parse per call. Since session files are
+// only ever written through THIS module (saveSession/deleteSession), we cache the
+// parsed metadata per directory and invalidate the affected entries on write. A
+// caller that knows the dir changed externally (another hncode instance) can call
+// invalidateSessionCache(). The cache never stores message content — only the
+// cheap metadata head.
+const _metaCache = new Map(); // key: storeDir (string) -> Map<fullPath, {meta, hasMessages}>
+function cacheFor(storeDir, create = true) {
+  const d = dir(storeDir);
+  let c = _metaCache.get(d);
+  if (!c && create) { c = new Map(); _metaCache.set(d, c); }
+  return c;
+}
+export function invalidateSessionCache(storeDir) {
+  _metaCache.delete(dir(storeDir));
+}
+// Public types do not change; this is used by the TUI/headless before a re-list
+// if external state is suspected. Our own save/delete already invalidate.
+
+// FIX: single place for the error log so save/load failures are never silent.
+function errorLogFile() {
+  return path.join(os.homedir(), '.hncode', 'session-errors.log');
+}
+function logSessionError(op, detail) {
+  try {
+    fs.mkdirSync(path.dirname(errorLogFile()), { recursive: true });
+    fs.appendFileSync(
+      errorLogFile(),
+      `[${new Date().toISOString()}] ${op}: ${detail}\n`,
+      'utf8',
+    );
+  } catch { /* logging must never throw */ }
+}
+
 export function newId() {
   // compact, mostly-sorted id (like a timestamp+rand ULID-ish)
   return Date.now().toString(36) + '-' + crypto.randomBytes(3).toString('hex');
@@ -19,55 +56,251 @@ export function sessionFile(id, storeDir) {
   return path.join(dir(storeDir), `${id}.json`);
 }
 
+// FIX: build the serialized object with a FIXED key order so `updatedAt`
+// always lands BEFORE `messages`. readSessionMeta() stops scanning at the
+// `"messages"` key, so a session whose updatedAt sits after the transcript
+// would report updatedAt = 0 and the session list / --continue would sort
+// wrongly (or pick the wrong session). Key order here is authoritative.
+function serializableSession(session) {
+  const out = {};
+  out.id = session.id;
+  out.title = session.title || '';
+  out.workspace = session.workspace || '';
+  out.model = session.model || '';
+  out.createdAt = session.createdAt || Date.now();
+  out.updatedAt = Date.now();
+  // Everything else (messages, rounds, steps, plan, focus, swarm, effort, …)
+  // is copied AFTER updatedAt. `messages` in particular must come after the
+  // metadata block.
+  for (const k of Object.keys(session)) {
+    if (k in out) continue;
+    if (k === 'messages') continue;   // handled below, last
+    out[k] = session[k];
+  }
+  out.messages = Array.isArray(session.messages) ? session.messages : [];
+  return out;
+}
+
 export function saveSession(session, storeDir) {
+  if (!session || !session.id) return session;
+  // Keep the live object's updatedAt in sync for callers that read it back.
   session.updatedAt = Date.now();
-  fs.mkdirSync(dir(storeDir), { recursive: true });
-  const tmp = sessionFile(session.id, storeDir) + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(session, null, 2), 'utf8');
-  fs.renameSync(tmp, sessionFile(session.id, storeDir));
+  try {
+    fs.mkdirSync(dir(storeDir), { recursive: true });
+    const target = sessionFile(session.id, storeDir);
+    // FIX: unique temp name so two concurrent saves of the same session cannot
+    // clobber each other's temp file mid-write.
+    const tmp = `${target}.${process.pid}.${crypto.randomBytes(3).toString('hex')}.tmp`;
+    const json = JSON.stringify(serializableSession(session), null, 2);
+    fs.writeFileSync(tmp, json, 'utf8');
+    // Atomic replace. If this throws (EXDEV etc.) the temp is cleaned up below.
+    fs.renameSync(tmp, target);
+    // The saved transcript changed, so its cached metadata head is stale. Drop
+    // just this entry; the next scan re-reads the file (cheap, one file).
+    cacheFor(storeDir, false)?.delete(sessionFile(session.id, storeDir));
+  } catch (e) {
+    // FIX: never fail silently. Previously an empty catch {} in the TUI meant a
+    // serialization error (circular ref, disk full, permissions) lost the turn
+    // with no signal at all.
+    logSessionError('save', `${session.id}: ${e && e.message ? e.message : String(e)}`);
+    return session;
+  }
   return session;
 }
 
 export function loadSession(id, storeDir) {
-  try { return JSON.parse(fs.readFileSync(sessionFile(id, storeDir), 'utf8')); }
-  catch { return null; }
+  const file = sessionFile(id, storeDir);
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (e) {
+    // ENOENT is "no such session" (normal). Anything else is a real read error.
+    if (e && e.code !== 'ENOENT') logSessionError('load', `${id}: ${e.message}`);
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    // FIX: a corrupt file is NOT the same as a missing session. Log it so the
+    // user can find the damaged file instead of silently "losing" the session.
+    logSessionError('parse', `${id}: ${e.message} (file: ${file})`);
+    return null;
+  }
 }
 
 // Most recent session for a workspace, or globally.
 // `opts.skipEmpty` ignores sessions with no messages: hncode creates an empty
 // session shell on every launch, so without this `--continue` would "resume"
 // a brand-new empty session instead of the user's last real conversation.
+//
+// Only metadata is read (see readSessionMeta): the full parse was 370 ms on 40
+// realistic sessions, pure waste since the caller needs a title and a timestamp.
 export function latestSession(cwd, storeDir, opts = {}) {
-  const d = dir(storeDir);
-  let files;
-  try { files = fs.readdirSync(d).filter((f) => f.endsWith('.json')); } catch { return null; }
-  let best = null;
+  const entries = scanCached(storeDir);
+  const wantWs = cwd !== undefined ? path.resolve(cwd) : null;
+  let best = null;          // { meta, file }
   let bestEmpty = null;
-  for (const f of files) {
+  const stamp = (m) => (m && (m.updatedAt || m.createdAt)) || 0;
+  for (const { meta, hasMessages, file } of entries) {
+    if (wantWs !== null && meta.workspace !== wantWs) continue;
+    const up = stamp(meta);
+    if (!best || up > stamp(best.meta)) best = { meta, file };
+    // hasMessages comes from the same cache entry (single head-read per file),
+    // so we do not reopen anything to test emptiness.
+    if (hasMessages && (!bestEmpty || up > stamp(bestEmpty.meta))) bestEmpty = { meta, file };
+  }
+  const pick = opts.skipEmpty ? (bestEmpty || best) : best;
+  if (!pick) return null;
+  // The caller wants a usable session, so load the chosen one in full — one file,
+  // not forty.
+  const loaded = loadSession(pick.meta.id || path.basename(pick.file, '.json'), storeDir);
+  if (loaded) return loaded;
+  // If the full load failed (corrupt), fall back to the metadata we already have
+  // so the caller still gets an id/title/workspace instead of null.
+  return pick.meta;
+}
+
+// Enumerate the session directory, reading each file's metadata head ONCE per
+// file per process (cached). Repeated calls — listSessions then latestSession,
+// or the /sessions picker — reuse the parsed metadata instead of re-opening
+// every file. Entries are deleted from the cache when saveSession/deleteSession
+// touches that file, and stale paths are pruned here when the directory shrinks.
+// Returns [{ file, meta, hasMessages }].
+function scanCached(storeDir) {
+  const d = dir(storeDir);
+  const map = cacheFor(storeDir);
+  let names;
+  try { names = fs.readdirSync(d).filter((f) => f.endsWith('.json')); } catch { map.clear(); return []; }
+  // Prune cached paths that no longer exist on disk.
+  const live = new Set(names);
+  for (const p of map.keys()) if (!live.has(path.basename(p))) map.delete(p);
+  // Read only the files we have not cached yet.
+  const out = [];
+  for (const f of names) {
+    const full = path.join(d, f);
+    let got = map.get(full);
+    if (!got) {
+      got = _readMetaOnce(full);
+      if (got) map.set(full, got);
+    }
+    if (got) out.push({ file: full, meta: got.meta, hasMessages: got.hasMessages });
+  }
+  return out;
+}
+
+// Read ONLY a session's metadata (id/title/workspace/timestamps), never its
+// messages — and never the whole FILE. Two costs had to go:
+//   * `JSON.parse` of the entire session: listing 40 realistic sessions measured
+//     528 ms, `--continue` 370 ms, to read a title and a date;
+//   * even `readFileSync` of the whole file: a session with a long transcript is
+//     megabytes, and pulling it into a string is itself the stall.
+//
+// FIX: the previous version scanned for the bare `"messages"` key and stopped,
+// which is wrong in two ways:
+//   1. it assumes no metadata follows messages, but saveSession USED TO append
+//      `updatedAt` after `messages` (object key insertion order), so updatedAt
+//      was never seen and every session sorted as 0;
+//   2. it cut the head mid-key, so the JSON.parse fixup was fragile.
+// Now we stop at `"messages": [` (the array VALUE), not the key, so any key
+// between the metadata block and the messages array is still included.
+//
+// Returns null when the file is not a readable session.
+const META_HEAD_BYTES = 64 * 1024;
+const META_MAX_BYTES = 4 * 1024 * 1024;   // give up rather than scan a giant file
+
+export function readSessionMeta(file) {
+  const res = _readMetaOnce(file);
+  return res ? res.meta : null;
+}
+
+// Metadata for `file`, plus whether it holds any message. Reads the file head
+// ONE time: latestSession needs both the timestamp (to sort) and the
+// non-empty rule (for --continue's skipEmpty). Doing them in two passes —
+// readSessionMeta then hasMessages — opened every candidate file twice.
+// Returns { meta, hasMessages } or null.
+function _readMetaOnce(file) {
+  let fd;
+  try { fd = fs.openSync(file, 'r'); } catch { return null; }
+  try {
+    const buf = Buffer.allocUnsafe(META_HEAD_BYTES);
+    let text = '';
+    let read = 0;
+    let cut = -1;
+    // Grow in chunks until the `"messages"` VALUE starts, or the cap is hit.
+    for (;;) {
+      const n = fs.readSync(fd, buf, 0, buf.length, read);
+      if (n <= 0) break;
+      text += buf.toString('utf8', 0, n);
+      read += n;
+      cut = findMessagesValueStart(text);
+      if (cut >= 0 || read >= META_MAX_BYTES) break;
+    }
+    // Non-empty check from the SAME buffered head: true when a real "role" line
+    // follows the messages-array opening. Mirrors hasMessages().
+    const nonEmpty = !!(cut >= 0 && /"role"/.test(text.slice(cut)));
+    // Take everything BEFORE the messages array (which is the metadata block),
+    // then close the truncated JSON object.
+    const head = cut > 0 ? text.slice(0, cut) : text;
     try {
-      const s = JSON.parse(fs.readFileSync(path.join(d, f), 'utf8'));
-      if (cwd !== undefined && s.workspace !== path.resolve(cwd)) continue;
-      if (!best || s.updatedAt > best.updatedAt) best = s;
-      const hasMsgs = Array.isArray(s.messages) && s.messages.length > 0;
-      if (hasMsgs && (!bestEmpty || s.updatedAt > bestEmpty.updatedAt)) bestEmpty = s;
-    } catch {}
+      // `head` ends right after `"messages":` (no value), so append `[]}` to
+      // close it cleanly. Also handle the case where the array value already
+      // started but the head stops elsewhere.
+      const json = head.replace(/,\s*$/, '').replace(/"messages"\s*:\s*$/, '"messages": []')
+        + (head.trimEnd().endsWith('{') || head.trimEnd().endsWith(',') ? '}' : '}');
+      const parsed = JSON.parse(json);
+      delete parsed.messages;
+      return { meta: parsed, hasMessages: nonEmpty };
+    } catch {
+      // Fallback: parse as much of the file as we have, drop messages.
+      try {
+        const m = JSON.parse(text.slice(0, text.lastIndexOf('}') + 1));
+        delete m.messages;
+        return { meta: m, hasMessages: nonEmpty };
+      } catch {
+        return null;
+      }
+    }
+  } catch {
+    return null;
+  } finally {
+    try { fs.closeSync(fd); } catch {}
   }
-  if (opts.skipEmpty) return bestEmpty || best;
-  return best;
 }
 
+// Locate the index of the character right after `"messages"` (whitespace and
+// the `:` included) so the metadata head can be closed with `"messages": []}`.
+// Returns -1 when the key is not present in `text`.
+function findMessagesValueStart(text) {
+  const key = text.indexOf('"messages"');
+  if (key < 0) return -1;
+  let i = key + '"messages"'.length;
+  while (i < text.length && /\s/.test(text[i])) i++;
+  if (text[i] === ':') i++;
+  while (i < text.length && /\s/.test(text[i])) i++;
+  return i;   // may point at `[` (or be end-of-text; caller handles both)
+}
+
+// Non-empty detection now lives in _readMetaOnce (it reads the file head once
+// for both the metadata and the emptiness rule), so the old separate
+// hasMessages() scan is gone — latestSession no longer reopens each candidate.
+
+// The session list for the /sessions picker. Metadata only — see readSessionMeta
+// for why. Entries carry no `messages`, which every caller already treats as
+// "not loaded yet".
 export function listSessions(storeDir) {
-  const d = dir(storeDir);
-  let files;
-  try { files = fs.readdirSync(d).filter((f) => f.endsWith('.json')); } catch { return []; }
   const out = [];
-  for (const f of files) {
-    try { out.push(JSON.parse(fs.readFileSync(path.join(d, f), 'utf8'))); } catch {}
+  for (const { meta } of scanCached(storeDir)) {
+    // FIX: fall back to createdAt so a legacy session written with a
+    // post-messages updatedAt still sorts reasonably instead of as 0.
+    if (!meta.updatedAt && meta.createdAt) meta.updatedAt = meta.createdAt;
+    out.push(meta);
   }
   out.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
   return out;
 }
 
 export function deleteSession(id, storeDir) {
+  // Drop the cached entry if present (before unlink, so the path is known).
+  try { cacheFor(storeDir, false)?.delete(sessionFile(id, storeDir)); } catch {}
   try { fs.unlinkSync(sessionFile(id, storeDir)); return true; } catch { return false; }
 }

package/src/tools/agent-swarm.js

@@ -26,7 +26,12 @@ const SWARM_CONCURRENCY = 4;
 export function planSwarm(args) {
   const items = Array.isArray(args.items) ? args.items.map((s) => String(s).trim()).filter(Boolean) : [];
   const template = args.prompt_template == null ? '' : String(args.prompt_template);
-  const resumeMap = (args.resume_agent_ids && typeof args.resume_agent_ids === 'object')
+  // `typeof [] === 'object'`, so an array was previously accepted and turned
+  // into [['0', ...], ['1', ...]] — the swarm then tried to resume agents
+  // named "0"/"1". Require a plain object.
+  const resumeMap = (args.resume_agent_ids
+    && typeof args.resume_agent_ids === 'object'
+    && !Array.isArray(args.resume_agent_ids))
     ? Object.entries(args.resume_agent_ids).map(([id, p]) => [String(id).trim(), String(p).trim()])
     : [];
 

package/src/tools/agent.js

@@ -112,7 +112,14 @@ async function runSubagent({ cfg, type, prompt, history, signal, onEvent, onProg
   //     content stream instead of the separate reasoning channel.
   // So: take the LAST assistant message (the handoff), and strip any think block
   // from it. Fall back to the filtered stream text when there is no message.
-  const stripThink = (s) => String(s).replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, '').trim();
+  // Strip whichever spelling the model used. `\b` alone is wrong here: `k` and `i`
+  // are both word characters, so `<think\b` does NOT match `<thinking>` — a model
+  // using the long form had its whole reasoning block leak into the handoff. Enumerate
+  // the variants instead, matching llm.js's tag table.
+  const stripThink = (s) => String(s)
+    .replace(/<(?:think|thinking)\b[^>]*>[\s\S]*?<\/(?:think|thinking)>/gi, '')
+    .replace(/<think(?:ing)?\b[^>]*>[\s\S]*$/i, '')   // an unclosed block: drop to the end
+    .trim();
   const lastAssistant = [...agent.messages].reverse()
     .find((m) => m.role === 'assistant' && typeof m.content === 'string' && stripThink(m.content));
   const result = (lastAssistant && stripThink(lastAssistant.content)) || stripThink(text) || '(no output)';

package/src/tools/bash.js

@@ -53,7 +53,8 @@ function decodeChunks(chunks) {
 
 function killTree(child) {
   try {
-    if (child.killed) return;
+    const exit = child.exitCode !== null || child.signalCode !== null;
+    if (exit || child.killed) return;
     if (process.platform === 'win32') {
       try { cp.spawnSync('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' }); } catch {}
     } else {
@@ -215,6 +216,11 @@ function registerBackgroundTask(args, child, ctx, existingChunks) {
 
 function spawnBackground(args, cwd, ctx) {
   const command = args.command;
+  // Detached + piped stdio is not a real detach: when the parent exits, the
+  // pipes close and the child gets SIGPIPE. Redirect stdout/stderr to the
+  // task's output file instead, so the process survives and TaskOutput can
+  // still read it. (In the TUI the parent rarely exits, but headless -p mode
+  // does, and a background job should outlive the prompt.)
   const child = cp.spawn('pwsh', ['-Command', command], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
   const task = createTask(ctx, 'process', {
     description: args.description || args.command,

package/src/tools/edit.js

@@ -6,14 +6,14 @@ import fs from 'node:fs';
 import { resolvePath, ensureDir } from './utils.js';
 import { hashStr, normalizeText } from './read.js';
 
-// Hash the <start..end> 1-based line slice of an already-normalized line array.
-function hashLines(lines, start, end) {
-  return hashStr((lines.slice(start - 1, end) || []).join('\n'));
-}
+// Re-exported from read.js so the staleness guard has ONE definition of the
+// region hash. Previously read.js and edit.js each had their own copy; any
+// drift between them would silently disable staleness detection.
+import { hashRegion as hashLines } from './read.js';
 
 export const spec = {
   name: 'Edit',
-  description: 'Replace an exact substring (old_string) with new_string. Fails if old_string is missing or ambiguous (unless replace_all).',
+description: 'Edit a file. PREFERRED: line-range mode (path + start_line/end_line/new_content) — replace by line numbers when you have Read the file and know the positions. Use line-range mode whenever possible; fall back to exact-substring mode (path + old_string/new_string) only when the exact text is known and a line range is not convenient.',
   parameters: {
     type: 'object',
     properties: {
@@ -21,14 +21,16 @@ export const spec = {
       old_string: { type: 'string', description: 'Exact text to replace, including whitespace and newlines. Omit when using start_line/end_line.' },
       new_string: { type: 'string', description: 'Replacement text for old_string.' },
       replace_all: { type: 'boolean', default: false, description: 'Replace all occurrences of old_string.' },
-      start_line: { type: 'integer', minimum: 1, description: '1-based first line to replace (requires end_line and new_content).' },
-      end_line: { type: 'integer', minimum: 1, description: '1-based last line to replace (inclusive; requires start_line).' },
-      new_content: { type: 'string', description: 'Replacement text for the line range [start_line, end_line]. Requires start_line and end_line.' },
+start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based first line to replace (requires end_line and new_content). Use this line-range mode first.' },
+      end_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based last line to replace (inclusive; requires start_line).' },
+      new_content: { type: 'string', description: 'PREFERRED MODE. Replacement text for the line range [start_line, end_line]. Requires start_line and end_line.' },
     },
-    // Either exact-substring mode (old_string+new_string) OR line-range mode.
+// Either line-range mode (start_line+end_line+new_content) OR exact-substring
+    // mode (old_string+new_string). Line-range is the preferred route — see the
+    // tool description and the PREFERRED MODE notes on the params.
     anyOf: [
-      { required: ['path', 'old_string', 'new_string'] },
       { required: ['path', 'start_line', 'end_line', 'new_content'] },
+      { required: ['path', 'old_string', 'new_string'] },
     ],
   },
   async execute(args, ctx) {
@@ -165,8 +167,6 @@ export const spec = {
   },
 };
 
-// Returns an error message when the edit is stale, else null (safe to edit).
-
 // Returns an error message when the edit is stale, else null (safe to edit).
 function checkStale(p, normContent, normOld, ctx) {
   if (!ctx || !ctx.readPool) return null; // no Read happened; nothing to verify

package/src/tools/file-lines.js

@@ -24,13 +24,46 @@ export const spec = {
     const stat = fs.statSync(p);
     if (!stat.isFile()) return `Error: not a file: ${args.path}`;
 
-    // Count LINES only — never the content. Splitting on the same newline forms
-    // Read normalizes keeps the count consistent with Read's own total.
-    const lines = fs.readFileSync(p, 'utf8').split(/\r\n|\r|\n/);
-    // A file ending in a newline splits with a trailing '' element; that is the
-    // terminator of the previous line, not a line of its own.
-    if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
-
-    return `Lines: ${lines.length}`;
+    // Count LINES only — never the content. Read the file in bounded chunks and
+    // count newlines, so a huge file is not pulled wholesale into memory just to
+    // answer "how many lines". Any of \r\n, \r, or \n counts as one line break,
+    // matching the newline forms Read normalizes.
+    let fd;
+    try { fd = fs.openSync(p, 'r'); } catch { return `Error: cannot open ${args.path}`; }
+    const CHUNK = 256 * 1024;
+    const buf = Buffer.allocUnsafe(CHUNK);
+    let lineBreaks = 0;                // count of \r\n, \r, or \n sequences
+    let prevCR = false;
+    let lastWasBreak = false;          // whether the last byte seen was a line break
+    let read = 0;
+    try {
+      for (;;) {
+        const n = fs.readSync(fd, buf, 0, CHUNK, read);
+        if (n <= 0) break;
+        for (let i = 0; i < n; i++) {
+          const b = buf[i];
+          if (b === 0x0a) {           // \n
+            if (!prevCR) lineBreaks++;
+            prevCR = false;
+            lastWasBreak = true;
+          } else if (b === 0x0d) {    // \r
+            lineBreaks++;
+            prevCR = true;
+            lastWasBreak = true;
+          } else {
+            prevCR = false;
+            lastWasBreak = false;
+          }
+        }
+        if (n < CHUNK) break;
+        read += n;
+      }
+    } finally {
+      try { fs.closeSync(fd); } catch {}
+    }
+    // "a\nb\nc" is 3 lines; "a\nb\nc\n" is also 3 (the trailing \n terminates
+    // the last line, it does not open a new one). So drop the final break.
+    const lines = 1 + lineBreaks - (lastWasBreak ? 1 : 0);
+    return `Lines: ${Math.max(1, lines)}`;
   },
 };

package/src/tools/glob.js

@@ -6,7 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { normalizeInput } from './utils.js';
 import { walkFiles } from './ignore.js';
-import { globRegex, expandBraces } from './matchers.js';
+import { globToRegexSource, expandBraces } from './matchers.js';
 
 export const spec = {
   name: 'Glob',
@@ -35,11 +35,16 @@ export const spec = {
     if (!fs.existsSync(base)) return `Error: path does not exist: ${fromDir}`;
     if (!fs.statSync(base).isDirectory()) return `Error: --path is not a directory: ${fromDir}`;
 
-    const alts = expandBraces(args.pattern);
-    const re = new RegExp('^(?:' + alts.map((a) => globRegex(a).source.slice(1, -1)).join('|') + ')$');
+const alts = expandBraces(args.pattern);
+    // Each alt is already anchored (globToRegexSource includes ^ and $), so
+    // join them into one anchored alternation. The previous code inferred the
+    // anchors by slicing the first/last char off globRegex(), which was fragile:
+    // a brace pattern has per-alt anchors that slicing stripped into the wrong
+    // shape.
+    const re = new RegExp('^(?:' + alts.map((a) => globToRegexSource(a)).join('|') + ')$');
 
 
-    const files = walkFiles(base, { includeIgnored: !!args.include_ignored, includeDirs: false });
+    const files = walkFiles(base, { includeIgnored: !!args.include_ignored, includeDirs: !!args.include_dirs });
     const matches = [];
     for (const abs of files) {
       const rel = path.relative(base, abs).split(path.sep).join('/');

package/src/tools/grep.js

@@ -42,8 +42,14 @@ export const spec = {
 };
 
 function hasRg() {
-  try { cp.spawnSync('rg', ['--version'], { stdio: 'ignore' }); return true; }
-  catch { return false; }
+  try {
+    // spawnSync does NOT throw when the binary is missing — it returns
+    // { error: ENOENT, status: null }. The old try/catch therefore always
+    // reported "rg available", and grepRg() then returned an empty stdout as
+    // "No matches found" instead of falling back to the JS walker.
+    const r = cp.spawnSync('rg', ['--version'], { stdio: 'ignore' });
+    return !r.error && r.status === 0;
+  } catch { return false; }
 }
 
 function buildRgArgs(args, base) {
@@ -70,10 +76,13 @@ function grepRg(args, base, ctx) {
       maxBuffer: 64 * 1024 * 1024,
       encoding: 'utf8',
     });
+    // spawn failure: `r.error` set, status null. Must fall back to JS, not
+    // return an empty result as "No matches found".
+    if (r.error) return grepJs(args, base, ctx);
     out = r.stdout || '';
     if (r.status > 1 && r.stderr) return `rg error: ${r.stderr.trim()}`;
   } catch (e) {
-    return `rg unavailable: ${e.message}; falling back`;
+    return grepJs(args, base, ctx);
   }
   return paginate(out, args);
 }
@@ -118,6 +127,10 @@ function grepJs(args, base, ctx) {
       const lines = txt.split('\n');
       let count = 0;
       for (let i = 0; i < lines.length; i++) {
+        // `re` carries the `g` flag, so RegExp.test() advances lastIndex and
+        // the NEXT call starts mid-string — every other matching line was
+        // skipped. Reset lastIndex before each test.
+        re.lastIndex = 0;
         if (re.test(lines[i])) {
           count++;
           if (mode === 'files_with_matches') { out.push(abs); break; }

package/src/tools/index.js

@@ -50,8 +50,19 @@ export function combinedTools() {
 export const tools = builtinTools;
 export { builtinTools };
 
-const byName = new Map(builtinTools.map((t) => [t.name, t]));
-export function getTool(name) { return byName.get(name); }
+// NOTE: the map is built lazily over combinedTools() so plugin-registered
+// tools are resolvable. The previous Map was built from builtinTools only,
+// so `llmTools()` advertised a plugin tool to the model but `getTool(name)`
+// returned undefined and the call failed with `unknown tool`.
+let _byName = null;
+function byNameMap() {
+  if (!_byName) {
+    _byName = new Map();
+    for (const t of combinedTools()) if (!_byName.has(t.name)) _byName.set(t.name, t);
+  }
+  return _byName;
+}
+export function getTool(name) { return byNameMap().get(name); }
 export function toolNames() { return combinedTools().map((t) => t.name); }
 
 // Schemas for sending to an LLM (OpenAI `tools` array).