@mindrian_os/cli 2.0.0-beta.3 → 2.0.0-beta.33

package/commands/analyze-timing.md

@@ -0,0 +1,98 @@
+---
+name: analyze-timing
+description: Place a technology on the S-Curve timing clock
+help_jtbd: "Find the timing window your venture sits inside."
+body_shape: "methodology"
+hitl_shape: "F.1"
+hitl_why: "S-curve timing resolves to a single next-move read the navigator confirms."
+serves_jtbd: ["understand-market"]
+# Phase 265-13 reward-before-investment backfill (field only; grounded in the
+# shipped Session Flow: naming the technology surfaces the S-Curve position
+# structure before the navigator invests in the full timing read).
+interactive_first_reward: schema_preview
+teaching: "When you need to know if your technology is too early, too late, or right on time, /mos:analyze-timing places it on the S-Curve. Best before you commit to a launch window."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["S-Curve Analysis", "Adoption-Capacity Theory"]
+produces: "room/**/timing/*"
+inputs: []
+# Phase 265-13: lets the navigation engine OFFER /mos:research at an F.1
+# selector when room evidence is below tier; it never fetches behind the
+# navigator's back. on: matches "Ask: File this to market-analysis?" below;
+# tier: Operational because S-Curve positioning is answered by industry
+# maturity data (adoption curves, analyst benchmarks) once the navigator
+# names the specific performance metric -- single-topic, textbook mid-flow
+# offer per the online-research audit.
+requires_evidence:
+  tier: Operational
+  on: [market-analysis]
+  dispatch: /mos:research
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+# --- Phase 144.1 connector frontmatter ---
+# Phase 172-12 (INV-11 reconciliation): analyze-timing is the connector home for
+# TWO reaches that land on the same command. The PRIMARY connector block declares
+# the S-Curve direct path (SENS-06 -> context_block). The Adoption-Capacity (ACE)
+# diffusion path is surfaced by SENS-09 (lib/core/sensors/sensor-diffusion-adoption.cjs),
+# which fires the FROZEN brain_consult reach with dispatch 'adoption-capacity';
+# the WFL-01 map (data/dispatch-framework-map.json) resolves that to
+# "Adoption-Capacity Theory" -> /mos:analyze-timing via commandsForFramework.
+# SENS-09 is therefore listed in sensor_triggers so the ACE surfacing is
+# first-class in the frontmatter (NO 7th reach minted; brain_consult is frozen).
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-06, SENS-09]
+  reach_id: context_block
+  sub_mode: timing-scurve
+  framework: "S-Curve Analysis"
+  posture: push_forward
+  hierarchy_rank: 27
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+---
+
+<!-- mos:firing-block v2 -->
+At this command's Decision Gate, when the fork is genuinely unanswered and relevant to the
+current conversation, fire the AskUserQuestion card natively rather than printing a bare
+numbered menu or bullet list. Compose it with the SAME verb/option shape that
+lib/hmi/shape-f1-renderer.cjs (renderShapeF1) produces and that lib/hmi/selector-dispatcher.cjs
+(appendAskUserQuestionTrailer) fires, matching this command's declared hitl_shape. Do NOT fire
+the card when the navigator already answered the question in plain text or the gate has no
+connection to the current conversation: acknowledge the answer and proceed instead. Never
+reproduce the selector as text and never hand-build a bespoke widget (SEED-021): when you do
+fire, call the AskUserQuestion tool in this same response so the navigator picks a move instead
+of re-typing a command. Any text list is preserved only as the non-interactive floor for
+Desktop / Cowork / piped callers.
+<!-- /mos:firing-block -->
+
+# /mos:analyze-timing
+
+You are Larry. This command guides the user through S-Curve Analysis.
+
+## Setup
+
+1. Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/analyze-timing.md` for framework details
+2. Read `${CLAUDE_PLUGIN_ROOT}/references/personality/voice-dna.md` for Larry's voice
+3. Read `room/STATE.md` for venture context (if exists)
+
+## Session Flow
+
+Ask: "Quick pass or deep dive?"
+
+Then follow the framework phases from the reference file. Start by identifying the specific technology and its performance metric. Do not accept "AI" or "blockchain" -- demand specificity. Once the metric is named, if market-analysis evidence for its maturity curve is thin, name the gap and offer: "Want to run /mos:research against this context before placing it?"
+
+Timing is not luck. It is reading the S-Curve correctly. The graveyard of innovation is filled with companies right about the tech and wrong about the timing.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to market-analysis?" before writing.
+
+If the conversation reveals a connection to another methodology, suggest it:
+"The timing analysis connects to /mos:research. Want to explore that next?"

package/commands/auto-explore.md

@@ -0,0 +1,85 @@
+---
+description: "Manually trigger auto-explore on a specific file (Desktop fallback when PostToolUse hook does not fire per RESEARCH 4.8)"
+help_jtbd: "Let Larry decompose your domain before you even ask."
+body_shape: "methodology"
+hitl_shape: "F.3"
+hitl_why: "The rabbit-hole exploration asks how deep to keep going, a depth budget."
+# Phase 267.3-06, ruled in 267.3-CLASSIFICATION.md (Row 3): first delivery at commands/auto-explore.md:65, the F.1 dispatch contract carrying the domain-decomposition finding computed over the navigator's own freshly-filed artifact.
+interactive_first_reward: methodology_reframe
+argument-hint: "<file_path>"
+serves_jtbd: ["find-problem", "understand-market", "explore"]
+teaching: "In the moment a new artifact lands, /mos:auto-explore kicks off the same domain decomposition the PostToolUse hook would run. Use it on Desktop when the hook does not fire."
+allowed-tools:
+  - "Bash"
+  - "Read"
+  - AskUserQuestion
+# --- Phase 144.1 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-01]
+  reach_id: context_block
+  sub_mode: auto-explore
+  framework: "Domain Selection"
+  posture: push_forward
+  hierarchy_rank: 17
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+---
+
+# /mos:auto-explore -- Manual auto-explore (Desktop fallback)
+
+On Desktop the PostToolUse hook does not fire (Desktop has no PostToolUse hook surface), so the auto-fire pathway from Phase 117-01's `scripts/auto-explore-fingerprint.cjs` cannot trigger automatically. This command is the **Desktop fallback** per RESEARCH 4.8 -- manual invocation produces the same F.1 contract as the CLI auto-fire path, preserving tri-polar render parity (invariant 4 from VALIDATION.md).
+
+## Steps for Larry
+
+1. Validate that the file at `$1` exists. If not, return: "File not found: $1".
+
+2. Compute material_id:
+
+   ```javascript
+   const store = require('lib/memory/explored-materials-store');
+   const fs = require('node:fs');
+   const stat = fs.statSync(file_path);
+   const material_id = store.computeMaterialId(roomDir, file_path, stat.mtime.getTime());
+   ```
+
+3. Check rate-limit ledger:
+
+   ```javascript
+   const existing = store.findLatest(roomSlug, material_id);
+   if (existing && existing.user_response && !forceFlag) {
+     return "Already explored -- last finding response: " + existing.user_response +
+            ". Re-run with --force to override.";
+   }
+   ```
+
+4. Call surfaceFinding directly (synchronous; no UserPromptSubmit drain needed since this is invoked directly by user):
+
+   ```javascript
+   const agent = require('lib/agents/auto-explore-agent');
+   const result = agent.surfaceFinding({
+     finding: theComputedFinding,
+     roomDir: roomDir,
+     operator: 'AUTONOMOUS',
+     tier: 1,
+   });
+   ```
+
+5. Return the F.1 dispatch contract inline. The user picks Explore / Skip / Later via Larry's AskUserQuestion follow-up turn.
+
+6. Mark surfaced=true in ledger via `store.appendMaterial`.
+
+7. When the user picks an option, call `agent.handleUserResponse` with the chosen verb so the F.1 selection routes back into JSONL state and (on EXPLORE) emits the INFORMS cascade edge.
+
+## Why this exists
+
+Per RESEARCH 4.8, Desktop has no PostToolUse hook. Without this command, Desktop users would never see auto-explore findings. The slash invocation produces the SAME F.1 contract as CLI auto-fire -- verified by the three-surface render parity smoke in VALIDATION.md (invariant 4). This is the structural fix for tri-polar coverage.
+
+## Tri-polar surfaces
+
+| Surface | Auto-fire path | Recovery path |
+|---------|----------------|---------------|
+| CLI | PostToolUse hook (`scripts/auto-explore-fingerprint.cjs`) -> background spawn -> UserPromptSubmit drain (`scripts/auto-explore-drain.cjs`) | SessionStart preflight (`scripts/preflight-auto-explore.cjs`) |
+| Cowork | Same as CLI | Same as CLI |
+| Desktop | NONE (no PostToolUse) | This slash command + SessionStart preflight drain |

package/commands/beautiful-question.md

@@ -0,0 +1,76 @@
+---
+name: beautiful-question
+description: Reframe a challenge as Why / What-if / How
+help_jtbd: "Reformulate the problem before solving the wrong one."
+body_shape: "methodology"
+hitl_shape: "F.9"
+hitl_why: "The Why then What-if then How progression is a fixed-order walk."
+serves_jtbd: ["find-problem", "explore"]
+# Phase 265-13 reward-before-investment backfill (field only; grounded in the
+# shipped Session Flow: Phase 1 (WHY) reframes the navigator's own sentence as
+# a sharper question before they invest beyond it, same shape as onboard).
+interactive_first_reward: reframe_question
+teaching: "When the framing feels stuck, /mos:beautiful-question reshapes the challenge as Why / What-if / How. The right question unlocks more progress than a better answer."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Beautiful Question Framework"]
+produces: "room/problem-definition/beautiful-question/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+# --- Phase 144.1 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-06]
+  reach_id: context_block
+  sub_mode: beautiful-question
+  framework: "Beautiful Question Framework"
+  posture: push_forward
+  hierarchy_rank: 30
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+---
+
+<!-- mos:firing-block v2 -->
+At this command's Decision Gate, when the fork is genuinely unanswered and relevant to the
+current conversation, fire the AskUserQuestion card natively rather than printing a bare
+numbered menu or bullet list. Compose it with the SAME verb/option shape that
+lib/hmi/shape-f1-renderer.cjs (renderShapeF1) produces and that lib/hmi/selector-dispatcher.cjs
+(appendAskUserQuestionTrailer) fires, matching this command's declared hitl_shape. Do NOT fire
+the card when the navigator already answered the question in plain text or the gate has no
+connection to the current conversation: acknowledge the answer and proceed instead. Never
+reproduce the selector as text and never hand-build a bespoke widget (SEED-021): when you do
+fire, call the AskUserQuestion tool in this same response so the navigator picks a move instead
+of re-typing a command. Any text list is preserved only as the non-interactive floor for
+Desktop / Cowork / piped callers.
+<!-- /mos:firing-block -->
+
+# /mos:beautiful-question
+
+You are Larry. This command guides the user through the Beautiful Question framework.
+
+## Setup
+
+1. Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/beautiful-question.md` for framework details
+2. Read `${CLAUDE_PLUGIN_ROOT}/references/personality/voice-dna.md` for Larry's voice
+3. Read `room/STATE.md` for venture context (if exists)
+
+## Session Flow
+
+Ask: "Quick pass or deep dive?"
+
+Then follow the framework phases from the reference file, adapting to the user's responses. You are NOT following a rigid script -- the phases are a guide. If the user provides rich context, skip ahead. If they need more exploration, slow down.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to problem-definition?" before writing.
+
+If the conversation reveals a connection to another methodology, suggest it:
+"The question you've crafted connects to /mos:explore-domains. Want to explore that next?"

