monomind 1.11.12 → 1.11.13

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

@@ -1,212 +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 { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, statSync } from 'fs';
-import { randomBytes } from 'crypto';
-import { dirname } from 'path';
-import { calculateDecayFactor } from './score-decay.js';
-import { parseJsonl } from '../utils/parse-jsonl.js';
-/** Key used to identify a unique agent+taskType pair in the JSONL store. */
-function scoreKey(agentSlug, taskType) {
-    return `${agentSlug}::${taskType}`;
-}
-/**
- * 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 class SpecializationScorer {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-        const dir = dirname(filePath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Persistence helpers
-    // ---------------------------------------------------------------------------
-    readAll() {
-        if (!existsSync(this.filePath)) {
-            return [];
-        }
-        // 10MB cap. readAll is on the routing hot path; without this cap a
-        // bloated scorer file (planted or grown via repeated recordOutcome calls
-        // with diverse agentSlug::taskType keys) crashes the CLI on every route.
-        const stat = statSync(this.filePath);
-        if (stat.size > 10 * 1024 * 1024) {
-            throw new Error('Scorer store exceeds 10MB; run compaction');
-        }
-        const raw = readFileSync(this.filePath, 'utf-8');
-        return parseJsonl(raw).filter((r) => r !== null && typeof r === 'object' && !Array.isArray(r) &&
-            Object.getPrototypeOf(r) === Object.prototype);
-    }
-    writeAll(records) {
-        const lines = records.map((r) => JSON.stringify(r));
-        // Unique tmp filename so concurrent recordOutcome calls don't collide.
-        const tmp = `${this.filePath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
-        writeFileSync(tmp, lines.join('\n') + '\n', 'utf-8');
-        renameSync(tmp, this.filePath);
-    }
-    // ---------------------------------------------------------------------------
-    // Public API
-    // ---------------------------------------------------------------------------
-    /**
-     * 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) {
-        const records = this.readAll();
-        const key = scoreKey(update.agentSlug, update.taskType);
-        let idx = records.findIndex((r) => scoreKey(r.agentSlug, r.taskType) === key);
-        const now = new Date().toISOString();
-        if (idx === -1) {
-            // Create new record
-            const score = {
-                agentSlug: update.agentSlug,
-                taskType: update.taskType,
-                successCount: update.success ? 1 : 0,
-                failureCount: update.success ? 0 : 1,
-                totalCount: 1,
-                successRate: update.success ? 1.0 : 0.0,
-                avgLatencyMs: update.latencyMs,
-                avgQualityScore: update.qualityScore ?? (update.success ? 1.0 : 0.0),
-                lastUpdated: now,
-                decayFactor: 1.0,
-                effectiveScore: update.success ? 1.0 : 0.0,
-            };
-            records.push(score);
-            this.writeAll(records);
-            return score;
-        }
-        // Update existing record
-        const existing = records[idx];
-        const newTotal = existing.totalCount + 1;
-        const newSuccess = existing.successCount + (update.success ? 1 : 0);
-        const newFailure = existing.failureCount + (update.success ? 0 : 1);
-        const newRate = newSuccess / newTotal;
-        // Running average for latency
-        const newAvgLatency = (existing.avgLatencyMs * existing.totalCount + update.latencyMs) /
-            newTotal;
-        // Running average for quality
-        const quality = update.qualityScore ?? (update.success ? 1.0 : 0.0);
-        const newAvgQuality = (existing.avgQualityScore * existing.totalCount + quality) / newTotal;
-        const decay = calculateDecayFactor(now);
-        const updated = {
-            agentSlug: update.agentSlug,
-            taskType: update.taskType,
-            successCount: newSuccess,
-            failureCount: newFailure,
-            totalCount: newTotal,
-            successRate: newRate,
-            avgLatencyMs: newAvgLatency,
-            avgQualityScore: newAvgQuality,
-            lastUpdated: now,
-            decayFactor: decay,
-            effectiveScore: newRate * decay,
-        };
-        records[idx] = updated;
-        this.writeAll(records);
-        return updated;
-    }
-    /**
-     * Get the score for a specific agent+taskType pair, or null if not found.
-     * Recalculates decay on read.
-     */
-    getScore(agentSlug, taskType) {
-        const records = this.readAll();
-        const key = scoreKey(agentSlug, taskType);
-        const record = records.find((r) => scoreKey(r.agentSlug, r.taskType) === key);
-        if (!record)
-            return null;
-        // Recalculate decay on read
-        const decay = calculateDecayFactor(record.lastUpdated);
-        return {
-            ...record,
-            decayFactor: decay,
-            effectiveScore: record.successRate * decay,
-        };
-    }
-    /**
-     * Get top N candidates for a task type from the given list of slugs,
-     * sorted by effectiveScore descending.
-     */
-    getTopCandidates(taskType, slugs, topN = 3) {
-        const scored = [];
-        for (const slug of slugs) {
-            const score = this.getScore(slug, taskType);
-            if (score) {
-                scored.push(score);
-            }
-        }
-        return scored
-            .sort((a, b) => b.effectiveScore - a.effectiveScore)
-            .slice(0, topN);
-    }
-    /**
-     * Return the best candidate slug for a task type.
-     * Falls back to the first candidate if no scores exist.
-     */
-    topCandidate(taskType, candidates) {
-        if (candidates.length === 0) {
-            throw new Error('candidates array must not be empty');
-        }
-        const top = this.getTopCandidates(taskType, candidates, 1);
-        if (top.length === 0) {
-            return candidates[0];
-        }
-        return top[0].agentSlug;
-    }
-    /**
-     * Get all scores for a given agent across all task types.
-     */
-    getAllScores(agentSlug) {
-        const records = this.readAll();
-        return records
-            .filter((r) => r.agentSlug === agentSlug)
-            .map((r) => {
-            const decay = calculateDecayFactor(r.lastUpdated);
-            return {
-                ...r,
-                decayFactor: decay,
-                effectiveScore: r.successRate * decay,
-            };
-        });
-    }
-    /**
-     * 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, taskType) {
-        const records = this.readAll();
-        const before = records.length;
-        const remaining = records.filter((r) => {
-            if (r.agentSlug !== agentSlug)
-                return true;
-            if (taskType !== undefined && r.taskType !== taskType)
-                return true;
-            return false;
-        });
-        const deleted = before - remaining.length;
-        if (deleted > 0) {
-            if (remaining.length === 0) {
-                writeFileSync(this.filePath, '', 'utf-8');
-            }
-            else {
-                this.writeAll(remaining);
-            }
-        }
-        return deleted;
-    }
-}
-//# sourceMappingURL=specialization-scorer.js.map

package/packages/@monomind/cli/dist/src/agents/termination-watcher.d.ts

@@ -1,30 +0,0 @@
-/**
- * Termination Watcher (Task 35)
- *
- * Monitors agent run state and checks termination conditions.
- * Persists termination events to JSONL.
- */
-import type { TerminationPolicy, TerminationEvent } from '../../../shared/src/types/termination.js';
-/** Live state of a running agent. */
-export interface AgentRunState {
-    agentId: string;
-    agentSlug: string;
-    swarmId?: string;
-    turnCount: number;
-    cumulativeCostUsd: number;
-    startedAt: Date;
-    consecutiveFailures: number;
-}
-/**
- * Check whether an agent should be terminated based on its current state,
- * last output, and the effective termination policy.
- *
- * Returns a `TerminationEvent` if a condition is met, or `null` if the
- * agent is still within bounds.
- */
-export declare function check(state: AgentRunState, lastOutput: string, policy?: Partial<TerminationPolicy>): TerminationEvent | null;
-/**
- * Persist a termination event to the JSONL log.
- */
-export declare function persistEvent(event: TerminationEvent, filePath?: string): void;
-//# sourceMappingURL=termination-watcher.d.ts.map

