mindforge-cc 11.7.1 → 11.8.0

package/.mindforge/dynamic-workflows/scripts/code-explainer.js

@@ -0,0 +1,138 @@
+export const meta = {
+  name: 'code-explainer',
+  description: 'Structural map → domain extraction → architecture patterns → guided narrative tour for onboarding',
+  whenToUse: 'When onboarding a new developer, writing system documentation, or creating a guided tour of an unfamiliar codebase',
+  phases: [
+    { title: 'Structure', detail: 'Map file structure, entry points, and module boundaries' },
+    { title: 'Domain', detail: 'Extract domain concepts, business logic, and key abstractions' },
+    { title: 'Architecture', detail: 'Identify architectural patterns, data flow, and design decisions' },
+    { title: 'Tour', detail: 'Synthesize a guided narrative tour for a new developer' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const STRUCTURE_SCHEMA = {
+    type: 'object',
+    properties: {
+      entryPoints: { type: 'array', items: { type: 'string' } },
+      modules: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            path: { type: 'string' },
+            responsibility: { type: 'string' },
+            publicApi: { type: 'array', items: { type: 'string' } },
+          },
+          required: ['name', 'path', 'responsibility'],
+        },
+      },
+      keyFiles: { type: 'array', items: { type: 'string' } },
+      dependencies: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['entryPoints', 'modules', 'keyFiles'],
+  };
+
+  const DOMAIN_SCHEMA = {
+    type: 'object',
+    properties: {
+      coreConcepts: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            concept: { type: 'string' },
+            definition: { type: 'string' },
+            whereImplemented: { type: 'string' },
+          },
+          required: ['concept', 'definition'],
+        },
+      },
+      businessRules: { type: 'array', items: { type: 'string' } },
+      dataModels: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['coreConcepts', 'businessRules'],
+  };
+
+  const ARCHITECTURE_SCHEMA = {
+    type: 'object',
+    properties: {
+      pattern: { type: 'string' },
+      dataFlow: { type: 'string' },
+      keyDesignDecisions: { type: 'array', items: { type: 'string' } },
+      integrationPoints: { type: 'array', items: { type: 'string' } },
+      gotchas: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['pattern', 'dataFlow', 'keyDesignDecisions'],
+  };
+
+  const TOUR_SCHEMA = {
+    type: 'object',
+    properties: {
+      summary: { type: 'string' },
+      steps: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            step: { type: 'number' },
+            title: { type: 'string' },
+            fileOrConcept: { type: 'string' },
+            explanation: { type: 'string' },
+            whyItMatters: { type: 'string' },
+          },
+          required: ['step', 'title', 'explanation', 'whyItMatters'],
+        },
+      },
+      firstDayChecklist: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['summary', 'steps', 'firstDayChecklist'],
+  };
+
+  const target = args || 'current codebase (run from repo root)';
+
+  phase('Structure');
+  log(`Mapping code structure for: ${target}`);
+  const structure = await agent(
+    `Map the file structure of: "${target}". Identify: (1) entry points (main files, index files, CLI entry), (2) all major modules with their path and single-line responsibility, (3) the 5-10 most important files a new developer should read first, (4) key external dependencies. Focus on what's PUBLIC — exported functions, routes, APIs.`,
+    { schema: STRUCTURE_SCHEMA, label: 'structure' }
+  );
+  if (!structure) { log('Warning: agent returned null for structure, skipping'); return { target, error: 'agent-null' }; }
+  log(`Found ${structure.modules.length} modules, ${structure.entryPoints.length} entry points`);
+
+  phase('Domain');
+  const moduleContext = structure.modules.slice(0, 10).map(m => `${m.name} (${m.path}): ${m.responsibility}`).join('\n');
+  const domain = await agent(
+    `Extract the domain concepts and business logic from: "${target}"\n\nModules:\n${moduleContext}\n\nIdentify: (1) core business concepts and their definitions (what is a "User", "Order", "Pipeline" etc. in THIS codebase), (2) key business rules (what must always be true), (3) the main data models and their relationships. Focus on the WHAT, not the HOW.`,
+    { schema: DOMAIN_SCHEMA, label: 'domain' }
+  );
+  if (!domain) { log('Warning: agent returned null for domain, skipping'); return { target, structure, error: 'agent-null' }; }
+  log(`${domain.coreConcepts.length} core concepts, ${domain.businessRules.length} business rules identified`);
+
+  phase('Architecture');
+  const domainContext = domain.coreConcepts.slice(0, 5).map(c => `${c.concept}: ${c.definition}`).join('\n');
+  const arch = await agent(
+    `Identify the architectural patterns in: "${target}"\n\nDomain: ${domainContext}\n\nDescribe: (1) the overall architectural pattern (MVC, CQRS, event-driven, layered, etc.), (2) how data flows through the system end-to-end, (3) the top 3-5 key design decisions and WHY they were made, (4) integration points with external systems, (5) gotchas and non-obvious behaviors a new developer must know.`,
+    { schema: ARCHITECTURE_SCHEMA, label: 'architecture' }
+  );
+  if (!arch) { log('Warning: agent returned null for arch, skipping'); return { target, structure, domain, error: 'agent-null' }; }
+  log(`Architecture: ${arch.pattern}`);
+
+  phase('Tour');
+  const tourContext = `
+Structure: ${structure.entryPoints.length} entry points, ${structure.modules.length} modules
+Key files: ${structure.keyFiles.slice(0, 5).join(', ')}
+Pattern: ${arch.pattern}
+Data flow: ${arch.dataFlow}
+Core concepts: ${domain.coreConcepts.slice(0, 4).map(c => c.concept).join(', ')}
+Gotchas: ${(arch.gotchas || []).slice(0, 3).join('; ')}
+  `.trim();
+
+  const tour = await agent(
+    `Create a guided narrative tour of: "${target}" for a developer joining the team today.\n\n${tourContext}\n\nWrite 6-10 sequential steps that progressively reveal the codebase. Each step: a clear title, which file/concept to look at, plain-English explanation, and WHY it matters. Start with the entry point, build to the domain, then reveal the architecture. End with a "first day" checklist of things to read and run.`,
+    { schema: TOUR_SCHEMA, label: 'tour' }
+  );
+
+  return { target, structure, domain, arch, tour };
+}

