monomind 1.11.12 → 1.11.13

package/packages/@monomind/cli/dist/src/agents/managed-agent.js

@@ -1,69 +0,0 @@
-import { randomBytes } from 'node:crypto';
-/**
- * Simulates spawn-and-await by creating a taskId, delegating to a runner function,
- * and applying timeout.
- */
-export async function spawnAndAwait(agentSlug, task, runner, options = {}) {
-    const { timeoutMs = 120_000 } = options;
-    const startedAt = Date.now();
-    const taskId = `managed-${Date.now().toString(36)}-${randomBytes(4).toString('hex')}`;
-    try {
-        let timeoutHandle;
-        const output = await Promise.race([
-            runner(agentSlug, taskId, task),
-            new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
-            }),
-        ]).finally(() => clearTimeout(timeoutHandle));
-        return {
-            agentSlug, taskId, output, status: 'success',
-            durationMs: Date.now() - startedAt,
-        };
-    }
-    catch (err) {
-        const isTimeout = String(err).includes('Timeout');
-        return {
-            agentSlug, taskId, output: '',
-            status: isTimeout ? 'timeout' : 'error',
-            durationMs: Date.now() - startedAt,
-            error: String(err),
-        };
-    }
-}
-export class ManagedAgent {
-    agentSlug;
-    runner;
-    options;
-    constructor(agentSlug, runner, options = {}) {
-        this.agentSlug = agentSlug;
-        this.runner = runner;
-        this.options = options;
-    }
-    async run(task) {
-        return spawnAndAwait(this.agentSlug, task, this.runner, this.options);
-    }
-    /** Generate an MCP-style tool descriptor for this agent */
-    toToolDescriptor() {
-        const toolName = `agent_${this.agentSlug.replace(/-/g, '_')}`;
-        return {
-            name: toolName,
-            description: `Delegate a task to the ${this.agentSlug} specialist agent`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    task: { type: 'string', description: 'Task description' },
-                    timeoutMs: { type: 'number', description: 'Timeout in ms (default 120000)' },
-                },
-                required: ['task'],
-            },
-        };
-    }
-    static create(agentSlug, runner, options) {
-        return new ManagedAgent(agentSlug, runner, options);
-    }
-}
-/** Run multiple agents in parallel */
-export async function runBatch(agents, runner, options = {}) {
-    return Promise.all(agents.map(({ agentSlug, task }) => spawnAndAwait(agentSlug, task, runner, options)));
-}
-//# sourceMappingURL=managed-agent.js.map

package/packages/@monomind/cli/dist/src/agents/prompt-experiment.d.ts

@@ -1,23 +0,0 @@
-/**
- * PromptExperimentRouter - A/B traffic splitting for prompt versions
- *
- * Checks for an active experiment on the given agent slug and probabilistically
- * routes to the candidate or control version. Falls back to the active version
- * when no experiment is running.
- *
- * @module @monomind/cli/agents/prompt-experiment
- */
-type PromptVersionStore = any;
-export interface ResolvedPrompt {
-    prompt: string;
-    version: string;
-    isCandidate: boolean;
-    agentSlug: string;
-}
-export declare class PromptExperimentRouter {
-    private readonly store;
-    constructor(store: PromptVersionStore);
-    resolvePromptForSpawn(agentSlug: string): ResolvedPrompt;
-}
-export {};
-//# sourceMappingURL=prompt-experiment.d.ts.map

package/packages/@monomind/cli/dist/src/agents/prompt-experiment.js

@@ -1,49 +0,0 @@
-/**
- * PromptExperimentRouter - A/B traffic splitting for prompt versions
- *
- * Checks for an active experiment on the given agent slug and probabilistically
- * routes to the candidate or control version. Falls back to the active version
- * when no experiment is running.
- *
- * @module @monomind/cli/agents/prompt-experiment
- */
-export class PromptExperimentRouter {
-    store;
-    constructor(store) {
-        this.store = store;
-    }
-    resolvePromptForSpawn(agentSlug) {
-        const experiment = this.store.getExperiment(agentSlug);
-        if (experiment) {
-            const useCandidate = Math.random() < experiment.trafficPct;
-            const targetVersion = useCandidate ? experiment.candidate : experiment.control;
-            const versions = this.store.listVersions(agentSlug);
-            const found = versions.find((v) => v.version === targetVersion);
-            if (found) {
-                return {
-                    prompt: found.prompt,
-                    version: found.version,
-                    isCandidate: useCandidate,
-                    agentSlug,
-                };
-            }
-        }
-        // Fallback to active version
-        const active = this.store.getActive(agentSlug);
-        if (active) {
-            return {
-                prompt: active.prompt,
-                version: active.version,
-                isCandidate: false,
-                agentSlug,
-            };
-        }
-        return {
-            prompt: '',
-            version: '',
-            isCandidate: false,
-            agentSlug,
-        };
-    }
-}
-//# sourceMappingURL=prompt-experiment.js.map

