medsci-skills 4.1.0

package/skills/write-paper/scripts/check_placeholders.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Flag unresolved authoring markers left in a manuscript before submission.
+
+Drafting leaves behind placeholder/marker debris that must never reach a frozen
+submission package. Until now these were caught only by grep instructions in
+SKILL.md prose (write-paper Phase 0/7, self-review Phase 2.5c); this promotes the
+grep to a deterministic gate so a single pre-flight run can halt on them.
+
+Detected finding types:
+  new_marker                (blocker) an unresolved [@NEW:topic] citation
+                            placeholder — never legitimate in a final manuscript.
+  ai_disclosure_placeholder (blocker) a literal [version]/[date]/[tool]/[model]/
+                            [channel] token in an AI-use disclosure (the FLAIR/
+                            TRIPOD+AI tokens were never filled in).
+  generic_todo              (blocker) a TODO / FIXME / TBD / XXX authoring marker
+                            outside a fenced code block.
+  template_url              (blocker) a template/unfilled URL — example.com,
+                            doi.org/XXXX, an empty markdown link ]( ), or a
+                            literal [URL]/[link] placeholder.
+  bare_numeric_cite         (warn) a bare [N] or [N-N] citation marker. WARN, not
+                            blocker, because Vancouver in-text citations are
+                            legitimately [N]; in a pandoc [@key] draft it is an
+                            unresolved placeholder, so write-paper Phase 0 /
+                            self-review escalate it with --strict.
+
+Guards against false positives: fenced code blocks (``` or ~~~) are skipped
+entirely, and a References/Bibliography section is skipped for bare_numeric_cite
+(numbered reference lists legitimately read "[1] Smith J ...").
+
+INPUTS
+  --manuscript   manuscript markdown/text (required).
+  --strict       also exit 1 on warn-severity findings (bare_numeric_cite).
+
+OUTPUT
+  A findings table (stdout) and, with --out, a JSON artifact:
+    {schema_version, source, summary:{blocker,warn}, findings[...], submission_safe}
+  submission_safe is true iff there are no blocker-severity findings.
+
+Stdlib-only (json / re / argparse / pathlib). Exit codes: 0 clean (no blocker, and
+no warn under --strict), 1 blocker found (or warn under --strict), 2 input/usage error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+# --- finding patterns --------------------------------------------------------
+# Blocker patterns: each match is an unambiguous unresolved authoring marker.
+NEW_MARKER = re.compile(r"\[@NEW:[^\]]*\]", re.IGNORECASE)
+AI_DISCLOSURE_PLACEHOLDER = re.compile(r"\[(?:version|date|tool|model|channel)\]", re.IGNORECASE)
+# TODO/FIXME/TBD and XXX (3+ uppercase X) — case-sensitive so "tbd"/"fix me" inside
+# ordinary words or Roman numerals (XXXI) do not trip it.
+GENERIC_TODO = re.compile(r"\b(?:TODO|FIXME|TBD|X{3,})\b")
+TEMPLATE_URL = re.compile(
+    r"https?://(?:www\.)?example\.(?:com|org|net)\S*"
+    r"|(?:https?://)?(?:dx\.)?doi\.org/(?:10\.)?X{3,}\S*"
+    r"|\]\(\s*\)"
+    r"|\[(?:URL|link)\]",
+    re.IGNORECASE,
+)
+# Warn pattern: bare [N] or [N-N]/[N–N] not followed by '(' (so markdown links
+# [1](url) are excluded) and not a footnote [^1].
+BARE_NUMERIC_CITE = re.compile(r"(?<!\w)\[\d{1,3}(?:\s*[–-]\s*\d{1,3})?\](?!\()")
+
+BLOCKER_PATTERNS = [
+    ("new_marker", NEW_MARKER),
+    ("ai_disclosure_placeholder", AI_DISCLOSURE_PLACEHOLDER),
+    ("generic_todo", GENERIC_TODO),
+    ("template_url", TEMPLATE_URL),
+]
+
+HEADING_RE = re.compile(r"^#{1,6}\s+(.*\S)\s*$")
+REFERENCES_TITLE_RE = re.compile(r"references|bibliography|works cited|reference list", re.IGNORECASE)
+FENCE_RE = re.compile(r"^\s*(?:```|~~~)")
+
+
+def scan(text: str) -> list[dict]:
+    """Line-by-line scan honoring code-fence and references-section guards."""
+    findings: list[dict] = []
+    in_fence = False
+    in_references = False
+    for lineno, line in enumerate(text.splitlines(), 1):
+        if FENCE_RE.match(line):
+            in_fence = not in_fence
+            continue
+        if in_fence:
+            continue
+        h = HEADING_RE.match(line.strip())
+        if h:
+            # entering / leaving a References-style section
+            in_references = bool(REFERENCES_TITLE_RE.search(h.group(1).lower()))
+        for type_name, pat in BLOCKER_PATTERNS:
+            for m in pat.finditer(line):
+                findings.append({
+                    "type": type_name,
+                    "line": lineno,
+                    "text": m.group(0).strip()[:120],
+                    "severity": "blocker",
+                })
+        if not in_references:
+            for m in BARE_NUMERIC_CITE.finditer(line):
+                findings.append({
+                    "type": "bare_numeric_cite",
+                    "line": lineno,
+                    "text": m.group(0).strip()[:120],
+                    "severity": "warn",
+                })
+    return findings
+
+
+def analyze(manuscript: str) -> dict:
+    p = Path(manuscript)
+    if not p.is_file():
+        sys.stderr.write(f"ERROR: manuscript not found: {manuscript}\n")
+        sys.exit(2)
+    findings = scan(p.read_text(encoding="utf-8"))
+    n_blocker = sum(1 for f in findings if f["severity"] == "blocker")
+    n_warn = len(findings) - n_blocker
+    return {
+        "schema_version": 1,
+        "source": str(p),
+        "summary": {"blocker": n_blocker, "warn": n_warn},
+        "findings": findings,
+        "submission_safe": n_blocker == 0,
+    }
+
+
+def render(result: dict) -> str:
+    lines = ["| Line | Type | Severity | Match |", "|---|---|---|---|"]
+    for f in result["findings"]:
+        lines.append(f"| {f['line']} | {f['type']} | {f['severity']} | `{f['text']}` |")
+    if len(lines) == 2:
+        lines.append("| — | (none) | — | no unresolved markers |")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="Flag unresolved authoring markers (placeholders) before submission.")
+    ap.add_argument("--manuscript", required=True, help="manuscript markdown/text")
+    ap.add_argument("--out", help="write JSON artifact to this path")
+    ap.add_argument("--strict", action="store_true",
+                    help="exit 1 on warn-severity findings too (bare [N] citations)")
+    ap.add_argument("--quiet", action="store_true", help="suppress stdout table")
+    args = ap.parse_args()
+
+    result = analyze(args.manuscript)
+    s = result["summary"]
+
+    if not args.quiet:
+        print("=" * 41)
+        print(" Placeholder / Marker Gate")
+        print("=" * 41)
+        print(render(result))
+        print()
+        if s["blocker"]:
+            print(f"BLOCKER: {s['blocker']} unresolved marker(s) must be removed before submission.")
+        elif s["warn"]:
+            print(f"WARN: {s['warn']} bare [N] citation(s) — confirm Vancouver style or resolve "
+                  f"(escalates to blocker under --strict).")
+        else:
+            print("OK: no unresolved authoring markers.")
+
+    if args.out:
+        Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.out).write_text(json.dumps(result, indent=2), encoding="utf-8")
+        if not args.quiet:
+            print(f"\nwrote {args.out}")
+
+    if s["blocker"]:
+        return 1
+    if args.strict and s["warn"]:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/write-paper/skill.yml

