mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/onboard-codebase.js

@@ -10,93 +10,91 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const MAP_SCHEMA = {
-    type: 'object',
-    properties: {
-      primaryLanguage: { type: 'string' },
-      secondaryLanguages: { type: 'array', items: { type: 'string' } },
-      frameworks: { type: 'array', items: { type: 'string' } },
-      entryPoints: { type: 'array', items: { type: 'string' } },
-      testingFrameworks: { type: 'array', items: { type: 'string' } },
-      totalFiles: { type: 'string' },
-      keyDirectories: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, purpose: { type: 'string' } }, required: ['path', 'purpose'] } },
-    },
-    required: ['primaryLanguage', 'frameworks', 'entryPoints', 'keyDirectories'],
-  };
+const MAP_SCHEMA = {
+  type: 'object',
+  properties: {
+    primaryLanguage: { type: 'string' },
+    secondaryLanguages: { type: 'array', items: { type: 'string' } },
+    frameworks: { type: 'array', items: { type: 'string' } },
+    entryPoints: { type: 'array', items: { type: 'string' } },
+    testingFrameworks: { type: 'array', items: { type: 'string' } },
+    totalFiles: { type: 'string' },
+    keyDirectories: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, purpose: { type: 'string' } }, required: ['path', 'purpose'] } },
+  },
+  required: ['primaryLanguage', 'frameworks', 'entryPoints', 'keyDirectories'],
+};
 
-  const DOMAIN_SCHEMA = {
-    type: 'object',
-    properties: {
-      domains: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, description: { type: 'string' }, keyFiles: { type: 'array', items: { type: 'string' } } }, required: ['name', 'description', 'keyFiles'] } },
-      coreAbstractions: { type: 'array', items: { type: 'string' } },
-      businessPurpose: { type: 'string' },
-    },
-    required: ['domains', 'coreAbstractions', 'businessPurpose'],
-  };
+const DOMAIN_SCHEMA = {
+  type: 'object',
+  properties: {
+    domains: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, description: { type: 'string' }, keyFiles: { type: 'array', items: { type: 'string' } } }, required: ['name', 'description', 'keyFiles'] } },
+    coreAbstractions: { type: 'array', items: { type: 'string' } },
+    businessPurpose: { type: 'string' },
+  },
+  required: ['domains', 'coreAbstractions', 'businessPurpose'],
+};
 
-  const ARCH_SCHEMA = {
-    type: 'object',
-    properties: {
-      architectureStyle: { type: 'string' },
-      layers: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, responsibility: { type: 'string' } }, required: ['name', 'responsibility'] } },
-      dataFlow: { type: 'string' },
-      keyPatterns: { type: 'array', items: { type: 'string' } },
-      externalDependencies: { type: 'array', items: { type: 'string' } },
-      gotchas: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['architectureStyle', 'layers', 'dataFlow', 'keyPatterns', 'gotchas'],
-  };
+const ARCH_SCHEMA = {
+  type: 'object',
+  properties: {
+    architectureStyle: { type: 'string' },
+    layers: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, responsibility: { type: 'string' } }, required: ['name', 'responsibility'] } },
+    dataFlow: { type: 'string' },
+    keyPatterns: { type: 'array', items: { type: 'string' } },
+    externalDependencies: { type: 'array', items: { type: 'string' } },
+    gotchas: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['architectureStyle', 'layers', 'dataFlow', 'keyPatterns', 'gotchas'],
+};
 
