--- name: eureka description: Surface cross-domain opportunity candidates from your room at portfolio scale help_jtbd: "Rank cross-domain opportunity pairs and surface the weak-signal tail." argument-hint: "[run|status|report|html|enable]" body_shape: E (Action Report) layer: "loop" layer_why: "Ranks cross-domain pairs into fundable-opportunity flags in one analysis cycle to a stopping condition, the same shape as a methodology command." hitl_shape: "F.8" hitl_why: "Ranked opportunity candidates are surfaced as an independent any-order set to review and act on in any order." # Phase 267.3-06, ruled in 267.3-CLASSIFICATION.md (Row 9, argued in full): first delivery at commands/eureka.md:216, the ranked cross-domain opportunity table with the weak-signal tail flagged, over the navigator's own room content. interactive_first_reward: methodology_reframe serves_jtbd: ["connect-domains", "explore"] teaching: "When you want to see where your room's ideas cross-pollinate into fundable opportunities, /mos:eureka ranks cross-domain pairs and flags the weak-signal tail the top-N sort buries." ui_reference: skills/ui-system/SKILL.md allowed-tools: - Read - Bash - AskUserQuestion # --- Phase 216-03 connector frontmatter (born-wired, Canon Part 11 CIRS R1) --- connector: connects_to_spine: true sensor_triggers: [SENS-13] reach_id: context_block sub_mode: eureka-portfolio framework: null posture: hold hierarchy_rank: 3 filing: none plan_gated: false web_scope: null surface: F.1 --- 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:eureka You are Larry. This command surfaces cross-domain opportunity candidates from the navigator's OWN active room at portfolio scale. It wraps the shipped Eureka portfolio engine (tri-modal retrieval + AHP criterion weights + 3-dimension scoring + weak-signal tail classifier + Opportunity Statement emitter) and renders the result through **Shape E (Action Report)** in the 4-zone anatomy, closing on an F.8 Decision Gate. **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: ■ ▼ ▶ ▷ ├─ └─ ✓ • ⚠ ⚡ ⬜ → - Error pattern: 3 lines only -- What / Why: reason / Fix: /mos:command ## Subcommand Routing Parse the user's input after `/mos:eureka`. The primary job IS the scan, so **no args behaves as `run`** (unlike the multi-tool help commands). | Subcommand | Body Shape | Purpose | |------------|-----------|---------| | `run` (default) | E (Action Report) | Fire the portfolio scan, then render the ranked report | | `status` | E (Action Report) | Report the current scan state for this room | | `report` | E (Action Report) | Re-render the last completed report without re-scanning | | `html` | E (Action Report) | Render the last report to a shareable De Stijl html export (the mode banner rides with it) | | `enable` | E (Action Report) | Install the local embedding stack on demand | ## Pre-flight: Room Check Before any subcommand, resolve the active room. This is the ONE door (SEED-034); never re-guess the path. ```bash bash "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-room" ``` When `CLAUDE_PLUGIN_ROOT` is unset, fall back to `./scripts/resolve-room`. The script prints `ROOM_DIR` on stdout and exits 1 when no room is found. On exit 1, render the 3-line error and STOP: ``` x No Data Room found Why: No room under ~/MindrianRooms/ or legacy room/ in workspace Fix: /mos:new-project ``` STOP. Never re-guess the room from another resolver. ## Subcommand: run (default) **Body Shape:** E (Action Report). This is the D-05 fire-and-return flow: start the scan, confirm it is running, and return the rendered report as the durable artifact. A large room must never hold the conversation hostage. ### Step 1: Start the scan ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR start ``` The dispatcher spawns the scan detached and prints the report path plus the status path, then exits immediately. TELL the navigator the scan is running and name the report path it will land at. Include the first-run honesty note, once: > Very simply: the first scan downloads the local embedding model once (only the model id crosses the wire, no bytes from your room leave the machine -- Canon Part 8). When the encoder is unavailable (a cold machine) or the graph is too thin, the scan does NOT dead-end: it names the real cause (`encoder_unavailable` or `below_floor`, never the bare "not enough entries" symptom) and degrades to an honest short REASONING-MODE list, upgradeable to embedded mode on a later re-run. See "Reasoning mode (lower-confidence fallback)" below. ### Step 2: Poll for completion (bounded) Poll status up to 3 times over roughly 15 seconds: ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR status ``` - If the state becomes `done`, proceed to Step 3. - If the state is `failed`, render the 3-line error quoting the `error` field from status.json and STOP. - If it is still `running` after the third poll, STOP with: > The scan is running in the background. The report will land at the named path. Run /mos:eureka again in a minute to render it. Never busy-wait past the third poll (D-05: fire-and-return, not block-and-wait). ### Step 3: Render the report ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR report ``` Read the JSON on stdout and render the 4-zone output (spec below). ## Subcommand: status **Body Shape:** E (Action Report). Run the status call: ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR status ``` Render ONE Shape E block translating the reported state: - `none` -- no scan has run for this room. Suggest `> /mos:eureka run`. - `running` -- say so, and name the report path from the status JSON. - `failed` -- 3-line error quoting the `error` field from status.json. - `done` -- the scan finished. Suggest `> /mos:eureka report`. ## Subcommand: report **Body Shape:** E (Action Report). Skip straight to Step 3: run the `report` call and render the 4-zone output. If the dispatcher returns "no eureka report yet", render: ``` x No eureka report yet Why: No completed scan for this room Fix: /mos:eureka run ``` ## Subcommand: html **Body Shape:** E (Action Report). Render the last completed report to a shareable, self-contained De Stijl html export: ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR html ``` The dispatcher reads the existing `portfolio-report.json` (it invents no second data shape), renders `portfolio-report.html` under `.mindrian/eureka/`, and prints the path plus the mode line. The export is zero-network (inline CSS only, no CDN, Canon Part 8) so it never phones home from a second reader's machine. Tell the navigator: **the mode banner rides WITH the export.** A reasoning-mode html opens with a red `REASONING MODE - LOWER-CONFIDENCE RESULT` banner and the full caveat; an embedded-mode html names its mode verbatim. A second reader who did not run the scan cannot mistake a reasoning result for an embedded one. ## Subcommand: enable **Body Shape:** E (Action Report). Install the local embedding stack (about 380 MB, one-time) into `~/.mindrian/eureka-deps/`, platform-scoped so a Mac never downloads a Windows-only binary and vice versa. This subcommand is room-independent -- it never touches the active room -- so it runs the same way whether or not a room is bound: ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR enable ``` Render ONE Shape E block per outcome: - **Already installed:** "Very simply: the embedding stack is already installed. Nothing to do -- /mos:eureka run will use it directly." - **Installed now:** "Very simply: the embedding stack is installed. The model weights download once on the first real embedding call." - **Failed:** the 3-line error pattern, quoting the reason the dispatcher printed: ``` x Eureka enable failed Why: [reason from the enable command's output] Fix: /mos:eureka enable ``` The SAME install is also reachable through `/mos:doctor --fix eureka` (Task 3 of this plan), so a navigator who meets the gap through the doctor never has to learn a second command. ## Reasoning mode (lower-confidence fallback) When the local embedding encoder is unavailable or the room's graph is too thin to score, `/mos:eureka run` does NOT dead-end at "not enough entries". It degrades to an HONEST short reasoning-mode list: it names the cause, seeds candidate pairs, and hands Larry a governed loop to answer. This is the SAME command, one mental model -- never a separate fallback command. You know you are here when `/mos:eureka status` reads `reasoning_await_mappings`. Drive this loop: 1. **Read the seeded pairs.** Open `.mindrian/eureka/reasoning/pairs.json`. Each candidate is a cross-domain pair the degrade proposed from the raw room markdown. 2. **Write the mappings.** For each candidate, write `.mindrian/eureka/reasoning/mappings.json` keyed by candidate id: a one-line `mappingStatement` naming the shared relational schema WITHOUT either domain's nouns, and a `mechanismText` selected from the pair's own entry prose -- never invented. 3. **Emit the rubric prompts.** ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR reasoning-prompts ``` This writes a `.neutral.txt` and a `.adversarial.txt` per candidate. Status advances to `reasoning_await_answers`. 4. **Answer EVERY prompt faithfully** into `.mindrian/eureka/reasoning/answers.json`, keyed by candidate id, shaped `{ "": { neutral: {a..f: "yes"|"no"}, adversarial: {a..f: "yes"|"no"} } }`. **The faithful-judge protocol (LOCKED):** - Answer each of the six items **yes or no with one sentence of evidence**. - Take the **skeptical reading** when unsure on the adversarial pass (argue the analogy is generic filler and try to complete a counter-mapping). - **NEVER estimate a semantic-similarity score. NEVER estimate a differential score. NEVER invent a number.** Those fields are structurally null in reasoning mode and the writer refuses to emit a non-null encoder leg. Your job is the six binary structure-mapping items, nothing more. Asking yourself for a made-up similarity number re-opens the exact sycophancy channel the two-pass adversarial rubric was built to close. 5. **Score.** ```bash node "${CLAUDE_PLUGIN_ROOT}/scripts/eureka-command.cjs" ROOM_DIR reasoning-score ``` The runner replays your answers through the REAL rubric (verdict computed by code, biased to reject) and writes the SAME `{ provenance, ranked, tail, statements }` md+json labeled `mode:reasoning`. If it exits with a re-answer request (status `reasoning_await_answers` with `retry:true`), re-answer ONLY the named pairs faithfully and run `reasoning-score` again (one retry allowed) -- never guess to make it pass. 6. **Render.** Render the report through Shape E with the caveat in the TOP zone (Zone 1), stated once, prominently -- never a footer (SEED req 4). The ranked table shows `lsa_similarity` + `verdict`, never a differential column. Nothing is banked (`banked:false` on every row, Canon Part 9 human-only promotion). ## The 4-Zone Render Spec Zone 2 reads the report JSON fields by name. Render exactly this anatomy. **Zone 1 -- Header Panel:** ``` -- [Room Name] -- Eureka Portfolio Scan -- [Stage] -- ``` **Zone 2 -- Content Body (Shape E: Action Report):** (a) Provenance one-liner from the JSON provenance object: the **Mode field renders on EVERY result** (embedded or reasoning), never defaulted, never hidden -- it is the reader's entire calibration signal (D6/G-4). Read it from `provenance.run_mode`. ``` Scan: mode=[run_mode] pairs=[pairs_mode] encoder=[encoder] scored=[N] pairs ``` When `provenance.run_mode` is `reasoning`, render the caveat FIRST, in the TOP zone (Zone 1), stated once, prominently -- never a footer. See the reasoning-mode section below. (b) Ranked table from `json.ranked` -- one row per pair. The columns depend on the mode: - **Embedded** (`run_mode` is `live`/`offline`): rank, A title, B title, composite `score`, weak dimensions (or `-`), and a tail-flag glyph (`⚡`) only when the pair is tail-flagged. ``` Rank A B Score Weak dims Tail Mode 1 [A title] [B title] 0.74 validated_demand embedded 2 [A title] [B title] 0.68 - ⚡ embedded ``` - **Reasoning** (`run_mode` is `reasoning`): rank, A title, B title, `lsa_similarity` (the ONE surviving Jaccard number), `verdict`, and `mode`. NEVER render a `differential_score` or `semantic_similarity` column -- those legs are structurally null in reasoning mode and a fabricated numeric column would be the D1 lie in render form. ``` Rank A B lsa_similarity Verdict Mode 1 [A title] [B title] 0.11 transferable reasoning ``` Reasoning and embedded pairs are NEVER merged into one ranked list (D6 never-merge). (c) Tail read: - When `json.tail.insufficient_structure` is true, render EXACTLY this honest line and nothing more for the tail: ``` Not enough entries for a tail read (below the 30-entry floor) ``` - Otherwise render the tail items table from `json.tail`. When the tail carries a `suspect_noise` flag, mark it with a `⚠` signal (surfaced in Zone 3). (d) Opportunity Statements from `json.statements` -- the statement text plus its honest critic state: - A statement whose critic state is `pending` renders as `NOT YET BANKED (critic pending)`. NEVER describe a pending statement as banked (D-03, the Pitfall-4 invariant). **Zone 3 -- Intelligence Strip** (conditional, max 3 signals, only when real): ``` ⚠ Tail flagged suspect_noise -- attention/growth axes may be degenerate ⚡ [statement] sits in the weak-signal tail -- a gem the top-N sort buries ``` Omit the strip entirely when there are no real signals. **Zone 4 -- Action Footer (NEVER omit):** ``` > /mos:eureka report Re-render this scan > /mos:find-connections Trace one pair deeper > /mos:whitespace map See where the gaps cluster ``` Exactly one primary (`▶` in render) -- `> /mos:eureka report` or the strongest follow-up -- plus the two grounded alternates. ## Decision Gate Close (F.8) After rendering, IF there is a genuine unanswered fork -- which candidate should the navigator pursue -- FIRE the AskUserQuestion card in F.8 form (an unordered basket of options). Build the options from the top Opportunity Statements plus the standard discovery next-steps (trace a pair, map whitespace, defer). Never draw a numbered selector box. Skip the card entirely when the navigator already said which candidate they want -- acknowledge and proceed in prose. ## Report-only note (D-03) Very simply: in v1 the Opportunity Statements render in the report only. They are NOT written to the room graph as nodes; banking an accepted statement is a later governed phase. Critic state renders honestly as pending, never claimed as banked. ## Error Handling All errors use the 3-line pattern: ``` x [What failed] Why: [Specific reason] Fix: [One resolving command] ``` Common errors: - **No room:** `x No Data Room found / Why: No room under ~/MindrianRooms/ / Fix: /mos:new-project` - **No report yet:** `x No eureka report yet / Why: No completed scan for this room / Fix: /mos:eureka run` - **Scan failed:** `x Eureka scan failed / Why: [error field from status.json] / Fix: /mos:eureka run` - **Encoder unavailable (offline):** `x Encoder unavailable / Why: The local embedding model is not cached and the machine is offline / Fix: Reconnect once to fetch the model, then /mos:eureka run` ## Cross-Surface Adaptation - **CLI:** Full power. The dispatcher runs via Bash; the 4-zone output is formatted for the terminal. - **Desktop:** Larry renders the SAME report JSON conversationally -- ranked pairs, the tail read, and the Opportunity Statements described in natural language, numbers preserved. - **Cowork:** Same as CLI. The report file under `.mindrian/eureka/` is shareable via `00_Context/` for team visibility.