@diottodev/runic 1.0.0 → 1.1.0

package/research/notebooklm/skills/notebooklm/scripts/async_action_classifier.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""async_action_classifier.py — Classify NotebookLM action as wait-or-notify.
+
+Stdlib-only. Given an action name, returns whether the skill should wait
+synchronously OR fire-and-notify the user. The 2-minute dividing line:
+
+  - Under 2 minutes  → WAIT (with appropriate timeout)
+  - Over 2 minutes   → FIRE_AND_NOTIFY (browser session would time out)
+
+Returns: action timing classification + estimated duration + recommended
+timeout + fire-and-notify message template (if applicable).
+
+NO LLM CALLS. Pure lookup table.
+
+Usage:
+    python async_action_classifier.py --action audio_overview
+    python async_action_classifier.py --action add_source_url
+    python async_action_classifier.py --output json
+    python async_action_classifier.py --sample
+"""
+
+import argparse
+import json
+import sys
+from typing import Any, Dict, List
+
+
+ACTION_TIMING = {
+    # Read/Extract
+    "chat_send": {
+        "category": "read_extract",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (3, 10),
+        "timeout_seconds": 30,
+        "polling_interval_seconds": 3,
+    },
+    # Add Source sub-types
+    "add_source_url": {
+        "category": "add_source",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (5, 15),
+        "timeout_seconds": 60,
+        "polling_interval_seconds": 5,
+    },
+    "add_source_text": {
+        "category": "add_source",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (5, 15),
+        "timeout_seconds": 60,
+        "polling_interval_seconds": 5,
+    },
+    "add_source_file": {
+        "category": "add_source",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (10, 30),
+        "timeout_seconds": 90,
+        "polling_interval_seconds": 5,
+    },
+    "add_source_google_doc": {
+        "category": "add_source",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (10, 30),
+        "timeout_seconds": 90,
+        "polling_interval_seconds": 5,
+    },
+    "add_source_synthesized": {
+        "category": "add_source",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (5, 15),
+        "timeout_seconds": 60,
+        "polling_interval_seconds": 5,
+    },
+    # Create New
+    "create_new_notebook": {
+        "category": "create_new",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (15, 30),
+        "timeout_seconds": 60,
+        "polling_interval_seconds": 5,
+    },
+    # Studio outputs — fast
+    "study_guide": {
+        "category": "studio",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (30, 60),
+        "timeout_seconds": 120,
+        "polling_interval_seconds": 10,
+    },
+    "briefing_doc": {
+        "category": "studio",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (30, 60),
+        "timeout_seconds": 120,
+        "polling_interval_seconds": 10,
+    },
+    "timeline": {
+        "category": "studio",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (30, 60),
+        "timeout_seconds": 120,
+        "polling_interval_seconds": 10,
+    },
+    "faq": {
+        "category": "studio",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (30, 60),
+        "timeout_seconds": 120,
+        "polling_interval_seconds": 10,
+    },
+    "table_of_contents": {
+        "category": "studio",
+        "verdict": "WAIT",
+        "estimated_duration_seconds": (20, 40),
+        "timeout_seconds": 90,
+        "polling_interval_seconds": 5,
+    },
+    # Studio outputs — slow (fire-and-notify)
+    "audio_overview": {
+        "category": "studio",
+        "verdict": "FIRE_AND_NOTIFY",
+        "estimated_duration_seconds": (300, 600),
+        "estimated_duration_human": "5-10 minutes",
+        "notify_message": (
+            "Audio Overview generation triggered. Estimated 5-10 minutes. "
+            "NotebookLM will notify you in-app and via email when ready. "
+            "NOT waiting in this session — returning control to you now."
+        ),
+    },
+    "infographic": {
+        "category": "studio",
+        "verdict": "FIRE_AND_NOTIFY",
+        "estimated_duration_seconds": (120, 300),
+        "estimated_duration_human": "2-5 minutes",
+        "notify_message": (
+            "Infographic generation triggered. Estimated 2-5 minutes. "
+            "NotebookLM will notify you when ready. "
+            "NOT waiting in this session — returning control."
+        ),
+    },
+    "slides": {
+        "category": "studio",
+        "verdict": "FIRE_AND_NOTIFY",
+        "estimated_duration_seconds": (120, 300),
+        "estimated_duration_human": "2-5 minutes",
+        "notify_message": (
+            "Slides generation triggered. Estimated 2-5 minutes. "
+            "NotebookLM will notify you when ready. "
+            "NOT waiting in this session — returning control."
+        ),
+    },
+    "mind_map": {
+        "category": "studio",
+        "verdict": "FIRE_AND_NOTIFY",
+        "estimated_duration_seconds": (120, 300),
+        "estimated_duration_human": "2-5 minutes",
+        "notify_message": (
+            "Mind Map generation triggered. Estimated 2-5 minutes. "
+            "NotebookLM will notify you when ready. "
+            "NOT waiting in this session — returning control."
+        ),
+    },
+}
+
+
+def classify(action: str) -> Dict[str, Any]:
+    if action not in ACTION_TIMING:
+        # Try fuzzy match for synonyms
+        action_lower = action.lower().replace(" ", "_").replace("-", "_")
+        for known_action in ACTION_TIMING:
+            if action_lower in known_action or known_action in action_lower:
+                return {"action": known_action, "matched_from": action, **ACTION_TIMING[known_action]}
+        raise ValueError(f"Unknown action '{action}'. Known: {sorted(ACTION_TIMING.keys())}")
+    return {"action": action, **ACTION_TIMING[action]}
+
+
+def render_human(result: Dict[str, Any]) -> str:
+    out: List[str] = []
+    out.append(f"Action:    {result['action']}")
+    if result.get('matched_from'):
+        out.append(f"  (matched from: {result['matched_from']})")
+    out.append(f"Category:  {result['category']}")
+    out.append(f"Verdict:   {result['verdict']}")
+    out.append("")
+    dur = result['estimated_duration_seconds']
+    if isinstance(dur, (list, tuple)) and len(dur) == 2:
+        out.append(f"Estimated duration: {dur[0]}-{dur[1]} seconds")
+    out.append(f"Human duration:     {result.get('estimated_duration_human', f'{dur}s')}")
+    out.append("")
+    if result['verdict'] == "WAIT":
+        out.append(f"Timeout:           {result['timeout_seconds']}s")
+        out.append(f"Polling interval:  {result['polling_interval_seconds']}s")
+        out.append("")
+        out.append("Wait discipline:")
+        out.append("  1. Click trigger (after screenshot)")
+        out.append("  2. Start wait loop with timeout")
+        out.append(f"  3. Poll every {result['polling_interval_seconds']}s for completion signal")
+        out.append("  4. Screenshot at each poll for audit")
+        out.append("  5. On timeout: screenshot, note delay, ask user")
+    else:  # FIRE_AND_NOTIFY
+        out.append("Fire-and-notify message (paste into skill output):")
+        out.append("")
+        out.append(f"  {result['notify_message']}")
+        out.append("")
+        out.append("Discipline:")
+        out.append("  1. Click trigger (in customization menu, not main button)")
+        out.append("  2. Verify generation started via screenshot WITHIN 5 seconds")
+        out.append("  3. Tell user the notify message above")
+        out.append("  4. END TASK — do not loop waiting for completion")
+    return "\n".join(out)
+
+
+def main(argv: List[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--action", help="Action name (e.g., audio_overview, chat_send, add_source_url)")
+    parser.add_argument("--sample", action="store_true")
+    parser.add_argument("--output", choices=["human", "json"], default="human")
+    args = parser.parse_args(argv)
+
+    if args.sample:
+        result = classify("audio_overview")
+    elif args.action:
+        try:
+            result = classify(args.action)
+        except ValueError as e:
+            print(f"error: {e}", file=sys.stderr); return 2
+    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/skills/notebooklm/scripts/custom_prompt_template_generator.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""custom_prompt_template_generator.py — Studio output type + audience → custom prompt starter.
+
+Stdlib-only. Generates a starter custom prompt for NotebookLM Studio outputs
+based on output type + audience + length + angle. Default prompts produce
+mediocre output; this generator produces a sharper starter the user can refine.
+
+Output types: audio_overview, study_guide, briefing_doc, timeline, faq,
+table_of_contents, infographic, slides, mind_map.
+
+NO LLM CALLS. Template-based prompt construction.
+
+Usage:
+    python custom_prompt_template_generator.py --output-type audio_overview --audience executive --length 8min
+    python custom_prompt_template_generator.py --output-type infographic --audience consumer --angle decision-tree
+    python custom_prompt_template_generator.py --sample
+"""
+
+import argparse
+import json
+import sys
+from typing import Any, Dict, List, Optional
+
+
+VALID_OUTPUT_TYPES = [
+    "audio_overview", "study_guide", "briefing_doc", "timeline", "faq",
+    "table_of_contents", "infographic", "slides", "mind_map",
+]
+
+VALID_AUDIENCES = [
+    "executive", "technical_lead", "undergraduate", "graduate",
+    "consumer", "internal_team", "investor", "general_public",
+]
+
+VALID_ANGLES = {
+    "audio_overview": ["business_implications", "technical_mechanism", "historical_evolution", "practical_applications"],
+    "infographic": ["decision_tree", "process_flow", "comparison", "storytelling"],
+    "study_guide": ["definitions_first", "problem_solving", "case_study", "review_focused"],
+    "briefing_doc": ["neutral_analytical", "persuasive", "cautionary"],
+    "slides": ["narrative", "data_driven", "framework", "case_study"],
+    "timeline": ["chronological", "reverse_chronological", "era_grouped"],
+    "faq": ["onboarding", "objection_handling", "deep_dive", "troubleshooting"],
+    "mind_map": ["hierarchical", "interconnected", "priority_marked"],
+    "table_of_contents": ["sequential", "thematic", "audience_guided"],
+}
+
+
+def generate_audio_overview(audience: str, length: str, angle: str) -> str:
+    audience_descriptions = {
+        "executive": "non-technical executive making a budget or strategic decision",
+        "technical_lead": "senior technical lead evaluating an implementation approach",
+        "undergraduate": "undergraduate student new to the subject",
+        "graduate": "graduate student doing literature review",
+        "consumer": "interested general public, no specialized background",
+        "internal_team": "internal team member needing context to do their work",
+        "investor": "investor evaluating a thesis or opportunity",
+        "general_public": "intelligent general public reader",
+    }
+    angle_focuses = {
+        "business_implications": "business implications, ROI, market dynamics — NOT technical depth",
+        "technical_mechanism": "how the mechanism works under the hood, with concrete technical detail",
+        "historical_evolution": "how the field got to its current state — inflection points, paradigm shifts",
+        "practical_applications": "how this gets used in practice, with concrete examples per major point",
+    }
+    aud = audience_descriptions.get(audience, audience)
+    foc = angle_focuses.get(angle, angle)
+    return (
+        f"Two-host conversation between a researcher and an experienced practitioner. "
+        f"Audience: {aud}. Length: {length}. Focus: {foc}. "
+        "Include one concrete example per major point. Acknowledge counter-arguments briefly. "
+        "End with one specific takeaway, not a generic summary."
+    )
+
+
+def generate_infographic(audience: str, length: str, angle: str) -> str:
+    angle_structures = {
+        "decision_tree": "Decision-tree style. Action-oriented (each panel ends with a decision/action). Branches lead to next panel.",
+        "process_flow": "Linear process flow. Panels are sequential steps. Each panel: step name + one-sentence what-happens + visual cue.",
+        "comparison": "Side-by-side comparison. 3-4 alternatives compared on 4-6 dimensions. Color-coded per alternative.",
+        "storytelling": "Narrative arc. Panels tell a story: situation → complication → resolution → takeaway.",
+    }
+    structure = angle_structures.get(angle, angle_structures["decision_tree"])
+    panel_count = "4-6 panels max" if length == "compact" else "6-8 panels"
+    return (
+        f"{structure} {panel_count}. "
+        f"Audience: {audience}. Monochrome navy with one accent color (amber highlight on key info). "
+        "Each panel: title (4-6 words), 1-2 sentence body, action/decision/next-step line. "
+        "No filler panels. Last panel: specific call-to-action with concrete next step (URL/contact/resource)."
+    )
+
+
+def generate_study_guide(audience: str, length: str, angle: str) -> str:
+    jargon_rule = (
+        "Define every technical term. Assume zero specialized background."
+        if audience in ("undergraduate", "general_public", "consumer")
+        else "Assume technical fluency in the field. Brief context for novel concepts only."
+        if audience in ("graduate", "technical_lead")
+        else "Calibrate jargon to audience expertise."
+    )
+    concept_count = "4-6 core concepts" if length == "compact" else "6-10 core concepts"
+    return (
+        f"Audience: {audience}. {jargon_rule} "
+        f"Structure: {concept_count}, each with 4 elements: "
+        "(1) one-paragraph definition, "
+        "(2) why this matters in practice (concrete example), "
+        "(3) one worked problem or applied scenario, "
+        "(4) 3 practice questions Bloom-higher-order (apply / analyze / evaluate; NO recall questions). "
+        "Discussion questions tied to a specific learning outcome listed at the start of each section."
+    )
+
+
+def generate_slides(audience: str, length: str, angle: str) -> str:
+    slide_count = "8-10 slides" if length == "compact" else "12-15 slides"
+    return (
+        f"{slide_count} max. Audience: {audience}. 1-2 sentences per slide body — "
+        "NO bullet points in slide bodies (prose only). "
+        "Per slide: include presenter notes with "
+        "(a) one concrete example, "
+        "(b) one likely audience objection, "
+        "(c) how to address it. "
+        "Title slide + content slides + closing call-to-action slide. "
+        "Closing slide: specific next step (not generic 'thank you')."
+    )
+
+
+def generate_briefing_doc(audience: str, length: str, angle: str) -> str:
+    tone_descriptions = {
+        "neutral_analytical": "Neutral analytical tone. Present evidence, let it speak.",
+        "persuasive": "Persuasive tone with explicit recommendation backed by evidence.",
+        "cautionary": "Cautionary tone, surface risks and trade-offs prominently.",
+    }
+    tone = tone_descriptions.get(angle, tone_descriptions["neutral_analytical"])
+    length_pages = "1 page" if length == "compact" else "2-3 pages" if length == "standard" else "5 pages"
+    return (
+        f"Audience: {audience}. Length: {length_pages}. {tone} "
+        "Structure: "
+        "(1) BLUF (bottom line up front, 2 sentences max), "
+        "(2) Key findings (3-5 numbered), "
+        "(3) Decisions needed from this audience (numbered, with options + recommendation), "
+        "(4) Open questions (3 max), "
+        "(5) Suggested next step (1 specific action)."
+    )
+
+
+def generate_timeline(audience: str, length: str, angle: str) -> str:
+    milestone_count = "5-8 milestones" if length == "compact" else "8-12 milestones"
+    direction = "Reverse-chronological (most recent first)" if angle == "reverse_chronological" else "Chronological (earliest first)"
+    return (
+        f"Milestone-focused (not event-dump). {milestone_count} max. "
+        "Per milestone: date, milestone (one phrase), significance (one sentence — why this changed the field). "
+        f"Order: {direction}. "
+        "Group into 3-4 eras with era-level summary at each boundary. "
+        "Exclude minor events that don't shift the trajectory."
+    )
+
+
+def generate_faq(audience: str, length: str, angle: str) -> str:
+    question_count = "6-10 questions" if length == "compact" else "10-15 questions"
+    return (
+        f"Audience: {audience}. {question_count}. "
+        "Each answer: 2-3 sentences max. "
+        "Question phrasing: how the audience would actually ask it (not how the topic owner would write it). "
+        "Group into 3 categories. "
+        "Include 2-3 'difficult question' entries (objections / concerns) — handle them directly, not evasively."
+    )
+
+
+def generate_mind_map(audience: str, length: str, angle: str) -> str:
+    return (
+        f"Audience: {audience}. Central concept clearly named. "
+        "3-5 primary branches (the major dimensions). Each branch: 2-4 sub-branches. "
+        "Max depth: 3 levels (central → branch → sub-branch). "
+        "Use noun phrases for branches (not full sentences). "
+        "Mark 2-3 sub-branches as 'critical' (the highest-leverage points). "
+        "Skip details that don't connect back to a critical sub-branch."
+    )
+
+
+def generate_table_of_contents(audience: str, length: str, angle: str) -> str:
+    section_count = "6-10 sections" if length == "compact" else "10-15 sections"
+    return (
+        f"{section_count}. Each entry: section number + section title + 1-sentence summary of what the section covers. "
+        f"Audience: {audience}. "
+        "Group into 2-3 parts with part-level summary at each boundary. "
+        "Mark 2-3 sections as 'start here' for newcomers."
+    )
+
+
+GENERATORS = {
+    "audio_overview": generate_audio_overview,
+    "infographic": generate_infographic,
+    "study_guide": generate_study_guide,
+    "slides": generate_slides,
+    "briefing_doc": generate_briefing_doc,
+    "timeline": generate_timeline,
+    "faq": generate_faq,
+    "mind_map": generate_mind_map,
+    "table_of_contents": generate_table_of_contents,
+}
+
+
+def generate(output_type: str, audience: str, length: str, angle: Optional[str] = None) -> Dict[str, Any]:
+    if output_type not in VALID_OUTPUT_TYPES:
+        raise ValueError(f"Invalid output_type '{output_type}'. Pick from: {VALID_OUTPUT_TYPES}")
+    if audience not in VALID_AUDIENCES:
+        raise ValueError(f"Invalid audience '{audience}'. Pick from: {VALID_AUDIENCES}")
+
+    valid_angles = VALID_ANGLES.get(output_type, [])
+    if angle and angle not in valid_angles:
+        raise ValueError(f"Invalid angle '{angle}' for output_type '{output_type}'. Pick from: {valid_angles}")
+    if not angle and valid_angles:
+        angle = valid_angles[0]  # default to first
+
+    generator_fn = GENERATORS[output_type]
+    prompt = generator_fn(audience, length, angle or "")
+
+    return {
+        "output_type": output_type,
+        "audience": audience,
+        "length": length,
+        "angle": angle,
+        "custom_prompt": prompt,
+        "instructions": "Use this as STARTER text in the NotebookLM customization menu (chevron next to Studio output button, NOT main button). Refine the prompt further based on the specific notebook contents and user's intent.",
+    }
+
+
+def render_human(result: Dict[str, Any]) -> str:
+    out: List[str] = []
+    out.append(f"Output type:  {result['output_type']}")
+    out.append(f"Audience:     {result['audience']}")
+    out.append(f"Length:       {result['length']}")
+    out.append(f"Angle:        {result['angle'] or '(default)'}")
+    out.append("")
+    out.append("Custom prompt (paste into NotebookLM customization menu):")
+    out.append("")
+    out.append(result['custom_prompt'])
+    out.append("")
+    out.append(f"📝 {result['instructions']}")
+    return "\n".join(out)
+
+
+def main(argv: List[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--output-type", choices=VALID_OUTPUT_TYPES)
+    parser.add_argument("--audience", choices=VALID_AUDIENCES)
+    parser.add_argument("--length", default="standard", choices=["compact", "standard", "deep"])
+    parser.add_argument("--angle")
+    parser.add_argument("--sample", action="store_true")
+    parser.add_argument("--output", choices=["human", "json"], default="human")
+    args = parser.parse_args(argv)
+
+    if args.sample:
+        result = generate("audio_overview", "executive", "compact", "business_implications")
+    elif args.output_type and args.audience:
+        try:
+            result = generate(args.output_type, args.audience, args.length, args.angle)
+        except ValueError as e:
+            print(f"error: {e}", file=sys.stderr); return 2
+    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/patent/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "patent",
+  "description": "Patent prior-art and landscape intelligence skill \u2014 not generic patent help. Commits to one of five sub-use-cases via forcing intake (novelty search / freedom-to-operate / competitive landscape / acquisition diligence / litigation prior-art) before any search runs. Searches Google Patents, Espacenet, USPTO, and optionally Lens.org for citation-graph signals. Output is an editable Word document (.docx) with verdict, ranked closest art (claim-text extracted), CPC-class-aware landscape, family-resolved hits, geographic coverage, FTO flags where applicable, strategy recommendations, and full audit log. Triggers: 'prior art search for [invention]', 'patent search on [topic]', 'freedom to operate analysis', 'FTO for [product]', 'patent landscape for [field]', 'is [invention] novel', 'patents on [topic]', 'competitive patent analysis', 'prior art for litigation', 'patent diligence on [company]'. Produces search signal, not legal advice \u2014 always recommends consulting a patent attorney before filing or licensing decisions. Trademark, copyright, and trade-secret questions are out of scope.",
+  "version": "2.9.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/research/patent",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills/patent"
+  ],
+  "source": {
+    "spec": "megaprompts/11-patent-megaprompt.md",
+    "build_pattern": "Path B (direct conversion). Research-pack shape, sub-use-case-routing variant. 5 sub-use-cases (novelty/FTO/landscape/diligence/litigation) drive entire search strategy + DOCX emphasis. Multi-source: Google Patents + Espacenet + USPTO + optional Lens.org BYOK.",
+    "sibling_of": "research/litreview, research/grants, research/dossier, research/pulse"
+  }
+}

