mindforge-cc 11.8.2 → 11.9.0

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

@@ -10,94 +10,92 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const FINDING_SCHEMA = {
-    type: 'object',
-    properties: {
-      dimension: { type: 'string' },
-      findings: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },
-            title: { type: 'string' },
-            file: { type: 'string' },
-            description: { type: 'string' },
-            remediation: { type: 'string' },
-          },
-          required: ['severity', 'title', 'description', 'remediation'],
+const FINDING_SCHEMA = {
+  type: 'object',
+  properties: {
+    dimension: { type: 'string' },
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },
+          title: { type: 'string' },
+          file: { type: 'string' },
+          description: { type: 'string' },
+          remediation: { type: 'string' },
         },
+        required: ['severity', 'title', 'description', 'remediation'],
       },
     },
-    required: ['dimension', 'findings'],
-  };
+  },
+  required: ['dimension', 'findings'],
+};
 
-  const VERDICT_SCHEMA = {
-    type: 'object',
-    properties: { isReal: { type: 'boolean' }, reason: { type: 'string' } },
-    required: ['isReal', 'reason'],
-  };
+const VERDICT_SCHEMA = {
+  type: 'object',
+  properties: { isReal: { type: 'boolean' }, reason: { type: 'string' } },
+  required: ['isReal', 'reason'],
+};
 
-  const REPORT_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      riskLevel: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
-      findings: { type: 'array', items: { type: 'object', properties: { severity: { type: 'string' }, title: { type: 'string' }, description: { type: 'string' }, remediation: { type: 'string' } }, required: ['severity', 'title', 'description', 'remediation'] } },
-      immediateActions: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['summary', 'riskLevel', 'findings', 'immediateActions'],
-  };
+const REPORT_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    riskLevel: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+    findings: { type: 'array', items: { type: 'object', properties: { severity: { type: 'string' }, title: { type: 'string' }, description: { type: 'string' }, remediation: { type: 'string' } }, required: ['severity', 'title', 'description', 'remediation'] } },
+    immediateActions: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['summary', 'riskLevel', 'findings', 'immediateActions'],
+};
 
-  const target = args || 'current git diff (run from repo root)';
+const target = args || 'current git diff (run from repo root)';
 
-  phase('Scope');
-  log(`Auditing: ${target}`);
+phase('Scope');
+log(`Auditing: ${target}`);
 
-  const AUDITORS = [
-    { label: 'security', prompt: `Perform a security audit of this codebase/diff: "${target}". Check for: OWASP Top 10 (injection, broken auth, XSS, IDOR, misconfig, exposure, CSRF, insecure deserialization, known vulns, logging failures), hardcoded secrets, unsafe dependencies, input validation gaps, authorization flaws. Rate each finding as critical/high/medium/low/info.` },
-    { label: 'quality', prompt: `Perform a code quality audit of: "${target}". Check for: functions >50 lines, nesting >4 levels, magic numbers, dead code, missing error handling, naming issues, copy-paste anti-patterns, missing tests, undefined behavior, race conditions. Rate each finding as critical/high/medium/low/info.` },
-    { label: 'performance', prompt: `Perform a performance audit of: "${target}". Check for: N+1 queries, unbounded loops, missing pagination, synchronous I/O in hot paths, memory leaks, missing indexes, large bundle imports, inefficient algorithms, cache invalidation issues. Rate each finding as critical/high/medium/low/info.` },
-  ];
+const AUDITORS = [
+  { label: 'security', prompt: `Perform a security audit of this codebase/diff: "${target}". Check for: OWASP Top 10 (injection, broken auth, XSS, IDOR, misconfig, exposure, CSRF, insecure deserialization, known vulns, logging failures), hardcoded secrets, unsafe dependencies, input validation gaps, authorization flaws. Rate each finding as critical/high/medium/low/info.` },
+  { label: 'quality', prompt: `Perform a code quality audit of: "${target}". Check for: functions >50 lines, nesting >4 levels, magic numbers, dead code, missing error handling, naming issues, copy-paste anti-patterns, missing tests, undefined behavior, race conditions. Rate each finding as critical/high/medium/low/info.` },
+  { label: 'performance', prompt: `Perform a performance audit of: "${target}". Check for: N+1 queries, unbounded loops, missing pagination, synchronous I/O in hot paths, memory leaks, missing indexes, large bundle imports, inefficient algorithms, cache invalidation issues. Rate each finding as critical/high/medium/low/info.` },
+];
 