@@ -0,0 +1,48 @@
+schema_version: 2
+name: write-paper
+layer: C
+owner_domain: manuscript_drafting
+when_to_use:
+  - Drafting an original medical/scientific manuscript from outline (8-phase IMRAD workflow)
+  - Original article, case report, meta-analysis report, AI validation study, animal study, or technical note
+  - Step 7.3a numerical claim audit before submission
+  - Step 7.6 reference handoff to /manage-refs for journal CSL render
+when_NOT_to_use:
+  - Self-criticism on the user's own draft (use /self-review — explicitly different routing)
+  - Reviewer-response writing (use /revise)
+  - Reviewing external manuscripts (use /peer-review)
+  - Generating references from memory (forbidden — use /search-lit + /verify-refs)
+  - Silently editing a frozen submission docx (forbidden — branch to v_(N+1))
+inputs:
+  - project.yaml
+  - analysis/_analysis_outputs.md
+  - analysis/figures/_figure_manifest.md
+outputs:
+  - manuscript/manuscript.md
+  - manuscript/title_page.md
+  - qc/_pipeline_log.md
+deterministic_scripts:
+  - none_required
+side_effects:
+  - writes_project_artifacts
+downstream_consumers:
+  - self-review
+  - verify-refs
+  - sync-submission
+forbidden_actions:
+  - generate_references_from_memory
+  - silently_edit_frozen_submission
+
+# v2.1 quality card
+purpose: "Draft a submission-ready IMRAD manuscript or section from approved project inputs (8-phase workflow)."
+safety_boundaries:
+  - "Never generates references from memory; citations come from search-lit and are checked by verify-refs."
+  - "Never silently edits a frozen submission; branches to v_(N+1) instead."
+  - "Numerical claims are audited against approved tables before submission (Step 7.3a)."
+known_limitations:
+  - "Reference integrity depends on verify-refs (PubMed/CrossRef); offline runs degrade to manual checking."
+  - "Drafts the user's own manuscript only; not for self-critique (self-review), reviewer response (revise), or external review (peer-review)."
+validation_commands:
+  - "/verify-refs --strict"
+  - "/self-review"
+evidence_surface: demo