package/packages/@monomind/cli/dist/src/agents/prompt-version-manager.d.ts

@@ -1,22 +0,0 @@
-/**
- * PromptVersionManager - High-level prompt version lifecycle operations
- *
- * Provides publish-from-file, promote, rollback, and experiment
- * start/stop workflows on top of PromptVersionStore.
- *
- * @module @monomind/cli/agents/prompt-version-manager
- */
-type PromptVersionStore = any;
-type PromptVersion = any;
-type PromptExperiment = any;
-export declare class PromptVersionManager {
-    private readonly store;
-    constructor(store: PromptVersionStore);
-    publishFromFile(agentSlug: string, filePath: string, newVersion: string, changelog: string): PromptVersion;
-    promote(agentSlug: string, version: string): void;
-    rollback(agentSlug: string, stepsBack?: number): void;
-    startExperiment(experiment: PromptExperiment): void;
-    stopExperiment(agentSlug: string, promoteWinner?: boolean): void;
-}
-export {};
-//# sourceMappingURL=prompt-version-manager.d.ts.map

package/packages/@monomind/cli/dist/src/agents/prompt-version-manager.js

@@ -1,80 +0,0 @@
-/**
- * PromptVersionManager - High-level prompt version lifecycle operations
- *
- * Provides publish-from-file, promote, rollback, and experiment
- * start/stop workflows on top of PromptVersionStore.
- *
- * @module @monomind/cli/agents/prompt-version-manager
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-export class PromptVersionManager {
-    store;
-    constructor(store) {
-        this.store = store;
-    }
-    publishFromFile(agentSlug, filePath, newVersion, changelog) {
-        // Symlink-aware containment: path.resolve does NOT follow symlinks, so
-        // a symlink under cwd pointing at /etc/shadow would have passed the
-        // prefix-check below. Use realpathSync on both sides and reject symlinks
-        // at the leaf so the resolved file is provably inside the project.
-        const allowedRoot = fs.realpathSync(process.cwd());
-        const requested = path.resolve(filePath);
-        if (!fs.existsSync(requested)) {
-            throw new Error(`filePath does not exist: ${requested}`);
-        }
-        if (fs.lstatSync(requested).isSymbolicLink()) {
-            throw new Error('filePath must not be a symlink');
-        }
-        const resolved = fs.realpathSync(requested);
-        const rel = path.relative(allowedRoot, resolved);
-        if (rel.startsWith('..') || path.isAbsolute(rel)) {
-            throw new Error(`filePath must be inside the project directory: ${allowedRoot}`);
-        }
-        const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
-        const fileSize = fs.statSync(resolved).size;
-        if (fileSize > MAX_PROMPT_BYTES) {
-            throw new Error(`filePath exceeds maximum allowed size (${MAX_PROMPT_BYTES} bytes): ${resolved}`);
-        }
-        const prompt = fs.readFileSync(resolved, 'utf-8');
-        const version = {
-            agentSlug,
-            version: newVersion,
-            prompt,
-            changelog,
-            activeFrom: new Date(),
-            traceCount: 0,
-            publishedBy: 'prompt-version-manager',
-            createdAt: new Date(),
-        };
-        this.store.save(version);
-        return version;
-    }
-    promote(agentSlug, version) {
-        this.store.setActive(agentSlug, version);
-    }
-    rollback(agentSlug, stepsBack = 1) {
-        const versions = this.store.listVersions(agentSlug);
-        if (versions.length < stepsBack + 1) {
-            throw new Error(`Cannot rollback ${stepsBack} step(s): only ${versions.length} version(s) exist for "${agentSlug}"`);
-        }
-        // versions are sorted DESC by createdAt, so index 0 = newest
-        const target = versions[stepsBack];
-        this.store.setActive(agentSlug, target.version);
-    }
-    startExperiment(experiment) {
-        this.store.saveExperiment(experiment);
-    }
-    stopExperiment(agentSlug, promoteWinner) {
-        const experiment = this.store.getExperiment(agentSlug);
-        if (!experiment) {
-            throw new Error(`No active experiment for "${agentSlug}"`);
-        }
-        const winnerId = (experiment.winner ?? experiment.control);
-        this.store.concludeExperiment(agentSlug, winnerId);
-        if (promoteWinner) {
-            this.store.setActive(agentSlug, winnerId);
-        }
-    }
-}
-//# sourceMappingURL=prompt-version-manager.js.map

package/packages/@monomind/cli/dist/src/agents/registry-query.d.ts

@@ -1,71 +0,0 @@
-/**
- * Registry Query (Task 30)
- *
- * Provides query and validation utilities over an AgentRegistry.
- * Supports loading from an in-memory object or a JSON file on disk.
- */
-import type { AgentRegistry, AgentRegistryEntry } from '../../../shared/src/types/agent-registry.js';
-/** Validation issue found during registry validation. */
-export interface RegistryValidationResult {
-    slug: string;
-    field: string;
-    message: string;
-    severity: 'error' | 'warning';
-}
-/** Conflict entry for duplicate slug detection. */
-export interface RegistryConflict {
-    slug: string;
-    entries: AgentRegistryEntry[];
-}
-/**
- * Query engine for the Central Agent Registry.
- */
-export declare class RegistryQuery {
-    private agents;
-    private constructor();
-    /**
-     * Create a RegistryQuery from an in-memory AgentRegistry object.
-     */
-    static loadFromJSON(registry: AgentRegistry): RegistryQuery;
-    /**
-     * Create a RegistryQuery by reading a registry JSON file from disk.
-     */
-    static loadFromFile(path: string): RegistryQuery;
-    /**
-     * Find all agents that list the given capability.
-     */
-    findByCapability(capability: string): AgentRegistryEntry[];
-    /**
-     * Find all agents that handle the given task type.
-     */
-    findByTaskType(taskType: string): AgentRegistryEntry[];
-    /**
-     * Find an agent by its unique slug. Returns undefined if not found.
-     */
-    findBySlug(slug: string): AgentRegistryEntry | undefined;
-    /**
-     * Find all agents that list the given tool.
-     */
-    findByTool(tool: string): AgentRegistryEntry[];
-    /**
-     * Find micro-agents — agents that have at least one trigger pattern.
-     */
-    findMicroAgents(): AgentRegistryEntry[];
-    /**
-     * Return all agent slugs in the registry.
-     */
-    allSlugs(): string[];
-    /**
-     * Validate the registry, returning a list of validation issues.
-     * Checks:
-     * - version must be valid semver (X.Y.Z pattern)
-     * - slug must be non-empty
-     * - name must be non-empty
-     */
-    validate(): RegistryValidationResult[];
-    /**
-     * Detect duplicate slugs across registry entries.
-     */
-    conflicts(): RegistryConflict[];
-}
-//# sourceMappingURL=registry-query.d.ts.map