package/packages/@monomind/cli/dist/src/agents/termination-watcher.js

@@ -1,84 +0,0 @@
-/**
- * Termination Watcher (Task 35)
- *
- * Monitors agent run state and checks termination conditions.
- * Persists termination events to JSONL.
- */
-import { randomUUID } from 'crypto';
-import { existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { DEFAULT_TERMINATION_POLICY } from '../../../shared/src/types/termination.js';
-/** Reasons that trigger cascade halt (hard failures). */
-const CASCADE_REASONS = new Set([
-    'max_turns_exceeded',
-    'max_cost_exceeded',
-    'timeout',
-    'max_retries_exceeded',
-]);
-/**
- * Check whether an agent should be terminated based on its current state,
- * last output, and the effective termination policy.
- *
- * Returns a `TerminationEvent` if a condition is met, or `null` if the
- * agent is still within bounds.
- */
-export function check(state, lastOutput, policy) {
-    const effective = {
-        ...DEFAULT_TERMINATION_POLICY,
-        ...policy,
-    };
-    // 1. Max turns
-    if (state.turnCount >= effective.maxTurns) {
-        return buildEvent(state, 'max_turns_exceeded', state.turnCount);
-    }
-    // 2. Max cost
-    if (state.cumulativeCostUsd >= effective.maxCostUsd) {
-        return buildEvent(state, 'max_cost_exceeded', state.cumulativeCostUsd);
-    }
-    // 3. Timeout
-    const elapsed = Date.now() - state.startedAt.getTime();
-    if (elapsed >= effective.timeoutMs) {
-        return buildEvent(state, 'timeout', elapsed);
-    }
-    // 4. Stop phrases
-    for (const phrase of effective.stopOnPhrases) {
-        if (lastOutput.includes(phrase)) {
-            return buildEvent(state, 'stop_phrase_matched', phrase);
-        }
-    }
-    // 5. Max retries (consecutive failures)
-    if (state.consecutiveFailures >= effective.maxRetries) {
-        return buildEvent(state, 'max_retries_exceeded', state.consecutiveFailures);
-    }
-    return null;
-}
-function buildEvent(state, reason, triggeredValue) {
-    return {
-        eventId: randomUUID(),
-        agentId: state.agentId,
-        agentSlug: state.agentSlug,
-        reason,
-        triggeredValue,
-        swarmId: state.swarmId,
-        terminatedAt: new Date(),
-        cascadeHalt: CASCADE_REASONS.has(reason),
-    };
-}
-/**
- * Persist a termination event to the JSONL log.
- */
-export function persistEvent(event, filePath) {
-    const target = filePath ?? join(process.cwd(), 'data', 'termination-events.jsonl');
-    const dir = dirname(target);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    const serialized = {
-        ...event,
-        terminatedAt: event.terminatedAt instanceof Date
-            ? event.terminatedAt.toISOString()
-            : String(event.terminatedAt),
-    };
-    appendFileSync(target, JSON.stringify(serialized) + '\n', 'utf-8');
-}
-//# sourceMappingURL=termination-watcher.js.map

package/packages/@monomind/cli/dist/src/agents/trigger-index.d.ts

@@ -1,20 +0,0 @@
-/**
- * Trigger Index Persistence (Task 32)
- *
- * Handles saving and loading the TriggerIndex JSON file
- * at `.monomind/trigger-index.json` (or a custom path).
- */
-import type { TriggerIndex } from '../../../../@monoes/shared/src/types/trigger.js';
-/** Default path for the persisted trigger index. */
-export declare const DEFAULT_TRIGGER_INDEX_PATH = ".monomind/trigger-index.json";
-/**
- * Save a TriggerIndex to a JSON file.
- * Creates parent directories if they don't exist.
- */
-export declare function save(index: TriggerIndex, path?: string): void;
-/**
- * Load a TriggerIndex from a JSON file.
- * Throws if the file does not exist or contains invalid JSON.
- */
-export declare function load(path?: string): TriggerIndex;
-//# sourceMappingURL=trigger-index.d.ts.map

package/packages/@monomind/cli/dist/src/agents/trigger-index.js

@@ -1,38 +0,0 @@
-/**
- * Trigger Index Persistence (Task 32)
- *
- * Handles saving and loading the TriggerIndex JSON file
- * at `.monomind/trigger-index.json` (or a custom path).
- */
-import { readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-/** Default path for the persisted trigger index. */
-export const DEFAULT_TRIGGER_INDEX_PATH = '.monomind/trigger-index.json';
-/**
- * Save a TriggerIndex to a JSON file.
- * Creates parent directories if they don't exist.
- */
-export function save(index, path = DEFAULT_TRIGGER_INDEX_PATH) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(index, null, 2), 'utf-8');
-}
-/**
- * Load a TriggerIndex from a JSON file.
- * Throws if the file does not exist or contains invalid JSON.
- */
-export function load(path = DEFAULT_TRIGGER_INDEX_PATH) {
-    const raw = readFileSync(path, 'utf-8');
-    const parsed = JSON.parse(raw);
-    // Basic structural validation
-    if (!Array.isArray(parsed.patterns)) {
-        throw new Error(`Invalid trigger index: "patterns" must be an array`);
-    }
-    if (typeof parsed.builtAt !== 'string') {
-        throw new Error(`Invalid trigger index: "builtAt" must be a string`);
-    }
-    if (typeof parsed.totalAgentsScanned !== 'number') {
-        throw new Error(`Invalid trigger index: "totalAgentsScanned" must be a number`);
-    }
-    return parsed;
-}
-//# sourceMappingURL=trigger-index.js.map

