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

package/commands/root-cause.md

@@ -0,0 +1,77 @@
+---
+name: root-cause
+description: Trace root cause via 5-Whys, Fishbone, Fault Tree
+help_jtbd: "Trace the root cause of a symptom in your venture."
+body_shape: "methodology"
+hitl_shape: "F.9"
+hitl_why: "The 5-Whys and fishbone drill down in a fixed order, an ordered walk toward the root."
+serves_jtbd: ["find-problem"]
+# Phase 265-13 reward-before-investment backfill (field only; grounded in the
+# shipped Session Flow: the first Why reframes the navigator's own symptom as
+# a sharper question before they invest in the full 5-Whys drill).
+interactive_first_reward: reframe_question
+teaching: "When the symptom keeps coming back, /mos:root-cause traces it via 5-Whys, Fishbone, and Fault Tree. Treats the cause, not the recurrence."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Root Cause Analysis"]
+produces: "room/**/root-cause/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-06]
+  reach_id: context_block
+  sub_mode: root-cause-5why
+  framework: "Root Cause Analysis"
+  posture: hold
+  hierarchy_rank: 42
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+  surface: F.2
+---
+
+<!-- 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:root-cause
+
+You are Larry. This command guides the user through Root Cause Analysis.
+
+## Setup
+
+1. Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/root-cause.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 root cause you found connects to /mos:find-bottlenecks. Want to explore that next?"

package/commands/rs-experts.md

