monomind 2.1.0 → 2.1.3

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.d.ts

@@ -69,8 +69,8 @@ export declare const CoherenceInputSchema: z.ZodObject<{
     vectors: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
     threshold: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    threshold: number;
     vectors: number[][];
+    threshold: number;
 }, {
     vectors: number[][];
     threshold?: number | undefined;
@@ -98,10 +98,10 @@ export declare const SpectralInputSchema: z.ZodObject<{
     analyzeType: z.ZodDefault<z.ZodEnum<["stability", "clustering", "connectivity"]>>;
 }, "strip", z.ZodTypeAny, {
     matrix: number[][];
-    analyzeType: "stability" | "clustering" | "connectivity";
+    analyzeType: "clustering" | "connectivity" | "stability";
 }, {
     matrix: number[][];
-    analyzeType?: "stability" | "clustering" | "connectivity" | undefined;
+    analyzeType?: "clustering" | "connectivity" | "stability" | undefined;
 }>;
 export type SpectralInput = z.infer<typeof SpectralInputSchema>;
 export interface SpectralResult {
@@ -150,15 +150,15 @@ export declare const CausalInputSchema: z.ZodObject<{
         nodes: string[];
         edges: [string, string][];
     };
-    outcome: string;
     intervention: string;
+    outcome: string;
 }, {
     graph: {
         nodes: string[];
         edges: [string, string][];
     };
-    outcome: string;
     intervention: string;
+    outcome: string;
 }>;
 export type CausalInput = z.infer<typeof CausalInputSchema>;
 export interface CausalResult {
@@ -185,13 +185,13 @@ export declare const AgentStateSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     agentId: string;
     embedding: number[];
-    metadata?: Record<string, unknown> | undefined;
     vote?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
 }, {
     agentId: string;
     embedding: number[];
-    metadata?: Record<string, unknown> | undefined;
     vote?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
 }>;
 export type AgentState = z.infer<typeof AgentStateSchema>;
 export declare const ConsensusInputSchema: z.ZodObject<{
@@ -203,29 +203,29 @@ export declare const ConsensusInputSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }, {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }>, "many">;
     threshold: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    threshold: number;
     agentStates: {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }[];
+    threshold: number;
 }, {
     agentStates: {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }[];
     threshold?: number | undefined;
 }>;
@@ -247,11 +247,11 @@ export declare const SimplexSchema: z.ZodObject<{
     vertices: z.ZodArray<z.ZodNumber, "many">;
     dimension: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    dimension: number;
     vertices: number[];
-}, {
     dimension: number;
+}, {
     vertices: number[];
+    dimension: number;
 }>;
 export type Simplex = z.infer<typeof SimplexSchema>;
 export declare const SimplicialComplexSchema: z.ZodObject<{
@@ -260,25 +260,25 @@ export declare const SimplicialComplexSchema: z.ZodObject<{
         vertices: z.ZodArray<z.ZodNumber, "many">;
         dimension: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        dimension: number;
         vertices: number[];
-    }, {
         dimension: number;
+    }, {
         vertices: number[];
+        dimension: number;
     }>, "many">>;
     maxDimension: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     vertices: number[][];
-    maxDimension: number;
     simplices?: {
-        dimension: number;
         vertices: number[];
+        dimension: number;
     }[] | undefined;
+    maxDimension: number;
 }, {
     vertices: number[][];
     simplices?: {
-        dimension: number;
         vertices: number[];
+        dimension: number;
     }[] | undefined;
     maxDimension?: number | undefined;
 }>;
@@ -290,43 +290,43 @@ export declare const TopologyInputSchema: z.ZodObject<{
             vertices: z.ZodArray<z.ZodNumber, "many">;
             dimension: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            dimension: number;
             vertices: number[];
-        }, {
             dimension: number;
+        }, {
             vertices: number[];
+            dimension: number;
         }>, "many">>;
         maxDimension: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         vertices: number[][];
