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

package/output-styles/destijl.md

@@ -0,0 +1,67 @@
+---
+name: destijl
+description: MindrianOS De Stijl 4-zone output style. System-prompt-enforced.
+force-for-plugin: true
+keep-coding-instructions: true
+---
+
+# MindrianOS De Stijl Output Style
+
+You are operating inside the MindrianOS plugin. ALL output from `/mos:*` commands and Larry's terminal prose follows the UI Ruling System defined in `skills/ui-system/SKILL.md`. This output style enforces the 4-zone anatomy at the system-prompt level so the rules apply even when a skill is not auto-loaded.
+
+## The 4 Zones (Fixed Order)
+
+Every output has exactly 4 zones in this order. No reordering. No invention.
+
+**Zone 1 (Header Panel):** room context, venture stage, section name.
+Standard form: `-- Room Name -- section -- Stage --`. Compact form on narrow terminals. Single-line dashes. Room name always first (multi-room canary).
+
+**Zone 2 (Content Body):** payload per body shape (see Body Shapes below). No chrome.
+
+**Zone 3 (Intelligence Strip):** signals from room-proactive. HIGH/MEDIUM only. Max 3. Omit entirely if no signals.
+
+**Zone 4 (Action Footer):** NEVER omitted. 2-3 grounded `/mos:` commands. One primary, 1-2 alternatives. Real commands grounded in current state. Never suggest what the user just ran.
+
+## Body Shapes (closed vocabulary)
+
+| Shape | Used for |
+|-------|----------|
+| A | Mondrian Board: progress bars per section (e.g. /mos:status) |
+| B | Semantic Tree: folder tree with state glyphs (e.g. /mos:help) |
+| C | Room Card: governing thought + entries + edges + MINTO health (e.g. /mos:room [section]) |
+| D | Document View: frontmatter + full content (e.g. /mos:query) |
+| E | Action Report: changes + new edges + summary (e.g. /mos:act, /mos:doctor) |
+| F.0 | Mini Decision Gate: tiny binary gate |
+| F.1 | Next Move selector: 3-5 verbs from the canonical ten |
+| F.2 | Path Control selector: plan/replan |
+| F.3 | Rabbit-Hole Depth: Shallow/Medium/Deep/Extreme/Back |
+| F.4 | Insight Extraction: Key insights / + contradictions / + actions / Create artifact / Back |
+| F.5 | Branch Resolution: Continue/Merge/Compare/Park/Drop |
+| F.6 | Plan Review Round |
+| methodology | Conversational output (no shape); filing confirmation uses Shape E |
+
+Each `commands/*.md` declares its `body_shape:` in frontmatter. The plugin enforces compliance via `/mos:doctor --ui-compliance` (Phase 121.5 Sub-plan J succeeds /mos:hmi-status).
+
+## Symbol Vocabulary
+
+12 glyphs, one meaning each. NO EMOJI in command output (carve-out: only `scripts/context-monitor` statusline may use emoji per the SKILL.md Section 3 directive). See `skills/ui-system/SKILL.md` Section 3 for the full glyph table.
+
+## Color Contract
+
+5 ANSI colors with fixed meaning. Color is NEVER decoration. Green=success, Cyan=commands/paths, Yellow=warning, Red=error only, Gray=meta. See SKILL.md Section 4.
+
+## Voice Rules (CLI Larry)
+
+Terse, structural, confident, action-oriented. No "Great question!" / "I'd be happy to help" / "It's important to note". Direct statements, imperatives, evidence-first. One insight per line. NO em-dashes (use hyphens). See SKILL.md Section 6.
+
+## Error Handling
+
+Three-line pattern: red `x` + what failed / indented `Why:` reason / indented `Fix:` resolving command in cyan. No stack traces. See SKILL.md Section 7.
+
+## Cross-Surface Adaptation
+
+CLI is the master template. Desktop degrades: no box chars (use bold headers), no progress bars (use text), no tree symbols (use bullets), no ANSI color (use markdown). Cowork matches CLI. Width: 80 cols default; <60 cols compacts headers and collapses trees. See SKILL.md Section 9.
+
+---
+
+**Self-check (for the assistant):** if your output is not in 4 zones with the correct body shape for the command being invoked, the output style is not loaded. /mos:doctor --ui-compliance --json will catch this.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindrian_os/cli",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.33",
   "description": "Install MindrianOS into Claude Code with one command -- `npx @mindrian_os/cli`. Ships the MindrianOS plugin (Larry + PWS methodology + Data Room) plus a setup/diagnostics CLI (install/doctor/update).",
   "scripts": {
     "mcp": "node bin/mindrian-mcp-server.cjs",
@@ -12,14 +12,32 @@
     "cli": "bin/cli.js"
   },
   "files": [
-    "bin/cli.js",
-    "lib/core/active-plugin-root.cjs",
+    ".claude-plugin",
+    ".mcp.json",
+    "settings.json",
+    "npm-shrinkwrap.json",
+    "hooks",
+    "commands",
+    "skills",
+    "agents",
+    "pipelines",
+    "output-styles",
+    "lib",
+    "!lib/wiki/editor-src",
+    "!lib/import/test-fixtures",
+    "scripts",
+    "!scripts/release.sh",
+    "!scripts/release-lib",
+    "bin",
+    "data",
+    "references",
+    "templates",
+    "assets",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@huggingface/transformers": "^4.2.0",
     "@ig3/markdown-it-wikilinks": "^1.0.2",
     "@modelcontextprotocol/ext-apps": "^1.5.0",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/pipelines/PWS_grading/01-deep-grade.md

@@ -0,0 +1,48 @@
+---
+stage: 1
+methodology: deep-grade
+chain: PWS_grading
+input_from: null
+output_to: mullins
+room_section: deep-grades
+---
+
+# Stage 1: Deep Grade (Calibrated Quality Baseline)
+
+## Input Extraction
+
+First stage. Uses the quote-anchored evidence JSON and the populated scratch room
+produced by Stage A intake (`evidence.json` + typed claim nodes in `room.db`). No
+prior pipeline artifact needed.
+
+Read the room's populated sections (problem, value proposition, evidence claims,
+self-identified gaps) as scaffolded by the intake pass. Every substantive read
+traces to a verbatim transcript quote or timestamp already captured in the
+evidence JSON. Do NOT introduce any claim absent from that evidence.
+
+## Stage Instructions
+
+Run `/mos:deep-grade` against the scratch room.
+
+Course-tier calibration (per the frozen rubric appended at session level): grade
+the thinking quality a first-venture undergraduate demonstrated, NOT an
+investor-grade venture. Evidence-vs-assertion awareness is rewarded at intro
+depth. Disfluencies, diarization noise, and non-native phrasing are NEVER graded
+as content weaknesses.
+
+When the methodology produces its artifact, add pipeline provenance to
+frontmatter:
+
+```yaml
+pipeline: PWS_grading
+pipeline_stage: 1
+pipeline_input: "Evidence JSON + populated scratch room (Stage A intake)"
+```
+
+## Output Contract
+
+Writes a calibrated grade artifact to the `deep-grades` room section. The grade
+and its evidence-anchored rationale become the baseline the next stage reads.
+
+`output_to: mullins` -- Stage 2 consumes this quality baseline as the starting
+read for the 7-Domains market/venture analysis.

