closed-loop-cli 1.0.0

package/src/orchestrator/meta-agent.ts

@@ -0,0 +1,434 @@
+import Anthropic from '@anthropic-ai/sdk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as dotenv from 'dotenv';
+import { runTaskAgent } from './task-agent';
+import { runCommand } from '../tools/shell-tools';
+import { evaluateSahoo } from './sahoo-gateway';
+import { getFormattedDiff } from '../tools/diff-tools';
+import { generateRepoMap } from '../tools/repo-map';
+import { ARCHITECT_PROMPT, CODER_PROMPT, CODEACT_CODER_PROMPT, DEBUGGER_PROMPT, GATEKEEPER_PROMPT } from './agent-prompts';
+import { updateEvolutionState } from './state-manager';
+import { printAgentHeader, printCollapsibleBlock } from '../tools/tui-tools';
+import { ResearchManager } from './research-manager';
+import { MicroagentRegistry } from './microagent-registry';
+import { EventStream } from './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 Anthropic({
+  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: 'architect' | 'coder' | 'debugger' | 'gatekeeper' | 'coder_codeact',
+  claudeContext: string,
+  learningsContext: string,
+  repoMapContext: string,
+  osContext: string,
+  microagentsContext: string
+): string {
+  let rolePrompt = '';
+  switch (role) {
+    case 'architect':
+      rolePrompt = ARCHITECT_PROMPT;
+      break;
+    case 'coder':
+      rolePrompt = CODER_PROMPT;
+      break;
+    case 'coder_codeact':
+      rolePrompt = CODEACT_CODER_PROMPT;
+      break;
+    case 'debugger':
+      rolePrompt = DEBUGGER_PROMPT;
+      break;
+    case 'gatekeeper':
+      rolePrompt = 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;
+}
+
+export async function runSelfImprovingTask(task: string, effort: 'standard' | 'ultracode' = 'standard', codeactMode = false): Promise<string> {
+  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: any) {
+    console.error(`\x1b[31m[MetaAgent] Failed to generate code index: ${err.message}\x1b[0m`);
+  }
+
+  // Generate Repository Map
+  let repoMapContext = '';
+  try {
+    repoMapContext = generateRepoMap(workspaceRoot);
+  } catch (err: any) {
+    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: string) => `- ${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 = 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(', ')}`);
+    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
+    printAgentHeader('architect');
+    ResearchManager.logDecision('Architect (Planner)', 'Spawning Planner Agent to generate implementation plan', 'info');
+    const architectPrompt = getRoleSystemPrompt('architect', claudeContext, learningsContext, repoMapContext, osContext, microagentsContext);
+    const architectReport = await 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`);
+    ResearchManager.logDecision('Architect (Planner)', 'Plan generated successfully', 'success', plan);
+
+    // Phase 2: Coder Agent
+    printAgentHeader('coder');
+    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 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' as any : 'coder',
+      effort
+    });
+    result = coderReport.result;
+    console.log(`\x1b[32m[MetaAgent]\x1b[0m Code mutations applied.`);
+    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...`);
+      ResearchManager.logDecision('Verification', `Running compilation check (Cycle ${cycle}/${healCycles})`, 'info');
+      const compileRes = await runCommand('npm run build');
+      buildSuccess = compileRes.exitCode === 0;
+
+      console.log(`\x1b[34m[MetaAgent]\x1b[0m Verification Loop - Cycle ${cycle}/${healCycles}: Running tests check...`);
+      ResearchManager.logDecision('Verification', `Running unit tests (Cycle ${cycle}/${healCycles})`, 'info');
+      const testRes = await 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`);
+        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}`;
+      ResearchManager.logDecision('Verification', `Build/tests failed (Cycle ${cycle}/${healCycles})`, 'failure', errorLog);
+
+      if (cycle < healCycles) {
+        printAgentHeader('debugger');
+        console.log(`\x1b[33m[MetaAgent] Build/tests failed. Invoking Diagnostics & Debugger Agent to analyze errors...\x1b[0m`);
+        ResearchManager.logDecision('Debugger', 'Spawning Debugger Agent to analyze compilation/test errors', 'info');
+        const debuggerPrompt = getRoleSystemPrompt('debugger', claudeContext, learningsContext, repoMapContext, osContext, microagentsContext);
+        const debuggerReport = await 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`);
+        ResearchManager.logDecision('Debugger', 'Diagnostic advice generated', 'success', debuggerReport.result);
+        
+        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 runTaskAgent(correctionTask, {
+          systemPrompt: coderPrompt,
+          role: 'coder',
+          effort
+        });
+        result = recoderReport.result;
+        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`);
+        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
+    printAgentHeader('gatekeeper');
+    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 runCommand('git status --porcelain');
+    const modifiedFiles: string[] = [];
+
+    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 runCommand('git diff');
+      const reviewerReport = await 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`);
+      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 runCommand(`git show HEAD:${filePath.replace(/\\/g, '/')}`);
+          if (beforeRes.exitCode === 0) {
+            beforeContent = beforeRes.stdout;
+          }
+        } catch (e) {
+          // If file is new, beforeContent remains empty
+        }
+        
+        ResearchManager.logDecision('SAHOO Safety Gate', `Evaluating SAHOO policies for ${filePath}`, 'info');
+        const sahooRes = 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`);
+          ResearchManager.logDecision('SAHOO Safety Gate', `SAHOO rejected change in ${filePath}: ${sahooRes.reason}`, 'failure');
+          
+          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)
+          ResearchManager.logDecision('Rollback', 'Reverting workspace modifications via git reset to preserve stability', 'info');
+          await runCommand('git reset --hard HEAD');
+          await 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 getFormattedDiff(filePath));
+          ResearchManager.logDecision('SAHOO Safety Gate', `SAHOO passed for ${filePath}`, 'success');
+
+          updateEvolutionState({
+            lastRefactorResult: {
+              success: true,
+              targetFile: filePath,
+              message: 'SAHOO Gateway passed.',
+              time: new Date().toISOString(),
+              metrics: sahooRes.metrics
+            }
+          });
+        }
+      }
+    }
+  } catch (err: any) {
+    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') as Anthropic.TextBlock | undefined;
+    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: any) {
+    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/src/orchestrator/microagent-registry.ts

@@ -0,0 +1,115 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface Microagent {
+  name: string;
+  trigger: string;
+  description: string;
+  instructions: string;
+}
+
+export class MicroagentRegistry {
+  private static instance: MicroagentRegistry;
+  private microagents: Microagent[] = [];
+  private dirPath: string;
+
+  private constructor() {
+    this.dirPath = path.join(process.cwd(), 'src', 'orchestrator', 'microagents');
+    this.ensureDirectoryExists();
+    this.loadMicroagents();
+  }
+
+  public static getInstance(): MicroagentRegistry {
+    if (!MicroagentRegistry.instance) {
+      MicroagentRegistry.instance = new MicroagentRegistry();
+    }
+    return MicroagentRegistry.instance;
+  }
+
+  private ensureDirectoryExists() {
+    if (!fs.existsSync(this.dirPath)) {
+      fs.mkdirSync(this.dirPath, { recursive: true });
+    }
+  }
+
+  public 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);
+    }
+  }
+
+  private parseMicroagent(content: string): Microagent | null {
+    // 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: any = {};
+    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
+    };
+  }
+
+  public getMicroagents(): Microagent[] {
+    return this.microagents;
+  }
+
+  /**
+   * Returns microagents whose triggers match the query/context string.
+   */
+  public findMatchingMicroagents(query: string): Microagent[] {
+    const matched: Microagent[] = [];
+    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;
+  }
+}

