monomind 2.1.0 → 2.1.4

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,28 @@ export declare class OrgDaemon {
         ok: false;
         error: string;
     };
+    private hasOrgDef;
+    private questionsPath;
+    private readQuestions;
+    private writeQuestions;
+    /** Agent-initiated human question (ask_human tool). Persists to questions.json (survives
+     *  process/dashboard restarts) and emits a 'question' BusEvent so the dashboard's SSE
+     *  stream and global inbox pick it up in real time. Returns a receipt string for the tool call. */
+    askHuman(org: string, role: string, question: string): Promise<string>;
+    /** Delivers a human's answer to a pending ask_human question. If the org is still
+     *  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. */
+    answerQuestion(org: string, role: string, questionId: string, answer: string): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /** 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;