mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/incident-response.js

@@ -10,97 +10,95 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const CHARACTERIZE_SCHEMA = {
-    type: 'object',
-    properties: {
-      incidentTitle: { type: 'string' },
-      severity: { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] },
-      impactDescription: { type: 'string' },
-      affectedSystems: { type: 'array', items: { type: 'string' } },
-      startTime: { type: 'string' },
-      symptoms: { type: 'array', items: { type: 'string' } },
-      hypothesis: { type: 'string' },
-    },
-    required: ['incidentTitle', 'severity', 'impactDescription', 'affectedSystems', 'symptoms', 'hypothesis'],
-  };
+const CHARACTERIZE_SCHEMA = {
+  type: 'object',
+  properties: {
+    incidentTitle: { type: 'string' },
+    severity: { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] },
+    impactDescription: { type: 'string' },
+    affectedSystems: { type: 'array', items: { type: 'string' } },
+    startTime: { type: 'string' },
+    symptoms: { type: 'array', items: { type: 'string' } },
+    hypothesis: { type: 'string' },
+  },
+  required: ['incidentTitle', 'severity', 'impactDescription', 'affectedSystems', 'symptoms', 'hypothesis'],
+};
 
-  const INVESTIGATE_SCHEMA = {
-    type: 'object',
-    properties: {
-      angle: { type: 'string' },
-      findings: { type: 'array', items: { type: 'string' } },
-      suspectedCause: { type: 'string' },
-      confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
-    },
-    required: ['angle', 'findings', 'suspectedCause', 'confidence'],
-  };
+const INVESTIGATE_SCHEMA = {
+  type: 'object',
+  properties: {
+    angle: { type: 'string' },
+    findings: { type: 'array', items: { type: 'string' } },
+    suspectedCause: { type: 'string' },
+    confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+  },
+  required: ['angle', 'findings', 'suspectedCause', 'confidence'],
+};
 