package/src/orchestrator/microagents/git-helper.md

@@ -0,0 +1,11 @@
+---
+name: Git Helper
+trigger: (git|commit|push|checkout|branch|stash)
+description: Provides guidelines for safe and clean Git operations in Closed-Loop
+---
+When executing Git operations:
+1. Do not use `--force` on any shared branches.
+2. Ensure you never commit uncompiled or failing code to main branches.
+3. Use clear, descriptive commit messages containing the task details.
+4. If rolling back, use git reset --hard HEAD followed by git clean -fd.
+5. Never attempt to push to remote unless explicitly authorized.

package/src/orchestrator/microagents/test-fixer.md

@@ -0,0 +1,10 @@
+---
+name: Test Fixer
+trigger: (test|fail|error|assert|expect|broken|diagnose)
+description: Provides strategies for diagnosing and repairing broken unit tests
+---
+When repairing failing tests:
+1. Examine the test report details, specifically looking for expected vs actual outcomes.
+2. Check if a dependency change caused regression in other modules.
+3. Keep test logic separate from business logic; don't change tests to fit broken logic unless the test itself is incorrect.
+4. Run npm run build first before running npm test to ensure you are testing the latest version.

package/src/orchestrator/microagents/typescript-expert.md

@@ -0,0 +1,11 @@
+---
+name: TypeScript Expert
+trigger: (\.ts|typescript|tsc|compile|strict|interface|type)
+description: Promotes standard TypeScript guidelines and practices
+---
+TypeScript development guidelines:
+1. Prefer explicit typing over 'any' wherever possible to maintain type safety.
+2. Use interfaces or type aliases for defining structured models.
+3. Make sure to run `npm run build` frequently to catch compilation issues early.
+4. Export only modules, functions, and interfaces that are intended to be public API.
+5. Use correct CommonJS import/export semantics since the target project uses CommonJS.