package/pipelines/PWS_grading/02-mullins.md

@@ -0,0 +1,50 @@
+---
+stage: 2
+methodology: mullins
+chain: PWS_grading
+input_from: deep-grade
+output_to: build-thesis
+room_section: mullins
+---
+
+# Stage 2: Mullins 7-Domains (Market and Venture Read)
+
+## Input Extraction
+
+Extract from the Stage 1 artifact (scan `room/deep-grades/` for the most recent
+artifact with `pipeline: PWS_grading` and `pipeline_stage: 1` in frontmatter):
+
+- **Calibrated grade + rationale** -- the quality baseline that frames how much
+  weight each domain read can carry
+- **Evidence-anchored strengths and gaps** -- carry forward as the domains to
+  examine, each still tied to its transcript quote/timestamp
+
+mullins runs BEFORE build-thesis (navigator-locked order): the 7-Domains read
+grounds the market/industry picture the scored thesis then interrogates.
+
+## Stage Instructions
+
+Run `/mos:mullins` against the scratch room with the extracted baseline.
+
+Tier the 7-Domains analysis to course depth: read market/industry/team domains
+at the level the assignment teaches (problem -> value -> prototype ->
+risks+mitigation -> critical path -> team -> gaps). Do NOT demand unit economics,
+moat defensibility, or term-sheet-grade market sizing the assignment never asked
+for. Credit self-identified gaps already captured in the evidence JSON; never
+re-list them as discovered deficiencies.
+
+When the methodology produces its artifact, add pipeline provenance to
+frontmatter:
+
+```yaml
+pipeline: PWS_grading
+pipeline_stage: 2
+pipeline_input: "Calibrated grade baseline from stage 1"
+```
+
+## Output Contract
+
+Writes a 7-Domains artifact to the `mullins` room section.
+
+`output_to: build-thesis` -- Stage 3 consumes the domains read as the evidence
+context for the scored (non-gating) Ten-Questions thesis.

