monomind 2.7.7 → 2.7.9

package/packages/@monomind/cli/.claude/helpers/intelligence.cjs

@@ -27,6 +27,7 @@ const RECENT_EDITS_FILE = path.join(DATA_DIR, 'recent-edits.jsonl');
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MiB guard
 const RING_BUFFER_MAX = 50;
+const MAX_ENTRIES = 200;
 
 var _entries = [];        // deduplicated memory entries loaded from store
 var _recentEdits = [];    // ring buffer of recently edited paths (in-memory, may be empty across subprocesses)
@@ -141,7 +142,7 @@ function init() {
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
-  });
+  }).slice(-MAX_ENTRIES);
 
   // Bootstrap from monograph when store is sparse — called externally via bootstrapFromDb(db)
 
@@ -490,6 +491,7 @@ function bootstrapFromDb(db) {
         files: h.file ? [h.file] : [],
         ts: Date.now(),
       };
+      if (_entries.length >= MAX_ENTRIES) _entries.shift();
       _entries.push(hubEntry);
       newHubEntries.push(hubEntry);
       added++;

package/packages/@monomind/cli/.claude/helpers/statusline.cjs

@@ -99,6 +99,22 @@ function readJSON(filePath) {
   } catch { /* ignore */ }
   return null;
 }
+/** Canonical data root — mirrors getMonomindDataRoot() in mcp-tools/types.ts. */
+function monomindDataRoot(cwd) {
+  if (process.env.MONOMIND_DATA_DIR) return process.env.MONOMIND_DATA_DIR;
+  try {
+    const gitEntry = path.join(cwd, '.git');
+    const st = fs.statSync(gitEntry);
+    if (st.isDirectory()) return path.join(gitEntry, 'monomind');
+    const m = fs.readFileSync(gitEntry, 'utf8').match(/^gitdir:\s*(.+)/m);
+    if (m) {
+      const wt = path.resolve(cwd, m[1].trim());
+      return path.join(path.dirname(path.dirname(wt)), 'monomind');
+    }
+  } catch { /* not a git repo */ }
+  return path.join(cwd, '.monomind');
+}
+
 
 // Safe file stat (returns null on failure)
 function safeStat(filePath) {
@@ -395,9 +411,17 @@ function getSwarmStatus() {
     } catch { /* fall through */ }
   }
 