package/.mindforge/dynamic-workflows/scripts/competitive-teardown.js

@@ -0,0 +1,142 @@
+export const meta = {
+  name: 'competitive-teardown',
+  description: '5 parallel competitor angle agents → pipeline synthesis into competitive positioning report',
+  whenToUse: 'When doing competitive research before a product launch, pricing decision, or strategy review',
+  phases: [
+    { title: 'Scope', detail: 'Identify competitors and define evaluation framework' },
+    { title: 'Research', detail: '5 parallel competitor angle agents: product/tech/pricing/hiring/community' },
+    { title: 'Analyze', detail: 'Synthesize competitive landscape from all angles' },
+    { title: 'Synthesis', detail: 'Competitive positioning report with differentiation opportunities' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const SCOPE_SCHEMA = {
+    type: 'object',
+    properties: {
+      productDescription: { type: 'string' },
+      competitors: { type: 'array', items: { type: 'string' } },
+      evaluationDimensions: { type: 'array', items: { type: 'string' } },
+      targetMarket: { type: 'string' },
+    },
+    required: ['productDescription', 'competitors', 'targetMarket'],
+  };
+
+  const ANGLE_SCHEMA = {
+    type: 'object',
+    properties: {
+      angle: { type: 'string' },
+      findings: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            competitor: { type: 'string' },
+            insight: { type: 'string' },
+            strength: { type: 'string' },
+            weakness: { type: 'string' },
+            signal: { type: 'string' },
+          },
+          required: ['competitor', 'insight'],
+        },
+      },
+      keyTakeaway: { type: 'string' },
+    },
+    required: ['angle', 'findings', 'keyTakeaway'],
+  };
+
+  const ANALYSIS_SCHEMA = {
+    type: 'object',
+    properties: {
+      competitorProfiles: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            summary: { type: 'string' },
+            keyStrengths: { type: 'array', items: { type: 'string' } },
+            keyWeaknesses: { type: 'array', items: { type: 'string' } },
+            threatLevel: { type: 'string', enum: ['high', 'medium', 'low'] },
+          },
+          required: ['name', 'summary', 'keyStrengths', 'keyWeaknesses', 'threatLevel'],
+        },
+      },
+      marketDynamics: { type: 'string' },
+    },
+    required: ['competitorProfiles', 'marketDynamics'],
+  };
+
+  const SYNTHESIS_SCHEMA = {
+    type: 'object',
+    properties: {
+      executiveSummary: { type: 'string' },
+      competitivePosition: { type: 'string', enum: ['leader', 'challenger', 'follower', 'nicher'] },
+      differentiationOpportunities: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            opportunity: { type: 'string' },
+            dimension: { type: 'string' },
+            confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+            actionable: { type: 'string' },
+          },
+          required: ['opportunity', 'dimension', 'actionable'],
+        },
+      },
+      threatsToWatch: { type: 'array', items: { type: 'string' } },
+      strategicRecommendations: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['executiveSummary', 'competitivePosition', 'differentiationOpportunities', 'strategicRecommendations'],
+  };
+
+  const target = args || 'current product (describe your product and list competitors in args)';
+
+  phase('Scope');
+  log(`Competitive teardown for: ${target}`);
+  const scope = await agent(
+    `Define the competitive landscape for: "${target}". Identify: (1) a concise description of the product/service being analyzed, (2) the top 3-5 direct competitors, (3) key evaluation dimensions for this market, (4) the target market and customer segment. If competitors are not specified in the input, infer them from the product description.`,
+    { schema: SCOPE_SCHEMA, label: 'scope' }
+  );
+  if (!scope) { log('Warning: agent returned null for scope, skipping'); return { target, error: 'agent-null' }; }
+  log(`Analyzing ${scope.competitors.length} competitors: ${scope.competitors.join(', ')}`);
+
+  const competitorList = scope.competitors.join(', ');
+  const productCtx = `Product: ${scope.productDescription} | Market: ${scope.targetMarket}`;
+
+  phase('Research');
+  const ANGLES = [
+    { label: 'product-features', prompt: `Analyze PRODUCT FEATURES AND UX for these competitors in the context of: "${target}". ${productCtx}. Competitors: ${competitorList}. For each: key features, UX quality, product gaps, what users love/hate (based on known reviews/feedback). What are the feature differentiators?` },
+    { label: 'technical-architecture', prompt: `Analyze TECHNICAL ARCHITECTURE AND STACK for: ${competitorList}. Context: "${target}". ${productCtx}. For each: known tech stack, scalability approach, API availability, integration ecosystem, technical moat (patents, proprietary tech, network effects). What technical signals suggest future direction?` },
+    { label: 'pricing-model', prompt: `Analyze PRICING MODELS for: ${competitorList}. Context: "${target}". ${productCtx}. For each: pricing tiers, free/trial offering, enterprise vs SMB focus, pricing transparency, value metric (per seat/usage/feature). What pricing patterns dominate? Where are the gaps?` },
+    { label: 'hiring-signals', prompt: `Analyze HIRING SIGNALS for: ${competitorList}. Context: "${target}". ${productCtx}. For each: recent job postings patterns (what roles they're hiring = what they're building), team growth trajectory, key hires/departures, which teams are expanding. What does hiring signal about product roadmap?` },
+    { label: 'community-ecosystem', prompt: `Analyze COMMUNITY AND ECOSYSTEM for: ${competitorList}. Context: "${target}". ${productCtx}. For each: community size and engagement (GitHub stars, Discord/Slack, forum activity), developer ecosystem (integrations, plugins, APIs), content marketing, thought leadership, NPS signals. Who has the strongest ecosystem moat?` },
+  ];
+
+  const angleResults = await parallel(
+    ANGLES.map(a => () => agent(a.prompt, { schema: ANGLE_SCHEMA, label: `angle:${a.label}`, phase: 'Research' }))
+  );
+
+  phase('Analyze');
+  const validAngles = angleResults.filter(Boolean);
+  const angleSummary = validAngles.map(a => `${a.angle}: ${a.keyTakeaway}`).join('\n');
+
+  const analysis = await agent(
+    `Synthesize competitive profiles for: "${target}"\n\nCompetitors: ${competitorList}\n\nAngle summaries:\n${angleSummary}\n\nFor each competitor: 2-sentence summary, top 3 strengths, top 3 weaknesses, and threat level (high/medium/low) to our product. Describe overall market dynamics.`,
+    { schema: ANALYSIS_SCHEMA, label: 'analyze' }
+  );
+
+  if (!analysis) { log('Warning: agent returned null for analysis, skipping'); return { target, error: 'agent-null' }; }
+  phase('Synthesis');
+  const profileSummary = analysis.competitorProfiles.map(p => `${p.name} (threat=${p.threatLevel}): strengths=[${p.keyStrengths.slice(0, 2).join(', ')}] weaknesses=[${p.keyWeaknesses.slice(0, 2).join(', ')}]`).join('\n');
+
+  const synthesis = await pipeline([
+    () => agent(
+      `Create a competitive positioning report for: "${target}"\n\n${productCtx}\n\nCompetitor profiles:\n${profileSummary}\n\nMarket dynamics: ${analysis.marketDynamics}\n\nAngle takeaways:\n${angleSummary}\n\nProvide: executive summary, competitive position (leader/challenger/follower/nicher), top 3-5 differentiation opportunities with confidence and actionable next steps, key threats to monitor, and 3-5 strategic recommendations.`,
+      { schema: SYNTHESIS_SCHEMA, label: 'synthesis' }
+    ),
+  ]);
+
+  return { target, scope, angles: validAngles, analysis, synthesis };
+}

