synapsexcoder 6.0.0

package/dist/synapsexcoder/agent-delegate.js

@@ -0,0 +1,837 @@
+import { OpenCodeToolBridge } from "./tool-bridge.js";
+import { ThoughtsManager } from "../thoughts/thoughts-manager.js";
+import { ContextSystem } from "../context/context-system.js";
+import { validateAndResolve } from "../utils/path-validator.js";
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+// Map short agent names to full OpenCode agent names
+const AGENT_NAME_MAP = {
+    planner: "synapse-planner",
+    analyzer: "synapse-analyzer",
+    reviewer: "synapse-reviewer",
+    rewriter: "synapse-rewriter",
+    ui_designer: "synapse-ui-designer",
+    researcher: "synapse-researcher",
+    gatekeeper: "synapse-gatekeeper",
+    verifier: "synapse-verifier",
+    strategist: "synapse-strategist",
+    diff_validator: "synapse-diff-validator",
+    debugger: "synapse-debugger",
+    test_runner: "synapse-test-runner",
+};
+// Expected execution time ranges per agent type (ms)
+const EXPECTED_EXECUTION_TIMES = {
+    "synapse-planner": { min: 2000, max: 30000 },
+    "synapse-analyzer": { min: 3000, max: 60000 },
+    "synapse-reviewer": { min: 2000, max: 45000 },
+    "synapse-rewriter": { min: 5000, max: 90000 },
+    "synapse-ui-designer": { min: 5000, max: 90000 },
+    "synapse-researcher": { min: 3000, max: 60000 },
+    "synapse-gatekeeper": { min: 2000, max: 30000 },
+    "synapse-verifier": { min: 3000, max: 60000 },
+    "synapse-strategist": { min: 2000, max: 30000 },
+    "synapse-diff-validator": { min: 2000, max: 30000 },
+    "synapse-debugger": { min: 3000, max: 60000 },
+    "synapse-test-runner": { min: 3000, max: 60000 },
+};
+// Indicators of model refusal in output
+const REFUSAL_INDICATORS = [
+    "i cannot",
+    "i can't",
+    "i'm unable to",
+    "i am unable to",
+    "as an ai",
+    "i don't have the ability",
+    "outside my capabilities",
+    "i must decline",
+];
+// Error indicators in output
+const ERROR_INDICATORS = [
+    "error:",
+    "exception:",
+    "traceback",
+    "fatal:",
+    "panic:",
+    "unhandled",
+    "stack trace",
+    "segmentation fault",
+];
+/**
+ * Convert short agent name to full OpenCode agent name
+ */
+function normalizeAgentName(name) {
+    if (name.startsWith("synapse-")) {
+        return name;
+    }
+    return AGENT_NAME_MAP[name] || name;
+}
+/**
+ * Extract simple keywords from a task description for pattern matching.
+ */
+function extractTaskKeywords(task) {
+    const stopWords = new Set([
+        "the",
+        "a",
+        "an",
+        "and",
+        "or",
+        "but",
+        "in",
+        "on",
+        "at",
+        "to",
+        "for",
+        "of",
+        "with",
+        "by",
+        "is",
+        "are",
+        "was",
+        "were",
+        "be",
+        "been",
+        "being",
+        "have",
+        "has",
+        "had",
+        "do",
+        "does",
+        "did",
+        "will",
+        "would",
+        "could",
+        "should",
+        "may",
+        "might",
+        "must",
+        "can",
+        "this",
+        "that",
+        "these",
+        "those",
+        "it",
+        "its",
+        "not",
+        "no",
+        "so",
+        "if",
+        "then",
+        "than",
+    ]);
+    return task
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((w) => w.length > 2 && !stopWords.has(w));
+}
+export class AgentDelegate {
+    bridge;
+    thoughts;
+    context;
+    projectRoot;
+    learningStorePath;
+    learningStore;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.bridge = new OpenCodeToolBridge({ mode: "embedded" }, projectRoot);
+        this.thoughts = new ThoughtsManager(projectRoot);
+        this.context = new ContextSystem(projectRoot);
+        // Initialize persistent learning store
+        const learningDir = join(projectRoot, ".synapsexcoder", "learning");
+        if (!existsSync(learningDir)) {
+            mkdirSync(learningDir, { recursive: true });
+        }
+        this.learningStorePath = join(learningDir, "execution-patterns.json");
+        this.learningStore = this.loadLearningStore();
+    }
+    // ========================================================================
+    // Persistence: Learning Store
+    // ========================================================================
+    loadLearningStore() {
+        if (existsSync(this.learningStorePath)) {
+            try {
+                const raw = readFileSync(this.learningStorePath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                // Corrupted file — start fresh
+            }
+        }
+        return { version: 1, records: [], agentStats: {}, updatedAt: Date.now() };
+    }
+    saveLearningStore() {
+        try {
+            this.learningStore.updatedAt = Date.now();
+            writeFileSync(this.learningStorePath, JSON.stringify(this.learningStore, null, 2), "utf-8");
+        }
+        catch (error) {
+            console.warn(`⚠️ Failed to persist learning store: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Debounced async save to avoid blocking on every delegation
+    saveLearningStoreDebounced() {
+        if (this._saveDebounceTimer) {
+            clearTimeout(this._saveDebounceTimer);
+        }
+        this._saveDebounceTimer = setTimeout(() => {
+            this.saveLearningStore();
+            this._saveDebounceTimer = null;
+        }, 2000); // 2 second debounce
+    }
+    _saveDebounceTimer = null;
+    // ========================================================================
+    // Result Analysis & Validation
+    // ========================================================================
+    /**
+     * Classify the failure mode from an execution result.
+     * Returns null if the result does not indicate a failure.
+     */
+    classifyFailureMode(result, executionTimeMs, timeoutMs) {
+        if (result.success)
+            return null;
+        // Timeout detection
+        if (executionTimeMs >= timeoutMs * 0.95 ||
+            result.error.toLowerCase().includes("timed out") ||
+            result.error.toLowerCase().includes("timeout")) {
+            return "timeout";
+        }
+        const outputLower = (result.output || "").toLowerCase();
+        const errorLower = (result.error || "").toLowerCase();
+        const combined = `${outputLower} ${errorLower}`;
+        // Model refusal
+        if (REFUSAL_INDICATORS.some((ind) => combined.includes(ind))) {
+            return "model_refusal";
+        }
+        // Empty output
+        if (!result.output || result.output.trim().length === 0) {
+            return "empty_output";
+        }
+        // Agent error (non-zero exit but has error text)
+        if (result.error && result.error.trim().length > 0) {
+            return "agent_error";
+        }
+        return "unknown";
+    }
+    /**
+     * Evaluate result completeness: checks for expected structural indicators
+     * in the output such as section headers, code blocks, or structured data.
+     * Returns a score 0–1.
+     */
+    evaluateCompleteness(output) {
+        if (!output || output.trim().length === 0)
+            return 0;
+        let score = 0;
+        const checks = [
+            // Has substantive content (more than a trivial response)
+            { test: output.trim().length > 50, weight: 0.2 },
+            // Contains structured sections (markdown headers or labeled sections)
+            { test: /^#+\s|\n#+\s|^[-*]\s/m.test(output), weight: 0.15 },
+            // Contains code blocks or structured data
+            { test: /```[\s\S]*?```|`[^`]+`/.test(output), weight: 0.15 },
+            // Has multiple lines (non-trivial output)
+            { test: output.split("\n").length > 3, weight: 0.15 },
+            // No truncation indicators
+            { test: !/(truncated|cut off|incomplete)/i.test(output), weight: 0.1 },
+            // Reasonable length (neither too short nor suspiciously brief)
+            { test: output.trim().length > 200, weight: 0.15 },
+            // Has a conclusion or summary section
+            {
+                test: /(summary|conclusion|result|output|done|complete)/i.test(output),
+                weight: 0.1,
+            },
+        ];
+        for (const check of checks) {
+            if (check.test)
+                score += check.weight;
+        }
+        return Math.min(1, score);
+    }
+    /**
+     * Evaluate result quality: checks for absence of error indicators,
+     * reasonable output length, and overall coherence signals.
+     * Returns a score 0–1.
+     */
+    evaluateQuality(output, error) {
+        if (!output || output.trim().length === 0)
+            return 0;
+        let score = 1.0;
+        const outputLower = output.toLowerCase();
+        // Penalize for error indicators in output
+        for (const indicator of ERROR_INDICATORS) {
+            if (outputLower.includes(indicator)) {
+                score -= 0.15;
+            }
+        }
+        // Penalize for refusal indicators
+        for (const indicator of REFUSAL_INDICATORS) {
+            if (outputLower.includes(indicator)) {
+                score -= 0.25;
+            }
+        }
+        // Penalize for stderr content
+        if (error && error.trim().length > 0) {
+            score -= 0.1;
+        }
+        // Penalize for very short output (likely incomplete)
+        if (output.trim().length < 30) {
+            score -= 0.3;
+        }
+        // Reward for structured output
+        if (/```[\s\S]*?```/.test(output)) {
+            score += 0.05;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Evaluate pattern consistency against historical executions for the same
+     * agent. Checks whether the output length and structure are consistent
+     * with past successful executions.
+     * Returns a score 0–1.
+     */
+    evaluatePatternConsistency(agent, output, executionTimeMs) {
+        const stats = this.learningStore.agentStats[agent];
+        if (!stats || stats.totalExecutions < 2) {
+            // Not enough history — assume neutral consistency
+            return 0.5;
+        }
+        let score = 0.5;
+        const outputLen = output.trim().length;
+        // Check if execution time is within the historical average ± 2 standard deviations
+        const avgTime = stats.avgExecutionTimeMs;
+        if (avgTime > 0) {
+            const ratio = executionTimeMs / avgTime;
+            if (ratio >= 0.3 && ratio <= 3.0) {
+                score += 0.25; // Within reasonable range
+            }
+            else {
+                score -= 0.15; // Outlier
+            }
+        }
+        // Compare success rate — if this agent usually succeeds, a success is consistent
+        const successRate = stats.totalExecutions > 0
+            ? stats.successCount / stats.totalExecutions
+            : 0.5;
+        if (successRate > 0.7) {
+            score += 0.15;
+        }
+        else if (successRate < 0.3) {
+            score -= 0.1;
+        }
+        // Penalize if output is trivially short compared to what we'd expect
+        if (outputLen < 20 && stats.totalExecutions > 3) {
+            score -= 0.2;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Evaluate execution time against expected range for the agent type.
+     * Returns a score 0–1.
+     */
+    evaluateExecutionTime(agent, executionTimeMs) {
+        const expected = EXPECTED_EXECUTION_TIMES[agent];
+        if (!expected)
+            return 0.5; // Unknown agent — neutral score
+        if (executionTimeMs < expected.min * 0.5) {
+            // Suspiciously fast — likely an error or empty response
+            return 0.3;
+        }
+        if (executionTimeMs <= expected.max) {
+            // Within expected range — good
+            return 1.0;
+        }
+        if (executionTimeMs <= expected.max * 1.5) {
+            // Slightly over — acceptable
+            return 0.7;
+        }
+        // Way over expected time
+        return 0.3;
+    }
+    /**
+     * Calculate a composite confidence score from the four evaluation dimensions.
+     */
+    calculateConfidence(completeness, quality, consistency, timeScore) {
+        // Weighted average — quality and completeness matter most
+        const score = completeness * 0.3 +
+            quality * 0.35 +
+            consistency * 0.2 +
+            timeScore * 0.15;
+        return Math.max(0, Math.min(1, score));
+    }
+    // ========================================================================
+    // Pattern Detection & Learning
+    // ========================================================================
+    /**
+     * Extract task-type → model → success-rate correlations.
+     * Identifies recurring failure modes and tracks prompt effectiveness.
+     * Updates the learning store's agentStats.
+     */
+    detectAndRecordPatterns(record) {
+        const patternIds = [];
+        const agent = record.agent;
+        const keywords = extractTaskKeywords(record.taskSummary);
+        const statsKey = agent;
+        // Initialize or update agent stats
+        if (!this.learningStore.agentStats[statsKey]) {
+            this.learningStore.agentStats[statsKey] = {
+                agent,
+                taskKeywords: keywords,
+                totalExecutions: 0,
+                successCount: 0,
+                avgConfidence: 0,
+                avgExecutionTimeMs: 0,
+                commonFailureModes: {},
+                lastExecuted: 0,
+            };
+        }
+        const stats = this.learningStore.agentStats[statsKey];
+        const prevTotal = stats.totalExecutions;
+        stats.totalExecutions += 1;
+        stats.lastExecuted = record.timestamp;
+        // Merge keywords (keep unique, cap at 20)
+        const keywordSet = new Set([...stats.taskKeywords, ...keywords]);
+        stats.taskKeywords = Array.from(keywordSet).slice(0, 20);
+        if (record.success) {
+            stats.successCount += 1;
+        }
+        // Running average for confidence
+        stats.avgConfidence =
+            prevTotal > 0
+                ? (stats.avgConfidence * prevTotal + record.confidenceScore) /
+                    (prevTotal + 1)
+                : record.confidenceScore;
+        // Running average for execution time
+        stats.avgExecutionTimeMs =
+            prevTotal > 0
+                ? (stats.avgExecutionTimeMs * prevTotal + record.executionTimeMs) /
+                    (prevTotal + 1)
+                : record.executionTimeMs;
+        // Track failure modes
+        if (record.failureMode) {
+            stats.commonFailureModes[record.failureMode] =
+                (stats.commonFailureModes[record.failureMode] || 0) + 1;
+        }
+        // Detect actionable patterns and add to ContextSystem
+        // Pattern: Agent consistently succeeds at a task type
+        const successRate = stats.totalExecutions > 0
+            ? stats.successCount / stats.totalExecutions
+            : 0;
+        if (stats.totalExecutions >= 3 && successRate >= 0.8) {
+            const patternName = `High-success agent: ${agent}`;
+            const existing = this.context.findRelevantPatterns({
+                keywords: [agent, "high-success"],
+                limit: 1,
+            });
+            if (existing.length > 0) {
+                this.context.updatePattern(existing[0].id, {
+                    description: `Agent ${agent} has ${Math.round(successRate * 100)}% success rate over ${stats.totalExecutions} executions (avg confidence: ${stats.avgConfidence.toFixed(2)})`,
+                });
+                patternIds.push(existing[0].id);
+            }
+            else {
+                const id = this.context.addPattern({
+                    type: "workflow",
+                    name: patternName,
+                    description: `Agent ${agent} has ${Math.round(successRate * 100)}% success rate over ${stats.totalExecutions} executions`,
+                    examples: [
+                        {
+                            input: record.taskSummary.substring(0, 100),
+                            output: `Success (confidence: ${record.confidenceScore.toFixed(2)})`,
+                            explanation: `Verified via ${stats.totalExecutions} historical executions`,
+                        },
+                    ],
+                    tags: ["high-success", agent, "auto-learned"],
+                });
+                patternIds.push(id);
+            }
+        }
+        // Pattern: Recurring failure mode
+        for (const [mode, count] of Object.entries(stats.commonFailureModes)) {
+            if (count >= 3) {
+                const failPatternName = `Recurring failure: ${agent} → ${mode}`;
+                const existing = this.context.findRelevantPatterns({
+                    keywords: [agent, mode, "recurring-failure"],
+                    limit: 1,
+                });
+                if (existing.length === 0) {
+                    const id = this.context.addPattern({
+                        type: "workflow",
+                        name: failPatternName,
+                        description: `Agent ${agent} has failed ${count} times with mode "${mode}". Consider alternative agents or task restructuring.`,
+                        examples: [
+                            {
+                                input: record.taskSummary.substring(0, 100),
+                                output: `Failure mode: ${mode}`,
+                                explanation: `Detected across ${count} executions`,
+                            },
+                        ],
+                        tags: ["recurring-failure", agent, mode, "auto-learned"],
+                    });
+                    patternIds.push(id);
+                }
+            }
+        }
+        // Pattern: Execution time anomaly
+        if (stats.totalExecutions >= 5 &&
+            record.executionTimeMs > stats.avgExecutionTimeMs * 2.5) {
+            const id = this.context.addPattern({
+                type: "workflow",
+                name: `Slow execution: ${agent}`,
+                description: `Agent ${agent} took ${record.executionTimeMs}ms vs average ${Math.round(stats.avgExecutionTimeMs)}ms. Possible complexity spike or resource contention.`,
+                examples: [
+                    {
+                        input: record.taskSummary.substring(0, 100),
+                        output: `${record.executionTimeMs}ms (${Math.round(record.executionTimeMs / stats.avgExecutionTimeMs)}x avg)`,
+                        explanation: "Execution time outlier detected",
+                    },
+                ],
+                tags: ["slow-execution", agent, "auto-learned"],
+            });
+            patternIds.push(id);
+        }
+        return patternIds;
+    }
+    /**
+     * Analyze an execution result and produce structured learning insights.
+     */
+    analyzeExecution(agent, task, result, executionTimeMs, timeoutMs, validationPassed) {
+        const output = result.output || "";
+        const error = result.error || "";
+        const failureMode = this.classifyFailureMode(result, executionTimeMs, timeoutMs);
+        const completeness = this.evaluateCompleteness(output);
+        const quality = this.evaluateQuality(output, error);
+        const consistency = this.evaluatePatternConsistency(agent, output, executionTimeMs);
+        const timeScore = this.evaluateExecutionTime(agent, executionTimeMs);
+        const confidence = this.calculateConfidence(completeness, quality, consistency, timeScore);
+        // Build the execution record
+        const record = {
+            timestamp: Date.now(),
+            agent,
+            taskSummary: task.substring(0, 200),
+            success: result.success && failureMode === null,
+            validationPassed,
+            executionTimeMs,
+            confidenceScore: confidence,
+            failureMode,
+            outputLengthChars: output.length,
+            patternIds: [],
+        };
+        // Detect patterns and get back created pattern IDs
+        const patternIds = this.detectAndRecordPatterns(record);
+        record.patternIds = patternIds;
+        // Persist execution record (keep last 500 records to bound storage)
+        this.learningStore.records.push(record);
+        if (this.learningStore.records.length > 500) {
+            this.learningStore.records = this.learningStore.records.slice(-500);
+        }
+        // Use debounced save to avoid blocking (saves after 2s idle)
+        this.saveLearningStoreDebounced();
+        // Generate actionable recommendations
+        const recommendations = [];
+        const stats = this.learningStore.agentStats[agent];
+        if (failureMode === "timeout") {
+            recommendations.push(`Consider increasing timeout for ${agent} or splitting the task into smaller chunks.`);
+        }
+        if (failureMode === "model_refusal") {
+            recommendations.push(`Task may be outside ${agent}'s capabilities. Try rephrasing or using a different agent.`);
+        }
+        if (failureMode === "empty_output") {
+            recommendations.push(`${agent} returned empty output. Check that the prompt provides sufficient context.`);
+        }
+        if (completeness < 0.4) {
+            recommendations.push(`Output appears incomplete. Consider providing more context files or a clearer task description.`);
+        }
+        if (stats && stats.totalExecutions >= 5) {
+            const successRate = stats.successCount / stats.totalExecutions;
+            if (successRate < 0.5) {
+                recommendations.push(`${agent} has a ${Math.round(successRate * 100)}% success rate. Consider using an alternative agent for this task type.`);
+            }
+        }
+        return {
+            confidenceScore: confidence,
+            resultCompleteness: completeness,
+            resultQuality: quality,
+            patternConsistency: consistency,
+            executionTimeScore: timeScore,
+            failureMode,
+            patternsDetected: patternIds,
+            recommendations,
+        };
+    }
+    // ========================================================================
+    // Security & Spawning
+    // ========================================================================
+    /**
+     * Validates a file path against the project root to prevent path traversal.
+     */
+    validateFilePath(filePath) {
+        return validateAndResolve(filePath, this.projectRoot);
+    }
+    // ========================================================================
+    // Core Delegation
+    // ========================================================================
+    /**
+     * Delegates a task to a specific sub-agent with enriched context.
+     */
+    async delegate(agentName, task, relatedFiles = []) {
+        const normalizedAgentName = normalizeAgentName(agentName);
+        const timeoutMs = 120000;
+        console.log(`🤖 Delegating task to ${normalizedAgentName}...`);
+        // 1. Gather Context with path validation
+        let fileContext = "";
+        for (const file of relatedFiles) {
+            try {
+                const fullPath = this.validateFilePath(file);
+                const content = await this.bridge.readFileContent(fullPath);
+                if (content) {
+                    fileContext += `\n--- File: ${file} ---\n${content.content}\n`;
+                }
+            }
+            catch (error) {
+                console.warn(`Warning: Could not read file ${file}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // 2. Get Learned Patterns & Thoughts
+        const contextPrompt = this.context.generateContextPrompt(task);
+        const recentThoughts = this.thoughts
+            .getRecentThoughts(3)
+            .map((t) => `[${t.type.toUpperCase()}] ${t.title}: ${t.content.substring(0, 100)}...`)
+            .join("\n");
+        // 2b. Inject relevant learned patterns as context
+        const learnedPatterns = this.context
+            .findRelevantPatterns({
+            keywords: extractTaskKeywords(task),
+            tags: [normalizedAgentName, "auto-learned"],
+            limit: 3,
+        })
+            .map((p) => `[LEARNED] ${p.name}: ${p.description}`)
+            .join("\n");
+        // 3. Construct the Optimized Prompt
+        const fullPrompt = `
+Task: ${task}
+
+${contextPrompt}
+
+${recentThoughts ? `## Recent Thoughts/Context\n${recentThoughts}\n` : ""}
+
+${learnedPatterns ? `## Learned Patterns\n${learnedPatterns}\n` : ""}
+
+${fileContext ? `## Related Files\n${fileContext}\n` : ""}
+
+Instructions:
+- Use the provided context to inform your response.
+- If you generate code, ensure it follows the project standards.
+`;
+        // 4. Validate required task parameters
+        const taskParams = {
+            agent: normalizedAgentName,
+            prompt: fullPrompt,
+            // Ensure required fields are always present per Synapse V5
+            load_skills: [],
+            run_in_background: false,
+            // Use a generic low-effort category; can be refined later
+            category: "unspecified-low",
+        };
+        const callStartTime = Date.now();
+        const result = await this.bridge.callTool({
+            tool: "task",
+            ...taskParams,
+        });
+        // 5. Analyze execution and learn from it
+        const execTimeMs = result.metadata?.executionTime ?? Date.now() - callStartTime;
+        const adaptedResult = {
+            success: result.success,
+            output: String(result.output ?? ""),
+            error: result.error ?? "",
+        };
+        const insights = this.analyzeExecution(normalizedAgentName, task, adaptedResult, execTimeMs, timeoutMs, null);
+        // 6. Record thought with enriched learning data
+        let thoughtID;
+        if (result.success) {
+            thoughtID = this.thoughts.createThought({
+                title: `Delegation to ${agentName}: ${task.substring(0, 30)}...`,
+                type: "plan",
+                content: [
+                    `Task: ${task}`,
+                    `Agent: ${agentName}`,
+                    `Confidence: ${insights.confidenceScore.toFixed(2)}`,
+                    `Completeness: ${insights.resultCompleteness.toFixed(2)}`,
+                    `Quality: ${insights.resultQuality.toFixed(2)}`,
+                    insights.failureMode ? `Failure Mode: ${insights.failureMode}` : null,
+                    insights.recommendations.length > 0
+                        ? `Recommendations:\n${insights.recommendations.map((r) => `  - ${r}`).join("\n")}`
+                        : null,
+                    `\nResult:\n${String(result.output ?? "")}`,
+                ]
+                    .filter(Boolean)
+                    .join("\n\n"),
+                tags: [
+                    "delegation",
+                    agentName,
+                    "auto-generated",
+                    `confidence-${Math.round(insights.confidenceScore * 100)}`,
+                ],
+                relatedFiles: relatedFiles,
+            });
+        }
+        else {
+            // Record failures as analysis thoughts for post-mortem
+            this.thoughts.createThought({
+                title: `Failed delegation to ${agentName}: ${task.substring(0, 30)}...`,
+                type: "analysis",
+                content: [
+                    `Task: ${task}`,
+                    `Agent: ${agentName}`,
+                    `Failure Mode: ${insights.failureMode || "unknown"}`,
+                    `Error: ${result.error ?? ""}`,
+                    `Confidence: ${insights.confidenceScore.toFixed(2)}`,
+                    insights.recommendations.length > 0
+                        ? `Recommendations:\n${insights.recommendations.map((r) => `  - ${r}`).join("\n")}`
+                        : null,
+                ]
+                    .filter(Boolean)
+                    .join("\n\n"),
+                tags: [
+                    "delegation-failed",
+                    agentName,
+                    "auto-generated",
+                    insights.failureMode || "unknown",
+                ],
+                relatedFiles: relatedFiles,
+            });
+        }
+        return {
+            success: result.success,
+            output: String(result.output || result.error || "No output"),
+            agent: normalizedAgentName,
+            thoughtID,
+        };
+    }
+    // ========================================================================
+    // Self-Learning Execution Loop
+    // ========================================================================
+    /**
+     * Executes a task, validates the result with a real validation command,
+     * analyzes the outcome to extract meaningful patterns, and updates the
+     * learning store and context system with actionable insights.
+     *
+     * The confidence score is calculated from four dimensions:
+     * - Result completeness (structural analysis of output)
+     * - Result quality (absence of errors, reasonable length)
+     * - Pattern consistency (matches historical success patterns)
+     * - Execution time (within expected range)
+     */
+    async learnFromExecution(agentName, task, validationCmd) {
+        const result = await this.delegate(agentName, task);
+        if (!result.success) {
+            // Delegation already recorded the failure in analyzeExecution
+            return result;
+        }
+        let validationPassed = null;
+        if (validationCmd) {
+            console.log(`🧪 Validating result with: ${validationCmd}`);
+            try {
+                const validation = await this.bridge.runBash(validationCmd);
+                validationPassed = validation.success;
+                if (validation.success) {
+                    console.log("✅ Validation passed! Recording verified pattern...");
+                    // Record a verified, high-confidence workflow pattern
+                    this.context.addPattern({
+                        type: "workflow",
+                        name: `Verified workflow: ${task.substring(0, 40)}...`,
+                        description: [
+                            `Agent ${agentName} successfully completed and passed validation.`,
+                            `Validation: ${validationCmd}`,
+                            `Task: ${task.substring(0, 150)}`,
+                        ].join(" "),
+                        examples: [
+                            {
+                                input: task,
+                                output: `Validated (thought: ${result.thoughtID || "N/A"})`,
+                                explanation: `Passed validation command: ${validationCmd}`,
+                            },
+                        ],
+                        tags: ["verified", agentName, "auto-learned"],
+                    });
+                }
+                else {
+                    console.warn("❌ Validation failed. Recording failure pattern...");
+                    const validationError = typeof validation.error === "string"
+                        ? validation.error
+                        : typeof validation.output === "string"
+                            ? validation.output
+                            : "Unknown validation error";
+                    this.context.addPattern({
+                        type: "workflow",
+                        name: `Validation failure: ${agentName} → ${task.substring(0, 30)}...`,
+                        description: [
+                            `Agent ${agentName} completed but validation failed.`,
+                            `Validation cmd: ${validationCmd}`,
+                            `Error: ${validationError.substring(0, 200)}`,
+                        ].join(" "),
+                        examples: [
+                            {
+                                input: task,
+                                output: `Validation failed: ${validationError.substring(0, 100)}`,
+                                explanation: "Output was generated but did not pass validation checks",
+                            },
+                        ],
+                        tags: ["validation-failed", agentName, "auto-learned"],
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️ Validation command error: ${error instanceof Error ? error.message : String(error)}`);
+                validationPassed = false;
+            }
+            // Re-analyze with validation result factored in
+            // This updates the learning store with the validation outcome
+            const normalizedAgent = normalizeAgentName(agentName);
+            const lastRecord = this.learningStore.records[this.learningStore.records.length - 1];
+            if (lastRecord && lastRecord.agent === normalizedAgent) {
+                lastRecord.validationPassed = validationPassed;
+                if (!validationPassed) {
+                    lastRecord.failureMode = "validation_failed";
+                    lastRecord.success = false;
+                    // Adjust confidence downward for validation failure
+                    lastRecord.confidenceScore = Math.max(0, lastRecord.confidenceScore * 0.5);
+                }
+                else {
+                    // Boost confidence for validation success
+                    lastRecord.confidenceScore = Math.min(1, lastRecord.confidenceScore * 1.15);
+                }
+                this.saveLearningStore();
+            }
+        }
+        return result;
+    }
+    // ========================================================================
+    // Introspection API
+    // ========================================================================
+    /**
+     * Get aggregated learning statistics for all agents.
+     */
+    getAgentStats() {
+        return { ...this.learningStore.agentStats };
+    }
+    /**
+     * Get recent execution records, optionally filtered by agent.
+     */
+    getRecentExecutions(limit = 10, agent) {
+        let records = [...this.learningStore.records];
+        if (agent) {
+            const normalized = normalizeAgentName(agent);
+            records = records.filter((r) => r.agent === normalized);
+        }
+        return records.slice(-limit);
+    }
+    /**
+     * Get success rate for a specific agent.
+     */
+    getSuccessRate(agent) {
+        const normalized = normalizeAgentName(agent);
+        const stats = this.learningStore.agentStats[normalized];
+        if (!stats || stats.totalExecutions === 0)
+            return 0;
+        return stats.successCount / stats.totalExecutions;
+    }
+}
+//# sourceMappingURL=agent-delegate.js.map