package/skills/write-paper/tests/test_placeholders.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# Test scripts/check_placeholders.py — the A5 placeholder/marker gate.
+# Synthetic, PII-free fixtures: a manuscript with one of each marker type, a clean
+# manuscript that exercises the code-fence and References-section guards, a warn-only
+# manuscript (bare [N] outside references), and a missing file. Stdlib-only.
+set -u
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT="$HERE/../scripts/check_placeholders.py"
+PASS=0
+FAIL=0
+ok()  { echo "  PASS: $1"; PASS=$((PASS+1)); }
+bad() { echo "  FAIL: $1"; FAIL=$((FAIL+1)); }
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+# --- fixtures ---
+# dirty: one of each blocker type + bare numeric cites in the body
+cat > "$WORK/dirty.md" <<'EOF'
+# Introduction
+
+Our method follows prior work [@NEW:competing-risk-model].
+
+We used [version] of the model via the [channel] interface.
+
+TODO: rewrite this. See FIXME below; values still XXX.
+
+Data are at https://example.com/data and doi.org/XXXX, link here [URL].
+
+This cites a source [4] in Vancouver style [5-7].
+
+## References
+
+[1] Smith J, et al. A real paper. 2020.
+[2] Doe A. Another paper. 2021.
+EOF
+
+# clean: code-fence guard + legit DOI + numbered reference list (no body markers)
+cat > "$WORK/clean.md" <<'EOF'
+# Methods
+
+We analyzed the cohort using a competing-risk model.
+
+```python
+# TODO: inside a code fence, must be ignored
+url = "https://example.com/ignored"
+ref = [1]  # ignored
+EOF
+printf '```\n' >> "$WORK/clean.md"
+cat >> "$WORK/clean.md" <<'EOF'
+
+Full data are at https://doi.org/10.1038/s41591-024-00001-2.
+
+## References
+
+[1] Smith J, et al. A real paper. N Engl J Med. 2020.
+[2] Doe A. Another paper. Lancet. 2021.
+EOF
+
+# warn-only: a bare [N] in the body, no blockers
+cat > "$WORK/warn.md" <<'EOF'
+# Body
+This cites a source [3] in Vancouver style.
+EOF
+
+run() { python3 "$SCRIPT" "$@" 2>/dev/null; }
+
+# 1. dirty manuscript fails with exit 1
+run --manuscript "$WORK/dirty.md" --quiet
+[ $? -eq 1 ] && ok "dirty manuscript fails (exit 1)" || bad "dirty manuscript should fail"
+
+# 2. JSON reports all five finding types and submission_safe=false
+run --manuscript "$WORK/dirty.md" --out "$WORK/dirty.json" --quiet
+python3 -c "
+import json,sys
+d=json.load(open('$WORK/dirty.json'))
+types={f['type'] for f in d['findings']}
+need={'new_marker','ai_disclosure_placeholder','generic_todo','template_url','bare_numeric_cite'}
+sys.exit(0 if need <= types and d['submission_safe'] is False and d['summary']['blocker']>=5 else 1)
+" && ok "JSON: all five finding types + submission_safe false" || bad "JSON findings incomplete"
+
+# 3. clean manuscript passes (code-fence + references guards work)
+run --manuscript "$WORK/clean.md" --quiet
+[ $? -eq 0 ] && ok "clean manuscript passes (guards work)" || bad "clean manuscript should pass"
+
+# 3b. clean manuscript has zero findings (no leakage from code fence / refs)
+run --manuscript "$WORK/clean.md" --out "$WORK/clean.json" --quiet
+python3 -c "
+import json,sys
+d=json.load(open('$WORK/clean.json'))
+sys.exit(0 if not d['findings'] and d['submission_safe'] is True else 1)
+" && ok "clean manuscript: zero findings" || bad "clean manuscript should have no findings"
+
+# 4. warn-only: passes by default, fails under --strict
+run --manuscript "$WORK/warn.md" --quiet
+[ $? -eq 0 ] && ok "warn-only passes by default" || bad "warn-only should pass by default"
+run --manuscript "$WORK/warn.md" --strict --quiet
+[ $? -eq 1 ] && ok "warn-only fails under --strict" || bad "warn-only should fail under --strict"
+
+# 5. missing file -> exit 2
+run --manuscript "$WORK/nope.md" --quiet
+[ $? -eq 2 ] && ok "missing file exits 2" || bad "missing file should exit 2"
+
+echo ""
+echo "test_placeholders: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ]