package/.mindforge/dynamic-workflows/scripts/cost-analysis.js

@@ -0,0 +1,107 @@
+export const meta = {
+  name: 'cost-analysis',
+  description: 'Parallel infra/API/query/bundle cost agents → reduction plan with ROI estimates',
+  whenToUse: 'When auditing and reducing operational costs across infrastructure, API calls, database, and frontend bundle',
+  phases: [
+    { title: 'Scope', detail: 'Identify cost centers and establish current baseline' },
+    { title: 'Analyze', detail: '4 parallel cost dimension agents: infra / API / database / bundle' },
+    { title: 'Model', detail: 'Cost model with reduction opportunities and ROI estimates' },
+    { title: 'Plan', detail: 'Prioritized cost reduction plan with implementation steps' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const SCOPE_SCHEMA = {
+    type: 'object',
+    properties: {
+      costCenters: { type: 'array', items: { type: 'string' } },
+      estimatedMonthlyCost: { type: 'string' },
+      primaryTechnology: { type: 'string' },
+    },
+    required: ['costCenters', 'primaryTechnology'],
+  };
+
+  const COST_DIM_SCHEMA = {
+    type: 'object',
+    properties: {
+      dimension: { type: 'string' },
+      currentEstimate: { type: 'string' },
+      findings: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            item: { type: 'string' },
+            currentCost: { type: 'string' },
+            wasteType: { type: 'string', enum: ['over-provisioning', 'idle-resource', 'inefficient-query', 'unused-api', 'large-bundle', 'redundant-call', 'other'] },
+            potentialSaving: { type: 'string' },
+            fix: { type: 'string' },
+          },
+          required: ['item', 'wasteType', 'potentialSaving', 'fix'],
+        },
+      },
+    },
+    required: ['dimension', 'findings'],
+  };
+
+  const PLAN_SCHEMA = {
+    type: 'object',
+    properties: {
+      summary: { type: 'string' },
+      totalEstimatedSaving: { type: 'string' },
+      reductionItems: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            action: { type: 'string' },
+            dimension: { type: 'string' },
+            monthlySaving: { type: 'string' },
+            effort: { type: 'string', enum: ['low', 'medium', 'high'] },
+            roi: { type: 'string' },
+            priority: { type: 'string', enum: ['p0', 'p1', 'p2'] },
+          },
+          required: ['action', 'dimension', 'monthlySaving', 'effort', 'priority'],
+        },
+      },
+    },
+    required: ['summary', 'totalEstimatedSaving', 'reductionItems'],
+  };
+
+  const target = args || 'current codebase (run from repo root)';
+
+  phase('Scope');
+  log(`Cost analysis target: ${target}`);
+  const scope = await agent(
+    `Identify the cost centers and technology stack for: "${target}". What cloud provider, databases, third-party APIs, and frontend framework are used? Estimate the primary monthly cost categories (infra, API calls, database, frontend delivery).`,
+    { schema: SCOPE_SCHEMA, label: 'scope' }
+  );
+  if (!scope) { log('Warning: agent returned null for scope, skipping'); return { target, error: 'agent-null' }; }
+  log(`Cost centers: ${scope.costCenters.join(', ')}`);
+
+  phase('Analyze');
+  const DIMENSIONS = [
+    { label: 'infrastructure', prompt: `Analyze INFRASTRUCTURE costs for: "${target}" (${scope.primaryTechnology}). Look for: over-provisioned compute (instances larger than needed), idle resources (unused databases, VMs, load balancers), storage waste (old snapshots, unused volumes), network egress inefficiencies, cold-start penalties on serverless. Estimate current spend and potential savings per item.` },
+    { label: 'api-costs', prompt: `Analyze THIRD-PARTY API costs for: "${target}". Look for: excessive LLM/AI API calls (missing caching, redundant calls), payment provider fees that could be reduced, over-calling external APIs when local cache would suffice, unused API subscriptions, inefficient batch vs single calls. Estimate current spend and potential savings.` },
+    { label: 'database-query', prompt: `Analyze DATABASE QUERY costs for: "${target}". Look for: N+1 queries (fetching rows in a loop), missing indexes on WHERE/JOIN/ORDER BY columns, SELECT * where only a few columns are needed, unbounded queries without LIMIT, expensive full-table scans, redundant queries that could be cached. Estimate compute cost impact and savings.` },
+    { label: 'bundle-runtime', prompt: `Analyze BUNDLE AND RUNTIME OVERHEAD costs for: "${target}". Look for: large JS bundles (over 500KB) increasing CDN bandwidth costs, unoptimized images (missing WebP, no lazy loading), missing HTTP cache headers causing repeat downloads, unused dependencies inflating bundle size, missing code splitting. Estimate bandwidth/CDN cost impact.` },
+  ];
+
+  const dimResults = await parallel(
+    DIMENSIONS.map(d => () => agent(d.prompt, { schema: COST_DIM_SCHEMA, label: `cost:${d.label}`, phase: 'Analyze' }))
+  );
+
+  phase('Model');
+  const allFindings = dimResults.filter(Boolean).flatMap(d => d.findings.map(f => ({ dimension: d.dimension, ...f })));
+  log(`${allFindings.length} cost findings across 4 dimensions`);
+
+  phase('Plan');
+  const findingSummary = allFindings.slice(0, 20).map(f => `[${f.dimension}/${f.wasteType}] ${f.item}: save ${f.potentialSaving} — ${f.fix}`).join('\n');
+  const plan = await agent(
+    `Create a cost reduction plan for: "${target}"\n\nCost findings:\n${findingSummary}\n\nPrioritize by: P0=quick wins with high savings (low effort, >$500/mo), P1=high savings medium effort, P2=nice-to-have. For each item estimate monthly saving, implementation effort, and ROI timeframe. Calculate total estimated monthly saving.`,
+    { schema: PLAN_SCHEMA, label: 'plan' }
+  );
+  if (!plan) { return { target, scope, dimResults: dimResults.filter(Boolean), error: 'plan-agent-null' }; }
+
+  return { target, scope, dimResults: dimResults.filter(Boolean), plan };
+}

