monomind 2.7.10 → 2.7.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.7.10",
+  "version": "2.7.12",
   "description": "Open-source CLI extension for Claude Code. Adds an MCP server with a codebase knowledge graph, persistent memory, multi-agent coordination, and reusable slash commands. MIT licensed, runs locally, no data leaves your machine.",
   "main": "dist/index.js",
   "type": "module",
@@ -64,7 +64,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.207",
     "@monoes/monobrowse": "^1.0.6",
-    "@monoes/monodesign": "^1.2.1",
+    "@monoes/monodesign": "^1.2.2",
     "@monoes/monograph": "^1.5.4",
     "@noble/ed25519": "^2.1.0",
     "mammoth": "^1.12.0",
@@ -109,7 +109,7 @@
       "@protobufjs/utf8": ">=1.1.1",
       "@grpc/grpc-js": ">=1.14.4",
       "vite": ">=8.0.16",
-      "postcss": ">=8.5.10",
+      "postcss": ">=8.5.18",
       "fast-uri": ">=4.1.1",
       "form-data": ">=4.0.6",
       "ip-address": ">=10.1.1",

package/packages/@monomind/cli/.claude/helpers/token-tracker.cjs

@@ -403,6 +403,26 @@ function parseAllSessions(dateStart, dateEnd) {
 
     var jsonlFiles = collectJsonlFiles(dirPath);
     for (var j = 0; j < jsonlFiles.length; j++) {
+      // Skip transcripts last written before the window opened. Sessions are
+      // append-only, so a file whose mtime predates dateStart cannot hold an
+      // entry inside the range — reading and JSON.parsing it is pure waste.
+      //
+      // `tokens today` was parsing every transcript on the machine: ~1GB over
+      // ~2,200 files here, of which ~300 had been touched that day. That took
+      // ~10s, which is what made it unusable as a SessionStart hook (#42) —
+      // the documented hook sets a 10s timeout and `npx` adds its own
+      // registry-check overhead on top.
+      //
+      // Safe with respect to the seenMsgIds dedupe: parseSessionFile applies
+      // the date filter BEFORE groupAndClassify ever consults that set, so
+      // out-of-range entries never registered a message id in the first place.
+      // Skipping the file is exactly equivalent to reading it and discarding
+      // every line. Only applied when a start bound was actually requested.
+      if (dateStart) {
+        var fstat;
+        try { fstat = fs.statSync(jsonlFiles[j]); } catch (_) { fstat = null; }
+        if (fstat && fstat.mtime < dateStart) continue;
+      }
       var session = parseSessionFile(jsonlFiles[j], dirName, seenMsgIds, dateStart, dateEnd);
       if (session && session.apiCalls > 0) {
         if (!projectMap[dirName]) {
@@ -543,14 +563,79 @@ function _computeQuickTotals() {
   return { todayCost: todayCost, todayCalls: todayCalls, monthCost: monthCost, monthCalls: monthCalls };
 }
 
+function _formatQuickTotals(d) {
+  return '[TOKEN_USAGE] Today: ' + fmt$(d.todayCost) + ' (' + d.todayCalls + ' calls)  |  Month: ' + fmt$(d.monthCost) + ' (' + d.monthCalls + ' calls)';
+}
+
+// The quick summary needs a MONTH window, and every transcript on an active
+// machine has been touched this month — so unlike the day view it cannot be
+// narrowed by mtime and inherently costs a full parse (~9.4s over ~1GB here).
+//
+// That is what broke `monomind tokens today` as a SessionStart hook (#42): the
+// documented hook allows 10s, so the computation alone straddles the timeout
+// before `npx` has even checked the registry, and Claude Code hangs waiting.
+//
+// A cost read-out does not need to be to-the-second, so serve it from cache and
+// refresh out of band: a session start returns instantly, and the next one
+// picks up the newly written value. A cold cache prints nothing rather than
+// blocking the editor — never make the user wait on a status line.
+var QUICK_CACHE_TTL_MS = 10 * 60 * 1000;
+
+function _quickCachePath() {
+  return path.join(path.dirname(getClaudeProjectsDir()), '.monomind-token-summary.json');
+}
+
+function _readQuickCache() {
+  try {
+    var raw = JSON.parse(fs.readFileSync(_quickCachePath(), 'utf8'));
+    if (!raw || typeof raw.computedAt !== 'number' || !raw.totals) return null;
+    return raw;
+  } catch (_) { return null; }
+}
+
+function _writeQuickCache(totals) {
+  try {
+    var tmp = _quickCachePath() + '.' + process.pid + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify({ computedAt: Date.now(), totals: totals }));
+    fs.renameSync(tmp, _quickCachePath()); // atomic: never expose a half-written cache
+  } catch (_) { /* cache is best-effort */ }
+}
+
+/** Recompute and persist the cached totals. Used by the background refresh. */
+function refreshQuickSummary() {
+  var d = _computeQuickTotals();
+  if (d) _writeQuickCache(d);
+  return d;
+}
+
+function _spawnQuickRefresh() {
+  try {
+    var child = require('child_process').spawn(
+      process.execPath, [__filename, 'refresh-summary'],
+      { detached: true, stdio: 'ignore' },
+    );
+    child.unref(); // must not hold the caller's event loop open
+  } catch (_) { /* best effort */ }
+}
+
 /**
  * Returns a one-line token usage summary for the current day and month.
- * Called at session-restore.
+ * Called at session-restore. Cache-first and non-blocking — see the note above.
  */
 function quickSummary() {
-  var d = _computeQuickTotals();
-  if (!d) return null;
-  return '[TOKEN_USAGE] Today: ' + fmt$(d.todayCost) + ' (' + d.todayCalls + ' calls)  |  Month: ' + fmt$(d.monthCost) + ' (' + d.monthCalls + ' calls)';
+  var cached = _readQuickCache();
+  var fresh = cached && (Date.now() - cached.computedAt) < QUICK_CACHE_TTL_MS;
+  if (fresh) return _formatQuickTotals(cached.totals);
+  // Stale or missing: never recompute inline, or we reintroduce #42. Serve the
+  // stale figure (clearly better than nothing) and refresh for next time.
+  _spawnQuickRefresh();
+  return cached ? _formatQuickTotals(cached.totals) : null;
+}
+
+/** Synchronous full computation. For `tokens` CLI views, which may block. */
+function quickSummaryBlocking() {
+  var d = refreshQuickSummary();
+  return d ? _formatQuickTotals(d) : null;
 }
 
 /**
@@ -913,6 +998,8 @@ function runInteractive() {
 module.exports = {
   parseAllSessions: parseAllSessions,
   quickSummary: quickSummary,
+  quickSummaryBlocking: quickSummaryBlocking,
+  refreshQuickSummary: refreshQuickSummary,
   quickSummaryData: quickSummaryData,
   renderDashboard: renderDashboard,
   runInteractive: runInteractive,
@@ -925,7 +1012,10 @@ module.exports = {
 if (require.main === module) {
   var args = process.argv.slice(2);
   var cmd = args[0] || 'dashboard';
-  if (cmd === 'summary') {
+  if (cmd === 'refresh-summary') {
+    // Detached background refresh spawned by quickSummary(). Silent by design.
+    refreshQuickSummary();
+  } else if (cmd === 'summary') {
     var s = quickSummary();
     process.stdout.write((s || 'No token data available') + '\n');
   } else if (cmd === 'report') {

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

@@ -368,8 +368,23 @@ function _graphGateWriteSessions(sessions) {
 // one is reclaimed, we still perform an atomic-rename write — no worse than the
 // old behavior, and never a hang. Hooks run on every tool call, so the total
 // wait is deliberately tiny.
-var _GRAPH_GATE_LOCK_TIMEOUT_MS = 250;
+// The acquire budget MUST exceed the stale threshold. It used to be 250ms
+// against a 2000ms stale window, which had two consequences:
+//
+//   1. A writer that could not get the lock within 250ms gave up and wrote
+//      UNLOCKED — precisely the lost-update this lock exists to prevent. CI
+//      landed 9 of 16 concurrent writers; a fast machine hides it, because the
+//      critical section is microseconds and the budget is never exhausted.
+//   2. The stale-reclaim branch below was nearly unreachable. Reclaiming needs
+//      the lock to be older than 2000ms, but we stopped waiting after 250ms, so
+//      a crashed holder's lock was almost never actually reclaimed.
+//
+// With the budget above the stale window both paths work: a live holder is
+// waited out (its critical section is a single read-modify-write), and a dead
+// holder's lock is reclaimed at 2s and then taken. The waiting only happens
+// under real contention — an uncontended acquire is one mkdir.
 var _GRAPH_GATE_LOCK_STALE_MS = 2000;
+var _GRAPH_GATE_LOCK_TIMEOUT_MS = 3000;
 
 function _sleepSync(ms) {
   try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch (e) { /* no SAB */ }

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/context-signals.mjs

@@ -93,7 +93,7 @@ function latestCritique(cwd) {
       p0: numKey('p0', 'p0_count'),
       p1: numKey('p1', 'p1_count'),
       timestamp: get('timestamp'),
-      file: path.relative(cwd, path.join(dir, newest)),
+      file: path.relative(cwd, path.join(dir, newest)).split(path.sep).join('/'),
       trend,
       openP0,
     };

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/context.mjs

@@ -75,10 +75,10 @@ export function loadContext(cwd = process.cwd(), options = {}) {
   return {
     hasProduct: !!product,
     product,
-    productPath: productPath ? path.relative(absCwd, productPath) : null,
+    productPath: productPath ? path.relative(absCwd, productPath).split(path.sep).join('/') : null,
     hasDesign: !!design,
     design,
-    designPath: designPath ? path.relative(absCwd, designPath) : null,
+    designPath: designPath ? path.relative(absCwd, designPath).split(path.sep).join('/') : null,
     contextDir: resolved.contextDir,
     productContextDir: productPath ? path.dirname(productPath) : null,
     designContextDir: designPath ? path.dirname(designPath) : null,
@@ -186,7 +186,7 @@ function resolveProject(cwd = process.cwd(), options = {}) {
 }
 
 function isPathInside(candidate, root) {
-  const rel = path.relative(root, candidate);
+  const rel = path.relative(root, candidate).split(path.sep).join('/');
   return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
 }
 
@@ -339,9 +339,9 @@ function contextSourceStatus(filePath, repoRoot, projectRoot) {
 
 function contextSourcePath(filePath, repoRoot) {
   if (!filePath) return null;
-  const rel = path.relative(repoRoot, filePath);
+  const rel = path.relative(repoRoot, filePath).split(path.sep).join('/');
   if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) {
-    return rel.split(path.sep).join('/');
+    return rel;
   }
   return filePath;
 }
@@ -447,9 +447,13 @@ function findTargetExample(repoRoot, projectRoot) {
 }
 
 function resolveWorkspaceProjectRoot(repoRoot, targetDir) {
-  const rel = path.relative(repoRoot, targetDir);
+  const rel = path.relative(repoRoot, targetDir).split(path.sep).join('/');
   if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return repoRoot;
-  const relSegments = rel.split(path.sep).filter(Boolean);
+  // rel is POSIX-normalised above, so split on '/' — splitting on path.sep here
+  // returned the whole string as a single segment on Windows, no workspace
+  // pattern ever matched, and every child project silently resolved to the
+  // repo root instead.
+  const relSegments = rel.split('/').filter(Boolean);
   const patterns = readWorkspacePatterns(repoRoot);
   const excluded = isExcludedByWorkspacePattern(relSegments, patterns);
   if (!excluded) {

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/critique-storage.mjs

@@ -64,7 +64,7 @@ export function slugFromTarget(resolved, { cwd = process.cwd() } = {}) {
   // File path. Make it project-relative so two devs critiquing the same
   // checkout get the same slug regardless of where their repo is cloned.
   const abs = path.isAbsolute(trimmed) ? trimmed : path.resolve(cwd, trimmed);
-  let rel = path.relative(cwd, abs);
+  let rel = path.relative(cwd, abs).split(path.sep).join('/');
   // If the target is outside cwd, fall back to the basename so we still
   // produce a stable slug (vs the absolute path, which would include
   // home dirs / usernames).
@@ -231,7 +231,7 @@ export function mirrorToMemory({ slug, meta = {}, filePath, cwd = process.cwd(),
       p1: asFiniteNumber(meta.p1_count ?? meta.p1),
       date: now.toISOString(),
       slug,
-      path: filePath ? path.relative(cwd, filePath) : null,
+      path: filePath ? path.relative(cwd, filePath).split(path.sep).join('/') : null,
     };
     const project = kebab(path.basename(path.resolve(cwd))) || 'project';
     const key = `${project}-${slug}`;
@@ -340,7 +340,7 @@ export function formatRecall(recall, { cwd = process.cwd() } = {}) {
   if (!issues.p0.length && !issues.p1.length) {
     lines.push('- No open P0/P1 lines found in the latest snapshot.');
   }
-  lines.push(`- Snapshot: ${path.relative(cwd, latest.path)}`);
+  lines.push(`- Snapshot: ${path.relative(cwd, latest.path).split(path.sep).join('/')}`);
   return lines.join('\n');
 }
 

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detect-csp.mjs

@@ -186,7 +186,7 @@ function walk(root, dir, depth, visit) {
         body = buf.slice(0, n).toString('utf-8');
       } finally { fs.closeSync(fd); }
     } catch { continue; }
-    visit(abs, path.relative(root, abs), body);
+    visit(abs, path.relative(root, abs).split(path.sep).join('/'), body);
   }
 }
 

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/fix/index.mjs

@@ -257,7 +257,7 @@ async function runFix(targets, options = {}) {
   const diffs = [];
   if (dryRun) {
     for (const [p, b] of changedFiles) {
-      diffs.push({ file: p, diff: unifiedDiff(b.original, b.content, path.relative(cwd, p) || p) });
+      diffs.push({ file: p, diff: unifiedDiff(b.original, b.content, path.relative(cwd, p).split(path.sep).join('/') || p) });
     }
   } else {
     for (const [p, b] of changedFiles) writeFileAtomic(p, b.content);

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/hook-admin.mjs

@@ -275,9 +275,9 @@ function statusReport(cwd) {
   const cfg = readConfig(cwd);
   const envKill = process.env.MONODESIGN_HOOK_DISABLED;
   const envState = envKill ? `MONODESIGN_HOOK_DISABLED=${envKill}` : 'unset';
-  const cfgPath = path.relative(cwd, getConfigPath(cwd)) || '.monodesign/config.json';
-  const localPath = path.relative(cwd, getLocalConfigPath(cwd)) || '.monodesign/config.local.json';
-  const cachePath = path.relative(cwd, getCachePath(cwd)) || '.monodesign/hook.cache.json';
+  const cfgPath = path.relative(cwd, getConfigPath(cwd)).split(path.sep).join('/') || '.monodesign/config.json';
+  const localPath = path.relative(cwd, getLocalConfigPath(cwd)).split(path.sep).join('/') || '.monodesign/config.local.json';
+  const cachePath = path.relative(cwd, getCachePath(cwd)).split(path.sep).join('/') || '.monodesign/hook.cache.json';
   const fileState = (info, relPath, absent) => {
     if (info.malformed) return `${relPath} (malformed; ignored)`;
     if (info.exists) return relPath;
@@ -306,14 +306,14 @@ function setEnabled(cwd, value) {
   config.enabled = value;
   const target = writeHookConfig(cwd, config);
   if (!value) {
-    return `Design hook disabled for this project (wrote ${path.relative(cwd, target) || target}).`;
+    return `Design hook disabled for this project (wrote ${path.relative(cwd, target).split(path.sep).join('/') || target}).`;
   }
 
   const localTarget = writeHookConfig(cwd, { consent: 'accepted' }, { local: true });
   const repaired = repairHookManifests(cwd);
   const parts = [
-    `Design hook enabled for this project (wrote ${path.relative(cwd, target) || target}).`,
-    `Recorded local hook consent in ${path.relative(cwd, localTarget) || localTarget}.`,
+    `Design hook enabled for this project (wrote ${path.relative(cwd, target).split(path.sep).join('/') || target}).`,
+    `Recorded local hook consent in ${path.relative(cwd, localTarget).split(path.sep).join('/') || localTarget}.`,
   ];
   if (repaired.written.length > 0) {
     parts.push(`Installed or repaired hook manifests for: ${repaired.written.join(', ')}.`);
@@ -323,7 +323,7 @@ function setEnabled(cwd, value) {
     parts.push('No installed provider skill folders found to repair.');
   }
   if (repaired.backups.length > 0) {
-    parts.push(`Backed up malformed manifest(s): ${repaired.backups.map((filePath) => path.relative(cwd, filePath) || filePath).join(', ')}.`);
+    parts.push(`Backed up malformed manifest(s): ${repaired.backups.map((filePath) => path.relative(cwd, filePath).split(path.sep).join('/') || filePath).join(', ')}.`);
   }
   return parts.join(' ');
 }
@@ -596,7 +596,7 @@ function addIgnoreValue(cwd, args) {
 
   const target = writeDetectorConfig(cwd, config, { local });
   const scope = local ? 'local detector.ignoreValues' : 'shared detector.ignoreValues';
-  return `Added ${parsed.rule}=${parsed.value} to ${scope} (${path.relative(cwd, target) || target}).`;
+  return `Added ${parsed.rule}=${parsed.value} to ${scope} (${path.relative(cwd, target).split(path.sep).join('/') || target}).`;
 }
 
 function reset(cwd) {
@@ -613,7 +613,7 @@ function reset(cwd) {
       } else {
         fs.writeFileSync(filePath, JSON.stringify(rest, null, 2) + '\n');
       }
-      removed.push(path.relative(cwd, filePath) || filePath);
+      removed.push(path.relative(cwd, filePath).split(path.sep).join('/') || filePath);
     } catch { /* ignore */ }
   }
   // State files are wholly ours; delete outright.
@@ -621,7 +621,7 @@ function reset(cwd) {
     try {
       if (fs.existsSync(filePath)) {
         fs.unlinkSync(filePath);
-        removed.push(path.relative(cwd, filePath) || filePath);
+        removed.push(path.relative(cwd, filePath).split(path.sep).join('/') || filePath);
       }
     } catch { /* ignore */ }
   }

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/hook-before-edit.mjs

@@ -320,7 +320,7 @@ function escapeRegExp(value) {
 
 function relativePath(filePath, cwd) {
   try {
-    const rel = path.relative(cwd, filePath);
+    const rel = path.relative(cwd, filePath).split(path.sep).join('/');
     if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return filePath;
     return rel.split(path.sep).join('/');
   } catch {
@@ -330,7 +330,7 @@ function relativePath(filePath, cwd) {
 
 function isInsideProject(filePath, cwd) {
   try {
-    const rel = path.relative(cwd, filePath);
+    const rel = path.relative(cwd, filePath).split(path.sep).join('/');
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
   } catch {
     return false;

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/hook-lib.mjs

@@ -1015,7 +1015,7 @@ function quoteCommandArg(value) {
 
 function relativize(filePath, cwd) {
   try {
-    const rel = path.relative(cwd, filePath);
+    const rel = path.relative(cwd, filePath).split(path.sep).join('/');
     if (!rel || rel.startsWith('..')) return filePath;
     return rel.split(path.sep).join('/');
   } catch {
@@ -1226,7 +1226,7 @@ function hasPathTraversal(filePath) {
 function isInsideProject(filePath, projectCwd) {
   if (!filePath || !projectCwd || hasPathTraversal(filePath)) return false;
   try {
-    const rel = path.relative(projectCwd, filePath);
+    const rel = path.relative(projectCwd, filePath).split(path.sep).join('/');
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
   } catch {
     return false;

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live/manual-apply.mjs

@@ -338,7 +338,7 @@ export function normalizeManualApplyEvidencePath(evidencePath, cwd = process.cwd
   if (!evidencePath || typeof evidencePath !== 'string') return null;
   const fullPath = path.isAbsolute(evidencePath) ? evidencePath : path.resolve(cwd, evidencePath);
   const evidenceDir = manualApplyEvidenceDir(cwd);
-  const relative = path.relative(evidenceDir, fullPath);
+  const relative = path.relative(evidenceDir, fullPath).split(path.sep).join('/');
   if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null;
   if (path.extname(relative) !== '.json') return null;
   return fullPath;
@@ -837,7 +837,7 @@ export function collectManualApplyFiles(batch, extraFiles = [], cwd = process.cw
 function normalizeProjectFile(file, cwd = process.cwd()) {
   if (!file || typeof file !== 'string') return null;
   const absolute = path.isAbsolute(file) ? file : path.resolve(cwd, file);
-  const relative = path.relative(cwd, absolute);
+  const relative = path.relative(cwd, absolute).split(path.sep).join('/');
   if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null;
   return relative;
 }
@@ -927,7 +927,7 @@ export function summarizeManualDiagnostics(items, cwd = process.cwd()) {
 export function summarizeManualLogFile(file, cwd = process.cwd()) {
   if (!file || typeof file !== 'string') return undefined;
   if (!path.isAbsolute(file)) return file;
-  const relative = path.relative(cwd, file);
+  const relative = path.relative(cwd, file).split(path.sep).join('/');
   return relative && !relative.startsWith('..') && !path.isAbsolute(relative) ? relative : file;
 }
 

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live/svelte-component.mjs

@@ -265,7 +265,7 @@ export function resolveSourceFile(sourceFile, cwd = process.cwd()) {
     throw new Error('Invalid svelte-component source file');
   }
   const full = path.resolve(cwd, sourceFile);
-  const rel = path.relative(cwd, full);
+  const rel = path.relative(cwd, full).split(path.sep).join('/');
   if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) {
     throw new Error('Svelte-component source file escapes project root');
   }

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-accept.mjs

@@ -119,7 +119,7 @@ Output (JSON):
   }
 
   const { file: targetFile, content, lines } = found;
-  const relFile = path.relative(process.cwd(), targetFile);
+  const relFile = path.relative(process.cwd(), targetFile).split(path.sep).join('/');
   const previewBlock = findMarkerBlock(id, lines);
   const sourceShadowPreview = previewBlock
     ? readSourceShadowPreviewMeta(content, id)

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-commit-manual-edits.mjs

@@ -224,7 +224,7 @@ function buildRepairBatch(batch, repair) {
 function normalizeProjectSourcePath(cwd, file, opts = {}) {
   if (!file || typeof file !== 'string') return null;
   const absolute = path.isAbsolute(file) ? file : path.resolve(cwd, file);
-  const relative = path.relative(cwd, absolute);
+  const relative = path.relative(cwd, absolute).split(path.sep).join('/');
   if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null;
   if (opts.requireExists && !fs.existsSync(absolute)) return null;
   if (isGeneratedFile(absolute, { cwd })) return null;
@@ -622,7 +622,7 @@ function scanRollbackDir(dir, cwd, out, seenDirs, seenFiles, depth) {
     try { realFile = fs.realpathSync(absolute); } catch { continue; }
     if (seenFiles.has(realFile)) continue;
     seenFiles.add(realFile);
-    const relative = path.relative(cwd, absolute);
+    const relative = path.relative(cwd, absolute).split(path.sep).join('/');
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) continue;
     out.push(relative);
   }

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-copy-edit-agent.mjs

@@ -534,7 +534,7 @@ function runAgentProcess(command, args, stdin, { cwd, env, logPath, timeoutMs, m
 }
 
 function isPathInsideOrEqual(cwd, file) {
-  const relative = path.relative(path.resolve(cwd), path.resolve(file));
+  const relative = path.relative(path.resolve(cwd), path.resolve(file)).split(path.sep).join('/');
   return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-insert.mjs

@@ -166,7 +166,7 @@ Output (JSON):
     console.error(JSON.stringify({
       error: 'file_is_generated',
       fallback: 'agent-driven',
-      file: path.relative(process.cwd(), path.resolve(process.cwd(), targetFile)),
+      file: path.relative(process.cwd(), path.resolve(process.cwd(), targetFile)).split(path.sep).join('/'),
     }));
     process.exit(1);
   }
@@ -179,7 +179,7 @@ Output (JSON):
     console.error(JSON.stringify({
       error: 'element_ambiguous',
       fallback: 'agent-driven',
-      file: path.relative(process.cwd(), targetFile),
+      file: path.relative(process.cwd(), targetFile).split(path.sep).join('/'),
       candidates: resolved.candidates.map((c) => ({
         startLine: c.startLine + 1,
         endLine: c.endLine + 1,

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-manual-edit-evidence.mjs

@@ -64,7 +64,7 @@ export function buildManualEditEvidence({ cwd = process.cwd(), pageUrl = null }
     ops,
     context: {
       cwd,
-      bufferPath: path.relative(cwd, getBufferPath(cwd)),
+      bufferPath: path.relative(cwd, getBufferPath(cwd)).split(path.sep).join('/'),
       totalEntries: entries.length,
       totalOps: opCount,
     },
@@ -157,7 +157,7 @@ function analyzeSourceHint(op, cwd) {
   const hint = normalizeSourceHint(op.sourceHint);
   if (!hint.file) return null;
   const file = path.resolve(cwd, hint.file);
-  const relativeFile = path.relative(cwd, file);
+  const relativeFile = path.relative(cwd, file).split(path.sep).join('/');
   if (!isPathInsideOrEqual(cwd, file)) {
     return { ...hint, status: 'outside_cwd', relativeFile: hint.file };
   }
@@ -254,7 +254,7 @@ function maybeAddSearchFile(file, cwd, seenFiles, out) {
   if (isGeneratedFile(file, { cwd })) return;
   let content;
   try { content = fs.readFileSync(file, 'utf-8'); } catch { return; }
-  out.push({ file, relativeFile: path.relative(cwd, file), content, lines: content.split('\n') });
+  out.push({ file, relativeFile: path.relative(cwd, file).split(path.sep).join('/'), content, lines: content.split('\n') });
 }
 
 function findLiteralMatches(searchFiles, needle, { max }) {
@@ -340,7 +340,7 @@ function matchForIndex(file, index, kind, needle) {
 }
 
 function isPathInsideOrEqual(cwd, file) {
-  const rel = path.relative(path.resolve(cwd), path.resolve(file));
+  const rel = path.relative(path.resolve(cwd), path.resolve(file)).split(path.sep).join('/');
   return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 }
 

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-server.mjs

@@ -789,7 +789,7 @@ function sessionFileMetadataFromPollReply(file) {
   let full;
   try {
     full = path.resolve(process.cwd(), normalized);
-    const rel = path.relative(process.cwd(), full);
+    const rel = path.relative(process.cwd(), full).split(path.sep).join('/');
     if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return base;
   } catch {
     return base;

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live-wrap.mjs

@@ -102,7 +102,7 @@ The agent should insert variant HTML at insertLine.`);
         console.error(JSON.stringify({
           error: 'element_not_in_source',
           fallback: 'agent-driven',
-          generatedMatch: path.relative(process.cwd(), generatedHit),
+          generatedMatch: path.relative(process.cwd(), generatedHit).split(path.sep).join('/'),
           hint: 'Element found only in a generated file. See "Handle fallback" in live.md.',
         }));
       } else {
@@ -119,7 +119,7 @@ The agent should insert variant HTML at insertLine.`);
       console.error(JSON.stringify({
         error: 'file_is_generated',
         fallback: 'agent-driven',
-        file: path.relative(process.cwd(), path.resolve(process.cwd(), targetFile)),
+        file: path.relative(process.cwd(), path.resolve(process.cwd(), targetFile)).split(path.sep).join('/'),
         hint: 'Explicit --file points at a generated file. Writing here gets wiped by the next build. See "Handle fallback" in live.md.',
       }));
       process.exit(1);
@@ -172,7 +172,7 @@ The agent should insert variant HTML at insertLine.`);
         console.error(JSON.stringify({
           error: 'element_ambiguous',
           fallback: 'agent-driven',
-          file: path.relative(process.cwd(), targetFile),
+          file: path.relative(process.cwd(), targetFile).split(path.sep).join('/'),
           candidates: filtered.map((c) => ({
             startLine: c.startLine + 1,
             endLine: c.endLine + 1,

package/packages/@monomind/cli/bin/cli.js

@@ -264,13 +264,72 @@ if (isMCPMode) {
     }
     process.exit(1);
   };
+  // Not every uncaught error is a bug in monomind, and filing a PUBLIC GitHub
+  // issue for one that isn't is worse than useless — it leaks the user's paths
+  // into a tracker and buries real crashes in noise. Two classes are user
+  // environment or normal usage, never a product defect:
+  //
+  //   EPIPE / ERR_STREAM_DESTROYED — the reader closed the pipe first. This is
+  //     what `monomind hooks worker list | head` does every single time, and
+  //     what `| less` does when you quit early. Completely normal (issue #41).
+  //
+  //   ERR_MODULE_NOT_FOUND — a dependency is missing from the install: a
+  //     partial/corrupt node_modules, or the CLI being run straight out of an
+  //     extracted tarball. The user needs an actionable message, not a bug
+  //     report filed on their behalf (issues #46, #47).
+  //
+  // Anything else still reports as before.
+  const classifyFault = (err) => {
+    const code = err && err.code;
+    if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') return 'broken-pipe';
+    if (code === 'ERR_MODULE_NOT_FOUND') return 'missing-dependency';
+    return 'crash';
+  };
+
+  /** Handles the non-bug classes. Returns true if it fully handled the error. */
+  const handleExpectedFault = (err) => {
+    switch (classifyFault(err)) {
+      case 'broken-pipe':
+        // Downstream went away — there is nothing left to say and nowhere to
+        // say it. Exiting 0 keeps `monomind ... | head` from looking failed.
+        process.exit(0);
+        return true;
+      case 'missing-dependency': {
+        const pkg = /Cannot find package '([^']+)'/.exec(safeMsg(err && err.message))?.[1];
+        console.error(
+          pkg
+            ? `[monomind] Missing dependency: ${pkg}\n` +
+                `  This is an install problem, not a crash — nothing was reported.\n` +
+                `  Try: npm install ${pkg}   (or reinstall monomind: npm i -g monomind@latest)`
+            : `[monomind] A dependency could not be resolved: ${safeMsg(err && err.message)}\n` +
+                `  This is an install problem, not a crash — nothing was reported.`,
+        );
+        if (process.env.DEBUG) console.error(err && err.stack);
+        process.exit(1);
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
+
+  // Belt and braces for the pipe case: handling 'error' on the streams keeps a
+  // mid-write EPIPE from becoming an uncaughtException at all.
+  for (const stream of [process.stdout, process.stderr]) {
+    stream.on('error', (err) => {
+      if (classifyFault(err) === 'broken-pipe') process.exit(0);
+    });
+  }
+
   process.on('uncaughtException', (err) => {
+    if (handleExpectedFault(err)) return;
     console.error(`[${new Date().toISOString()}] FATAL [monomind] uncaughtException: ${safeMsg(err && err.message)}`);
     if (process.env.DEBUG) console.error(err && err.stack);
     reportAndExit(safeMsg(err && err.message) || 'uncaughtException', err && err.stack);
     return;
   });
   process.on('unhandledRejection', (reason) => {
+    if (reason instanceof Error && handleExpectedFault(reason)) return;
     const msg = reason instanceof Error ? reason.message : String(reason);
     console.error(`[${new Date().toISOString()}] FATAL [monomind] unhandledRejection: ${safeMsg(msg)}`);
     if (process.env.DEBUG && reason instanceof Error) console.error(reason.stack);

package/packages/@monomind/cli/dist/src/commands/org.js

@@ -300,6 +300,49 @@ const serveAction = async (ctx) => {
     };
     process.on('uncaughtException', (err) => { crashExit('uncaughtException', err); process.exit(1); });
     process.on('unhandledRejection', (err) => { crashExit('unhandledRejection', err); process.exit(1); });
+    // Termination diagnostics (#45). The two handlers above only cover errors
+    // raised *inside* the daemon. A report of the daemon vanishing after hours
+    // had a log holding nothing but its startup lines, because the ways a daemon
+    // usually dies were all unhandled:
+    //
+    //   - a signal (SIGTERM from a supervisor/OS, SIGHUP when a terminal closes)
+    //   - the event loop simply draining, which exits 0 and says nothing at all
+    //
+    // Both now announce themselves. Note what this deliberately cannot cover:
+    // SIGKILL, which is what the OOM killer sends, is uncatchable by design — no
+    // in-process handler can ever log it. That case is instead made *inferable*:
+    // every shutdown path below prints a terminal line, so a log that starts and
+    // then stops with no such line means the process was killed from outside
+    // (OOM being the usual culprit, and the reporter's org logs did show memory
+    // pressure). Absence of a shutdown line is now evidence, not ambiguity.
+    let shuttingDown = false;
+    const announceExit = (reason) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        try {
+            console.error(`[org serve] shutting down: ${reason}`);
+        }
+        catch { /* stderr gone */ }
+    };
+    for (const sig of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
+        process.on(sig, () => {
+            announceExit(`received ${sig}`);
+            try {
+                daemon.persistCrashStateAll();
+                daemon.clearHeartbeat();
+            }
+            catch { /* best effort */ }
+            // A daemon holds ref'd timers, so it will not drain on its own; an
+            // explicit exit is required here and is the intended signal semantics.
+            process.exit(sig === 'SIGTERM' || sig === 'SIGINT' ? 0 : 1);
+        });
+    }
+    process.on('exit', (code) => {
+        // Last word on the way out. Reached for the "event loop drained" case,
+        // which previously produced a completely silent disappearance.
+        announceExit(`process exiting with code ${code}`);
+    });
     // Heartbeat: write every 30s so `org status` can tell "alive but busy" from
     // "daemon gone" without relying on pid liveness alone.
     daemon.writeHeartbeat();

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.7.10",
+  "version": "2.7.12",
   "type": "module",
   "description": "CLI engine for Monomind \u2014 an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",
@@ -81,13 +81,13 @@
     "README.md"
   ],
   "scripts": {
-    "prebuild": "rm -rf dist tsconfig.tsbuildinfo",
-    "build": "tsc && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html && mkdir -p dist/src/ui && cp src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html dist/src/ui/ && rm -rf dist/src/ui/data && cp -r src/ui/data dist/src/ui/data",
-    "build:loose": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html && mkdir -p dist/src/ui && cp src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html dist/src/ui/ && rm -rf dist/src/ui/data && cp -r src/ui/data dist/src/ui/data",
+    "prebuild": "node ../../../scripts/build-fs.mjs clean dist tsconfig.tsbuildinfo",
+    "build": "tsc && node ../../../scripts/build-fs.mjs copy-into dist/src/browser/dashboard src/browser/dashboard/ui.html && node ../../../scripts/build-fs.mjs copy-into dist/src/ui src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html && node ../../../scripts/build-fs.mjs clean dist/src/ui/data && node ../../../scripts/build-fs.mjs copy-dir src/ui/data dist/src/ui/data",
+    "build:loose": "tsc --noEmitOnError false || true && node ../../../scripts/build-fs.mjs copy-into dist/src/browser/dashboard src/browser/dashboard/ui.html && node ../../../scripts/build-fs.mjs copy-into dist/src/ui src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html && node ../../../scripts/build-fs.mjs clean dist/src/ui/data && node ../../../scripts/build-fs.mjs copy-dir src/ui/data dist/src/ui/data",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
-    "prepublishOnly": "node ../../@monoes/monodesign/scripts/sync-skill.mjs && cp ../../../README.md ./README.md && npm run build",
+    "prepublishOnly": "node ../../@monoes/monodesign/scripts/sync-skill.mjs && node ../../../scripts/build-fs.mjs copy-into . ../../../README.md && npm run build",
     "release": "npm version prerelease --preid=alpha && npm run publish:all",
     "publish:all": "./scripts/publish.sh"
   },
@@ -99,7 +99,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.207",
     "@monoes/monobrowse": "^1.0.6",
-    "@monoes/monodesign": "^1.2.1",
+    "@monoes/monodesign": "^1.2.2",
     "@monoes/monograph": "^1.5.4",
     "@noble/ed25519": "^2.1.0",
     "mammoth": "^1.12.0",

package/scripts/build-fs.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform filesystem primitives for npm build scripts.
+ *
+ * Every package's build used POSIX shell directly — recursive delete, mkdir -p,
+ * cp -r. npm runs scripts through cmd.exe on Windows, which does not understand
+ * any of them and answers "The syntax of the command is incorrect". Seven of
+ * eight packages had this shape, so monomind could not be BUILT on Windows at
+ * all. That does not affect users installing from npm (they get prebuilt dist
+ * output), but it locks out Windows contributors entirely.
+ *
+ * Node's own fs covers all of it, so this adds no dependency — rimraf, shx and
+ * friends would each be a new supply-chain edge for something the stdlib
+ * already does. Node >= 20 is the floor, where rmSync and cpSync are both
+ * available.
+ *
+ * Subcommands are deliberately explicit rather than mirroring `cp`'s
+ * file-vs-directory inference, so a caller can never get directory semantics by
+ * accident:
+ *
+ *   clean <path...>              recursive delete, no error if absent
+ *   copy-into <destDir> <src...> copy each src INTO destDir, keeping basenames
+ *   copy-dir <src> <dest>        recursive directory copy
+ */
+import { rmSync, mkdirSync, cpSync, existsSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const [cmd, ...args] = process.argv.slice(2);
+
+const fail = (msg) => {
+  console.error(`build-fs: ${msg}`);
+  process.exit(1);
+};
+
+switch (cmd) {
+  case 'clean': {
+    if (args.length === 0) fail('clean needs at least one path');
+    for (const target of args) {
+      rmSync(target, { recursive: true, force: true });
+    }
+    break;
+  }
+
+  case 'copy-into': {
+    const [destDir, ...sources] = args;
+    if (!destDir || sources.length === 0) {
+      fail('copy-into needs a destination directory and at least one source');
+    }
+    mkdirSync(destDir, { recursive: true });
+    for (const src of sources) {
+      // Fail loudly on a missing source. The shell `cp` this replaces would
+      // also error, and a build that silently omits a file produces a dist
+      // that looks fine until something 404s at runtime.
+      if (!existsSync(src)) fail(`source does not exist: ${src}`);
+      cpSync(src, join(destDir, basename(src)), {
+        recursive: statSync(src).isDirectory(),
+      });
+    }
+    break;
+  }
+
+  case 'copy-dir': {
+    const [src, dest] = args;
+    if (!src || !dest) fail('copy-dir needs a source and a destination');
+    if (!existsSync(src)) fail(`source does not exist: ${src}`);
+    cpSync(src, dest, { recursive: true });
+    break;
+  }
+
+  default:
+    fail(
+      `unknown subcommand ${cmd ? `"${cmd}"` : '(none given)'} — ` +
+      'expected clean, copy-into, or copy-dir',
+    );
+}