-  phase('Audit');
-  const audits = await parallel(
-    AUDITORS.map(a => () => agent(a.prompt, { schema: FINDING_SCHEMA, label: `audit:${a.label}`, phase: 'Audit' }))
-  );
+phase('Audit');
+const audits = await parallel(
+  AUDITORS.map(a => () => agent(a.prompt, { schema: FINDING_SCHEMA, label: `audit:${a.label}`, phase: 'Audit' }))
+);
 
-  phase('Verify');
-  const allFindings = audits.filter(Boolean).flatMap(a => a.findings.map(f => ({ ...f, dimension: a.dimension })));
-  const highSeverity = allFindings.filter(f => f.severity === 'critical' || f.severity === 'high');
-  log(`${allFindings.length} total findings, ${highSeverity.length} high/critical → adversarially verifying`);
+phase('Verify');
+const allFindings = audits.filter(Boolean).flatMap(a => a.findings.map(f => ({ ...f, dimension: a.dimension })));
+const highSeverity = allFindings.filter(f => f.severity === 'critical' || f.severity === 'high');
+log(`${allFindings.length} total findings, ${highSeverity.length} high/critical → adversarially verifying`);
 
-  const verifiedFindings = await parallel(
-    highSeverity.map(f => () =>
-      parallel([
-        () => agent(`Is this finding a real issue or a false positive? Try to REFUTE it. Finding: "${f.title}" — ${f.description}`, { schema: VERDICT_SCHEMA, label: `verify-1:${f.title.slice(0, 30)}` }),
-        () => agent(`Challenge this finding from a different angle. Is it actually exploitable/impactful? Finding: "${f.title}" — ${f.description}`, { schema: VERDICT_SCHEMA, label: `verify-2:${f.title.slice(0, 30)}` }),
-      ]).then(votes => {
-        const confirmed = votes.filter(Boolean).filter(v => v.isReal).length;
-        return { ...f, verified: confirmed >= 1 };
-      })
-    )
-  );
+const verifiedFindings = await parallel(
+  highSeverity.map(f => () =>
+    parallel([
+      () => agent(`Is this finding a real issue or a false positive? Try to REFUTE it. Finding: "${f.title}" — ${f.description}`, { schema: VERDICT_SCHEMA, label: `verify-1:${f.title.slice(0, 30)}` }),
+      () => agent(`Challenge this finding from a different angle. Is it actually exploitable/impactful? Finding: "${f.title}" — ${f.description}`, { schema: VERDICT_SCHEMA, label: `verify-2:${f.title.slice(0, 30)}` }),
+    ]).then(votes => {
+      const confirmed = votes.filter(Boolean).filter(v => v.isReal).length;
+      return { ...f, verified: confirmed >= 1 };
+    })
+  )
+);
 
-  const confirmedHigh = verifiedFindings.filter(Boolean).filter(f => f.verified);
-  const lowSeverity = allFindings.filter(f => f.severity !== 'critical' && f.severity !== 'high');
-  const finalFindings = [...confirmedHigh, ...lowSeverity];
+const confirmedHigh = verifiedFindings.filter(Boolean).filter(f => f.verified);
+const lowSeverity = allFindings.filter(f => f.severity !== 'critical' && f.severity !== 'high');
+const finalFindings = [...confirmedHigh, ...lowSeverity];
 
