closed-loop-cli 1.0.0

package/dist/orchestrator/meta-agent.js

@@ -0,0 +1,421 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSelfImprovingTask = runSelfImprovingTask;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const task_agent_1 = require("./task-agent");
+const shell_tools_1 = require("../tools/shell-tools");
+const sahoo_gateway_1 = require("./sahoo-gateway");
+const diff_tools_1 = require("../tools/diff-tools");
+const repo_map_1 = require("../tools/repo-map");
+const agent_prompts_1 = require("./agent-prompts");
+const state_manager_1 = require("./state-manager");
+const tui_tools_1 = require("../tools/tui-tools");
+const research_manager_1 = require("./research-manager");
+const microagent_registry_1 = require("./microagent-registry");
+const event_stream_1 = require("./event-stream");
+// Load environment variables
+dotenv.config();
+const apiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || '';
+const baseURL = process.env.ANTHROPIC_BASE_URL || undefined;
+const defaultModel = process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]';
+const anthropic = new sdk_1.default({
+    apiKey: apiKey,
+    baseURL: baseURL,
+});
+/**
+ * Runs a task inside the closed-loop system:
+ * 1. Reads current codebase rules (CLAUDE.md) and past experiences (Learnings.md).
+ * 2. Prepends memory context to the prompt.
+ * 3. Executes Task Agent.
+ * 4. Extracts learnings from the session logs and writes them back to Learnings.md.
+ */
+function getRoleSystemPrompt(role, claudeContext, learningsContext, repoMapContext, osContext, microagentsContext) {
+    let rolePrompt = '';
+    switch (role) {
+        case 'architect':
+            rolePrompt = agent_prompts_1.ARCHITECT_PROMPT;
+            break;
+        case 'coder':
+            rolePrompt = agent_prompts_1.CODER_PROMPT;
+            break;
+        case 'coder_codeact':
+            rolePrompt = agent_prompts_1.CODEACT_CODER_PROMPT;
+            break;
+        case 'debugger':
+            rolePrompt = agent_prompts_1.DEBUGGER_PROMPT;
+            break;
+        case 'gatekeeper':
+            rolePrompt = agent_prompts_1.GATEKEEPER_PROMPT;
+            break;
+    }
+    // Load custom playbooks from the Skill Registry
+    let skillsSummary = 'No custom development skills recorded yet.';
+    try {
+        const { getSkillsSummary } = require('../tools/skills');
+        skillsSummary = getSkillsSummary();
+    }
+    catch (e) { }
+    return `You are operating inside a self-improving workspace. You have specialized responsibilities.
+ROLE SPECIFICATION:
+${rolePrompt}
+
+---
+CRITICAL WORKSPACE GUIDELINES (CLAUDE.md):
+${claudeContext}
+
+---
+REUSABLE DEVELOPMENT SKILLS (Playbooks derived from past successful evolutions):
+${skillsSummary}
+
+---
+PAST EXPERIENCE & LEARNINGS (Learnings.md):
+${learningsContext}
+
+---
+DYNAMICS & INSTRUCTIONS FROM MICROAGENTS:
+${microagentsContext || 'No microagents active for this context.'}
+
+---
+CODEBASE REPOSITORY MAP (Overview of files and structural signatures):
+${repoMapContext}
+---
+` + osContext;
+}
+async function runSelfImprovingTask(task, effort = 'standard', codeactMode = false) {
+    const workspaceRoot = process.cwd();
+    const claudePath = path.join(workspaceRoot, 'CLAUDE.md');
+    const learningsPath = path.join(workspaceRoot, 'Learnings.md');
+    // 1. Read CLAUDE.md and Learnings.md context
+    let claudeContext = '';
+    let learningsContext = '';
+    if (fs.existsSync(claudePath)) {
+        claudeContext = fs.readFileSync(claudePath, 'utf-8');
+    }
+    if (fs.existsSync(learningsPath)) {
+        learningsContext = fs.readFileSync(learningsPath, 'utf-8');
+    }
+    // Generate AST Code Index
+    try {
+        const { generateCodeIndex } = require('../tools/indexer');
+        console.log(`\x1b[34m[MetaAgent]\x1b[0m Generating AST code index (code-index.json)...`);
+        generateCodeIndex(workspaceRoot);
+    }
+    catch (err) {
+        console.error(`\x1b[31m[MetaAgent] Failed to generate code index: ${err.message}\x1b[0m`);
+    }
+    // Generate Repository Map
+    let repoMapContext = '';
+    try {
+        repoMapContext = (0, repo_map_1.generateRepoMap)(workspaceRoot);
+    }
+    catch (err) {
+        console.error(`\x1b[31m[MetaAgent] Failed to generate codebase map: ${err.message}\x1b[0m`);
+    }
+    console.log(`\x1b[34m[MetaAgent]\x1b[0m Ingesting memory context and codebase map...`);
+    // Inject OS environment awareness to guide command execution safely
+    const osType = process.platform === 'win32' ? 'Windows (win32)' : process.platform;
+    const shellType = process.platform === 'win32' ? 'PowerShell or Command Prompt (cmd.exe)' : 'Bash or Sh';
+    const osContext = `\n\n---
+CURRENT ENVIRONMENT & OS SAFETY GUIDELINES:
+- Operating System: ${osType}
+- Active Terminal Shell: ${shellType}
+${process.platform === 'win32' ? `
+IMPORTANT: You are running on Windows. Unix terminal commands such as 'cat', 'ls', 'grep', 'rm -rf', and pipes like '| head' or '| grep' are NOT supported natively.
+- Use Windows/PowerShell equivalent commands (e.g., 'Get-Content' instead of 'cat', 'dir' or 'Get-ChildItem' instead of 'ls', and Node scripts or PowerShell commands for string filtering).
+- Keep commands compatible with Windows environment syntax.` : `
+- Use Unix terminal commands natively compatible with the active shell.`}
+---`;
+    let targetFile = '';
+    let dependencyWarning = '';
+    if (task.includes('Refactor the file "')) {
+        targetFile = task.split('"')[1];
+    }
+    else if (task.includes('file "')) {
+        targetFile = task.split('"')[1];
+    }
+    if (targetFile) {
+        try {
+            const { getDependents } = require('../tools/indexer');
+            const dependents = getDependents(targetFile, workspaceRoot);
+            if (dependents.length > 0) {
+                dependencyWarning = `\n\n---
+DEPENDENCY WARNING:
+The file you are modifying ("${targetFile}") is imported by the following files in this project:
+${dependents.map((f) => `- ${f}`).join('\n')}
+
+IMPORTANT: Make sure that any changes to function signatures, classes, or exported variables do not break these importing files. If you change exports, you must also update the files importing them.
+---`;
+                console.log(`\x1b[33m[Dependency Guard] Target file "${targetFile}" is imported by: ${JSON.stringify(dependents)}\x1b[0m\n`);
+            }
+        }
+        catch (e) {
+            console.error('[Dependency Guard] Failed to resolve dependents:', e);
+        }
+    }
+    // Load Microagents context
+    const registry = microagent_registry_1.MicroagentRegistry.getInstance();
+    registry.loadMicroagents(); // reload to get latest updates
+    const matchingAgents = registry.findMatchingMicroagents(task);
+    let microagentsContext = '';
+    if (matchingAgents.length > 0) {
+        microagentsContext = matchingAgents.map(a => `[Microagent: ${a.name}]\nInstructions:\n${a.instructions}`).join('\n\n');
+        console.log(`\x1b[32m[MicroagentRegistry]\x1b[0m Triggered Microagents: ${matchingAgents.map(a => a.name).join(', ')}`);
+        event_stream_1.EventStream.getInstance().publish('system', 'log', 'MicroagentsTriggered', `Triggered microagents: ${matchingAgents.map(a => a.name).join(', ')}`);
+    }
+    let result = '';
+    let errorMsg = '';
+    const startTime = new Date();
+    try {
+        // Phase 1: Architect / Planner Agent
+        (0, tui_tools_1.printAgentHeader)('architect');
+        research_manager_1.ResearchManager.logDecision('Architect (Planner)', 'Spawning Planner Agent to generate implementation plan', 'info');
+        const architectPrompt = getRoleSystemPrompt('architect', claudeContext, learningsContext, repoMapContext, osContext, microagentsContext);
+        const architectReport = await (0, task_agent_1.runTaskAgent)(task + dependencyWarning, {
+            systemPrompt: architectPrompt,
+            role: 'architect',
+            effort
+        });
+        const plan = architectReport.result;
+        console.log(`\x1b[32m[MetaAgent]\x1b[0m Plan generated successfully:\n${plan}\n`);
+        research_manager_1.ResearchManager.logDecision('Architect (Planner)', 'Plan generated successfully', 'success', plan);
+        // Phase 2: Coder Agent
+        (0, tui_tools_1.printAgentHeader)('coder');
+        research_manager_1.ResearchManager.logDecision('Coder (Worker)', `Spawning Coder Agent to apply mutations (CodeAct=${codeactMode})`, 'info');
+        const coderPrompt = getRoleSystemPrompt(codeactMode ? 'coder_codeact' : 'coder', claudeContext, learningsContext, repoMapContext, osContext, microagentsContext);
+        const coderReport = await (0, task_agent_1.runTaskAgent)(`Here is the task you must implement:\n"${task}"\n\nHere is the approved design plan/blueprint to guide your implementation:\n"""\n${plan}\n"""\n\nPlease implement the code changes as planned. Use editFile or writeFile to execute the plan.`, {
+            systemPrompt: coderPrompt,
+            role: codeactMode ? 'coder_codeact' : 'coder',
+            effort
+        });
+        result = coderReport.result;
+        console.log(`\x1b[32m[MetaAgent]\x1b[0m Code mutations applied.`);
+        research_manager_1.ResearchManager.logDecision('Coder (Worker)', 'Coder mutated files successfully based on design plan', 'success', result);
+        // Phase 3: Inner Self-Healing Loop (Debugger <-> Coder)
+        const healCycles = 3;
+        let buildSuccess = false;
+        let testSuccess = false;
+        for (let cycle = 1; cycle <= healCycles; cycle++) {
+            console.log(`\n\x1b[34m[MetaAgent]\x1b[0m Verification Loop - Cycle ${cycle}/${healCycles}: Running compilation check...`);
+            research_manager_1.ResearchManager.logDecision('Verification', `Running compilation check (Cycle ${cycle}/${healCycles})`, 'info');
+            const compileRes = await (0, shell_tools_1.runCommand)('npm run build');
+            buildSuccess = compileRes.exitCode === 0;
+            console.log(`\x1b[34m[MetaAgent]\x1b[0m Verification Loop - Cycle ${cycle}/${healCycles}: Running tests check...`);
+            research_manager_1.ResearchManager.logDecision('Verification', `Running unit tests (Cycle ${cycle}/${healCycles})`, 'info');
+            const testRes = await (0, shell_tools_1.runCommand)('npm test');
+            testSuccess = testRes.exitCode === 0;
+            if (buildSuccess && testSuccess) {
+                console.log(`\x1b[32m[MetaAgent]\x1b[0m Codebase compile & test execution passed! Code is healthy.\x1b[0m`);
+                research_manager_1.ResearchManager.logDecision('Verification', 'Compilation & unit tests passed successfully', 'success');
+                break;
+            }
+            const errorLog = `Compilation Output:\nExit Code: ${compileRes.exitCode}\nStdout:\n${compileRes.stdout}\nStderr:\n${compileRes.stderr}\n\nTest Suite Output:\nExit Code: ${testRes.exitCode}\nStdout:\n${testRes.stdout}\nStderr:\n${testRes.stderr}`;
+            research_manager_1.ResearchManager.logDecision('Verification', `Build/tests failed (Cycle ${cycle}/${healCycles})`, 'failure', errorLog);
+            if (cycle < healCycles) {
+                (0, tui_tools_1.printAgentHeader)('debugger');
+                console.log(`\x1b[33m[MetaAgent] Build/tests failed. Invoking Diagnostics & Debugger Agent to analyze errors...\x1b[0m`);
+                research_manager_1.ResearchManager.logDecision('Debugger', 'Spawning Debugger Agent to analyze compilation/test errors', 'info');
+                const debuggerPrompt = getRoleSystemPrompt('debugger', claudeContext, learningsContext, repoMapContext, osContext, microagentsContext);
+                const debuggerReport = await (0, task_agent_1.runTaskAgent)(`The code modification failed verification. Here is the compile/test execution log:\n\n${errorLog}\n\nPlease inspect the error trace, identify the exact lines and files of code that caused the issue, and output a specific, actionable instruction for the Coder agent to fix it. Do NOT make file changes yourself.`, {
+                    systemPrompt: debuggerPrompt,
+                    role: 'debugger',
+                    effort
+                });
+                console.log(`\x1b[33m[MetaAgent] Diagnostic feedback received. Re-running Coder Agent to apply the fix...\x1b[0m`);
+                research_manager_1.ResearchManager.logDecision('Debugger', 'Diagnostic advice generated', 'success', debuggerReport.result);
+                research_manager_1.ResearchManager.logDecision('Coder (Worker)', `Applying corrections based on diagnostic instructions (Cycle ${cycle}/${healCycles})`, 'info');
+                const correctionTask = `The previous implementation caused build/test failures.
+Here is the error trace:
+${errorLog}
+
+Here is the diagnostic instruction from the Debugger agent:
+"${debuggerReport.result}"
+
+Please make the necessary file edits (using editFile or writeFile) to correct the codebase.`;
+                const recoderReport = await (0, task_agent_1.runTaskAgent)(correctionTask, {
+                    systemPrompt: coderPrompt,
+                    role: 'coder',
+                    effort
+                });
+                result = recoderReport.result;
+                research_manager_1.ResearchManager.logDecision('Coder (Worker)', `Applied corrections (Cycle ${cycle}/${healCycles})`, 'success');
+            }
+            else {
+                console.log(`\x1b[31m[MetaAgent] Build/tests failed after maximum self-healing cycles.\x1b[0m`);
+                research_manager_1.ResearchManager.logDecision('Verification', `Self-healing failed to stabilize build and tests after ${healCycles} attempts`, 'failure');
+                throw new Error(`Self-healing failed to stabilize build and tests after ${healCycles} attempts.\n${errorLog}`);
+            }
+        }
+        // Phase 4: Gatekeeper & Reviewer Agent
+        (0, tui_tools_1.printAgentHeader)('gatekeeper');
+        research_manager_1.ResearchManager.logDecision('Gatekeeper', 'Spawning Gatekeeper Agent to perform safety and quality review', 'info');
+        const gatekeeperPrompt = getRoleSystemPrompt('gatekeeper', claudeContext, learningsContext, repoMapContext, osContext, microagentsContext);
+        // Find modified files via git status
+        const gitStatus = await (0, shell_tools_1.runCommand)('git status --porcelain');
+        const modifiedFiles = [];
+        if (gitStatus.exitCode === 0 && gitStatus.stdout.trim()) {
+            const lines = gitStatus.stdout.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith('M ') || trimmed.startsWith('A ') || trimmed.startsWith('?? ')) {
+                    const filePath = trimmed.substring(2).trim();
+                    if (filePath && !filePath.includes('Learnings.md') && !filePath.includes('.env') && !filePath.includes('code-index.json')) {
+                        modifiedFiles.push(filePath);
+                    }
+                }
+            }
+        }
+        console.log(`\x1b[34m[MetaAgent]\x1b[0m Modified files detected: ${JSON.stringify(modifiedFiles)}`);
+        if (modifiedFiles.length > 0) {
+            const diffRes = await (0, shell_tools_1.runCommand)('git diff');
+            const reviewerReport = await (0, task_agent_1.runTaskAgent)(`Please review the modifications in the git diff below and confirm if they compile and are safe:\n\n${diffRes.stdout}\n\nIf anything is unsafe or incorrect, raise a concern.`, {
+                systemPrompt: gatekeeperPrompt,
+                role: 'gatekeeper',
+                effort
+            });
+            console.log(`\x1b[32m[MetaAgent]\x1b[0m Reviewer comments:\n${reviewerReport.result}\n`);
+            research_manager_1.ResearchManager.logDecision('Gatekeeper', 'Safety & quality audit report complete', 'success', reviewerReport.result);
+            for (const filePath of modifiedFiles) {
+                const fullPath = path.join(workspaceRoot, filePath);
+                let afterContent = '';
+                if (fs.existsSync(fullPath)) {
+                    afterContent = fs.readFileSync(fullPath, 'utf-8');
+                }
+                // Get beforeContent using git show HEAD:path
+                let beforeContent = '';
+                try {
+                    const beforeRes = await (0, shell_tools_1.runCommand)(`git show HEAD:${filePath.replace(/\\/g, '/')}`);
+                    if (beforeRes.exitCode === 0) {
+                        beforeContent = beforeRes.stdout;
+                    }
+                }
+                catch (e) {
+                    // If file is new, beforeContent remains empty
+                }
+                research_manager_1.ResearchManager.logDecision('SAHOO Safety Gate', `Evaluating SAHOO policies for ${filePath}`, 'info');
+                const sahooRes = (0, sahoo_gateway_1.evaluateSahoo)(filePath, beforeContent, afterContent, buildSuccess, testSuccess);
+                if (!sahooRes.passed) {
+                    console.log(`\x1b[31m[SAHOO HALT TRIGGERED]\x1b[0m ${sahooRes.reason}`);
+                    console.log(`\x1b[31m[MetaAgent] SAHOO Gateway Rejected changes. Rolling back codebase...\x1b[0m`);
+                    research_manager_1.ResearchManager.logDecision('SAHOO Safety Gate', `SAHOO rejected change in ${filePath}: ${sahooRes.reason}`, 'failure');
+                    (0, state_manager_1.updateEvolutionState)({
+                        lastRefactorResult: {
+                            success: false,
+                            targetFile: filePath,
+                            message: `SAHOO Gateway Rejected: ${sahooRes.reason}`,
+                            time: new Date().toISOString(),
+                            metrics: sahooRes.metrics,
+                            reason: sahooRes.reason
+                        }
+                    });
+                    // Execute git rollback (revert all changes)
+                    research_manager_1.ResearchManager.logDecision('Rollback', 'Reverting workspace modifications via git reset to preserve stability', 'info');
+                    await (0, shell_tools_1.runCommand)('git reset --hard HEAD');
+                    await (0, shell_tools_1.runCommand)('git clean -fd');
+                    throw new Error(`SAHOO Policy Violation: ${sahooRes.reason}. Reverted all changes to preserve system stability.`);
+                }
+                else {
+                    console.log(`\x1b[32m[SAHOO Passed]\x1b[0m File: ${filePath} | GDI: ${sahooRes.metrics.goalDriftIndex.toFixed(3)} | CPS: ${sahooRes.metrics.constraintPreservationScore}`);
+                    console.log(await (0, diff_tools_1.getFormattedDiff)(filePath));
+                    research_manager_1.ResearchManager.logDecision('SAHOO Safety Gate', `SAHOO passed for ${filePath}`, 'success');
+                    (0, state_manager_1.updateEvolutionState)({
+                        lastRefactorResult: {
+                            success: true,
+                            targetFile: filePath,
+                            message: 'SAHOO Gateway passed.',
+                            time: new Date().toISOString(),
+                            metrics: sahooRes.metrics
+                        }
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        errorMsg = err.message;
+        console.error(`\x1b[31m[MetaAgent] Multi-Agent run encountered an error: ${errorMsg}\x1b[0m`);
+    }
+    const endTime = new Date();
+    const elapsedMinutes = ((endTime.getTime() - startTime.getTime()) / 60000).toFixed(1);
+    // 4. Summarize and write learnings to Learnings.md (Closing the Loop)
+    console.log(`\x1b[34m[MetaAgent]\x1b[0m Synthesizing learnings from session...`);
+    const dateStr = startTime.toISOString().split('T')[0];
+    const summaryPrompt = `Based on the following session logs, extract the key learnings in the strict Learnings.md format.
+Include:
+1. Observation (สิ่งที่พบ): What succeeded, failed, linter errors, or quirks of the codebase.
+2. Action (การแก้ไข): The precise changes, command fixes, or prompt templates adjusted.
+3. Confidence: A decimal from 0.0 to 1.0.
+
+Session Details:
+- Task: "${task}"
+- Duration: ${elapsedMinutes} minutes
+- Status: ${errorMsg ? 'FAILED with error: ' + errorMsg : 'SUCCESS'}
+- Agent Output: "${result}"
+
+Return ONLY the markdown section matching:
+### YYYY-MM-DD - [Task Name]
+- **Observation (สิ่งที่พบ)**: ...
+- **Action (การแก้ไข)**: ...
+- **Confidence (ความมั่นใจ 0-1)**: ...
+`;
+    try {
+        const summaryResponse = await anthropic.messages.create({
+            model: defaultModel,
+            max_tokens: 1000,
+            messages: [{ role: 'user', content: summaryPrompt }],
+        });
+        const summaryBlock = summaryResponse.content.find(b => b.type === 'text');
+        if (summaryBlock && summaryBlock.text) {
+            const learningsText = summaryBlock.text.trim();
+            console.log(`\n\x1b[32m[New Learnings Formulated]:\x1b[0m\n${learningsText}\n`);
+            // Append to Learnings.md
+            fs.appendFileSync(learningsPath, `\n${learningsText}\n`, 'utf-8');
+            console.log(`\x1b[34m[MetaAgent]\x1b[0m Successfully updated Learnings.md`);
+        }
+    }
+    catch (summaryErr) {
+        console.error(`\x1b[31m[MetaAgent] Failed to write learnings to Learnings.md: ${summaryErr.message}\x1b[0m`);
+    }
+    if (errorMsg) {
+        throw new Error(errorMsg);
+    }
+    return result;
+}

package/dist/orchestrator/microagent-registry.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroagentRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MicroagentRegistry {
+    static instance;
+    microagents = [];
+    dirPath;
+    constructor() {
+        this.dirPath = path.join(process.cwd(), 'src', 'orchestrator', 'microagents');
+        this.ensureDirectoryExists();
+        this.loadMicroagents();
+    }
+    static getInstance() {
+        if (!MicroagentRegistry.instance) {
+            MicroagentRegistry.instance = new MicroagentRegistry();
+        }
+        return MicroagentRegistry.instance;
+    }
+    ensureDirectoryExists() {
+        if (!fs.existsSync(this.dirPath)) {
+            fs.mkdirSync(this.dirPath, { recursive: true });
+        }
+    }
+    loadMicroagents() {
+        this.microagents = [];
+        if (!fs.existsSync(this.dirPath))
+            return;
+        try {
+            const files = fs.readdirSync(this.dirPath);
+            for (const file of files) {
+                if (file.endsWith('.md')) {
+                    const filePath = path.join(this.dirPath, file);
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const microagent = this.parseMicroagent(content);
+                    if (microagent) {
+                        this.microagents.push(microagent);
+                    }
+                }
+            }
+            console.log(`[MicroagentRegistry] Loaded ${this.microagents.length} microagents.`);
+        }
+        catch (e) {
+            console.error('[MicroagentRegistry] Failed to load microagents:', e);
+        }
+    }
+    parseMicroagent(content) {
+        // Simple YAML frontmatter parser
+        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+        if (!match)
+            return null;
+        const frontmatter = match[1];
+        const instructions = match[2].trim();
+        const metadata = {};
+        const lines = frontmatter.split('\n');
+        for (const line of lines) {
+            const parts = line.split(':');
+            if (parts.length >= 2) {
+                const key = parts[0].trim();
+                const value = parts.slice(1).join(':').trim();
+                metadata[key] = value;
+            }
+        }
+        if (!metadata.name || !metadata.trigger) {
+            return null;
+        }
+        return {
+            name: metadata.name,
+            trigger: metadata.trigger,
+            description: metadata.description || '',
+            instructions
+        };
+    }
+    getMicroagents() {
+        return this.microagents;
+    }
+    /**
+     * Returns microagents whose triggers match the query/context string.
+     */
+    findMatchingMicroagents(query) {
+        const matched = [];
+        const lowerQuery = query.toLowerCase();
+        for (const agent of this.microagents) {
+            try {
+                const regex = new RegExp(agent.trigger, 'i');
+                if (regex.test(lowerQuery)) {
+                    matched.push(agent);
+                }
+            }
+            catch (e) {
+                // Fallback to substring match if regex is invalid
+                if (lowerQuery.includes(agent.trigger.toLowerCase())) {
+                    matched.push(agent);
+                }
+            }
+        }
+        return matched;
+    }
+}
+exports.MicroagentRegistry = MicroagentRegistry;