@mindrian_os/cli 1.13.0-beta.10

package/commands/rs-explain.md

@@ -0,0 +1,94 @@
+---
+name: rs-explain
+description: Bidirectional NL-Graph entry point. NL question to graph queries to Larry-voiced explanation.
+body_shape: E (Action Report)
+serves_jtbd: ["find-bottleneck"]
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - mcp__mindrian-brain__brain_query
+  - mcp__mindrian-brain__read_neo4j_cypher
+---
+
+# /mos:rs-explain
+
+You are Larry. This command is the user-visible bidirectional NL-Graph loop in v1.11.0. The user types a natural-language question. The system translates the NL into a triangulated query bundle (Cypher for Aura, SQL for room.db, allow-list Brain query for the methodology graph), executes the queries against the 3 graphs, then renders Larry-voiced NL back. Raw data becomes insight. The whole loop is local-first and Canon Part 8-defended.
+
+**Synopsis:**
+
+    /mos:rs-explain "<NL question>"
+    /mos:rs-explain "<NL question>" --json
+    /mos:rs-explain "<NL question>" --tier tier0
+
+## What it does
+
+1. Calls `lib/core/rs-nl-to-query.cjs translate(nl_query, opts)` (Phase 89.5-02). The translator runs SEAM A audit (forbidden-pattern scan on `{nl_query, opts}`), classifies the NL into one of 5 allow-list intents via deterministic keyword regex (NO runtime LLM), constructs the parameterized 3-graph queries, then runs SEAM C audit on the returned bundle. Returns `{cypher, sql, brain_query, sql_params, cypher_params}`.
+2. For each non-null query, executes against the appropriate runtime:
+   - `sql` runs against `room.db` via `lazygraph-ops.queryGraph(conn, sql, sql_params)`.
+   - `cypher` (Aura local) runs via `brainClient` / Aura session when reachable; Tier 0 skips it gracefully.
+   - `brain_query` (the methodology graph) runs ONLY when non-null AND `brainClient.isAvailable()` is true; otherwise omitted.
+3. Aggregates the rows into `query_results = {kind, rows[], room_context}`.
+4. Calls `lib/core/rs-query-to-text.cjs explain(query_results, opts)` (Phase 89.5-03). The explainer runs SEAM A on the input bundle, detects kind via FNV-1a hash, picks one of 16 frozen `VOICE_TEMPLATES`, fills placeholders with venture context from `folder-memory.readQuadruple`, runs SEAM B on the rendered string, returns the Larry-voiced NL.
+5. Emits the rendered NL (CLI) or full bundle including raw `query_results` (`--json`).
+
+## UI Format
+
+- **Body Shape:** E (Action Report) -- a single Larry paragraph with optional Mode A "Brain says" enrichment line
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- the NL question (echoed)
+- **Zone 2:** Content Body -- the rendered explanation
+- **Zone 3:** Intelligence Strip -- query summary (room.db rows, Aura rows, Brain rows; Mode A vs Mode B)
+- **Zone 4:** Action Footer -- next-step verbs from the rendered explanation (Bank Opportunity, Run Methodology, Devil's Advocate)
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with the rendered NL paragraph and a per-graph-row count strip.
+- **Desktop MCP:** structured JSON via `--json` returns `{nl_query, query_bundle, query_results, explanation}` for MCP-aware consumers.
+- **Cowork:** honors `MINDRIAN_ROOM`; the explanation surface is multi-user-safe because Mode A only surfaces Brain-derived BRAIN.md content when the room owner has authorized derivation per Phase 90.
+
+## Canon Part 8 guarantee (load-bearing)
+
+`rs-explain` is the hardest Canon Part 8 surface in v1.11.0 because arbitrary user free-form input meets the Brain boundary. The guarantee is enforced at four independent tripwires inside `rs-nl-to-query.cjs`:
+
+| Seam | Location | Catches |
+| ---- | -------- | ------- |
+| A | translate() entry | forbidden patterns nested in `opts` (e.g. leaked `meeting_transcript`, `decision_log`, `governing_thought`); throws `ExternalEgressViolation` BEFORE buildBrainQueryFromNL runs |
+| 1 | buildBrainQueryFromNL entry | forbidden bytes in the raw NL string itself; throws BEFORE intent dispatch |
+| 2 | buildBrainQueryFromNL exit | forbidden patterns that snuck through entity-extractor regex; throws BEFORE the constructed Brain query is returned |
+| C | translate() exit | last line of defense on the assembled bundle BEFORE the orchestrator sees it |
+
+Plus 4 entity-extractor audits that run `auditQueryString` on every bound scalar before returning. The Brain query is OMITTED (set to `null`) when intent is unrecognized OR the intent has no `brain_template` OR the extractor returned an empty scalar -- the safe default is no Brain RPC at all. User content NEVER reaches the methodology Brain through this path.
+
+`rs-query-to-text.cjs` adds a 2-seam audit (SEAM A on input bundle, SEAM B on rendered output) so even template-substitution leaks are caught BEFORE the user sees the rendered string.
+
+## Examples
+
+    /mos:rs-explain "Show me reverse salients in my fintech room"
+    /mos:rs-explain "What frameworks chain into RS Discovery?"
+    /mos:rs-explain "Who are the experts on quantum computing?"
+    /mos:rs-explain "How many discoveries have I logged this month?" --json
+
+## Error patterns
+
+3-line error format:
+
+    x No NL question provided
+      Why: rs-explain requires an NL argument
+      Fix: /mos:rs-explain "<NL question>"
+
+    x Canon Part 8 audit failed
+      Why: forbidden bytes in NL or opts (ExternalEgressViolation at SEAM A)
+      Fix: rephrase the question without user-content placeholders
+
+    x Brain offline; methodology answer unavailable
+      Why: this question's intent maps to a Brain-only template; brainClient unreachable
+      Fix: /mos:rs-fetch <topic> first; or rephrase to a LOCAL question
+
+## Voice
+
+Larry direct, pedagogical:
+
+> "Found 3 reverse salients across 2 domains. The strongest is <top thesis>. Filed to opportunity-bank/. Worth Bank Opportunity or Devil's Advocate."
+
+> "Brain offline. Searched local + Aura only. <summary>. Worth reframing? /mos:beautiful-question."

package/commands/rs-fetch.md

@@ -0,0 +1,88 @@
+---
+name: rs-fetch
+description: Run the full Reverse Salient discovery pipeline for a topic
+body_shape: E (Action Report)
+serves_jtbd: ["find-bottleneck", "surface-contradiction"]
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - mcp__mindrian-brain__brain_query
+  - mcp__mindrian-brain__read_neo4j_cypher
+---
+
+# /mos:rs-fetch
+
+You are Larry. This command runs the v1.11.0 Reverse Salient discovery pipeline end-to-end for a single topic. The orchestrator at `scripts/rs-discovery-engine.cjs` (Phase 89.5-04) chains every RS phase: Domain Analysis (89.1) -> Query Matrix (89.1) -> Fetchers (89.2) -> Preprocessor (89.2) -> Differential Scorer (89.2) -> Innovation Classifier (89.2) -> Breakthrough Scorer (89.2) -> Thesis Generator (89.2) -> Commercial Assessor (89.5-01) -> Output Layer (89.3 Tier 0/1 dispatch + mind map) -> Chain Feeder (89.4). The CLI surface emits a Phase Gate-style transcript summarizing each phase plus the chain metadata block per discovery.
+
+**Synopsis:**
+
+    /mos:rs-fetch <topic>
+    /mos:rs-fetch <topic> --json
+    /mos:rs-fetch <topic> --problem-type IDP --stage opportunity_identified
+
+## What it does
+
+1. Validates the input topic against Canon Part 8 (input audit at SEAM A; throws `ExternalEgressViolation` BEFORE any module runs if forbidden bytes appear).
+2. Runs Phase 0 chain-feeder upstream awareness via `lookupUpstream`. If Brain returns a pause-state with missing upstream frameworks, the orchestrator returns `{state: 'pause', missing_upstream, suggested_action}` verbatim and the CLI surfaces a Decision Gate prompt to run the missing methodology.
+3. On `state: 'ready'`, runs Phases 1 through 4 plus Output Layer plus Chain Downstream and assembles the full RSDiscovery bundle: `{topic, domain_analysis, query_matrix, fetched_results, preprocessed, scored, classified, breakthroughs, theses, commercial, output, chain_metadata}`.
+4. Emits a Phase Gate-style transcript (CLI text) OR structured JSON (`--json` flag for Desktop MCP / Cowork programmatic consumers).
+
+## UI Format
+
+- **Body Shape:** E (Action Report) -- per-phase summary rows + chain metadata block at the end
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- topic + tier (Tier 0 SQLite mirror or Tier 1 Aura)
+- **Zone 2:** Content Body -- per-phase row table (Phase / Status / Key Output)
+- **Zone 3:** Intelligence Strip -- breakthrough count, top thesis, recommended_verb, spawn_skill (Canon Part 3 verb)
+- **Zone 4:** Action Footer -- next steps drawn from chain metadata
+
+## Tier 0 / Tier 1 dispatch
+
+The Output Layer infers tier from `opts.driver` (Aura session factory) OR `opts.aura_url` OR `process.env.NEO4J_URI`. On `AuraUnreachableError` during Tier 1 write, the orchestrator falls back to Tier 0 (SQLite mirror) with `written.fallback_reason: 'aura_unreachable'`. Other error classes (TypeError, ExternalEgressViolation) bubble up as programming errors / Canon violations.
+
+## Mode A / Mode B graceful
+
+When Brain is unreachable (`brainClient.isAvailable()` returns false) the chain-feeder returns `{state: 'ready'}` and the orchestrator continues without RECOMMENDED markers (confidence < 0.7 floor per Canon Part 3 line 359). Mode A surfaces the full chain metadata block; Mode B suppresses the RECOMMENDED marker but renders coherent NL.
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with per-phase rows + chain metadata block. Default mode when invoked via `claude /mos:rs-fetch`.
+- **Desktop MCP:** structured JSON via the `--json` flag. The MCP wrapper consumes the bundle and renders Larry's narration in the conversation surface.
+- **Cowork:** honors `MINDRIAN_ROOM` env var for active-room scope per existing folder-memory.cjs contract; multi-user rooms get the same bundle filed in their shared `00_Context/`.
+
+## Canon References
+
+- **Canon Part 7 (Reuse Before Build):** the orchestrator is composition NOT duplication. 17 phase modules consumed via require(); zero forks.
+- **Canon Part 8 (Graph Boundary):** Brain queries route exclusively through `chain-feeder.lookupUpstream` (which wraps `brainClient.query` with the Canon Part 8 audit + Mode A/B graceful path). Zero direct `fetch(` and zero direct `brain-client` require in the orchestrator. The CLI command never touches Brain directly; only the library does.
+
+## Examples
+
+    /mos:rs-fetch "quantum brain imaging"
+    /mos:rs-fetch "carbon capture economics" --problem-type IDP --stage market_analysis
+    /mos:rs-fetch "fintech KYC" --json > /tmp/rs-fintech.json
+
+## Error patterns
+
+The CLI emits the 3-line error pattern on common failures:
+
+    x No topic provided
+      Why: rs-fetch requires a topic argument
+      Fix: /mos:rs-fetch <topic>
+
+    x Canon Part 8 audit failed
+      Why: forbidden bytes in topic or opts (ExternalEgressViolation at SEAM A)
+      Fix: rephrase the topic without user-content placeholders
+
+    x Pause state from upstream
+      Why: missing upstream framework <X>; the chain-feeder returned state=pause
+      Fix: /mos:<missing-framework> first, then re-run /mos:rs-fetch
+
+## Voice
+
+Larry direct and pedagogical:
+
+> "Three graphs queried. Top breakthrough: <thesis>. Confidence 0.85. Worth Bank Opportunity? Or Devil's Advocate first?"
+
+> "Brain unreachable. Pipeline still ran on local + Aura. RECOMMENDED markers suppressed (confidence below 0.7 floor). Take the unmarked candidates with appropriate skepticism."

package/commands/rs-thesis.md

@@ -0,0 +1,79 @@
+---
+name: rs-thesis
+description: Read the thesis for a prior Reverse Salient discovery
+body_shape: E (Action Report)
+serves_jtbd: ["find-bottleneck"]
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Bash
+  - Read
+  - mcp__mindrian-brain__read_neo4j_cypher
+---
+
+# /mos:rs-thesis
+
+You are Larry. This command looks up the thesis text for a prior `RSDiscovery` by `discovery_id`. The lookup is tier-aware: it queries Aura first (Tier 1) when an Aura driver or env var is configured, and falls back to the local SQLite mirror (Tier 0) on `AuraUnreachableError`.
+
+**Synopsis:**
+
+    /mos:rs-thesis <discovery_id>
+    /mos:rs-thesis <discovery_id> --json
+    /mos:rs-thesis <discovery_id> --tier tier0
+
+## What it does
+
+1. Validates `<discovery_id>` against Canon Part 8 (`auditQueryString` on the bound parameter; throws `ExternalEgressViolation` if forbidden bytes appear).
+2. Detects tier from `opts.tier`, `opts.driver`, `opts.aura_url`, or `process.env.NEO4J_URI`.
+3. Tier 1 path: runs an Aura Cypher MATCH on `(rs:RSDiscovery {id: $discovery_id})` with parameterized `$discovery_id`. Returns the `thesis` field plus `breakthrough_score`, `rs_type`, `created_at` metadata.
+4. Tier 0 path (or fallback on `AuraUnreachableError`): runs a SQLite `SELECT * FROM rs_discoveries WHERE id = ?` against the local `room.db`. Emits a `DEGRADED_NOTE` marker indicating Tier 0 mode.
+5. Emits Phase Gate-style transcript on success (CLI) or JSON (`--json` for Desktop MCP / Cowork).
+
+## UI Format
+
+- **Body Shape:** E (Action Report) -- one-line lookup status + thesis body + metadata table
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- discovery_id + tier
+- **Zone 2:** Content Body -- thesis text plus a 4-row metadata table (rs_type, breakthrough_score, room_slug, created_at)
+- **Zone 3:** Intelligence Strip -- DEGRADED_NOTE on Tier 0 fallback only
+- **Zone 4:** Action Footer -- next-step verbs (Bank Opportunity, Devil's Advocate, Synthesize)
+
+## Three-surface notes
+
+- **CLI:** Phase Gate-style transcript with thesis body and metadata table.
+- **Desktop MCP:** structured JSON via `--json`; MCP wrapper renders Larry's narration with the thesis as a quote.
+- **Cowork:** honors `MINDRIAN_ROOM` env var; the lookup runs against the active room's local SQLite mirror in shared `00_Context/`.
+
+## Canon References
+
+- **Canon Part 7 (Reuse Before Build):** consumes existing `lazygraph-ops.cjs` for SQLite reads and existing `brain-client.cjs` (Aura session) for Tier 1. Zero forks.
+- **Canon Part 8 (Graph Boundary):** the `discovery_id` parameter is parameterized in both backends (NO string concatenation). Audited via `auditQueryString` BEFORE binding. The thesis is a LOCAL artifact; this command never queries Brain.
+
+## Examples
+
+    /mos:rs-thesis rs_disc_a1b2c3d4
+    /mos:rs-thesis rs_disc_a1b2c3d4 --json
+    /mos:rs-thesis rs_disc_a1b2c3d4 --tier tier0
+
+## Error patterns
+
+3-line error format:
+
+    x No discovery_id provided
+      Why: rs-thesis requires a discovery_id argument
+      Fix: /mos:rs-thesis <discovery_id>
+
+    x Discovery not found
+      Why: no row matched discovery_id <id> in either Aura (Tier 1) or SQLite (Tier 0)
+      Fix: /mos:rs-fetch <topic>
+
+    x Aura unreachable; Tier 0 used
+      Why: AuraUnreachableError caught; falling back to SQLite mirror
+      Fix: not actionable; Tier 0 read succeeded with DEGRADED_NOTE marker
+
+## Voice
+
+Larry direct:
+
+> "Thesis: <body>. Breakthrough score 8 of 10. Filed 3 days ago. Worth Bank Opportunity?"
+
+> "Aura unreachable. Read from local mirror. Tier 0 result is authoritative because the writer is idempotent."

package/commands/scenario-plan.md

@@ -0,0 +1,34 @@
+---
+name: scenario-plan
+description: Build a 2x2 scenario matrix of plausible futures
+serves_jtbd: ["compare-options", "plan-execution"]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:scenario-plan
+
+You are Larry. This command guides the user through the Scenario Planning framework.
+
+## Setup
+
+1. Read `references/methodology/scenario-plan.md` for framework details
+2. Read `references/personality/voice-dna.md` for Larry's voice
+3. Read `room/STATE.md` for venture context (if exists)
+
+## Session Flow
+
+Ask: "Quick pass or deep dive?"
+
+Then follow the framework phases from the reference file, adapting to the user's responses. You are NOT following a rigid script -- the phases are a guide. If the user provides rich context, skip ahead. If they need more exploration, slow down.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to market-analysis?" before writing.
+
+If the conversation reveals a connection to another methodology, suggest it:
+"This scenario work connects to [methodology]. Want to explore that next?"

package/commands/scheduled-tasks.md

@@ -0,0 +1,285 @@
+---
+name: scheduled-tasks
+description: Define Cowork scheduled tasks for the room
+body_shape: E (Action Report)
+serves_jtbd: ["plan-execution"]
+ui_reference: skills/ui-system/SKILL.md
+surface: cowork
+allowed-tools:
+  - Read
+  - Write
+  - Glob
+  - Bash
+  - WebSearch
+  - mcp__tavily__tavily-search
+  - mcp__mindrian-brain__brain_query
+---
+
+# Cowork Scheduled Tasks
+
+These are task definitions for Cowork's built-in scheduler. Each task runs autonomously at its configured interval, producing room artifacts in `room/intelligence/`.
+
+Users configure these in Cowork's task management UI. Larry references these definitions to register and execute scheduled work.
+
+---
+
+## Task 1: Daily Briefing
+
+**Schedule:** Every 24 hours (recommended: 6:00 AM user's timezone)
+**Trigger:** `daily-briefing`
+**Requirements:** SCHED-02
+
+### What It Does
+
+Generates a daily intelligence briefing from room state:
+- Approaching prediction deadlines (overdue, urgent, approaching)
+- New contradictions detected in intelligence files
+- Stale sections (7+ days without updates)
+- Room health summary (section coverage, artifact counts)
+
+### Execution
+
+```javascript
+const { writeBriefing } = require('lib/core/daily-briefing.cjs');
+const result = writeBriefing(roomDir);
+// result.outputPath = room/intelligence/briefing-YYYY-MM-DD.md
+```
+
+### Output
+
+Filed to: `room/intelligence/briefing-YYYY-MM-DD.md`
+
+Frontmatter includes: type, date, predictions_tracked, contradictions_found, stale_sections, generated timestamp.
+
+### Recovery
+
+If missed (Cowork was offline), the session catch-up module detects the gap and generates the briefing on next session start.
+
+---
+
+## Task 2: Prediction Deadline Tracker
+
+**Schedule:** Every 12 hours
+**Trigger:** `prediction-tracker`
+**Requirements:** SCHED-02
+
+### What It Does
+
+Scans `.predictions/REGISTRY.json` for:
+- OVERDUE predictions (deadline passed)
+- URGENT predictions (due within 3 days)
+- APPROACHING predictions (due within 14 days)
+
+Alerts are included in the daily briefing. This task runs more frequently to catch deadline transitions between briefings.
+
+### Execution
+
+```javascript
+const { getPredictionDeadlines } = require('lib/core/daily-briefing.cjs');
+const deadlines = getPredictionDeadlines(roomDir);
+const overdue = deadlines.filter(p => p.status === 'OVERDUE');
+const urgent = deadlines.filter(p => p.status === 'URGENT');
+```
+
+If overdue or urgent predictions exist, surface them via resource notification:
+> "You have N overdue predictions and M predictions due within 3 days."
+
+### Output
+
+No separate file -- results feed into the daily briefing. Notifications are surfaced to the user in the Cowork conversation.
+
+---
+
+## Task 3: Competitor Watch
+
+**Schedule:** Weekly (recommended: Monday 8:00 AM)
+**Trigger:** `competitor-watch`
+**Requirements:** SCHED-03, SCHED-07
+
+### What It Does
+
+1. Extracts tracked competitors from `room/competitive-analysis/` and `.config.json`
+2. Builds search queries for each competitor (max 5)
+3. Executes web searches for recent competitor activity
+4. Checks findings against room assumptions for contradictions
+5. Files results to `room/intelligence/competitors-YYYY-MM-DD.md`
+
+### Execution
+
+```javascript
+const { buildCompetitorQueries, fileCompetitorResults } = require('lib/core/scheduled-scanner.cjs');
+const queryPlan = buildCompetitorQueries(roomDir);
+
+if (queryPlan.insufficient) {
+  // No competitors tracked -- skip
+  return;
+}
+
+// For each query, use WebSearch or Tavily
+for (const q of queryPlan.queries) {
+  // Execute: WebSearch(q.searchQuery)
+  // Collect findings and check for contradictions against room/competitive-analysis/
+}
+
+// File results
+fileCompetitorResults(roomDir, results);
+```
+
+### Search Strategy
+
+For each competitor:
+- Query: `"[name]" funding OR launch OR pivot OR acquisition OR partnership`
+- Time range: last 30 days
+- Extract: key developments, funding rounds, product launches, pivots
+- Flag: any finding that contradicts claims in room/competitive-analysis/
+
+### Output
+
+Filed to: `room/intelligence/competitors-YYYY-MM-DD.md`
+
+Frontmatter includes: type, date, competitors_scanned, contradictions_found, generated timestamp, source.
+
+---
+
+## Task 4: Grant & Funding Discovery
+
+**Schedule:** Weekly (recommended: Wednesday 8:00 AM)
+**Trigger:** `grant-discovery`
+**Requirements:** SCHED-04, SCHED-07
+
+### What It Does
+
+1. Reads room context (domain keywords, geography, venture stage from STATE.md)
+2. Queries Grants.gov API and Simpler Grants API
+3. Scores results for relevance against room context
+4. Files top results to `room/intelligence/grants-YYYY-MM-DD.md`
+
+### Execution
+
+```javascript
+const { scanAndFileGrants } = require('lib/core/scheduled-scanner.cjs');
+const result = await scanAndFileGrants(roomDir);
+// result.outputPath, result.resultCount, result.apiErrors
+```
+
+### Prerequisites
+
+Room STATE.md should contain `domain_keywords` for accurate matching. Without keywords, the scanner falls back to problem-definition/ content.
+
+### Output
+
+Filed to: `room/intelligence/grants-YYYY-MM-DD.md`
+
+Frontmatter includes: type, date, results count, api_errors count, generated timestamp, source.
+
+---
+
+## Task 5: Domain News Scan
+
+**Schedule:** Weekly (recommended: Friday 8:00 AM)
+**Trigger:** `news-scan`
+**Requirements:** SCHED-05, SCHED-07
+
+### What It Does
+
+1. Reads domain keywords from room STATE.md
+2. Builds news queries: domain developments, regulatory updates, market/investment
+3. Executes web searches
+4. Files results to `room/intelligence/news-YYYY-MM-DD.md`
+
+### Execution
+
+```javascript
+const { buildNewsQueries, fileNewsResults } = require('lib/core/scheduled-scanner.cjs');
+const queryPlan = buildNewsQueries(roomDir);
+
+if (queryPlan.insufficient) {
+  // No domain keywords -- skip
+  return;
+}
+
+// For each query, use WebSearch or Tavily
+// Collect results per topic
+
+fileNewsResults(roomDir, results);
+```
+
+### Output
+
+Filed to: `room/intelligence/news-YYYY-MM-DD.md`
+
+Frontmatter includes: type, date, topics_scanned, items_found, generated timestamp, source.
+
+---
+
+## Task 6: Scout Sentinel
+
+**Schedule:** Weekly (recommended: Sunday midnight)
+**Trigger:** `scout-sentinel`
+**Requirements:** SCHED-06
+
+### What It Does
+
+Runs the full `/mos:scout` sentinel suite:
+1. State snapshot
+2. Health check (compare STATE.md vs last snapshot)
+3. Deadline monitor (funding/ and opportunity-bank/ deadlines)
+4. Competitor watch (if competitors tracked)
+5. HSI recomputation (if dependencies available)
+
+### Execution
+
+This task invokes the scout command directly:
+
+```bash
+PLUGIN_ROOT="$(dirname "$(readlink -f "$0")")/.."
+bash "${PLUGIN_ROOT}/scripts/sentinel-snapshot" "$ROOM_DIR"
+bash "${PLUGIN_ROOT}/scripts/sentinel-health-check" "$ROOM_DIR"
+bash "${PLUGIN_ROOT}/scripts/sentinel-deadline-monitor" "$ROOM_DIR"
+```
+
+For HSI recomputation (if scikit-learn is available):
+```bash
+python3 "${PLUGIN_ROOT}/scripts/compute-hsi.py" "$ROOM_DIR"
+python3 "${PLUGIN_ROOT}/scripts/detect-reverse-salients.py" "$ROOM_DIR"
+node "${PLUGIN_ROOT}/scripts/hsi-to-graph.cjs" "$ROOM_DIR"
+```
+
+### Output
+
+Multiple outputs:
+- `room/.snapshots/STATE-YYYY-MM-DD.md`
+- `room/.intelligence/health-YYYY-MM-DD.md` (if drift detected)
+- HSI results updated in `room/.hsi-results.json`
+
+---
+
+## Tri-Polar Notes
+
+**CLI:** These tasks don't run on CLI. Users invoke `/mos:scout` manually. Session-start hook handles catch-up scanning.
+
+**Desktop:** These tasks don't run on Desktop (no scheduler). Desktop users get the session catch-up summary when reconnecting after a gap.
+
+**Cowork:** Primary surface. Tasks register in Cowork's built-in scheduler. Users configure frequency in task management UI. Missed tasks are recovered by session catch-up on next connection.
+
+---
+
+## Configuration
+
+Users can customize task schedules by setting preferences in `room/.config.json`:
+
+```json
+{
+  "scheduled_tasks": {
+    "daily_briefing": { "enabled": true, "interval_hours": 24 },
+    "prediction_tracker": { "enabled": true, "interval_hours": 12 },
+    "competitor_watch": { "enabled": true, "interval_days": 7 },
+    "grant_discovery": { "enabled": true, "interval_days": 7 },
+    "news_scan": { "enabled": true, "interval_days": 7 },
+    "scout_sentinel": { "enabled": true, "interval_days": 7 }
+  },
+  "tracked_competitors": ["Competitor A", "Competitor B"]
+}
+```
+
+All tasks are enabled by default. Users can disable individual tasks or adjust frequency.

package/commands/score-innovation.md

@@ -0,0 +1,37 @@
+---
+name: score-innovation
+description: Score cross-domain innovation via HSI
+serves_jtbd: ["compare-options", "validate-idea"]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+---
+
+# /mos:score-innovation
+
+You are Larry. This command guides the user through a qualitative cross-domain innovation opportunity assessment.
+
+## Setup
+
+1. Read `references/methodology/score-innovation.md` for the HSI framework, phases, and artifact template
+2. Read `references/personality/voice-dna.md` for Larry's voice
+3. Read `room/STATE.md` for venture context (if exists)
+4. Read all room sections to identify domains the user has explored
+
+## Session Flow
+
+Ask: "Quick pass or deep dive?"
+
+This is a CONVERSATIONAL assessment -- Larry guides the user through qualitative cross-domain opportunity scoring. No computation, no algorithms. Larry's judgment and Socratic questioning drive the assessment.
+
+Follow the framework phases from the reference file. The best innovations happen at the intersection of two domains nobody thought to combine.
+
+## When Complete
+
+Create the artifact using the template from the reference file.
+Ask: "File this to problem-definition?" before writing.
+
+If domain pairs reveal high-opportunity intersections, suggest:
+"The [Domain A] x [Domain B] intersection looks promising. Want to run /mos:explore-domains to map it deeper?"