monomind 1.11.11 → 1.11.13

package/packages/@monomind/cli/dist/src/eval/trace-collector.d.ts

@@ -1,40 +0,0 @@
-import type { EvalTrace } from '../../../shared/src/types/eval.js';
-export interface RecordTraceInput {
-    agentSlug: string;
-    agentVersion: string;
-    taskDescription: string;
-    taskInput: string;
-    agentOutput: string;
-    retryCount: number;
-    qualityScore?: number;
-    outcome: 'success' | 'failure' | 'timeout';
-    latencyMs: number;
-    tokenCount?: number;
-    costUsd?: number;
-    correctedOutput?: string;
-}
-export declare class TraceCollector {
-    private filePath;
-    constructor(filePath: string);
-    /**
-     * Determine auto review status based on trace quality signals.
-     */
-    autoReviewStatus(input: RecordTraceInput): 'pending' | 'approved';
-    /**
-     * Auto-generate tags based on trace characteristics.
-     */
-    autoTag(input: RecordTraceInput): string[];
-    /**
-     * Record a trace, auto-generating traceId, capturedAt, reviewStatus, and tags.
-     */
-    record(input: RecordTraceInput): EvalTrace;
-    /**
-     * Read all traces from the JSONL file.
-     */
-    readAll(): EvalTrace[];
-    /**
-     * Get traces pending review, with optional limit.
-     */
-    getTracesPendingReview(limit?: number): EvalTrace[];
-}
-//# sourceMappingURL=trace-collector.d.ts.map

package/packages/@monomind/cli/dist/src/eval/trace-collector.js

