@mindrian_os/install 1.13.0-beta.11 → 1.13.0-beta.13

package/lib/memory/workflow-layer-e2e.test.cjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 122-05 -- workflow-layer end-to-end test (new suite; registered in the Feynman runner).
+ * =============================================================================================
+ * Walks the FULL chain frontmatter -> registry -> resolver -> composed chain,
+ * then runs the Canon Part 8 zero-Brain-mutation grep sweep:
+ *
+ *   Test 1 (frontmatter -> registry consistency):
+ *     spawnSync('node', ['scripts/build-command-registry.cjs', '--check']) -> status === 0
+ *     (the committed data/command-registry.json is in sync with commands/*.md frontmatter).
+ *
+ *   Test 2 (the spec's acceptance example):
+ *     composeWorkflow(["Beautiful Question Framework","Domain Selection","Jobs to Be Done (JTBD)"])
+ *       -> a 3-step array; each step 1-indexed, optional === false, command a non-null /mos:
+ *          string that exists in data/command-registry.json commands[].command.
+ *     (Shape + registered-ness asserted, not hardcoded slugs -- the 122-01 retrofit owns the
+ *      exact strings.)
+ *
+ *   Test 3 (the command-less degrade case):
+ *     composeWorkflow([<a framework with no command in the registry>])
+ *       -> [{step:1, framework:<that>, command:null, optional:true}].
+ *     The command-less framework is picked dynamically: a name in data/framework-names.json
+ *     that is NOT a key in framework_index (so it has no /mos: command). Falls back to
+ *     "Red Teaming" if the dynamic pick fails (Red Teaming is command-less in the retrofit).
+ *
+ *   Test 4 (the /mos:act --chain stop-point):
+ *     a workflow including a command whose registry entry has autonomous_safe: false
+ *     (dynamically: the first command of any framework whose first command is not
+ *      autonomous_safe -- in the retrofit, "Six Thinking Hats" -> /mos:hat-briefing)
+ *       -> validateChainAutonomy -> runnable === false AND blockers names that step.
+ *
+ *   Test 5 (Canon Part 8 grep sweep):
+ *     - for every .cjs under lib/brain/ and lib/workflow/: no line matches /mos:[a-z-]+ within
+ *       ~80 chars of a brain/query/fetch/http token;
+ *     - lib/workflow/command-resolver.cjs has no require(...brain-client...);
+ *     - scripts/build-command-registry.cjs has no write-Cypher (/CREATE |MERGE |SET |DELETE /i);
+ *     - grep -rE "Brain has Command|brain_proactive_command|FOLLOWS_FRAMEWORK.*Command|:Command"
+ *       skills/ agents/ references/ -> empty (no Command-node assertion left anywhere).
+ *
+ * Hermetic: zero network. The only Brain touch in the whole Workflow Layer is the build-time
+ * --refresh-names (not exercised here -- Test 1 runs --check, which regenerates from frontmatter
+ * against the committed allowlist and never queries the Brain).
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs TEST_FILES[] and tests/run-all-122.sh CJS_SUITES
+ * (as ../lib/memory/workflow-layer-e2e.test.cjs).
+ * Run: node lib/memory/workflow-layer-e2e.test.cjs
+ * Exit 0 on pass; throws (node:assert) on any fail.
+ *
+ * License: BSL 1.1.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const REGISTRY_PATH = path.join(REPO_ROOT, 'data', 'command-registry.json');
+const FW_NAMES_PATH = path.join(REPO_ROOT, 'data', 'framework-names.json');
+const BUILD_SCRIPT = path.join(REPO_ROOT, 'scripts', 'build-command-registry.cjs');
+
+const resolver = require('../workflow/command-resolver.cjs');
+
+const registry = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+const REGISTERED_COMMANDS = new Set((registry.commands || []).map(function (c) { return c && c.command; }));
+const COMMAND_BY_NAME = new Map((registry.commands || []).map(function (c) { return [c && c.command, c]; }));
+
+let passed = 0;
+function test(name, fn) {
+  fn();
+  passed += 1;
+  process.stdout.write('  ok  ' + name + '\n');
+}
+
+// ---------- helpers ----------
+
+function listCjsFilesUnder(relDir) {
+  const dir = path.join(REPO_ROOT, relDir);
+  const out = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_e) {
+    return out;
+  }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      out.push.apply(out, listCjsFilesUnder(path.join(relDir, e.name)));
+    } else if (e.isFile() && /\.cjs$/.test(e.name)) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+// True iff a /mos:<slug> literal appears within `window` chars of a
+// brain/query/fetch/http token on the same source (a heuristic for "a command
+// string in a Brain-query payload builder"). Test files are excluded -- they
+// legitimately mention /mos: literals near assertion text.
+function hasCommandNearBrainToken(src, window) {
+  const w = (typeof window === 'number' && window > 0) ? window : 80;
+  const re = /\/mos:[a-z][a-z0-9-]*/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const start = Math.max(0, m.index - w);
+    const end = Math.min(src.length, m.index + m[0].length + w);
+    const around = src.slice(start, end).toLowerCase();
+    if (/\b(brain|query|fetch|http)\b/.test(around)) return true;
+  }
+  return false;
+}
+
+// Recursively grep a directory for any line matching `re`. Returns [{file, line}].
+function grepDirForRegex(relDir, re) {
+  const dir = path.join(REPO_ROOT, relDir);
+  const hits = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_e) {
+    return hits;
+  }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      hits.push.apply(hits, grepDirForRegex(path.join(relDir, e.name), re));
+    } else if (e.isFile()) {
+      let src;
+      try { src = fs.readFileSync(p, 'utf8'); } catch (_e2) { continue; }
+      const lines = src.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i += 1) {
+        if (re.test(lines[i])) hits.push({ file: path.relative(REPO_ROOT, p), line: i + 1, text: lines[i].trim() });
+      }
+    }
+  }
+  return hits;
+}
+
+// ---------- Test 1: frontmatter -> registry consistency ----------
+
+test('build-command-registry.cjs --check exits 0 (the committed registry is in sync with commands/*.md frontmatter)', function () {
+  assert.ok(fs.existsSync(BUILD_SCRIPT), 'scripts/build-command-registry.cjs must exist');
+  const res = spawnSync(process.execPath, [BUILD_SCRIPT, '--check'], { cwd: REPO_ROOT, encoding: 'utf8' });
+  assert.equal(res.status, 0, 'build-command-registry.cjs --check should exit 0; stderr: ' + (res.stderr || '') + ' stdout: ' + (res.stdout || ''));
+});
+
+// ---------- Test 2: the spec's acceptance example ----------
+
+test('composeWorkflow(["Beautiful Question Framework","Domain Selection","Jobs to Be Done (JTBD)"]) -> a 3-step workflow, every command a registered /mos: string', function () {
+  const chain = ['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)'];
+  const wf = resolver.composeWorkflow(chain);
+  assert.ok(Array.isArray(wf), 'composeWorkflow must return an array');
+  assert.equal(wf.length, 3, 'the acceptance example is a 3-step workflow');
+  for (let i = 0; i < wf.length; i += 1) {
+    const s = wf[i];
+    assert.equal(s.step, i + 1, 'step ' + (i + 1) + ' must be 1-indexed in order');
+    assert.equal(s.framework, chain[i], 'step ' + (i + 1) + ' framework must match the input chain');
+    assert.equal(s.optional, false, 'step ' + (i + 1) + ' must not be optional (all three frameworks have a command)');
+    assert.equal(typeof s.command, 'string', 'step ' + (i + 1) + ' command must be a string');
+    assert.match(s.command, /^\/mos:[a-z][a-z0-9-]*$/, 'step ' + (i + 1) + ' command must be a /mos: slug');
+    assert.ok(REGISTERED_COMMANDS.has(s.command), 'step ' + (i + 1) + ' command ' + s.command + ' must exist in data/command-registry.json (no hallucinated command)');
+  }
+});
+
+// ---------- Test 3: the command-less degrade case ----------
+
+test('composeWorkflow([<a command-less framework>]) -> [{step:1, command:null, optional:true}] (degrade, do not fabricate)', function () {
+  // Pick a framework with no /mos: command dynamically: a name in
+  // data/framework-names.json that is NOT a key in framework_index. Fall back
+  // to "Red Teaming" if the dynamic pick somehow fails.
+  let commandless = 'Red Teaming';
+  try {
+    const fwNames = JSON.parse(fs.readFileSync(FW_NAMES_PATH, 'utf8'));
+    const names = Array.isArray(fwNames && fwNames.framework_names) ? fwNames.framework_names : [];
+    const idxKeys = new Set(Object.keys(registry.framework_index || {}));
+    const cand = names.find(function (n) { return !idxKeys.has(n) && resolver.commandsForFramework(n).length === 0; });
+    if (cand) commandless = cand;
+  } catch (_e) { /* keep the Red Teaming fallback */ }
+  assert.equal(resolver.commandsForFramework(commandless).length, 0, 'the chosen framework "' + commandless + '" must have no /mos: command');
+  const wf = resolver.composeWorkflow([commandless]);
+  assert.deepEqual(wf, [{ step: 1, framework: commandless, command: null, optional: true }],
+    'a command-less framework must yield exactly [{step:1, framework, command:null, optional:true}]');
+});
+
+// ---------- Test 4: the /mos:act --chain stop-point ----------
+
+test('validateChainAutonomy(a workflow including an autonomous_safe:false command) -> runnable false, the step is a blocker', function () {
+  // Pick a framework whose FIRST command (the one composeWorkflow picks) is
+  // autonomous_safe: false -- in the 122-01 retrofit that is "Six Thinking
+  // Hats" -> /mos:hat-briefing. Find it dynamically; fail loudly if none.
+  let blockedFramework = null;
+  let blockedCommand = null;
+  for (const [fw, cmds] of Object.entries(registry.framework_index || {})) {
+    if (Array.isArray(cmds) && cmds.length > 0) {
+      const c = COMMAND_BY_NAME.get(cmds[0]);
+      if (c && c.autonomous_safe === false) { blockedFramework = fw; blockedCommand = cmds[0]; break; }
+    }
+  }
+  assert.ok(blockedFramework, 'expected at least one framework whose first command is autonomous_safe:false (e.g. Six Thinking Hats -> /mos:hat-briefing)');
+  const wf = resolver.composeWorkflow([blockedFramework]);
+  assert.equal(wf.length, 1);
+  assert.equal(wf[0].command, blockedCommand);
+  const v = resolver.validateChainAutonomy(wf);
+  assert.equal(v.runnable, false, '/mos:act --chain must NOT be runnable when it includes a non-autonomous_safe command (' + blockedCommand + ')');
+  assert.ok(Array.isArray(v.blockers) && v.blockers.length >= 1, 'there must be at least one blocker');
+  assert.ok(v.blockers.some(function (b) { return b && b.command === blockedCommand && b.step === 1; }),
+    'the blocker list must name step 1 / ' + blockedCommand);
+  // Sanity: an all-autonomous_safe workflow is runnable.
+  const v2 = resolver.validateChainAutonomy([
+    { step: 1, framework: 'Beautiful Question Framework', command: '/mos:beautiful-question', optional: false },
+  ]);
+  // Only assert runnable if /mos:beautiful-question is autonomous_safe in the registry (it is, in the retrofit).
+  if ((COMMAND_BY_NAME.get('/mos:beautiful-question') || {}).autonomous_safe === true) {
+    assert.equal(v2.runnable, true, 'an all-autonomous_safe workflow must be runnable');
+    assert.deepEqual(v2.blockers, []);
+  }
+});
+
+// ---------- Test 5: Canon Part 8 grep sweep ----------
+
+test('Canon Part 8 grep sweep: no /mos: literal near a brain/query/fetch/http token in lib/brain/ or lib/workflow/ (non-test .cjs)', function () {
+  const files = listCjsFilesUnder('lib/brain').concat(listCjsFilesUnder('lib/workflow'));
+  assert.ok(files.length > 0, 'expected at least one .cjs under lib/brain/ + lib/workflow/');
+  for (const f of files) {
+    if (/\.test\.cjs$/.test(f)) continue; // test files legitimately mention /mos: near assertion prose
+    const src = fs.readFileSync(f, 'utf8');
+    assert.equal(hasCommandNearBrainToken(src, 80), false,
+      'a /mos: command literal appears within ~80 chars of a brain/query/fetch/http token in ' + path.relative(REPO_ROOT, f) + ' -- a Canon Part 8 breach signal');
+  }
+});
+
+test('Canon Part 8 grep sweep: lib/workflow/command-resolver.cjs does not require a brain client', function () {
+  const src = fs.readFileSync(path.join(REPO_ROOT, 'lib', 'workflow', 'command-resolver.cjs'), 'utf8');
+  assert.equal(/require\([^)]*brain-client[^)]*\)/.test(src), false, 'command-resolver.cjs must not require brain-client');
+  assert.equal(/require\([^)]*brain-ask[^)]*\)/.test(src), false, 'command-resolver.cjs must not require brain-ask');
+  assert.equal(/\bfetch\s*\(/.test(src), false, 'command-resolver.cjs must not call fetch()');
+  assert.equal(/require\(['"]node:https?['"]\)/.test(src), false, 'command-resolver.cjs must not require node:http(s)');
+});
+
+test('Canon Part 8 grep sweep: scripts/build-command-registry.cjs has no write-Cypher', function () {
+  const src = fs.readFileSync(BUILD_SCRIPT, 'utf8');
+  // Write-Cypher keywords as standalone tokens (avoid matching e.g. "settings" containing "SET").
+  assert.equal(/\b(CREATE|MERGE|SET|DELETE|DETACH)\s/i.test(src), false, 'build-command-registry.cjs must contain no write-Cypher');
+});
+
+test('Canon Part 8 grep sweep: no Command-node assertion left in skills/ agents/ references/', function () {
+  const re = /Brain has Command|brain_proactive_command|FOLLOWS_FRAMEWORK.*Command|:Command/;
+  const hits = grepDirForRegex('skills', re)
+    .concat(grepDirForRegex('agents', re))
+    .concat(grepDirForRegex('references', re));
+  assert.deepEqual(hits, [], 'no Command-node assertion may survive anywhere in skills/ agents/ references/; found: ' + JSON.stringify(hits, null, 2));
+});
+
+// ---------- summary ----------
+
+process.stdout.write('\nworkflow-layer-e2e.test.cjs: ' + passed + ' assertion groups PASSED\n');
+process.exit(0);

package/lib/workflow/ROOM.md

@@ -5,7 +5,7 @@ section: lib/workflow
 purpose: Workflow layer -- the framework <-> command registry resolver. The sole door from "framework" to "/mos: command".
 founding_phase: 122
 phase: 122
-milestone: v1.13.0-beta.11
+milestone: v1.13.0-beta.12
 canon_parts: [7, 8]
 created: 2026-05-12
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindrian_os/install",
-  "version": "1.13.0-beta.11",
+  "version": "1.13.0-beta.13",
   "description": "Install MindrianOS into Claude Code with one command -- `npx @mindrian_os/install`. Ships the MindrianOS plugin (Larry + PWS methodology + Data Room) plus a setup/diagnostics CLI (install/doctor/update).",
   "scripts": {
     "mcp": "node bin/mindrian-mcp-server.cjs",
@@ -37,6 +37,9 @@
     "markdown-it": "^14.1.0",
     "zod": "^3.25.76"
   },
+  "devDependencies": {
+    "semver": "^7.7.4"
+  },
   "engines": {
     "node": ">=22.5.0"
   },

package/references/brain/command-triggers-schema.md

@@ -1,226 +1,15 @@
-# Brain Command Trigger Schema
+# Brain Command Trigger Schema -- REMOVED (Phase 122, v1.13.0-beta)
 
-## Purpose
+This document used to describe a "commands are first-class Neo4j nodes with typed trigger relationships" design. That design was never built into the live Brain (no such label exists in the deployed graph), and it is a latent **Canon Part 8** breach in prose: it asserts that plugin commands live in the Brain. Per Canon Part 8 (`docs/MINDRIAN-CANON.md`), the Brain is a repository of strategic thinking tools, never a repository of plugin internals or user data. Commands never enter the Brain.
 
-Commands are first-class nodes in the Neo4j Brain. They have typed relationships to Frameworks, ProblemTypes, VentureStages, and Signals that define WHEN they should fire. The Brain doesn't just recommend frameworks -- it recommends ACTIONS mapped to specific /mos: commands with trigger conditions.
+## What replaced it
 
-## Node: Command
+The framework-to-command mapping is now plugin-local, generated, and CI-checked:
 
-```cypher
-CREATE (c:Command {
-  name: '/mos:find-analogies',
-  slug: 'find-analogies',
-  category: 'intelligence',          // infrastructure | methodology | intelligence | export | meeting | funding
-  description: 'Cross-domain analogy discovery via structural isomorphism',
-  jtbd_when: 'stuck on a problem that feels unique to your domain',
-  jtbd_want: 'discover that other industries already solved the same structural conflict',
-  jtbd_so: 'adapt their approach instead of inventing from scratch',
-  time_estimate: '5 minutes',
-  flags: ['--brain', '--external'],   // available flags
-  min_sections: 2,                    // minimum populated sections to be relevant
-  requires_brain: false,              // works without Brain (but better with)
-  powerhouse: true                    // v1.6.0+ feature
-})
-```
+- **Source of truth:** the `frameworks:` key in each `commands/*.md` frontmatter. Contract: `docs/COMMAND-FRONTMATTER.md`.
+- **Generated registry:** `data/command-registry.json` -- built from frontmatter by `scripts/build-command-registry.cjs`; never hand-edited; pre-commit + Feynman-runner tripwire on drift.
+- **The only door at runtime:** `lib/workflow/command-resolver.cjs` (`commandsForFramework`, `composeWorkflow`, `validateChainAutonomy`).
+- **The Brain side:** `lib/brain/chain-recommender.cjs` ranks WHICH frameworks to chain next via the Brain's `FEEDS_INTO` traversal -- framework names + problem-type enums only, never a command string, never user content.
+- **The full picture:** `docs/WORKFLOWS.md`.
 
-## Relationships
-
-### TRIGGERED_BY_SIGNAL
-
-Links a Command to the Room Signal types that should trigger it.
-
-```cypher
-// When a CONTRADICTS edge exists between sections -> suggest find-analogies
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:TRIGGERED_BY_SIGNAL {
-  signal_type: 'TENSION',            // TENSION | BLIND_SPOT | BOTTLENECK | PATTERN | SURPRISE
-  priority: 1,                        // 1=highest, 5=lowest
-  condition: 'contradicts_count >= 1',
-  jtbd_framing: 'When your Sections have unresolved Tensions, you want to see how other domains resolved the same structural conflict'
-}]->(sig:SignalType {name: 'TENSION'})
-
-// When 3+ sections have gaps -> suggest act --swarm
-CREATE (cmd:Command {name: '/mos:act --swarm'})-[:TRIGGERED_BY_SIGNAL {
-  signal_type: 'BLIND_SPOT',
-  priority: 1,
-  condition: 'gap_count >= 3',
-  jtbd_framing: 'When 3+ Sections have Blind Spots, you want to fill them all at once instead of one at a time'
-}]->(sig:SignalType {name: 'BLIND_SPOT'})
-
-// When reverse salients detected -> suggest specific methodology for lagging section
-CREATE (cmd:Command {name: '/mos:act'})-[:TRIGGERED_BY_SIGNAL {
-  signal_type: 'BOTTLENECK',
-  priority: 2,
-  condition: 'reverse_salient_count >= 1',
-  jtbd_framing: 'When a Section lags behind the others, you want to close the gap before it compounds'
-}]->(sig:SignalType {name: 'BOTTLENECK'})
-```
-
-### FOLLOWS_FRAMEWORK
-
-Links a Command to the Framework it should follow (chaining).
-
-```cypher
-// After JTBD analysis -> suggest Blue Ocean
-CREATE (cmd:Command {name: '/mos:dominant-designs'})-[:FOLLOWS_FRAMEWORK {
-  confidence: 0.85,
-  reason: 'JTBD reveals customer needs; dominant designs reveals competitive whitespace',
-  hop_distance: 1
-}]->(f:Framework {name: 'Jobs-to-Be-Done'})
-
-// After find-analogies -> suggest validate (stress-test the analogy)
-CREATE (cmd:Command {name: '/mos:validate'})-[:FOLLOWS_FRAMEWORK {
-  confidence: 0.90,
-  reason: 'Analogies must be stress-tested before acting on them',
-  hop_distance: 1
-}]->(f:Framework {name: 'Design-by-Analogy'})
-
-// After grade --full -> suggest act --swarm on weak sections
-CREATE (cmd:Command {name: '/mos:act --swarm'})-[:FOLLOWS_FRAMEWORK {
-  confidence: 0.80,
-  reason: 'Grading reveals gaps; swarm attacks them in parallel',
-  hop_distance: 1
-}]->(f:Framework {name: 'Assessment'})
-```
-
-### RELEVANT_AT_STAGE
-
-Links a Command to VentureStages where it's most impactful.
-
-```cypher
-// find-analogies is most powerful at Discovery and Design stages
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:RELEVANT_AT_STAGE {
-  impact: 'high',
-  reason: 'Discovery needs fresh perspectives; Design needs proven patterns'
-}]->(stage:VentureStage {name: 'Discovery'})
-
-// grade --full becomes critical at Investment stage
-CREATE (cmd:Command {name: '/mos:grade --full'})-[:RELEVANT_AT_STAGE {
-  impact: 'critical',
-  reason: 'Investment stage demands rigor across every Section'
-}]->(stage:VentureStage {name: 'Investment'})
-
-// scout is always relevant but especially at Validation
-CREATE (cmd:Command {name: '/mos:scout'})-[:RELEVANT_AT_STAGE {
-  impact: 'high',
-  reason: 'Validation stage has deadlines and competitor dynamics'
-}]->(stage:VentureStage {name: 'Validation'})
-```
-
-### ADDRESSES_PROBLEM_TYPE
-
-Links a Command to ProblemTypes it solves (via multi-hop through Frameworks).
-
-```cypher
-// find-analogies addresses wicked problems (via Design-by-Analogy framework)
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:ADDRESSES_PROBLEM_TYPE {
-  via_framework: 'Design-by-Analogy',
-  effectiveness: 0.85
-}]->(pt:ProblemType {name: 'wicked'})
-
-// act --swarm addresses complex problems with multiple dimensions
-CREATE (cmd:Command {name: '/mos:act --swarm'})-[:ADDRESSES_PROBLEM_TYPE {
-  via_framework: 'Multiple simultaneous frameworks',
-  effectiveness: 0.90
-}]->(pt:ProblemType {name: 'ill-defined-complex'})
-```
-
-### RESOLVES_TENSION_BETWEEN
-
-Links a Command to Framework pairs that commonly produce contradictions.
-
-```cypher
-// find-analogies resolves tensions between pricing frameworks and competitive positioning
-CREATE (cmd:Command {name: '/mos:find-analogies'})-[:RESOLVES_TENSION_BETWEEN {
-  framework_a: 'Lean Canvas',
-  framework_b: 'Competitive Analysis',
-  resolution_pattern: 'Cross-domain structural isomorphism finds how other industries resolved pricing vs positioning'
-}]->(tension:TensionType {name: 'pricing_vs_positioning'})
-```
-
-## Multi-Hop Proactive Query
-
-The power of this schema is MULTI-HOP reasoning. The Brain can traverse:
-
-```
-User's Room State
-  -> Current Frameworks (from Room artifacts)
-    -> FEEDS_INTO relationships (what comes next)
-      -> Command nodes (which /mos: command delivers it)
-        -> TRIGGERED_BY_SIGNAL (is the trigger condition met?)
-          -> Return ranked command suggestion with full JTBD framing
-```
-
-### Query: brain_proactive_command (Pattern 10d)
-
-```cypher
-// Multi-hop: Room frameworks -> next framework -> command -> trigger check
-MATCH (current:Framework)<-[:FOLLOWS_FRAMEWORK]-(cmd:Command)
-WHERE current.name IN $room_frameworks
-
-// Check if command is relevant at this venture stage
-OPTIONAL MATCH (cmd)-[stage_rel:RELEVANT_AT_STAGE]->(stage:VentureStage {name: $venture_stage})
-
-// Check if command is triggered by current signals
-OPTIONAL MATCH (cmd)-[trigger:TRIGGERED_BY_SIGNAL]->(sig:SignalType)
-
-// Get success data
-OPTIONAL MATCH (current)-[:APPLIED_IN]->(example:Example)
-WHERE example.grade_numeric >= 80
-
-RETURN cmd.name AS command,
-       cmd.jtbd_when AS when_situation,
-       cmd.jtbd_want AS want_motivation,
-       cmd.jtbd_so AS so_outcome,
-       cmd.time_estimate AS time,
-       cmd.flags AS available_flags,
-       stage_rel.impact AS stage_impact,
-       trigger.signal_type AS triggered_by,
-       trigger.condition AS trigger_condition,
-       trigger.jtbd_framing AS trigger_framing,
-       count(example) AS success_count
-ORDER BY stage_rel.impact DESC, trigger.priority ASC, success_count DESC
-LIMIT 5
-```
-
-**Parameters:**
-- `$room_frameworks` -- frameworks used in Room (from artifact frontmatter)
-- `$venture_stage` -- from STATE.md
-
-**Output:** Ranked command suggestions with full JTBD framing, trigger conditions, and success data from real projects.
-
-## Seeding Script
-
-The Command nodes and trigger relationships need to be seeded into Neo4j. Create a script that:
-
-1. Reads all commands/*.md files
-2. Extracts: name, description, allowed-tools, category
-3. Generates JTBD statements from the command's purpose
-4. Creates Command nodes with relationships to:
-   - Frameworks they follow (from methodology chaining rules)
-   - VentureStages they're relevant at (from problem-types.md)
-   - SignalTypes that trigger them (from proactive-intelligence patterns)
-5. Runs the Cypher via `mcp__neo4j-brain__write_neo4j_cypher`
-
-Script location: `scripts/seed-brain-commands.cjs`
-
-## The Intelligence Hierarchy (Updated)
-
-```
-LEVEL 3 (Brain + Room + Signals):
-  brain_proactive_command (Pattern 10d)
-  Multi-hop: frameworks -> commands -> triggers -> JTBD
-  Calibrated from 100+ real projects
-  Knows which sequences ACTUALLY produced results
-
-LEVEL 2 (Room + Local Fabric):
-  Larry's JTBD provoked suggestions (every 3-7 turns)
-  KuzuDB Tensions, Bottlenecks, Surprises, Convergences
-  Good but not cross-venture calibrated
-
-LEVEL 1 (No Room):
-  Generic stage-based defaults
-  methodology/index.md routing table
-  Better than nothing
-```
-
-Brain-connected users get LEVEL 3: the Brain literally tells Larry which command to suggest, when, and why -- backed by data from 100+ real ventures. The JTBD framing is baked into the Command node itself. Larry just reads it and presents it naturally.
+Trigger conditions (which signal surfaces which next step) live in the navigation engine (Phase 91 family) and the cascade hooks (Phase 116/117) -- locally, where the room state is, not in the Brain.

package/references/methodology/index.md

@@ -1,81 +1,24 @@
-# Methodology Index -- Command Routing Reference
+# Methodology Index -- Pointer
 
-*All MindrianOS methodology commands. Used for progressive disclosure and framework routing.*
+> Phase 122 (Workflow Layer) replaced the hand-maintained framework-to-command routing table that used to live here. That table drifted (it is the exact drift class the Workflow Layer was built to delete). The authoritative mapping is now generated, CI-checked, and resolved at runtime through one door.
 
 ---
 
-## Infrastructure Commands
+## Where the framework-to-command mapping lives now
 
-| Command | Description | Default Room |
-|---------|-------------|--------------|
-| `/mos:new-project` | Start a new venture project -- Larry explores your idea and creates your Data Room | (creates all rooms) |
-| `/mos:help` | Larry recommends 2-3 relevant commands based on your room state | (none) |
-| `/mos:status` | Room overview, venture stage, gaps, suggested next action | (none) |
-| `/mos:room` | View, add, or export Data Room sections | (none) |
+- **Source of truth:** the `frameworks:` key in each `commands/*.md` frontmatter (one place, nothing else asserts it). Contract: `docs/COMMAND-FRONTMATTER.md`.
+- **Generated registry:** `data/command-registry.json` -- built from that frontmatter by `scripts/build-command-registry.cjs`; never hand-edited. A pre-commit tripwire (`build-command-registry.cjs --check`) and the Feynman test runner fail the build on a stale registry or an unresolvable framework name.
+- **The only door at runtime:** `lib/workflow/command-resolver.cjs` (`commandsForFramework(<framework>)`, `composeWorkflow(<framework-chain>)`, `validateChainAutonomy(...)`). Larry never names a `/mos:` command from memory -- every command he surfaces came back from the resolver. If a framework has no command yet, the resolver returns `null` and the answer is "run it manually" (degrade, do not fabricate).
+- **The Brain side:** `lib/brain/chain-recommender.cjs` ranks WHICH frameworks to chain next via the Brain's `FEEDS_INTO` traversal -- framework names + problem-type enums only. Turning a recommended framework into a `/mos:` command is the resolver's job, not the Brain's. Commands NEVER enter the Brain (Canon Part 8). See `docs/WORKFLOWS.md` for the full Brain <-> registry <-> Larry join.
 
----
-
-## Methodology Commands (26)
-
-| Command | Description | Default Room |
-|---------|-------------|--------------|
-| `/mos:beautiful-question` | Reframe your challenge into a question worth answering -- Why / What If / How | problem-definition |
-| `/mos:map-unknowns` | Map what you know, don't know, and can't see -- Known/Unknown Matrix | problem-definition |
-| `/mos:challenge-assumptions` | Stress-test your assumptions before the market does -- Devil's Advocate | competitive-analysis |
-| `/mos:analyze-systems` | Decompose complex systems into layers -- find where leverage lives | solution-design |
-| `/mos:leadership` | Leadership coaching -- what kind of leader does your team actually need? | team-execution |
-| `/mos:lean-canvas` | Build your business model on one page -- 9 boxes, no fluff | business-model |
-| `/mos:systems-thinking` | See feedback loops, stocks, flows, and leverage points in your system | solution-design |
-| `/mos:explore-domains` | Map the innovation domains around your venture -- find where fields collide | problem-definition |
-| `/mos:structure-argument` | Build a Minto Pyramid -- structure your thinking top-down | problem-definition |
-| `/mos:think-hats` | Six Thinking Hats -- explore your problem from 6 perspectives | solution-design |
-| `/mos:analyze-needs` | Jobs to Be Done -- discover what progress your customers hire for | market-analysis |
-| `/mos:find-bottlenecks` | Reverse Salient -- find the bottleneck holding your system back | solution-design |
-| `/mos:build-thesis` | Build an investment thesis -- structure your venture's narrative | financial-model |
-| `/mos:grade` | Assess your progress -- get honest feedback on your venture thinking | (all rooms) |
-| `/mos:explore-trends` | Trending to the Absurd -- push current trends to their logical extreme | market-analysis |
-| `/mos:analyze-timing` | S-Curve analysis -- is the technology ready? Is the market ready? | market-analysis |
-| `/mos:scenario-plan` | Map plausible futures and prepare for each | market-analysis |
-| `/mos:validate` | Check claims against evidence -- Validation Compass | competitive-analysis |
-| `/mos:build-knowledge` | Ackoff's Pyramid -- climb from data to wisdom | problem-definition |
-| `/mos:explore-futures` | Oracle -- explore long-range futures and weak signals | market-analysis |
-| `/mos:root-cause` | Trace problems to their source -- 5 Whys, Fishbone, and more | problem-definition |
-| `/mos:macro-trends` | Identify large-scale shifts affecting your domain | market-analysis |
-| `/mos:dominant-designs` | Analyze convergence patterns in your market | competitive-analysis |
-| `/mos:user-needs` | Deep dive into user behavior and motivation | market-analysis |
-| `/mos:score-innovation` | HSI scoring -- cross-domain innovation opportunity assessment | (all rooms) |
-| `/mos:diagnose` | Problem type classification + framework recommendation | (none) |
-
----
-
-## Venture Stage Routing
-
-| Venture Stage | Recommended Commands |
-|---------------|---------------------|
-| **Pre-Opportunity** | new-project, beautiful-question, explore-domains, explore-trends, map-unknowns |
-| **Discovery** | analyze-needs, challenge-assumptions, explore-domains, structure-argument, build-knowledge |
-| **Validation** | validate, find-bottlenecks, analyze-timing, map-unknowns, challenge-assumptions |
-| **Design** | think-hats, structure-argument, scenario-plan, analyze-systems, systems-thinking, lean-canvas |
-| **Investment** | build-thesis, grade, root-cause, build-knowledge, score-innovation |
-
----
-
-## Brain-Powered Commands (5)
-
-*Require Brain MCP connection. Run `/mos:setup brain` to enable.*
-
-| Command | Description | Default Room |
-|---------|-------------|--------------|
-| `/mos:suggest-next` | Graph-informed recommendation -- what should you work on next? (Requires Brain) | (none) |
-| `/mos:find-connections` | Cross-domain pattern discovery -- what connects to your work? (Requires Brain) | (none) |
-| `/mos:compare-ventures` | Who else did something like this -- and what happened? (Requires Brain) | (none) |
-| `/mos:deep-grade` | Calibrated venture assessment -- scored against 100+ real projects (Requires Brain) | competitive-analysis |
-| `/mos:research` | External web research with Brain cross-reference -- find evidence for your venture (Requires Brain) | market-analysis |
+For a human-readable list of commands with descriptions, see `commands/help.md` (the `/mos:help` surface) or `docs/COMMAND-FRONTMATTER.md`. For the closed-loop picture, see `docs/WORKFLOWS.md`.
 
 ---
 
 ## Design-by-Analogy Reference Files
 
+These are reference *data* files (not a framework-to-command map), loaded on demand by the Design-by-Analogy pipeline:
+
 | File | Description |
 |------|-------------|
 | `triz-matrix.json` | 39x39 TRIZ contradiction matrix mapping engineering parameter pairs to inventive principles |
@@ -88,10 +31,4 @@ Used by the Design-by-Analogy pipeline (`/mos:find-analogies`) and `enrichContra
 
 ## Brain Enhancement
 
-When Brain MCP is connected, methodology commands gain:
-- Contextual framework chaining (Brain recommends the perfect next framework)
-- Calibrated grading (100+ real student projects)
-- Cross-domain pattern matching (21K+ knowledge graph nodes)
-- Framework sequencing based on your specific room state
-
-Without Brain, all commands work using embedded reference definitions.
+When Brain MCP is connected, methodology commands gain contextual framework chaining (the Brain ranks the next framework via `FEEDS_INTO`), calibrated grading (100+ real student projects), and cross-domain pattern matching (21K+ knowledge graph nodes). Without Brain, all commands work using embedded reference definitions. Either way, the framework-to-command mapping comes from the plugin-local `data/command-registry.json` via `lib/workflow/command-resolver.cjs` -- not from the Brain, not from memory.