mindforge-cc 11.6.0 → 11.7.1

package/.mindforge/dynamic-workflows/scripts/pr-review.js

@@ -0,0 +1,87 @@
+export const meta = {
+  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',
+  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' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const REVIEW_SCHEMA = {
+    type: 'object',
+    properties: {
+      dimension: { type: 'string' },
+      findings: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            severity: { type: 'string', enum: ['blocking', 'major', 'minor', 'suggestion'] },
+            location: { type: 'string' },
+            issue: { type: 'string' },
+            suggestion: { type: 'string' },
+          },
+          required: ['severity', 'issue', 'suggestion'],
+        },
+      },
+      summary: { type: 'string' },
+    },
+    required: ['dimension', 'findings', 'summary'],
+  };
+
+  const VERDICT_SCHEMA = {
+    type: 'object',
+    properties: {
+      verdict: { type: 'string', enum: ['APPROVED', 'APPROVED_WITH_SUGGESTIONS', 'CHANGES_REQUIRED', 'BLOCKING'] },
+      summary: { type: 'string' },
+      blockingIssues: { type: 'array', items: { type: 'string' } },
+      majorIssues: { type: 'array', items: { type: 'string' } },
+      suggestions: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['verdict', 'summary', 'blockingIssues', 'majorIssues', 'suggestions'],
+  };
+
+  const target = args || 'current git diff HEAD~1 (run from repo root)';
+
+  phase('Scope');
+  log(`Reviewing: ${target}`);
+
+  const REVIEWERS = [
+    { label: 'correctness', prompt: `Review this code change for CORRECTNESS: "${target}". Check for: logic errors, off-by-one bugs, null/undefined handling, incorrect assumptions, broken edge cases, missing error handling, incorrect API usage, race conditions, and test coverage gaps. Rate each finding as blocking/major/minor/suggestion.` },
+    { label: 'security', prompt: `Review this code change for SECURITY: "${target}". Check for: injection vulnerabilities, broken authentication, XSS, CSRF, insecure direct object references, sensitive data exposure, hardcoded credentials, missing authorization checks, and insecure dependencies. Rate each as blocking/major/minor/suggestion.` },
+    { label: 'performance', prompt: `Review this code change for PERFORMANCE: "${target}". Check for: N+1 queries, missing indexes, inefficient algorithms, memory leaks, synchronous blocking operations, unnecessary re-renders, large bundle imports, missing caching, and scalability concerns. Rate each as blocking/major/minor/suggestion.` },
+    { label: 'style', prompt: `Review this code change for CODE STYLE and MAINTAINABILITY: "${target}". Check for: naming conventions, function length, complexity, magic numbers, dead code, missing comments for non-obvious logic, inconsistent patterns, DRY violations, and adherence to project conventions. Rate each as blocking/major/minor/suggestion.` },
+  ];
+
+  phase('Review');
+  const reviews = await parallel(
+    REVIEWERS.map(r => () => agent(r.prompt, { schema: REVIEW_SCHEMA, label: `review:${r.label}`, phase: 'Review' }))
+  );
+
+  phase('Consensus');
+  const allFindings = reviews.filter(Boolean).flatMap(r => r.findings.map(f => ({ ...f, dimension: r.dimension })));
+  const blocking = allFindings.filter(f => f.severity === 'blocking');
+  const major = allFindings.filter(f => f.severity === 'major');
+  const minor = allFindings.filter(f => f.severity === 'minor');
+  const suggestions = allFindings.filter(f => f.severity === 'suggestion');
+  log(`${allFindings.length} total findings: ${blocking.length} blocking, ${major.length} major, ${minor.length} minor, ${suggestions.length} suggestions`);
+
+  const findingsSummary = allFindings.slice(0, 20).map(f => `[${f.severity.toUpperCase()}][${f.dimension}] ${f.issue} → ${f.suggestion}`).join('\n');
+
+  phase('Verdict');
+  const verdict = await agent(
+    `Produce a final PR review verdict for: "${target}"\n\nFindings:\n${findingsSummary}\n\nIf there are any blocking issues, verdict is BLOCKING. If major issues exist, CHANGES_REQUIRED. If only minor/suggestions, APPROVED_WITH_SUGGESTIONS. Otherwise APPROVED.`,
+    { schema: VERDICT_SCHEMA, label: 'verdict' }
+  );
+
+  return {
+    target,
+    reviews: reviews.filter(Boolean),
+    verdict,
+    stats: { total: allFindings.length, blocking: blocking.length, major: major.length, minor: minor.length, suggestions: suggestions.length },
+  };
+}

