cognitive-core 0.0.2 → 0.1.2

package/dist/runtime/types.d.ts

@@ -0,0 +1,176 @@
+import type { Task, Trajectory } from '../types/index.js';
+import type { MemoryQueryResultV2 } from '../memory/system.js';
+import type { ComputeRequirements } from './compute-provider.js';
+/**
+ * Message in an agent conversation
+ */
+export interface AgentMessage {
+    role: 'user' | 'assistant' | 'system' | 'tool_use' | 'tool_result';
+    content: string;
+    toolName?: string;
+    toolInput?: unknown;
+    toolOutput?: unknown;
+    timestamp: Date;
+}
+/**
+ * Tool call made by an agent
+ */
+export interface ToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+    output?: unknown;
+    error?: string;
+    startTime: Date;
+    endTime?: Date;
+}
+/**
+ * Agent execution state
+ */
+export type AgentState = 'idle' | 'running' | 'paused' | 'completed' | 'failed';
+/**
+ * Agent session - represents a running or completed agent execution
+ */
+export interface AgentSession {
+    id: string;
+    agentType: string;
+    task: Task;
+    state: AgentState;
+    messages: AgentMessage[];
+    toolCalls: ToolCall[];
+    startTime: Date;
+    endTime?: Date;
+    result?: unknown;
+    error?: string;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Configuration for spawning an agent
+ */
+export interface AgentSpawnConfig {
+    /** Type of agent to spawn (e.g., 'claude-code', 'custom', etc.) */
+    agentType: string;
+    /** Task for the agent to work on */
+    task: Task;
+    /** Optional knowledge to inject into the agent's context */
+    injectedKnowledge?: MemoryQueryResultV2;
+    /** Custom system prompt additions */
+    systemPromptAdditions?: string;
+    /** Environment variables for the agent */
+    env?: Record<string, string>;
+    /** Working directory */
+    cwd?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Whether to capture detailed tool calls */
+    captureToolCalls?: boolean;
+    /** Callback for real-time observation */
+    onMessage?: (message: AgentMessage) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+    /** Additional backend-specific options */
+    backendOptions?: Record<string, unknown>;
+    /** Compute requirements for provider-based backend resolution */
+    computeRequirements?: ComputeRequirements;
+}
+/**
+ * Result of agent execution
+ */
+export interface AgentResult {
+    session: AgentSession;
+    trajectory: Trajectory;
+    success: boolean;
+    metrics: {
+        totalTime: number;
+        toolCallCount: number;
+        messageCount: number;
+        tokenEstimate?: number;
+    };
+}
+/**
+ * Agent backend protocol - implement this for different agent systems
+ */
+export interface AgentBackend {
+    /** Unique name for this backend */
+    readonly name: string;
+    /** Supported agent types */
+    readonly supportedTypes: string[];
+    /** Check if backend is available/configured */
+    isAvailable(): Promise<boolean>;
+    /** Spawn and run an agent */
+    spawn(config: AgentSpawnConfig): Promise<AgentSession>;
+    /** Get status of a running session */
+    getSession(sessionId: string): Promise<AgentSession | undefined>;
+    /** Send a message to a running session */
+    sendMessage?(sessionId: string, message: string): Promise<void>;
+    /** Pause a running session */
+    pause?(sessionId: string): Promise<void>;
+    /** Resume a paused session */
+    resume?(sessionId: string): Promise<void>;
+    /** Terminate a session */
+    terminate?(sessionId: string): Promise<void>;
+    /** List active sessions */
+    listSessions?(): Promise<AgentSession[]>;
+}
+/**
+ * Knowledge injector - formats knowledge for injection into agents
+ */
+export interface KnowledgeInjector {
+    /** Format knowledge for a specific agent type */
+    format(knowledge: MemoryQueryResultV2, agentType: string, options?: {
+        maxTokens?: number;
+        format?: 'markdown' | 'json' | 'xml';
+    }): string;
+}
+/**
+ * Trajectory extractor - extracts trajectories from agent sessions
+ */
+export interface TrajectoryExtractor {
+    /** Extract a trajectory from an agent session */
+    extract(session: AgentSession, task: Task): Trajectory;
+}
+/**
+ * Agent observer callbacks
+ */
+export interface AgentObserverCallbacks {
+    onSessionStart?: (session: AgentSession) => void;
+    onMessage?: (session: AgentSession, message: AgentMessage) => void;
+    onToolCall?: (session: AgentSession, toolCall: ToolCall) => void;
+    onSessionEnd?: (session: AgentSession, trajectory: Trajectory) => void;
+    onError?: (session: AgentSession, error: Error) => void;
+}
+/**
+ * Options passed to an AgentDelegate when executing a task
+ */
+export interface AgentDelegateOptions {
+    /** Working directory for execution */
+    cwd: string;
+    /** System context (formatted knowledge + skill context) */
+    systemContext?: string;
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+}
+/**
+ * Result returned by an AgentDelegate after execution
+ */
+export interface AgentDelegateResult {
+    /** Whether the execution succeeded */
+    success: boolean;
+    /** Text output from the agent */
+    output: string;
+    /** Optional structured output */
+    structured?: unknown;
+    /** Optional trajectory — when provided, used directly for full learning fidelity */
+    trajectory?: Trajectory;
+}
+/**
+ * AgentDelegate — lets callers provide their own agent instances.
+ *
+ * When set on AgentManager, bypasses backend resolution and compute provider.
+ * The caller owns all lifecycle, tracking, and billing. cognitive-core only
+ * sends a prompt + context and receives a result.
+ */
+export interface AgentDelegate {
+    /** Execute a task with the given prompt and options */
+    execute(prompt: string, options: AgentDelegateOptions): Promise<AgentDelegateResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/runtime/types.ts"],"names":[],"mappings":"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"}

package/dist/runtime/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/runtime/types.ts"],"names":[],"mappings":""}

package/dist/search/evaluator.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Solution Evaluator
+ *
+ * Evaluates solution quality using a hybrid approach:
+ * 1. First tries task verification (if available)
+ * 2. Falls back to ACP agent evaluation
+ * 3. Falls back to heuristic evaluation as last resort
+ */
+import type { Trajectory } from '../types/trajectory.js';
+import type { Task } from '../types/task.js';
+import type { AgentManager } from '../runtime/manager.js';
+import type { AgenticTaskRunner } from '../workspace/runner.js';
+import { type EvaluationResult } from './refinement-types.js';
+/**
+ * Verification function signature for task-specific verification
+ */
+export interface VerificationFunction {
+    (trajectory: Trajectory, task: Task): Promise<VerificationResult>;
+}
+/**
+ * Result from a verification function
+ */
+export interface VerificationResult {
+    /** Whether the solution passed verification */
+    passed: boolean;
+    /** Confidence in the verification result (0-1) */
+    confidence: number;
+    /** Specific issues found */
+    issues?: Array<{
+        type: 'incomplete' | 'incorrect' | 'error';
+        description: string;
+        severity?: 'critical' | 'major' | 'minor';
+    }>;
+    /** Additional details */
+    details?: string;
+}
+/**
+ * Configuration for the SolutionEvaluator
+ */
+export interface EvaluatorConfig {
+    /** Agent type to use for evaluation (default: 'evaluator') */
+    evaluatorAgentType?: string;
+    /** Minimum confidence for verification to be accepted */
+    verificationConfidenceThreshold?: number;
+    /** Whether to always run agent evaluation even if verification passes */
+    alwaysUseAgent?: boolean;
+    /** Timeout for agent evaluation in ms */
+    agentTimeout?: number;
+}
+/**
+ * SolutionEvaluator - Evaluates trajectory quality using hybrid approach
+ */
+export declare class SolutionEvaluator {
+    private agentManager;
+    private taskRunner;
+    private config;
+    private verifiers;
+    constructor(agentManager: AgentManager | null, config?: EvaluatorConfig);
+    /**
+     * Set the task runner for workspace-based evaluation.
+     * When set, evaluation delegates to solutionEvaluationTemplate.
+     */
+    setTaskRunner(runner: AgenticTaskRunner): void;
+    /**
+     * Register a verification function for a task domain
+     */
+    registerVerifier(domain: string, verifier: VerificationFunction): void;
+    /**
+     * Evaluate a trajectory's quality
+     */
+    evaluate(trajectory: Trajectory, task: Task): Promise<EvaluationResult>;
+    /**
+     * Try verification if a verifier is available for the task domain
+     */
+    private tryVerification;
+    /**
+     * Evaluate using an ACP agent
+     */
+    private evaluateWithAgent;
+    /**
+     * Build evaluation prompt for the agent
+     */
+    private buildEvaluationPrompt;
+    /**
+     * Parse agent evaluation response into EvaluationResult
+     */
+    private parseAgentEvaluation;
+    /**
+     * Heuristic evaluation based on trajectory properties
+     */
+    private evaluateHeuristic;
+    /**
+     * Parse quality string to QualityLevel
+     */
+    private parseQuality;
+    /**
+     * Parse issue type string
+     */
+    private parseIssueType;
+    /**
+     * Parse severity string
+     */
+    private parseSeverity;
+}
+/**
+ * Create a solution evaluator
+ */
+export declare function createSolutionEvaluator(agentManager: AgentManager | null, config?: EvaluatorConfig): SolutionEvaluator;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/search/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/search/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACnE;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,MAAM,EAAE,OAAO,CAAC;IAChB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,YAAY,GAAG,WAAW,GAAG,OAAO,CAAC;QAC3C,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;KAC3C,CAAC,CAAC;IACH,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,yDAAyD;IACzD,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,yEAAyE;IACzE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAYD;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,SAAS,CAAgD;gBAG/D,YAAY,EAAE,YAAY,GAAG,IAAI,EACjC,MAAM,GAAE,eAAoB;IAM9B;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAI9C;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAItE;;OAEG;IACG,QAAQ,CACZ,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,gBAAgB,CAAC;IA8C5B;;OAEG;YACW,eAAe;IAyC7B;;OAEG;YACW,iBAAiB;IAoC/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA8C7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA0D5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6EzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAmBpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAqBtB;;OAEG;IACH,OAAO,CAAC,aAAa;CAatB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,YAAY,GAAG,IAAI,EACjC,MAAM,CAAC,EAAE,eAAe,GACvB,iBAAiB,CAEnB"}

package/dist/search/evaluator.js

@@ -0,0 +1,372 @@
+/**
+ * Solution Evaluator
+ *
+ * Evaluates solution quality using a hybrid approach:
+ * 1. First tries task verification (if available)
+ * 2. Falls back to ACP agent evaluation
+ * 3. Falls back to heuristic evaluation as last resort
+ */
+import { solutionEvaluationTemplate } from '../workspace/templates/solution-evaluation.js';
+import { createEvaluationResult, scoreToQuality, } from './refinement-types.js';
+/**
+ * Default evaluator configuration
+ */
+const DEFAULT_CONFIG = {
+    evaluatorAgentType: 'evaluator',
+    verificationConfidenceThreshold: 0.8,
+    alwaysUseAgent: false,
+    agentTimeout: 60000,
+};
+/**
+ * SolutionEvaluator - Evaluates trajectory quality using hybrid approach
+ */
+export class SolutionEvaluator {
+    agentManager;
+    taskRunner = null;
+    config;
+    verifiers = new Map();
+    constructor(agentManager, config = {}) {
+        this.agentManager = agentManager;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Set the task runner for workspace-based evaluation.
+     * When set, evaluation delegates to solutionEvaluationTemplate.
+     */
+    setTaskRunner(runner) {
+        this.taskRunner = runner;
+    }
+    /**
+     * Register a verification function for a task domain
+     */
+    registerVerifier(domain, verifier) {
+        this.verifiers.set(domain, verifier);
+    }
+    /**
+     * Evaluate a trajectory's quality
+     */
+    async evaluate(trajectory, task) {
+        // 1. Try verification first (if available and applicable)
+        const verificationResult = await this.tryVerification(trajectory, task);
+        if (verificationResult) {
+            const { result, evalResult } = verificationResult;
+            // If verification is confident enough and doesn't always require agent
+            if (result.confidence >= this.config.verificationConfidenceThreshold &&
+                !this.config.alwaysUseAgent) {
+                return evalResult;
+            }
+        }
+        // 2. Try workspace-based evaluation (preferred)
+        if (this.taskRunner) {
+            try {
+                const result = await this.taskRunner.run(solutionEvaluationTemplate, {
+                    trajectory,
+                    task,
+                });
+                return result.output;
+            }
+            catch (error) {
+                console.warn('Workspace-based evaluation failed, falling back:', error instanceof Error ? error.message : String(error));
+            }
+        }
+        // 3. Try ad-hoc ACP agent evaluation
+        if (this.agentManager) {
+            try {
+                const agentResult = await this.evaluateWithAgent(trajectory, task);
+                return agentResult;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.warn(`Agent evaluation failed, falling back to heuristic: ${errorMsg}`);
+            }
+        }
+        // 4. Fall back to heuristic evaluation
+        return this.evaluateHeuristic(trajectory, task);
+    }
+    /**
+     * Try verification if a verifier is available for the task domain
+     */
+    async tryVerification(trajectory, task) {
+        // Check for domain-specific verifier
+        const verifier = task.domain ? this.verifiers.get(task.domain) : undefined;
+        if (!verifier) {
+            return null;
+        }
+        try {
+            const result = await verifier(trajectory, task);
+            const score = result.passed
+                ? Math.max(0.7, result.confidence)
+                : Math.min(0.5, 1 - result.confidence);
+            const evalResult = createEvaluationResult({
+                quality: scoreToQuality(score),
+                score,
+                acceptable: result.passed && result.confidence >= this.config.verificationConfidenceThreshold,
+                issues: result.issues?.map((issue) => ({
+                    type: issue.type,
+                    description: issue.description,
+                    severity: issue.severity ?? 'major',
+                })) ?? [],
+                method: 'verification',
+                rawResponse: result.details,
+            });
+            return { result, evalResult };
+        }
+        catch (error) {
+            // Verification failed, return null to try other methods
+            console.warn('Verification failed:', error instanceof Error ? error.message : String(error));
+            return null;
+        }
+    }
+    /**
+     * Evaluate using an ACP agent
+     */
+    async evaluateWithAgent(trajectory, task) {
+        if (!this.agentManager) {
+            throw new Error('AgentManager not available for agent evaluation');
+        }
+        // Create evaluation task for the agent
+        const evaluationTask = {
+            id: `eval-${trajectory.id}`,
+            description: this.buildEvaluationPrompt(trajectory, task),
+            domain: 'evaluation',
+            context: {},
+            createdAt: new Date(),
+            metadata: {
+                originalTaskId: task.id,
+                trajectoryId: trajectory.id,
+            },
+        };
+        // Spawn evaluation agent
+        const result = await this.agentManager.spawn({
+            agentType: this.config.evaluatorAgentType,
+            task: evaluationTask,
+            timeout: this.config.agentTimeout,
+            backendOptions: {
+                // Evaluation agents should be concise
+                maxTokens: 2000,
+            },
+        });
+        // Parse agent response into EvaluationResult
+        return this.parseAgentEvaluation(result.session.result, result.trajectory);
+    }
+    /**
+     * Build evaluation prompt for the agent
+     */
+    buildEvaluationPrompt(trajectory, task) {
+        const steps = trajectory.steps
+            .map((step, i) => {
+            let stepStr = `Step ${i + 1}:`;
+            if (step.thought)
+                stepStr += `\n  Thought: ${step.thought}`;
+            stepStr += `\n  Action: ${step.action}`;
+            if (step.observation)
+                stepStr += `\n  Observation: ${step.observation}`;
+            return stepStr;
+        })
+            .join('\n\n');
+        const outcomeStr = trajectory.outcome.success
+            ? `SUCCESS: ${trajectory.outcome.solution ?? 'Task completed'}`
+            : `FAILURE: ${trajectory.outcome.errorInfo ?? 'Unknown error'}`;
+        return `Evaluate the quality of this solution attempt.
+
+## Original Task
+${task.description}
+
+## Solution Steps
+${steps}
+
+## Outcome
+${outcomeStr}
+
+## Instructions
+Analyze the solution and provide:
+1. Overall quality assessment (excellent/good/needs_work/poor)
+2. A numeric score from 0.0 to 1.0
+3. Whether this solution is acceptable
+4. List any specific issues found
+5. Suggestions for improvement
+
+Respond in JSON format:
+{
+  "quality": "excellent|good|needs_work|poor",
+  "score": 0.85,
+  "acceptable": true,
+  "issues": [
+    {"type": "incomplete|incorrect|inefficient|off_topic|error", "description": "...", "severity": "critical|major|minor"}
+  ],
+  "suggestions": ["..."]
+}`;
+    }
+    /**
+     * Parse agent evaluation response into EvaluationResult
+     */
+    parseAgentEvaluation(result, _evalTrajectory) {
+        // Try to parse as JSON
+        if (typeof result === 'string') {
+            try {
+                // Extract JSON from response (agent may include extra text)
+                const jsonMatch = result.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    const parsed = JSON.parse(jsonMatch[0]);
+                    return createEvaluationResult({
+                        quality: this.parseQuality(parsed.quality),
+                        score: Math.min(1, Math.max(0, parsed.score ?? 0.5)),
+                        acceptable: parsed.acceptable ?? false,
+                        issues: (parsed.issues ?? []).map((issue) => ({
+                            type: this.parseIssueType(issue.type),
+                            description: issue.description ?? 'Unknown issue',
+                            severity: this.parseSeverity(issue.severity),
+                            suggestion: undefined,
+                        })),
+                        method: 'agent',
+                        rawResponse: result,
+                    });
+                }
+            }
+            catch {
+                // Fall through to heuristic parsing
+            }
+        }
+        // If we can't parse, return a conservative result
+        return createEvaluationResult({
+            quality: 'needs_work',
+            score: 0.5,
+            acceptable: false,
+            issues: [
+                {
+                    type: 'error',
+                    description: 'Could not parse agent evaluation response',
+                    severity: 'major',
+                },
+            ],
+            method: 'agent',
+            rawResponse: typeof result === 'string' ? result : JSON.stringify(result),
+        });
+    }
+    /**
+     * Heuristic evaluation based on trajectory properties
+     */
+    evaluateHeuristic(trajectory, _task) {
+        const issues = [];
+        let score = 0.5; // Start neutral
+        // Check outcome
+        if (trajectory.outcome.success) {
+            score += 0.3;
+        }
+        else {
+            score -= 0.2;
+            issues.push({
+                type: 'error',
+                description: trajectory.outcome.errorInfo ?? 'Task did not complete successfully',
+                severity: 'critical',
+            });
+        }
+        // Check for steps taken
+        if (trajectory.steps.length === 0) {
+            score -= 0.2;
+            issues.push({
+                type: 'incomplete',
+                description: 'No steps were taken to solve the task',
+                severity: 'critical',
+            });
+        }
+        else {
+            // Penalize very long trajectories (may indicate inefficiency)
+            if (trajectory.steps.length > 20) {
+                score -= 0.1;
+                issues.push({
+                    type: 'inefficient',
+                    description: `Solution took ${trajectory.steps.length} steps, which may indicate inefficiency`,
+                    severity: 'minor',
+                });
+            }
+        }
+        // Check for errors in steps
+        const errorSteps = trajectory.steps.filter((step) => step.observation?.toLowerCase().includes('error'));
+        if (errorSteps.length > 0) {
+            score -= 0.1 * Math.min(3, errorSteps.length);
+            issues.push({
+                type: 'error',
+                description: `${errorSteps.length} step(s) encountered errors`,
+                severity: errorSteps.length > 2 ? 'major' : 'minor',
+            });
+        }
+        // Check key steps (high attribution)
+        const keySteps = trajectory.steps.filter((step) => (step.attributionScore ?? 0) >= 0.15);
+        if (keySteps.length > 0 && trajectory.outcome.success) {
+            score += 0.1;
+        }
+        // Normalize score to [0, 1]
+        score = Math.max(0, Math.min(1, score));
+        return createEvaluationResult({
+            quality: scoreToQuality(score),
+            score,
+            acceptable: trajectory.outcome.success && score >= 0.6,
+            issues,
+            method: 'heuristic',
+        });
+    }
+    /**
+     * Parse quality string to QualityLevel
+     */
+    parseQuality(quality) {
+        const normalized = quality?.toLowerCase();
+        switch (normalized) {
+            case 'excellent':
+                return 'excellent';
+            case 'good':
+                return 'good';
+            case 'needs_work':
+            case 'needs work':
+                return 'needs_work';
+            case 'poor':
+                return 'poor';
+            default:
+                return 'needs_work';
+        }
+    }
+    /**
+     * Parse issue type string
+     */
+    parseIssueType(type) {
+        const normalized = type?.toLowerCase();
+        switch (normalized) {
+            case 'incomplete':
+                return 'incomplete';
+            case 'incorrect':
+                return 'incorrect';
+            case 'inefficient':
+                return 'inefficient';
+            case 'off_topic':
+            case 'off-topic':
+                return 'off_topic';
+            case 'error':
+                return 'error';
+            default:
+                return 'error';
+        }
+    }
+    /**
+     * Parse severity string
+     */
+    parseSeverity(severity) {
+        const normalized = severity?.toLowerCase();
+        switch (normalized) {
+            case 'critical':
+                return 'critical';
+            case 'major':
+                return 'major';
+            case 'minor':
+                return 'minor';
+            default:
+                return 'major';
+        }
+    }
+}
+/**
+ * Create a solution evaluator
+ */
+export function createSolutionEvaluator(agentManager, config) {
+    return new SolutionEvaluator(agentManager, config);
+}
+//# sourceMappingURL=evaluator.js.map