package/research/patent/README.md

@@ -0,0 +1,61 @@
+# patent
+
+Patent prior-art and landscape intelligence skill. Refuses to be "generic patent help" — every invocation commits to **one of five sub-use-cases** before any search runs, and the chosen sub-use-case dictates the entire search strategy, ranking heuristics, and DOCX emphasis.
+
+## The 5 Sub-Use-Cases
+
+| Sub-use-case | Search strategy | DOCX emphasis |
+|---|---|---|
+| **Novelty search** (am I novel) | Narrow + claims-text focused | Closest art + claim-differentiation |
+| **Freedom-to-operate** (will I get sued) | Broad + active patents only; jurisdiction-filtered | FTO flags + claim-by-claim risk |
+| **Competitive landscape** (who plays here) | Breadth + filer tally + CPC trends | Filer map + investment hotspots |
+| **Acquisition diligence** (does target really own X) | Specific assignee + portfolio scope + assignment chain | Portfolio table + ownership verification |
+| **Litigation prior-art** (kill a specific patent) | Target patent + adjacent art before priority date | Knock-out candidates ranked by relevance |
+
+**Out of scope:** trademark, copyright, trade-secret. Flagged at intake.
+
+## Sibling skill relationship
+
+Part of the **research pack** (sibling of `pulse`, `litreview`, `grants`, `dossier`). Shares Agent Integrity Rules. Adds:
+
+- **Sub-use-case routing** as a non-skippable Q2 commitment (refuses generic "patent help")
+- **CPC/IPC class follow-up** queries (catches art keyword search misses)
+- **Family resolution** (deduplicates same-invention filings across jurisdictions)
+- **Date discipline** (filing vs priority vs publication vs grant — surfaces legally-relevant date per sub-use-case)
+- **Mandatory legal disclaimer** for novelty + FTO sub-use-cases
+
+## Source spec
+
+[`megaprompts/11-patent-megaprompt.md`](../../megaprompts/11-patent-megaprompt.md) (PR #657).
+
+## Plugin layout
+
+```
+research/patent/
+├── .claude-plugin/plugin.json
+├── README.md
+├── agents/cs-patent.md
+├── commands/cs-patent.md
+└── skills/patent/
+    ├── SKILL.md
+    ├── references/
+    │   ├── sub_use_case_routing.md         ← 5-sub-use-case canon (7+ sources)
+    │   ├── cpc_classification_canon.md     ← CPC/IPC class follow-up rationale (7+ sources)
+    │   └── legal_disclaimer_discipline.md  ← when + why mandatory (7+ sources)
+    └── scripts/
+        ├── citation_tracker.py             ← multi-source three-count (Google Patents + Espacenet + USPTO + Lens.org)
+        ├── family_resolver.py              ← deduplicates same-invention across jurisdictions
+        └── sub_use_case_router.py          ← deterministic search-strategy selection from intake answers
+```
+
+## Dependencies
+
+- **`web_fetch`** — Required (Google Patents, Espacenet, USPTO)
+- **`WebSearch`** — Required (academic prior art adjacent to patents)
+- **`bash_tool` + `curl`** — Required for Lens.org if BYOK key
+- **Node.js `docx` library** — Required
+- **Lens.org API key** — Optional, BYOK; enables citation-graph section
+
+## License
+
+MIT.

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

@@ -0,0 +1,76 @@
+---
+name: cs-patent
+description: Patent prior-art + landscape intelligence persona. Walks 6 forcing intake questions with mandatory sub-use-case commitment (novelty / FTO / landscape / diligence / litigation). Refuses to start without a sub-use-case picked. Refuses generic "patent help" requests. Searches Google Patents + Espacenet + USPTO + optional Lens.org sequentially at 1 q/sec. Always includes legal disclaimer for novelty + FTO sub-use-cases (signal, not legal advice). Family-resolves duplicates across jurisdictions. Outputs 8-section .docx with verdict + audit log.
+skills: research/patent/skills/patent
+domain: research
+model: opus
+tools: [Read, Write, Bash, WebFetch, WebSearch]
+---
+
+# Patent Agent
+
+## Voice
+
+**Opening:** "Drop the invention — 2-3 sentences specific. I'll grill you on sub-use-case (novelty / FTO / landscape / diligence / litigation), jurisdictions, known prior art, risk tolerance, attorney status. **I refuse to run a generic 'patent search'** — pick one sub-use-case so I know which strategy to deploy."
+
+**Refusing vague Q1:** "AI for healthcare" → "What does it DO that existing systems don't? Be specific about the technical mechanism."
+
+**Refusing Q2 evasion:** "All of them" → "Pick the primary one. Secondary sub-use-cases can run as follow-up searches. Each sub-use-case uses a fundamentally different search strategy."
+
+**Mandatory legal disclaimer (novelty + FTO):**
+> "This skill produces search signal, not legal advice. Verdict is technical assessment only. **Consult a patent attorney before filing or licensing decisions.** Disclaimer footer included in DOCX."
+
+**Closing (with sub-use-case-specific verdict):**
+> "Saved: <path>/patent_<invention>_<sub-use-case>_<date>.docx. **Verdict: NOVEL / POTENTIALLY NOVEL / NOT NOVEL** (or CLEAR/FLAGGED/HIGH RISK for FTO). Audit: 8 queries × 47 results / 12 cited. Closest art: 3 hits with claim-text extracted. Reminder: consult patent attorney before any filing/licensing."
+
+## Purpose
+
+The cs-patent agent orchestrates the `patent` skill across prior-art + landscape research:
+
+1. **Phase 1 intake** — Q1-Q6 one at a time, with sub-use-case commitment at Q2
+2. **Phase 2 search strategy selection** — deterministic via `scripts/sub_use_case_router.py`
+3. **Phase 3 multi-source search** — Google Patents (workhorse) + Espacenet + USPTO + optional Lens.org
+4. **Phase 4 claim extraction + relevance scoring** — pull independent claim 1 + key dependents
+5. **Phase 5 citation graph + family resolution** — deduplicate via `scripts/family_resolver.py`
+6. **Phase 6 DOCX** — 8 sections with sub-use-case-specific emphasis
+7. **Phase 7 deliver** — file + chat summary with verdict
+
+**Hard rules:**
+
+1. **One intake Q per turn.** Never bundle.
+2. **Refuse vague Q1** (invention description). One push-back.
+3. **Refuse Q2 evasion** ("all of them"). Force a primary sub-use-case.
+4. **Sequential search at 1 q/sec.** Multi-source but never parallel.
+5. **CPC class follow-up after initial keyword pass.** Catches keyword-missed art.
+6. **Family resolution.** Same-invention duplicates across jurisdictions reported once.
+7. **Date discipline.** Distinguish filing / priority / publication / grant; surface legally-relevant per sub-use-case.
+8. **Mandatory legal disclaimer** for novelty + FTO.
+9. **Out-of-scope flagging.** Trademark / copyright / trade-secret get flagged at intake, not silently included.
+
+## Skill Integration
+
+**Skill Location:** `../skills/patent/`
+
+### Python Tools (Stdlib)
+
+1. **Citation Tracker** — `scripts/citation_tracker.py` — three-count audit across Google Patents + Espacenet + USPTO + Lens.org sources at `~/.patent_sessions/<session>.json`
+2. **Family Resolver** — `scripts/family_resolver.py` — group same-invention filings (e.g., US + EP + JP + CN of one priority) by priority number / family ID
+3. **Sub-Use-Case Router** — `scripts/sub_use_case_router.py` — deterministic search strategy from intake answers
+
+### Knowledge Bases
+
+- `references/sub_use_case_routing.md` — 5-sub-use-case canon + when each applies (7+ sources)
+- `references/cpc_classification_canon.md` — CPC/IPC class follow-up rationale (7+ sources)
+- `references/legal_disclaimer_discipline.md` — when + why disclaimer mandatory (7+ sources)
+
+## Related Agents
+
+- [cs-litreview](../../litreview/agents/cs-litreview.md) — sibling, academic literature
+- [cs-grants](../../grants/agents/cs-grants.md) — sibling, NIH funding
+- [cs-dossier](../../dossier/agents/cs-dossier.md) — sibling, hypothesis-tested entity research
+- Future: cs-syllabus (course readings)
+
+---
+
+**Version:** 1.0.0
+**Source:** Path-B direct conversion of `megaprompts/11-patent-megaprompt.md`