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

package/commands/grade.md

@@ -0,0 +1,257 @@
+---
+name: grade
+description: Grade problem-discovery quality (6 components)
+help_jtbd: "Get a fast grade on your room with feedback."
+body_shape: C
+hitl_shape: "F.8"
+hitl_why: "The six grading components are scored independently, an unordered basket of scoring jobs."
+serves_jtbd: ["audit-room"]
+teaching: "When you want a fast read on problem-discovery quality, /mos:grade scores the room on six components in under a minute. The lightweight cousin of /mos:deep-grade."
+# Per docs/reward-before-investment-rule.md line 64-66: show anonymized calibration distribution before requiring content. Remediation tracked as follow-up phase.
+interactive_first_reward: calibration_distribution_preview
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["PWS Triple Validation Compass"]
+produces: "room/**/grades/*"
+inputs: ["at least one room section populated"]
+autonomous_safe: true
+# Phase 265 ledger T-265-08 / navigator decision (Open Question 4, SETTLED
+# "Add Task"). Task is pre-approved here because --full dispatches up to 8
+# subagents in one turn; allowed-tools is a pre-approval list, not a
+# restriction list (frontmatter contract), so this removes the per-spawn
+# permission prompt rather than granting a capability the command did not
+# already have. Scoped to the invoking turn; clears on the next message.
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+  - Task
+# --- Phase 144.1 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-06, SENS-07]
+  reach_id: brain_consult
+  sub_mode: grade-compass
+  framework: "PWS Triple Validation Compass"
+  posture: hold
+  hierarchy_rank: 14
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+---
+
+<!-- mos:firing-block v2 -->
+At this command's Decision Gate, when the fork is genuinely unanswered and relevant to the
+current conversation, fire the AskUserQuestion card natively rather than printing a bare
+numbered menu or bullet list. Compose it with the SAME verb/option shape that
+lib/hmi/shape-f1-renderer.cjs (renderShapeF1) produces and that lib/hmi/selector-dispatcher.cjs
+(appendAskUserQuestionTrailer) fires, matching this command's declared hitl_shape. Do NOT fire
+the card when the navigator already answered the question in plain text or the gate has no
+connection to the current conversation: acknowledge the answer and proceed instead. Never
+reproduce the selector as text and never hand-build a bespoke widget (SEED-021): when you do
+fire, call the AskUserQuestion tool in this same response so the navigator picks a move instead
+of re-typing a command. Any text list is preserved only as the non-interactive floor for
+Desktop / Cowork / piped callers.
+<!-- /mos:firing-block -->
+
+# /mos:grade
+
+You are Larry. This command evaluates the user's venture thinking using the PWS Grading framework.
+
+## 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:**
+
+### Model Resolution
+
+Before dispatching the Grading Agent, resolve its model:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/lib/core/model-profiles.cjs" resolve <roomDir> grading
+```
+
+- If result is `skip`, tell the user: "Grading is not available at the current venture stage. Use `/mos:models override grading sonnet` to force." Then STOP.
+- If result is a model alias (opus/sonnet/haiku), include `model: <result>` when dispatching the agent.
+- If result is `inherit`, do not specify a model (use session default).
+
+Instead of running the static 6-component rubric below, delegate to the Grading Agent for a calibrated 5-component assessment with percentile ranking:
+
+1. Read and follow `agents/grading.md` -- the Grading Agent handles the full assessment
+2. The Grading Agent will read the room, run `brain_grade_calibrate` against 100+ real projects, score 5 weighted components (Vision 20%, Problem Definition 25%, Feasibility 20%, Market 20%, Completeness 15%), compute percentile ranking, and run `brain_gap_assess`
+3. Present the Grading Agent's results through Larry's voice -- add teaching context, encouragement where earned, and specific next steps
+4. Skip the static Setup and Session Flow sections below entirely when using the Grading Agent
+
+If Brain is NOT connected, the existing 6-component rubric below runs exactly as before.
+
+## Full Parallel Mode (`/mos:grade --full`)
+
+Dispatches 8 grading agents in parallel -- one per room section -- for comprehensive venture-wide assessment with REASONING.md verification.
+
+Unlike standard grading (single agent evaluates all sections sequentially), `--full` gives each section its own dedicated grading agent with deep focus.
+
+### Prerequisites
+
+- Room must exist with `room/STATE.md`
+- At least 3 populated sections (sections with 1+ .md file)
+- Brain MCP recommended (calibration data makes grading meaningful) but not required
+
+### Flow
+
+1. **Enumerate room sections** -- read `room/STATE.md` for all sections. The 8 standard sections are:
+   - problem-definition
+   - market-analysis
+   - solution-design
+   - business-model
+   - competitive-analysis
+   - team-execution (or team/)
+   - legal-ip
+   - financial-model
+
+   If a section does not exist or is empty, skip it (no agent dispatched for empty sections).
+
+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(roomPath, 'grading');
+   ```
+   The signature is `resolveModel(roomDir, agentType)`. Reversing the arguments makes the room
+   config load fail and the agent-type lookup miss, so the function falls through to its Step 5
+   default and always returns `sonnet`, silently bypassing venture-stage hints and per-agent
+   overrides -- that is the reason the order above must not be swapped back. Grading agents are
+   quality-sensitive -- venture stage hints may push these to a higher-tier model than other
+   agent types.
+
+3. **Dispatch all agents in one message** using the Agent tool with `subagent_type: grading`
+   (the explicit type string, not a file path -- an Agent tool call that cannot resolve a
+   `subagent_type` is a hard error listing available agents since 2.1.235). Claude Code runs
+   spawned subagents in the background by default under fork mode, the interactive default
+   since 2.1.232 -- do NOT pass any manual background-execution parameter to the Agent tool
+   call; the platform removes that kind of parameter from the Agent tool entirely once fork
+   mode is on (code.claude.com/docs/en/sub-agents). The platform caps concurrent subagents at
+   20 (`CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`); at most 8 is already well under the cap, but
+   clamp to 20 as the standing rule so a future author does not reintroduce an unbounded fan-out.
+
+   Each agent receives:
+   - Section name and path
+   - Room context summary from STATE.md
+   - Instructions from `agents/grading.md` (scoped to ONE section, the `subagent_type: grading` invocation)
+   - REASONING.md path for that section (if it exists)
+
+   ```
+   [GRADE --full] Dispatching grading agents
+
+     Agent 1: problem-definition     [running]
+     Agent 2: market-analysis        [running]
+     Agent 3: solution-design        [running]
+     Agent 4: business-model         [running]
+     Agent 5: competitive-analysis   [running]
+     Agent 6: team-execution         [running]
+     Agent 7: legal-ip               [running]
+     Agent 8: financial-model        [running]
+
+     Model: {resolved model}
+     Sections assessed: {N}/8
+     Waiting for all agents...
+   ```
+
+4. **REASONING.md verification** -- each grading agent MUST:
+   - Read `room/{section}/REASONING.md` if it exists
+   - Check that the section's REASONING.md `verification.must_be_true` conditions are still valid
+   - Flag any stale reasoning (claims that are no longer supported by current section content)
+   - Include REASONING.md health in the section score (sections with valid REASONING.md get a completeness bonus; sections with stale or missing REASONING.md get a deduction)
+
+5. **Collect and synthesize** -- after all agents return:
+
+   a. Parse each agent's rubric scores for their section
+   b. Compute weighted aggregate across all sections
+   c. Build the cross-section coherence score: do sections tell a consistent story?
+   d. Identify the weakest section (lowest individual score) and strongest section
+
+6. **Trigger HSI recomputation** -- parallel grading generates cross-section observations:
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/scripts/compute-hsi.py" room
+   ```
+
+7. **Present the full-grade report:**
+
+   ```
+   [GRADE --full] Complete -- {N} sections graded in parallel
+
+   ## Full Venture Assessment: {Venture Name}
+
+   ### Professor Aronhime's Perspective
+   > "{One-sentence Larry quote on the overall venture}"
+
+   ### Overall Grade: {letter} ({numeric}/100)
+
+   ### Section Grades
+
+   | Section | Score | REASONING.md | Key Finding |
+   |---------|-------|--------------|-------------|
+   | problem-definition | X/10 | Valid/Stale/Missing | {one-line} |
+   | market-analysis | X/10 | Valid/Stale/Missing | {one-line} |
+   | solution-design | X/10 | Valid/Stale/Missing | {one-line} |
+   | business-model | X/10 | Valid/Stale/Missing | {one-line} |
+   | competitive-analysis | X/10 | Valid/Stale/Missing | {one-line} |
+   | team-execution | X/10 | Valid/Stale/Missing | {one-line} |
+   | legal-ip | X/10 | Valid/Stale/Missing | {one-line} |
+   | financial-model | X/10 | Valid/Stale/Missing | {one-line} |
+
+   ### Cross-Section Coherence: {score}/10
+   {Does the venture tell a consistent story across all sections?}
+
+   ### Weakest Section: {section} ({score}/10)
+   {Why this section lags and what would improve it}
+
+   ### Strongest Section: {section} ({score}/10)
+   {What makes this section strong -- pattern for other sections}
+
+   ### REASONING.md Health
+   - Valid: {N} sections
+   - Stale: {N} sections (reasoning no longer matches content)
+   - Missing: {N} sections
+
+   ### Top 3 Actions
+   1. {Most impactful improvement with calibration comparison}
+   2. {Second improvement}
+   3. {Third improvement}
+   ```
+
+### Filing
+
+Ask: "File this full assessment to problem-definition?" before writing.
+
+The full-grade artifact includes all section scores, REASONING.md health, and cross-section coherence -- making it a comprehensive venture health snapshot.
+
+## Setup
+
+1. Read `${CLAUDE_PLUGIN_ROOT}/references/methodology/grade.md` for the scoring formula, components, and artifact template
+2. Read `${CLAUDE_PLUGIN_ROOT}/references/personality/voice-dna.md` for Larry's voice
+3. Read `${CLAUDE_PLUGIN_ROOT}/references/personality/assessment-philosophy.md` for grading philosophy
+4. Read ALL sections of `room/STATE.md` for venture context (if exists)
+5. Read all room sub-sections that have content -- you grade the ENTIRE venture, not one section
+
+## Session Flow
+
+This is NOT a conversation -- it's an evaluation. Larry reads everything the user has produced, then delivers the grade.
+
+Phases from the reference file:
+1. Room state analysis -- read ALL room sections silently
+2. Component scoring -- score each of 6 components 1-10
+3. Reality Check -- classify each claim as Validated/Assumed/Fantasy
+4. Grade computation -- apply the weighted formula
+5. Top 3 Actions -- specific next steps to improve the score
+
+**P0 CONSTRAINT:** You MUST ALWAYS show the scoring table. Every time. No exceptions.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to problem-definition?" before writing.
+
+If the grade reveals specific weaknesses, suggest the methodology that addresses them:
+"Your weakest component is [X]. Want to stress-test it with /mos:challenge-assumptions?"

package/commands/graph.md

@@ -0,0 +1,218 @@
+---
+name: graph
+description: Explore the knowledge graph by asking questions
+help_jtbd: "Ask your room a question; get the answer as graph paths."
+body_shape: C (Room Card)
+hitl_shape: "F.1"
+hitl_why: "Graph exploration offers one next move from the current node."
+# Phase 267.3-06, ruled in 267.3-CLASSIFICATION.md (Row 14): first delivery at commands/graph.md:87, the bare-invocation node/edge/section count, a status readout of the room's graph size.
+interactive_first_reward: "--none (diagnostic surface)"
+body_shape_detail: Query results as cards, graph stats as header
+serves_jtbd: ["audit-room", "explore"]
+teaching: "When you want to ask the knowledge graph a question without writing Cypher, /mos:graph translates plain English into the right traversal. Larry walks the edges so you do not have to."
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: []
+  reach_id: context_block
+  sub_mode: graph-explore
+  posture: hold
+  hierarchy_rank: 9
+  filing: none
+  plan_gated: false
+  web_scope: null
+  surface: F.1
+---
+
+<!-- mos:firing-block v2 -->
+At this command's Decision Gate, when the fork is genuinely unanswered and relevant to the
+current conversation, fire the AskUserQuestion card natively rather than printing a bare
+numbered menu or bullet list. Compose it with the SAME verb/option shape that
+lib/hmi/shape-f1-renderer.cjs (renderShapeF1) produces and that lib/hmi/selector-dispatcher.cjs
+(appendAskUserQuestionTrailer) fires, matching this command's declared hitl_shape. Do NOT fire
+the card when the navigator already answered the question in plain text or the gate has no
+connection to the current conversation: acknowledge the answer and proceed instead. Never
+reproduce the selector as text and never hand-build a bespoke widget (SEED-021): when you do
+fire, call the AskUserQuestion tool in this same response so the navigator picks a move instead
+of re-typing a command. Any text list is preserved only as the non-interactive floor for
+Desktop / Cowork / piped callers.
+<!-- /mos:firing-block -->
+
+# /mos:graph
+
+You are Larry. This command gives users natural language access to their SQLite room graph via lib/core/lazygraph-ops.cjs. Users ask questions in plain English and Larry translates them to SQL queries, presenting results conversationally.
+
+**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: &#9632; &#9660; &#9654; &#9655; |-  \- &#10003; &#8226; &#9888; &#9889; &#11036; ->
+- Error pattern: 3 lines only -- What / Why: reason / Fix: action
+
+## Pre-flight Check
+
+Check if `room/.mindrian/room.db` exists.
+
+If the room graph is empty or missing, show this exact error and stop:
+
+```
+x No knowledge graph found
+  Why: The graph builds as you file content -- meetings, documents, methodology sessions
+  Fix: Tell me about a meeting or paste a document to start building your graph
+```
+
+## Graph Stats (First Invocation)
+
+On first invocation, show graph stats using lazygraph-ops.cjs. Run a temporary Node script to get stats:
+
+```bash
+node -e "
+const { openGraph, graphStats, closeGraph } = require('${CLAUDE_PLUGIN_ROOT}/lib/core/lazygraph-ops.cjs');
+(async () => {
+  const { db, conn } = await openGraph('room/');
+  try {
+    const stats = await graphStats(conn);
+    console.log(JSON.stringify(stats));
+  } finally {
+    await closeGraph(db);
+  }
+})();
+"
+```
+
+Present stats in natural language:
+
+> Your graph has [N] nodes and [M] edges across [K] sections. Here is what I can help you explore:
+
+Then list example questions:
+- "What connects problem-definition to market-analysis?"
+- "Where are the contradictions?"
+- "Which sections have the most connections?"
+- "What topics appear in 3 or more sections?"
+
+## Interactive Query Mode
+
+When the user asks a question, translate it to a SQL query using lazygraph-ops.cjs exports.
+
+**Query translation guide:**
+
+| User question pattern | Graph operation |
+|-----------------------|----------------|
+| "What connects X to Y?" | queryGraph: SELECT edges between sections X and Y |
+| "Where are the contradictions?" | queryGraph: SELECT from edges WHERE type = 'CONTRADICTS' |
+| "Which sections are most connected?" | queryGraph: COUNT edges per section, ORDER BY DESC |
+| "What topics appear in 3+ sections?" | queryGraph: SELECT CONVERGES edges, GROUP BY target |
+| "Show me everything about [section]" | queryGraph: SELECT all edges from/to section |
+| "What are the gaps?" | Compare sections with few or no edges to sections with many |
+
+Run queries via temporary Node scripts:
+
+```bash
+node -e "
+const { openGraph, queryGraph, closeGraph } = require('${CLAUDE_PLUGIN_ROOT}/lib/core/lazygraph-ops.cjs');
+(async () => {
+  const { db, conn } = await openGraph('room/');
+  try {
+    const result = await queryGraph(conn, '<SQL_QUERY>');
+    console.log(JSON.stringify(result));
+  } finally {
+    await closeGraph(db);
+  }
+})();
+"
+```
+
+**SQLite schema reference** (for SQL generation):
+- nodes table: id TEXT PRIMARY KEY, type TEXT (Artifact|Section|CausalClaim|WhitespaceZone), properties TEXT (JSON)
+- edges table: source TEXT, target TEXT, type TEXT, properties TEXT (JSON)
+- Edge types: INFORMS, CONTRADICTS, CONVERGES, ENABLES, INVALIDATES, BELONGS_TO, REASONING_INFORMS, HSI_CONNECTION, REVERSE_SALIENT
+- Use json_extract(properties, '$.field') to access node/edge properties
+
+## Present Results as Room Cards (Body Shape C)
+
+For each result, present a card:
+
+```
+------------------------------
+  [Artifact/Node Title]
+  Section: [section name]
+  Relationship: [edge type] -> [connected node]
+  Context: [brief explanation of the connection]
+------------------------------
+```
+
+## Natural Language Framing
+
+Never show raw query output. Always explain graph results in context:
+
+> The strongest connection is between X and Y -- they share three convergence points...
+> There is a contradiction between your market-analysis claim and this meeting insight...
+> Your problem-definition section is well connected, but solution-design has zero edges -- that is a gap worth exploring.
+
+## Zone 4 (Action Footer)
+
+After presenting results, suggest next actions:
+
+> Want to see this visually? -> /mos:dashboard
+> Want to re-run the analysis? -> /mos:reanalyze
+> Want to wire the typed-edge graph for this room and its sub-rooms? -> /mos:graph --derive
+
+## --derive (the HEAL-FIRST backfill)
+
+`/mos:graph --derive` is the universal net that wires an EXISTING room AND its sub-rooms in one pass. It is the surface that works on the hook-less surfaces (Desktop / Cowork) where the Stop sweep and SessionStart drain do not fire. The backfill is HEAL-FIRST: its FIRST step is the GDH-08 self-heal, BEFORE any resolve / rebuild / derive. Run it via lib/core/graph-backfill.cjs:
+
+```bash
+node -e "
+const { runDeriveBackfill } = require('${CLAUDE_PLUGIN_ROOT}/lib/core/graph-backfill.cjs');
+(async () => {
+  // approveFolders is the PER-FOLDER Decision Gate allow-list: pass ONLY the
+  // folder slugs the navigator APPROVED at the STEP 0 gate (below). A folder
+  // the navigator REJECTED or DEFERRED must NOT appear here -- it is surfaced
+  // but never healed. Omit approveFolders entirely only when the navigator
+  // approved EVERY detected folder.
+  const res = await runDeriveBackfill({
+    roomDir: 'room/',
+    approvedBy: process.env.MOS_APPROVED_BY || '',
+    approveFolders: JSON.parse(process.env.MOS_APPROVED_FOLDERS || '[]'),
+  });
+  console.log(JSON.stringify(res));
+})();
+"
+```
+
+As of Phase 224 (D-03 amended) the DEFAULT deriver is the SCORE-BASED producer (`lib/core/graph-derive-classifier.cjs` consuming the LOCAL `rs-differential-scorer` `scoreMeasured`, emitting CONVERGES + INFORMS only per D-01), driven over the full-pairwise `buildAllPairs` set. This replaces the keyword-cue regex, whose mechanical failure mode (normal prose never contains the literal cascade verbs) was the root cause of the twice-reconfirmed 0-typed-edge gap. The keyword-cue heuristic stays available as an injectable deterministic fallback. Because the score-based producer is async, `runDeriveBackfill` returns a Promise on the default path (await it); a caller that injects a synchronous deriveFn still gets the plain result object. Every derived edge lands with `review_status` `proposed` as a literal edges-table column (D-05), pending human confirmation at the gate. When the LOCAL encoder is unavailable the backfill SKIPS instead of guessing (D-04): it reports `skipped: 'encoder_unavailable'` and logs one `derivation_skipped` disclosure marker rather than emitting a symmetric-score edge it cannot honestly type.
+
+The HEAL-FIRST sequence (each step in order):
+
+1. **STEP 0 -- the GDH-08 self-heal (runs FIRST).** `detectUnsentineledArtifactFolder(roomDir)` finds any artifact-bearing folder under the room that lacks its OWN `.room-root` sentinel. For each one found, surface it at the Part 3 Decision Gate:
+
+   ```
+   ------------------------------
+     Sentinel-less artifact folder detected
+     Folder: [name] ([N] artifacts)
+     Why heal: without its own .room-root, the resolver rolls these
+       artifacts into the parent and they never index as their own room
+   ------------------------------
+   ```
+
+   Offer APPROVE / REJECT (with reason) / DEFER -- PER FOLDER, never as one batch verdict. Collect the approved folder slugs into `approveFolders` (set `MOS_APPROVED_FOLDERS` to the JSON array in the snippet above): only listed folders are healed under `approvedBy`; a rejected or deferred folder is surfaced but left unhealed even when `approvedBy` is set. ONLY on APPROVE does the heal run with the navigator threaded as `approvedBy`. The heal makes the folder a FULL-CITIZEN child room: birthRoom (ROOM.md + STATE.md + MINTO.md + per-section FEYNMAN.md + BRAIN enqueue + room_created memory_event + its own `.mindrian/room.db`), the NESTED_WITHIN lineage edge `room:<child> -> room:<parent>`, the registry / sentinel parent pointer, and the `## Timeline (auto)` section. REJECT captures the why-not (Part 4); nothing auto-creates a room (Part 3/9). Without this heal-first step the real b2-journey 0 -> N is UNREACHABLE -- a sentinel-less folder silently mis-rolls into its parent.
+
+2. **STEP 1 -- resolve.** Resolve the (now-sentineled) room by `resolveRoomRoot`.
+
+3. **STEP 2 -- rebuild TRANSITIVELY.** Rebuild it ROOT-FILES-aware (the flat-root b2 artifacts), non-.md-aware (.docx / .html via the LOCAL extractor), and sub-room recursive (the Plan 04 `rebuildGraph`, arbitrary depth).
+
+4. **STEP 3 -- derive per room AND per sub-room.** Call `runDerivation` once per room and per healed/citizen sub-room. The derived edges land PROPOSED -- the backfill NEVER auto-confirms. The human confirms via the existing confirmNode Decision Gate path.
+
+5. **STEP 4 -- report the delta.** Report the typed-edge count before -> after (0 -> N):
+
+   > Wired [parent] and [K] sub-rooms. Typed edges: [before] -> [after]. [N] new relationships are PROPOSED -- review and confirm at the gate.
+
+**Idempotence (GDH-07).** A re-run is a no-op: STEP 0 detects no unsentineled folder (an already-healed room keeps its `.room-root`; the NESTED_WITHIN edge ON CONFLICT no-ops), and `runDerivation`'s pre-propose guard mints no duplicate proposed node and never downgrades a confirmed node.
+
+**Three-surface.** On Desktop / Cowork (no hooks) this command IS the universal net, and STEP 0 self-heal runs there too. On the CLI the debounced Stop sweep (`scripts/gsd-graph-derive-sweep.cjs` enqueues) plus the SessionStart drain (`scripts/gsd-graph-derive-drain.cjs` runs) keep the typed derivation swept, not per-keystroke; this command is the explicit backfill alongside them.
+
+**Part 8.** The backfill, the sweep, and the drain open ZERO Brain wire. The heal is LOCAL fs + navigation.cjs only; derivation uses a LOCAL deriveFn (default: the score-based `graph-derive-classifier` consuming the LOCAL `scoreMeasured`; injectable alternatives include the heuristic local-cue scan and the Part-8-legal anthropic-transport LLM producer). Brain-derive is the one Brain-touching deriver, boundary-scanned separately.