@@ -0,0 +1,153 @@
+---
+name: rs-experts
+description: Resolve the expert network for a topic from the local room mirror
+help_jtbd: "Surface the expert profiles for a reverse salient."
+body_shape: D (Comparison Matrix)
+hitl_shape: "F.8"
+hitl_why: "A synthetic expert panel is generated as an independent set consulted in any order."
+serves_jtbd: ["find-bottleneck", "connect-domains"]
+interactive_first_reward: instant_brief
+teaching: "When you need to know who in the world is working on a reverse salient you found, /mos:rs-experts resolves the expert network from your local room mirror, populated by /mos:rs-fetch. Routes you to the people who already know."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Reverse Salient Analysis"]
+produces: "room/**/rs-experts/*"
+inputs: []
+autonomous_safe: true
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+  # mcp__mindrian-brain__read_neo4j_cypher intentionally removed (BUG 2 fix):
+  # Author/Paper/Institution nodes are LOCAL-only (populated by /mos:rs-fetch).
+  # The remote Brain must never be called from this command.
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-02]
+  reach_id: context_block
+  sub_mode: reverse-salient-experts
+  framework: "Reverse Salient Analysis"   # MUST match the existing frameworks: value
+  posture: pull_back
+  hierarchy_rank: 4
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+  surface: F.1
+---
+
+<!-- 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:rs-experts
+
+You are Larry. This command resolves the expert network for a topic from the local Aura instance (Tier 1). Authors and institutions accumulate in Aura via `rs-fetcher-experts` (Phase 89.2-05) and `rs-expert-mapper.mapAuthorsToAura` (Phase 89.3-04) during prior `/mos:rs-fetch` runs. `resolveExpertTier` (Phase 296-02) distinguishes three named outcomes rather than one collapsed message:
+
+- `AURA_TRANSPORT_ABSENT` -- no local Aura transport ships yet (the only branch reachable today). A capability statement, not a fault.
+- `BRAIN_UNREACHABLE` -- a transport is present but the instance cannot be reached. Copy comes verbatim from `lib/core/refusal-messaging.cjs`, never invented at this surface.
+- A topic with genuinely zero experts -- a SUCCESS (`tier: 'tier1'`, `authors: []`, `matched: 0`, no `refusal_code`), not a fault. An empty answer is a correct answer.
+
+**Synopsis:**
+
+    /mos:rs-experts <topic>
+    /mos:rs-experts <topic> --json
+    /mos:rs-experts <topic> --limit 20
+
+## What it does
+
+1. Validates `<topic>` against Canon Part 8 (`auditQueryString` on the bound parameter; throws `ExternalEgressViolation` if forbidden bytes appear).
+2. `scripts/rs-experts-command.cjs`'s own BUG 2 fix note (2026-05-22, still current): the former Tier 1 path called `brainClient.query(cypher)`, which routes to the REMOTE Brain -- but Author/Paper/Institution nodes live in the user's LOCAL Aura mirror, not the Brain. That routing bug is fixed by REMOVAL: `brainClient` is never loaded by this command, and `brainClient.isAvailable()` does NOT gate an Aura-availability check here -- it checks the Brain key, a fully separate probe (Phase 252-01, SWEEP-01: this line previously named `brainClient.isAvailable()` as an Aura-availability detector, which was the wrong probe -- the Brain key and the Aura connection are unrelated).
+3. No live Tier 1 Aura query path ships in the current command. Every invocation resolves to `refusal_code: AURA_TRANSPORT_ABSENT`, pointing to `/mos:rs-fetch`. When it does ship, its unreachable and query-failure branches read their copy from `lib/core/refusal-messaging.cjs` so no phrasing is invented at this surface. A local-only Aura transport (not `brain-client.cjs`) is a filed follow-up, not yet built.
+4. Emits Phase Gate-style transcript (CLI) or JSON (`--json`) carrying the Tier 0 guidance.
+
+## UI Format
+
+- **Body Shape:** D (Comparison Matrix) -- ranked authors with institutions
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- topic + author count
+- **Zone 2:** Content Body -- ranked table: Rank / Author / Institution / Papers / Score
+- **Zone 3:** Intelligence Strip -- top institution cluster signals
+- **Zone 4:** Action Footer -- next-step verbs (`/mos:persona` may be warranted; `/mos:rs-fetch` for fresh papers)
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with the ranked table.
+- **Desktop MCP:** structured JSON via `--json`; the MCP wrapper renders Larry's narration with top 3 authors as conversational mentions.
+- **Cowork:** honors `MINDRIAN_ROOM`; multi-user rooms see the same shared expert list filed in `00_Context/`.
+
+## Tier-0 LOCAL-only base (Canon Part 8, D-200-2 (b) unchanged half)
+
+Expert resolution (Author / Paper / Institution) is **LOCAL-only from `room.db`**. It needs NO Brain call and NO Brain key. Author names, ORCIDs, and institution affiliations are user artifacts (Canon Part 8: people/paper data is LOCAL and NEVER egresses to the Brain). The frontmatter deliberately carries no `mcp__mindrian-brain__*` tool, so this command cannot reach the remote Brain even if a key is present.
+
+Degradation is clean by construction:
+
+- Brain key ABSENT -> no effect; Tier-0 resolves the whole expert network from `room.db`. No throw.
+- No live Tier 1 Aura query path ships today (see "What it does" above) -> Tier 0 guidance message pointing at `/mos:rs-fetch`, every invocation.
+
+The people-graph base is the local mind; the Brain is never the source of an expert's identity. This is the unchanged half of navigator decision D-200-2 (b): local-only Tier-0 stays the base.
+
+Theo (the eventual Brain-contract cutover successor, Phase 9) declares 17 node labels and none of them is `Author`, `Person`, or `Institution`. Keeping expert resolution LOCAL-only is therefore not a temporary compromise -- it is structurally required by the cutover itself.
+
+## Optional Mode-A Brain projection (Canon Part 8, D-200-2 (b) additive half)
+
+On top of the LOCAL-only base, `lib/core/rs-expert-brain-projection.cjs` exposes an ADDITIVE, optional reader: `projectExpertHandles(localExpertNode, opts)`. It reads the Brain expert-network as **GENERIC framework/enum handles ONLY** (framework names, methodology enums, domain slugs) - never a person's name, affiliation, ORCID, or any Author/Institution byte. It is the substrate the Phase 203 synthetic-expert reader consumes.
+
+Its Part-8 contract is load-bearing and enforced in code + proven by `tests/test-200-brain-projection.cjs`:
+
+- **Outbound:** only a tight whitelist of methodology-enum keys (`framework` / `domain` / `methodology` / `problem_type` / `enum` / `tier`) is ever read off the local expert node. Person keys are never read, so a person byte cannot enter the outbound payload by construction. A belt-and-suspenders token-level leak scan then fails the whole projection closed if any person byte still appears.
+- **Guard:** EVERY Brain call routes through the Phase 196 boundary guard (`part8-egress-guard.classify()`). A verdict that is not `allow` - or a guard throw - degrades to Tier-0 (returns `[]`), never an error.
+- **Inbound:** the read keeps only generic framework/enum handles; any returned handle that echoes a specific person's identity is dropped. If that leaves nothing, it returns `[]`.
+- **Degrade:** Brain absent (no key / no MCP) => `[]` (pure Tier-0 degrade), no throw.
+
+The projection reuses the shipped Phase 196 guard and `rs-brain-substrate` read surface (Canon Part 7); it adds no second Brain client.
+
+## Canon References
+
+- **Canon Part 7 (Reuse Before Build):** the unreachable-transport message is sourced verbatim from the already-shipped `lib/core/refusal-messaging.cjs` rail, not a `brain-client.cjs` Aura session (that coupling has not existed since 2026-05-22, `2f0e4e79`). Zero forks, zero invented phrasing.
+- **Canon Part 8 (Graph Boundary):** topic is parameterized as `$topic` (NO string concatenation). Audited via `auditQueryString` BEFORE binding. The Aura is a LOCAL Brain mirror per Canon Part 8; this command does NOT query the remote Brain methodology graph.
+
+## Examples
+
+    /mos:rs-experts "quantum brain imaging"
+    /mos:rs-experts "fintech KYC" --json
+    /mos:rs-experts "carbon capture" --limit 50
+
+## Error patterns
+
+`refusal_code: AURA_TRANSPORT_ABSENT` (cause a, the only branch reachable today), 3-line format:
+
+    x Expert transport not available
+      Why: no local Aura transport is configured for rs-experts yet; this is a
+           capability gap, not an outage
+      Fix: /mos:rs-fetch <topic> first to populate the local SQLite mirror, then retry
+
+`refusal_code: BRAIN_UNREACHABLE` (cause b, once a local transport ships), the rail's own rendered block -- copy sourced from `lib/core/refusal-messaging.cjs`, never invented here:
+
+    I can't reach the methodology graph right now, so I will not fake what it would say.
+    We can retry in a moment, or keep going with your room context.
+
+A topic with genuinely zero experts is NOT an error pattern. It renders through the normal transcript (`No experts found for topic.` plus the `/mos:rs-fetch` next step) because an empty answer is a legitimate answer, not a fault.
+
+    x Canon Part 8 audit failed
+      Why: forbidden bytes in topic argument (ExternalEgressViolation)
+      Fix: rephrase the topic without user-content placeholders
+
+## Voice
+
+Larry direct:
+
+> "Mapped <N> experts across <M> institutions. Leading: <top institution>. /mos:persona may be warranted to build the engagement strategy."
+
+> "Expert transport not available yet. Run /mos:rs-fetch first to populate the mirror, then I can resolve the expert network."