package/.mindforge/dynamic-workflows/scripts/data-pipeline-validate.js

@@ -0,0 +1,69 @@
+export const meta = {
+  name: 'data-pipeline-validate',
+  description: 'Pipeline stage-by-stage validation → data quality gates → anomaly detection report',
+  whenToUse: 'When validating a data pipeline for correctness, completeness, and quality before production use',
+  phases: [
+    { title: 'Map', detail: 'Map all pipeline stages from source to sink' },
+    { title: 'Validate', detail: 'Parallel validation per stage (schema / completeness / transforms / outputs)' },
+    { title: 'Quality', detail: 'Data quality gate assessment — freshness, completeness, consistency' },
+    { title: 'Report', detail: 'Validation report with stage health scores and fix recommendations' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const PIPELINE_SCHEMA = {
+    type: 'object',
+    properties: {
+      stages: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string', enum: ['source', 'transform', 'enrich', 'filter', 'aggregate', 'sink'] }, input: { type: 'string' }, output: { type: 'string' } }, required: ['name', 'type'] } },
+      pipelineName: { type: 'string' },
+    },
+    required: ['stages', 'pipelineName'],
+  };
+
+  const STAGE_SCHEMA = {
+    type: 'object',
+    properties: {
+      stage: { type: 'string' },
+      issues: { type: 'array', items: { type: 'object', properties: { severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] }, category: { type: 'string' }, description: { type: 'string' }, fix: { type: 'string' } }, required: ['severity', 'category', 'description', 'fix'] } },
+      healthScore: { type: 'number' },
+    },
+    required: ['stage', 'issues', 'healthScore'],
+  };
+
+  const REPORT_SCHEMA = {
+    type: 'object',
+    properties: {
+      overallHealth: { type: 'string', enum: ['healthy', 'degraded', 'critical', 'failing'] },
+      summary: { type: 'string' },
+      criticalIssues: { type: 'array', items: { type: 'string' } },
+      recommendations: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['overallHealth', 'summary', 'criticalIssues', 'recommendations'],
+  };
+
+  const target = args || 'current data pipeline (run from pipeline directory)';
+
+  phase('Map');
+  const pipelineMap = await agent(`Map all stages of the data pipeline in: "${target}". Identify each stage by name, type (source/transform/enrich/filter/aggregate/sink), its input data source, and output. List them in execution order.`, { schema: PIPELINE_SCHEMA, label: 'map' });
+  if (!pipelineMap) { log('Warning: agent returned null for pipelineMap, skipping'); return { target, error: 'agent-null' }; }
+  log(`Pipeline: ${pipelineMap.pipelineName} — ${pipelineMap.stages.length} stages`);
+
+  phase('Validate');
+  const validations = await parallel(
+    pipelineMap.stages.map(s => () => agent(
+      `Validate pipeline stage "${s.name}" (${s.type}) in: "${target}". Check: (1) schema validation — correct data types, required fields present, (2) completeness — no unexpected nulls or missing records, (3) transform correctness — business rules applied correctly, (4) output contracts — downstream consumers will receive expected format. Rate each issue critical/high/medium/low.`,
+      { schema: STAGE_SCHEMA, label: `validate:${s.name}`, phase: 'Validate' }
+    ))
+  );
+
+  phase('Quality');
+  const stageScores = validations.filter(Boolean).map(v => `${v.stage}: ${v.healthScore}/100`).join(', ');
+  log(`Stage health: ${stageScores}`);
+
+  phase('Report');
+  const issueList = validations.filter(Boolean).flatMap(v => v.issues.map(i => `[${v.stage}/${i.severity}] ${i.description}`)).slice(0, 15);
+  const report = await agent(`Create a data pipeline validation report for: "${target}"\n\nStage health scores: ${stageScores}\n\nIssues found:\n${issueList.join('\n')}\n\nDetermine overall pipeline health, list critical issues, and provide prioritized recommendations.`, { schema: REPORT_SCHEMA, label: 'report' });
+  if (!report) { return { target, pipelineMap, validations: validations.filter(Boolean), error: 'report-agent-null' }; }
+
+  return { target, pipelineMap, validations: validations.filter(Boolean), report };
+}

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

@@ -0,0 +1,113 @@
+export const meta = {
+  name: 'database-migration',
+  description: 'Schema diff → risk analysis → migration scripts → rollback plan',
+  whenToUse: 'When planning or reviewing a database schema migration — adding columns, changing types, dropping tables',
+  phases: [
+    { title: 'SchemaDiff', detail: 'Parse current and target schema, compute structural diff' },
+    { title: 'RiskAnalysis', detail: 'Assess data loss risk, locking impact, and rollback complexity' },
+    { title: 'Scripts', detail: 'Generate forward migration + rollback scripts' },
+    { title: 'Runbook', detail: 'Step-by-step production runbook with verification checks' },
+  ],
+};
+
+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'],
+        },
+      },
+      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'],
+        },
+      },
+      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 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)';
+
+  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' }
+    ),
+  ]);
+
+  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 };
+}