package/.mindforge/dynamic-workflows/scripts/refactor-plan.js

@@ -0,0 +1,121 @@
+export const meta = {
+  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',
+  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' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const DEBT_SCHEMA = {
+    type: 'object',
+    properties: {
+      area: { type: 'string' },
+      debts: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            type: { type: 'string' },
+            location: { type: 'string' },
+            description: { type: 'string' },
+            blastRadius: { type: 'string', enum: ['wide', 'medium', 'narrow'] },
+            testCoverage: { type: 'string', enum: ['good', 'partial', 'none'] },
+          },
+          required: ['type', 'description', 'blastRadius', 'testCoverage'],
+        },
+      },
+    },
+    required: ['area', 'debts'],
+  };
+
+  const PRIORITY_SCHEMA = {
+    type: 'object',
+    properties: {
+      prioritized: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            rank: { type: 'number' },
+            description: { type: 'string' },
+            risk: { type: 'string', enum: ['low', 'medium', 'high'] },
+            rationale: { type: 'string' },
+            prerequisite: { type: 'string' },
+          },
+          required: ['rank', 'description', 'risk', 'rationale'],
+        },
+      },
+    },
+    required: ['prioritized'],
+  };
+
+  const PLAN_SCHEMA = {
+    type: 'object',
+    properties: {
+      summary: { type: 'string' },
+      steps: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            step: { type: 'number' },
+            title: { type: 'string' },
+            action: { type: 'string' },
+            verification: { type: 'string' },
+            rollback: { type: 'string' },
+            estimatedEffort: { type: 'string' },
+          },
+          required: ['step', 'title', 'action', 'verification'],
+        },
+      },
+      totalEstimate: { type: 'string' },
+      risks: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['summary', 'steps', 'totalEstimate', 'risks'],
+  };
+
+  const target = args || 'current codebase (run from repo root)';
+
+  phase('Scan');
+  log(`Scanning: ${target}`);
+
+  const SCAN_AREAS = [
+    { label: 'structural', prompt: `Scan for structural technical debt in: "${target}". Look for: God objects/files (>400 lines), circular dependencies, tight coupling, missing abstraction layers, inconsistent patterns across similar features.` },
+    { label: 'complexity', prompt: `Scan for complexity debt in: "${target}". Look for: functions >50 lines, nesting >4 levels, cyclomatic complexity, boolean parameter flags, long parameter lists, feature envy, shotgun surgery patterns.` },
+    { label: 'maintenance', prompt: `Scan for maintenance debt in: "${target}". Look for: dead code, commented-out code, outdated comments, TODO/FIXME/HACK markers, deprecated API usage, inconsistent naming, magic numbers/strings.` },
+  ];
+
+  const scans = await parallel(
+    SCAN_AREAS.map(a => () => agent(a.prompt, { schema: DEBT_SCHEMA, label: `scan:${a.label}`, phase: 'Scan' }))
+  );
+
+  phase('Prioritize');
+  const allDebts = scans.filter(Boolean).flatMap(s => s.debts);
+  log(`Found ${allDebts.length} debt items across ${scans.filter(Boolean).length} areas`);
+  const debtList = allDebts.slice(0, 20).map((d, i) => `${i + 1}. [blast:${d.blastRadius}][coverage:${d.testCoverage}] ${d.description}`).join('\n');
+  const prioritized = await agent(
+    `Prioritize this refactoring backlog by risk. Items with narrow blast radius + good test coverage = tackle first (low risk). Wide blast radius + no coverage = tackle last or skip.\n\nDebts:\n${debtList}`,
+    { schema: PRIORITY_SCHEMA, label: 'prioritize' }
+  );
+
+  phase('Sequence');
+  const topItems = prioritized.prioritized.slice(0, 10).map(p => `${p.rank}. [${p.risk}] ${p.description}: ${p.rationale}`).join('\n');
+
+  phase('Plan');
+  const plan = await agent(
+    `Create a safe, step-by-step refactoring plan for: "${target}"\n\nPrioritized items:\n${topItems}\n\nFor each step, specify: the action to take, how to verify it didn't break anything, rollback procedure, and estimated effort. Order steps to minimize merge conflicts.`,
+    { schema: PLAN_SCHEMA, label: 'plan' }
+  );
+
+  return {
+    target,
+    debtItems: allDebts.length,
+    prioritized: prioritized.prioritized,
+    plan,
+  };
+}

