monomind 2.7.6 → 2.7.8

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/.claude/skills/monodesign/scripts/live-server.mjs

@@ -1112,7 +1112,8 @@ applyLegacyDeferredAcceptsOnStartup();
 restorePendingEventsFromStore();
 manualApply.pruneStaleEvidence();
 const portArg = args.find(a => a.startsWith('--port='));
-state.port = portArg ? parseInt(portArg.split('=')[1], 10) : await findOpenPort();
+const explicitPort = portArg ? parseInt(portArg.split('=')[1], 10) : null;
+state.port = explicitPort ?? await findOpenPort();
 // Annotation screenshots live in the project root so the agent's Read tool
 // doesn't trip a per-file permission prompt. Sessioned by token so concurrent
 // projects (or quick restarts) don't collide.
@@ -1123,7 +1124,43 @@ state.sessionDir = fs.mkdtempSync(path.join(annotRoot, 'session-'));
 const { detectScript, liveScriptParts } = loadBrowserScripts();
 httpServer = http.createServer(createRequestHandler({ detectScript, liveScriptParts }));
 
+// findOpenPort() probes a port, closes the probe socket, and only then does the
+// real server bind it. Another process scanning the same range can take the
+// port inside that gap, which surfaced as an intermittent
+// "EADDRINUSE 127.0.0.1:8405" — about one run in five of the test suite, where
+// several server-starting test files run in parallel.
+//
+// Retry on the next port when we picked it ourselves. An explicit --port is
+// never silently moved: the caller asked for that port, so a conflict there
+// must be an error they can see.
+const MAX_PORT_RETRIES = 25;
+let portRetries = 0;
+
+httpServer.on('error', (err) => {
+  if (err?.code !== 'EADDRINUSE') throw err;
+
+  if (explicitPort !== null) {
+    console.error(`\nPort ${state.port} is already in use.`);
+    console.error('Another live server may be running — stop it, or pass a different --port.');
+    process.exit(1);
+  }
+
+  if (portRetries >= MAX_PORT_RETRIES) {
+    console.error(`\nCould not find a free port after ${MAX_PORT_RETRIES} attempts (last tried ${state.port}).`);
+    process.exit(1);
+  }
+
+  portRetries++;
+  state.port++;
+  httpServer.listen(state.port, '127.0.0.1');
+});
+
 httpServer.listen(state.port, '127.0.0.1', () => {
+  // Trust the address the OS actually bound over the one we asked for — after
+  // a retry above, state.port and the bound port must not drift apart.
+  const boundAddr = httpServer.address();
+  if (boundAddr && typeof boundAddr === 'object') state.port = boundAddr.port;
+
   writeLiveServerInfo(process.cwd(), { pid: process.pid, port: state.port, token: state.token });
   const url = `http://localhost:${state.port}`;
   console.log(`\nMonodesign live server running on ${url}`);

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/agent-ops.js

@@ -180,6 +180,36 @@ export const healthCommand = {
         { command: 'monomind agent health -i agent-001 -d', description: 'Detailed health for specific agent' },
     ],
     action: async (ctx) => {
+        // --watch was declared (and documented as "refresh every 5s") but never
+        // read, so the command rendered once and exited. Mirrors the watch loop in
+        // commands/status.ts.
+        if (ctx.flags.watch) {
+            return watchAgentHealth(ctx);
+        }
+        return renderAgentHealth(ctx);
+    },
+};
+const WATCH_INTERVAL_MS = 5000;
+async function watchAgentHealth(ctx) {
+    const refresh = async () => {
+        process.stdout.write('\x1b[2J\x1b[H');
+        output.writeln(output.dim(`Last updated: ${new Date().toLocaleTimeString()} — refreshing every 5s. Press Ctrl+C to exit.`));
+        await renderAgentHealth(ctx);
+    };
+    await refresh();
+    const intervalId = setInterval(() => { void refresh(); }, WATCH_INTERVAL_MS);
+    // `once` so repeated invocations don't accumulate SIGINT handlers.
+    return new Promise((resolve) => {
+        process.once('SIGINT', () => {
+            clearInterval(intervalId);
+            output.writeln();
+            output.printInfo('Watch mode stopped');
+            resolve({ success: true });
+        });
+    });
+}
+async function renderAgentHealth(ctx) {
+    {
         const agentId = ctx.args[0] || ctx.flags.id;
         const detailed = ctx.flags.detailed;
         try {
@@ -242,6 +272,6 @@ export const healthCommand = {
             output.printError(error instanceof MCPClientError ? `Health check error: ${error.message}` : `Unexpected error: ${String(error)}`);
             return { success: false, exitCode: 1 };
         }
-    },
-};
+    }
+}
 //# sourceMappingURL=agent-ops.js.map

package/packages/@monomind/cli/dist/src/commands/browse-workflow.js