package/packages/@monomind/cli/dist/src/agents/registry-query.js

@@ -1,125 +0,0 @@
-/**
- * Registry Query (Task 30)
- *
- * Provides query and validation utilities over an AgentRegistry.
- * Supports loading from an in-memory object or a JSON file on disk.
- */
-import { readFileSync } from 'fs';
-/**
- * Query engine for the Central Agent Registry.
- */
-export class RegistryQuery {
-    agents;
-    constructor(agents) {
-        this.agents = agents;
-    }
-    /**
-     * Create a RegistryQuery from an in-memory AgentRegistry object.
-     */
-    static loadFromJSON(registry) {
-        return new RegistryQuery(registry.agents ?? []);
-    }
-    /**
-     * Create a RegistryQuery by reading a registry JSON file from disk.
-     */
-    static loadFromFile(path) {
-        const raw = readFileSync(path, 'utf-8');
-        const registry = JSON.parse(raw);
-        return RegistryQuery.loadFromJSON(registry);
-    }
-    /**
-     * Find all agents that list the given capability.
-     */
-    findByCapability(capability) {
-        return this.agents.filter((a) => a.capabilities.includes(capability));
-    }
-    /**
-     * Find all agents that handle the given task type.
-     */
-    findByTaskType(taskType) {
-        return this.agents.filter((a) => a.taskTypes.includes(taskType));
-    }
-    /**
-     * Find an agent by its unique slug. Returns undefined if not found.
-     */
-    findBySlug(slug) {
-        return this.agents.find((a) => a.slug === slug);
-    }
-    /**
-     * Find all agents that list the given tool.
-     */
-    findByTool(tool) {
-        return this.agents.filter((a) => a.tools.includes(tool));
-    }
-    /**
-     * Find micro-agents — agents that have at least one trigger pattern.
-     */
-    findMicroAgents() {
-        return this.agents.filter((a) => a.triggers.length > 0);
-    }
-    /**
-     * Return all agent slugs in the registry.
-     */
-    allSlugs() {
-        return this.agents.map((a) => a.slug);
-    }
-    /**
-     * Validate the registry, returning a list of validation issues.
-     * Checks:
-     * - version must be valid semver (X.Y.Z pattern)
-     * - slug must be non-empty
-     * - name must be non-empty
-     */
-    validate() {
-        const results = [];
-        const semverRe = /^\d+\.\d+\.\d+/;
-        for (const agent of this.agents) {
-            if (!agent.slug) {
-                results.push({ slug: agent.slug ?? '(empty)', field: 'slug', message: 'Slug is empty', severity: 'error' });
-            }
-            if (!agent.name) {
-                results.push({ slug: agent.slug, field: 'name', message: 'Name is empty', severity: 'error' });
-            }
-            if (!semverRe.test(agent.version)) {
-                results.push({
-                    slug: agent.slug,
-                    field: 'version',
-                    message: `Invalid semver: "${agent.version}"`,
-                    severity: 'error',
-                });
-            }
-            if (agent.deprecated && !agent.deprecatedBy) {
-                results.push({
-                    slug: agent.slug,
-                    field: 'deprecatedBy',
-                    message: 'Agent is deprecated but deprecatedBy is not set',
-                    severity: 'warning',
-                });
-            }
-        }
-        return results;
-    }
-    /**
-     * Detect duplicate slugs across registry entries.
-     */
-    conflicts() {
-        const map = new Map();
-        for (const agent of this.agents) {
-            const existing = map.get(agent.slug);
-            if (existing) {
-                existing.push(agent);
-            }
-            else {
-                map.set(agent.slug, [agent]);
-            }
-        }
-        const result = [];
-        for (const [slug, entries] of map) {
-            if (entries.length > 1) {
-                result.push({ slug, entries });
-            }
-        }
-        return result;
-    }
-}
-//# sourceMappingURL=registry-query.js.map

