mindforge-cc 11.6.0 → 11.7.1

package/RELEASENOTES.md

@@ -1,5 +1,59 @@
 # Release Notes
 
+## v11.7.0 — Workflow Forge
+
+**Release Date**: 2026-06-23
+**Type**: Minor — new dynamic workflow library, no breaking changes
+**Upgrade Path**: `npx mindforge-cc@latest`
+
+---
+
+The first Dynamic Workflow Library for MindForge. Twelve pre-built multi-agent workflow scripts ship in the npm package and are immediately available to any user who installs MindForge. Each workflow runs via Claude Code's native `Workflow` tool for true parallel agent execution.
+
+### Dynamic Workflow Library
+
+12 workflows across 4 tiers, each backed by a full JS orchestration script in `.mindforge/dynamic-workflows/scripts/`:
+
+**Research tier** — fan-out parallel searches, adversarial claim verification, cited synthesis:
+- `deep-research` — Decompose → 5× parallel web search → fetch 15 sources → 3-vote verify → synthesize cited report
+- `competitive-analysis` — 5× angles (product/pricing/reviews/community/roadmap) → SWOT → positioning
+- `tech-evaluation` — 5× dimensions (DX/perf/security/ecosystem/community) → scored matrix → recommendation
+
+**Dev tier** — coding-assistant power workflows:
+- `code-audit` — 3× parallel auditors (security/quality/perf) → adversarial verify high-severity findings → risk report
+- `feature-planner` — Brief → PRD → Architecture → User stories (sequential pipeline)
+- `pr-review` — 4× parallel reviewers (correctness/security/perf/style) → consensus verdict
+- `tdd-sprint` — Spec → RED (failing test) → GREEN (minimal impl) → REFACTOR (clean up) loop
+- `refactor-plan` — Debt scan → risk-sort → sequence → safe implementation plan
+
+**Ops tier**:
+- `incident-response` — 4× parallel investigation (logs/metrics/traces/code) → mitigate → RCA → postmortem
+- `release-prep` — Tests → changelog → semver bump → PR body → announcement draft
+
+**Intelligence tier**:
+- `onboard-codebase` — Map → domain analysis → architecture → guided tour + onboarding docs
+- `perf-optimize` — Profile → 4× parallel bottleneck hunt (DB/network/CPU/memory) → prioritized fix plan → benchmarks
+
+### 13 new commands
+
+`/mindforge:wf-catalog` — browseable index of all 12 workflows grouped by tier
+`/mindforge:wf-<name>` — one command per workflow, each with usage and phase descriptions
+
+### CLI discovery
+
+```bash
+node bin/mindforge-cli.js workflow list          # print catalog
+node bin/mindforge-cli.js workflow info <name>   # show phases and description
+```
+
+### Upgrade steps
+
+1. `npx mindforge-cc@latest` — all 12 workflows and 13 commands install automatically
+2. Run `/mindforge:wf-catalog` to browse the library
+3. Try `/mindforge:wf-deep-research <your question>` for a first run
+
+---
+
 ## v11.6.0 — Skill Forge
 
 **Release Date**: 2026-06-17

package/bin/installer-core.js

@@ -527,9 +527,13 @@ async function install(runtime, scope, options = {}) {
   ];
 
   if (runtime === 'claude') {
-    // Claude Code specifically looks in .claude/commands/mindforge
+    // Claude Code looks in .claude/commands/mindforge. Use .agent/mindforge as the
+    // canonical source — it is always committed, while .claude/ is gitignored. The
+    // previous behaviour of reading from .claude/commands/mindforge/ (itself gitignored)
+    // left CI with an empty command set on a fresh checkout.
     cmdSources.length = 0;
-    cmdSources.push({ src: src('.claude', 'commands', 'mindforge'), namespace: 'mindforge' });
+    cmdSources.push({ src: src('.agent', 'mindforge'), namespace: 'mindforge' });
+    cmdSources.push({ src: src('.agent', 'forge'),     namespace: 'forge' });
   }
 
   let totalCount = 0;

package/bin/mindforge-cli.js

@@ -140,6 +140,13 @@ const COMMANDS = {
   }
 };
 
