@holoscript/framework 6.0.3 → 6.0.4

package/src/learning/learning/SemanticClusterer.ts

@@ -0,0 +1,66 @@
+import { EpisodicEvent } from './MemoryScorer';
+
+/**
+ * SemanticClusterer
+ *
+ * Compresses raw temporal Episodic buffers into distilled arrays.
+ * Native distillation drops repeating trivial structures mapping them into aggregated
+ * density nodes explicitly reducing database storage loads across vector boundaries.
+ */
+export class SemanticClusterer {
+  /**
+   * Actively squash sequentially repeating abstract patterns mapping out semantic arrays.
+   */
+  static distill(events: EpisodicEvent[]): EpisodicEvent[] {
+    if (events.length === 0) return [];
+
+    const distilled: EpisodicEvent[] = [];
+    let currentSequence: EpisodicEvent = { ...events[0] };
+    let repetitonCount = 1;
+
+    for (let i = 1; i < events.length; i++) {
+      const ev = events[i];
+
+      // If the Action and Target align, we squash them and increment the density metrics
+      if (this.isSimilar(currentSequence, ev)) {
+        repetitonCount++;
+        currentSequence.outcome = `Repeated action successfully (${repetitonCount} times)`;
+
+        // Track total time span passed over the squash boundary
+        if (!currentSequence.context.timeSpanStarted) {
+          currentSequence.context.timeSpanStarted = currentSequence.timestamp;
+        }
+        currentSequence.context.timeSpanEnded = ev.timestamp;
+      } else {
+        // Similarity broken. Push distilled sequence array and begin anew.
+        if (repetitonCount > 1) {
+          currentSequence.action = `${currentSequence.action}_Aggregated`;
+        }
+        distilled.push({ ...currentSequence });
+
+        currentSequence = { ...ev };
+        repetitonCount = 1;
+      }
+    }
+
+    // Push final buffer
+    if (repetitonCount > 1) {
+      currentSequence.action = `${currentSequence.action}_Aggregated`;
+    }
+    distilled.push(currentSequence);
+
+    return distilled;
+  }
+
+  /**
+   * Determines heuristic thresholds to squash logic natively offline without LLM.
+   */
+  private static isSimilar(a: EpisodicEvent, b: EpisodicEvent): boolean {
+    if (a.action !== b.action) return false;
+
+    const aTarget = a.context?.target || a.context?.location;
+    const bTarget = b.context?.target || b.context?.location;
+
+    return aTarget === bTarget;
+  }
+}

package/src/llm/llm-adapter.ts

@@ -49,11 +49,16 @@ async function callAnthropic(
   const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
   if (!apiKey) throw new Error('ANTHROPIC_API_KEY required');
 
-  const system = messages.filter(m => m.role === 'system').map(m => m.content).join('\n');
-  const userMessages = messages.filter(m => m.role !== 'system').map(m => ({
-    role: m.role as 'user' | 'assistant',
-    content: m.content,
-  }));
+  const system = messages
+    .filter((m) => m.role === 'system')
+    .map((m) => m.content)
+    .join('\n');
+  const userMessages = messages
+    .filter((m) => m.role !== 'system')
+    .map((m) => ({
+      role: m.role as 'user' | 'assistant',
+      content: m.content,
+    }));
 
   const res = await fetch('https://api.anthropic.com/v1/messages', {
     method: 'POST',
@@ -73,7 +78,10 @@ async function callAnthropic(
   });
 
   if (!res.ok) throw new Error(`Anthropic API error: ${res.status}`);
-  const data = await res.json() as { content: Array<{ text: string }>; usage?: { output_tokens: number } };
+  const data = (await res.json()) as {
+    content: Array<{ text: string }>;
+    usage?: { output_tokens: number };
+  };
 
   return {
     content: data.content?.[0]?.text || '',
@@ -105,13 +113,16 @@ async function callOpenAICompatible(
       model: config.model,
       max_tokens: maxTokens,
       temperature,
-      messages: messages.map(m => ({ role: m.role, content: m.content })),
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
     }),
     signal: AbortSignal.timeout(60_000),
   });
 
   if (!res.ok) throw new Error(`${config.provider} API error: ${res.status}`);
