@mindrian_os/install 1.13.0-beta.11

package/commands/jtbd.md

@@ -0,0 +1,241 @@
+---
+name: jtbd
+description: Show, set, list, or inspect the active JTBD (job-to-be-done) -- the per-room signal that tells Larry what kind of work the navigator is doing right now
+argument-hint: "[set <jtbd> | clear | list | history] [--json]"
+body_shape: E (Action Report)
+body_shape_detail: current state + last 5 history (default), 13 entries (list), full history (history), Shape F.1 picker (set with no arg), Shape E confirmation (clear, set <jtbd>)
+serves_jtbd: ["audit-room"]
+locks_operator: null
+min_tier: 0
+concurrency: sequential
+streams_events: false
+disable-model-invocation: false
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# /mos:jtbd
+
+Inspect or manually set the active Job-to-be-Done (JTBD) for the current room. The JTBD is the per-room signal that tells Larry what kind of work the navigator is doing right now -- `find-bottleneck`, `prepare-pitch`, `audit-room`, `explore` (fallback), and 9 more. Phase 100 makes JTBD a first-class, persisted, room-local state so every subsequent `/mos:` command can render against the same job signal.
+
+The JTBD state file lives at `<roomDir>/.mindrian/jtbd-state.json` (per-room, never global -- Phase 100 D-06). The heuristic classifier (Phase 100-02) updates it silently per turn. Manual sets stick for 24 hours unless cleared, switched, or re-set (Phase 100 D-12). Most users never need this command directly. Use `/mos:jtbd` when:
+
+- You want to inspect what Larry currently believes the job is.
+- The classifier mis-routed and you want to manually override.
+- You are debugging the classifier or auditing the transition history.
+- You want a one-line index of all 12 first-class jobs + the `explore` fallback.
+
+## Step 1: Parse the user's intent
+
+Look at the invocation:
+
+- `/mos:jtbd` (no args) -> show current JTBD + last 5 history (Shape E)
+- `/mos:jtbd history` -> show last 20 transitions (Shape E)
+- `/mos:jtbd list` -> show all 13 entries with their one-liners (Shape E)
+- `/mos:jtbd set <jtbd>` -> manual override; sticky 24 hours (writes history with trigger=manual_set)
+- `/mos:jtbd set` (no arg) -> render Shape F.1 picker with the 12 jobs + Free-Text
+- `/mos:jtbd clear` -> return to null (no JTBD inferred); writes history with trigger=manual_clear
+- `/mos:jtbd --json` -> machine-readable output for hooks / regression tests
+
+Combine `--json` with any subcommand: `/mos:jtbd history --json`.
+
+## Step 2: Execute
+
+Run via Bash:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/jtbd-command.cjs" $ARGUMENTS
+```
+
+If `CLAUDE_PLUGIN_ROOT` is unset (older Claude Code versions), fall back to:
+
+```bash
+node ~/.claude/plugins/mindrian-os/scripts/jtbd-command.cjs $ARGUMENTS
+```
+
+The script does the work:
+
+1. Resolves the active room from `~/MindrianRooms/.rooms/registry.json`.
+2. Loads `<roomDir>/.mindrian/jtbd-state.json` via `lib/hmi/jtbd-state.cjs.getCurrent`.
+3. Loads `lib/hmi/jtbd-taxonomy.json` for taxonomy lookups.
+4. Branches on subcommand: render Shape E, render Shape F.1, or perform a write transition.
+5. For `set` subcommand: validates the requested JTBD against the taxonomy; rejects unknown JTBDs with a 3-line stderr per Canon Part 3 Rule 2 and exits non-zero.
+
+## Step 3: Render the output
+
+The script outputs a 4-zone Shape E (Action Report) per `skills/ui-system/SKILL.md`. Display the script's stdout directly. Do not re-format. Do not strip ANSI color codes.
+
+## Subcommands
+
+### `/mos:jtbd` (default -- show current state)
+
+Renders Shape E with the current JTBD, confidence, evidence chain, and last 5 history entries. Zone 4 footer surfaces 3 grounded follow-up commands tuned to the active job.
+
+### `/mos:jtbd history`
+
+Renders Shape E with the last 20 transitions (chronological-recent-first). Each row shows from -> to + trigger + timestamp.
+
+### `/mos:jtbd list`
+
+Renders Shape E with all 13 taxonomy entries (12 first-class jobs + `explore` fallback). Each row: id + one-line description.
+
+### `/mos:jtbd set <jtbd>`
+
+Validates `<jtbd>` against the 13-entry taxonomy. On success, writes the state with `trigger=manual_set` and a 24h `expires_at` window (the manual override). On failure (unknown JTBD), prints a 3-line error to stderr and exits 1.
+
+### `/mos:jtbd set` (no arg)
+
+Renders a Shape F.1 Next Move selector listing the 12 first-class jobs + `Free-Text`. Per Phase 95.1-04 D-19 deferral pattern, the F.1 picker renders as a STRUCTURAL marker block in stdout. Larry handles conversational selection: when the user types "set to find-bottleneck" in natural language, Larry interprets and re-invokes the command with the explicit id (e.g., `/mos:jtbd set find-bottleneck`). Phase 88.2 (`uiux-selector-block`) will replace the marker block with the canonical AskUserQuestion primitive. See `.planning/phases/100-jtbd-inference-engine/f1-selector-deferred.md`.
+
+### `/mos:jtbd clear`
+
+Clears the current JTBD to null (no JTBD inferred). Writes a history row with `trigger=manual_clear`. Subsequent classifier runs may re-populate the state.
+
+## Examples
+
+### Default show (active JTBD)
+
+```
+-- mindrianos -- jtbd -- find-bottleneck --
+
+  ■ Current               find-bottleneck
+     entered  2026-05-01T10:42:00Z (3m ago)
+     confidence  0.82
+     evidence  tokens:rs-fetch, operator:METHODOLOGY, recency:rs-thesis
+     expires  manual override active until 2026-05-02T10:42:00Z
+
+  ■ Last 5 history
+     ├─ explore           2026-05-01T10:30:00Z  trigger=session_start
+     ├─ explore           2026-05-01T10:35:00Z  trigger=user_message
+     └─ find-bottleneck   2026-05-01T10:42:00Z  trigger=manual_set
+
+  Summary: total transitions=3, history_used=3/50
+
+  ▶ /mos:act                  # run methodology for active job
+  ▷ /mos:jtbd set             # manual override (F.1 picker)
+  ▷ /mos:jtbd history         # full transition history
+```
+
+### Default show (no JTBD inferred)
+
+```
+-- mindrianos -- jtbd -- null --
+
+  ⬜ no JTBD set
+     classifier confidence below 0.6 threshold; explore fallback active
+     evidence  below_threshold
+
+  ▶ /mos:jtbd list            # browse 13 jobs
+  ▷ /mos:jtbd set <id>        # manual selection
+  ▷ /mos:status               # room state
+```
+
+### list subcommand
+
+```
+-- mindrianos -- jtbd -- list --
+
+  ■ JTBD taxonomy (13 entries)
+     • decide-pursue          Decide if a venture / opportunity / approach is worth pursuing
+     • find-problem           Find the problem worth solving (not the symptom, the root)
+     • understand-market      Understand the market for this idea -- size, structure, dynamics
+     • find-bottleneck        Find the lagging component (Hughes 1983 reverse salient) blocking progress
+     • prepare-pitch          Prepare for an investor / partner / customer meeting
+     • validate-idea          Test if an idea / hypothesis / claim holds up under scrutiny
+     • compare-options        Compare alternatives across criteria -- choose between A/B/C
+     • connect-domains        Find cross-domain analogues -- what does this look like in another field?
+     • surface-contradiction  Notice and resolve internal contradictions in the room
+     • plan-execution         Plan the next 90 days -- milestones, owners, dates
+     • file-meeting           Capture and route meeting intelligence into the room
+     • audit-room             Audit Data Room health -- gaps, drift, evidence tier, decision quality
+     • explore                No specific job -- general thinking, talking, ranging (fallback)
+
+  ▶ /mos:jtbd                 # current state
+  ▷ /mos:jtbd set <id>        # manual selection
+  ▷ /mos:jtbd history         # transition history
+```
+
+### set subcommand (Shape F.1 picker, no arg)
+
+```
+-- mindrianos -- jtbd -- set --
+
+  ■ Manual JTBD selection
+     current: explore
+
+  [F.1 Next Move]
+   ▶ decide-pursue           # decide if worth pursuing
+   ▷ find-problem            # find the root problem
+   ▷ understand-market       # understand the market
+   ▷ find-bottleneck         # find the lagging component
+   ▷ prepare-pitch           # prepare for stakeholder meeting
+   ▷ validate-idea           # stress-test a claim
+   ▷ compare-options         # compare alternatives
+   ▷ connect-domains         # find cross-domain analogues
+   ▷ surface-contradiction   # resolve room contradictions
+   ▷ plan-execution          # plan next 90 days
+   ▷ file-meeting            # file meeting intelligence
+   ▷ audit-room              # audit room health
+   ▷ Free-Text               # describe the job in your own words
+
+  ▶ /mos:jtbd                 # cancel and re-show state
+  ▷ /mos:jtbd list            # browse one-liners first
+```
+
+### history subcommand
+
+```
+-- mindrianos -- jtbd -- history --
+
+  ■ History (3 of 50 entries)
+     ├─ explore           2026-05-01T10:30:00Z  trigger=session_start    from=null
+     ├─ explore           2026-05-01T10:35:00Z  trigger=user_message     from=explore
+     └─ find-bottleneck   2026-05-01T10:42:00Z  trigger=manual_set       from=explore
+
+  Summary: total transitions=3, history_used=3/50, oldest=2026-05-01T10:30:00Z
+
+  ▶ /mos:jtbd                 # current state
+  ▷ /mos:jtbd set <id>        # manual selection
+  ▷ /mos:jtbd clear           # return to null
+```
+
+### clear subcommand
+
+```
+-- mindrianos -- jtbd -- clear --
+
+  ✓ Cleared JTBD (was: find-bottleneck)
+     trigger: manual_clear
+     classifier may re-populate on next user turn
+
+  ▶ /mos:jtbd list            # browse 13 jobs
+  ▷ /mos:jtbd set <id>        # manual selection
+  ▷ /mos:status               # room state
+```
+
+## Note on Shape F.1 deferral
+
+Per Phase 95.1-04 D-19 deferral pattern, the F.1 picker renders as a STRUCTURAL marker block in stdout. Larry handles conversational selection: when the user types natural language ("set to find-bottleneck", "let's pitch"), Larry interprets and re-invokes the command with the explicit id. Phase 88.2 (`uiux-selector-block`) will replace the marker block with the canonical AskUserQuestion primitive. See `.planning/phases/100-jtbd-inference-engine/f1-selector-deferred.md` for the deferral note + re-trigger condition.
+
+## Voice rules
+
+When Larry surfaces the output conversationally:
+
+- "You're on `find-bottleneck`. The classifier saw `rs-fetch` in your last turn plus you're in METHODOLOGY operator -- 0.82 confidence."
+- "Want to override? `/mos:jtbd set <id>` lets you pick from the 12 first-class jobs."
+- "If the JTBD looks wrong, `/mos:jtbd list` shows all 13 with one-liners; `/mos:jtbd clear` returns to null."
+
+NEVER:
+- Apologize for the JTBD inference being what it is. The state is the truth; the classifier is heuristic and the user can always override.
+- Suggest the user "should" be doing a particular job. The user picks; Larry classifies.
+- Re-show the example blocks above when speaking conversationally; just describe what they would see.
+
+## Cross-references
+
+- **Canon:** `docs/MINDRIAN-CANON.md` Part 3 (Tri-Context Decision Gate; F.1 surface), Part 4 (manual_clear is a typed transition row), Part 7 (12 jobs map to existing methodology commands; no net-new framework), Part 8 (classifier is LOCAL-only; no Brain queries).
+- **Phase 100 KICKOFF:** `.planning/phases/100-jtbd-inference-engine/100-CONTEXT.md` D-09 / D-10 (subcommand list).
+- **/mos:operator** (Phase 99): the JTBD classifier reads the active operator as input stratum 2.
+- **/mos:doctor:** if the renderer drifts from the UI Ruling System, `/mos:doctor --ui-compliance` will surface the violation.
+- **Phase 100-04 plan:** this command's source spec.

package/commands/leadership.md

@@ -0,0 +1,73 @@
+---
+name: leadership
+description: Diagnose the leadership shape your team needs
+serves_jtbd: ["explore"]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:leadership
+
+You are Larry. This command runs a leadership coaching session -- Socratic, not prescriptive.
+
+## Setup
+
+1. Read `references/methodology/leadership.md` for framework details
+2. Read `references/personality/voice-dna.md` for Larry's voice
+3. Read `room/STATE.md` for venture context (if exists)
+4. Check for team context:
+   - Read `room/team-execution/` entries (ls the directory)
+   - Read `room/team/members/` if it exists (team member profiles)
+   - Count team members, identify gaps (no mentors? no advisors?)
+   - Read any existing leadership assessment artifacts
+5. If Brain is connected (mcp__mindrian-brain tools available):
+   - Query Brain for leadership frameworks matching current venture stage
+   - Get the FEEDS_INTO chain from the user's current team state
+   - Use Brain calibration: what leadership patterns correlate with the user's venture stage?
+   - If Brain MCP tools are not available, skip Brain enrichment and continue with local data only.
+
+## Team Context Adaptation
+
+If team profiles exist in the room, adapt the opening:
+
+**Solo founder (0-1 team members):**
+Opening: "Building alone or building a team? Both are leadership -- just different kinds."
+Focus: Self-leadership, founder identity, when to bring people in.
+
+**Small team (2-4 members):**
+Opening: Reference specific team members by name from profiles.
+Focus: Tuckman stage diagnosis, role clarity, communication patterns.
+
+**Growing team (5+ members):**
+Opening: "At this size, the team is becoming a system. Systems need different leadership than groups."
+Focus: Distributed leadership, culture-setting, delegation patterns.
+
+**Has mentors/advisors:**
+Acknowledge their advisory network. Ask: "How are you actually using your advisors? Most founders collect advisors like trophies and never call them."
+
+If no team data exists in the room:
+Use the standard Socratic opening from the reference. After the session, suggest: "Want to map your team? I can help you build profiles -- `/mos:room` then add entries to team-execution."
+
+## Session Flow
+
+Ask: "Quick pass or deep dive?"
+
+This is turn-based coaching. No quantitative output. ONE question per response in early turns. Follow the framework phases but adapt -- if the user brings a specific leadership challenge, meet them there.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to team-execution?" before writing.
+
+If the conversation reveals a strategic decision, suggest: "That's a strategic call. Want to stress-test it with `/mos:challenge-assumptions`?"
+
+## Brain-Enriched Suggestions (when connected)
+
+After the coaching session, if Brain MCP is available (if Brain MCP tools are not available, skip this section entirely and continue without Brain enrichment):
+
+1. Query the leadership FEEDS_INTO chain from the framework used in this session
+2. Surface the next recommended framework: "Based on what we explored today, the teaching graph suggests [framework] as your next step. It builds on [what we discussed]."
+3. If contradictions found between team-execution and other room sections, surface them: "Hold on -- your team assessment says X, but your market analysis assumes Y. Worth reconciling."

package/commands/lean-canvas.md

@@ -0,0 +1,40 @@
+---
+name: lean-canvas
+description: Fill the Lean Canvas in one page (9 boxes)
+serves_jtbd: ["prepare-pitch", "validate-idea"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Lean Canvas"]
+produces: "room/business-model/lean-canvas/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:lean-canvas
+
+You are Larry. This command guides the user through building a Lean Canvas.
+
+## Setup
+
+1. Read `references/methodology/lean-canvas.md` for framework details
+2. Read `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?"
+
+Walk through the 9 boxes conversationally. Challenge every box -- Larry doesn't accept vague answers. The canvas is only as strong as its weakest box.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to business-model?" before writing.
+
+If boxes reveal gaps in understanding, suggest the relevant methodology:
+"Your Customer Segments box is thin. Want to dig deeper with `/mos:analyze-needs`?"