package/skills/write-protocol/SKILL.md

@@ -0,0 +1,243 @@
+---
+name: write-protocol
+description: >
+  IRB/ethics committee research protocol generator. Produces 4 core sections (Background,
+  Study Design, Sample Size, Statistical Plan) with full prose, plus 6 skeleton sections
+  with TODO markers for institution-specific content. Integrates outputs from design-study,
+  calc-sample-size, and search-lit.
+triggers: write protocol, IRB protocol, ethics protocol, research protocol, IRB submission, ethics submission, protocol draft
+tools: Read, Write, Edit, Bash, Grep, Glob
+model: inherit
+---
+
+# Write-Protocol Skill
+
+You are helping a medical researcher draft a research protocol for IRB/ethics committee
+submission. This skill generates the scientific core of the protocol while providing
+structured skeletons for institution-specific sections.
+
+## Scope
+
+This skill generates **4 core sections** with full prose:
+1. Background and Rationale
+2. Study Design and Eligibility Criteria
+3. Sample Size Justification
+4. Statistical Analysis Plan
+
+The remaining **6 sections** are provided as structured skeletons with `[TODO]` markers,
+because they vary significantly across institutions, countries, and regulatory frameworks.
+
+**Important**: This protocol is a STARTING POINT. Every institution has its own IRB
+submission form and requirements. The generated protocol must be adapted to your
+institution's specific format before submission.
+
+## Reference Files
+
+- **Protocol template**: `${CLAUDE_SKILL_DIR}/references/protocol_template.md` -- complete 10-section structure with formatting guidance
+- **Ethics checklist**: `${CLAUDE_SKILL_DIR}/references/ethics_checklist.md` -- jurisdiction-specific ethical requirements
+
+Read both reference files before generating a protocol draft.
+
+## Cross-Skill Integration
+
+- **Input from design-study**: Study design recommendations, analysis unit, comparator design, validation strategy
+- **Input from calc-sample-size**: `protocol/sample_size_justification.md` (canonical IRB-ready prose) + `protocol/sample_size_calc.{R,py}` (reproducible code). Embed `sample_size_justification.md` VERBATIM into Methods §Sample Size — do not rephrase numbers (per `~/.claude/rules/numerical-safety.md`).
+- **Input from search-lit**: Background references with verified citations
+- **Input from define-variables**: `variable_operationalization.md` — literature-grounded definitions, cutoffs, DB-variable mappings for the Methods section. **Precondition**: if the study is observational and no operationalization artifact exists, call `/define-variables` before drafting Methods. Do not invent phenotype/cutoff definitions from the data dictionary inside this skill.
+- **Pipeline position**: search-lit -> design-study -> calc-sample-size -> define-variables -> **write-protocol** -> manage-project
+
+When prior skill outputs are available, incorporate them directly. When they are not,
+prompt the user or call the relevant skill.
+
+---
+
+## Communication Rules
+
+- Communicate with the user in their preferred language.
+- Use English for all protocol content, statistical terminology, and medical terminology.
+- Be explicit about what is generated versus what requires institutional input.
+
+---
+
+## Required Inputs
+
+Collect all required inputs before generating. Ask one question at a time if information is missing.
+
+1. **Research question / hypothesis** -- specific, testable
+2. **Study type** -- retrospective cohort, prospective cohort, cross-sectional, RCT, diagnostic accuracy, case-control, case series
+3. **Target population** -- who, where, when
+4. **Primary outcome** -- what you are measuring
+5. **Secondary outcomes** (if any)
+
+## Optional Inputs (enhance quality if available)
+
+6. **design-study output** -- if `/design-study` was already run, load its recommendations
+7. **calc-sample-size output** -- if `/calc-sample-size` was already run, load its results and IRB text
+8. **Key references** -- DOIs or search terms for background section
+9. **Institution name** -- for header and ethics section guidance
+10. **Regulatory context** -- Korea (PIPA), US (HIPAA/Common Rule), EU (GDPR), other
+
+---
+
+## Protocol Structure -- 10 Sections
+
+### Core Sections (Fully Generated)
+
+#### Section 1: Background and Rationale (400-600 words)
+
+Generate full prose covering:
+- **Clinical context**: disease burden, current practice, knowledge gap
+- **Literature support**: call `/search-lit` if key references are not provided; every citation must have a verified DOI or PMID
+- **Rationale**: why this study is needed, what it adds to existing evidence
+- **Research question**: clear statement of the hypothesis or research question
+
+Do not use bullet points in the output. Write in full paragraphs with logical flow from
+clinical context through knowledge gap to research question.
+
+#### Section 2: Study Design and Eligibility Criteria (300-500 words)
+
+Generate full prose plus structured criteria lists:
+- **Study design** with justification (why this design answers this question)
+- **Setting**: single-center vs multi-center, institution description
+- **Study period**: start and end dates or planned duration
+- **Inclusion criteria** (numbered list)
+- **Exclusion criteria** (numbered list)
+
+If design-study output is available, incorporate its recommendations on:
+- Analysis unit (patient vs lesion vs exam)
+- Comparator design
+- Validation strategy
+- Potential leakage risks and mitigations
+
+#### Section 3: Sample Size Justification (150-300 words)
+
+- If `protocol/sample_size_justification.md` exists (calc-sample-size output): embed VERBATIM. Do not rephrase numbers.
+- If not available: prompt the user to run `/calc-sample-size` first; only fall back to a basic justification if the user explicitly declines.
+- Must include: test type, expected effect size (with literature source), alpha level, power, attrition adjustment
+- Final statement: "We plan to enroll N participants."
+
+#### Section 4: Statistical Analysis Plan (300-500 words)
+
+Generate full prose covering:
+- **Descriptive statistics**: continuous variables as mean (SD) or median (IQR); categorical variables as count (%)
+- **Primary analysis**: statistical test, assumptions, handling of violations
+- **Secondary analyses**: pre-specified
+- **Subgroup analyses**: pre-specified, with interaction tests
+- **Missing data**: handling strategy (complete case, multiple imputation, sensitivity analysis)
+- **Software**: name and version (e.g., R 4.4.0, Python 3.12, SAS 9.4)
+- **Significance level**: two-sided alpha = 0.05 unless otherwise justified
+
+### Skeleton Sections (TODO Markers)
+
+#### Section 5: Study Title and Registration
+
+```
+[TODO: Full study title]
+[TODO: Short title / acronym]
+[TODO: Clinical trial registry number if applicable (e.g., ClinicalTrials.gov, CRIS)]
+[TODO: Protocol version number and date]
+```
+
+#### Section 6: Data Collection and Management
+
+```
+[TODO: List variables to be collected -- use your institution's case report form (CRF) template]
+[TODO: Data collection method (chart review / prospective forms / electronic extraction)]
+[TODO: Data storage and security measures (encrypted database, access controls)]
+[TODO: Quality assurance procedures (double data entry, range checks)]
+[TODO: Data retention period per institutional policy]
+```
+
+#### Section 7: Ethical Considerations
+
+```
+[TODO: IRB/Ethics committee name and expected submission date]
+[TODO: Informed consent process -- or justification for waiver]
+[TODO: Patient privacy and data protection measures]
+```
+
+Include regulatory guidance by jurisdiction:
+- **Korea**: Personal Information Protection Act (PIPA), Bioethics and Safety Act
+- **United States**: HIPAA Privacy Rule, Common Rule (45 CFR 46)
+- **European Union**: GDPR Article 9 (health data), Clinical Trials Regulation (EU 536/2014)
+
+```
+[TODO: Confirm applicable regulations with your IRB office]
+```
+
+Refer to `${CLAUDE_SKILL_DIR}/references/ethics_checklist.md` for the full checklist.
+
+#### Section 8: Timeline and Milestones
+
+```
+[TODO: Adapt to your project schedule]
+
+| Phase | Activity                              | Duration    | Target Date |
+|-------|---------------------------------------|-------------|-------------|
+| 1     | IRB approval                          | [X] weeks   | [TODO]      |
+| 2     | Data collection / Patient enrollment  | [X] months  | [TODO]      |
+| 3     | Data cleaning and analysis            | [X] months  | [TODO]      |
+| 4     | Manuscript preparation                | [X] months  | [TODO]      |
+| 5     | Submission                            | --          | [TODO]      |
+```
+
+#### Section 9: Budget
+
+```
+[TODO: Use your institution's budget template]
+[TODO: Common cost categories below -- delete or add as needed]
+- Personnel (research coordinator, statistician)
+- Equipment and supplies
+- Software licenses
+- Statistical consultation
+- Publication fees (open access APC)
+- Patient compensation (if applicable)
+```
+
+#### Section 10: References
+
+Generate a numbered reference list from:
+- Citations used in Section 1 (Background and Rationale)
+- Effect size sources from Section 3 (Sample Size Justification)
+- Any additional references from calc-sample-size output
+
+All references must have verified DOIs or PMIDs. Mark any unverified references
+as `[UNVERIFIED - NEEDS MANUAL CHECK]`.
+
+---
+
+## Output Format
+
+Generate a single markdown file: `protocol_draft.md`
+
+Requirements:
+- All 10 sections with clear numbering (1. through 10.)
+- Core sections (1-4) in full prose, no bullet points in body text
+- Skeleton sections (5-9) with `[TODO]` markers clearly visible
+- Word count targets noted in comments at the start of each core section
+- Institution name in the header if provided
+
+After generating, inform the user:
+1. Which sections are complete and ready for review
+2. Which `[TODO]` items require their input
+3. Recommended next steps (e.g., "Fill in Section 5 title and registration, then adapt Section 7 to your IRB form")
+
+---
+
+## Quality Checks
+
+Before delivering the protocol:
+
+1. **Citation integrity**: Every reference has a DOI or PMID, or is marked `[UNVERIFIED]`
+2. **Internal consistency**: Sample size in Section 3 matches the analysis plan in Section 4
+3. **Design alignment**: Study type in Section 2 matches the statistical approach in Section 4
+4. **TODO completeness**: All institution-specific items have `[TODO]` markers
+5. **Word counts**: Core sections fall within target ranges
+6. **No AI patterns**: Avoid phrases like "it is worth noting", "comprehensive", "plays a crucial role"
+
+## Anti-Hallucination
+
+- **Never fabricate references.** All citations must be verified via `/search-lit` with confirmed DOI or PMID. Mark unverified references as `[UNVERIFIED - NEEDS MANUAL CHECK]`.
+- **Never invent clinical definitions, diagnostic criteria, or guideline recommendations.** If uncertain, flag with `[VERIFY]` and ask the user.
+- **Never fabricate numerical results** — compliance percentages, scores, effect sizes, or sample sizes must come from actual data or analysis output.
+- If a reporting guideline item, journal policy, or clinical standard is uncertain, state the uncertainty rather than guessing.