@holoscript/framework 6.0.3 → 6.0.4

package/src/protocol/micro-step-decomposer.test.ts

@@ -12,8 +12,19 @@ function mockLLM(response: string): LLMAdapter {
   return { call: vi.fn().mockResolvedValue(response) };
 }
 
-function phase(id: string, deps: string[] = [], duration = 5000, caps: string[] = ['coding']): MicroPhase {
-  return { id, description: `Phase ${id}`, dependencies: deps, estimatedDuration: duration, requiredCapabilities: caps };
+function phase(
+  id: string,
+  deps: string[] = [],
+  duration = 5000,
+  caps: string[] = ['coding']
+): MicroPhase {
+  return {
+    id,
+    description: `Phase ${id}`,
+    dependencies: deps,
+    estimatedDuration: duration,
+    requiredCapabilities: caps,
+  };
 }
 
 const simpleTask: TaskDescription = {
@@ -30,11 +41,7 @@ describe('SmartMicroPhaseDecomposer', () => {
       const llm = mockLLM('');
       const decomposer = new SmartMicroPhaseDecomposer(llm);
 
-      const phases: MicroPhase[] = [
-        phase('a'),
-        phase('b'),
-        phase('c'),
-      ];
+      const phases: MicroPhase[] = [phase('a'), phase('b'), phase('c')];
 
       const plan = decomposer.buildExecutionPlan(phases);
 
@@ -49,18 +56,14 @@ describe('SmartMicroPhaseDecomposer', () => {
       const llm = mockLLM('');
       const decomposer = new SmartMicroPhaseDecomposer(llm);
 
-      const phases: MicroPhase[] = [
-        phase('a'),
-        phase('b', ['a']),
-        phase('c', ['b']),
-      ];
+      const phases: MicroPhase[] = [phase('a'), phase('b', ['a']), phase('c', ['b'])];
 
       const plan = decomposer.buildExecutionPlan(phases);
 
       expect(plan.waves).toHaveLength(3);
-      expect(plan.waves[0].map(p => p.id)).toEqual(['a']);
-      expect(plan.waves[1].map(p => p.id)).toEqual(['b']);
-      expect(plan.waves[2].map(p => p.id)).toEqual(['c']);
+      expect(plan.waves[0].map((p) => p.id)).toEqual(['a']);
+      expect(plan.waves[1].map((p) => p.id)).toEqual(['b']);
+      expect(plan.waves[2].map((p) => p.id)).toEqual(['c']);
       expect(plan.totalEstimatedDuration).toBe(15000);
       expect(plan.parallelizationRatio).toBe(0);
     });
@@ -84,9 +87,9 @@ describe('SmartMicroPhaseDecomposer', () => {
       const plan = decomposer.buildExecutionPlan(phases);
 
       expect(plan.waves).toHaveLength(3);
-      expect(plan.waves[0].map(p => p.id)).toEqual(['a']);
-      expect(plan.waves[1].map(p => p.id).sort()).toEqual(['b', 'c']);
-      expect(plan.waves[2].map(p => p.id)).toEqual(['d']);
+      expect(plan.waves[0].map((p) => p.id)).toEqual(['a']);
+      expect(plan.waves[1].map((p) => p.id).sort()).toEqual(['b', 'c']);
+      expect(plan.waves[2].map((p) => p.id)).toEqual(['d']);
     });
 
     it('returns empty plan for no phases', () => {
@@ -112,10 +115,7 @@ describe('SmartMicroPhaseDecomposer', () => {
       const llm = mockLLM('');
       const decomposer = new SmartMicroPhaseDecomposer(llm);
 
-      const phases: MicroPhase[] = [
-        phase('a', ['b']),
-        phase('b', ['a']),
-      ];
+      const phases: MicroPhase[] = [phase('a', ['b']), phase('b', ['a'])];
 
       expect(() => decomposer.buildExecutionPlan(phases)).toThrow('Circular dependency');
     });
@@ -150,10 +150,34 @@ describe('SmartMicroPhaseDecomposer', () => {
     it('parses well-formed LLM JSON response', async () => {
       const llmResponse = JSON.stringify({
         phases: [
-          { id: 'phase_1', description: 'Setup project', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
-          { id: 'phase_2', description: 'Write components', dependencies: ['phase_1'], estimatedDuration: 8000, requiredCapabilities: ['coding'] },
-          { id: 'phase_3', description: 'Write tests', dependencies: ['phase_1'], estimatedDuration: 5000, requiredCapabilities: ['testing'] },
-          { id: 'phase_4', description: 'Integration test', dependencies: ['phase_2', 'phase_3'], estimatedDuration: 4000, requiredCapabilities: ['testing'] },
+          {
+            id: 'phase_1',
+            description: 'Setup project',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
+          {
+            id: 'phase_2',
+            description: 'Write components',
+            dependencies: ['phase_1'],
+            estimatedDuration: 8000,
+            requiredCapabilities: ['coding'],
+          },
+          {
+            id: 'phase_3',
+            description: 'Write tests',
+            dependencies: ['phase_1'],
+            estimatedDuration: 5000,
+            requiredCapabilities: ['testing'],
+          },
+          {
+            id: 'phase_4',
+            description: 'Integration test',
+            dependencies: ['phase_2', 'phase_3'],
+            estimatedDuration: 4000,
+            requiredCapabilities: ['testing'],
+          },
         ],
       });
 
@@ -169,7 +193,8 @@ describe('SmartMicroPhaseDecomposer', () => {
     });
 
     it('extracts JSON from markdown code blocks', async () => {
-      const llmResponse = '```json\n{"phases": [{"id": "p1", "description": "Do it", "dependencies": [], "estimatedDuration": 5000, "requiredCapabilities": ["coding"]}]}\n```';
+      const llmResponse =
+        '```json\n{"phases": [{"id": "p1", "description": "Do it", "dependencies": [], "estimatedDuration": 5000, "requiredCapabilities": ["coding"]}]}\n```';
 
       const llm = mockLLM(llmResponse);
       const decomposer = new SmartMicroPhaseDecomposer(llm);
@@ -200,7 +225,15 @@ describe('SmartMicroPhaseDecomposer', () => {
 
     it('does not mark as decomposed when below complexity threshold', async () => {
       const llmResponse = JSON.stringify({
-        phases: [{ id: 'only', description: 'Just do it', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] }],
+        phases: [
+          {
+            id: 'only',
+            description: 'Just do it',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
+        ],
       });
 
       const llm = mockLLM(llmResponse);
@@ -214,8 +247,20 @@ describe('SmartMicroPhaseDecomposer', () => {
     it('respects custom complexity threshold', async () => {
       const llmResponse = JSON.stringify({
         phases: [
-          { id: 'a', description: 'Step A', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
-          { id: 'b', description: 'Step B', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
+          {
+            id: 'a',
+            description: 'Step A',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
+          {
+            id: 'b',
+            description: 'Step B',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
         ],
       });
 
@@ -229,10 +274,34 @@ describe('SmartMicroPhaseDecomposer', () => {
     it('enforces maxParallelism by adding synthetic dependencies', async () => {
       const llmResponse = JSON.stringify({
         phases: [
-          { id: 'a', description: 'A', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
-          { id: 'b', description: 'B', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
-          { id: 'c', description: 'C', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
-          { id: 'd', description: 'D', dependencies: [], estimatedDuration: 3000, requiredCapabilities: ['coding'] },
+          {
+            id: 'a',
+            description: 'A',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
+          {
+            id: 'b',
+            description: 'B',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
+          {
+            id: 'c',
+            description: 'C',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
+          {
+            id: 'd',
+            description: 'D',
+            dependencies: [],
+            estimatedDuration: 3000,
+            requiredCapabilities: ['coding'],
+          },
         ],
       });
 
@@ -272,11 +341,7 @@ describe('SmartMicroPhaseDecomposer', () => {
       const decomposer = new SmartMicroPhaseDecomposer(llm);
 
       // a(5s) and b(5s) in parallel, c(5s) depends on both
-      const phases = [
-        phase('a', [], 5000),
-        phase('b', [], 5000),
-        phase('c', ['a', 'b'], 5000),
-      ];
+      const phases = [phase('a', [], 5000), phase('b', [], 5000), phase('c', ['a', 'b'], 5000)];
       const plan = decomposer.buildExecutionPlan(phases);
 
       // Sequential: 15000ms, Parallel: 5000 + 5000 = 10000ms

package/src/protocol-agent.test.ts

@@ -36,17 +36,21 @@ describe('defineProtocolAgent', () => {
   // ── Validation ──
 
   it('throws on empty name', () => {
-    expect(() => defineProtocolAgent({ ...BASE_CONFIG, name: '' })).toThrow('Agent name is required');
+    expect(() => defineProtocolAgent({ ...BASE_CONFIG, name: '' })).toThrow(
+      'Agent name is required'
+    );
   });
 
   it('throws on invalid role', () => {
-    expect(() => defineProtocolAgent({ ...BASE_CONFIG, role: 'wizard' as never })).toThrow('Invalid role');
+    expect(() => defineProtocolAgent({ ...BASE_CONFIG, role: 'wizard' as never })).toThrow(
+      'Invalid role'
+    );
   });
 
   it('throws on missing model provider', () => {
-    expect(() => defineProtocolAgent({ ...BASE_CONFIG, model: { provider: '' as never, model: 'x' } })).toThrow(
-      'Agent model must specify provider and model'
-    );
+    expect(() =>
+      defineProtocolAgent({ ...BASE_CONFIG, model: { provider: '' as never, model: 'x' } })
+    ).toThrow('Agent model must specify provider and model');
   });
 
   it('throws on empty capabilities', () => {
@@ -138,7 +142,7 @@ describe('defineProtocolAgent', () => {
     expect(handle.status).toBe('cancelled');
 
     // At least INTAKE and REFLECT ran, then EXECUTE should be skipped
-    const skipped = result.phases.filter(p => p.status === 'skipped');
+    const skipped = result.phases.filter((p) => p.status === 'skipped');
     expect(skipped.length).toBeGreaterThan(0);
   });
 
@@ -256,7 +260,13 @@ describe('protocolToFrameworkCycleResult', () => {
           status: 'success',
           data: {
             validated: [
-              { type: 'wisdom', content: 'insight', domain: 'testing', confidence: 0.8, source: 'test' },
+              {
+                type: 'wisdom',
+                content: 'insight',
+                domain: 'testing',
+                confidence: 0.8,
+                source: 'test',
+              },
             ],
           },
           durationMs: 50,

package/src/protocol-agent.ts

@@ -29,8 +29,7 @@ const PHASE_PROMPTS: Record<number, string> = {
     'You are gathering context for a task. Summarize the task, relevant knowledge, and constraints. Be concise.',
   [ProtocolPhase.REFLECT]:
     'You are analyzing an approach. Given the context, identify the best strategy, risks, and key considerations. Be brief.',
-  [ProtocolPhase.EXECUTE]:
-    '', // Uses the agent's own system prompt
+  [ProtocolPhase.EXECUTE]: '', // Uses the agent's own system prompt
   [ProtocolPhase.COMPRESS]:
     'You are extracting knowledge from completed work. Identify Wisdom (insights), Patterns (reusable solutions), and Gotchas (pitfalls). Format each as: [wisdom|pattern|gotcha] content',
   [ProtocolPhase.REINTAKE]:
@@ -302,11 +301,7 @@ export class ProtocolAgent extends BaseAgent {
 // ── Helpers ──
 
 /** Parse LLM output into KnowledgeInsight[]. */
-function parseKnowledgeItems(
-  content: string,
-  domain: string,
-  source: string
-): KnowledgeInsight[] {
+function parseKnowledgeItems(content: string, domain: string, source: string): KnowledgeInsight[] {
   const insights: KnowledgeInsight[] = [];
 
   for (const line of content.split('\n')) {
@@ -344,20 +339,13 @@ export async function runProtocolCycle(
   });
 
   // Extract summary from EXECUTE phase
-  const executePhase = cycleResult.phases.find(
-    (p) => p.phase === ProtocolPhase.EXECUTE
-  );
+  const executePhase = cycleResult.phases.find((p) => p.phase === ProtocolPhase.EXECUTE);
   const summary =
-    (executePhase?.data as { output?: string })?.output?.slice(0, 500) ??
-    'Task completed';
+    (executePhase?.data as { output?: string })?.output?.slice(0, 500) ?? 'Task completed';
 
   // Extract insights from REINTAKE phase (validated) or COMPRESS phase (raw)
-  const reintakePhase = cycleResult.phases.find(
-    (p) => p.phase === ProtocolPhase.REINTAKE
-  );
-  const compressPhase = cycleResult.phases.find(
-    (p) => p.phase === ProtocolPhase.COMPRESS
-  );
+  const reintakePhase = cycleResult.phases.find((p) => p.phase === ProtocolPhase.REINTAKE);
+  const compressPhase = cycleResult.phases.find((p) => p.phase === ProtocolPhase.COMPRESS);
   const insights: KnowledgeInsight[] =
     (reintakePhase?.data as { validated?: KnowledgeInsight[] })?.validated ??
     (compressPhase?.data as { insights?: KnowledgeInsight[] })?.insights ??
@@ -383,29 +371,32 @@ export function protocolToFrameworkCycleResult(
   cycle: number
 ): FrameworkCycleResult {
   // Extract insights from compress/reintake phases
-  const reintake = protocol.phases.find(p => p.phase === ProtocolPhase.REINTAKE);
-  const compress = protocol.phases.find(p => p.phase === ProtocolPhase.COMPRESS);
+  const reintake = protocol.phases.find((p) => p.phase === ProtocolPhase.REINTAKE);
+  const compress = protocol.phases.find((p) => p.phase === ProtocolPhase.COMPRESS);
   const insights: KnowledgeInsight[] =
     (reintake?.data as { validated?: KnowledgeInsight[] })?.validated ??
     (compress?.data as { insights?: KnowledgeInsight[] })?.insights ??
     [];
 
-  const executePhase = protocol.phases.find(p => p.phase === ProtocolPhase.EXECUTE);
-  const summary = (executePhase?.data as { output?: string })?.output?.slice(0, 500) ?? 'Task completed';
+  const executePhase = protocol.phases.find((p) => p.phase === ProtocolPhase.EXECUTE);
+  const summary =
+    (executePhase?.data as { output?: string })?.output?.slice(0, 500) ?? 'Task completed';
 
   const hasFailed = protocol.status === 'failed';
 
   return {
     teamName,
     cycle,
-    agentResults: [{
-      agentName: protocol.domain, // best available identifier
-      taskId: protocol.cycleId,
-      taskTitle: protocol.task,
-      action: hasFailed ? 'error' : 'completed',
-      summary,
-      knowledge: insights,
-    }],
+    agentResults: [
+      {
+        agentName: protocol.domain, // best available identifier
+        taskId: protocol.cycleId,
+        taskTitle: protocol.task,
+        action: hasFailed ? 'error' : 'completed',
+        summary,
+        knowledge: insights,
+      },
+    ],
     knowledgeProduced: insights,
     compoundedInsights: insights.length,
     durationMs: protocol.totalDurationMs,
@@ -421,7 +412,7 @@ export function frameworkToProtocolCycleResult(
   domain: string
 ): ProtocolCycleResult {
   const now = Date.now();
-  const hasError = fw.agentResults.some(r => r.action === 'error');
+  const hasError = fw.agentResults.some((r) => r.action === 'error');
 
   return {
     cycleId: `cycle_${fw.cycle}_${now.toString(36)}`,
@@ -460,7 +451,7 @@ export function defineProtocolAgent(config: ProtocolAgentConfig): ProtocolAgentH
     throw new Error('Agent name is required');
   }
   const VALID_ROLES = ['architect', 'coder', 'researcher', 'reviewer'] as const;
-  if (!VALID_ROLES.includes(config.role as typeof VALID_ROLES[number])) {
+  if (!VALID_ROLES.includes(config.role as (typeof VALID_ROLES)[number])) {
     throw new Error(`Invalid role "${config.role}". Valid: ${VALID_ROLES.join(', ')}`);
   }
   if (!config.model?.provider || !config.model?.model) {
@@ -472,7 +463,9 @@ export function defineProtocolAgent(config: ProtocolAgentConfig): ProtocolAgentH
 
   const protocolStyle = config.protocolStyle ?? 'uaa2';
   if (protocolStyle !== 'uaa2') {
-    throw new Error(`Protocol style "${protocolStyle}" is not yet implemented. Only 'uaa2' is supported.`);
+    throw new Error(
+      `Protocol style "${protocolStyle}" is not yet implemented. Only 'uaa2' is supported.`
+    );
   }
 
   // Internal mutable state
@@ -509,7 +502,7 @@ export function defineProtocolAgent(config: ProtocolAgentConfig): ProtocolAgentH
     // Check pause — wait until resumed
     if (pauseRequested) {
       status = 'paused';
-      await new Promise<void>(resolve => {
+      await new Promise<void>((resolve) => {
         pauseResolver = resolve;
       });
       status = 'running';
@@ -555,14 +548,24 @@ export function defineProtocolAgent(config: ProtocolAgentConfig): ProtocolAgentH
   }
 
   const handle: ProtocolAgentHandle = {
-    get name() { return config.name; },
-    get role() { return config.role; },
-    get status() { return status; },
-    get history() { return [...phaseHistory]; },
+    get name() {
+      return config.name;
+    },
+    get role() {
+      return config.role;
+    },
+    get status() {
+      return status;
+    },
+    get history() {
+      return [...phaseHistory];
+    },
 
     async execute(task: { title: string; description: string }): Promise<ProtocolCycleResult> {
       if (status === 'running') {
-        throw new Error('Agent is already executing. Await the current execution or cancel() first.');
+        throw new Error(
+          'Agent is already executing. Await the current execution or cancel() first.'
+        );
       }
 
       status = 'running';
@@ -605,17 +608,17 @@ export function defineProtocolAgent(config: ProtocolAgentConfig): ProtocolAgentH
           previousData = result.data;
         }
 
-        const hasFailed = phaseResults.some(p => p.status === 'failure');
+        const hasFailed = phaseResults.some((p) => p.status === 'failure');
         const wasCancelled = cancelRequested;
 
-        status = wasCancelled ? 'cancelled' : (hasFailed ? 'error' : 'idle');
+        status = wasCancelled ? 'cancelled' : hasFailed ? 'error' : 'idle';
 
         return {
           cycleId,
           task: task.title,
           domain: agent.identity.domain,
           phases: phaseResults,
-          status: wasCancelled ? 'partial' : (hasFailed ? 'partial' : 'complete'),
+          status: wasCancelled ? 'partial' : hasFailed ? 'partial' : 'complete',
           totalDurationMs: Date.now() - startedAt,
           startedAt,
           completedAt: Date.now(),

package/src/self-improve/absorb-scanner.ts

@@ -71,10 +71,11 @@ interface KnowledgeEntry {
  */
 export async function scanFramework(config: AbsorbScanConfig = {}): Promise<ScanResult> {
   const orchestratorUrl = config.orchestratorUrl || DEFAULT_ORCHESTRATOR_URL;
-  const apiKey = config.mcpApiKey || process.env.MCP_API_KEY || '';
+  const apiKey = config.mcpApiKey || process.env.HOLOSCRIPT_API_KEY || '';
   const workspaceId = config.workspaceId || DEFAULT_WORKSPACE_ID;
   const maxTasks = config.maxTasks || 20;
-  const searchQuery = config.searchQuery ||
+  const searchQuery =
+    config.searchQuery ||
     'framework improvement opportunities type-safety test-coverage refactoring agents';
 
   if (!apiKey) {
@@ -84,7 +85,7 @@ export async function scanFramework(config: AbsorbScanConfig = {}): Promise<Scan
       issuesFound: 0,
       improvements: [],
       knowledge: [],
-      error: 'MCP_API_KEY required for knowledge store query',
+      error: 'HOLOSCRIPT_API_KEY required for knowledge store query',
     };
   }
 
@@ -108,7 +109,7 @@ export async function scanFramework(config: AbsorbScanConfig = {}): Promise<Scan
     let filesAnalyzed = 0;
 
     if (queryRes.ok) {
-      const data = await queryRes.json() as {
+      const data = (await queryRes.json()) as {
         results?: KnowledgeEntry[];
         entries?: KnowledgeEntry[];
       };
@@ -245,8 +246,10 @@ export async function scanTodos(codebasePath: string): Promise<ScanResult> {
 function categorizeContent(content: string): ImprovementTask['category'] {
   const lower = content.toLowerCase();
   if (lower.includes('test') || lower.includes('coverage') || lower.includes('spec')) return 'test';
-  if (lower.includes('perf') || lower.includes('slow') || lower.includes('optim')) return 'performance';
+  if (lower.includes('perf') || lower.includes('slow') || lower.includes('optim'))
+    return 'performance';
   if (lower.includes('doc') || lower.includes('readme') || lower.includes('comment')) return 'docs';
-  if (lower.includes('type') || lower.includes('any') || lower.includes('cast')) return 'type-safety';
+  if (lower.includes('type') || lower.includes('any') || lower.includes('cast'))
+    return 'type-safety';
   return 'refactor';
 }

package/src/self-improve/evolution-engine.ts

@@ -91,7 +91,9 @@ export async function evolve(team: Team, config: EvolutionConfig = {}): Promise<
         await team.suggest(imp.title, {
           description: imp.description,
           category: mapCategory(imp.category),
-          evidence: imp.file ? `Detected in ${imp.file}${imp.line ? `:${imp.line}` : ''}` : undefined,
+          evidence: imp.file
+            ? `Detected in ${imp.file}${imp.line ? `:${imp.line}` : ''}`
+            : undefined,
         });
         suggestionsCreated++;
       } catch {
@@ -102,9 +104,9 @@ export async function evolve(team: Team, config: EvolutionConfig = {}): Promise<
 
   // Step 3: Auto-board critical items
   if (autoBoard) {
-    const critical = scan.improvements.filter(imp => imp.priority <= autoBoardMinPriority);
+    const critical = scan.improvements.filter((imp) => imp.priority <= autoBoardMinPriority);
     if (critical.length > 0) {
-      const tasks = critical.map(imp => ({
+      const tasks = critical.map((imp) => ({
         title: imp.title,
         description: `[Self-improvement] ${imp.description}`,
         priority: imp.priority,
@@ -119,31 +121,47 @@ export async function evolve(team: Team, config: EvolutionConfig = {}): Promise<
   // Step 4: Publish extracted knowledge
   for (const k of scan.knowledge) {
     team.knowledge.publish(
-      { type: k.type, content: k.content, domain: k.domain, confidence: k.confidence, source: 'evolution:self-scan' },
+      {
+        type: k.type,
+        content: k.content,
+        domain: k.domain,
+        confidence: k.confidence,
+        source: 'evolution:self-scan',
+      },
       'evolution-engine'
     );
     knowledgePublished++;
   }
 
   // Step 5: Compound
-  team.knowledge.compound(scan.knowledge.map(k => ({
-    type: k.type,
-    content: k.content,
-    domain: k.domain,
-    confidence: k.confidence,
-    source: 'evolution:self-scan',
-  })));
+  team.knowledge.compound(
+    scan.knowledge.map((k) => ({
+      type: k.type,
+      content: k.content,
+      domain: k.domain,
+      confidence: k.confidence,
+      source: 'evolution:self-scan',
+    }))
+  );
 
   return { scan, todoScan, suggestionsCreated, tasksCreated, knowledgePublished };
 }
 
-function mapCategory(cat: ImprovementTask['category']): 'process' | 'tooling' | 'architecture' | 'testing' | 'docs' | 'performance' | 'other' {
+function mapCategory(
+  cat: ImprovementTask['category']
+): 'process' | 'tooling' | 'architecture' | 'testing' | 'docs' | 'performance' | 'other' {
   switch (cat) {
-    case 'refactor': return 'architecture';
-    case 'test': return 'testing';
-    case 'docs': return 'docs';
-    case 'performance': return 'performance';
-    case 'type-safety': return 'tooling';
-    default: return 'other';
+    case 'refactor':
+      return 'architecture';
+    case 'test':
+      return 'testing';
+    case 'docs':
+      return 'docs';
+    case 'performance':
+      return 'performance';
+    case 'type-safety':
+      return 'tooling';
+    default:
+      return 'other';
   }
 }

package/src/self-improve/framework-absorber.ts

@@ -10,7 +10,12 @@
  * service is unreachable.
  */
 
-import type { AbsorbScanConfig, ScanResult, ImprovementTask, ExtractedKnowledge } from './absorb-scanner';
+import type {
+  AbsorbScanConfig,
+  ScanResult,
+  ImprovementTask,
+  ExtractedKnowledge,
+} from './absorb-scanner';
 import { scanFramework, scanTodos } from './absorb-scanner';
 
 export interface CodebaseGraph {
@@ -117,7 +122,7 @@ export class FrameworkAbsorber {
           if (rpcResult.result?.content) {
             // Parse the absorb graph from the MCP response
             const raw = rpcResult.result.content;
-            const textContent = raw.find(c => c.text)?.text;
+            const textContent = raw.find((c) => c.text)?.text;
             let parsed: Record<string, unknown> = {};
             if (textContent) {
               try {
@@ -129,19 +134,19 @@ export class FrameworkAbsorber {
             }
 
             return {
-              fileCount: typeof parsed.file_count === 'number'
-                ? parsed.file_count
-                : typeof parsed.files === 'number'
-                  ? parsed.files
-                  : 0,
-              edgeCount: typeof parsed.edge_count === 'number'
-                ? parsed.edge_count
-                : typeof parsed.edges === 'number'
-                  ? parsed.edges
-                  : 0,
-              modules: Array.isArray(parsed.modules)
-                ? parsed.modules as string[]
-                : [],
+              fileCount:
+                typeof parsed.file_count === 'number'
+                  ? parsed.file_count
+                  : typeof parsed.files === 'number'
+                    ? parsed.files
+                    : 0,
+              edgeCount:
+                typeof parsed.edge_count === 'number'
+                  ? parsed.edge_count
+                  : typeof parsed.edges === 'number'
+                    ? parsed.edges
+                    : 0,
+              modules: Array.isArray(parsed.modules) ? (parsed.modules as string[]) : [],
               raw: parsed,
             };
           }
@@ -167,7 +172,7 @@ export class FrameworkAbsorber {
    * Returns ranked improvement list with confidence scores.
    */
   async findImprovements(): Promise<Improvement[]> {
-    const scan = this.lastScan || await this.runFullScan();
+    const scan = this.lastScan || (await this.runFullScan());
     return scan.improvements.map((imp, i) => ({
       id: `fw-imp-${i}-${Date.now()}`,
       title: imp.title,