-  phase('Report');
-  const findingsSummary = finalFindings.slice(0, 20).map(f => `[${f.severity.toUpperCase()}] ${f.title}: ${f.description} → Fix: ${f.remediation}`).join('\n');
-  const report = await agent(
-    `Produce a final security and quality report for: "${target}"\n\nFindings:\n${findingsSummary}\n\nIdentify the overall risk level, list findings by severity, and give the 3-5 most important immediate actions.`,
-    { schema: REPORT_SCHEMA, label: 'report' }
-  );
+phase('Report');
+const findingsSummary = finalFindings.slice(0, 20).map(f => `[${f.severity.toUpperCase()}] ${f.title}: ${f.description} → Fix: ${f.remediation}`).join('\n');
+const report = await agent(
+  `Produce a final security and quality report for: "${target}"\n\nFindings:\n${findingsSummary}\n\nIdentify the overall risk level, list findings by severity, and give the 3-5 most important immediate actions.`,
+  { schema: REPORT_SCHEMA, label: 'report' }
+);
 
-  return {
-    target,
-    audits: audits.filter(Boolean),
-    report,
-    stats: { total: allFindings.length, highSeverity: highSeverity.length, confirmed: confirmedHigh.length },
-  };
-}
+return {
+  target,
+  audits: audits.filter(Boolean),
+  report,
+  stats: { total: allFindings.length, highSeverity: highSeverity.length, confirmed: confirmedHigh.length },
+};

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

@@ -10,129 +10,127 @@ export const meta = {
   ],
 };
 
-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'],
+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'],
-  };
+    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'],
+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'],
-  };
+    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 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'],
+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'],
-  };
+    firstDayChecklist: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['summary', 'steps', 'firstDayChecklist'],
+};
 
