monomind 2.5.0 → 2.5.2

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

@@ -19,6 +19,8 @@ export class OrgDaemon {
     globalSubscribers = new Set();
     leases = new Map();
     forwarders = new Map();
+    watchdogs = new Map();
+    stopping = new Map();
     constructor(root, opts = {}) {
         this.root = root;
         this.opts = opts;
@@ -51,10 +53,26 @@ export class OrgDaemon {
         // Write's captured content snapshot alone can be up to 200KB (policy.ts).
         const MAX_COLLECTED = 5000;
         const collected = [];
+        let lastActivity = Date.now();
         bus.subscribe(e => {
             collected.push(e);
             if (collected.length > MAX_COLLECTED)
                 collected.splice(0, collected.length - MAX_COLLECTED);
+            // The watchdog's own nudge event must not count as org activity, or a
+            // hung boss would never trip the "nudge produced no activity" stop.
+            if (e.reason !== 'idle-nudge')
+                lastActivity = Date.now();
+            // org_complete IS the end of the run — self-stop instead of sitting
+            // "running" forever after a recorded outcome. Deferred (unref'd) so the
+            // tool call's receipt reaches the boss and its final turn text still
+            // lands on the bus before mailboxes close; stopOrg is reentrant-safe
+            // against a concurrent manual stop.
+            if (e.type === 'status' && e.reason === 'org-complete') {
+                const t = setTimeout(() => {
+                    this.stopOrg(name).catch(err => console.error(`org ${name}: auto-stop after org_complete failed:`, err instanceof Error ? err.message : err));
+                }, 1000);
+                t.unref?.();
+            }
             for (const fn of this.globalSubscribers)
                 fn(e);
         });
@@ -69,6 +87,19 @@ export class OrgDaemon {
         // fallback-selected boss could be told to call org_complete without having
         // the tool.
         const bossRole = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
+        // Canonical entity names from the org KG — injected into the coordinator
+        // prompt so org_learn extractions reuse them instead of minting duplicates.
+        const glossary = await (async () => {
+            try {
+                if (!(await this.orgMemoryUsable()))
+                    return [];
+                const kg = await import('../memory/memory-kg.js');
+                return await kg.kgGlossary({ dbPath: this.orgMemoryDbPath() });
+            }
+            catch {
+                return [];
+            }
+        })();
         for (const role of def.roles) {
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
@@ -84,7 +115,7 @@ export class OrgDaemon {
                     }
                     : undefined,
                 recall: async (r, q) => {
-                    const answer = await this.recallOrgMemory(name, def, q);
+                    const answer = await this.recallOrgMemory(name, def, q, r);
                     bus.emit({ type: 'status', from: r, reason: 'org-recall', msg: `recall: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
                     return answer.text;
                 },
@@ -93,6 +124,20 @@ export class OrgDaemon {
                     bus.emit({ type: 'status', from: r, reason: 'knowledge-search', msg: `knowledge: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
                     return answer.text;
                 },
+                glossary,
+                remember: async (r, content, scope) => {
+                    const text = await this.rememberOrgMemory(name, def, r, content, scope, run);
+                    bus.emit({ type: 'status', from: r, reason: 'org-remember', msg: `remember (${scope}): ${content.slice(0, 80)}`, data: { scope } });
+                    return text;
+                },
+                learn: async (r, payload) => {
+                    const text = await this.learnOrgKnowledge(name, run, payload);
+                    bus.emit({
+                        type: 'status', from: r, reason: 'org-learn', msg: `learn: ${text.slice(0, 120)}`,
+                        data: { nodes: payload.nodes?.length ?? 0, edges: payload.edges?.length ?? 0, rules: payload.rules?.length ?? 0 },
+                    });
+                    return text;
+                },
                 queryFn: this.opts.queryFn,
             };
             // Supervised session: transient crashes (provider blips, network) restart
@@ -163,6 +208,50 @@ export class OrgDaemon {
             `Coordinate your team via org_send. When the goal is achieved (or clearly can't be), record it with org_complete, then end your turn.${prevBrief}`);
         bus.emit({ type: 'status', msg: `org started (${def.roles.length} agents)`, data: { goal: taskOverride ?? def.goal } });
         this.persistState(name, 'running', run);
+        // Idle watchdog: a hung tool call (or a run that quietly finished without
+        // org_complete) produces no bus events, and every agent just waits. After
+        // idle_minutes of silence, nudge the boss to complete or reassign; if the
+        // nudge itself produces no activity (boss hung/crashed), or the org keeps
+        // going idle after MAX_IDLE_NUDGES nudges, stop the run instead of letting
+        // it freeze forever. idle_minutes: 0 disables.
+        const idleMs = (def.run_config.idle_minutes ?? 10) * 60_000;
+        if (idleMs > 0) {
+            const MAX_IDLE_NUDGES = 3;
+            let nudgedAt = 0;
+            let nudges = 0;
+            const idleStop = (msg) => {
+                bus.emit({ type: 'audit', reason: 'idle-stop', msg });
+                this.stopOrg(name).catch(err => console.error(`org ${name}: idle-stop failed:`, err instanceof Error ? err.message : err));
+            };
+            const wd = setInterval(() => {
+                const idleFor = Date.now() - lastActivity;
+                if (idleFor < idleMs) {
+                    nudgedAt = 0;
+                    return;
+                }
+                if (nudgedAt === 0) {
+                    if (nudges >= MAX_IDLE_NUDGES) {
+                        idleStop(`org idle again after ${nudges} nudges — stopping run`);
+                        return;
+                    }
+                    const bossRt = running.agents.get(bossRole.id);
+                    if (!bossRt || bossRt.status !== 'running' || bossRt.mailbox.isClosed) {
+                        idleStop(`org idle for ${Math.round(idleFor / 60_000)}m and boss "${bossRole.id}" is unreachable — stopping run`);
+                        return;
+                    }
+                    nudges++;
+                    nudgedAt = Date.now();
+                    bus.emit({ type: 'audit', from: bossRole.id, reason: 'idle-nudge', msg: `no org activity for ${Math.round(idleFor / 60_000)}m — nudging boss (${nudges}/${MAX_IDLE_NUDGES})` });
+                    bossRt.mailbox.push(`[watchdog] No activity in org "${name}" for ${Math.round(idleFor / 60_000)} minute(s). ` +
+                        `If the goal is achieved (or clearly can't be), call org_complete now. Otherwise check on your team via org_send and reassign stalled work.`);
+                }
+                else if (Date.now() - nudgedAt >= idleMs) {
+                    idleStop(`nudge produced no activity for another ${Math.round(idleMs / 60_000)}m — boss appears hung, stopping run`);
+                }
+            }, Math.max(200, Math.min(idleMs / 2, 30_000)));
+            wd.unref?.();
+            this.watchdogs.set(name, wd);
+        }
         if (this.opts.crossProcess && this.opts.inboxUrl) {
             const lease = new BrokerLease(name, this.opts.inboxUrl, this.opts.brokerDir);
             lease.start();
@@ -383,19 +472,42 @@ export class OrgDaemon {
             .finally(() => { this.waking.delete(name); });
     }
     async stopOrg(name) {
+        // Join an in-flight stop instead of no-oping: the self-stop paths
+        // (org_complete, idle watchdog) run detached, and a caller like
+        // `org run`'s final stopAll() must not resolve — letting the process
+        // exit — while that stop is still flushing the bus and writing
+        // history/runtime.json.
+        const inflight = this.stopping.get(name);
+        if (inflight)
+            return inflight;
         const org = this.orgs.get(name);
         if (!org)
-            return; // already stopped, or another concurrent stopOrg() call is handling it
+            return; // already stopped
         // Remove immediately (not at the end) so a concurrent stopOrg(name) call —
-        // e.g. stopAll() racing a scheduler-triggered stop on SIGINT — sees the org
-        // is already gone and no-ops instead of re-running the whole shutdown and
+        // e.g. stopAll() racing a scheduler-triggered stop on SIGINT — joins this
+        // shutdown via `stopping` instead of re-running the whole sequence and
         // double-emitting 'org stopped' (duplicate org:complete/session:complete).
         this.orgs.delete(name);
+        const p = this.finishStop(name, org);
+        this.stopping.set(name, p);
+        try {
+            await p;
+        }
+        finally {
+            this.stopping.delete(name);
+        }
+    }
+    async finishStop(name, org) {
         // Capture THIS run's forwarder now: an autoWake-restart of the same org
         // during the long tail below (agent wait, flush, history write) would
         // register a NEW forwarder under the same name — settling/unsubscribing
         // that one would sever the new run's dashboard stream.
         const forwarder = this.forwarders.get(name);
+        const wd = this.watchdogs.get(name);
+        if (wd) {
+            clearInterval(wd);
+            this.watchdogs.delete(name);
+        }
         this.leases.get(name)?.stop();
         this.leases.delete(name);
         for (const a of org.agents.values())
@@ -453,7 +565,10 @@ export class OrgDaemon {
             this.persistState(name, 'stopped', org.run);
     }
     async stopAll() {
-        await Promise.all([...this.orgs.keys()].map(n => this.stopOrg(n)));
+        await Promise.all([
+            ...[...this.orgs.keys()].map(n => this.stopOrg(n)),
+            ...this.stopping.values(), // detached self-stops still flushing
+        ]);
     }
     orgMemoryNamespace(name, def) {
         return def.run_config.memory_namespace ?? `org:${name}`;
@@ -486,21 +601,82 @@ export class OrgDaemon {
             return false;
         }
     }
+    /** Namespace for a role's PRIVATE memories, inside the org memory DB. */
+    agentMemoryNamespace(name, def, role) {
+        return `agent:${this.orgMemoryNamespace(name, def)}:${role}`;
+    }
+    /** org_remember implementation: a deliberate write to org-shared or
+     *  role-private memory (both in the org memory DB, split by namespace). */
+    async rememberOrgMemory(name, def, role, content, scope, run) {
+        try {
+            if (!(await this.orgMemoryUsable()))
+                return 'org memory is not available in this environment.';
+            const { bridgeStoreEntry } = await import('../memory/memory-bridge.js');
+            const namespace = scope === 'agent' ? this.agentMemoryNamespace(name, def, role) : this.orgMemoryNamespace(name, def);
+            const res = await bridgeStoreEntry({
+                key: `mem-${run}-${Date.now().toString(36)}`,
+                value: content.slice(0, 20_000),
+                namespace,
+                dbPath: this.orgMemoryDbPath(),
+                tags: [scope, role],
+                metadata: { origin_refs: [`run:${run}`], by: role },
+            });
+            if (res?.duplicate)
+                return `Already remembered (near-duplicate exists) — reinforced instead.`;
+            return res?.success ? `Remembered (${scope} scope).` : `Could not store memory${res?.error ? `: ${res.error}` : ''}.`;
+        }
+        catch (err) {
+            return `org_remember failed (${err instanceof Error ? err.message : 'error'})`;
+        }
+    }
+    /** Entry IDs served by org_recall during the current run, per org. This is
+     *  the usage record the run-outcome auto-rating consumes (cognee's
+     *  used_graph_element_ids pattern) — recall renders text to the agent, so
+     *  the IDs must be captured here or they're gone. */
+    recallUsage = new Map();
     /** org_recall implementation: search the org's memory namespace via the
      *  memory bridge (semantic when the local model is available, tokenized
      *  keyword otherwise). Failures return a message, never throw into the tool. */
-    async recallOrgMemory(name, def, query) {
+    async recallOrgMemory(name, def, query, role) {
         try {
             if (!(await this.orgMemoryUsable()))
                 return { text: 'org memory is not available in this environment.', hits: 0 };
-            const { bridgeSearchEntries } = await import('../memory/memory-bridge.js');
-            const res = await bridgeSearchEntries({
-                query, namespace: this.orgMemoryNamespace(name, def), limit: 5, dbPath: this.orgMemoryDbPath(),
-            });
-            const results = res?.results ?? [];
+            const bridge = await import('../memory/memory-bridge.js');
+            // Shared org memory plus the caller's private agent scope, merged by score.
+            const [shared, priv] = await Promise.all([
+                bridge.bridgeSearchEntries({
+                    query, namespace: this.orgMemoryNamespace(name, def), limit: 5, dbPath: this.orgMemoryDbPath(),
+                }),
+                role ? bridge.bridgeSearchEntries({
+                    query, namespace: this.agentMemoryNamespace(name, def, role), limit: 3, dbPath: this.orgMemoryDbPath(),
+                }) : null,
+            ]);
+            const results = [
+                ...(shared?.results ?? []),
+                ...(priv?.results ?? []).map(r => ({ ...r, key: `${r.key} (private)` })),
+            ].sort((a, b) => b.score - a.score).slice(0, 6);
             if (!results.length)
                 return { text: 'No matching org memory found — this may be the first run covering this topic.', hits: 0 };
-            const text = results.map((r, i) => `${i + 1}. [${r.key}] ${r.content}`).join('\n\n');
+            const ids = results.map(r => r.id).filter(Boolean);
+            let used = this.recallUsage.get(name);
+            if (!used) {
+                used = new Set();
+                this.recallUsage.set(name, used);
+            }
+            for (const id of ids)
+                used.add(id);
+            // Frequency reinforcement is immediate; the feedback rating waits for the
+            // run outcome (positive-only — see storeRunMemory).
+            bridge.bridgeRecordUsage({ entryIds: ids, dbPath: this.orgMemoryDbPath() }).catch(() => { });
+            let text = results.map((r, i) => `${i + 1}. [${r.key}] ${r.content}`).join('\n\n');
+            // Structured knowledge: relationship triplets from the org KG, when any.
+            try {
+                const kg = await import('../memory/memory-kg.js');
+                const graph = await kg.kgSearch({ query, dbPath: this.orgMemoryDbPath(), limit: 5 });
+                if (graph.context)
+                    text += `\n\nKnowledge graph:\n${graph.context}`;
+            }
+            catch { /* best effort */ }
             return { text, hits: results.length };
         }
         catch (err) {
@@ -524,6 +700,38 @@ export class OrgDaemon {
             return { text: `knowledge search unavailable (${err instanceof Error ? err.message : 'error'})`, hits: 0 };
         }
     }
+    /** org_learn implementation: merge coordinator-extracted entities/relations/
+     *  rules into the org's knowledge graph (LLM extraction happens inside the
+     *  agent's own subscription-auth SDK session — no separate LLM call here). */
+    orgLearnedRuns = new Set();
+    async learnOrgKnowledge(name, run, payload) {
+        try {
+            if (!(await this.orgMemoryUsable()))
+                return 'org memory is not available in this environment.';
+            const kg = await import('../memory/memory-kg.js');
+            const dbPath = this.orgMemoryDbPath();
+            const originRef = `run:${run}`;
+            const graph = await kg.kgIngest({
+                nodes: (payload.nodes ?? []),
+                edges: (payload.edges ?? []),
+                originRef, dbPath,
+            });
+            const rules = Array.isArray(payload.rules) && payload.rules.length
+                ? await kg.kgIngestRules({ rules: payload.rules, originRef, dbPath })
+                : null;
+            this.orgLearnedRuns.add(`${name}:${run}`);
+            const parts = [
+                `entities: +${graph.nodesAdded} new, ${graph.nodesMerged} merged`,
+                `relations: +${graph.edgesAdded} new, ${graph.edgesMerged} merged`,
+            ];
+            if (rules)
+                parts.push(`rules: ${rules.accepted} accepted, ${rules.verdicts.filter(v => v.verdict === 'already_known').length} already known`);
+            return `Recorded in org knowledge graph — ${parts.join('; ')}. Rollback ref: ${originRef}.`;
+        }
+        catch (err) {
+            return `org_learn failed (${err instanceof Error ? err.message : 'error'})`;
+        }
+    }
     /** Persist the run's outcome into cross-run org memory so org_recall (and
      *  future runs) can find it by meaning, not just recency. Best-effort. */
     async storeRunMemory(name, def, run, summary) {
@@ -547,6 +755,35 @@ export class OrgDaemon {
                 dbPath: this.orgMemoryDbPath(),
                 upsert: true,
             });
+            // Heuristic KG fallback: if the coordinator never called org_learn this
+            // run, extract lower-trust entities from the outcome summary so the
+            // graph still accumulates something. LLM-quality extraction only comes
+            // from org_learn (the agent's own session).
+            if (!this.orgLearnedRuns.delete(`${name}:${run}`)) {
+                try {
+                    const kg = await import('../memory/memory-kg.js');
+                    const extracted = kg.heuristicExtract(lines.join('\n'), { sourceName: `run:${run}` });
+                    if (extracted.nodes.length) {
+                        await kg.kgIngest({ ...extracted, originRef: `run:${run}`, dbPath: this.orgMemoryDbPath() });
+                    }
+                }
+                catch { /* best effort */ }
+            }
+            // Auto-rate the memories this run recalled — POSITIVE-ONLY: a failed run
+            // proves nothing about the recalled memories (the failure may be entirely
+            // unrelated), so failure never rates them down. Idempotent per run via
+            // the feedback ledger, so a retried stopOrg can't double-apply.
+            const used = this.recallUsage.get(name);
+            this.recallUsage.delete(name);
+            if (used?.size && summary.outcome?.status === 'achieved') {
+                const { bridgeApplyFeedback } = await import('../memory/memory-bridge.js');
+                await bridgeApplyFeedback({
+                    entryIds: [...used],
+                    score: 0.9,
+                    ledgerKey: `org-${name}-${run}`,
+                    dbPath: this.orgMemoryDbPath(),
+                }).catch(() => { });
+            }
         }
         catch (err) {
             if (process.env.DEBUG || process.env.MONOMIND_DEBUG)

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

@@ -59,6 +59,13 @@ export function migrateOrgConfig(raw) {
         const roleKeysDropped = new Set();
         def['roles'] = def['roles'].map(role => {
             const r = { ...role };
+            // Legacy serialization artifact: some v1 writers stringified a missing
+            // manager as the literal "undefined". Treat it as unset (schema
+            // defaults to null); structural validation still enforces one root.
+            if (r['reports_to'] === 'undefined') {
+                delete r['reports_to'];
+                notes.push(`role ${String(r['id'])}: reports_to "undefined" → unset`);
+            }
             if (typeof r['agent_type'] === 'string') {
                 if (r['type'] == null || r['type'] === 'specialist') {
                     r['type'] = r['agent_type'];

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

@@ -1,6 +1,11 @@
 // packages/@monomind/cli/src/orgrt/policy.ts
 import { relative, resolve } from 'node:path';
 const WRITE_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit']);
+/** Harness messaging tools that bypass the org bus. Always denied: an agent
+ *  that picks one gets the SDK's misleading "no agent named X is reachable"
+ *  error, concludes its teammate is down, and deadlocks the run (observed in
+ *  the field). org_send is the only inter-agent channel. */
+const HARNESS_MESSAGING_TOOLS = new Set(['SendMessage']);
 const READ_TOOLS = new Set(['Read', 'Glob', 'Grep']);
 const WEB_TOOLS = new Set(['WebFetch', 'WebSearch']);
 /** Cap for inline content snapshots on 'asset' events (bytes, UTF-16 chars) — keeps
@@ -83,6 +88,8 @@ export class PolicyEngine {
             }
             return { behavior: 'allow', updatedInput: input };
         };
+        if (HARNESS_MESSAGING_TOOLS.has(tool))
+            return deny(`${tool} does not reach org agents — inter-agent messaging goes through the org_send tool only; resend via org_send (to, subject, message)`);
         if (this.overBudget)
             return deny(`token budget exhausted (${this.used}/${this.policy.maxTokens})`);
         if (this.policy.denyTools?.includes(tool))

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

@@ -17,6 +17,29 @@ export interface SessionOpts {
     onComplete?: (role: string, outcome: 'achieved' | 'partial' | 'failed', summary: string) => void;
     /** Search the org's accumulated cross-run memory (memory_namespace). */
     recall?: (role: string, query: string) => Promise<string>;
+    /** Write a memory deliberately: scope 'org' (shared, default) or 'agent' (private to this role). */
+    remember?: (role: string, content: string, scope: 'org' | 'agent') => Promise<string>;
+    /** Persist extracted entities/relations/rules into the org's knowledge graph. */
+    learn?: (role: string, payload: {
+        nodes?: {
+            name: string;
+            type?: string;
+            description?: string;
+        }[];
+        edges?: {
+            source: string;
+            target: string;
+            relation: string;
+            description?: string;
+        }[];
+        rules?: {
+            rule: string;
+            context?: string;
+        }[];
+    }) => Promise<string>;
+    /** Top existing KG entity names — injected into the coordinator prompt so
+     *  extraction reuses canonical names instead of minting near-duplicates. */
+    glossary?: string[];
     /** Search the user's Second Brain (project documents + personal global brain). */
     searchKnowledge?: (role: string, query: string) => Promise<string>;
     def?: OrgDef;
@@ -24,7 +47,7 @@ export interface SessionOpts {
     queryFn?: typeof query;
 }
 /** Role briefing given to each agent session (SDK systemPrompt option). */
-export declare function buildRolePrompt(role: OrgRole, def: Pick<OrgDef, 'name' | 'goal'>, roster: string[]): string;
+export declare function buildRolePrompt(role: OrgRole, def: Pick<OrgDef, 'name' | 'goal'>, roster: string[], glossary?: string[]): string;
 /**
  * Runs a role for the life of the org, transparently restarting the
  * underlying SDK session whenever it ends on its own (`maxTurns` reached)

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

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { query, tool, createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
 import { resolveProviderEnv } from './provider.js';
 /** Role briefing given to each agent session (SDK systemPrompt option). */
-export function buildRolePrompt(role, def, roster) {
+export function buildRolePrompt(role, def, roster, glossary) {
     const isCoordinator = role.reports_to == null;
     return [
         `You are agent "${role.id}" (${role.title || role.type}) in the org "${def.name}".`,
@@ -18,8 +18,11 @@ export function buildRolePrompt(role, def, roster) {
         `The user's documents (notes, handbooks, specs) are searchable with knowledge_search — ground your work in them instead of guessing; results labeled [global] come from the user's personal cross-project brain.`,
         `When you receive a message, act on it, then org_send your result to the requester.`,
         isCoordinator
-            ? `When the org's goal for this run is achieved (or clearly can't be), call org_complete exactly once with the outcome and a concise summary of what was done — it is recorded in the org's run history and briefed to the next run. Then end your turn.`
+            ? `When the org's goal for this run is achieved (or clearly can't be): first call org_learn ONCE with the durable knowledge this run produced — key entities (basic types, fullest names), their relationships (snake_case, one-sentence facts), and any reusable rules ("when X, do Y") worth keeping. Then call org_complete exactly once with the outcome and a concise summary. Then end your turn.`
             : `When your current work is complete and no reply is needed, end your turn without further tool calls.`,
+        isCoordinator && glossary?.length
+            ? `Known entities (reuse these EXACT names in org_learn instead of near-duplicates): ${glossary.slice(0, 40).join(', ')}`
+            : '',
     ].filter(Boolean).join('\n\n');
 }
 /**
@@ -65,6 +68,18 @@ async function runOneSession(opts) {
                     const text = await opts.recall(role.id, args.query);
                     return { content: [{ type: 'text', text }] };
                 })] : []),
+            ...(opts.remember ? [tool('org_remember', 'Save a memory for future runs. scope "org" (default) shares it with the whole org; scope "agent" keeps it private to your role. Use for decisions, findings, and state worth recalling later — org_recall searches both.', { content: z.string(), scope: z.enum(['org', 'agent']).optional() }, async (args) => {
+                    const text = await opts.remember(role.id, args.content, args.scope ?? 'org');
+                    return { content: [{ type: 'text', text }] };
+                })] : []),
+            ...(opts.learn ? [tool('org_learn', 'Persist durable knowledge from this run into the org\'s knowledge graph: entities ({name, type?, description?}), relationships ({source, target, relation, description?}) and reusable rules ({rule, context?}). Entities merge by name across runs — reuse the exact names listed in your briefing. Call once, before org_complete.', {
+                    nodes: z.array(z.object({ name: z.string(), type: z.string().optional(), description: z.string().optional() })).optional(),
+                    edges: z.array(z.object({ source: z.string(), target: z.string(), relation: z.string(), description: z.string().optional() })).optional(),
+                    rules: z.array(z.object({ rule: z.string(), context: z.string().optional() })).optional(),
+                }, async (args) => {
+                    const text = await opts.learn(role.id, args);
+                    return { content: [{ type: 'text', text }] };
+                })] : []),
             // Gate purely on onComplete: the daemon passes it only to the role its
             // boss-selection rule picked, so tool availability always matches the
             // kickoff instruction (reports_to may be non-null for a fallback boss).
@@ -90,7 +105,7 @@ async function runOneSession(opts) {
         const stream = queryFn({
             prompt: mailbox.stream(),
             options: {
-                systemPrompt: buildRolePrompt(role, (opts.def ?? { name: org, goal: '' }), opts.def?.roles.map(r => r.id) ?? [role.id]),
+                systemPrompt: buildRolePrompt(role, (opts.def ?? { name: org, goal: '' }), opts.def?.roles.map(r => r.id) ?? [role.id], opts.glossary),
                 model: role.adapter_config?.model,
                 cwd,
                 env: resolveProviderEnv(role.provider),

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

@@ -5,6 +5,7 @@ interface TemplateRole {
     type: string;
     reports_to: string | null;
     responsibilities: string[];
+    model?: string;
 }
 interface Template {
     goal: string;

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

@@ -3,6 +3,11 @@
 // Each validates against OrgDefSchema; goal is a placeholder the user edits
 // (or supplies via --goal).
 import { OrgDefSchema } from './types.js';
+// Per-role model hints keep scheduled-org economics sane: coordinators keep
+// the default (strongest) model since they synthesize and decide; verification
+// and mechanical roles run on Haiku — the dogfooded release-desk run showed
+// review/QA roles spend a third of the tokens for checklist-shaped work.
+const FAST_MODEL = 'claude-haiku-4-5-20251001';
 export const ORG_TEMPLATES = {
     'content-team': {
         goal: 'Produce and publish high-quality content on a steady cadence',
@@ -11,7 +16,7 @@ export const ORG_TEMPLATES = {
                 responsibilities: ['Own the content calendar and quality bar', 'Assign pieces to the writer and route drafts to review', 'Approve final drafts for publishing'] },
             { id: 'writer', title: 'Staff Writer', type: 'specialist', reports_to: 'editor-in-chief',
                 responsibilities: ['Draft articles from assigned briefs', 'Incorporate review feedback', 'Hand finished drafts to the reviewer'] },
-            { id: 'reviewer', title: 'Content Reviewer', type: 'reviewer', reports_to: 'editor-in-chief',
+            { id: 'reviewer', title: 'Content Reviewer', type: 'reviewer', reports_to: 'editor-in-chief', model: FAST_MODEL,
                 responsibilities: ['Review drafts for accuracy, clarity, and tone', 'Return actionable feedback to the writer', 'Flag anything needing human judgment via ask_human'] },
         ],
     },
@@ -24,7 +29,7 @@ export const ORG_TEMPLATES = {
                 responsibilities: ['Implement assigned tasks with tests', 'Keep changes small and focused', 'Send diffs to the reviewer before reporting done'] },
             { id: 'code-reviewer', title: 'Code Reviewer', type: 'reviewer', reports_to: 'tech-lead',
                 responsibilities: ['Review diffs for correctness and maintainability', 'Verify claimed test results', 'Reject unverified work'] },
-            { id: 'qa', title: 'QA Engineer', type: 'specialist', reports_to: 'tech-lead',
+            { id: 'qa', title: 'QA Engineer', type: 'specialist', reports_to: 'tech-lead', model: FAST_MODEL,
                 responsibilities: ['Exercise delivered features end-to-end', 'File precise reproduction steps for defects'] },
         ],
     },
@@ -35,7 +40,7 @@ export const ORG_TEMPLATES = {
                 responsibilities: ['Define research questions for each cycle', 'Synthesize findings into the final brief', 'Decide what merits deeper follow-up'] },
             { id: 'researcher', title: 'Researcher', type: 'researcher', reports_to: 'lead-analyst',
                 responsibilities: ['Gather primary sources on assigned questions', 'Separate observed facts from inference', 'Deliver structured findings with citations'] },
-            { id: 'fact-checker', title: 'Fact Checker', type: 'reviewer', reports_to: 'lead-analyst',
+            { id: 'fact-checker', title: 'Fact Checker', type: 'reviewer', reports_to: 'lead-analyst', model: FAST_MODEL,
                 responsibilities: ['Verify claims in draft briefs against sources', 'Flag unverifiable claims for removal or hedging'] },
         ],
     },
@@ -51,7 +56,7 @@ export function buildFromTemplate(templateName, orgName, goal) {
         status: 'stopped',
         schedule: null,
         run_config: { max_concurrent_agents: 4, budget_tokens: 1_000_000, memory_namespace: `org:${orgName}`, max_turns_per_message: 30 },
-        roles: t.roles,
+        roles: t.roles.map(({ model, ...r }) => model ? { ...r, adapter_config: { model } } : r),
     });
 }
 //# sourceMappingURL=templates.js.map

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

@@ -222,18 +222,22 @@ export declare const OrgDefSchema: z.ZodObject<{
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough">>>, {
         memory_namespace?: string | undefined;
+        idle_minutes?: number | undefined;
         max_concurrent_agents: number;
         budget_tokens: number;
         max_turns_per_message: number;
@@ -242,6 +246,7 @@ export declare const OrgDefSchema: z.ZodObject<{
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough"> | undefined>;
     roles: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -425,18 +430,22 @@ export declare const OrgDefSchema: z.ZodObject<{
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough">>>, {
         memory_namespace?: string | undefined;
+        idle_minutes?: number | undefined;
         max_concurrent_agents: number;
         budget_tokens: number;
         max_turns_per_message: number;
@@ -445,6 +454,7 @@ export declare const OrgDefSchema: z.ZodObject<{
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough"> | undefined>;
     roles: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -628,18 +638,22 @@ export declare const OrgDefSchema: z.ZodObject<{
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough">>>, {
         memory_namespace?: string | undefined;
+        idle_minutes?: number | undefined;
         max_concurrent_agents: number;
         budget_tokens: number;
         max_turns_per_message: number;
@@ -648,6 +662,7 @@ export declare const OrgDefSchema: z.ZodObject<{
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     }, z.ZodTypeAny, "passthrough"> | undefined>;
     roles: z.ZodArray<z.ZodObject<{
         id: z.ZodString;

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

@@ -43,6 +43,8 @@ export const OrgDefSchema = z.object({
         budget_tokens: z.number().int().positive().default(1_000_000),
         memory_namespace: z.string().optional(),
         max_turns_per_message: z.number().int().positive().default(30),
+        /** idle watchdog window in minutes (fractions allowed); 0 disables. Default 10. */
+        idle_minutes: z.number().nonnegative().optional(),
     }).partial().passthrough().default({})
         .transform(rc => ({ max_concurrent_agents: 4, budget_tokens: 1_000_000, max_turns_per_message: 30, ...rc })),
     roles: z.array(RoleSchema).min(1),