medsci-skills 4.1.0

package/skills/sync-submission/scripts/scope_drift_check.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""
+scope_drift_check.py — Phase 6 intra-manuscript scope drift detection.
+
+Detects two related failure modes:
+
+1. **Numeric anchor in Limitations only**: an AUC / OR / HR / RR /
+   sensitivity / specificity value appears in the Limitations or Discussion
+   section but is absent from Methods + Results. This is a strong indicator
+   that a late-revision sensitivity analysis was introduced without
+   propagating to the primary report, leaving the manuscript's stated scope
+   inconsistent with its prose-level claims.
+
+2. **PROSPERO ↔ Methods synthesis-method drift**: the PROSPERO record
+   commits to a synthesis method (e.g., Freeman-Tukey transformation,
+   random-effects DerSimonian-Laird, bivariate, HSROC, Bayesian) but the
+   Methods section silently uses a different one — or vice versa. This
+   is a documented "silent protocol deviation" pattern that reviewers
+   flag as fabrication-grade if accompanied by a "no amendment lodged"
+   PROSPERO note.
+
+Why this gate exists
+====================
+Cross-project precedents (anonymized):
+- Project (DTA-MA example, reporting-quality SR variant): a leave-pair-out
+  sensitivity envelope appeared in Limitations with five AUC values and
+  four CIs. The primary pool AUC `0.869` was not reported in Methods or
+  Results.
+- Project (intervention-MA example): PROSPERO committed to Freeman-Tukey
+  pooled-proportion; Methods said descriptive-only Python with no R; the
+  manuscript line "no amendment lodged" turned the silent change into a
+  documented violation.
+
+P0 active-fix pattern when caught.
+
+Usage
+=====
+
+    python scope_drift_check.py \\
+        --manuscript manuscript.md \\
+        --prospero prospero/prospero_v2.md \\
+        --out qc/scope_drift.json
+
+    python scope_drift_check.py \\
+        --manuscript manuscript.md \\
+        --out qc/scope_drift.json
+
+Output (qc/scope_drift.json):
+
+    {
+      "submission_safe": false,
+      "limitations_only_anchors": [
+        {"anchor": "0.869", "kind": "AUC",
+         "found_in": ["Limitations:31"], "missing_from": ["Methods", "Results"]}
+      ],
+      "synthesis_method_drift": [
+        {"method": "Freeman-Tukey", "prospero": true, "methods": false}
+      ]
+    }
+
+Exit codes:
+    0 — no drift
+    1 — drift detected
+    2 — invocation error
+
+Read-only script. No file modification.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+# Section detection — case-insensitive header match. We deliberately accept
+# common variants seen in radiology / MA manuscripts: bolded all-caps
+# (`## **METHODS**`), Title Case (`## Methods`), and Markdown subsections.
+SECTION_HEADERS: dict[str, re.Pattern[str]] = {
+    "Methods": re.compile(
+        r"^#{1,3}\s*\*{0,2}(?:METHODS?|Method[s]?|Materials and Methods)\*{0,2}\s*$",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "Results": re.compile(
+        r"^#{1,3}\s*\*{0,2}(?:RESULTS?|Result[s]?|Findings)\*{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,
+    ),
+    "Conclusion": re.compile(
+        r"^#{1,3}\s*\*{0,2}(?:CONCLUSIONS?|Conclusion[s]?)\*{0,2}\s*$",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+}
+
+
+# Numeric anchor patterns. We bias toward conservative matchers: false
+# positives (e.g. "0.50%" from a table) are easier to triage than false
+# negatives (a missed AUC). Each entry yields a canonical "anchor" string.
+ANCHOR_PATTERNS = [
+    # AUC: 0.600-0.999 (typical study range, excludes test-set 0.5 floor)
+    ("AUC", re.compile(r"\b(0\.[6-9]\d{2})\b")),
+    # OR / HR / RR / aOR / aHR with explicit label
+    (
+        "RiskRatio",
+        re.compile(
+            r"\b(?:aOR|aHR|OR|HR|RR)\s*[=:]\s*(\d+\.\d+)\b",
+            re.IGNORECASE,
+        ),
+    ),
+    # Sensitivity / specificity with explicit label
+    (
+        "SnSp",
+        re.compile(
+            r"\b(?:Sn|Sp|sens(?:itivity)?|spec(?:ificity)?)\s*[=:]\s*"
+            r"(\d+(?:\.\d+)?%?)\b",
+            re.IGNORECASE,
+        ),
+    ),
+]
+
+
+# Synthesis method keywords (case-insensitive substring search). When the
+# PROSPERO record names a method that does NOT appear in Methods (or
+# vice-versa), emit a drift.
+SYNTHESIS_METHODS = [
+    "Freeman-Tukey",
+    "Mantel-Haenszel",
+    "DerSimonian-Laird",
+    "REML",
+    "bivariate",
+    "HSROC",
+    "Bayesian",
+    "random-effects",
+    "fixed-effect",
+    "fixed-effects",
+    "Egger",
+    "I²",
+    "Wilson",
+    "Clopper-Pearson",
+]
+
+
+@dataclass
+class LimitsOnlyAnchor:
+    anchor: str
+    kind: str
+    found_in: list[str]
+    missing_from: list[str]
+
+
+@dataclass
+class SynthesisDrift:
+    method: str
+    prospero: bool
+    methods: bool
+
+
+@dataclass
+class Report:
+    submission_safe: bool
+    limitations_only_anchors: list[LimitsOnlyAnchor] = field(default_factory=list)
+    synthesis_method_drift: list[SynthesisDrift] = field(default_factory=list)
+
+    def as_dict(self) -> dict:
+        return {
+            "submission_safe": self.submission_safe,
+            "limitations_only_anchors": [asdict(a) for a in self.limitations_only_anchors],
+            "synthesis_method_drift": [asdict(s) for s in self.synthesis_method_drift],
+        }
+
+
+def split_sections(text: str) -> dict[str, str]:
+    """Return mapping of section name → body text. Sections without a header
+    return empty string. Body extends from the matched header to the next
+    matched header in the document."""
+    # Compute (name, start, end_of_header_line) per match across the doc.
+    hits: list[tuple[str, int, int]] = []
+    for name, pat in SECTION_HEADERS.items():
+        for m in pat.finditer(text):
+            hits.append((name, m.start(), m.end()))
+    hits.sort(key=lambda t: t[1])
+
+    out: dict[str, str] = {name: "" for name in SECTION_HEADERS}
+    for i, (name, start, hdr_end) in enumerate(hits):
+        body_start = hdr_end
+        body_end = hits[i + 1][1] if i + 1 < len(hits) else len(text)
+        out[name] = (out[name] + "\n" + text[body_start:body_end]).strip()
+    return out
+
+
+def find_anchors(text: str) -> list[tuple[str, str]]:
+    """Return (anchor_string, kind) tuples found in text."""
+    out: list[tuple[str, str]] = []
+    for kind, pat in ANCHOR_PATTERNS:
+        for m in pat.finditer(text):
+            anchor = m.group(1)
+            out.append((anchor, kind))
+    return out
+
+
+def line_numbers(text: str, needle: str) -> list[int]:
+    """Return 1-based line numbers in text containing the literal needle."""
+    out: list[int] = []
+    for i, line in enumerate(text.splitlines(), start=1):
+        if needle in line:
+            out.append(i)
+    return out
+
+
+def detect_limits_only(text: str) -> list[LimitsOnlyAnchor]:
+    sections = split_sections(text)
+    limits = sections.get("Limitations", "")
+    discussion = sections.get("Discussion", "")
+    methods = sections.get("Methods", "")
+    results = sections.get("Results", "")
+
+    # Anchors that appear in Limitations OR Discussion but NOT in Methods or
+    # Results. We include Discussion because in many manuscripts the
+    # Limitations subsection is folded into Discussion without an explicit
+    # `## Limitations` header.
+    out: list[LimitsOnlyAnchor] = []
+    seen: set[tuple[str, str]] = set()
+    for region_name, region_text in (("Limitations", limits), ("Discussion", discussion)):
+        for anchor, kind in find_anchors(region_text):
+            if (anchor, kind) in seen:
+                continue
+            in_methods = anchor in methods
+            in_results = anchor in results
+            if not in_methods and not in_results:
+                lineno = line_numbers(text, anchor)
+                found_label = f"{region_name}:{lineno[0]}" if lineno else region_name
+                out.append(
+                    LimitsOnlyAnchor(
+                        anchor=anchor,
+                        kind=kind,
+                        found_in=[found_label],
+                        missing_from=["Methods", "Results"],
+                    )
+                )
+                seen.add((anchor, kind))
+    return out
+
+
+def detect_synthesis_drift(
+    manuscript_text: str,
+    prospero_text: str | None,
+) -> list[SynthesisDrift]:
+    if prospero_text is None:
+        return []
+    sections = split_sections(manuscript_text)
+    methods_text = sections.get("Methods", "")
+    out: list[SynthesisDrift] = []
+    for method in SYNTHESIS_METHODS:
+        # case-insensitive presence
+        in_prospero = method.lower() in prospero_text.lower()
+        in_methods = method.lower() in methods_text.lower()
+        if in_prospero != in_methods:
+            out.append(
+                SynthesisDrift(
+                    method=method,
+                    prospero=in_prospero,
+                    methods=in_methods,
+                )
+            )
+    return out
+
+
+def build_report(
+    manuscript_path: Path,
+    prospero_path: Path | None,
+) -> Report:
+    text = manuscript_path.read_text(encoding="utf-8")
+    prospero_text: str | None = None
+    if prospero_path is not None and prospero_path.is_file():
+        prospero_text = prospero_path.read_text(encoding="utf-8")
+
+    limits_only = detect_limits_only(text)
+    synth_drift = detect_synthesis_drift(text, prospero_text)
+    submission_safe = not limits_only and not synth_drift
+    return Report(
+        submission_safe=submission_safe,
+        limitations_only_anchors=limits_only,
+        synthesis_method_drift=synth_drift,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Phase 6 intra-manuscript scope drift detection. Flags numeric "
+            "anchors that appear only in Limitations/Discussion (not Methods/"
+            "Results) and PROSPERO↔Methods synthesis-method disagreement."
+        )
+    )
+    parser.add_argument(
+        "--manuscript",
+        type=Path,
+        required=True,
+        help="Path to manuscript.md (markdown).",
+    )
+    parser.add_argument(
+        "--prospero",
+        type=Path,
+        default=None,
+        help=(
+            "Path to PROSPERO record markdown. When supplied, also performs "
+            "synthesis-method cross-check vs Methods."
+        ),
+    )
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=None,
+        help="Write JSON report to this path.",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress stdout summary.",
+    )
+    args = parser.parse_args(argv)
+
+    if not args.manuscript.is_file():
+        parser.error(f"--manuscript not a file: {args.manuscript}")
+    if args.prospero is not None and not args.prospero.is_file():
+        parser.error(f"--prospero not a file: {args.prospero}")
+
+    report = build_report(args.manuscript, args.prospero)
+
+    if args.out is not None:
+        args.out.parent.mkdir(parents=True, exist_ok=True)
+        args.out.write_text(json.dumps(report.as_dict(), indent=2), encoding="utf-8")
+
+    if not args.quiet:
+        if report.submission_safe:
+            print("PASS: no scope drift detected.")
+        else:
+            print(
+                f"FAIL: {len(report.limitations_only_anchors)} limits-only anchor(s), "
+                f"{len(report.synthesis_method_drift)} synthesis drift(s)."
+            )
+            for a in report.limitations_only_anchors:
+                print(f"  - SCOPE_DRIFT {a.kind} {a.anchor!r} found in {a.found_in}, "
+                      f"missing from {a.missing_from}")
+            for s in report.synthesis_method_drift:
+                print(f"  - PROSPERO_DRIFT {s.method} prospero={s.prospero} methods={s.methods}")
+
+    return 0 if report.submission_safe else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/sync-submission/scripts/sync_submission.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Audit and build submission packages from canonical manuscript sources."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import sys
+from datetime import date
+from pathlib import Path
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+            h.update(chunk)
+    return "sha256:" + h.hexdigest()
+
+
+def read_project_yaml(path: Path) -> dict[str, str]:
+    data: dict[str, str] = {}
+    if not path.exists():
+        return data
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        data[key.strip()] = value.strip().strip('"').strip("'")
+    return data
+
+
+def resolve_canonical(project_root: Path, explicit: str | None) -> Path:
+    if explicit:
+        path = Path(explicit)
+        return path if path.is_absolute() else project_root / path
+    project = read_project_yaml(project_root / "project.yaml")
+    rel = project.get("canonical_manuscript", "manuscript/manuscript.md")
+    return project_root / rel
+
+
+def submission_md_path(project_root: Path, journal: str) -> Path:
+    return project_root / "submission" / journal / "manuscript" / "manuscript.md"
+
+
+def write_json(path: Path, payload: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def load_json(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def update_manifest(project_root: Path, journal: str, meta_rel: str, status: str, source_hash: str) -> None:
+    manifest_path = project_root / "artifact_manifest.json"
+    manifest = load_json(manifest_path) or {"schema_version": 1, "submissions": {}}
+    manifest.setdefault("schema_version", 1)
+    manifest.setdefault("submissions", {})
+    manifest["submissions"][journal] = {
+        "path": f"submission/{journal}",
+        "metadata": meta_rel,
+        "status": status,
+        "source_hash": source_hash,
+    }
+    write_json(manifest_path, manifest)
+
+
+def audit(project_root: Path, journal: str, canonical: Path) -> int:
+    qc_path = project_root / "qc" / f"submission_sync_{journal}.json"
+    sub_path = submission_md_path(project_root, journal)
+    if not canonical.exists():
+        write_json(qc_path, {"schema_version": 1, "journal": journal, "status": "ERROR", "message": "canonical manuscript missing"})
+        return 2
+    source_hash = sha256_file(canonical)
+    meta_path = project_root / "submission" / journal / ".journal_meta.json"
+    meta = load_json(meta_path)
+    current_hash = sha256_file(sub_path) if sub_path.exists() else None
+    recorded_hash = meta.get("source_hash")
+    drift = bool(sub_path.exists() and current_hash != source_hash)
+    status = "DRIFT" if drift else "CURRENT" if sub_path.exists() else "MISSING_SUBMISSION"
+    payload = {
+        "schema_version": 1,
+        "journal": journal,
+        "status": status,
+        "canonical": str(canonical.relative_to(project_root)),
+        "submission_manuscript": str(sub_path.relative_to(project_root)),
+        "source_hash": source_hash,
+        "submission_hash": current_hash,
+        "recorded_source_hash": recorded_hash,
+        "message": "Submission differs from canonical manuscript" if drift else "",
+    }
+    write_json(qc_path, payload)
+    print(json.dumps(payload, indent=2))
+    return 1 if drift else 0
+
+
+def build(project_root: Path, journal: str, canonical: Path) -> int:
+    if not canonical.exists():
+        print(f"Canonical manuscript missing: {canonical}", file=sys.stderr)
+        return 2
+    sub_path = submission_md_path(project_root, journal)
+    sub_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(canonical, sub_path)
+    source_hash = sha256_file(canonical)
+    meta_path = project_root / "submission" / journal / ".journal_meta.json"
+    meta = {
+        "schema_version": 1,
+        "journal": journal,
+        "status": "built",
+        "canonical": str(canonical.relative_to(project_root)),
+        "submission_manuscript": str(sub_path.relative_to(project_root)),
+        "source_hash": source_hash,
+        "built_date": date.today().isoformat(),
+        "frozen": False,
+    }
+    write_json(meta_path, meta)
+    update_manifest(project_root, journal, str(meta_path.relative_to(project_root)), "built", source_hash)
+    return audit(project_root, journal, canonical)
+
+
+def freeze(project_root: Path, journal: str, canonical: Path, status: str) -> int:
+    audit_code = audit(project_root, journal, canonical)
+    if audit_code != 0:
+        print("Cannot freeze a drifted or invalid submission package.", file=sys.stderr)
+        return audit_code
+    meta_path = project_root / "submission" / journal / ".journal_meta.json"
+    meta = load_json(meta_path)
+    meta.update({"status": status, "frozen": True, "frozen_date": date.today().isoformat()})
+    write_json(meta_path, meta)
+    update_manifest(project_root, journal, str(meta_path.relative_to(project_root)), status, meta.get("source_hash", ""))
+    print(json.dumps(meta, indent=2))
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Audit or build journal submission package.")
+    parser.add_argument("mode", choices=["audit", "build", "freeze"])
+    parser.add_argument("--project-root", default=".")
+    parser.add_argument("--journal", required=True)
+    parser.add_argument("--canonical")
+    parser.add_argument("--status", default="submitted")
+    args = parser.parse_args()
+
+    project_root = Path(args.project_root).resolve()
+    canonical = resolve_canonical(project_root, args.canonical).resolve()
+    try:
+        canonical.relative_to(project_root)
+    except ValueError:
+        print("Canonical manuscript must be inside project root.", file=sys.stderr)
+        return 2
+
+    if args.mode == "audit":
+        return audit(project_root, args.journal, canonical)
+    if args.mode == "build":
+        return build(project_root, args.journal, canonical)
+    return freeze(project_root, args.journal, canonical, args.status)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/sync-submission/skill.yml

@@ -0,0 +1,43 @@
+schema_version: 2
+name: sync-submission
+layer: A
+owner_domain: submission_packaging
+when_to_use:
+  - Auditing SSOT-to-submission drift before freezing a journal package
+  - Building a journal-specific submission manifest from canonical manuscript artifacts
+  - Retargeting an existing submission to a new journal (cascade rejection)
+  - Refreshing artifact_manifest.json to reflect the current canonical state
+when_NOT_to_use:
+  - Drafting or editing the canonical manuscript (use /write-paper or /revise)
+  - Choosing the target journal (use /find-journal)
+  - Freezing a submission while drift is detected (forbidden — fix drift first)
+inputs:
+  - project.yaml
+  - manuscript/manuscript.md
+outputs:
+  - submission/{journal}/.journal_meta.json
+  - qc/submission_sync_{journal}.json
+  - artifact_manifest.json
+deterministic_scripts:
+  - scripts/sync_submission.py
+side_effects:
+  - writes_project_artifacts
+downstream_consumers:
+  - orchestrate
+  - find-journal
+forbidden_actions:
+  - silently_edit_canonical_manuscript
+  - freeze_drifted_submission
+
+# v2.1 quality card
+purpose: "Audit SSOT-to-submission drift and build journal submission manifests from canonical manuscript artifacts."
+safety_boundaries:
+  - "Never silently edits the canonical manuscript; a drifted submission is not frozen until reconciled."
+  - "Submission packages are derived from canonical sources, not hand-assembled."
+known_limitations:
+  - "Detects drift it is configured to scan (counts, cover-letter fields, scope); portal free-text fields still need a human check."
+  - "A clean audit is necessary, not sufficient, for acceptance."
+validation_commands:
+  - "python3 scripts/sync_submission.py"
+  - "python3 scripts/cross_document_n_check.py"
+evidence_surface: bundled_script

package/skills/sync-submission/tests/fixtures/copy_ok.md

@@ -0,0 +1,5 @@
+## Methods
+After re-lock the analytic cohort comprised n = 998 participants. Emphysema was
+associated with mortality (HR 1.34), not significant (p = 0.074); prevalence 12.5%.
+## Results
+The adjusted estimate was OR 2.25 in the exploratory analysis.

package/skills/sync-submission/tests/fixtures/copy_stale.md

@@ -0,0 +1,5 @@
+## Methods
+The analytic cohort comprised n = 998 participants. Emphysema was associated with
+mortality (HR 1.34) but this was not significant. Prevalence was 12.5%.
+## Results
+The adjusted estimate was OR 2.25 in the exploratory analysis.

package/skills/sync-submission/tests/fixtures/ssot.md

@@ -0,0 +1,5 @@
+## Methods
+The analytic cohort comprised n = 998 participants. Emphysema was associated with
+mortality (HR 1.34) but this was not significant (p = 0.074). Prevalence was 12.5%.
+## Results
+The adjusted estimate was OR 2.25 in the exploratory analysis.

package/skills/sync-submission/tests/test_asset_anonymization.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Test scripts/check_asset_anonymization.py — the A2 asset-anonymization gate.
+# Synthetic, PII-free fixtures: a figure script with a generic institution token,
+# a docx with a (synthetic) author metadata, a --names-file name hit, and clean
+# counterparts. Stdlib-only; does not require poppler (PDF paths are exercised
+# only opportunistically).
+set -u
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT="$HERE/../scripts/check_asset_anonymization.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 ---
+mkdir -p "$WORK/leaky/figures" "$WORK/clean/figures"
+
+# figure script with an institution token (review-severity)
+cat > "$WORK/leaky/figures/flow.R" <<'EOF'
+# CONSORT flow diagram
+label <- "Recruited at General Hospital, 2020-2024"
+plot(1:10)
+EOF
+# clean figure script
+cat > "$WORK/clean/figures/plot.py" <<'EOF'
+import matplotlib.pyplot as plt
+plt.plot([1, 2, 3]); plt.savefig("fig1.png")
+EOF
+# figure script with a name that only --names-file knows (leak-severity)
+cat > "$WORK/leaky/figures/panel.py" <<'EOF'
+caption = "Data from Mercy Riverside Clinic cohort"
+EOF
+cat > "$WORK/names.txt" <<'EOF'
+Mercy Riverside Clinic
+EOF
+
+# build a docx with synthetic author metadata (leak) and a clean one (tool author)
+python3 - "$WORK" <<'PY'
+import sys, zipfile, os
+work = sys.argv[1]
+def make_docx(path, creator):
+    core = (
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+        '<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" '
+        'xmlns:dc="http://purl.org/dc/elements/1.1/">'
+        f'<dc:creator>{creator}</dc:creator>'
+        f'<cp:lastModifiedBy>{creator}</cp:lastModifiedBy>'
+        '</cp:coreProperties>'
+    )
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("docProps/core.xml", core)
+        z.writestr("word/document.xml", "<w:document/>")
+make_docx(os.path.join(work, "leaky", "manuscript.docx"), "Alex P. Investigator")
+make_docx(os.path.join(work, "clean", "manuscript.docx"), "Microsoft Office User")
+PY
+
+run() { python3 "$SCRIPT" "$@" 2>/dev/null; }
+
+# 1. leaky dir (no names file): docx author leak -> exit 1
+run --dir "$WORK/leaky" --quiet
+[ $? -eq 1 ] && ok "leaky dir fails (docx author leak)" || bad "leaky dir should fail"
+
+# 2. JSON reports the docx author + institution token finding types
+out="$(run --dir "$WORK/leaky" --names-file "$WORK/names.txt" --out "$WORK/r.json"; cat "$WORK/r.json")"
+echo "$out" | python3 -c "
+import json,sys
+d=json.load(open('$WORK/r.json'))
+types={f['type'] for f in d['findings']}
+need={'docx_metadata_author','figure_script_institution','figure_script_name'}
+sys.exit(0 if need <= types and d['submission_safe'] is False else 1)
+" && ok "JSON: docx author + institution + name-file findings" || bad "JSON findings incomplete"
+
+# 3. name-file hit is a 'leak'
+run --dir "$WORK/leaky" --names-file "$WORK/names.txt" --out "$WORK/r2.json" --quiet
+python3 -c "
+import json,sys
+d=json.load(open('$WORK/r2.json'))
+sys.exit(0 if d['summary']['leak'] >= 2 else 1)  # docx author + name hit
+" && ok "name-file hit counts as leak" || bad "name-file hit should be leak"
+
+# 4. clean dir -> exit 0
+run --dir "$WORK/clean" --quiet
+[ $? -eq 0 ] && ok "clean dir passes (tool author, no tokens)" || bad "clean dir should pass"
+
+# 5. review-only dir under --strict fails; default passes
+mkdir -p "$WORK/reviewonly/figures"
+cp "$WORK/leaky/figures/flow.R" "$WORK/reviewonly/figures/flow.R"
+run --dir "$WORK/reviewonly" --quiet
+[ $? -eq 0 ] && ok "review-only passes by default" || bad "review-only should pass by default"
+run --dir "$WORK/reviewonly" --strict --quiet
+[ $? -eq 1 ] && ok "review-only fails under --strict" || bad "review-only should fail under --strict"
+
+echo ""
+echo "test_asset_anonymization: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ]