@diottodev/runic 1.0.0 → 1.1.0

package/research/research/skills/research/scripts/classifier.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+classifier.py — Deterministic SIGNALS-based routing classifier for the research orchestrator.
+
+Given a research question, returns the routing decision (specialist name or "fallback"),
+matched signals per specialist, and confidence reasoning.
+
+The SIGNALS map is the post-PR-#657-audit canonical version: verb-noun-paired phrases
+that route reliably, with NO bracketed placeholders (those over-trigger on generic
+"research [topic]" queries that should fall back instead).
+
+Usage:
+  python classifier.py --question "What's the literature on PICO for sepsis?"
+  python classifier.py --question "..." --output json
+  python classifier.py --sample
+"""
+
+import argparse
+import json
+import sys
+
+SIGNALS = {
+    "pulse": [
+        "reddit", "hn", "hacker news", "x.com", "twitter", "buzz",
+        "sentiment", "trending", "what are people saying",
+        "what's happening", "the conversation around",
+        "pulse on", "take the pulse", "current conversation",
+    ],
+    "grants": [
+        "nih", "grant", "grants for", "r01", "r21", "k-award", "reporter",
+        "nosi", "funding", "fda", "study section", "principal investigator",
+    ],
+    "litreview": [
+        "literature review", "lit review", "litreview", "pico", "spider",
+        "systematic review", "review papers on", "research papers on",
+        "papers about", "meta-analysis",
+    ],
+    "syllabus": [
+        "syllabus", "course outline", "curriculum", "reading list",
+        "for my class", "for my students", "course material",
+    ],
+    "patent": [
+        "prior art", "fto", "freedom to operate", "patent",
+        "patent landscape", "invention", "novelty search",
+        "patent search", "ip landscape",
+    ],
+    "dossier": [
+        "dossier on", "due diligence", "background check",
+        "prep me for", "competitor research", "investor diligence",
+        "interview prep", "research my competitor", "background on",
+    ],
+}
+
+
+def classify(question: str) -> dict:
+    """
+    Apply the deterministic routing algorithm:
+      - score[S] = count of SIGNALS[S] substrings matched (case-insensitive)
+      - if max(score) >= 2: route to argmax
+      - elif max(score) == 1 AND only one specialist scored 1: route to that one
+      - else: route to "fallback"
+    """
+    q = question.lower()
+    scores = {}
+    matched = {}
+
+    for specialist, phrases in SIGNALS.items():
+        hits = [p for p in phrases if p in q]
+        scores[specialist] = len(hits)
+        if hits:
+            matched[specialist] = hits
+
+    max_score = max(scores.values()) if scores else 0
+    top = [s for s, sc in scores.items() if sc == max_score and sc > 0]
+
+    if max_score >= 2:
+        route_to = top[0] if len(top) == 1 else _pick_highest_priority(top, scores)
+        confidence = f"high ({max_score} signals)"
+    elif max_score == 1:
+        single_scorers = [s for s, sc in scores.items() if sc == 1]
+        if len(single_scorers) == 1:
+            route_to = single_scorers[0]
+            confidence = "weak (1 signal, single specialist)"
+        else:
+            route_to = "fallback"
+            confidence = "ambiguous (multiple specialists with 1 signal)"
+    else:
+        route_to = "fallback"
+        confidence = "no signals matched"
+
+    return {
+        "route_to": route_to,
+        "confidence": confidence,
+        "scores": scores,
+        "matched_signals": matched,
+        "question": question,
+    }
+
+
+def _pick_highest_priority(candidates: list, scores: dict) -> str:
+    """When max(score) is tied across specialists, prefer the one with the
+    most specific signals (longest matched phrase across SIGNALS map). This is
+    a tie-breaker; in practice ties at ≥2 are rare."""
+    return sorted(candidates)[0]
+
+
+def render_human(result: dict) -> str:
+    lines = [
+        f"Question: {result['question']}",
+        f"Route to: {result['route_to']}",
+        f"Confidence: {result['confidence']}",
+        "",
+        "Per-specialist scores:",
+    ]
+    for s, sc in sorted(result["scores"].items(), key=lambda kv: -kv[1]):
+        lines.append(f"  {s}: {sc}")
+    if result["matched_signals"]:
+        lines.append("")
+        lines.append("Matched signals:")
+        for s, phrases in result["matched_signals"].items():
+            lines.append(f"  {s}: {', '.join(repr(p) for p in phrases)}")
+    if result["route_to"] != "fallback":
+        lines.append("")
+        lines.append(
+            f"Routing transparency: 'Routing to `{result['route_to']}` because "
+            f"of {result['confidence']}. Override or proceed in 5s.'"
+        )
+    else:
+        lines.append("")
+        lines.append("Routing transparency: 'No specialist matched. Running fallback.'")
+    return "\n".join(lines)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--question", help="The research question to classify.")
+    p.add_argument("--output", choices=["human", "json"], default="human")
+    p.add_argument("--sample", action="store_true", help="Run with built-in sample question.")
+    args = p.parse_args()
+
+    if args.sample:
+        args.question = "Can you do a systematic review of PICO frameworks for sepsis treatment? I need a meta-analysis."
+
+    if not args.question:
+        p.error("either --question or --sample is required")
+
+    result = classify(args.question)
+
+    if args.output == "json":
+        print(json.dumps(result, indent=2))
+    else:
+        print(render_human(result))
+
+
+if __name__ == "__main__":
+    main()

package/research/research/skills/research/scripts/fallback_decomposer.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+fallback_decomposer.py — Heuristic question decomposer for the fallback workflow.
+
+Given a research question, returns 3-5 sub-questions using the
+what / why / how / who / what's next framework. Deterministic + stdlib only.
+
+The output is a starting point; the orchestrator + user should refine before
+search budget is committed.
+
+Usage:
+  python fallback_decomposer.py --question "How are health systems integrating LLM-based clinical decision support in 2026?"
+  python fallback_decomposer.py --question "..." --output json
+  python fallback_decomposer.py --sample
+"""
+
+import argparse
+import json
+import re
+
+
+FRAMEWORK = [
+    ("what",        "What is {topic} — definition, scope, and current state?"),
+    ("why",         "Why does {topic} matter now — the forces driving attention or change?"),
+    ("how",         "How is {topic} being implemented or applied — methods, players, examples?"),
+    ("who",         "Who are the key actors in {topic} — leaders, critics, regulators, adopters?"),
+    ("whats_next",  "What's next for {topic} — near-term trajectory, open questions, watchpoints?"),
+]
+
+
+def _extract_topic(question: str) -> str:
+    """Strip leading 'research', interrogatives, framing verbs to surface the topic noun phrase."""
+    q = question.strip().rstrip("?").strip()
+    q = re.sub(
+        r"^(can you |could you |please |i need to |i want to |help me )",
+        "", q, flags=re.IGNORECASE,
+    ).strip()
+    q = re.sub(
+        r"^(research |look into |investigate |find me information on |"
+        r"find information on |do some research on |what do we know about |"
+        r"what is |what's |how are |how is |how do |why is |why are |"
+        r"who is |who are |when |where |tell me about )",
+        "", q, flags=re.IGNORECASE,
+    ).strip()
+    q = re.sub(r"\s+", " ", q)
+    return q or question.strip().rstrip("?")
+
+
+def decompose(question: str, n: int = 5) -> dict:
+    """Build 3-5 sub-questions from the framework. n is capped at 5 and floored at 3."""
+    n = max(3, min(5, n))
+    topic = _extract_topic(question)
+    selected = FRAMEWORK[:n]
+    sub_questions = [
+        {"label": label, "question": template.format(topic=topic)}
+        for label, template in selected
+    ]
+    return {
+        "question": question,
+        "extracted_topic": topic,
+        "sub_question_count": len(sub_questions),
+        "framework": "what/why/how/who/what's next",
+        "sub_questions": sub_questions,
+        "note": ("Starting point only. Refine sub-questions with the user "
+                 "before committing search budget. Drop any that don't fit; "
+                 "rewrite ones that do."),
+    }
+
+
+def render_human(result: dict) -> str:
+    lines = [
+        f"Question: {result['question']}",
+        f"Extracted topic: {result['extracted_topic']}",
+        f"Framework: {result['framework']}",
+        f"Sub-questions ({result['sub_question_count']}):",
+    ]
+    for i, sq in enumerate(result["sub_questions"], 1):
+        lines.append(f"  {i}. [{sq['label']}] {sq['question']}")
+    lines.append("")
+    lines.append(f"Note: {result['note']}")
+    return "\n".join(lines)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--question", help="The research question to decompose.")
+    p.add_argument("--n", type=int, default=5, help="Number of sub-questions (3-5; default 5).")
+    p.add_argument("--output", choices=["human", "json"], default="human")
+    p.add_argument("--sample", action="store_true", help="Run with built-in sample question.")
+    args = p.parse_args()
+
+    if args.sample:
+        args.question = "How are health systems integrating LLM-based clinical decision support in 2026?"
+
+    if not args.question:
+        p.error("either --question or --sample is required")
+
+    result = decompose(args.question, n=args.n)
+
+    if args.output == "json":
+        print(json.dumps(result, indent=2))
+    else:
+        print(render_human(result))
+
+
+if __name__ == "__main__":
+    main()

