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

package/lib/memory/statusline-two-row.test.cjs

@@ -0,0 +1,338 @@
+// statusline-two-row.test.cjs -- Phase 121.5-03 Task 2
+//
+// 12 behavioral tests covering the two-row renderer + version resolver +
+// visual-ops palette derivation + migrate-stale-user-settings bare-path
+// detection.
+//
+// Bash only. No emoji. No em-dashes.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const REPO_ROOT = path.join(__dirname, '..', '..');
+const RENDERER = path.join(REPO_ROOT, 'lib', 'statusline', 'two-row-renderer.cjs');
+const VERSION_RESOLVER = path.join(REPO_ROOT, 'lib', 'statusline', 'version-resolver.cjs');
+const TRUNCATOR = path.join(REPO_ROOT, 'lib', 'statusline', 'governing-thought-truncator.cjs');
+const VISUAL_OPS = path.join(REPO_ROOT, 'lib', 'core', 'visual-ops.cjs');
+const MIGRATOR = path.join(REPO_ROOT, 'scripts', 'migrate-stale-user-settings.cjs');
+
+const renderer = require(RENDERER);
+const versionResolver = require(VERSION_RESOLVER);
+
+let passed = 0;
+let failed = 0;
+
+function ok(name) {
+  console.log('  ok   ' + name);
+  passed++;
+}
+function fail(name, msg) {
+  console.error('  FAIL ' + name + (msg ? ' -- ' + msg : ''));
+  failed++;
+}
+function assert(cond, name, msg) {
+  if (cond) ok(name);
+  else fail(name, msg);
+}
+
+console.log('test statusline-two-row');
+
+// Test 1: renderRow1 shape with default state.
+try {
+  const out = renderer.renderRow1({
+    current_version: '1.13.0-beta.18',
+    brain_tier: 'BRAIN',
+    ctx_pct: 47,
+  });
+  const hasBrand = out.indexOf('⬡ MindrianOS v1.13.0-beta.18') === 0;
+  const hasBrain = out.indexOf('🧠 BRAIN') >= 0;
+  const hasBar = out.indexOf('📊') >= 0 && out.indexOf('47%') >= 0;
+  const hasSeparators = (out.match(/ │ /g) || []).length === 2;
+  assert(hasBrand && hasBrain && hasBar && hasSeparators,
+    'test1 renderRow1 shape',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test1 renderRow1 shape', e.message);
+}
+
+// Test 2: renderRow1 OMITS the update glyph when update_available is false.
+try {
+  const out = renderer.renderRow1({
+    current_version: '1.13.0-beta.18',
+    brain_tier: 'BRAIN',
+    ctx_pct: 30,
+    update_available: false,
+  });
+  const noGlyph = out.indexOf('🔄') === -1;
+  assert(noGlyph, 'test2 renderRow1 omits update glyph when not available',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test2 renderRow1 omits update glyph', e.message);
+}
+
+// Test 3: renderRow1 INCLUDES `🔄 v<new>` when update_available is true.
+try {
+  const out = renderer.renderRow1({
+    current_version: '1.13.0-beta.18',
+    brain_tier: 'LOCAL',
+    ctx_pct: 12,
+    update_available: true,
+    update_available_version: '1.13.0',
+  });
+  const hasGlyph = out.indexOf('🔄 v1.13.0') >= 0;
+  const hasLocal = out.indexOf('🧠 LOCAL') >= 0;
+  assert(hasGlyph && hasLocal,
+    'test3 renderRow1 includes update glyph + LOCAL tier',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test3 renderRow1 includes update glyph', e.message);
+}
+
+// Test 4: renderBar at >=80% renders ANSI blink-red + ⚠ compaction-imminent
+// warning text; at <80% does not. Byte-identical to Phase 106-02 D-02
+// contract (the legacy compaction-imminent text was preserved in the
+// renderer extraction; see test-context-monitor-d02-broadcast.cjs Test 3).
+try {
+  const lowBar = renderer.renderBar(45);
+  const highBar = renderer.renderBar(85);
+  const lowHasBlinkRed = lowBar.indexOf('\x1b[5;31m') >= 0;
+  const highHasBlinkRed = highBar.indexOf('\x1b[5;31m') >= 0;
+  const highHasWarn = highBar.indexOf('⚠ compaction-imminent') >= 0;
+  const lowHasWarn = lowBar.indexOf('⚠') >= 0;
+  // Bar geometry: 10 chars, 8 filled at 85, 4 filled at 45
+  const lowFilledCount = (lowBar.match(/█/g) || []).length;
+  const highFilledCount = (highBar.match(/█/g) || []).length;
+  assert(!lowHasBlinkRed && highHasBlinkRed && highHasWarn && !lowHasWarn &&
+         lowFilledCount === 4 && highFilledCount === 8,
+    'test4 renderBar -- low=no blink-red/warn, high=blink-red+compaction-imminent, geometry correct',
+    'low=' + JSON.stringify(lowBar) + ' high=' + JSON.stringify(highBar));
+} catch (e) {
+  fail('test4 renderBar', e.message);
+}
+
+// Test 5: renderRow2 full shape at COLUMNS=120.
+try {
+  const out = renderer.renderRow2({
+    room: 'MindrianOS-Plugin',
+    section: 'product-evolution',
+    jtbd: 'find-problem',
+    stage: 'ILL_DEFINED',
+    governing_thought: 'JTBD-invariant single shape wins',
+    operator: 'METHODOLOGY',
+  }, 120);
+  const hasRoom = out.indexOf('🏠 MindrianOS-Plugin') >= 0;
+  const hasSection = out.indexOf('📂 product-evolution') >= 0;
+  const hasJTBD = out.indexOf('🎯 find-problem') >= 0;
+  const hasStage = out.indexOf('🔍 ILL_DEFINED') >= 0;
+  const hasThought = out.indexOf('JTBD-invariant single shape wins') >= 0;
+  const hasOperator = out.indexOf('METHODOLOGY') >= 0;
+  assert(hasRoom && hasSection && hasJTBD && hasStage && hasThought && hasOperator,
+    'test5 renderRow2 full shape at COLUMNS=120',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test5 renderRow2 full shape', e.message);
+}
+
+// Test 6: renderRow2 governing-thought truncation at exactly 40 chars boundary.
+try {
+  const longThought = 'a'.repeat(50); // 50 chars
+  const out = renderer.renderRow2({
+    room: 'r',
+    section: 's',
+    governing_thought: longThought,
+  }, 120);
+  // 37 'a's + '...'
+  const expected = 'a'.repeat(37) + '...';
+  const hasExpected = out.indexOf(expected) >= 0;
+  // And the un-truncated tail must NOT appear (the 50-char string)
+  const hasFull = out.indexOf(longThought) >= 0;
+  assert(hasExpected && !hasFull,
+    'test6 governing-thought truncation > 40 chars yields 37 + ...',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test6 governing-thought truncation', e.message);
+}
+
+// Test 7: renderRow2 at COLUMNS=60 drops the operator segment (60 < 80).
+try {
+  const out = renderer.renderRow2({
+    room: 'r',
+    section: 's',
+    jtbd: 'j',
+    stage: 'st',
+    governing_thought: 'gt',
+    operator: 'METHODOLOGY',
+  }, 60);
+  const noOperator = out.indexOf('METHODOLOGY') === -1;
+  const hasStage = out.indexOf('🔍 st') >= 0;
+  const hasJTBD = out.indexOf('🎯 j') >= 0;
+  assert(noOperator && hasStage && hasJTBD,
+    'test7 renderRow2 COLUMNS=60 drops operator, keeps stage + jtbd',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test7 renderRow2 COLUMNS=60', e.message);
+}
+
+// Test 8: renderRow2 at COLUMNS=50 drops operator AND stage.
+try {
+  const out = renderer.renderRow2({
+    room: 'r',
+    section: 's',
+    jtbd: 'j',
+    stage: 'st',
+    governing_thought: 'gt',
+    operator: 'METHODOLOGY',
+  }, 50);
+  const noOperator = out.indexOf('METHODOLOGY') === -1;
+  const noStage = out.indexOf('🔍') === -1;
+  const hasJTBD = out.indexOf('🎯 j') >= 0;
+  assert(noOperator && noStage && hasJTBD,
+    'test8 renderRow2 COLUMNS=50 drops operator + stage, keeps jtbd',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test8 renderRow2 COLUMNS=50', e.message);
+}
+
+// Test 9: renderRow2 at COLUMNS=40 drops operator, stage, AND jtbd.
+try {
+  const out = renderer.renderRow2({
+    room: 'r',
+    section: 's',
+    jtbd: 'j',
+    stage: 'st',
+    governing_thought: 'gt',
+    operator: 'METHODOLOGY',
+  }, 40);
+  const noOperator = out.indexOf('METHODOLOGY') === -1;
+  const noStage = out.indexOf('🔍') === -1;
+  const noJTBD = out.indexOf('🎯') === -1;
+  const hasRoom = out.indexOf('🏠 r') >= 0;
+  const hasThought = out.indexOf('gt') >= 0;
+  assert(noOperator && noStage && noJTBD && hasRoom && hasThought,
+    'test9 renderRow2 COLUMNS=40 drops operator + stage + jtbd, keeps room + thought',
+    'got: ' + JSON.stringify(out));
+} catch (e) {
+  fail('test9 renderRow2 COLUMNS=40', e.message);
+}
+
+// Test 10: renderStatusline emits EXACTLY two newline-separated rows.
+try {
+  const out = renderer.renderStatusline({
+    current_version: '1.13.0-beta.18',
+    brain_tier: 'BRAIN',
+    ctx_pct: 50,
+    room: 'r',
+    section: 's',
+    jtbd: 'j',
+    stage: 'st',
+    governing_thought: 'gt',
+    operator: 'METHODOLOGY',
+  }, 120);
+  const lines = out.split('\n');
+  assert(lines.length === 2 && lines[0].length > 0 && lines[1].length > 0,
+    'test10 renderStatusline emits exactly 2 newline-separated rows',
+    'lines.length=' + lines.length);
+} catch (e) {
+  fail('test10 renderStatusline two-row split', e.message);
+}
+
+// Test 11: visual-ops.cjs DS_HEX now sourced from palette.json. Sentinel test:
+// override MINDRIAN_PALETTE_PATH to point at a synthetic palette with a
+// sentinel hex; spawn a child node that requires visual-ops + reports DS_HEX.
+try {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'visual-ops-test-'));
+  const sentinelHex = '#abcdef';
+  const fakePalette = {
+    version: 1,
+    base: {
+      mondrian_red: sentinelHex,
+      mondrian_blue: '#1e3a6e',
+      mondrian_yellow: '#c8a43c',
+      mondrian_black: '#0d0d0d',
+      mondrian_white: '#f5f0e8',
+      cream: '#f5f0e8',
+      gray_meta: '#a09a90',
+      amethyst: '#6b4e8b',
+      success_green: '#2d6b4a',
+    },
+    palette_a_discovery: { muted_red: '#a63d2f', muted_green: '#2d6b4a', teal_accent: '#2a6b5e' },
+    palette_b_build: { saturated_red: '#a63d2f', saturated_blue: '#1e3a6e', saturated_yellow: '#c8a43c' },
+    extended: { sienna: '#b5602a', bg: '#0d0d0d', surface: '#1a1a1a', elevated: '#2a2a2a', gray: '#5c5a56' },
+  };
+  const fakePalettePath = path.join(tmpDir, 'fake-palette.json');
+  fs.writeFileSync(fakePalettePath, JSON.stringify(fakePalette, null, 2));
+
+  const child = spawnSync(process.execPath, [
+    '-e',
+    "const vo = require('" + VISUAL_OPS.replace(/\\/g, '\\\\') + "'); " +
+    "process.stdout.write(JSON.stringify(vo.DS_HEX));"
+  ], {
+    env: Object.assign({}, process.env, { MINDRIAN_PALETTE_PATH: fakePalettePath }),
+    encoding: 'utf8',
+  });
+  if (child.status !== 0) {
+    fail('test11 DS_HEX from palette.json -- child failed: ' + child.stderr);
+  } else {
+    const dshex = JSON.parse(child.stdout);
+    // The legacy DS_HEX key is `red` (not `mondrian_red`); the wiring should
+    // alias so DS_HEX.red maps to palette.base.mondrian_red. Test the
+    // sentinel hex propagation.
+    const hasSentinel = dshex.red === sentinelHex || dshex.mondrian_red === sentinelHex;
+    assert(hasSentinel,
+      'test11 visual-ops DS_HEX sourced from palette.json sentinel',
+      'got DS_HEX.red=' + dshex.red + ' / DS_HEX.mondrian_red=' + dshex.mondrian_red);
+  }
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+} catch (e) {
+  fail('test11 DS_HEX from palette.json', e.message);
+}
+
+// Test 12: migrate-stale-user-settings.cjs --auto detects bare-path context-monitor
+// and proposes migration via SessionStart envelope.
+try {
+  const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-home-'));
+  const claudeDir = path.join(tmpHome, '.claude');
+  fs.mkdirSync(claudeDir, { recursive: true });
+  const fakeSettings = {
+    statusLine: {
+      type: 'command',
+      command: 'node /home/x/.claude/plugins/cache/mindrian-marketplace/mos/1.13.0-beta.5/scripts/context-monitor',
+    },
+  };
+  fs.writeFileSync(path.join(claudeDir, 'settings.json'), JSON.stringify(fakeSettings, null, 2));
+
+  // Use --auto --quiet so stdout is JSON-only (no header lines). The QUIET
+  // flag was added in Phase 106-01 D-01 specifically for hook-friendly
+  // invocation; --auto without --quiet emits header lines + envelope.
+  const child = spawnSync(process.execPath, [MIGRATOR, '--auto', '--quiet'], {
+    env: Object.assign({}, process.env, { HOME: tmpHome, USERPROFILE: tmpHome }),
+    encoding: 'utf8',
+  });
+  if (child.status !== 0) {
+    fail('test12 migrate --auto detects bare-path', 'exit=' + child.status + ' stderr=' + child.stderr);
+  } else {
+    let envelope = null;
+    try { envelope = JSON.parse(child.stdout); } catch (_) {}
+    const hasAdditional =
+      envelope &&
+      envelope.hookSpecificOutput &&
+      typeof envelope.hookSpecificOutput.additionalContext === 'string' &&
+      envelope.hookSpecificOutput.additionalContext.indexOf('drift') >= 0;
+    assert(hasAdditional,
+      'test12 migrate --auto --quiet emits SessionStart envelope with drift warning',
+      'stdout=' + child.stdout);
+  }
+  try { fs.rmSync(tmpHome, { recursive: true, force: true }); } catch (_) {}
+} catch (e) {
+  fail('test12 migrate --auto', e.message);
+}
+
+// Summary
+console.log('');
+console.log('statusline-two-row.test: ' + passed + ' passed, ' + failed + ' failed');
+if (failed > 0) process.exit(1);
+process.exit(0);

package/lib/memory/terminal-capability.test.cjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 121.5-07 Task 1 -- Terminal capability probe + help_jtbd frontmatter
+ * sweep acceptance tests.
+ *
+ * Asserts:
+ *   - lib/core/terminal-capability.cjs exists with probeCapability() dispatch
+ *     covering 6 paths (truecolor, 256color via COLORTERM, 256color via TERM,
+ *     ascii via non-TTY, ascii via no-COLORTERM-no-TERM, ascii via Desktop).
+ *   - Every commands/<name>.md declares help_jtbd: frontmatter.
+ *   - Every help_jtbd: value is a quoted string >= 8 and <= 120 chars.
+ *
+ * Canon references:
+ *   Part 3 UI Ruling System -- bulletproof terminal coherence depends on a
+ *           single capability probe shared across surfaces.
+ *   Part 7 Reuse Before Build -- terminal-capability.cjs consolidates an
+ *           inline check that would otherwise live in N command renderers;
+ *           reusable across /mos:status, /mos:doctor, /mos:splash, etc.
+ *   Part 8 Graph Boundary -- probe reads env-vars + isTTY only; zero
+ *           network, zero Brain, zero telemetry egress.
+ *
+ * Test map (8 cases, one-to-one with PLAN Task 1 <behavior>):
+ *
+ *   1. probeCapability({isTTY:true, env:{COLORTERM:'truecolor'}}) -> 'truecolor'
+ *   2. probeCapability({isTTY:true, env:{COLORTERM:'256color'}})  -> '256color'
+ *   3. probeCapability({isTTY:true, env:{TERM:'xterm-256color'}}) -> '256color'
+ *   4. probeCapability({isTTY:false})                              -> 'ascii'
+ *   5. probeCapability({isTTY:true, env:{}})                       -> 'ascii'
+ *   6. probeCapability({isTTY:true, env:{CLAUDE_DESKTOP:'1'}})     -> 'ascii'
+ *   7. Every commands/*.md declares help_jtbd: frontmatter.
+ *   8. Every help_jtbd: value is quoted, 8..120 chars, no em-dashes.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const PROBE_PATH = path.join(REPO, 'lib', 'core', 'terminal-capability.cjs');
+const COMMANDS_DIR = path.join(REPO, 'commands');
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function run(name, fn) {
+  try {
+    fn();
+    console.log('  PASS  ' + name);
+    passed++;
+  } catch (err) {
+    console.error('  FAIL  ' + name);
+    console.error('        ' + (err.message || err));
+    failed++;
+    failures.push(name);
+  }
+}
+
+// --- Test 1: truecolor dispatch via COLORTERM ---
+run('Test 1: COLORTERM=truecolor + isTTY=true returns truecolor', () => {
+  assert.ok(fs.existsSync(PROBE_PATH), 'lib/core/terminal-capability.cjs must exist');
+  const { probeCapability } = require(PROBE_PATH);
+  const result = probeCapability({ isTTY: true, env: { COLORTERM: 'truecolor' } });
+  assert.equal(result, 'truecolor');
+});
+
+// --- Test 2: 256color via COLORTERM ---
+run('Test 2: COLORTERM=256color + isTTY=true returns 256color', () => {
+  const { probeCapability } = require(PROBE_PATH);
+  const result = probeCapability({ isTTY: true, env: { COLORTERM: '256color' } });
+  assert.equal(result, '256color');
+});
+
+// --- Test 3: 256color via TERM fallback ---
+run('Test 3: TERM=xterm-256color + isTTY=true (COLORTERM unset) returns 256color', () => {
+  const { probeCapability } = require(PROBE_PATH);
+  const result = probeCapability({ isTTY: true, env: { TERM: 'xterm-256color' } });
+  assert.equal(result, '256color');
+});
+
+// --- Test 4: non-TTY -> ascii ---
+run('Test 4: isTTY=false returns ascii (piped/non-TTY)', () => {
+  const { probeCapability } = require(PROBE_PATH);
+  const result = probeCapability({ isTTY: false, env: { COLORTERM: 'truecolor' } });
+  assert.equal(result, 'ascii');
+});
+
+// --- Test 5: isTTY=true with neither COLORTERM nor TERM -> ascii ---
+run('Test 5: isTTY=true with empty env returns ascii', () => {
+  const { probeCapability } = require(PROBE_PATH);
+  const result = probeCapability({ isTTY: true, env: {} });
+  assert.equal(result, 'ascii');
+});
+
+// --- Test 6: Desktop hard-override ---
+run('Test 6: CLAUDE_DESKTOP=1 returns ascii (Desktop simulator)', () => {
+  const { probeCapability } = require(PROBE_PATH);
+  const result = probeCapability({
+    isTTY: true,
+    env: { CLAUDE_DESKTOP: '1', COLORTERM: 'truecolor' },
+  });
+  assert.equal(result, 'ascii');
+});
+
+// --- Test 7: every command has help_jtbd: ---
+run('Test 7: every commands/*.md declares help_jtbd frontmatter', () => {
+  const files = fs.readdirSync(COMMANDS_DIR).filter((f) => f.endsWith('.md'));
+  assert.ok(files.length >= 80, 'expected >= 80 command files, found ' + files.length);
+  const missing = [];
+  for (const f of files) {
+    const text = fs.readFileSync(path.join(COMMANDS_DIR, f), 'utf8');
+    const fm = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm || !/^help_jtbd:/m.test(fm[1])) {
+      missing.push(f);
+    }
+  }
+  assert.deepEqual(missing, [], 'commands missing help_jtbd: ' + missing.join(', '));
+});
+
+// --- Test 8: help_jtbd value contract (quoted, 8..120 chars, no em-dash) ---
+run('Test 8: every help_jtbd value is quoted, 8..120 chars, no em-dashes', () => {
+  const files = fs.readdirSync(COMMANDS_DIR).filter((f) => f.endsWith('.md'));
+  const violations = [];
+  for (const f of files) {
+    const text = fs.readFileSync(path.join(COMMANDS_DIR, f), 'utf8');
+    const fm = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm) continue;
+    const line = fm[1].split('\n').find((l) => /^help_jtbd:/.test(l));
+    if (!line) continue;
+    // Must be quoted with double-quotes
+    const m = line.match(/^help_jtbd:\s*"([^"]*)"\s*$/);
+    if (!m) {
+      violations.push(f + ': not double-quoted -> ' + line);
+      continue;
+    }
+    const val = m[1];
+    if (val.length < 8) violations.push(f + ': too short (' + val.length + ' chars)');
+    if (val.length > 120) violations.push(f + ': too long (' + val.length + ' chars)');
+    if (/—/.test(val)) violations.push(f + ': contains em-dash');
+  }
+  assert.deepEqual(violations, [], 'help_jtbd violations: ' + violations.join('\n  '));
+});
+
+console.log('');
+console.log('passed=' + passed + ' failed=' + failed);
+if (failed > 0) {
+  console.error('Failed tests:');
+  for (const t of failures) console.error('  - ' + t);
+  process.exit(1);
+}
+process.exit(0);

package/lib/render/ROOM.md

@@ -9,51 +9,103 @@ The universal renderer translates a 4-zone payload + render mode + conversation
 ## Phase status
 
 - **Phase 99-03 (shipped):** contract surface + no-op pass-through stub. Callers can import `{ render }` today; envelope returns `rendered: false` + `_stub: 'phase-99-03'` provenance tag. Operator validation against the 5 canonical values (JUST_TALK / EXPLORE_CAPTURE / BUILD_ROOM / METHODOLOGY / DECISION_GATE) ships now so Phase 102 inherits the fence.
-- **Phase 102 (planned):** replaces the stub internals with real rendering logic per Phase 99 CONTEXT.md D-16. Same import surface; no caller changes.
+- **Phase 102 (shipped):** replaces the stub internals with real rendering logic per Phase 99 CONTEXT.md D-16. Same import surface; no caller changes. The destructured `render({ zones, mode, operator, tier, jtbd, tokenBudget, roomDir, provenance })` API ships; the legacy 4-arg signature stays alive at `lib/render/render.cjs` as a thin shim that forwards to v2.
+- **Phase 121.5-04 (shipped, Sub-plan E):** the long-open question of whether render-v2 should be wired into the ordinary Larry prose path is resolved -- see **Disposition** below.
+
+## Disposition (Sub-plan E, 2026-05-16)
+
+> **render-v2 stays agent-surface-only by design.** SKILL.md remains the canonical prose contract for Larry's main conversation path. The v2 destructured `render()` entry is reserved for /mos:* command surfaces and the Shape F decision-gate output side that route through `lib/hmi/selector-dispatcher.cjs`.
+
+This is the disposition that Phase 121.5 commits to for v1.13.0 final. The verdict was locked at plan-phase after the 2026-05-16 dual-graph review. Sub-plan E (this plan, 121.5-04) closes the open question; Sub-plan E ALSO closes the Phase 102 release loop by shipping `102-VERIFICATION.md` and flipping `102-VALIDATION.md` out of `status: draft`.
+
+### Allowed render-v2 consumers (current production set)
+
+| Consumer | Role | Why allowed |
+|----------|------|-------------|
+| `lib/render/render.cjs` | v1 legacy-signature shim | Reuses v2 muscle for the 4-arg positional API per Phase 102 CONTEXT D-10. One renderer, two entry points (Canon Part 7). |
+| `lib/hmi/selector-dispatcher.cjs` | Shape F / Shape E agentic dispatcher | The /mos:* command output side -- Canon Part 3 tri-context decision-gate enforcement surface. NOT the ordinary prose path. |
+
+CI gate: `lib/memory/render-v2-disposition.test.cjs` asserts the allowlist matches this table on every test run. The operator-facing audit lives at `scripts/disposition-render-v2.cjs` (`--json` for machine-readable, default for human summary; exit 1 on any prose-path import).
+
+### Why not wire it into the prose path
+
+Three reasons, in priority order:
+
+1. **Canon Part 7 (Reuse Before Build).** SKILL.md is the canonical prose contract today; it ships, it is exercised on every Larry turn, and the 4-zone format is enforced by skill instruction. Replacing instruction-side enforcement with code-side enforcement would be a parallel implementation rather than reuse, which is the bar the canon explicitly raises against.
+2. **Canon Part 3 (the gate output side).** The v2 destructured signature was designed for Shape F.x gate surfaces -- decision-gate output, not free prose. The compaction layer (102-02), JTBD-aware Zone 4 (102-03), provenance envelope (102-04), and color overlay (102-05) all assume gate-bounded payloads. Wrapping them around ordinary prose would silently change Larry's conversational shape -- a regression risk against Phase 88.1 + 88.2 + the Part 10 capstone work.
+3. **Phase 121.5 capstone scope.** Sub-plan C reconciles SKILL.md v2 with the shipped Shape F set + dual palette + the 🎯/JTBD disambiguation. After 121.5 lands, SKILL.md IS the source of truth -- a separate v1.14.0 phase can revisit whether code-side prose rendering still earns its keep against a freshly-reconciled SKILL.md.
+
+### Current rankable input signal types (additive expansion reserved)
+
+The render-v2 entry today consumes a closed-by-version-but-open-by-future set of typed inputs:
+
+| Signal | Source | Phase shipped |
+|--------|--------|----------------|
+| `operator` (5 canonical: JUST_TALK / EXPLORE_CAPTURE / BUILD_ROOM / METHODOLOGY / DECISION_GATE) | Phase 99 conversation operator state machine | 99-03 |
+| `mode` ('A' / 'B' / 'tier-0') | Phase 90 brain-derivation tier-awareness | 102-04 |
+| `tier` (0/1/2/3) | Phase 90 brain-derivation gating | 102-04 |
+| `jtbd` (one of 13 canonical Phase 100 handles or null) | Phase 100 JTBD inference engine | 102-03 |
+| `tokenBudget` ({used, total}) | Phase 102-02 compaction layer | 102-02 |
+| `provenance` (caller-supplied; NOT folded into `_provenance`) | Phase 90 brain-derived inputs | 102-04 |
+
+These are the input signal types render-v2 accepts **as of Phase 121.5-04** (additive expansion is reserved for future lens-aware variants once the dual-graph proposal lands -- ASSOCIATION_LENS + TRANSITION_LENS lens classes may add lens-derived signals). The set is current; it is not closed for all time. Per Canon Part 7 language discipline: "current" / "as of" / "today" framing is the convention -- never "final" / "complete" / "closed set" framing.
 
 ## Files
 
 | File | Role |
 |------|------|
-| render-v2.cjs | Contract surface. Phase 99-03 stub today, Phase 102 implementation later. Exports `{ render, OPERATORS }`. |
-| render-v2.test.cjs | Contract tests: 8 IIFE scenarios (5-operator round-trip, JUST_TALK default for undefined and null, invalid-operator throw, envelope shape stable, mode passthrough, tier passthrough, OPERATORS frozen). Registered in lib/memory/run-feynman-tests.cjs. |
+| render-v2.cjs | Contract surface + Phase 102 implementation. Exports `{ render, OPERATORS, composeZones, isCompact, applyCompaction, JTBD_CLI_COLOR, ANSI }`. |
+| render.cjs | v1 legacy-signature shim. Forwards to render-v2 with defensive defaults; returns just the `rendered` string. |
+| render-v2.test.cjs | Contract regression fence: 8 IIFE scenarios (5-operator round-trip, JUST_TALK default for undefined and null, unknown-operator tolerated, envelope shape stable, mode passthrough, tier passthrough, OPERATORS frozen). Registered in lib/memory/run-feynman-tests.cjs. |
+| JTBD-PALETTES.md | CLI + Mondrian dual-palette tables for the 13 canonical JTBDs (Phase 102-05). |
 | ROOM.md | This file -- ICM Layer 0 identity per CLAUDE.md Decision #15. |
 
-## Render contract (Phase 99 CONTEXT.md D-16)
+## Render contract (Phase 99 CONTEXT.md D-16, refined in Phase 102)
 
 ```
-render(zones, mode, operator, tier) -> envelope
-
-operator == JUST_TALK        -> emit prose only                          (Phase 102)
-operator == EXPLORE_CAPTURE  -> prose; Shape E only on crystallization   (Phase 102)
-operator == BUILD_ROOM       -> full 4-zone anatomy                      (Phase 102)
-operator == METHODOLOGY      -> no shape mid-session; Shape E at gate    (Phase 102)
-operator == DECISION_GATE    -> Shape F.x; keyboard only                 (Phase 102)
+render({ zones, mode, operator, tier, jtbd, tokenBudget, roomDir, provenance })
+  -> { rendered: string, contract: object, _provenance: <non-enumerable, frozen> }
+
+operator == JUST_TALK        -> emit prose only; suppress envelope             (Phase 102-01)
+operator == EXPLORE_CAPTURE  -> prose; Shape E only on crystallization         (Phase 102)
+operator == BUILD_ROOM       -> full 4-zone anatomy + JTBD-aware Zone 4        (Phase 102-03)
+operator == METHODOLOGY      -> no Zone 4 mid-session; Shape E at gate         (Phase 102-01)
+operator == DECISION_GATE    -> Shape F.x; keyboard only                       (Phase 102-03)
 ```
 
-Phase 99-03 stub returns `{ zones, mode, operator, tier, rendered: false, _stub: 'phase-99-03' }` with operator validated and defaulted to JUST_TALK when null/undefined.
+The legacy 4-arg signature lives at `lib/render/render.cjs`:
+
+```
+render(zones, mode, operator, tier) -> string
+```
 
 ## Canon refs
 
-- **Part 3 (Tri-Context Decision Gate):** DECISION_GATE locks Shape F.x; the renderer enforces this at output time (Phase 102).
-- **Part 4 (Every Choice Is Graph Data):** operator transitions written by Phase 99-01 are read by this renderer to pick shape (Phase 102).
-- **Part 7 (Reuse Before Build):** Phase 99-03 ships the seam, not the muscle. Phase 102 replaces the stub internals without touching callers.
+- **Part 3 (Tri-Context Decision Gate):** DECISION_GATE locks Shape F.x; the renderer enforces this at output time. The v2 entry is reserved for this gate-output side.
+- **Part 4 (Every Choice Is Graph Data):** operator transitions written by Phase 99-01 are read by this renderer to pick shape.
+- **Part 7 (Reuse Before Build):** the v1 shim wraps v2 -- one renderer, two entry points. The Sub-plan E disposition (this section) is itself a Canon Part 7 decision: don't add a parallel prose-side renderer when SKILL.md is the canonical prose contract.
+- **Part 8 (Graph Boundary):** the renderer is pure formatting; no Brain calls anywhere in the chain (D-09).
 
 ## Downstream consumers
 
-- **Phase 99-04 (hooks):** imports `{ render }` for SessionStart restore behavior and PostToolUse rendering.
-- **Phase 99-05 (`/mos:operator` command):** imports `{ render }` for Shape E inspection output.
-- **Phase 102:** owns the actual rendering implementation; the import surface is byte-stable.
+- **lib/render/render.cjs (v1 shim):** the legacy 4-arg positional signature surface. Reuses v2 muscle by construction.
+- **lib/hmi/selector-dispatcher.cjs:** the Shape F / Shape E agent-surface dispatcher; the /mos:* command output side. This is the canonical gate-output consumer.
+
+Any consumer outside this set is a violation of the Sub-plan E disposition. The CI gate at `lib/memory/render-v2-disposition.test.cjs` catches drift; the operator-facing audit at `scripts/disposition-render-v2.cjs` answers the question at any moment.
 
 ## Constraints
 
 - Zero new runtime dependencies (Phase 87 invariant).
 - CJS only (Phase 87 invariant).
-- `render()` import surface MUST remain byte-stable across the Phase 102 swap.
+- `render()` import surface MUST remain byte-stable across the Phase 102 swap (RENDER-102-06 fence).
 - Operator vocabulary frozen at 5 canonical values; any 6th operator requires a Gate 1 review per Phase 99 CONTEXT.md D-03.
+- Disposition: agent-surface-only. Adding a new consumer requires updating the allowlist in `scripts/disposition-render-v2.cjs` AND this ROOM.md in the same commit -- the CI gate enforces parity.
 
 ## See also
 
-- `.planning/phases/99-conversation-operator-state-machine/99-CONTEXT.md` -- canonical context (operator taxonomy, transition table, renderer signature contract D-16, graceful degradation D-17).
-- `.planning/phases/99-conversation-operator-state-machine/99-03-PLAN.md` -- this plan.
-- `docs/MINDRIAN-CANON.md` -- North Star, Part 3 (Tri-Context Decision Gate), Part 4 (Every Choice Is Graph Data), Part 7 (Reuse Before Build).
+- `.planning/phases/99-conversation-operator-state-machine/99-CONTEXT.md` -- operator taxonomy, transition table, renderer signature contract D-16, graceful degradation D-17.
+- `.planning/phases/102-context-aware-rendering/102-CONTEXT.md` -- the Phase 102 implementation spec.
+- `.planning/phases/102-context-aware-rendering/102-VALIDATION.md` -- the Phase 102 validation strategy (Sub-plan E flips this out of draft).
+- `.planning/phases/102-context-aware-rendering/102-VERIFICATION.md` -- the Phase 102 verification record (shipped by Sub-plan E).
+- `.planning/phases/121.5-terminal-coherence-capstone/121.5-CONTEXT.md` -- Sub-plan E disposition rationale.
+- `docs/MINDRIAN-CANON.md` -- North Star, Part 3 (Tri-Context Decision Gate), Part 4 (Every Choice Is Graph Data), Part 7 (Reuse Before Build), Part 8 (Graph Boundary).