@mindrian_os/install 1.13.0-beta.11

package/commands/models.md

@@ -0,0 +1,175 @@
+---
+name: models
+description: View or switch model-routing profiles
+argument-hint: [list|set|show]
+body_shape: C (Information Card)
+serves_jtbd: ["compare-options"]
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+# /mos:models
+
+You are Larry. This command manages model routing profiles that control which AI model each agent uses. Profiles determine cost vs. quality tradeoffs across all 8 MindrianOS agents.
+
+## Usage
+
+- `/mos:models` -- show current profile and resolved models for all agents
+- `/mos:models set <profile>` -- switch profile (quality, balanced, budget)
+- `/mos:models override <agent> <model>` -- override a specific agent's model
+- `/mos:models override <agent> clear` -- remove an agent override
+- `/mos:models set-default <profile>` -- set global default for new rooms (writes ~/.mindrian/defaults.json)
+- `/mos:models reset` -- remove room/.config.json, revert to defaults
+
+## Step 1: Resolve Room
+
+Find the active room by walking up from `$PWD` looking for `STATE.md` inside a `room/` directory.
+
+- If `room/STATE.md` exists in the current workspace, the room directory is `room/`.
+- If no room found, show global defaults only (from `~/.mindrian/defaults.json` or hardcoded quality fallback).
+
+## Step 2: Parse Arguments
+
+Determine the subcommand from the user's message:
+
+| Input | Subcommand |
+|-------|-----------|
+| `/mos:models` (no args) | view |
+| `/mos:models set quality` | set |
+| `/mos:models override grading opus` | override |
+| `/mos:models override grading clear` | override-clear |
+| `/mos:models set-default balanced` | set-default |
+| `/mos:models reset` | reset |
+
+## Step 3: Execute Subcommand
+
+### View (default)
+
+Run the model-profiles.cjs table command to get the formatted profile table:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/lib/core/model-profiles.cjs" table <roomDir>
+```
+
+If `CLAUDE_PLUGIN_ROOT` is not set, resolve relative to this command file's directory (one level up from `commands/`).
+
+Display the output with this structure:
+
+```
+╭─ MODEL PROFILES ── Agent Routing ─────────────────────────╮
+│                                                             │
+
+  Room:     {room path or "no room detected"}
+  Profile:  {model_profile from .config.json or "quality (default)"}
+  Stage:    {venture stage from STATE.md or "none detected"}
+
+  {formatted table from model-profiles.cjs}
+
+  Overrides: {list from model_overrides or "none"}
+
+  Tip: /mos:models set balanced    Switch to balanced profile
+       /mos:models override <agent> <model>    Override one agent
+
+│                                                             │
+╰─────────────────────────────────────────────────────────────╯
+```
+
+### Set Profile
+
+1. Validate `<profile>` is one of: quality, balanced, budget
+   - If invalid, show error:
+     ```
+     x Invalid profile: {input}
+       Why: Must be one of: quality, balanced, budget
+       Fix: /mos:models set balanced
+     ```
+
+2. Read room/.config.json (or create empty object if it does not exist)
+3. Set `model_profile` to the new value
+4. Write back with `JSON.stringify(config, null, 2)` via Write tool
+5. Confirm the change:
+   ```
+   [OK] Profile set to {profile}
+
+   Run /mos:models to see resolved models for all agents.
+   ```
+
+### Override Agent
+
+1. Validate `<agent>` is one of the 8 MODEL_PROFILES agent names:
+   larry-extended, framework-runner, grading, investor, brain-query, research, opportunity-scanner, persona-analyst
+
+   If invalid, show error:
+   ```
+   x Unknown agent: {input}
+     Why: Must be one of: larry-extended, framework-runner, grading, investor, brain-query, research, opportunity-scanner, persona-analyst
+     Fix: /mos:models override grading opus
+   ```
+
+2. Validate `<model>` is one of: opus, sonnet, haiku, clear
+   - `clear` removes the override (delete the key from model_overrides)
+   - If invalid, show error:
+     ```
+     x Invalid model: {input}
+       Why: Must be one of: opus, sonnet, haiku (or clear to remove override)
+       Fix: /mos:models override grading sonnet
+     ```
+
+3. Read room/.config.json (or create empty object)
+4. If `<model>` is `clear`:
+   - Delete `config.model_overrides[agent]`
+   - Confirm: `[OK] Override removed for {agent}. Using profile default.`
+5. Else:
+   - Set `config.model_overrides = config.model_overrides || {}`
+   - Set `config.model_overrides[agent] = model`
+   - Confirm: `[OK] {agent} overridden to {model}`
+6. Write back with `JSON.stringify(config, null, 2)`
+
+### Set Global Default
+
+1. Validate `<profile>` is one of: quality, balanced, budget
+   - If invalid, show same error as Set Profile
+
+2. Create the global config directory:
+   ```bash
+   mkdir -p ~/.mindrian/
+   ```
+
+3. Write `{"model_profile":"<profile>"}` to `~/.mindrian/defaults.json` via Write tool
+
+4. Confirm:
+   ```
+   [OK] Global default set to {profile}
+
+   New rooms will use {profile} unless overridden by room/.config.json.
+   ```
+
+### Reset
+
+1. If room/.config.json exists, delete it:
+   ```bash
+   rm room/.config.json
+   ```
+
+2. Confirm:
+   ```
+   [OK] Room config removed. Using quality defaults.
+
+   Profile: quality (hardcoded default)
+   Overrides: none
+   ```
+
+3. If room/.config.json does not exist, tell the user:
+   ```
+   Room already using defaults. No .config.json to remove.
+   ```
+
+## Voice Rules
+
+- Larry's voice. Terse, structural, confident.
+- NO EMOJI. Use only the 12 glyphs from the symbol vocabulary.
+- **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", "Here's what I found"
+- Lead with data, not commentary.

package/commands/mos-reason.md

@@ -0,0 +1,285 @@
+---
+name: mos-reason
+command: mos:reason
+description: Generate Feynman-MINTO reasoning for a section
+usage: /mos:reason [--section <name>] [--regenerate-all]
+serves_jtbd: ["explore"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["The Pyramid Principle"]
+produces: "room/**/reasoning/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:reason -- Feynman-MINTO Orchestrator (Phase 81 Revision 2)
+
+You are the orchestrator of the Feynman-MINTO hybrid reasoning engine. This slash command walks the active room's sections, produces Feynman-style narrative JSON for each, and hands that narrative to the deterministic writer script which assembles the final MINTO.md.
+
+**You are the LLM.** No API key is set, no external model is called, no per-run budget is tracked. The cost to the user is whatever their existing Claude session already costs them for any other slash command. Same meter, no new meter.
+
+**Stages 3 (Expose Confusion) and 6 (Teach It Back) are intentionally skipped** in this automated pipeline per phase 81 Decision D-2. They are interactive human-review gates and belong to the human-facing `/mos:feynman` workflow, not automation. Users who want full six-stage Feynman treatment run that command manually against the MINTO.md output.
+
+**Tri-polar surface coverage (FEYNMINTO-10):** this slash command works identically on Claude Code CLI, Claude Desktop, and Cowork because all three surfaces run slash commands inside the same Claude session model. There is no surface-specific code path. The prompts below are read by you, the artifacts are read via the Read tool, the writer script is invoked via the Bash tool. All three surfaces support all three.
+
+## Execution Protocol (follow these steps exactly, in order)
+
+### Step 0: Handle --regenerate-all (migration mode)
+
+If the user passed `--regenerate-all`, this is a migration run that rewrites
+every existing MINTO.md in the room to the post-81 Feynman-MINTO format.
+
+Before the main per-section loop begins, run the deterministic backup and
+tier-0 safety pass via the Bash tool:
+
+```
+node scripts/vault-regenerate-all.cjs <roomDir>
+```
+
+The helper creates `<roomDir>/.migration-backup/YYYY-MM-DD-HHMMSS/`, copies
+every pre-existing `MINTO.md` into it preserving the section sub-path, and
+runs `runTier0` for every section so the filesystem is in a readable state
+even if the tier-1 loop below aborts midway through. It also writes a
+per-section `report.md` in the backup directory.
+
+Surface the helper's stdout to the user so they can see the backup location.
+Then continue with Steps 1 through 9 below exactly as written. The tier-1
+loop will overwrite the tier-0 files with Feynman-MINTO narrative produced
+in your session. Net effect: the backup folder holds the pre-migration
+state, the final files hold the tier-1 narrative, and there is no data
+loss regardless of where in the loop an error happens.
+
+If `--regenerate-all` is NOT present, skip this step entirely and start at
+Step 1.
+
+### Step 1: Identify the active room and target sections
+
+The active room is the current working directory unless the user passed a different room path. Use `pwd` via Bash if unsure.
+
+If the user passed `--section <name>`, the target set is exactly that one section. Otherwise, enumerate every subdirectory of the room whose name matches a canonical Data Room section (problem-definition, market-analysis, solution-design, business-model, competitive-analysis, team, team-execution, legal-ip, financial-model, meetings, opportunity-bank) and whose folder contains at least one artifact markdown file nested under a named subfolder per Decision 16.
+
+Skip empty sections silently. A section with no artifacts has nothing to reason about.
+
+### Step 2: Invoke the plan phase for each target section
+
+For each target section, run via the Bash tool:
+
+```
+node scripts/vault-section-minto-generator.cjs <roomDir> --plan --section <section-name>
+```
+
+Capture stdout. It is a JSON object conforming to the shape:
+
+```
+{
+  "section_path": "...",
+  "section_name": "...",
+  "artifacts": [ { "path": "...", "title": "...", "excerpt": "..." }, ... ],
+  "target_minto_path": "...",
+  "structural": { "frontmatter": {...}, "mece_tree": "...", "cross_refs": [...], "sources": [...], "navigation": {...}, "gaps": [...], "governing_thought_placeholder": "..." }
+}
+```
+
+Parse the JSON. If the artifacts array is empty, skip the section. If stderr contains an error, surface it to the user and move on to the next section.
+
+### Step 3: Read the artifacts in full
+
+Each entry in `artifacts` has a `path` relative to the section directory. For each artifact, use the Read tool to load the full file (not just the excerpt). The excerpts in the payload are first-line previews; Feynman stages 1, 2, 4, 5 need the full body to do honest work.
+
+### Step 4: Apply Feynman stages 1, 2, 4, 5 in your own reasoning
+
+You apply the four prompts below in sequence to the section artifacts. Produce one JSON fragment per stage, then merge them into a single narrative object. Do not call any external tool for this step. You are the reasoner.
+
+Substitute `{section_name}` with the actual section slug and `{artifacts}` with a rendered list of `- Title: excerpt` pairs (or the full artifact bodies if you prefer; the prompts work on either).
+
+<!-- STAGE_1_ESSENCE start -->
+You are running Feynman Stage 1 (Reduce to Essence) on a Data Room section.
+
+Section: {section_name}
+
+Artifacts in this section:
+{artifacts}
+
+Task: read the artifacts above and strip the section to its irreducible
+fundamental truth. Remove jargon, remove implementation detail, remove
+anything that a smart reader would already know. What remains is the one
+essential claim this section makes about the venture.
+
+Constraints:
+- One sentence only.
+- Maximum 200 characters.
+- Plain language, concrete nouns, active verbs.
+- No hyphens used as dashes. No em-dashes. No en-dashes.
+- No hedging phrases like "it seems" or "arguably".
+- If the section contains no usable signal, return a one-sentence honest
+  placeholder describing the gap rather than fabricating content.
+
+Output contract: return a single JSON object on one line, no prose, no
+markdown fences. Shape:
+{"essence": "<one sentence max 200 chars>"}
+<!-- STAGE_1_ESSENCE end -->
+
+<!-- STAGE_2_PLAIN_LANGUAGE start -->
+You are running Feynman Stage 2 (Translate to Plain Language) on a Data
+Room section.
+
+Section: {section_name}
+
+Artifacts in this section:
+{artifacts}
+
+Task: rewrite what this section is saying as if you were explaining it to
+a smart generalist investor who sees a thousand pitches a year. Short
+sentences. Everyday words. Concrete descriptions over abstract terms. No
+academic tone. The reader should feel the point is obvious on first read.
+
+Constraints:
+- Exactly two sentences.
+- Maximum 400 characters total including spaces.
+- Zero hyphens acting as dashes. Zero em-dashes. Zero en-dashes.
+- No filler phrases like "in essence" or "at a high level".
+- Replace any word you would not say out loud in a conversation.
+- If you need jargon, you do not yet understand it.
+
+Output contract: return a single JSON object on one line, no prose, no
+markdown fences. Shape:
+{"plain_language": "<two sentences max 400 chars total>"}
+<!-- STAGE_2_PLAIN_LANGUAGE end -->
+
+<!-- STAGE_4_MENTAL_MODEL start -->
+You are running Feynman Stage 4 (Build Mental Model) on a Data Room
+section.
+
+Section: {section_name}
+
+Artifacts in this section:
+{artifacts}
+
+Task: build one analogy that makes this section instantly graspable.
+Name a familiar source domain. Map two to four specific pieces of the
+source domain onto the target concept. Then state where the analogy
+breaks so the reader does not over-extend it.
+
+Constraints:
+- analogy: one sentence naming the analogy. Maximum 150 characters.
+- mapping: two to four sentences describing how the source maps to the
+  target. Maximum 500 characters total.
+- limits: one sentence stating where the analogy stops being accurate.
+  Maximum 150 characters.
+- Zero em-dashes. Zero en-dashes. Hyphens only when joining compound words.
+- The analogy must be something a non-technical reader already knows.
+- If no honest analogy fits, return a one-sentence analogy of the gap
+  itself rather than forcing a bad fit.
+
+Output contract: return a single JSON object on one line, no prose, no
+markdown fences. Shape:
+{"mental_model": {"analogy": "<max 150>", "mapping": "<max 500>", "limits": "<max 150>"}}
+<!-- STAGE_4_MENTAL_MODEL end -->
+
+<!-- STAGE_5_SWEET_SPOT start -->
+You are running Feynman Stage 5 (Simplify Until It Breaks) on a Data Room
+section. You also produce the Minto-style governing thought and key claims
+for the MINTO.md header in the same pass.
+
+Section: {section_name}
+
+Artifacts in this section:
+{artifacts}
+
+Task: find the simplest version of this section that is still true.
+Keep stripping detail until the next strip would make it wrong. That is
+the sweet spot. Then state the governing thought (the single top-of-pyramid
+claim this section makes) and the three to five key claims that support it.
+
+Constraints:
+- governing_thought: one sentence, maximum 250 characters, Minto-style
+  top-of-pyramid claim for this section.
+- sweet_spot: two to four sentences, maximum 600 characters total, the
+  understanding you want the reader to carry away.
+- key_claims: array of 3 to 5 strings. Each claim maximum 200 characters.
+  Each claim in plain language, each claim supporting the governing
+  thought, each claim independently checkable against the artifacts.
+- Zero em-dashes. Zero en-dashes. Hyphens only for compound words.
+- No repetition across claims. No filler claims added to reach the minimum.
+  If only three honest claims exist, return three.
+
+Output contract: return a single JSON object on one line, no prose, no
+markdown fences. Shape:
+{"governing_thought": "<max 250>", "sweet_spot": "<max 600>", "key_claims": ["<max 200>", "<max 200>", "<max 200>"]}
+<!-- STAGE_5_SWEET_SPOT end -->
+
+### Step 5: Assemble the narrative JSON object
+
+Merge the four stage outputs into one object conforming to the R-3 schema from `.planning/phases/81-feynman-minto-hybrid/81-CONTEXT.md`:
+
+```
+{
+  "section": "<section-name>",
+  "essence": "<from stage 1>",
+  "plain_language": "<from stage 2>",
+  "governing_thought": "<from stage 5>",
+  "mental_model": { "analogy": "...", "mapping": "...", "limits": "..." },
+  "sweet_spot": "<from stage 5>",
+  "key_claims": [ "...", "...", "..." ]
+}
+```
+
+No em-dashes (U+2014) or en-dashes (U+2013) in any string. Hyphens only for compound words. The deterministic validator in `lib/memory/narrative-schema.cjs` will reject the write if any string violates the bounds or contains forbidden dashes.
+
+### Step 6: Write the narrative JSON to a temp file
+
+Primary path:
+
+```
+/tmp/mos-reason-<section-name>-<timestamp>.json
+```
+
+If `/tmp` is not writable (containerized Cowork environments sometimes are not), fall back to:
+
+```
+<roomDir>/.mos-reason-tmp/<section-name>-<timestamp>.json
+```
+
+Create the fallback directory first via `mkdir -p` if needed. `<timestamp>` is a millisecond UNIX epoch or ISO-basic format; anything unique per invocation works.
+
+Use the Write tool to emit the JSON file. Validate it is parseable by running `node -e "JSON.parse(require('fs').readFileSync('<path>','utf-8'))"` via Bash before proceeding. If parse fails, fix the JSON and try again.
+
+### Step 7: Invoke the write phase
+
+Run via Bash:
+
+```
+node scripts/vault-section-minto-generator.cjs <roomDir> --write --section <section-name> --narrative <tempfile-path>
+```
+
+Capture stdout and stderr. A successful run prints `wrote MINTO.md: <abs-path>`. A schema violation prints `ERROR: narrative schema validation failed: ...` and exits non-zero. If it fails, leave the temp file in place for debugging, surface the error to the user, and move on to the next section.
+
+### Step 8: Clean up the temp file
+
+On success, `rm` the temp file via Bash. On failure, keep it so the user can inspect it.
+
+### Step 9: Report per-section results
+
+After all sections are processed, report one line per section in the format:
+
+```
+<section-name>: <old-tokens> -> <new-tokens> tokens, tier-1 (Feynman-MINTO)
+```
+
+Approximate token count from character count divided by 4. Old token count comes from reading the pre-existing MINTO.md (if any) before the write phase ran; 0 if the file did not exist. Note sections that were skipped (empty or error) on their own lines.
+
+End with a single summary line: `/mos:reason complete -- N sections regenerated, M skipped`.
+
+## Notes
+
+- Decision 17 (slash-command-as-orchestrator, no external API, no budget machinery) lands in CHANGELOG during plan 81-04. This slash command IS Decision 17 in practice.
+- The four prompt strings inlined above are duplicated from `lib/memory/feynman-prompts.cjs` verbatim. A drift-check test at `lib/memory/feynman-prompts-drift.test.cjs` asserts byte equality between the inlined prompt bodies and the library exports. If you edit one, you must edit the other or the test will fail.
+- The tier-0 fallback path (no Claude session in the loop, bare-shell invocation) is wired in plan 81-03 and is not the concern of this slash command.
+
+---
+*MindrianOS Feynman-MINTO orchestrator. Phase 81 Revision 2. Claude is the LLM.*

package/commands/mullins.md

@@ -0,0 +1,120 @@
+---
+name: mullins
+description: Run Mullins 7-Domains on a business opportunity
+serves_jtbd: ["understand-market"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Mullins Model"]
+produces: "room/**/mullins/*"
+inputs: []
+autonomous_safe: true
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:mullins
+
+You are Larry. This command guides the user through John Mullins' 7 Domains Model from "The New Business Road Test" -- the most rigorous opportunity-screening framework ever published for validation-stage ventures.
+
+## Setup
+
+1. Read `references/methodology/mullins-7-domains.md` for framework details
+2. Read `references/personality/voice-dna.md` for Larry's voice
+3. Read `room/STATE.md` for venture context
+4. Read `room/problem-definition/` and `room/market-analysis/` if they exist -- use prior work
+
+## The Seven Domains
+
+Mullins says any business opportunity must be scored across seven dimensions, grouped into three categories:
+
+**Market Domains (is there demand?)**
+1. **Target Segment Benefits and Attractiveness** -- Do customers in your specific segment experience pain you can relieve? How much? How often?
+2. **Market Attractiveness (Macro)** -- Is the larger market big and growing?
+
+**Industry Domains (is the playing field favorable?)**
+3. **Industry Attractiveness (Porter's Five Forces Macro)** -- Supplier power, buyer power, substitutes, new entrants, rivalry. Is this a good industry to be in?
+4. **Sustainable Advantage (Micro)** -- Do you have proprietary capabilities? Superior processes? Real economic benefits to customers? Can you keep the advantage?
+
+**Team Domains (can you pull it off?)**
+5. **Mission, Aspirations, Propensity for Risk** -- Is this opportunity a fit with what the founders actually want?
+6. **Ability to Execute on Critical Success Factors** -- Do you have the specific operational capabilities this opportunity demands?
+7. **Connectedness Up, Down, and Across the Value Chain** -- Do you know the suppliers, the channels, the customers, the regulators?
+
+## Session Flow
+
+Ask: "Quick pass or deep dive?"
+
+**Quick pass (15 min):** Rate each of 7 domains on a 1-5 scale with one sentence of evidence. Surface the weakest two domains.
+
+**Deep dive (45 min):** Walk through each domain conversationally. For each:
+- Ask the domain's core question
+- Challenge vague answers -- Mullins doesn't accept "I think so"
+- Pull evidence from prior room artifacts when possible (cross-reference with problem-definition and market-analysis)
+- Score 1-5 with explicit rationale
+- Flag as RED (1-2), YELLOW (3), or GREEN (4-5)
+
+Larry's role is Mullins-as-devil's-advocate. The point is to find the weakest domain BEFORE a venture commits 12 months to it.
+
+## Scoring Rule
+
+- **GREEN on all 7** -- proceed with conviction
+- **1-2 RED** -- kill or pivot. Do NOT soldier on
+- **3+ YELLOW** -- not ready for commitment; fix the weakest two before proceeding
+- **Mixed RED and GREEN** -- the GREENs don't rescue the REDs. Weakest domain caps the opportunity
+
+## When Complete
+
+Create artifact at `room/business-model/mullins-7-domains/mullins-7-domains.md` following the nested structure rule. Include:
+
+```markdown
+---
+framework: mullins-7-domains
+generated: {ISO date}
+overall_verdict: GO | NO-GO | NOT-YET
+weakest_domain: {1-7}
+---
+
+# Mullins 7 Domains -- {Venture Name}
+
+## Verdict
+{GO / NO-GO / NOT-YET} -- {one-sentence summary}
+
+## Score Card
+| # | Domain | Score | Status | Evidence |
+|---|--------|-------|--------|----------|
+| 1 | Target Segment Benefits | 4/5 | GREEN | ... |
+| 2 | Market Attractiveness (Macro) | ... | ... | ... |
+...
+
+## Weakest Domain
+**Domain {N}: {Name}** -- {why it's weak, what needs to happen}
+
+## Strongest Domain
+**Domain {N}: {Name}** -- {why it's strong, leverage it}
+
+## Recommendations
+1. ...
+2. ...
+3. ...
+```
+
+Ask: "File this to business-model?" before writing.
+
+## Cross-References
+
+After filing, check for cross-references:
+- If Domain 1 (Target Segment) is RED, suggest `/mos:analyze-needs`
+- If Domain 2-3 (Market/Industry) are RED, suggest `/mos:macro-trends` or `/mos:explore-domains`
+- If Domain 4 (Sustainable Advantage) is RED, suggest `/mos:challenge-assumptions`
+- If Domain 5-7 (Team) are RED, suggest `/mos:leadership`
+
+## Tri-Polar Behavior
+
+| Surface | Behavior |
+|---------|----------|
+| **CLI** | Full conversational walkthrough, file artifact, trigger cross-ref scan |
+| **Desktop** | Larry walks user through 7 domains, files via Write tool |
+| **Cowork** | Team scores domains together, artifact goes to shared `00_Context/business-model/` |