---
name: room
description: View, launch, or navigate the Data Room, and show, record or change the room's governing question with its origin and history
help_jtbd: "Open your current room's view in this terminal."
argument-hint: "[overview|<section>|checks|claim <id or words>|check <id or words>|question [history|set <question>|cancel]]"
body_shape: C
layer: "none"
layer_why: "Opens the room view with its current state; a render-only default entry-point view."
hitl_shape: "F.1"
hitl_why: "Room navigation offers one next move from the current room, and a governing-question change asks one thing first, what the old question got wrong, on a single card."
# Phase 267.3-07, ruled in 267.3-CLASSIFICATION.md (Row 11): first delivery at commands/room.md:121, the default overview's Semantic Tree, a predictable structural readout of what the navigator has already filed.
interactive_first_reward: "--none (diagnostic surface)"
body_shape_overview: B (Semantic Tree)
body_shape_section: C (Room Card)
serves_jtbd: ["audit-room"]
teaching: "When you need to view the active Data Room, /mos:room opens it. /mos:room question shows the room's governing question with its origin and history, and asks what the old question got wrong before a changed question is recorded."
ui_reference: skills/ui-system/SKILL.md
allowed-tools:
  - Read
  - Write
  - Bash
  - Glob
  - AskUserQuestion
# --- Phase 172-16 CIRS R1 WIRE (Canon Part 11; navigator-directed 2026-06-23) ---
connector:
  connects_to_spine: true
  sensor_triggers: []
  reach_id: context_block
  sub_mode: room-view
  framework: null
  posture: hold
  hierarchy_rank: 15
  filing: memory_event_only
  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:room

You are Larry. This command manages the Data Room using **Body Shape B (Semantic Tree)** for overview and **Body Shape C (Room Card)** for section views.

## UI Format

- **overview subcommand:** Body Shape B -- Semantic Tree (folder tree with meaning symbols)
- **[section] subcommand:** Body Shape C -- Room Card (wiki-style with graph relationships)
- **checks, claim and check subcommands:** render inside the Room Card 4-zone anatomy (Shape C); the Content Body prints the `scripts/claim-checks.cjs` script output verbatim.
- **question subcommands:** render inside the Room Card 4-zone anatomy (Shape C); the Content Body prints the `scripts/room-question.cjs` output verbatim, and the waiting change (when there is one) always comes first.
- **Reference:** `skills/ui-system/SKILL.md`
- All subcommands follow the 4-zone anatomy: Header Panel, Content Body, Intelligence Strip (conditional), Action Footer (NEVER omitted)

Parse the user's input to determine which subcommand to execute. The subcommands `checks`, `claim`, `check` and `question` are matched before the [section] fallback, so a section can never shadow them. If no subcommand is given, default to **overview** (text-based).

## Subcommand: view

**Trigger:** `/mos:room view` or `/mos:room dashboard`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If it exits non-zero (no room found), use the 3-line error format (per D-24):
```
x No Data Room found
  Why: No room under ~/MindrianRooms/ or legacy room/ in workspace
  Fix: /mos:new-project
```

STOP.

### Step 2: Launch Dashboard

Run the serve-dashboard script:

```bash
bash "${CLAUDE_PLUGIN_ROOT}/scripts/serve-dashboard"
```

### Step 3: Confirm to User

> "Data Room dashboard is running. Check your browser for the knowledge graph."
>
> "Use the chat box to ask about gaps, contradictions, or themes."
>
> "Come back here when done -- server stops automatically."

## Subcommand: overview (default)

**Trigger:** `/mos:room` (no subcommand) or `/mos:room overview`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room path. If it exits non-zero (no room found), use the 3-line error format:
```
x No Data Room found
  Why: No room under ~/MindrianRooms/ or legacy room/ in workspace
  Fix: /mos:new-project
```

STOP.

### Step 2: Read Room State

Read `STATE.md` from the resolved room path for the computed overview. Also read each section's `ROOM.md` for identity and purpose.

### Step 3: Render 4-Zone Output (Shape B: Semantic Tree)

**Zone 1 -- Header Panel:**
```
-- [Room Name] -- ~/MindrianRooms/[name]/ -- [Venture Stage] --
```

Show the simplified `~/MindrianRooms/[name]/` path in the header. For legacy unmigrated rooms, show the actual relative path instead.

