@mindrian_os/install 1.13.0-beta.16 → 1.13.0-beta.17

package/lib/core/navigation/dashboard-helpers.cjs

@@ -0,0 +1,145 @@
+'use strict';
+/*
+ * Phase 118 Plan 02 -- dashboard-helpers: thin wrappers used by the Plan
+ * 118-02 dashboard-graph-neighborhood MVA agent (Agent 6 of 6 in B1).
+ *
+ * Two wrappers, both kept under lib/core/navigation/ so the chokepoint module
+ * (lib/core/navigation.cjs) re-exports them as the navigator-facing API. The
+ * dashboard MVA agent goes through navigation.cjs only -- the Phase 109 D-06
+ * chokepoint invariant (Canon Part 9).
+ *
+ * Wrappers:
+ *   detectActiveRoom() -> { roomDir, hasRoomDb } | null
+ *     Resolves the active room via MindrianRooms/.rooms/registry.json (the
+ *     scripts/brain-derive-command.cjs precedent at line 142). Returns null if
+ *     no registry, no active slug, or the resolved path is not a directory.
+ *
+ *   getRecentDecisionNeighborhood(roomDir, opts) -> { nodes:[], edges:[] }
+ *     Opens room.db via lib/core/room-db.cjs (the SOLE owner of better-sqlite3
+ *     instantiation), picks the most recent 'decision' node, calls the
+ *     existing getNeighborhood() chokepoint, returns the typed neighborhood.
+ *     Returns { nodes:[], edges:[] } when room.db has no decisions yet.
+ *
+ * Canon Part 9 (Memory Locality + Interpretation): this helper IS a navigation
+ * surface; agents that need room-graph reads go through here.
+ *
+ * Canon Part 8: zero network surface. Pure LOCAL filesystem + SQLite reads.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const roomDbMod = require('../room-db.cjs');
+const neighborhoodMod = require('./neighborhood.cjs');
+
+function _safeIsFile(p) {
+  try { return fs.statSync(p).isFile(); } catch (_e) { return false; }
+}
+function _safeIsDir(p) {
+  try { return fs.statSync(p).isDirectory(); } catch (_e) { return false; }
+}
+
+/**
+ * Resolve the active room via the MindrianRooms registry. Mirrors
+ * scripts/brain-derive-command.cjs::resolveActiveRoom verbatim so the same
+ * detection rules apply across CLI commands and MVA agents.
+ *
+ * @returns {{ roomDir: string, hasRoomDb: boolean } | null}
+ */
+function detectActiveRoom() {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  const roomsRoot = process.env.MINDRIAN_ROOMS_ROOT
+    || process.env.MINDRIAN_ROOMS_HOME
+    || path.join(home, 'MindrianRooms');
+  const registryPath = path.join(roomsRoot, '.rooms', 'registry.json');
+  if (!_safeIsFile(registryPath)) return null;
+  let reg;
+  try {
+    reg = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+  if (!reg || typeof reg !== 'object') return null;
+  const activeSlug = reg.active;
+  if (!activeSlug || typeof activeSlug !== 'string') return null;
+  const entry = reg.rooms && reg.rooms[activeSlug];
+  if (!entry || typeof entry !== 'object') return null;
+  const relPath = entry.path || activeSlug;
+  const absPath = path.resolve(roomsRoot, relPath);
+  if (!_safeIsDir(absPath)) return null;
+  const roomDbPath = path.join(absPath, '.mindrian', 'room.db');
+  const hasRoomDb = _safeIsFile(roomDbPath);
+  return { roomDir: absPath, hasRoomDb: hasRoomDb };
+}
+
+/**
+ * Return a 1-2 hop neighborhood snapshot of the most-recent Decision node in
+ * the room graph. The dashboard MVA agent renders this as the "your room
+ * already has N related decision nodes" surface.
+ *
+ * @param {string} roomDir   absolute path to the active room
+ * @param {{ hops?: number, limit?: number }} [opts]
+ * @returns {{ nodes: Array, edges: Array }}
+ */
+function getRecentDecisionNeighborhood(roomDir, opts) {
+  const options = opts || {};
+  const hops = Number.isInteger(options.hops) && options.hops >= 1 ? options.hops : 1;
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 5;
+
+  let db;
+  try {
+    db = roomDbMod.openRoomDb(roomDir);
+  } catch (_e) {
+    return { nodes: [], edges: [] };
+  }
+
+  let nodes = [];
+  let edges = [];
+  try {
+    // Pick the most recent decision node (or any node if no decisions) as focus.
+    const focusRow = db.prepare(
+      "SELECT id FROM nodes WHERE type = 'decision' ORDER BY created_at DESC LIMIT 1"
+    ).get();
+    if (!focusRow) {
+      return { nodes: [], edges: [] };
+    }
+    const focusNodeId = focusRow.id;
+    // Use the existing chokepoint to get the neighborhood. The depth + topK
+    // map onto Plan 118-02's "1-2 hop / 5-node snapshot" contract.
+    const neighborhood = neighborhoodMod.getNeighborhood(db, focusNodeId, {
+      maxDepth: hops,
+      topK: limit,
+    });
+    // Always include the focus node itself as the first node in the returned set.
+    nodes = [{ id: focusNodeId, type: 'decision' }].concat(neighborhood.map((n) => ({
+      id: n.id,
+      type: n.type,
+      score: n.score,
+      edgeTypeIn: n.edgeTypeIn,
+      depth: n.depth,
+    })));
+    // The closed neighborhood query also returns edge_path; surface a flat
+    // edges array of (source, target, type) tuples derived from the path
+    // metadata so the deck renderer (Plan 118-03) can draw the graph.
+    for (const n of neighborhood) {
+      if (n.edgePath && n.edgePath.length >= 2) {
+        const pathArr = n.edgePath;
+        for (let i = 0; i + 1 < pathArr.length; i++) {
+          edges.push({
+            source: pathArr[i],
+            target: pathArr[i + 1],
+            type: i + 1 === pathArr.length - 1 ? (n.edgeTypeIn || 'unknown') : 'path',
+          });
+        }
+      }
+    }
+  } catch (_e) {
+    nodes = [];
+    edges = [];
+  } finally {
+    try { roomDbMod.closeRoomDb(db); } catch (_e) { /* tolerant */ }
+  }
+  return { nodes, edges };
+}
+
+module.exports = { detectActiveRoom, getRecentDecisionNeighborhood };

package/lib/core/navigation.cjs

@@ -30,6 +30,7 @@ const packet = require('./navigation/packet.cjs');
 const ingestion = require('./navigation/ingestion.cjs');
 const roomHome = require('./navigation/room-home.cjs');
 const edges = require('./navigation/edges.cjs');
+const dashboardHelpers = require('./navigation/dashboard-helpers.cjs');
 
 function notImplementedYet(name, plan) {
   return function () {
@@ -88,4 +89,14 @@ module.exports = {
   //   116/117/118 will extend the allowlist additively for tension / auto-explore /
   //   MVA edges. Same additive-re-export pattern as logMemoryEvent + firstCapturedLastTouchedBySection.)
   writeEdge: edges.writeEdge,
+
+  // Dashboard MVA helpers (Phase 118 Plan 02 -- additive re-export so the
+  //   lib/agents/mva/dashboard-graph-neighborhood.cjs agent goes through the
+  //   navigation chokepoint per Canon Part 9 D-06 invariant. Same additive-
+  //   re-export pattern as logMemoryEvent / firstCapturedLastTouchedBySection /
+  //   writeEdge. detectActiveRoom mirrors scripts/brain-derive-command.cjs
+  //   line 142 verbatim; getRecentDecisionNeighborhood is a thin wrapper that
+  //   resolves the focus node + calls the existing getNeighborhood chokepoint.)
+  detectActiveRoom: dashboardHelpers.detectActiveRoom,
+  getRecentDecisionNeighborhood: dashboardHelpers.getRecentDecisionNeighborhood,
 };

package/lib/core/resolve-vercel-key.cjs

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 118-04 Plan 04 Task 1 -- resolve-vercel-key.
+ *
+ * The ONE resolver for "where is the Vercel deploy token on this machine?".
+ * Mirrors lib/core/resolve-brain-key.cjs (Phase 95.6 / Phase 123 Plan-07).
+ *
+ * Precedence per LD2 (Locked Decision 2 in 118-CONTEXT.md):
+ *   1. process.env.VERCEL_TOKEN      -- explicit operator intent, highest.
+ *   2. <home>/.mindrian.env          -- global backup, persists across CWDs.
+ *   3. <cwd>/.env                    -- project-local override.
+ *   4. null                          -- triggers local-file fallback path.
+ *
+ * Quote-stripping: handles both `VERCEL_TOKEN="abc"` (double-quoted) and
+ * `VERCEL_TOKEN=abc` (raw) per feedback_gmail_qp_env_var_corruption.md.
+ *
+ * Returns:
+ *   resolveVercelKey({home?, cwd?}) -> string | null
+ *
+ * Constants:
+ *   VERCEL_PROJECT_NAME = 'mindrianos-briefs'
+ *
+ * Canon Part 8: this module reads LOCAL files and env only. Zero network
+ * surface. The Vercel API call is mva-vercel-deploy.cjs's job; this module
+ * only DISCOVERS whether a token exists.
+ *
+ * No transitive runtime dependencies; node built-ins only.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+/** @type {string} The project name on Vercel where deck deploys live. */
+const VERCEL_PROJECT_NAME = 'mindrianos-briefs';
+
+/**
+ * Parse a single VERCEL_TOKEN=... line out of a (possibly multi-line) env-file
+ * body. Returns the trimmed value with surrounding double-quotes stripped, or
+ * null if the line is absent or the value is empty.
+ *
+ * @param {string} body
+ * @returns {string|null}
+ */
+function _parseKey(body) {
+  const m = body.match(/^VERCEL_TOKEN\s*=\s*(.+?)\s*$/m);
+  if (!m) return null;
+  let v = m[1].trim();
+  // Strip surrounding double-quotes if present
+  if (v.length >= 2 && v.startsWith('"') && v.endsWith('"')) {
+    v = v.slice(1, -1);
+  }
+  return v.length > 0 ? v : null;
+}
+
+/**
+ * Resolve the Vercel deploy token from the standard precedence chain.
+ *
+ * The `home` and `cwd` parameters exist as test seams (mirrors
+ * resolve-brain-key.cjs pattern). Env-aware home resolution so hermetic tests
+ * overriding process.env.HOME work on Linux/POSIX, where os.homedir() reads
+ * /etc/passwd and ignores the env override.
+ *
+ * @param {{home?: string, cwd?: string}} [opts]
+ * @returns {string|null}
+ */
+function resolveVercelKey(opts) {
+  const o = opts || {};
+  const home = o.home || process.env.HOME || process.env.USERPROFILE || os.homedir();
+  const cwd = o.cwd || process.cwd();
+
+  // (1) Env var wins.
+  if (process.env.VERCEL_TOKEN) {
+    const v = String(process.env.VERCEL_TOKEN).trim();
+    if (v.length > 0) return v;
+  }
+
+  // (2) <home>/.mindrian.env
+  const mindrianEnvPath = path.join(home, '.mindrian.env');
+  if (fs.existsSync(mindrianEnvPath)) {
+    try {
+      const body = fs.readFileSync(mindrianEnvPath, 'utf8');
+      const v = _parseKey(body);
+      if (v) return v;
+    } catch (_e) { /* fall through */ }
+  }
+
+  // (3) <cwd>/.env
+  const cwdEnvPath = path.join(cwd, '.env');
+  if (fs.existsSync(cwdEnvPath)) {
+    try {
+      const body = fs.readFileSync(cwdEnvPath, 'utf8');
+      const v = _parseKey(body);
+      if (v) return v;
+    } catch (_e) { /* fall through */ }
+  }
+
+  // (4) not-found
+  return null;
+}
+
+module.exports = {
+  resolveVercelKey,
+  VERCEL_PROJECT_NAME,
+};

package/lib/core/resolve-vercel-key.test.cjs

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 118-04 Plan 04 Task 1 -- resolve-vercel-key tests.
+ *
+ * Mirrors test patterns from lib/core/resolve-brain-key.cjs tests.
+ * Precedence per LD2: process.env.VERCEL_TOKEN -> <home>/.mindrian.env ->
+ * <cwd>/.env -> null.
+ *
+ * Quote-stripping: handles both `VERCEL_TOKEN="abc"` (double-quoted) and
+ * `VERCEL_TOKEN=abc` (raw) per feedback_gmail_qp_env_var_corruption.md.
+ *
+ * VERCEL_PROJECT_NAME is exported as the constant 'mindrianos-briefs'.
+ */
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+function _mkTmpHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'mva-vercel-key-test-'));
+}
+
+function _cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
+}
+
+// Force-reload module after env mutation
+function _freshRequire() {
+  const p = require.resolve('./resolve-vercel-key.cjs');
+  delete require.cache[p];
+  return require('./resolve-vercel-key.cjs');
+}
+
+test('Test 1: process.env.VERCEL_TOKEN takes precedence over file', () => {
+  const home = _mkTmpHome();
+  try {
+    fs.writeFileSync(path.join(home, '.mindrian.env'),
+      'VERCEL_TOKEN="from-file"\n', { mode: 0o600 });
+    const prev = process.env.VERCEL_TOKEN;
+    process.env.VERCEL_TOKEN = 'from-env';
+    try {
+      const { resolveVercelKey } = _freshRequire();
+      const r = resolveVercelKey({ home });
+      assert.equal(r, 'from-env');
+    } finally {
+      if (prev === undefined) { delete process.env.VERCEL_TOKEN; }
+      else { process.env.VERCEL_TOKEN = prev; }
+    }
+  } finally {
+    _cleanup(home);
+  }
+});
+
+test('Test 2: ~/.mindrian.env with quoted VERCEL_TOKEN resolves correctly', () => {
+  const home = _mkTmpHome();
+  try {
+    fs.writeFileSync(path.join(home, '.mindrian.env'),
+      'OTHER_VAR=ignore\nVERCEL_TOKEN="abc123"\n', { mode: 0o600 });
+    const prev = process.env.VERCEL_TOKEN;
+    delete process.env.VERCEL_TOKEN;
+    try {
+      const { resolveVercelKey } = _freshRequire();
+      const r = resolveVercelKey({ home, cwd: home });
+      assert.equal(r, 'abc123');
+    } finally {
+      if (prev !== undefined) process.env.VERCEL_TOKEN = prev;
+    }
+  } finally {
+    _cleanup(home);
+  }
+});
+
+test('Test 3: no env + no file = null', () => {
+  const home = _mkTmpHome();
+  try {
+    const prev = process.env.VERCEL_TOKEN;
+    delete process.env.VERCEL_TOKEN;
+    try {
+      const { resolveVercelKey } = _freshRequire();
+      const r = resolveVercelKey({ home, cwd: home });
+      assert.equal(r, null);
+    } finally {
+      if (prev !== undefined) process.env.VERCEL_TOKEN = prev;
+    }
+  } finally {
+    _cleanup(home);
+  }
+});
+
+test('Test 4: ~/.mindrian.env with unquoted VERCEL_TOKEN resolves correctly', () => {
+  const home = _mkTmpHome();
+  try {
+    fs.writeFileSync(path.join(home, '.mindrian.env'),
+      'VERCEL_TOKEN=raw-no-quotes\n', { mode: 0o600 });
+    const prev = process.env.VERCEL_TOKEN;
+    delete process.env.VERCEL_TOKEN;
+    try {
+      const { resolveVercelKey } = _freshRequire();
+      const r = resolveVercelKey({ home, cwd: home });
+      assert.equal(r, 'raw-no-quotes');
+    } finally {
+      if (prev !== undefined) process.env.VERCEL_TOKEN = prev;
+    }
+  } finally {
+    _cleanup(home);
+  }
+});
+
+test('Test 5: VERCEL_PROJECT_NAME exported constant === mindrianos-briefs', () => {
+  const { VERCEL_PROJECT_NAME } = _freshRequire();
+  assert.equal(VERCEL_PROJECT_NAME, 'mindrianos-briefs');
+});
+
+test('Test 5b: CWD .env fallback when ~/.mindrian.env absent', () => {
+  const home = _mkTmpHome();
+  const cwd = _mkTmpHome();
+  try {
+    fs.writeFileSync(path.join(cwd, '.env'),
+      'VERCEL_TOKEN="from-cwd-env"\n', { mode: 0o600 });
+    const prev = process.env.VERCEL_TOKEN;
+    delete process.env.VERCEL_TOKEN;
+    try {
+      const { resolveVercelKey } = _freshRequire();
+      const r = resolveVercelKey({ home, cwd });
+      assert.equal(r, 'from-cwd-env');
+    } finally {
+      if (prev !== undefined) process.env.VERCEL_TOKEN = prev;
+    }
+  } finally {
+    _cleanup(home);
+    _cleanup(cwd);
+  }
+});

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