package/commands/bono.md

@@ -0,0 +1,152 @@
+---
+name: bono
+description: Run a BONO research debate over a what-if hypothesis
+help_jtbd: "Spawn a parallel research swarm, debate it as inter-hat arguments over a graph-proposed what-if, and land a navigator-confirmed synthesis."
+body_shape: B (Semantic Tree)
+hitl_stages:
+  - stage: "topic-confirm"
+    shapes: ["F.1"]
+    mode: "gate"
+  - stage: "hypothesis-confirm"
+    shapes: ["F.1"]
+    mode: "gate"
+  - stage: "ruling"
+    shapes: ["F.5"]
+    mode: "gate"
+hitl_why: "Bono halts at three navigator decision surfaces: topic-confirm (F.1) frames the scope and reads the room's JTBD, hypothesis-confirm (F.1) anchors the what-if the debate bears on, and ruling (F.5) resolves the governed positions into a verb."
+body_shape_detail: A Shape F selector front door, then a governed parallel cell fan-out with per-persona research, then a governed sequential inter-hat debate as nested decision gates, then a MECE-Minto conclusion closed through the shared graph-write spine
+serves_jtbd: ["explore", "decide-pursue"]
+teaching: "When you have a wicked question and need a structured argument rather than one opinion, /mos:bono spawns a governed research swarm across the (subdomain x hat) grid, each persona bound to its hat's scrutiny discipline and its own wired sources, then debates the readings as a sequential inter-hat argument over a graph-proposed what-if hypothesis. The navigator confirms the topic, the hypothesis, and the ruling at three decision gates; the MECE-Minto synthesis files only on APPROVE and closes the loop into the room's logical graph."
+interactive_first_reward: reframe_question
+ui_reference: skills/ui-system/SKILL.md
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Six Thinking Hats"]
+produces: "room/solution-design/*"
+inputs: []
+autonomous_safe: false
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - WebSearch
+  - WebFetch
+  - AskUserQuestion
+# --- Phase 164-05 connector frontmatter (D-164-S4: the GENERATED front door) ---
+# --- /mos:bono rides the FROZEN hats reach with a NEW bono sub_mode. It is NEVER
+#     a 7th reach: the inter-hat debate IS a Six Thinking Hats surface, so it
+#     shares the hats reach_id / framework with /mos:think-hats (six-hats) as a
+#     second sub_mode. The connector block is GENERATED, not hand-minted: run
+#     scripts/build-connector-registry.cjs so the tuple lands in
+#     data/connector-registry.json and --check stays clean (no 7th reach, no
+#     duplicate reach_id + sub_mode tuple). posture: hold, because the debate HALTS
+#     at the three material Part 3 Decision Gates (topic-confirm + hypothesis-confirm
+#     + ruling). web_scope: green, because the per-persona web research legs are now
+#     first-class (direction stays SIGNAL -> LOCAL, proven by the Part 8 egress
+#     guard: generic subdomain handles cross toward the public web, never LOCAL
+#     content toward the Brain). ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-17]
+  reach_id: hats
+  sub_mode: bono
+  framework: "Six Thinking Hats"   # MUST match the existing frameworks: value
+  posture: hold
+  hierarchy_rank: 4
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: green
+  surface: F.1
+---
+
+# /mos:bono
+
+You are Larry. This command is the front door for the BONO Research/Debate Engine: a navigator arrives with a wicked question and needs a structured ARGUMENT over it, not one flat opinion. `/mos:bono` runs a GOVERNED, twice-fanned research debate. Fan one spreads a research swarm across the (subdomain x hat) grid, each persona bound to its hat's scrutiny discipline and its own wired world-of-knowledge. Fan two debates the collected readings as a SEQUENTIAL inter-hat argument over a graph-proposed what-if hypothesis. The navigator confirms the topic, the hypothesis, and the ruling at three Decision Gates; the terminal MECE-Minto synthesis files to `solution-design/` only on APPROVE and CLOSES THE LOOP into the room's logical graph.
+
+`/mos:bono` is ORCHESTRATION, not a new atom (Canon Part 7). It SEQUENCES the shipped BONO substrate: Engine 1 decomposition, the Wave-2 library-first team assembly (`lib/core/expert-library.cjs` `assembleTeam`), the Wave-4 parallel cell fan-out (`lib/core/bono/cell-fanout.cjs` `runCellFanout`), and the Wave-5 sequential debate composition (`lib/core/bono/debate-composition.cjs` `runDebate`). Phase 223 wires three governance seams onto that same substrate WITHOUT minting a new loop runtime, a new derivation loop, or a new edge type: `lib/core/bono/hat-governance.cjs` (`HAT_GOVERNANCE`, `assertHeterogeneity`, `composeGovernedSeams`), `lib/core/bono/persona-research.cjs` (`personaDispatchCell`, `validateCitations`), and the shared close-the-loop spine `lib/core/close-loop-writer.cjs` (`writeCloseLoop`, `findPriorConclusion`) plus the version-cut walker `lib/core/temporal/supersession.cjs` `walkSupersedesChain`. The ONLY net-new surface is this selector + the flow that wires the shipped pieces together.
+
+The surface was scaffolded via the documented `/mos:new-surface` path (D-164-S4): the connector block above is GENERATED by `scripts/build-connector-registry.cjs`, pinned to the FROZEN `hats` reach + a `bono` sub_mode. It is NEVER a 7th reach (the inter-hat debate IS a Six Thinking Hats surface, so it shares the `hats` reach with `/mos:think-hats`).
+
+#### The 8-phase governed flow
+
+## 1. Topic-confirm + JTBD orientation
+
+Render a Shape F selector (the AskUserQuestion primitive, Canon Part 3; see `skills/ui-system/SKILL.md`) gathering:
+
+- **scope** -- the domain / subdomain grid the swarm will fan out over (seeded from Engine 1 decomposition).
+- **purpose** -- what the debate is FOR (a decision, a thesis stress-test, a reframing).
+- **substrates** -- which evidence sources the cells may reach (LOCAL graph + the hat-scoped public web legs; never Brain user data, Part 8).
+- **hypothesis seed** -- a candidate "what if" Larry surfaces from the room graph; the navigator refines it at phase 5's gate.
+
+Before rendering, read the room's active JTBD via `lib/hmi/jtbd-state.cjs` `getCurrent(roomDir)` and let it ORIENT the scope options (a validate-idea JTBD sharpens the grid toward the risky assumption; an explore JTBD widens it). This is the F.1 **topic-confirm** gate: the navigator picks; the selection becomes a typed edge (Part 4). No bespoke dialog.
+
+## 2. Domain decomposition
+
+Run Engine 1 decomposition over the confirmed scope to build the subdomain grid (the existing substrate, UNCHANGED). Each subdomain becomes one axis of the (subdomain x hat) cell grid the fan-out runs over.
+
+## 3. Governed team assembly
+
+Assemble the persona roster with the Wave-2 library-first `assembleTeam` (confirmed `SyntheticExpert` nodes first, generate the gaps, with the three anti-ossification guards -- a mandatory fresh slot, Black always re-derived, the reuse cap K < N; all unchanged). Then bind governance: each persona slot binds to `HAT_GOVERNANCE[hat]`'s scrutiny discipline (White cite-or-retract, Black ACH disconfirming-first, Yellow evidence-backed value, Green provocation-marked, Red no-justification, Blue anti-convergence judge). Run `assertHeterogeneity` over the assembled cells; if two cells share an identical lens, a duplicate-lens slot is RE-DRAWN before any research fires (Req 1: the heterogeneity mandate holds at assembly time, not after the fact).
+
+## 4. Per-persona research fan
+
+Launch the Wave-4 parallel `runCellFanout` over the (subdomain x hat) grid with `dispatchCell = personaDispatchCell` (Plan 01). Each cell runs `extractContext` -> `runSourceLens` -> `wireAccept` on a GENERIC subdomain handle only (Part 8); the accepted sources become that persona's wired INFORMS world-of-knowledge (an EvidenceClaim `proposed` node + an `INFORMS` edge through the navigation chokepoint). A persona may not later assert beyond its own wired set. `part8-egress-guard.classify` is the fail-closed pre-egress gate: only the generic handle crosses toward the public web, never LOCAL content toward the Brain (this is why `web_scope` is `green`, SIGNAL -> LOCAL). `planDispatch` sizes the fan and the fan cap stays the cost control; the fan is PARALLEL and is never re-run inside the debate loop (D-164-S2).
+
+## 5. Hypothesis-confirm + governed debate
+
+The F.1 **hypothesis-confirm** gate HALTS so the navigator confirms or edits the graph-proposed what-if. The confirmed hypothesis is the debate's anchor (the `hypothesisId` the per-hat derived relationships bear on).
+
+Then hand the collected cell array into `runDebate` (Wave-5 `debate-composition.cjs`) as the runChain seed `previousOutput`, with `composeGovernedSeams` injected as its `{deriveFn, selfCritiqueFn, onStep}` options. The `deriveFn` stays SYNCHRONOUS over pre-resolved data (CR-01: any thenable is coerced to `[]` so no Promise reaches `runDerivation`). `validateCitations` rides the self-critique so no persona asserts beyond its wired sources. The debate is a runChain step sequence: one per-hat argument step per hat (the consolidator argues that hat's stance over ITS slice of the collected cells, governed by `enforceGovernance`), then the F.5 **ruling** gate HALTS and emits a verb in `supported | rejected | refined | undecided` plus a residual-tension record.
+
+The graph writes COMPOSE on the shipped substrate (Canon Part 7), never a hand-rolled loop and never a direct navigation edge-writer call: the per-step DERIVED relationships ride `lib/core/graph-derivation.cjs` `runDerivation` (a PROPOSED truth-claim node + a frozen `CASCADE_SUBSET` edge through the chokepoint, governance-critiqued, idempotent).
+
+## 6. MECE-Minto synthesis + unknowns matrix
+
+Apply the Pyramid + MECE discipline of `/mos:structure-argument` to emit the conclusion as narrative-schema JSON (`lib/memory/narrative-schema.cjs` `validateNarrative`-conformant: `governing_thought` <= 250 chars, 3-5 `key_claims`, no em-dashes anywhere). Apply the `/mos:map-unknowns` Rumsfeld matrix to produce the unknowns base (the open questions the debate could not close). Reuse those two commands' vocabulary; do not re-derive the disciplines. `lib/memory/feynman-prompts.cjs` is NOT touched (a byte-checked SPEC constraint: the conclusion step borrows the Pyramid discipline, it does not edit the Feynman stage prompts).
+
+## 7. Close the loop
+
+Detect a re-run first: `findPriorConclusion(db, topic_hash)` (from `lib/core/close-loop-writer.cjs`) looks up any prior conclusion on the same topic. Then make ONE `writeCloseLoop` call carrying claims / relations / killed / conclusion / knowns / unknowns / opportunities, plus `priorConclusionId` when a confirmed prior exists. The writer is the ONE spine both 223 surfaces terminate through: D-01 dual write (opportunity bank .md FIRST, room.db node SECOND, one shared artifact_id) and D-02 proposed edges live INSIDE the writer; the command never bypasses it. Every node is born `review_status: proposed` (Part 9). After the write, run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/compute-opportunity-state" <roomDir>` so the bank rollup surfaces the new opportunity nodes (Req 4).
+
+## 8. Version cut + --version-log
+
+The SUPERSEDES chain is written by phase 7's supersede path (D-04: the SUPERSEDES edge binds NULL `review_status` -- it is mechanical bookkeeping; the new conclusion NODE is what the navigator ratifies). CONTRACT: `supersede` requires the prior conclusion to be CONFIRMED (confirmed -> superseded is the only legal transition). NEVER auto-confirm a prior conclusion to force a chain; confirmation is `confirmNode(byUser)` only (Part 9). A proposed prior yields a new proposed conclusion plus a DISCLOSED "no chain written: prior unconfirmed" outcome (the SEED-059 disclosed-thin-world convention), never a silent no-op and never an auto-confirm.
+
+`--version-log` renders `walkSupersedesChain(db, newestConclusionId)` as a chain-order list: newest first, one line per conclusion with its `created_at` and a governing-thought snippet. A first run renders a single-entry log and ZERO SUPERSEDES edges (no false chain on a first run).
+
+#### Hard rules (in-body)
+
+- **All writes are LOCAL** through `lib/core/navigation.cjs`, reached ONLY through the `runDerivation` + `wireAccept` / `writeCloseLoop` chokepoints (Part 9). The command never calls the navigation edge-writer directly and never mints a new edge type; every semantic edge draws from the frozen `ALLOWED_EDGE_TYPES` set (`SUPPORTS` / `CONTRADICTS` / `CONVERGES` / `INFORMS` / `REJECTED_BECAUSE` / `SUPERSEDES` / `CASCADE_SUBSET`).
+- **Everything the hats conclude is `proposed`** (Part 9): claims, the conclusion node, knowns, unknowns, and opportunities all land `review_status: proposed`. Only a human confirms a truth-claim node via `navigation.confirmNode(byUser)`. The engines propose; the navigator ratifies.
+- **Brain is generic-methodology read-only** (Part 8): any hat's Brain leg carries framework names + problem-type enums ONLY, never venture content. Zero user-content egress; `part8-egress-guard.classify` is the fail-closed gate on every Brain-bound payload.
+- **Governance is debate-only** (Plan 01 scope caution): `HAT_GOVERNANCE` disciplines the assembled personas and the debate steps; it is never live-conversation enforcement.
+- **Tri-polar** (Canon Tri-Polar rule): on CLI the dial-TUI Shape F selectors drive the three gates + the composition runs via the shipped modules; on Desktop / Cowork the same gates render as a structured-prompt fallback (no TUI), with the navigator confirming the topic, hypothesis, and ruling conversationally.
+- No emoji, no em-dashes; the 12-glyph UI vocabulary only; 3-line errors.
+
+#### Offer high-value hats as reusable SyntheticExperts
+
+At the ruling gate, offer the run's high-value hats for filing as reusable `SyntheticExpert` nodes (Wave-2 `offerExpertsForFiling`). The navigator APPROVEs which experts are worth keeping; promotion to `confirmed` rides `navigation.confirmNode(byUser)` (Part 9 role 5: the human confirms truth).
+
+#### Decisions carried (D-164, updated for Phase 223)
+
+The Phase-164 constitutional decisions still bind; Phase 223 only names the new modules they route through:
+
+- **D-164-S2 (fan is parallel, never looped):** the (subdomain x hat) research fan runs through `runCellFanout` with `personaDispatchCell`, capped by `planDispatch`; the collected cells seed the debate as `previousOutput` and are never re-run inside `runDebate`.
+- **D-164-S3 (two-layer critique):** the governance self-critique (`composeGovernedSeams`'s `selfCritiqueFn`, carrying `validateCitations`) rides the material debate steps AND is passed into `runDerivation`, so a bad debate step or a bad derived relationship is caught before it folds forward.
+- **D-164-S4 (generated front door):** the connector block above is machine-generated by `scripts/build-connector-registry.cjs`; author it, then regenerate, never hand-trust the final block.
+- **D-164-S5 (incremental filing):** each debate step journals via `pipeline-state.cjs` before the next runs, so a crashed run resumes from the cursor; the `isNext` HARD gate prevents a re-run of completed steps.
+
+#### Cost controls
+
+The three gates are the cost brake: `planDispatch` budget-caps the research fan, the topic-confirm gate bounds the grid before any web leg fires, and the hypothesis-confirm gate anchors the debate before the per-hat arguments run. A `quality: low` reading is caught by the governance self-critique BEFORE it propagates into the debate, so a thin cell never drives a conclusion.
+
+#### Footer routing
+
+When the navigator's intent is better served by a single-perspective hat surface or a persona lens, footer-route:
+
+- `commands/think-hats.md` -- the six-hats single-pass surface (the `hats` reach `six-hats` sub_mode) when the navigator wants one structured pass rather than the full research debate.
+- `commands/persona.md` -- the persona lens when the navigator wants to embody one team member rather than run the inter-hat argument.
+- `commands/intel-pipeline.md` -- the JTBD-driven meta-orchestrator sibling when the navigator wants the calibrate-through-write-to-graph loop against the whole room rather than a single what-if debate.
+
+All are sibling surfaces on the same governed spine; `/mos:bono` is the full governed research-debate orchestration, the others are the lighter single-surface entry points.

package/commands/brain-derive.md

@@ -0,0 +1,137 @@
+---
+description: Derive BRAIN.md for section(s) now
+help_jtbd: "Pull the Brain's framework recommendations for your current section."
+body_shape: E
+hitl_shape: "F.0"
+hitl_why: "It surfaces one derived Brain packet for a single APPROVE, REJECT, or DEFER."
+argument-hint: "[section] [--all] [--cross-room] [--dry-run] [--review-anchors] [--orphan-census] [--cross-label-dups]"
+serves_jtbd: ["audit-room"]
+# Phase 245-02: this command becomes spine-invocable below, so the Phase 118-06
+# reward-before-investment rule now applies to it. schema_preview is the value
+# the command already implements: `--dry-run` previews the target sections and
+# their cost without firing a single Brain call or writing any BRAIN.md, which
+# is a structural preview of what WOULD be derived, handed over before the user
+# invests anything. Grounded in shipped behavior, not aspirational.
+interactive_first_reward: schema_preview
+teaching: "When a room section drifts from its BRAIN.md derivation, /mos:brain-derive rebuilds the per-section Brain context now. Run after large filings or before a decision gate."
+disable-model-invocation: false
+allowed-tools: Bash(node *), AskUserQuestion
+# --- Phase 245-02 CIRS R1 wire (Canon Part 11), promoting the Phase 172-06 exclude ---
+# The 172-06 exclude named its own promotion condition: "INV-06 promotion
+# candidate (a future mindrian-operation counterpart could make derivation
+# contextually triggered), excluded for now." That counterpart now ships: the
+# governing-thought-change enqueue, the BRAIN_STALE_AGE_DAYS session-start
+# enqueue, and the UserPromptSubmit drain make derivation contextually
+# triggered, so the explicit ask is the third arm of a live trigger set rather
+# than a manual-only maintenance knob. SENS-03 is not invented here: the drain
+# already fires sensor 'SENS-03' with surface 'brain_consult', dispatch
+# 'brain-derivation' and posture 'hold' through navigation.logSpineRead
+# (scripts/brain-derivation-drain.cjs), so this declaration describes live
+# behavior. framework: null is the additive-degrade case (CONNECTOR-CONTRACT.md
+# section 4): no methodology framework fires on APPROVE, only the derivation.
+connector:
+  excluded: false
+  connects_to_spine: true
+  sensor_triggers: [SENS-03]
+  reach_id: brain_consult
+  sub_mode: brain-derive
+  framework: null
+  posture: hold
+  hierarchy_rank: 61
+  filing: memory_event_only
+---
+
+<!-- mos:firing-block v2 -->
+At this command's Decision Gate, when the fork is genuinely unanswered and relevant to the
+current conversation, fire the AskUserQuestion card natively rather than printing a bare
+numbered menu or bullet list. Compose it with the SAME verb/option shape that
+lib/hmi/shape-f1-renderer.cjs (renderShapeF1) produces and that lib/hmi/selector-dispatcher.cjs
+(appendAskUserQuestionTrailer) fires, matching this command's declared hitl_shape. Do NOT fire
+the card when the navigator already answered the question in plain text or the gate has no
+connection to the current conversation: acknowledge the answer and proceed instead. Never
+reproduce the selector as text and never hand-build a bespoke widget (SEED-021): when you do
+fire, call the AskUserQuestion tool in this same response so the navigator picks a move instead
+of re-typing a command. Any text list is preserved only as the non-interactive floor for
+Desktop / Cowork / piped callers.
+<!-- /mos:firing-block -->
+
+# /mos:brain-derive
+
+Force-refresh BRAIN.md per section via the Brain derivation pipeline. This is the manual knob users reach for when the automatic triggers (hash-change queue drain, session-start staleness scan) are not enough because they want to inspect explicitly, or the room has no recent regeneration activity.
+
+## Modes
+
+- `/mos:brain-derive <section>` -- derive one section
+- `/mos:brain-derive --all` -- derive every active section in the current room
+- `/mos:brain-derive <section> --cross-room` -- add structural cross-room contradiction scan for that one section
+- `/mos:brain-derive --all --cross-room` -- most expensive; cross-room scan on every section
+- Append `--dry-run` to any mode above to preview targets + cost without firing any Brain calls or writing BRAIN.md
+
+## Curation surfaces (Phase 130.7-03)
+
+Three standalone reporting modes that pair with the dual-graph health gate so curation debt becomes visible within days, not months. Each runs a read-only methodology-node aggregate (the 2026-05-17 brain-curation audit queries) and prints a digest. They are REPORTING surfaces that feed Phase 132 dedup -- they never themselves dedup or fail a build, and they are mutually exclusive with each other and with the derive path (each is standalone, like `--all`).
+
+- `/mos:brain-derive --review-anchors` -- the REVIEW_REQUIRED queue digest (audit Q1): the count of frameworks stuck in curation review plus a sample list.
+- `/mos:brain-derive --orphan-census` -- the all-label orphan census (audit section 7): a per-label table of zero-edge node counts plus the total orphan mass.
+- `/mos:brain-derive --cross-label-dups` -- same-name-different-label collisions (audit section 13): groups of one canonical name carrying more than one distinct primary label, each listing its variant labels (keyed by correlation_id collisions across primary_label, feeding the Phase 132 dedup pass).
+
+When the Brain is offline, each curation mode degrades to a single-line "Brain offline" message and exits 0 (soft-fail), exactly like the derive path.
+
+## Output
+
+Shape E Action Report (Canon Part 3 UI Ruling System; same structure as `/mos:diagnostics` from Phase 88.6 Plan 02). Five summary rows plus a PER SECTION breakdown plus a NEXT action footer:
+
+- Sections derived: N / M
+- Schema gates: passed X / failed Y
+- Cross-room: Z contradictions surfaced / scanned rooms
+- Brain offline: A sections skipped (rate-limited flag if applicable)
+- Cost tokens: ~T
+
+When there are more than 3 target sections, per-section progress streams to stderr as each completes: `[1/7] market-analysis: derived`. The final Shape E report renders to stdout at the end.
+
+## Graceful degradation
+
+- **Brain offline from start**: single-line "Brain offline, no derivation possible" message, zero derivations, exit 0 (soft-fail). The user has not done anything wrong; BRAIN.md is enrichment, not a gate.
+- **Rate-limited mid-batch**: the first rate_limited result stops further Brain calls. Every remaining section is recorded as skipped with reason rate_limited. The rendered report carries the flag and the NEXT footer suggests retrying in a few minutes.
+- **Schema gate rejection on one section**: other sections still derive. The failed section appears in the PER SECTION block with the schema violation summary. The command does NOT attempt to force-write a schema-invalid BRAIN.md.
+- **Invalid section name**: exit 1 with a pointer to the active room and a hint to list sections.
+- **No active room**: exit 1 with "Set one with /mos:rooms switch <slug>".
+
+## Canon references
+
+- **Canon Part 3 (Tri-Context Decision Gate)**: output uses the Shape E Action Report body shape so the user sees a LOCAL + BRAIN snapshot of what was derived this run.
+- **Canon Part 7 (Reuse Before Build)**: the command wraps the existing `deriveSection` entry point (Plan 90-01) and the cross-room aggregator (Plan 90-06). No new derivation logic is introduced at the command layer.
+- **Canon Part 8 (Graph Boundary)**: the command adds zero net new Brain surface. Every Brain call still routes through `deriveSection` which has its chokepoint (`buildBrainQueryContext`), the prompt-builder allow-list schema, the invariants body scan, and the cross-room sanitize + JSON.stringify audit. The dispatcher only sequences those calls and renders results.
+
+## Invocation
+
+Run the dispatcher via Bash:
+
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/brain-derive-command.cjs $ARGUMENTS
+```
+
+## Examples
+
+```
+/mos:brain-derive market-analysis
+/mos:brain-derive --all
+/mos:brain-derive --all --cross-room
+/mos:brain-derive market-analysis --dry-run
+/mos:brain-derive --all --cross-room --dry-run
+```
+
+## Exit codes
+
+| Exit | Meaning |
+| --- | --- |
+| 0 | Success (including Brain-offline soft-fail and all partial-completion paths) |
+| 1 | Invocation error: no active room, invalid section name, or missing arguments |
+
+## Cross-surface adaptation
+
+- **CLI**: full power. Slash command resolves via Claude Code's plugin hook substrate and runs the dispatcher through the Bash tool. Shape E report renders in the terminal.
+- **Desktop**: the same slash command runs when the plugin is connected. Larry may narrate the result conversationally; the underlying dispatcher is identical.
+- **Cowork**: same as CLI. Team members see the regenerated BRAIN.md through the shared `00_Context/` snapshot on their next session-start.
+
+No surface-specific code exists anywhere in the dispatcher.