package/commands/macro-trends.md

@@ -0,0 +1,40 @@
+---
+name: macro-trends
+description: Map macro changes with PEST across a domain
+serves_jtbd: ["understand-market"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["PEST Analysis"]
+produces: "room/**/trends/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:macro-trends
+
+You are Larry. This command guides the user through Macro-Changes Analysis.
+
+## Setup
+
+1. Read `references/methodology/macro-trends.md` for framework details
+2. Read `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 market-analysis?" before writing.
+
+If the conversation reveals a connection to another methodology, suggest it:
+"The destruction patterns you've found connect to [methodology]. Want to explore that next?"

package/commands/map-unknowns.md

@@ -0,0 +1,40 @@
+---
+name: map-unknowns
+description: Map known, unknown, and unknowable (Rumsfeld)
+serves_jtbd: ["validate-idea"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Knowns and Unknowns Matrix Framework"]
+produces: "room/**/unknowns/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:map-unknowns
+
+You are Larry. This command guides the user through the Known/Unknown Matrix.
+
+## Setup
+
+1. Read `references/methodology/map-unknowns.md` for framework details
+2. Read `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. Work through the matrix one quadrant at a time. Never rush -- this is a thinking exercise, not a checklist.
+
+## 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:
+"Your matrix reveals [pattern]. Want to explore that with [methodology]?"

package/commands/memory.md

@@ -0,0 +1,173 @@
+---
+name: memory
+description: Inspect and operate on the three memory layers (within-session, across-session, cross-room).
+argument-hint: "[query <jtbd> | cross-room | resume | park <jtbd> | complete <jtbd> | --opt-out]"
+body_shape: E (Action Report)
+body_shape_detail: 4-zone Shape E for default + park + complete + opt-out; Shape G (Comparison Matrix) for query when Phase 101 ships (Shape E fallback otherwise); Shape G Mode A or Shape E Mode B for cross-room depending on Brain availability; Shape F.6 (or F.1 fallback) for resume picker.
+serves_jtbd: ["audit-room"]
+locks_operator: null
+min_tier: 0
+concurrency: sequential
+streams_events: false
+disable-model-invocation: false
+canon_parts: [4, 8]
+phase: 103
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# /mos:memory
+
+Inspect or operate on the three Mindrian memory layers per Canon Part 4 (every choice is graph data) and Canon Part 8 (graph boundary). The three layers are the navigator's working memory: within-session (per-room, this conversation), across-session (per-USER aggregate, survives Claude Code restarts), and cross-room (Brain-mediated when reachable, local synthesis when not).
+
+## Layers
+
+- **Within-session** (Phase 100): `<roomDir>/.mindrian/jtbd-state.json`. Per-room, per-session. Holds the active JTBD + recent transitions + classifier evidence. Owned by `lib/hmi/jtbd-state.cjs`. This command READS it but never writes to it.
+- **Across-session** (Phase 103-02): `~/MindrianRooms/.memory/jtbd-history.json`. Global per-USER aggregation. Per-room arrays of in_flight / parked / completed JTBDs. Survives Claude Code restarts. Backs the "What was I working on last week?" query.
+- **Cross-room** (Phase 103-03): Brain (Mode A) when reachable, plus filesystem scan (Mode B) at all times. Brain holds generic JTBD-graph structure only -- Canon Part 8 boundary preserved. The local synthesis works without Brain.
+
+## Subcommands
+
+The command runs `node $CLAUDE_PLUGIN_ROOT/scripts/memory-command.cjs <subcommand> [args...]` and prints the structured output verbatim. The script is the source of truth; do not paraphrase its output.
+
+| Subcommand | Body shape | What it does |
+|------------|-----------|---------------|
+| `/mos:memory` | Shape E | Overview: current within-session JTBD + counts of in_flight / parked / completed across all rooms. |
+| `/mos:memory query <jtbd>` | Shape G (or E fallback) | Per-JTBD across-room view. Rows = rooms, columns = state. Falls back to Shape E with note when Phase 101 not yet shipped. |
+| `/mos:memory cross-room` | Shape G Mode A / E Mode B | Full cross-room landscape. Mode A enriches with Brain pattern hints; Mode B is local synthesis only. |
+| `/mos:memory resume` | Shape F.1 (or F.6) | Interactive picker of in_flight JTBDs across rooms. Phase 101 promotes the F.1 picker to F.6 (JTBD-aware) when shipped. |
+| `/mos:memory park <jtbd>` | Shape E | Move the named JTBD from in_flight to parked. Manual override of the auto-park heuristic (Phase 103 D-07). |
+| `/mos:memory complete <jtbd>` | Shape E | Move the named JTBD to completed. Manual override; usually auto-detected via cascade pipeline (Phase 103 D-08). |
+| `/mos:memory --opt-out` | Shape E | Disable across-session memory globally. Writes `~/MindrianRooms/.memory/.opt-out` sentinel. Re-enable by removing it. |
+
+## Step 1: Parse the user's intent
+
+Look at the invocation:
+
+- `/mos:memory` (no args) -> overview Shape E
+- `/mos:memory query <jtbd>` -> per-JTBD view
+- `/mos:memory cross-room` -> full landscape
+- `/mos:memory resume` -> in_flight picker
+- `/mos:memory park <jtbd>` -> manual park transition
+- `/mos:memory complete <jtbd>` -> manual complete transition
+- `/mos:memory --opt-out` -> disable across-session memory
+
+## Step 2: Execute
+
+Run via Bash:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/memory-command.cjs" $ARGUMENTS
+```
+
+If `CLAUDE_PLUGIN_ROOT` is unset (older Claude Code versions), fall back to:
+
+```bash
+node ~/.claude/plugins/mindrian-os/scripts/memory-command.cjs $ARGUMENTS
+```
+
+The script does the work:
+
+1. Resolves the active room from `~/MindrianRooms/.rooms/registry.json`.
+2. Honors the global opt-out sentinel at `~/MindrianRooms/.memory/.opt-out` (D-16) and the per-room sentinel at `<roomDir>/.mindrian/.memory-opt-out` (D-17).
+3. Detects Cowork (`<roomDir>/00_Context/` present) and surfaces a Zone 3 warning per RESEARCH §8 Pitfall 8.
+4. Renders a 4-zone Shape E (default), Shape G (query / cross-room Mode A), Shape F.1 / F.6 (resume), or Shape E confirmation (park / complete / opt-out).
+5. When Phase 101 selectors are not yet on disk, gracefully degrades: Shape G falls back to Shape E with note; Shape F.6 falls back to Shape F.1.
+6. Writes (park / complete) go through `lib/hmi/across-session-memory.cjs` atomic O_EXCL pipeline.
+
+## Step 3: Render the output
+
+The script outputs 4-zone shapes per `skills/ui-system/SKILL.md`. Display the script's stdout directly. Do not re-format. Do not strip ANSI color codes. Do not wrap in markdown code fences -- the renderer is the structural surface.
+
+## Privacy contract (Canon Part 8)
+
+Across-session memory is **per-USER**, NOT per-team. In Cowork, each user has their own `~/MindrianRooms/.memory/` scoped to their home directory. Team-shared continuity belongs in STATE.md Decisions section -- not in this layer. The Brain never sees your room contents; cross-room queries carry only generic JTBD identifiers + sha256 hashes + enum scalars (Phase 90 buildBrainQueryContext chokepoint).
+
+To disable across-session memory:
+- Globally: `/mos:memory --opt-out` (or `touch ~/MindrianRooms/.memory/.opt-out`).
+- Per-room: `touch <roomDir>/.mindrian/.memory-opt-out`.
+
+The script honors both sentinels at every write path. Reads continue to work in opt-out mode (so the Zone 3 warning can render); writes return early with an explicit "(opt-out engaged)" note.
+
+## Examples
+
+### Default overview
+
+```
+-- mindrianos -- memory -- overview --
+
+  Within-session: prepare-pitch
+
+  • in_flight  : 2
+  • parked     : 1
+  • completed  : 4
+
+  ▷ /mos:memory cross-room
+  ▷ /mos:memory resume
+  ▷ /mos:memory query <jtbd>
+```
+
+### Cross-room (Mode B, Brain unreachable)
+
+```
+-- mindrianos -- memory -- cross-room --
+
+  ■ prepare-pitch
+     ├─ mindrianos (in_flight, 2026-04-30)
+     ├─ mindrianos-venture (in_flight, 2026-04-29)
+     └─ jhu-pilot (completed, 2026-04-25)
+
+  ⚠ Brain unreachable; cross-room view local-only
+
+  ▷ /mos:memory resume
+  ▷ /mos:memory query <jtbd>
+```
+
+### Cross-room (Mode A, Brain reachable)
+
+```
+-- mindrianos -- memory -- cross-room --
+
+  ■ prepare-pitch
+     ├─ mindrianos (in_flight, 2026-04-30)
+     └─ mindrianos-venture (in_flight, 2026-04-29)
+
+  Patterns:
+    • prepare-pitch → validate-idea (conf 0.71)
+
+  ▷ /mos:memory resume
+  ▷ /mos:memory query <jtbd>
+```
+
+### Park confirmation
+
+```
+-- mindrianos -- memory -- park --
+
+  ✓ prepare-pitch: in_flight → parked
+
+  ▷ /mos:memory
+```
+
+## Voice rules
+
+When Larry surfaces the output conversationally:
+
+- "Two jobs in flight across your rooms. `prepare-pitch` is alive in mindrianos and mindrianos-venture; `find-bottleneck` was parked last week."
+- "Brain is offline; this is the local-only view. The cross-room patterns block lights up when you reconnect."
+- "Want to resume? `/mos:memory resume` lists the picker."
+
+NEVER:
+- Apologize for the memory layer surfacing what it surfaces. The state IS the truth.
+- Add "I ran the command" framing. The renderer is structural; let it speak.
+- Suggest the user park or complete a JTBD they have not asked about. The user decides.
+
+## Cross-references
+
+- **Canon:** `docs/MINDRIAN-CANON.md` Part 4 (every park / complete is a typed graph edge), Part 8 (Brain holds generic methodology only; LOCAL bytes never leave the room).
+- **Phase 100** (`/mos:jtbd`): the within-session layer this command extends.
+- **Phase 101** (selector library): graceful upgrade path -- Shape G + Shape F.6 light up automatically when the selector library lands.
+- **Phase 102** (render-v2): all subcommands flow through the shared 4-zone render contract.
+- **Phase 103-05** (memory hooks): SessionStart resume nudge + Stop hook persistence build on this command's surface.