mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/database-migration.js

@@ -10,104 +10,102 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const DIFF_SCHEMA = {
-    type: 'object',
-    properties: {
-      changes: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            type: { type: 'string', enum: ['add_table', 'drop_table', 'add_column', 'drop_column', 'change_type', 'add_index', 'drop_index', 'add_constraint', 'drop_constraint'] },
-            table: { type: 'string' },
-            column: { type: 'string' },
-            from: { type: 'string' },
-            to: { type: 'string' },
-            notes: { type: 'string' },
-          },
-          required: ['type', 'table'],
+const DIFF_SCHEMA = {
+  type: 'object',
+  properties: {
+    changes: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          type: { type: 'string', enum: ['add_table', 'drop_table', 'add_column', 'drop_column', 'change_type', 'add_index', 'drop_index', 'add_constraint', 'drop_constraint'] },
+          table: { type: 'string' },
+          column: { type: 'string' },
+          from: { type: 'string' },
+          to: { type: 'string' },
+          notes: { type: 'string' },
         },
+        required: ['type', 'table'],
       },
-      database: { type: 'string' },
     },
-    required: ['changes', 'database'],
-  };
+    database: { type: 'string' },
+  },
+  required: ['changes', 'database'],
+};
 
-  const RISK_SCHEMA = {
-    type: 'object',
-    properties: {
-      overallRisk: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
-      risks: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            change: { type: 'string' },
-            risk: { type: 'string' },
-            severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
-            mitigation: { type: 'string' },
-          },
-          required: ['change', 'risk', 'severity', 'mitigation'],
+const RISK_SCHEMA = {
+  type: 'object',
+  properties: {
+    overallRisk: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+    risks: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          change: { type: 'string' },
+          risk: { type: 'string' },
+          severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+          mitigation: { type: 'string' },
         },
+        required: ['change', 'risk', 'severity', 'mitigation'],
       },
-      requiresMaintenanceWindow: { type: 'boolean' },
-      estimatedLockDuration: { type: 'string' },
     },
-    required: ['overallRisk', 'risks', 'requiresMaintenanceWindow'],
-  };
+    requiresMaintenanceWindow: { type: 'boolean' },
+    estimatedLockDuration: { type: 'string' },
+  },
+  required: ['overallRisk', 'risks', 'requiresMaintenanceWindow'],
+};
 