package/pipelines/PWS_grading/03-build-thesis.md

@@ -0,0 +1,60 @@
+---
+stage: 3
+methodology: build-thesis
+chain: PWS_grading
+input_from: mullins
+output_to: structure-argument
+room_section: financial-model
+scored_mode: true
+---
+
+# Stage 3: Build Thesis (Scored, Non-Gating)
+
+## Input Extraction
+
+Extract from the Stage 2 artifact (scan `room/mullins/` for the most recent
+artifact with `pipeline: PWS_grading` and `pipeline_stage: 2` in frontmatter):
+
+- **7-Domains read** -- the market/industry/team context each of the ten
+  questions is scored against
+- **Evidence-anchored strengths and gaps** -- still tied to transcript
+  quotes/timestamps; the ten questions are answered from THIS evidence, never
+  from invented content
+
+## Stage Instructions
+
+Run `/mos:build-thesis` against the scratch room.
+
+**SCORE-AND-CONTINUE (this stage is non-gating).** The shipped build-thesis body
+carries a prompt-level 6/10 "Binary gate" that STOPS below threshold. In this
+chain that halt is neutralized: SCORE all ten questions and CONTINUE
+unconditionally. Never halt below 6/10. Emit the per-question 0/1 scores WITH
+their one-line evidence as feedback input for the packaging stage, not as a
+go/no-go gate. The primary mechanism is the frozen course-tier rubric
+`${CLAUDE_PLUGIN_ROOT}/references/methodology/rubric-huji.md` appended at session level via
+`--append-system-prompt-file`; `${CLAUDE_PLUGIN_ROOT}/references/methodology/build-thesis-scored.md` is
+the demo-verified fallback scored variant if a residual halt is observed.
+
+Course-tier discipline: score the ten questions at the depth the assignment
+teaches. Do NOT fail a course pitch on unit economics, moat, defensibility, or
+valuation the assignment never asked for. Credit self-identified gaps; never
+double-punish metacognition. Never penalize disfluencies, diarization noise, or
+non-native phrasing.
+
+When the methodology produces its artifact, add pipeline provenance to
+frontmatter:
+
+```yaml
+pipeline: PWS_grading
+pipeline_stage: 3
+pipeline_input: "7-Domains read from stage 2"
+```
+
+## Output Contract
+
+Writes a scored Ten-Questions thesis artifact to the `financial-model` room
+section. The artifact carries per-question scores and evidence, NOT a
+gate-passed/failed halt.
+
+`output_to: structure-argument` -- Stage 4 packages the surviving points into a
+Minto Pyramid.

