monomind 2.7.12 → 2.7.13

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

@@ -1,157 +0,0 @@
-// packages/@monomind/cli/src/orgrt/session.ts
-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, glossary) {
-    const isCoordinator = role.reports_to == null;
-    return [
-        `You are agent "${role.id}" (${role.title || role.type}) in the org "${def.name}".`,
-        `Org goal: ${def.goal}`,
-        isCoordinator ? `You are the coordinator of this org.` : `You report to "${role.reports_to}".`,
-        role.responsibilities?.length ? `Your responsibilities:\n- ${role.responsibilities.join('\n- ')}` : '',
-        `## Communication protocol`,
-        `The ONLY way to communicate with other agents is the org_send tool.`,
-        `Roster: ${roster.join(', ')}. Address another org's agent as "<org-name>:<role-id>".`,
-        `If you need a human decision, call ask_human with your question, then end your turn — you'll receive the human's answer as a new message when it arrives. Do not call ask_human for anything you can resolve yourself.`,
-        `Before starting substantial work, call org_recall to check what previous runs already learned or delivered — do not redo finished work.`,
-        `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): 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');
-}
-/**
- * Runs a role for the life of the org, transparently restarting the
- * underlying SDK session whenever it ends on its own (`maxTurns` reached)
- * while the mailbox is still open. `maxTurns` bounds a single SDK query()
- * call's TOTAL turns, not "turns per incoming message" — since one query()
- * call stays open across every mailbox message for as long as the mailbox
- * itself stays open, without a restart the role would go permanently silent
- * (no crash, no alert) once its lifetime turn count crossed the limit, while
- * deliver() kept queuing new messages into a mailbox nobody was reading.
- */
-export async function runAgentSession(opts) {
-    const { mailbox } = opts;
-    // Carries the SDK's own session_id across a maxTurns restart so the next
-    // query() call resumes the prior conversation instead of starting cold —
-    // without this, a restart silently discarded all in-progress reasoning.
-    let resumeSessionId;
-    // Always run at least once: a mailbox can be closed with queued items still
-    // pending (stream() drains the queue before honoring `closed`), which is a
-    // normal, valid starting state — checking isClosed before the first run
-    // would skip that drain entirely.
-    while (true) {
-        resumeSessionId = await runOneSession(opts, resumeSessionId);
-        // The dead session's generator may still hold the waker — drop it so a
-        // push() before the next stream() starts only queues instead of being
-        // consumed by the abandoned generator (silent message loss).
-        mailbox.detach();
-        if (mailbox.isClosed)
-            return;
-        opts.bus.emit({ type: 'status', from: opts.role.id, msg: 'session restarting (turn limit reached, mailbox still open)' });
-    }
-}
-/** One bounded SDK session for a role; resolves with the SDK's session_id (for resuming on restart) when the stream ends (mailbox closed or maxTurns reached). */
-async function runOneSession(opts, resume) {
-    const { org, role, bus, policy, mailbox, cwd, deliver } = opts;
-    const queryFn = opts.queryFn ?? query;
-    const orgServer = createSdkMcpServer({
-        name: 'org',
-        version: '1.0.0',
-        tools: [
-            ...(opts.searchKnowledge ? [tool('knowledge_search', 'Semantic search over the user\'s Second Brain: this project\'s indexed documents plus their personal cross-project global brain. Use to ground work in the user\'s actual notes, handbooks, and documents.', { query: z.string() }, async (args) => {
-                    const text = await opts.searchKnowledge(role.id, args.query);
-                    return { content: [{ type: 'text', text }] };
-                })] : []),
-            ...(opts.recall ? [tool('org_recall', 'Search this org\'s accumulated memory from previous runs (outcomes, decisions, learnings). Use before starting work that may already have been done.', { query: z.string() }, async (args) => {
-                    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).
-            ...(opts.onComplete ? [tool('org_complete', 'Record the outcome of this run. Call exactly once, when the goal is achieved or clearly cannot be. The outcome and summary are persisted to the org run history and briefed to the next run.', { outcome: z.enum(['achieved', 'partial', 'failed']), summary: z.string() }, async (args) => {
-                    opts.onComplete(role.id, args.outcome, args.summary);
-                    return { content: [{ type: 'text', text: `outcome "${args.outcome}" recorded` }] };
-                })] : []),
-            tool('org_send', 'Send a message to another agent (role id) or another org ("org:role"). This is the only inter-agent channel.', { to: z.string(), subject: z.string(), message: z.string() }, async (args) => {
-                const receipt = await deliver(role.id, args.to, args.subject, args.message);
-                return { content: [{ type: 'text', text: receipt }] };
-            }),
-            tool('ask_human', 'Ask a human a free-form question and pause for their answer. Use only when you genuinely need human judgment.', { question: z.string() }, async (args) => {
-                if (!opts.askHuman) {
-                    return { content: [{ type: 'text', text: 'ask_human is not available in this session' }] };
-                }
-                const receipt = await opts.askHuman(role.id, args.question);
-                return { content: [{ type: 'text', text: receipt }] };
-            }),
-        ],
-    });
-    bus.emit({ type: 'status', from: role.id, msg: 'session starting' });
-    let sessionId = resume;
-    try {
-        const stream = queryFn({
-            prompt: mailbox.stream(),
-            options: {
-                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),
-                mcpServers: { org: orgServer },
-                maxTurns: opts.maxTurns ?? 30,
-                permissionMode: 'default',
-                resume,
-                canUseTool: async (toolName, input) => policy.decide(toolName, input),
-                // test seam: lets the scripted fake SDK (test-loop.ts) drive org_send and
-                // tool calls through the real deliver/policy paths; the real SDK ignores it
-                _orgTest: {
-                    deliver: (to, subject, body) => deliver(role.id, to, subject, body),
-                    callTool: (name, input) => policy.decide(name, input),
-                },
-            },
-        });
-        for await (const m of stream) {
-            if (m.session_id)
-                sessionId = m.session_id;
-            if (m.type === 'assistant') {
-                const text = (m.message?.content ?? [])
-                    .filter((b) => b.type === 'text').map((b) => b.text).join('\n');
-                if (text.trim())
-                    bus.emit({ type: 'chat', from: role.id, msg: text });
-            }
-            else if (m.type === 'result') {
-                const tokens = (m.usage?.input_tokens ?? 0) + (m.usage?.output_tokens ?? 0);
-                policy.addUsage(tokens);
-                bus.emit({ type: 'usage', from: role.id, data: { tokens, cost_usd: m.total_cost_usd, subtype: m.subtype } });
-                if (policy.overBudget) {
-                    bus.emit({ type: 'status', from: role.id, msg: 'token budget exhausted — closing session' });
-                    mailbox.close();
-                }
-            }
-        }
-        bus.emit({ type: 'status', from: role.id, msg: 'session ended' });
-        return sessionId;
-    }
-    catch (err) {
-        bus.emit({ type: 'status', from: role.id, msg: `session error: ${err.message}` });
-        throw err;
-    }
-}
-//# sourceMappingURL=session.js.map

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

@@ -1,17 +0,0 @@
-import { type OrgDef } from './types.js';
-interface TemplateRole {
-    id: string;
-    title: string;
-    type: string;
-    reports_to: string | null;
-    responsibilities: string[];
-    model?: string;
-}
-interface Template {
-    goal: string;
-    roles: TemplateRole[];
-}
-export declare const ORG_TEMPLATES: Record<string, Template>;
-export declare function buildFromTemplate(templateName: string, orgName: string, goal?: string): OrgDef | null;
-export {};
-//# sourceMappingURL=templates.d.ts.map

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

@@ -1,62 +0,0 @@
-// packages/@monomind/cli/src/orgrt/templates.ts
-// Starter org configs for `monomind org create <name> --template <t>`.
-// 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',
-        roles: [
-            { id: 'editor-in-chief', title: 'Editor in Chief', type: 'boss', reports_to: null,
-                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', 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'] },
-        ],
-    },
-    'dev-team': {
-        goal: 'Deliver features and fixes from a continuously groomed backlog',
-        roles: [
-            { id: 'tech-lead', title: 'Tech Lead', type: 'boss', reports_to: null,
-                responsibilities: ['Break the goal into concrete tasks and assign them', 'Arbitrate design questions', 'Merge only work that passed review and tests'] },
-            { id: 'developer', title: 'Developer', type: 'specialist', reports_to: 'tech-lead',
-                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', model: FAST_MODEL,
-                responsibilities: ['Exercise delivered features end-to-end', 'File precise reproduction steps for defects'] },
-        ],
-    },
-    'research-pod': {
-        goal: 'Produce a recurring intelligence brief on a defined topic',
-        roles: [
-            { id: 'lead-analyst', title: 'Lead Analyst', type: 'boss', reports_to: null,
-                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', model: FAST_MODEL,
-                responsibilities: ['Verify claims in draft briefs against sources', 'Flag unverifiable claims for removal or hedging'] },
-        ],
-    },
-};
-export function buildFromTemplate(templateName, orgName, goal) {
-    const t = ORG_TEMPLATES[templateName];
-    if (!t)
-        return null;
-    // Parse through the schema so a template can never produce an unrunnable config.
-    return OrgDefSchema.parse({
-        name: orgName,
-        goal: goal ?? t.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.map(({ model, ...r }) => model ? { ...r, adapter_config: { model } } : r),
-    });
-}
-//# sourceMappingURL=templates.js.map

package/packages/@monomind/cli/dist/src/orgrt/test-loop.d.ts

@@ -1,12 +0,0 @@
-interface IterationResult {
-    checks: Record<string, boolean>;
-    events: number;
-}
-export interface LoopReport {
-    iterations: IterationResult[];
-    failed: number;
-    summary: string;
-}
-export declare function runTestLoop(root: string, times: number): Promise<LoopReport>;
-export {};
-//# sourceMappingURL=test-loop.d.ts.map

package/packages/@monomind/cli/dist/src/orgrt/test-loop.js

@@ -1,108 +0,0 @@
-// packages/@monomind/cli/src/orgrt/test-loop.ts
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { OrgDaemon } from './daemon.js';
-import { startOrgServer } from './server.js';
-import { OrgBus } from './bus.js';
-import { queueMessage } from './inbox.js';
-import { ORG_DIR } from './types.js';
-/**
- * Scripted fake SDK used by the verification loop (no API cost, deterministic).
- * boss: on kickoff, delegates to coder, then pings the partner org's boss.
- * coder: "writes" a report (Write allowed by policy), attempts Bash (denied), replies to boss.
- * It drives the SAME production code paths via the _orgTest seam:
- * callTool → policy.decide → bus; deliver → daemon.deliver → mailboxes + bus;
- * assistant/result → chat/usage events.
- */
-const scriptedQuery = (roleId) => ({ prompt, options }) => (async function* () {
-    const seam = options._orgTest;
-    for await (const m of prompt) {
-        const text = String(m.message.content);
-        // Trigger ONLY on the daemon kickoff message (starts with `Org "`). A bare
-        // includes('started') also matches the xorg body "alpha started its run",
-        // making the partner boss re-deliver to itself forever — an unbroken
-        // microtask chain that starves the event loop (waitFor's timer never fires).
-        if (roleId === 'boss' && text.startsWith('Org "') && text.includes('started')) {
-            yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Kicking off: delegating to coder.' }] } };
-            await seam.deliver('coder', 'task', 'produce out/report.md');
-            await seam.deliver('partner:boss', 'fyi', 'alpha started its run');
-        }
-        else if (roleId === 'coder') {
-            await seam.callTool('Write', { file_path: join(options.cwd, 'out/report.md'), content: '# report' });
-            await seam.callTool('Bash', { command: 'echo should-be-denied' }); // policy MUST deny
-            yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Report written.' }] } };
-            await seam.deliver('boss', 're: task', 'done — out/report.md');
-        }
-        else {
-            yield { type: 'assistant', message: { content: [{ type: 'text', text: `ack: ${text.slice(0, 40)}` }] } };
-        }
-        yield { type: 'result', subtype: 'success', usage: { input_tokens: 5, output_tokens: 5 } };
-    }
-})();
-function writeFixtures(root) {
-    const dir = join(root, ORG_DIR);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'alpha.json'), JSON.stringify({
-        name: 'alpha', goal: 'produce a report',
-        roles: [
-            { id: 'boss', title: 'Boss', type: 'boss', reports_to: null },
-            { id: 'coder', title: 'Coder', type: 'specialist', reports_to: 'boss',
-                policy: { denyTools: ['Bash'], fileWrite: ['out/**'] } },
-        ],
-    }));
-    writeFileSync(join(dir, 'partner.json'), JSON.stringify({
-        name: 'partner', goal: 'receive handoffs',
-        roles: [{ id: 'boss', title: 'Boss', type: 'boss', reports_to: null }],
-    }));
-}
-async function waitFor(pred, ms = 5000) {
-    const t0 = Date.now();
-    while (Date.now() - t0 < ms) {
-        if (pred())
-            return true;
-        await new Promise(r => setTimeout(r, 50));
-    }
-    return pred();
-}
-export async function runTestLoop(root, times) {
-    writeFixtures(root);
-    const iterations = [];
-    for (let i = 0; i < times; i++) {
-        const queryFn = (args) => {
-            const roleId = /You are agent "([^"]+)"/.exec(args.options.systemPrompt)?.[1] ?? 'unknown';
-            return scriptedQuery(roleId)(args);
-        };
-        const daemon = new OrgDaemon(root, { queryFn: queryFn, forward: false });
-        // xdeliver server for cross-process delivery (tested via the xorg check)
-        const srv = await startOrgServer(daemon, 0);
-        daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
-        // Queue a message for partner:boss BEFORE starting it — verifies inbox drain on startup
-        queueMessage(root, 'partner', { fromQualified: 'external:system', toRole: 'boss', subject: 'pre-start', body: 'queued while offline', ts: Date.now() });
-        const alpha = await daemon.startOrg('alpha');
-        const partner = await daemon.startOrg('partner');
-        await waitFor(() => alpha.busEvents().some(e => e.type === 'message' && e.from === 'coder' && e.to === 'boss'));
-        await daemon.stopAll();
-        srv.close();
-        const evs = alpha.busEvents();
-        const has = (pred) => evs.some(pred);
-        const persistedCount = OrgBus.readHistory(join(root, ORG_DIR, 'alpha', alpha.run)).length;
-        const partnerEvs = partner.busEvents();
-        const checks = {
-            chat: has(e => e.type === 'chat'),
-            message: has(e => e.type === 'message' && e.from === 'boss' && e.to === 'coder'),
-            tool: has(e => e.type === 'tool' && e.decision === 'allow' && e.tool === 'Write'),
-            policyDeny: has(e => e.type === 'tool' && e.decision === 'deny' && e.tool === 'Bash'),
-            asset: has(e => e.type === 'asset' && (e.path ?? '').endsWith('out/report.md')),
-            xorg: has(e => e.type === 'xorg' && e.to === 'partner:boss'),
-            usage: has(e => e.type === 'usage'),
-            persisted: persistedCount === evs.length,
-            inboxDrain: partnerEvs.some(e => e.type === 'xorg' && e.from === 'external:system' && e.subject === 'pre-start'),
-        };
-        iterations.push({ checks, events: evs.length });
-    }
-    const failed = iterations.filter(it => Object.values(it.checks).some(v => !v)).length;
-    const summary = `org e2e: ${times - failed}/${times} passed` +
-        (failed ? ` — failing checks: ${JSON.stringify(iterations.filter(it => Object.values(it.checks).some(v => !v)).map(it => it.checks))}` : '');
-    return { iterations, failed, summary };
-}
-//# sourceMappingURL=test-loop.js.map