package/packages/@monomind/cli/dist/src/agents/trigger-scanner.d.ts

@@ -1,64 +0,0 @@
-/**
- * Trigger Scanner (Task 32)
- *
- * Scans task descriptions against compiled trigger patterns
- * from agent frontmatter and returns matches.
- *
- * - Patterns are tested in descending priority order.
- * - A `takeover` match short-circuits: only that agent is returned.
- * - `inject` matches accumulate as additional candidates.
- * - Invalid regex patterns are silently skipped.
- */
-import type { TriggerPattern, TriggerMatch, TriggerIndex } from '../../../../@monomind/shared/src/types/trigger.js';
-export declare class TriggerScanner {
-    private compiled;
-    private patterns;
-    private totalAgentsScanned;
-    private buildingIndex;
-    constructor(patterns?: TriggerPattern[]);
-    /**
-     * Test all patterns against `taskDescription` and return matches.
-     *
-     * Patterns are tested in descending priority order.
-     * If a `takeover` pattern matches, scanning stops immediately
-     * and only that agent is returned.
-     */
-    scan(taskDescription: string): TriggerMatch[];
-    /**
-     * Build an index by scanning agent markdown files under `agentDir`.
-     *
-     * Reads each `.md` file, extracts YAML frontmatter, and looks for
-     * `triggers:` entries with `pattern`, `mode`, and optional `priority`.
-     */
-    buildIndex(agentDir: string, allowedRoot?: string): TriggerIndex;
-    private _buildIndex;
-    /** Add a pattern to the index at runtime. */
-    addPattern(pattern: TriggerPattern): void;
-    /**
-     * Remove a specific pattern for an agent.
-     * Returns `true` if the pattern was found and removed.
-     */
-    removePattern(agentSlug: string, pattern: string): boolean;
-    /** Return a snapshot of the current index. */
-    getIndex(): TriggerIndex;
-    /** Number of compiled patterns. */
-    get size(): number;
-    private compileAndAdd;
-    private sortByPriority;
-    /** Recursively collect `.md` files (symlinks skipped, visited inodes tracked). */
-    private collectMdFiles;
-    /** Derive slug from filename. */
-    private slugFromPath;
-    /**
-     * Extract trigger definitions from markdown frontmatter.
-     *
-     * Looks for a YAML block between `---` markers, then finds lines like:
-     *   - pattern: "\\b(auth|jwt)\\b"
-     *     mode: "inject"
-     *     priority: 10
-     */
-    private extractTriggers;
-    private finalizeTrigger;
-    private extractYamlValue;
-}
-//# sourceMappingURL=trigger-scanner.d.ts.map