medsci-skills 4.1.0

package/skills/self-review/scripts/check_reviewer_team_consistency.py

@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+"""
+check_reviewer_team_consistency.py — fabrication-grade self-review check.
+
+Detects manuscripts that simultaneously claim dual independent reviewers
+(in Methods + PROSPERO) and confess to single-reviewer execution (in
+Discussion §Limitations). Either claim alone is fine; the conjunction is
+a fabrication-grade red flag.
+
+Why this check exists
+=====================
+Cross-project precedent (anonymized): a reporting-quality SR-of-AI-tools
+manuscript had:
+- Methods: "Two reviewers independently screened titles and abstracts ..."
+- PROSPERO record: "Two independent reviewers will perform full-text
+  screening and data extraction."
+- Discussion §Limitations: "Single primary reviewer; a 20% sample by an
+  additional reviewer is deferred to before submission."
+
+The conjunction admits in Limitations what Methods denies in narrative
+form. Reviewers and editors who notice this read it as fabrication-grade
+(the manuscript misrepresents what was actually done) and reject.
+
+Detection strategy
+==================
+Section-aware grep for two regex families:
+- DUAL claim: "(independently|dual|two reviewers|both reviewers|two
+  independent)" within Methods OR a PROSPERO record file.
+- SINGLE confession: "(single primary reviewer|one additional reviewer|
+  20% sample|sample of records|deferred to before submission|due to
+  resource constraints|by the first reviewer alone)" within Limitations
+  OR Discussion.
+
+Both present → MAJOR self-review red flag.
+
+Two further fabrication-grade axes (the prose↔JSON↔confession 3-way):
+- LLM-AS-REVIEWER (fatal): a per-study extraction JSON whose reviewer /
+  screener / extractor / rater field is an LLM ("Claude", "GPT-4", "LLM",
+  "Gemini"). An LLM is a tool, not an independent reviewer; listing it as
+  one misrepresents the screening team regardless of the prose. Pass the
+  extraction JSON (file or directory) via --extraction-json.
+- DEFERRED-MITIGATION (MAJOR): a future-tense mitigation promise — "a 20%
+  sample will be completed before submission" — that is unmet at the time
+  the manuscript circulates. The promise is evidence the work is not done.
+
+Usage
+=====
+
+    python check_reviewer_team_consistency.py \\
+        --manuscript manuscript.md \\
+        --prospero prospero/record.md \\
+        --out _audit_self/reviewer_team_consistency.md
+
+Output
+======
+Markdown report at `--out` summarizing matches. Also a JSON sidecar at
+`--out` + ".json".
+
+Exit codes
+==========
+  0  no conflict
+  1  MAJOR red flag detected (both DUAL and SINGLE patterns present)
+  2  invocation error
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+DUAL_PATTERNS = [
+    (
+        re.compile(r"\btwo\s+(?:independent\s+)?reviewers?\b", re.IGNORECASE),
+        "two reviewers",
+    ),
+    (re.compile(r"\bdual\s+(?:independent\s+)?(?:reviewers?|extractors?)\b", re.IGNORECASE),
+     "dual reviewers"),
+    (re.compile(r"\bindependent(?:ly)?\s+screened\b", re.IGNORECASE), "independently screened"),
+    (
+        re.compile(r"\bboth\s+reviewers?\s+(?:independently|extracted|screened)\b", re.IGNORECASE),
+        "both reviewers",
+    ),
+    (
+        re.compile(r"\bindependent(?:ly)?\s+(?:extracted|coded|assessed)\b", re.IGNORECASE),
+        "independent extraction",
+    ),
+    (
+        re.compile(r"\bindependent\s+reviewers?\b", re.IGNORECASE),
+        "independent reviewers",
+    ),
+]
+
+SINGLE_PATTERNS = [
+    (re.compile(r"\bsingle\s+primary\s+reviewer\b", re.IGNORECASE), "single primary reviewer"),
+    (
+        re.compile(r"\bone\s+additional\s+reviewer\b", re.IGNORECASE),
+        "one additional reviewer",
+    ),
+    (
+        re.compile(r"\b20\s*%?\s+sample\b", re.IGNORECASE),
+        "20% sample",
+    ),
+    (
+        re.compile(r"\bsample\s+of\s+records\b", re.IGNORECASE),
+        "sample of records",
+    ),
+    (
+        re.compile(r"\bdeferred\s+to\s+before\s+submission\b", re.IGNORECASE),
+        "deferred to before submission",
+    ),
+    (
+        re.compile(r"\bdue\s+to\s+resource\s+constraints\b", re.IGNORECASE),
+        "due to resource constraints",
+    ),
+    (
+        re.compile(r"\b(?:by|with)\s+(?:the\s+)?first\s+reviewer\s+(?:alone|only)\b", re.IGNORECASE),
+        "first reviewer alone",
+    ),
+]
+
+
+# An LLM named where an independent reviewer should be (fatal). Bare "ai" is too
+# broad (matches names), so it is excluded; explicit model families + "LLM" only.
+LLM_NAME_RE = re.compile(
+    r"\b(?:claude|chatgpt|gpt-?\d|gpt|llm|large language model|gemini|copilot|bard|"
+    r"ai model|an ai\b)\b", re.IGNORECASE)
+REVIEWER_KEY_RE = re.compile(
+    r"reviewer|screener|extractor|rater|annotator|adjudicator|coder", re.IGNORECASE)
+
+# A future-tense mitigation promised but not yet executed at circulation.
+DEFERRED_MITIGATION_RE = re.compile(
+    r"(?:will be|to be|is to be|are to be)\s+"
+    r"(?:completed|performed|conducted|done|undertaken|carried out|finalized|finalised)\b"
+    r"[^.]{0,80}?(?:before|prior to|ahead of)\s+(?:final\s+)?submission",
+    re.IGNORECASE)
+
+
+SECTION_HEADERS = {
+    "Methods": re.compile(
+        r"^#{1,3}\s*\*{0,2}(?:METHODS?|Method[s]?|Materials and Methods)\*{0,2}\s*$",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "Discussion": re.compile(
+        r"^#{1,3}\s*\*{0,2}(?:DISCUSSION|Discussion)\*{0,2}\s*$",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "Limitations": re.compile(
+        r"^#{1,3}\s*\*{0,2}(?:LIMITATIONS?|Limitations?|Study Limitations)\*{0,2}\s*$",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+}
+
+
+@dataclass
+class Hit:
+    pattern_label: str
+    line: int
+    context: str
+
+
+@dataclass
+class Report:
+    submission_safe: bool
+    dual_hits: list[dict] = field(default_factory=list)
+    single_hits: list[dict] = field(default_factory=list)
+    llm_reviewer_hits: list[dict] = field(default_factory=list)
+    deferred_mitigation_hits: list[dict] = field(default_factory=list)
+
+
+def split_sections(text: str) -> dict[str, str]:
+    out: dict[str, str] = {name: "" for name in SECTION_HEADERS}
+    headers: list[tuple[str, int, int]] = []
+    for name, pat in SECTION_HEADERS.items():
+        for m in pat.finditer(text):
+            headers.append((name, m.start(), m.end()))
+    headers.sort(key=lambda t: t[1])
+    for i, (name, _, hdr_end) in enumerate(headers):
+        end = headers[i + 1][1] if i + 1 < len(headers) else len(text)
+        out[name] = (out[name] + "\n" + text[hdr_end:end]).strip()
+    return out
+
+
+def scan_text(text: str, patterns: list[tuple[re.Pattern[str], str]]) -> list[Hit]:
+    hits: list[Hit] = []
+    lines = text.splitlines()
+    for lineno, line in enumerate(lines, start=1):
+        for pat, label in patterns:
+            if pat.search(line):
+                ctx = line.strip()
+                if len(ctx) > 200:
+                    ctx = ctx[:200] + "..."
+                hits.append(Hit(pattern_label=label, line=lineno, context=ctx))
+    return hits
+
+
+def hit_to_dict(h: Hit, source: str) -> dict:
+    return {
+        "source": source,
+        "pattern": h.pattern_label,
+        "line": h.line,
+        "context": h.context,
+    }
+
+
+def _iter_extraction_files(path: Path):
+    if path.is_dir():
+        yield from sorted(path.rglob("*.json"))
+    elif path.is_file():
+        yield path
+
+
+def _walk_reviewer_fields(obj, source: str, hits: list[dict], keypath: str = "") -> None:
+    """Recursively find reviewer-role fields whose value names an LLM."""
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            kp = f"{keypath}.{k}" if keypath else str(k)
+            if isinstance(v, str) and REVIEWER_KEY_RE.search(str(k)) and LLM_NAME_RE.search(v):
+                hits.append({"source": source, "field": kp, "value": v[:120]})
+            _walk_reviewer_fields(v, source, hits, kp)
+    elif isinstance(obj, list):
+        for i, v in enumerate(obj):
+            _walk_reviewer_fields(v, source, hits, f"{keypath}[{i}]")
+
+
+def scan_llm_reviewers(extraction: Path | None) -> list[dict]:
+    hits: list[dict] = []
+    if extraction is None:
+        return hits
+    for f in _iter_extraction_files(extraction):
+        try:
+            data = json.loads(f.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+        _walk_reviewer_fields(data, f.name, hits)
+    return hits
+
+
+def scan_deferred_mitigation(manuscript: str) -> list[dict]:
+    hits: list[dict] = []
+    for lineno, line in enumerate(manuscript.splitlines(), start=1):
+        m = DEFERRED_MITIGATION_RE.search(line)
+        if m:
+            hits.append({"source": "manuscript", "line": lineno, "context": m.group(0).strip()[:160]})
+    return hits
+
+
+def build_report(manuscript: str, prospero: str | None,
+                 extraction: Path | None = None) -> Report:
+    sections = split_sections(manuscript)
+
+    dual_hits: list[dict] = []
+    single_hits: list[dict] = []
+
+    # Methods → DUAL evidence.
+    for h in scan_text(sections.get("Methods", ""), DUAL_PATTERNS):
+        dual_hits.append(hit_to_dict(h, "manuscript:Methods"))
+
+    # PROSPERO → DUAL evidence.
+    if prospero is not None:
+        for h in scan_text(prospero, DUAL_PATTERNS):
+            dual_hits.append(hit_to_dict(h, "prospero"))
+
+    # Discussion & Limitations → SINGLE evidence.
+    for region in ("Limitations", "Discussion"):
+        for h in scan_text(sections.get(region, ""), SINGLE_PATTERNS):
+            single_hits.append(hit_to_dict(h, f"manuscript:{region}"))
+
+    llm_reviewer_hits = scan_llm_reviewers(extraction)
+    deferred_hits = scan_deferred_mitigation(manuscript)
+
+    submission_safe = not (
+        (dual_hits and single_hits) or llm_reviewer_hits or deferred_hits
+    )
+    return Report(
+        submission_safe=submission_safe,
+        dual_hits=dual_hits,
+        single_hits=single_hits,
+        llm_reviewer_hits=llm_reviewer_hits,
+        deferred_mitigation_hits=deferred_hits,
+    )
+
+
+def _render_extra(lines: list[str], report: Report) -> None:
+    if report.llm_reviewer_hits:
+        lines.append("")
+        lines.append("## LLM-AS-REVIEWER (fatal)")
+        lines.append("An LLM is named where an independent reviewer is required:")
+        for h in report.llm_reviewer_hits:
+            lines.append(f"- `{h['source']}` field `{h['field']}` = {h['value']}")
+        lines.append("Fix: list a human reviewer; an LLM is a tool, not a member of the review team.")
+    if report.deferred_mitigation_hits:
+        lines.append("")
+        lines.append("## DEFERRED-MITIGATION (MAJOR)")
+        lines.append("A mitigation is promised in the future tense but not yet executed:")
+        for h in report.deferred_mitigation_hits:
+            lines.append(f"- line {h['line']}: {h['context']}")
+        lines.append("Fix: execute and report the mitigation before circulation, or remove the claim.")
+
+
+def render_markdown(report: Report) -> str:
+    lines = ["# Reviewer-team consistency audit", ""]
+    if report.submission_safe:
+        lines.append(
+            "Status: **PASS** — no conjunction of DUAL claim + SINGLE confession."
+        )
+        lines.append("")
+        if report.dual_hits:
+            lines.append(f"DUAL claims found ({len(report.dual_hits)}, OK alone):")
+            for h in report.dual_hits:
+                lines.append(f"- `{h['source']}` line {h['line']}: `{h['pattern']}` — {h['context']}")
+        if report.single_hits:
+            lines.append("")
+            lines.append(f"SINGLE confessions found ({len(report.single_hits)}, OK alone):")
+            for h in report.single_hits:
+                lines.append(f"- `{h['source']}` line {h['line']}: `{h['pattern']}` — {h['context']}")
+    else:
+        triggers = []
+        if report.dual_hits and report.single_hits:
+            triggers.append("DUAL claim + SINGLE confession")
+        if report.llm_reviewer_hits:
+            triggers.append("LLM-as-reviewer")
+        if report.deferred_mitigation_hits:
+            triggers.append("deferred mitigation")
+        lines.append(f"Status: **MAJOR red flag** — {', '.join(triggers)}.")
+        lines.append("")
+        lines.append("Reviewers will read this as fabrication-grade.")
+        if report.dual_hits and report.single_hits:
+            lines.append("")
+            lines.append("## DUAL claims (Methods / PROSPERO)")
+            for h in report.dual_hits:
+                lines.append(f"- `{h['source']}` line {h['line']}: `{h['pattern']}`")
+                lines.append(f"  > {h['context']}")
+            lines.append("")
+            lines.append("## SINGLE confessions (Discussion / Limitations)")
+            for h in report.single_hits:
+                lines.append(f"- `{h['source']}` line {h['line']}: `{h['pattern']}`")
+                lines.append(f"  > {h['context']}")
+        _render_extra(lines, report)
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Reviewer-team consistency check (fabrication-grade self-review)."
+    )
+    parser.add_argument("--manuscript", type=Path, required=True)
+    parser.add_argument("--prospero", type=Path, default=None)
+    parser.add_argument(
+        "--extraction-json", type=Path, default=None,
+        help="per-study extraction JSON file or directory (reviewer-field LLM scan)",
+    )
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=Path("_audit_self/reviewer_team_consistency.md"),
+    )
+    parser.add_argument("--quiet", action="store_true")
+    args = parser.parse_args(argv)
+
+    if not args.manuscript.is_file():
+        print(f"ERROR: manuscript not found: {args.manuscript}", file=sys.stderr)
+        return 2
+    prospero_text: str | None = None
+    if args.prospero is not None:
+        if not args.prospero.is_file():
+            print(f"ERROR: prospero not found: {args.prospero}", file=sys.stderr)
+            return 2
+        prospero_text = args.prospero.read_text(encoding="utf-8")
+    if args.extraction_json is not None and not args.extraction_json.exists():
+        print(f"ERROR: extraction-json not found: {args.extraction_json}", file=sys.stderr)
+        return 2
+
+    text = args.manuscript.read_text(encoding="utf-8")
+    report = build_report(text, prospero_text, args.extraction_json)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(render_markdown(report), encoding="utf-8")
+    json_out = args.out.with_suffix(args.out.suffix + ".json")
+    json_out.write_text(
+        json.dumps(
+            {
+                "submission_safe": report.submission_safe,
+                "dual_hits": report.dual_hits,
+                "single_hits": report.single_hits,
+                "llm_reviewer_hits": report.llm_reviewer_hits,
+                "deferred_mitigation_hits": report.deferred_mitigation_hits,
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+
+    if not args.quiet:
+        counts = (f"DUAL={len(report.dual_hits)} SINGLE={len(report.single_hits)} "
+                  f"LLM={len(report.llm_reviewer_hits)} "
+                  f"DEFERRED={len(report.deferred_mitigation_hits)}")
+        if report.submission_safe:
+            print(f"PASS: no fabrication-grade conflict. {counts}")
+        else:
+            print(f"FAIL: MAJOR red flag. {counts}")
+            print(f"See {args.out}")
+
+    return 0 if report.submission_safe else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/self-review/scripts/check_scope_coherence.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Endpoint↔conclusion scope-coherence gate (self-review §D).
+
+Two overclaim patterns where the conclusion's action exceeds what the design or
+endpoint can support. Both are deterministic when a design/endpoint signal and a
+conclusion action verb co-occur, and both are documented anti-patterns
+(scope-coherence-gate.md):
+
+  CROSS_SECTIONAL_PROGNOSTIC  the design is cross-sectional / single-visit /
+                              prevalence, yet the conclusion makes a prognostic or
+                              surveillance claim (rescreen interval, surveillance,
+                              disease progression, predicting future risk). A single
+                              time point cannot license a longitudinal conclusion.
+  SURROGATE_CARE_DIRECTIVE    a binary surrogate endpoint (present/absent, >0,
+                              dichotomized) drives a patient-care directive (defer,
+                              withhold, initiate/discontinue therapy, statin). A
+                              risk-stratification marker is not a management trigger.
+
+The gate is conservative: it fires only when both a signal and a conclusion-region
+verb are present, to keep false positives low on a widely-used skill.
+
+INPUTS
+  --manuscript  manuscript markdown/text (required).
+
+OUTPUT
+  A reconciliation table (stdout) and, with --out, a JSON artifact:
+    {manuscript, claims[{verdict, severity, detail, where}], summary}
+  Both verdicts are Major. Exit 1 (with --strict) when any Major claim exists.
+
+Stdlib-only (json / re / argparse / pathlib). Exit codes: 0 clean (or report-only),
+1 Major claim(s) found (with --strict), 2 input/usage error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+DESIGN_CROSS_SECTIONAL = re.compile(
+    r"cross[-\s]?sectional|single[-\s](?:time[-\s]?point|visit|examination|measurement)|"
+    r"at (?:a |one )?(?:single |one )?time[-\s]?point|point[-\s]prevalence|"
+    r"prevalence (?:study|survey|design)", re.IGNORECASE)
+
+PROGNOSTIC_VERB = re.compile(
+    r"surveillance|re[-\s]?screen|screening interval|rescreening|"
+    r"monitor(?:ed|ing)?\s+over\s+time|disease progression|progress(?:es|ion)\s+to|"
+    r"prognost|predict(?:s|ing|ed)?\s+(?:incident|future|long[-\s]?term|the risk of developing)|"
+    r"longitudinal (?:follow|risk|trajector)", re.IGNORECASE)
+
+DIRECTIVE_VERB = re.compile(
+    r"\bdefer(?:ral|red|ring)?\b|\bwithhold\b|\bforgo\b|\binitiat(?:e|ed|ion)\b|"
+    r"\bdiscontinu(?:e|ed|ation)\b|start(?:ing)?\s+(?:statin|therapy|treatment|pharmacotherapy)|"
+    r"(?:statin|treatment|therapy|pharmacotherapy)\s+(?:can|should|may)\s+be\s+(?:deferred|withheld|started|initiated)|"
+    r"recommend(?:ed)?\s+(?:statin|treatment|therapy|initiation|against treatment)|"
+    r"guide\s+(?:treatment|management|therapy)", re.IGNORECASE)
+
+SURROGATE_SIGNAL = re.compile(
+    r"binary (?:surrogate|endpoint|outcome|marker)|dichotom(?:ous|ised|ized)|surrogate (?:endpoint|marker|outcome)|"
+    r"presence (?:or absence )?of|present (?:vs\.?|versus|or) absent|positive (?:vs\.?|versus|or) negative|"
+    r"categor(?:ised|ized) as (?:positive|present|absent)|>\s?0\b", re.IGNORECASE)
+
+CONCLUSION_HEADINGS = re.compile(
+    r"^#{1,4}\s*\*{0,2}(?:CONCLUSIONS?|Conclusions?|DISCUSSION|Discussion|"
+    r"Clinical Implications?|Interpretation)\*{0,2}\s*$", re.IGNORECASE | re.MULTILINE)
+
+
+def conclusion_region(text: str) -> str:
+    """Text under Conclusion/Discussion/Implications headings, plus any inline
+    'Conclusion:' clause (abstract). Fallback: the last 25% of the document."""
+    spans = []
+    starts = [m.end() for m in CONCLUSION_HEADINGS.finditer(text)]
+    # heading-delimited regions: from each heading to the next top-level heading
+    all_headings = [m.start() for m in re.finditer(r"^#{1,4}\s", text, re.MULTILINE)]
+    for s in starts:
+        nxt = next((h for h in all_headings if h > s), len(text))
+        spans.append(text[s:nxt])
+    for m in re.finditer(r"(?:^|\n)\s*\*{0,2}Conclusions?\*{0,2}\s*[:.]\s*(.+?)(?:\n\n|$)",
+                         text, re.IGNORECASE | re.DOTALL):
+        spans.append(m.group(1))
+    if not spans:
+        spans.append(text[int(len(text) * 0.75):])
+    return "\n".join(spans)
+
+
+def check(text: str) -> list[dict]:
+    claims = []
+    concl = conclusion_region(text)
+
+    if DESIGN_CROSS_SECTIONAL.search(text):
+        pm = PROGNOSTIC_VERB.search(concl)
+        if pm:
+            claims.append({
+                "verdict": "CROSS_SECTIONAL_PROGNOSTIC",
+                "severity": "Major",
+                "detail": (f"cross-sectional/single-visit design, but the conclusion makes a "
+                           f"prognostic/surveillance claim ('{pm.group(0).strip()}')"),
+                "where": concl[max(0, pm.start() - 40):pm.end() + 40].strip()[:160],
+            })
+
+    dm = DIRECTIVE_VERB.search(concl)
+    sm = SURROGATE_SIGNAL.search(concl)
+    if dm and sm:
+        claims.append({
+            "verdict": "SURROGATE_CARE_DIRECTIVE",
+            "severity": "Major",
+            "detail": (f"a binary surrogate endpoint ('{sm.group(0).strip()}') drives a "
+                       f"patient-care directive ('{dm.group(0).strip()}') in the conclusion"),
+            "where": concl[max(0, dm.start() - 40):dm.end() + 40].strip()[:160],
+        })
+
+    return claims
+
+
+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)
+    claims = check(p.read_text(encoding="utf-8"))
+    n_major = sum(1 for c in claims if c["severity"] == "Major")
+    return {
+        "manuscript": str(p),
+        "claims": claims,
+        "summary": {
+            "n_claims": len(claims),
+            "n_major": n_major,
+            "n_flag": len(claims) - n_major,
+            "verdict": "MAJOR_CANDIDATE" if n_major else "OK",
+        },
+    }
+
+
+def render(result: dict) -> str:
+    lines = ["| Check | Severity | Detail |", "|---|---|---|"]
+    for c in result["claims"]:
+        lines.append(f"| {c['verdict']} | {c['severity']} | {c['detail']} |")
+    if len(lines) == 2:
+        lines.append("| (none) | — | conclusion scope matches the design/endpoint |")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Endpoint↔conclusion scope-coherence gate (§D).")
+    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 if any Major claim exists")
+    ap.add_argument("--quiet", action="store_true", help="suppress stdout table")
+    args = ap.parse_args()
+
+    result = analyze(args.manuscript)
+
+    if not args.quiet:
+        print("=" * 41)
+        print(" Scope Coherence (§D)")
+        print("=" * 41)
+        print(render(result))
+        print()
+        s = result["summary"]
+        if s["n_major"]:
+            print(f"MAJOR candidate: {s['n_major']} endpoint↔conclusion scope mismatch(es).")
+        else:
+            print("OK: conclusion scope matches the design/endpoint.")
+
+    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}")
+
+    return 1 if (args.strict and result["summary"]["n_major"]) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/self-review/skill.yml

@@ -0,0 +1,47 @@
+schema_version: 2
+name: self-review
+layer: D
+owner_domain: own_manuscript_critique
+when_to_use:
+  - Pre-submission self-criticism on the user's own manuscript across 10 review categories
+  - Generating Anticipated Major / Minor Comments before sending to senior co-authors
+  - Phase 2.5a numerical source-fidelity audit (CSV ↔ analysis ↔ manuscript ↔ primary paper)
+  - Producing R0-numbered comments that flow into /revise for the response document
+  - Multi-agent panel review (--panel) — parallel domain-expert reviewers + editor synthesis for a high-stakes pre-submission final pass
+when_NOT_to_use:
+  - Reviewing external (assigned) manuscripts (use /peer-review)
+  - Drafting the user's manuscript (use /write-paper)
+  - Generating reviewer-response prose (use /revise)
+  - Silently fixing non-AI-fixable issues without surfacing them to the user (forbidden)
+inputs:
+  - manuscript/manuscript.md
+outputs:
+  - qc/self_review.md
+  - qc/self_review.json
+  - qc/reference_adequacy.json
+deterministic_scripts:
+  - scripts/check_reference_adequacy.py
+side_effects:
+  - may_edit_manuscript_when_fix_flag_set
+downstream_consumers:
+  - revise
+  - sync-submission
+forbidden_actions:
+  - review_external_manuscripts_as_peer_reviewer
+  - silently_fix_non_ai_fixable_issues
+
+# v2.1 quality card
+purpose: "Pre-submission self-review of the user's own manuscript from a reviewer's perspective across 10 categories, with severity-framed anticipated comments."
+safety_boundaries:
+  - "Reviews the user's own manuscript only; not for reviewing external (journal-assigned) manuscripts."
+  - "Does not silently fix non-AI-fixable issues; it flags them for the author."
+known_limitations:
+  - "Anticipates likely reviewer comments; cannot predict a specific reviewer's focus."
+  - "Advisory; produces recommendations, not manuscript edits."
+validation_commands:
+  - "python3 scripts/check_reviewer_team_consistency.py"
+  - "python3 scripts/check_domain_probe_sync.py --strict"
+  - "bash tests/test_panel_mode.sh"
+  - "bash tests/test_reference_adequacy.sh"
+  - "feed R0-numbered output into /revise"
+evidence_surface: demo

package/skills/self-review/tests/fixtures/claim_manuscript.md

@@ -0,0 +1,17 @@
+# Synthetic manuscript fixture (claim-vs-artifact test)
+
+## Methods
+
+The primary analysis was the association between emphysema and all-cause mortality
+estimated by a multiple-imputation Cox model. This primary endpoint was re-designated
+at the manuscript stage from the pre-specified complete-case model after the imputed
+estimate was found to be more favourable.
+
+## Results
+
+In the primary model, emphysema was not associated with all-cause mortality. The
+E-value for the primary association (HR 1.34) was 2.79, which we interpret as robust
+to unmeasured confounding.
+
+In an exploratory analysis, the E-value for the cancer-specific subdistribution hazard
+(sHR 2.25) was 3.93, suggesting the cancer signal is hard to explain away.

package/skills/self-review/tests/fixtures/claim_prereg.md

@@ -0,0 +1,6 @@
+# Synthetic pre-registration fixture (claim-vs-artifact test)
+
+Primary outcome: the association between emphysema and all-cause mortality in the
+complete-case multivariable Cox model is the primary analysis of this study.
+
+Secondary outcomes: cause-specific mortality (cancer, cardiovascular, respiratory).

package/skills/self-review/tests/fixtures/cohort_bad.md

@@ -0,0 +1,21 @@
+# Results
+
+## Incidence
+
+During follow-up there were 120 events over 50,000 person-years, an incidence
+rate of 5.0 per 1,000 person-years.
+
+## Study population
+
+Of 4,252 participants, 583 had missing data, leaving 3,667 in the analytic cohort.
+
+## Risk by tier
+
+The cohort was partitioned into three mutually exclusive risk tiers.
+
+| Risk tier | n | events |
+| --- | --- | --- |
+| Low | 5,000 | 30 |
+| Medium | 4,000 | 50 |
+| High | 3,498 | 45 |
+| Total | 12,019 | 115 |