-  const MITIGATE_SCHEMA = {
-    type: 'object',
-    properties: {
-      immediateActions: { type: 'array', items: { type: 'object', properties: { action: { type: 'string' }, command: { type: 'string' }, risk: { type: 'string' } }, required: ['action', 'risk'] } },
-      estimatedRecoveryTime: { type: 'string' },
-      rollbackSteps: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['immediateActions', 'estimatedRecoveryTime', 'rollbackSteps'],
-  };
+const MITIGATE_SCHEMA = {
+  type: 'object',
+  properties: {
+    immediateActions: { type: 'array', items: { type: 'object', properties: { action: { type: 'string' }, command: { type: 'string' }, risk: { type: 'string' } }, required: ['action', 'risk'] } },
+    estimatedRecoveryTime: { type: 'string' },
+    rollbackSteps: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['immediateActions', 'estimatedRecoveryTime', 'rollbackSteps'],
+};
 
-  const POSTMORTEM_SCHEMA = {
-    type: 'object',
-    properties: {
-      rootCause: { type: 'string' },
-      timeline: { type: 'array', items: { type: 'object', properties: { time: { type: 'string' }, event: { type: 'string' } }, required: ['time', 'event'] } },
-      contributingFactors: { type: 'array', items: { type: 'string' } },
-      actionItems: { type: 'array', items: { type: 'object', properties: { action: { type: 'string' }, owner: { type: 'string' }, priority: { type: 'string' } }, required: ['action', 'owner', 'priority'] } },
-      lessonsLearned: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['rootCause', 'timeline', 'contributingFactors', 'actionItems', 'lessonsLearned'],
-  };
+const POSTMORTEM_SCHEMA = {
+  type: 'object',
+  properties: {
+    rootCause: { type: 'string' },
+    timeline: { type: 'array', items: { type: 'object', properties: { time: { type: 'string' }, event: { type: 'string' } }, required: ['time', 'event'] } },
+    contributingFactors: { type: 'array', items: { type: 'string' } },
+    actionItems: { type: 'array', items: { type: 'object', properties: { action: { type: 'string' }, owner: { type: 'string' }, priority: { type: 'string' } }, required: ['action', 'owner', 'priority'] } },
+    lessonsLearned: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['rootCause', 'timeline', 'contributingFactors', 'actionItems', 'lessonsLearned'],
+};
 
-  const incident = args || 'No incident description provided — pass your incident description, symptoms, and affected systems as args.';
+const incident = args || 'No incident description provided — pass your incident description, symptoms, and affected systems as args.';
 
-  phase('Alert');
-  log(`Incident: ${incident.slice(0, 80)}`);
-  const characterization = await agent(
-    `Characterize this production incident: "${incident}"\n\nDetermine severity (P0=total outage, P1=major degradation, P2=partial impact, P3=minor), list affected systems, symptoms, and your initial hypothesis about the root cause.`,
-    { schema: CHARACTERIZE_SCHEMA, label: 'characterize' }
-  );
-  log(`[${characterization.severity}] ${characterization.incidentTitle} — ${characterization.symptoms.length} symptoms identified`);
+phase('Alert');
+log(`Incident: ${incident.slice(0, 80)}`);
+const characterization = await agent(
+  `Characterize this production incident: "${incident}"\n\nDetermine severity (P0=total outage, P1=major degradation, P2=partial impact, P3=minor), list affected systems, symptoms, and your initial hypothesis about the root cause.`,
+  { schema: CHARACTERIZE_SCHEMA, label: 'characterize' }
+);
+log(`[${characterization.severity}] ${characterization.incidentTitle} — ${characterization.symptoms.length} symptoms identified`);
 
-  phase('Investigate');
-  const context = `Incident: ${characterization.incidentTitle}\nHypothesis: ${characterization.hypothesis}\nSystems: ${characterization.affectedSystems.join(', ')}`;
+phase('Investigate');
+const context = `Incident: ${characterization.incidentTitle}\nHypothesis: ${characterization.hypothesis}\nSystems: ${characterization.affectedSystems.join(', ')}`;
 
-  const INVESTIGATION_ANGLES = [
-    { label: 'logs', prompt: `Investigate this incident from the LOGS angle: ${context}\n\nWhat log patterns, error messages, or anomalies would you look for? What do recent application/system logs likely show? What would confirm or refute the hypothesis?` },
-    { label: 'metrics', prompt: `Investigate this incident from the METRICS angle: ${context}\n\nWhat metrics (CPU, memory, latency, error rates, throughput) would spike or drop? What dashboards to check? What thresholds were likely crossed?` },
-    { label: 'traces', prompt: `Investigate this incident from the DISTRIBUTED TRACES angle: ${context}\n\nWhat trace patterns would reveal the failure point? Which service calls would show elevated latency or errors? What would a flame graph show?` },
-    { label: 'code', prompt: `Investigate this incident from the RECENT CODE CHANGES angle: ${context}\n\nWhat types of recent deployments, config changes, or dependency updates could cause this? What specific code patterns are suspect? What git history to examine?` },
-  ];
+const INVESTIGATION_ANGLES = [
+  { label: 'logs', prompt: `Investigate this incident from the LOGS angle: ${context}\n\nWhat log patterns, error messages, or anomalies would you look for? What do recent application/system logs likely show? What would confirm or refute the hypothesis?` },
+  { label: 'metrics', prompt: `Investigate this incident from the METRICS angle: ${context}\n\nWhat metrics (CPU, memory, latency, error rates, throughput) would spike or drop? What dashboards to check? What thresholds were likely crossed?` },
+  { label: 'traces', prompt: `Investigate this incident from the DISTRIBUTED TRACES angle: ${context}\n\nWhat trace patterns would reveal the failure point? Which service calls would show elevated latency or errors? What would a flame graph show?` },
+  { label: 'code', prompt: `Investigate this incident from the RECENT CODE CHANGES angle: ${context}\n\nWhat types of recent deployments, config changes, or dependency updates could cause this? What specific code patterns are suspect? What git history to examine?` },
+];
 
-  const investigations = await parallel(
-    INVESTIGATION_ANGLES.map(a => () => agent(a.prompt, { schema: INVESTIGATE_SCHEMA, label: `investigate:${a.label}`, phase: 'Investigate' }))
-  );
+const investigations = await parallel(
+  INVESTIGATION_ANGLES.map(a => () => agent(a.prompt, { schema: INVESTIGATE_SCHEMA, label: `investigate:${a.label}`, phase: 'Investigate' }))
+);
 
-  phase('Mitigate');
-  const investigationSummary = investigations.filter(Boolean).map(i => `[${i.angle}] ${i.suspectedCause} (${i.confidence} confidence): ${i.findings.slice(0, 2).join(', ')}`).join('\n');
-  const mitigation = await agent(
-    `Based on these investigation findings, identify IMMEDIATE mitigation actions:\n${investigationSummary}\n\nPrioritize actions that restore service quickly. Include rollback steps and estimate recovery time.`,
-    { schema: MITIGATE_SCHEMA, label: 'mitigate' }
-  );
+phase('Mitigate');
+const investigationSummary = investigations.filter(Boolean).map(i => `[${i.angle}] ${i.suspectedCause} (${i.confidence} confidence): ${i.findings.slice(0, 2).join(', ')}`).join('\n');
+const mitigation = await agent(
+  `Based on these investigation findings, identify IMMEDIATE mitigation actions:\n${investigationSummary}\n\nPrioritize actions that restore service quickly. Include rollback steps and estimate recovery time.`,
+  { schema: MITIGATE_SCHEMA, label: 'mitigate' }
+);
 
-  phase('RCA');
-  const allContext = `Incident: ${characterization.incidentTitle}\nInvestigations:\n${investigationSummary}\nMitigation: ${mitigation.immediateActions.map(a => a.action).join(', ')}`;
-  const postmortem = await agent(
-    `Write a blameless postmortem for this incident:\n${allContext}\n\nIdentify the root cause, create a timeline, list contributing factors, define concrete action items (with owners and priority), and extract lessons learned.`,
-    { schema: POSTMORTEM_SCHEMA, label: 'postmortem' }
-  );
+phase('RCA');
+const allContext = `Incident: ${characterization.incidentTitle}\nInvestigations:\n${investigationSummary}\nMitigation: ${mitigation.immediateActions.map(a => a.action).join(', ')}`;
+const postmortem = await agent(
+  `Write a blameless postmortem for this incident:\n${allContext}\n\nIdentify the root cause, create a timeline, list contributing factors, define concrete action items (with owners and priority), and extract lessons learned.`,
+  { schema: POSTMORTEM_SCHEMA, label: 'postmortem' }
+);
 
-  return {
-    incident,
-    characterization,
-    investigations: investigations.filter(Boolean),
-    mitigation,
-    postmortem,
-  };
-}
+return {
+  incident,
+  characterization,
+  investigations: investigations.filter(Boolean),
+  mitigation,
+  postmortem,
+};

package/.mindforge/dynamic-workflows/scripts/multi-repo-sync.js

@@ -10,54 +10,52 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const REPO_SCHEMA = {
-    type: 'object',
-    properties: {
-      repos: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, path: { type: 'string' }, role: { type: 'string' } }, required: ['name', 'path'] } },
-      referenceRepo: { type: 'string' },
-      syncDimensions: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['repos', 'syncDimensions'],
-  };
-
-  const AUDIT_SCHEMA = {
-    type: 'object',
-    properties: {
-      repo: { type: 'string' },
-      divergences: { type: 'array', items: { type: 'object', properties: { dimension: { type: 'string' }, severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] }, description: { type: 'string' }, fix: { type: 'string' } }, required: ['dimension', 'severity', 'description', 'fix'] } },
-    },
-    required: ['repo', 'divergences'],
-  };
-
-  const SYNC_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      syncItems: { type: 'array', items: { type: 'object', properties: { repo: { type: 'string' }, dimension: { type: 'string' }, action: { type: 'string' }, priority: { type: 'string', enum: ['p0', 'p1', 'p2'] } }, required: ['repo', 'dimension', 'action', 'priority'] } },
-    },
-    required: ['summary', 'syncItems'],
-  };
-
-  const target = args || 'current workspace (list repo paths in args, comma-separated)';
-
-  phase('Discover');
-  const discovery = await agent(`Discover all related repositories in: "${target}". List each repo's name, path, and role (primary/service/library/config). Identify the reference/canonical repo (if any) and what dimensions should be synchronized: dependencies, CI config, lint config, code conventions, shared utilities, test patterns.`, { schema: REPO_SCHEMA, label: 'discover' });
-  if (!discovery) { return { target, error: 'discovery-agent-null' }; }
-  log(`Found ${discovery.repos.length} repos, ${discovery.syncDimensions.length} sync dimensions`);
-
-  phase('Audit');
-  const audits = await parallel(
-    discovery.repos.map(r => () => agent(`Audit repo "${r.name}" at "${r.path}" against the reference "${discovery.referenceRepo || 'best practices'}". Check dimensions: ${discovery.syncDimensions.join(', ')}. For each divergence: dimension, severity, what differs, and exact fix.`, { schema: AUDIT_SCHEMA, label: `audit:${r.name}`, phase: 'Audit' }))
-  );
-
-  phase('DivergenceMap');
-  const allDivergences = audits.filter(Boolean).flatMap(a => a.divergences.map(d => ({ repo: a.repo, ...d })));
-  log(`${allDivergences.length} divergences across ${discovery.repos.length} repos`);
-
-  phase('SyncPlan');
-  const divergenceText = allDivergences.slice(0, 20).map(d => `[${d.severity}] ${d.repo}/${d.dimension}: ${d.description} → ${d.fix}`).join('\n');
-  const syncPlan = await agent(`Create a sync plan for: "${target}"\n\nDivergences:\n${divergenceText}\n\nPrioritize by severity and group by dimension for efficient batching. P0=critical/security, P1=high/consistency, P2=medium/nice-to-have.`, { schema: SYNC_SCHEMA, label: 'sync-plan' });
-
-  return { target, discovery, audits: audits.filter(Boolean), syncPlan };
-}
+const REPO_SCHEMA = {
+  type: 'object',
+  properties: {
+    repos: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, path: { type: 'string' }, role: { type: 'string' } }, required: ['name', 'path'] } },
+    referenceRepo: { type: 'string' },
+    syncDimensions: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['repos', 'syncDimensions'],
+};
+
+const AUDIT_SCHEMA = {
+  type: 'object',
+  properties: {
+    repo: { type: 'string' },
+    divergences: { type: 'array', items: { type: 'object', properties: { dimension: { type: 'string' }, severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] }, description: { type: 'string' }, fix: { type: 'string' } }, required: ['dimension', 'severity', 'description', 'fix'] } },
+  },
+  required: ['repo', 'divergences'],
+};
+
+const SYNC_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    syncItems: { type: 'array', items: { type: 'object', properties: { repo: { type: 'string' }, dimension: { type: 'string' }, action: { type: 'string' }, priority: { type: 'string', enum: ['p0', 'p1', 'p2'] } }, required: ['repo', 'dimension', 'action', 'priority'] } },
+  },
+  required: ['summary', 'syncItems'],
+};
+
+const target = args || 'current workspace (list repo paths in args, comma-separated)';
+
+phase('Discover');
+const discovery = await agent(`Discover all related repositories in: "${target}". List each repo's name, path, and role (primary/service/library/config). Identify the reference/canonical repo (if any) and what dimensions should be synchronized: dependencies, CI config, lint config, code conventions, shared utilities, test patterns.`, { schema: REPO_SCHEMA, label: 'discover' });
+if (!discovery) { return { target, error: 'discovery-agent-null' }; }
+log(`Found ${discovery.repos.length} repos, ${discovery.syncDimensions.length} sync dimensions`);
+
+phase('Audit');
+const audits = await parallel(
+  discovery.repos.map(r => () => agent(`Audit repo "${r.name}" at "${r.path}" against the reference "${discovery.referenceRepo || 'best practices'}". Check dimensions: ${discovery.syncDimensions.join(', ')}. For each divergence: dimension, severity, what differs, and exact fix.`, { schema: AUDIT_SCHEMA, label: `audit:${r.name}`, phase: 'Audit' }))
+);
+
+phase('DivergenceMap');
+const allDivergences = audits.filter(Boolean).flatMap(a => a.divergences.map(d => ({ repo: a.repo, ...d })));
+log(`${allDivergences.length} divergences across ${discovery.repos.length} repos`);
+
+phase('SyncPlan');
+const divergenceText = allDivergences.slice(0, 20).map(d => `[${d.severity}] ${d.repo}/${d.dimension}: ${d.description} → ${d.fix}`).join('\n');
+const syncPlan = await agent(`Create a sync plan for: "${target}"\n\nDivergences:\n${divergenceText}\n\nPrioritize by severity and group by dimension for efficient batching. P0=critical/security, P1=high/consistency, P2=medium/nice-to-have.`, { schema: SYNC_SCHEMA, label: 'sync-plan' });
+
+return { target, discovery, audits: audits.filter(Boolean), syncPlan };

