@mindrian_os/install 1.13.0-beta.11

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,43 @@
+---
+name: score-innovation
+description: Score cross-domain innovation via HSI
+serves_jtbd: ["compare-options", "validate-idea"]
+# --- Phase 122 workflow-layer frontmatter ---
+kind: methodology
+frameworks: ["HSI Semantic Surprise Analysis Assistant"]
+produces: "room/opportunity-bank/hsi-scores/*"
+inputs: []
+autonomous_safe: true
+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?"

package/commands/scout.md

@@ -0,0 +1,239 @@
+---
+name: scout
+description: Run sentinel scans across the room
+body_shape: E (Action Report)
+serves_jtbd: ["explore", "understand-market"]
+ui_reference: skills/ui-system/SKILL.md
+allowed-tools:
+  - Read
+  - Write
+  - Glob
+  - Bash
+  - WebSearch
+  - mcp__tavily__tavily-search
+  - mcp__mindrian-brain__brain_query
+  - mcp__mindrian-brain__read_neo4j_cypher
+---
+
+# /mos:scout
+
+You are Larry. This command runs the full Sentinel Intelligence suite -- five automated tasks that monitor room health, track deadlines, watch competitors, recompute innovation scores, and snapshot state for future comparison.
+
+**Modes:**
+- `/mos:scout` -- run all 5 sentinel tasks + query efficiency telemetry summary
+- `/mos:scout health` -- health check only (compare STATE.md vs last snapshot)
+- `/mos:scout deadlines` -- deadline scan only (funding/ and opportunity-bank/)
+- `/mos:scout competitors` -- competitor watch only (web search tracked competitors)
+- `/mos:scout hsi` -- HSI recomputation only (compute-hsi + detect-reverse-salients + hsi-to-graph)
+- `/mos:scout snapshot` -- state snapshot only (copy STATE.md to .snapshots/)
+- `/mos:scout efficiency` -- query efficiency telemetry summary only (aggregate JSONL, render median + top 5 + threshold status)
+
+## UI Format
+
+- **Body Shape:** E -- Action Report (status block, reasoning, then action)
+- **Reference:** `skills/ui-system/SKILL.md`
+- **Zone 1:** Header Panel -- room name + "Sentinel Intelligence"
+- **Zone 2:** Content Body -- Task results with status indicators
+- **Zone 3:** Intelligence Strip -- critical alerts (overdue deadlines, drift detected, contradictions)
+- **Zone 4:** Action Footer -- suggest next commands based on findings
+
+## Step 0: Resolve Room
+
+```bash
+SCRIPT_DIR="$(dirname "$(readlink -f "$0")")"
+PLUGIN_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+ROOM_DIR=$(bash "${PLUGIN_ROOT}/scripts/resolve-room" "$PWD")
+```
+
+If no room is found, tell the user:
+> "No active room detected. Start a project with /mos:new-project first."
+
+## Step 1: State Snapshot (SENT-07)
+
+Always run first -- this ensures a baseline exists for health checks.
+
+```bash
+bash "${PLUGIN_ROOT}/scripts/sentinel-snapshot" "$ROOM_DIR"
+```
+
+Report the result:
+- If `SNAPSHOT_CREATED` -- note the date
+- If snapshot was pruned -- mention cleanup
+
+## Step 2: Health Check (SENT-01)
+
+Compare current STATE.md against the latest snapshot.
+
+```bash
+bash "${PLUGIN_ROOT}/scripts/sentinel-health-check" "$ROOM_DIR"
+```
+
+Report the result:
+- `HEALTHY` -- room is stable, brief confirmation
+- `DRIFT` -- highlight each drift point (stage change, entry count change, staleness)
+- `BASELINE` -- first snapshot created, no comparison possible yet
+
+## Step 3: Deadline Monitor (SENT-02)
+
+Scan funding/ and opportunity-bank/ for approaching deadlines.
+
+```bash
+bash "${PLUGIN_ROOT}/scripts/sentinel-deadline-monitor" "$ROOM_DIR"
+```
+
+Report the result:
+- `CLEAR` -- no approaching deadlines
+- `ALERT` -- list overdue items first (red), then urgent (yellow), then upcoming (cyan)
+- Emphasize overdue items with strong language: "You have N deadlines that have PASSED."
+
+## Step 4: Competitor Watch (SENT-03)
+
+This task requires web search capability. Search for each tracked competitor and flag contradictions with room assumptions.
+
+### 4a: Find Tracked Competitors
+
+Look for competitors in these locations (in order):
+1. `room/competitive-analysis/*.md` -- extract company names from filenames and content
+2. `room/STATE.md` -- look for competitor mentions
+3. `room/.config.json` -- check for `tracked_competitors` array
+
+If no competitors are tracked:
+> "No competitors tracked yet. Run /mos:challenge-assumptions on your competitive-analysis section to identify competitors worth monitoring."
+
+### 4b: Web Search Each Competitor
+
+For each tracked competitor (max 5):
+1. Search for recent news: `"[competitor name]" funding OR launch OR pivot OR acquisition` (last 30 days)
+2. Summarize key findings in 2-3 bullet points
+3. Flag any finding that CONTRADICTS an assumption in the room:
+   - Check `room/competitive-analysis/*.md` for existing claims about this competitor
+   - If web search reveals contradicting information, flag as: `CONTRADICTION:[competitor]:[claim]:[new finding]`
+
+### 4c: Write Competitor Report
+
+Write findings to `room/.intelligence/competitors-YYYY-MM-DD.md`:
+
+```markdown
+---
+type: competitor-watch
+date: YYYY-MM-DD
+competitors_scanned: N
+contradictions_found: N
+---
+
+# Competitor Watch - YYYY-MM-DD
+
+## [Competitor Name]
+
+**Recent Activity:**
+- [finding 1]
+- [finding 2]
+
+**Room Contradictions:** [none | list contradictions]
+
+...
+```
+
+## Step 5: HSI Recomputation (SENT-04)
+
+Run the full HSI pipeline to update innovation connection scores and reverse salient detection.
+
+### 5a: Check Dependencies
+
+```bash
+bash "${PLUGIN_ROOT}/scripts/check-hsi-deps" 2>/dev/null
+```
+
+If sklearn is not available, skip with a note:
+> "HSI computation requires scikit-learn. Install with: pip install scikit-learn. Skipping for now."
+
+### 5b: Run HSI Pipeline
+
+If dependencies are available:
+
+```bash
+# Step 1: Compute HSI scores
+python3 "${PLUGIN_ROOT}/scripts/compute-hsi.py" "$ROOM_DIR" --output "$ROOM_DIR/.hsi-results.json"
+
+# Step 2: Detect reverse salients (lagging subsystems)
+python3 "${PLUGIN_ROOT}/scripts/detect-reverse-salients.py" "$ROOM_DIR"
+
+# Step 3: Write HSI edges to room graph (if available)
+node "${PLUGIN_ROOT}/scripts/hsi-to-graph.cjs" "$ROOM_DIR" 2>/dev/null || true
+```
+
+Report:
+- Number of HSI pairs scored
+- Top 3 highest-scoring connections
+- Any new reverse salients detected
+- Whether room graph was updated
+
+## Step 5b: Query Efficiency Telemetry (SENT-08)
+
+Aggregate the query-efficiency JSONL produced by the 88.1-16 PostToolUse hook at `~/.mindrian/telemetry/query-efficiency.jsonl`. This summary surfaces whether the 57x token-efficiency claim (Canon Part 6) is holding up in real usage. Release gate (Plan 88.1-11) consumes the threshold status before tagging.
+
+```bash
+node "${PLUGIN_ROOT}/scripts/scout-telemetry-aggregator.cjs"
+```
+
+Options the user can pass through as `/mos:scout efficiency --days=30` or similar:
+- `--days=N` -- window size in days (default 7)
+- `--all` -- no window filter (all-time aggregation)
+- `--json` -- machine-readable JSON output (release gate uses this)
+
+Report the result verbatim. The aggregator emits:
+- event count in the window
+- median ratio + mean ratio
+- top 5 commands by ratio (per-command max)
+- threshold status: `PASS` (median >= 40x) | `RETUNE` (median < 40x) | `NO_DATA` (empty window)
+
+If the JSONL file does not exist yet, the aggregator prints "no events in window yet. Run a /mos:* query first." -- this is normal for fresh installs and is not an error.
+
+Expose the threshold status prominently in the final Sentinel summary (Step 6).
+
+## Step 6: Generate Summary
+
+After all tasks complete, present a unified summary using the E body shape:
+
+```
+  ┌─────────────────────────────────────────────────────┐
+  │  SENTINEL INTELLIGENCE                              │
+  │  Room: [room-name]        [venture-stage]           │
+  └─────────────────────────────────────────────────────┘
+
+  ■ Health:     [HEALTHY | DRIFT DETECTED]
+  ■ Deadlines:  [N overdue, N urgent, N upcoming | CLEAR]
+  ■ Competitors: [N scanned, N contradictions | NOT TRACKED]
+  ■ HSI:        [N pairs scored, N reverse salients | SKIPPED]
+  ■ Snapshot:   [STATE-YYYY-MM-DD.md created]
+  ■ Efficiency: [median R.RRx over N events, PASS | RETUNE | NO_DATA]
+
+  [If any critical findings, show Intelligence Strip here]
+
+  ──────────────────────────────────────────────
+  Next steps:
+  ▷ /mos:scout health        Re-run health check only
+  ▷ /mos:scout efficiency    Query efficiency telemetry summary only
+  ▷ /mos:challenge-assumptions  Address contradictions found
+  ▷ /mos:funding             Review approaching deadlines
+  ▷ /mos:score-innovation    Deep-dive into HSI connections
+```
+
+## Tri-Polar Notes
+
+**CLI:** Full automation. All scripts run, reports written to `.intelligence/`. Power users can run individual tasks via flags.
+
+**Desktop:** Larry narrates findings conversationally. "Here's the thing -- your room hasn't changed in 2 weeks, and you have a grant deadline in 3 days. Let's prioritize."
+
+**Cowork:** Reports in `.intelligence/` are visible to all team members via `00_Context/`. Competitor watch findings can be discussed collaboratively.
+
+## Cron Integration (DEFERRED)
+
+When CronCreate tool becomes available, sentinel tasks can be scheduled:
+- `sentinel-snapshot` + `sentinel-health-check`: Weekly (Sunday midnight)
+- `sentinel-deadline-monitor`: Daily (6 AM)
+- Competitor watch: Weekly (Monday morning)
+- HSI recomputation: Weekly (after health check)
+
+Until then, `/mos:scout` is the manual trigger for all sentinel intelligence. Remind users to run it weekly:
+> "I'd suggest running /mos:scout every Monday. Think of it as your weekly venture check-up."