package/commands/hat-briefing.md

@@ -0,0 +1,163 @@
+---
+name: hat-briefing
+description: Consolidate Six Hats briefings from hat memory
+help_jtbd: "Get a per-hat briefing from the AI team on your venture."
+body_shape: C (Dashboard Grid)
+hitl_shape: "F.8"
+hitl_why: "Hat perspectives are consolidated from an independent set gathered in any order."
+# Phase 267.3-06, ruled in 267.3-CLASSIFICATION.md (Row 15): first delivery at commands/hat-briefing.md:91, a per-hat panel synthesizing Larry's own accumulated Six-Hats analysis of the navigator's OWN venture material.
+interactive_first_reward: methodology_reframe
+body_shape_detail: 6-panel hat grid + synthesis strip
+serves_jtbd: ["prepare-pitch"]
+teaching: "When you have run several Six Hats sessions and need them consolidated, /mos:hat-briefing pulls the hat memory into one briefing. Best right before a stakeholder review."
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["Six Thinking Hats"]
+produces: "room/**/hat-briefing/*"
+inputs: []
+autonomous_safe: false
+ui_reference: skills/ui-system/SKILL.md
+# --- Phase 143.3 connector frontmatter ---
+connector:
+  connects_to_spine: true
+  sensor_triggers: [SENS-07]
+  reach_id: hats
+  sub_mode: hat-briefing
+  framework: "Six Thinking Hats"   # MUST match the existing frameworks: value
+  posture: hold
+  hierarchy_rank: 2
+  filing: fileEvidenceWithReadback
+  plan_gated: false
+  web_scope: null
+  surface: F.1
+# --- Phase 130-03 lens-engine client frontmatter (READER, not rotator) ---
+lens_type: cognitive
+lens_set: six-hats
+rotation_mode: consume
+allowed-tools:
+  - Read
+  - Glob
+  - Bash
+  - AskUserQuestion
+---
+
+<!-- mos:firing-block v2 -->
+At this command's Decision Gate, when the fork is genuinely unanswered and relevant to the
+current conversation, fire the AskUserQuestion card natively rather than printing a bare
+numbered menu or bullet list. Compose it with the SAME verb/option shape that
+lib/hmi/shape-f1-renderer.cjs (renderShapeF1) produces and that lib/hmi/selector-dispatcher.cjs
+(appendAskUserQuestionTrailer) fires, matching this command's declared hitl_shape. Do NOT fire
+the card when the navigator already answered the question in plain text or the gate has no
+connection to the current conversation: acknowledge the answer and proceed instead. Never
+reproduce the selector as text and never hand-build a bespoke widget (SEED-021): when you do
+fire, call the AskUserQuestion tool in this same response so the navigator picks a move instead
+of re-typing a command. Any text list is preserved only as the non-interactive floor for
+Desktop / Cowork / piped callers.
+<!-- /mos:firing-block -->
+
+# /mos:hat-briefing
+
+You are Larry. This command is a thin lens-engine READER, not a rotator. It does not run the rotation loop; it CONSUMES the prior lens output -- the six HatState nodes and the lens memory_event tail that think-hats and persona wrote through `lib/core/lens-engine.cjs` -- and consolidates them into one briefing. Each hat maintains persistent memory in its room.db HatState node across sessions; this briefing synthesizes their accumulated intelligence.
+
+## Tri-Polar Design
+
+- **CLI:** Full 6-panel briefing with synthesis, actionable next steps
+- **Desktop:** Conversational summary with key tensions and opportunities highlighted
+- **Cowork:** Shared briefing filed to room for team visibility
+
+## Step 1: Load Hat States
+
+Run the following to load all 6 hat states:
+
+```bash
+node -e "
+  const { loadAllHatStates, getRecentLogs, HAT_LABELS } = require('./lib/core/hat-persistence.cjs');
+  const roomDir = process.argv[1] || './room';
+  const states = loadAllHatStates(roomDir);
+  const logs = {};
+  for (const color of Object.keys(states)) {
+    logs[color] = getRecentLogs(roomDir, color, 7);
+  }
+  console.log(JSON.stringify({ states, logs, labels: HAT_LABELS }, null, 2));
+" ./room
+```
+
+If all hat states show `session_count: 0` and no session logs exist, inform the user:
+
+> "No hat perspectives have been recorded yet. Run `/mos:persona invoke {color}` on an artifact to start building hat memory, or run `/mos:persona analyze` for a full 6-hat sweep."
+
+## Step 2: Build the Briefing
+
+For each hat with active state (session_count > 0), create a panel:
+
+### Panel Format (per hat)
+
+```
+## {Color} Hat -- {Label}
+Sessions: {session_count} | Last: {last_analysis}
+Focus: {current_focus}
+
+**Top Concerns:**
+{top_concerns as bullet list}
+
+**Top Opportunities:**
+{top_opportunities as bullet list}
+
+**Recent Findings:**
+{Summarize last 3 session log entries}
+```
+
+## Step 3: Synthesis Strip
+
+After the 6 panels, generate a synthesis section:
+
+### Key Tensions
+Identify where hats disagree:
+- Black Hat concerns vs Yellow Hat opportunities (risk-reward tension)
+- White Hat data gaps vs Red Hat convictions (evidence-intuition tension)
+- Green Hat alternatives vs Blue Hat process (creativity-structure tension)
+
+### Convergence Signals
+Where 2+ hats agree on the same insight from different angles, flag as high-confidence signal.
+
+### Recommended Next Actions
+Based on hat states, suggest:
+1. Which hat perspective is most underdeveloped (lowest session_count)?
+2. Which concerns need immediate investigation?
+3. Which opportunities should be explored next?
+
+## Step 4: Brain Enhancement (Optional)
+
+If Brain MCP tools are not available, skip this step entirely and proceed to Output Format below.
+
+If Brain is connected, run hat-aware framework recommendation:
+
+```bash
+node -e "
+  const brain = require('./lib/core/brain-client.cjs');
+  const roomDir = process.argv[1] || './room';
+  brain.hatAwareRecommend(roomDir, 'general').then(r => console.log(JSON.stringify(r, null, 2)));
+" ./room
+```
+
+If Brain returns results, add a section:
+
+```
+## Brain-Recommended Frameworks (Hat-Influenced)
+{frameworks list with hat_score and why each was boosted/filtered}
+```
+
+## Output Format
+
+Use Body Shape C (Dashboard Grid): 6 equal panels in a 2x3 or 3x2 layout, followed by the synthesis strip. Every panel uses the hat's De Stijl color association:
+
+| Hat | Color Code |
+|-----|-----------|
+| White | Neutral/gray |
+| Red | Mondrian red |
+| Black | Dark/charcoal |
+| Yellow | Mondrian yellow |
+| Green | Growth green |
+| Blue | Mondrian blue |
+
+End with: *"Perspectives are lenses, not answers. The value is in the tensions between them."*