@@ -53,6 +53,35 @@ const runSubcommand = {
         const wf = await readWorkflow(filePath).catch(e => { output.printError(e.message); return null; });
         if (!wf)
             return { success: false, exitCode: 1 };
+        // --items feeds the run's input set. Previously the flag was parsed and
+        // then dropped, so every run silently used the single empty default item.
+        let items;
+        const itemsFlag = ctx.flags.items;
+        if (itemsFlag) {
+            const itemsPath = isAbsolute(itemsFlag) ? itemsFlag : resolve(ctx.cwd, itemsFlag);
+            let parsed;
+            try {
+                const { readFile } = await import('fs/promises');
+                parsed = JSON.parse(await readFile(itemsPath, 'utf8'));
+            }
+            catch (e) {
+                output.printError(`Cannot read items file ${itemsPath}: ${e.message}`);
+                return { success: false, exitCode: 1 };
+            }
+            if (!Array.isArray(parsed)) {
+                output.printError(`Items file ${itemsPath} must contain a JSON array`);
+                return { success: false, exitCode: 1 };
+            }
+            // Accept both the engine's `{ data: {...} }` envelope and a bare array
+            // of objects, which is the shape people naturally write by hand.
+            items = parsed.map((entry) => {
+                const rec = entry;
+                return rec && typeof rec === 'object' && 'data' in rec && typeof rec.data === 'object' && rec.data !== null
+                    ? { data: rec.data }
+                    : { data: (rec ?? {}) };
+            });
+            output.printInfo(`Loaded ${items.length} input item(s) from ${itemsFlag}`);
+        }
         const port = ctx.flags.port ?? 4243;
         const dashboard = getDashboardServer(port);
         if (!ctx.flags['no-dashboard']) {
@@ -65,6 +94,7 @@ const runSubcommand = {
         spinner.start();
         const record = await runWorkflow(wf, {
             onEvent: (ev) => dashboard.broadcast(ev),
+            ...(items ? { items } : {}),
         });
         if (record.status === 'completed') {
             spinner.succeed(`Done — ${record.itemsProcessed} items in ${((record.completedAt - record.startedAt) / 1000).toFixed(1)}s`);

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/hooks-extended-commands.js

@@ -200,7 +200,7 @@ export const notifyCommand = {
     options: [
         { name: 'message', short: 'm', type: 'string', description: 'Notification message', required: true },
         { name: 'level', short: 'l', type: 'string', description: 'Level: info, warn, error', default: 'info' },
-        { name: 'channel', short: 'c', type: 'string', description: 'Notification channel', default: 'console' },
+        { name: 'channel', short: 'c', type: 'string', description: 'Notification channel (only "console" is implemented)', default: 'console' },
     ],
     examples: [
         { command: 'monomind hooks notify -m "Build complete"', description: 'Send info notification' },
@@ -213,6 +213,14 @@ export const notifyCommand = {
             output.printError('Message is required: --message "your message"');
             return { success: false, exitCode: 1 };
         }
+        // Console is the only delivery mechanism that exists. Accepting
+        // `--channel slack` and then printing to the console anyway would tell the
+        // user their message went somewhere it did not.
+        const channel = ctx.flags.channel || 'console';
+        if (channel !== 'console') {
+            output.writeln(output.warning(`Channel "${channel}" is not implemented — delivering to console. ` +
+                `Only "console" is supported today.`));
+        }
         const timestamp = new Date().toISOString();
         if (level === 'error') {
             output.printError(`[${timestamp}] ${message}`);
@@ -229,7 +237,7 @@ export const notifyCommand = {
             await storeEntry({ key: `notify-${Date.now()}`, value: `[${level}] ${message}`, namespace: 'notifications' });
         }
         catch { /* memory not available */ }
-        return { success: true, data: { timestamp, level, message } };
+        return { success: true, data: { timestamp, level, message, channel: 'console' } };
     }
 };
 //# sourceMappingURL=hooks-extended-commands.js.map

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

@@ -297,7 +297,10 @@ export const searchCommand = {
                 output.writeln();
             }
         }
-        output.printInfo(`Searching: "${query}" (${searchType})`);
+        // Requested type only — the method that ACTUALLY ran is printed after the
+        // search, from searchResult.searchMethod. Labelling this line "(semantic)"
+        // used to claim a vector search that may never have happened.
+        output.printInfo(`Searching: "${query}" (requested: ${searchType})`);
         output.writeln();
         // Use direct sql.js search with vector similarity
         try {
@@ -318,11 +321,45 @@ export const searchCommand = {
                 namespace: r.namespace,
                 preview: r.content
             }));
+            const actualMethod = searchResult.searchMethod ?? 'unknown';
+            const fallbackReason = searchResult.fallbackReason;
             if (ctx.flags.format === 'json') {
-                output.printJson({ query, searchType, results, searchTime: `${searchResult.searchTime}ms` });
+                output.printJson({
+                    query,
+                    searchType,
+                    searchMethod: actualMethod,
+                    ...(fallbackReason ? { fallbackReason } : {}),
+                    results,
+                    searchTime: `${searchResult.searchTime}ms`,
+                });
                 return { success: true, data: results };
             }
-            // Performance stats
+            // Performance stats — method first, so a keyword fallback is never hidden
+            // 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 {
+                output.printWarning(`Method: ${actualMethod}${why ? ` — ${why}` : ''}. Scores are token-overlap fractions, not vector similarity.`);
+            }
             output.writeln(output.dim(`  Search time: ${searchResult.searchTime}ms`));
             output.writeln();
             if (results.length === 0) {