package/.mindforge/dynamic-workflows/scripts/mutation-testing.js

@@ -10,139 +10,137 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const SOURCE_SCHEMA = {
-    type: 'object',
-    properties: {
-      sourceFiles: { type: 'array', items: { type: 'string' } },
-      testFiles: { type: 'array', items: { type: 'string' } },
-      mutableLines: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            file: { type: 'string' },
-            lineNumber: { type: 'number' },
-            code: { type: 'string' },
-            mutationType: { type: 'string', enum: ['condition', 'operator', 'return-value', 'boundary', 'negation', 'constant'] },
-          },
-          required: ['file', 'code', 'mutationType'],
+const SOURCE_SCHEMA = {
+  type: 'object',
+  properties: {
+    sourceFiles: { type: 'array', items: { type: 'string' } },
+    testFiles: { type: 'array', items: { type: 'string' } },
+    mutableLines: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          file: { type: 'string' },
+          lineNumber: { type: 'number' },
+          code: { type: 'string' },
+          mutationType: { type: 'string', enum: ['condition', 'operator', 'return-value', 'boundary', 'negation', 'constant'] },
         },
+        required: ['file', 'code', 'mutationType'],
       },
     },
-    required: ['sourceFiles', 'testFiles', 'mutableLines'],
-  };
+  },
+  required: ['sourceFiles', 'testFiles', 'mutableLines'],
+};
 