-  const SCRIPTS_SCHEMA = {
-    type: 'object',
-    properties: {
-      forwardMigration: { type: 'string' },
-      rollbackMigration: { type: 'string' },
-      verificationQueries: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['forwardMigration', 'rollbackMigration', 'verificationQueries'],
-  };
+const SCRIPTS_SCHEMA = {
+  type: 'object',
+  properties: {
+    forwardMigration: { type: 'string' },
+    rollbackMigration: { type: 'string' },
+    verificationQueries: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['forwardMigration', 'rollbackMigration', 'verificationQueries'],
+};
 
-  const RUNBOOK_SCHEMA = {
-    type: 'object',
-    properties: {
-      preChecks: { type: 'array', items: { type: 'string' } },
-      steps: { type: 'array', items: { type: 'object', properties: { step: { type: 'number' }, action: { type: 'string' }, command: { type: 'string' }, rollbackIf: { type: 'string' } }, required: ['step', 'action'] } },
-      postChecks: { type: 'array', items: { type: 'string' } },
-      rollbackProcedure: { type: 'string' },
-    },
-    required: ['preChecks', 'steps', 'postChecks', 'rollbackProcedure'],
-  };
+const RUNBOOK_SCHEMA = {
+  type: 'object',
+  properties: {
+    preChecks: { type: 'array', items: { type: 'string' } },
+    steps: { type: 'array', items: { type: 'object', properties: { step: { type: 'number' }, action: { type: 'string' }, command: { type: 'string' }, rollbackIf: { type: 'string' } }, required: ['step', 'action'] } },
+    postChecks: { type: 'array', items: { type: 'string' } },
+    rollbackProcedure: { type: 'string' },
+  },
+  required: ['preChecks', 'steps', 'postChecks', 'rollbackProcedure'],
+};
 
-  const target = args || 'current migration files (provide schema diff or migration directory as args)';
+const target = args || 'current migration files (provide schema diff or migration directory as args)';
 
-  phase('SchemaDiff');
-  log(`Analyzing schema migration for: ${target}`);
-  const diff = await agent(
-    `Parse the database schema migration in: "${target}". Identify all schema changes: tables added/dropped, columns added/dropped/renamed, type changes, index changes, constraint changes. Identify the database type (PostgreSQL, MySQL, SQLite, etc.).`,
-    { schema: DIFF_SCHEMA, label: 'schema-diff' }
-  );
-  if (!diff) { log('Warning: agent returned null for diff, skipping'); return { target, error: 'agent-null' }; }
-  log(`${diff.changes.length} schema changes in ${diff.database}`);
+phase('SchemaDiff');
+log(`Analyzing schema migration for: ${target}`);
+const diff = await agent(
+  `Parse the database schema migration in: "${target}". Identify all schema changes: tables added/dropped, columns added/dropped/renamed, type changes, index changes, constraint changes. Identify the database type (PostgreSQL, MySQL, SQLite, etc.).`,
+  { schema: DIFF_SCHEMA, label: 'schema-diff' }
+);
+if (!diff) { log('Warning: agent returned null for diff, skipping'); return { target, error: 'agent-null' }; }
+log(`${diff.changes.length} schema changes in ${diff.database}`);
 
-  phase('RiskAnalysis');
-  const [risks, scripts] = await parallel([
-    () => agent(
-      `Assess the production risk of this database migration on ${diff.database}: ${diff.changes.map(c => `${c.type} on ${c.table}${c.column ? '.' + c.column : ''}`).join(', ')}. For each change identify: data loss risk, lock duration, rollback complexity. Does this require a maintenance window? What's the overall risk level?`,
-      { schema: RISK_SCHEMA, label: 'risk-analysis', phase: 'RiskAnalysis' }
-    ),
-    () => agent(
-      `Generate migration scripts for ${diff.database} with these changes: ${diff.changes.map(c => `${c.type} on ${c.table}`).join(', ')}. Write: (1) forward migration SQL, (2) rollback SQL that fully reverses the changes, (3) verification queries to confirm success. Use safe patterns: IF NOT EXISTS, transactions, backfill before NOT NULL, etc.`,
-      { schema: SCRIPTS_SCHEMA, label: 'scripts', phase: 'RiskAnalysis' }
-    ),
-  ]);
+phase('RiskAnalysis');
+const [risks, scripts] = await parallel([
+  () => agent(
+    `Assess the production risk of this database migration on ${diff.database}: ${diff.changes.map(c => `${c.type} on ${c.table}${c.column ? '.' + c.column : ''}`).join(', ')}. For each change identify: data loss risk, lock duration, rollback complexity. Does this require a maintenance window? What's the overall risk level?`,
+    { schema: RISK_SCHEMA, label: 'risk-analysis', phase: 'RiskAnalysis' }
+  ),
+  () => agent(
+    `Generate migration scripts for ${diff.database} with these changes: ${diff.changes.map(c => `${c.type} on ${c.table}`).join(', ')}. Write: (1) forward migration SQL, (2) rollback SQL that fully reverses the changes, (3) verification queries to confirm success. Use safe patterns: IF NOT EXISTS, transactions, backfill before NOT NULL, etc.`,
+    { schema: SCRIPTS_SCHEMA, label: 'scripts', phase: 'RiskAnalysis' }
+  ),
+]);
 
-  if (!risks) { log('Warning: agent returned null for risks, skipping'); return { target, diff, error: 'agent-null' }; }
-  phase('Runbook');
-  const runbook = await agent(
-    `Create a production deployment runbook for this ${diff.database} migration.\n\nChanges: ${diff.changes.map(c => `${c.type} on ${c.table}`).join(', ')}\nRisk: ${risks.overallRisk} — maintenance window required: ${risks.requiresMaintenanceWindow}\nTop risks: ${risks.risks.slice(0, 3).map(r => r.risk).join(', ')}\n\nInclude: pre-migration checks, numbered execution steps with exact commands and rollback conditions per step, post-migration verification, and complete rollback procedure.`,
-    { schema: RUNBOOK_SCHEMA, label: 'runbook' }
-  );
-  if (!runbook) { return { target, diff, risks, scripts, error: 'runbook-agent-null' }; }
+if (!risks) { log('Warning: agent returned null for risks, skipping'); return { target, diff, error: 'agent-null' }; }
+phase('Runbook');
+const runbook = await agent(
+  `Create a production deployment runbook for this ${diff.database} migration.\n\nChanges: ${diff.changes.map(c => `${c.type} on ${c.table}`).join(', ')}\nRisk: ${risks.overallRisk} — maintenance window required: ${risks.requiresMaintenanceWindow}\nTop risks: ${risks.risks.slice(0, 3).map(r => r.risk).join(', ')}\n\nInclude: pre-migration checks, numbered execution steps with exact commands and rollback conditions per step, post-migration verification, and complete rollback procedure.`,
+  { schema: RUNBOOK_SCHEMA, label: 'runbook' }
+);
+if (!runbook) { return { target, diff, risks, scripts, error: 'runbook-agent-null' }; }
 
-  return { target, diff, risks, scripts, runbook };
-}
+return { target, diff, risks, scripts, runbook };

package/.mindforge/dynamic-workflows/scripts/debug-detective.js

@@ -11,114 +11,112 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const INTAKE_SCHEMA = {
-    type: 'object',
-    properties: {
-      bugSummary: { type: 'string' },
-      symptoms: { type: 'array', items: { type: 'string' } },
-      reproducible: { type: 'boolean' },
-      affectedComponents: { type: 'array', items: { type: 'string' } },
-      recentChanges: { type: 'array', items: { type: 'string' } },
-      environment: { type: 'string' },
-    },
-    required: ['bugSummary', 'symptoms', 'affectedComponents'],
-  };
+const INTAKE_SCHEMA = {
+  type: 'object',
+  properties: {
+    bugSummary: { type: 'string' },
+    symptoms: { type: 'array', items: { type: 'string' } },
+    reproducible: { type: 'boolean' },
+    affectedComponents: { type: 'array', items: { type: 'string' } },
+    recentChanges: { type: 'array', items: { type: 'string' } },
+    environment: { type: 'string' },
+  },
+  required: ['bugSummary', 'symptoms', 'affectedComponents'],
+};
 
-  const HYPOTHESIS_SCHEMA = {
-    type: 'object',
-    properties: {
-      angle: { type: 'string' },
-      hypothesis: { type: 'string' },
-      reasoning: { type: 'string' },
-      evidenceNeeded: { type: 'array', items: { type: 'string' } },
-      probability: { type: 'string', enum: ['high', 'medium', 'low'] },
-    },
-    required: ['angle', 'hypothesis', 'reasoning', 'evidenceNeeded', 'probability'],
-  };
+const HYPOTHESIS_SCHEMA = {
+  type: 'object',
+  properties: {
+    angle: { type: 'string' },
+    hypothesis: { type: 'string' },
+    reasoning: { type: 'string' },
+    evidenceNeeded: { type: 'array', items: { type: 'string' } },
+    probability: { type: 'string', enum: ['high', 'medium', 'low'] },
+  },
+  required: ['angle', 'hypothesis', 'reasoning', 'evidenceNeeded', 'probability'],
+};
 
-  const EVIDENCE_SCHEMA = {
-    type: 'object',
-    properties: {
-      hypothesis: { type: 'string' },
-      supportingEvidence: { type: 'array', items: { type: 'string' } },
-      refutingEvidence: { type: 'array', items: { type: 'string' } },
-      verdict: { type: 'string', enum: ['strongly-supported', 'weakly-supported', 'inconclusive', 'refuted'] },
-      confidence: { type: 'number' },
-    },
-    required: ['hypothesis', 'supportingEvidence', 'refutingEvidence', 'verdict', 'confidence'],
-  };
+const EVIDENCE_SCHEMA = {
+  type: 'object',
+  properties: {
+    hypothesis: { type: 'string' },
+    supportingEvidence: { type: 'array', items: { type: 'string' } },
+    refutingEvidence: { type: 'array', items: { type: 'string' } },
+    verdict: { type: 'string', enum: ['strongly-supported', 'weakly-supported', 'inconclusive', 'refuted'] },
+    confidence: { type: 'number' },
+  },
+  required: ['hypothesis', 'supportingEvidence', 'refutingEvidence', 'verdict', 'confidence'],
+};
 
-  const RCA_SCHEMA = {
-    type: 'object',
-    properties: {
-      rootCause: { type: 'string' },
-      causalChain: { type: 'array', items: { type: 'string' } },
-      contributingFactors: { type: 'array', items: { type: 'string' } },
-      whyNowExplanation: { type: 'string' },
-      confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
-    },
-    required: ['rootCause', 'causalChain', 'confidence'],
-  };
+const RCA_SCHEMA = {
+  type: 'object',
+  properties: {
+    rootCause: { type: 'string' },
+    causalChain: { type: 'array', items: { type: 'string' } },
+    contributingFactors: { type: 'array', items: { type: 'string' } },
+    whyNowExplanation: { type: 'string' },
+    confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+  },
+  required: ['rootCause', 'causalChain', 'confidence'],
+};
 
-  const FIX_SCHEMA = {
-    type: 'object',
-    properties: {
-      fixDescription: { type: 'string' },
-      filestoChange: { type: 'array', items: { type: 'string' } },
-      implementationSteps: { type: 'array', items: { type: 'string' } },
-      regressionTestSpec: { type: 'string' },
-      riskOfFix: { type: 'string', enum: ['low', 'medium', 'high'] },
-    },
-    required: ['fixDescription', 'implementationSteps', 'regressionTestSpec'],
-  };
+const FIX_SCHEMA = {
+  type: 'object',
+  properties: {
+    fixDescription: { type: 'string' },
+    filestoChange: { type: 'array', items: { type: 'string' } },
+    implementationSteps: { type: 'array', items: { type: 'string' } },
+    regressionTestSpec: { type: 'string' },
+    riskOfFix: { type: 'string', enum: ['low', 'medium', 'high'] },
+  },
+  required: ['fixDescription', 'implementationSteps', 'regressionTestSpec'],
+};
 
-  const bugReport = args || 'No bug report provided — describe the bug, symptoms, and context in args.';
+const bugReport = args || 'No bug report provided — describe the bug, symptoms, and context in args.';
 
-  phase('Intake');
-  log(`Analyzing bug report: ${bugReport.slice(0, 80)}`);
-  const intake = await agent(
-    `Analyze this bug report and extract structured information: "${bugReport}"\n\nIdentify: bug summary, specific symptoms observed, whether reproducible, affected components/files, any recent changes that might be related, and environment (prod/staging/dev, OS, browser, etc.).`,
-    { schema: INTAKE_SCHEMA, label: 'intake' }
-  );
-  if (!intake) { log('Warning: agent returned null for intake, skipping'); return { bugReport, error: 'agent-null' }; }
-  log(`Bug: ${intake.bugSummary} | Affects: ${intake.affectedComponents.join(', ')}`);
+phase('Intake');
+log(`Analyzing bug report: ${bugReport.slice(0, 80)}`);
+const intake = await agent(
+  `Analyze this bug report and extract structured information: "${bugReport}"\n\nIdentify: bug summary, specific symptoms observed, whether reproducible, affected components/files, any recent changes that might be related, and environment (prod/staging/dev, OS, browser, etc.).`,
+  { schema: INTAKE_SCHEMA, label: 'intake' }
+);
+if (!intake) { log('Warning: agent returned null for intake, skipping'); return { bugReport, error: 'agent-null' }; }
+log(`Bug: ${intake.bugSummary} | Affects: ${intake.affectedComponents.join(', ')}`);
 
-  phase('Hypothesize');
-  const context = `Bug: ${intake.bugSummary}\nSymptoms: ${intake.symptoms.join(', ')}\nAffected: ${intake.affectedComponents.join(', ')}\nRecent changes: ${(intake.recentChanges || []).join(', ')}`;
-  const hypotheses = await parallel([
-    () => agent(`Generate a hypothesis from a CODE perspective for this bug: ${context}\n\nFocus on: logic errors, off-by-one, null/undefined handling, async/await issues, type coercion. What specific code defect could cause these symptoms?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-code', phase: 'Hypothesize' }),
-    () => agent(`Generate a hypothesis from a STATE/DATA perspective for this bug: ${context}\n\nFocus on: database state corruption, stale cache, race condition, shared mutable state, session/cookie issues. What data or state problem could cause these symptoms?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-state', phase: 'Hypothesize' }),
-    () => agent(`Generate a hypothesis from an INTEGRATION/ENVIRONMENT perspective for this bug: ${context}\n\nFocus on: API contract mismatch, network timeout, environment variable, dependency version conflict, OS/browser differences. What external factor could cause these symptoms?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-integration', phase: 'Hypothesize' }),
-    () => agent(`Generate a hypothesis from a REGRESSION perspective for this bug: ${context}\n\nFocus on: what recent change (deploy, config, dependency update) most likely introduced this. Which commit or change is the prime suspect?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-regression', phase: 'Hypothesize' }),
-  ]);
+phase('Hypothesize');
+const context = `Bug: ${intake.bugSummary}\nSymptoms: ${intake.symptoms.join(', ')}\nAffected: ${intake.affectedComponents.join(', ')}\nRecent changes: ${(intake.recentChanges || []).join(', ')}`;
+const hypotheses = await parallel([
+  () => agent(`Generate a hypothesis from a CODE perspective for this bug: ${context}\n\nFocus on: logic errors, off-by-one, null/undefined handling, async/await issues, type coercion. What specific code defect could cause these symptoms?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-code', phase: 'Hypothesize' }),
+  () => agent(`Generate a hypothesis from a STATE/DATA perspective for this bug: ${context}\n\nFocus on: database state corruption, stale cache, race condition, shared mutable state, session/cookie issues. What data or state problem could cause these symptoms?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-state', phase: 'Hypothesize' }),
+  () => agent(`Generate a hypothesis from an INTEGRATION/ENVIRONMENT perspective for this bug: ${context}\n\nFocus on: API contract mismatch, network timeout, environment variable, dependency version conflict, OS/browser differences. What external factor could cause these symptoms?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-integration', phase: 'Hypothesize' }),
+  () => agent(`Generate a hypothesis from a REGRESSION perspective for this bug: ${context}\n\nFocus on: what recent change (deploy, config, dependency update) most likely introduced this. Which commit or change is the prime suspect?`, { schema: HYPOTHESIS_SCHEMA, label: 'hypothesis-regression', phase: 'Hypothesize' }),
+]);
 
-  phase('Evidence');
-  const validHypotheses = hypotheses.filter(Boolean);
-  log(`${validHypotheses.length} hypotheses — gathering evidence in parallel`);
+phase('Evidence');
+const validHypotheses = hypotheses.filter(Boolean);
+log(`${validHypotheses.length} hypotheses — gathering evidence in parallel`);
 
-  const evidence = await parallel(
-    validHypotheses.map(h => () => agent(
-      `Gather evidence for or against this hypothesis about the bug "${intake.bugSummary}":\n\nHypothesis: ${h.hypothesis}\nEvidence needed: ${h.evidenceNeeded.join(', ')}\n\nLook in the codebase for: ${h.evidenceNeeded.join(', ')}. Report what you find that supports OR refutes this hypothesis. Rate your verdict.`,
-      { schema: EVIDENCE_SCHEMA, label: `evidence:${h.angle.slice(0, 20)}`, phase: 'Evidence' }
-    ))
-  );
+const evidence = await parallel(
+  validHypotheses.map(h => () => agent(
+    `Gather evidence for or against this hypothesis about the bug "${intake.bugSummary}":\n\nHypothesis: ${h.hypothesis}\nEvidence needed: ${h.evidenceNeeded.join(', ')}\n\nLook in the codebase for: ${h.evidenceNeeded.join(', ')}. Report what you find that supports OR refutes this hypothesis. Rate your verdict.`,
+    { schema: EVIDENCE_SCHEMA, label: `evidence:${h.angle.slice(0, 20)}`, phase: 'Evidence' }
+  ))
+);
 
-  phase('RCA');
-  const evidenceSummary = evidence.filter(Boolean).map(e => `${e.hypothesis}: ${e.verdict} (${e.confidence}%) — supports: [${e.supportingEvidence.slice(0, 2).join(', ')}] refutes: [${e.refutingEvidence.slice(0, 1).join(', ')}]`).join('\n');
-  const rca = await agent(
-    `Perform a scientific root cause analysis for: "${intake.bugSummary}"\n\nEvidence summary:\n${evidenceSummary}\n\nIdentify the root cause (the specific defect that, if fixed, would prevent the bug), the causal chain (how root cause leads to symptoms), contributing factors, and why it appeared now. Rate your confidence.`,
-    { schema: RCA_SCHEMA, label: 'rca' }
-  );
-  if (!rca) { log('Warning: agent returned null for rca, skipping'); return { bugReport, intake, hypotheses: validHypotheses, evidence: evidence.filter(Boolean), error: 'agent-null' }; }
-  log(`RCA: ${rca.rootCause.slice(0, 80)} (confidence: ${rca.confidence})`);
+phase('RCA');
+const evidenceSummary = evidence.filter(Boolean).map(e => `${e.hypothesis}: ${e.verdict} (${e.confidence}%) — supports: [${e.supportingEvidence.slice(0, 2).join(', ')}] refutes: [${e.refutingEvidence.slice(0, 1).join(', ')}]`).join('\n');
+const rca = await agent(
+  `Perform a scientific root cause analysis for: "${intake.bugSummary}"\n\nEvidence summary:\n${evidenceSummary}\n\nIdentify the root cause (the specific defect that, if fixed, would prevent the bug), the causal chain (how root cause leads to symptoms), contributing factors, and why it appeared now. Rate your confidence.`,
+  { schema: RCA_SCHEMA, label: 'rca' }
+);
+if (!rca) { log('Warning: agent returned null for rca, skipping'); return { bugReport, intake, hypotheses: validHypotheses, evidence: evidence.filter(Boolean), error: 'agent-null' }; }
+log(`RCA: ${rca.rootCause.slice(0, 80)} (confidence: ${rca.confidence})`);
 
-  phase('Fix');
-  const fix = await agent(
-    `Design a targeted fix for this bug.\n\nRoot cause: ${rca.rootCause}\nCausal chain: ${rca.causalChain.join(' → ')}\nAffected components: ${intake.affectedComponents.join(', ')}\n\nProvide: exact fix description, which files to change, step-by-step implementation, a regression test specification that would catch this bug if reintroduced, and risk assessment of the fix.`,
-    { schema: FIX_SCHEMA, label: 'fix' }
-  );
-  if (!fix) { log('Warning: agent returned null for fix, skipping'); return { bugReport, intake, hypotheses: validHypotheses, evidence: evidence.filter(Boolean), rca, error: 'agent-null' }; }
+phase('Fix');
+const fix = await agent(
+  `Design a targeted fix for this bug.\n\nRoot cause: ${rca.rootCause}\nCausal chain: ${rca.causalChain.join(' → ')}\nAffected components: ${intake.affectedComponents.join(', ')}\n\nProvide: exact fix description, which files to change, step-by-step implementation, a regression test specification that would catch this bug if reintroduced, and risk assessment of the fix.`,
+  { schema: FIX_SCHEMA, label: 'fix' }
+);
+if (!fix) { log('Warning: agent returned null for fix, skipping'); return { bugReport, intake, hypotheses: validHypotheses, evidence: evidence.filter(Boolean), rca, error: 'agent-null' }; }
 
-  return { bugReport, intake, hypotheses: validHypotheses, evidence: evidence.filter(Boolean), rca, fix };
-}
+return { bugReport, intake, hypotheses: validHypotheses, evidence: evidence.filter(Boolean), rca, fix };

package/.mindforge/dynamic-workflows/scripts/dependency-health.js

@@ -10,101 +10,99 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const INVENTORY_SCHEMA = {
-    type: 'object',
-    properties: {
-      dependencies: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            version: { type: 'string' },
-            type: { type: 'string', enum: ['prod', 'dev', 'peer', 'optional'] },
-          },
-          required: ['name', 'version', 'type'],
+const INVENTORY_SCHEMA = {
+  type: 'object',
+  properties: {
+    dependencies: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          version: { type: 'string' },
+          type: { type: 'string', enum: ['prod', 'dev', 'peer', 'optional'] },
         },
+        required: ['name', 'version', 'type'],
       },
-      packageManager: { type: 'string' },
     },
-    required: ['dependencies', 'packageManager'],
-  };
+    packageManager: { type: 'string' },
+  },
+  required: ['dependencies', 'packageManager'],
+};
 
-  const BATCH_SCHEMA = {
-    type: 'object',
-    properties: {
-      audits: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            cveRisk: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'none'] },
-            licenseRisk: { type: 'string', enum: ['copyleft', 'permissive', 'unknown', 'proprietary'] },
-            staleness: { type: 'string', enum: ['current', 'minor-behind', 'major-behind', 'abandoned'] },
-            maintenanceStatus: { type: 'string', enum: ['active', 'slow', 'stale', 'archived', 'unknown'] },
-            recommendation: { type: 'string', enum: ['upgrade', 'replace', 'accept', 'remove'] },
-            notes: { type: 'string' },
-          },
-          required: ['name', 'cveRisk', 'licenseRisk', 'staleness', 'maintenanceStatus', 'recommendation'],
+const BATCH_SCHEMA = {
+  type: 'object',
+  properties: {
+    audits: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          cveRisk: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'none'] },
+          licenseRisk: { type: 'string', enum: ['copyleft', 'permissive', 'unknown', 'proprietary'] },
+          staleness: { type: 'string', enum: ['current', 'minor-behind', 'major-behind', 'abandoned'] },
+          maintenanceStatus: { type: 'string', enum: ['active', 'slow', 'stale', 'archived', 'unknown'] },
+          recommendation: { type: 'string', enum: ['upgrade', 'replace', 'accept', 'remove'] },
+          notes: { type: 'string' },
         },
+        required: ['name', 'cveRisk', 'licenseRisk', 'staleness', 'maintenanceStatus', 'recommendation'],
       },
     },
-    required: ['audits'],
-  };
+  },
+  required: ['audits'],
+};
 
-  const ACTION_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      immediateUpgrades: { type: 'array', items: { type: 'string' } },
-      replaceWithAlternatives: { type: 'array', items: { type: 'object', properties: { current: { type: 'string' }, replacement: { type: 'string' }, reason: { type: 'string' } }, required: ['current', 'replacement', 'reason'] } },
-      acceptableRisks: { type: 'array', items: { type: 'string' } },
-      licenseIssues: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['summary', 'immediateUpgrades', 'replaceWithAlternatives', 'acceptableRisks'],
-  };
+const ACTION_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    immediateUpgrades: { type: 'array', items: { type: 'string' } },
+    replaceWithAlternatives: { type: 'array', items: { type: 'object', properties: { current: { type: 'string' }, replacement: { type: 'string' }, reason: { type: 'string' } }, required: ['current', 'replacement', 'reason'] } },
+    acceptableRisks: { type: 'array', items: { type: 'string' } },
+    licenseIssues: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['summary', 'immediateUpgrades', 'replaceWithAlternatives', 'acceptableRisks'],
+};
 
-  const target = args || 'current project (run from repo root)';
+const target = args || 'current project (run from repo root)';
 
-  phase('Inventory');
-  log(`Inventorying dependencies in: ${target}`);
-  const inventory = await agent(
-    `Extract the complete dependency list from package manifests in: "${target}". Look for package.json, requirements.txt, Pipfile, go.mod, Gemfile, Cargo.toml, or similar. List each dependency with its current version and type (prod/dev/peer/optional). Identify the package manager used.`,
-    { schema: INVENTORY_SCHEMA, label: 'inventory' }
-  );
-  if (!inventory) { return { target, error: 'inventory-agent-null' }; }
-  const allDeps = inventory.dependencies || [];
-  log(`Found ${allDeps.length} dependencies (${inventory.packageManager})`);
+phase('Inventory');
+log(`Inventorying dependencies in: ${target}`);
+const inventory = await agent(
+  `Extract the complete dependency list from package manifests in: "${target}". Look for package.json, requirements.txt, Pipfile, go.mod, Gemfile, Cargo.toml, or similar. List each dependency with its current version and type (prod/dev/peer/optional). Identify the package manager used.`,
+  { schema: INVENTORY_SCHEMA, label: 'inventory' }
+);
+if (!inventory) { return { target, error: 'inventory-agent-null' }; }
+const allDeps = inventory.dependencies || [];
+log(`Found ${allDeps.length} dependencies (${inventory.packageManager})`);
 
-  const BATCH_SIZE = 10;
-  const batches = [];
-  for (let i = 0; i < allDeps.length; i += BATCH_SIZE) {
-    batches.push(allDeps.slice(i, i + BATCH_SIZE));
-  }
-  log(`Auditing in ${batches.length} batches of up to ${BATCH_SIZE}`);
+const BATCH_SIZE = 10;
+const batches = [];
+for (let i = 0; i < allDeps.length; i += BATCH_SIZE) {
+  batches.push(allDeps.slice(i, i + BATCH_SIZE));
+}
+log(`Auditing in ${batches.length} batches of up to ${BATCH_SIZE}`);
 
-  phase('Audit');
-  const batchResults = await parallel(
-    batches.map((batch, idx) => () => agent(
-      `Audit these dependencies for security and health: ${batch.map(d => `${d.name}@${d.version}`).join(', ')}. For each: (1) known CVEs or security advisories, (2) license type (MIT/Apache/GPL/etc.), (3) staleness (how far behind latest), (4) maintenance status (active/slow/stale/archived). Provide upgrade/replace/accept/remove recommendation.`,
-      { schema: BATCH_SCHEMA, label: `audit-batch-${idx}`, phase: 'Audit' }
-    ))
-  );
+phase('Audit');
+const batchResults = await parallel(
+  batches.map((batch, idx) => () => agent(
+    `Audit these dependencies for security and health: ${batch.map(d => `${d.name}@${d.version}`).join(', ')}. For each: (1) known CVEs or security advisories, (2) license type (MIT/Apache/GPL/etc.), (3) staleness (how far behind latest), (4) maintenance status (active/slow/stale/archived). Provide upgrade/replace/accept/remove recommendation.`,
+    { schema: BATCH_SCHEMA, label: `audit-batch-${idx}`, phase: 'Audit' }
+  ))
+);
 
-  phase('RiskMatrix');
-  const allAudits = batchResults.filter(Boolean).flatMap(b => b.audits || []);
-  const critical = allAudits.filter(a => a.cveRisk === 'critical' || a.cveRisk === 'high');
-  const licenseIssues = allAudits.filter(a => a.licenseRisk === 'copyleft' || a.licenseRisk === 'unknown');
-  log(`${critical.length} high/critical CVE risks, ${licenseIssues.length} license issues`);
+phase('RiskMatrix');
+const allAudits = batchResults.filter(Boolean).flatMap(b => b.audits || []);
+const critical = allAudits.filter(a => a.cveRisk === 'critical' || a.cveRisk === 'high');
+const licenseIssues = allAudits.filter(a => a.licenseRisk === 'copyleft' || a.licenseRisk === 'unknown');
+log(`${critical.length} high/critical CVE risks, ${licenseIssues.length} license issues`);
 
-  phase('Action');
-  const matrixText = allAudits.filter(a => a.cveRisk !== 'none' || a.recommendation !== 'accept').slice(0, 20).map(a => `${a.name}: CVE=${a.cveRisk}, license=${a.licenseRisk}, staleness=${a.staleness}, status=${a.maintenanceStatus} → ${a.recommendation}`).join('\n');
-  const actions = await agent(
-    `Create a dependency action plan for: "${target}"\n\nRisk matrix:\n${matrixText}\n\nPrioritize: (1) immediate upgrades for critical CVEs, (2) replacements for abandoned/high-risk deps, (3) acceptable-risk accepts, (4) license issues to resolve. For replacements, suggest specific alternative packages.`,
-    { schema: ACTION_SCHEMA, label: 'action-plan' }
-  );
+phase('Action');
+const matrixText = allAudits.filter(a => a.cveRisk !== 'none' || a.recommendation !== 'accept').slice(0, 20).map(a => `${a.name}: CVE=${a.cveRisk}, license=${a.licenseRisk}, staleness=${a.staleness}, status=${a.maintenanceStatus} → ${a.recommendation}`).join('\n');
+const actions = await agent(
+  `Create a dependency action plan for: "${target}"\n\nRisk matrix:\n${matrixText}\n\nPrioritize: (1) immediate upgrades for critical CVEs, (2) replacements for abandoned/high-risk deps, (3) acceptable-risk accepts, (4) license issues to resolve. For replacements, suggest specific alternative packages.`,
+  { schema: ACTION_SCHEMA, label: 'action-plan' }
+);
 
-  return { target, inventory, audits: allAudits, actions, stats: { total: allDeps.length, criticalCVE: critical.length, licenseIssues: licenseIssues.length } };
-}
+return { target, inventory, audits: allAudits, actions, stats: { total: allDeps.length, criticalCVE: critical.length, licenseIssues: licenseIssues.length } };