@@ -1346,6 +1346,33 @@ const TEST_FILES = [
   //   .planning/phases/104.1-per-command-teaching-content/104.1-01-PLAN.md.
   path.join(REPO_ROOT, 'lib', 'memory', 'per-command-teaching.test.cjs'),
   path.join(REPO_ROOT, 'lib', 'memory', 'per-command-jtbd-derivation.test.cjs'),
+  // ---------- Phase 118 ----------
+  // 30-Second MVA + Reward-Before-Investment Rule. Plans 00-06 ship the
+  // pipeline; Plan 06 ships the rule + linter + Dror 2.0 harness.
+  // Aggregator: tests/run-all-118.sh.
+  //   Plan 118-00 (UserPromptSubmit detection):
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-classifier.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-detect.smoke.test.cjs'),
+  //   Plan 118-01 (dispatch architecture):
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-agent-contract.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-budget.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-dispatcher.test.cjs'),
+  //   Plan 118-02 (six MVA agents -- aggregate runner for all 6):
+  path.join(REPO_ROOT, 'lib', 'agents', 'mva', 'test-all-six-agents.cjs'),
+  //   Plan 118-03 (progressive streaming + orchestrator + telemetry):
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-progressive-renderer.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-telemetry.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-orchestrator.test.cjs'),
+  //   Plan 118-04 (Feynman deck + Vercel deploy):
+  path.join(REPO_ROOT, 'lib', 'core', 'resolve-vercel-key.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-vercel-deploy.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-deck-builder.test.cjs'),
+  //   Plan 118-05 (footer routing + operator helper):
+  path.join(REPO_ROOT, 'lib', 'conversation', 'operator.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-option-router.test.cjs'),
+  //   Plan 118-06 (rule-linter + Dror 2.0 acceptance harness):
+  path.join(REPO_ROOT, 'lib', 'core', 'mva-rule-linter.test.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-mva-dror-harness.cjs'),
 ];
 
 // Exit code convention for child tests:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindrian_os/install",