@@ -1,102 +0,0 @@
-/**
- * TraceCollector - JSONL-based production trace collection (Task 33)
- */
-import { randomUUID } from 'crypto';
-import { appendFileSync, readFileSync, existsSync, statSync } from 'fs';
-import { parseJsonl } from '../utils/parse-jsonl.js';
-export class TraceCollector {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    /**
-     * Determine auto review status based on trace quality signals.
-     */
-    autoReviewStatus(input) {
-        if (input.retryCount > 1)
-            return 'pending';
-        if (input.qualityScore !== undefined && input.qualityScore < 0.6)
-            return 'pending';
-        if (input.outcome === 'failure')
-            return 'pending';
-        return 'approved';
-    }
-    /**
-     * Auto-generate tags based on trace characteristics.
-     */
-    autoTag(input) {
-        const tags = [];
-        if (input.retryCount > 1)
-            tags.push('high-retry');
-        if (input.outcome === 'failure')
-            tags.push('failure');
-        if (input.outcome === 'timeout')
-            tags.push('timeout');
-        return tags;
-    }
-    /**
-     * Record a trace, auto-generating traceId, capturedAt, reviewStatus, and tags.
-     */
-    record(input) {
-        const trace = {
-            traceId: randomUUID(),
-            agentSlug: input.agentSlug,
-            agentVersion: input.agentVersion,
-            taskDescription: input.taskDescription,
-            taskInput: input.taskInput,
-            agentOutput: input.agentOutput,
-            retryCount: input.retryCount,
-            qualityScore: input.qualityScore,
-            outcome: input.outcome,
-            latencyMs: input.latencyMs,
-            tokenCount: input.tokenCount,
-            costUsd: input.costUsd,
-            capturedAt: new Date().toISOString(),
-            reviewStatus: this.autoReviewStatus(input),
-            correctedOutput: input.correctedOutput,
-            tags: this.autoTag(input),
-        };
-        // Defensive serialization — agent outputs may contain circular references
-        // or BigInt; without this guard the writer crashes mid-trace.
-        let serialized;
-        try {
-            serialized = JSON.stringify(trace);
-        }
-        catch {
-            serialized = JSON.stringify({
-                traceId: trace.traceId,
-                agentSlug: trace.agentSlug,
-                capturedAt: trace.capturedAt,
-                reviewStatus: trace.reviewStatus,
-                outcome: 'serialize_failed',
-            });
-        }
-        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
-        return trace;
-    }
-    /**
-     * Read all traces from the JSONL file.
-     */
-    readAll() {
-        if (!existsSync(this.filePath))
-            return [];
-        const stat = statSync(this.filePath);
-        if (stat.size > 256 * 1024 * 1024) {
-            throw new Error(`Trace file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
-        }
-        const content = readFileSync(this.filePath, 'utf-8').trim();
-        if (!content)
-            return [];
-        return parseJsonl(content);
-    }
-    /**
-     * Get traces pending review, with optional limit.
-     */
-    getTracesPendingReview(limit) {
-        const all = this.readAll().filter((t) => t.reviewStatus === 'pending');
-        if (limit !== undefined)
-            return all.slice(0, limit);
-        return all;
-    }
-}
-//# sourceMappingURL=trace-collector.js.map

package/packages/@monomind/cli/dist/src/infrastructure/in-memory-repositories.d.ts

@@ -1,68 +0,0 @@
-/**
- * In-Memory Repositories - CLI Infrastructure
- *
- * Lightweight in-memory implementations for CLI use.
- *
- * @module v1/cli/infrastructure
- */
-import { Agent, AgentStatus, AgentRole } from '../../../swarm/src/domain/entities/agent.js';
-import { Task, TaskStatus, TaskPriority } from '../../../swarm/src/domain/entities/task.js';
-import { IAgentRepository, AgentQueryOptions, AgentStatistics } from '../../../swarm/src/domain/repositories/agent-repository.interface.js';
-import { ITaskRepository, TaskQueryOptions, TaskStatistics } from '../../../swarm/src/domain/repositories/task-repository.interface.js';
-/**
- * In-Memory Agent Repository
- */
-export declare class InMemoryAgentRepository implements IAgentRepository {
-    private agents;
-    private initialized;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    clear(): Promise<void>;
-    save(agent: Agent): Promise<void>;
-    findById(id: string): Promise<Agent | null>;
-    findByName(name: string): Promise<Agent | null>;
-    delete(id: string): Promise<boolean>;
-    exists(id: string): Promise<boolean>;
-    saveMany(agents: Agent[]): Promise<void>;
-    findByIds(ids: string[]): Promise<Agent[]>;
-    deleteMany(ids: string[]): Promise<number>;
-    findAll(options?: AgentQueryOptions): Promise<Agent[]>;
-    findByStatus(status: AgentStatus): Promise<Agent[]>;
-    findByRole(role: AgentRole): Promise<Agent[]>;
-    findByDomain(domain: string): Promise<Agent[]>;
-    findByParent(parentId: string): Promise<Agent[]>;
-    findByCapability(capability: string): Promise<Agent[]>;
-    findAvailable(): Promise<Agent[]>;
-    getStatistics(): Promise<AgentStatistics>;
-    count(options?: AgentQueryOptions): Promise<number>;
-}
-/**
- * In-Memory Task Repository
- */
-export declare class InMemoryTaskRepository implements ITaskRepository {
-    private tasks;
-    private initialized;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    clear(): Promise<void>;
-    save(task: Task): Promise<void>;
-    findById(id: string): Promise<Task | null>;
-    delete(id: string): Promise<boolean>;
-    exists(id: string): Promise<boolean>;
-    saveMany(tasks: Task[]): Promise<void>;
-    findByIds(ids: string[]): Promise<Task[]>;
-    deleteMany(ids: string[]): Promise<number>;
-    findAll(options?: TaskQueryOptions): Promise<Task[]>;
-    findByStatus(status: TaskStatus): Promise<Task[]>;
-    findByPriority(priority: TaskPriority): Promise<Task[]>;
-    findByAgent(agentId: string): Promise<Task[]>;
-    findPending(): Promise<Task[]>;
-    findQueued(): Promise<Task[]>;
-    findRunning(): Promise<Task[]>;
-    findTimedOut(): Promise<Task[]>;
-    getNextTask(agentCapabilities?: string[]): Promise<Task | null>;
-    getTaskQueue(limit?: number): Promise<Task[]>;
-    getStatistics(): Promise<TaskStatistics>;
-    count(options?: TaskQueryOptions): Promise<number>;
-}
-//# sourceMappingURL=in-memory-repositories.d.ts.map

package/packages/@monomind/cli/dist/src/infrastructure/in-memory-repositories.js

@@ -1,264 +0,0 @@
-/**
- * In-Memory Repositories - CLI Infrastructure
- *
- * Lightweight in-memory implementations for CLI use.
- *
- * @module v1/cli/infrastructure
- */
-/**
- * In-Memory Agent Repository
- */
-export class InMemoryAgentRepository {
-    agents = new Map();
-    initialized = false;
-    async initialize() {
-        this.initialized = true;
-    }
-    async shutdown() {
-        this.agents.clear();
-        this.initialized = false;
-    }
-    async clear() {
-        this.agents.clear();
-    }
-    async save(agent) {
-        this.agents.set(agent.id, agent);
-    }
-    async findById(id) {
-        return this.agents.get(id) ?? null;
-    }
-    async findByName(name) {
-        for (const agent of this.agents.values()) {
-            if (agent.name === name)
-                return agent;
-        }
-        return null;
-    }
-    async delete(id) {
-        return this.agents.delete(id);
-    }
-    async exists(id) {
-        return this.agents.has(id);
-    }
-    async saveMany(agents) {
-        for (const agent of agents) {
-            this.agents.set(agent.id, agent);
-        }
-    }
-    async findByIds(ids) {
-        return ids.map((id) => this.agents.get(id)).filter((a) => a !== undefined);
-    }
-    async deleteMany(ids) {
-        let deleted = 0;
-        for (const id of ids) {
-            if (this.agents.delete(id))
-                deleted++;
-        }
-        return deleted;
-    }
-    async findAll(options) {
-        let result = Array.from(this.agents.values());
-        if (options?.status)
-            result = result.filter((a) => a.status === options.status);
-        if (options?.role)
-            result = result.filter((a) => a.role === options.role);
-        if (options?.domain)
-            result = result.filter((a) => a.domain === options.domain);
-        if (options?.limit)
-            result = result.slice(0, options.limit);
-        return result;
-    }
-    async findByStatus(status) {
-        return this.findAll({ status });
-    }
-    async findByRole(role) {
-        return this.findAll({ role });
-    }
-    async findByDomain(domain) {
-        return this.findAll({ domain });
-    }
-    async findByParent(parentId) {
-        return Array.from(this.agents.values()).filter((a) => a.parentId === parentId);
-    }
-    async findByCapability(capability) {
-        return Array.from(this.agents.values()).filter((a) => a.hasCapability(capability));
-    }
-    async findAvailable() {
-        return Array.from(this.agents.values()).filter((a) => a.isAvailable());
-    }
-    async getStatistics() {
-        const agents = Array.from(this.agents.values());
-        const byStatus = {
-            idle: 0,
-            active: 0,
-            busy: 0,
-            paused: 0,
-            terminated: 0,
-            error: 0,
-        };
-        const byRole = {};
-        const byDomain = {};
-        let totalCompleted = 0;
-        let totalUtilization = 0;
-        for (const agent of agents) {
-            byStatus[agent.status]++;
-            byRole[agent.role] = (byRole[agent.role] ?? 0) + 1;
-            byDomain[agent.domain] = (byDomain[agent.domain] ?? 0) + 1;
-            totalCompleted += agent.completedTaskCount;
-            totalUtilization += agent.getUtilization();
-        }
-        return {
-            total: agents.length,
-            byStatus,
-            byRole,
-            byDomain,
-            totalTasksCompleted: totalCompleted,
-            averageUtilization: agents.length > 0 ? totalUtilization / agents.length : 0,
-        };
-    }
-    async count(options) {
-        return (await this.findAll(options)).length;
-    }
-}
-/**
- * In-Memory Task Repository
- */
-export class InMemoryTaskRepository {
-    tasks = new Map();
-    initialized = false;
-    async initialize() {
-        this.initialized = true;
-    }
-    async shutdown() {
-        this.tasks.clear();
-        this.initialized = false;
-    }
-    async clear() {
-        this.tasks.clear();
-    }
-    async save(task) {
-        this.tasks.set(task.id, task);
-    }
-    async findById(id) {
-        return this.tasks.get(id) ?? null;
-    }
-    async delete(id) {
-        return this.tasks.delete(id);
-    }
-    async exists(id) {
-        return this.tasks.has(id);
-    }
-    async saveMany(tasks) {
-        for (const task of tasks) {
-            this.tasks.set(task.id, task);
-        }
-    }
-    async findByIds(ids) {
-        return ids.map((id) => this.tasks.get(id)).filter((t) => t !== undefined);
-    }
-    async deleteMany(ids) {
-        let deleted = 0;
-        for (const id of ids) {
-            if (this.tasks.delete(id))
-                deleted++;
-        }
-        return deleted;
-    }
-    async findAll(options) {
-        let result = Array.from(this.tasks.values());
-        if (options?.status)
-            result = result.filter((t) => t.status === options.status);
-        if (options?.priority)
-            result = result.filter((t) => t.priority === options.priority);
-        if (options?.type)
-            result = result.filter((t) => t.type === options.type);
-        if (options?.assignedAgentId)
-            result = result.filter((t) => t.assignedAgentId === options.assignedAgentId);
-        if (options?.limit)
-            result = result.slice(0, options.limit);
-        return result;
-    }
-    async findByStatus(status) {
-        return this.findAll({ status });
-    }
-    async findByPriority(priority) {
-        return this.findAll({ priority });
-    }
-    async findByAgent(agentId) {
-        return this.findAll({ assignedAgentId: agentId });
-    }
-    async findPending() {
-        return this.findByStatus('pending');
-    }
-    async findQueued() {
-        return this.findByStatus('queued');
-    }
-    async findRunning() {
-        return this.findByStatus('running');
-    }
-    async findTimedOut() {
-        return Array.from(this.tasks.values()).filter((t) => t.isTimedOut());
-    }
-    async getNextTask(agentCapabilities) {
-        const queued = await this.findQueued();
-        if (queued.length === 0)
-            return null;
-        queued.sort((a, b) => a.comparePriority(b));
-        return queued[0];
-    }
-    async getTaskQueue(limit = 10) {
-        const queued = await this.findQueued();
-        queued.sort((a, b) => a.comparePriority(b));
-        return queued.slice(0, limit);
-    }
-    async getStatistics() {
-        const tasks = Array.from(this.tasks.values());
-        const byStatus = {
-            pending: 0,
-            queued: 0,
-            assigned: 0,
-            running: 0,
-            completed: 0,
-            failed: 0,
-            cancelled: 0,
-        };
-        const byPriority = {
-            critical: 0,
-            high: 0,
-            normal: 0,
-            low: 0,
-        };
-        const byType = {};
-        let totalDuration = 0;
-        let completedCount = 0;
-        let failedCount = 0;
-        let retryTotal = 0;
-        for (const task of tasks) {
-            byStatus[task.status]++;
-            byPriority[task.priority]++;
-            byType[task.type] = (byType[task.type] ?? 0) + 1;
-            if (task.status === 'completed') {
-                completedCount++;
-                const duration = task.getExecutionDuration();
-                if (duration)
-                    totalDuration += duration;
-            }
-            if (task.status === 'failed')
-                failedCount++;
-            retryTotal += task.retryCount;
-        }
-        return {
-            total: tasks.length,
-            byStatus,
-            byPriority,
-            byType,
-            averageExecutionTime: completedCount > 0 ? totalDuration / completedCount : 0,
-            successRate: tasks.length > 0 ? completedCount / tasks.length : 0,
-            retryRate: tasks.length > 0 ? retryTotal / tasks.length : 0,
-        };
-    }
-    async count(options) {
-        return (await this.findAll(options)).length;
-    }
-}
-//# sourceMappingURL=in-memory-repositories.js.map

package/packages/@monomind/cli/dist/src/interactive/interrupt.d.ts

@@ -1,22 +0,0 @@
-export type InterruptDecision = 'approved' | 'rejected' | 'edited';
-export interface InterruptPromptResult {
-    decision: InterruptDecision;
-    editedTask?: string;
-}
-export interface InterruptConfig {
-    interruptBefore: string[];
-    confidenceThreshold?: number;
-    autoApprove?: boolean;
-}
-export declare class InterruptRegistry {
-    private config;
-    load(config: InterruptConfig): void;
-    shouldInterrupt(agentSlug: string, confidence?: number): boolean;
-    getConfig(): InterruptConfig;
-}
-export declare const interruptRegistry: InterruptRegistry;
-export declare class InterruptController {
-    prompt(agentSlug: string, taskDescription: string, checkpointId: string): Promise<InterruptPromptResult>;
-}
-export declare const interruptController: InterruptController;
-//# sourceMappingURL=interrupt.d.ts.map

package/packages/@monomind/cli/dist/src/interactive/interrupt.js

@@ -1,71 +0,0 @@
-import * as readline from 'node:readline';
-export class InterruptRegistry {
-    config = { interruptBefore: [] };
-    load(config) {
-        this.config = config;
-    }
-    shouldInterrupt(agentSlug, confidence) {
-        if (this.config.autoApprove)
-            return false;
-        if (this.config.interruptBefore.includes(agentSlug))
-            return true;
-        if (confidence !== undefined &&
-            this.config.confidenceThreshold !== undefined &&
-            confidence < this.config.confidenceThreshold) {
-            return true;
-        }
-        return false;
-    }
-    getConfig() {
-        return { ...this.config };
-    }
-}
-export const interruptRegistry = new InterruptRegistry();
-export class InterruptController {
-    async prompt(agentSlug, taskDescription, checkpointId) {
-        // Non-TTY / CI mode
-        if (!process.stdin.isTTY || process.env.CI_AUTO_APPROVE === '1') {
-            return { decision: 'approved' };
-        }
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        // Strip control characters from interpolated fields. ANSI escape sequences
-        // in any of these fields would let a malicious agent or LLM-generated task
-        // description redraw the screen and trick the user into approving an
-        // entirely different action than the one shown — defeating this very gate.
-        const safe = (s) => String(s ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, '?').slice(0, 500);
-        console.log('\n' + '='.repeat(60));
-        console.log('[MONOMIND] Interrupt — Human approval required');
-        console.log(`  Agent:      ${safe(agentSlug)}`);
-        console.log(`  Task:       ${safe(taskDescription)}`);
-        console.log(`  Checkpoint: ${safe(checkpointId)}`);
-        console.log('='.repeat(60));
-        console.log('  Options: [y] approve  [n] reject  [e] edit task');
-        return new Promise((resolve) => {
-            rl.question('  Choice (y/n/e): ', (answer) => {
-                rl.close();
-                const trimmed = answer.trim().toLowerCase();
-                if (trimmed === 'y' || trimmed === 'yes') {
-                    resolve({ decision: 'approved' });
-                }
-                else if (trimmed === 'e' || trimmed === 'edit') {
-                    const rl2 = readline.createInterface({
-                        input: process.stdin,
-                        output: process.stdout,
-                    });
-                    rl2.question('  New task description: ', (newTask) => {
-                        rl2.close();
-                        resolve({ decision: 'edited', editedTask: newTask });
-                    });
-                }
-                else {
-                    resolve({ decision: 'rejected' });
-                }
-            });
-        });
-    }
-}
-export const interruptController = new InterruptController();
-//# sourceMappingURL=interrupt.js.map

package/packages/@monomind/cli/dist/src/mcp/deprecation-injector.d.ts

@@ -1,25 +0,0 @@
-/**
- * Deprecation Injector (Task 31)
- *
- * Injects deprecation warnings into MCP tool responses when the
- * invoked tool has been marked as deprecated in the ToolRegistry.
- */
-import type { ToolRegistry } from './tool-registry.js';
-/**
- * Injects deprecation metadata into MCP responses.
- */
-export declare class DeprecationInjector {
-    private readonly registry;
-    constructor(registry: ToolRegistry);
-    /**
-     * If `toolName` is deprecated, augment the response with a warning.
-     *
-     * Returns the original response unmodified when the tool is not
-     * deprecated. When deprecated, adds `_deprecation` metadata.
-     *
-     * Warning format:
-     *   [DEPRECATED] Tool "<name>" is deprecated. <message>. Use "<successor>" instead.
-     */
-    inject(response: Record<string, unknown>, toolName: string): Record<string, unknown>;
-}
-//# sourceMappingURL=deprecation-injector.d.ts.map

package/packages/@monomind/cli/dist/src/mcp/deprecation-injector.js

@@ -1,48 +0,0 @@
-/**
- * Deprecation Injector (Task 31)
- *
- * Injects deprecation warnings into MCP tool responses when the
- * invoked tool has been marked as deprecated in the ToolRegistry.
- */
-/**
- * Injects deprecation metadata into MCP responses.
- */
-export class DeprecationInjector {
-    registry;
-    constructor(registry) {
-        this.registry = registry;
-    }
-    /**
-     * If `toolName` is deprecated, augment the response with a warning.
-     *
-     * Returns the original response unmodified when the tool is not
-     * deprecated. When deprecated, adds `_deprecation` metadata.
-     *
-     * Warning format:
-     *   [DEPRECATED] Tool "<name>" is deprecated. <message>. Use "<successor>" instead.
-     */
-    inject(response, toolName) {
-        const tool = this.registry.getVersion(toolName);
-        if (!tool || !tool.deprecated) {
-            return response;
-        }
-        const parts = [`[DEPRECATED] Tool "${toolName}" is deprecated.`];
-        if (tool.deprecationMessage) {
-            parts.push(tool.deprecationMessage + '.');
-        }
-        if (tool.successor) {
-            parts.push(`Use "${tool.successor}" instead.`);
-        }
-        const warning = parts.join(' ');
-        return {
-            ...response,
-            _deprecation: {
-                warning,
-                deprecated: true,
-                successor: tool.successor ?? null,
-                deprecatedAt: tool.deprecatedAt ?? null,
-            },
-        };
-    }
-}
-//# sourceMappingURL=deprecation-injector.js.map