package/packages/@monomind/cli/dist/src/agents/score-decay.d.ts

@@ -1,19 +0,0 @@
-/**
- * Score Decay (Task 39)
- *
- * Time-based decay for agent specialization scores.
- * Scores from 90 days ago have 50% weight (half-life model).
- */
-/** Half-life in days: after this many days, score weight is halved. */
-export declare const SCORE_HALF_LIFE_DAYS = 90;
-/**
- * Calculate the decay factor for a score based on how old it is.
- *
- * decay(t) = 0.5^(days_since_update / 90)
- *
- * - Returns 1.0 for scores updated right now
- * - Returns ~0.5 for scores updated 90 days ago
- * - Returns ~0.25 for scores updated 180 days ago
- */
-export declare function calculateDecayFactor(lastUpdatedIso: string): number;
-//# sourceMappingURL=score-decay.d.ts.map

package/packages/@monomind/cli/dist/src/agents/score-decay.js

@@ -1,22 +0,0 @@
-/**
- * Score Decay (Task 39)
- *
- * Time-based decay for agent specialization scores.
- * Scores from 90 days ago have 50% weight (half-life model).
- */
-/** Half-life in days: after this many days, score weight is halved. */
-export const SCORE_HALF_LIFE_DAYS = 90;
-/**
- * Calculate the decay factor for a score based on how old it is.
- *
- * decay(t) = 0.5^(days_since_update / 90)
- *
- * - Returns 1.0 for scores updated right now
- * - Returns ~0.5 for scores updated 90 days ago
- * - Returns ~0.25 for scores updated 180 days ago
- */
-export function calculateDecayFactor(lastUpdatedIso) {
-    const daysSince = (Date.now() - new Date(lastUpdatedIso).getTime()) / 86_400_000;
-    return Math.pow(0.5, daysSince / SCORE_HALF_LIFE_DAYS);
-}
-//# sourceMappingURL=score-decay.js.map