-  const TOUR_SCHEMA = {
-    type: 'object',
-    properties: {
-      quickStart: { type: 'string' },
-      tourSteps: { type: 'array', items: { type: 'object', properties: { step: { type: 'number' }, title: { type: 'string' }, file: { type: 'string' }, explanation: { type: 'string' } }, required: ['step', 'title', 'explanation'] } },
-      keyConventions: { type: 'array', items: { type: 'string' } },
-      whereToStartCoding: { type: 'string' },
-      commonPitfalls: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['quickStart', 'tourSteps', 'keyConventions', 'whereToStartCoding', 'commonPitfalls'],
-  };
+const TOUR_SCHEMA = {
+  type: 'object',
+  properties: {
+    quickStart: { type: 'string' },
+    tourSteps: { type: 'array', items: { type: 'object', properties: { step: { type: 'number' }, title: { type: 'string' }, file: { type: 'string' }, explanation: { type: 'string' } }, required: ['step', 'title', 'explanation'] } },
+    keyConventions: { type: 'array', items: { type: 'string' } },
+    whereToStartCoding: { type: 'string' },
+    commonPitfalls: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['quickStart', 'tourSteps', 'keyConventions', 'whereToStartCoding', 'commonPitfalls'],
+};
 
-  const repo = args || 'current repository (run from repo root)';
+const repo = args || 'current repository (run from repo root)';
 
-  phase('Map');
-  log(`Mapping: ${repo}`);
-  const map = await agent(
-    `Map the structure of this codebase: "${repo}"\n\nIdentify: primary language, frameworks, entry points (main files, index, CLI), test frameworks, and the purpose of each top-level directory. Be specific — list actual file paths.`,
-    { schema: MAP_SCHEMA, label: 'map' }
-  );
-  log(`${map.primaryLanguage} codebase, ${map.frameworks.join('+')} — ${map.keyDirectories.length} key directories`);
+phase('Map');
+log(`Mapping: ${repo}`);
+const map = await agent(
+  `Map the structure of this codebase: "${repo}"\n\nIdentify: primary language, frameworks, entry points (main files, index, CLI), test frameworks, and the purpose of each top-level directory. Be specific — list actual file paths.`,
+  { schema: MAP_SCHEMA, label: 'map' }
+);
+log(`${map.primaryLanguage} codebase, ${map.frameworks.join('+')} — ${map.keyDirectories.length} key directories`);
 
-  phase('Domain');
-  const mapSummary = `Stack: ${map.primaryLanguage} + ${map.frameworks.join(', ')}\nDirs: ${map.keyDirectories.map(d => `${d.path} (${d.purpose})`).join(', ')}`;
-  const domain = await agent(
-    `Identify the business domains and core abstractions in: "${repo}"\n${mapSummary}\n\nWhat problem does this software solve? What are the main domain concepts? What are the key abstractions (models, services, controllers, etc.)?`,
-    { schema: DOMAIN_SCHEMA, label: 'domain' }
-  );
-  log(`${domain.domains.length} domains: ${domain.domains.map(d => d.name).join(', ')}`);
+phase('Domain');
+const mapSummary = `Stack: ${map.primaryLanguage} + ${map.frameworks.join(', ')}\nDirs: ${map.keyDirectories.map(d => `${d.path} (${d.purpose})`).join(', ')}`;
+const domain = await agent(
+  `Identify the business domains and core abstractions in: "${repo}"\n${mapSummary}\n\nWhat problem does this software solve? What are the main domain concepts? What are the key abstractions (models, services, controllers, etc.)?`,
+  { schema: DOMAIN_SCHEMA, label: 'domain' }
+);
+log(`${domain.domains.length} domains: ${domain.domains.map(d => d.name).join(', ')}`);
 
-  phase('Architecture');
-  const domainSummary = `Purpose: ${domain.businessPurpose}\nDomains: ${domain.domains.map(d => d.name).join(', ')}\nAbstractions: ${domain.coreAbstractions.join(', ')}`;
-  const arch = await agent(
-    `Map the technical architecture of: "${repo}"\n${domainSummary}\n\nWhat architecture style (MVC, layered, event-driven, microservices)? What are the layers? How does data flow? What key patterns and gotchas should a new developer know?`,
-    { schema: ARCH_SCHEMA, label: 'architecture' }
-  );
+phase('Architecture');
+const domainSummary = `Purpose: ${domain.businessPurpose}\nDomains: ${domain.domains.map(d => d.name).join(', ')}\nAbstractions: ${domain.coreAbstractions.join(', ')}`;
+const arch = await agent(
+  `Map the technical architecture of: "${repo}"\n${domainSummary}\n\nWhat architecture style (MVC, layered, event-driven, microservices)? What are the layers? How does data flow? What key patterns and gotchas should a new developer know?`,
+  { schema: ARCH_SCHEMA, label: 'architecture' }
+);
 
-  phase('Tour');
-  const archSummary = `Style: ${arch.architectureStyle}\nLayers: ${arch.layers.map(l => l.name).join(' → ')}\nPatterns: ${arch.keyPatterns.join(', ')}`;
-  const tour = await agent(
-    `Create an onboarding tour for: "${repo}"\n${mapSummary}\n${domainSummary}\n${archSummary}\n\nWrite a quick start, a 5-10 step guided tour through the most important files (in learning order), key conventions to follow, where to start making changes, and common pitfalls to avoid.`,
-    { schema: TOUR_SCHEMA, label: 'tour' }
-  );
+phase('Tour');
+const archSummary = `Style: ${arch.architectureStyle}\nLayers: ${arch.layers.map(l => l.name).join(' → ')}\nPatterns: ${arch.keyPatterns.join(', ')}`;
+const tour = await agent(
+  `Create an onboarding tour for: "${repo}"\n${mapSummary}\n${domainSummary}\n${archSummary}\n\nWrite a quick start, a 5-10 step guided tour through the most important files (in learning order), key conventions to follow, where to start making changes, and common pitfalls to avoid.`,
+  { schema: TOUR_SCHEMA, label: 'tour' }
+);
 
-  return {
-    repo,
-    map,
-    domain,
-    architecture: arch,
-    tour,
-  };
-}
+return {
+  repo,
+  map,
+  domain,
+  architecture: arch,
+  tour,
+};

package/.mindforge/dynamic-workflows/scripts/orchestrate-review.js

@@ -0,0 +1,115 @@
+export const meta = {
+  name: 'orchestrate-review',
+  description: '4-lens parallel review — factual, domain, safety, style — coordinated as one panel and merged into a single verdict',
+  whenToUse: 'When reviewing content or a decision where correctness/security/performance is the wrong axis split — e.g. a document, a policy, a plan, an AI-generated artifact, anything where you want independent factual-accuracy, domain-expert, safety, and voice/style perspectives rather than code-review dimensions',
+  phases: [
+    { title: 'Scope', detail: 'pin the target and any domain context' },
+    { title: 'Panel', detail: '4 parallel lenses: factual / domain / safety / style' },
+    { title: 'Consensus', detail: 'merge findings, deduplicate, score severity' },
+    { title: 'Verdict', detail: 'single panel verdict with findings by lens' },
+  ],
+};
+
+const LENS_SCHEMA = {
+  type: 'object',
+  properties: {
+    lens: { type: 'string' },
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          severity: { type: 'string', enum: ['blocking', 'major', 'minor', 'suggestion'] },
+          location: { type: 'string' },
+          issue: { type: 'string' },
+          suggestion: { type: 'string' },
+        },
+        required: ['severity', 'issue', 'suggestion'],
+      },
+    },
+    summary: { type: 'string' },
+  },
+  required: ['lens', 'findings', 'summary'],
+};
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  properties: {
+    verdict: { type: 'string', enum: ['APPROVED', 'APPROVED_WITH_SUGGESTIONS', 'CHANGES_REQUIRED', 'BLOCKING'] },
+    summary: { type: 'string' },
+    blockingIssues: { type: 'array', items: { type: 'string' } },
+    majorIssues: { type: 'array', items: { type: 'string' } },
+    suggestions: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['verdict', 'summary', 'blockingIssues', 'majorIssues', 'suggestions'],
+};
+
+function parseArgs(raw) {
+  if (raw && typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('{')) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        // Not valid JSON despite looking like it — fall through and treat as a plain target string.
+      }
+    }
+    return trimmed;
+  }
+  return raw || {};
+}
+
+const input = parseArgs(args);
+const target = (typeof input === 'string' ? input : input.target) || 'the artifact provided in this conversation';
+const domainContext = typeof input === 'object' ? input.domainContext : null;
+
+phase('Scope');
+log(`Reviewing: ${target}`);
+if (domainContext) log(`Domain context: ${domainContext}`);
+
+const PANEL = [
+  {
+    label: 'factual',
+    prompt: `Review for FACTUAL ACCURACY: "${target}". Check every checkable claim: numbers, dates, names, quotes, causal claims, and anything stated as fact. Flag claims that are wrong, unverifiable, unsourced where a source is implied, or stated with more confidence than the evidence supports. Do not flag matters of opinion or style — only things that could be objectively wrong. Rate each as blocking/major/minor/suggestion.`,
+  },
+  {
+    label: 'domain',
+    prompt: `Review for DOMAIN CORRECTNESS: "${target}". ${domainContext ? `Domain context: ${domainContext}. ` : ''}Check whether the content reflects genuine expertise in its subject area: correct terminology, sound reasoning within the field's own conventions, no naive mistakes an actual practitioner would catch, and no missing context a domain expert would consider essential. Rate each as blocking/major/minor/suggestion.`,
+  },
+  {
+    label: 'safety',
+    prompt: `Review for SAFETY: "${target}". Check for: harmful, dangerous, or misleading instructions; content that could cause real-world harm if acted on; missing caveats on genuinely risky actions; privacy or security exposure; and anything that should carry a warning but doesn't. Do not flag mild edginess or strong opinions — only things with real potential for harm. Rate each as blocking/major/minor/suggestion.`,
+  },
+  {
+    label: 'style',
+    prompt: `Review for STYLE and VOICE: "${target}". Check for: clarity, tone consistency, awkward phrasing, structure that buries the point, jargon that doesn't earn its place, and whether the writing matches its evident purpose and audience. Rate each as blocking/major/minor/suggestion — reserve "blocking" for style so broken it undermines comprehension, not mere preference.`,
+  },
+];
+
+phase('Panel');
+const reviews = await parallel(
+  PANEL.map(p => () => agent(p.prompt, { schema: LENS_SCHEMA, label: `lens:${p.label}`, phase: 'Panel' }))
+);
+
+phase('Consensus');
+const allFindings = reviews.filter(Boolean).flatMap(r => r.findings.map(f => ({ ...f, lens: r.lens })));
+const blocking = allFindings.filter(f => f.severity === 'blocking');
+const major = allFindings.filter(f => f.severity === 'major');
+const minor = allFindings.filter(f => f.severity === 'minor');
+const suggestions = allFindings.filter(f => f.severity === 'suggestion');
+log(`${allFindings.length} total findings: ${blocking.length} blocking, ${major.length} major, ${minor.length} minor, ${suggestions.length} suggestions`);
+
+const findingsSummary = allFindings.slice(0, 20).map(f => `[${f.severity.toUpperCase()}][${f.lens}] ${f.issue} → ${f.suggestion}`).join('\n');
+
+phase('Verdict');
+const verdict = await agent(
+  `Produce a final panel verdict for: "${target}"\n\nFindings:\n${findingsSummary}\n\nIf there are any blocking issues, verdict is BLOCKING. If major issues exist, CHANGES_REQUIRED. If only minor/suggestions, APPROVED_WITH_SUGGESTIONS. Otherwise APPROVED.`,
+  { schema: VERDICT_SCHEMA, label: 'verdict' }
+);
+
+return {
+  target,
+  reviews: reviews.filter(Boolean),
+  verdict,
+  stats: { total: allFindings.length, blocking: blocking.length, major: major.length, minor: minor.length, suggestions: suggestions.length },
+};

