monomind 1.11.13 → 1.11.14

package/packages/@monomind/cli/dist/src/commands/agent-wasm.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM Agent CLI Subcommands
+ *
+ * Exposes @monoes/rvagent-wasm operations via the `agent` CLI command.
+ * Wraps functions from monovector/agent-wasm.ts for CLI usage.
+ */
+import type { Command } from '../types.js';
+export declare const wasmStatusCommand: Command;
+export declare const wasmCreateCommand: Command;
+export declare const wasmPromptCommand: Command;
+export declare const wasmGalleryCommand: Command;
+/** All WASM subcommands for the agent command */
+export declare const wasmSubcommands: Command[];
+//# sourceMappingURL=agent-wasm.d.ts.map

package/packages/@monomind/cli/dist/src/commands/agent-wasm.js

@@ -0,0 +1,333 @@
+/**
+ * WASM Agent CLI Subcommands
+ *
+ * Exposes @monoes/rvagent-wasm operations via the `agent` CLI command.
+ * Wraps functions from monovector/agent-wasm.ts for CLI usage.
+ */
+import { output } from '../output.js';
+const WASM_NOT_AVAILABLE_MSG = '@monoes/rvagent-wasm is not installed.\n' +
+    'Install it with: npm install @monoes/rvagent-wasm';
+async function loadWasm() {
+    const mod = await import('../monovector/agent-wasm.js');
+    return mod;
+}
+// agent wasm-status
+export const wasmStatusCommand = {
+    name: 'wasm-status',
+    description: 'Check rvagent-wasm availability, version, and capabilities',
+    options: [],
+    examples: [
+        { command: 'monomind agent wasm-status', description: 'Check WASM agent runtime status' },
+    ],
+    action: async (ctx) => {
+        try {
+            const wasm = await loadWasm();
+            const available = await wasm.isAgentWasmAvailable();
+            if (!available) {
+                output.writeln();
+                output.printWarning(WASM_NOT_AVAILABLE_MSG);
+                if (ctx.flags.format === 'json') {
+                    output.printJson({ available: false });
+                }
+                return { success: true, data: { available: false } };
+            }
+            // Init to get full status
+            await wasm.initAgentWasm();
+            const agents = wasm.listWasmAgents();
+            let galleryCount = 0;
+            let categories = {};
+            try {
+                galleryCount = await wasm.getGalleryCount();
+                categories = await wasm.getGalleryCategories();
+            }
+            catch {
+                // Gallery may not be available in all builds
+            }
+            const statusData = {
+                available: true,
+                activeAgents: agents.length,
+                gallery: {
+                    templates: galleryCount,
+                    categories,
+                },
+                tools: ['read_file', 'write_file', 'edit_file', 'write_todos', 'list_files'],
+                features: ['sandboxed-execution', 'virtual-filesystem', 'gallery-templates', 'rvf-containers', 'mcp-bridge'],
+            };
+            if (ctx.flags.format === 'json') {
+                output.printJson(statusData);
+                return { success: true, data: statusData };
+            }
+            output.writeln();
+            output.writeln(output.bold('WASM Agent Runtime'));
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'property', header: 'Property', width: 20 },
+                    { key: 'value', header: 'Value', width: 40 },
+                ],
+                data: [
+                    { property: 'Available', value: output.success('yes') },
+                    { property: 'Active Agents', value: String(agents.length) },
+                    { property: 'Gallery Templates', value: String(galleryCount) },
+                    { property: 'Sandbox Tools', value: statusData.tools.join(', ') },
+                    { property: 'Features', value: statusData.features.join(', ') },
+                ],
+            });
+            if (Object.keys(categories).length > 0) {
+                output.writeln();
+                output.writeln(output.bold('Gallery Categories'));
+                output.printTable({
+                    columns: [
+                        { key: 'category', header: 'Category', width: 20 },
+                        { key: 'count', header: 'Templates', width: 10, align: 'right' },
+                    ],
+                    data: Object.entries(categories).map(([category, count]) => ({ category, count })),
+                });
+            }
+            return { success: true, data: statusData };
+        }
+        catch (error) {
+            output.printError(`WASM status check failed: ${String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+// agent wasm-create
+export const wasmCreateCommand = {
+    name: 'wasm-create',
+    description: 'Create a WASM-sandboxed agent',
+    options: [
+        {
+            name: 'template',
+            short: 't',
+            description: 'Gallery template (coder, researcher, tester, reviewer, security, swarm)',
+            type: 'string',
+        },
+        {
+            name: 'model',
+            short: 'm',
+            description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)',
+            type: 'string',
+        },
+        {
+            name: 'instructions',
+            short: 'i',
+            description: 'System instructions for the agent',
+            type: 'string',
+        },
+        {
+            name: 'max-turns',
+            description: 'Maximum conversation turns (default: 50)',
+            type: 'number',
+            default: 50,
+        },
+    ],
+    examples: [
+        { command: 'monomind agent wasm-create', description: 'Create a default WASM agent' },
+        { command: 'monomind agent wasm-create -t coder', description: 'Create from gallery template' },
+        { command: 'monomind agent wasm-create -m "anthropic:claude-sonnet-4-20250514" -i "You are a security auditor"', description: 'Create with custom config' },
+    ],
+    action: async (ctx) => {
+        try {
+            const wasm = await loadWasm();
+            const available = await wasm.isAgentWasmAvailable();
+            if (!available) {
+                output.printError(WASM_NOT_AVAILABLE_MSG);
+                return { success: false, exitCode: 1 };
+            }
+            const template = ctx.flags.template;
+            let info;
+            if (template) {
+                output.printInfo(`Creating WASM agent from template: ${output.highlight(template)}`);
+                info = await wasm.createAgentFromTemplate(template);
+            }
+            else {
+                output.printInfo('Creating WASM agent...');
+                info = await wasm.createWasmAgent({
+                    model: ctx.flags.model,
+                    instructions: ctx.flags.instructions,
+                    maxTurns: ctx.flags['max-turns'],
+                });
+            }
+            if (ctx.flags.format === 'json') {
+                output.printJson({ success: true, agent: info, source: template ? 'gallery' : 'custom' });
+                return { success: true, data: info };
+            }
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'property', header: 'Property', width: 15 },
+                    { key: 'value', header: 'Value', width: 45 },
+                ],
+                data: [
+                    { property: 'ID', value: info.id },
+                    { property: 'State', value: info.state },
+                    { property: 'Model', value: info.model },
+                    { property: 'Turn Count', value: String(info.turnCount) },
+                    { property: 'File Count', value: String(info.fileCount) },
+                    { property: 'Created', value: info.createdAt },
+                    ...(template ? [{ property: 'Template', value: template }] : []),
+                ],
+            });
+            output.writeln();
+            output.printSuccess(`WASM agent created: ${info.id}`);
+            return { success: true, data: info };
+        }
+        catch (error) {
+            output.printError(`Failed to create WASM agent: ${String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+// agent wasm-prompt
+export const wasmPromptCommand = {
+    name: 'wasm-prompt',
+    description: 'Send a prompt to a WASM agent',
+    options: [
+        {
+            name: 'agent-id',
+            short: 'a',
+            description: 'WASM agent ID (required)',
+            type: 'string',
+        },
+        {
+            name: 'input',
+            short: 'i',
+            description: 'Prompt text to send',
+            type: 'string',
+        },
+    ],
+    examples: [
+        { command: 'monomind agent wasm-prompt -a wasm-agent-1-abc -i "Write a hello world"', description: 'Send prompt to WASM agent' },
+    ],
+    action: async (ctx) => {
+        const agentId = ctx.flags['agent-id'] || ctx.args[0];
+        const promptInput = ctx.flags.input || ctx.args[1];
+        if (!agentId) {
+            output.printError('Agent ID is required. Use --agent-id or -a');
+            return { success: false, exitCode: 1 };
+        }
+        if (!promptInput) {
+            output.printError('Prompt input is required. Use --input or -i');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const wasm = await loadWasm();
+            const available = await wasm.isAgentWasmAvailable();
+            if (!available) {
+                output.printError(WASM_NOT_AVAILABLE_MSG);
+                return { success: false, exitCode: 1 };
+            }
+            output.printInfo(`Sending prompt to ${output.highlight(agentId)}...`);
+            const result = await wasm.promptWasmAgent(agentId, promptInput);
+            if (ctx.flags.format === 'json') {
+                output.printJson({ agentId, response: result });
+                return { success: true, data: { agentId, response: result } };
+            }
+            output.writeln();
+            output.writeln(output.bold('Response'));
+            output.writeln();
+            output.writeln(result);
+            // Show updated agent info
+            const info = wasm.getWasmAgent(agentId);
+            if (info) {
+                output.writeln();
+                output.writeln(output.dim(`[turns: ${info.turnCount}, files: ${info.fileCount}, state: ${info.state}]`));
+            }
+            return { success: true, data: { agentId, response: result } };
+        }
+        catch (error) {
+            output.printError(`Prompt failed: ${String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+// agent wasm-gallery
+export const wasmGalleryCommand = {
+    name: 'wasm-gallery',
+    description: 'List available WASM agent gallery templates',
+    options: [
+        {
+            name: 'search',
+            short: 's',
+            description: 'Search templates by query',
+            type: 'string',
+        },
+        {
+            name: 'category',
+            short: 'c',
+            description: 'Filter by category',
+            type: 'string',
+        },
+    ],
+    examples: [
+        { command: 'monomind agent wasm-gallery', description: 'List all gallery templates' },
+        { command: 'monomind agent wasm-gallery -s coder', description: 'Search gallery templates' },
+    ],
+    action: async (ctx) => {
+        try {
+            const wasm = await loadWasm();
+            const available = await wasm.isAgentWasmAvailable();
+            if (!available) {
+                output.printError(WASM_NOT_AVAILABLE_MSG);
+                return { success: false, exitCode: 1 };
+            }
+            const searchQuery = ctx.flags.search;
+            const category = ctx.flags.category;
+            let templates;
+            if (searchQuery) {
+                output.printInfo(`Searching gallery for: ${output.highlight(searchQuery)}`);
+                templates = await wasm.searchGalleryTemplates(searchQuery);
+            }
+            else {
+                templates = await wasm.listGalleryTemplates();
+            }
+            // Filter by category if specified
+            if (category) {
+                templates = templates.filter((t) => t.category.toLowerCase() === category.toLowerCase());
+            }
+            if (ctx.flags.format === 'json') {
+                output.printJson({ templates, count: templates.length });
+                return { success: true, data: { templates, count: templates.length } };
+            }
+            output.writeln();
+            output.writeln(output.bold('WASM Agent Gallery'));
+            output.writeln();
+            if (templates.length === 0) {
+                output.printInfo('No templates found matching criteria');
+                return { success: true, data: { templates: [], count: 0 } };
+            }
+            output.printTable({
+                columns: [
+                    { key: 'id', header: 'ID', width: 20 },
+                    { key: 'name', header: 'Name', width: 18 },
+                    { key: 'category', header: 'Category', width: 12 },
+                    { key: 'description', header: 'Description', width: 35 },
+                    { key: 'version', header: 'Version', width: 10 },
+                ],
+                data: templates.map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    category: t.category,
+                    description: t.description.length > 35 ? t.description.slice(0, 32) + '...' : t.description,
+                    version: t.version,
+                })),
+            });
+            output.writeln();
+            output.printInfo(`${templates.length} template(s) found. Create with: agent wasm-create -t <id>`);
+            return { success: true, data: { templates, count: templates.length } };
+        }
+        catch (error) {
+            output.printError(`Gallery listing failed: ${String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+/** All WASM subcommands for the agent command */
+export const wasmSubcommands = [
+    wasmStatusCommand,
+    wasmCreateCommand,
+    wasmPromptCommand,
+    wasmGalleryCommand,
+];
+//# sourceMappingURL=agent-wasm.js.map

package/packages/@monomind/cli/dist/src/commands/doctor.js

@@ -579,6 +579,58 @@ async function checkMonoesIntegration() {
         };
     }
 }
+// Patterns that must be covered by .gitignore to prevent leaking session data / machine paths.
+// Uses the surgical approach: ignore specific sensitive subdirs and file globs inside .monomind/
+// rather than the entire directory, so safe content (orgs/, test-fixtures/) can still be tracked.
+const REQUIRED_GITIGNORE_PATTERNS = [
+    { pattern: '.monomind/sessions/', reason: 'session files contain cwd and machine paths' },
+    { pattern: '.monomind/data/', reason: 'intelligence data with edit file paths' },
+    { pattern: '.monomind/metrics/', reason: 'metrics with file path references' },
+    { pattern: '.monomind/knowledge/', reason: 'knowledge chunks with local file content' },
+    { pattern: '.monomind/*.json', reason: 'root-level runtime JSON (control, registry, routing)' },
+    { pattern: '.monomind/*.jsonl', reason: 'root-level event logs (decisions, routing-feedback)' },
+    { pattern: '**/.monomind/sessions/', reason: 'nested session files in sub-packages' },
+    { pattern: '**/.monomind/*.json', reason: 'nested runtime JSON in sub-packages' },
+    { pattern: 'data/sessions/', reason: 'session files with machine paths' },
+    { pattern: 'data/mastermind-*.json', reason: 'mastermind session data' },
+    { pattern: 'data/mastermind-*.jsonl', reason: 'mastermind event logs' },
+    { pattern: '**/.claude-flow/', reason: 'claude-flow runtime data with paths' },
+    { pattern: '.hive-mind/', reason: 'hive-mind state with session info' },
+    { pattern: '.swarm/', reason: 'swarm state files' },
+];
+// Check whether a gitignore file covers all required monomind runtime patterns
+async function checkGitignoreCoverage() {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        return {
+            name: 'Gitignore Coverage',
+            status: 'warn',
+            message: 'No .gitignore found — all monomind runtime paths are unprotected',
+            fix: 'echo ".monomind/\\n**/.monomind/" >> .gitignore',
+        };
+    }
+    const content = readFileSync(gitignorePath, 'utf-8');
+    const lines = content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+    const missing = REQUIRED_GITIGNORE_PATTERNS.filter(({ pattern }) => {
+        // A pattern is "covered" if the gitignore contains it exactly, or a parent glob covers it
+        const base = pattern.replace(/\*\*\//g, '').replace(/\*/g, '');
+        return !lines.some(l => l === pattern ||
+            l === pattern.replace(/\/$/, '') ||
+            // e.g. "**/.monomind/" covers ".monomind/"
+            (l.includes('**') && base && l.replace(/\*\*\//g, '').replace(/\*/g, '') === base));
+    });
+    if (missing.length === 0) {
+        return { name: 'Gitignore Coverage', status: 'pass', message: 'All monomind runtime paths are gitignored' };
+    }
+    const missingList = missing.map(m => m.pattern).join(', ');
+    const fixLines = missing.map(m => m.pattern).join('\\n');
+    return {
+        name: 'Gitignore Coverage',
+        status: 'warn',
+        message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`,
+        fix: `printf "${fixLines}\\n" >> .gitignore`,
+    };
+}
 async function checkGuidanceGates() {
     const settingsPath = join(process.cwd(), '.claude', 'settings.json');
     const gatesHandlerPath = join(process.cwd(), '.claude', 'helpers', 'handlers', 'gates-handler.cjs');
@@ -671,7 +723,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, helpers, monoes, gates)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, helpers, monoes, gates, gitignore)',
             type: 'string'
         },
         {
@@ -718,6 +770,7 @@ export const doctorCommand = {
             checkAgenticFlow,
             checkMonoesIntegration,
             checkGuidanceGates,
+            checkGitignoreCoverage,
         ];
         const componentMap = {
             'version': checkVersionFreshness,
@@ -738,6 +791,7 @@ export const doctorCommand = {
             'agentic-flow': checkAgenticFlow,
             'monoes': checkMonoesIntegration,
             'gates': checkGuidanceGates,
+            'gitignore': checkGitignoreCoverage,
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

package/packages/@monomind/cli/dist/src/commands/ui.js

@@ -0,0 +1,68 @@
+/**
+ * monomind ui — Live dashboard command
+ * Starts a local HTTP server serving the Neural Control Room dashboard.
+ */
+import * as path from 'path';
+import * as os from 'os';
+
+export const uiCommand = {
+  name: 'ui',
+  description: 'Start the live Monomind dashboard (Neural Control Room)',
+  category: 'core',
+  async action(ctx) {
+    return this.execute(ctx.args || [], ctx.flags || {});
+  },
+  async execute(args = [], options = {}) {
+    const port = parseInt(options.port || options.p || '4242', 10);
+    const noOpen = options['no-open'] || options['no-browser'] || false;
+    const projectDir = options.dir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+    console.log('\x1b[36m◆ Monomind Neural Control Room\x1b[0m');
+    console.log('\x1b[2mStarting dashboard server...\x1b[0m\n');
+
+    try {
+      const { fileURLToPath } = await import('url');
+      const { dirname } = await import('path');
+      const { createRequire } = await import('module');
+      const serverPath = new URL('../ui/server.mjs', import.meta.url);
+      const { startServer } = await import(serverPath.href);
+
+      const result = await startServer({
+        port,
+        projectDir,
+        openBrowser: !noOpen,
+      });
+
+      console.log(`\x1b[32m✓ Dashboard running at \x1b[1m${result.url}\x1b[0m`);
+      console.log(`\x1b[2m  Project: ${projectDir}\x1b[0m`);
+      console.log(`\x1b[2m  Press Ctrl+C to stop\x1b[0m\n`);
+
+      // Keep alive
+      await new Promise((resolve) => {
+        process.on('SIGINT', resolve);
+        process.on('SIGTERM', resolve);
+      });
+    } catch (err) {
+      console.error(`\x1b[31m✗ Failed to start dashboard: ${err.message}\x1b[0m`);
+      if (process.env.DEBUG) console.error(err.stack);
+      process.exit(1);
+    }
+  },
+  help() {
+    return `
+\x1b[1mUsage:\x1b[0m  monomind ui [options]
+
+\x1b[1mOptions:\x1b[0m
+  --port, -p <number>   Port to listen on (default: 4242)
+  --no-open             Don't open browser automatically
+  --dir <path>          Project directory to monitor (default: cwd)
+
+\x1b[1mExamples:\x1b[0m
+  monomind ui
+  monomind ui --port 8080
+  monomind ui --no-open --dir /path/to/project
+    `.trim();
+  },
+};
+
+export default uiCommand;

package/packages/@monomind/cli/dist/src/consensus/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Consensus module barrel export (Task 36)
+ */
+export { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export { AuditWriter } from './audit-writer.js';
+export type { RecordInput } from './audit-writer.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/consensus/index.js

@@ -0,0 +1,6 @@
+/**
+ * Consensus module barrel export (Task 36)
+ */
+export { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+export { AuditWriter } from './audit-writer.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/context/context-provider.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Context Provider — interfaces and base class for dynamic prompt assembly.
+ *
+ * Each provider contributes a named section of context to the assembled prompt.
+ * Providers are prioritised (0-100) and budget-aware via token estimation.
+ */
+export interface RunContext {
+    agentSlug: string;
+    taskDescription: string;
+    sessionId: string;
+    swarmId?: string;
+    workingDir?: string;
+    metadata: Record<string, unknown>;
+}
+export interface ContextSection {
+    name: string;
+    content: string;
+    tokenCount: number;
+    priority: number;
+    required: boolean;
+}
+export interface ContextProvider {
+    readonly name: string;
+    readonly priority: number;
+    readonly maxTokens: number;
+    readonly required: boolean;
+    provide(ctx: RunContext): Promise<string>;
+}
+/**
+ * Convenience base class that implements the ContextProvider contract and
+ * supplies a rough token-truncation helper (approx 4 chars per token).
+ */
+export declare abstract class BaseContextProvider implements ContextProvider {
+    abstract readonly name: string;
+    abstract readonly priority: number;
+    readonly maxTokens: number;
+    readonly required: boolean;
+    /**
+     * Truncate `text` so that it fits within `maxTokens` (4 chars/token).
+     */
+    protected truncateToTokens(text: string, maxTokens: number): string;
+    abstract provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=context-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/context-provider.js

@@ -0,0 +1,25 @@
+/**
+ * Context Provider — interfaces and base class for dynamic prompt assembly.
+ *
+ * Each provider contributes a named section of context to the assembled prompt.
+ * Providers are prioritised (0-100) and budget-aware via token estimation.
+ */
+/**
+ * Convenience base class that implements the ContextProvider contract and
+ * supplies a rough token-truncation helper (approx 4 chars per token).
+ */
+export class BaseContextProvider {
+    maxTokens = 500;
+    required = false;
+    /**
+     * Truncate `text` so that it fits within `maxTokens` (4 chars/token).
+     */
+    truncateToTokens(text, maxTokens) {
+        const maxChars = maxTokens * 4;
+        if (text.length <= maxChars) {
+            return text;
+        }
+        return text.slice(0, maxChars);
+    }
+}
+//# sourceMappingURL=context-provider.js.map

package/packages/@monomind/cli/dist/src/context/git-state-provider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GitStateProvider — injects current git branch, recent log, and changed files
+ * into the assembled prompt.  Falls back gracefully when not inside a git repo.
+ */
+import { BaseContextProvider, type RunContext } from './context-provider.js';
+export declare class GitStateProvider extends BaseContextProvider {
+    readonly name: "git-state";
+    readonly priority = 60;
+    readonly maxTokens = 300;
+    provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=git-state-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/git-state-provider.js

@@ -0,0 +1,34 @@
+/**
+ * GitStateProvider — injects current git branch, recent log, and changed files
+ * into the assembled prompt.  Falls back gracefully when not inside a git repo.
+ */
+import { execSync } from 'child_process';
+import { BaseContextProvider } from './context-provider.js';
+export class GitStateProvider extends BaseContextProvider {
+    name = 'git-state';
+    priority = 60;
+    maxTokens = 300;
+    async provide(ctx) {
+        try {
+            const cwd = ctx.workingDir ?? process.cwd();
+            const opts = { cwd, encoding: 'utf-8', timeout: 5000 };
+            const branch = execSync('git branch --show-current', opts).trim();
+            const log = execSync('git log --oneline -5', opts).trim();
+            const changed = execSync('git diff --name-only HEAD', opts).trim();
+            const parts = [
+                `**Branch:** ${branch}`,
+                '',
+                '**Recent commits:**',
+                log,
+            ];
+            if (changed) {
+                parts.push('', '**Changed files:**', changed);
+            }
+            return this.truncateToTokens(parts.join('\n'), this.maxTokens);
+        }
+        catch {
+            return 'Git state unavailable (not a git repository or git not installed).';
+        }
+    }
+}
+//# sourceMappingURL=git-state-provider.js.map

package/packages/@monomind/cli/dist/src/context/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Context module — dynamic system prompt assembly.
+ *
+ * Re-exports all context providers and the prompt assembler.
+ */
+export { type RunContext, type ContextSection, type ContextProvider, BaseContextProvider, } from './context-provider.js';
+export { GitStateProvider } from './git-state-provider.js';
+export { TaskHistoryProvider, type SearchFn, type SearchResult, } from './task-history-provider.js';
+export { ProjectConventionsProvider, type ConventionsLoader, } from './project-conventions-provider.js';
+export { UserPreferencesProvider, type PreferencesGetter, } from './user-preferences-provider.js';
+export { PromptAssembler, type AssemblyConfig, type AssembledPrompt, } from './prompt-assembler.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/context/index.js

@@ -0,0 +1,12 @@
+/**
+ * Context module — dynamic system prompt assembly.
+ *
+ * Re-exports all context providers and the prompt assembler.
+ */
+export { BaseContextProvider, } from './context-provider.js';
+export { GitStateProvider } from './git-state-provider.js';
+export { TaskHistoryProvider, } from './task-history-provider.js';
+export { ProjectConventionsProvider, } from './project-conventions-provider.js';
+export { UserPreferencesProvider, } from './user-preferences-provider.js';
+export { PromptAssembler, } from './prompt-assembler.js';
+//# sourceMappingURL=index.js.map