monomind 1.11.12 → 1.11.13

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

@@ -1,93 +0,0 @@
-/**
- * PromptAssembler — collects context sections from multiple providers,
- * prioritises them within a token budget, and concatenates the result
- * with the base prompt.
- */
-const DEFAULT_MAX_TOTAL_TOKENS = 6000;
-const CHARS_PER_TOKEN = 4;
-const SECTION_SEPARATOR = '\n\n---\n\n';
-function estimateTokens(text) {
-    return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
-function truncateToTokens(text, maxTokens) {
-    const maxChars = maxTokens * CHARS_PER_TOKEN;
-    if (text.length <= maxChars) {
-        return text;
-    }
-    return text.slice(0, maxChars);
-}
-export class PromptAssembler {
-    maxTotalTokens;
-    basePromptTokens;
-    providers;
-    constructor(config) {
-        this.maxTotalTokens = config.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
-        this.basePromptTokens = config.basePromptTokens;
-        this.providers = config.providers;
-    }
-    async assemble(basePrompt, ctx) {
-        // 1. Call all providers concurrently
-        const settled = await Promise.allSettled(this.providers.map(async (p) => {
-            const content = await p.provide(ctx);
-            return {
-                name: p.name,
-                content,
-                tokens: estimateTokens(content),
-                priority: p.priority,
-                required: p.required,
-            };
-        }));
-        // 2. Filter out rejected / empty results
-        const sections = [];
-        for (const result of settled) {
-            if (result.status === 'fulfilled' && result.value.content.length > 0) {
-                sections.push(result.value);
-            }
-        }
-        // 3. Sort by priority descending
-        sections.sort((a, b) => b.priority - a.priority);
-        // 4. Fit within budget
-        const budget = this.maxTotalTokens - this.basePromptTokens;
-        let remaining = budget;
-        const included = [];
-        const truncated = [];
-        const dropped = [];
-        for (const section of sections) {
-            if (section.tokens <= remaining) {
-                // Fits entirely
-                included.push(section);
-                remaining -= section.tokens;
-            }
-            else if (section.required) {
-                // Required but exceeds remaining — truncate to fit
-                const truncatedContent = truncateToTokens(section.content, remaining);
-                included.push({
-                    ...section,
-                    content: truncatedContent,
-                    tokens: estimateTokens(truncatedContent),
-                });
-                truncated.push(section.name);
-                remaining -= estimateTokens(truncatedContent);
-            }
-            else {
-                // Optional and doesn't fit — drop
-                dropped.push(section.name);
-            }
-        }
-        // 5. Build final prompt: context sections first, then base prompt
-        const contextParts = included.map((s) => s.content);
-        const assembled = contextParts.length > 0
-            ? contextParts.join(SECTION_SEPARATOR) +
-                SECTION_SEPARATOR +
-                basePrompt
-            : basePrompt;
-        return {
-            content: assembled,
-            sectionsIncluded: included.map((s) => s.name),
-            sectionsTruncated: truncated,
-            sectionsDropped: dropped,
-            totalTokenEstimate: estimateTokens(assembled),
-        };
-    }
-}
-//# sourceMappingURL=prompt-assembler.js.map

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

@@ -1,24 +0,0 @@
-/**
- * TaskHistoryProvider — searches memory for previously completed tasks that
- * are similar to the current one and formats them as markdown context.
- */
-import { BaseContextProvider, type RunContext } from './context-provider.js';
-export interface SearchResult {
-    metadata: Record<string, unknown>;
-    value: string;
-    score: number;
-}
-export type SearchFn = (query: string, options: {
-    namespace: string;
-    limit: number;
-    minScore: number;
-}) => Promise<SearchResult[]>;
-export declare class TaskHistoryProvider extends BaseContextProvider {
-    private readonly search;
-    readonly name: "task-history";
-    readonly priority = 50;
-    readonly maxTokens = 600;
-    constructor(search: SearchFn);
-    provide(ctx: RunContext): Promise<string>;
-}
-//# sourceMappingURL=task-history-provider.d.ts.map

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

@@ -1,32 +0,0 @@
-/**
- * TaskHistoryProvider — searches memory for previously completed tasks that
- * are similar to the current one and formats them as markdown context.
- */
-import { BaseContextProvider } from './context-provider.js';
-export class TaskHistoryProvider extends BaseContextProvider {
-    search;
-    name = 'task-history';
-    priority = 50;
-    maxTokens = 600;
-    constructor(search) {
-        super();
-        this.search = search;
-    }
-    async provide(ctx) {
-        const results = await this.search(ctx.taskDescription, {
-            namespace: 'tasks',
-            limit: 5,
-            minScore: 0.6,
-        });
-        if (!results || results.length === 0) {
-            return '';
-        }
-        const lines = ['**Similar past tasks:**'];
-        for (const r of results) {
-            const label = r.metadata?.['title'] ?? r.value.slice(0, 80);
-            lines.push(`- (${(r.score * 100).toFixed(0)}%) ${label}`);
-        }
-        return this.truncateToTokens(lines.join('\n'), this.maxTokens);
-    }
-}
-//# sourceMappingURL=task-history-provider.js.map

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

@@ -1,14 +0,0 @@
-/**
- * UserPreferencesProvider — fetches user-level preferences for the active
- * session and formats them as a bullet list for injection into the prompt.
- */
-import { BaseContextProvider, type RunContext } from './context-provider.js';
-export type PreferencesGetter = (sessionId: string) => Promise<Record<string, string>>;
-export declare class UserPreferencesProvider extends BaseContextProvider {
-    private readonly getter;
-    readonly name: "user-preferences";
-    readonly priority = 90;
-    constructor(getter: PreferencesGetter);
-    provide(ctx: RunContext): Promise<string>;
-}
-//# sourceMappingURL=user-preferences-provider.d.ts.map

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

@@ -1,27 +0,0 @@
-/**
- * UserPreferencesProvider — fetches user-level preferences for the active
- * session and formats them as a bullet list for injection into the prompt.
- */
-import { BaseContextProvider } from './context-provider.js';
-export class UserPreferencesProvider extends BaseContextProvider {
-    getter;
-    name = 'user-preferences';
-    priority = 90;
-    constructor(getter) {
-        super();
-        this.getter = getter;
-    }
-    async provide(ctx) {
-        const prefs = await this.getter(ctx.sessionId);
-        const entries = Object.entries(prefs);
-        if (entries.length === 0) {
-            return '';
-        }
-        const lines = ['**User preferences:**'];
-        for (const [key, value] of entries) {
-            lines.push(`- ${key}: ${value}`);
-        }
-        return this.truncateToTokens(lines.join('\n'), this.maxTokens);
-    }
-}
-//# sourceMappingURL=user-preferences-provider.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-reader.d.ts

@@ -1,31 +0,0 @@
-/**
- * DLQ Reader (Task 37)
- *
- * Reads, filters, and purges DLQ entries from JSONL storage.
- */
-import type { DLQEntry, DLQEntryStatus } from '../../../shared/src/types/dlq.js';
-/** Options for listing DLQ entries */
-export interface DLQListOptions {
-    status?: DLQEntryStatus;
-    toolName?: string;
-    agentId?: string;
-    olderThanDays?: number;
-    limit?: number;
-}
-export declare class DLQReader {
-    private readonly filePath;
-    constructor(filePath: string);
-    /** Read all entries from the JSONL file with a hard size cap.
-     * The DLQ is append-only with no rotation — without this guard a long-running
-     * process can grow the file to GBs and OOM on every list/get/purge call. */
-    private readAll;
-    /** Write all entries back (used for purge) — uses unique tmp filename to avoid concurrent writer collisions */
-    private writeAll;
-    /** List entries with optional filters (defaults to status='pending') */
-    list(opts?: DLQListOptions): DLQEntry[];
-    /** Get a single entry by messageId */
-    get(messageId: string): DLQEntry | null;
-    /** Purge old pending entries (mark as 'purged') */
-    purge(olderThanDays: number): number;
-}
-//# sourceMappingURL=dlq-reader.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-reader.js

@@ -1,81 +0,0 @@
-/**
- * DLQ Reader (Task 37)
- *
- * Reads, filters, and purges DLQ entries from JSONL storage.
- */
-import { randomUUID } from 'crypto';
-import { existsSync, readFileSync, writeFileSync, renameSync, statSync, unlinkSync } from 'fs';
-import { parseJsonl } from '../utils/parse-jsonl.js';
-export class DLQReader {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    /** Read all entries from the JSONL file with a hard size cap.
-     * The DLQ is append-only with no rotation — without this guard a long-running
-     * process can grow the file to GBs and OOM on every list/get/purge call. */
-    readAll() {
-        if (!existsSync(this.filePath))
-            return [];
-        const stat = statSync(this.filePath);
-        if (stat.size > 256 * 1024 * 1024) {
-            throw new Error(`DLQ file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
-        }
-        const raw = readFileSync(this.filePath, 'utf-8');
-        return parseJsonl(raw);
-    }
-    /** Write all entries back (used for purge) — uses unique tmp filename to avoid concurrent writer collisions */
-    writeAll(entries) {
-        const content = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
-        const tmp = `${this.filePath}.${randomUUID()}.tmp`;
-        try {
-            writeFileSync(tmp, content, 'utf-8');
-            renameSync(tmp, this.filePath);
-        }
-        catch (err) {
-            try {
-                unlinkSync(tmp);
-            }
-            catch { /* ignore cleanup failure */ }
-            throw err;
-        }
-    }
-    /** List entries with optional filters (defaults to status='pending') */
-    list(opts = {}) {
-        const status = opts.status ?? 'pending';
-        let entries = this.readAll().filter((e) => e.status === status);
-        if (opts.toolName) {
-            entries = entries.filter((e) => e.toolName === opts.toolName);
-        }
-        if (opts.agentId) {
-            entries = entries.filter((e) => e.agentId === opts.agentId);
-        }
-        if (opts.olderThanDays !== undefined) {
-            const cutoff = Date.now() - opts.olderThanDays * 24 * 60 * 60 * 1000;
-            entries = entries.filter((e) => new Date(e.createdAt).getTime() < cutoff);
-        }
-        if (opts.limit !== undefined) {
-            entries = entries.slice(0, opts.limit);
-        }
-        return entries;
-    }
-    /** Get a single entry by messageId */
-    get(messageId) {
-        return this.readAll().find((e) => e.messageId === messageId) ?? null;
-    }
-    /** Purge old pending entries (mark as 'purged') */
-    purge(olderThanDays) {
-        const entries = this.readAll();
-        const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
-        let count = 0;
-        for (const entry of entries) {
-            if (entry.status === 'pending' && new Date(entry.createdAt).getTime() < cutoff) {
-                entry.status = 'purged';
-                count++;
-            }
-        }
-        this.writeAll(entries);
-        return count;
-    }
-}
-//# sourceMappingURL=dlq-reader.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-writer.d.ts

@@ -1,24 +0,0 @@
-/**
- * DLQ Writer (Task 37)
- *
- * JSONL append-only storage for dead-letter queue entries.
- */
-import type { DLQEntry, DeliveryAttempt } from '../../../shared/src/types/dlq.js';
-/** Input for enqueue — caller provides these fields */
-export interface EnqueueInput {
-    toolName: string;
-    originalPayload: unknown;
-    deliveryAttempts: DeliveryAttempt[];
-    agentId?: string;
-    swarmId?: string;
-    tags?: string[];
-}
-export declare class DLQWriter {
-    private readonly filePath;
-    constructor(dataDir: string);
-    /** Enqueue a failed message into the DLQ */
-    enqueue(input: EnqueueInput): DLQEntry;
-    /** Get the file path (for reader/replayer) */
-    getFilePath(): string;
-}
-//# sourceMappingURL=dlq-writer.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-writer.js

@@ -1,65 +0,0 @@
-/**
- * DLQ Writer (Task 37)
- *
- * JSONL append-only storage for dead-letter queue entries.
- */
-import { randomUUID } from 'crypto';
-import { existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join, resolve, sep } from 'path';
-export class DLQWriter {
-    filePath;
-    constructor(dataDir) {
-        const resolvedDataDir = resolve(dataDir);
-        const allowedRoot = resolve(process.env.MONOMIND_DATA_DIR ?? process.cwd());
-        if (resolvedDataDir !== allowedRoot && !resolvedDataDir.startsWith(allowedRoot + sep)) {
-            throw new Error(`DLQ dataDir escapes allowed root: ${resolvedDataDir}`);
-        }
-        if (!existsSync(resolvedDataDir)) {
-            mkdirSync(resolvedDataDir, { recursive: true });
-        }
-        this.filePath = join(resolvedDataDir, 'dead-letter-queue.jsonl');
-    }
-    /** Enqueue a failed message into the DLQ */
-    enqueue(input) {
-        const lastAttempt = input.deliveryAttempts[input.deliveryAttempts.length - 1];
-        const firstAttempt = input.deliveryAttempts[0];
-        const entry = {
-            messageId: randomUUID(),
-            toolName: input.toolName,
-            originalPayload: input.originalPayload,
-            deliveryAttempts: input.deliveryAttempts,
-            finalError: lastAttempt?.errorMessage ?? 'unknown',
-            finalErrorType: lastAttempt?.errorType ?? 'unknown',
-            agentId: input.agentId,
-            swarmId: input.swarmId,
-            createdAt: firstAttempt?.attemptedAt ?? new Date().toISOString(),
-            archivedAt: new Date().toISOString(),
-            status: 'pending',
-            tags: input.tags ?? [],
-        };
-        // JSON.stringify can throw on circular references, BigInt, and non-serializable
-        // values. originalPayload is `unknown` (caller-controlled), so a malicious or
-        // malformed input could otherwise crash the writer mid-flight. Fall back to
-        // a sanitized record so the audit trail is preserved.
-        let serialized;
-        try {
-            serialized = JSON.stringify(entry);
-        }
-        catch {
-            serialized = JSON.stringify({
-                messageId: entry.messageId,
-                toolName: entry.toolName,
-                archivedAt: entry.archivedAt,
-                status: 'pending',
-                finalError: 'serialize_failed',
-            });
-        }
-        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
-        return entry;
-    }
-    /** Get the file path (for reader/replayer) */
-    getFilePath() {
-        return this.filePath;
-    }
-}
-//# sourceMappingURL=dlq-writer.js.map

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

@@ -1,10 +0,0 @@
-/**
- * DLQ Module Barrel (Task 37)
- */
-export { DLQWriter } from './dlq-writer.js';
-export type { EnqueueInput } from './dlq-writer.js';
-export { DLQReader } from './dlq-reader.js';
-export type { DLQListOptions } from './dlq-reader.js';
-export { DLQReplayer } from './dlq-replayer.js';
-export type { ToolCaller } from './dlq-replayer.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,7 +0,0 @@
-/**
- * DLQ Module Barrel (Task 37)
- */
-export { DLQWriter } from './dlq-writer.js';
-export { DLQReader } from './dlq-reader.js';
-export { DLQReplayer } from './dlq-replayer.js';
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/eval/dataset-manager.d.ts

@@ -1,33 +0,0 @@
-import type { EvalDataset, EvalDatasetEntry, EvalTrace } from '../../../shared/src/types/eval.js';
-export interface CreateFromTracesOpts {
-    name: string;
-    description: string;
-    traces: EvalTrace[];
-    agentSlugs?: string[];
-}
-export declare class DatasetManager {
-    private datasetsPath;
-    private entriesPath;
-    constructor(datasetsPath: string, entriesPath: string);
-    /**
-     * Create a dataset from a set of filtered traces.
-     */
-    createFromTraces(opts: CreateFromTracesOpts): EvalDataset;
-    /**
-     * List all datasets.
-     */
-    listDatasets(): EvalDataset[];
-    /**
-     * Get entries for a specific dataset.
-     */
-    getEntries(datasetId: string): EvalDatasetEntry[];
-    /**
-     * Add a single trace to an existing dataset.
-     */
-    addTraceToDataset(datasetId: string, traceId: string): EvalDatasetEntry;
-    /**
-     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
-     */
-    exportToFile(datasetId: string, outputPath: string, allowedRoot?: string): void;
-}
-//# sourceMappingURL=dataset-manager.d.ts.map

package/packages/@monomind/cli/dist/src/eval/dataset-manager.js

@@ -1,107 +0,0 @@
-/**
- * DatasetManager - JSONL-based eval dataset management (Task 33)
- */
-import { randomUUID } from 'crypto';
-import { appendFileSync, readFileSync, writeFileSync, renameSync, existsSync, statSync } from 'fs';
-import { resolve, sep } from 'path';
-import { parseJsonl } from '../utils/parse-jsonl.js';
-export class DatasetManager {
-    datasetsPath;
-    entriesPath;
-    constructor(datasetsPath, entriesPath) {
-        this.datasetsPath = datasetsPath;
-        this.entriesPath = entriesPath;
-    }
-    /**
-     * Create a dataset from a set of filtered traces.
-     */
-    createFromTraces(opts) {
-        const now = new Date().toISOString();
-        const agentSlugs = opts.agentSlugs ?? [...new Set(opts.traces.map((t) => t.agentSlug))];
-        const dataset = {
-            datasetId: randomUUID(),
-            name: opts.name,
-            description: opts.description,
-            agentSlugs,
-            createdAt: now,
-            updatedAt: now,
-            entryCount: opts.traces.length,
-        };
-        appendFileSync(this.datasetsPath, JSON.stringify(dataset) + '\n', 'utf-8');
-        for (const trace of opts.traces) {
-            const entry = {
-                entryId: randomUUID(),
-                datasetId: dataset.datasetId,
-                traceId: trace.traceId,
-                addedAt: now,
-            };
-            appendFileSync(this.entriesPath, JSON.stringify(entry) + '\n', 'utf-8');
-        }
-        return dataset;
-    }
-    /**
-     * List all datasets.
-     */
-    listDatasets() {
-        if (!existsSync(this.datasetsPath))
-            return [];
-        if (statSync(this.datasetsPath).size > 50 * 1024 * 1024) {
-            throw new Error('Dataset file exceeds 50MB — run cleanup');
-        }
-        const content = readFileSync(this.datasetsPath, 'utf-8');
-        return parseJsonl(content);
-    }
-    /**
-     * Get entries for a specific dataset.
-     */
-    getEntries(datasetId) {
-        if (!existsSync(this.entriesPath))
-            return [];
-        if (statSync(this.entriesPath).size > 50 * 1024 * 1024) {
-            throw new Error('Entries file exceeds 50MB — run cleanup');
-        }
-        const content = readFileSync(this.entriesPath, 'utf-8');
-        return parseJsonl(content).filter((e) => e.datasetId === datasetId);
-    }
-    /**
-     * Add a single trace to an existing dataset.
-     */
-    addTraceToDataset(datasetId, traceId) {
-        const entry = {
-            entryId: randomUUID(),
-            datasetId,
-            traceId,
-            addedAt: new Date().toISOString(),
-        };
-        appendFileSync(this.entriesPath, JSON.stringify(entry) + '\n', 'utf-8');
-        // Update dataset entryCount via atomic write
-        const datasets = this.listDatasets();
-        const updated = datasets.map((d) => {
-            if (d.datasetId === datasetId) {
-                return { ...d, entryCount: d.entryCount + 1, updatedAt: new Date().toISOString() };
-            }
-            return d;
-        });
-        const tmp = `${this.datasetsPath}.${randomUUID()}.tmp`;
-        writeFileSync(tmp, updated.map((d) => JSON.stringify(d)).join('\n') + '\n', 'utf-8');
-        renameSync(tmp, this.datasetsPath);
-        return entry;
-    }
-    /**
-     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
-     */
-    exportToFile(datasetId, outputPath, allowedRoot) {
-        if (allowedRoot) {
-            const resolvedOut = resolve(outputPath);
-            const resolvedRoot = resolve(allowedRoot);
-            if (!resolvedOut.startsWith(resolvedRoot + sep) && resolvedOut !== resolvedRoot) {
-                throw new Error(`Export path escapes allowed root: ${resolvedOut}`);
-            }
-        }
-        const datasets = this.listDatasets();
-        const dataset = datasets.find((d) => d.datasetId === datasetId);
-        const entries = this.getEntries(datasetId);
-        writeFileSync(outputPath, JSON.stringify({ dataset, entries }, null, 2), 'utf-8');
-    }
-}
-//# sourceMappingURL=dataset-manager.js.map

package/packages/@monomind/cli/dist/src/eval/dataset-runner.d.ts

@@ -1,23 +0,0 @@
-import type { EvalRunResult, EvalTrace } from '../../../shared/src/types/eval.js';
-export interface AgentRunnerResult {
-    agentOutput: string;
-    outcome: 'success' | 'failure' | 'timeout';
-    qualityScore: number;
-    latencyMs: number;
-}
-export interface DatasetRunOpts {
-    datasetId: string;
-    agentVersion: string;
-    traces: EvalTrace[];
-    agentRunner: (trace: EvalTrace) => Promise<AgentRunnerResult>;
-    baselineResult?: EvalRunResult;
-    regressionThreshold?: number;
-}
-export declare class DatasetRunner {
-    /**
-     * Run all traces through the agent runner and compute stats.
-     * Optionally compare against a baseline to detect regressions.
-     */
-    run(opts: DatasetRunOpts): Promise<EvalRunResult>;
-}
-//# sourceMappingURL=dataset-runner.d.ts.map

package/packages/@monomind/cli/dist/src/eval/dataset-runner.js

@@ -1,59 +0,0 @@
-/**
- * DatasetRunner - Run eval datasets against agents and detect regressions (Task 33)
- */
-import { randomUUID } from 'crypto';
-export class DatasetRunner {
-    /**
-     * Run all traces through the agent runner and compute stats.
-     * Optionally compare against a baseline to detect regressions.
-     */
-    async run(opts) {
-        const { datasetId, agentVersion, traces, agentRunner, baselineResult, regressionThreshold = 0.1, } = opts;
-        const results = [];
-        for (const trace of traces) {
-            const result = await agentRunner(trace);
-            results.push({ trace, result });
-        }
-        const passCount = results.filter((r) => r.result.outcome === 'success').length;
-        const failCount = results.length - passCount;
-        const totalQuality = results.reduce((sum, r) => sum + r.result.qualityScore, 0);
-        const totalLatency = results.reduce((sum, r) => sum + r.result.latencyMs, 0);
-        const avgQualityScore = results.length > 0 ? totalQuality / results.length : 0;
-        const avgLatencyMs = results.length > 0 ? totalLatency / results.length : 0;
-        // Regression detection
-        const regressionDetails = [];
-        let regressionDetected = false;
-        if (baselineResult) {
-            const delta = baselineResult.avgQualityScore - avgQualityScore;
-            if (delta > regressionThreshold) {
-                regressionDetected = true;
-                // Report per-trace regressions for traces with quality below baseline average
-                for (const { trace, result } of results) {
-                    if (result.qualityScore < baselineResult.avgQualityScore) {
-                        regressionDetails.push({
-                            traceId: trace.traceId,
-                            agentSlug: trace.agentSlug,
-                            baselineScore: baselineResult.avgQualityScore,
-                            currentScore: result.qualityScore,
-                            delta: baselineResult.avgQualityScore - result.qualityScore,
-                        });
-                    }
-                }
-            }
-        }
-        return {
-            runId: randomUUID(),
-            datasetId,
-            runAt: new Date().toISOString(),
-            agentVersion,
-            entriesTested: results.length,
-            passCount,
-            failCount,
-            avgQualityScore,
-            avgLatencyMs,
-            regressionDetected,
-            regressionDetails,
-        };
-    }
-}
-//# sourceMappingURL=dataset-runner.js.map

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

@@ -1,10 +0,0 @@
-/**
- * Eval Module - Automated eval dataset from production traces (Task 33)
- */
-export { TraceCollector } from './trace-collector.js';
-export type { RecordTraceInput } from './trace-collector.js';
-export { DatasetManager } from './dataset-manager.js';
-export type { CreateFromTracesOpts } from './dataset-manager.js';
-export { DatasetRunner } from './dataset-runner.js';
-export type { AgentRunnerResult, DatasetRunOpts } from './dataset-runner.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,7 +0,0 @@
-/**
- * Eval Module - Automated eval dataset from production traces (Task 33)
- */
-export { TraceCollector } from './trace-collector.js';
-export { DatasetManager } from './dataset-manager.js';
-export { DatasetRunner } from './dataset-runner.js';
-//# sourceMappingURL=index.js.map