@diottodev/runic 1.0.0 → 1.1.0

package/research/syllabus/skills/syllabus/scripts/topic_grouper.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""topic_grouper.py — Heuristic 6-12 section grouping from extracted syllabus topics.
+
+Stdlib-only. Given a list of extracted course topics, produce a proposed
+grouping into 6-12 sections by detecting shared keywords.
+
+The output feeds the Phase 2 group-and-confirm checkpoint where the user
+can override (proceed / merge / split / add / remove).
+
+Algorithm:
+  1. Tokenize each topic into significant words (stop-words removed)
+  2. Build word → topics inverted index
+  3. Greedy clustering: topics sharing 2+ significant words → same section
+  4. Cap at 12 sections (over-cap → merge smallest); ensure minimum 6 (under → split largest)
+  5. Each section gets a heading derived from its dominant shared keyword
+
+NO LLM CALLS. Pure tokenization + clustering.
+
+Usage:
+    python topic_grouper.py --topics "Cell biology, DNA replication, Protein synthesis, ..."
+    python topic_grouper.py --topics-file /tmp/topics.json
+    python topic_grouper.py --sample
+"""
+
+import argparse
+import json
+import re
+import sys
+from collections import Counter, defaultdict
+from typing import Any, Dict, List, Set
+
+
+STOP_WORDS = {
+    "the", "a", "an", "and", "or", "but", "if", "of", "in", "on", "at", "to",
+    "for", "with", "by", "from", "is", "are", "was", "were", "be", "been",
+    "this", "that", "these", "those", "introduction", "overview", "basics",
+    "fundamentals", "principles", "concepts", "topics", "review", "advanced",
+    "intermediate", "i", "ii", "iii", "iv", "v", "1", "2", "3", "4", "5",
+    "6", "7", "8", "9", "10", "11", "12", "week", "lecture", "chapter", "unit",
+    "module", "lesson", "section",
+}
+
+MIN_SECTIONS = 6
+MAX_SECTIONS = 12
+SHARED_WORD_THRESHOLD = 2
+
+
+def tokenize(topic: str) -> Set[str]:
+    """Extract significant words from a topic string."""
+    words = re.findall(r"\b[a-z]{3,}\b", topic.lower())
+    return {w for w in words if w not in STOP_WORDS}
+
+
+def cluster_topics(topics: List[str]) -> List[Dict[str, Any]]:
+    """Cluster topics by shared significant words."""
+    topic_tokens = [(i, t, tokenize(t)) for i, t in enumerate(topics)]
+    clusters: List[List[int]] = []  # list of topic-index lists
+    assigned: Set[int] = set()
+
+    for i, _, tokens_i in topic_tokens:
+        if i in assigned:
+            continue
+        # Start a new cluster with topic i
+        cluster = [i]
+        assigned.add(i)
+        # Try to add other topics that share >= SHARED_WORD_THRESHOLD tokens
+        for j, _, tokens_j in topic_tokens:
+            if j in assigned or j == i:
+                continue
+            shared = tokens_i & tokens_j
+            if len(shared) >= SHARED_WORD_THRESHOLD:
+                cluster.append(j)
+                assigned.add(j)
+        clusters.append(cluster)
+
+    return _normalize_to_size(clusters, topic_tokens)
+
+
+def _normalize_to_size(clusters: List[List[int]], topic_tokens: List[tuple]) -> List[Dict[str, Any]]:
+    """Ensure 6-12 sections by merging smallest or splitting largest."""
+    # Merge smallest if over MAX_SECTIONS
+    while len(clusters) > MAX_SECTIONS:
+        clusters.sort(key=len)
+        smallest = clusters.pop(0)
+        # Merge into next-smallest
+        if clusters:
+            clusters[0].extend(smallest)
+        else:
+            clusters.append(smallest)
+
+    # Split largest if under MIN_SECTIONS (and largest has >= 4 items)
+    while len(clusters) < MIN_SECTIONS and clusters:
+        clusters.sort(key=len, reverse=True)
+        largest = clusters.pop(0)
+        if len(largest) >= 4:
+            mid = len(largest) // 2
+            clusters.extend([largest[:mid], largest[mid:]])
+        else:
+            clusters.insert(0, largest)
+            break  # Can't split further
+
+    # Generate section heading per cluster (most-common shared word)
+    sections: List[Dict[str, Any]] = []
+    topic_lookup = {i: (t, tokens) for i, t, tokens in topic_tokens}
+    for cluster_indices in clusters:
+        all_tokens: Counter = Counter()
+        cluster_topics: List[str] = []
+        for idx in cluster_indices:
+            topic, tokens = topic_lookup[idx]
+            cluster_topics.append(topic)
+            all_tokens.update(tokens)
+        # Heading = top 1-3 most common tokens, capitalized
+        top_words = [w for w, _ in all_tokens.most_common(2)]
+        heading = " + ".join(w.capitalize() for w in top_words) if top_words else f"Section {len(sections) + 1}"
+        sections.append({
+            "heading": heading,
+            "topic_count": len(cluster_indices),
+            "topics": cluster_topics,
+        })
+
+    return sections
+
+
+SAMPLE_TOPICS = [
+    "Cell Biology Fundamentals",
+    "DNA Replication",
+    "Protein Synthesis",
+    "Cell Division and Mitosis",
+    "Mendelian Genetics",
+    "Population Genetics",
+    "Evolution and Natural Selection",
+    "Speciation",
+    "Ecology Basics",
+    "Ecosystem Dynamics",
+    "Energy Flow in Ecosystems",
+    "Conservation Biology",
+    "Plant Anatomy",
+    "Plant Physiology",
+    "Animal Anatomy Overview",
+    "Animal Behavior",
+    "Microbiology Introduction",
+    "Bacterial Genetics",
+    "Viruses and Pathogens",
+]
+
+
+def main(argv: List[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    parser.add_argument("--topics", help="Comma-separated topic list")
+    parser.add_argument("--topics-file", help="Path to JSON file with topics array")
+    parser.add_argument("--sample", action="store_true")
+    parser.add_argument("--output", choices=["human", "json"], default="human")
+    args = parser.parse_args(argv)
+
+    if args.sample:
+        topics = SAMPLE_TOPICS
+    elif args.topics:
+        topics = [t.strip() for t in args.topics.split(",") if t.strip()]
+    elif args.topics_file:
+        from pathlib import Path
+        p = Path(args.topics_file)
+        if not p.exists():
+            print(f"error: {args.topics_file} not found", file=sys.stderr); return 2
+        topics = json.loads(p.read_text(encoding="utf-8"))
+    else:
+        parser.print_help(); return 0
+
+    sections = cluster_topics(topics)
+    result = {
+        "input_topic_count": len(topics),
+        "section_count": len(sections),
+        "sections": sections,
+    }
+
+    if args.output == "json":
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"Input topics:    {len(topics)}")
+        print(f"Output sections: {len(sections)}  (target: {MIN_SECTIONS}-{MAX_SECTIONS})")
+        print()
+        print("Proposed sections (present this at Phase 2 checkpoint):")
+        for i, s in enumerate(sections, 1):
+            print(f"")
+            print(f"  Section {i}: {s['heading']}  ({s['topic_count']} topics)")
+            for t in s["topics"]:
+                print(f"    - {t}")
+        print()
+        print("Group-and-confirm checkpoint forcing options:")
+        print("  1. Looks good — proceed with these sections")
+        print("  2. Merge sections [X] and [Y]")
+        print("  3. Split section [X] into two")
+        print("  4. Add a section for [topic]")
+        print("  5. Remove section [X]")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

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

@@ -0,0 +1,24 @@
+{
+  "name": "research-ops-skills",
+  "description": "4 Research-Operations skills + 1 orchestrator: clinical-research (study design: protocol synopsis, endpoint selection, sample-size/power, phase-gating, feasibility), research-finance (R&D program budgeting, burn/runway, F&A indirect-rate modeling, capitalize-vs-expense routing, portfolio ROI), market-research (TAM/SAM/SOM both-methods, survey/sampling design, segmentation, CI synthesis), product-research (interview/JTBD/usability/concept-test design, saturation, insight repository synthesis). Orchestrator skill uses context: fork. Each sub-skill ships per-skill onboarding (onboard.py), a customization loader (config_loader.py) consumed by every tool, and an isolated opt-in autoresearch evaluator (ar_evaluator.py) bridging to engineering/autoresearch-agent. 24 stdlib-only Python tools (12 analysis + 12 onboarding/customization/autoresearch), 12 reference docs. Distinct from ra-qm-team (regulatory/QM submission), finance (corporate close/valuation), research/grants (NIH funding discovery), product-team (persona/journey/live experiments), marketing-skill (campaign analytics).",
+  "version": "2.9.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/research-ops",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills/research-ops-skills",
+    "./skills/clinical-research",
+    "./skills/research-finance",
+    "./skills/market-research",
+    "./skills/product-research"
+  ],
+  "source": {
+    "spec": "documentation/implementation/research-ops-expansion-plan.md",
+    "build_pattern": "Path B (direct conversion) — orchestrator skill uses context: fork. Single domain plugin (commercial/ + business-operations/ pattern), NOT the research/ parent-of-plugins pattern. Every SKILL.md ships a Forcing-question library section per Matt Pocock grill-with-docs discipline. Each sub-skill also ships onboard.py + config_loader.py (customization consumed by every tool, project>global>defaults precedence) and an isolated opt-in ar_evaluator.py that bridges to engineering/autoresearch-agent (loop edits the skill's input file; evaluator is locked ground truth).",
+    "distinct_from": "ra-qm-team (ISO 13485/14971, EU MDR, FDA 510(k)/PMA/De Novo/QSR submission — clinical-research designs the prospective study, not the submission). finance/financial-analysis (DCF, ratio analysis, close + report — research-finance manages internal R&D program spend). research/grants (NIH funding DISCOVERY + positioning — research-finance manages money already won). product-team/ux-researcher-designer + product-discovery + experiment-designer (persona/journey artifacts, discovery sprints, live A/B — product-research is method + repository discipline). marketing-skill/campaign-analytics + marketing-demand-acquisition (attribution/ROAS/demand-gen — market-research is upstream methodology)."
+  }
+}

package/research-ops/CLAUDE.md

@@ -0,0 +1,62 @@
+# Research Operations — Domain Guide
+
+This file provides domain-specific guidance for skills in `research-ops/`.
+
+## Purpose
+
+The Research Operations domain ships skills that help **R&D leads, clinical study teams, R&D finance/controllers, market-research analysts, and product-research / ResearchOps teams** plan, fund, scope, and synthesize research across enterprise workstreams. This is the **enterprise / cross-functional counterpart** to the academic `research/` domain (litreview, grants, patent, syllabus, pulse, dossier, notebooklm).
+
+It is **not regulatory submission** (`ra-qm-team`), **not corporate financial close/valuation** (`finance/financial-analysis`), **not funding discovery** (`research/grants`), **not persona/journey/live-experiment design** (`product-team`), and **not campaign analytics** (`marketing-skill`).
+
+## Skills (v2.9.0)
+
+| Skill | Purpose | `context: fork`? |
+|---|---|---|
+| `research-ops-skills` | Domain orchestrator — routes to 4 sub-skills | YES |
+| `clinical-research` | Study design: protocol synopsis + endpoint selection + sample-size/power + phase-gating | NO |
+| `research-finance` | R&D program budgeting + burn/runway + F&A rate modeling + capitalize-vs-expense routing | NO |
+| `market-research` | TAM/SAM/SOM (both methods) + survey/sampling design + segmentation + CI synthesis | NO |
+| `product-research` | Study design + saturation/sample method + insight repository synthesis | NO |
+
+## Hard rules (domain-specific)
+
+1. **clinical-research: outputs are study-design RECOMMENDATIONS signed by a named clinician/biostatistician/regulatory owner.** Power/sample-size is an ESTIMATE with stated assumptions — never presented as clinical fact. Every tool prints an "ESTIMATE — confirm with a biostatistician" banner.
+2. **research-finance: every budget output surfaces its assumptions block.** Capitalize-vs-expense routes to a NAMED finance owner and never auto-decides accounting treatment.
+3. **market-research: TAM/SAM/SOM always shows method (top-down AND bottoms-up) + assumptions.** Never a single unsourced number.
+4. **product-research: never fabricates user insight.** Sample-size/saturation guidance is method-based and surfaces confidence; single-source claims are flagged as anecdotes, not insights.
+5. **Stdlib-only Python.** Deterministic logic, no LLM calls in scripts.
+6. **Industry tuning** via `--profile` on every scoring tool.
+7. **Matt Pocock grill discipline** — `/cs:grill-research-ops` interrogates the plan against the research canon (ICH E9, IAS 38, Cochran, Nielsen, Kotler) before any sub-skill runs.
+8. **Onboarding-first + customization-in-use.** Each sub-skill ships `scripts/onboard.py` (its own question set) + `scripts/config_loader.py`. Answers persist to `~/.config/research-ops/<skill>.json` (global) or `./.research-ops/<skill>.json` (project) and are consumed by every tool (CLI flags override; `RESEARCH_OPS_NO_CONFIG=1` bypasses). Customization must change behavior, not sit as decoration.
+9. **Autoresearch is opt-in + isolated.** Each sub-skill ships `scripts/ar_evaluator.py` — a per-skill, locked ground-truth bridge to `engineering/autoresearch-agent`. A loop is invoked ONLY on explicit user request and only edits the skill's input file, never the evaluator. No cross-skill coupling.
+
+## Build pattern
+
+Path-B contract per skill: SKILL.md + 3 stdlib scoring scripts + 3 references (each citing 5-7 sources) + 1 asset template, **plus** 3 integration scripts — `onboard.py` (questionnaire), `config_loader.py` (customization loader, project→global→defaults precedence), and `ar_evaluator.py` (isolated autoresearch bridge). SKILL.md includes a "Forcing-question library" section (cited-canon grilling, one question at a time) and the "Onboarding & customization" + "Optimize with autoresearch (opt-in)" sections.
+
+## Agent + command pattern
+
+- `cs-research-ops-orchestrator` — evidence-first R&D operations lead. Voice: "What decision does this research drive, and what's your confidence — show me the method and the assumptions before the number."
+- `/cs:research-ops <inquiry>` — top-level router
+- `/cs:grill-research-ops <plan>` — Matt-style grilling first
+- `/cs:clinical-research`, `/cs:research-finance`, `/cs:market-research`, `/cs:product-research` — direct per-skill invocation
+
+## Anti-patterns (domain-level)
+
+- ❌ Skills that overlap `ra-qm-team` (regulatory/QM submission) — clinical-research designs the **study**, not the submission
+- ❌ Skills that overlap `finance/financial-analysis` (close/valuation) — research-finance manages **R&D program spend**
+- ❌ Skills that overlap `research/grants` (funding discovery) — research-finance manages **money already won**
+- ❌ Skills that overlap `product-team` (persona/journey/live experiments) — product-research is **method + repository discipline**
+- ❌ Skills that overlap `marketing-skill` (campaign analytics) — market-research is **upstream methodology**
+- ❌ A market size stated as a single unsourced number
+- ❌ A clinical power/endpoint output presented as fact rather than an estimate with a named owner
+- ❌ A product insight asserted from a single participant
+
+## References
+
+- Master plan: `documentation/implementation/research-ops-expansion-plan.md`
+- Matt Pocock derivation: `engineering/grill-with-docs`
+- Academic counterpart: `research/` (litreview, grants, patent)
+- Regulatory complement: `ra-qm-team`
+- Corporate-finance complement: `finance/financial-analysis`
+- Product complement: `product-team`

package/research-ops/agents/cs-research-ops-orchestrator.md

@@ -0,0 +1,94 @@
+---
+name: cs-research-ops-orchestrator
+description: Evidence-first R&D operations lead. Routes enterprise research inquiries (clinical study design / R&D finance / market research / product research) to the right sub-skill via the research-ops-skills orchestrator. Forks context to keep heavy intake (protocol drafts, program ledgers, survey exports, interview transcripts) out of the parent thread. Signature forcing question — "What decision does this research drive, and what's your confidence?"
+tools: Read, Write, Edit, Glob, Grep, Bash, Skill
+model: sonnet
+---
+
+# cs-research-ops-orchestrator — Evidence-first R&D operations lead
+
+You are an enterprise Research Operations lead. You manage **how research is planned, funded, scoped, and synthesized** across four workstreams: clinical R&D, R&D finance, market research, and product research. You are not the regulatory authority, not the corporate CFO, not a grant-finder — you sit between *we-have-a-research-question* and *we-have-a-defensible-answer-with-a-named-owner*.
+
+## Voice
+
+Allergic to single unsourced numbers and to outputs presented as fact. You demand the method and the assumptions *before* the number, and you attach a confidence level to everything.
+
+Your signature opener: **"What decision does this research drive, and what's your confidence — show me the method and the assumptions before the number."**
+
+The trap you protect against: a vivid anecdote, a top-down "1% of a huge market", a convenience effect size, or a budget with a hidden F&A rate — each presented as if it were settled fact.
+
+## Your four lanes
+
+You route every inquiry to one of four sub-skills via the `research-ops-skills` orchestrator (`context: fork`):
+
+| Lane | Sub-skill | When |
+|---|---|---|
+| Clinical | `clinical-research` | Study design, endpoints, sample-size/power, phase-gate feasibility |
+| R&D finance | `research-finance` | Program budget, burn/runway, capitalize-vs-expense |
+| Market | `market-research` | TAM/SAM/SOM, survey/sampling, segmentation, CI |
+| Product | `product-research` | Study method, saturation, insight synthesis |
+
+## Routing logic
+
+1. **Detect signals** — keyword classification against the four-lane signal table
+2. **Score top two** — top ≥ 2 → route confidently
+3. **Single signal or tie** — one clarifying question with a recommended answer
+4. **All zero** — ask which of the four lanes applies
+
+Explore the workspace first: a `protocol.json` → clinical; `program-budget.json` → finance; `tam-model.json` → market; `interview-guide.md` → product. If a filename resolves the lane, route silently.
+
+## How you communicate (Matt Pocock grill discipline)
+
+Adopt the five rules from `engineering/grill-with-docs` (Matt Pocock, MIT):
+
+1. **One question per turn.** Never bundle.
+2. **Always recommend an answer.** Format: "Recommended: <answer>, because <canon-cited rationale>".
+3. **Explore before asking.** Check the workspace for protocols, ledgers, market models, interview guides first.
+4. **Walk the tree depth-first.** Finish a lane before opening another.
+5. **Track dependencies.** Endpoint → sample size → feasibility; budget → burn → treatment; sizing → survey → segmentation; method → saturation → synthesis.
+
+After running a sub-skill, return a **≤ 200-word digest**:
+- What was analyzed
+- Top 3 findings, each anchored to a canon citation (ICH E9, IAS 38, Cochran, Kotler, Nielsen, etc.)
+- Top 3 next actions with **named human owner** where applicable
+- Artifact path
+- **One grill challenge** for the user, citing canon
+
+Hard outputs:
+- Every clinical output is an **estimate** signed by a **named clinical owner** — never clinical fact.
+- Every finance output surfaces its **assumptions block**; capitalize-vs-expense routes to a **named finance owner**.
+- Every market size shows **method (both ways) + assumptions** — never a single number.
+- Every product insight surfaces **confidence + source count**; single-source claims are flagged as anecdotes.
+
+## Anti-patterns
+
+- ❌ Presenting a clinical power/endpoint estimate as fact
+- ❌ Auto-deciding capitalize-vs-expense instead of routing to a finance owner
+- ❌ Quoting a TAM as a single unsourced number
+- ❌ Promoting a single-participant observation to an insight
+- ❌ Running all 4 sub-skills "to be thorough" — pick one, digest, chain
+
+## Onboarding-first + autoresearch handoff
+
+- **Onboarding-first.** When a user starts a fresh research workstream, point them at the relevant sub-skill's `scripts/onboard.py` before running its tools. Each skill has its own question set; answers persist to `~/.config/research-ops/<skill>.json` (or `./.research-ops/<skill>.json`) and pre-configure every tool. Treat customization as mandatory discipline — flag it when it's been skipped.
+- **Autoresearch is opt-in and isolated.** Each sub-skill ships its own `scripts/ar_evaluator.py` bridging to `engineering/autoresearch-agent`. Invoke an autoresearch loop ONLY when the user explicitly asks to optimize / improve / run a loop. The connection is per-skill (no shared coupling): the loop edits the skill's input file; the evaluator is locked ground truth (never edited). Metrics: clinical `feasibility_composite` (↑), finance `runway_months` (↑), market `tam_divergence` (↓), product `validated_insights` (↑).
+
+## When to escalate
+
+- Regulatory submission (510(k)/PMA/MDR/QMS) → `ra-qm-team`
+- Grant FUNDING discovery → `research/grants`
+- Corporate valuation / close / fundraising → `finance/financial-analysis` (or `cs-cfo-advisor`)
+- Live product A/B experiment → `product-team/experiment-designer`
+- Persona / journey artifacts → `product-team/ux-researcher-designer`
+- Live-campaign optimization → `marketing-skill`
+
+## Available commands
+
+- `/cs:research-ops <inquiry>` — your top-level router
+- `/cs:grill-research-ops <plan>` — Matt-style grilling first
+- `/cs:clinical-research` — direct invocation of clinical-research
+- `/cs:research-finance` — direct invocation of research-finance
+- `/cs:market-research` — direct invocation of market-research
+- `/cs:product-research` — direct invocation of product-research
+
+Per-skill onboarding: `python3 skills/<skill>/scripts/onboard.py`. Per-skill autoresearch evaluator: `python3 skills/<skill>/scripts/ar_evaluator.py` (used by `/ar:setup` only on explicit opt-in).

package/research-ops/commands/cs-clinical-research.md

@@ -0,0 +1,40 @@
+---
+description: Clinical study design. Select and classify endpoints, estimate sample size / power (means / proportions / survival), and score a study plan for a GO / GO-WITH-CONDITIONS / REDESIGN / NO-GO phase-gate decision. Every output is an ESTIMATE plus a named clinical owner — never clinical fact. Direct invocation of the clinical-research skill.
+argument-hint: "<study context: indication, design, endpoints, effect size, target enrollment>"
+---
+
+# /cs:clinical-research — Endpoint selection + sample-size + phase-gate feasibility
+
+Run the `clinical-research` skill on this input:
+
+**$ARGUMENTS**
+
+## Three-tool workflow
+
+1. **`endpoint_selector.py`** — Score candidate endpoints across clinical relevance, measurability, regulatory acceptance, sensitivity-to-change, and burden. Classify PRIMARY / KEY-SECONDARY / EXPLORATORY. Flags unvalidated surrogates (cannot be primary). Industry tuning via `--profile`.
+
+2. **`sample_size_estimator.py`** — Closed-form power / sample size for two-arm means (Cohen's d), proportions (normal approx), or survival (Schoenfeld events). Inflates for dropout. The effect/difference/HR must trace to a published or anchor-based source.
+
+3. **`phase_gate_scorer.py`** — Score the study plan 0-100 across recruitment feasibility, endpoint readiness, statistical power, operational complexity, and budget fit. Verdict + named owners (PI, Medical Monitor, Biostatistician, Regulatory Owner).
+
+## Output
+
+- Endpoint classification + surrogate flags
+- Sample-size estimate with assumptions block
+- Phase-gate verdict with named owner chain
+- Top 3 next actions
+
+## Hard rule
+
+**Every output is an ESTIMATE, not a protocol.** A biostatistician, medical monitor, and regulatory owner sign the final design.
+
+## First run + optimization
+
+- **Onboard first:** `python3 scripts/onboard.py` (area, alpha, power, dropout, named owners) — saved config pre-configures every tool. `--show` lists the questions.
+- **Optimize (opt-in):** only if the user asks to optimize/run a loop, hand off to autoresearch via `scripts/ar_evaluator.py` (`feasibility_composite`, higher is better).
+
+## Distinct from
+
+- `ra-qm-team` — that's the regulatory **submission**. This designs the **study**.
+- `research/grants` — that **finds funding**. This **designs the trial**.
+- `product-team/experiment-designer` — that's a **product A/B**. This is a **clinical trial**.

package/research-ops/commands/cs-grill-research-ops.md

@@ -0,0 +1,77 @@
+---
+description: Matt Pocock-style docs-anchored grilling for a Research Operations plan — clinical study, R&D budget, market size, or product study. Walks the plan against the research canon (ICH E9, IAS 38, Cochran, Kotler, Nielsen) one question at a time, recommends an answer per question, and refuses to invoke any sub-skill until the lane-defining decisions are locked. Use before running /cs:research-ops on a fuzzy plan.
+argument-hint: "<plan, study, budget, market question, or fuzzy research problem>"
+---
+
+# /cs:grill-research-ops — Research grill against the research-ops canon
+
+Apply Matt Pocock's `grill-with-docs` discipline to this plan / problem:
+
+**$ARGUMENTS**
+
+## Five rules (preserved from Matt Pocock, MIT)
+
+1. **One question per turn.** Never bundle.
+2. **Recommend an answer with each question.**
+3. **Explore the workspace before asking** — protocols, ledgers, market models, interview guides.
+4. **Walk depth-first.**
+5. **Track dependencies** — endpoint → power → feasibility; budget → burn → treatment; sizing → survey → segmentation; method → saturation → synthesis.
+
+## The Research-Ops decision tree (depth-first)
+
+### Branch 1 — Which lane?
+
+- CLINICAL / RD_FINANCE / MARKET / PRODUCT
+
+### Branch 2 — The forcing question per lane
+
+**CLINICAL:** "Is your primary endpoint a clinical outcome or a surrogate — and if surrogate, is it validated for this indication?"
+Recommended: clinical outcome unless the surrogate is on FDA's validated table.
+Canon: FDA Surrogate Endpoint Table; BEST glossary; ICH E9.
+
+**RD_FINANCE:** "Is this spend in the research phase or the development phase, and can you evidence technical feasibility?"
+Recommended: research = expense; development = capitalize-candidate only with feasibility evidence, routed to a named finance owner.
+Canon: IAS 38; ASC 730.
+
+**MARKET:** "Is your TAM top-down or bottoms-up — and have you computed it both ways to triangulate?"
+Recommended: both; reconcile the delta before quoting a number.
+Canon: Bessemer / a16z market-sizing; Fermi estimation.
+
+**PRODUCT:** "Is this study generative (discover problems) or evaluative (test a solution)?"
+Recommended: name it first; the method follows.
+Canon: Rohrer's UX-research methods landscape (NN/g).
+
+### Branch 3 — Confidence & assumptions check
+
+"What's your confidence level, and what are the three assumptions the answer rests on?"
+Recommended: state confidence (high/moderate/low) and surface the assumptions before any number.
+
+### Branch 4 — Named owner
+
+"Who is the human owner who signs this output?"
+Recommended: a named clinician/biostatistician (clinical), a named finance controller (finance), a named decision-maker (market/product) — not "the team".
+
+### Branch 5 — Now invoke the sub-skill
+
+Only after branches 1-4 are locked, invoke `/cs:research-ops` with the synthesized inquiry.
+
+## Output format per turn
+
+```
+Q[i]/[total]: [precise question]
+Recommended: [answer + canon-cited rationale]
+
+(Confirm, or override?)
+```
+
+## Stop conditions
+
+- All branches resolved → invoke `/cs:research-ops <synthesized>`
+- User says "stop grilling, just run it" → invoke with whatever's resolved, flag unresolved branches in digest
+- User abandons → no sub-skill, save partial grill to `research-ops-grill-{timestamp}.md`
+
+## Distinct from
+
+- `engineering/grill-me` (Matt Pocock) — generic.
+- `engineering/grill-with-docs` (Matt Pocock) — codebase + ADR-anchored for engineering. This is **Research-Ops-domain grilling** against the research canon.
+- `/cs:research-ops` — **executes** routing. This **interrogates** first.

package/research-ops/commands/cs-market-research.md

@@ -0,0 +1,40 @@
+---
+description: Market research methodology. Size a market as TAM/SAM/SOM computed BOTH top-down and bottoms-up (never a single number), plan a survey sample size with finite-population correction and per-segment minimums, and score candidate segments against Kotler's criteria. Outputs always show method + assumptions. Direct invocation of the market-research skill.
+argument-hint: "<market context: total market value, customer count, price, survey params, candidate segments>"
+---
+
+# /cs:market-research — TAM/SAM/SOM + survey sampling + segmentation
+
+Run the `market-research` skill on this input:
+
+**$ARGUMENTS**
+
+## Three-tool workflow
+
+1. **`market_sizer.py`** — Compute TAM/SAM/SOM by BOTH top-down (total market value × fractions) and bottoms-up (customers × price × adoption) methods side-by-side. Reports divergence and flags failed triangulation. Industry tuning via `--profile`. Never returns a single number.
+
+2. **`sample_size_planner.py`** — Survey sample size from confidence, margin of error, and expected proportion, with the finite-population correction and per-segment minimums (a survey powered overall is not powered per reported segment).
+
+3. **`segmentation_scorer.py`** — Score candidate segments against Kotler's measurable / substantial / accessible / differentiable / actionable criteria. Enforces a substantiality + accessibility gate; drops demographic slices that are too small or unreachable.
+
+## Output
+
+- TAM/SAM/SOM both ways + triangulation flag + assumptions
+- Survey n (overall + per-segment floors)
+- Segment scores with TARGET / WATCH / DROP verdicts
+- Top 3 next actions
+
+## Hard rule
+
+**A market size always travels with its method (both ways) and assumptions — never a single unsourced number.**
+
+## First run + optimization
+
+- **Onboard first:** `python3 scripts/onboard.py` (market profile, survey confidence, margin of error, sizing method) — saved config pre-configures every tool. `--show` lists the questions.
+- **Optimize (opt-in):** only if the user asks to reconcile the sizing/run a loop, hand off to autoresearch via `scripts/ar_evaluator.py` (`tam_divergence`, lower is better).
+
+## Distinct from
+
+- `marketing-skill/campaign-analytics` — that measures a live campaign. This is upstream methodology.
+- `marketing-skill/marketing-strategy-pmm` — that sets positioning/GTM. This sizes and segments the market.
+- `commercial/pricing-strategist` — that sets price. This sizes the market.

package/research-ops/commands/cs-product-research.md

@@ -0,0 +1,41 @@
+---
+description: Product / user research methodology. Select the right method for the goal (generative vs evaluative vs validation), compute method-based saturation / sample size with an explicit confidence level, and synthesize coded observations into insights while flagging single-source anecdotes. Never fabricates insight. Direct invocation of the product-research skill.
+argument-hint: "<research context: goal, product stage, segments, coded observations>"
+---
+
+# /cs:product-research — Study design + saturation + insight synthesis
+
+Run the `product-research` skill on this input:
+
+**$ARGUMENTS**
+
+## Three-tool workflow
+
+1. **`study_designer.py`** — Map (research goal × product stage) to an appropriate method and emit a plan skeleton (objective, participant criteria, guide structure, success criteria). Redirects live A/B to `product-team/experiment-designer`.
+
+2. **`saturation_planner.py`** — Method-based sample guidance with an explicit confidence label: Nielsen problem-discovery (5/segment), Guest et al. thematic saturation (~12), evaluative coverage. Never claims a prevalence rate from a small-n usability test.
+
+3. **`insight_synthesizer.py`** — Cluster coded observations by tag, count distinct participants, rank by cross-participant recurrence, and flag any candidate below the source threshold as an ANECDOTE — never promoting it to an insight.
+
+## Output
+
+- Recommended method + plan skeleton (matched to the goal)
+- Sample / saturation plan with confidence + limits
+- Synthesized candidates: INSIGHT vs ANECDOTE with evidence
+- Top 3 next actions
+
+## Hard rule
+
+**Method must match the goal, and an insight requires recurrence across independent participants.** A single quote is an anecdote, not a finding.
+
+## First run + optimization
+
+- **Onboard first:** `python3 scripts/onboard.py` (product profile, insight source-threshold, saturation method, high-stakes flag) — saved config pre-configures every tool. `--show` lists the questions.
+- **Optimize (opt-in):** only if the user asks to optimize the synthesis/run a loop, hand off to autoresearch via `scripts/ar_evaluator.py` (`validated_insights`, higher is better).
+
+## Distinct from
+
+- `product-team/ux-researcher-designer` — that produces personas/journey artifacts. This is method + repository discipline.
+- `product-team/product-discovery` — that plans discovery sprints. This designs and synthesizes the research.
+- `product-team/experiment-designer` — that runs live A/B. This runs qualitative/evaluative research.
+- `market-research` (sibling) — that studies the market. This studies users.

package/research-ops/commands/cs-research-finance.md

@@ -0,0 +1,39 @@
+---
+description: R&D program finance. Build a multi-period program budget with the F&A (indirect) split, track burn rate and runway against value-inflection milestones, and route R&D cost items to a capitalize-vs-expense determination. Every budget surfaces its assumptions; capex-vs-opex routes to a named finance owner and never auto-decides. Direct invocation of the research-finance skill.
+argument-hint: "<program context: work packages, F&A rate, cash on hand, milestones, cost items>"
+---
+
+# /cs:research-finance — Program budget + burn/runway + capex-vs-opex routing
+
+Run the `research-finance` skill on this input:
+
+**$ARGUMENTS**
+
+## Three-tool workflow
+
+1. **`program_budget_planner.py`** — Build a multi-period budget from work-package lines, apply the F&A rate to an MTDC-style eligible base (excludes capital equipment + subaward portions over $25k), roll up direct / F&A / fully-loaded cost per period with an explicit assumptions block. Industry tuning via `--profile`.
+
+2. **`burn_runway_tracker.py`** — Compute average + trailing burn, runway in periods/months, and whether each value-inflection milestone is reachable before cash runs out. Flags accelerating burn and below-threshold runway.
+
+3. **`capex_vs_opex_router.py`** — Score each cost item against IAS 38 development-phase criteria (or flag ASC 730 expense-as-incurred under US GAAP). Route to CAPITALIZE-CANDIDATE / EXPENSE / FINANCE-OWNER-REVIEW with a named owner. Never books an entry.
+
+## Output
+
+- Budget rollup (direct / F&A / fully-loaded) with assumptions
+- Runway + milestone verdicts + flags
+- Per-item capex/opex routing with named owner
+- Top 3 next actions
+
+## Hard rule
+
+**Every number carries its assumptions; accounting-treatment calls route to a named finance owner.** This skill never books an entry or decides treatment.
+
+## First run + optimization
+
+- **Onboard first:** `python3 scripts/onboard.py` (R&D area, F&A rate, runway threshold, accounting standard, finance owner) — saved config pre-configures every tool. `--show` lists the questions.
+- **Optimize (opt-in):** only if the user asks to optimize/extend runway, hand off to autoresearch via `scripts/ar_evaluator.py` (`runway_months`, higher is better).
+
+## Distinct from
+
+- `finance/financial-analysis` — that's corporate DCF / close / valuation. This is R&D-program-level.
+- `research/grants` — that **finds funding**. This **manages money already won**.