package/.mindforge/dynamic-workflows/scripts/release-prep.js

@@ -0,0 +1,102 @@
+export const meta = {
+  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',
+  phases: [
+    { title: 'Check', detail: 'Verify tests pass, no uncommitted changes, CI status' },
+    { title: 'Changelog', detail: 'Generate changelog from commits since last release' },
+    { title: 'Bump', detail: 'Identify next version using semver conventions' },
+    { title: 'PR', detail: 'Draft release PR description and announcement' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const READINESS_SCHEMA = {
+    type: 'object',
+    properties: {
+      ready: { type: 'boolean' },
+      blockers: { type: 'array', items: { type: 'string' } },
+      warnings: { type: 'array', items: { type: 'string' } },
+      testSummary: { type: 'string' },
+    },
+    required: ['ready', 'blockers', 'warnings', 'testSummary'],
+  };
+
+  const CHANGELOG_SCHEMA = {
+    type: 'object',
+    properties: {
+      breaking: { type: 'array', items: { type: 'string' } },
+      features: { type: 'array', items: { type: 'string' } },
+      fixes: { type: 'array', items: { type: 'string' } },
+      chores: { type: 'array', items: { type: 'string' } },
+      highlights: { type: 'string' },
+    },
+    required: ['breaking', 'features', 'fixes', 'chores', 'highlights'],
+  };
+
+  const VERSION_SCHEMA = {
+    type: 'object',
+    properties: {
+      current: { type: 'string' },
+      next: { type: 'string' },
+      bumpType: { type: 'string', enum: ['major', 'minor', 'patch'] },
+      rationale: { type: 'string' },
+      filesToUpdate: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['current', 'next', 'bumpType', 'rationale', 'filesToUpdate'],
+  };
+
+  const PR_SCHEMA = {
+    type: 'object',
+    properties: {
+      prTitle: { type: 'string' },
+      prBody: { type: 'string' },
+      announcementDraft: { type: 'string' },
+      releaseNotes: { type: 'string' },
+    },
+    required: ['prTitle', 'prBody', 'announcementDraft', 'releaseNotes'],
+  };
+
+  const context = args || 'current repository (run from repo root)';
+
+  phase('Check');
+  log(`Preparing release for: ${context}`);
+  const readiness = await agent(
+    `Check release readiness for: "${context}"\n\nVerify: are there uncommitted changes? Any failing tests? Any security vulnerabilities in dependencies? Any open critical bugs that should block release? List any blockers and warnings.`,
+    { schema: READINESS_SCHEMA, label: 'check' }
+  );
+  if (!readiness.ready && readiness.blockers.length > 0) {
+    log(`BLOCKED: ${readiness.blockers.join(', ')}`);
+  }
+  log(`Readiness: ${readiness.ready ? 'GO' : 'BLOCKED'} — ${readiness.blockers.length} blockers, ${readiness.warnings.length} warnings`);
+
+  phase('Changelog');
+  const changelog = await agent(
+    `Generate a changelog for this release of: "${context}"\n\nAnalyze recent commits (look for conventional commit format: feat/fix/chore/refactor/docs/test/perf/ci). Separate into: breaking changes, new features, bug fixes, chores. Write a highlights summary (2-3 sentences).`,
+    { schema: CHANGELOG_SCHEMA, label: 'changelog' }
+  );
+  log(`Changelog: ${changelog.breaking.length} breaking, ${changelog.features.length} features, ${changelog.fixes.length} fixes`);
+
+  phase('Bump');
+  const changelogSummary = `Breaking: ${changelog.breaking.length}, Features: ${changelog.features.length}, Fixes: ${changelog.fixes.length}`;
+  const version = await agent(
+    `Determine the next semantic version for: "${context}"\nChanges: ${changelogSummary}\nHighlights: ${changelog.highlights}\n\nUse semver rules: breaking change = major bump, new features = minor bump, fixes only = patch bump. List all files that need version updated.`,
+    { schema: VERSION_SCHEMA, label: 'bump' }
+  );
+  log(`Version: ${version.current} → ${version.next} (${version.bumpType})`);
+
+  phase('PR');
+  const releaseContext = `Version: ${version.current} → ${version.next}\nHighlights: ${changelog.highlights}\nFeatures: ${changelog.features.slice(0, 5).join(', ')}\nFixes: ${changelog.fixes.slice(0, 5).join(', ')}`;
+  const pr = await agent(
+    `Draft the release PR and announcement for: "${context}"\n${releaseContext}\n\nWrite: a PR title and body (markdown), a 280-char social announcement draft, and full release notes (markdown, suitable for GitHub Releases).`,
+    { schema: PR_SCHEMA, label: 'pr' }
+  );
+
+  return {
+    context,
+    readiness,
+    changelog,
+    version,
+    pr,
+  };
+}

package/.mindforge/dynamic-workflows/scripts/tdd-sprint.js

@@ -0,0 +1,103 @@
+export const meta = {
+  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',
+  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' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const SPEC_SCHEMA = {
+    type: 'object',
+    properties: {
+      behaviorName: { type: 'string' },
+      given: { type: 'string' },
+      when: { type: 'string' },
+      then: { type: 'string' },
+      acceptanceCriteria: { type: 'array', items: { type: 'string' } },
+      edgeCases: { type: 'array', items: { type: 'string' } },
+      outOfScope: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['behaviorName', 'given', 'when', 'then', 'acceptanceCriteria', 'edgeCases'],
+  };
+
+  const TEST_SCHEMA = {
+    type: 'object',
+    properties: {
+      testDescription: { type: 'string' },
+      testCode: { type: 'string' },
+      whyItFails: { type: 'string' },
+      fileToCreate: { type: 'string' },
+    },
+    required: ['testDescription', 'testCode', 'whyItFails', 'fileToCreate'],
+  };
+
+  const IMPL_SCHEMA = {
+    type: 'object',
+    properties: {
+      approachExplanation: { type: 'string' },
+      implementationCode: { type: 'string' },
+      fileToCreate: { type: 'string' },
+      minimalityRationale: { type: 'string' },
+    },
+    required: ['approachExplanation', 'implementationCode', 'fileToCreate', 'minimalityRationale'],
+  };
+
+  const REFACTOR_SCHEMA = {
+    type: 'object',
+    properties: {
+      improvements: { type: 'array', items: { type: 'string' } },
+      refactoredCode: { type: 'string' },
+      testsStillPass: { type: 'boolean' },
+      explanation: { type: 'string' },
+    },
+    required: ['improvements', 'refactoredCode', 'testsStillPass', 'explanation'],
+  };
+
+  const requirement = args || 'No requirement specified — pass your feature/behavior description as args.';
+
+  phase('Spec');
+  log(`Requirement: ${requirement.slice(0, 80)}`);
+  const spec = await agent(
+    `Write a precise behavioral specification for: "${requirement}"\n\nUse Given-When-Then format. Be explicit about inputs, outputs, and edge cases. List what is OUT of scope to keep this focused.`,
+    { schema: SPEC_SCHEMA, label: 'spec' }
+  );
+  log(`Spec: ${spec.behaviorName} | ${spec.acceptanceCriteria.length} acceptance criteria, ${spec.edgeCases.length} edge cases`);
+
+  phase('Red');
+  const specText = `Given: ${spec.given}\nWhen: ${spec.when}\nThen: ${spec.then}\nCriteria: ${spec.acceptanceCriteria.join(', ')}`;
+  const test = await agent(
+    `Write a FAILING test for this behavior specification:\n${specText}\n\nWrite the minimal test that will fail because the implementation doesn't exist yet. Explain WHY it fails. Use the project's test framework (detect from file extensions or state Jest/Vitest/Node assert).`,
+    { schema: TEST_SCHEMA, label: 'red' }
+  );
+  log(`[RED] Test: "${test.testDescription}" — fails because: ${test.whyItFails}`);
+
+  phase('Green');
+  const testContext = `Test: ${test.testDescription}\n\nTest code:\n${test.testCode}\n\nFails because: ${test.whyItFails}`;
+  const impl = await agent(
+    `Write the MINIMUM implementation to make this test pass:\n${testContext}\n\nWrite ONLY what is needed to make the test go green. No extra features, no future-proofing. Explain why this is the minimal solution.`,
+    { schema: IMPL_SCHEMA, label: 'green' }
+  );
+  log(`[GREEN] Minimal implementation: ${impl.minimalityRationale}`);
+
+  phase('Refactor');
+  const greenContext = `Test: ${test.testCode}\nImplementation: ${impl.implementationCode}`;
+  const refactored = await agent(
+    `Refactor this passing implementation for clarity and maintainability, keeping all tests green:\n${greenContext}\n\nList specific improvements made (naming, structure, extraction, simplification). The tests MUST still pass after refactoring.`,
+    { schema: REFACTOR_SCHEMA, label: 'refactor' }
+  );
+  log(`[REFACTOR] ${refactored.improvements.length} improvements, tests still pass: ${refactored.testsStillPass}`);
+
+  return {
+    requirement,
+    spec,
+    test,
+    implementation: impl,
+    refactored,
+    cycle: { red: test.testDescription, green: impl.approachExplanation, refactor: refactored.explanation },
+  };
+}

package/.mindforge/dynamic-workflows/scripts/tech-evaluation.js

@@ -0,0 +1,72 @@
+export const meta = {
+  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',
+  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' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const EVAL_SCHEMA = {
+    type: 'object',
+    properties: {
+      dimension: { type: 'string' },
+      score: { type: 'number', minimum: 1, maximum: 10 },
+      rationale: { type: 'string' },
+      pros: { type: 'array', items: { type: 'string' } },
+      cons: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['dimension', 'score', 'rationale', 'pros', 'cons'],
+  };
+
+  const RECOMMEND_SCHEMA = {
+    type: 'object',
+    properties: {
+      winner: { type: 'string' },
+      summary: { type: 'string' },
+      ranking: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, totalScore: { type: 'number' }, verdict: { type: 'string' } }, required: ['name', 'totalScore', 'verdict'] } },
+      tradeoffs: { type: 'array', items: { type: 'string' } },
+      recommendation: { type: 'string' },
+    },
+    required: ['winner', 'summary', 'ranking', 'tradeoffs', 'recommendation'],
+  };
+
+  const input = args || 'No candidates specified — pass "TechA vs TechB vs TechC for [use case]" as args.';
+
+  phase('Scope');
+  log(`Evaluating: ${input.slice(0, 80)}`);
+
+  const DIMENSIONS = [
+    { label: 'dx', name: 'Developer Experience', prompt: `Evaluate the developer experience of: ${input}. Consider: API ergonomics, documentation quality, error messages, learning curve, tooling, IDE support, type safety, and community examples. Score 1-10.` },
+    { label: 'perf', name: 'Performance', prompt: `Evaluate the runtime performance of: ${input}. Consider: throughput, latency, memory footprint, scalability, benchmarks available, and known bottlenecks. Score 1-10.` },
+    { label: 'security', name: 'Security', prompt: `Evaluate the security posture of: ${input}. Consider: CVE history, security audit results, supply chain risk, default-secure configuration, auth/authz support, and maintenance cadence. Score 1-10.` },
+    { label: 'ecosystem', name: 'Ecosystem', prompt: `Evaluate the ecosystem of: ${input}. Consider: number of integrations, plugin quality, third-party packages, cloud provider support, and lock-in risk. Score 1-10.` },
+    { label: 'community', name: 'Community', prompt: `Evaluate the community health of: ${input}. Consider: GitHub stars, contributor count, issue response time, Discord/Slack activity, recent releases, and long-term viability. Score 1-10.` },
+  ];
+
+  phase('Evaluate');
+  const evaluations = await parallel(
+    DIMENSIONS.map(d => () => agent(d.prompt, { schema: EVAL_SCHEMA, label: `eval:${d.label}`, phase: 'Evaluate' }))
+  );
+
+  phase('Score');
+  const validEvals = evaluations.filter(Boolean);
+  const scoreMatrix = validEvals.map(e => `${e.dimension}: ${e.score}/10 — ${e.rationale}`).join('\n');
+  log(`Score matrix built from ${validEvals.length} dimensions`);
+
+  phase('Recommend');
+  const recommendation = await agent(
+    `Based on this technology evaluation for "${input}", produce a ranked recommendation:\n\nScores:\n${scoreMatrix}\n\nIdentify the winner, explain the trade-offs, and give a clear recommendation for when to choose each option.`,
+    { schema: RECOMMEND_SCHEMA, label: 'recommend' }
+  );
+
+  return {
+    input,
+    evaluations: validEvals,
+    recommendation,
+  };
+}