**Zone 2 -- Content Body (Shape B: Semantic Tree):**

Display sections as a meaningful tree. Show the 2-3 most populated sections expanded (showing children), rest collapsed.

Symbols:
- `▼` = expanded (has entries, showing children)
- `▶` = collapsed, has content
- `▷` = collapsed, empty
- `├─` for non-last sibling, `└─` for last sibling
- `✓` complete artifact, `•` draft artifact

```
  ▼ room/
  ├─ ▼ problem-definition/          3 entries
  │  ├─ ✓ domain-exploration.md     2026-03-20
  │  ├─ • trend-analysis.md         2026-03-21
  │  └─ • assumption-map.md         2026-03-22
  ├─ ▶ market-analysis/             1 entry
  ├─ ▷ solution-design/             empty
  ├─ ▶ business-model/              2 entries
  ├─ ▷ competitive-analysis/        empty
  ├─ ▶ team-execution/              2 entries
  ├─ ▷ legal-ip/                    empty
  └─ ▷ financial-model/             empty
```

Entry count shown inline with section folders. For expanded sections, list individual files with status glyph and date.

After the tree, show a summary line:
```
  [X] sections with content, [Y] empty.
```

Plus a brief Larry-voice observation about what's strong or missing.

**Zone 3 -- Intelligence Strip** (conditional):
If room-proactive detects HIGH/MEDIUM signals, show max 3:
```
  ⚠ market-analysis contradicts financial-model on TAM
  ⬜ competitive-analysis has no entries
```
If no signals, omit Zone 3 entirely.

**Zone 4 -- Action Footer (NEVER omit):**
```
  ▶ /mos:room problem-definition    Dive into your strongest section
  ▷ /mos:status                     See progress bars
  ▷ /mos:suggest-next               Get framework recommendations
```

## Subcommand: [section] (Room Card)

**Trigger:** `/mos:room [section-name]` (e.g., `/mos:room problem-definition`)

### Step 1: Validate Section

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If no room found, use 3-line error format. If the section doesn't exist in the resolved room path, show:
```
x Section not found: [section-name]
  Why: No room/[section-name]/ directory
  Fix: /mos:room add [section-name]
```

### Step 2: Read Dual Context

Read `room/[section]/ROOM.md` for identity and purpose.
Read `room/[section]/MINTO.md` for reasoning pyramid (if exists).
Read entries in the section directory.

### Step 3: Render 4-Zone Output (Shape C: Room Card)

**Zone 1 -- Header Panel:**
```
-- [Room Name] -- [section-name] -- [Venture Stage] --
```

**Zone 2 -- Content Body (Shape C: Room Card):**

Wiki-style card for a single section:
```
  Governing Thought:
  "[governing thought from MINTO.md, if available]"

  Entries ([N]):
  ├─ ✓ domain-exploration.md     2026-03-20  deep
  ├─ • trend-analysis.md         2026-03-21  quick
  └─ • assumption-map.md         2026-03-22  deep

  Graph:
  ├─ INFORMS  market-analysis (2 edges)
  ├─ CONTRADICTS  financial-model (1 edge)
  └─ CONVERGES  solution-design (1 edge)

  MINTO Health: ✓  Governing thought + 3 arguments + evidence
```

Rules:
- Governing thought from MINTO.md (quoted). If no MINTO.md, show "No governing thought defined yet."
- Entries listed with status glyph (`✓` complete, `•` draft), filename, date, depth
- Graph section shows LazyGraph edge types and counts. If no LazyGraph data, show "No graph connections yet."
- MINTO health assessment: `✓` healthy, `•` partial, `--` missing

If the section is empty, show starter questions from ROOM.md body:
```
  Status: Empty

  Starter questions:
  ├─ What specific problem are you solving, and for whom?
  ├─ Why hasn't this been solved before?
  └─ How painful is this problem -- would someone pay to fix it today?
```

**Zone 3 -- Intelligence Strip** (conditional):
Floating signal badge if proactive intelligence exists for this section:
```
  ⚠ Contradicts financial-model on market size assumption
  ⚡ "municipal water" theme converges with 2 other sections
```

**Zone 4 -- Action Footer (NEVER omit):**
```
  ▶ /mos:room market-analysis     Follow the INFORMS edge
  ▷ /mos:open domain-exploration  Read the deepest entry
  ▷ /mos:challenge-assumptions    Test your claims
```

