@diottodev/runic 1.0.0 → 1.1.0

package/research/litreview/skills/litreview/scripts/framework_recommender.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""framework_recommender.py — Heuristic PICO/SPIDER/Decomposition picker.
+
+Stdlib-only. Given a research question, suggests which literature-review
+framework to use, with confidence + rationale + starter sub-area questions.
+
+Heuristic keyword signals:
+  - "compared to", "vs", "versus", "better than" → PICO (Comparison signal)
+  - "intervention", "treatment", "drug", "therapy" → PICO (Intervention)
+  - "experience", "perception", "lived", "meaning" → SPIDER (Phenomenon)
+  - "qualitative", "interview", "ethnography" → SPIDER (Design)
+  - "system", "model", "algorithm", "architecture" → Decomposition (Solution)
+  - "benchmark", "evaluation", "metric" → Decomposition (Evaluation)
+  - Multiple signals across frameworks → Hybrid
+  - No strong signal → PICO (default)
+
+NO LLM CALLS. Pure regex + keyword counting.
+
+Usage:
+    python framework_recommender.py --question "How do LLMs perform on clinical reasoning compared to physicians?"
+    python framework_recommender.py --question "..." --output json
+    python framework_recommender.py --sample
+"""
+
+import argparse
+import json
+import re
+import sys
+from typing import Any, Dict, List
+
+
+PICO_SIGNALS = {
+    "comparison": ["compared to", "vs", "versus", "better than", "compared with", "relative to"],
+    "intervention": ["intervention", "treatment", "drug", "therapy", "drug therapy", "regimen"],
+    "outcome": ["outcome", "efficacy", "effectiveness", "accuracy", "mortality", "survival"],
+    "population": ["patients", "subjects", "cohort", "participants"],
+}
+
+SPIDER_SIGNALS = {
+    "phenomenon": ["experience", "perception", "meaning", "lived", "narrative", "perspective"],
+    "design": ["qualitative", "interview", "ethnography", "phenomenology", "grounded theory"],
+    "sample": ["women's", "men's", "clinicians", "students", "patients with"],  # demographic-context
+    "evaluation": ["thematic", "narrative analysis", "lived experience"],
+}
+
+DECOMPOSITION_SIGNALS = {
+    "solution": ["system", "model", "algorithm", "architecture", "method", "approach", "framework"],
+    "evaluation": ["benchmark", "evaluation", "metric", "performance", "accuracy"],
+    "problem": ["challenge", "problem", "issue with", "limitations of"],
+    "limitations": ["limitations", "failure mode", "edge case", "robustness"],
+}
+
+
+def count_signals(text: str, signal_map: Dict[str, List[str]]) -> Dict[str, int]:
+    text_lower = text.lower()
+    counts: Dict[str, int] = {}
+    for component, phrases in signal_map.items():
+        component_count = 0
+        for phrase in phrases:
+            # Allow optional plural 's' / 'ed' / 'ing' suffix for single-word phrases (not multi-word)
+            if " " in phrase:
+                pattern = re.compile(rf"\b{re.escape(phrase)}\b", re.IGNORECASE)
+            else:
+                pattern = re.compile(rf"\b{re.escape(phrase)}(?:s|es|ed|ing)?\b", re.IGNORECASE)
+            component_count += len(pattern.findall(text_lower))
+        counts[component] = component_count
+    return counts
+
+
+def recommend(question: str) -> Dict[str, Any]:
+    pico = count_signals(question, PICO_SIGNALS)
+    spider = count_signals(question, SPIDER_SIGNALS)
+    decomp = count_signals(question, DECOMPOSITION_SIGNALS)
+
+    pico_total = sum(pico.values())
+    spider_total = sum(spider.values())
+    decomp_total = sum(decomp.values())
+
+    total = pico_total + spider_total + decomp_total
+
+    # Confidence: ratio of dominant framework to total
+    if total == 0:
+        framework = "PICO"
+        confidence = "low"
+        rationale = "No strong framework signals detected — defaulting to PICO (covers ~70% of questions)"
+    elif pico_total >= 2 and spider_total >= 2:
+        framework = "Hybrid (PICO + SPIDER)"
+        confidence = "medium"
+        rationale = f"Both PICO ({pico_total} signals) and SPIDER ({spider_total}) detected — question spans quantitative + qualitative"
+    elif pico_total >= 2 and decomp_total >= 2:
+        framework = "Hybrid (PICO + Decomposition)"
+        confidence = "medium"
+        rationale = f"Both PICO ({pico_total}) and Decomposition ({decomp_total}) — clinical + technology evaluation"
+    elif decomp_total > pico_total and decomp_total > spider_total:
+        framework = "Decomposition"
+        confidence = "high" if decomp_total >= 3 else "medium"
+        active = [k for k, v in decomp.items() if v > 0]
+        rationale = f"Decomposition signals dominate ({decomp_total} total, components: {', '.join(active)})"
+    elif spider_total > pico_total and spider_total > decomp_total:
+        framework = "SPIDER"
+        confidence = "high" if spider_total >= 3 else "medium"
+        active = [k for k, v in spider.items() if v > 0]
+        rationale = f"SPIDER signals dominate ({spider_total} total, components: {', '.join(active)})"
+    else:
+        framework = "PICO"
+        confidence = "high" if pico_total >= 3 else "medium" if pico_total >= 1 else "low"
+        active = [k for k, v in pico.items() if v > 0]
+        rationale = f"PICO signals dominate ({pico_total} total, components: {', '.join(active) if active else 'default'})"
+
+    # Sub-area starter questions (template — actual generation needs LLM context)
+    starter_questions = generate_starter_questions(question, framework)
+
+    return {
+        "question": question,
+        "framework": framework,
+        "confidence": confidence,
+        "rationale": rationale,
+        "signal_counts": {"PICO": pico, "SPIDER": spider, "Decomposition": decomp},
+        "starter_sub_areas": starter_questions,
+    }
+
+
+def generate_starter_questions(question: str, framework: str) -> List[str]:
+    """Template-driven sub-area starter questions per framework."""
+    if framework.startswith("PICO") or "PICO" in framework:
+        return [
+            "Population: who is being studied? (define inclusion + exclusion)",
+            "Intervention: what is being tested? (specify dose / variant / version)",
+            "Comparison: against what baseline? (placebo / standard / alternative)",
+            "Outcome: what is being measured? (primary + secondary endpoints)",
+            "Cross-cutting: methodological quality or population variation",
+        ]
+    elif framework.startswith("SPIDER") or "SPIDER" in framework:
+        return [
+            "Sample: who has the experience? (define context)",
+            "Phenomenon: what experience or perception? (be specific)",
+            "Design: what qualitative methods? (interviews / observation / artifacts)",
+            "Evaluation: what kind of analysis? (thematic / narrative / phenomenological)",
+            "Cross-cutting: cultural or temporal variation in the phenomenon",
+        ]
+    elif framework.startswith("Decomposition"):
+        return [
+            "Problem: what challenge is being addressed? (constraints + objectives)",
+            "Solution: what is the proposed approach? (architecture + key innovation)",
+            "Evaluation: how is it being measured? (benchmarks + metrics + baselines)",
+            "Limitations: where does it fail? (edge cases + failure modes)",
+            "Cross-cutting: scalability or deployment considerations",
+        ]
+    else:  # Hybrid
+        return [
+            "Primary framework components (from dominant signals)",
+            "Secondary framework components (from cross-cutting signals)",
+            "Comparison or evaluation dimension",
+            "Outcome or impact dimension",
+            "Cross-cutting: methodological consistency across paradigms",
+        ]
+
+
+def render_human(result: Dict[str, Any]) -> str:
+    out: List[str] = []
+    out.append(f"Question:        {result['question']}")
+    out.append("")
+    out.append(f"Recommended:     {result['framework']}")
+    out.append(f"Confidence:      {result['confidence']}")
+    out.append(f"Rationale:       {result['rationale']}")
+    out.append("")
+    out.append("Signal counts:")
+    for fw, components in result["signal_counts"].items():
+        total = sum(components.values())
+        active = ", ".join(f"{k}={v}" for k, v in components.items() if v > 0) or "(none)"
+        out.append(f"  {fw:<18s} total={total}  ({active})")
+    out.append("")
+    out.append("Starter sub-area questions:")
+    for q in result["starter_sub_areas"]:
+        out.append(f"  - {q}")
+    return "\n".join(out)
+
+
+SAMPLE_QUESTION = "How do large language models perform on clinical reasoning tasks compared to physicians?"
+
+
+def main(argv: List[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--question", help="Research question text")
+    parser.add_argument("--sample", action="store_true", help="Run on embedded sample question")
+    parser.add_argument("--output", choices=["human", "json"], default="human")
+    args = parser.parse_args(argv)
+
+    if args.sample:
+        result = recommend(SAMPLE_QUESTION)
+    elif args.question:
+        result = recommend(args.question)
+    else:
+        parser.print_help(); return 0
+
+    if args.output == "json":
+        print(json.dumps(result, indent=2))
+    else:
+        print(render_human(result))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/research/notebooklm/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "notebooklm",
+  "description": "Browser automation skill for controlling Google's NotebookLM. Handles reading and querying notebooks, adding sources (URLs, text, files, YouTube links, synthesized content), generating Studio outputs (Audio Overview, infographics, slide decks, study guides, briefing docs, mind maps, timelines, FAQs), and creating new notebooks. Triggers on any phrase involving NotebookLM \u2014 'open NotebookLM', 'check my [name] notebook', 'pull info from NotebookLM', 'ask my notebook about X', 'add [source] to NotebookLM', 'create an infographic in NotebookLM', 'use NotebookLM Studio', 'generate a slide deck from my notebook', or any variation where the goal involves NotebookLM. Requires browser automation environment \u2014 fails gracefully when unavailable.",
+  "version": "2.9.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/research/notebooklm",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills/notebooklm"
+  ],
+  "source": {
+    "spec": "megaprompts/03-notebooklm-megaprompt.md",
+    "build_pattern": "Path B (direct conversion). Browser-automation shape \u2014 distinct from research-pack convention. Action-routing intake (Q1 picks one of 4 actions: read/extract, add source, generate studio output, create new). CLI-only portability with graceful failure in web context.",
+    "sibling_of": "research/pulse, litreview, grants, dossier, patent, syllabus (semantic domain) but DIFFERENT SHAPE (browser-automation, not research-pack)"
+  }
+}

package/research/notebooklm/README.md

@@ -0,0 +1,69 @@
+# notebooklm
+
+Browser-automation skill for controlling Google's NotebookLM (https://notebooklm.google.com). The only **browser-automation shape** in the v2 collection — distinct from the research-pack convention.
+
+## Critical Portability Notice
+
+> **Requires:** A browser automation environment (Claude Code CLI with computer-use, Claude Chrome Extension, or equivalent). Skill will gracefully fail in non-automation contexts with a clear "not supported" message.
+
+This skill cannot run in Claude.ai web (no browser automation). It detects environment at Step 0 and exits cleanly if unsupported.
+
+## What this skill does
+
+Four core actions controlled via the grill-me action-routing intake:
+
+| Action | Q1 picks | UI flow |
+|---|---|---|
+| **Read/Extract** | 1 | Ask the notebook's chat a question, return clean response |
+| **Add Sources** | 2 | Push URL / text / file / Google Doc / synthesized content into a notebook |
+| **Generate Studio Outputs** | 3 | Audio Overview, Study Guide, Briefing Doc, Timeline, FAQ, Table of Contents, Infographic, Slides, Mind Map |
+| **Create New Notebook** | 4 | Initialize with title + initial sources |
+
+## Domain folder — research (semantic) vs shape difference
+
+This skill lives in `research/` (with pulse/litreview/grants/dossier/patent/syllabus) because its **user-facing semantic domain** is research — users automate NotebookLM as part of their research workflow.
+
+But the **technical shape** is completely different from the research-pack:
+- No Consensus / Agent Integrity Rules
+- No 1 q/sec rate limits (browser automation has different constraints)
+- No DOCX generation (NotebookLM outputs come from NotebookLM itself)
+- No three-count tracking
+- Async discipline is fundamentally different (UI generation can take 5-10 min)
+
+Users find it where they expect (research/), but it's the only research-domain skill with this shape.
+
+## Source spec
+
+[`megaprompts/03-notebooklm-megaprompt.md`](../../megaprompts/03-notebooklm-megaprompt.md) (PR #657).
+
+## Plugin layout
+
+```
+research/notebooklm/
+├── .claude-plugin/plugin.json
+├── README.md
+├── agents/cs-notebooklm.md          ← browser-automation persona, async-discipline enforcer
+├── commands/cs-notebooklm.md        ← /cs:notebooklm (or auto-triggers on phrases)
+└── skills/notebooklm/
+    ├── SKILL.md
+    ├── references/
+    │   ├── browser_automation_canon.md         ← screenshot-first / find-before-click (7+ sources)
+    │   ├── studio_output_custom_prompts.md     ← why default prompts mediocre + per-type templates (7+ sources)
+    │   └── async_action_discipline.md          ← fire-and-notify pattern for slow UI ops (7+ sources)
+    └── scripts/
+        ├── action_router.py                    ← stdlib: Q1-Q4 answers → action plan + UI flow
+        ├── custom_prompt_template_generator.py ← stdlib: studio output type + audience → custom prompt starter
+        └── async_action_classifier.py          ← stdlib: action → wait-or-notify-and-move-on
+```
+
+## Dependencies
+
+- **Browser automation tool** — Required. Examples:
+  - Claude Code CLI with computer-use
+  - Claude Chrome Extension
+  - Playwright / Puppeteer with screenshot + click tools
+- **NotebookLM account** (Google) — User-provided, never auto-login
+
+## License
+
+MIT.

package/research/notebooklm/agents/cs-notebooklm.md

@@ -0,0 +1,83 @@
+---
+name: cs-notebooklm
+description: NotebookLM browser-automation persona. Walks 2-4 forcing intake questions (Q1 action: read / add source / Studio output / create new; Q2-Q4 branch per action). Refuses to start without action commitment. Refuses to handle login flows automatically. Refuses to wait synchronously for Studio generations (fire-and-notify). Always opens Studio customization menu and writes detailed custom prompt (default prompts produce mediocre output). Screenshot-first discipline. find()-before-click. Fails fast when browser automation unavailable.
+skills: research/notebooklm/skills/notebooklm
+domain: research
+model: opus
+tools: [Read, Write, Bash]
+---
+
+# NotebookLM Agent
+
+## Voice
+
+**Opening:** "Tell me the action: read/extract / add source / Studio output / create new. I need browser automation — fails fast if you're on web."
+
+**Environment check (Step 0):** *(silent if available; halt otherwise)*
+> "Browser automation not detected. This skill requires Claude Code CLI with computer-use, Chrome Extension, or equivalent. Cannot proceed."
+
+**Refusing action ambiguity:**
+> "You said 'open NotebookLM' but didn't say what to do. Pick: read / add source / Studio / create new. Each takes a different UI path."
+
+**Refusing login attempts:**
+> "I detect a login screen. I won't attempt to handle login automatically. Please log in to NotebookLM in the browser, then re-invoke this skill."
+
+**Studio custom-prompt mandatory:**
+> "Default Studio prompts produce mediocre output. Open customization menu. Tell me the angle, audience, and length — I'll write a detailed custom prompt before submitting."
+
+**Async fire-and-notify (Audio Overview):**
+> "Generation triggered for {output}. NotebookLM takes 5-10 minutes for Audio Overview. NOT waiting in this session — NotebookLM will notify you in-app when ready. Returning control to you now."
+
+**Closing:**
+> "Action complete. Notebook: {name}. Action: {type}. Result: {summary}. {output-location if applicable}."
+
+Browser-aware, async-disciplined, screenshot-first.
+
+## Purpose
+
+The cs-notebooklm agent orchestrates the `notebooklm` skill across NotebookLM browser-automation workflows:
+
+1. **Step 0 environment check** — verify browser automation available; halt with clear message if not
+2. **Phase 0 intake** — Q1 action / Q2 notebook / Q3 action-specific / Q4 Studio custom-prompt (only if Q1=3)
+3. **Notebook discovery** — homepage → find by name OR navigate to URL
+4. **Execute action** — per Q1 (4 distinct UI flows)
+5. **Async handoff** — for Studio generations, don't wait; notify user and end
+6. **Report** — clean summary, not raw chat dumps
+
+**Hard rules:**
+
+1. **Browser automation required.** Check at Step 0. Fail fast if unavailable.
+2. **Action commitment mandatory.** Refuse to start without Q1 picked.
+3. **Screenshot-first.** Every UI action preceded by screenshot. NotebookLM is a dynamic SPA where UI varies by account/rollout.
+4. **find()-before-click.** Semantic element finders over pixel coordinates.
+5. **Never handle login automatically.** Detect login wall → stop, tell user.
+6. **Studio custom prompts always.** Default prompts produce mediocre output. Open customization menu, write detailed prompt.
+7. **Fire-and-notify for slow ops.** Studio generations (especially Audio Overview) can take 5-10 min. DO NOT wait synchronously. Confirm started, notify user, end.
+8. **Tool-agnostic language.** Use "browser automation tool" / "screenshot tool" / "click tool" — don't hardcode "Claude Chrome Extension."
+
+## Skill Integration
+
+**Skill Location:** `../skills/notebooklm/`
+
+### Python Tools (Stdlib)
+
+1. **Action Router** — `scripts/action_router.py` — Q1-Q4 answers → action plan + UI flow + required parameters
+2. **Custom Prompt Template Generator** — `scripts/custom_prompt_template_generator.py` — Studio output type + audience → starter custom prompt
+3. **Async Action Classifier** — `scripts/async_action_classifier.py` — action name → wait-or-notify pattern (which generations block and which return immediately)
+
+### Knowledge Bases
+
+- `references/browser_automation_canon.md` — screenshot-first + find-before-click + tool-agnostic patterns (7+ sources)
+- `references/studio_output_custom_prompts.md` — why defaults are mediocre + per-output-type templates (7+ sources)
+- `references/async_action_discipline.md` — fire-and-notify pattern for slow UI ops (7+ sources)
+
+## Related Agents
+
+- [cs-pulse](../../pulse/agents/cs-pulse.md) — research domain, different shape (multi-source web)
+- [cs-litreview](../../litreview/agents/cs-litreview.md) — research domain, Consensus-based
+- Future: cs-research orchestrator (Slice 7)
+
+---
+
+**Version:** 1.0.0
+**Source:** Path-B direct conversion of `megaprompts/03-notebooklm-megaprompt.md`

package/research/notebooklm/commands/cs-notebooklm.md

@@ -0,0 +1,152 @@
+---
+name: "cs-notebooklm"
+description: "/cs:notebooklm — NotebookLM browser automation. Action-routing intake (Q1: read / add source / Studio output / create new) + per-action Q2-Q4 branching. Fire-and-notify for slow Studio ops. Mandatory custom prompts (defaults are mediocre). Requires browser automation environment — fails clean on web."
+---
+
+# /cs:notebooklm — NotebookLM Browser Automation
+
+**Command:** `/cs:notebooklm`
+
+The `cs-notebooklm` persona controls Google NotebookLM via browser automation across 4 core actions.
+
+## Critical Prerequisite
+
+**Requires browser automation environment.** Works in:
+
+- Claude Code CLI with computer-use
+- Claude Chrome Extension
+- Playwright / Puppeteer with screenshot + click tools
+
+Does NOT work in:
+
+- Claude.ai web (no browser automation) — skill exits cleanly at Step 0
+
+## When to Run
+
+- Want to ask your existing NotebookLM notebook a question (Action 1)
+- Want to add a source (URL / text / file / Google Doc / YouTube) to a notebook (Action 2)
+- Want to generate a Studio output (Audio Overview / Infographic / Slides / Study Guide / etc.) (Action 3)
+- Want to create a new notebook from scratch (Action 4)
+
+## Action-Routing Intake (2-4 Forcing Questions)
+
+| Q | Asks | Notes |
+|---|---|---|
+| Q1 | Action: read / add source / Studio output / create new | Forcing — refuses to start without commitment |
+| Q2 | Notebook name or URL (actions 1-3) OR title for new notebook (action 4) | Drives navigation |
+| Q3 | Action-specific parameter (question text / source type / Studio output type / initial sources) | Branches per Q1 |
+| Q4 | Studio custom prompt detail | Asked only if Q1=3 (Studio); mandatory |
+
+Most invocations stop at Q3. Q4 only fires for Studio generation.
+
+## What You Get
+
+Per action:
+
+| Action | Result |
+|---|---|
+| Read/Extract | Clean response from notebook chat (not raw dump) |
+| Add Sources | Confirmation of ingestion (with screenshot) |
+| Studio Output | Confirmation that generation started + "NotebookLM will notify you when ready" — fire-and-notify |
+| Create New | New notebook URL + confirmation of initial sources added |
+
+## Studio Output Types
+
+All 9 types supported:
+
+- Audio Overview (5-10 min generation — fire-and-notify)
+- Study Guide
+- Briefing Doc
+- Timeline
+- FAQ
+- Table of Contents
+- Infographic
+- Slides (slide deck)
+- Mind Map
+
+## Mandatory Custom Prompts
+
+Default Studio prompts produce mediocre output. The skill ALWAYS opens the customization menu and writes a detailed custom prompt before submitting.
+
+Examples per output type:
+
+| Output | Example custom prompt |
+|---|---|
+| Audio Overview | "Two-host conversation for a non-technical executive, 8-10 min, focus on business implications not technical depth" |
+| Infographic | "Decision-tree style, action-oriented, 6 panels max, monochrome navy" |
+| Study Guide | "Undergrad-level, definitions + 3 practice questions per concept" |
+| Slides | "12 slides max, 1-2 sentences per slide, presenter notes with examples per slide" |
+
+## Discipline
+
+- **Step 0 environment check** — verify browser automation; fail fast if not
+- **Screenshot-first** — every UI action preceded by screenshot
+- **find()-before-click** — semantic finders over pixel coordinates
+- **Never auto-handle login** — detect login wall, stop, tell user to log in manually
+- **Studio custom prompts always** — open customization menu, write detailed prompt
+- **Fire-and-notify for slow ops** — Studio generation doesn't block this session
+- **Tool-agnostic language** — "browser automation tool", not "Claude Chrome Extension"
+
+## Trigger Phrases (auto-invoke without /cs:)
+
+- "open NotebookLM"
+- "check my [notebook name] notebook"
+- "pull info from NotebookLM"
+- "ask my notebook about X"
+- "add [source] to NotebookLM"
+- "create an infographic in NotebookLM"
+- "use NotebookLM Studio"
+- "generate a slide deck from my notebook"
+- "what does my notebook say about X"
+- Any variation involving NotebookLM
+
+## Workflow
+
+```bash
+# Step 0: environment check (silent if available; halt if not)
+
+# Phase 0 intake (Q1 + Q2 minimum; Q3-Q4 branch per action)
+python ../skills/notebooklm/scripts/action_router.py \
+  --action read_extract --notebook "Q3 prep" --question "what are the latest trends?"
+
+# Studio output flow includes custom prompt generation:
+python ../skills/notebooklm/scripts/custom_prompt_template_generator.py \
+  --output-type infographic --audience executive --length compact
+
+# Async classification (for "should I wait or fire-and-notify?")
+python ../skills/notebooklm/scripts/async_action_classifier.py --action audio_overview
+# Returns: FIRE_AND_NOTIFY (5-10 min generation)
+
+# Execute action via browser automation (screenshot → find → click → verify)
+# Return clean summary
+```
+
+## Stop Conditions
+
+- Browser automation unavailable → halt at Step 0 with clear message
+- Q1 action commitment refused → halt, re-ask
+- Login wall detected → halt, ask user to log in manually
+- Page layout changed unexpectedly → screenshot, ask user for guidance
+- 3 consecutive UI find() failures → halt, alert user
+
+## Anti-Patterns Rejected
+
+- Tool-specific names without abstraction (e.g., hardcoding "Claude Chrome Extension")
+- Synchronous waiting on Studio generations (especially Audio Overview)
+- Skipping screenshots between actions
+- Using pixel coordinates when semantic find() is available
+- Attempting to handle login flows automatically
+- Generating Studio outputs without opening customization menu
+- Using default Studio prompts (always write custom)
+
+## Related
+
+- Agent: [`cs-notebooklm`](../agents/cs-notebooklm.md)
+- Skill: [`notebooklm`](../skills/notebooklm/SKILL.md)
+- Source spec: [`megaprompts/03-notebooklm-megaprompt.md`](../../../megaprompts/03-notebooklm-megaprompt.md)
+- Research-domain siblings (different shape): `/cs:pulse`, `/cs:litreview`, `/cs:grants`, `/cs:dossier`, `/cs:patent`, `/cs:syllabus`
+
+---
+
+**Version:** 1.0.0
+**Source:** Path-B direct conversion of `megaprompts/03-notebooklm-megaprompt.md`