package/commands/rs-explain.md

@@ -0,0 +1,134 @@
+---
+name: rs-explain
+description: Bidirectional NL-Graph entry point. NL question to graph queries to Larry-voiced explanation.
+help_jtbd: "Explain a reverse salient finding in plain language."
+body_shape: E (Action Report)
+hitl_shape: "F.1"
+hitl_why: "It presents the reverse-salient explanation and one next move to take."
+# Phase 267.3-07, ruled in 267.3-CLASSIFICATION.md (Row 12): first delivery at commands/rs-explain.md:70, the Larry-voiced NL explanation triangulated across room.db, Aura and the methodology Brain.
+interactive_first_reward: methodology_reframe
+serves_jtbd: ["find-bottleneck"]
+teaching: "When you have a question about a Reverse Salient discovery, /mos:rs-explain takes natural language in and returns a Larry-voiced explanation grounded in the graph. Bidirectional NL to graph and back."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Reverse Salient Analysis"]
+produces: "room/**/rs-explain/*"
+inputs: []
+autonomous_safe: false
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - mcp__mindrian-brain__brain_ask
+  - mcp__mindrian-brain__brain_search
+  - AskUserQuestion
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-02]
+  reach_id: context_block
+  sub_mode: reverse-salient-explain
+  framework: "Reverse Salient Analysis"   # MUST match the existing frameworks: value
+  posture: pull_back
+  hierarchy_rank: 3
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+  surface: F.1
+---
+
+<!-- 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:rs-explain
+
+You are Larry. This command is the user-visible bidirectional NL-Graph loop in v1.11.0. The user types a natural-language question. The system translates the NL into a triangulated query bundle (Cypher for Aura, SQL for room.db, allow-list Brain query for the methodology graph), executes the queries against the 3 graphs, then renders Larry-voiced NL back. Raw data becomes insight. The whole loop is local-first and Canon Part 8-defended.
+
+**Synopsis:**
+
+    /mos:rs-explain "<NL question>"
+    /mos:rs-explain "<NL question>" --json
+    /mos:rs-explain "<NL question>" --tier tier0
+
+## What it does
+
+1. Calls `lib/core/rs-nl-to-query.cjs translate(nl_query, opts)` (Phase 89.5-02). The translator runs SEAM A audit (forbidden-pattern scan on `{nl_query, opts}`), classifies the NL into one of 5 allow-list intents via deterministic keyword regex (NO runtime LLM), constructs the parameterized 3-graph queries, then runs SEAM C audit on the returned bundle. Returns `{cypher, sql, brain_query, sql_params, cypher_params}`.
+2. For each non-null query, executes against the appropriate runtime:
+   - `sql` runs against `room.db` via `lazygraph-ops.queryGraph(conn, sql, sql_params)`.
+   - `cypher` (Aura local) runs via `brainClient` / Aura session when reachable; Tier 0 skips it gracefully.
+   - `brain_query` (the methodology graph) runs ONLY when non-null AND `brainClient.isAvailable()` is true; otherwise omitted.
+3. Aggregates the rows into `query_results = {kind, rows[], room_context}`.
+4. Calls `lib/core/rs-query-to-text.cjs explain(query_results, opts)` (Phase 89.5-03). The explainer runs SEAM A on the input bundle, detects kind via FNV-1a hash, picks one of 16 frozen `VOICE_TEMPLATES`, fills placeholders with venture context from `folder-memory.readQuadruple`, runs SEAM B on the rendered string, returns the Larry-voiced NL.
+5. Emits the rendered NL (CLI) or full bundle including raw `query_results` (`--json`).
+
+## UI Format
+
+- **Body Shape:** E (Action Report) -- a single Larry paragraph with optional Mode A "Brain says" enrichment line
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- the NL question (echoed)
+- **Zone 2:** Content Body -- the rendered explanation
+- **Zone 3:** Intelligence Strip -- query summary (room.db rows, Aura rows, Brain rows; Mode A vs Mode B)
+- **Zone 4:** Action Footer -- next-step verbs from the rendered explanation (Bank Opportunity, Run Methodology, Devil's Advocate)
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with the rendered NL paragraph and a per-graph-row count strip.
+- **Desktop MCP:** structured JSON via `--json` returns `{nl_query, query_bundle, query_results, explanation}` for MCP-aware consumers.
+- **Cowork:** honors `MINDRIAN_ROOM`; the explanation surface is multi-user-safe because Mode A only surfaces Brain-derived BRAIN.md content when the room owner has authorized derivation per Phase 90.
+
+## Canon Part 8 guarantee (load-bearing)
+
+`rs-explain` is the hardest Canon Part 8 surface in v1.11.0 because arbitrary user free-form input meets the Brain boundary. The guarantee is enforced at four independent tripwires inside `rs-nl-to-query.cjs`:
+
+| Seam | Location | Catches |
+| ---- | -------- | ------- |
+| A | translate() entry | forbidden patterns nested in `opts` (e.g. leaked `meeting_transcript`, `decision_log`, `governing_thought`); throws `ExternalEgressViolation` BEFORE buildBrainQueryFromNL runs |
+| 1 | buildBrainQueryFromNL entry | forbidden bytes in the raw NL string itself; throws BEFORE intent dispatch |
+| 2 | buildBrainQueryFromNL exit | forbidden patterns that snuck through entity-extractor regex; throws BEFORE the constructed Brain query is returned |
+| C | translate() exit | last line of defense on the assembled bundle BEFORE the orchestrator sees it |
+
+Plus 4 entity-extractor audits that run `auditQueryString` on every bound scalar before returning. The Brain query is OMITTED (set to `null`) when intent is unrecognized OR the intent has no `brain_template` OR the extractor returned an empty scalar -- the safe default is no Brain RPC at all. User content NEVER reaches the methodology Brain through this path.
+
+`rs-query-to-text.cjs` adds a 2-seam audit (SEAM A on input bundle, SEAM B on rendered output) so even template-substitution leaks are caught BEFORE the user sees the rendered string.
+
+## Examples
+
+    /mos:rs-explain "Show me reverse salients in my fintech room"
+    /mos:rs-explain "What frameworks chain into RS Discovery?"
+    /mos:rs-explain "Who are the experts on quantum computing?"
+    /mos:rs-explain "How many discoveries have I logged this month?" --json
+
+## Error patterns
+
+3-line error format:
+
+    x No NL question provided
+      Why: rs-explain requires an NL argument
+      Fix: /mos:rs-explain "<NL question>"
+
+    x Canon Part 8 audit failed
+      Why: forbidden bytes in NL or opts (ExternalEgressViolation at SEAM A)
+      Fix: rephrase the question without user-content placeholders
+
+    x Brain offline; methodology answer unavailable
+      Why: this question's intent maps to a Brain-only template; brainClient unreachable
+      Fix: /mos:rs-fetch <topic> first; or rephrase to a LOCAL question
+
+## Voice
+
+Larry direct, pedagogical:
+
+> "Found 3 reverse salients across 2 domains. The strongest is <top thesis>. Filed to opportunity-bank/. Worth Bank Opportunity or Devil's Advocate."
+
+> "Brain offline. Searched local + Aura only. <summary>. Worth reframing? /mos:beautiful-question."

package/commands/rs-fetch.md

@@ -0,0 +1,119 @@
+---
+name: rs-fetch
+description: Run the full Reverse Salient discovery pipeline for a topic
+help_jtbd: "Fetch the latest reverse salient analysis for your room."
+body_shape: E (Action Report)
+hitl_stages:
+  - stage: "build-path"
+    shapes: ["F.2"]
+    mode: "ordered"
+  - stage: "ordered-stages"
+    shapes: ["F.9"]
+    mode: "ordered"
+hitl_why: "The full reverse-salient pipeline runs a dependency path (F.2) as a fixed-order stage walk (F.9)."
+# Phase 267.3-07, ruled in 267.3-CLASSIFICATION.md (Row 13): first delivery at commands/rs-fetch.md:58, the completed RSDiscovery bundle (breakthrough thesis plus confidence score) assembled end-to-end within this invocation.
+interactive_first_reward: methodology_reframe
+serves_jtbd: ["find-bottleneck", "surface-contradiction"]
+teaching: "When you need the full Reverse Salient pipeline run on a topic, /mos:rs-fetch executes the discovery end-to-end: corpus, math, cross-domain match, thesis. The complete sweep, not a sample."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Reverse Salient Analysis"]
+produces: "room/**/rs-fetch/*"
+inputs: []
+autonomous_safe: true
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - mcp__mindrian-brain__brain_query
+  - mcp__mindrian-brain__read_neo4j_cypher
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-02]
+  reach_id: context_block
+  sub_mode: reverse-salient-fetch
+  framework: "Reverse Salient Analysis"   # MUST match the existing frameworks: value
+  posture: pull_back
+  hierarchy_rank: 2
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+  surface: F.1
+---
+
+# /mos:rs-fetch
+
+You are Larry. This command runs the v1.11.0 Reverse Salient discovery pipeline end-to-end for a single topic. The orchestrator at `scripts/rs-discovery-engine.cjs` (Phase 89.5-04) chains every RS phase: Domain Analysis (89.1) -> Query Matrix (89.1) -> Fetchers (89.2) -> Preprocessor (89.2) -> Differential Scorer (89.2) -> Innovation Classifier (89.2) -> Breakthrough Scorer (89.2) -> Thesis Generator (89.2) -> Commercial Assessor (89.5-01) -> Output Layer (89.3 Tier 0/1 dispatch + mind map) -> Chain Feeder (89.4). The CLI surface emits a Phase Gate-style transcript summarizing each phase plus the chain metadata block per discovery.
+
+**Synopsis:**
+
+    /mos:rs-fetch <topic>
+    /mos:rs-fetch <topic> --json
+    /mos:rs-fetch <topic> --problem-type IDP --stage opportunity_identified
+
+## What it does
+
+1. Validates the input topic against Canon Part 8 (input audit at SEAM A; throws `ExternalEgressViolation` BEFORE any module runs if forbidden bytes appear).
+2. Runs Phase 0 chain-feeder upstream awareness via `lookupUpstream`. If Brain returns a pause-state with missing upstream frameworks, the orchestrator returns `{state: 'pause', missing_upstream, suggested_action}` verbatim and the CLI surfaces a Decision Gate prompt to run the missing methodology.
+3. On `state: 'ready'`, runs Phases 1 through 4 plus Output Layer plus Chain Downstream and assembles the full RSDiscovery bundle: `{topic, domain_analysis, query_matrix, fetched_results, preprocessed, scored, classified, breakthroughs, theses, commercial, output, chain_metadata}`.
+4. Emits a Phase Gate-style transcript (CLI text) OR structured JSON (`--json` flag for Desktop MCP / Cowork programmatic consumers).
+
+## UI Format
+
+- **Body Shape:** E (Action Report) -- per-phase summary rows + chain metadata block at the end
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- topic + tier (Tier 0 SQLite mirror or Tier 1 Aura)
+- **Zone 2:** Content Body -- per-phase row table (Phase / Status / Key Output)
+- **Zone 3:** Intelligence Strip -- breakthrough count, top thesis, recommended_verb, spawn_skill (Canon Part 3 verb)
+- **Zone 4:** Action Footer -- next steps drawn from chain metadata
+
+## Tier 0 / Tier 1 dispatch
+
+The Output Layer infers tier from `opts.driver` (Aura session factory) OR `opts.aura_url` OR `process.env.NEO4J_URI`. On `AuraUnreachableError` during Tier 1 write, the orchestrator falls back to Tier 0 (SQLite mirror) with `written.fallback_reason: 'aura_unreachable'`. Other error classes (TypeError, ExternalEgressViolation) bubble up as programming errors / Canon violations.
+
+## Mode A / Mode B graceful
+
+When Brain is unreachable (`brainClient.isAvailable()` returns false) the chain-feeder returns `{state: 'ready'}` and the orchestrator continues without RECOMMENDED markers (confidence < 0.7 floor per Canon Part 3 line 359). Mode A surfaces the full chain metadata block; Mode B suppresses the RECOMMENDED marker but renders coherent NL.
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with per-phase rows + chain metadata block. Default mode when invoked via `claude /mos:rs-fetch`.
+- **Desktop MCP:** structured JSON via the `--json` flag. The MCP wrapper consumes the bundle and renders Larry's narration in the conversation surface.
+- **Cowork:** honors `MINDRIAN_ROOM` env var for active-room scope per existing folder-memory.cjs contract; multi-user rooms get the same bundle filed in their shared `00_Context/`.
+
+## Canon References
+
+- **Canon Part 7 (Reuse Before Build):** the orchestrator is composition NOT duplication. 17 phase modules consumed via require(); zero forks.
+- **Canon Part 8 (Graph Boundary):** Brain queries route exclusively through `chain-feeder.lookupUpstream` (which wraps `brainClient.query` with the Canon Part 8 audit + Mode A/B graceful path). Zero direct `fetch(` and zero direct `brain-client` require in the orchestrator. The CLI command never touches Brain directly; only the library does.
+
+## Examples
+
+    /mos:rs-fetch "quantum brain imaging"
+    /mos:rs-fetch "carbon capture economics" --problem-type IDP --stage market_analysis
+    /mos:rs-fetch "fintech KYC" --json > /tmp/rs-fintech.json
+
+## Error patterns
+
+The CLI emits the 3-line error pattern on common failures:
+
+    x No topic provided
+      Why: rs-fetch requires a topic argument
+      Fix: /mos:rs-fetch <topic>
+
+    x Canon Part 8 audit failed
+      Why: forbidden bytes in topic or opts (ExternalEgressViolation at SEAM A)
+      Fix: rephrase the topic without user-content placeholders
+
+    x Pause state from upstream
+      Why: missing upstream framework <X>; the chain-feeder returned state=pause
+      Fix: /mos:<missing-framework> first, then re-run /mos:rs-fetch
+
+## Voice
+
+Larry direct and pedagogical:
+
+> "Three graphs queried. Top breakthrough: <thesis>. Confidence 0.85. Worth Bank Opportunity? Or Devil's Advocate first?"
+
+> "Brain unreachable. Pipeline still ran on local + Aura. RECOMMENDED markers suppressed (confidence below 0.7 floor). Take the unmarked candidates with appropriate skepticism."