package/research/research/skills/research/scripts/routing_transparency_logger.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+routing_transparency_logger.py — JSON-backed audit log for the research orchestrator.
+
+Records every routing decision, override, and delegation handoff to a
+per-session JSON file at ~/.research_sessions/<session>.json. Stdlib only.
+
+Schema:
+  {
+    "session": "<name>",
+    "created_at": "<iso8601>",
+    "events": [
+      {"at": "<iso8601>", "type": "decision",   "question": "...", "route_to": "...", "confidence": "...", "matched": {...}},
+      {"at": "<iso8601>", "type": "override",   "from": "...", "to": "...", "reason": "..."},
+      {"at": "<iso8601>", "type": "delegation", "target": "...", "signals": "..."}
+    ]
+  }
+
+Usage:
+  python routing_transparency_logger.py --action record_decision --session demo --question "..." --route-to litreview --confidence "high (2 signals)"
+  python routing_transparency_logger.py --action record_override --session demo --from litreview --to fallback --reason "wanted general scope"
+  python routing_transparency_logger.py --action record_delegation --session demo --target litreview --signals "pico,meta-analysis"
+  python routing_transparency_logger.py --action read --session demo
+  python routing_transparency_logger.py --sample
+"""
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _session_path(session: str) -> Path:
+    base = Path.home() / ".research_sessions"
+    base.mkdir(parents=True, exist_ok=True)
+    safe = "".join(c if c.isalnum() or c in ("-", "_") else "_" for c in session)
+    return base / f"{safe}.json"
+
+
+def _load(session: str) -> dict:
+    path = _session_path(session)
+    if not path.exists():
+        return {"session": session, "created_at": _now(), "events": []}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _save(session: str, data: dict) -> Path:
+    path = _session_path(session)
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    return path
+
+
+def record_decision(session: str, question: str, route_to: str, confidence: str,
+                    matched: dict | None = None) -> dict:
+    data = _load(session)
+    event = {
+        "at": _now(),
+        "type": "decision",
+        "question": question,
+        "route_to": route_to,
+        "confidence": confidence,
+        "matched": matched or {},
+    }
+    data["events"].append(event)
+    _save(session, data)
+    return event
+
+
+def record_override(session: str, from_target: str, to_target: str, reason: str) -> dict:
+    data = _load(session)
+    event = {
+        "at": _now(),
+        "type": "override",
+        "from": from_target,
+        "to": to_target,
+        "reason": reason,
+    }
+    data["events"].append(event)
+    _save(session, data)
+    return event
+
+
+def record_delegation(session: str, target: str, signals: str) -> dict:
+    data = _load(session)
+    event = {
+        "at": _now(),
+        "type": "delegation",
+        "target": target,
+        "signals": signals,
+    }
+    data["events"].append(event)
+    _save(session, data)
+    return event
+
+
+def read(session: str) -> dict:
+    return _load(session)
+
+
+def render_human(result: dict) -> str:
+    if "events" in result:
+        lines = [
+            f"Session: {result['session']}",
+            f"Created: {result['created_at']}",
+            f"Events ({len(result['events'])}):",
+        ]
+        for e in result["events"]:
+            t = e.get("type")
+            if t == "decision":
+                lines.append(f"  [{e['at']}] decision → {e['route_to']} ({e['confidence']})")
+            elif t == "override":
+                lines.append(f"  [{e['at']}] override {e['from']} → {e['to']} ({e['reason']})")
+            elif t == "delegation":
+                lines.append(f"  [{e['at']}] delegation → {e['target']} (signals: {e['signals']})")
+            else:
+                lines.append(f"  [{e['at']}] {t}: {e}")
+        return "\n".join(lines)
+    return json.dumps(result, indent=2)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--action",
+                   choices=["record_decision", "record_override", "record_delegation", "read"],
+                   help="What to do.")
+    p.add_argument("--session", help="Session name (used as filename stem).")
+    p.add_argument("--question", help="(record_decision) The classified question.")
+    p.add_argument("--route-to", dest="route_to", help="(record_decision) Routing target.")
+    p.add_argument("--confidence", help="(record_decision) Confidence string.")
+    p.add_argument("--matched", help="(record_decision) Matched signals (JSON).")
+    p.add_argument("--from", dest="from_target", help="(record_override) Previous target.")
+    p.add_argument("--to", dest="to_target", help="(record_override) New target.")
+    p.add_argument("--reason", help="(record_override) Why user overrode.")
+    p.add_argument("--target", help="(record_delegation) Specialist target.")
+    p.add_argument("--signals", help="(record_delegation) Signals that matched.")
+    p.add_argument("--output", choices=["human", "json"], default="human")
+    p.add_argument("--sample", action="store_true", help="Run a built-in 4-event sample sequence.")
+    args = p.parse_args()
+
+    if args.sample:
+        session = "sample"
+        path = _session_path(session)
+        if path.exists():
+            path.unlink()
+        record_decision(session,
+                        "Can you review the literature on PICO for sepsis?",
+                        "litreview",
+                        "high (2 signals)",
+                        {"litreview": ["pico", "literature"]})
+        record_delegation(session, "litreview", "pico,literature")
+        record_decision(session,
+                        "What's the buzz about Anthropic on HN?",
+                        "pulse",
+                        "high (2 signals)",
+                        {"pulse": ["hn", "buzz"]})
+        record_override(session, "pulse", "fallback", "wanted general scope")
+        result = read(session)
+        if args.output == "json":
+            print(json.dumps(result, indent=2))
+        else:
+            print(render_human(result))
+        return
+
+    if not args.action:
+        p.error("--action is required (unless --sample)")
+    if not args.session:
+        p.error("--session is required")
+
+    if args.action == "record_decision":
+        if not (args.question and args.route_to and args.confidence):
+            p.error("record_decision requires --question, --route-to, --confidence")
+        matched = json.loads(args.matched) if args.matched else None
+        out = record_decision(args.session, args.question, args.route_to, args.confidence, matched)
+    elif args.action == "record_override":
+        if not (args.from_target and args.to_target and args.reason):
+            p.error("record_override requires --from, --to, --reason")
+        out = record_override(args.session, args.from_target, args.to_target, args.reason)
+    elif args.action == "record_delegation":
+        if not (args.target and args.signals):
+            p.error("record_delegation requires --target, --signals")
+        out = record_delegation(args.session, args.target, args.signals)
+    elif args.action == "read":
+        out = read(args.session)
+    else:
+        p.error(f"unknown action {args.action}")
+
+    if args.output == "json":
+        print(json.dumps(out, indent=2))
+    else:
+        print(render_human(out))
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,20 @@
+{
+  "name": "syllabus",
+  "description": "Generates a curated supplementary reading list from any course syllabus using Consensus academic search. Grill-me intake (syllabus input format + course audience + year range) plus a grouping forcing-options checkpoint before any search runs \u2014 so the reading list matches the course's level and recency need. Parses the syllabus to extract topics and learning outcomes, searches Consensus for recent peer-reviewed papers per topic, and produces a professionally formatted .docx with clickable Consensus links, plain-language summaries calibrated to audience level, and Bloom-higher-order discussion questions tied to course learning goals. Triggers whenever a user uploads a syllabus, course outline, or curriculum document and wants supplementary readings. Also triggers on: 'syllabus reading list', 'find papers for my course', 'create a reading list from this syllabus', 'recent research for my class', 'supplementary readings', 'find journal articles for these topics', 'what recent papers cover this material', 'any new research on these course topics', 'update my syllabus with recent papers'. Even casual mentions when a syllabus is attached should trigger this skill.",
+  "version": "2.9.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/research/syllabus",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills/syllabus"
+  ],
+  "source": {
+    "spec": "megaprompts/10-syllabus-megaprompt.md",
+    "build_pattern": "Path B (direct conversion). Research-pack shape, BUNDLED-JS-DOCX-GENERATOR variant \u2014 ships scripts/generate_reading_list.js for 300+ line DOCX assembly logic (token-efficient: skill doesn't re-derive layout each run).",
+    "sibling_of": "research/litreview, research/grants, research/patent, research/dossier, research/pulse"
+  }
+}

package/research/syllabus/README.md

@@ -0,0 +1,68 @@
+# syllabus
+
+Course supplementary reading list generator. Takes any course syllabus (PDF / DOCX / text / image) and produces a curated `.docx` of recent peer-reviewed papers via Consensus search, with plain-language summaries calibrated to audience level + Bloom-higher-order discussion questions tied to learning outcomes.
+
+## What this skill does
+
+1. **Phase 0 grill-me** (3 forcing Qs): syllabus input format + course audience + year range
+2. **Phase 1**: parse syllabus (PDF/DOCX/text/image) → extract topics + learning outcomes
+3. **Phase 2**: group topics into 6-12 sections + grill-me forcing checkpoint (proceed/merge/split/add/remove)
+4. **Phase 3**: targeted Consensus searches per section (1-2 queries each, sequential at 1 q/sec, **applied-domain weaving**)
+5. **Phase 4**: write summaries (audience-calibrated jargon) + discussion questions (Bloom higher-order)
+6. **Phase 5**: generate .docx via **bundled JS script** (`scripts/generate_reading_list.js`)
+7. **Phase 6**: deliver file + audit summary
+
+## Architectural pattern: bundled JS
+
+This skill uses a **bundled JavaScript helper script** (`scripts/generate_reading_list.js`) for DOCX generation rather than inlining the 300+ lines of layout code in SKILL.md. Rationale:
+
+- DOCX generation logic is reusable + complex
+- Better separation of concerns: skill = orchestration + intelligence; script = mechanical document assembly
+- Token-efficient: skill doesn't re-derive layout each run
+- Easier to maintain and version
+
+The skill orchestrates the pipeline and invokes the script with JSON input.
+
+## Sibling skill relationship
+
+Part of the **research pack** (sibling of `pulse`, `litreview`, `grants`, `patent`, `dossier`). Shares Agent Integrity Rules. Adds:
+
+- **Audience calibration** — undergrad summaries define every term; grad summaries assume technical fluency
+- **Applied-domain weaving** — search "X applications" not just "X" (boosts relevance dramatically)
+- **Bundled JS script pattern** — first research-pack skill to use this layout
+
+## Source spec
+
+[`megaprompts/10-syllabus-megaprompt.md`](../../megaprompts/10-syllabus-megaprompt.md) (PR #657).
+
+## Plugin layout
+
+```
+research/syllabus/
+├── .claude-plugin/plugin.json
+├── README.md
+├── agents/cs-syllabus.md
+├── commands/cs-syllabus.md
+└── skills/syllabus/
+    ├── SKILL.md
+    ├── references/
+    │   ├── applied_domain_weaving.md       ← search-quality canon (7+ sources)
+    │   ├── audience_calibration.md         ← undergrad vs grad summary jargon (7+ sources)
+    │   └── bundled_script_pattern.md       ← why bundle vs inline (7+ sources)
+    └── scripts/
+        ├── citation_tracker.py             ← stdlib: Consensus three-count + 1s sequential
+        ├── topic_grouper.py                ← stdlib: heuristic 6-12 section grouping
+        ├── discussion_question_validator.py ← stdlib: Bloom higher-order quality check
+        └── generate_reading_list.js        ← bundled Node.js: DOCX assembly (~300 lines)
+```
+
+## Dependencies
+
+- **Consensus MCP** — Required for literature search
+- **Node.js with `docx` package** — Required (`npm install docx`)
+- **Bundled script** — `scripts/generate_reading_list.js` (shipped with skill, not external)
+- **File reading** — PDF reader / DOCX parser via pandoc / vision for images
+
+## License
+
+MIT.

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

@@ -0,0 +1,84 @@
+---
+name: cs-syllabus
+description: Course supplementary reading list persona. Walks 3 forcing intake questions (syllabus input format + course audience + year range) before parsing. Halts at grouping checkpoint after Phase 2 (proceed/merge/split/add/remove). Searches Consensus sequentially at 1 q/sec with applied-domain weaving (e.g., 'enzyme kinetics food processing' not just 'enzyme kinetics'). Calibrates summary jargon to audience (undergrad defines every term; grad assumes technical fluency). Writes Bloom higher-order discussion questions tied to learning outcomes. Generates .docx via bundled JS script.
+skills: research/syllabus/skills/syllabus
+domain: research
+model: opus
+tools: [Read, Write, Bash]
+---
+
+# Syllabus Agent
+
+## Voice
+
+**Opening:** "Drop your syllabus — file path, pasted text, or image. I'll grill you on audience and year range, parse the syllabus into 6-12 sections, halt for your confirmation, then search Consensus per section with applied-domain weaving."
+
+**Refusing missing syllabus:** Q1 force; can't proceed without input.
+
+**Audience calibration reminder (mid-Phase 4):**
+> "Audience: Q2=undergrad-intro. Calibrating summaries to define jargon, not assume fluency. Discussion questions test analysis, not critique."
+
+**Group-and-confirm checkpoint:**
+> "Proposed sections: [list]. **Pick one:** proceed / merge X+Y / split X / add section for Y / remove X. This is the last cheap moment before search budget is consumed."
+
+**Closing:**
+> "Saved: <path>/reading_list_<course>_<date>.docx via bundled JS script. Audit: 12 searches × 47 papers / 22 cited. Plan tier: free (3/search). Sections: 8. Each paper has: hyperlinked title + audience-calibrated summary + Bloom-tied discussion question."
+
+Sequential, audience-aware, applied-domain-weaving discipline.
+
+## Purpose
+
+The cs-syllabus agent orchestrates the `syllabus` skill across course-reading-list generation:
+
+1. **Phase 0 intake** — Q1 input format, Q2 audience, Q3 year range
+2. **Phase 1 parse** — PDF/DOCX/text/image → topics + learning outcomes
+3. **Phase 2 group** — 6-12 sections + checkpoint
+4. **Phase 3 search** — Consensus sequential 1 q/sec with applied-domain angle
+5. **Phase 4 write** — audience-calibrated summaries + Bloom higher-order questions
+6. **Phase 5 generate** — bundled JS DOCX
+7. **Phase 6 deliver** — file + audit summary
+
+**Hard rules:**
+
+1. **One intake Q per turn.** Never bundle.
+2. **Refuse missing syllabus** at Q1.
+3. **Halt at grouping checkpoint.** No Phase 3 without explicit user choice.
+4. **Sequential Consensus.** 1 q/sec.
+5. **Applied-domain weaving** on every query (not "enzyme kinetics" alone — "enzyme kinetics food processing").
+6. **Audience-calibrated summaries.** Undergrad defines jargon; grad assumes fluency.
+7. **Bloom higher-order discussion questions.** Apply / analyze / evaluate. NOT recall ("what did the authors find?").
+8. **Source discipline.** Consensus-only; training knowledge labeled.
+9. **Three-count tracking.** Sent / received / cited.
+10. **Bundled JS for DOCX.** Don't inline.
+
+## Skill Integration
+
+**Skill Location:** `../skills/syllabus/`
+
+### Python Tools (Stdlib)
+
+1. **Citation Tracker** — `scripts/citation_tracker.py` — Consensus three-count + 1s sequential at `~/.syllabus_sessions/<session>.json`
+2. **Topic Grouper** — `scripts/topic_grouper.py` — heuristic 6-12 section grouping from extracted topics
+3. **Discussion Question Validator** — `scripts/discussion_question_validator.py` — Bloom higher-order quality check (rejects recall questions)
+
+### Bundled Node.js Script
+
+**Generate Reading List** — `scripts/generate_reading_list.js` — JSON-input → .docx output. ~300 lines. Handles `docx` package require with multi-location fallback. Uses `ExternalHyperlink` with full Consensus URLs (never truncated). `LevelFormat.BULLET` for lists.
+
+### Knowledge Bases
+
+- `references/applied_domain_weaving.md` — search-quality canon (7+ sources)
+- `references/audience_calibration.md` — undergrad vs grad summary jargon (7+ sources)
+- `references/bundled_script_pattern.md` — why bundle vs inline (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-patent](../../patent/agents/cs-patent.md) — sibling, patent prior-art
+- [cs-dossier](../../dossier/agents/cs-dossier.md) — sibling, entity research
+
+---
+
+**Version:** 1.0.0
+**Source:** Path-B direct conversion of `megaprompts/10-syllabus-megaprompt.md`