mindforge-cc 11.5.1 → 11.7.0

package/.claude/commands/mindforge/wf-pr-review.md

@@ -0,0 +1,31 @@
+---
+description: "4-dimensional parallel PR review: correctness, security, performance, style → consensus verdict"
+---
+# /mindforge:wf-pr-review
+
+Runs the **Pr Review** dynamic workflow.
+
+## Usage
+`/mindforge:wf-pr-review [diff target or 'current HEAD~1']`
+
+## What it does
+- **Scope**: Reads the diff and gathers review context
+- **Review**: 4 parallel reviewers — correctness, security, performance, code style
+- **Consensus**: Merges all findings, deduplicates, assigns severity (blocking/major/minor)
+- **Verdict**: APPROVED / APPROVED_WITH_SUGGESTIONS / CHANGES_REQUIRED / BLOCKING
+
+## Running
+
+Invoke via Claude Code's Workflow tool:
+
+```
+Workflow({
+  scriptPath: ".mindforge/dynamic-workflows/scripts/pr-review.js",
+  args: "<your input>"
+})
+```
+
+Or discover via CLI:
+```bash
+node bin/mindforge-cli.js workflow info pr-review
+```

package/.claude/commands/mindforge/wf-refactor-plan.md

@@ -0,0 +1,31 @@
+---
+description: "Technical debt scan → risk-sorted sequence → safe refactor implementation plan"
+---
+# /mindforge:wf-refactor-plan
+
+Runs the **Refactor Plan** dynamic workflow.
+
+## Usage
+`/mindforge:wf-refactor-plan [path or 'current codebase']`
+
+## What it does
+- **Scan**: 3 parallel scans — structural debt, complexity debt, maintenance debt
+- **Prioritize**: Risk-sorts items by blast radius × test coverage inverse
+- **Sequence**: Orders changes to minimize conflicts and risk
+- **Plan**: Step-by-step refactor plan with verification gates and rollback procedures
+
+## Running
+
+Invoke via Claude Code's Workflow tool:
+
+```
+Workflow({
+  scriptPath: ".mindforge/dynamic-workflows/scripts/refactor-plan.js",
+  args: "<your input>"
+})
+```
+
+Or discover via CLI:
+```bash
+node bin/mindforge-cli.js workflow info refactor-plan
+```

package/.claude/commands/mindforge/wf-release-prep.md

@@ -0,0 +1,31 @@
+---
+description: "Automated release pipeline: tests → changelog → version bump → PR → announcement draft"
+---
+# /mindforge:wf-release-prep
+
+Runs the **Release Prep** dynamic workflow.
+
+## Usage
+`/mindforge:wf-release-prep [repo context]`
+
+## What it does
+- **Check**: Verifies readiness — no uncommitted changes, tests passing, no critical open bugs
+- **Changelog**: Generates changelog from conventional commits since last release
+- **Bump**: Determines next semver version based on breaking/feature/fix counts
+- **PR**: Drafts the release PR body, release notes, and social announcement
+
+## Running
+
+Invoke via Claude Code's Workflow tool:
+
+```
+Workflow({
+  scriptPath: ".mindforge/dynamic-workflows/scripts/release-prep.js",
+  args: "<your input>"
+})
+```
+
+Or discover via CLI:
+```bash
+node bin/mindforge-cli.js workflow info release-prep
+```

package/.claude/commands/mindforge/wf-tdd-sprint.md

@@ -0,0 +1,31 @@
+---
+description: "Strict Red-Green-Refactor TDD loop with spec-first discipline"
+---
+# /mindforge:wf-tdd-sprint
+
+Runs the **Tdd Sprint** dynamic workflow.
+
+## Usage
+`/mindforge:wf-tdd-sprint <feature or behavior to implement>`
+
+## What it does
+- **Spec**: Writes a precise Given-When-Then behavioral spec with edge cases
+- **Red**: Writes a failing test that captures exactly the required behavior
+- **Green**: Writes the MINIMAL implementation to make the test pass
+- **Refactor**: Cleans up the passing implementation with specific improvements listed
+
+## Running
+
+Invoke via Claude Code's Workflow tool:
+
+```
+Workflow({
+  scriptPath: ".mindforge/dynamic-workflows/scripts/tdd-sprint.js",
+  args: "<your input>"
+})
+```
+
+Or discover via CLI:
+```bash
+node bin/mindforge-cli.js workflow info tdd-sprint
+```