-  const MUTATIONS_SCHEMA = {
-    type: 'object',
-    properties: {
-      mutations: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            id: { type: 'string' },
-            file: { type: 'string' },
-            original: { type: 'string' },
-            mutated: { type: 'string' },
-            mutationType: { type: 'string' },
-            description: { type: 'string' },
-          },
-          required: ['id', 'file', 'original', 'mutated', 'mutationType', 'description'],
+const MUTATIONS_SCHEMA = {
+  type: 'object',
+  properties: {
+    mutations: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          file: { type: 'string' },
+          original: { type: 'string' },
+          mutated: { type: 'string' },
+          mutationType: { type: 'string' },
+          description: { type: 'string' },
         },
+        required: ['id', 'file', 'original', 'mutated', 'mutationType', 'description'],
       },
     },
-    required: ['mutations'],
-  };
+  },
+  required: ['mutations'],
+};
 
-  const KILL_SCHEMA = {
-    type: 'object',
-    properties: {
-      mutationId: { type: 'string' },
-      status: { type: 'string', enum: ['killed', 'survived', 'timeout', 'equivalent'] },
-      killedBy: { type: 'string' },
-      reason: { type: 'string' },
-      suggestedTest: { type: 'string' },
-    },
-    required: ['mutationId', 'status', 'reason'],
-  };
+const KILL_SCHEMA = {
+  type: 'object',
+  properties: {
+    mutationId: { type: 'string' },
+    status: { type: 'string', enum: ['killed', 'survived', 'timeout', 'equivalent'] },
+    killedBy: { type: 'string' },
+    reason: { type: 'string' },
+    suggestedTest: { type: 'string' },
+  },
+  required: ['mutationId', 'status', 'reason'],
+};
 