package/.mindforge/dynamic-workflows/scripts/perf-optimize.js

@@ -10,119 +10,117 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const PROFILE_SCHEMA = {
-    type: 'object',
-    properties: {
-      slowestPaths: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, currentLatency: { type: 'string' }, target: { type: 'string' } }, required: ['path', 'currentLatency'] } },
-      bottleneckHypothesis: { type: 'string' },
-      profilingCommands: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['slowestPaths', 'bottleneckHypothesis', 'profilingCommands'],
-  };
+const PROFILE_SCHEMA = {
+  type: 'object',
+  properties: {
+    slowestPaths: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, currentLatency: { type: 'string' }, target: { type: 'string' } }, required: ['path', 'currentLatency'] } },
+    bottleneckHypothesis: { type: 'string' },
+    profilingCommands: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['slowestPaths', 'bottleneckHypothesis', 'profilingCommands'],
+};
 
-  const BOTTLENECK_SCHEMA = {
-    type: 'object',
-    properties: {
-      dimension: { type: 'string' },
-      issues: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            description: { type: 'string' },
-            location: { type: 'string' },
-            impact: { type: 'string', enum: ['high', 'medium', 'low'] },
-            fix: { type: 'string' },
-            effort: { type: 'string', enum: ['low', 'medium', 'high'] },
-          },
-          required: ['description', 'impact', 'fix', 'effort'],
+const BOTTLENECK_SCHEMA = {
+  type: 'object',
+  properties: {
+    dimension: { type: 'string' },
+    issues: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          description: { type: 'string' },
+          location: { type: 'string' },
+          impact: { type: 'string', enum: ['high', 'medium', 'low'] },
+          fix: { type: 'string' },
+          effort: { type: 'string', enum: ['low', 'medium', 'high'] },
         },
+        required: ['description', 'impact', 'fix', 'effort'],
       },
     },
