monomind 2.7.7 → 2.7.9

package/packages/@monomind/cli/dist/src/mcp-tools/knowledge-tools.js

@@ -82,36 +82,50 @@ const knowledgeSearch = {
             limit: { type: 'number', description: 'Max results (default: 10)' },
             minScore: { type: 'number', description: 'Minimum similarity threshold (default: 0.3)' },
             surfaces: { type: 'array', items: { type: 'string' }, description: "Override routing: any of 'chunks','kg','rules','memory'" },
+            includeSuperseded: { type: 'boolean', description: 'Also return chunks from older, re-ingested versions of a document (flagged superseded). Default false.' },
         },
         required: ['query'],
     },
     handler: async (input) => {
         const { searchKnowledge } = await import('../knowledge/document-pipeline.js');
-        const { routeQuery, rrfFuse } = await import('../memory/query-router.js');
+        const { routeQuery, rrfFuse, recordRouteOverride } = await import('../memory/query-router.js');
         try {
             const query = String(input.query);
             const limit = input.limit ? Number(input.limit) : 10;
             const route = routeQuery(query);
-            const surfaces = Array.isArray(input.surfaces) && input.surfaces.length
+            const explicitSurfaces = Array.isArray(input.surfaces) && input.surfaces.length
                 ? input.surfaces
-                : (route.confident ? route.surfaces : ['chunks', ...route.surfaces.filter(s => s !== 'chunks')]);
+                : null;
+            const surfaces = explicitSurfaces
+                ?? (route.confident ? route.surfaces : ['chunks', ...route.surfaces.filter(s => s !== 'chunks')]);
+            const chunkOpts = {
+                scope: input.scope ? String(input.scope) : undefined,
+                limit,
+                minScore: input.minScore ? Number(input.minScore) : undefined,
+                includeSuperseded: input.includeSuperseded === true,
+            };
             const bridge = await import('../memory/memory-bridge.js');
             const kg = await import('../memory/memory-kg.js');
             const [excerpts, graph, rules, memories] = await Promise.all([
-                surfaces.includes('chunks')
-                    ? searchKnowledge(query, {
-                        scope: input.scope ? String(input.scope) : undefined,
-                        limit,
-                        minScore: input.minScore ? Number(input.minScore) : undefined,
-                    })
-                    : [],
+                surfaces.includes('chunks') ? searchKnowledge(query, chunkOpts) : [],
                 surfaces.includes('kg') ? kg.kgSearch({ query, limit: 6 }) : null,
                 surfaces.includes('rules') ? bridge.bridgeSearchEntries({ query, namespace: 'rules', limit: 3, threshold: 0.35 }) : null,
                 surfaces.includes('memory') ? bridge.bridgeSearchEntries({ query, namespace: 'patterns', limit: 3 }) : null,
             ]);
+            // Confident non-chunk routing against an empty surface (e.g. a project
+            // with no KG yet) must not read as "no knowledge" — fall back to chunks.
+            // Same rule the CLI `doc search` path applies; without it agents got
+            // "no results" where the CLI returned document excerpts.
+            let fellBack = false;
+            let chunkExcerpts = excerpts;
+            if (!explicitSurfaces && !chunkExcerpts.length && !(graph?.triplets?.length) && !(rules?.results?.length) && !(memories?.results?.length) && !surfaces.includes('chunks')) {
+                fellBack = true;
+                recordRouteOverride(surfaces[0], 'chunks');
+                chunkExcerpts = await searchKnowledge(query, chunkOpts);
+            }
             // Rank-fuse heterogeneous lists (raw scores aren't comparable).
             const fused = rrfFuse([
-                excerpts.map(e => ({ id: e.id || `${e.filePath}#${e.chunkIndex}`, kind: 'excerpt', ...e })),
+                chunkExcerpts.map(e => ({ id: e.id || `${e.filePath}#${e.chunkIndex}`, kind: 'excerpt', ...e })),
                 (graph?.triplets ?? []).map((t, i) => ({ id: `kg:${i}:${t.source}|${t.relation}|${t.target}`, kind: 'triplet', ...t })),
                 (rules?.results ?? []).map(r => ({ id: r.id, kind: 'rule', key: r.key, text: r.content, importance: 0.7 })),
                 (memories?.results ?? []).map(r => ({ id: r.id, kind: 'memory', key: r.key, text: r.content })),
@@ -122,10 +136,10 @@ const knowledgeSearch = {
                         text: JSON.stringify({
                             success: true,
                             count: fused.length,
-                            routing: { surfaces, confident: route.confident },
+                            routing: { surfaces, confident: route.confident, fellBackToChunks: fellBack },
                             results: fused,
                             // Back-compat: excerpt-only view for existing consumers.
-                            excerpts,
+                            excerpts: chunkExcerpts,
                         }),
                     }],
             };

package/packages/@monomind/cli/dist/src/memory/memory-bridge.d.ts

@@ -67,7 +67,7 @@ export declare function bridgeSearchEntries(options: {
      *  vector path was attempted and did not produce the results. */
     searchMethod?: 'semantic' | 'keyword' | 'keyword-fallback';
     /** Why the vector path did not serve these results (absent when it did). */
-    fallbackReason?: 'no-embedding-model' | 'embedding-failed' | 'no-semantic-matches';
+    fallbackReason?: 'no-embedding-model' | 'empty-query' | 'embedding-failed' | 'no-semantic-matches';
     error?: string;
 } | null>;
 export declare function bridgeListEntries(options: {

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

@@ -407,7 +407,11 @@ export async function bridgeSearchEntries(options) {
         let results = [];
         let searchMethod = 'keyword';
         // Reported to callers so "(semantic)" can never be printed over keyword hits.
-        let fallbackReason = _embedder && queryStr.length > 0 ? undefined : 'no-embedding-model';
+        // The two reasons for skipping the vector path are distinct and must not be
+        // conflated: a healthy model given an empty query is not a missing model.
+        let fallbackReason = !_embedder ? 'no-embedding-model'
+            : queryStr.length === 0 ? 'empty-query'
+                : undefined;
         let semanticAttempted = false;
         if (_embedder && queryStr.length > 0) {
             semanticAttempted = true;

package/packages/@monomind/cli/dist/src/memory/memory-read.d.ts

@@ -26,8 +26,13 @@ export declare function searchEntries(options: {
     }[];
     searchTime: number;
     /** What actually ran — propagated from the bridge so callers can report the
-     *  real method instead of echoing the requested one. */
-    searchMethod?: 'semantic' | 'keyword' | 'keyword-fallback' | 'hybrid';
+     *  real method instead of echoing the requested one.
+     *
+     *  'hash-vector'/'hash-hybrid' are the sql.js paths running on
+     *  generateEmbedding()'s deterministic hash fallback: a vector search was
+     *  performed, but over hashes with no semantic content, so neither may be
+     *  reported as 'semantic'/'hybrid'. */
+    searchMethod?: 'semantic' | 'keyword' | 'keyword-fallback' | 'hybrid' | 'hash-vector' | 'hash-hybrid';
     fallbackReason?: string;
     error?: string;
 }>;

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

@@ -59,6 +59,11 @@ export async function searchEntries(options) {
         }
         const queryEmb = await generateEmbedding(query);
         const queryEmbedding = queryEmb.embedding;
+        // generateEmbedding() never fails — when no ONNX model can be loaded it
+        // silently returns generateHashEmbedding() output tagged 'hash-fallback'.
+        // Cosine over those hashes is a deterministic lexical trick with no
+        // semantic content, so the methods below must not claim otherwise.
+        const realVectors = queryEmb.model !== 'hash-fallback';
         // Try HNSW search first (150x faster)
         const hnswResults = await searchHNSWIndex(queryEmbedding, { k: limit, namespace: effectiveNamespace });
         if (hnswResults && hnswResults.length > 0) {
@@ -67,7 +72,8 @@ export async function searchEntries(options) {
                 success: true,
                 results: filtered,
                 searchTime: Date.now() - startTime,
-                searchMethod: 'semantic'
+                searchMethod: realVectors ? 'semantic' : 'hash-vector',
+                ...(realVectors ? {} : { fallbackReason: 'no-embedding-model' })
             };
         }
         // Fall back to brute-force SQLite search
@@ -130,7 +136,9 @@ export async function searchEntries(options) {
             results: results.slice(0, limit),
             searchTime: Date.now() - startTime,
             // Per-row: cosine when the entry had a vector, keyword overlap otherwise.
-            searchMethod: 'hybrid'
+            // With hash-fallback vectors the cosine half is not semantic either.
+            searchMethod: realVectors ? 'hybrid' : 'hash-hybrid',
+            ...(realVectors ? {} : { fallbackReason: 'no-embedding-model' })
         };
     }
     catch (error) {

package/packages/@monomind/cli/dist/src/monovector/diff-classifier.js

@@ -352,12 +352,15 @@ export function getGitDiffNumstat(ref = 'HEAD') {
     try {
         // SECURITY: Use execFileSync with args array instead of shell string
         // This prevents command injection via the ref parameter
+        // stdio must be fully piped: execFileSync otherwise forwards git's stderr
+        // straight to the parent's terminal AND leaves err.stderr null, so the
+        // thrown error below would carry no explanation of what git objected to.
         const numstatOutput = execFileSync('git', [
             'diff', '--numstat', '--diff-filter=ACDMRTUXB', ref
-        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'] });
         const statusOutput = execFileSync('git', [
             'diff', '--name-status', ref
-        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'] });
         const output = numstatOutput + '---STATUS---' + statusOutput;
         const [numstatPart, statusPart] = output.split('---STATUS---');
         // Parse status (usually smaller, parse first)
@@ -411,10 +414,25 @@ export function getGitDiffNumstat(ref = 'HEAD') {
         diffCache.set(cacheKey, { files, timestamp: Date.now() });
         return files;
     }
-    catch {
-        return [];
+    catch (e) {
+        // Do NOT return [] here. An empty array is indistinguishable from a genuinely
+        // clean diff, so a broken git invocation (not a repo, bad ref, git missing)
+        // used to surface as "low risk, 0 files changed". Callers (analyze_* MCP
+        // tools) already convert a throw into an explicit error response.
+        throw new Error(`git diff failed for ref "${ref}": ${describeGitError(e)}`);
     }
 }
+/**
+ * Extract a useful message from an execFile error, preferring git's own stderr.
+ */
+function describeGitError(e) {
+    const err = e;
+    const stderr = err && typeof err.stderr === 'string' ? err.stderr.trim() : '';
+    if (stderr)
+        return stderr.split('\n')[0].slice(0, 300);
+    const msg = err && typeof err.message === 'string' ? err.message : String(e);
+    return msg.slice(0, 300);
+}
 /**
  * Async version of getGitDiffNumstat for non-blocking operation
  */
@@ -480,8 +498,9 @@ export async function getGitDiffNumstatAsync(ref = 'HEAD') {
         diffCache.set(cacheKey, { files, timestamp: Date.now() });
         return files;
     }
-    catch {
-        return [];
+    catch (e) {
+        // See getGitDiffNumstat: a git failure must not look like a clean diff.
+        throw new Error(`git diff failed for ref "${ref}": ${describeGitError(e)}`);
     }
 }
 /**

package/packages/@monomind/cli/dist/src/orgrt/daemon.d.ts

@@ -53,6 +53,9 @@ export declare class OrgDaemon {
     subscribe(fn: (e: BusEvent) => void): () => void;
     listOrgs(): RunningOrg[];
     getOrg(name: string): RunningOrg | undefined;
+    /** Names of the orgs this daemon currently has running. Snapshot — safe to
+     *  iterate while stopOrg() mutates the underlying map. */
+    listRunning(): string[];
     startOrg(name: string, taskOverride?: string): Promise<RunningOrg>;
     /** A role that failed its resource gate at boot isn't abandoned — keep polling
      *  for capacity in the background (bounded) and spawn it the moment resources
@@ -96,7 +99,16 @@ export declare class OrgDaemon {
      *  running, pushes straight into the role's live mailbox (picked up on its very next
      *  generator tick — see Mailbox.stream()). If the org has since stopped, queues the
      *  answer via the same offline fallback deliver()/receiveRemote() already use
-     *  (inbox.ts + autoWake) and it's delivered when the org next starts. */
+     *  (inbox.ts + autoWake) and it's delivered when the org next starts.
+     *
+     *  PERSIST-AFTER-DELIVERY: questions.json is only marked answered once delivery has
+     *  actually happened (mailbox push, or the message landing in inbox.jsonl). Marking it
+     *  first meant a rejected delivery — unknown role, mailbox closed mid-shutdown, a
+     *  queueMessage that threw on a full/read-only disk — left the question recorded as
+     *  answered while nobody ever received the answer, and the `already answered` guard
+     *  then refused every retry. The answer was simply gone. The inverse failure (crash
+     *  between delivery and the write) merely re-shows the question as pending, which a
+     *  human can act on; a silently swallowed answer is not recoverable. */
     answerQuestion(org: string, role: string, questionId: string, answer: string): Promise<{
         ok: true;
     } | {
@@ -150,6 +162,14 @@ export declare class OrgDaemon {
      *  future runs) can find it by meaning, not just recency. Best-effort. */
     private storeRunMemory;
     private persistState;
+    /** Mark every currently-running org as crashed in runtime.json.
+     *  Called from process-level crash handlers — must be synchronous and best-effort. */
+    persistCrashStateAll(): void;
+    private heartbeatPath;
+    /** Write a heartbeat file so `org status` can distinguish "daemon alive" from
+     *  "daemon gone" even when runtime.json still says running. */
+    writeHeartbeat(): void;
+    clearHeartbeat(): void;
 }
 export {};
 //# sourceMappingURL=daemon.d.ts.map

package/packages/@monomind/cli/dist/src/orgrt/daemon.js

@@ -1,6 +1,6 @@
 // packages/@monomind/cli/src/orgrt/daemon.ts
 // monolean: single-process inter-org — upgrade path = daemon-to-daemon HTTP when multi-host is real
-import { readFileSync, mkdirSync, writeFileSync, existsSync, renameSync } from 'node:fs';
+import { readFileSync, mkdirSync, writeFileSync, existsSync, renameSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { reapOrphanedSdkProcesses } from '../utils/resource-governor.js';
 import { OrgBus } from './bus.js';
@@ -36,6 +36,9 @@ export class OrgDaemon {
     }
     listOrgs() { return [...this.orgs.values()]; }
     getOrg(name) { return this.orgs.get(name); }
+    /** Names of the orgs this daemon currently has running. Snapshot — safe to
+     *  iterate while stopOrg() mutates the underlying map. */
+    listRunning() { return [...this.orgs.keys()]; }
     async startOrg(name, taskOverride) {
         if (this.orgs.has(name))
             throw new Error(`org ${name} already running`);
@@ -500,7 +503,16 @@ export class OrgDaemon {
      *  running, pushes straight into the role's live mailbox (picked up on its very next
      *  generator tick — see Mailbox.stream()). If the org has since stopped, queues the
      *  answer via the same offline fallback deliver()/receiveRemote() already use
-     *  (inbox.ts + autoWake) and it's delivered when the org next starts. */
+     *  (inbox.ts + autoWake) and it's delivered when the org next starts.
+     *
+     *  PERSIST-AFTER-DELIVERY: questions.json is only marked answered once delivery has
+     *  actually happened (mailbox push, or the message landing in inbox.jsonl). Marking it
+     *  first meant a rejected delivery — unknown role, mailbox closed mid-shutdown, a
+     *  queueMessage that threw on a full/read-only disk — left the question recorded as
+     *  answered while nobody ever received the answer, and the `already answered` guard
+     *  then refused every retry. The answer was simply gone. The inverse failure (crash
+     *  between delivery and the write) merely re-shows the question as pending, which a
+     *  human can act on; a silently swallowed answer is not recoverable. */
     async answerQuestion(org, role, questionId, answer) {
         const data = this.readQuestions(org);
         const idx = data.questions.findIndex(q => q.questionId === questionId);
@@ -508,8 +520,19 @@ export class OrgDaemon {
             return { ok: false, error: `question "${questionId}" not found for org "${org}"` };
         if (data.questions[idx].answer !== null)
             return { ok: false, error: `question "${questionId}" already answered` };
-        data.questions[idx] = { ...data.questions[idx], answer, answeredAt: Date.now() };
-        this.writeQuestions(org, data);
+        const question = data.questions[idx].question;
+        // Applied to questions.json ONLY after the delivery below succeeds.
+        const markAnswered = () => {
+            // Re-read so a question the daemon appended (or answered) meanwhile isn't
+            // clobbered by this stale snapshot — merge by questionId, never replace.
+            const fresh = this.readQuestions(org);
+            const fIdx = fresh.questions.findIndex(q => q.questionId === questionId);
+            if (fIdx === -1)
+                fresh.questions.push({ ...data.questions[idx], answer, answeredAt: Date.now() });
+            else
+                fresh.questions[fIdx] = { ...fresh.questions[fIdx], answer, answeredAt: Date.now() };
+            this.writeQuestions(org, fresh);
+        };
         const running = this.orgs.get(org);
         if (running) {
             // Org IS running — deliver or report a real error, but never fall through to the
@@ -523,20 +546,32 @@ export class OrgDaemon {
                 return { ok: false, error: `role "${role}" not found in org "${org}"` };
             if (agent.mailbox.isClosed)
                 return { ok: false, error: `role "${role}" in org "${org}" is shutting down — answer not delivered` };
+            try {
+                agent.mailbox.push(`[answer from human] question: ${question}\n\nanswer: ${answer}`);
+            }
+            catch (err) {
+                return { ok: false, error: `delivery to "${role}" in org "${org}" failed — answer not recorded (${err instanceof Error ? err.message : String(err)})` };
+            }
+            markAnswered();
             running.bus.emit({ type: 'status', from: role, msg: 'question answered', data: { questionId } });
-            agent.mailbox.push(`[answer from human] question: ${data.questions[idx].question}\n\nanswer: ${answer}`);
             return { ok: true };
         }
         // Org not running at all — queue for delivery on next start, matching deliver()'s
         // existing offline fallback exactly (inbox.ts + autoWake).
         if (!this.hasOrgDef(org))
             return { ok: false, error: `org "${org}" not found (no saved definition)` };
-        queueMessage(this.root, org, {
-            fromQualified: 'human', toRole: role,
-            subject: `answer:${questionId}`,
-            body: `question: ${data.questions[idx].question}\n\nanswer: ${answer}`,
-            ts: Date.now(),
-        });
+        try {
+            queueMessage(this.root, org, {
+                fromQualified: 'human', toRole: role,
+                subject: `answer:${questionId}`,
+                body: `question: ${question}\n\nanswer: ${answer}`,
+                ts: Date.now(),
+            });
+        }
+        catch (err) {
+            return { ok: false, error: `could not queue answer for org "${org}" — answer not recorded (${err instanceof Error ? err.message : String(err)})` };
+        }
+        markAnswered();
         this.autoWake(org);
         return { ok: true };
     }
@@ -890,5 +925,41 @@ export class OrgDaemon {
         const p = join(this.root, ORG_DIR, name, 'runtime.json');
         writeFileSync(p, JSON.stringify({ status, run, pid: process.pid, updated: new Date().toISOString() }, null, 2));
     }
+    /** Mark every currently-running org as crashed in runtime.json.
+     *  Called from process-level crash handlers — must be synchronous and best-effort. */
+    persistCrashStateAll() {
+        for (const [name, org] of this.orgs) {
+            try {
+                const p = join(this.root, ORG_DIR, name, 'runtime.json');
+                writeFileSync(p, JSON.stringify({
+                    status: 'crashed', run: org.run, pid: process.pid,
+                    updated: new Date().toISOString(), closedBy: 'crash-handler',
+                }, null, 2));
+            }
+            catch { /* best effort — filesystem may be unavailable */ }
+        }
+    }
+    heartbeatPath() {
+        return join(this.root, '.monomind', 'serve-heartbeat.json');
+    }
+    /** Write a heartbeat file so `org status` can distinguish "daemon alive" from
+     *  "daemon gone" even when runtime.json still says running. */
+    writeHeartbeat() {
+        try {
+            const p = this.heartbeatPath();
+            mkdirSync(join(this.root, '.monomind'), { recursive: true });
+            writeFileSync(p, JSON.stringify({
+                pid: process.pid, updatedAt: new Date().toISOString(),
+                running: this.listRunning(),
+            }, null, 2));
+        }
+        catch { /* best effort */ }
+    }
+    clearHeartbeat() {
+        try {
+            unlinkSync(this.heartbeatPath());
+        }
+        catch { /* already gone or never written */ }
+    }
 }
 //# sourceMappingURL=daemon.js.map

package/packages/@monomind/cli/dist/src/orgrt/inbox.js

@@ -1,7 +1,7 @@
 // packages/@monomind/cli/src/orgrt/inbox.ts
 // Persistent message queue for offline orgs. Messages that can't be delivered
 // (target org not running) are spooled here and drained when the org starts.
-import { appendFileSync, readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'node:fs';
+import { appendFileSync, readFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { ORG_DIR } from './types.js';
 function inboxPath(root, orgName) {
@@ -12,37 +12,70 @@ export function queueMessage(root, orgName, msg) {
     mkdirSync(dir, { recursive: true });
     appendFileSync(inboxPath(root, orgName), JSON.stringify(msg) + '\n');
 }
+function parseLines(raw) {
+    const msgs = [];
+    for (const line of raw.trim().split('\n')) {
+        if (!line)
+            continue;
+        try {
+            msgs.push(JSON.parse(line));
+        }
+        catch { /* skip corrupt lines */ }
+    }
+    return msgs;
+}
 export function drainInbox(root, orgName) {
     const path = inboxPath(root, orgName);
+    const draining = `${path}.draining`;
+    const msgs = [];
+    // Recover a .draining file left behind by a mid-drain crash. Without this the
+    // rename below would overwrite it and lose exactly the messages the rename-then-read
+    // scheme exists to protect.
+    if (existsSync(draining)) {
+        try {
+            msgs.push(...parseLines(readFileSync(draining, 'utf8')));
+            unlinkSync(draining);
+        }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[inbox] drainInbox recovery of .draining failed:', e);
+            return msgs; // don't rename over a file we couldn't consume
+        }
+    }
     if (!existsSync(path))
-        return [];
+        return msgs;
     // Rename-then-read: if the process crashes after rename but before we finish
-    // reading, the .draining file survives for manual recovery. A plain
-    // read-then-truncate would lose messages on a mid-drain crash.
-    const draining = `${path}.draining`;
+    // reading, the .draining file survives (and is recovered above on the next
+    // drain). A plain read-then-truncate would lose messages on a mid-drain crash.
     try {
         renameSync(path, draining);
     }
     catch (e) {
         if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
             console.error('[inbox] drainInbox rename failed:', e);
-        return [];
+        return msgs;
     }
-    const raw = readFileSync(draining, 'utf8').trim();
-    if (!raw) {
-        writeFileSync(draining, '');
-        renameSync(draining, path);
-        return [];
+    let raw = '';
+    try {
+        raw = readFileSync(draining, 'utf8');
     }
-    // Clear the draining file — messages are now the caller's responsibility
-    writeFileSync(draining, '');
-    renameSync(draining, path);
-    const msgs = [];
-    for (const line of raw.split('\n')) {
-        try {
-            msgs.push(JSON.parse(line));
-        }
-        catch { /* skip corrupt lines */ }
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[inbox] drainInbox read failed:', e);
+        return msgs;
+    }
+    msgs.push(...parseLines(raw));
+    // Unlink the drained snapshot rather than truncating it and renaming it back over
+    // `path`. A sender that appended between the rename above and this point created a
+    // fresh `path` (queueMessage mkdir+appends), and renaming the emptied snapshot back
+    // would clobber it — destroying messages whose sender already got a "queued" receipt.
+    // Those messages now simply stay in `path` and are picked up by the next drain.
+    try {
+        unlinkSync(draining);
+    }
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[inbox] drainInbox unlink failed:', e);
     }
     return msgs;
 }

package/packages/@monomind/cli/dist/src/parser.d.ts

@@ -74,12 +74,14 @@ export declare class CommandParser {
      * fixing collisions where multiple subcommands use the same short flag (e.g. -t).
      */
     private buildScopedAliases;
+    /** Normalize a single command or a resolved chain into an array. */
+    private static asChain;
     /**
-     * Get boolean flags scoped to a specific command/subcommand.
+     * Get boolean flags scoped to a specific command/subcommand chain.
      */
     private getScopedBooleanFlags;
     /**
-     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand.
+     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand chain.
      */
     private getScopedArrayFlags;
     private getBooleanFlags;