monomind 2.7.6 → 2.7.8

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

@@ -406,7 +406,15 @@ export async function bridgeSearchEntries(options) {
         const startTime = Date.now();
         let results = [];
         let searchMethod = 'keyword';
+        // Reported to callers so "(semantic)" can never be printed over keyword hits.
+        // 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;
             try {
                 const queryEmbedding = await _embedder(queryStr);
                 const searchResults = await backend.search(queryEmbedding, {
@@ -431,8 +439,14 @@ export async function bridgeSearchEntries(options) {
                     };
                 }).sort((a, b) => b.score - a.score);
                 searchMethod = 'semantic';
+                fallbackReason = undefined;
+            }
+            catch (e) {
+                // fall through to keyword search — but never claim this was semantic
+                fallbackReason = 'embedding-failed';
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] semantic search failed — falling back to keyword matching:', e);
             }
-            catch { /* fall through to keyword search */ }
         }
         // Keyword fallback — scan all entries in namespace (not just first 100)
         // to avoid missing documents that were ingested later in the batch.
@@ -463,14 +477,22 @@ export async function bridgeSearchEntries(options) {
                     id: e.id,
                     key: e.key,
                     content: e.content || '',
-                    score: Math.min(0.9, 0.3 + score * 0.6),
+                    // Raw token-overlap fraction, NOT rescaled to look like a cosine.
+                    // The old `min(0.9, 0.3 + score*0.6)` floor/ceiling made a weak
+                    // keyword hit outrank a genuine cosine match (0.90 vs 0.63 for the
+                    // same entry) and fed cosine-calibrated gates (memory-kg dedup)
+                    // scores that never came from a vector.
+                    score,
                     namespace: e.namespace,
                     provenance: `keyword:${score.toFixed(2)}`,
                     tags: e.tags ?? [],
                     _createdAt: e.createdAt || 0,
                 }));
             }
-            searchMethod = 'keyword';
+            // The vector path ran and simply matched nothing — still not semantic.
+            searchMethod = semanticAttempted ? 'keyword-fallback' : 'keyword';
+            if (semanticAttempted && !fallbackReason)
+                fallbackReason = 'no-semantic-matches';
         }
         // Filter stale entries based on automem config — skip for knowledge
         // namespaces (documents should remain searchable indefinitely)