-  const target = args || 'current codebase (run from repo root)';
+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('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('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('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 = `
+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();
+`.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' }
-  );
+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 };
-}
+return { target, structure, domain, arch, tour };

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

@@ -10,76 +10,74 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const RESEARCH_SCHEMA = {
-    type: 'object',
-    properties: {
-      angle: { type: 'string' },
-      findings: { type: 'array', items: { type: 'string' } },
-      sources: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['angle', 'findings', 'sources'],
-  };
+const RESEARCH_SCHEMA = {
+  type: 'object',
+  properties: {
+    angle: { type: 'string' },
+    findings: { type: 'array', items: { type: 'string' } },
+    sources: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['angle', 'findings', 'sources'],
+};
 
-  const SWOT_SCHEMA = {
-    type: 'object',
-    properties: {
-      strengths: { type: 'array', items: { type: 'string' } },
-      weaknesses: { type: 'array', items: { type: 'string' } },
-      opportunities: { type: 'array', items: { type: 'string' } },
-      threats: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['strengths', 'weaknesses', 'opportunities', 'threats'],
-  };
+const SWOT_SCHEMA = {
+  type: 'object',
+  properties: {
+    strengths: { type: 'array', items: { type: 'string' } },
+    weaknesses: { type: 'array', items: { type: 'string' } },
+    opportunities: { type: 'array', items: { type: 'string' } },
+    threats: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['strengths', 'weaknesses', 'opportunities', 'threats'],
+};
 
-  const POSITION_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      differentiators: { type: 'array', items: { type: 'string' } },
-      recommendations: { type: 'array', items: { type: 'string' } },
-      risks: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['summary', 'differentiators', 'recommendations', 'risks'],
-  };
+const POSITION_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    differentiators: { type: 'array', items: { type: 'string' } },
+    recommendations: { type: 'array', items: { type: 'string' } },
+    risks: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['summary', 'differentiators', 'recommendations', 'risks'],
+};
 
-  const target = args || 'No target specified — pass your product/company/technology as args.';
+const target = args || 'No target specified — pass your product/company/technology as args.';
 
-  phase('Scope');
-  log(`Target: ${target.slice(0, 60)}`);
+phase('Scope');
+log(`Target: ${target.slice(0, 60)}`);
 
-  const ANGLES = [
-    { label: 'product', prompt: `Research the core product features, capabilities, and user experience of: ${target}. Include concrete examples and compare against known alternatives.` },
-    { label: 'pricing', prompt: `Research the pricing model, tiers, and value proposition of: ${target}. Compare against competitor pricing. Include free vs paid features.` },
-    { label: 'reviews', prompt: `Research user reviews, sentiment, and common complaints/praise for: ${target}. Look for patterns in G2, Product Hunt, Reddit, and tech forums.` },
-    { label: 'community', prompt: `Research the developer/user community, ecosystem, integrations, and third-party support for: ${target}. Check GitHub stars, Discord, documentation quality.` },
-    { label: 'roadmap', prompt: `Research the public roadmap, recent releases, and future direction of: ${target}. Look for changelogs, blog posts, and founder/team communications.` },
-  ];
+const ANGLES = [
+  { label: 'product', prompt: `Research the core product features, capabilities, and user experience of: ${target}. Include concrete examples and compare against known alternatives.` },
+  { label: 'pricing', prompt: `Research the pricing model, tiers, and value proposition of: ${target}. Compare against competitor pricing. Include free vs paid features.` },
+  { label: 'reviews', prompt: `Research user reviews, sentiment, and common complaints/praise for: ${target}. Look for patterns in G2, Product Hunt, Reddit, and tech forums.` },
+  { label: 'community', prompt: `Research the developer/user community, ecosystem, integrations, and third-party support for: ${target}. Check GitHub stars, Discord, documentation quality.` },
+  { label: 'roadmap', prompt: `Research the public roadmap, recent releases, and future direction of: ${target}. Look for changelogs, blog posts, and founder/team communications.` },
+];
 
-  phase('Research');
-  const research = await parallel(
-    ANGLES.map(a => () => agent(a.prompt, { schema: RESEARCH_SCHEMA, label: `research:${a.label}`, phase: 'Research' }))
-  );
+phase('Research');
+const research = await parallel(
+  ANGLES.map(a => () => agent(a.prompt, { schema: RESEARCH_SCHEMA, label: `research:${a.label}`, phase: 'Research' }))
+);
 
-  phase('SWOT');
-  const allFindings = research.filter(Boolean).map(r => `[${r.angle}] ${r.findings.join(' | ')}`).join('\n');
-  const swot = await agent(
-    `Based on this competitive research about "${target}", produce a SWOT analysis:\n\n${allFindings}`,
-    { schema: SWOT_SCHEMA, label: 'swot' }
-  );
+phase('SWOT');
+const allFindings = research.filter(Boolean).map(r => `[${r.angle}] ${r.findings.join(' | ')}`).join('\n');
+const swot = await agent(
+  `Based on this competitive research about "${target}", produce a SWOT analysis:\n\n${allFindings}`,
+  { schema: SWOT_SCHEMA, label: 'swot' }
+);
 
-  phase('Position');
-  const swotText = `S: ${swot.strengths.join(', ')} | W: ${swot.weaknesses.join(', ')} | O: ${swot.opportunities.join(', ')} | T: ${swot.threats.join(', ')}`;
-  const positioning = await agent(
-    `Based on this SWOT for "${target}", produce a positioning summary with key differentiators, strategic recommendations, and risks to watch:\n\n${swotText}`,
-    { schema: POSITION_SCHEMA, label: 'position' }
-  );
+phase('Position');
+const swotText = `S: ${swot.strengths.join(', ')} | W: ${swot.weaknesses.join(', ')} | O: ${swot.opportunities.join(', ')} | T: ${swot.threats.join(', ')}`;
+const positioning = await agent(
+  `Based on this SWOT for "${target}", produce a positioning summary with key differentiators, strategic recommendations, and risks to watch:\n\n${swotText}`,
+  { schema: POSITION_SCHEMA, label: 'position' }
+);
 
-  return {
-    target,
-    research: research.filter(Boolean),
-    swot,
-    positioning,
-    sources: research.filter(Boolean).flatMap(r => r.sources),
-  };
-}
+return {
+  target,
+  research: research.filter(Boolean),
+  swot,
+  positioning,
+  sources: research.filter(Boolean).flatMap(r => r.sources),
+};