package/commands/rs-thesis.md

@@ -0,0 +1,131 @@
+---
+name: rs-thesis
+description: Read the thesis for a prior Reverse Salient discovery
+help_jtbd: "Compose the thesis statement from your reverse salient findings."
+body_shape: E (Action Report)
+hitl_shape: "F.9"
+hitl_why: "The reverse-salient thesis is assembled through ordered stages, a fixed-order walk."
+# Phase 267.3-07, ruled in 267.3-CLASSIFICATION.md (Row 14): first delivery at commands/rs-thesis.md:55, a lookup of an already-computed thesis by discovery_id, a rendered log rather than fresh analysis.
+interactive_first_reward: "--none (diagnostic surface)"
+serves_jtbd: ["find-bottleneck"]
+teaching: "When you ran a Reverse Salient discovery earlier and want the thesis read back, /mos:rs-thesis surfaces the analytic conclusion in plain language. Best for revisiting old findings before a meeting."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Reverse Salient Analysis"]
+produces: "room/**/rs-thesis/*"
+inputs: []
+autonomous_safe: true
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+  # mcp__mindrian-brain__read_neo4j_cypher intentionally removed (BUG 2 fix):
+  # RSDiscovery is USER DATA (Canon Part 8 -- LOCAL -> BRAIN: NO). The remote
+  # Brain must never be called from this command. Always uses Tier 0 SQLite.
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-02]
+  reach_id: context_block
+  sub_mode: reverse-salient-thesis
+  framework: "Reverse Salient Analysis"   # MUST match the existing frameworks: value
+  posture: pull_back
+  hierarchy_rank: 5
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+  surface: F.1
+---
+
+<!-- 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:rs-thesis
+
+You are Larry. This command looks up the thesis text for a prior `RSDiscovery` by `discovery_id`. The lookup is tier-aware: it queries Aura first (Tier 1) when an Aura driver or env var is configured, and falls back to the local SQLite mirror (Tier 0) on `AuraUnreachableError`.
+
+**Synopsis:**
+
+    /mos:rs-thesis <discovery_id>
+    /mos:rs-thesis <discovery_id> --json
+    /mos:rs-thesis <discovery_id> --tier tier0
+
+## What it does
+
+1. Validates `<discovery_id>` against Canon Part 8 (`auditQueryString` on the bound parameter; throws `ExternalEgressViolation` if forbidden bytes appear).
+2. Detects tier from `opts.tier`, `opts.driver`, `opts.aura_url`, or `process.env.NEO4J_URI`.
+3. Tier 1 path: runs an Aura Cypher MATCH on `(rs:RSDiscovery {id: $discovery_id})` with parameterized `$discovery_id`. Returns the `thesis` field plus `breakthrough_score`, `rs_type`, `created_at` metadata.
+4. Tier 0 path (or fallback on `AuraUnreachableError`): runs a SQLite `SELECT * FROM rs_discoveries WHERE id = ?` against the local `room.db`. Emits a `DEGRADED_NOTE` marker indicating Tier 0 mode.
+5. Emits Phase Gate-style transcript on success (CLI) or JSON (`--json` for Desktop MCP / Cowork).
+
+## UI Format
+
+- **Body Shape:** E (Action Report) -- one-line lookup status + thesis body + metadata table
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- discovery_id + tier
+- **Zone 2:** Content Body -- thesis text plus a 4-row metadata table (rs_type, breakthrough_score, room_slug, created_at)
+- **Zone 3:** Intelligence Strip -- DEGRADED_NOTE on Tier 0 fallback only
+- **Zone 4:** Action Footer -- next-step verbs (Bank Opportunity, Devil's Advocate, Synthesize)
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with thesis body and metadata table.
+- **Desktop MCP:** structured JSON via `--json`; MCP wrapper renders Larry's narration with the thesis as a quote.
+- **Cowork:** honors `MINDRIAN_ROOM` env var; the lookup runs against the active room's local SQLite mirror in shared `00_Context/`.
+
+## Tier-0 LOCAL-only base (Canon Part 8, D-200-2 (b) unchanged half)
+
+The thesis and its `RSDiscovery` / Author / Paper / Institution neighborhood are **LOCAL-only** user artifacts. Tier-0 resolution reads them straight from `room.db` with NO Brain call and NO Brain key (Canon Part 8: people/paper data is LOCAL and NEVER egresses). The frontmatter carries no `mcp__mindrian-brain__*` tool, so a missing Brain key changes nothing:
+
+- Brain key ABSENT -> Tier-0 SQLite read is authoritative (the writer is idempotent). No throw.
+- Aura reachable -> Tier 1 Cypher MATCH on the local mirror.
+- Aura unreachable -> Tier-0 SQLite fallback with a `DEGRADED_NOTE` marker.
+
+This is the unchanged half of navigator decision D-200-2 (b): the local-only Tier-0 stays the base; the Brain never holds a discovery's bytes.
+
+## Canon References
+
+- **Canon Part 7 (Reuse Before Build):** consumes existing `lazygraph-ops.cjs` for SQLite reads and existing `brain-client.cjs` (Aura session) for Tier 1. Zero forks.
+- **Canon Part 8 (Graph Boundary):** the `discovery_id` parameter is parameterized in both backends (NO string concatenation). Audited via `auditQueryString` BEFORE binding. The thesis is a LOCAL artifact; this command never queries Brain.
+
+## Examples
+
+    /mos:rs-thesis rs_disc_a1b2c3d4
+    /mos:rs-thesis rs_disc_a1b2c3d4 --json
+    /mos:rs-thesis rs_disc_a1b2c3d4 --tier tier0
+
+## Error patterns
+
+3-line error format:
+
+    x No discovery_id provided
+      Why: rs-thesis requires a discovery_id argument
+      Fix: /mos:rs-thesis <discovery_id>
+
+    x Discovery not found
+      Why: no row matched discovery_id <id> in either Aura (Tier 1) or SQLite (Tier 0)
+      Fix: /mos:rs-fetch <topic>
+
+    x Aura unreachable; Tier 0 used
+      Why: AuraUnreachableError caught; falling back to SQLite mirror
+      Fix: not actionable; Tier 0 read succeeded with DEGRADED_NOTE marker
+
+## Voice
+
+Larry direct:
+
+> "Thesis: <body>. Breakthrough score 8 of 10. Filed 3 days ago. Worth Bank Opportunity?"
+
+> "Aura unreachable. Read from local mirror. Tier 0 result is authoritative because the writer is idempotent."