monomind 1.5.7 → 1.6.0

package/packages/@monomind/cli/dist/src/autopilot-state.js

@@ -0,0 +1,279 @@
+/**
+ * Autopilot Shared State Module
+ *
+ * Centralizes state management, validation, and task discovery
+ * for both CLI command and MCP tools. Eliminates code duplication.
+ *
+ * ADR-072: Autopilot Integration
+ * Security: Addresses prototype pollution, NaN bypass, input validation
+ */
+// ── Constants ─────────────────────────────────────────────────
+export const STATE_DIR = '.monomind/data';
+export const STATE_FILE = `${STATE_DIR}/autopilot-state.json`;
+export const LOG_FILE = `${STATE_DIR}/autopilot-log.json`;
+/** Maximum entries kept in state.history (prevents unbounded growth) */
+const MAX_HISTORY_ENTRIES = 50;
+/** Maximum entries kept in the event log */
+const MAX_LOG_ENTRIES = 1000;
+/** Allowlist for valid task sources */
+export const VALID_TASK_SOURCES = new Set(['team-tasks', 'swarm-tasks', 'file-checklist']);
+/** Terminal task statuses */
+export const TERMINAL_STATUSES = new Set(['completed', 'done', 'cancelled', 'skipped', 'failed']);
+// ── Validation Helpers ────────────────────────────────────────
+/**
+ * Sanitize a parsed JSON object to prevent prototype pollution.
+ * Removes __proto__, constructor, and prototype keys recursively.
+ */
+function sanitizeObject(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(sanitizeObject);
+    const clean = {};
+    for (const key of Object.keys(obj)) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            continue;
+        clean[key] = sanitizeObject(obj[key]);
+    }
+    return clean;
+}
+/**
+ * Safe JSON.parse that prevents prototype pollution.
+ */
+export function safeJsonParse(raw) {
+    return sanitizeObject(JSON.parse(raw));
+}
+/**
+ * Validate and coerce a numeric parameter. Returns the default if
+ * the input is NaN, undefined, or outside the allowed range.
+ */
+export function validateNumber(value, min, max, defaultValue) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return defaultValue;
+    return Math.min(Math.max(min, Math.round(num)), max);
+}
+/**
+ * Validate task sources against the allowlist.
+ * Returns only valid sources; falls back to defaults if none are valid.
+ */
+export function validateTaskSources(sources) {
+    const defaults = ['team-tasks', 'swarm-tasks', 'file-checklist'];
+    if (!Array.isArray(sources))
+        return defaults;
+    const valid = sources
+        .filter((s) => typeof s === 'string')
+        .map(s => s.trim())
+        .filter(s => VALID_TASK_SOURCES.has(s));
+    return valid.length > 0 ? valid : defaults;
+}
+// ── State Management ──────────────────────────────────────────
+export function getDefaultState() {
+    const crypto = require('crypto');
+    return {
+        sessionId: crypto.randomUUID(),
+        enabled: false,
+        startTime: Date.now(),
+        iterations: 0,
+        maxIterations: 50,
+        timeoutMinutes: 240,
+        taskSources: ['team-tasks', 'swarm-tasks', 'file-checklist'],
+        lastCheck: null,
+        history: [],
+    };
+}
+export function loadState() {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.resolve(STATE_FILE);
+    const defaults = getDefaultState();
+    try {
+        if (fs.existsSync(filePath)) {
+            const raw = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
+            const merged = { ...defaults, ...raw };
+            // Re-validate fields that could be tampered with
+            merged.maxIterations = validateNumber(merged.maxIterations, 1, 1000, 50);
+            merged.timeoutMinutes = validateNumber(merged.timeoutMinutes, 1, 1440, 240);
+            merged.iterations = validateNumber(merged.iterations, 0, 1000, 0);
+            merged.taskSources = validateTaskSources(merged.taskSources);
+            // Cap history to prevent unbounded growth
+            if (Array.isArray(merged.history) && merged.history.length > MAX_HISTORY_ENTRIES) {
+                merged.history = merged.history.slice(-MAX_HISTORY_ENTRIES);
+            }
+            return merged;
+        }
+    }
+    catch {
+        // Corrupted state file — return defaults
+    }
+    return defaults;
+}
+export function saveState(state) {
+    const fs = require('fs');
+    const path = require('path');
+    const dir = path.resolve(STATE_DIR);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    // Cap history before saving
+    if (state.history.length > MAX_HISTORY_ENTRIES) {
+        state.history = state.history.slice(-MAX_HISTORY_ENTRIES);
+    }
+    const tmpFile = path.resolve(STATE_FILE) + '.tmp';
+    fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2));
+    fs.renameSync(tmpFile, path.resolve(STATE_FILE));
+}
+export function appendLog(entry) {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.resolve(LOG_FILE);
+    const dir = path.resolve(STATE_DIR);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    let log = [];
+    try {
+        if (fs.existsSync(filePath)) {
+            log = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
+            if (!Array.isArray(log))
+                log = [];
+        }
+    }
+    catch {
+        log = [];
+    }
+    log.push(entry);
+    if (log.length > MAX_LOG_ENTRIES)
+        log = log.slice(-MAX_LOG_ENTRIES);
+    const tmpFile = filePath + '.tmp';
+    fs.writeFileSync(tmpFile, JSON.stringify(log, null, 2));
+    fs.renameSync(tmpFile, filePath);
+}
+export function loadLog() {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.resolve(LOG_FILE);
+    try {
+        if (fs.existsSync(filePath)) {
+            const result = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
+            return Array.isArray(result) ? result : [];
+        }
+    }
+    catch {
+        // Corrupted log — return empty
+    }
+    return [];
+}
+// ── Task Discovery ────────────────────────────────────────────
+export function discoverTasks(sources) {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    const tasks = [];
+    // Only process valid sources
+    const validSources = sources.filter(s => VALID_TASK_SOURCES.has(s));
+    for (const source of validSources) {
+        if (source === 'team-tasks') {
+            const tasksDir = path.join(os.homedir(), '.claude', 'tasks');
+            try {
+                if (fs.existsSync(tasksDir)) {
+                    const teams = fs.readdirSync(tasksDir, { withFileTypes: true });
+                    for (const team of teams) {
+                        if (!team.isDirectory())
+                            continue;
+                        const teamDir = path.join(tasksDir, team.name);
+                        const files = fs.readdirSync(teamDir).filter((f) => f.endsWith('.json'));
+                        for (const file of files) {
+                            try {
+                                const data = safeJsonParse(fs.readFileSync(path.join(teamDir, file), 'utf-8'));
+                                tasks.push({
+                                    id: String(data.id || file.replace('.json', '')),
+                                    subject: String(data.subject || data.title || file),
+                                    status: String(data.status || 'unknown'),
+                                    source: 'team-tasks',
+                                });
+                            }
+                            catch { /* skip individual file */ }
+                        }
+                    }
+                }
+            }
+            catch { /* skip source */ }
+        }
+        if (source === 'swarm-tasks') {
+            const swarmFile = path.resolve('.monomind/swarm-tasks.json');
+            try {
+                if (fs.existsSync(swarmFile)) {
+                    const data = safeJsonParse(fs.readFileSync(swarmFile, 'utf-8'));
+                    const swarmTasks = Array.isArray(data) ? data : (data.tasks || []);
+                    for (const t of swarmTasks) {
+                        if (t && typeof t === 'object') {
+                            const task = t;
+                            tasks.push({
+                                id: String(task.id || task.taskId || `swarm-${tasks.length}`),
+                                subject: String(task.subject || task.description || task.name || 'Unnamed task'),
+                                status: String(task.status || 'unknown'),
+                                source: 'swarm-tasks',
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* skip source */ }
+        }
+        if (source === 'file-checklist') {
+            const checklistFile = path.resolve('.monomind/data/checklist.json');
+            try {
+                if (fs.existsSync(checklistFile)) {
+                    const data = safeJsonParse(fs.readFileSync(checklistFile, 'utf-8'));
+                    const items = Array.isArray(data) ? data : (data.items || []);
+                    for (const item of items) {
+                        if (item && typeof item === 'object') {
+                            const i = item;
+                            tasks.push({
+                                id: String(i.id || `check-${tasks.length}`),
+                                subject: String(i.subject || i.text || i.description || 'Unnamed item'),
+                                status: String(i.status || (i.done ? 'completed' : 'pending')),
+                                source: 'file-checklist',
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* skip source */ }
+        }
+    }
+    return tasks;
+}
+// ── Progress Helpers ──────────────────────────────────────────
+export function isTerminal(status) {
+    return TERMINAL_STATUSES.has(status.toLowerCase());
+}
+export function getProgress(tasks) {
+    const completed = tasks.filter(t => isTerminal(t.status)).length;
+    const total = tasks.length;
+    const percent = total === 0 ? 100 : Math.round((completed / total) * 100);
+    const incomplete = tasks.filter(t => !isTerminal(t.status));
+    return { completed, total, percent, incomplete };
+}
+// ── Reward Calculation ────────────────────────────────────────
+export function calculateReward(iterations, durationMs) {
+    const iterFactor = (1 - iterations / (iterations + 10)) * 0.6;
+    const timeFactor = (1 - Math.min(durationMs / 3600000, 1)) * 0.4;
+    return Math.round((iterFactor + timeFactor) * 100) / 100;
+}
+// ── Learning Integration ──────────────────────────────────────
+export async function tryLoadLearning() {
+    try {
+        const modPath = 'agentic-flow/dist/coordination/autopilot-learning.js';
+        const mod = await import(/* webpackIgnore: true */ modPath).catch(() => null);
+        if (mod?.AutopilotLearning) {
+            const instance = new mod.AutopilotLearning();
+            if (await instance.initialize())
+                return instance;
+        }
+    }
+    catch { /* not available */ }
+    return null;
+}
+//# sourceMappingURL=autopilot-state.js.map

package/packages/@monomind/cli/dist/src/benchmarks/benchmark-runner.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Benchmark Runner for Regression Testing (Task 34)
+ * Loads benchmark definitions, evaluates quality metrics, and detects regressions.
+ */
+import type { BenchmarkDefinition, BenchmarkResult, BenchmarkBaseline, QualityMetric, MetricResult } from '@monoes/shared';
+export declare class BenchmarkRunner {
+    private baselines;
+    /**
+     * Load benchmark definitions from JSON files in a directory.
+     * Each JSON file should contain a single BenchmarkDefinition or an array of them.
+     */
+    loadBenchmarks(dir: string): BenchmarkDefinition[];
+    /**
+     * Evaluate quality metrics against an output string.
+     */
+    evaluateMetrics(output: string, metrics: QualityMetric[]): MetricResult[];
+    /**
+     * Run a single benchmark against provided agent output.
+     */
+    runBenchmark(def: BenchmarkDefinition, agentOutput: string): BenchmarkResult;
+    /**
+     * Pin current results as the baseline for a benchmark.
+     */
+    pinBaseline(benchmarkId: string, results: BenchmarkResult[]): BenchmarkBaseline;
+    /**
+     * Detect regression by comparing current results against a baseline.
+     * Returns true if the current pass rate is strictly below the baseline pass rate.
+     */
+    detectRegression(current: BenchmarkResult[], baseline: BenchmarkBaseline): boolean;
+    /**
+     * Get a stored baseline by benchmark ID.
+     */
+    getBaseline(benchmarkId: string): BenchmarkBaseline | undefined;
+    private evaluateSingleMetric;
+}
+/** Minimal local type aliases so SwarmBench doesn't depend on the broken
+ *  @monoes/shared exports at the top of this file. */
+export interface SwarmBenchTask {
+    /** Unique task ID */
+    id: string;
+    /** One of the 5 SwarmBench coordination categories */
+    type: 'pursuit' | 'synchronization' | 'foraging' | 'flocking' | 'transport';
+    /** Human-readable description */
+    description: string;
+    /** Number of agents participating */
+    agentCount: number;
+    /** Steps / budget allowed */
+    stepBudget: number;
+    /** Success criterion function */
+    evaluate: (agentOutputs: string[]) => SwarmBenchResult;
+}
+export interface SwarmBenchResult {
+    taskId: string;
+    type: SwarmBenchTask['type'];
+    passed: boolean;
+    score: number;
+    stepsTaken: number;
+    agentCount: number;
+    details: string;
+}
+export declare const SWARM_BENCH_TASKS: readonly SwarmBenchTask[];
+/**
+ * SwarmBenchRunner — runs the 5 SwarmBench coordination task types.
+ * Wraps BenchmarkRunner for regression baseline tracking.
+ *
+ * Source: https://arxiv.org/abs/2505.04364
+ */
+export declare class SwarmBenchRunner {
+    private readonly inner;
+    private baselines;
+    /** Run all (or a subset of) SwarmBench tasks against simulated agent outputs. */
+    runAll(agentOutputsByTask: Map<string, string[]>): SwarmBenchResult[];
+    /** Run a single task type by id. */
+    runTask(taskId: string, agentOutputs: string[]): SwarmBenchResult | undefined;
+    /** Pin current results as the regression baseline. */
+    pinBaseline(results: SwarmBenchResult[]): void;
+    /** Detect regression: returns task IDs whose score dropped below baseline. */
+    detectRegressions(current: SwarmBenchResult[]): string[];
+    /** Expose underlying BenchmarkRunner for general benchmarks. */
+    get benchmarkRunner(): BenchmarkRunner;
+}
+//# sourceMappingURL=benchmark-runner.d.ts.map

package/packages/@monomind/cli/dist/src/benchmarks/benchmark-runner.js

@@ -0,0 +1,261 @@
+/**
+ * Benchmark Runner for Regression Testing (Task 34)
+ * Loads benchmark definitions, evaluates quality metrics, and detects regressions.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import { containsExpected, lengthRange, noHallucination, jsonValid, customRegex, } from './metric-evaluators.js';
+export class BenchmarkRunner {
+    baselines = new Map();
+    /**
+     * Load benchmark definitions from JSON files in a directory.
+     * Each JSON file should contain a single BenchmarkDefinition or an array of them.
+     */
+    loadBenchmarks(dir) {
+        const benchmarks = [];
+        if (!fs.existsSync(dir)) {
+            return benchmarks;
+        }
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.json'));
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                benchmarks.push(...parsed);
+            }
+            else {
+                benchmarks.push(parsed);
+            }
+        }
+        return benchmarks;
+    }
+    /**
+     * Evaluate quality metrics against an output string.
+     */
+    evaluateMetrics(output, metrics) {
+        return metrics.map((metric) => this.evaluateSingleMetric(output, metric));
+    }
+    /**
+     * Run a single benchmark against provided agent output.
+     */
+    runBenchmark(def, agentOutput) {
+        const startTime = Date.now();
+        const metricResults = this.evaluateMetrics(agentOutput, def.qualityMetrics);
+        const durationMs = Date.now() - startTime;
+        const passed = metricResults.every((r) => r.passed);
+        return {
+            benchmarkId: def.benchmarkId,
+            runId: randomUUID(),
+            agentSlug: def.agentSlug,
+            passed,
+            metricResults,
+            runAt: new Date().toISOString(),
+            durationMs,
+        };
+    }
+    /**
+     * Pin current results as the baseline for a benchmark.
+     */
+    pinBaseline(benchmarkId, results) {
+        const relevantResults = results.filter((r) => r.benchmarkId === benchmarkId);
+        if (relevantResults.length === 0) {
+            const baseline = {
+                pinnedAt: new Date().toISOString(),
+                passRate: 0,
+                avgDurationMs: 0,
+            };
+            this.baselines.set(benchmarkId, baseline);
+            return baseline;
+        }
+        const passCount = relevantResults.filter((r) => r.passed).length;
+        const passRate = passCount / relevantResults.length;
+        const avgDurationMs = relevantResults.reduce((sum, r) => sum + r.durationMs, 0) /
+            relevantResults.length;
+        const baseline = {
+            pinnedAt: new Date().toISOString(),
+            passRate,
+            avgDurationMs,
+        };
+        this.baselines.set(benchmarkId, baseline);
+        return baseline;
+    }
+    /**
+     * Detect regression by comparing current results against a baseline.
+     * Returns true if the current pass rate is strictly below the baseline pass rate.
+     */
+    detectRegression(current, baseline) {
+        if (current.length === 0) {
+            return false;
+        }
+        const passCount = current.filter((r) => r.passed).length;
+        const currentPassRate = passCount / current.length;
+        return currentPassRate < baseline.passRate;
+    }
+    /**
+     * Get a stored baseline by benchmark ID.
+     */
+    getBaseline(benchmarkId) {
+        return this.baselines.get(benchmarkId);
+    }
+    // ------------------------------------------------------------------
+    // Private helpers
+    // ------------------------------------------------------------------
+    evaluateSingleMetric(output, metric) {
+        switch (metric.type) {
+            case 'contains_expected':
+                return containsExpected(output, metric.config);
+            case 'length_range':
+                return lengthRange(output, metric.config);
+            case 'no_hallucination':
+                return noHallucination(output, metric.config);
+            case 'json_valid':
+                return jsonValid(output);
+            case 'custom_regex':
+                return customRegex(output, metric.config);
+            default:
+                return {
+                    type: metric.type,
+                    passed: false,
+                    actual: null,
+                    expected: null,
+                    message: `Unknown metric type: ${metric.type}`,
+                };
+        }
+    }
+}
+// ------------------------------------------------------------------
+// Default benchmark suite (5 coordination task types)
+// ------------------------------------------------------------------
+/** Pursuit — agents must collectively report a common target string. */
+const pursuitTask = {
+    id: 'swarm-pursuit-01',
+    type: 'pursuit',
+    description: 'All agents converge on and name the same moving target within the step budget',
+    agentCount: 4,
+    stepBudget: 10,
+    evaluate(agentOutputs) {
+        const target = 'TARGET_FOUND';
+        const hits = agentOutputs.filter(o => o.includes(target)).length;
+        const score = agentOutputs.length > 0 ? hits / agentOutputs.length : 0;
+        return { taskId: this.id, type: this.type, passed: score >= 0.75, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `${hits}/${agentOutputs.length} agents converged` };
+    },
+};
+/** Synchronization — all agents must emit the same token at the same logical step. */
+const synchronizationTask = {
+    id: 'swarm-sync-01',
+    type: 'synchronization',
+    description: 'Agents reach consensus on a shared value simultaneously without direct communication',
+    agentCount: 6,
+    stepBudget: 5,
+    evaluate(agentOutputs) {
+        if (agentOutputs.length === 0)
+            return { taskId: this.id, type: this.type, passed: false, score: 0, stepsTaken: 0, agentCount: 0, details: 'no outputs' };
+        const counts = new Map();
+        for (const o of agentOutputs) {
+            const tok = o.trim().split(/\s+/)[0] ?? '';
+            counts.set(tok, (counts.get(tok) ?? 0) + 1);
+        }
+        const maxAgree = Math.max(...counts.values());
+        const score = maxAgree / agentOutputs.length;
+        return { taskId: this.id, type: this.type, passed: score >= 0.8, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `majority agreement: ${(score * 100).toFixed(0)}%` };
+    },
+};
+/** Foraging — agents must collectively mention ≥ N distinct resources. */
+const foragingTask = {
+    id: 'swarm-forage-01',
+    type: 'foraging',
+    description: 'Agents distribute to discover and collect distinct resources from the environment',
+    agentCount: 5,
+    stepBudget: 15,
+    evaluate(agentOutputs) {
+        const resourcePattern = /RESOURCE_[A-Z]+/g;
+        const found = new Set();
+        for (const o of agentOutputs) {
+            for (const m of o.matchAll(resourcePattern))
+                found.add(m[0]);
+        }
+        const goal = 4;
+        const score = Math.min(1, found.size / goal);
+        return { taskId: this.id, type: this.type, passed: found.size >= goal, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `${found.size}/${goal} resources found: ${[...found].join(', ')}` };
+    },
+};
+/** Flocking — each agent must maintain formation by referencing its neighbour. */
+const flockingTask = {
+    id: 'swarm-flock-01',
+    type: 'flocking',
+    description: 'Agents maintain cohesion and alignment while navigating toward a goal',
+    agentCount: 8,
+    stepBudget: 20,
+    evaluate(agentOutputs) {
+        const cohesionKeyword = 'NEIGHBOUR_OK';
+        const aligned = agentOutputs.filter(o => o.includes(cohesionKeyword)).length;
+        const score = agentOutputs.length > 0 ? aligned / agentOutputs.length : 0;
+        return { taskId: this.id, type: this.type, passed: score >= 0.7, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `${aligned}/${agentOutputs.length} in formation` };
+    },
+};
+/** Transport — item must appear in successive agent outputs showing relay progress. */
+const transportTask = {
+    id: 'swarm-transport-01',
+    type: 'transport',
+    description: 'Agents relay a payload across a chain; payload must appear in last agent output',
+    agentCount: 4,
+    stepBudget: 8,
+    evaluate(agentOutputs) {
+        const payload = 'PAYLOAD_DELIVERED';
+        const lastAgentDelivered = agentOutputs.length > 0 && agentOutputs[agentOutputs.length - 1].includes(payload);
+        const relayCount = agentOutputs.filter(o => o.includes('RELAY')).length;
+        const score = lastAgentDelivered ? 1 : relayCount / Math.max(agentOutputs.length, 1);
+        return { taskId: this.id, type: this.type, passed: lastAgentDelivered, score, stepsTaken: agentOutputs.length, agentCount: agentOutputs.length, details: lastAgentDelivered ? 'payload delivered' : `relay progress: ${relayCount}/${agentOutputs.length}` };
+    },
+};
+export const SWARM_BENCH_TASKS = [
+    pursuitTask,
+    synchronizationTask,
+    foragingTask,
+    flockingTask,
+    transportTask,
+];
+/**
+ * SwarmBenchRunner — runs the 5 SwarmBench coordination task types.
+ * Wraps BenchmarkRunner for regression baseline tracking.
+ *
+ * Source: https://arxiv.org/abs/2505.04364
+ */
+export class SwarmBenchRunner {
+    inner = new BenchmarkRunner();
+    baselines = new Map();
+    /** Run all (or a subset of) SwarmBench tasks against simulated agent outputs. */
+    runAll(agentOutputsByTask) {
+        return SWARM_BENCH_TASKS.map(task => {
+            const outputs = agentOutputsByTask.get(task.id) ?? [];
+            return task.evaluate(outputs);
+        });
+    }
+    /** Run a single task type by id. */
+    runTask(taskId, agentOutputs) {
+        const task = SWARM_BENCH_TASKS.find(t => t.id === taskId);
+        return task?.evaluate(agentOutputs);
+    }
+    /** Pin current results as the regression baseline. */
+    pinBaseline(results) {
+        for (const r of results) {
+            this.baselines.set(r.taskId, r);
+        }
+    }
+    /** Detect regression: returns task IDs whose score dropped below baseline. */
+    detectRegressions(current) {
+        return current
+            .filter(r => {
+            const baseline = this.baselines.get(r.taskId);
+            return baseline !== undefined && r.score < baseline.score;
+        })
+            .map(r => r.taskId);
+    }
+    /** Expose underlying BenchmarkRunner for general benchmarks. */
+    get benchmarkRunner() {
+        return this.inner;
+    }
+}
+//# sourceMappingURL=benchmark-runner.js.map

package/packages/@monomind/cli/dist/src/benchmarks/metric-evaluators.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Metric Evaluators for Benchmark Runner (Task 34)
+ * Individual metric evaluation functions for quality assessment.
+ */
+import type { MetricResult } from '@monoes/shared';
+/**
+ * Checks whether the output contains the expected substring.
+ */
+export declare function containsExpected(output: string, config: {
+    expected: string;
+}): MetricResult;
+/**
+ * Checks whether the output length falls within the specified range.
+ */
+export declare function lengthRange(output: string, config: {
+    min: number;
+    max: number;
+}): MetricResult;
+/**
+ * Checks that the output does not contain any forbidden words (hallucination markers).
+ */
+export declare function noHallucination(output: string, config: {
+    forbidden: string[];
+}): MetricResult;
+/**
+ * Checks whether the output is valid JSON.
+ */
+export declare function jsonValid(output: string): MetricResult;
+/**
+ * Checks whether the output matches a custom regex pattern.
+ */
+export declare function customRegex(output: string, config: {
+    pattern: string;
+}): MetricResult;
+//# sourceMappingURL=metric-evaluators.d.ts.map