package/pipelines/PWS_grading/04-structure-argument.md

@@ -0,0 +1,77 @@
+---
+stage: 4
+methodology: structure-argument
+chain: PWS_grading
+input_from: build-thesis
+output_to: null
+room_section: argument
+---
+
+# Stage 4: Structure Argument (Minto Pyramid Packaging)
+
+## Input Extraction
+
+Extract from the Stage 3 artifact (scan `room/financial-model/` for the most
+recent artifact with `pipeline: PWS_grading` and `pipeline_stage: 3` in
+frontmatter):
+
+- **Per-question scores + evidence** -- the scored (non-gating) Ten-Questions
+  read; each score still carries its transcript quote/timestamp
+- **Strengths and gaps** across deep-grade, mullins, and the scored thesis -- the
+  raw material to package as the student-facing feedback
+
+structure-argument runs LAST: it is the Minto packaging step, not a new analysis.
+Do NOT introduce claims absent from the upstream evidence.
+
+## Stage Instructions
+
+Run `/mos:structure-argument` against the scratch room to package the feedback as
+a Minto Pyramid tiered to the student's level:
+
+- **Governing thought first** -- one clear top-line the student can act on
+- **2-3 MECE branches** -- each branch names the criterion (feed-up), what this
+  pitch did against it with the quoted evidence (feed-back), and ONE concrete
+  next step at course level (feed-forward)
+- **Every quoted span is byte-verbatim.** Each quote you deliver is a single
+  contiguous run copied character for character from the transcript: no ellipsis
+  joins across non-adjacent fragments (never `"biosensor engineer... a mobile app
+  developer"`), no cleaned disfluencies (keep `vali- validating`, `surprising--
+  important`), nothing added or dropped inside the span. Quote less, but exactly -
+  the delivered quotes are re-checked against the transcript by the D1 verifier
+  before the artifact is written (see rubric-huji.md Section 3b).
+- **Quote marks mean verbatim, never counterfactual.** Put quotation marks (single
+  or double) ONLY around words the student actually spoke. Never quote a phrase the
+  student did NOT say, even to contrast with it (never `you did not say 'a good
+  team'`) - the D1 verifier checks that quoted span too and a phrase absent from the
+  transcript fails the gate. Write contrasts and emphasis as plain text, no quotes.
+- Length proportionate to a 2-minute pitch; never a 4,000-word essay
+- Credit self-identified gaps and deepen them (HOW to do the work, not THAT it is
+  missing); never punish disfluencies or non-native phrasing
+
+When the methodology produces its artifact, add pipeline provenance to
+frontmatter:
+
+```yaml
+pipeline: PWS_grading
+pipeline_stage: 4
+pipeline_input: "Scored Ten-Questions read from stage 3"
+```
+
+## Output Contract
+
+Final stage -- no `output_to`. This completes the PWS Grading Pipeline.
+
+### What the Full PWS Grading Pipeline Produced
+
+Across all 4 stages, the scratch Room now contains:
+
+| Room Section | Artifact | From Stage |
+|-------------|----------|------------|
+| deep-grades | Calibrated grade at course tier | Stage 1 |
+| mullins | 7-Domains market/venture read | Stage 2 |
+| financial-model | Scored Ten-Questions thesis (non-gating) | Stage 3 |
+| argument | Minto Pyramid feedback (governing thought + 2-3 branches) | Stage 4 |
+
+The provenance chain (`pipeline: PWS_grading`, `pipeline_stage: 1/2/3/4`)
+connects all four artifacts, showing how a quote-anchored evidence JSON became
+packaged formative feedback through the navigator-locked native-order chain.

package/pipelines/PWS_grading/CHAIN.md

