riskrails 4.0.1 → 4.2.0

package/.claude-plugin/marketplace.json

@@ -5,7 +5,7 @@
   },
   "metadata": {
     "description": "A weight-based engineering pipeline for Claude Code and Codex: each change is weighed on six axes, runs light, guarded or full, edits only the files its plan names, and ends at human approval — enforced by hooks, reviewed adversarially, routed to the cheap model tier by default.",
-    "version": "4.0.1"
+    "version": "4.2.0"
   },
   "plugins": [
     {
@@ -14,7 +14,7 @@
         "source": "url",
         "url": "https://github.com/vanssata/claude-agentic-sdlc-module.git"
       },
-      "version": "4.0.1",
+      "version": "4.2.0",
       "strict": true
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "riskrails",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "description": "A weight-based engineering pipeline for Claude Code and Codex: each change is weighed on six axes, runs light, guarded or full, edits only the files its plan names, and ends at human approval — enforced by hooks, reviewed adversarially, routed to the cheap model tier by default.",
   "author": {
     "name": "Ivan Kakurov"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "riskrails",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "description": "A weight-based engineering pipeline for Claude Code and Codex: each change is weighed on six axes, runs light, guarded or full, edits only the files its plan names, and ends at human approval — enforced by hooks, reviewed adversarially, routed to the cheap model tier by default.",
   "author": {
     "name": "Ivan Kakurov"

package/README.md

@@ -1,6 +1,6 @@
 # RiskRails
 
-[![Version](https://img.shields.io/badge/version-4.0.1-d2f878?labelColor=101210)](https://github.com/vanssata/claude-agentic-sdlc-module/releases/tag/v4.0.1)
+[![Version](https://img.shields.io/badge/version-4.2.0-d2f878?labelColor=101210)](https://github.com/vanssata/claude-agentic-sdlc-module/releases/tag/v4.2.0)
 [![Runtimes](https://img.shields.io/badge/runtimes-Claude%20Code%20%7C%20Codex-d2f878?labelColor=101210)](docs/routing.md)
 [![Known risks](https://img.shields.io/badge/known%20risks-documented-d2f878?labelColor=101210)](docs/known-risks.md)
 [![License: MIT](https://img.shields.io/badge/license-MIT-d2f878?labelColor=101210)](LICENSE)
@@ -18,7 +18,7 @@ approval. Risky actions are stopped by a hook, not by a polite request in a
 prompt.
 
 ```bash
-npx riskrails@4.0.1   # detects Claude Code, Codex or both (Node 18+, Python 3.11+)
+npx riskrails@4.2.0   # detects Claude Code, Codex or both (Node 18+, Python 3.11+)
 ```
 
 Then, in any project: `/rr-setup` once, and `/rr-build <what you want>` for
@@ -50,7 +50,7 @@ Tuned for **one developer who knows the codebase**, on a Claude Pro, Max or
 Team plan, or a ChatGPT Plus or Pro plan, following the
 [AI-native SDLC playbook](https://claude.com/blog/the-ai-native-sdlc-playbook).
 
-**Version 4.0.1.** The guards have limits: read [Known risks](docs/known-risks.md)
+**Version 4.2.0.** The guards have limits: read [Known risks](docs/known-risks.md)
 before relying on them. What is decided but not built is in [ROADMAP.md](ROADMAP.md).
 
 ## Upgrade to 4.0
@@ -65,7 +65,7 @@ the plugin. Step by step, in this order:
    riskrails goes through the version that still converts it: install it
    (`npx riskrails@3.1.0`), run `/rr-setup --update` with it, then install 4.0.
 2. **Commit every project's `.ai/`** first; `git restore` is the rollback.
-3. **Update the home** on every machine, for every runtime: `npx riskrails@4.0.1`
+3. **Update the home** on every machine, for every runtime: `npx riskrails@4.2.0`
    (the plugin route and the npm route are separate installs: reinstall both
    if you use both). Restart the runtime. In Codex, open `/hooks` and trust the
    changed entries.
@@ -84,16 +84,24 @@ are removed; use the `/rr-*` commands. Details are in
 ## Install
 
 ```bash
-npx riskrails@4.0.1                       # detects Claude Code, Codex, or both; proposes the detected plan
-npx riskrails@4.0.1 --target codex        # auto | claude | codex | both
-npx riskrails@4.0.1 --plan max --fable no # pro | team-pro | team-max | max | max20 | balanced-max
-npx riskrails@4.0.1 --codex-plan plus     # plus | pro | balanced-max
-npx riskrails@4.0.1 --context economy     # the plan's compaction window; the context guard also blocks
-npx riskrails@4.0.1 --statusline own      # keep your own statusline command (from 3.2.1; default: the plugin's two-line statusline)
-npx riskrails@4.0.1 --dry-run             # print what would be written, write nothing
+npx riskrails@4.2.0                       # detects Claude Code, Codex, or both; proposes the detected plan
+npx riskrails@4.2.0 --target codex        # auto | claude | codex | both
+npx riskrails@4.2.0 --plan max --fable no # pro | team-pro | team-max | max | max20 | balanced-max
+npx riskrails@4.2.0 --codex-plan plus     # plus | pro | balanced-max
+npx riskrails@4.2.0 --context economy     # the plan's compaction window; the context guard also blocks
+npx riskrails@4.2.0 --statusline own      # keep your own statusline command (from 3.2.1; default: the plugin's two-line statusline)
+npx riskrails@4.2.0 --dry-run             # print what would be written, write nothing
 npx -y riskrails@latest --yes             # update in place, keeping the recorded plan
 ```
 
+On a terminal each question is a menu — runtime, plan, Fable, context,
+statusline, Codex plan — with the proposal highlighted (the detected or
+recorded runtime, plan, statusline and Codex plan; Fable `yes`, context `default`):
+↑/↓ (or k/j), Home/End or 1–9 to move, Enter to confirm, Esc, q or Ctrl-C to
+stop with nothing written. Enter through every menu installs what detection
+proposes. A flag skips its menu; `--yes` or no terminal asks nothing, and
+`RISKRAILS_MENU=off` (or `TERM=dumb`) brings back the typed plan question.
+
 Pin the version: the hooks it installs see every command an agent runs. It
 installs the managed block, the plan's settings and limits, the five agents
 with their tiers baked in, the hooks, the skills, the shared tree at
@@ -165,7 +173,8 @@ until it passes. After three failed review passes the next verdict is yours.
 ### The record
 
 A closed task's who, what, how and why travel as a compact record: `state.py
-memory enable` (yours, in a terminal) switches a project to packages mode, in
+memory enable` (yours, in a terminal, or as your pick in the `/rr-setup`
+dialog) switches a project to packages mode, in
 which `close` appends the task's entries to a per-developer batch under
 `.ai/memory/` and a pre-push hook validates them; `state.py recall --files …`
 gives an agent what the record holds about the files it is about to touch,
@@ -234,7 +243,7 @@ python3 -I -m unittest discover -s tests -p 'test_*.py'      # CI's serial oracl
 AI_E2E=1 python3 -I -m unittest discover -s tests -p test_end_to_end.py
 ```
 
-Fifty-eight suites, 1133 tests, about 75 seconds in parallel. The guards against JSON fixtures for both runtimes and a
+Sixty suites, 1217 tests, about 75 seconds in parallel. The guards against JSON fixtures for both runtimes and a
 golden of 1 341 recorded decisions, byte for byte, with timed cases that hold
 the hot path under its budget; the state machine, the weight, the batch loop,
 the dialog contract and the documents rule; the compact record and its

package/bin/menu.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+// The installer's arrow-key menu (spec interactive-setup-options R2, R7). Node 18+, stdlib only.
+//
+// bin/riskrails.js runs this file as a child, `spawnSync(process.execPath, [menu.js])` with
+// stdio ['inherit', 'pipe', 'inherit'], and passes the menu in RISKRAILS_MENU_SPEC:
+//   {"title": "plan", "why": "detected from …", "initial": 0,
+//    "items": [{"value": "pro", "label": "pro", "note": "…"}, …]}
+// The child owns the terminal while it runs: raw mode on stdin, the menu drawn on stderr.
+//   Enter          erases the menu, prints `<title>: <value>` (and ` (<why>)` when the value is the
+//                  initial one) on stderr, writes the value to stdout, exit 0
+//   Ctrl-C/Esc/q   erases the menu, exit 130
+//   no terminal    exit 3, nothing drawn: the parent falls back to its typed prompt
+// Keys: ↑/k ↓/j (stop at the ends), Home/End, 1–9 jump to that row, Enter picks.
+'use strict';
+
+// The key, as readline's keypress event gives it, as one of the reducer's tokens (or null).
+function token(key) {
+  if (!key) return null;
+  if (key.ctrl && key.name === 'c') return 'abort';
+  if (key.ctrl || key.meta) return null;
+  const name = key.name || key.sequence;
+  if (name === 'up' || name === 'k') return 'up';
+  if (name === 'down' || name === 'j') return 'down';
+  if (name === 'home' || name === 'end') return name;
+  if (name === 'return' || name === 'enter') return 'enter';
+  if (name === 'escape' || name === 'q') return 'abort';
+  if (/^[1-9]$/.test(String(name))) return String(name);
+  return null;
+}
+
+// The pure step: {index, count, done} and a token → the next state. done is null, 'pick' or 'abort'.
+function reduce(state, tok) {
+  const last = state.count - 1;
+  switch (tok) {
+    case 'up': return { ...state, index: Math.max(0, state.index - 1) };
+    case 'down': return { ...state, index: Math.min(last, state.index + 1) };
+    case 'home': return { ...state, index: 0 };
+    case 'end': return { ...state, index: last };
+    case 'enter': return { ...state, done: 'pick' };
+    case 'abort': return { ...state, done: 'abort' };
+    default: {
+      const n = /^[1-9]$/.test(String(tok)) ? Number(tok) : 0;
+      return n >= 1 && n <= state.count ? { ...state, index: n - 1 } : state;
+    }
+  }
+}
+
+// The menu's lines, each cut to the terminal's width: a wrapped line would break the redraw's count.
+function lines(spec, index, columns) {
+  const fit = (t) => (columns > 1 && [...t].length > columns - 1 ? [...t].slice(0, columns - 2).join('') + '…' : t);
+  const head = `${spec.title}${spec.why ? ` (${spec.why})` : ''} — ↑/↓ to move, Enter to confirm, Esc to abort`;
+  const width = Math.max(...spec.items.map((it) => String(it.label).length));
+  return [fit(head), ...spec.items.map((it, i) => {
+    const mark = i === index ? '❯' : ' ';
+    const row = fit(`${mark} ${i + 1}. ${String(it.label).padEnd(width)}${it.note ? `  ${it.note}` : ''}`);
+    return i === index ? `\x1b[7m${row}\x1b[0m` : row;
+  })];
+}
+
+function main() {
+  let spec;
+  try { spec = JSON.parse(process.env.RISKRAILS_MENU_SPEC || ''); } catch (e) { process.exit(3); }
+  if (!spec || !Array.isArray(spec.items) || spec.items.length === 0) process.exit(3);
+  const stdin = process.stdin;
+  if (!stdin.isTTY || !process.stderr.isTTY) process.exit(3);
+  try { stdin.setRawMode(true); } catch (e) { process.exit(3); }
+
+  const write = (s) => process.stderr.write(s);
+  let drawn = 0;
+  const erase = () => { if (drawn) write(`\x1b[${drawn}A\r\x1b[J`); drawn = 0; };
+  const draw = (index) => {
+    erase();
+    const shown = lines(spec, index, process.stderr.columns || 0);
+    write(shown.join('\n') + '\n');
+    drawn = shown.length;
+  };
+  const restore = () => {
+    try { stdin.setRawMode(false); } catch (e) { /* already gone */ }
+    stdin.pause();
+    write('\x1b[?25h');
+  };
+  const finish = (code, value) => {
+    erase();
+    restore();
+    if (code === 0) {
+      const why = state.index === initial && spec.why ? ` (${spec.why})` : '';
+      write(`${spec.title}: ${value}${why}\n`);
+      process.stdout.write(value, () => process.exit(0));
+    } else {
+      process.exit(code);
+    }
+  };
+  for (const sig of ['SIGTERM', 'SIGHUP', 'SIGINT']) process.on(sig, () => finish(130));
+
+  const initial = Number.isInteger(spec.initial) && spec.initial >= 0 && spec.initial < spec.items.length
+    ? spec.initial : 0;
+  let state = { index: initial, count: spec.items.length, done: null };
+  // A lone Esc: emitKeypressEvents without a readline interface has no escape timeout and would
+  // wait for the rest of a sequence. An arrow key arrives as one chunk (ESC [ B), never as ESC alone.
+  stdin.on('data', (chunk) => { if (chunk.length === 1 && chunk[0] === 0x1b) finish(130); });
+  require('readline').emitKeypressEvents(stdin);
+  write('\x1b[?25l');
+  draw(state.index);
+  stdin.on('keypress', (_str, key) => {
+    const tok = token(key);
+    if (tok === null) return;
+    const next = reduce(state, tok);
+    if (next.done === 'pick') { state = next; finish(0, String(spec.items[state.index].value)); return; }
+    if (next.done === 'abort') { finish(130); return; }
+    if (next.index !== state.index) { state = next; draw(state.index); }
+  });
+  stdin.resume();
+}
+
+module.exports = { reduce, token, lines };
+if (require.main === module) main();

package/bin/riskrails.js

@@ -37,6 +37,12 @@
 //          variables CLAUDE_DIR and CODEX_DIR mean the same). Naming exactly one of them under
 //          --target auto installs that runtime alone.
 // --dry-run prints everything that would be written, per runtime, and writes nothing.
+// On a terminal each choice no flag names is an arrow-key menu, in this order: runtime (only
+//          without --target, --home and --codex-home), plan, fable (max, max20, team-max),
+//          context, statusline, codex plan. The proposal above is highlighted and Enter
+//          confirms it (an undetected plan proposes pro); ↑/↓ or k/j, Home/End and 1-9 move;
+//          Esc, q or Ctrl-C stop with nothing written (exit 130). RISKRAILS_MENU=off or 0, or
+//          TERM=dumb: the typed plan question instead. --yes or no terminal: no question.
 //
 // This is the port of the install.sh that shipped up to 2.0.2: the same tree, the same
 // messages, the same backups (backups/<date>/<path> under the runtime's home). JSON merges
@@ -65,6 +71,8 @@ const HOME = env.HOME || os.homedir();
 let PLAN = '', FABLE = 'auto', DRY = false, TARGET = 'auto', PLAN_GIVEN = false;
 let CODEX_PLAN = '', CODEX_PLAN_GIVEN = false, YES = false;
 let CONTEXT = 'default', STATUSLINE_CONTEXT = 'yes', STATUSLINE = 'riskrails', STATUSLINE_GIVEN = false;
+// A flag that names a choice skips its menu on a terminal (bin/menu.js).
+let TARGET_GIVEN = false, FABLE_GIVEN = false, CONTEXT_GIVEN = false;
 
 function version() {
   try { return JSON.parse(fs.readFileSync(path.join(SRC, 'package.json'), 'utf8')).version || 'unknown'; }
@@ -90,11 +98,11 @@ function usage() {
       return v;
     };
     switch (a) {
-      case '--target': TARGET = take(); break;
+      case '--target': TARGET = take(); TARGET_GIVEN = true; break;
       case '--plan': PLAN = take(); PLAN_GIVEN = true; break;
-      case '--fable': FABLE = take(); PLAN_GIVEN = true; break;
+      case '--fable': FABLE = take(); PLAN_GIVEN = true; FABLE_GIVEN = true; break;
       case '--codex-plan': CODEX_PLAN = take(); CODEX_PLAN_GIVEN = true; break;
-      case '--context': CONTEXT = take(); break;
+      case '--context': CONTEXT = take(); CONTEXT_GIVEN = true; break;
       case '--statusline-context': STATUSLINE_CONTEXT = take(); break;
       case '--statusline': STATUSLINE = take(); STATUSLINE_GIVEN = true; break;
       case '--home': CLAUDE_DIR = path.resolve(take()); CLAUDE_DIR_GIVEN = true; break;
@@ -260,6 +268,51 @@ function ask(prompt) {
 }
 const interactive = () => !YES && process.stdin.isTTY === true;
 
+// A choice on a terminal, as an arrow-key menu: bin/menu.js runs as a child that owns the
+// terminal (raw mode, the menu on stderr) and writes the picked value to stdout. null means
+// no menu — not a terminal, RISKRAILS_MENU=off|0, TERM=dumb, or the child could not take the
+// terminal (exit 3) — and the caller asks as before. An abort exits 130 here, before anything
+// is written: every menu runs in claudeRender/codexRender, ahead of the apply steps.
+const menuOff = () => !interactive() || ['off', '0'].includes(env.RISKRAILS_MENU) || env.TERM === 'dumb';
+function choose(title, items, initial, why) {
+  if (menuOff() || initial < 0) return null;
+  const spec = JSON.stringify({ title, why: why || '', items, initial });
+  const r = spawnSync(process.execPath, [path.join(__dirname, 'menu.js')],
+    { stdio: ['inherit', 'pipe', 'inherit'], env: { ...env, RISKRAILS_MENU_SPEC: spec }, encoding: 'utf8' });
+  if (r.status === 0 && items.some((it) => it.value === r.stdout)) return r.stdout;
+  if (r.status === 130 || r.signal) {
+    if (r.signal) err(`riskrails: the menu was stopped by ${r.signal}; run \`stty sane\` if the terminal misbehaves`);
+    die('riskrails: aborted — nothing was written', 130);
+  }
+  return null;
+}
+const pick = (values, notes) => values.map((v, i) => ({ value: v, label: v, note: notes[i] || '' }));
+
+// --context on a terminal, asked once: by the Claude branch, else before the Codex plan.
+let CONTEXT_ASKED = false;
+function askContext() {
+  if (CONTEXT_GIVEN || CONTEXT_ASKED) return;
+  CONTEXT_ASKED = true;
+  const c = choose('context', pick(['default', 'economy'], ["each runtime's own context window and compaction",
+    "the plan's autoCompactWindow; context-guard also holds a prompt back past 120% of it"]), 0);
+  if (c) CONTEXT = c;
+}
+// --statusline on a terminal: the mode riskrails/statusline.json records is the proposal, read as
+// statuslineGate reads it. Only a different pick counts as given, so Enter keeps today's run.
+function askStatusline() {
+  if (STATUSLINE_GIVEN) return;
+  let mode = '';
+  try {
+    const r = readJSON(path.join(CLAUDE_DIR, 'riskrails', 'statusline.json'));
+    if (isObj(r) && ['riskrails', 'own'].includes(r.mode)) mode = r.mode;
+  } catch (e) { /* none yet */ }
+  const MODES = ['riskrails', 'own'];
+  const v = choose('statusline', pick(MODES, ["the plugin's statusline over your own command (kept, --statusline own brings it back)",
+    'your own statusline command, behind the quota check']), MODES.indexOf(mode || 'riskrails'),
+  mode ? 'recorded by the previous install' : '');
+  if (v && v !== (mode || 'riskrails')) { STATUSLINE = v; STATUSLINE_GIVEN = true; }
+}
+
 // ------------------------------------------------------------------ runtime detection
 let DO_CLAUDE = false, DO_CODEX = false;
 const skippedRuntime = (rt, dir) => err(`${rt}: ${dir} found but no ${rt} on PATH — skipped (--target ${rt} for it alone, --target both for both)`);
@@ -287,7 +340,16 @@ Code or Codex first, or name the runtime yourself:
   npx riskrails --target both        # both, whether or not they are detected`);
   process.exit(1);
 }
-if (TARGET === 'auto') out('detected runtime:' + (DO_CLAUDE ? ' claude' : '') + (DO_CODEX ? ' codex' : ''));
+// On a terminal, with nothing naming the runtime, the detected set is the menu's first proposal.
+let RUNTIME_PICKED = false;
+if (TARGET === 'auto' && !TARGET_GIVEN && !CLAUDE_DIR_GIVEN && !CODEX_DIR_GIVEN) {
+  const RUNTIMES = ['claude', 'codex', 'both'];
+  const detected = DO_CLAUDE && DO_CODEX ? 'both' : DO_CLAUDE ? 'claude' : 'codex';
+  const rt = choose('runtime', pick(RUNTIMES, ['Claude Code', 'Codex', 'Claude Code and Codex']),
+    RUNTIMES.indexOf(detected), `detected: ${detected}`);
+  if (rt && rt !== detected) { DO_CLAUDE = rt !== 'codex'; DO_CODEX = rt !== 'claude'; RUNTIME_PICKED = true; }
+}
+if (TARGET === 'auto' && !RUNTIME_PICKED) out('detected runtime:' + (DO_CLAUDE ? ' claude' : '') + (DO_CODEX ? ' codex' : ''));
 
 const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'riskrails-'));
 process.on('exit', () => rmrf(TMP));
@@ -389,21 +451,37 @@ function detectPlan(runtime) {
   return {};
 }
 
+// The plan question on a terminal: the plan the previous install recorded, else the detected
+// one, is proposed and Enter confirms it; a Team seat, or a plan nothing detected, is typed.
+// On a terminal with the menu on, the six plans are a menu instead: the proposal is the same,
+// and without one it is team-pro for a Team org, else pro (Enter installs it rather than exiting).
+const CLAUDE_PLANS = ['pro', 'team-pro', 'team-max', 'max', 'max20', 'balanced-max'];
+const CLAUDE_PLAN_NOTES = ['Pro', 'Team Standard seat', 'Team Premium seat', 'Max',
+  "Max 20x: max's settings, larger budgets", 'Max account, only the session runs Opus 5.5 (200k window)'];
+function pickClaudePlan(prev, detected, from, org) {
+  const proposed = prev || detected;
+  const first = proposed || (from === 'team' ? 'team-pro' : 'pro');
+  const menuWhy = prev ? 'recorded by the previous install' : detected ? `detected from ${from}`
+    : from === 'team' ? `Team org ${org}, seat unknown` : `could not detect the plan, organizationType='${org}'`;
+  const picked = choose('plan', pick(CLAUDE_PLANS, CLAUDE_PLAN_NOTES), CLAUDE_PLANS.indexOf(first), menuWhy);
+  if (picked !== null) return picked;
+  if (proposed) {
+    const why = prev ? 'recorded by the previous install' : `detected from ${from}`;
+    return ask(`plan: ${proposed} (${why}) — Enter to confirm, or type pro/team-pro/team-max/max/max20/balanced-max: `) || proposed;
+  } else if (from === 'team') {
+    return ask(`Team org detected (${org}) but not the seat. Enter plan [team-pro/team-max]: `);
+  } else {
+    return ask(`Could not detect plan (organizationType='${org}'). Enter plan [pro/team-pro/team-max/max/max20]: `);
+  }
+}
+
 function claudeRender() {
   const PREV_PLAN = prevPlan(CLAUDE_DIR);
   if (!PLAN) {
     const live = detectPlan('claude');
     const org = live.org || '', detected = live.plan || '', from = live.from || '';
     if (interactive()) {
-      const proposed = PREV_PLAN || detected;
-      if (proposed) {
-        const why = PREV_PLAN ? 'recorded by the previous install' : `detected from ${from}`;
-        PLAN = ask(`plan: ${proposed} (${why}) — Enter to confirm, or type pro/team-pro/team-max/max/max20/balanced-max: `) || proposed;
-      } else if (from === 'team') {
-        PLAN = ask(`Team org detected (${org}) but not the seat. Enter plan [team-pro/team-max]: `);
-      } else {
-        PLAN = ask(`Could not detect plan (organizationType='${org}'). Enter plan [pro/team-pro/team-max/max/max20]: `);
-      }
+      PLAN = pickClaudePlan(PREV_PLAN, detected, from, org);
     } else if (detected) {
       PLAN = detected; err(`detected plan: ${PLAN} (${from})`);
     } else if (from === 'team') {
@@ -425,6 +503,14 @@ function claudeRender() {
   if (['balanced_max', 'balancedmax'].includes(PLAN)) PLAN = 'balanced-max';
   if (!plans[PLAN]) die(`--plan must be pro, team-pro, team-max, max, max20 or balanced-max (got '${PLAN}')`, 2);
   const [TIER, PROFILE_NAME, PLAN_LABEL] = plans[PLAN];
+  // The option menus on a terminal, each skipped by its own flag: fable, context, statusline.
+  if (!FABLE_GIVEN && TIER === 'max' && PLAN !== 'balanced-max') {
+    const f = choose('fable', pick(['yes', 'no'], ['Fable 5.1 pinned on architect, the runtime gate on',
+      'no Fable anywhere in this install']), 0, `auto on ${PLAN}`);
+    if (f === 'no') FABLE = 'no';
+  }
+  askContext();
+  askStatusline();
   if (FABLE === 'auto') FABLE = TIER === 'max' && PLAN !== 'balanced-max' ? 'yes' : 'no';
   else if (!['yes', 'no'].includes(FABLE)) die('--fable must be auto|yes|no', 2);
   if ((TIER === 'pro' || PLAN === 'balanced-max') && FABLE === 'yes') {
@@ -1264,22 +1350,35 @@ function claudeSummary() {
 // ~/.codex/auth.json carries chatgpt_plan_type.
 const X = {};   // the Codex branch's rendered values
 
+// The Codex plan question on a terminal: the previous install's plan, else the detected one,
+// is proposed and Enter confirms it; without either the plan is typed.
+const CODEX_PLANS = ['plus', 'pro', 'balanced-max'];
+const CODEX_PLAN_NOTES = ['ChatGPT Plus', 'ChatGPT Pro', 'only the session runs the strong model'];
+function pickCodexPlan(prev, det, why, detected) {
+  const proposed = prev || det;
+  const menuWhy = prev ? 'recorded by the previous install' : det ? `detected from ${why}`
+    : `could not detect the ChatGPT plan, chatgpt_plan_type='${detected}'`;
+  const picked = choose('codex plan', pick(CODEX_PLANS, CODEX_PLAN_NOTES), CODEX_PLANS.indexOf(proposed || 'pro'), menuWhy);
+  if (picked !== null) return picked;
+  if (proposed) {
+    const w = prev ? 'recorded by the previous install' : `detected from ${why}`;
+    return ask(`codex plan: ${proposed} (${w}) — Enter to confirm, or type plus/pro/balanced-max: `) || proposed;
+  } else {
+    return ask(`Could not detect the ChatGPT plan (chatgpt_plan_type='${detected}'). Enter plan [plus/pro]: `);
+  }
+}
+
 function codexRender() {
   const prev = prevPlan(CODEX_DIR);
   // BalancedMax is one routing idea on both runtimes: --plan balanced-max selects the Codex
   // balanced-max profile too, unless --codex-plan says otherwise.
   if (!CODEX_PLAN && PLAN === 'balanced-max') CODEX_PLAN = 'balanced-max';
+  askContext();
   if (!CODEX_PLAN) {
     const live = detectPlan('codex');
     const detected = live.raw || '', det = live.plan || '', why = live.from || '';
     if (interactive()) {
-      const proposed = prev || det;
-      if (proposed) {
-        const w = prev ? 'recorded by the previous install' : `detected from ${why}`;
-        CODEX_PLAN = ask(`codex plan: ${proposed} (${w}) — Enter to confirm, or type plus/pro/balanced-max: `) || proposed;
-      } else {
-        CODEX_PLAN = ask(`Could not detect the ChatGPT plan (chatgpt_plan_type='${detected}'). Enter plan [plus/pro]: `);
-      }
+      CODEX_PLAN = pickCodexPlan(prev, det, why, detected);
     } else if (det) {
       CODEX_PLAN = det; err(`detected codex plan: ${CODEX_PLAN} (${why})`);
     } else if (prev) {

package/hooks/AGENTS.md

@@ -1,6 +0,0 @@
-<!-- riskrails:rule:hooks:start -->
-# Hooks rules
-- Weigh a change by what it does to a user project's decisions, never by the hook being a process every call runs through (constitution C6). The mode is what W gives (`state.py weight`); the rows below set the behaviour axis.
-- behaviour 0: no guard decision moves, golden byte-identical. behaviour 1: adds a deny or changes a deny's text, golden re-recorded. behaviour 2: allows what was denied or weakens a refusal — declare it, `--declare behaviour=2:"<the effect>"`. Start such a task with `start --mode full --by <name>`: its weight lands in guarded, and these effects keep a STRONG review and the gate.
-- The guards defend against an agent's mistakes, not a constructed command: such a finding is accepted in `known-risks.md` under the threat model in `.ai/policies/safety.md`.
-<!-- riskrails:rule:hooks:end -->

package/hooks/CLAUDE.md

@@ -1,6 +0,0 @@
-<!-- riskrails:rule:hooks:start -->
-# Hooks rules
-- Weigh a change by what it does to a user project's decisions, never by the hook being a process every call runs through (constitution C6). The mode is what W gives (`state.py weight`); the rows below set the behaviour axis.
-- behaviour 0: no guard decision moves, golden byte-identical. behaviour 1: adds a deny or changes a deny's text, golden re-recorded. behaviour 2: allows what was denied or weakens a refusal — declare it, `--declare behaviour=2:"<the effect>"`. Start such a task with `start --mode full --by <name>`: its weight lands in guarded, and these effects keep a STRONG review and the gate.
-- The guards defend against an agent's mistakes, not a constructed command: such a finding is accepted in `known-risks.md` under the threat model in `.ai/policies/safety.md`.
-<!-- riskrails:rule:hooks:end -->

package/hooks/guard/dialog.py

@@ -216,12 +216,16 @@ def validate_label(label):
         return None
     if state_label_ok(tokens):
         return None
-    return "a label starts with git commit, git push, a human-only state.py command or npx riskrails@<v>"
+    return ("a label starts with git commit, git push, a human-only state.py command (approve, reject, "
+            "profile set, verify/review/start --by, memory enable) or npx riskrails@<v>")
 
 
 def state_label_ok(tokens):
     """python3 [-I|-S…] <…/state.py> approve|reject|profile set|verify --by|
-    review --by|start --mode … --by."""
+    review --by|start --mode … --by|memory enable [--author S] [--period month|quarter|year]
+    [--index none|sqlite]: each option at most once, as two words, in any order, and no other
+    memory verb. rr_state/labels.py keeps the same rule; tests/test_dialog_contract.py pins the
+    two equal."""
     if not tokens or not INTERPRETER_RE.match(tokens[0]):
         return False
     i = 1
@@ -236,6 +240,14 @@ def state_label_ok(tokens):
         return True
     if rest[:1] in (["verify"], ["review"]):
         return "--by" in rest
+    if rest[:2] == ["memory", "enable"]:
+        # The pick is the exact command the human read: no `--opt=value`, no abbreviation argparse would
+        # take, no positional, an option once, a value of its own kind (an author never starts with '-').
+        names, values = rest[2::2], rest[3::2]
+        kinds = {"--author": None, "--period": ("month", "quarter", "year"), "--index": ("none", "sqlite")}
+        return (len(names) == len(values) == len(set(names)) and set(names) <= set(kinds)
+                and all((v[:1] not in ("", "-")) if kinds[n] is None else v in kinds[n]
+                        for n, v in zip(names, values)))
     return rest[:1] == ["start"] and "--mode" in rest and "--by" in rest