-        maxDimension: number;
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
+        maxDimension: number;
     }, {
         vertices: number[][];
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
         maxDimension?: number | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     complex: {
         vertices: number[][];
-        maxDimension: number;
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
+        maxDimension: number;
     };
 }, {
     complex: {
         vertices: number[][];
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
         maxDimension?: number | undefined;
     };
@@ -362,27 +362,27 @@ export declare const MemoryGateInputSchema: z.ZodObject<{
         reject: z.ZodDefault<z.ZodNumber>;
         warn: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        warn: number;
         reject: number;
+        warn: number;
     }, {
-        warn?: number | undefined;
         reject?: number | undefined;
+        warn?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     key: string;
     value?: unknown;
     existingVectors?: number[][] | undefined;
     thresholds?: {
-        warn: number;
         reject: number;
+        warn: number;
     } | undefined;
 }, {
     key: string;
     value?: unknown;
     existingVectors?: number[][] | undefined;
     thresholds?: {
-        warn?: number | undefined;
         reject?: number | undefined;
+        warn?: number | undefined;
     } | undefined;
 }>;
 export type MemoryGateInput = z.infer<typeof MemoryGateInputSchema>;

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

@@ -406,7 +406,11 @@ export const hiveMindTools = [
                         id: w,
                         type: agent?.agentType || 'worker',
                         status: agent?.status || 'unknown',
-                        currentTask: agent?.currentTask || null,
+                        // AgentRecord has no currentTask field — always null. Kept in the
+                        // response shape for API stability; was already dead before this
+                        // (the previous `as unknown as Record<string, unknown>` cast hid
+                        // that `agent?.currentTask` never matched a real field).
+                        currentTask: null,
                         tasksCompleted: agent?.taskCount || 0,
                     };
                 }),

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

@@ -744,7 +744,10 @@ async function computeCommitsBehind(repoPath) {
     const dbPath = getDbPath(repoPath);
     if (!_isValidDb(dbPath))
         return null;
-    const db = openDb(dbPath, { fileMustExist: true });
+    // openDb's fileMustExist option isn't in the currently-published
+    // @monoes/monograph release this CLI depends on — _isValidDb above is the
+    // real guard against openDb silently creating an empty DB at a missing path.
+    const db = openDb(dbPath);
     try {
         const meta = db.prepare("SELECT value FROM index_meta WHERE key = 'last_commit_hash'").get() ?? db.prepare("SELECT value FROM index_meta WHERE key = 'lastCommit'").get();
         const lastCommit = meta?.value ?? null;
@@ -1761,9 +1764,15 @@ const monographInstallSkillsTool = {
         }
         // Load community data from graph
         const dbPath = getDbPath(repoPath);
+        // openDb's fileMustExist option isn't in the currently-published
+        // @monoes/monograph release this CLI depends on — check validity
+        // ourselves so a missing DB doesn't get silently auto-created empty.
+        if (!_isValidDb(dbPath)) {
+            return text('Graph not built yet. Run monograph_build first.');
+        }
         let db;
         try {
-            db = openDb(dbPath, { fileMustExist: true });
+            db = openDb(dbPath);
         }
         catch {
             return text('Graph not built yet. Run monograph_build first.');
@@ -1974,9 +1983,25 @@ const monographDeadCodeTool = {
         const cats = input.categories ?? ['dead-functions', 'orphan-files', 'stale-dist'];
         const result = {};
         const dbPath = getDbPath(repoPath);
+        // openDb's fileMustExist option isn't in the currently-published
+        // @monoes/monograph release this CLI depends on — check validity
+        // ourselves so a missing DB doesn't get silently auto-created empty.
+        if (!_isValidDb(dbPath)) {
+            return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));
+        }
         let db = null;
         try {
-            db = openDb(dbPath, { fileMustExist: true });
+            db = openDb(dbPath);
+            // _isValidDb's size check can't distinguish a real index from an
+            // empty-but-schema-migrated DB (better-sqlite3 auto-creates + migrates
+            // on open, and other unguarded openDb() call sites in this file can
+            // create exactly that as a side effect of an unrelated tool call before
+            // monograph_build ever runs). Verify actual content post-open so this
+            // reports "never built" instead of a misleading "0 dead functions found".
+            const { count } = db.prepare('SELECT COUNT(*) as count FROM nodes').get();
+            if (count === 0) {
+                return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));
+            }
         }
         catch {
             return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));

package/packages/@monomind/cli/dist/src/mcp-tools/quality/coverage-analysis/prioritize-gaps.d.ts

@@ -13,14 +13,14 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         startLine: z.ZodNumber;
         endLine: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        type: "function" | "line" | "branch";
         id: string;