package/.mindforge/memory/sync-manifest.json

@@ -1,6 +1,6 @@
 {
   "pattern-library.jsonl": {
-    "lastSync": "2026-06-17T12:34:17.920Z",
+    "lastSync": "2026-06-23T08:21:37.029Z",
     "localCount": 1
   }
 }

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [11.7.1] - 2026-06-23 — Workflow Forge (patch)
+
+Patch release: adds `bin/parse-workflow-args.js` (slash command argument splitter, produced by the tdd-sprint E2E run) and resolves 2 high-severity npm vulnerabilities in the tmp/inquirer dependency chain. No feature changes; all 94 tests pass.
+
+---
+
+## [11.7.0] - 2026-06-23 — Workflow Forge
+
+First Dynamic Workflow Library for MindForge. Adds 12 pre-built multi-agent workflow scripts that users trigger via `/mindforge:wf-*` commands. Each workflow uses Claude Code's `Workflow` tool primitives (`parallel()`, `pipeline()`, `phase()`, `agent()`) for true fan-out concurrent agent execution with structured synthesis. Architecture follows adversarially-verified best practices: three-tier progressive disclosure, one-workflow-per-domain, predefined (not open-ended) patterns.
+
+### Added
+
+- **Dynamic Workflow Library (`.mindforge/dynamic-workflows/`)** — 12 self-contained multi-agent workflow scripts:
+  - *Research tier:* `deep-research` (5× parallel searches → 3-vote adversarial verify → cited synthesis), `competitive-analysis` (5× parallel angles → SWOT → positioning), `tech-evaluation` (5× dimension agents → scored matrix → recommendation)
+  - *Dev tier:* `code-audit` (3× parallel auditors → adversarial verify → risk report), `feature-planner` (brief → PRD → architecture → user stories pipeline), `pr-review` (4× parallel reviewers → consensus verdict), `tdd-sprint` (Spec → Red → Green → Refactor loop), `refactor-plan` (debt scan → risk-sort → safe sequence → plan)
+  - *Ops tier:* `incident-response` (4× parallel investigation → mitigation → RCA → postmortem), `release-prep` (tests → changelog → version bump → PR → announcement)
+  - *Intelligence tier:* `onboard-codebase` (map → domain → architecture → guided tour), `perf-optimize` (profile → 4× parallel bottleneck hunt → fix plan → benchmarks)
+- **13 new slash commands** — `/mindforge:wf-catalog` (browseable index) + 12 `/mindforge:wf-<name>` workflow commands
+- **CLI workflow subcommand** — `node bin/mindforge-cli.js workflow list|info|run <name>` for discovery and metadata access
+- **Workflow registry** — `index.json` (machine-readable) + `REGISTRY.md` (human-readable catalog) with tier, description, phases, and command for each workflow
+- **`tests/workflow-registry.test.js`** — validates registry consistency, script meta exports, command mirror parity, and frontmatter schema for all workflow commands
+
+### Summary
+
+| Tier | Workflows | Commands |
+|------|-----------|----------|
+| Research | 3 | `wf-deep-research`, `wf-competitive-analysis`, `wf-tech-evaluation` |
+| Dev | 4 | `wf-code-audit`, `wf-feature-planner`, `wf-pr-review`, `wf-tdd-sprint`, `wf-refactor-plan` |
+| Ops | 2 | `wf-incident-response`, `wf-release-prep` |
+| Intelligence | 2 | `wf-onboard-codebase`, `wf-perf-optimize` |
+| **Total** | **12** | **13 (including wf-catalog)** |
+
+---
+
 ## [11.6.0] - 2026-06-17 — Skill Forge
 
 Largest single skill expansion in MindForge's history. Adds 80 community-sourced skills across 8 engineering domains with zero external attribution in any committed file. 30 skills are promoted to the engine tier for automatic trigger-matching; 50 live in the extended tier for explicit activation. Three new slash commands complete the discovery surface.