-  const data = await res.json() as { choices: Array<{ message: { content: string } }>; usage?: { completion_tokens: number } };
+  const data = (await res.json()) as {
+    choices: Array<{ message: { content: string } }>;
+    usage?: { completion_tokens: number };
+  };
 
   return {
     content: data.choices?.[0]?.message?.content || '',
@@ -142,13 +153,16 @@ async function callOpenRouter(
       model: config.model,
       max_tokens: maxTokens,
       temperature,
-      messages: messages.map(m => ({ role: m.role, content: m.content })),
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
     }),
     signal: AbortSignal.timeout(60_000),
   });
 
   if (!res.ok) throw new Error(`OpenRouter API error: ${res.status}`);
-  const data = await res.json() as { choices: Array<{ message: { content: string } }>; usage?: { completion_tokens: number } };
+  const data = (await res.json()) as {
+    choices: Array<{ message: { content: string } }>;
+    usage?: { completion_tokens: number };
+  };
 
   return {
     content: data.choices?.[0]?.message?.content || '',

package/src/mesh/index.ts

@@ -47,9 +47,15 @@ export class MeshDiscovery {
     return false;
   }
 
-  getPeers(): PeerMetadata[] { return [...this.peers.values()]; }
-  getPeer(id: string): PeerMetadata | undefined { return this.peers.get(id); }
-  getPeerCount(): number { return this.peers.size; }
+  getPeers(): PeerMetadata[] {
+    return [...this.peers.values()];
+  }
+  getPeer(id: string): PeerMetadata | undefined {
+    return this.peers.get(id);
+  }
+  getPeerCount(): number {
+    return this.peers.size;
+  }
 
   pruneStalePeers(timeoutMs: number = 15000): number {
     const now = Date.now();
@@ -97,7 +103,10 @@ export class SignalService {
     this.nodeId = nodeId ?? `node-${Date.now().toString(36)}`;
   }
 
-  broadcastSignal(signal: Omit<MeshSignal, 'nodeId' | 'expiresAt'>, ttlMs: number = 3600000): MeshSignal {
+  broadcastSignal(
+    signal: Omit<MeshSignal, 'nodeId' | 'expiresAt'>,
+    ttlMs: number = 3600000
+  ): MeshSignal {
     const full: MeshSignal = { ...signal, nodeId: this.nodeId, expiresAt: Date.now() + ttlMs };
     this.localSignals.set(`${full.type}:${full.nodeId}`, full);
     return full;
@@ -112,13 +121,14 @@ export class SignalService {
     for (const [key, sig] of this.remoteSignals) {
       if (sig.expiresAt < now) this.remoteSignals.delete(key);
     }
-    return [
-      ...this.remoteSignals.values(),
-      ...this.localSignals.values(),
-    ].filter((s) => s.type === type);
+    return [...this.remoteSignals.values(), ...this.localSignals.values()].filter(
+      (s) => s.type === type
+    );
   }
 
-  getLocalSignals(): MeshSignal[] { return [...this.localSignals.values()]; }
+  getLocalSignals(): MeshSignal[] {
+    return [...this.localSignals.values()];
+  }
 }
 
 // =============================================================================
@@ -160,8 +170,12 @@ export class GossipProtocol {
     return absorbed;
   }
 
-  getPool(): Map<string, GossipPacket> { return new Map(this.pool); }
-  getPoolSize(): number { return this.pool.size; }
+  getPool(): Map<string, GossipPacket> {
+    return new Map(this.pool);
+  }
+  getPoolSize(): number {
+    return this.pool.size;
+  }
 }
 
 // =============================================================================
@@ -194,8 +208,10 @@ export const MCP_TOOL_SCHEMAS: MCPToolSchema[] = [
     inputSchema: {
       type: 'object',
       properties: {
-        id: { type: 'string' }, domain: { type: 'string' },
-        problem: { type: 'string' }, solution: { type: 'string' },
+        id: { type: 'string' },
+        domain: { type: 'string' },
+        problem: { type: 'string' },
+        solution: { type: 'string' },
         tags: { type: 'array', items: { type: 'string' } },
       },
       required: ['id', 'domain', 'problem', 'solution'],
@@ -207,8 +223,10 @@ export const MCP_TOOL_SCHEMAS: MCPToolSchema[] = [
     inputSchema: {
       type: 'object',
       properties: {
-        id: { type: 'string' }, domain: { type: 'string' },
-        insight: { type: 'string' }, context: { type: 'string' },
+        id: { type: 'string' },
+        domain: { type: 'string' },
+        insight: { type: 'string' },
+        context: { type: 'string' },
       },
       required: ['id', 'domain', 'insight'],
     },
@@ -219,8 +237,10 @@ export const MCP_TOOL_SCHEMAS: MCPToolSchema[] = [
     inputSchema: {
       type: 'object',
       properties: {
-        id: { type: 'string' }, domain: { type: 'string' },
-        mistake: { type: 'string' }, fix: { type: 'string' },
+        id: { type: 'string' },
+        domain: { type: 'string' },
+        mistake: { type: 'string' },
+        fix: { type: 'string' },
         severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
       },
       required: ['id', 'domain', 'mistake', 'fix'],

package/src/protocol/goal-synthesizer.ts

@@ -107,7 +107,7 @@ const DOMAIN_GOALS: Record<string, string[]> = {
     'Review and refine CI/CD pipeline efficiency',
     'Automate environment provisioning for local scenario tests',
     'Evaluate telemetry logging cardinality and storage costs',
-  ]
+  ],
 };
 
 // ── GoalSynthesizer ──
@@ -125,10 +125,7 @@ export class GoalSynthesizer {
    * Synthesize goals from context. Uses LLM when available, falls back to heuristics.
    * Returns goals ranked by relevance.
    */
-  async synthesizeMultiple(
-    context: GoalContext,
-    count = 3
-  ): Promise<SynthesizedGoal[]> {
+  async synthesizeMultiple(context: GoalContext, count = 3): Promise<SynthesizedGoal[]> {
     // Gather knowledge context
     const knowledgeEntries = context.recentKnowledge ?? this.queryKnowledge(context.domain);
 
@@ -148,15 +145,8 @@ export class GoalSynthesizer {
   /**
    * Synthesize a single goal. Backward-compatible with the original API.
    */
-  synthesize(
-    agentDomain: string = 'general',
-    source: Goal['source'] = 'autonomous-boredom'
-  ): Goal {
-    const goals = this.synthesizeHeuristic(
-      { domain: agentDomain },
-      [],
-      1
-    );
+  synthesize(agentDomain: string = 'general', source: Goal['source'] = 'autonomous-boredom'): Goal {
+    const goals = this.synthesizeHeuristic({ domain: agentDomain }, [], 1);
     if (goals.length > 0) {
       return { ...goals[0], source };
     }
@@ -189,9 +179,10 @@ export class GoalSynthesizer {
     knowledge: StoredEntry[],
     count: number
   ): Promise<SynthesizedGoal[]> {
-    const knowledgeContext = knowledge.length > 0
-      ? knowledge.map(k => `[${k.type}] ${k.content}`).join('\n')
-      : 'No relevant knowledge entries found.';
+    const knowledgeContext =
+      knowledge.length > 0
+        ? knowledge.map((k) => `[${k.type}] ${k.content}`).join('\n')
+        : 'No relevant knowledge entries found.';
 
     const recentTasks = context.recentCompletedTasks?.length
       ? context.recentCompletedTasks.slice(0, 10).join('\n- ')
@@ -200,15 +191,15 @@ export class GoalSynthesizer {
     const systemPrompt = [
       `You are a goal synthesizer for an autonomous AI agent team.`,
       `The agent "${context.agentName ?? 'unknown'}" operates in the "${context.domain}" domain.`,
-      context.capabilities?.length
-        ? `Agent capabilities: ${context.capabilities.join(', ')}`
-        : '',
+      context.capabilities?.length ? `Agent capabilities: ${context.capabilities.join(', ')}` : '',
       context.teamName ? `Team: ${context.teamName}` : '',
       ``,
       `Your job: propose ${count} actionable goals the agent should pursue autonomously.`,
       `Goals should be specific, achievable, and build on existing knowledge.`,
       `Avoid duplicating recently completed tasks.`,
-    ].filter(Boolean).join('\n');
+    ]
+      .filter(Boolean)
+      .join('\n');
 
     const userPrompt = [
       `## Knowledge Context`,
@@ -223,7 +214,9 @@ export class GoalSynthesizer {
       `[{"description": "...", "category": "...", "priority": "low|medium|high", "rationale": "...", "estimatedComplexity": 1-5}]`,
       ``,
       `Respond with ONLY the JSON array, no markdown fences.`,
-    ].filter(Boolean).join('\n');
+    ]
+      .filter(Boolean)
+      .join('\n');
 
     const messages: LLMMessage[] = [
       { role: 'system', content: systemPrompt },
@@ -238,11 +231,7 @@ export class GoalSynthesizer {
     return this.parseLLMGoals(response.content, context, count);
   }
 
-  private parseLLMGoals(
-    content: string,
-    context: GoalContext,
-    count: number
-  ): SynthesizedGoal[] {
+  private parseLLMGoals(content: string, context: GoalContext, count: number): SynthesizedGoal[] {
     try {
       // Strip markdown fences if present
       const cleaned = content.replace(/```(?:json)?\s*\n?/g, '').trim();
@@ -265,7 +254,7 @@ export class GoalSynthesizer {
         generatedAt: new Date().toISOString(),
         source: 'autonomous-boredom' as const,
         rationale: g.rationale || 'LLM-generated goal based on context',
-        relevanceScore: 1 - (i * 0.1), // rank order from LLM
+        relevanceScore: 1 - i * 0.1, // rank order from LLM
       }));
     } catch {
       return this.synthesizeHeuristic(context, [], count);
@@ -278,7 +267,7 @@ export class GoalSynthesizer {
     count: number
   ): SynthesizedGoal[] {
     const completedSet = new Set(
-      (context.recentCompletedTasks ?? []).map(t => t.toLowerCase().trim())
+      (context.recentCompletedTasks ?? []).map((t) => t.toLowerCase().trim())
     );
 
     // Build candidate pool from domain + generic goals
@@ -287,11 +276,12 @@ export class GoalSynthesizer {
 
     // If we have knowledge, generate knowledge-derived goals
     const knowledgeGoals = knowledge
-      .filter(k => k.type === 'gotcha')
-      .map(k => `Investigate and resolve: ${k.content.slice(0, 120)}`);
+      .filter((k) => k.type === 'gotcha')
+      .map((k) => `Investigate and resolve: ${k.content.slice(0, 120)}`);
 
-    const allCandidates = [...knowledgeGoals, ...candidates]
-      .filter(desc => !completedSet.has(desc.toLowerCase().trim()));
+    const allCandidates = [...knowledgeGoals, ...candidates].filter(
+      (desc) => !completedSet.has(desc.toLowerCase().trim())
+    );
 
     // Shuffle and pick
     const shuffled = allCandidates.sort(() => Math.random() - 0.5);
@@ -308,7 +298,7 @@ export class GoalSynthesizer {
       rationale: knowledgeGoals.includes(description)
         ? 'Derived from knowledge store gotcha entries'
         : `Heuristic goal for ${context.domain} domain`,
-      relevanceScore: Math.max(0.3, 1 - (i * 0.2)),
+      relevanceScore: Math.max(0.3, 1 - i * 0.2),
     }));
   }
 }

package/src/protocol/implementations.ts

@@ -117,22 +117,48 @@ export interface ServiceConfig {
 export type PWGSeverity = 'low' | 'medium' | 'high' | 'critical';
 
 export interface Pattern {
-  id: string; domain: string; problem: string; solution: string; context?: string; tags: string[]; confidence: number; createdAt: number; updatedAt: number;
+  id: string;
+  domain: string;
+  problem: string;
+  solution: string;
+  context?: string;
+  tags: string[];
+  confidence: number;
+  createdAt: number;
+  updatedAt: number;
 }
 
 export interface Wisdom {
-  id: string; domain: string; insight: string; context: string; source: string; tags: string[]; createdAt: number;
+  id: string;
+  domain: string;
+  insight: string;
+  context: string;
+  source: string;
+  tags: string[];
+  createdAt: number;
 }
 
 export interface Gotcha {
-  id: string; domain: string; mistake: string; fix: string; severity: PWGSeverity; tags: string[]; createdAt: number;
+  id: string;
+  domain: string;
+  mistake: string;
+  fix: string;
+  severity: PWGSeverity;
+  tags: string[];
+  createdAt: number;
 }
 
 export type PWGEntry = Pattern | Wisdom | Gotcha;
 
-export function isPattern(entry: PWGEntry): entry is Pattern { return entry.id.startsWith('P.'); }
-export function isWisdom(entry: PWGEntry): entry is Wisdom { return entry.id.startsWith('W.'); }
-export function isGotcha(entry: PWGEntry): entry is Gotcha { return entry.id.startsWith('G.'); }
+export function isPattern(entry: PWGEntry): entry is Pattern {
+  return entry.id.startsWith('P.');
+}
+export function isWisdom(entry: PWGEntry): entry is Wisdom {
+  return entry.id.startsWith('W.');
+}
+export function isGotcha(entry: PWGEntry): entry is Gotcha {
+  return entry.id.startsWith('G.');
+}
 
 // =============================================================================
 // BASE AGENT — Abstract 7-phase agent contract
@@ -159,7 +185,10 @@ export abstract class BaseAgent {
   /**
    * Execute a complete 7-phase cycle
    */
-  async runCycle(task: string, context: Record<string, unknown> = {}): Promise<ProtocolCycleResult> {
+  async runCycle(
+    task: string,
+    context: Record<string, unknown> = {}
+  ): Promise<ProtocolCycleResult> {
     const startedAt = Date.now();
     const cycleId = `cycle_${startedAt}_${Math.random().toString(36).slice(2, 8)}`;
     const phases: PhaseResult[] = [];
@@ -191,8 +220,16 @@ export abstract class BaseAgent {
     const intakeResult = await runPhase(ProtocolPhase.INTAKE, this.intake, { task, ...context });
     const reflectResult = await runPhase(ProtocolPhase.REFLECT, this.reflect, intakeResult.data);
     const executeResult = await runPhase(ProtocolPhase.EXECUTE, this.execute, reflectResult.data);
-    const compressResult = await runPhase(ProtocolPhase.COMPRESS, this.compress, executeResult.data);
-    const reintakeResult = await runPhase(ProtocolPhase.REINTAKE, this.reintake, compressResult.data);
+    const compressResult = await runPhase(
+      ProtocolPhase.COMPRESS,
+      this.compress,
+      executeResult.data
+    );
+    const reintakeResult = await runPhase(
+      ProtocolPhase.REINTAKE,
+      this.reintake,
+      compressResult.data
+    );
     const growResult = await runPhase(ProtocolPhase.GROW, this.grow, reintakeResult.data);
     await runPhase(ProtocolPhase.EVOLVE, this.evolve, growResult.data);
 
@@ -273,9 +310,15 @@ export abstract class BaseService {
     this.metadata.lifecycle = ServiceLifecycle.STOPPED;
   }
 
-  getMetadata(): ServiceMetadata { return { ...this.metadata }; }
-  getMetrics(): ServiceMetrics { return { ...this.metrics }; }
-  isReady(): boolean { return this.metadata.lifecycle === ServiceLifecycle.READY; }
+  getMetadata(): ServiceMetadata {
+    return { ...this.metadata };
+  }
+  getMetrics(): ServiceMetrics {
+    return { ...this.metrics };
+  }
+  isReady(): boolean {
+    return this.metadata.lifecycle === ServiceLifecycle.READY;
+  }
 
   protected recordRequest(latency: number): void {
     this.metrics.requestCount++;
@@ -333,16 +376,16 @@ export class ServiceManager {
   }
 
   health(): ServiceManagerHealth {
-    const ready = this.services.filter(s => s.isReady());
+    const ready = this.services.filter((s) => s.isReady());
     return {
       totalServices: this.services.length,
       readyCount: ready.length,
       allReady: this.services.length > 0 && ready.length === this.services.length,
-      services: this.services.map(s => ({
+      services: this.services.map((s) => ({
         name: s.getMetadata().name,
         ready: s.isReady(),
-        lifecycle: s.getMetadata().lifecycle
-      }))
+        lifecycle: s.getMetadata().lifecycle,
+      })),
     };
   }
 }
@@ -406,7 +449,13 @@ export class MicroPhaseDecomposer {
         groupIdx = Math.max(groupIdx, (assignedToGroup.get(depId) ?? 0) + 1);
       }
       while (groups.length <= groupIdx) {
-        groups.push({ id: `group_${groups.length}`, name: `Group ${groups.length}`, tasks: [], parallel: true, estimatedDuration: 0 });
+        groups.push({
+          id: `group_${groups.length}`,
+          name: `Group ${groups.length}`,
+          tasks: [],
+          parallel: true,
+          estimatedDuration: 0,
+        });
       }
       groups[groupIdx].tasks.push(task);
       assignedToGroup.set(taskId, groupIdx);
@@ -419,7 +468,11 @@ export class MicroPhaseDecomposer {
     }
 
     const seqTime = [...this.nodes.values()].reduce((s, t) => s + t.estimatedDuration, 0);
-    return { groups, totalEstimatedTime: totalTime, parallelizationRatio: seqTime > 0 ? ((seqTime - totalTime) / seqTime) * 100 : 0 };
+    return {
+      groups,
+      totalEstimatedTime: totalTime,
+      parallelizationRatio: seqTime > 0 ? ((seqTime - totalTime) / seqTime) * 100 : 0,
+    };
   }
 
   async executePlan(plan: ExecutionPlan): Promise<ExecutionResult[]> {
@@ -432,12 +485,26 @@ export class MicroPhaseDecomposer {
             const timeout = task.timeout ?? 30000;
             const result = await Promise.race([
               task.execute(),
-              new Promise((_, reject) => setTimeout(() => reject(new Error('Task timeout')), timeout)),
+              new Promise((_, reject) =>
+                setTimeout(() => reject(new Error('Task timeout')), timeout)
+              ),
             ]);
-            return { taskId: task.id, status: 'success' as const, duration: Date.now() - start, result, timestamp: Date.now() };
+            return {
+              taskId: task.id,
+              status: 'success' as const,
+              duration: Date.now() - start,
+              result,
+              timestamp: Date.now(),
+            };
           } catch (err) {
             const isTimeout = err instanceof Error && err.message === 'Task timeout';
-            return { taskId: task.id, status: (isTimeout ? 'timeout' : 'failure') as 'timeout' | 'failure', duration: Date.now() - start, error: err instanceof Error ? err : new Error(String(err)), timestamp: Date.now() };
+            return {
+              taskId: task.id,
+              status: (isTimeout ? 'timeout' : 'failure') as 'timeout' | 'failure',
+              duration: Date.now() - start,
+              error: err instanceof Error ? err : new Error(String(err)),
+              timestamp: Date.now(),
+            };
           }
         })
       );
@@ -447,7 +514,9 @@ export class MicroPhaseDecomposer {
     return results;
   }
 
-  getHistory(): ExecutionResult[] { return [...this.history]; }
+  getHistory(): ExecutionResult[] {
+    return [...this.history];
+  }
 
   reset(): void {
     this.nodes.clear();

package/src/protocol/micro-phase-decomposer.ts

@@ -58,7 +58,10 @@ const DEFAULT_COMPLEXITY_THRESHOLD = 2;
 // ── LLM Adapter Interface (injectable for testing) ──
 
 export interface LLMAdapter {
-  call(messages: LLMMessage[], options?: { maxTokens?: number; temperature?: number }): Promise<string>;
+  call(
+    messages: LLMMessage[],
+    options?: { maxTokens?: number; temperature?: number }
+  ): Promise<string>;
 }
 
 /** Create an LLMAdapter from a ModelConfig */
@@ -159,7 +162,7 @@ Rules:
     this.validatePhases(phases);
 
     const sorted = this.topologicalSort(phases);
-    const phaseMap = new Map(phases.map(p => [p.id, p]));
+    const phaseMap = new Map(phases.map((p) => [p.id, p]));
     const waveAssignment = new Map<string, number>();
     const waves: MicroPhase[][] = [];
 
@@ -181,15 +184,16 @@ Rules:
     // Calculate timing
     const sequentialTime = phases.reduce((sum, p) => sum + p.estimatedDuration, 0);
     const parallelTime = waves.reduce((sum, wave) => {
-      return sum + Math.max(...wave.map(p => p.estimatedDuration));
+      return sum + Math.max(...wave.map((p) => p.estimatedDuration));
     }, 0);
 
     return {
       waves,
       totalEstimatedDuration: parallelTime,
-      parallelizationRatio: sequentialTime > 0
-        ? Math.round(((sequentialTime - parallelTime) / sequentialTime) * 100)
-        : 0,
+      parallelizationRatio:
+        sequentialTime > 0
+          ? Math.round(((sequentialTime - parallelTime) / sequentialTime) * 100)
+          : 0,
       phaseCount: phases.length,
     };
   }
@@ -212,7 +216,9 @@ Rules:
         description: String(p.description ?? 'Unknown phase'),
         dependencies: Array.isArray(p.dependencies) ? p.dependencies.map(String) : [],
         estimatedDuration: typeof p.estimatedDuration === 'number' ? p.estimatedDuration : 5000,
-        requiredCapabilities: Array.isArray(p.requiredCapabilities) ? p.requiredCapabilities.map(String) : ['coding'],
+        requiredCapabilities: Array.isArray(p.requiredCapabilities)
+          ? p.requiredCapabilities.map(String)
+          : ['coding'],
       }));
     } catch {
       return this.fallbackSinglePhase(taskId);
@@ -220,17 +226,19 @@ Rules:
   }
 
   private fallbackSinglePhase(taskId: string): MicroPhase[] {
-    return [{
-      id: `${taskId}_single`,
-      description: 'Execute task as single unit',
-      dependencies: [],
-      estimatedDuration: 10000,
-      requiredCapabilities: ['coding'],
-    }];
+    return [
+      {
+        id: `${taskId}_single`,
+        description: 'Execute task as single unit',
+        dependencies: [],
+        estimatedDuration: 10000,
+        requiredCapabilities: ['coding'],
+      },
+    ];
   }
 
   private validatePhases(phases: MicroPhase[]): void {
-    const ids = new Set(phases.map(p => p.id));
+    const ids = new Set(phases.map((p) => p.id));
 
     for (const phase of phases) {
       for (const dep of phase.dependencies) {
@@ -245,7 +253,7 @@ Rules:
   }
 
   private topologicalSort(phases: MicroPhase[]): string[] {
-    const phaseMap = new Map(phases.map(p => [p.id, p]));
+    const phaseMap = new Map(phases.map((p) => [p.id, p]));
     const visited = new Set<string>();
     const inStack = new Set<string>();
     const result: string[] = [];
@@ -280,7 +288,7 @@ Rules:
   private enforceParallelismLimit(phases: MicroPhase[], maxParallelism: number): void {
     // Build initial plan to see wave sizes
     const plan = this.buildExecutionPlan(phases);
-    const phaseMap = new Map(phases.map(p => [p.id, p]));
+    const phaseMap = new Map(phases.map((p) => [p.id, p]));
 
     for (const wave of plan.waves) {
       if (wave.length <= maxParallelism) continue;