-  const REPORT_SCHEMA = {
-    type: 'object',
-    properties: {
-      mutationScore: { type: 'number' },
-      summary: { type: 'string' },
-      killed: { type: 'number' },
-      survived: { type: 'number' },
-      timeout: { type: 'number' },
-      equivalent: { type: 'number' },
-      survivorDetails: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            mutation: { type: 'string' },
-            suggestedTest: { type: 'string' },
-          },
-          required: ['mutation', 'suggestedTest'],
+const REPORT_SCHEMA = {
+  type: 'object',
+  properties: {
+    mutationScore: { type: 'number' },
+    summary: { type: 'string' },
+    killed: { type: 'number' },
+    survived: { type: 'number' },
+    timeout: { type: 'number' },
+    equivalent: { type: 'number' },
+    survivorDetails: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          mutation: { type: 'string' },
+          suggestedTest: { type: 'string' },
         },
+        required: ['mutation', 'suggestedTest'],
       },
-      topWeaknesses: { type: 'array', items: { type: 'string' } },
     },
-    required: ['mutationScore', 'summary', 'killed', 'survived', 'topWeaknesses'],
-  };
+    topWeaknesses: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['mutationScore', 'summary', 'killed', 'survived', 'topWeaknesses'],
+};
 
-  const target = args || 'current codebase (run from repo root)';
+const target = args || 'current codebase (run from repo root)';
 
