mindforge-cc 11.8.2 → 11.9.0

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

@@ -10,133 +10,131 @@ export const meta = {
   ],
 };
 
-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 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'],
+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'],
-  };
+    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'],
+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'],
-  };
+    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'],
+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'],
-  };
+    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)';
+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(', ')}`);
+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}`;
+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?` },
-  ];
+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' }))
-  );
+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');
+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' }
-  );
+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');
+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' }
-    ),
-  ]);
+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 };
-}
+return { target, scope, angles: validAngles, analysis, synthesis };

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

@@ -10,98 +10,96 @@ export const meta = {
   ],
 };
 
-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 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'],
+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'],
-  };
+  },
+  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'],
+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'],
-  };
+  },
+  required: ['summary', 'totalEstimatedSaving', 'reductionItems'],
+};
 
-  const target = args || 'current codebase (run from repo root)';
+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('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.` },
-  ];
+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' }))
-  );
+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('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' }; }
+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 };
-}
+return { target, scope, dimResults: dimResults.filter(Boolean), plan };

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

@@ -10,60 +10,58 @@ export const meta = {
   ],
 };
 
-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 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 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 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)';
+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('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('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('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' }; }
+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 };
-}
+return { target, pipelineMap, validations: validations.filter(Boolean), report };