-    required: ['dimension', 'issues'],
-  };
+  },
+  required: ['dimension', 'issues'],
+};
 
-  const FIX_PLAN_SCHEMA = {
-    type: 'object',
-    properties: {
-      prioritized: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            rank: { type: 'number' },
-            fix: { type: 'string' },
-            dimension: { type: 'string' },
-            expectedImprovement: { type: 'string' },
-            effort: { type: 'string' },
-            implementation: { type: 'string' },
-          },
-          required: ['rank', 'fix', 'expectedImprovement', 'effort', 'implementation'],
+const FIX_PLAN_SCHEMA = {
+  type: 'object',
+  properties: {
+    prioritized: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          rank: { type: 'number' },
+          fix: { type: 'string' },
+          dimension: { type: 'string' },
+          expectedImprovement: { type: 'string' },
+          effort: { type: 'string' },
+          implementation: { type: 'string' },
         },
+        required: ['rank', 'fix', 'expectedImprovement', 'effort', 'implementation'],
       },
-      totalEstimate: { type: 'string' },
-      quickWins: { type: 'array', items: { type: 'string' } },
     },
-    required: ['prioritized', 'totalEstimate', 'quickWins'],
-  };
+    totalEstimate: { type: 'string' },
+    quickWins: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['prioritized', 'totalEstimate', 'quickWins'],
+};
 