-  "version": "1.13.0-beta.16",
+  "version": "1.13.0-beta.17",
   "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",

package/skills/mva-pipeline/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: mva-pipeline
+description: Auto-activates when UserPromptSubmit detection classifies the user's prompt as a venture sentence; relays the 30-second MVA brief in Larry's voice
+auto-activate: state-file
+state-file: ~/.mindrian/mva/<session-id>.json
+state-condition: pending && !running
+interactive_first_reward: instant_brief
+canon_parts: [Part 2, Part 8, Part 10]
+---
+
+# The 30-second MVA skill
+
+## When this activates
+
+When Plan 118-00's UserPromptSubmit detection writes a pending state with
+`pipeline_status: 'pending'` (or `hebrew_refusal: true`), this skill fires on
+the NEXT model turn. The skill is the bridge between Plan 118-00's classifier
+and Plan 118-03's orchestrator: it makes Larry the GUIDED narrator of the
+brief without baking the orchestrator into Claude Code's hook protocol.
+
+## What to do
+
+1. Run `/mos:mva-brief` (or invoke `node scripts/mva-run.cjs` via Bash directly).
+2. Relay the stdout to the user VERBATIM, in your normal Larry voice (no extra
+   framing). The renderer already speaks in Larry's GUIDED voice; double-voicing
+   breaks the pedagogical contract.
+3. Wait for the user's option selection (1, 2, 3, or free-text).
+4. Route per the footer behavior:
+   - 1 -> stay in JUST_TALK; the brief stays visible; user can ask follow-ups
+     about any cell ("tell me more about the Honeydue case", "what was the
+     Gottman analogy?", etc.)
+   - 2 -> invoke /mos:new-project (Phase 119 wrapper; in v1.13.0 this surfaces
+     a stub message that the full room-build flow lands in beta.18)
+   - 3 -> invoke /mos:challenge-assumptions against the brief
+
+## What NOT to do (per feedback_larry_pedagogical_guided_first.md)
+
+- Do NOT add commentary or "I noticed..." preamble before the rendered output.
+  The renderer already opens with "Scanning for precedents..." in Larry's
+  GUIDED voice.
+- Do NOT interpret findings autonomously ("This means you should..."). The
+  rendered output IS GUIDED -- it asks the user to think; the renderer
+  surfaces what's in the graph and lets the navigator chew on it.
+- Do NOT skip the 3-option footer. Even if all agents failed, the
+  sharp-question fallback substitutes for the footer (per binding decision B7);
+  the renderer handles this -- you just relay verbatim.
+- Do NOT pre-pick an option. The user picks. That's the decision gate.
+
+## Canon parts implemented
+
+- Part 2 (team around navigator -- 6 agents as a parallel team, with the skill
+  being the surface Larry uses to relay the team's output)
+- Part 8 (boundary -- the agents send ONLY generic handles to Brain and
+  Tavily; the renderer + skill never re-introduce user content)
+- Part 10 sub-claim 3 (room as receipt -- the brief IS the reward delivered
+  BEFORE the user is asked to invest in setting up a room; option 2 is the
+  ask-for-investment that comes AFTER the reward, per Hooked sequencing)
+
+## State file contract
+
+Read from `~/.mindrian/mva/<session-id>.json` (the Plan 118-00 wire):
+
+```
+{
+  "sentence_sha256":       "<64-hex>",      // NEVER the raw sentence
+  "classified_at":         <epoch_ms>,
+  "classifier_source":     "heuristic" | "heuristic_fallback" | "haiku-4-5",
+  "classifier_confidence": "high" | "medium" | "low",
+  "locale":                "en" | "he",
+  "hebrew_refusal":        true,            // optional, set on LD1 short-circuit
+  "pipeline_status":       "pending" | "running" | "complete"
+}
+```
+
+On `hebrew_refusal:true`, the orchestrator renders the bilingual refusal block
+and DOES NOT fire the dispatcher (per LD1 in 118-CONTEXT.md).
+
+## Routing the 3-option footer (after the brief renders)
+
+Once `/mos:mva-brief` (or the orchestrator) has rendered the brief to the user,
+the user's next message is most likely an option selection. Recognition rule:
+
+- User types exactly `1`, `2`, or `3` -> invoke `/mos:mva-option <N>` (no sha8
+  argument needed; the command auto-resolves via `resolveCurrentSha8()`)
+- User types `/mos:mva-option N` explicitly -> invoke `/mos:mva-option <N>`
+  (sha8 still optional; auto-resolved when omitted)
+- User types anything else -> handle as a normal conversation turn (do NOT
+  route through `mva-option`)
+
+The sha8 argument is OPTIONAL because the router auto-discovers the most
+recent brief via `resolveCurrentSha8()` -> `~/.mindrian/mva/state.json` (the
+manifest written by Plan 118-03's orchestrator after `mva_brief_rendered`).
+
+### Per-option behavior
+
+Option 1 -- "Just tell me what's new" (stay in tell-me mode):
+- Acknowledgment: "Keeping the brief visible. Ask me anything about what you just saw."
+- Operator: transitions to `JUST_TALK`
+- Brief stays in scrollback; follow-up questions about any of the 6 cells are welcome
+
+Option 2 -- "Build a room around this" (invest, deferred):
+- Show the stub message verbatim from `STUB_MESSAGE_119`:
+  "Building a room around this is the next layer; shipping in beta.18 (Phase 119). For now, press option 1 to keep this brief visible, or option 3 to go deeper."
+- Operator: no transition (option 2 is stubbed for v1.13.0)
+- In v1.13.0-beta.18 (Phase 119), this routes to `/mos:new-project --from-brief <sha8>`
+
+Option 3 -- "Challenge me -- Devil's Advocate" (go deeper):
+- Bridge text: "Going deeper. Pulling the brief into a Devil's Advocate pass."
+- Operator: transitions to `METHODOLOGY`
+- Invoke: `/mos:challenge-assumptions --from-brief <sha8>`
+
+### Edge cases
+
+- Brief data expired (side-file missing): tell the user the brief expired and
+  offer to re-run by typing their venture sentence again.
+- Brief is still rendering (`mva_brief_rendered` event not yet emitted): hold
+  the option, tell the user "Brief is still rendering -- options will activate
+  when it completes".
+- No `state.json` exists (fresh install or Hebrew refusal path): tell the user
+  "No recent brief found. Type your venture sentence to fire the pipeline."
+- Invalid option (`4`, `99`, etc.): treat as free-text and route normally.
+
+### Do NOT
+
+- Do NOT autonomously pick an option for the user.
+- Do NOT pre-summarize what option 2 "would do" -- the stub message says it.
+- Do NOT add em-dashes to any rendered option text -- use `--` only.
+- Do NOT invoke `/mos:new-project` for option 2 in v1.13.0 -- that wiring
+  lands in Phase 119 (beta.18).