-  phase('Analyze');
-  log(`Analyzing source for mutable lines in: ${target}`);
-  const sourceAnalysis = await agent(
-    `Analyze the source code in: "${target}" to identify mutable lines for mutation testing. Find: (1) conditional expressions (if/else, ternary, switch), (2) arithmetic/comparison operators (+, -, *, /, >, <, ==, !=), (3) return values in key functions, (4) boundary values (0, -1, +1, null checks), (5) boolean negations. Also identify source files and their test files. List the 15 most testable mutable lines.`,
-    { schema: SOURCE_SCHEMA, label: 'analyze' }
-  );
-  if (!sourceAnalysis) { return { target, error: 'sourceAnalysis-agent-null' }; }
-  log(`Found ${sourceAnalysis.mutableLines.length} mutable lines across ${sourceAnalysis.sourceFiles.length} source files`);
+phase('Analyze');
+log(`Analyzing source for mutable lines in: ${target}`);
+const sourceAnalysis = await agent(
+  `Analyze the source code in: "${target}" to identify mutable lines for mutation testing. Find: (1) conditional expressions (if/else, ternary, switch), (2) arithmetic/comparison operators (+, -, *, /, >, <, ==, !=), (3) return values in key functions, (4) boundary values (0, -1, +1, null checks), (5) boolean negations. Also identify source files and their test files. List the 15 most testable mutable lines.`,
+  { schema: SOURCE_SCHEMA, label: 'analyze' }
+);
+if (!sourceAnalysis) { return { target, error: 'sourceAnalysis-agent-null' }; }
+log(`Found ${sourceAnalysis.mutableLines.length} mutable lines across ${sourceAnalysis.sourceFiles.length} source files`);
 
-  phase('Mutate');
-  const mutableContext = sourceAnalysis.mutableLines.slice(0, 15).map(l => `${l.file}:${l.lineNumber || '?'} [${l.mutationType}] \`${l.code}\``).join('\n');
-  const mutationSpec = await agent(
-    `Generate 10-15 specific mutations for testing the test suite quality of: "${target}"\n\nMutable lines:\n${mutableContext}\n\nFor each mutation: assign unique ID (M01, M02...), show original code, mutated code, mutation type, and plain-English description of what changed. Focus on mutations that SHOULD be caught by good tests — boundary off-by-ones, condition flips, operator swaps.`,
-    { schema: MUTATIONS_SCHEMA, label: 'mutate' }
-  );
-  if (!mutationSpec) { return { target, sourceAnalysis, error: 'mutationSpec-agent-null' }; }
-  log(`Generated ${mutationSpec.mutations.length} mutations`);
+phase('Mutate');
+const mutableContext = sourceAnalysis.mutableLines.slice(0, 15).map(l => `${l.file}:${l.lineNumber || '?'} [${l.mutationType}] \`${l.code}\``).join('\n');
+const mutationSpec = await agent(
+  `Generate 10-15 specific mutations for testing the test suite quality of: "${target}"\n\nMutable lines:\n${mutableContext}\n\nFor each mutation: assign unique ID (M01, M02...), show original code, mutated code, mutation type, and plain-English description of what changed. Focus on mutations that SHOULD be caught by good tests — boundary off-by-ones, condition flips, operator swaps.`,
+  { schema: MUTATIONS_SCHEMA, label: 'mutate' }
+);
+if (!mutationSpec) { return { target, sourceAnalysis, error: 'mutationSpec-agent-null' }; }
+log(`Generated ${mutationSpec.mutations.length} mutations`);
 
