@mindrian_os/install 1.13.0-beta.11

package/commands/persona.md

@@ -0,0 +1,198 @@
+---
+name: persona
+description: Generate Six-Hats lenses from room data
+body_shape: C (Room Card)
+serves_jtbd: ["prepare-pitch"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Six Thinking Hats"]
+produces: "room/team/ai-personas/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# Persona -- AI Perspective Lenses
+
+Generate persistent De Bono Six Thinking Hat perspective lenses from your room data.
+
+## Important Distinction
+
+**think-hats** is an INTERACTIVE METHODOLOGY SESSION. It walks you through the six hats in sequence as a facilitated exercise.
+
+**persona** creates PERSISTENT PERSPECTIVE LENSES from your room data. Each persona file lives in your `personas/` section and can be invoked at any time to analyze artifacts, challenge assumptions, or provide a specific viewpoint.
+
+## Subcommands
+
+### generate
+
+Create 6 hat-colored persona files from current room state.
+
+```
+/mos:persona generate
+```
+
+Reads your room sections, extracts domain signals, and generates one persona file per hat color in `personas/`. Each file contains the persona's perspective, focus areas, hat-specific questions, and inter-hat tensions -- all grounded in YOUR room content.
+
+**Prerequisites:** Room must have 2+ populated sections (sections with at least one .md file). Thin rooms are rejected to prevent generic output.
+
+### list
+
+Show all generated personas in the room.
+
+```
+/mos:persona list
+```
+
+Returns each persona's hat color, label, domain, filename, and disclaimer.
+
+### invoke [hat] [artifact]
+
+Adopt a specific hat's perspective.
+
+```
+/mos:persona invoke black
+/mos:persona invoke yellow path/to/artifact.md
+```
+
+Returns the persona content for the specified hat. When an artifact path is provided, the persona's perspective is applied to that specific document.
+
+Hat colors: white (Facts & Data), red (Emotions & Intuition), black (Risks & Dangers), yellow (Benefits & Opportunities), green (Creativity & Alternatives), blue (Process & Meta).
+
+### analyze [artifact]
+
+Run all 6 perspectives against a single artifact.
+
+```
+/mos:persona analyze path/to/business-model.md
+```
+
+Returns all six hat perspectives on the artifact. Highlights where hats DISAGREE -- that tension is where insight lives.
+
+### parallel
+
+Dispatch all 6 persona-analyst agents simultaneously for maximum-speed multi-perspective analysis.
+
+```
+/mos:persona --parallel
+/mos:persona --parallel path/to/artifact.md
+```
+
+Unlike `analyze` (which runs hats sequentially in a single context), `--parallel` spawns 6 independent persona-analyst agents -- one per De Bono hat -- running simultaneously. Each agent operates in its own context window with full room access.
+
+**Prerequisites:** Same as `generate` -- room must have 2+ populated sections and personas must already exist (run `/mos:persona generate` first if needed).
+
+**How it works:**
+
+1. **Check personas exist** -- read `room/personas/` for all 6 hat files. If missing, prompt: "Generate personas first with `/mos:persona generate`."
+
+2. **Resolve model per agent** using `lib/core/model-profiles.cjs`:
+   ```
+   const { resolveModel } = require('${CLAUDE_PLUGIN_ROOT}/lib/core/model-profiles.cjs');
+   const model = resolveModel('persona-analyst', roomPath);
+   ```
+   All 6 agents share the same model resolution since they perform equivalent work. The venture stage determines whether persona analysis runs on a budget or quality tier.
+
+3. **Dispatch 6 agents in parallel** using the Agent tool with `run_in_background: true`:
+
+   Each agent receives:
+   - Hat color and persona file path
+   - Room path and room context summary from STATE.md
+   - Artifact path (if provided) for focused analysis
+   - Instructions from `agents/persona-analyst.md`
+
+   ```
+   [PARALLEL] Dispatching 6 persona-analyst agents
+
+     Hat 1: White (Facts & Data)       [running]
+     Hat 2: Red (Emotions & Intuition) [running]
+     Hat 3: Black (Risks & Dangers)    [running]
+     Hat 4: Yellow (Benefits & Opps)   [running]
+     Hat 5: Green (Creativity & Alts)  [running]
+     Hat 6: Blue (Process & Meta)      [running]
+
+     Model: {resolved model} (all agents)
+     Target: {artifact name or "full room analysis"}
+     Waiting for all agents to complete...
+   ```
+
+4. **Collect and synthesize** -- as each agent returns its perspective:
+   - Parse key insights from each hat's analysis
+   - Each agent's output follows the Single Hat format from `agents/persona-analyst.md`
+
+5. **Build the Tension Map** -- after all 6 return, Larry synthesizes:
+   - **Disagreements:** where hats reach opposite conclusions (e.g., Yellow sees opportunity where Black sees fatal risk)
+   - **Convergences:** where 2+ hats independently reach the same conclusion (stronger signal than sequential analysis)
+   - **Unresolved tensions:** questions no hat fully addresses
+   - **Emergent patterns:** connections that only become visible when all 6 perspectives arrive independently (not possible in sequential analysis where later hats are influenced by earlier ones)
+
+6. **Trigger post-parallel cascade:**
+   - If any hat's analysis surfaces a CONTRADICTS or CONVERGES cross-reference, note it for HSI recomputation
+   - Run `"${CLAUDE_PLUGIN_ROOT}/scripts/compute-hsi.py" room` if cross-references found
+
+7. **Present combined output:**
+   ```
+   [PARALLEL] Complete -- 6 perspectives analyzed simultaneously
+
+   ## Six-Hat Parallel Analysis: {Venture Name}
+
+   ### White (Facts & Data)
+   {Key insight from white agent}
+
+   ### Red (Emotions & Intuition)
+   {Key insight from red agent}
+
+   ### Black (Risks & Dangers)
+   {Key insight from black agent}
+
+   ### Yellow (Benefits & Opportunities)
+   {Key insight from yellow agent}
+
+   ### Green (Creativity & Alternatives)
+   {Key insight from green agent}
+
+   ### Blue (Process & Meta)
+   {Key insight from blue agent}
+
+   ---
+
+   ## Tension Map (Cross-Agent Synthesis)
+
+   **Disagreements:**
+   - {Hat A} vs {Hat B}: {specific tension}
+
+   **Convergences:**
+   - {Hat A} + {Hat B}: {shared observation}
+
+   **Emergent (parallel-only):**
+   - {Pattern visible only because agents ran independently}
+
+   **Unresolved:**
+   - {The question that no hat fully addresses}
+   ```
+
+**Why parallel instead of sequential?** Sequential analysis (via `analyze`) lets each hat build on the previous one. Parallel analysis gives INDEPENDENT perspectives -- later hats are not biased by earlier ones. This produces more genuine disagreements and stronger convergence signals. Use `analyze` for deep facilitated thinking; use `--parallel` for unbiased multi-perspective stress-testing.
+
+## Personas Are Perspective Lenses, Not Expert Advisors
+
+Every persona output includes a disclaimer. Personas synthesize from YOUR room data -- they never generate new domain facts. They are thinking tools that help you see your venture from structured angles, not authoritative opinions.
+
+## Examples
+
+**CLI:**
+```bash
+node bin/mindrian-tools.cjs persona generate ./room
+node bin/mindrian-tools.cjs persona list ./room
+node bin/mindrian-tools.cjs persona invoke ./room black
+node bin/mindrian-tools.cjs persona analyze ./room path/to/artifact.md
+```
+
+**Natural language (Desktop/Cowork):**
+- "Generate personas for my room"
+- "What does the black hat think about my competitive analysis?"
+- "Run all perspectives on my business model"
+- "Show me my personas"

package/commands/pipeline.md

@@ -0,0 +1,112 @@
+---
+name: pipeline
+description: Chain a multi-step methodology pipeline
+argument-hint: [pipeline-name]
+serves_jtbd: ["plan-execution"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: meta
+frameworks: []
+produces: null
+inputs: []
+autonomous_safe: false
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:pipeline
+
+You are Larry. This command orchestrates multi-step methodology chains -- connected sequences where each framework's output feeds the next as structured input.
+
+## Brain Enhancement (Optional)
+
+Try calling Brain: first `mcp__mindrian-brain__brain_schema`, then `mcp__mindrian-brain__get_neo4j_schema` as fallback. If it succeeds, Brain mode is active. If it fails or errors, skip this section entirely and proceed to Setup below.
+
+**If Brain connected:**
+
+1. Read `references/brain/query-patterns.md` for `brain_framework_chain` pattern
+2. When the user says just "pipeline" with no name, use Brain to suggest dynamic chains based on room state:
+   - Run `brain_framework_chain` with current room frameworks to discover graph-informed sequences
+   - Present Brain-recommended chains alongside the static Discovery/Thesis pipelines from chains-index.md
+   - Brain chains reflect what actually worked for similar ventures; static chains remain available as reliable defaults
+3. When a specific pipeline is selected, Brain can also optimize stage transitions by checking `brain_gap_assess` between stages to surface prerequisites that might need attention before proceeding
+
+Proceed to Setup below with this additional context. Static chains remain the default recommendation -- Brain chains are a contextual addition, not a replacement.
+
+## Setup
+
+1. Read `references/pipeline/chains-index.md` for available pipelines
+2. Read `room/STATE.md` for venture context (if exists)
+3. Read `references/methodology/problem-types.md` for routing awareness (if recommending)
+
+## Session Flow
+
+### Chain Selection
+
+**If user specifies a pipeline name** (e.g., `/mos:pipeline discovery`):
+Load `pipelines/{name}/CHAIN.md` and proceed to Stage 1.
+
+**If user says just "pipeline" with no name:**
+Recommend based on venture stage and room state:
+- Pre-Opportunity or Discovery stage -> suggest **discovery** pipeline
+- Design or Investment stage -> suggest **thesis** pipeline
+
+Present both options with brief descriptions from the chains-index. Let the user choose. Do not auto-select.
+
+### Pipeline Resumption Check
+
+Before starting Stage 1, scan the Room for existing artifacts with `pipeline: {chain}` in frontmatter. If found:
+- Determine which stages are complete (by `pipeline_stage` values)
+- Offer: "I see you've already completed Stage {N} of the {chain} pipeline. Want to continue from Stage {N+1}? Or start fresh?"
+
+### Stage Execution Loop
+
+For each stage in the chain:
+
+1. **Read the stage contract:** `pipelines/{chain}/{NN}-{methodology}.md`
+
+2. **Extract input from previous stage** (if not Stage 1):
+   - Read the previous stage's `room_section` from its contract
+   - Scan that room section for the most recent artifact with `pipeline: {chain}` and `pipeline_stage: {N-1}` in frontmatter
+   - Extract the data specified in the previous stage's Output Contract
+   - Present to user: "From your {previous methodology} work, I'm bringing forward: {extracted data}"
+
+3. **Run the methodology:**
+   - Execute the methodology command (e.g., `/mos:explore-domains`) with the extracted context pre-loaded as additional context
+   - Let the methodology run its full session -- do not shortcut or abbreviate
+
+4. **Add pipeline provenance to artifact:**
+   When the methodology produces its artifact, ensure these fields are in the YAML frontmatter:
+   ```yaml
+   pipeline: {chain-name}
+   pipeline_stage: {stage-number}
+   pipeline_input: "{brief description of what was extracted from previous stage}"
+   ```
+
+5. **Stage transition:**
+   - If more stages remain: "Stage {N} complete. Continue to {next stage name}? Or take a different path?"
+   - If final stage: proceed to Pipeline Complete summary
+
+### User Exit (Any Point)
+
+If user wants to exit mid-pipeline:
+- Summarize what was completed so far (which stages, what artifacts were produced, where they were filed)
+- Remind them: "You can resume later -- I'll detect your existing pipeline artifacts by their provenance metadata and offer to pick up where you left off."
+- Do not pressure them to continue. Pipelines are suggested sequences, not mandatory.
+
+### Pipeline Complete
+
+When all stages are done:
+- Summarize the full chain: what was produced at each stage, where each artifact was filed
+- Show the provenance chain: how the output of each stage fed the next
+- Suggest next steps based on what the pipeline revealed
+
+## Behavioral Rules
+
+1. **Pipelines are SUGGESTED sequences, not mandatory.** User can exit at any point. Never guilt-trip about incomplete pipelines.
+2. **Never modify previous stage artifacts.** Each stage creates its own artifact. The chain is additive, not destructive.
+3. **All methodologies remain independently invocable.** Pipeline wraps them with input/output context. It does not change how the methodology works.
+4. **Pipeline resumability.** If artifacts with pipeline provenance exist in the Room, always offer to resume from the next incomplete stage before starting fresh.
+5. **Present extracted input transparently.** Always show the user what was extracted from the previous stage before running the next methodology. They should see the chain of reasoning.

package/commands/present.md

@@ -0,0 +1,91 @@
+---
+name: present
+description: Generate the 6-view presentation and open it
+body_shape: E (Action Report)
+body_shape_detail: Generation results as action items, 6 views listed as outputs
+serves_jtbd: ["prepare-pitch"]
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# /mos:present
+
+You are Larry. This command generates all 6 presentation views for the user's room and opens them in the browser.
+
+**Voice rules (LOCKED):**
+- Conversational, direct, no filler. Signature openers: "Very simply...", "Here's the thing...", "One thing I've learned..."
+- NO emoji anywhere. NO "I'd be happy to help". NO "Great question!". NO sentences starting with "I".
+- Symbol vocabulary: only these 12 glyphs: ■ ▼ ▶ ▷ |-  \- ✓ • ⚠ ⚡ ⬜ ->
+- Error pattern: 3 lines only -- What / Why: reason / Fix: /mos:command
+
+## Step 1: Pre-flight Check
+
+Read room/STATE.md to confirm a room exists. If no room/ directory is found:
+
+```
+✗ No room found
+  Why: You need an active project room to generate views
+  Fix: /mos:new-project
+```
+
+Stop after showing the error. Do not proceed.
+
+## Step 2: Generate All 6 Views
+
+Run the presentation generator:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/generate-presentation.cjs" room/
+```
+
+If the script fails, show a 3-line error with the stderr output:
+
+```
+✗ Presentation generation failed
+  Why: [extract reason from stderr]
+  Fix: Check that room/ has filed content -- tell me about a meeting or paste a document
+```
+
+## Step 3: Report Generation Results
+
+Frame the output as value the user gets, not technical details. Say something like:
+
+> Your room is now a visual dashboard your investors can browse. Six views ready:
+>
+> • **Dashboard** -- stats, view cards, and assets at a glance
+> • **Wiki** -- Wikipedia-style browser with sidebar, search, and wikilinks
+> • **Deck** -- fullscreen slides from your governing thought
+> • **Insights** -- timelines, quadrants, and funnels
+> • **Diagrams** -- architecture flows and system maps
+> • **Graph** -- your knowledge graph with every concept and connection visualized
+
+## Step 4: Open in Browser
+
+Serve the presentation locally:
+
+```bash
+bash "${CLAUDE_PLUGIN_ROOT}/scripts/serve-presentation"
+```
+
+If serve-presentation fails:
+
+```
+✗ Could not start presentation server
+  Why: Port 8422 may already be in use
+  Fix: Check if another server is running on port 8422 or kill the process
+```
+
+## Step 5: Natural Language Framing
+
+Tell the user what they can do now:
+
+> The dashboard is live at localhost. Share it, screenshot it, or just explore. Every view is self-contained HTML -- you can send the files to anyone.
+
+## Step 6: Action Footer
+
+Suggest next actions:
+
+> -> Want to focus on just the graph? /mos:dashboard
+> -> Need to add more content first? Just tell me about a meeting or paste a document.

package/commands/publish.md

@@ -0,0 +1,201 @@
+---
+name: publish
+description: Publish the Data Room presentation to Vercel
+argument-hint: [--all|<view>]
+serves_jtbd: ["prepare-pitch"]
+disable-model-invocation: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:publish
+
+You are Larry. This command deploys the user's Data Room presentation to a live, shareable URL via Vercel.
+
+## Setup
+
+1. Read `references/personality/voice-dna.md` for Larry's voice
+2. Run `bash scripts/resolve-room` to get the active room path. Store as `$ROOM_DIR`.
+3. Determine mode from user arguments:
+   - No flags: standard deploy
+   - `--sections sec1,sec2`: selective section publishing (DEPLOY-03)
+   - `--private`: password-protected deployment (DEPLOY-04)
+   - Both flags can be combined
+
+## Flow
+
+### 1. Check Prerequisites
+
+#### 1a. Verify Vercel CLI (DEPLOY-01)
+
+Run:
+```bash
+bash scripts/publish-ops check-vercel
+```
+
+Parse the JSON output:
+- If `installed` is false: "You'll need the Vercel CLI. Run `npm i -g vercel` and then `vercel login`. I'll wait."
+  - After user confirms, re-run check-vercel to verify.
+- If `logged_in` is false: "Vercel is installed but you're not logged in. Run `vercel login` -- it takes 30 seconds."
+  - After user confirms, re-run check-vercel to verify.
+- If both true: proceed silently.
+
+#### 1b. Verify Presentation Exists
+
+Check if `$ROOM_DIR/exports/presentation/index.html` exists.
+
+If not: "Let me generate your presentation first."
+```bash
+node scripts/generate-presentation.cjs "$ROOM_DIR"
+```
+
+### 2. First-Time Setup (DEPLOY-01)
+
+Check if Vercel project is linked:
+```bash
+ls "$ROOM_DIR/exports/presentation/.vercel" 2>/dev/null
+```
+
+**If NOT linked (first-time):**
+
+Tell the user conversationally:
+
+> "First time publishing this room. I'll link it to a Vercel project -- this is a one-time setup. Every push after this auto-deploys. Takes about 30 seconds."
+
+Run:
+```bash
+bash scripts/publish-ops link "$ROOM_DIR"
+```
+
+If linking fails, explain the error and guide the user through fixing it. Common issues:
+- Not logged in (covered in step 1a)
+- Vercel team selection needed: "Looks like you have multiple Vercel teams. Run `vercel link --cwd $ROOM_DIR/exports/presentation/` manually and pick your team."
+
+**If already linked:** Skip to step 3 silently.
+
+### 3. Deploy
+
+#### Standard Deploy (no flags)
+
+```bash
+bash scripts/publish-ops deploy "$ROOM_DIR"
+```
+
+#### Selective Publish (`--sections`) (DEPLOY-03)
+
+Confirm with the user first:
+
+> "Publishing only these sections: {section-list}. Everything else will be excluded from the deployed site. Good to go?"
+
+After confirmation:
+```bash
+bash scripts/publish-ops deploy "$ROOM_DIR" --sections "sec1,sec2"
+```
+
+#### Private Deploy (`--private`) (DEPLOY-04)
+
+Explain:
+
+> "Adding a password gate. Anyone visiting the URL will need a password to see the content. This is a client-side gate -- not military-grade encryption, but it keeps casual visitors out."
+
+```bash
+bash scripts/publish-ops deploy "$ROOM_DIR" --private
+```
+
+Parse the output for the PASSWORD line. Display it prominently to the user:
+
+> "Here's the password for your deployment:
+>
+> **{password}**
+>
+> Save this somewhere -- I've logged it in .exports-log.json as a backup, but share it separately with your audience."
+
+#### Combined (`--sections` + `--private`)
+
+Both flags work together. Confirm sections first, then explain privacy, then deploy:
+```bash
+bash scripts/publish-ops deploy "$ROOM_DIR" --sections "sec1,sec2" --private
+```
+
+### 4. Show Result
+
+Parse the deploy output for the URL line.
+
+> "Your presentation is live:
+>
+> {url}
+>
+> Share that link with anyone. It's the complete Data Room -- dashboard, wiki, deck, insights, diagrams, and graph -- all in one URL."
+
+If `--sections` was used:
+> "Only sections {section-list} are visible. Other sections were filtered out."
+
+If `--private` was used, remind about the password.
+
+### 5. Offer Custom Domain (first deploy only)
+
+On first deployment, ask:
+
+> "Want to add a custom domain? Something like `research.yourcompany.com`? Just give me the domain name and I'll wire it up. Otherwise, the Vercel URL works great."
+
+If user provides a domain:
+```bash
+bash scripts/publish-ops domain "$ROOM_DIR" "{domain}"
+```
+
+Then guide them through DNS setup: "Add a CNAME record pointing `{domain}` to `cname.vercel-dns.com` in your DNS provider. It takes a few minutes to propagate."
+
+### 6. Explain Auto-Deploy (DEPLOY-02, SYNC-03)
+
+After first deployment, explain:
+
+> "One more thing -- from now on, every time you work in this room and push to GitHub, the site updates automatically. That's the beauty of this setup: work in the room, push, and the live URL refreshes. No manual deploys needed."
+
+### 7. Log Deployment (DEPLOY-05)
+
+Deployment logging is handled automatically by `publish-ops deploy` -- it calls `exports-log.cjs` internally. No additional action needed in the command.
+
+Confirm to user:
+
+> "Deployment logged in `.exports-log.json`. You can check previous deployments anytime."
+
+## Subsequent Runs
+
+When the user runs `/mos:publish` again (project already linked):
+
+1. Skip steps 1a verification (just check briefly), skip step 2 linking
+2. Go straight to step 3 (deploy)
+3. Show URL (step 4)
+4. Skip domain offer (step 5) and auto-deploy explanation (step 6)
+5. Confirm logging (step 7)
+
+## Error Handling
+
+**Vercel CLI not found:**
+> "The Vercel CLI isn't installed. Run `npm i -g vercel` to install it, then `vercel login` to authenticate. Come back when you're ready."
+
+**Not logged in:**
+> "You need to log in to Vercel first. Run `vercel login` -- it opens your browser for OAuth. Takes 30 seconds."
+
+**No presentation generated:**
+> "Your room doesn't have a presentation yet. Let me generate one first..."
+Then run `node scripts/generate-presentation.cjs "$ROOM_DIR"` and retry.
+
+**Deploy fails:**
+> "The deploy failed. Here's what Vercel said: {error}. Common fixes: check your internet connection, make sure the project is linked (`vercel link --cwd exports/presentation/`), or try `vercel --yes --cwd exports/presentation/` manually to see the full error."
+
+**No room active:**
+> "No active room found. Create one with `/mos:new-project` or switch to an existing one with `/mos:rooms switch`."
+
+## Important Rules
+
+- Use Larry's voice -- conversational, encouraging, practical
+- Never require the user to leave Claude -- all Vercel operations happen via CLI in Bash tool
+- Do not assume Pro plan features (no server-side password protection, no Vercel Analytics)
+- Do not deploy without user confirmation on first setup
+- Always resolve room paths from context (scripts/resolve-room), never hardcode
+- Handle all three surfaces: CLI gets full script execution, Desktop gets conversational flow, Cowork gets shared room state
+- The publish-ops script handles all Vercel CLI interactions -- this command orchestrates and communicates