package/MINDFORGE.md

@@ -3,10 +3,10 @@
 ## 1. IDENTITY & VERSIONING
 
 [NAME]    = MindForge
-[VERSION] = 11.6.0
+[VERSION] = 11.7.1
 [STABLE]  = true
 [MODE]    = "Platform Sovereign"
-[REQUIRED_CORE_VERSION] = 11.6.0
+[REQUIRED_CORE_VERSION] = 11.7.1
 [SOVEREIGN_IDENTITY] = true
 [SRE_LAYER_ENABLED]  = true
 

package/README.md

@@ -4,11 +4,11 @@
 
 ---
 
-## Latest: v11.6.0
+## Latest: v11.7.0
 
-- **v11.6.0 — "Skill Forge".** Adds 80 community-sourced skills across 8 domains (software-development, github, devops, research, security, creative, data-science, note-taking) — 30 promoted to engine tier for automatic trigger-matching, 50 in the extended tier for explicit activation. Three new slash commands: `/mindforge:systematic-debug`, `/mindforge:skill-tdd`, `/mindforge:skills-index`. Total: 153 skills, 232 engine-tier entries, 177 commands.
+- **v11.7.0 — "Workflow Forge".** Ships the first Dynamic Workflow Library — 12 pre-built multi-agent workflow scripts that run via Claude Code's `Workflow` tool with true parallel agent execution. Four tiers: Research (deep-research, competitive-analysis, tech-evaluation), Dev (code-audit, feature-planner, pr-review, tdd-sprint, refactor-plan), Ops (incident-response, release-prep), Intelligence (onboard-codebase, perf-optimize). 13 new `/mindforge:wf-*` commands. Total: 198 commands.
+- **v11.6.0 — "Skill Forge".** Adds 80 community-sourced skills across 8 domains (software-development, github, devops, research, security, creative, data-science, note-taking) — 30 promoted to engine tier for automatic trigger-matching, 50 in the extended tier for explicit activation. Three new slash commands: `/mindforge:systematic-debug`, `/mindforge:skill-tdd`, `/mindforge:skills-index`. Total: 153 skills, 232 engine-tier entries, 185 commands.
 - **v11.5.1 — Standalone MCP server.** The MindForge MCP server now ships as its own npm package, `mindforge-mcp-server@11.5.1`, listed on the official MCP Registry as `io.github.sairam0424/mindforge`. Add it to Claude Code with one command (see [Use the MCP server](#-use-the-mcp-server-standalone)); it exposes 7 tools over stdio (6 read-only + 1 guarded write).
-- **v11.3.1 — Packaging hotfix.** Restores the full published payload: every `npx mindforge-cc` install now delivers all 177 slash commands, 153 skills, 154 subagents, and the complete `.mindforge/` framework.
 - **v11.3.0 — "Legion".** Imports 154 specialized Claude-Code-native subagents across 10 categories into `.claude/agents/`, fully rebranded and collision-safe. Additive and backward-compatible.
 
 See [CHANGELOG.md](./CHANGELOG.md) for full release history.
@@ -24,7 +24,7 @@ MindForge v11.0.0 "Sovereign Stability" is a production-hardening release focuse
 - **Production observability** — `/api/v1/system` health endpoint, P95 latency tracking, heap health monitoring, and real EIS client with retry logic.
 - **Graduated intelligence** — Adaptive tier escalation (+1/+2/MAX) with cost-awareness, 3-tier stuck detection, and adaptive context windows.
 
-This release ships 211 personas, 153 skills, 154 specialized subagents, 177 commands, 18 pillars, and 49 swarm templates across 12 engineering domains.
+This release ships 211 personas, 153 skills, 154 specialized subagents, 198 commands, 18 pillars, and 49 swarm templates across 12 engineering domains.
 
 
 ## Installation & Setup
@@ -380,8 +380,41 @@ See `.mindforge/production/token-optimiser.md`.
 - **Architecture:** `docs/architecture/README.md`
 - **Contributing:** `docs/contributing/CONTRIBUTING.md`
 
+## 🚀 Dynamic Workflow Library
+
+12 pre-built multi-agent workflow scripts that run via Claude Code's `Workflow` tool. Each workflow fans out concurrent agents, synthesizes results, and returns structured output.
+
+**Discover:** `/mindforge:wf-catalog` or `node bin/mindforge-cli.js workflow list`
+
+| Tier | Command | What it does |
+|------|---------|-------------|
+| Research | `/mindforge:wf-deep-research` | Fan-out web research → adversarial verify → cited report |
+| Research | `/mindforge:wf-competitive-analysis` | 5× parallel angles → SWOT → positioning |
+| Research | `/mindforge:wf-tech-evaluation` | 5× dimensions → scored matrix → recommendation |
+| Dev | `/mindforge:wf-code-audit` | 3× parallel auditors → verified findings → risk report |
+| Dev | `/mindforge:wf-feature-planner` | Brief → PRD → architecture → user stories |
+| Dev | `/mindforge:wf-pr-review` | 4× parallel reviewers → consensus verdict |
+| Dev | `/mindforge:wf-tdd-sprint` | Spec → RED → GREEN → REFACTOR loop |
+| Dev | `/mindforge:wf-refactor-plan` | Debt scan → risk-sort → safe sequence → plan |
+| Ops | `/mindforge:wf-incident-response` | 4× parallel investigation → mitigate → RCA → postmortem |
+| Ops | `/mindforge:wf-release-prep` | Tests → changelog → version bump → PR → announcement |
+| Intelligence | `/mindforge:wf-onboard-codebase` | Map → domain → architecture → guided tour |
+| Intelligence | `/mindforge:wf-perf-optimize` | Profile → 4× bottleneck hunt → prioritized fix plan |
+
+---
+
 ## 📜 Framework Evolution & Version History
 
+<details>
+<summary><b>v11.7.0 — Workflow Forge (Dynamic Workflow Library)</b></summary>
+
+- **12 dynamic workflow scripts** in `.mindforge/dynamic-workflows/scripts/` — each runs via Claude Code's `Workflow` tool with true parallel agent execution, structured JSON schemas, and adversarial verification where appropriate.
+- **4 tiers:** Research (fan-out search + verify + synthesis), Dev (code-audit, feature-planner, pr-review, tdd-sprint, refactor-plan), Ops (incident-response, release-prep), Intelligence (onboard-codebase, perf-optimize).
+- **13 new commands:** `/mindforge:wf-catalog` discovery index + 12 workflow-specific commands.
+- **CLI discovery:** `node bin/mindforge-cli.js workflow list|info|run <name>`.
+- Architecture follows adversarially-verified best practices: one-workflow-per-domain, predefined (not open-ended) pipelines, fan-out + gated synthesis pattern.
+</details>
+
 <details>
 <summary><b>v11.6.0 — Skill Forge (Core + Dev Skill Pack)</b></summary>