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

package/lib/core/framework-chain-composer.cjs

@@ -12,6 +12,31 @@
  * an engine.offer_next_step candidate consumed by the navigation engine
  * (Plan 91-00) and rendered through the offer presenter (Plan 91-04).
  *
+ * Phase 122-04 -- routed through the resolver (the only door)
+ * ==========================================================
+ * proposeNextFramework() now resolves the next framework's /mos: command
+ * via lib/workflow/command-resolver.cjs commandsForFramework() -- the SOLE
+ * deterministic framework -> command path, reading only the generated
+ * data/command-registry.json. When the registry has no command for that
+ * framework, command degrades to null ("no /mos: for [framework] yet" --
+ * degrade, not fabricate per WORKFLOW-LAYER-SPEC reliability rule 5); the
+ * offer presenter already treats a null/empty command as not-an-offer.
+ * proposeNextFramework also returns a workflow field -- the resolver's
+ * composeWorkflow([completed, next, ...successors]) array -- so a multi-hop
+ * FEEDS_INTO chain is available as data on the proposal (a future plan can
+ * carry it into offer_next_step / shape-f1-renderer; this plan only puts
+ * the data there). mapFrameworkToCommandSlug() relies solely on the
+ * resolver (then FALLBACK_COMMAND_SLUG) so any remaining caller also gets
+ * the resolver answer.
+ *
+ * Phase 122-05 -- the residual map pruned
+ * =======================================
+ * FRAMEWORK_TO_COMMAND_SLUG is now Object.freeze({}) -- the resolver is the
+ * ONLY framework-to-command door (data/command-registry.json, generated from
+ * frontmatter; WORKFLOW-LAYER-SPEC reliability rule 1). The empty table is
+ * kept only as a back-compat export. KNOWN_FRAMEWORKS stays exported as a
+ * name-recognition bootstrap (it is NOT the framework-to-command source).
+ *
  * Canon Part 2 Engine 1 + Appendix E:
  *   Framework chains power Act 1 -> BONO Orchestration handoffs.
  *   FEEDS_INTO is the Brain-flagged graph infrastructure (~40 edges in
@@ -49,6 +74,11 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+// The resolver (the only door). Required lazily inside the functions that
+// need it so a missing module never crashes a caller that does not use the
+// resolver path -- but it is an in-repo sibling so this never fails in
+// practice. Reads only data/command-registry.json; never touches the Brain.
+
 // ---------- Frozen constants ----------
 
 // Confidence gates per locked decision in PLAN frontmatter:
@@ -63,12 +93,14 @@ const RECOMMENDED_FLOOR = 0.7;
 // plans may layer richer signal on top).
 const RECENT_WRITE_WINDOW_MS = 5 * 60 * 1000;
 
-// Bootstrap KNOWN_FRAMEWORKS list. Order is preservation-friendly with
-// existing /mos:* commands. The list is conservative; Brain-derived
-// FEEDS_INTO edges may reference frameworks outside this set (in which
-// case completion detection falls through to the mtime slug fallback,
-// and command mapping falls through to /mos:beautiful-question). The
-// list is extensible; future plans may pull from the Brain frameworks
+// Bootstrap KNOWN_FRAMEWORKS list. NAME-RECOGNITION BOOTSTRAP ONLY -- this is
+// NOT the framework-to-command source (that is OWNED by lib/workflow/
+// command-resolver.cjs, reading the generated data/command-registry.json).
+// detectCompletedFramework() uses this list to recognize a framework name in a
+// governing thought / a filed-artifact slug; the list is conservative; a
+// Brain-derived FEEDS_INTO edge may reference a framework outside this set, in
+// which case completion detection falls through to the mtime slug fallback.
+// The list is extensible; future plans may pull from the Brain frameworks
 // catalog directly.
 const KNOWN_FRAMEWORKS = Object.freeze([
   'SWOT Analysis',
@@ -91,31 +123,14 @@ const KNOWN_FRAMEWORKS = Object.freeze([
   'Rich Pictures',
 ]);
 
-// Map known framework names to canonical /mos: command slugs. This is a
-// best-effort table; unknown frameworks fall back to the
-// /mos:beautiful-question guide command per plan locked decisions.
-// The map is intentionally case-insensitive at lookup time so a Brain
-// edge "Lean Canvas" or "lean canvas" resolves identically.
-const FRAMEWORK_TO_COMMAND_SLUG = Object.freeze({
-  'swot analysis': 'beautiful-question', // No dedicated /mos:swot today; bypass to BQ guide.
-  'porter five forces': 'beautiful-question',
-  'value chain analysis': 'beautiful-question',
-  'business model canvas': 'beautiful-question',
-  'lean canvas': 'lean-canvas',
-  'jobs-to-be-done': 'beautiful-question',
-  'value proposition canvas': 'beautiful-question',
-  '5 whys': 'beautiful-question',
-  'first principles': 'beautiful-question',
-  'design thinking': 'beautiful-question',
-  'blue ocean strategy': 'beautiful-question',
-  "innovator's dilemma": 'beautiful-question',
-  '7 s framework': 'beautiful-question',
-  'balanced scorecard': 'beautiful-question',
-  'mullins': 'mullins',
-  'beautiful question': 'beautiful-question',
-  'soft systems': 'beautiful-question',
-  'rich pictures': 'beautiful-question',
-});
+// Framework-to-command mapping is OWNED by lib/workflow/command-resolver.cjs
+// (the generated data/command-registry.json, built from each command's
+// frontmatter -- WORKFLOW-LAYER-SPEC reliability rule 1: a single source of
+// truth, nothing else asserts the mapping). Phase 122-05 pruned this table to
+// an empty Object.freeze({}); it is kept ONLY as an empty back-compat export
+// so any caller that still imports FRAMEWORK_TO_COMMAND_SLUG does not crash.
+// Do NOT add entries here -- declare `frameworks:` in the command frontmatter.
+const FRAMEWORK_TO_COMMAND_SLUG = Object.freeze({});
 
 // Default fallback command when the next framework has no known mapping.
 const FALLBACK_COMMAND_SLUG = 'beautiful-question';
@@ -304,7 +319,12 @@ function detectCompletedFramework(roomDir, sectionPath, reasoning) {
  *     confidence: number,
  *     source: 'FEEDS_INTO',
  *     phase_indicator: string|null,
- *     command: string,               // '/mos:<slug>'
+ *     command: string|null,          // '/mos:<slug>' from the resolver, or null
+ *                                    //   when the registry has no command for
+ *                                    //   `next` yet (degrade, do not fabricate)
+ *     workflow: Array|null,           // resolver.composeWorkflow([completed, next, ...])
+ *                                    //   -- the multi-hop chain as data; the engine
+ *                                    //   does not propagate it yet (future plan)
  *     reason: string,                // grounding text (FEEDS_INTO + Brain + confidence)
  *     recommended_eligible: boolean, // true when confidence >= 0.7
  *   }
@@ -353,12 +373,44 @@ function proposeNextFramework(completedFramework, edges) {
   // the noise gate (we cannot certify a confidenceless edge).
   if (conf === null || conf < NOISE_FLOOR) return null;
 
-  // Map next to /mos: command.
-  const slug = mapFrameworkToCommandSlug(top.to);
-  const command = '/mos:' + slug;
+  // Resolve next -> /mos: command via the resolver (the only door). The
+  // resolver reads only data/command-registry.json; it never touches the
+  // Brain. When the registry has no command for `next`, command degrades
+  // to null -- "no /mos: for [framework] yet" -- never a fabricated one
+  // (WORKFLOW-LAYER-SPEC reliability rule 5). The offer presenter already
+  // treats a null/empty command as not-an-offer.
+  let resolver = null;
+  try {
+    resolver = require('../workflow/command-resolver.cjs');
+  } catch (_e) {
+    resolver = null;
+  }
+  let command = null;
+  let workflow = null;
+  if (resolver) {
+    try {
+      const cmds = resolver.commandsForFramework(top.to);
+      command = (Array.isArray(cmds) && cmds.length > 0) ? cmds[0] : null;
+    } catch (_e) {
+      command = null;
+    }
+    // Multi-step path: build the resolver's composeWorkflow for the chain
+    // [completedFramework, next, ...further FEEDS_INTO successors up to ~3].
+    // This puts the multi-hop chain on the proposal as data; the navigation
+    // engine does not propagate `workflow` into offer_next_step in this plan
+    // (the presenter / shape-f1-renderer wiring is a future plan's job).
+    try {
+      const chain = collectForwardChain(completedFramework, edges, 3);
+      workflow = resolver.composeWorkflow(chain);
+    } catch (_e) {
+      workflow = null;
+    }
+  }
 
   // Grounding-rule reason: must contain FEEDS_INTO + Brain + the
-  // confidence number per Plan 91-04 presenter contract + Test 13.
+  // confidence number per Plan 91-04 presenter contract + Test 13. When
+  // there is no command for `next`, the reason still names the framework
+  // (the consumer prints "run [framework] manually" rather than a command).
   const confStr = conf.toFixed(2);
   const reason =
     completedFramework + ' FEEDS_INTO ' + top.to +
@@ -370,26 +422,81 @@ function proposeNextFramework(completedFramework, edges) {
     source: 'FEEDS_INTO',
     phase_indicator: (typeof top.phase_indicator === 'string') ? top.phase_indicator : null,
     command: command,
+    workflow: workflow,
     reason: reason,
     recommended_eligible: conf >= RECOMMENDED_FLOOR,
   };
 }
 
+/**
+ * collectForwardChain(start, edges, maxHops) -> [start, next, ...]
+ *
+ * Walks the highest-confidence FEEDS_INTO edge from `start`, then from that
+ * successor, etc., up to `maxHops` hops. Cycle-safe (a framework already in
+ * the chain stops the walk). Only follows edges that pass the noise floor.
+ * Returns at least [start]. Pure: no I/O.
+ *
+ * @param {string} start
+ * @param {Array} edges
+ * @param {number} maxHops
+ * @returns {string[]}
+ */
+function collectForwardChain(start, edges, maxHops) {
+  const chain = [start];
+  if (!Array.isArray(edges) || edges.length === 0) return chain;
+  const hops = (typeof maxHops === 'number' && maxHops > 0) ? maxHops : 3;
+  const seen = new Set([String(start).toLowerCase()]);
+  let current = start;
+  for (let i = 0; i < hops; i += 1) {
+    const cur = String(current).toLowerCase();
+    let best = null;
+    for (const e of edges) {
+      if (!e || typeof e !== 'object') continue;
+      if (typeof e.from !== 'string' || typeof e.to !== 'string') continue;
+      if (e.from.toLowerCase() !== cur) continue;
+      const c = (typeof e.confidence === 'number') ? e.confidence : null;
+      if (c === null || c < NOISE_FLOOR) continue;
+      if (best === null || c > best.confidence) best = { to: e.to, confidence: c };
+    }
+    if (best === null) break;
+    const nextLc = best.to.toLowerCase();
+    if (seen.has(nextLc)) break;
+    chain.push(best.to);
+    seen.add(nextLc);
+    current = best.to;
+  }
+  return chain;
+}
+
 /**
  * mapFrameworkToCommandSlug(name) -> slug
  *
- * Maps a framework name (in any case) to a /mos: command slug via the
- * frozen FRAMEWORK_TO_COMMAND_SLUG table. Falls back to FALLBACK_COMMAND_
- * SLUG ('beautiful-question') when no entry matches. Pure: no I/O.
+ * Maps a framework name (in any case) to a /mos: command slug via the resolver
+ * (lib/workflow/command-resolver.cjs commandsForFramework -- the ONLY door,
+ * reads only data/command-registry.json, never touches the Brain), falling
+ * back to FALLBACK_COMMAND_SLUG ('beautiful-question') when the registry has no
+ * command for `name` or the resolver is unavailable. Phase 122-05 removed the
+ * legacy in-module table (FRAMEWORK_TO_COMMAND_SLUG is now empty) -- the
+ * resolver is authoritative.
+ *
+ * Note: proposeNextFramework() does NOT use this helper -- it calls
+ * commandsForFramework() directly so it can degrade to command:null (the
+ * helper keeps a non-null fallback for back-compat with callers that expect
+ * a slug string).
  *
  * @param {string} name
  * @returns {string}
  */
 function mapFrameworkToCommandSlug(name) {
   if (typeof name !== 'string' || name.length === 0) return FALLBACK_COMMAND_SLUG;
-  const lc = name.toLowerCase();
-  if (Object.prototype.hasOwnProperty.call(FRAMEWORK_TO_COMMAND_SLUG, lc)) {
-    return FRAMEWORK_TO_COMMAND_SLUG[lc];
+  // Resolver -- the only door.
+  try {
+    const cmds = require('../workflow/command-resolver.cjs').commandsForFramework(name);
+    if (Array.isArray(cmds) && cmds.length > 0) {
+      return cmds[0].replace(/^\/mos:/, '');
+    }
+  } catch (_e) {
+    // resolver unavailable -> fall through to the fallback slug
   }
   return FALLBACK_COMMAND_SLUG;
 }
@@ -400,7 +507,13 @@ module.exports = {
   parseFrameworkChainSection: parseFrameworkChainSection,
   detectCompletedFramework: detectCompletedFramework,
   proposeNextFramework: proposeNextFramework,
-  // Frozen tables exposed for downstream introspection + test invariants.
+  collectForwardChain: collectForwardChain,
+  // Exported for back-compat: relies solely on the resolver, then the
+  // fallback slug. Phase 122-05 removed the legacy in-module table.
+  mapFrameworkToCommandSlug: mapFrameworkToCommandSlug,
+  // KNOWN_FRAMEWORKS is a name-recognition bootstrap (NOT the framework-to-
+  // command source). FRAMEWORK_TO_COMMAND_SLUG is an EMPTY back-compat export
+  // (Phase 122-05) -- the resolver (data/command-registry.json) is the only door.
   KNOWN_FRAMEWORKS: KNOWN_FRAMEWORKS,
   FRAMEWORK_TO_COMMAND_SLUG: FRAMEWORK_TO_COMMAND_SLUG,
   // Constants exposed for invariant tests + downstream callers.

package/lib/core/migrations/phase-109-nodes-provenance.cjs

@@ -242,6 +242,31 @@ function backfillAssumptionsAsGraphNodes(db) {
   return db.prepare("SELECT COUNT(*) AS n FROM assumptions").get().n;
 }
 
+function dependentSchemaObjects(db) {
+  // Enumerate every view and trigger that mentions the legacy `nodes` table in
+  // its definition. The SQLite "making other kinds of table schema changes"
+  // recipe (the canonical 12-step procedure) requires these to be dropped
+  // BEFORE the rename-out-of-existence rebuild and recreated AFTER -- otherwise
+  // SQLite re-validates the schema during ALTER TABLE ... RENAME TO, finds the
+  // now-dangling view, and throws "error in view <name>: no such table:
+  // main.nodes". We do not hardcode rs_discoveries; any future view/trigger on
+  // `nodes` is picked up automatically. Drop-then-recreate is idempotent: views
+  // whose sql carries IF NOT EXISTS re-exec cleanly; ones without it are simply
+  // recreated fresh since we dropped them first.
+  const rows = db.prepare(
+    "SELECT type, name, sql FROM sqlite_master " +
+    "WHERE type IN ('view','trigger') AND sql IS NOT NULL " +
+    // \bnodes\b style match: the token "nodes" not immediately followed by an
+    // identifier char (so we do not mistakenly catch nodes_new). SQLite LIKE
+    // has no word boundaries, so over-match a little and trust the recreate to
+    // be a no-op for anything unrelated -- but exclude the obvious nodes_new.
+    "AND sql LIKE '%nodes%' AND sql NOT LIKE '%nodes_new%'"
+  ).all();
+  // Defensive: drop NULL/empty sql rows (autogenerated indexes never appear
+  // here because we filtered type, but be safe).
+  return rows.filter((r) => r && r.name && typeof r.sql === 'string' && r.sql.trim());
+}
+
 function tightenSchemaWithCheckConstraints(db) {
   // Step 2: re-create-table-with-NOT-NULL plus CHECK constraints.
   // Canonical SQLite 12-step recipe (foreign_keys disabled for the duration;
@@ -251,6 +276,19 @@ function tightenSchemaWithCheckConstraints(db) {
   // do not flip it here; the BEGIN/COMMIT wrapper guarantees atomicity, and
   // FK behavior is unchanged because the only FK targeting nodes is from edges
   // which we do not drop.
+
+  // Step 2a: capture and drop every view/trigger that depends on `nodes`. Must
+  // happen before DROP TABLE nodes so the schema stays internally consistent
+  // through the rename. Recreated verbatim at the end of this function.
+  const dependents = dependentSchemaObjects(db);
+  for (const obj of dependents) {
+    if (obj.type === 'view') {
+      db.exec('DROP VIEW IF EXISTS "' + obj.name.replace(/"/g, '""') + '"');
+    } else {
+      db.exec('DROP TRIGGER IF EXISTS "' + obj.name.replace(/"/g, '""') + '"');
+    }
+  }
+
   db.exec(
     "CREATE TABLE nodes_new (" +
     "  id TEXT PRIMARY KEY, " +
@@ -291,6 +329,15 @@ function tightenSchemaWithCheckConstraints(db) {
     'CREATE INDEX IF NOT EXISTS idx_nodes_confirmed_by ON nodes(confirmed_by) ' +
     'WHERE confirmed_by IS NOT NULL'
   );
+
+  // Step 2b: recreate the views/triggers we dropped in Step 2a, now that
+  // `nodes` exists again with the tightened schema. The captured `sql` is the
+  // exact CREATE statement from sqlite_master; many carry IF NOT EXISTS which
+  // keeps the recreate idempotent, and any that do not were dropped above so
+  // re-exec is still safe.
+  for (const obj of dependents) {
+    db.exec(obj.sql);
+  }
 }
 
 function insertSentinel(db) {

package/lib/hmi/jtbd-taxonomy.json

@@ -1,6 +1,7 @@
 {
   "version": 1,
   "canon_parts": [2, "2a", 3, 7],
+  "methodology_hooks_note": "informational only; lib/workflow/command-resolver.cjs (reading the generated data/command-registry.json, built from each command's frontmatter -- see docs/COMMAND-FRONTMATTER.md and docs/WORKFLOWS.md) is authoritative for framework-to-command. These hooks are convenience pointers for JTBD-driven routing; they are NOT a source of truth. Larry never names a /mos: from memory.",
   "entries": [
     {
       "id": "decide-pursue",
@@ -16,7 +17,7 @@
       "methodology_hooks": [
         "/mos:diagnose",
         "/mos:build-thesis",
-        "/mos:value-proposition",
+        "/mos:validate-proposition",
         "/mos:lean-canvas"
       ],
       "next_move_verbs": [

package/lib/memory/framework-chain-composer.test.cjs

@@ -104,6 +104,17 @@ const SAMPLE_4_LINES = [
   '- Jobs-to-be-Done FEEDS_INTO Value Proposition Canvas (confidence: 0.90, phase: pre-opportunity)',
 ].join('\n');
 
+// Phase 122-04: a chain whose `next` framework IS registered in
+// data/command-registry.json, so proposeNextFramework returns a non-null
+// /mos: command (Tests 16 + 18 need the engine's offer_next_step.command
+// to be a real command string -- only the resolver-registered frameworks
+// yield one; unregistered ones degrade to null per reliability rule 5).
+// 'Business Model Canvas' is in KNOWN_FRAMEWORKS (detectable from a
+// governing thought); 'Lean Canvas' resolves to /mos:lean-canvas.
+const SAMPLE_REGISTERED_CHAIN = [
+  '- Business Model Canvas FEEDS_INTO Lean Canvas (confidence: 0.85, phase: thesis-build)',
+].join('\n');
+
 // =========================================================
 // Task 1 -- parser + completion detection + proposal (Tests 1..15)
 // =========================================================
@@ -297,25 +308,43 @@ run('Test 11: proposeNextFramework tie-breaking by confidence desc', () => {
   assert.equal(Math.abs(out.confidence - 0.85) < 1e-9, true);
 });
 
-run('Test 12: proposeNextFramework /mos: command mapping', () => {
+run('Test 12: proposeNextFramework command resolution via the resolver (Phase 122-04: degrade to null, not fabricate)', () => {
   const { proposeNextFramework } = requireComposer();
-  // 'Lean Canvas' has an existing /mos:lean-canvas command.
+  const resolver = require('../workflow/command-resolver.cjs');
+  // 'Lean Canvas' has an existing /mos:lean-canvas command in the registry.
   const knownEdges = [
     { from: 'Business Model Canvas', to: 'Lean Canvas', confidence: 0.82, phase_indicator: 'thesis' },
   ];
   const known = proposeNextFramework('Business Model Canvas', knownEdges);
   assert.equal(known !== null, true);
-  assert.equal(typeof known.command, 'string');
-  assert.equal(known.command.indexOf('/mos:') === 0, true,
-    'command must start with /mos:; got: ' + known.command);
-  // Unknown framework name falls back to /mos:beautiful-question or
-  // a slugified default. Either way the command MUST start with /mos:.
+  // Phase 122-04: command comes from the resolver (commandsForFramework[0]).
+  const expected = resolver.commandsForFramework('Lean Canvas');
+  assert.equal(known.command, expected.length > 0 ? expected[0] : null,
+    'command must equal commandsForFramework(next)[0] (or null); got: ' + known.command);
+  assert.equal(typeof known.command === 'string' && known.command.indexOf('/mos:') === 0, true,
+    'Lean Canvas is registered, so command must be a /mos: string; got: ' + known.command);
+  // A workflow array (the resolver's composeWorkflow for the chain) is on
+  // the proposal as data -- a list of { step, framework, command|null, optional }.
+  assert.equal(Array.isArray(known.workflow), true, 'workflow must be a composeWorkflow array');
+  assert.equal(known.workflow.length >= 2, true, 'workflow includes [completed, next, ...]');
+  assert.equal(known.workflow[0].step, 1);
+  for (let i = 0; i < known.workflow.length; i += 1) {
+    const s = known.workflow[i];
+    assert.equal(s.step, i + 1);
+    assert.equal('command' in s && 'optional' in s && 'framework' in s, true);
+    assert.equal(s.command === null || (typeof s.command === 'string' && s.command.indexOf('/mos:') === 0), true);
+  }
+  // A framework name the registry does not know yet -> command is null
+  // (degrade, do not fabricate -- WORKFLOW-LAYER-SPEC reliability rule 5).
   const unknownEdges = [
     { from: 'X', to: 'A Wholly Imaginary Framework', confidence: 0.8, phase_indicator: null },
   ];
   const unknown = proposeNextFramework('X', unknownEdges);
   assert.equal(unknown !== null, true);
-  assert.equal(unknown.command.indexOf('/mos:') === 0, true);
+  assert.equal(unknown.command, null, 'command must be null for an unregistered framework; got: ' + unknown.command);
+  assert.equal(Array.isArray(unknown.workflow), true);
+  assert.equal(unknown.workflow.every(function (s) { return s.command === null; }), true,
+    'an unregistered chain composes to all-null commands (run manually)');
 });
 
 run('Test 13: proposeNextFramework grounding rule (FEEDS_INTO + Brain + confidence in reason)', () => {
@@ -408,9 +437,13 @@ function makeQuadrupleWithChain(chainBody, governingThought) {
 
 run('Test 16: decide() with chain + governing_thought -> offer_next_step with FEEDS_INTO reason', () => {
   const { decide } = requireEngine();
+  // Phase 122-04: use a chain whose `next` framework is registered, so the
+  // resolver yields a real /mos: command (an unregistered `next` would
+  // degrade to command:null -- a true statement, but the presenter then
+  // treats it as not-an-offer; this test wants the command-carrying path).
   const quadruple = makeQuadrupleWithChain(
-    SAMPLE_4_LINES,
-    'After our SWOT Analysis we found two key threats and one opportunity.'
+    SAMPLE_REGISTERED_CHAIN,
+    'After our Business Model Canvas work we mapped the value flows.'
   );
   const out = decide(
     { sectionPath: '/tmp/fixture', sessionId: 's1' },
@@ -421,11 +454,11 @@ run('Test 16: decide() with chain + governing_thought -> offer_next_step with FE
       intentSignal: null,
     }
   );
-  // Engine should compose a chain offer: SWOT -> Porter (the highest-conf
-  // outgoing edge from SWOT in SAMPLE_4_LINES).
+  // Engine should compose a chain offer: Business Model Canvas -> Lean Canvas.
   assert.equal(out.offer_next_step !== null, true,
     'expected non-null offer_next_step; trace: ' + (out.decision_trace.chosen_rationale || ''));
-  assert.equal(typeof out.offer_next_step.command, 'string');
+  assert.equal(typeof out.offer_next_step.command, 'string',
+    'offer command must be a string (Lean Canvas is registered); got: ' + out.offer_next_step.command);
   assert.equal(out.offer_next_step.command.indexOf('/mos:') === 0, true);
   assert.equal(/FEEDS_INTO/.test(out.offer_next_step.reason), true,
     'offer reason must reference FEEDS_INTO; got: ' + out.offer_next_step.reason);
@@ -460,13 +493,12 @@ run('Test 17: decide() Mode A confidence 0.85 chain -> recommended_eligible flag
 
 run('Test 18: decide() user override path: turn 1 offer; turn 2 different command -> REJECTED chain trace', () => {
   const { decide } = requireEngine();
-  // Turn 1: chain proposes /mos:porter-five-forces (or similar slug from
-  // Porter Five Forces). Engine writes trace.brain_patterns including
-  // category 'framework_chain_proposal' OR sets offer_next_step with
-  // chain context.
+  // Turn 1: chain proposes /mos:lean-canvas (Business Model Canvas FEEDS_INTO
+  // Lean Canvas; Lean Canvas is resolver-registered so the command is real).
+  // Engine sets offer_next_step with the chain command + reason.
   const turn1Quad = makeQuadrupleWithChain(
-    SAMPLE_4_LINES,
-    'After our SWOT Analysis we identified threats.'
+    SAMPLE_REGISTERED_CHAIN,
+    'After our Business Model Canvas work we mapped the value flows.'
   );
   const turn1 = decide(
     { sectionPath: '/tmp/fixture', sessionId: 's1', userText: '' },
@@ -480,6 +512,8 @@ run('Test 18: decide() user override path: turn 1 offer; turn 2 different comman
   assert.equal(turn1.offer_next_step !== null, true,
     'turn 1 must produce a chain offer; trace: ' + turn1.decision_trace.chosen_rationale);
   const turn1Command = turn1.offer_next_step.command;
+  assert.equal(typeof turn1Command === 'string' && turn1Command.length > 0, true,
+    'turn 1 chain command must be a real /mos: string; got: ' + turn1Command);
 
   // Turn 2: user invokes a DIFFERENT /mos: command. Engine should record
   // this as REJECTED chain suggestion in decision_trace.
@@ -487,7 +521,7 @@ run('Test 18: decide() user override path: turn 1 offer; turn 2 different comman
     {
       sectionPath: '/tmp/fixture',
       sessionId: 's1',
-      userText: '/mos:lean-canvas help me with my lean canvas instead',
+      userText: '/mos:mullins run the 7-domains screen instead',
     },
     {
       quadruple: turn1Quad,