@@ -0,0 +1,79 @@
+---
+name: PWS_grading
+display_name: PWS Grading Pipeline
+description: Turn one pitch's evidence into formative feedback -- deep-grade, Mullins, scored thesis, Minto packaging
+stages: 4
+estimated_time: 8-12min
+venture_stages: [Validation]
+problem_types: [well-defined-complex, ill-defined-complex]
+hitl_stages:
+  - stage: "deep-grade"
+    shapes: ["F.8"]
+    mode: "ordered"
+  - stage: "mullins"
+    shapes: ["F.8"]
+    mode: "ordered"
+  - stage: "build-thesis"
+    shapes: ["F.9"]
+    mode: "ordered"
+  - stage: "structure-argument"
+    shapes: ["F.9"]
+    mode: "ordered"
+hitl_why: "Four ordered stages from a pitch's quote-anchored evidence to packaged formative feedback: deep-grade then mullins then build-thesis (scored, non-gating) then structure-argument, each stage feeding the next. Under the frozen course-tier rubric (references/methodology/rubric-huji.md) the chain runs score-and-continue, never halting on the build-thesis 6/10 gate."
+---
+
+# PWS Grading Pipeline
+
+## When to Use
+
+A student's pitch has been extracted into a quote-anchored evidence JSON and a
+populated scratch room (Stage A intake), and you need one written formative
+feedback artifact tiered to course depth, not investor depth. This is the HUJI
+pitch-feedback chain: the batch spawns `/mos:pipeline PWS_grading` once per
+submission, and each headless session runs this chain on the shared runChain
+spine.
+
+Typical starting point:
+- "I have a diarized pitch transcript extracted into evidence and need formative
+  feedback a student can act on before the next milestone."
+
+## Stage Sequence
+
+1. **deep-grade** -- Score the room against the calibrated project corpus at course tier
+2. **mullins** -- Run the 7-Domains market/venture read (BEFORE build-thesis)
+3. **build-thesis** -- Score all ten questions and CONTINUE (non-gating, never halts below 6/10)
+4. **structure-argument** -- Package the surviving points as a Minto Pyramid (governing thought first)
+
+The order is navigator-locked (15.7.2026) and MIRRORS the single ordering
+authority `NAMED_RECIPES.PWS_grading` in `lib/core/recipe-maps.cjs`. mullins runs
+BEFORE build-thesis; structure-argument is last as the Minto packaging step. This
+CHAIN.md is a mirror of the recipe-maps list, never a competing order.
+
+## Score-and-Continue Mode
+
+The build-thesis Ten-Questions gate ships as a prompt-level 6/10 "Binary gate."
+For a 200-person course that halt would abort the batch ("half the class fails
+question 2 and learns nothing"). Two layers neutralize it:
+
+- **Chain-level (code):** all four commands are `autonomous_safe: true`, so
+  runChain auto-runs each step and never reaches a material human gate under
+  `--permission-mode dontAsk`. `validateChainAutonomy` reports zero blockers.
+- **Prompt-level (natural language):** the frozen `${CLAUDE_PLUGIN_ROOT}/references/methodology/rubric-huji.md`,
+  appended via `--append-system-prompt-file`, instructs build-thesis to SCORE all
+  ten questions and CONTINUE unconditionally, emitting per-question scores as
+  feedback input. `${CLAUDE_PLUGIN_ROOT}/references/methodology/build-thesis-scored.md` is the
+  demo-verified fallback if the rubric override alone leaves a residual halt.
+
+## What It Produces
+
+After all 4 stages, the scratch Room will have:
+- **deep-grades:** calibrated grade artifact at course tier
+- **mullins:** 7-Domains read of the venture
+- **financial-model:** scored Ten-Questions thesis (non-gating; per-question scores as feedback)
+- **argument:** Minto Pyramid packaging the feedback (governing thought + 2-3 branches)
+
+## Chain Provenance
+
+Each artifact includes `pipeline: PWS_grading` and `pipeline_stage: N` in
+frontmatter, creating an inspectable provenance chain. This lets a later pass
+detect existing pipeline progress and audit which stage produced what.

package/pipelines/analogy/01-decompose.md

@@ -0,0 +1,80 @@
+---
+stage: 1
+methodology: reason
+chain: analogy
+input_from: null
+output_to: abstract
+room_section: problem-definition
+---
+
+# Stage 1: Decompose (SAPPhIRE Extraction)
+
+## Input Extraction
+
+First stage -- uses room artifacts across all sections. No prior pipeline artifact needed.
+
+Scan `room/STATE.md` for venture context: problem type, venture stage, filled sections. Then read key artifacts from the most populated sections (problem-definition, solution-design, market-analysis) to understand the venture's core challenge.
+
+If the user provided a specific problem or contradiction when starting the pipeline, use that as the focal point. Otherwise, identify the venture's primary challenge from room state.
+
+## Stage Instructions
+
+Run `/mos:reason` with the venture's core problem, framing the decomposition around SAPPhIRE layers.
+
+Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/sapphire-encoding.md` for the SAPPhIRE ontology reference.
+
+For each major room artifact, extract:
+
+### SAPPhIRE Triples
+
+| Layer | Question | Extract From |
+|-------|----------|-------------|
+| **State** | What is the current situation/condition? | problem-definition/ |
+| **Action** | What action does the system perform? | solution-design/ |
+| **Part** | What structural components exist? | team-execution/ |
+| **Phenomenon** | What observable behaviors/trends drive this? | market-analysis/ |
+| **Input** | What resources/inputs does the system consume? | business-model/ |
+| **Real effect** | What underlying principle/mechanism operates? | competitive-analysis/ |
+| **Effect** | What measurable outcome results? | financial-model/ |
+
+### Core Contradiction Identification
+
+Identify the venture's CORE CONTRADICTION -- the tension where improving one dimension worsens another:
+- "Increasing [X] degrades [Y]"
+- "We need [A] but [A] prevents [B]"
+- "Our strength in [domain] becomes a weakness when [condition]"
+
+Check existing KuzuDB `CONTRADICTS` edges if available:
+```
+Scan room/.lazygraph/ for existing contradiction edges
+```
+
+### Function-Behavior-Structure Encoding
+
+For the core problem, produce:
+- **Function:** What the system DOES (verb + object, domain-independent)
+- **Behavior:** HOW it achieves the function (mechanism)
+- **Structure:** WHAT components enable the behavior (parts and relationships)
+
+Larry should push the user past domain-specific language: "You say 'customer acquisition' -- but functionally, what are you doing? You're FILTERING a population by fit criteria and CONVERTING interest to commitment. Those are functions that exist everywhere."
+
+When the methodology produces its artifact, ensure pipeline provenance is added to frontmatter:
+
+```yaml
+pipeline: analogy
+pipeline_stage: 1
+sapphire_function: "[extracted function]"
+sapphire_behavior: "[extracted behavior]"
+sapphire_structure: "[extracted structure]"
+core_contradiction: "[improving X] vs [worsening Y]"
+```
+
+## Output Contract
+
+The following sections from the artifact feed into Stage 2 (abstract):
+
+- **SAPPhIRE triples** -- become the input for domain-independent encoding
+- **Core contradiction** -- becomes the target for TRIZ parameter mapping
+- **Function-behavior-structure** -- becomes the basis for cross-domain search queries
+
+Stage 2 will extract these by scanning `room/problem-definition/` for the most recent artifact with `pipeline: analogy` and `pipeline_stage: 1` in frontmatter.

package/pipelines/analogy/02-abstract.md

@@ -0,0 +1,87 @@
+---
+stage: 2
+methodology: reason
+chain: analogy
+input_from: decompose
+output_to: search
+room_section: problem-definition
+---
+
+# Stage 2: Abstract (Domain-Independent Encoding)
+
+## Input Extraction
+
+Extract from Stage 1 artifact (scan `room/problem-definition/` for most recent artifact with `pipeline: analogy` and `pipeline_stage: 1` in frontmatter):
+
+- **SAPPhIRE triples** -- the function-behavior-structure decomposition per room section
+- **Core contradiction** -- the improving-vs-worsening tension
+- **Function-behavior-structure** -- the domain-specific encoding to be abstracted
+
+Present to the user: "From the decomposition, I'm abstracting: [function] as the core function, with [contradiction] as the key tension to resolve."
+
+## Stage Instructions
+
+The goal is to strip ALL domain-specific language and produce a purely functional description that could apply to any field. This is what enables cross-domain search -- you cannot find analogies in biology if you keep using business terminology.
+
+### Step 1: Functional Verb Replacement
+
+Replace every domain-specific term with a standardized functional verb. Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/sapphire-encoding.md` for the functional verb vocabulary.
+
+Standard functional verbs: deliver, protect, transform, connect, filter, amplify, regulate, separate, convert, store, distribute, stabilize, absorb, channel, detect, signal, adapt, repair, recycle, generate.
+
+Examples:
+- "Customer acquisition funnel" becomes "filter population by fit criteria, convert interest to commitment"
+- "Tumor drug resistance" becomes "adaptive barrier blocks delivery system"
+- "Supply chain optimization" becomes "minimize transfer distance while maintaining flow capacity"
+- "Competitive moat" becomes "structural barrier that increases with usage"
+
+Larry should challenge domain-locked thinking aggressively: "You keep saying 'market penetration' -- but functionally, what is penetration? It's overcoming a barrier to reach a target. Where else do systems overcome barriers to reach targets? Everywhere -- cell membranes, firewalls, military logistics, root systems in soil."
+
+### Step 2: TRIZ Parameter Mapping
+
+Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/triz-principles.md` for the 39 TRIZ parameters and 40 inventive principles.
+
+Map the core contradiction to TRIZ parameter space:
+1. Identify which of the 39 parameters the venture is trying to IMPROVE
+2. Identify which of the 39 parameters WORSENS as a result
+3. Look up the TRIZ Contradiction Matrix intersection for suggested inventive principles
+
+Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/triz-matrix.json` for the contradiction matrix data.
+
+Format:
+```
+TRIZ Contradiction:
+  Improving: Parameter [N] - [name]
+  Worsening: Parameter [M] - [name]
+  Suggested Principles: [P1], [P2], [P3], [P4]
+  Principle descriptions: [from triz-principles.md]
+```
+
+### Step 3: Functional Keywords for Search
+
+Produce 5-10 domain-independent keywords that capture the venture's core functions. These become the search queries for Stage 3.
+
+Format: `[verb] + [abstract object]`
+Examples: "filter population", "overcome adaptive barrier", "amplify weak signal", "distribute through network", "regulate bidirectional flow"
+
+When the methodology produces its artifact, ensure pipeline provenance is added to frontmatter:
+
+```yaml
+pipeline: analogy
+pipeline_stage: 2
+abstract_function: "[domain-independent function description]"
+triz_improving: "[parameter number and name]"
+triz_worsening: "[parameter number and name]"
+triz_principles: [list of suggested principle numbers]
+functional_keywords: [list of 5-10 search keywords]
+```
+
+## Output Contract
+
+The following sections from the artifact feed into Stage 3 (search):
+
+- **Abstract function description** -- becomes the primary search query for cross-domain analogy retrieval
+- **TRIZ parameter mapping** -- guides search toward domains that resolved the same contradiction type
+- **Functional keywords** -- become specific search terms for AskNature, patents, and academic databases
+
+Stage 3 will extract these by scanning `room/problem-definition/` for the most recent artifact with `pipeline: analogy` and `pipeline_stage: 2` in frontmatter.