-  phase('Kill');
-  const killResults = await parallel(
-    mutationSpec.mutations.map(m => () => agent(
-      `Assess if the existing test suite in: "${target}" would CATCH this mutation.\n\nMutation ${m.id}: In file ${m.file}, changed \`${m.original}\` to \`${m.mutated}\`.\nDescription: ${m.description}\n\nLook at the test files. Would any existing test fail if this mutation were applied? Answer: killed (test would fail), survived (no test catches it), equivalent (mutation doesn't change behavior), or timeout (unclear). If survived, suggest a specific test that would kill it.`,
-      { schema: KILL_SCHEMA, label: `kill:${m.id}`, phase: 'Kill' }
-    ))
-  );
+phase('Kill');
+const killResults = await parallel(
+  mutationSpec.mutations.map(m => () => agent(
+    `Assess if the existing test suite in: "${target}" would CATCH this mutation.\n\nMutation ${m.id}: In file ${m.file}, changed \`${m.original}\` to \`${m.mutated}\`.\nDescription: ${m.description}\n\nLook at the test files. Would any existing test fail if this mutation were applied? Answer: killed (test would fail), survived (no test catches it), equivalent (mutation doesn't change behavior), or timeout (unclear). If survived, suggest a specific test that would kill it.`,
+    { schema: KILL_SCHEMA, label: `kill:${m.id}`, phase: 'Kill' }
+  ))
+);
 
-  phase('Report');
-  const killData = killResults.filter(Boolean);
-  const killed = killData.filter(r => r.status === 'killed').length;
-  const survived = killData.filter(r => r.status === 'survived').length;
-  const timeout = killData.filter(r => r.status === 'timeout').length;
-  const equivalent = killData.filter(r => r.status === 'equivalent').length;
-  const total = killed + survived + timeout;
-  const mutationScore = total > 0 ? Math.round((killed / total) * 100) : 0;
+phase('Report');
+const killData = killResults.filter(Boolean);
+const killed = killData.filter(r => r.status === 'killed').length;
+const survived = killData.filter(r => r.status === 'survived').length;
+const timeout = killData.filter(r => r.status === 'timeout').length;
+const equivalent = killData.filter(r => r.status === 'equivalent').length;
+const total = killed + survived + timeout;
+const mutationScore = total > 0 ? Math.round((killed / total) * 100) : 0;
 
-  log(`Mutation score: ${mutationScore}% (${killed} killed, ${survived} survived, ${timeout} timeout)`);
+log(`Mutation score: ${mutationScore}% (${killed} killed, ${survived} survived, ${timeout} timeout)`);
 
-  const survivorSummary = killData
-    .filter(r => r.status === 'survived')
-    .map(r => {
-      const mutation = mutationSpec.mutations.find(m => m.id === r.mutationId);
-      return `${r.mutationId}: ${mutation ? mutation.description : r.mutationId} — suggested test: ${r.suggestedTest || 'none'}`;
-    })
-    .join('\n');
+const survivorSummary = killData
+  .filter(r => r.status === 'survived')
+  .map(r => {
+    const mutation = mutationSpec.mutations.find(m => m.id === r.mutationId);
+    return `${r.mutationId}: ${mutation ? mutation.description : r.mutationId} — suggested test: ${r.suggestedTest || 'none'}`;
+  })
+  .join('\n');
 
-  const report = await agent(
-    `Write a mutation testing report for: "${target}"\n\nMutation score: ${mutationScore}% (${killed}/${total} killed)\nKilled: ${killed}, Survived: ${survived}, Timeout: ${timeout}, Equivalent: ${equivalent}\n\nSurvivors:\n${survivorSummary || 'none'}\n\nDescribe: overall test suite quality, top weaknesses in test coverage exposed by survivors, specific suggested tests to add, and interpretation of the mutation score.`,
-    { schema: REPORT_SCHEMA, label: 'report' }
-  );
+const report = await agent(
+  `Write a mutation testing report for: "${target}"\n\nMutation score: ${mutationScore}% (${killed}/${total} killed)\nKilled: ${killed}, Survived: ${survived}, Timeout: ${timeout}, Equivalent: ${equivalent}\n\nSurvivors:\n${survivorSummary || 'none'}\n\nDescribe: overall test suite quality, top weaknesses in test coverage exposed by survivors, specific suggested tests to add, and interpretation of the mutation score.`,
+  { schema: REPORT_SCHEMA, label: 'report' }
+);
 
-  return { target, sourceAnalysis, mutations: mutationSpec.mutations, killResults: killData, report };
-}
+return { target, sourceAnalysis, mutations: mutationSpec.mutations, killResults: killData, report };