@monoes/monomindcli 2.0.3 → 2.1.3

package/.claude/helpers/intelligence.cjs

@@ -13,6 +13,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { claimLock, releaseLock } = require('./utils/fs-helpers.cjs');
 
 // Resolve base dir at require-time so tests can inject CLAUDE_PROJECT_DIR
 // per fresh require() call.
@@ -35,6 +36,76 @@ function ensureDataDir() {
   try { fs.mkdirSync(DATA_DIR, { recursive: true }); } catch (_) {}
 }
 
+// ── multi-process-safe store flush (P1-14) ──────────────────────────────────
+// STORE_FILE (auto-memory-store.json) is read once into `_entries` at init()
+// and can be written by more than one code path — consolidate() and
+// bootstrapFromDb() — each of which may be running in a *different* process
+// (e.g. the long-lived MCP server process and a short-lived CJS hook
+// subprocess launched concurrently). Without a lock + re-read-before-write,
+// whichever process flushes last silently erases whatever the other process
+// added since its own load. mergeAndWriteStore() re-reads the current
+// on-disk file immediately before writing, merges the caller's updates in by
+// `id` (keeping whichever record has the newer `ts`), and writes atomically
+// via tmp+rename, guarded by a short advisory lock.
+
+const STORE_LOCK_FILE = STORE_FILE + '.lock';
+const STORE_LOCK_STALE_MS = 10 * 1000; // single JSON write — 10s is generous
+
+// Uses fs-helpers.cjs's claimLock/releaseLock: unlike an unlink-then-recreate
+// stale-break, it reclaims via an atomic rename, so two processes that both
+// decide the lock is stale can't both end up believing they hold it (a real
+// TOCTOU race a previous unlink-then-create version of this had — best-effort
+// either way, since a missed lock still merges via mergeAndWriteStore's
+// re-read, this just narrows the window further).
+function claimStoreLock() {
+  return claimLock(STORE_LOCK_FILE, STORE_LOCK_STALE_MS);
+}
+
+function releaseStoreLock() {
+  releaseLock(STORE_LOCK_FILE);
+}
+
+/**
+ * Merge `updates` (new or changed entries) into the on-disk store and write
+ * the result atomically. Re-reads STORE_FILE immediately before writing so a
+ * concurrent flush from another process is merged, not clobbered. When both
+ * sides have an entry with the same `id`, the one with the newer `ts` wins.
+ */
+function mergeAndWriteStore(updates, capTo) {
+  var acquired = claimStoreLock();
+  if (!acquired) acquired = claimStoreLock(); // one retry — lock is short-lived
+
+  try {
+    var diskRaw = safeReadJson(STORE_FILE);
+    var diskEntries = Array.isArray(diskRaw) ? diskRaw : [];
+    var merged = new Map();
+    for (var i = 0; i < diskEntries.length; i++) {
+      var d = diskEntries[i];
+      if (d && d.id) merged.set(String(d.id), d);
+    }
+    for (var j = 0; j < (updates || []).length; j++) {
+      var u = updates[j];
+      if (!u || !u.id) continue;
+      var key = String(u.id);
+      var existing = merged.get(key);
+      if (!existing || (u.ts || 0) >= (existing.ts || 0)) {
+        merged.set(key, u);
+      }
+    }
+    var result = Array.from(merged.values());
+    if (capTo && result.length > capTo) {
+      result.sort(function(a, b) { return (b.ts || 0) - (a.ts || 0); });
+      result = result.slice(0, capTo);
+    }
+    var tmpPath = STORE_FILE + '.' + process.pid + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(result, null, 2), 'utf-8');
+    fs.renameSync(tmpPath, STORE_FILE);
+    return result;
+  } finally {
+    if (acquired) releaseStoreLock();
+  }
+}
+
 function safeReadJson(filePath) {
   try {
     if (!fs.existsSync(filePath)) return null;
@@ -274,7 +345,11 @@ function consolidate() {
   }
 
   if (newStoreEntries.length > 0) {
-    // Merge with existing store entries
+    // Decide which of newStoreEntries are worth adding, based on a read of
+    // the store as of "now". The actual write below re-reads immediately
+    // before flushing (mergeAndWriteStore), so a concurrent process's writes
+    // in between are merged rather than clobbered — this initial read is
+    // only used for the near-duplicate decision, not as the write's base.
     var existing = safeReadJson(STORE_FILE);
     var store = Array.isArray(existing) ? existing : [];
     var existingIds = new Set(store.map(function(e) { return e && e.id; }));
@@ -283,25 +358,23 @@ function consolidate() {
     var fileSetKey = function(e) { return (e.files || []).slice().sort().join('|'); };
     var seenSummaries = new Set(store.map(function(e) { return e && e.summary; }));
     var seenFileSets = new Set(store.filter(function(e) { return e && Array.isArray(e.files) && e.files.length > 0; }).map(fileSetKey));
+    var toAdd = [];
     var addedCount = 0;
     for (var j = 0; j < newStoreEntries.length; j++) {
       var ne = newStoreEntries[j];
       if (existingIds.has(ne.id)) continue;
       if (seenSummaries.has(ne.summary)) continue;
       if (ne.files && ne.files.length > 0 && seenFileSets.has(fileSetKey(ne))) continue;
-      store.push(ne);
+      toAdd.push(ne);
       seenSummaries.add(ne.summary);
       if (ne.files && ne.files.length > 0) seenFileSets.add(fileSetKey(ne));
       addedCount++;
     }
-    // Cap store at 200 entries to prevent unbounded growth
-    if (store.length > 200) {
-      store.sort(function(a, b) { return (b.ts || 0) - (a.ts || 0); });
-      store = store.slice(0, 200);
+    if (toAdd.length > 0) {
+      try {
+        mergeAndWriteStore(toAdd, 200);
+      } catch (_) {}
     }
-    try {
-      fs.writeFileSync(STORE_FILE, JSON.stringify(store, null, 2), 'utf-8');
-    } catch (_) {}
     count += addedCount;
   }
 
@@ -395,19 +468,20 @@ function bootstrapFromDb(db) {
   if (!db || _entries.length >= 5) return 0;
   try {
     var hubs = db.prepare(
-      "SELECT n.name, n.label, n.file, COUNT(e.id) AS deg " +
-      "FROM nodes n JOIN edges e ON (e.source = n.id OR e.target = n.id) " +
-      "WHERE n.label IN ('File','Function','Class') AND n.file NOT LIKE '%node_modules%' AND n.file NOT LIKE '%dist/%' " +
+      "SELECT n.name, n.label, n.file_path AS file, COUNT(e.id) AS deg " +
+      "FROM nodes n JOIN edges e ON (e.source_id = n.id OR e.target_id = n.id) " +
+      "WHERE n.label IN ('File','Function','Class') AND n.file_path NOT LIKE '%node_modules%' AND n.file_path NOT LIKE '%dist/%' " +
       "GROUP BY n.id ORDER BY deg DESC LIMIT 10"
     ).all();
     if (hubs.length === 0) return 0;
     var existingIds = new Set(_entries.map(function(e) { return e.id; }));
+    var newHubEntries = [];
     var added = 0;
     for (var hi = 0; hi < hubs.length; hi++) {
       var h = hubs[hi];
       var bId = 'bootstrap-hub-' + hi;
       if (existingIds.has(bId)) continue;
-      _entries.push({
+      var hubEntry = {
         id: bId,
         type: 'hub',
         content: h.name + ' (' + h.label + ') — ' + (h.file || '').replace(CWD + '/', '') + ' (' + h.deg + ' connections)',
@@ -415,12 +489,17 @@ function bootstrapFromDb(db) {
         confidence: 0.4,
         files: h.file ? [h.file] : [],
         ts: Date.now(),
-      });
+      };
+      _entries.push(hubEntry);
+      newHubEntries.push(hubEntry);
       added++;
     }
     if (added > 0) {
       ensureDataDir();
-      try { fs.writeFileSync(STORE_FILE, JSON.stringify(_entries, null, 2), 'utf-8'); } catch (_) {}
+      // mergeAndWriteStore re-reads STORE_FILE immediately before writing, so
+      // this only ever adds these hub entries into whatever is currently on
+      // disk — it never overwrites entries a concurrent process added.
+      try { mergeAndWriteStore(newHubEntries, 200); } catch (_) {}
     }
     return added;
   } catch (_) { return 0; }

package/.claude/helpers/session.cjs

@@ -9,6 +9,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { atomicWriteFileSync } = require('./utils/fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
@@ -54,7 +55,11 @@ function readCurrent() {
 function writeCurrent(data) {
   ensureDir();
   try {
-    fs.writeFileSync(CURRENT_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    // P2-21: tmp+rename — current.json is read+written by metric()/update()
+    // from multiple concurrent hook processes (pre-task, post-edit, etc. can
+    // all fire in one batched tool-call message); a plain writeFileSync lets
+    // a concurrent reader observe a partially-written file.
+    atomicWriteFileSync(CURRENT_FILE, JSON.stringify(data, null, 2), 'utf-8');
   } catch (_) {}
 }
 

package/.claude/helpers/statusline.cjs

@@ -18,6 +18,7 @@ const fs = require('fs');
 const path = require('path');
 const { execSync, spawnSync } = require('child_process');
 const os = require('os');
+const { cleanEntries } = require('./utils/fs-helpers.cjs');
 
 // Configuration
 const CONFIG = {
@@ -197,8 +198,7 @@ function getModelFromSessionJSONL() {
     if (!fs.existsSync(projectsDir)) return null;
 
     // Most recently modified JSONL = current (or latest) session
-    const files = fs.readdirSync(projectsDir)
-      .filter(f => f.endsWith('.jsonl'))
+    const files = cleanEntries(projectsDir, f => f.endsWith('.jsonl'))
       .map(f => ({ f, mt: (() => { try { return fs.statSync(path.join(projectsDir, f)).mtimeMs; } catch { return 0; } })() }))
       .sort((a, b) => b.mt - a.mt);
     if (files.length === 0) return null;
@@ -303,7 +303,7 @@ function getLearningStats() {
   try {
     const sessDir = path.join(CWD, '.claude', 'sessions');
     if (fs.existsSync(sessDir)) {
-      sessions = fs.readdirSync(sessDir).filter(f => f.endsWith('.json')).length;
+      sessions = cleanEntries(sessDir, f => f.endsWith('.json')).length;
     }
   } catch { /* ignore */ }
 
@@ -357,7 +357,7 @@ function getSecurityStatus() {
   try {
     const scanDir = path.join(CWD, '.claude', 'security-scans');
     if (fs.existsSync(scanDir)) {
-      scanCount = fs.readdirSync(scanDir).filter(f => f.endsWith('.json')).length;
+      scanCount = cleanEntries(scanDir, f => f.endsWith('.json')).length;
     }
   } catch { /* ignore */ }
 
@@ -379,7 +379,7 @@ function getSwarmStatus() {
   const regDir = path.join(CWD, '.monomind', 'agents', 'registrations');
   if (fs.existsSync(regDir)) {
     try {
-      const files = fs.readdirSync(regDir).filter(f => f.endsWith('.json'));
+      const files = cleanEntries(regDir, f => f.endsWith('.json'));
       const liveCount = files.filter(f => {
         try {
           return (now - fs.statSync(path.join(regDir, f)).mtimeMs) < agentRegTtlMs;
@@ -488,7 +488,7 @@ function getADRStatus() {
   for (const adrPath of adrPaths) {
     try {
       if (fs.existsSync(adrPath)) {
-        const files = fs.readdirSync(adrPath).filter(f =>
+        const files = cleanEntries(adrPath, f =>
           f.endsWith('.md') && (f.startsWith('ADR-') || f.startsWith('adr-') || /^\d{4}-/.test(f))
         );
         // Report actual count — don't guess compliance without reading files
@@ -523,7 +523,7 @@ function getHooksStatus() {
   try {
     const hooksDir = path.join(CWD, '.claude', 'hooks');
     if (fs.existsSync(hooksDir)) {
-      const hookFiles = fs.readdirSync(hooksDir).filter(f => f.endsWith('.js') || f.endsWith('.sh')).length;
+      const hookFiles = cleanEntries(hooksDir, f => f.endsWith('.js') || f.endsWith('.sh')).length;
       total = Math.max(total, hookFiles);
       enabled = Math.max(enabled, hookFiles);
     }
@@ -870,7 +870,7 @@ function getLoopStatus() {
   const now = Date.now();
   const loops = [];
   try {
-    const files = fs.readdirSync(loopsDir).filter(f =>
+    const files = cleanEntries(loopsDir, f =>
       f.endsWith('.json') && !f.includes('-hil') && !f.endsWith('.stop'));
     for (const f of files) {
       const d = readJSON(path.join(loopsDir, f));
@@ -895,7 +895,7 @@ function getHILPending() {
   if (!fs.existsSync(loopsDir)) return { pending: 0 };
   let pending = 0;
   try {
-    const files = fs.readdirSync(loopsDir).filter(f => f.endsWith('-hil.md'));
+    const files = cleanEntries(loopsDir, f => f.endsWith('-hil.md'));
     for (const f of files) {
       try {
         const txt = fs.readFileSync(path.join(loopsDir, f), 'utf-8');
@@ -932,7 +932,7 @@ function getActiveOrgs() {
       const runsDir = path.join(orgsDir, orgName, 'runs');
       if (!fs.existsSync(runsDir)) continue;
       try {
-        const files = fs.readdirSync(runsDir).filter(f => f.endsWith('.jsonl'));
+        const files = cleanEntries(runsDir, f => f.endsWith('.jsonl'));
         if (!files.length) continue;
         files.sort();
         const latest = files[files.length - 1];

package/.claude/helpers/token-tracker.cjs

@@ -351,7 +351,7 @@ function parseSessionFile(filePath, project, seenMsgIds, dateStart, dateEnd) {
 function collectJsonlFiles(dirPath) {
   var files = [];
   var entries;
-  try { entries = fs.readdirSync(dirPath); } catch (e) { return files; }
+  try { entries = fs.readdirSync(dirPath).filter(function(f) { return !f.startsWith('._'); }); } catch (e) { return files; }
   for (var i = 0; i < entries.length; i++) {
     var e = entries[i];
     if (e.endsWith('.jsonl')) {
@@ -360,7 +360,7 @@ function collectJsonlFiles(dirPath) {
       // Check subagents
       var subDir = path.join(dirPath, e, 'subagents');
       var subFiles;
-      try { subFiles = fs.readdirSync(subDir); } catch (_) { continue; }
+      try { subFiles = fs.readdirSync(subDir).filter(function(f) { return !f.startsWith('._'); }); } catch (_) { continue; }
       for (var j = 0; j < subFiles.length; j++) {
         if (subFiles[j].endsWith('.jsonl')) {
           files.push(path.join(subDir, subFiles[j]));
@@ -389,7 +389,7 @@ function unsanitize(name) {
 function parseAllSessions(dateStart, dateEnd) {
   var projectsDir = getClaudeProjectsDir();
   var projectDirs;
-  try { projectDirs = fs.readdirSync(projectsDir); } catch (e) { return []; }
+  try { projectDirs = fs.readdirSync(projectsDir).filter(function(f) { return !f.startsWith('._'); }); } catch (e) { return []; }
 
   var seenMsgIds = new Set();
   var projectMap = {};

package/.claude/helpers/utils/agent-registrations.cjs

@@ -0,0 +1,41 @@
+'use strict';
+// Shared agent-registration purge logic.
+//
+// .monomind/agents/registrations/*.json accumulate one file per subagent
+// spawn. The only purge used to be the FIFO-oldest-removal + stale sweep in
+// task-handler.cjs's handlePostTask, which only fires on TeammateIdle/
+// TaskCompleted — so any session that spawns agents but never emits those
+// events (crashes, single-shot Task calls outside a team, etc.) leaked
+// registrations forever. agent-start-handler.cjs already reads this
+// directory on every subagent start, so it also runs this same stale sweep.
+
+const path = require('path');
+const fs = require('fs');
+const { cleanEntries } = require('./fs-helpers.cjs');
+
+const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
+
+/**
+ * Delete registration files older than maxAgeMs. Returns the number of
+ * registrations remaining after the purge (or null if regDir doesn't exist
+ * or an error occurred).
+ */
+function purgeStaleRegistrations(regDir, maxAgeMs) {
+  maxAgeMs = maxAgeMs || DEFAULT_MAX_AGE_MS;
+  try {
+    if (!fs.existsSync(regDir)) return null;
+    const now = Date.now();
+    for (const f of cleanEntries(regDir, f => f.endsWith('.json'))) {
+      try {
+        if (now - fs.statSync(path.join(regDir, f)).mtimeMs > maxAgeMs) {
+          fs.unlinkSync(path.join(regDir, f));
+        }
+      } catch { /* ignore */ }
+    }
+    return cleanEntries(regDir, f => f.endsWith('.json')).length;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { purgeStaleRegistrations, DEFAULT_MAX_AGE_MS };

package/.claude/helpers/utils/fs-helpers.cjs

@@ -0,0 +1,183 @@
+'use strict';
+// Shared fs helpers for hook handlers.
+//
+// exFAT / macOS AppleDouble junk files (`._foo.json`, `.__protocol.md`, etc.)
+// get created whenever files touch an exFAT volume (external drives, some
+// network shares) and then get picked up by naive `readdirSync().filter(...)`
+// calls as if they were real data — corrupting counts, getting parsed as
+// JSON and failing, or (worst case) surfacing as garbage entries in
+// Claude Code's own skill/command list. Every readdir in the hook handlers
+// should route through `cleanEntries()` so this is filtered exactly once.
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read a directory and filter out exFAT AppleDouble junk (`._*`) before
+ * applying the caller's own filter predicate.
+ * @param {string} dir - directory to read
+ * @param {(name: string) => boolean} [filterFn] - optional additional filter
+ * @returns {string[]} entry names (not full paths), junk-free
+ */
+function cleanEntries(dir, filterFn) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  entries = entries.filter(f => !f.startsWith('._'));
+  return filterFn ? entries.filter(filterFn) : entries;
+}
+
+/**
+ * Same as cleanEntries but returns full paths.
+ */
+function cleanEntryPaths(dir, filterFn) {
+  return cleanEntries(dir, filterFn).map(f => path.join(dir, f));
+}
+
+/**
+ * Synchronous sleep (blocks the event loop) — used for tiny lock-retry
+ * backoffs where an async setTimeout would require restructuring a
+ * short-lived hook script into a promise chain for no real benefit.
+ * Falls back to a busy-wait if Atomics.wait is unavailable.
+ */
+function sleepSync(ms) {
+  try {
+    const sab = new SharedArrayBuffer(4);
+    Atomics.wait(new Int32Array(sab), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* spin */ }
+  }
+}
+
+/**
+ * Write a file atomically: write to a unique temp path then rename into
+ * place. `fs.renameSync` is atomic on POSIX and Windows (same volume), so
+ * concurrent readers of `filePath` never observe a partially-written file
+ * (torn read) — they see either the old complete file or the new complete
+ * file, never a half-written one. Does not by itself prevent lost updates
+ * from concurrent read-modify-write cycles — pair with `claimLock` when
+ * that matters (see hook-latency.json / swarm-activity.json writers).
+ */
+function atomicWriteFileSync(filePath, data, encoding) {
+  const dir = path.dirname(filePath);
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, data, encoding);
+  fs.renameSync(tmp, filePath);
+}
+
+/**
+ * Claim an exclusive lock file for short-lived critical sections (e.g. a
+ * rebuild-cooldown or spawn-once guard). Uses `wx` (exclusive create) so
+ * the claim itself is atomic — no read-check-write window.
+ *
+ * On contention, a lock older than `staleMs` is treated as abandoned (the
+ * holder crashed or never released it) and broken via an atomic RENAME
+ * (never unlink-then-create): renaming the stale lock path away is only
+ * ever won by exactly one racing process, so a concurrent process that
+ * also decided the lock was stale cannot delete *this* process's
+ * freshly-reclaimed lock out from under it (the TOCTOU race an
+ * unlink-then-create approach is vulnerable to). The loser of the rename
+ * race backs off and retries the whole claim sequence from the top rather
+ * than assuming it owns anything.
+ *
+ * Returns true if the lock was claimed (caller must eventually call
+ * `releaseLock`), false if another live/fresh owner holds it.
+ */
+function claimLock(lockPath, staleMs, maxAttempts) {
+  staleMs = staleMs || 30000;
+  maxAttempts = maxAttempts || 3;
+  try { fs.mkdirSync(path.dirname(lockPath), { recursive: true }); } catch { /* ignore */ }
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+      return true;
+    } catch {
+      let stat;
+      try {
+        stat = fs.statSync(lockPath);
+      } catch {
+        // Lock vanished between our failed wx-create and this stat check —
+        // retry the create immediately.
+        continue;
+      }
+      if (Date.now() - stat.mtimeMs < staleMs) return false; // held by a live/fresh owner
+
+      const claimedName = `${lockPath}.${process.pid}.${Date.now()}.stale`;
+      try {
+        fs.renameSync(lockPath, claimedName);
+      } catch {
+        // Someone else already renamed the stale lock away — they're
+        // claiming it. Back off briefly and retry from the top rather than
+        // proceeding as if we own it.
+        sleepSync(5);
+        continue;
+      }
+      try { fs.unlinkSync(claimedName); } catch { /* ignore */ }
+      // We won the rename race — loop back and attempt the wx-create fresh.
+    }
+  }
+  return false;
+}
+
+/** Release a lock previously claimed by this process via `claimLock`. */
+function releaseLock(lockPath) {
+  try {
+    if (Number(fs.readFileSync(lockPath, 'utf-8')) === process.pid) fs.unlinkSync(lockPath);
+  } catch { /* ignore */ }
+}
+
+/**
+ * Run `fn` while holding a lock (see `claimLock`) so a read-modify-write
+ * cycle is protected end-to-end, not just the final write. If the lock
+ * can't be claimed after retries, `fn` still runs (never block a hook) but
+ * without lost-update protection — best-effort, matching this codebase's
+ * "hooks must not block the session" rule.
+ */
+function withLock(lockPath, fn, staleMs, maxAttempts) {
+  const acquired = claimLock(lockPath, staleMs, maxAttempts);
+  try {
+    return fn();
+  } finally {
+    if (acquired) releaseLock(lockPath);
+  }
+}
+
+/**
+ * Append a JSONL line and rotate the file down to `maxLines` (keep the
+ * most recent lines) when it exceeds that count — mirrors the size-cap
+ * pattern already used for intelligence-outcomes.jsonl (500 lines) and
+ * episodes.jsonl. Prevents unbounded JSONL growth. Rotation write is
+ * atomic (tmp+rename).
+ */
+function appendJsonlWithRotation(filePath, line, maxLines) {
+  maxLines = maxLines || 500;
+  try { fs.mkdirSync(path.dirname(filePath), { recursive: true }); } catch { /* ignore */ }
+  fs.appendFileSync(filePath, line.endsWith('\n') ? line : line + '\n');
+  try {
+    const st = fs.statSync(filePath);
+    // Cheap heuristic to skip reading huge files line-by-line on every
+    // append: only bother counting lines once the file is already
+    // suspiciously large relative to a plausible maxLines * avg-line-size.
+    if (st.size < 4096) return;
+    const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+    if (lines.length > maxLines) {
+      atomicWriteFileSync(filePath, lines.slice(-maxLines).join('\n') + '\n', 'utf-8');
+    }
+  } catch { /* non-fatal — rotation is best-effort */ }
+}
+
+module.exports = {
+  cleanEntries,
+  cleanEntryPaths,
+  sleepSync,
+  atomicWriteFileSync,
+  claimLock,
+  releaseLock,
+  withLock,
+  appendJsonlWithRotation,
+};

package/.claude/helpers/utils/micro-agents.cjs

@@ -5,6 +5,7 @@ const path = require('path');
 const fs = require('fs');
 
 const { _openMonographDb } = require('./monograph.cjs');
+const { cleanEntries, atomicWriteFileSync } = require('./fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
@@ -82,7 +83,7 @@ function _triggerCollectMdFiles(dir, _depth) {
   if (depth > 5) return []; // cap recursion depth to prevent stack overflow DoS
   var results = [];
   try {
-    var entries = fs.readdirSync(dir);
+    var entries = cleanEntries(dir);
     for (var i = 0; i < entries.length; i++) {
       if (results.length >= 200) break; // cap total file count to prevent DoS
       var full = path.join(dir, entries[i]);
@@ -135,8 +136,11 @@ function scanMicroAgentTriggers(prompt) {
   if (!cacheLoaded) {
     patterns = _triggerBuildIndex(agentDir);
     try {
-      fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
-      fs.writeFileSync(indexPath, JSON.stringify({ patterns: patterns, builtAt: new Date().toISOString(), totalAgentsScanned: patterns.length }));
+      // P2-21: tmp+rename — multiple concurrent hook processes (route-handler
+      // invocations fire per prompt/subagent) can all miss the cache at once
+      // and rebuild+write trigger-index.json simultaneously; atomic write
+      // prevents a concurrent reader from parsing a half-written file.
+      atomicWriteFileSync(indexPath, JSON.stringify({ patterns: patterns, builtAt: new Date().toISOString(), totalAgentsScanned: patterns.length }));
     } catch (e) {}
   }
 
@@ -334,9 +338,9 @@ function _autoIndexKnowledge(knowledgeDir) {
   } catch (e) { /* graph not available yet */ }
 
   try {
-    fs.mkdirSync(knowledgeDir, { recursive: true });
-    fs.writeFileSync(chunksFile, newLines.length > 0 ? newLines.join('\n') + '\n' : '', 'utf-8');
-    fs.writeFileSync(hashFile, contentHash, 'utf-8');
+    // Same torn-read hazard as trigger-index.json above — atomic write.
+    atomicWriteFileSync(chunksFile, newLines.length > 0 ? newLines.join('\n') + '\n' : '', 'utf-8');
+    atomicWriteFileSync(hashFile, contentHash, 'utf-8');
   } catch (e) {}
   return newLines.length;
 }