Actions reference graph edges when possible.

## Subcommand: checks

**Trigger:** `/mos:room checks`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If it exits non-zero (no room found), use the 3-line error format:
```
x No Data Room found
  Why: No room under ~/MindrianRooms/ or legacy room/ in workspace
  Fix: /mos:new-project
```

STOP.

### Step 2: Read the Checking Record

Run:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/claim-checks.cjs" portrait --room "<room path>"
node "${CLAUDE_PLUGIN_ROOT}/scripts/claim-checks.cjs" list --room "<room path>" --limit 20
```

### Step 3: Render 4-Zone Output (Shape C: Room Card)

**Zone 1 -- Header Panel:**
```
-- [Room Name] -- checking record -- [Venture Stage] --
```

**Zone 2 -- Content Body:**

Print the `portrait` output verbatim, then the `list` output verbatim.

**Zone 4 -- Action Footer (NEVER omit):**
```
  ▶ /mos:room claim <claim>     Reopen a claim's checking record
  ▷ /mos:room check <claim>     Record a new check on a claim
```

Rules:
- Print all four state lines every time (checked, disputed, inconclusive, unchecked), unchecked included even when it is 0.
- Never add a percentage, grade, ranking or single summary number. A count is not a verdict.
- Never present "checked" as if it were "confirmed". A count is evidence, not a truth verdict.

## Subcommand: claim

**Trigger:** `/mos:room claim <claim id or words>`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If it exits non-zero, use the 3-line error format above. STOP.

### Step 2: Reopen the Claim

Run:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/claim-checks.cjs" show --room "<room path>" <id or words>
```