+// ── Workflow subcommand (non-script, handled inline) ─────────────────────────
+if (COMMAND === 'workflow') {
+  const workflowRunner = require('./workflows/workflow-runner');
+  workflowRunner.run(COMMAND_ARGS[0], COMMAND_ARGS.slice(1));
+  process.exit(0);
+}
+
 if (!COMMAND || ARGS.includes('--help') || ARGS.includes('-h')) {
   printUsage();
   process.exit(0);

package/bin/parse-workflow-args.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * parseWorkflowArgs — Slash-command argument splitter
+ *
+ * Parses a /mindforge:wf-<name> [args...] slash command string into a
+ * structured object containing the bare workflow name and the trimmed argument
+ * text.
+ *
+ * Format:  /mindforge:wf-<workflowName>[ <args>]
+ * Example: /mindforge:wf-deep-research What is the future of AI?
+ *          -> { workflowName: 'deep-research', args: 'What is the future of AI?' }
+ */
+
+/** Matches /mindforge:wf-<name> with an optional trailing argument block. */
+const SLASH_COMMAND_PATTERN = /^\/mindforge:wf-([\w-]+)(?:\s+([\s\S]*))?$/;
+
+/**
+ * Split a /mindforge:wf-* slash command into workflowName and args.
+ *
+ * @param {string} input  Raw slash command string from user input.
+ * @returns {{ workflowName: string, args: string }}
+ * @throws {TypeError}   When input is not a string.
+ * @throws {RangeError}  When input does not match the /mindforge:wf-* format.
+ */
+function parseWorkflowArgs(input) {
+  if (typeof input !== 'string') {
+    throw new TypeError(`parseWorkflowArgs: expected a string, received ${typeof input}`);
+  }
+
+  const match = SLASH_COMMAND_PATTERN.exec(input);
+
+  if (match === null) {
+    throw new RangeError(
+      `parseWorkflowArgs: input does not match /mindforge:wf-<name> format — got: "${input}"`
+    );
+  }
+
+  const [, workflowName, rawArgs = ''] = match;
+
+  return {
+    workflowName,
+    args: rawArgs.trim(),
+  };
+}
+
+module.exports = { parseWorkflowArgs };

package/bin/workflows/workflow-runner.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const REGISTRY_PATH = path.join(ROOT, '.mindforge', 'dynamic-workflows', 'index.json');
+
+function loadRegistry() {
+  if (!fs.existsSync(REGISTRY_PATH)) {
+    console.error('Workflow registry not found. Run `npx mindforge-cc@latest` to reinstall.');
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+}
+
+function cmdList() {
+  const workflows = loadRegistry();
+  const tiers = ['research', 'dev', 'ops', 'intelligence'];
+  const byTier = {};
+  for (const wf of workflows) {
+    (byTier[wf.tier] = byTier[wf.tier] || []).push(wf);
+  }
+
+  console.log('\nMindForge Dynamic Workflow Library\n');
+  for (const tier of tiers) {
+    if (!byTier[tier]) continue;
+    console.log(`  ${tier.toUpperCase()} TIER`);
+    for (const wf of byTier[tier]) {
+      console.log(`    ${wf.command.padEnd(40)} ${wf.description}`);
+    }
+    console.log('');
+  }
+  console.log(`  Total: ${workflows.length} workflows`);
+  console.log('  Run `node bin/mindforge-cli.js workflow info <name>` for details.\n');
+}
+
+function cmdInfo(name) {
+  if (!name) {
+    console.error('Usage: workflow info <name>');
+    process.exit(1);
+  }
+  const workflows = loadRegistry();
+  const wf = workflows.find(w => w.name === name);
+  if (!wf) {
+    console.error(`Workflow not found: ${name}`);
+    console.error(`Available: ${workflows.map(w => w.name).join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`\n${wf.name}`);
+  console.log(`  Command:    ${wf.command}`);
+  console.log(`  Tier:       ${wf.tier}`);
+  console.log(`  Description: ${wf.description}`);
+  console.log(`  When to use: ${wf.whenToUse}`);
+  console.log(`  Script:     ${wf.scriptPath}`);
+  console.log('  Phases:');
+  for (const p of wf.phases) {
+    console.log(`    ${p.title.padEnd(16)} ${p.detail}`);
+  }
+  console.log('');
+}
+
+function cmdRun(name, args) {
+  if (!name) {
+    console.error('Usage: workflow run <name> [args...]');
+    process.exit(1);
+  }
+  const workflows = loadRegistry();
+  const wf = workflows.find(w => w.name === name);
+  if (!wf) {
+    console.error(`Workflow not found: ${name}`);
+    process.exit(1);
+  }
+
+  const scriptPath = path.join(ROOT, wf.scriptPath);
+  if (!fs.existsSync(scriptPath)) {
+    console.error(`Workflow script not found: ${scriptPath}`);
+    process.exit(1);
+  }
+
+  const argsStr = args.join(' ');
+  console.log(`\nTo run the "${name}" workflow in Claude Code:`);
+  console.log('\nInvoke via the Workflow tool with:');
+  console.log(`  scriptPath: "${wf.scriptPath}"`);
+  console.log(`  args: "${argsStr}"`);
+  console.log(`\nOr use the command: ${wf.command} ${argsStr}`);
+  console.log('\nThe Workflow tool runs in Claude Code\'s native multi-agent environment.');
+  console.log('Phases: ' + wf.phases.map(p => p.title).join(' -> ') + '\n');
+}
+
+function run(subcommand, args) {
+  switch (subcommand) {
+  case 'list':
+    cmdList();
+    break;
+  case 'info':
+    cmdInfo(args[0]);
+    break;
+  case 'run':
+    cmdRun(args[0], args.slice(1));
+    break;
+  default:
+    console.error(`Unknown workflow subcommand: ${subcommand || '(none)'}`);
+    console.error('Usage: workflow <list|info|run> [args]');
+    process.exit(1);
+  }
+}
+
+module.exports = { run };

package/docs/commands-reference.md

@@ -194,4 +194,29 @@ mindforge <command> [options]
 | `tokens` | Analyze token consumption and cost efficiency |
 | `learning` | Consult or initialize the project agentic learning memory |
 | `record-learning` | Append a new Learning Entry to the Evolution Log |
+| `workflow list` | List all available dynamic workflows with descriptions |
+| `workflow info <name>` | Show phases and metadata for a specific workflow |
+| `workflow run <name> [args]` | Display invocation instructions for a workflow |
+
+---
+
+## 🚀 Dynamic Workflow Library
+
+Pre-built multi-agent workflow scripts triggered via `/mindforge:wf-*` commands. Each runs via Claude Code's `Workflow` tool with true parallel agent execution.
+
+| Command | Tier | Description |
+| :--- | :--- | :--- |
+| `/mindforge:wf-catalog` | — | Browse all 12 workflows grouped by tier |
+| `/mindforge:wf-deep-research` | research | Fan-out web research → adversarial verify → cited report |
+| `/mindforge:wf-competitive-analysis` | research | 5× parallel angles → SWOT → positioning |
+| `/mindforge:wf-tech-evaluation` | research | 5× dimensions → scored matrix → recommendation |
+| `/mindforge:wf-code-audit` | dev | 3× parallel auditors → verified findings → risk report |
+| `/mindforge:wf-feature-planner` | dev | Brief → PRD → architecture → user stories pipeline |
+| `/mindforge:wf-pr-review` | dev | 4× parallel reviewers → consensus verdict |
+| `/mindforge:wf-tdd-sprint` | dev | Spec → RED → GREEN → REFACTOR loop |
+| `/mindforge:wf-refactor-plan` | dev | Debt scan → risk-sort → safe sequence → plan |
+| `/mindforge:wf-incident-response` | ops | 4× parallel investigation → mitigate → RCA → postmortem |
+| `/mindforge:wf-release-prep` | ops | Tests → changelog → version bump → PR → announcement |
+| `/mindforge:wf-onboard-codebase` | intelligence | Map → domain → architecture → guided tour |
+| `/mindforge:wf-perf-optimize` | intelligence | Profile → 4× bottleneck hunt → prioritized fix plan |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindforge-cc",
-  "version": "11.6.0",
+  "version": "11.7.1",
   "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",
@@ -23,6 +23,7 @@
     ".mindforge/schemas/",
     ".mindforge/personas/",
     ".mindforge/skills/",
+    ".mindforge/dynamic-workflows/",
     ".mindforge/governance/",
     ".mindforge/integrations/",
     ".mindforge/intelligence/",