monomind 2.7.6 → 2.7.8

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

@@ -178,17 +178,44 @@ export const reportAction = async (ctx, name) => {
     }
     return { success: true };
 };
+/** Read questions.json. A MISSING file legitimately means "no questions" → [].
+ *  Any other failure (unreadable, malformed — e.g. a partial daemon write) THROWS:
+ *  answerAction rewrites this file from what this returns, so silently coercing a
+ *  failed read to [] would atomically replace every recorded question with one. */
 const readQuestions = (cwd, name) => {
+    const path = join(cwd, ORG_DIR, name, 'questions.json');
+    let raw;
     try {
-        return JSON.parse(readFileSync(join(cwd, ORG_DIR, name, 'questions.json'), 'utf8')).questions ?? [];
+        raw = readFileSync(path, 'utf8');
     }
-    catch {
-        return [];
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw new Error(`cannot read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
     }
+    catch (err) {
+        throw new Error(`${path} is not valid JSON (${err instanceof Error ? err.message : String(err)})`);
+    }
+    if (parsed?.questions === undefined || parsed.questions === null)
+        return [];
+    if (!Array.isArray(parsed.questions))
+        throw new Error(`${path}: "questions" is not an array`);
+    return parsed.questions;
 };
 /** `org questions <name> [--all]` — list pending (or all) ask_human questions. */
 export const questionsAction = async (ctx, name) => {
-    const all = readQuestions(ctx.cwd, name);
+    let all;
+    try {
+        all = readQuestions(ctx.cwd, name);
+    }
+    catch (err) {
+        log(output.error(`Cannot read questions for org ${name}: ${err instanceof Error ? err.message : String(err)}`));
+        return { success: false, message: 'questions.json unreadable' };
+    }
     const shown = ctx.flags['all'] === true ? all : all.filter(q => q.answer === null);
     if (!shown.length) {
         log(output.info(all.length ? `No pending questions for org ${name} (${all.length} answered — use --all).` : `No questions recorded for org ${name}.`));
@@ -212,7 +239,14 @@ export const answerAction = async (ctx, name) => {
     const answer = ctx.args.slice(2).join(' ').trim();
     if (!questionId || !answer)
         return { success: false, message: `usage: monomind org answer ${name} <question-id> "answer text"` };
-    const questions = readQuestions(ctx.cwd, name);
+    let questions;
+    try {
+        questions = readQuestions(ctx.cwd, name);
+    }
+    catch (err) {
+        log(output.error(`Cannot read questions for org ${name}: ${err instanceof Error ? err.message : String(err)}`));
+        return { success: false, message: 'questions.json unreadable — answer not recorded' };
+    }
     const q = questions.find(x => x.questionId === questionId);
     if (!q) {
         log(output.error(`Question "${questionId}" not found for org ${name} — list with: monomind org questions ${name}`));
@@ -246,11 +280,38 @@ export const answerAction = async (ctx, name) => {
     // snapshot can be up to 10s stale (live-delivery timeout), and rewriting
     // from it would delete questions the daemon appended meanwhile and revert
     // answers it recorded (atomic rename prevents torn writes, not lost updates).
-    const fresh = readQuestions(ctx.cwd, name);
+    // A FAILED re-read must abort the write: rewriting from [] would atomically
+    // rename a single-question file over every other recorded question.
+    let fresh;
+    try {
+        fresh = readQuestions(ctx.cwd, name);
+    }
+    catch (err) {
+        log(output.error(`Refusing to rewrite questions.json — ${err instanceof Error ? err.message : String(err)}`));
+        log(output.warning(`The answer was NOT recorded. Fix or restore ${join(ctx.cwd, ORG_DIR, name, 'questions.json')}, then retry.`));
+        return { success: false, message: 'questions.json unreadable — answer not recorded' };
+    }
     const freshQ = fresh.find(x => x.questionId === questionId);
     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() }];
@@ -259,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

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

@@ -1,5 +1,5 @@
 // packages/@monomind/cli/src/commands/org.ts
-import { readFileSync, existsSync, unlinkSync, rmSync, readdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, unlinkSync, rmSync, readdirSync, mkdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { output } from '../output.js';
 import { OrgDaemon } from '../orgrt/daemon.js';
@@ -162,9 +162,35 @@ const stopAction = async (ctx) => {
         log(output.error(`Org not found: ${name}`));
         return { success: false, message: 'org not found' };
     }
-    const { writeFileSync, mkdirSync } = await import('node:fs');
+    // The stopfile is only meaningful to a process that polls it (`org run` and, since
+    // this fix, `org serve`). Writing it for an org that nothing is running was a silent
+    // no-op that still reported "daemon exits within 2s" — say what's actually true.
+    let rt;
+    try {
+        rt = JSON.parse(readFileSync(join(ctx.cwd, ORG_DIR, name, 'runtime.json'), 'utf8'));
+    }
+    catch { /* never run */ }
+    if (rt?.status !== 'running') {
+        log(output.warning(`Org "${name}" is not running (runtime state: ${rt?.status ?? 'never run'}) — nothing to stop.`));
+        return { success: false, message: 'org not running' };
+    }
+    if (rt.pid) {
+        let alive = true;
+        try {
+            process.kill(rt.pid, 0);
+        }
+        catch {
+            alive = false;
+        }
+        if (!alive) {
+            log(output.warning(`Org "${name}" is not running — runtime.json says running but pid ${rt.pid} is gone (crashed daemon).`));
+            log(output.info(`Clear the stale record with: monomind org mark-complete ${name}`));
+            return { success: false, message: 'org crashed — use mark-complete' };
+        }
+    }
     mkdirSync(join(ctx.cwd, ORG_DIR, name), { recursive: true });
     writeFileSync(join(ctx.cwd, ORG_DIR, name, 'stop'), new Date().toISOString());
+    log(output.info(`Stop requested for "${name}" (pid ${rt.pid}) — the daemon picks it up within ~2s.`));
     return { success: true, message: `stop requested for ${name} (daemon exits within 2s)` };
 };
 const statusAction = async (ctx) => {
@@ -198,12 +224,26 @@ const statusAction = async (ctx) => {
         }
         // A "running" record whose pid is gone means the daemon died without its
         // stopOrg cleanup — surface that instead of reporting it as still running.
-        if (state.status === 'running' && state.pid) {
-            try {
-                process.kill(state.pid, 0);
-            }
-            catch {
-                log(output.warning(`${t}: crashed (runtime.json says running but pid ${state.pid} is gone)${state.run ? ` — run ${state.run}` : ''} — close it out with "monomind org mark-complete ${t}"`));
+        if ((state.status === 'running' || state.status === 'crashed') && state.pid) {
+            const pidGone = state.status === 'crashed' || (() => {
+                try {
+                    process.kill(state.pid, 0);
+                    return false;
+                }
+                catch {
+                    return true;
+                }
+            })();
+            if (pidGone) {
+                let heartbeatHint = '';
+                try {
+                    const hb = JSON.parse(readFileSync(join(ctx.cwd, '.monomind', 'serve-heartbeat.json'), 'utf8'));
+                    heartbeatHint = ` (last heartbeat: ${hb.updatedAt})`;
+                }
+                catch { /* no heartbeat file — daemon predates this change or was already cleaned up */ }
+                const closedBy = state.closedBy;
+                const label = closedBy === 'crash-handler' ? 'crashed (caught by crash handler)' : `crashed (runtime.json says ${state.status} but pid ${state.pid} is gone)`;
+                log(output.warning(`${t}: ${label}${heartbeatHint}${state.run ? ` — run ${state.run}` : ''} — close it out with "monomind org mark-complete ${t}"`));
                 continue;
             }
         }
@@ -211,6 +251,34 @@ const statusAction = async (ctx) => {
     }
     return { success: true };
 };
+/** 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 const pollStopfiles = async (cwd, daemon) => {
+    const stopped = [];
+    for (const name of daemon.listRunning()) {
+        if (!existsSync(join(cwd, ORG_DIR, name, 'stop')))
+            continue;
+        log(output.info(`org ${name}: stop requested — shutting it down`));
+        try {
+            await daemon.stopOrg(name);
+            stopped.push(name);
+        }
+        catch (err) {
+            console.error(`org ${name}: stop failed:`, err);
+        }
+        finally {
+            clearStopfile(cwd, name);
+        }
+    }
+    return stopped;
+};
 const serveAction = async (ctx) => {
     const crossProcess = ctx.flags['crossProcess'] !== false;
     const daemon = new OrgDaemon(ctx.cwd, { crossProcess });
@@ -219,6 +287,24 @@ const serveAction = async (ctx) => {
         srv = await startOrgServer(daemon, 0);
         daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
     }
+    // Crash handlers: log the reason and persist crashed state so `org status`
+    // shows what happened instead of a silent "pid is gone".
+    const crashExit = (label, err) => {
+        try {
+            console.error(`[org serve] ${label}:`, err);
+        }
+        catch { /* stderr gone */ }
+        daemon.persistCrashStateAll();
+        daemon.clearHeartbeat();
+        process.exitCode = 1;
+    };
+    process.on('uncaughtException', (err) => { crashExit('uncaughtException', err); process.exit(1); });
+    process.on('unhandledRejection', (err) => { crashExit('unhandledRejection', err); process.exit(1); });
+    // Heartbeat: write every 30s so `org status` can tell "alive but busy" from
+    // "daemon gone" without relying on pid liveness alone.
+    daemon.writeHeartbeat();
+    const heartbeatInterval = setInterval(() => { daemon.writeHeartbeat(); }, 30_000);
+    heartbeatInterval.unref?.();
     log(output.info('org daemon serving — Ctrl-C to stop'));
     // schedule orgs whose definition declares an interval (e.g. "15m", "2h")
     const { OrgScheduler, parseSchedule } = await import('../orgrt/scheduler.js');
@@ -270,9 +356,14 @@ const serveAction = async (ctx) => {
             }
         }
     }
+    const stopPoll = setInterval(() => { void pollStopfiles(ctx.cwd, daemon); }, 2000);
+    stopPoll.unref?.();
     await new Promise(r => { process.once('SIGINT', () => r()); process.once('SIGTERM', () => r()); });
+    clearInterval(stopPoll);
+    clearInterval(heartbeatInterval);
     sched.stop();
     await daemon.stopAll();
+    daemon.clearHeartbeat();
     srv?.close();
     return { success: true };
 };
@@ -393,6 +484,36 @@ const deleteAction = async (ctx) => {
     log(output.success(`Org "${orgName}" deleted (${removed} file(s) removed).`));
     return { success: true };
 };
+/** Clear a stale `running` record from runtime.json. This is the state `org status`
+ *  reads, so mark-complete MUST touch it — the dashboard's run:complete event alone
+ *  left `org status` reporting the same "crashed" line it had just told the user to
+ *  fix with this exact command. Refuses when the recorded pid is still alive: a live
+ *  daemon would just rewrite the file, and `org stop` is the right command there. */
+const clearStaleRuntime = (cwd, name) => {
+    const rtPath = join(cwd, ORG_DIR, name, 'runtime.json');
+    if (!existsSync(rtPath))
+        return { cleared: false, reason: 'absent' };
+    let rt;
+    try {
+        rt = JSON.parse(readFileSync(rtPath, 'utf8'));
+    }
+    catch (err) {
+        return { cleared: false, reason: 'unreadable', detail: err instanceof Error ? err.message : String(err) };
+    }
+    if (rt.status !== 'running' && rt.status !== 'crashed')
+        return { cleared: false, reason: 'not-running' };
+    if (rt.status === 'running' && rt.pid) {
+        try {
+            process.kill(rt.pid, 0);
+            return { cleared: false, reason: 'alive', detail: String(rt.pid) };
+        }
+        catch { /* pid is gone — this is exactly the stale case mark-complete exists for */ }
+    }
+    // Same shape stopOrg's persistState() writes, so every reader (org status,
+    // isOrgRunning, the mastermind-org* skills' jq checks) sees a stopped org.
+    writeFileSync(rtPath, JSON.stringify({ status: 'stopped', run: rt.run, pid: rt.pid, updated: new Date().toISOString(), closedBy: 'mark-complete' }, null, 2));
+    return { cleared: true, run: rt.run };
+};
 const markCompleteAction = async (ctx) => {
     const orgName = ctx.args[0];
     if (!orgName || !ORG_NAME_RE.test(orgName)) {
@@ -400,6 +521,30 @@ const markCompleteAction = async (ctx) => {
         return { success: false, message: 'valid org name required' };
     }
     const cwd = resolve(ctx.cwd || process.cwd());
+    // Reject an org that does not exist, using the same check as runAction. Without
+    // it `org mark-complete nosuchorg` printed "local state was cleared" and exited
+    // 0 — a typo looked like a successful cleanup.
+    const orgsDir = join(cwd, ORG_DIR);
+    if (!existsSync(join(orgsDir, `${orgName}.json`))) {
+        const known = existsSync(orgsDir) ? listOrgConfigFiles(orgsDir).map(f => f.replace(/\.json$/, '')) : [];
+        log(output.error(`Org not found: ${orgName}${known.length ? ` — available: ${known.join(', ')}` : ''}`));
+        return { success: false, message: 'org not found' };
+    }
+    // 1) Local runtime.json — the state `org status` actually reads. Done first and
+    //    independently of the dashboard so the recommended remedy works with no server.
+    const local = clearStaleRuntime(cwd, orgName);
+    if (!local.cleared && local.reason === 'alive') {
+        log(output.error(`Org "${orgName}" is still running (pid ${local.detail}) — stop it with "monomind org stop ${orgName}" instead.`));
+        return { success: false, message: 'org is running' };
+    }
+    if (local.cleared)
+        log(output.success(`Cleared stale runtime state for "${orgName}"${local.run ? ` (run ${local.run})` : ''}.`));
+    else if (local.reason === 'unreadable')
+        log(output.warning(`runtime.json for "${orgName}" is unreadable (${local.detail}) — left untouched.`));
+    else
+        log(output.info(`No stale runtime state for "${orgName}" (runtime.json ${local.reason === 'absent' ? 'absent' : 'already not running'}).`));
+    // 2) Dashboard run:complete event — best effort. A missing/unauthorized dashboard
+    //    must not make the command fail after the local state was already cleared.
     let ctrlUrl = 'http://localhost:4242';
     try {
         const ctl = JSON.parse(readFileSync(join(cwd, '.monomind', 'control.json'), 'utf8'));
@@ -420,17 +565,19 @@ const markCompleteAction = async (ctx) => {
         });
         const body = await res.json().catch(() => ({}));
         if (!res.ok) {
-            log(output.error(`mark-complete failed (${res.status}): ${body.error || 'unknown error'}`));
-            return { success: false, message: 'server rejected mark-complete' };
+            log(output.warning(`Dashboard not updated (${res.status}: ${body.error || 'unknown error'}) — ${local.cleared ? 'local state was cleared' : 'there was no local state to clear'}.`));
+        }
+        else {
+            const runId = body.runId;
+            log(output.success(`Dashboard run marked complete for "${orgName}"${runId ? ` (run ${runId})` : ''}.`));
         }
-        const runId = body.runId;
-        log(output.success(`Run marked complete for org "${orgName}"${runId ? ` (run ${runId})` : ''}.`));
-        return { success: true };
     }
     catch (err) {
-        log(output.error(`Dashboard server unreachable at ${ctrlUrl} — is it running? (${err instanceof Error ? err.message : 'error'})`));
-        return { success: false, message: 'server unreachable' };
+        log(output.warning(`Dashboard unreachable at ${ctrlUrl} (${err instanceof Error ? err.message : 'error'}) — ${local.cleared ? 'local state was cleared' : 'there was no local state to clear'}.`));
     }
+    return local.cleared
+        ? { success: true, message: `run marked complete for ${orgName}` }
+        : { success: true, message: `nothing to clear for ${orgName}` };
 };
 const migrateAction = async (ctx) => {
     const validated = validateOrgName(ctx.args[0]);

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

@@ -521,12 +521,24 @@ const bottleneckCommand = {
     ],
     examples: [
         { command: 'monomind performance bottleneck', description: 'Find bottlenecks' },
-        { command: 'monomind performance bottleneck -d full', description: 'Full analysis' },
+        { command: 'monomind performance bottleneck -c network', description: 'Only the Network component' },
     ],
     action: async (ctx) => {
         output.writeln();
         output.writeln(output.bold('Bottleneck Analysis'));
         output.writeln(output.dim('─'.repeat(50)));
+        // Components this command actually knows how to inspect. Used both to
+        // validate --component and to tell the user what they could have asked for.
+        const ANALYZED_COMPONENTS = ['Runtime', 'Vector Search', 'Traces', 'Memory DB', 'Network'];
+        // Only a single depth of analysis is implemented. Accepting `--depth full`
+        // and quietly running the quick analysis discards the user's request with
+        // no indication it was ignored, so say so instead.
+        const depthRaw = ctx.flags.depth || 'quick';
+        if (depthRaw !== 'quick') {
+            output.writeln(output.warning(`--depth ${depthRaw} is not implemented — running the "quick" analysis. ` +
+                `Only "quick" is supported today.`));
+        }
+        const componentFilter = ctx.flags.component?.trim();
         const spinner = output.createSpinner({ text: 'Analyzing system...', spinner: 'dots' });
         spinner.start();
         const fs = await import('node:fs');
@@ -575,10 +587,24 @@ const bottleneckCommand = {
         if (!network.batching) {
             findings.push({ component: 'Network', bottleneck: 'No request batching', severity: output.info('Low'), solution: 'Run: monomind performance optimize --apply -t latency' });
         }
-        if (findings.length === 0) {
-            findings.push({ component: 'System', bottleneck: 'No bottlenecks detected', severity: output.success('None'), solution: 'System is performing well' });
+        let results = findings;
+        if (componentFilter) {
+            const known = ANALYZED_COMPONENTS.find(c => c.toLowerCase() === componentFilter.toLowerCase())
+                ?? ANALYZED_COMPONENTS.find(c => c.toLowerCase().includes(componentFilter.toLowerCase()));
+            if (!known) {
+                spinner.fail(`Unknown component "${componentFilter}"`);
+                output.writeln(output.warning(`Analyzed components: ${ANALYZED_COMPONENTS.join(', ')}.`));
+                return { success: false, message: `Unknown component: ${componentFilter}`, exitCode: 1 };
+            }
+            results = findings.filter(f => f.component === known);
+            if (results.length === 0) {
+                results = [{ component: known, bottleneck: 'No bottlenecks detected', severity: output.success('None'), solution: `${known} is performing well` }];
+            }
+        }
+        else if (results.length === 0) {
+            results = [{ component: 'System', bottleneck: 'No bottlenecks detected', severity: output.success('None'), solution: 'System is performing well' }];
         }
-        spinner.succeed(`Analysis complete — ${findings.length} finding(s)`);
+        spinner.succeed(`Analysis complete — ${results.length} finding(s)`);
         output.writeln();
         output.printTable({
             columns: [
@@ -587,7 +613,7 @@ const bottleneckCommand = {
                 { key: 'severity', header: 'Severity', width: 12 },
                 { key: 'solution', header: 'Solution', width: 50 },
             ],
-            data: findings,
+            data: results,
         });
         return { success: true };
     },

package/packages/@monomind/cli/dist/src/commands/security-misc.js

@@ -11,10 +11,11 @@ export const auditCommand = {
     options: [
         { name: 'action', short: 'a', type: 'string', description: 'Action: list (only supported value — log/export/clear are not implemented)', default: 'list' },
         { name: 'limit', short: 'l', type: 'number', description: 'Number of entries to show', default: '20' },
-        { name: 'filter', short: 'f', type: 'string', description: 'Filter by event type' },
+        { name: 'filter', short: 'f', type: 'string', description: 'Filter by event type (substring, case-insensitive)' },
     ],
     examples: [
         { command: 'monomind security audit --action list', description: 'List audit logs' },
+        { command: 'monomind security audit --filter SWARM', description: 'Only swarm activity events' },
     ],
     action: async (ctx) => {
         const requestedAction = ctx.flags.action || 'list';
@@ -54,7 +55,21 @@ export const auditCommand = {
         const now = new Date().toISOString().replace('T', ' ').substring(0, 19);
         auditEntries.push({ timestamp: now, event: 'AUDIT_RUN', user: 'cli', status: output.success('Success') });
         auditEntries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-        if (auditEntries.length === 0) {
+        // --filter was previously parsed and discarded, so every invocation
+        // returned the full log regardless of what the user asked for.
+        const eventFilter = ctx.flags.filter?.trim();
+        let visibleEntries = auditEntries;
+        if (eventFilter) {
+            const needle = eventFilter.toLowerCase();
+            visibleEntries = auditEntries.filter(e => e.event.toLowerCase().includes(needle));
+            if (visibleEntries.length === 0) {
+                const seen = [...new Set(auditEntries.map(e => e.event))].sort();
+                output.writeln(output.warning(`No audit events match "${eventFilter}".`));
+                output.writeln(output.dim(`Event types present: ${seen.join(', ') || 'none'}`));
+                return { success: true, data: { entries: [], filter: eventFilter } };
+            }
+        }
+        if (visibleEntries.length === 0) {
             output.writeln(output.dim('No audit events found. Initialize a project first: monomind init'));
         }
         else {
@@ -65,7 +80,7 @@ export const auditCommand = {
                     { key: 'user', header: 'User', width: 15 },
                     { key: 'status', header: 'Status', width: 12 },
                 ],
-                data: auditEntries.slice(0, parseInt(ctx.flags.limit || '20', 10)),
+                data: visibleEntries.slice(0, parseInt(ctx.flags.limit || '20', 10)),
             });
         }
         return { success: true };

package/packages/@monomind/cli/dist/src/commands/security-scan.d.ts

@@ -12,7 +12,36 @@ export type SecretFinding = {
     location: string;
     description: string;
 };
-export declare function findSecretsInDir(dir: string, depthLimit: number, baseDir: string, findings: SecretFinding[]): void;
+/**
+ * Records what the scanner could NOT look at.
+ *
+ * Without this the scanner swallowed unreadable directories and stopped at its
+ * depth limit, then printed "No secrets found." — an error presented as a clean
+ * result. Callers must consult `scanWasIncomplete()` before reporting a clean
+ * bill of health.
+ */
+export interface ScanCoverage {
+    /** Directories that could not be listed (permissions, I/O). Real failures. */
+    unreadableDirs: string[];
+    /** Files that could not be read or stat'd. Real failures. */
+    unreadableFiles: string[];
+    /** Directories not descended into because the depth limit was reached. */
+    depthTruncatedDirs: string[];
+    /** Files skipped because they exceed the 1MB per-file cap. */
+    oversizedFiles: string[];
+    /** Files actually opened and pattern-matched. */
+    filesScanned: number;
+    /** Directories actually listed. */
+    dirsScanned: number;
+}
+export declare function createScanCoverage(): ScanCoverage;
+/** True when some part of the tree was not examined, for any reason. */
+export declare function scanWasIncomplete(c: ScanCoverage): boolean;
+/** True when the scanner hit a hard failure (not merely a configured limit). */
+export declare function scanHadErrors(c: ScanCoverage): boolean;
+/** Human-readable lines describing every gap in coverage. Empty when complete. */
+export declare function describeScanGaps(c: ScanCoverage): string[];
+export declare function findSecretsInDir(dir: string, depthLimit: number, baseDir: string, findings: SecretFinding[], coverage?: ScanCoverage): void;
 export declare const scanCommand: Command;
 export declare const secretsCommand: Command;
 //# sourceMappingURL=security-scan.d.ts.map