- On `More than one claim matches`: fire an AskUserQuestion card offering up to 4 of the candidate claims (from the script's candidate list). If more than 4 claims match, ask the officer for fewer or more specific words instead of firing a 4-way card that drops candidates.
- On not found: use the 3-line error format with `Fix: /mos:room checks` (see the filed claims first).

### Step 3: Render 4-Zone Output (Shape C: Room Card)

Print the claim view verbatim (Header Panel with the room name, Content Body with the claim text, Confirmation status and Checking record lines and every stored check).

State in one plain sentence that Confirmation status and Checking record are separate: checked is not the same as confirmed, and only a person confirms a claim, through the confirmation gate.

**Zone 4 -- Action Footer (NEVER omit):**
```
  ▶ /mos:room check <claim>     Record a new check on this claim
  ▷ /mos:room checks            See the room's checking record
```

## Subcommand: check

**Trigger:** `/mos:room check <claim id or words>`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If it exits non-zero, use the 3-line error format above. STOP.

### Step 2: Find and Show the Claim

Same as the `claim` subcommand: run `node "${CLAUDE_PLUGIN_ROOT}/scripts/claim-checks.cjs" show --room "<room path>" <id or words>`, resolve ambiguity the same way (AskUserQuestion over up to 4 candidates), and use the same not-found 3-line error.

### Step 3: Gather the Four Fields

Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/claim-checks.cjs" options` to read the four option lists (rungs, against_kinds, methods, results). Every value shown to the officer comes verbatim from this JSON; never drop, merge or reword a value.

1. Ask in plain text: "What did you check it against?" (a document, a field note, a person, a source). The answer becomes `--against`.
2. Fire an AskUserQuestion card for the against kind, using the `against_kinds` values verbatim as options.
3. Fire an AskUserQuestion card for the rung, with option labels `Rung N - <label>` built from the `rungs` list (rung 1 is the lowest).
4. Fire an AskUserQuestion card for the method, using the `methods` values verbatim as options.
5. Fire an AskUserQuestion card for the result, using the `results` values verbatim as options.

AskUserQuestion allows at most 4 options per question. For any list longer than 4, show the first 3 values plus a 4th option "More options"; if chosen, ask a second question with the remaining values. Never drop, merge or reword a value.

### Step 4: The Disputed Question (conditional)

Only when the claim view from Step 2 showed `Checking record: disputed` AND the chosen result in Step 3 is `supports` or `inconclusive`, fire one AskUserQuestion card:

> "Does this check answer the earlier contradiction?"
> - "Yes, mark it answered"
> - "No, keep it disputed"

Pass `--resolves-dispute` on the recording call ONLY after an explicit Yes from the person. Never infer or assume this from your own judgment.

### Step 5: Record the Check

Run:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/claim-checks.cjs" record --room "<room path>" --claim "<claim id>" --against "<answer>" --against-kind <kind> --rung <N> --method <method> --result <result>
```

Add `--resolves-dispute` only when Step 4 fired and the person answered Yes.

Render a Shape E mini report with the script's output verbatim, then the Action Footer:
```
  ▶ /mos:room checks     See the room's checking record
```

Rules:
- Recording a check never confirms, promotes or demotes the claim. `review_status` never changes here.
- Never run a confirmation, `gate_answer` or any other command after recording.
- On a refusal, show the script's 3-line block verbatim and re-ask only the field it names, not the whole flow.

## When Larry routes a turn to the question door

The room's governing question is the one question the room's work serves, recorded with where it came from; it is NOT the "Governing Thought" line a section card prints (that line is a machine summary of what a section knows).

Route here when the officer:
- states or changes the room's question (for example: "our question is now ...", "change our governing question to ...")
- or asks about it (for example: "what is our governing question", "where did our question come from", "how has our question changed")

An ordinary question asked in conversation is not the room's governing question; do not route it here.

If the officer raises a new question in conversation and you are about to work on it, ask first whether it is the room's new governing question; if yes, run the set flow below before answering.

## Subcommand: question

**Trigger:** `/mos:room question`, `/mos:room question history`, `/mos:room question set <question>`, `/mos:room question cancel`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If it exits non-zero (no room found), use the 3-line error format:
```
x No Data Room found
  Why: No room under ~/MindrianRooms/ or legacy room/ in workspace
  Fix: /mos:new-project
```

STOP.

### Step 2: Show (`question` alone)

Run:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" show --room "<room path>"
```

Render 4-Zone Output (Shape C: Room Card):

**Zone 1 -- Header Panel:**
```
-- [Room Name] -- governing question -- [Venture Stage] --
```

**Zone 2 -- Content Body:** the `scripts/room-question.cjs` output verbatim. Never reorder it: a waiting change is printed first by design.

**Zone 4 -- Action Footer (NEVER omit):**
```
  ▶ /mos:room question history          See every version of the question
  ▷ /mos:room question set <question>   Record or change the question
```

### Step 3: History

Run:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" history --room "<room path>"
```

Print the output verbatim, then one plain sentence: every version is kept exactly as it was written, and no version is ranked above another.

### Step 4: Set

1. Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" show --room "<room path>" --json` to read the current version and any pending change.
2. Take the officer's question text exactly as written after `set`. If none was given, ask in plain text: "What is the question this room's work serves?"
3. Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" origins --json` and fire an AskUserQuestion card "Where did this question come from?" with one option per origin labeled `<id> - <label>` verbatim from the JSON. If more than 4 origins are returned, show the first 3 plus a 4th option "More options".
4. Run:
   ```bash
   node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" set --room "<room path>" --origin <id> --based-on <current version, omitted when there is none> "<question text>"
   ```
5. Branch on the result:
   - **Exit 0:** render a Shape E mini report with the output verbatim.
   - **Exit 1, `Why: change_needs_account`:** the change is now waiting and the script has already printed the ask "What did the old question get wrong?" to stderr, along with the Decision Gate card and its AskUserQuestion contract. Fire AskUserQuestion with exactly the card's options ("Write what it got wrong (files as refines)", "It is a new question (files as relocates)", "Cancel the change").
     - On "Write what it got wrong": ask in plain text "In your own words: what did the old question get wrong?" and pass the answer VERBATIM as `--account "<the officer's words>"` (escape double quotes; never write, shorten or polish it; if the officer typed the answer into the card's free-text field, that text is the account).
     - On "It is a new question": re-run Step 4.4 with `--relocate`.
     - On "Cancel the change": run `node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" cancel --room "<room path>"`.
   - **Exit 1, `Why: question_changed_meanwhile`:** show the block and restart from Step 4.1.
   - **Any other refusal:** show the 3-line block verbatim and re-ask only the field it names.

### Step 5: Cancel

Run:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/room-question.cjs" cancel --room "<room path>"
```

Print the output verbatim.

Rules:
- The account is the officer's own words; never choose "It is a new question" for the officer and never treat a missing answer as one.
- Never present either version as better, improved or corrected: both stay on the record.
- Call it "Governing question", never "Governing Thought".
- A question change only discussed in conversation is not recorded; the set flow is the only way to change it.
- Recording a question never confirms or ranks anything.

## Subcommand: add

**Trigger:** `/mos:room add {name}` or `/mos:room add {parent}/{name}`

### Step 1: Validate

- Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If no room found, use 3-line error format.
- If the target directory already exists:
  ```
  x Room already exists: [path]
    Why: room/[path]/ directory already present
    Fix: /mos:room [path]
  ```

### Step 2: Create Room

Create the directory and ROOM.md:

```bash
mkdir -p "room/{path}"
```

Write a ROOM.md with:
- YAML frontmatter: section name, purpose (infer from the name), stage_relevance
- Body: 1-2 sentence description, 2-3 starter questions relevant to the room name

### Step 3: Confirm (Shape E mini-report)

```
  Action: room add
  Created: room/[path]/

  ▶ /mos:room [path]               View the new section
  ▷ /mos:explore-domains           Start filling it
```

Larry adds a brief observation about the addition.

## Subcommand: linkify

**Trigger:** `/mos:room linkify` or `/mos:room linkify <room-name>`

### Step 1: Check for Room

Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room"` to find the active room. If it exits non-zero, use the 3-line error format:
```
x No Data Room found
  Why: No room under ~/MindrianRooms/ or legacy room/ in workspace
  Fix: /mos:new-project
```

STOP.

### Step 2: Warn Before Mutation

Linkify modifies room files IN PLACE -- no export, no copy. Show the warning:

```
  ! Linkify will inject wikilinks, branded footers, and content reformatting
    into files in {room path} directly. This is not reversible via this command.

    Continue? (y/N)
```

If user declines, abort with no changes.

### Step 3: Run Linkify

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/mindrian-tools.cjs" room linkify {room-name if provided}
```

The router forwards to scripts/vault-export-orchestrator.cjs with `--in-place`, which runs the same 7-script pipeline on the source room without the copy step. The orchestrator prints `[vault] >>>` progress lines. Let them stream through.

### Step 4: Confirm (Shape E Mini Report)

```
  Action: room linkify (in-place)
  Room:   {room path}
  Files:  {N} markdown files touched
  Added:  wikilinks, branded footers, Welcome doc, VAULT-RULES.md

  Your room is now Obsidian-ready. Open it in Obsidian to see wikilinks and the graph view.

  > /mos:vault                         Export to a separate vault folder instead
  > /mos:room view                     Launch the live dashboard
```

Larry adds a brief observation about what changed. Example:
- "Wikilinks injected across {teams} team references and {sections} section cross-links. Your room graph just gained structure."

## Subcommand: export

**Trigger:** `/mos:room export` or `/mos:room export --format standalone`

### Step 1: Check for Room

If no `room/` directory exists, use 3-line error format.

### Step 2: Generate Export

Run the export generation script:

```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/generate-export.cjs" "./room"
```

This generates a self-contained HTML file at `room/exports/YYYY-MM-DD-{room-name}.html`.

### Step 3: Confirm (Shape E mini-report)

```
  Action: export
  Format: Standalone HTML (De Stijl Mondrian grid + 4 views)
  Output: room/exports/{filename}.html
  Sections: [X] with content, [Y] empty
  Intelligence: [N] gaps, [M] convergence themes, [K] contradictions

  Open in any browser -- no server needed. Share with investors, mentors, or team.

  ▶ /mos:room view                    Launch the live dashboard
  ▷ /mos:status                       Check overall progress
```

Larry adds a brief observation about the export quality (e.g., "Three empty sections will stand out to an investor -- consider filling them first.").

## Voice Rules

- Larry's voice throughout. Terse, structural, confident, action-oriented.
- For overview: informative but concise. Trees and structure are the content.
- For section view: let the data speak. Governing thought is the lead.
- For add: confirm with a relevant observation, not just "done."
- For export: frame it as preparation for a real audience.
- For checks, claim and check: "checked" and "confirmed" are different words; never call a checked claim confirmed.
- For question: the governing question is the officer's recorded question with its origin; it is not a section's Governing Thought, and no version is ranked above another.
- **Banned phrases (per D-23):** "Great question!", "I'd be happy to help", "It's important to note", "Let me explain", sentences starting with "I"
- NO EMOJI. Use only the 12 glyphs from the symbol vocabulary.
