monomind 2.0.3 → 2.1.3

package/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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/packages/@monomind/cli/.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;
 }

package/packages/@monomind/cli/.claude/helpers/utils/monograph.cjs

@@ -9,6 +9,25 @@ const { _getRecentEdits } = require('./telemetry.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
+// @monoes/monograph is "type":"module" with an exports map that has no
+// "require" condition — a bare `require('@monoes/monograph')` (or
+// require() of its package directory) always throws "No exports main
+// defined", regardless of whether the package is actually installed.
+// require()-ing the package's *resolved entry file* directly bypasses the
+// exports-map restriction and works via Node's require(esm) support (this
+// codebase targets Node 20+, which has it). Reads the entry path from the
+// package's own package.json instead of hardcoding "dist/src/index.js" so
+// this survives a future monograph dist-layout change.
+function _resolvePkgEntryFile(pkgDir) {
+  try {
+    var pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf-8'));
+    var entry = (pkg.exports && pkg.exports['.'] && (pkg.exports['.'].import || pkg.exports['.'].default)) || pkg.main;
+    if (!entry) return null;
+    var full = path.join(pkgDir, entry);
+    return fs.existsSync(full) ? full : null;
+  } catch (e) { return null; }
+}
+
 function _requireMonograph() {
   var candidates = [
     path.join(CWD, 'node_modules/.pnpm/node_modules/@monoes/monograph'),
@@ -16,9 +35,21 @@ function _requireMonograph() {
     path.join(CWD, 'node_modules/@monoes/monograph'),
   ];
   for (var i = 0; i < candidates.length; i++) {
-    try { if (fs.existsSync(candidates[i])) return require(candidates[i]); } catch(e) {}
+    var entry = fs.existsSync(candidates[i]) ? _resolvePkgEntryFile(candidates[i]) : null;
+    if (entry) { try { return require(entry); } catch (e) {} }
+  }
+  // Ancestor-directory search — the equivalent of bare `require('@monoes/
+  // monograph')`'s own node_modules walk, needed since that call form can
+  // never succeed against this package's exports map.
+  var dir = CWD;
+  for (;;) {
+    var pkgDir = path.join(dir, 'node_modules', '@monoes', 'monograph');
+    var entry = fs.existsSync(pkgDir) ? _resolvePkgEntryFile(pkgDir) : null;
+    if (entry) { try { return require(entry); } catch (e) {} break; }
+    var parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
-  try { return require('@monoes/monograph'); } catch(e) {}
   return null;
 }
 
@@ -257,6 +288,44 @@ function _recordGraphTelemetry(event) {
   } catch (e) { /* non-fatal */ }
 }
 
+// ─── Graph gate ─────────────────────────────────────────────────────────────
+// The pre-search/pre-bash heuristic assist above silently resolves Grep/Bash
+// patterns against the graph and counts that as a "graph win" even when the
+// agent never actually called monograph_query — so the graph-usage % can look
+// healthy while zero real monograph_call events ever fire. This gate forces
+// at least one real monograph_query/monograph_suggest call per session before
+// Grep/Glob/bash grep|find are allowed, by hard-blocking (exitCode 2) the
+// first such call each session. Capped at ONE block per session (never a
+// second) so a subagent with no monograph MCP tool access can't deadlock.
+function _graphGateStateFile() {
+  return path.join(CWD, '.monomind', 'graph-gate-state.json');
+}
+
+function _graphGateMarkQueried(sessionId) {
+  if (!sessionId) return;
+  try {
+    fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
+    fs.writeFileSync(_graphGateStateFile(), JSON.stringify({ sessionId: sessionId, queried: true }));
+  } catch (e) { /* non-fatal */ }
+}
+
+function _graphGateShouldBlock(sessionId) {
+  if (!sessionId || !_isGraphFresh()) return false;
+  var f = _graphGateStateFile();
+  var d = {};
+  try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (e) {}
+  if (typeof d !== 'object' || d === null || d.sessionId !== sessionId) {
+    d = { sessionId: sessionId, queried: false, blockedOnce: false };
+  }
+  if (d.queried || d.blockedOnce) return false;
+  d.blockedOnce = true;
+  try {
+    fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
+    fs.writeFileSync(f, JSON.stringify(d));
+  } catch (e) { return false; }
+  return true;
+}
+
 function _injectCompactGraphMap() {
   try {
     var db = _openMonographDb();
@@ -476,5 +545,7 @@ module.exports = {
   _injectCompactGraphMap,
   _findAffectedTests,
   _maybeRebuildMonograph,
+  _graphGateShouldBlock,
+  _graphGateMarkQueried,
   injectGodNodesContext,
 };

package/packages/@monomind/cli/.claude/helpers/utils/telemetry.cjs

@@ -4,6 +4,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { atomicWriteFileSync, withLock, appendJsonlWithRotation } = require('./fs-helpers.cjs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
@@ -19,7 +20,11 @@ function _recordRecentEdit(filePath) {
     d.edits = d.edits.filter(function(e) { return e.file !== storedPath; });
     d.edits.unshift({ file: storedPath, editedAt: Date.now() });
     if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
-    fs.writeFileSync(f, JSON.stringify(d));
+    // P2-21: tmp+rename so a concurrent reader of recent-edits.json (fired by
+    // another PostToolUse hook process in the same batched Edit) never sees a
+    // partially-written file. Last-writer-wins on the merge itself is
+    // acceptable here — losing one recent-edit entry is low-stakes.
+    atomicWriteFileSync(f, JSON.stringify(d));
   } catch (e) { /* non-fatal */ }
 }
 
@@ -45,7 +50,8 @@ function _recordToolCall(signature) {
       d = { startedAt: Date.now(), calls: {} };
     }
     d.calls[signature] = (d.calls[signature] || 0) + 1;
-    fs.writeFileSync(f, JSON.stringify(d));
+    // P2-21: atomic write — see _recordRecentEdit above for rationale.
+    atomicWriteFileSync(f, JSON.stringify(d));
     return d.calls[signature];
   } catch (e) { return 0; }
 }
@@ -77,8 +83,8 @@ function _getBudgetStatus() {
         monthlyLimit = Math.max(monthlyLimit || 0, Math.ceil(dailyAvg * 1.5 * 30));
         autoTuned = true;
         try {
-          fs.mkdirSync(path.dirname(budgetFile), { recursive: true });
-          fs.writeFileSync(budgetFile, JSON.stringify({
+          // P2-21: atomic write — see _recordRecentEdit above for rationale.
+          atomicWriteFileSync(budgetFile, JSON.stringify({
             dailyLimit: dailyLimit, monthlyLimit: monthlyLimit,
             autoTuned: true, tunedAt: now.toISOString(),
             basis: 'rolling avg $' + dailyAvg.toFixed(2) + '/day × 1.5',
@@ -106,20 +112,28 @@ function _getBudgetStatus() {
 }
 
 function _recordHookLatency(handlerName, durationMs) {
+  var f = path.join(CWD, '.monomind', 'metrics', 'hook-latency.json');
+  // P2-21: hook-latency.json's per-handler count/total/max are aggregated
+  // counters written by every hook invocation — a plain read-modify-write
+  // silently drops whichever concurrent process wrote last (lost update),
+  // not just torn reads. Wrap the whole cycle in a lock (see
+  // utils/fs-helpers.cjs claimLock/withLock, same TOCTOU-safe pattern used
+  // for the rebuild/spawn locks) so the read and the write happen as one
+  // critical section instead of racing.
   try {
-    var f = path.join(CWD, '.monomind', 'metrics', 'hook-latency.json');
-    fs.mkdirSync(path.dirname(f), { recursive: true });
-    var d = {};
-    try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
-    if (typeof d !== 'object' || d === null) d = {};
-    var entry = d[handlerName] || { count: 0, total: 0, max: 0 };
-    entry.count++;
-    entry.total += durationMs;
-    entry.max = Math.max(entry.max, durationMs);
-    entry.mean = Math.round(entry.total / entry.count);
-    d[handlerName] = entry;
-    d.lastUpdated = Date.now();
-    fs.writeFileSync(f, JSON.stringify(d));
+    withLock(f + '.lock', function() {
+      var d = {};
+      try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
+      if (typeof d !== 'object' || d === null) d = {};
+      var entry = d[handlerName] || { count: 0, total: 0, max: 0 };
+      entry.count++;
+      entry.total += durationMs;
+      entry.max = Math.max(entry.max, durationMs);
+      entry.mean = Math.round(entry.total / entry.count);
+      d[handlerName] = entry;
+      d.lastUpdated = Date.now();
+      atomicWriteFileSync(f, JSON.stringify(d));
+    }, 5000);
   } catch (e) {}
 }
 
@@ -130,9 +144,11 @@ function _recordDecisionMarkers(promptText) {
   if (!matches || matches.length === 0) return;
   try {
     var f = path.join(CWD, '.monomind', 'decisions.jsonl');
-    fs.mkdirSync(path.dirname(f), { recursive: true });
     var entry = JSON.stringify({ ts: Date.now(), excerpts: matches.slice(0, 3), prompt: promptText.slice(0, 400) });
-    fs.appendFileSync(f, entry + '\n');
+    // P2-26: decisions.jsonl was a pure appendFileSync with no rotation —
+    // unlike intelligence-outcomes.jsonl (capped at 500 lines). Cap it the
+    // same way so it can't grow unbounded across a long project history.
+    appendJsonlWithRotation(f, entry, 500);
   } catch (e) {}
 }