-  const BENCHMARK_SCHEMA = {
-    type: 'object',
-    properties: {
-      baselineTests: { type: 'array', items: { type: 'string' } },
-      successCriteria: { type: 'array', items: { type: 'object', properties: { fix: { type: 'string' }, metric: { type: 'string' }, target: { type: 'string' } }, required: ['fix', 'metric', 'target'] } },
-      monitoringSetup: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['baselineTests', 'successCriteria', 'monitoringSetup'],
-  };
+const BENCHMARK_SCHEMA = {
+  type: 'object',
+  properties: {
+    baselineTests: { type: 'array', items: { type: 'string' } },
+    successCriteria: { type: 'array', items: { type: 'object', properties: { fix: { type: 'string' }, metric: { type: 'string' }, target: { type: 'string' } }, required: ['fix', 'metric', 'target'] } },
+    monitoringSetup: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['baselineTests', 'successCriteria', 'monitoringSetup'],
+};
 
-  const target = args || 'current application (run from repo root)';
+const target = args || 'current application (run from repo root)';
 
-  phase('Profile');
-  log(`Profiling: ${target}`);
-  const profile = await agent(
-    `Identify the slowest code paths and performance bottleneck hypothesis for: "${target}"\n\nWhat are the likely slow endpoints/functions? What profiling commands should be run? What is your initial bottleneck hypothesis?`,
-    { schema: PROFILE_SCHEMA, label: 'profile' }
-  );
-  log(`${profile.slowestPaths.length} slow paths identified, hypothesis: ${profile.bottleneckHypothesis.slice(0, 80)}`);
+phase('Profile');
+log(`Profiling: ${target}`);
+const profile = await agent(
+  `Identify the slowest code paths and performance bottleneck hypothesis for: "${target}"\n\nWhat are the likely slow endpoints/functions? What profiling commands should be run? What is your initial bottleneck hypothesis?`,
+  { schema: PROFILE_SCHEMA, label: 'profile' }
+);
+log(`${profile.slowestPaths.length} slow paths identified, hypothesis: ${profile.bottleneckHypothesis.slice(0, 80)}`);
 
-  phase('Identify');
-  const context = `Target: ${target}\nSlow paths: ${profile.slowestPaths.map(p => p.path).join(', ')}\nHypothesis: ${profile.bottleneckHypothesis}`;
+phase('Identify');
+const context = `Target: ${target}\nSlow paths: ${profile.slowestPaths.map(p => p.path).join(', ')}\nHypothesis: ${profile.bottleneckHypothesis}`;
 
-  const DIMENSIONS = [
-    { label: 'db', prompt: `Hunt for DATABASE performance bottlenecks in: ${context}\n\nLook for: N+1 queries, missing indexes, full table scans, unoptimized JOINs, missing query caching, connection pool exhaustion, slow aggregate queries.` },
-    { label: 'network', prompt: `Hunt for NETWORK performance bottlenecks in: ${context}\n\nLook for: missing HTTP caching, no CDN, uncompressed responses, chatty APIs (many small requests), missing connection pooling, DNS lookups in hot paths, synchronous external calls.` },
-    { label: 'cpu', prompt: `Hunt for CPU/COMPUTE performance bottlenecks in: ${context}\n\nLook for: inefficient algorithms (O(n²) where O(n log n) exists), regex in hot paths, JSON serialization overhead, cryptographic operations in request path, missing memoization.` },
-    { label: 'memory', prompt: `Hunt for MEMORY performance bottlenecks in: ${context}\n\nLook for: memory leaks, unbounded caches, large object retention, excessive GC pressure, buffer accumulation, object pool exhaustion, unnecessary data loading.` },
-  ];
+const DIMENSIONS = [
+  { label: 'db', prompt: `Hunt for DATABASE performance bottlenecks in: ${context}\n\nLook for: N+1 queries, missing indexes, full table scans, unoptimized JOINs, missing query caching, connection pool exhaustion, slow aggregate queries.` },
+  { label: 'network', prompt: `Hunt for NETWORK performance bottlenecks in: ${context}\n\nLook for: missing HTTP caching, no CDN, uncompressed responses, chatty APIs (many small requests), missing connection pooling, DNS lookups in hot paths, synchronous external calls.` },
+  { label: 'cpu', prompt: `Hunt for CPU/COMPUTE performance bottlenecks in: ${context}\n\nLook for: inefficient algorithms (O(n²) where O(n log n) exists), regex in hot paths, JSON serialization overhead, cryptographic operations in request path, missing memoization.` },
+  { label: 'memory', prompt: `Hunt for MEMORY performance bottlenecks in: ${context}\n\nLook for: memory leaks, unbounded caches, large object retention, excessive GC pressure, buffer accumulation, object pool exhaustion, unnecessary data loading.` },
+];
 
-  const bottlenecks = await parallel(
-    DIMENSIONS.map(d => () => agent(d.prompt, { schema: BOTTLENECK_SCHEMA, label: `identify:${d.label}`, phase: 'Identify' }))
-  );
+const bottlenecks = await parallel(
+  DIMENSIONS.map(d => () => agent(d.prompt, { schema: BOTTLENECK_SCHEMA, label: `identify:${d.label}`, phase: 'Identify' }))
+);
 
-  phase('Plan');
-  const allIssues = bottlenecks.filter(Boolean).flatMap(b => b.issues.map(i => ({ ...i, dimension: b.dimension })));
-  log(`${allIssues.length} bottlenecks found across ${bottlenecks.filter(Boolean).length} dimensions`);
-  const issueList = allIssues.slice(0, 20).map(i => `[${i.dimension}][${i.impact}/${i.effort}] ${i.description} → ${i.fix}`).join('\n');
-  const fixPlan = await agent(
-    `Prioritize this performance fix backlog by impact-to-effort ratio:\n${issueList}\n\nRank by: high impact + low effort first. List quick wins (can implement in <1 hour) separately. Include implementation guidance for each.`,
-    { schema: FIX_PLAN_SCHEMA, label: 'plan' }
-  );
+phase('Plan');
+const allIssues = bottlenecks.filter(Boolean).flatMap(b => b.issues.map(i => ({ ...i, dimension: b.dimension })));
+log(`${allIssues.length} bottlenecks found across ${bottlenecks.filter(Boolean).length} dimensions`);
+const issueList = allIssues.slice(0, 20).map(i => `[${i.dimension}][${i.impact}/${i.effort}] ${i.description} → ${i.fix}`).join('\n');
+const fixPlan = await agent(
+  `Prioritize this performance fix backlog by impact-to-effort ratio:\n${issueList}\n\nRank by: high impact + low effort first. List quick wins (can implement in <1 hour) separately. Include implementation guidance for each.`,
+  { schema: FIX_PLAN_SCHEMA, label: 'plan' }
+);
 
-  phase('Benchmark');
-  const topFixes = fixPlan.prioritized.slice(0, 5).map(f => `${f.rank}. ${f.fix} (expected: ${f.expectedImprovement})`).join('\n');
-  const benchmarks = await agent(
-    `Define performance benchmarks for verifying these fixes:\n${topFixes}\n\nFor each fix, specify: the baseline test to run before, the success metric (P95 latency, throughput, memory), and the target value. Include monitoring setup recommendations.`,
-    { schema: BENCHMARK_SCHEMA, label: 'benchmark' }
-  );
+phase('Benchmark');
+const topFixes = fixPlan.prioritized.slice(0, 5).map(f => `${f.rank}. ${f.fix} (expected: ${f.expectedImprovement})`).join('\n');
+const benchmarks = await agent(
+  `Define performance benchmarks for verifying these fixes:\n${topFixes}\n\nFor each fix, specify: the baseline test to run before, the success metric (P95 latency, throughput, memory), and the target value. Include monitoring setup recommendations.`,
+  { schema: BENCHMARK_SCHEMA, label: 'benchmark' }
+);
 
-  return {
-    target,
-    profile,
-    bottlenecks: bottlenecks.filter(Boolean),
-    fixPlan,
-    benchmarks,
-    stats: { totalIssues: allIssues.length, quickWins: fixPlan.quickWins.length },
-  };
-}
+return {
+  target,
+  profile,
+  bottlenecks: bottlenecks.filter(Boolean),
+  fixPlan,
+  benchmarks,
+  stats: { totalIssues: allIssues.length, quickWins: fixPlan.quickWins.length },
+};