package/packages/@monomind/cli/dist/src/agents/shared-instructions-loader.d.ts

@@ -1,13 +0,0 @@
-export declare class SharedInstructionsLoader {
-    private cache;
-    private filePath;
-    constructor(filePath?: string);
-    load(basePath?: string): string;
-    getSharedInstructions(basePath?: string): string;
-    reload(basePath?: string): string;
-    isLoaded(): boolean;
-    /** Prepend shared instructions to an agent prompt with separator */
-    prependToPrompt(agentPrompt: string, basePath?: string): string;
-}
-export declare const sharedInstructionsLoader: SharedInstructionsLoader;
-//# sourceMappingURL=shared-instructions-loader.d.ts.map

package/packages/@monomind/cli/dist/src/agents/shared-instructions-loader.js

@@ -1,40 +0,0 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-const DEFAULT_PATH = '.agents/shared_instructions.md';
-export class SharedInstructionsLoader {
-    cache = null;
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath ?? DEFAULT_PATH;
-    }
-    load(basePath) {
-        const fullPath = basePath ? resolve(basePath, this.filePath) : this.filePath;
-        if (!existsSync(fullPath)) {
-            this.cache = '';
-            return '';
-        }
-        this.cache = readFileSync(fullPath, 'utf-8');
-        return this.cache;
-    }
-    getSharedInstructions(basePath) {
-        if (this.cache !== null)
-            return this.cache;
-        return this.load(basePath);
-    }
-    reload(basePath) {
-        this.cache = null;
-        return this.load(basePath);
-    }
-    isLoaded() {
-        return this.cache !== null;
-    }
-    /** Prepend shared instructions to an agent prompt with separator */
-    prependToPrompt(agentPrompt, basePath) {
-        const shared = this.getSharedInstructions(basePath);
-        if (!shared)
-            return agentPrompt;
-        return `${shared}\n\n---\n\n${agentPrompt}`;
-    }
-}
-export const sharedInstructionsLoader = new SharedInstructionsLoader();
-//# sourceMappingURL=shared-instructions-loader.js.map

package/packages/@monomind/cli/dist/src/agents/specialization-scorer.d.ts

@@ -1,54 +0,0 @@
-/**
- * Agent Specialization Scorer (Task 39)
- *
- * JSONL-based per-agent-per-task-type scoring with time-decay.
- * Enables monomind to prefer historically successful agents for specific task types.
- */
-import type { SpecializationScore, ScoreUpdate } from '../../../shared/src/types/specialization.js';
-/**
- * JSONL-based specialization scorer.
- *
- * Stores one JSON object per line in the configured file path.
- * Each line represents a SpecializationScore for a unique agent+taskType pair.
- * On update, the entire file is rewritten to maintain a single record per pair.
- */
-export declare class SpecializationScorer {
-    private readonly filePath;
-    constructor(filePath: string);
-    private readAll;
-    private writeAll;
-    /**
-     * Record an outcome for a given agent+taskType pair.
-     *
-     * Updates running averages for latency and quality, recalculates
-     * successRate, applies time-decay, and persists the result.
-     */
-    recordOutcome(update: ScoreUpdate): SpecializationScore;
-    /**
-     * Get the score for a specific agent+taskType pair, or null if not found.
-     * Recalculates decay on read.
-     */
-    getScore(agentSlug: string, taskType: string): SpecializationScore | null;
-    /**
-     * Get top N candidates for a task type from the given list of slugs,
-     * sorted by effectiveScore descending.
-     */
-    getTopCandidates(taskType: string, slugs: string[], topN?: number): SpecializationScore[];
-    /**
-     * Return the best candidate slug for a task type.
-     * Falls back to the first candidate if no scores exist.
-     */
-    topCandidate(taskType: string, candidates: string[]): string;
-    /**
-     * Get all scores for a given agent across all task types.
-     */
-    getAllScores(agentSlug: string): SpecializationScore[];
-    /**
-     * Reset scores for an agent. If taskType is provided, only that
-     * pair is removed; otherwise all scores for the agent are removed.
-     *
-     * @returns The number of records deleted.
-     */
-    resetScores(agentSlug: string, taskType?: string): number;
-}
-//# sourceMappingURL=specialization-scorer.d.ts.map