-  // SECONDARY: swarm-state.json written by MCP swarm_init — trust if fresh
-  const swarmStatePath = path.join(CWD, '.monomind', 'swarm', 'swarm-state.json');
-  const swarmState = readJSON(swarmStatePath);
+  // SECONDARY: swarm-state.json written by MCP swarm_init — trust if fresh.
+  // The MCP tools resolve their data root via getMonomindDataRoot(), which
+  // inside a git repo is `<repo>/.git/monomind` — so reading only
+  // `<cwd>/.monomind` showed a stale or missing swarm in every real project.
+  // Canonical first, legacy second for projects written by an older CLI.
+  const swarmStateCandidates = [
+    path.join(monomindDataRoot(CWD), 'swarm', 'swarm-state.json'),
+    path.join(CWD, '.monomind', 'swarm', 'swarm-state.json'),
+  ];
+  let swarmState = null;
+  for (const p of swarmStateCandidates) { swarmState = readJSON(p); if (swarmState) break; }
   if (swarmState) {
     const updatedAt = swarmState.updatedAt || swarmState.startedAt;
     const age = updatedAt ? now - new Date(updatedAt).getTime() : Infinity;

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

@@ -330,25 +330,107 @@ function _graphGateReadSessions() {
   return sessions;
 }
 
+// Atomic replace: write a per-process temp file, then rename() over the
+// target. rename() within a directory is atomic on POSIX and on Windows via
+// Node's fs, so a concurrent reader sees either the old file or the new one
+// — never a half-written one. (The previous plain writeFileSync truncated
+// the live file first, so a reader could observe a truncated/torn document.)
 function _graphGateWriteSessions(sessions) {
   var ids = Object.keys(sessions);
   if (ids.length > 20) {
     ids.sort(function (a, b) { return (sessions[a].ts || 0) - (sessions[b].ts || 0); });
     for (var i = 0; i < ids.length - 20; i++) delete sessions[ids[i]];
   }
-  fs.mkdirSync(path.join(CWD, '.monomind'), { recursive: true });
-  fs.writeFileSync(_graphGateStateFile(), JSON.stringify({ sessions: sessions }));
+  var dir = path.join(CWD, '.monomind');
+  fs.mkdirSync(dir, { recursive: true });
+  var target = _graphGateStateFile();
+  var tmp = target + '.' + process.pid + '.' + Math.random().toString(36).slice(2, 8) + '.tmp';
+  try {
+    fs.writeFileSync(tmp, JSON.stringify({ sessions: sessions }));
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
 }
 
-function _graphGateMarkQueried(sessionId) {
-  if (!sessionId) return;
+// Cross-process advisory lock around the read-modify-write above.
+//
+// Three concurrent paths touch this state (pre-bash, pre-search, and
+// post-graph-tool's markQueried), each in its own short-lived process. Without
+// a lock, two of them read the same snapshot and the second write erases the
+// first — measured: 12 concurrent writers landed as few as 6 of 12 session
+// records. A lost `queried:true` re-blocks a session that already called
+// monograph; a lost `blockedOnce` can block it a second time.
+//
+// mkdir is the atomic primitive (works on every platform and over network FS).
+// The lock is best-effort: if it can't be taken within the budget, or a stale
+// 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;
+var _GRAPH_GATE_LOCK_STALE_MS = 2000;
+
+function _sleepSync(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch (e) { /* no SAB */ }
+}
+
+function _graphGateAcquireLock() {
+  var lockDir = _graphGateStateFile() + '.lock';
+  var deadline = Date.now() + _GRAPH_GATE_LOCK_TIMEOUT_MS;
+  var held = false;
+  for (;;) {
+    try {
+      fs.mkdirSync(lockDir);
+      held = true;
+      break;
+    } catch (e) {
+      if (e && e.code !== 'EEXIST') break; // can't lock at all — proceed unlocked
+      try {
+        var st = fs.statSync(lockDir);
+        if (Date.now() - st.mtimeMs > _GRAPH_GATE_LOCK_STALE_MS) {
+          fs.rmSync(lockDir, { recursive: true, force: true }); // crashed holder
+          continue;
+        }
+      } catch (_) { continue; } // lock vanished — retry immediately
+      if (Date.now() >= deadline) break; // give up; write unlocked
+      _sleepSync(5);
+    }
+  }
+  return function release() {
+    if (!held) return;
+    try { fs.rmSync(lockDir, { recursive: true, force: true }); } catch (_) {}
+  };
+}
+
+/**
+ * Read-modify-write one session's entry under the lock. `mutate(s, ctx)`
+ * receives the session record (created if absent) and mutates it in place; its
+ * return value is passed through to the caller. A mutator that changed nothing
+ * can call `ctx.noWrite()` to skip the write entirely (the common read-only
+ * case: a session that already called monograph).
+ */
+function _graphGateUpdateSession(sessionId, mutate) {
+  var release = _graphGateAcquireLock();
   try {
     var sessions = _graphGateReadSessions();
-    var s = sessions[sessionId] || { blockedOnce: false };
-    s.queried = true;
+    var s = sessions[sessionId] || { queried: false, blockedOnce: false };
+    var write = true;
+    var out = mutate(s, { noWrite: function () { write = false; } });
+    if (!write) return out;
     s.ts = Date.now();
     sessions[sessionId] = s;
     _graphGateWriteSessions(sessions);
+    return out;
+  } finally {
+    release();
+  }
+}
+
+function _graphGateMarkQueried(sessionId) {
+  if (!sessionId) return;
+  try {
+    _graphGateUpdateSession(sessionId, function (s) { s.queried = true; });
   } catch (e) { /* non-fatal */ }
 }
 
@@ -356,19 +438,23 @@ function _graphGateMarkQueried(sessionId) {
 function _graphGateShouldBlock(sessionId) {
   if (String(process.env.MONOMIND_GRAPH_GATE || '').toLowerCase() === 'off') return false;
   if (!sessionId || !_isGraphFresh()) return false;
-  var sessions = _graphGateReadSessions();
-  var s = sessions[sessionId] || { queried: false, blockedOnce: false };
-  if (s.queried) return false;
-  if (!s.blockedOnce) {
-    s.blockedOnce = true;
-    s.ts = Date.now();
-    sessions[sessionId] = s;
-    try { _graphGateWriteSessions(sessions); } catch (e) { return false; }
-    return 'block';
+  // Test-and-set blockedOnce atomically: two concurrent greps in the same
+  // session must not both observe blockedOnce=false and both block.
+  try {
+    return _graphGateUpdateSession(sessionId, function (s, ctx) {
+      if (s.queried) { ctx.noWrite(); return false; }
+      if (!s.blockedOnce) {
+        s.blockedOnce = true;
+        return 'block';
+      }
+      // Already blocked once but monograph still not called — warn without
+      // blocking so subagents without MCP access don't deadlock.
+      ctx.noWrite();
+      return 'warn';
+    });
+  } catch (e) {
+    return false; // state unreadable/unwritable — never block on a state error
   }
-  // Already blocked once but monograph still not called — warn without blocking
-  // so subagents without MCP access don't deadlock.
-  return 'warn';
 }
 
 function _getNodeCount() {

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

@@ -57,7 +57,7 @@
         ]
       },
       {
-        "matcher": "Write|Edit|MultiEdit",
+        "matcher": "Write|Edit|MultiEdit|NotebookEdit",
         "hooks": [
           {
             "type": "command",

package/packages/@monomind/cli/dist/src/browser/dashboard/server.js

@@ -4,6 +4,7 @@ import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
+import { getMonomindDataRoot } from '../../mcp-tools/types.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // 4243: the main monomind dashboard owns 4242 — keep this server off that port
 const DEFAULT_PORT = 4243;
@@ -49,7 +50,11 @@ async function readMetricsDir(root) {
 async function collectDashboardState(root) {
     const [workerMetrics, swarmState, lastRoute, autoMemory] = await Promise.all([
         readMetricsDir(root),
-        readJsonSafe(join(root, '.monomind', 'swarm', 'swarm-state.json')),
+        // Canonical root first (getMonomindDataRoot(): `<repo>/.git/monomind` in a
+        // git repo), legacy `<root>/.monomind` second. Reading only the legacy path
+        // showed stale/absent swarm state in every real project.
+        readJsonSafe(join(getMonomindDataRoot(root), 'swarm', 'swarm-state.json'))
+            .then((v) => v ?? readJsonSafe(join(root, '.monomind', 'swarm', 'swarm-state.json'))),
         readJsonSafe(join(root, '.monomind', 'last-route.json')),
         readJsonSafe(join(root, '.monomind', 'data', 'auto-memory-store.json')),
     ]);

package/packages/@monomind/cli/dist/src/capabilities/index.d.ts

@@ -1,7 +1,6 @@
 export * from './types.js';
 export { scanDirectory, saveFingerprint, loadFingerprint } from './scanner.js';
 export { CapabilityManager } from './manager.js';
-export { FileWatcher } from './watcher.js';
 export { codeCapability } from './cap-code.js';
 export { documentsCapability } from './cap-documents.js';
 export { mediaCapability } from './cap-media.js';

package/packages/@monomind/cli/dist/src/capabilities/index.js

@@ -1,7 +1,14 @@
 export * from './types.js';
 export { scanDirectory, saveFingerprint, loadFingerprint } from './scanner.js';
 export { CapabilityManager } from './manager.js';
-export { FileWatcher } from './watcher.js';
+// `FileWatcher` (./watcher.ts) was deleted 2026-07: it was built, exported and
+// unit-tested but never instantiated anywhere in production. Nothing in the
+// capabilities pipeline watches files — `search scan` re-fingerprints on demand
+// (see commands/search-universal.ts) and monograph has its own separate watcher
+// (`monograph_watch`). Nothing outside this package could reach it either:
+// capabilities/ is not in package.json's `exports` map and src/index.ts never
+// re-exported it. If incremental re-scanning is wanted later, wire it to the
+// scanner at the same time rather than landing an unused class again.
 export { codeCapability } from './cap-code.js';
 export { documentsCapability } from './cap-documents.js';
 export { mediaCapability } from './cap-media.js';

package/packages/@monomind/cli/dist/src/commands/agent-lifecycle.js

@@ -181,6 +181,10 @@ export const listCommand = {
     ],
     action: async (ctx) => {
         try {
+            // agent_list emits `agentId` (agent-tools.ts), not `id` — reading `id`
+            // here rendered a blank ID column for every agent. `id` is kept as a
+            // fallback because agent_pool/agent_health project the same records
+            // under that key.
             const result = await callMCPTool('agent_list', {
                 status: ctx.flags.all ? 'all' : ctx.flags.status || undefined,
                 agentType: ctx.flags.type || undefined,
@@ -198,7 +202,7 @@ export const listCommand = {
                 return { success: true, data: result };
             }
             const displayAgents = result.agents.map(agent => ({
-                id: agent.id,
+                id: agent.agentId ?? agent.id ?? '',
                 type: agent.agentType,
                 status: agent.status,
                 created: new Date(agent.createdAt).toLocaleTimeString(),

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.js

@@ -627,7 +627,14 @@ export async function checkGuidanceGates() {
         }
         const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
         const preToolUse = settings?.hooks?.PreToolUse ?? [];
-        const hasPreWrite = preToolUse.some(e => e.matcher === 'Write|Edit|MultiEdit' && e.hooks.some(h => h.command?.includes('pre-write')));
+        // Match on capability, not on an exact matcher string. The matcher is a
+        // regex alternation that legitimately changes as tools are added — it
+        // gained `|NotebookEdit` when that tool turned out to bypass the secret
+        // gate — and an `=== 'Write|Edit|MultiEdit'` test reported the gate as
+        // INACTIVE the moment it did, telling users their secrets gate was off
+        // while it was demonstrably blocking secrets, and sending them to
+        // `guidance setup`, which would then add a duplicate entry.
+        const hasPreWrite = preToolUse.some(e => /\bWrite\b/.test(e.matcher ?? '') && e.hooks.some(h => h.command?.includes('pre-write')));
         const hasPreBash = preToolUse.some(e => e.matcher === 'Bash' && e.hooks.some(h => h.command?.includes('pre-bash')));
         if (!hasPreWrite && !hasPreBash)
             return { name: 'Guidance Gates', status: 'warn', message: 'gates-handler.cjs present but no gates registered', fix: 'monomind guidance setup' };

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

@@ -52,12 +52,18 @@ const setupCommand = {
         const preToolUse = hooks.PreToolUse || [];
         const PRE_BASH_MATCHER = 'Bash';
         const PRE_BASH_COMMAND = 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" pre-bash';
-        const PRE_WRITE_MATCHER = 'Write|Edit|MultiEdit';
+        // Keep in step with .claude/settings.json and init/settings-generator.ts.
+        // NotebookEdit is listed explicitly: its content field is `new_source`, so
+        // it slipped past the secret gate until the handler learned to read it.
+        const PRE_WRITE_MATCHER = 'Write|Edit|MultiEdit|NotebookEdit';
         const PRE_WRITE_COMMAND = 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" pre-write';
         // Find any existing Bash/Write entry (may have different hooks from other tools)
         const existingBashEntry = preToolUse.find(e => e.matcher === PRE_BASH_MATCHER);
         const alreadyHasPreBash = existingBashEntry?.hooks.some(h => h.command.includes('pre-bash')) ?? false;
-        const existingWriteEntry = preToolUse.find(e => e.matcher === PRE_WRITE_MATCHER);
+        // Find by capability, not exact string: a settings.json written before
+        // NotebookEdit was added still says 'Write|Edit|MultiEdit', and an exact
+        // match would miss it and append a second, overlapping entry.
+        const existingWriteEntry = preToolUse.find(e => /\bWrite\b/.test(e.matcher ?? ''));
         const alreadyHasPreWrite = existingWriteEntry?.hooks.some(h => h.command.includes('pre-write')) ?? false;
         const changes = [];
         // Register pre-bash (destructive-ops gate)

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

@@ -90,7 +90,18 @@ const initAction = async (ctx) => {
         // Start monograph watch for ongoing file-change rebuilds, unless --no-watch was passed.
         // Guard: skip if a watcher PID file already exists and the process is still alive,
         // preventing duplicate watchers from accumulating on repeated `init --force` runs.
-        const noWatch = ctx.flags['no-watch'];
+        // `--no-watch` is the parser's negation of the declared boolean `watch`
+        // option. It used to be declared as its own boolean named 'no-watch', which
+        // the parser never populated: parseFlag strips the `--no-` prefix and looks
+        // up `watch`, which IS a declared boolean (status/agent-ops declare it and
+        // getBooleanFlags() is global across all registered commands). So
+        // `--no-watch` set the unrelated `watch` flag to false and left `no-watch`
+        // at its `false` default — the flag was a silent no-op and the watcher
+        // started anyway. The legacy `no-watch`/`noWatch` keys are still honoured
+        // for programmatic callers that set ctx.flags directly.
+        const noWatch = ctx.flags.watch === false ||
+            ctx.flags['no-watch'] === true ||
+            ctx.flags.noWatch === true;
         if (!noWatch) {
             try {
                 const { spawn } = await import('child_process');
@@ -354,10 +365,13 @@ export const initCommand = {
             default: true,
         },
         {
-            name: 'no-watch',
-            description: 'Skip starting the monograph knowledge graph watcher after init',
+            // Declared as the positive `watch` so the parser's `--no-X` negation
+            // actually reaches it. Declaring it as `no-watch` made `--no-watch` a
+            // no-op — see the noWatch resolution in initAction.
+            name: 'watch',
+            description: 'Start the monograph knowledge graph watcher after init (default: true; --no-watch skips it)',
             type: 'boolean',
-            default: false,
+            default: true,
         },
         {
             name: 'with-embeddings',

package/packages/@monomind/cli/dist/src/commands/memory-crud.js

@@ -338,20 +338,26 @@ export const searchCommand = {
             // behind a "(semantic)" header.
             const REASON_TEXT = {
                 'no-embedding-model': 'embedding model unavailable',
+                'empty-query': 'query was empty, so no vector could be built',
                 'embedding-failed': 'embedding generation failed',
                 'no-semantic-matches': 'vector search returned no matches',
             };
+            const why = fallbackReason ? REASON_TEXT[fallbackReason] ?? fallbackReason : undefined;
             if (actualMethod === 'semantic') {
                 output.writeln(output.dim('  Method: semantic (vector similarity)'));
             }
             else if (actualMethod === 'hybrid') {
                 output.writeln(output.dim('  Method: hybrid (per-entry cosine, keyword overlap where no vector exists)'));
             }
+            else if (actualMethod === 'hash-vector' || actualMethod === 'hash-hybrid') {
+                // A vector search did run, but over hash-fallback embeddings — the
+                // scores are cosines of a lexical hash, not of a semantic model.
+                output.printWarning(`Method: ${actualMethod}${why ? ` — ${why}` : ''}. Scores are cosines over deterministic hash embeddings, not semantic similarity.`);
+            }
             else if (actualMethod === 'unknown') {
                 output.writeln(output.dim('  Method: unknown'));
             }
             else {
-                const why = fallbackReason ? REASON_TEXT[fallbackReason] ?? fallbackReason : undefined;
                 output.printWarning(`Method: ${actualMethod}${why ? ` — ${why}` : ''}. Scores are token-overlap fractions, not vector similarity.`);
             }
             output.writeln(output.dim(`  Search time: ${searchResult.searchTime}ms`));

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

@@ -295,6 +295,23 @@ export const answerAction = async (ctx, name) => {
     if (freshQ && freshQ.answer !== null) {
         return { success: false, message: `question "${questionId}" was answered while this command was running` };
     }
+    // Queue BEFORE marking answered (same rule as daemon.answerQuestion): if the
+    // append fails, the question must stay pending and answerable. Marking first meant
+    // a failed queueMessage recorded the answer as delivered while nothing was queued,
+    // and the `already answered` guard then rejected every retry.
+    const { queueMessage } = await import('../orgrt/inbox.js');
+    try {
+        queueMessage(ctx.cwd, name, {
+            fromQualified: 'human', toRole: q.role,
+            subject: `answer:${questionId}`,
+            body: `question: ${q.question}\n\nanswer: ${answer}`,
+            ts: Date.now(),
+        });
+    }
+    catch (err) {
+        log(output.error(`Could not queue the answer for ${name}:${q.role} (${err instanceof Error ? err.message : String(err)}) — answer NOT recorded, retry it.`));
+        return { success: false, message: 'queueing failed — answer not recorded' };
+    }
     const merged = fresh.some(x => x.questionId === questionId)
         ? fresh.map(x => x.questionId === questionId ? { ...x, answer, answeredAt: Date.now() } : x)
         : [...fresh, { ...q, answer, answeredAt: Date.now() }];
@@ -303,13 +320,6 @@ export const answerAction = async (ctx, name) => {
     writeFileSync(tmp, JSON.stringify({ questions: merged }, null, 2));
     const { renameSync } = await import('node:fs');
     renameSync(tmp, dest);
-    const { queueMessage } = await import('../orgrt/inbox.js');
-    queueMessage(ctx.cwd, name, {
-        fromQualified: 'human', toRole: q.role,
-        subject: `answer:${questionId}`,
-        body: `question: ${q.question}\n\nanswer: ${answer}`,
-        ts: Date.now(),
-    });
     log(output.success(`Answer recorded — ${name}:${q.role} receives it when the org next runs.`));
     return { success: true };
 };

package/packages/@monomind/cli/dist/src/commands/org.d.ts

@@ -1,4 +1,5 @@
 import type { Command, CommandResult } from '../types.js';
+import { OrgDaemon } from '../orgrt/daemon.js';
 export declare function validateOrgName(name: string | undefined): {
     ok: true;
     name: string;
@@ -9,6 +10,16 @@ export declare function validateOrgName(name: string | undefined): {
 export declare function listOrgConfigFiles(orgsDir: string): string[];
 /** Remove a lingering stopfile so a fresh `org run` doesn't self-terminate. */
 export declare const clearStopfile: (cwd: string, name: string) => void;
+/** One pass of the `org serve` stopfile poll.
+ *
+ * `monomind org stop <name>` writes `.monomind/orgs/<name>/stop`. `org run` has always
+ * polled that file; `org serve` did not — so against a serve daemon `org stop` was a
+ * silent no-op that still printed "daemon exits within 2s" and exited 0 while the org
+ * kept running. Stops every running org whose stopfile is present, then clears the
+ * stopfile so the next scheduled iteration isn't killed on sight.
+ *
+ * Returns the names it stopped (awaited), so callers/tests don't have to guess. */
+export declare const pollStopfiles: (cwd: string, daemon: OrgDaemon) => Promise<string[]>;
 export declare const orgCommand: Command;
 export default orgCommand;
 //# sourceMappingURL=org.d.ts.map