+        type: "branch" | "function" | "line";
         file: string;
         startLine: number;
         endLine: number;
     }, {
-        type: "function" | "line" | "branch";
         id: string;
+        type: "branch" | "function" | "line";
         file: string;
         startLine: number;
         endLine: number;
@@ -52,9 +52,15 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;
     groupBy: z.ZodDefault<z.ZodEnum<["risk", "file", "type", "none"]>>;
 }, "strip", z.ZodTypeAny, {
-    limit: number;
-    factors: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[];
-    groupBy: "type" | "none" | "file" | "risk";
+    gaps?: {
+        id: string;
+        type: "branch" | "function" | "line";
+        file: string;
+        startLine: number;
+        endLine: number;
+    }[] | undefined;
+    targetPath?: string | undefined;
+    factors: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[];
     weights?: {
         complexity: number;
         changeFrequency: number;
@@ -63,16 +69,18 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         dependencyCount: number;
         testDifficulty: number;
     } | undefined;
+    limit: number;
+    groupBy: "file" | "none" | "risk" | "type";
+}, {
     gaps?: {
-        type: "function" | "line" | "branch";
         id: string;
+        type: "branch" | "function" | "line";
         file: string;
         startLine: number;
         endLine: number;
     }[] | undefined;
     targetPath?: string | undefined;
-}, {
-    limit?: number | undefined;
+    factors?: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[] | undefined;
     weights?: {
         complexity?: number | undefined;
         changeFrequency?: number | undefined;
@@ -81,16 +89,8 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         dependencyCount?: number | undefined;
         testDifficulty?: number | undefined;
     } | undefined;
-    gaps?: {
-        type: "function" | "line" | "branch";
-        id: string;
-        file: string;
-        startLine: number;
-        endLine: number;
-    }[] | undefined;
-    targetPath?: string | undefined;
-    factors?: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[] | undefined;
-    groupBy?: "type" | "none" | "file" | "risk" | undefined;
+    limit?: number | undefined;
+    groupBy?: "file" | "none" | "risk" | "type" | undefined;
 }>;
 export type PrioritizeGapsInput = z.infer<typeof PrioritizeGapsInputSchema>;
 export interface PrioritizeGapsOutput {
@@ -176,14 +176,14 @@ export declare const toolDefinition: {
             startLine: z.ZodNumber;
             endLine: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            type: "function" | "line" | "branch";
             id: string;
+            type: "branch" | "function" | "line";
             file: string;
             startLine: number;
             endLine: number;
         }, {
-            type: "function" | "line" | "branch";
             id: string;
+            type: "branch" | "function" | "line";
             file: string;
             startLine: number;
             endLine: number;
@@ -215,9 +215,15 @@ export declare const toolDefinition: {
         limit: z.ZodDefault<z.ZodNumber>;
         groupBy: z.ZodDefault<z.ZodEnum<["risk", "file", "type", "none"]>>;
     }, "strip", z.ZodTypeAny, {
-        limit: number;
-        factors: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[];
-        groupBy: "type" | "none" | "file" | "risk";
+        gaps?: {
+            id: string;
+            type: "branch" | "function" | "line";
+            file: string;
+            startLine: number;
+            endLine: number;
+        }[] | undefined;
+        targetPath?: string | undefined;
+        factors: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[];
         weights?: {
             complexity: number;
             changeFrequency: number;
@@ -226,16 +232,18 @@ export declare const toolDefinition: {
             dependencyCount: number;
             testDifficulty: number;
         } | undefined;
+        limit: number;
+        groupBy: "file" | "none" | "risk" | "type";
+    }, {
         gaps?: {
-            type: "function" | "line" | "branch";
             id: string;
+            type: "branch" | "function" | "line";
             file: string;
             startLine: number;
             endLine: number;
         }[] | undefined;
         targetPath?: string | undefined;
-    }, {
-        limit?: number | undefined;
+        factors?: ("business-critical" | "change-frequency" | "complexity" | "defect-history" | "dependency-count" | "test-difficulty")[] | undefined;
         weights?: {
             complexity?: number | undefined;
             changeFrequency?: number | undefined;
@@ -244,16 +252,8 @@ export declare const toolDefinition: {
             dependencyCount?: number | undefined;
             testDifficulty?: number | undefined;
         } | undefined;
-        gaps?: {
-            type: "function" | "line" | "branch";
-            id: string;
-            file: string;
-            startLine: number;
-            endLine: number;
-        }[] | undefined;
-        targetPath?: string | undefined;
-        factors?: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[] | undefined;
-        groupBy?: "type" | "none" | "file" | "risk" | undefined;
+        limit?: number | undefined;
+        groupBy?: "file" | "none" | "risk" | "type" | undefined;
     }>;
     handler: typeof handler;
 };

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.d.ts

@@ -15,16 +15,16 @@ export declare const DetectSecretsInputSchema: z.ZodObject<{
     scanHistory: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     targetPath: string;
+    secretTypes: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[];
     excludePatterns: string[];
-    secretTypes: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
     includeEntropy: boolean;
     entropyThreshold: number;
     verifySecrets: boolean;
     scanHistory: boolean;
 }, {
     targetPath: string;
+    secretTypes?: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[] | undefined;
     excludePatterns?: string[] | undefined;
-    secretTypes?: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
     includeEntropy?: boolean | undefined;
     entropyThreshold?: number | undefined;
     verifySecrets?: boolean | undefined;
@@ -116,16 +116,16 @@ export declare const toolDefinition: {
         scanHistory: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         targetPath: string;
+        secretTypes: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[];
         excludePatterns: string[];
-        secretTypes: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
         includeEntropy: boolean;
         entropyThreshold: number;
         verifySecrets: boolean;
         scanHistory: boolean;
     }, {
         targetPath: string;
+        secretTypes?: ("api-key" | "aws-key" | "aws-secret" | "azure-key" | "certificate" | "connection-string" | "gcp-key" | "generic" | "password" | "private-key" | "token")[] | undefined;
         excludePatterns?: string[] | undefined;
-        secretTypes?: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
         includeEntropy?: boolean | undefined;
         entropyThreshold?: number | undefined;
         verifySecrets?: boolean | undefined;

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

@@ -127,6 +127,12 @@ export declare class EWCConsolidator {
     private globalFisher;
     private consolidationHistory;
     private initialized;
+    /** Dirty flag: true when in-memory state diverges from disk */
+    private dirty;
+    /** Pending debounced write timer */
+    private saveTimer;
+    /** Debounce window for disk writes (ms) */
+    private static readonly SAVE_DEBOUNCE_MS;
     constructor(config?: Partial<EWCConfig>);
     /**
      * Initialize the consolidator by loading persisted state
@@ -237,6 +243,12 @@ export declare class EWCConsolidator {
      * Prune old, low-importance patterns to stay within limit
      */
     private pruneOldPatterns;
+    /**
+     * Schedule a debounced disk flush.
+     * Multiple calls within SAVE_DEBOUNCE_MS coalesce into one write,
+     * preventing blocking I/O on every consolidation or gradient event.
+     */
+    private scheduleSave;
     /**
      * Save state to disk
      */

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

@@ -94,6 +94,12 @@ export declare class SONAOptimizer {
     private failedRoutings;
     private lastUpdate;
     private persistencePath;
+    /** Set when in-memory state diverges from disk — triggers next debounced write */
+    private dirty;
+    /** NodeJS timeout handle for debounced disk flush */
+    private saveTimer;
+    /** Debounce window for disk writes (ms) — batches rapid trajectory bursts */
+    private static readonly SAVE_DEBOUNCE_MS;
     constructor(options?: {
         persistencePath?: string;
     });
@@ -182,6 +188,12 @@ export declare class SONAOptimizer {
      * Load patterns from disk
      */
     private loadFromDisk;
+    /**
+     * Schedule a debounced disk flush.
+     * Multiple calls within SAVE_DEBOUNCE_MS coalesce into a single write,
+     * preventing blocking I/O on every trajectory event during swarm bursts.
+     */
+    private scheduleSave;
     /**
      * Save patterns to disk
      */

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

@@ -4,7 +4,9 @@ export interface BrokerEntry {
     updatedAt: number;
 }
 export declare function defaultRegistryDir(): string;
-/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease. */
+/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease.
+ *  Writes via tmp+rename (same-directory rename is atomic on POSIX/NTFS) so a concurrent lookupOrg() never observes a
+ *  partially-written entry — this file is rewritten every heartbeat (default 20s) while other processes may read it. */
 export declare function registerOrg(name: string, url: string, dir?: string): void;
 /** Remove this process's registration for `name` (best effort). */
 export declare function unregisterOrg(name: string, dir?: string): void;

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

@@ -2,7 +2,7 @@
 // monolean: file-based local broker for cross-process org discovery (different
 // `monomind org` processes / project directories, same machine). Upgrade path:
 // a real network registry when cross-machine discovery is needed.
-import { mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'node:fs';
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 const SAFE_NAME = /^[a-z0-9][a-z0-9_-]*$/i;
@@ -15,11 +15,16 @@ function entryPath(name, dir) {
         throw new Error(`invalid org name for broker registry: ${name}`);
     return join(dir, `${name}.json`);
 }
-/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease. */
+/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease.
+ *  Writes via tmp+rename (same-directory rename is atomic on POSIX/NTFS) so a concurrent lookupOrg() never observes a
+ *  partially-written entry — this file is rewritten every heartbeat (default 20s) while other processes may read it. */
 export function registerOrg(name, url, dir = defaultRegistryDir()) {
     mkdirSync(dir, { recursive: true });
     const entry = { url, pid: process.pid, updatedAt: Date.now() };
-    writeFileSync(entryPath(name, dir), JSON.stringify(entry));
+    const dest = entryPath(name, dir);
+    const tmp = `${dest}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(entry));
+    renameSync(tmp, dest);
 }
 /** Remove this process's registration for `name` (best effort). */
 export function unregisterOrg(name, dir = defaultRegistryDir()) {

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

@@ -15,7 +15,11 @@ export declare class OrgBus {
     constructor(org: string, run: string, dir: string);
     subscribe(fn: Listener): () => void;
     emit(partial: Omit<BusEvent, 'id' | 'ts' | 'org' | 'run'>): BusEvent;
-    /** await all queued disk writes (tests, shutdown) */
+    /** Await all queued disk writes (tests, shutdown). Listeners registered via subscribe() run
+     *  synchronously inside emit() — flush() has no visibility into any async work they schedule
+     *  off of that (e.g. the forwarder's HTTP POSTs). A caller that needs an async subscriber's
+     *  work to have settled too must await that subscriber's own completion signal separately
+     *  (see daemon.ts stopOrg(), which awaits forwarder.settle() alongside bus.flush()). */
     flush(): Promise<void>;
     static readHistory(dir: string): BusEvent[];
 }

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

@@ -45,7 +45,11 @@ export class OrgBus {
         }
         return e;
     }
-    /** await all queued disk writes (tests, shutdown) */
+    /** Await all queued disk writes (tests, shutdown). Listeners registered via subscribe() run
+     *  synchronously inside emit() — flush() has no visibility into any async work they schedule
+     *  off of that (e.g. the forwarder's HTTP POSTs). A caller that needs an async subscriber's
+     *  work to have settled too must await that subscriber's own completion signal separately
+     *  (see daemon.ts stopOrg(), which awaits forwarder.settle() alongside bus.flush()). */
     flush() { return this.pending; }
     static readHistory(dir) {
         const f = join(dir, 'bus.jsonl');

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

@@ -33,11 +33,14 @@ export interface DaemonOpts {
     inboxUrl?: string;
     /** Override the broker's file registry directory (tests only). */
     brokerDir?: string;
+    /** Override how long stopOrg() waits for agent sessions before proceeding anyway (tests only; default 15000ms). */
+    stopWaitMs?: number;
 }
 export declare class OrgDaemon {
     private root;
     private opts;
     private orgs;
+    private waking;
     private globalSubscribers;
     private leases;
     private forwarders;
@@ -49,9 +52,18 @@ export declare class OrgDaemon {
     listOrgs(): RunningOrg[];
     getOrg(name: string): RunningOrg | undefined;
     startOrg(name: string, taskOverride?: string): Promise<RunningOrg>;
+    /**
+     * Resolves an org_send `to` address ("role" for same-org, "org:role" for
+     * cross-org) into its parts. Centralizes the one addressing rule that
+     * matters (an "own-org:role" self-prefix is intra-org, not cross-org) so
+     * deliver()/deliverRemote() don't each re-derive it — the qualified `to`
+     * string returned is always the canonical display form for that address.
+     */
+    private resolveAddress;
     /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
     deliver(fromOrg: string, fromRole: string, to: string, subject: string, body: string): Promise<string>;
-    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP. */
+    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP.
+     *  `to` here is always the fully-qualified "org:role" display form (resolveAddress already normalized it). */
     private deliverRemote;
     /** Inbound handler for cross-process delivery — called by the server's POST /api/xdeliver route
      *  when ANOTHER process's deliverRemote() reaches this daemon. Pushes straight into the target
@@ -63,6 +75,10 @@ export declare class OrgDaemon {
         ok: false;
         error: string;
     };
+    private hasOrgDef;
+    /** Start an offline org in the background so queued messages get drained.
+     *  Fire-and-forget — errors are logged but don't propagate to the sender. */
+    private autoWake;
     stopOrg(name: string): Promise<void>;
     stopAll(): Promise<void>;
     private persistState;