@@ -494,6 +516,7 @@ export async function bridgeSearchEntries(options) {
             results,
             searchTime: Date.now() - startTime,
             searchMethod,
+            ...(searchMethod === 'semantic' ? {} : { fallbackReason }),
         };
     }
     catch {

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

@@ -25,6 +25,15 @@ export declare function searchEntries(options: {
         namespace: string;
     }[];
     searchTime: number;
+    /** What actually ran — propagated from the bridge so callers can report the
+     *  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) {
@@ -66,7 +71,9 @@ export async function searchEntries(options) {
             return {
                 success: true,
                 results: filtered,
-                searchTime: Date.now() - startTime
+                searchTime: Date.now() - startTime,
+                searchMethod: realVectors ? 'semantic' : 'hash-vector',
+                ...(realVectors ? {} : { fallbackReason: 'no-embedding-model' })
             };
         }
         // Fall back to brute-force SQLite search
@@ -127,7 +134,11 @@ export async function searchEntries(options) {
         return {
             success: true,
             results: results.slice(0, limit),
-            searchTime: Date.now() - startTime
+            searchTime: Date.now() - startTime,
+            // Per-row: cosine when the entry had a vector, keyword overlap otherwise.
+            // 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;

package/packages/@monomind/cli/dist/src/parser.js

@@ -166,26 +166,51 @@ export class CommandParser {
             positional: [],
             raw: [...args]
         };
-        // Pass 1: Identify command and subcommand (skip flags)
+        // Pass 1: Identify the command and its subcommand chain (skip flags).
+        //
+        // This walks the WHOLE tree, not just one subcommand level. It used to
+        // stop after depth 1 (`resolvedCmd` + `resolvedSub`), so options declared
+        // on a subcommand nested 2+ levels deep were invisible to the alias and
+        // boolean scans below: `hooks worker run -n audit` resolved `-n` from the
+        // global last-write-wins alias pool (where it happened to mean `--limit`)
+        // instead of `run`'s own `-n, --name`, and the command then failed with
+        // "Worker name is required" while `--name audit` worked.
+        const scopeChain = [];
         let resolvedCmd;
-        let resolvedSub;
         for (const arg of args) {
             if (arg.startsWith('-'))
                 continue;
-            if (!resolvedCmd && this.commands.has(arg)) {
-                resolvedCmd = this.commands.get(arg);
+            if (!resolvedCmd) {
+                const top = this.commands.get(arg);
+                if (top) {
+                    resolvedCmd = top;
+                    scopeChain.push(top);
+                }
+                continue;
             }
-            else if (resolvedCmd && !resolvedSub && resolvedCmd.subcommands) {
-                resolvedSub = resolvedCmd.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+            const next = resolvedCmd.subcommands?.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+            if (next) {
+                resolvedCmd = next;
+                scopeChain.push(next);
             }
         }
-        // Pass 2: Build aliases scoped to the resolved subcommand
-        // Subcommand-specific aliases take priority over global ones
-        const aliases = this.buildScopedAliases(resolvedSub || resolvedCmd);
-        const booleanFlags = this.getScopedBooleanFlags(resolvedSub || resolvedCmd);
-        const arrayFlags = this.getScopedArrayFlags(resolvedSub || resolvedCmd);
+        // Pass 2: Build aliases scoped to the resolved subcommand chain.
+        // Subcommand-specific aliases take priority over global ones, and the
+        // deepest subcommand wins over its ancestors. The top-level command is
+        // excluded when it has a resolved subcommand (preserving the previous
+        // `resolvedSub || resolvedCmd` precedence exactly for depth <= 1).
+        const scope = scopeChain.length > 1 ? scopeChain.slice(1) : scopeChain;
+        const aliases = this.buildScopedAliases(scope);
+        const booleanFlags = this.getScopedBooleanFlags(scope);
+        const arrayFlags = this.getScopedArrayFlags(scope);
         let i = 0;
         let parsingFlags = true;
+        // Once a non-flag token has been seen that is NOT a registered command,
+        // no later token may be promoted to "the command". Without this, an
+        // unrecognised first token was silently discarded and the SECOND token
+        // dispatched instead — `monomind typo status` ran `status`. A mistyped
+        // command must never run something the user did not ask for.
+        let commandSearchClosed = false;
         while (i < args.length) {
             const arg = args[i];
             // Check for end of flags marker
@@ -208,7 +233,7 @@ export class CommandParser {
                 continue;
             }
             // Handle positional arguments
-            if (result.command.length === 0 && this.commands.has(arg)) {
+            if (result.command.length === 0 && !commandSearchClosed && this.commands.has(arg)) {
                 // This is a command
                 result.command.push(arg);
                 // Check for subcommand (level 1)
@@ -245,7 +270,11 @@ export class CommandParser {
                 }
             }
             else {
-                // Positional argument
+                // Positional argument. If we haven't resolved a command yet, this
+                // token was the user's attempt at one — close the search so a later
+                // token can't be silently dispatched in its place.
+                if (result.command.length === 0)
+                    commandSearchClosed = true;
                 result.positional.push(arg);
                 result.flags._.push(arg);
             }
@@ -444,12 +473,13 @@ export class CommandParser {
      * The resolved command's short flags take priority over global ones,
      * fixing collisions where multiple subcommands use the same short flag (e.g. -t).
      */
-    buildScopedAliases(resolvedCmd) {
+    buildScopedAliases(scope) {
         // Start with global aliases as base
         const aliases = this.buildAliases();
-        // Override with the resolved command's own options (these take priority)
-        if (resolvedCmd?.options) {
-            for (const opt of resolvedCmd.options) {
+        // Override with the resolved chain's own options (these take priority);
+        // deepest subcommand last, so it wins over its ancestors.
+        for (const cmd of CommandParser.asChain(scope)) {
+            for (const opt of cmd.options ?? []) {
                 if (opt.short) {
                     aliases[opt.short] = opt.name;
                 }
@@ -457,13 +487,19 @@ export class CommandParser {
         }
         return aliases;
     }
+    /** Normalize a single command or a resolved chain into an array. */
+    static asChain(scope) {
+        if (!scope)
+            return [];
+        return Array.isArray(scope) ? scope : [scope];
+    }
     /**
-     * Get boolean flags scoped to a specific command/subcommand.
+     * Get boolean flags scoped to a specific command/subcommand chain.
      */
-    getScopedBooleanFlags(resolvedCmd) {
+    getScopedBooleanFlags(scope) {
         const flags = this.getBooleanFlags();
-        if (resolvedCmd?.options) {
-            for (const opt of resolvedCmd.options) {
+        for (const cmd of CommandParser.asChain(scope)) {
+            for (const opt of cmd.options ?? []) {
                 if (opt.type === 'boolean') {
                     flags.add(this.normalizeKey(opt.name));
                 }
@@ -472,12 +508,12 @@ export class CommandParser {
         return flags;
     }
     /**
-     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand.
+     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand chain.
      */
-    getScopedArrayFlags(resolvedCmd) {
+    getScopedArrayFlags(scope) {
         const flags = new Set();
-        if (resolvedCmd?.options) {
-            for (const opt of resolvedCmd.options) {
+        for (const cmd of CommandParser.asChain(scope)) {
+            for (const opt of cmd.options ?? []) {
                 if (opt.type === 'array') {
                     flags.add(this.normalizeKey(opt.name));
                 }

package/packages/@monomind/cli/dist/src/routing/route-layer-factory.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Pick the argv prefix used to spawn the embedding worker.
+ *
+ * dist/: `embed-worker.js` exists → `node embed-worker.js <task>`, byte-identical
+ * to the original behaviour, no extra flags, no extra resolution.
+ *
+ * src/ (tsx / vitest): only `embed-worker.ts` exists. Node's
+ * `--experimental-strip-types` cannot run it — the worker imports
+ * `./embedder.js`, and type-stripping does no `.js`→`.ts` extension rewriting,
+ * so it dies with ERR_MODULE_NOT_FOUND. tsx does rewrite, so the source path
+ * runs through tsx's CLI (a devDependency, never needed by dist/).
+ *
+ * Exported for tests.
+ */
+export declare function resolveWorkerArgv(): string[];
 type RouteResult = any;
 export interface ConfiguredRouteLayer {
     route: (taskDescription: string) => Promise<RouteResult>;