package/.claude/commands/mindforge/wf-tech-evaluation.md

@@ -0,0 +1,31 @@
+---
+description: "Scored technology evaluation across DX, performance, security, ecosystem, community"
+---
+# /mindforge:wf-tech-evaluation
+
+Runs the **Tech Evaluation** dynamic workflow.
+
+## Usage
+`/mindforge:wf-tech-evaluation <TechA vs TechB vs TechC for [use case]>`
+
+## What it does
+- **Scope**: Parses candidates and evaluation criteria from your input
+- **Evaluate**: 5 parallel dimension agents — DX, performance, security, ecosystem, community
+- **Score**: Builds a weighted 1-10 scoring matrix per dimension
+- **Recommend**: Produces ranked recommendation with trade-offs for each option
+
+## Running
+
+Invoke via Claude Code's Workflow tool:
+
+```
+Workflow({
+  scriptPath: ".mindforge/dynamic-workflows/scripts/tech-evaluation.js",
+  args: "<your input>"
+})
+```
+
+Or discover via CLI:
+```bash
+node bin/mindforge-cli.js workflow info tech-evaluation
+```

package/.mindforge/config.json

@@ -1,11 +1,11 @@
 {
-  "version": "11.5.1",
+  "version": "11.7.0",
   "environment": "development",
   "governance": {
     "drift_threshold": 0.75,
     "critical_drift_threshold": 0.5,
     "res_threshold": 0.8,
-    "active_did": "did:mindforge:7dffeae7-eb70-45c9-9001-701fba7809d2"
+    "active_did": "did:mindforge:5a2153fe-8744-4cc6-907d-bcfbdeca23a6"
   },
   "revops": {
     "market_registry": {

package/.mindforge/dynamic-workflows/REGISTRY.md

@@ -0,0 +1,65 @@
+# MindForge Dynamic Workflow Registry
+
+Dynamic workflows are multi-agent JS orchestration scripts that run via Claude Code's `Workflow` tool. They use `parallel()`, `pipeline()`, `phase()`, and `agent()` primitives to fan out work across multiple concurrent subagents and synthesize results.
+
+**Trigger:** Use `/mindforge:wf-catalog` to browse interactively, or invoke any `/mindforge:wf-<name>` command directly.
+
+**Discovery:** `node bin/mindforge-cli.js workflow list`
+
+---
+
+## Research Tier — Fan-out search, adversarial verification, cited output
+
+| Name | Command | Description | Phases |
+|------|---------|-------------|--------|
+| `deep-research` | `/mindforge:wf-deep-research` | Fan-out web research with adversarial claim verification and cited synthesis | Scope → Search → Fetch → Verify → Synthesize |
+| `competitive-analysis` | `/mindforge:wf-competitive-analysis` | Multi-angle competitive research producing a SWOT and positioning summary | Scope → Research → SWOT → Position |
+| `tech-evaluation` | `/mindforge:wf-tech-evaluation` | Scored technology evaluation across DX, performance, security, ecosystem, community | Scope → Evaluate → Score → Recommend |
+
+## Dev Tier — Coding-assistant power workflows
+
+| Name | Command | Description | Phases |
+|------|---------|-------------|--------|
+| `code-audit` | `/mindforge:wf-code-audit` | Parallel security + quality + performance audit with adversarial finding verification | Scope → Audit → Verify → Report |
+| `feature-planner` | `/mindforge:wf-feature-planner` | Sequential pipeline: brief → PRD → architecture → user stories | Brief → PRD → Arch → Stories |
+| `pr-review` | `/mindforge:wf-pr-review` | 4-dimensional parallel PR review: correctness, security, performance, style → verdict | Scope → Review → Consensus → Verdict |
+| `tdd-sprint` | `/mindforge:wf-tdd-sprint` | Strict Red-Green-Refactor TDD loop with spec-first discipline | Spec → Red → Green → Refactor |
+| `refactor-plan` | `/mindforge:wf-refactor-plan` | Debt scan → risk-sorted sequence → safe refactor implementation plan | Scan → Prioritize → Sequence → Plan |
+
+## Ops Tier — Infrastructure and release workflows
+
+| Name | Command | Description | Phases |
+|------|---------|-------------|--------|
+| `incident-response` | `/mindforge:wf-incident-response` | Parallel investigation: logs/metrics/traces/code → mitigation → RCA → postmortem | Alert → Investigate → Mitigate → RCA |
+| `release-prep` | `/mindforge:wf-release-prep` | Automated release pipeline: tests → changelog → version bump → PR → announcement | Check → Changelog → Bump → PR |
+
+## Intelligence Tier — Deep analysis and optimization
+
+| Name | Command | Description | Phases |
+|------|---------|-------------|--------|
+| `onboard-codebase` | `/mindforge:wf-onboard-codebase` | Map structure → domain analysis → architecture → guided tour and onboarding docs | Map → Domain → Arch → Tour |
+| `perf-optimize` | `/mindforge:wf-perf-optimize` | Profile → parallel bottleneck hunt (DB/network/CPU/memory) → prioritized fix plan | Profile → Identify → Plan → Benchmark |
+
+---
+
+## Schema
+
+Each workflow script at `.mindforge/dynamic-workflows/scripts/<name>.js` exports:
+
+```javascript
+export const meta = {
+  name: '<name>',          // matches filename (without .js)
+  description: '<string>', // shown in this catalog
+  whenToUse: '<string>',   // trigger conditions
+  phases: [{ title, detail }],
+}
+```
+
+Scripts use the Claude Code `Workflow` tool primitives: `agent()`, `parallel()`, `pipeline()`, `phase()`, `log()`, `args`, `budget`.
+
+## Adding a workflow
+
+1. Write `.mindforge/dynamic-workflows/scripts/<name>.js` with a valid `meta` export
+2. Add an entry to `index.json`
+3. Add paired command files to `.agent/mindforge/wf-<name>.md` and `.claude/commands/mindforge/wf-<name>.md`
+4. Run `npm test` — `tests/workflow-registry.test.js` validates all three steps

package/.mindforge/dynamic-workflows/index.json

@@ -0,0 +1,171 @@
+[
+  {
+    "name": "deep-research",
+    "description": "Fan-out web research with adversarial claim verification and cited synthesis",
+    "whenToUse": "When you need a deep, multi-source, fact-checked research report on any topic",
+    "tier": "research",
+    "command": "/mindforge:wf-deep-research",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/deep-research.js",
+    "phases": [
+      { "title": "Scope", "detail": "Decompose question into 5 search angles" },
+      { "title": "Search", "detail": "5 parallel web search agents" },
+      { "title": "Fetch", "detail": "Dedup URLs, fetch top 15 sources, extract claims" },
+      { "title": "Verify", "detail": "3-vote adversarial verification per claim" },
+      { "title": "Synthesize", "detail": "Merge dupes, rank by confidence, cite sources" }
+    ]
+  },
+  {
+    "name": "competitive-analysis",
+    "description": "Multi-angle competitive research producing a SWOT and positioning summary",
+    "whenToUse": "When evaluating a product, company, or technology against competitors",
+    "tier": "research",
+    "command": "/mindforge:wf-competitive-analysis",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/competitive-analysis.js",
+    "phases": [
+      { "title": "Scope", "detail": "Define target and 5 research angles" },
+      { "title": "Research", "detail": "Parallel research: product / pricing / reviews / community / roadmap" },
+      { "title": "SWOT", "detail": "Synthesize strengths, weaknesses, opportunities, threats" },
+      { "title": "Position", "detail": "Produce positioning recommendations" }
+    ]
+  },
+  {
+    "name": "tech-evaluation",
+    "description": "Scored technology evaluation across DX, performance, security, ecosystem, and community",
+    "whenToUse": "When choosing between technologies, frameworks, or libraries for a project",
+    "tier": "research",
+    "command": "/mindforge:wf-tech-evaluation",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/tech-evaluation.js",
+    "phases": [
+      { "title": "Scope", "detail": "Define candidates and evaluation criteria" },
+      { "title": "Evaluate", "detail": "5 parallel dimension agents per candidate" },
+      { "title": "Score", "detail": "Build weighted scoring matrix" },
+      { "title": "Recommend", "detail": "Produce ranked recommendation with trade-offs" }
+    ]
+  },
+  {
+    "name": "code-audit",
+    "description": "Parallel security + quality + performance audit with adversarial finding verification",
+    "whenToUse": "When you need a comprehensive code review before a release or security review",
+    "tier": "dev",
+    "command": "/mindforge:wf-code-audit",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/code-audit.js",
+    "phases": [
+      { "title": "Scope", "detail": "Build file list from git diff or path argument" },
+      { "title": "Audit", "detail": "3 parallel auditors: security / quality / performance" },
+      { "title": "Verify", "detail": "Adversarial verification of high-severity findings" },
+      { "title": "Report", "detail": "Risk-ranked report with actionable remediation" }
+    ]
+  },
+  {
+    "name": "feature-planner",
+    "description": "Sequential pipeline: brief → PRD → architecture → user stories",
+    "whenToUse": "When starting a new feature and need a complete specification before coding",
+    "tier": "dev",
+    "command": "/mindforge:wf-feature-planner",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/feature-planner.js",
+    "phases": [
+      { "title": "Brief", "detail": "Clarify goals, users, success criteria" },
+      { "title": "PRD", "detail": "Generate product requirements document" },
+      { "title": "Architecture", "detail": "Design technical architecture and data flow" },
+      { "title": "Stories", "detail": "Break into implementation user stories" }
+    ]
+  },
+  {
+    "name": "pr-review",
+    "description": "4-dimensional parallel PR review: correctness, security, performance, style → consensus verdict",
+    "whenToUse": "When you want a thorough multi-perspective review of a pull request or diff",
+    "tier": "dev",
+    "command": "/mindforge:wf-pr-review",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/pr-review.js",
+    "phases": [
+      { "title": "Scope", "detail": "Read diff and build review context" },
+      { "title": "Review", "detail": "4 parallel reviewers: correctness / security / performance / style" },
+      { "title": "Consensus", "detail": "Merge findings, deduplicate, score severity" },
+      { "title": "Verdict", "detail": "Produce APPROVED / CHANGES REQUIRED verdict with findings" }
+    ]
+  },
+  {
+    "name": "tdd-sprint",
+    "description": "Strict Red-Green-Refactor TDD loop with spec-first discipline",
+    "whenToUse": "When implementing a feature or fix using test-driven development methodology",
+    "tier": "dev",
+    "command": "/mindforge:wf-tdd-sprint",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/tdd-sprint.js",
+    "phases": [
+      { "title": "Spec", "detail": "Define behavior requirements and acceptance criteria" },
+      { "title": "Red", "detail": "Write failing test that captures the requirement" },
+      { "title": "Green", "detail": "Write minimal code to make the test pass" },
+      { "title": "Refactor", "detail": "Clean up while keeping tests green, verify all pass" }
+    ]
+  },
+  {
+    "name": "refactor-plan",
+    "description": "Technical debt scan → risk-sorted sequence → safe refactor implementation plan",
+    "whenToUse": "When you need to plan a refactoring safely without breaking existing behavior",
+    "tier": "dev",
+    "command": "/mindforge:wf-refactor-plan",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/refactor-plan.js",
+    "phases": [
+      { "title": "Scan", "detail": "Identify technical debt, complexity hotspots, dead code" },
+      { "title": "Prioritize", "detail": "Risk-sort by blast radius and test coverage" },
+      { "title": "Sequence", "detail": "Order changes to minimize merge conflicts" },
+      { "title": "Plan", "detail": "Produce step-by-step refactor plan with verification gates" }
+    ]
+  },
+  {
+    "name": "incident-response",
+    "description": "Parallel investigation across logs, metrics, traces, and code → mitigation → RCA → postmortem",
+    "whenToUse": "When responding to a production incident or unexpected system failure",
+    "tier": "ops",
+    "command": "/mindforge:wf-incident-response",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/incident-response.js",
+    "phases": [
+      { "title": "Alert", "detail": "Characterize the incident: impact, scope, timeline" },
+      { "title": "Investigate", "detail": "4 parallel agents: logs / metrics / traces / code changes" },
+      { "title": "Mitigate", "detail": "Identify and apply immediate mitigation steps" },
+      { "title": "RCA", "detail": "Root cause analysis and postmortem document" }
+    ]
+  },
+  {
+    "name": "release-prep",
+    "description": "Automated release pipeline: tests → changelog → version bump → PR → announcement draft",
+    "whenToUse": "When preparing a production release and need all release artifacts generated",
+    "tier": "ops",
+    "command": "/mindforge:wf-release-prep",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/release-prep.js",
+    "phases": [
+      { "title": "Check", "detail": "Run tests, verify no uncommitted changes, check CI status" },
+      { "title": "Changelog", "detail": "Generate changelog from commits since last release" },
+      { "title": "Bump", "detail": "Update version in all required files" },
+      { "title": "PR", "detail": "Create release PR and draft announcement" }
+    ]
+  },
+  {
+    "name": "onboard-codebase",
+    "description": "Map structure → domain analysis → architecture → generate guided tour and onboarding docs",
+    "whenToUse": "When joining a new codebase or onboarding a team member to an existing repo",
+    "tier": "intelligence",
+    "command": "/mindforge:wf-onboard-codebase",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/onboard-codebase.js",
+    "phases": [
+      { "title": "Map", "detail": "Discover file structure, languages, entry points" },
+      { "title": "Domain", "detail": "Identify business domains and core abstractions" },
+      { "title": "Architecture", "detail": "Map layers, data flow, and key patterns" },
+      { "title": "Tour", "detail": "Generate guided tour and onboarding documentation" }
+    ]
+  },
+  {
+    "name": "perf-optimize",
+    "description": "Profile → parallel bottleneck hunt across DB/network/CPU/memory → prioritized fix plan",
+    "whenToUse": "When an application is slow and you need to find and fix performance bottlenecks",
+    "tier": "intelligence",
+    "command": "/mindforge:wf-perf-optimize",
+    "scriptPath": ".mindforge/dynamic-workflows/scripts/perf-optimize.js",
+    "phases": [
+      { "title": "Profile", "detail": "Establish baseline metrics and identify slow paths" },
+      { "title": "Identify", "detail": "4 parallel agents: DB queries / network / CPU / memory" },
+      { "title": "Plan", "detail": "Prioritize fixes by impact-to-effort ratio" },
+      { "title": "Benchmark", "detail": "Define verification benchmarks for each fix" }
+    ]
+  }
+]

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

@@ -0,0 +1,103 @@
+export const meta = {
+  name: 'code-audit',
+  description: 'Parallel security + quality + performance audit with adversarial finding verification',
+  whenToUse: 'When you need a comprehensive code review before a release or security review',
+  phases: [
+    { title: 'Scope', detail: 'Build file list from git diff or path argument' },
+    { title: 'Audit', detail: '3 parallel auditors: security / quality / performance' },
+    { title: 'Verify', detail: 'Adversarial verification of high-severity findings' },
+    { title: 'Report', detail: 'Risk-ranked report with actionable remediation' },
+  ],
+};
+
+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'],
+        },
+      },
+    },
+    required: ['dimension', 'findings'],
+  };
+
+  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 target = args || 'current git diff (run from repo root)';
+
+  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.` },
+  ];
+
+  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`);
+
+  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];
+
+  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 },
+  };
+}

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

@@ -0,0 +1,85 @@
+export const meta = {
+  name: 'competitive-analysis',
+  description: 'Multi-angle competitive research producing a SWOT and positioning summary',
+  whenToUse: 'When evaluating a product, company, or technology against competitors',
+  phases: [
+    { title: 'Scope', detail: 'Define target and 5 research angles' },
+    { title: 'Research', detail: 'Parallel: product / pricing / reviews / community / roadmap' },
+    { title: 'SWOT', detail: 'Synthesize strengths, weaknesses, opportunities, threats' },
+    { title: 'Position', detail: 'Produce positioning recommendations' },
+  ],
+};
+
+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 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 target = args || 'No target specified — pass your product/company/technology as args.';
+
+  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.` },
+  ];
+
+  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('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),
+  };
+}