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

package/lib/memory/navigation-hook-resolver.test.cjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 122-04 -- navigation-hook-resolver tests (new suite; registered in the Feynman runner).
+ * ============================================================================================
+ * Asserts the ONE surgical edit in lib/core/framework-chain-composer.cjs:
+ * proposeNextFramework() now resolves the next framework's /mos: command via
+ * lib/workflow/command-resolver.cjs commandsForFramework() (the only door),
+ * degrades to command:null when the registry has no command for it (degrade,
+ * do not fabricate -- WORKFLOW-LAYER-SPEC reliability rule 5), and carries a
+ * workflow array (the resolver's composeWorkflow for the multi-hop chain) as
+ * data on the proposal. mapFrameworkToCommandSlug() delegates to the resolver.
+ * The navigation engine / offer presenter / hooks are NOT touched.
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs TEST_FILES[] and in
+ * tests/run-all-122.sh CJS_SUITES (as ../lib/memory/navigation-hook-resolver.test.cjs).
+ * Run: node lib/memory/navigation-hook-resolver.test.cjs
+ * Exit 0 on pass; throws (node:assert) on any fail.
+ *
+ * Assertion groups:
+ *   1. framework-chain-composer.cjs source requires ../workflow/command-resolver
+ *      (the surgical edit is in place) and references composeWorkflow.
+ *   2. proposeNextFramework(completed, edges).command === commandsForFramework(next)[0]
+ *      (or null when there is none). Tested on a registered next framework
+ *      (Business Model Canvas -> Lean Canvas -> /mos:lean-canvas) and an
+ *      unregistered one (X -> A Wholly Imaginary Framework -> null).
+ *   3. proposeNextFramework returns a workflow array shaped like composeWorkflow
+ *      ([{ step, framework, command|null, optional }], 1-indexed, in order),
+ *      and for a multi-hop FEEDS_INTO chain it includes the successors.
+ *   4. mapFrameworkToCommandSlug delegates to the resolver (a registered
+ *      framework slug round-trips), falls back to the legacy table for an
+ *      unknown name, and stays exported alongside FRAMEWORK_TO_COMMAND_SLUG
+ *      and KNOWN_FRAMEWORKS (122-05 prunes the legacy table, not this plan).
+ *   5. The engine / presenter / hooks are NOT touched: framework-chain-composer.cjs
+ *      is the only file that gained the resolver require (we assert the
+ *      navigation-engine source did NOT gain a command-resolver require).
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const COMPOSER_PATH = path.join(REPO_ROOT, 'lib', 'core', 'framework-chain-composer.cjs');
+const ENGINE_PATH = path.join(REPO_ROOT, 'lib', 'core', 'navigation-engine.cjs');
+
+const composer = require('../core/framework-chain-composer.cjs');
+const resolver = require('../workflow/command-resolver.cjs');
+
+let passed = 0;
+function test(name, fn) {
+  fn();
+  process.stdout.write('  ok  ' + name + '\n');
+  passed += 1;
+}
+
+// ---------------------------------------------------------------------------
+// 1. the surgical edit is in place (source requires the resolver)
+// ---------------------------------------------------------------------------
+test('framework-chain-composer.cjs requires ../workflow/command-resolver and references composeWorkflow', function () {
+  const src = fs.readFileSync(COMPOSER_PATH, 'utf8');
+  assert.ok(/require\(['"]\.\.\/workflow\/command-resolver(\.cjs)?['"]\)/.test(src),
+    'framework-chain-composer.cjs must require ../workflow/command-resolver');
+  assert.ok(/command-resolver/.test(src), 'source mentions command-resolver');
+  assert.ok(/composeWorkflow/.test(src), 'source mentions composeWorkflow (the multi-step path)');
+});
+
+// ---------------------------------------------------------------------------
+// 2. proposeNextFramework.command === resolver answer (or null)
+// ---------------------------------------------------------------------------
+test('proposeNextFramework.command === commandsForFramework(next)[0] (or null when there is none)', function () {
+  // Registered next framework: Lean Canvas -> /mos:lean-canvas.
+  const registeredEdges = [
+    { from: 'Business Model Canvas', to: 'Lean Canvas', confidence: 0.85, phase_indicator: 'thesis' },
+  ];
+  const p = composer.proposeNextFramework('Business Model Canvas', registeredEdges);
+  assert.ok(p !== null, 'a 0.85-confidence edge yields a proposal');
+  const expected = resolver.commandsForFramework('Lean Canvas');
+  assert.strictEqual(p.command, expected.length > 0 ? expected[0] : null,
+    'command must equal commandsForFramework(next)[0]; got: ' + p.command);
+  assert.ok(typeof p.command === 'string' && p.command.indexOf('/mos:') === 0,
+    'Lean Canvas IS registered, so command must be a /mos: string; got: ' + p.command);
+
+  // Unregistered next framework -> command is null (degrade, not fabricate).
+  const unregEdges = [
+    { from: 'X', to: 'A Wholly Imaginary Framework', confidence: 0.8, phase_indicator: null },
+  ];
+  const u = composer.proposeNextFramework('X', unregEdges);
+  assert.ok(u !== null, 'a 0.8-confidence edge yields a proposal even when the next has no command');
+  assert.strictEqual(u.command, null, 'unregistered next framework -> command:null; got: ' + u.command);
+  // It still matches the resolver: commandsForFramework returns [] for it.
+  assert.deepStrictEqual(resolver.commandsForFramework('A Wholly Imaginary Framework'), []);
+});
+
+// ---------------------------------------------------------------------------
+// 3. proposeNextFramework.workflow is a composeWorkflow-shaped array
+// ---------------------------------------------------------------------------
+test('proposeNextFramework.workflow is a composeWorkflow array; a multi-hop chain includes the successors', function () {
+  // Single hop: workflow = composeWorkflow([completed, next]).
+  const single = composer.proposeNextFramework('Business Model Canvas', [
+    { from: 'Business Model Canvas', to: 'Lean Canvas', confidence: 0.85, phase_indicator: null },
+  ]);
+  assert.ok(Array.isArray(single.workflow), 'workflow is an array');
+  assert.ok(single.workflow.length >= 2, 'workflow includes [completed, next]');
+  single.workflow.forEach(function (s, i) {
+    assert.strictEqual(s.step, i + 1, 'workflow is 1-indexed and in order');
+    assert.ok('framework' in s && 'command' in s && 'optional' in s, 'workflow step shape');
+    assert.ok(s.command === null || (typeof s.command === 'string' && s.command.indexOf('/mos:') === 0),
+      'workflow step command is a /mos: string or null');
+  });
+  assert.strictEqual(single.workflow[0].framework, 'Business Model Canvas');
+  assert.strictEqual(single.workflow[1].framework, 'Lean Canvas');
+
+  // Multi-hop FEEDS_INTO: BQ -> Domain Selection -> JTBD. The workflow walks
+  // the highest-confidence chain and composeWorkflow attaches the commands.
+  const multi = composer.proposeNextFramework('Beautiful Question Framework', [
+    { from: 'Beautiful Question Framework', to: 'Domain Selection', confidence: 0.9, phase_indicator: null },
+    { from: 'Domain Selection', to: 'Jobs to Be Done (JTBD)', confidence: 0.85, phase_indicator: null },
+    { from: 'Jobs to Be Done (JTBD)', to: 'PWS Value Proposition', confidence: 0.8, phase_indicator: null },
+  ]);
+  assert.ok(Array.isArray(multi.workflow));
+  // [completed, +3 hops] -> 4 steps (collectForwardChain caps at 3 hops).
+  assert.strictEqual(multi.workflow.length, 4, 'workflow includes the 3-hop chain; got ' + multi.workflow.length);
+  assert.deepStrictEqual(multi.workflow.map(function (s) { return s.framework; }),
+    ['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)', 'PWS Value Proposition']);
+  // And the workflow equals what the resolver would compose for that chain.
+  assert.deepStrictEqual(multi.workflow,
+    resolver.composeWorkflow(['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)', 'PWS Value Proposition']));
+
+  // composer.collectForwardChain is also directly exercisable.
+  assert.deepStrictEqual(
+    composer.collectForwardChain('Beautiful Question Framework', [
+      { from: 'Beautiful Question Framework', to: 'Domain Selection', confidence: 0.9 },
+      { from: 'Domain Selection', to: 'Jobs to Be Done (JTBD)', confidence: 0.85 },
+    ], 3),
+    ['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)']
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 4. mapFrameworkToCommandSlug delegates to the resolver; exports preserved
+// ---------------------------------------------------------------------------
+test('mapFrameworkToCommandSlug delegates to the resolver; FRAMEWORK_TO_COMMAND_SLUG + KNOWN_FRAMEWORKS still exported', function () {
+  // A registered framework: the slug round-trips through the resolver.
+  const cmds = resolver.commandsForFramework('Lean Canvas');
+  assert.ok(cmds.length > 0);
+  assert.strictEqual(composer.mapFrameworkToCommandSlug('Lean Canvas'), cmds[0].replace(/^\/mos:/, ''));
+  assert.strictEqual(composer.mapFrameworkToCommandSlug('Domain Selection'),
+    resolver.commandsForFramework('Domain Selection')[0].replace(/^\/mos:/, ''));
+  // An unknown name: falls back to the legacy table / FALLBACK_COMMAND_SLUG.
+  assert.strictEqual(composer.mapFrameworkToCommandSlug('A Wholly Imaginary Framework'), composer.FALLBACK_COMMAND_SLUG);
+  assert.strictEqual(typeof composer.mapFrameworkToCommandSlug('Lean Canvas'), 'string',
+    'mapFrameworkToCommandSlug always returns a slug string (it keeps a non-null fallback)');
+  // Exports preserved (122-05 prunes FRAMEWORK_TO_COMMAND_SLUG; not this plan).
+  assert.strictEqual(typeof composer.proposeNextFramework, 'function');
+  assert.strictEqual(typeof composer.mapFrameworkToCommandSlug, 'function');
+  assert.ok(composer.FRAMEWORK_TO_COMMAND_SLUG && typeof composer.FRAMEWORK_TO_COMMAND_SLUG === 'object');
+  assert.ok(Array.isArray(composer.KNOWN_FRAMEWORKS) && composer.KNOWN_FRAMEWORKS.length > 0);
+});
+
+// ---------------------------------------------------------------------------
+// 5. the engine / presenter / hooks are NOT touched (only the composer gained the resolver require)
+// ---------------------------------------------------------------------------
+test('navigation-engine.cjs did NOT gain a command-resolver require (the surgical edit is composer-only)', function () {
+  const engineSrc = fs.readFileSync(ENGINE_PATH, 'utf8');
+  assert.ok(!/command-resolver/.test(engineSrc),
+    'navigation-engine.cjs must not require command-resolver (the resolver wiring is in framework-chain-composer.cjs only)');
+  // Sanity: the composer's require IS there (the only file that should have it among these two).
+  const composerSrc = fs.readFileSync(COMPOSER_PATH, 'utf8');
+  assert.ok(/command-resolver/.test(composerSrc));
+});
+
+process.stdout.write('\nnavigation-hook-resolver.test.cjs: ' + passed + ' assertion groups PASSED\n');
+process.exit(0);

package/lib/memory/run-feynman-tests.cjs

@@ -1166,6 +1166,14 @@ const TEST_FILES = [
   path.join(REPO_ROOT, 'tests', 'test-precommit-hook-aliases.cjs'),
   path.join(REPO_ROOT, 'tests', 'test-canon-crossref-completeness.cjs'),
   path.join(REPO_ROOT, 'tests', 'test-part-9-invariant.cjs'),
+  // Phase 109-01 regression: the nodes-provenance migration drops + recreates
+  // every view/trigger that references `nodes` around the table rebuild. Seeds
+  // a room.db with an rs_discoveries-style view (+ a second view + a trigger),
+  // runs the migration, asserts no throw + views/trigger still work + idempotent
+  // re-run. Guards against the phase-109-migration-view-drop-collision bug
+  // (migration used to crash openRoomDb for any room.db carrying the Phase-89
+  // rs_discoveries view: "error in view rs_discoveries: no such table: main.nodes").
+  path.join(REPO_ROOT, 'tests', 'test-navigation-migration-views.cjs'),
   // Phase 89-07 Wave 0 (graph-native HARD RULE; ReverseSalientAgent dual-surface).
   path.join(REPO_ROOT, 'tests', 'test-reverse-salient-agent.cjs'),
   path.join(REPO_ROOT, 'tests', 'test-reverse-salient-cascade-emit.cjs'),
@@ -1208,6 +1216,15 @@ const TEST_FILES = [
   path.join(REPO_ROOT, 'lib', 'memory', 'command-registry.test.cjs'),
   // Phase 122-03: the chain recommender (recommendFrameworkChain via FEEDS_INTO).
   path.join(REPO_ROOT, 'lib', 'memory', 'chain-recommender.test.cjs'),
+  // Phase 122-04: the navigation-hook surgical edit (framework-chain-composer
+  // routed through the resolver) + the suggest-next integration test.
+  path.join(REPO_ROOT, 'lib', 'memory', 'navigation-hook-resolver.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'suggest-next-workflow.test.cjs'),
+  // Phase 122-05: the workflow-layer end-to-end test (frontmatter -> registry
+  // --check -> resolver.composeWorkflow(acceptance example) -> the degrade case
+  // -> validateChainAutonomy stop-point) + the Canon Part 8 zero-Brain-mutation
+  // grep sweep.
+  path.join(REPO_ROOT, 'lib', 'memory', 'workflow-layer-e2e.test.cjs'),
 ];
 
 // Exit code convention for child tests:

package/lib/memory/suggest-next-workflow.test.cjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 122-04 -- suggest-next-workflow integration test (new suite; registered in the Feynman runner).
+ * ====================================================================================================
+ * The end-to-end check for the Workflow Layer's user-facing slice:
+ *   - a fixture room with a ProblemType -> /mos:suggest-next returns a COMMAND
+ *     SEQUENCE (a step-numbered framework list AND at least one /mos: token),
+ *     and every /mos: it emits exists in data/command-registry.json (no
+ *     hallucinated command);
+ *   - a synthetic chain that includes /mos:hat-briefing -> validateChainAutonomy
+ *     reports it as a blocker (the /mos:act --chain stop point);
+ *   - /mos:pipeline --from-problem-type <x> derives a Brain-derived command
+ *     chain (the helper prints a run order of registered /mos: commands);
+ *   - /mos:act --chain stops at the first non-autonomous_safe step (here,
+ *     /mos:hat-briefing for Six Thinking Hats).
+ *
+ * Hermetic: a tmp room dir + a STATE.md with "Problem Type: ill-defined" (no
+ * network -- recommendFrameworkChain degrades to [seed] without offline edges,
+ * and that seed is what the room's ProblemType maps to via problem-type-router).
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs TEST_FILES[] and in
+ * tests/run-all-122.sh CJS_SUITES (as ../lib/memory/suggest-next-workflow.test.cjs).
+ * Run: node lib/memory/suggest-next-workflow.test.cjs
+ * Exit 0 on pass; throws (node:assert) on any fail.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+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 SUGGEST_SCRIPT = path.join(REPO_ROOT, 'scripts', 'suggest-next-command.cjs');
+const PIPELINE_SCRIPT = path.join(REPO_ROOT, 'scripts', 'pipeline-command.cjs');
+const ACT_SCRIPT = path.join(REPO_ROOT, 'scripts', 'act-command.cjs');
+
+const resolver = require('../workflow/command-resolver.cjs');
+const recommender = require('../brain/chain-recommender.cjs');
+
+const registry = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+const REGISTERED_COMMANDS = new Set((registry.commands || []).map(function (c) { return c && c.command; }));
+
+let passed = 0;
+function test(name, fn) {
+  fn();
+  process.stdout.write('  ok  ' + name + '\n');
+  passed += 1;
+}
+
+// Extract /mos:... tokens from a string.
+function extractCommands(text) {
+  const m = String(text).match(/\/mos:[a-z][a-z0-9-]*/g);
+  return m ? m.slice() : [];
+}
+
+// A fixture room: a tmp dir with a STATE.md carrying a ProblemType line.
+function makeFixtureRoom(problemTypeLine) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'p122-04-suggest-'));
+  const roomDir = path.join(root, 'room');
+  fs.mkdirSync(roomDir, { recursive: true });
+  fs.writeFileSync(path.join(roomDir, 'STATE.md'),
+    '# Room State\n\n' + problemTypeLine + '\n\nStage: discovery\n');
+  return { root: root, roomDir: roomDir };
+}
+function rmFixture(fx) { try { fs.rmSync(fx.root, { recursive: true, force: true }); } catch (_e) {} }
+
+// ---------------------------------------------------------------------------
+// 1. fixture room with a ProblemType -> /mos:suggest-next returns a command SEQUENCE
+// ---------------------------------------------------------------------------
+test('a fixture room with a ProblemType -> /mos:suggest-next prints a step-numbered command sequence; every /mos: is registered', function () {
+  const fx = makeFixtureRoom('Problem Type: ill-defined');
+  try {
+    const res = spawnSync(process.execPath, [SUGGEST_SCRIPT, '--room', fx.roomDir], { encoding: 'utf8' });
+    assert.strictEqual(res.status, 0, 'suggest-next-command.cjs exits 0; stderr: ' + (res.stderr || ''));
+    const out = res.stdout || '';
+    // It is a SEQUENCE: a "Command sequence" header + a step-numbered list + at least one /mos: token.
+    assert.ok(/command sequence/i.test(out), 'output names a command sequence; got:\n' + out);
+    assert.ok(/^\s*\d+\.\s/m.test(out), 'output has a step-numbered list; got:\n' + out);
+    assert.ok(/recommended framework chain/i.test(out), 'output shows the framework chain too');
+    const cmds = extractCommands(out);
+    assert.ok(cmds.length >= 1, 'output emits at least one /mos: command; got:\n' + out);
+    // Every /mos: it emits in the SEQUENCE/chain is a registered command (the
+    // footer cross-references /mos:status, /mos:pipeline -- also registered).
+    for (const c of cmds) {
+      assert.ok(REGISTERED_COMMANDS.has(c), 'emitted command must exist in data/command-registry.json: ' + c + '\nfull output:\n' + out);
+    }
+    // And the methodology command in the sequence is the resolver's answer for
+    // the IDP seed framework -- not a hallucinated one (in particular, NOT
+    // /mos:jtbd, which does not exist).
+    assert.ok(!/\/mos:jtbd\b/.test(out), 'must not emit the non-existent /mos:jtbd');
+  } finally {
+    rmFixture(fx);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 2. direct: recommendFrameworkChain + composeWorkflow for the IDP room state
+// ---------------------------------------------------------------------------
+test('recommendFrameworkChain({roomState:{problemType:"ill-defined"}}) -> composeWorkflow -> a chain of registered commands (no hallucination)', function () {
+  const chain = recommender.recommendFrameworkChain({ roomState: { problemType: 'ill-defined' } });
+  assert.ok(Array.isArray(chain) && chain.length >= 1, 'a non-empty framework chain');
+  const wf = resolver.composeWorkflow(chain);
+  assert.ok(Array.isArray(wf) && wf.length === chain.length);
+  wf.forEach(function (s, i) {
+    assert.strictEqual(s.step, i + 1);
+    assert.ok('framework' in s && 'command' in s && 'optional' in s);
+    if (s.command !== null) {
+      assert.ok(typeof s.command === 'string' && s.command.indexOf('/mos:') === 0);
+      assert.ok(REGISTERED_COMMANDS.has(s.command), 'composeWorkflow only ever yields registered commands: ' + s.command);
+    } else {
+      assert.strictEqual(s.optional, true, 'a command-less step is marked optional (run it manually)');
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 3. a synthetic chain including /mos:hat-briefing -> validateChainAutonomy flags it
+// ---------------------------------------------------------------------------
+test('a synthetic chain that includes /mos:hat-briefing -> validateChainAutonomy reports it as a blocker (the /mos:act --chain stop point)', function () {
+  // Six Thinking Hats resolves to /mos:hat-briefing (autonomous_safe: false in
+  // the registry) as its first command -- so a chain through it is the stop point.
+  const sixHatsCmds = resolver.commandsForFramework('Six Thinking Hats');
+  assert.ok(sixHatsCmds.length > 0 && sixHatsCmds[0] === '/mos:hat-briefing',
+    'Six Thinking Hats resolves to /mos:hat-briefing first; got: ' + JSON.stringify(sixHatsCmds));
+  const wf = resolver.composeWorkflow(['Beautiful Question Framework', 'Six Thinking Hats']);
+  const report = resolver.validateChainAutonomy(wf);
+  assert.strictEqual(report.runnable, false, 'a chain with /mos:hat-briefing is not fully runnable');
+  assert.ok(Array.isArray(report.blockers) && report.blockers.length >= 1);
+  const blocked = report.blockers.find(function (b) { return b && b.command === '/mos:hat-briefing'; });
+  assert.ok(blocked, 'the blocker names /mos:hat-briefing; report: ' + JSON.stringify(report));
+  assert.strictEqual(blocked.step, 2, 'the blocker is step 2 (the second step in the chain)');
+  // Step 1 (/mos:beautiful-question, autonomous_safe) is NOT a blocker.
+  assert.ok(!report.blockers.some(function (b) { return b && b.step === 1; }), 'step 1 is autonomous_safe -- not a blocker');
+});
+
+// ---------------------------------------------------------------------------
+// 4. /mos:pipeline --from-problem-type ill-defined prints a Brain-derived command chain
+// ---------------------------------------------------------------------------
+test('/mos:pipeline --from-problem-type ill-defined prints a run order of registered /mos: commands', function () {
+  const res = spawnSync(process.execPath, [PIPELINE_SCRIPT, '--from-problem-type', 'ill-defined'], { encoding: 'utf8' });
+  assert.strictEqual(res.status, 0, 'pipeline-command.cjs exits 0; stderr: ' + (res.stderr || ''));
+  const out = res.stdout || '';
+  assert.ok(/brain-derived framework chain/i.test(out), 'output names the Brain-derived chain; got:\n' + out);
+  assert.ok(/run order/i.test(out), 'output shows a run order; got:\n' + out);
+  const cmds = extractCommands(out);
+  assert.ok(cmds.length >= 1, 'output emits at least one /mos: command');
+  for (const c of cmds) {
+    assert.ok(REGISTERED_COMMANDS.has(c), 'pipeline run-order command must be registered: ' + c + '\nfull output:\n' + out);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 5. /mos:act --chain --from-framework "Six Thinking Hats" stops at the first non-autonomous step
+// ---------------------------------------------------------------------------
+test('/mos:act --chain stops at the first non-autonomous_safe step (Six Thinking Hats -> /mos:hat-briefing)', function () {
+  const res = spawnSync(process.execPath, [ACT_SCRIPT, '--chain', '--from-framework', 'Six Thinking Hats'], { encoding: 'utf8' });
+  assert.strictEqual(res.status, 0, 'act-command.cjs exits 0; stderr: ' + (res.stderr || ''));
+  const out = res.stdout || '';
+  assert.ok(/\[GATE\]/.test(out), 'output renders a needs-you-here gate; got:\n' + out);
+  assert.ok(/not autonomous_safe/i.test(out), 'the gate cites the autonomy reason');
+  assert.ok(/\/mos:hat-briefing/.test(out), 'the gate names /mos:hat-briefing (the stop point)');
+  assert.ok(/runnable:\s*false/i.test(out), 'validateChainAutonomy reported runnable=false');
+  // Every /mos: it prints is registered.
+  for (const c of extractCommands(out)) {
+    assert.ok(REGISTERED_COMMANDS.has(c), 'act --chain command must be registered: ' + c + '\nfull output:\n' + out);
+  }
+});
+
+process.stdout.write('\nsuggest-next-workflow.test.cjs: ' + passed + ' assertion groups PASSED\n');
+process.exit(0);

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);