medsci-skills 5.5.0 → 5.6.0

package/metadata/distribution_files.json

@@ -3393,8 +3393,8 @@
     },
     {
       "path": "skills/self-review/SKILL.md",
-      "size": 95312,
-      "sha256": "ff45218dcd5cc5233787b95c8f6ce9168dc2ff27db1ce98d4b121884e13ae526"
+      "size": 104683,
+      "sha256": "8cc62fbae95f1dd18c5c62f65931904d981daa8a565bad2f8418e3671ca56e7c"
     },
     {
       "path": "skills/self-review/references/domain-probes/ai_overclaiming.md",
@@ -3538,8 +3538,8 @@
     },
     {
       "path": "skills/self-review/references/panel_review_template.md",
-      "size": 11648,
-      "sha256": "07a714771f9a0a07804c0f56db3191627ce3555aad605e9b2e1bdaf31e242afa"
+      "size": 14863,
+      "sha256": "a44567b5ea0c47971bcc75b0e6c46f3846d687240b0607ded07183d6fbaad86f"
     },
     {
       "path": "skills/self-review/scripts/check_artifact_coverage.py",
@@ -3576,6 +3576,11 @@
       "size": 21506,
       "sha256": "7d3e67074d58a28ffee52ce64b486231f103a3ddcaf6b3b6ee83ba5f89c63bc2"
     },
+    {
+      "path": "skills/self-review/scripts/check_editorial_impression.py",
+      "size": 22032,
+      "sha256": "42e0e9315e1c97ca0f9943213c65ea91d7064773d25287b2577f0386dfb7fc41"
+    },
     {
       "path": "skills/self-review/scripts/check_null_calibration.py",
       "size": 7594,
@@ -3613,8 +3618,8 @@
     },
     {
       "path": "skills/self-review/skill.yml",
-      "size": 2135,
-      "sha256": "803c868da4e5bdfc0e3447c67dc54809f78c0f64cee448033c919693e9e6537c"
+      "size": 2223,
+      "sha256": "4009f3148776fab2096da3dad8a15e503c5073b4cc66b42c57498948e2040270"
     },
     {
       "path": "skills/setup-medsci/SKILL.md",

package/metadata/distribution_manifest.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "version": "5.5.0",
+  "version": "5.6.0",
   "owned_skills": [
     "academic-aio",
     "add-journal",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medsci-skills",
-  "version": "5.5.0",
+  "version": "5.6.0",
   "description": "MedSci Skills — a medical/scientific research skill suite for AI coding agents (Claude Code, Codex, Cursor, Copilot). The npm package is a terminal-friendly installer shortcut; the canonical distribution remains the GitHub repository and the Claude Code plugin marketplace.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/Aperivue/medsci-skills#readme",

package/skills/self-review/SKILL.md

@@ -33,6 +33,29 @@ When flagging issues, classify severity:
 
 Most issues are Fixable. Reserve Fatal for true design-level problems.
 
+## Two Objectives: the Floor and the Ceiling
+
+A submission-ready manuscript optimizes **two** things at once, and most of this skill (and
+the gate stack behind it) only optimizes the first:
+
+- **Floor — minimize rejection-for-cause.** Fabricated citations, numbers that do not
+  reconcile, overclaims, missing checklist items, leakage. Categories A–K and the
+  deterministic gates (Phases 2.5–2.5f) do this, and they are right to. Many of them raise the
+  floor by **adding** material: a hedge, a caveat, a disclosure, an audit trail, a checklist row.
+- **Ceiling — maximize editorial-championing.** Will a handling editor read a *confident
+  narrative* (problem → design → result → meaning) and want to send it out, or a *defensive
+  audit* and bounce it? Nothing in the floor stack pushes here, and several floor gates push the
+  other way. Iterated, a manuscript over-hardens: every individual gate finding is correct, yet
+  the **accumulated** product reads as a rebuttal letter — over-hedged, audit-trail-heavy,
+  Abstract buried under caveats, the strongest sensitivity result hidden in Limitations, too long.
+
+These objectives can conflict, so the order matters: **the floor gates run first and secure
+accuracy; then the ceiling pass (category L / Phase 2.5g) reads the accurate manuscript as a
+whole and recommends SUBTRACTION — REMOVE, MOVE, or TIGHTEN — so the same content is read
+confidently.** The ceiling pass is advisory and never blocks; it cannot relax a floor gate.
+Without it, repeated self-review monotonically over-defends. Surface the ceiling findings as
+their own first-class output (Phase 3), not folded silently into the "add this" comments.
+
 ## Workflow
 
 ### Phase 1: Intake
@@ -250,6 +273,38 @@ fabrication. Resolution path:
 1. Honest Methods/PROSPERO update (single-reviewer execution disclosed), OR
 2. Limitations confession rewritten if dual review was actually completed.
 
+#### L. Editorial impression & defensiveness (advisory; the counterweight)
+
+This is the **ceiling** category (see "Two Objectives" above) and the inverse of the floor
+gates: where A–K and the numerical gates ask "what is missing or wrong?" (and answer by
+**adding**), L asks "does the accurate manuscript read confidently, or has it over-defended?"
+(and answers by **subtracting**). Every L finding is **advisory (Minor / impression) and
+non-blocking** — it never converts to a Major and never blocks submission. The fixes are
+REMOVE / MOVE / TIGHTEN, not "add a caveat."
+
+| Check | What to look for | Action |
+|-------|-----------------|--------|
+| Hedge density | Defensive-caveat tokens stacking up per 1,000 narrative words — the prose hedges faster than it asserts. Keep the load-bearing caveats; cut the reflexive ones. | TIGHTEN |
+| Repeated caveat | The same caveat motif ("no deployable claim", "not generalizable", "hypothesis-generating") repeated across body + Abstract. Say it once, firmly. | TIGHTEN |
+| Audit minutiae in body | Provenance tokens (SHA / git commit / unit-test / post-lock timeline / manifest / seed=N / audit trail) in the Introduction / Results / Discussion narrative. Reproducibility detail belongs in a Methods statement or a supplement. | MOVE |
+| Limitations volume | A Limitations passage that enumerates a long list of discrete items reads as a rebuttal letter; consolidate related items. | TIGHTEN |
+| Abstract caveat load | The Abstract carries several caveat clauses, burying the headline result before a reader reaches it. Lead with the result; keep one or two essential qualifiers. | TIGHTEN |
+| Buried defense | A strong numeric robustness / sensitivity result sitting only in Limitations or the supplement, with no robustness mention in Results. Promote it into Results — it is *evidence for* the finding, not a caveat against it. (The inverse of the scope-coherence gate, which pushes a *weak* analysis out of Results.) | MOVE |
+
+Run the deterministic gate (Phase 2.5g) rather than eyeballing it — these are all counts and placements:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/scripts/check_editorial_impression.py" \
+  --manuscript manuscript.md --out qc/editorial_impression.json
+```
+
+`HEDGE_DENSITY`, `HEDGE_REPEAT`, `AUDIT_IN_BODY`, `LIMITATIONS_VOLUME`, `ABSTRACT_CAVEAT_LOAD`,
+and `BURIED_DEFENSE` are Anticipated **Minor** Comments (category: L. Editorial impression),
+each carrying a REMOVE / MOVE / TIGHTEN `action`. The gate never blocks (it has no Major and
+exits 0 even under `--strict`); thresholds are tunable (`--hedge-per-1k`, `--repeat-threshold`,
+`--limitations-max`, `--abstract-caveat-max`). It is conservative — each probe fires only on an
+explicit, locatable signal.
+
 ### Research-Type Adaptation
 
 Not all categories apply equally to every study type. Use this routing table:
@@ -267,6 +322,7 @@ Not all categories apply equally to every study type. Use this routing table:
 | I. Protocol Heterogeneity | Full | Full | N/A | Per-study | N/A | Full |
 | J. Method Transparency | Full | Partial | Partial | N/A | N/A | Partial |
 | K. Reviewer-team consistency | N/A | N/A | N/A | Full | N/A | N/A |
+| L. Editorial impression | Full | Full | Full | Full | Full | Full |
 
 *Meta-analysis: Replace C with heterogeneity assessment (I-squared, prediction intervals),
 publication bias (funnel plot, Egger), and sensitivity/subgroup analyses.
@@ -1016,6 +1072,48 @@ reconciliation in `qc/claim_artifact.json` and confirm against the actual regist
 before raising `ESTIMAND_DRIFT`. For time-to-event manuscripts, also apply probe **S8
 (estimand provenance)** of `references/domain-probes/survival_prognostic.md`.
 
+### Phase 2.5g: Editorial-Impression / Defensiveness Scan (the ceiling pass)
+
+Run this **after** the floor gates (Phases 2.5–2.5f), because it reads the *accurate* manuscript
+and recommends what to take back out. It is the operational form of category L and the
+counterweight to the additive bias of the rest of the stack: every other phase can only make the
+manuscript longer and more defended; this one is the only phase that can make it shorter and more
+confident. It is advisory and **non-blocking** — it never produces a Major and never gates
+submission.
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/scripts/check_editorial_impression.py" \
+  --manuscript manuscript.md --out qc/editorial_impression.json
+```
+
+The gate reads the manuscript as a whole, segments it by IMRAD heading, and emits up to six
+verdicts, each tagged with a SUBTRACTION `action`:
+
+| Verdict | Reads as | Action |
+|---|---|---|
+| `HEDGE_DENSITY` | defensive-caveat tokens per 1,000 narrative words over threshold | TIGHTEN |
+| `HEDGE_REPEAT` | one caveat motif repeated across body + Abstract | TIGHTEN |
+| `AUDIT_IN_BODY` | SHA / commit / unit-test / post-lock / manifest / seed in the narrative | MOVE (→ Methods/supplement) |
+| `LIMITATIONS_VOLUME` | a long enumerated Limitations list | TIGHTEN (consolidate) |
+| `ABSTRACT_CAVEAT_LOAD` | several caveat clauses in the Abstract | TIGHTEN |
+| `BURIED_DEFENSE` | strong numeric robustness result only in Limitations/supplement | MOVE (→ Results) |
+
+**Fold the findings into the report as the SUBTRACTION axis, not the additive one.** Each
+becomes a Minor `issues[]` entry under `category: "L" / category_name: "Editorial impression"`,
+additively carrying `issue_type: "editorial_impression"`, `subtype: <verdict>`, and
+`action: "REMOVE" | "MOVE" | "TIGHTEN"`. They are summarized in their own Phase 3 block
+("Editorial-Impression Risks — REMOVE / MOVE / TIGHTEN"), kept visually separate from the
+"Anticipated Major / Minor Comments (ADD / FIX)" so the author sees both forces. Mark them
+`fixable_by_ai: false` by default — TIGHTEN-ing a hedge or MOVE-ing a robustness result is a
+voice-and-judgment edit the author should own — except a clearly-redundant repeated caveat
+(`HEDGE_REPEAT`), which `--fix` may collapse to a single statement.
+
+**Net-impact note.** When an *earlier* phase recommends adding a caveat or disclosure, weigh it
+against L: an integrity-critical disclosure is a **must (state it once, crisply)**, but a
+defensive over-disclosure is a **cut / move**. The two are not symmetric — keep the disclosure,
+but place it once and point to the supplement rather than repeating it at every claim site
+(placement discipline: main text narrates, auditability lives in the supplement).
+
 ### Phase 2.6: Multi-Agent Panel Review (--panel, opt-in)
 
 Run this phase **only when `--panel` is passed**. The default single-pass review (Phases 2–2.5d) stays the fast path; the panel is the high-cost, high-precision option for a pre-submission final pass on a top-tier target. Run it after the numerical audits (Phases 2.5–2.5d) so the reviewers see source-verified numbers, and before the Phase 3 report, which it feeds.
@@ -1038,6 +1136,12 @@ The panel simulates independent peer reviewers who do not see each other's comme
 
 If the type is ambiguous, ask the user before composing the set.
 
+Append the **handling-editor desk-impression** persona (the ceiling lens) to every reviewer set:
+it loads no domain probe, reads only for narrative confidence vs over-defensiveness, and returns
+Minor REMOVE / MOVE / TIGHTEN findings (category L) that the editor routes to the separate
+Editorial-Impression Risks block. Its focus checklist is in `references/panel_review_template.md`.
+It does not count toward the Step 3.5 lens-diversity axes.
+
 **Step 2 — Run the reviewers (portable execution).** When the host provides a parallel subagent / Task capability (Claude Code, or any harness exposing an Agent tool), spawn the reviewer set as independent parallel subagents, each blinded to the others, then run the editor as a final synthesis agent. **Fallback (no subagent capability — e.g. a minimal Codex/Cursor harness):** a single agent role-plays each reviewer sequentially and in isolation — it completes and writes out reviewer R1's full structured review before reading the manuscript "fresh" as R2, so a later reviewer never sees an earlier reviewer's comments. The panel is defined by these instructions; it does **not** depend on the `Workflow` tool or any Claude-Code-only orchestration.
 
 A reusable reviewer schema, a generic harsh-but-fair reviewer prompt skeleton with per-domain focus checklists, and the editor synthesis prompt skeleton live in `${CLAUDE_SKILL_DIR}/references/panel_review_template.md`.
@@ -1103,6 +1207,15 @@ M2. ...
 m1. **{Issue}** [{Category}]: {1 sentence with location + fix}
 m2. ...
 
+## Editorial-Impression Risks (REMOVE / MOVE / TIGHTEN)
+
+*The subtraction axis — what to take out, move, or tighten so the accurate manuscript reads
+confidently. Advisory and non-blocking; from Phase 2.5g / category L. Omit this block only if the
+scan returned nothing.*
+
+L1. **{Issue}** [{REMOVE | MOVE | TIGHTEN}]: {1 sentence — what reads as over-defensive and where, with the subtraction to make}
+L2. ...
+
 ## Strengths (emphasize in cover letter)
 
 - {Specific strength 1}
@@ -1110,9 +1223,15 @@ m2. ...
 - ...
 ```
 
+The report carries **two** axes, kept visually separate: the **ADD / FIX** axis (Anticipated
+Major / Minor Comments — what is missing or wrong) and the **SUBTRACTION** axis
+(Editorial-Impression Risks — what to remove, move, or tighten). Do not fold the L items into the
+Minor Comments; an author who sees only "add this" will monotonically over-defend.
+
 **Conciseness targets**:
 - Anticipated Major Comments: 3-7 items, each 3-5 lines
 - Anticipated Minor Comments: 3-6 items, each 1-2 sentences
+- Editorial-Impression Risks: 0-6 items, each 1 sentence (only what the Phase 2.5g gate flagged)
 - Strengths: 3-5 items, each 1 sentence
 - Total report: 400-800 words (excluding optional R0 section)
 
@@ -1181,6 +1300,7 @@ When `--json` is passed, or when invoked by `/write-paper` Phase 7, append a mac
 - `requires_reanalysis` *(optional, default `false`)*: `true` when closing the finding needs a **committed analysis re-run against the real data**, not a prose edit — power/MDE re-simulation under the full model, first-visit/one-record-per-subject dedup, an extended- or reduced-adjustment sensitivity model, optimism correction of calibration. Always implies `fixable_by_ai: false`. Additive and backwards-compatible; parsers that do not expect it must ignore it. Route these to `/analyze-stats` (see Phase 4).
 - `suggested_fix`: Specific, actionable instruction. If `fixable_by_ai` is true, this must be concrete enough for the fixer to execute without ambiguity.
 - `consensus` *(optional, panel mode only)*: array of reviewer ids that raised the issue, e.g. `["R1","R3"]`. Additive and backwards-compatible — present only when Phase 2.6 ran; parsers that do not expect it must ignore it.
+- `action` *(optional, editorial-impression findings only)*: `"REMOVE" | "MOVE" | "TIGHTEN"` — the SUBTRACTION direction for a category-L finding (Phase 2.5g). Present alongside `issue_type: "editorial_impression"` and `subtype: <verdict>` (e.g. `HEDGE_REPEAT`). Additive and backwards-compatible; these are always `severity: "minor"`, never block, and are `fixable_by_ai: false` by default (except a redundant `HEDGE_REPEAT`, which `--fix` may collapse). Parsers that do not expect it must ignore it.
 
 ### Phase 4: Fix Support
 
@@ -1272,5 +1392,6 @@ Here is how to address it with your existing data."
 | Phase 2.5c reference hallucination scan (delegate `/verify-refs`) | ENFORCED | `FABRICATED` in `records[]` OR nonempty `duplicate_findings[]` | P0 Major Comment, blocks submission |
 | Phase 2.5a-2 design/power statistic provenance | ENFORCED | a reported MDE / power / sample-size value is not reproduced by committed code, or is reproducible only by a method the committed script does not implement | Major Comment (P0 if a headline claim); recompute and either correct the value or update the committed code to reproduce it |
 | `--fix` auto-fix loop (max 2 iterations) | ENFORCED in `/write-paper` Phase 7.4 chain | score still below threshold after 2 iterations | Route to write-paper Phase 7.4a Audit Recovery |
+| Phase 2.5g editorial-impression scan (`check_editorial_impression.py`) | ADVISORY (non-blocking) | HEDGE_DENSITY / HEDGE_REPEAT / AUDIT_IN_BODY / LIMITATIONS_VOLUME / ABSTRACT_CAVEAT_LOAD / BURIED_DEFENSE | Minor REMOVE/MOVE/TIGHTEN recommendation in the Editorial-Impression Risks block; never blocks submission |
 | R0 numbering output | OPT-IN | `--r0-numbering` flag or downstream `/revise` consumer | Emits structured Anticipated Major/Minor Comments — consumable by `/revise` |
 | `--json` machine-readable output | OPT-IN | `--json` flag | Emits parseable JSON block consumed by `/orchestrate` post-skill validation |

package/skills/self-review/references/panel_review_template.md

@@ -126,6 +126,36 @@ design-level finding, **Fixable** for a reporting-level finding.
 - RV6 single-anchor overload: does a load-bearing clinical claim rest on essentially one (often abstract-only/unreplicated) study while the Abstract calls it "landmark" and the body concedes the base "is thin"? Flag the Abstract↔body register mismatch.
 - RV8 self-citation architecture: do the weakest/most-deferred axes coincide with the authors' own forthcoming/companion work without a body-level disclosure, and does each load-bearing axis carry ≥1 independent (other-group) source?
 
+**Handling editor — desk-impression / champion-or-bounce (cross-type, the ceiling lens)**
+
+This persona is the counterweight to the rigor reviewers above. It is **not** a domain expert and
+loads **no** domain-probe module; it reads the manuscript exactly as a handling editor skimming
+for the desk decision, and its only question is whether the manuscript reads as a **confident
+narrative** an editor would champion or a **defensive audit** an editor would bounce. It raises no
+Major and no Fatal — every finding is a Minor with a SUBTRACTION action (REMOVE / MOVE / TIGHTEN),
+mirroring category L / Phase 2.5g. Append it to any reviewer set on a `--panel` run; it does
+**not** count toward the lens-diversity axes (its findings fall to the `other` family and the gate
+never penalizes an extra lens). Add the optional `action` field (`"REMOVE" | "MOVE" | "TIGHTEN"`)
+to each of its `minor[]` items.
+
+- Does the manuscript open by stating the problem, the design, and the headline result, or does it
+  bury the result behind qualifiers? Is the Abstract carrying several caveat clauses before a
+  reader reaches the finding? (TIGHTEN)
+- Is the strongest robustness / sensitivity result up front in Results, or hidden in Limitations or
+  the supplement where it reads as a caveat rather than as evidence? (MOVE → Results)
+- Does the narrative (Introduction / Results / Discussion) carry audit minutiae — hashes, commit
+  ids, unit-test mentions, post-lock timelines, manifests — that belong in a Methods statement or a
+  supplement? (MOVE)
+- Is the same caveat repeated at multiple claim sites? Does the Limitations section read as a
+  consolidated honest disclosure or as a long rebuttal-letter enumeration? Say each caveat once,
+  firmly. (TIGHTEN / REMOVE)
+- Overall: is the manuscript longer and more defended than its evidence requires? Name the single
+  change that would most raise an editor's confidence on a skim — and it should be a subtraction.
+
+Run `scripts/check_editorial_impression.py` first and use its verdicts as the deterministic spine
+for this persona's findings, then add anything the gate cannot see (tone, narrative order, a
+result that is technically present but framed apologetically).
+
 ---
 
 ## Editor synthesis prompt skeleton
@@ -147,6 +177,14 @@ design-level finding, **Fixable** for a reporting-level finding.
 >    undisclosed near-identical prior publication, or (for a review/primer) weak novelty /
 >    no distinct contribution since the contribution IS the product — let it dominate the
 >    tier over fixable reporting defects rather than letting the fixable framing soften it.
+>    Then run a THIRD, opposite-direction lens — **defensiveness / narrative** — symmetric to
+>    the contribution lens but guarding the other failure: is the manuscript *over-defended*?
+>    Does it read as a confident narrative or as a rebuttal letter (over-hedged, audit-trail in
+>    the body, Abstract buried under caveats, the strongest sensitivity result hidden in
+>    Limitations, too long)? Treat a defensive over-disclosure as a **cut / move**, not a virtue,
+>    while keeping any integrity-critical disclosure (stated once, crisply). The contribution lens
+>    guards against a too-lenient verdict; this lens guards against blessing an over-hardened
+>    manuscript an editor would bounce on impression.
 > 2. De-duplicate and consolidate the major comments by theme. For each consolidated
 >    point, flag CONSENSUS (raised by ≥2 reviewers) or single-reviewer, and attribute
 >    (R1/R2/R3).
@@ -159,10 +197,13 @@ design-level finding, **Fixable** for a reporting-level finding.
 >    rather than implicit in the attribution.
 >
 > Map every finding onto the self-review framing (Fatal / Fixable, category letters
-> A–K) and emit it through the Phase 3 report, Phase 3b R0 numbering, and Phase 3c
-> JSON, adding the optional `consensus` field where ≥2 reviewers agreed. Follow the
-> manuscript-style rules: no "§" symbols, minimal em-dashes, full prose, cite specific
-> locations.
+> A–L) and emit it through the Phase 3 report, Phase 3b R0 numbering, and Phase 3c
+> JSON, adding the optional `consensus` field where ≥2 reviewers agreed. Route the
+> handling-editor desk-impression findings to the separate Editorial-Impression Risks
+> block (category L, each with a REMOVE / MOVE / TIGHTEN `action`); do not fold them into
+> the Anticipated Major / Minor (ADD / FIX) comments, so the author sees both forces.
+> Follow the manuscript-style rules: no "§" symbols, minimal em-dashes, full prose, cite
+> specific locations.
 
 ---
 

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

@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+"""Editorial-impression / defensiveness gate (self-review §L) — the counterweight pass.
+
+The rest of the MedSci-Audit stack minimizes *rejection-for-cause* (the floor):
+fabricated citations, drifting numbers, overclaims, missing checklist items. Several
+of those gates raise the floor by *adding* material — a hedge, a caveat, a disclosure,
+a checklist row — and nothing in the stack pushes back. Iterated, a manuscript
+monotonically over-hardens: a confident narrative turns into a defensive audit that an
+editor reads as a risk signal even when every individual gate finding was correct.
+
+This gate is the missing opposite force. It does not relax any integrity gate; it scans
+the *manuscript as a whole* for editorial-impression risks and recommends SUBTRACTION —
+REMOVE, MOVE, or TIGHTEN — so the accurate content the gates secured is also read
+confidently. Every finding is advisory (Minor / impression) and NON-BLOCKING: this gate
+never returns a submission blocker. It raises the ceiling; it does not gate the floor.
+
+  HEDGE_DENSITY         defensive-caveat tokens per 1,000 body-narrative words exceed a
+                        threshold — the prose hedges faster than it asserts. TIGHTEN.
+  HEDGE_REPEAT          one caveat motif ("no deployable claim", "not generalizable",
+                        "none evaluated here") repeats >=N times across body + abstract.
+                        Say it once, firmly. TIGHTEN.
+  AUDIT_IN_BODY         provenance/audit minutiae (SHA / git commit / unit-test /
+                        post-lock timeline / manifest / seed=N / audit trail) appear in
+                        the Introduction / Results / Discussion narrative rather than a
+                        Methods reproducibility statement or a supplement. MOVE.
+  LIMITATIONS_VOLUME    the Limitations passage enumerates more than N discrete items;
+                        a wall of limitations reads as a rebuttal letter. TIGHTEN.
+  ABSTRACT_CAVEAT_LOAD  the Abstract carries >=N caveat clauses; the headline result is
+                        buried under qualifiers before a reader reaches it. TIGHTEN.
+  BURIED_DEFENSE        a strong numeric robustness / sensitivity result sits only in the
+                        Limitations / supplement, with no robustness mention in Results.
+                        This is the inverse of the scope-coherence gate: scope-coherence
+                        pushes a *weak* analysis out of Results; BURIED_DEFENSE pulls a
+                        *strong* confound rebuttal back into Results. MOVE (promote).
+
+Conservative by construction: each probe fires only on an explicit, locatable signal, to
+keep false positives low on a widely-used skill. The gate needs IMRAD-style headings to
+locate sections; with none it degrades to a whole-document density read.
+
+INPUTS
+  --manuscript  manuscript markdown/text (required).
+  thresholds    --hedge-per-1k (10.0), --repeat-threshold (3), --limitations-max (6),
+                --abstract-caveat-max (2). A probe fires when its count exceeds the max.
+
+OUTPUT
+  A reconciliation table (stdout) and, with --out, a JSON artifact:
+    {manuscript, claims[{verdict, severity, action, detail, where}], summary}
+  Every claim is severity "Minor" with an action of REMOVE / MOVE / TIGHTEN. Exit code is
+  always 0 for the findings themselves (advisory); --strict is accepted for CLI parity
+  with the other gates but never blocks, since this gate emits no Major.
+
+Stdlib-only (json / re / argparse / pathlib). Exit codes: 0 clean or advisory findings,
+2 input/usage error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+# --------------------------------------------------------------------------- #
+# Section segmentation
+# --------------------------------------------------------------------------- #
+
+HEADING_RE = re.compile(r"^(#{1,6})\s*\*{0,2}(.+?)\*{0,2}\s*$", re.MULTILINE)
+
+# Narrative regions where defensive prose and out-of-place audit minutiae read worst.
+# Methods is deliberately excluded (a reproducibility statement belongs there), as is
+# any supplement / availability / declarations region.
+BODY_NARRATIVE = {"introduction", "results", "discussion", "conclusion", "limitations"}
+
+
+def classify_heading(h: str) -> str:
+    t = h.lower().strip()
+    if "abstract" in t or t == "summary":
+        return "abstract"
+    if any(k in t for k in (
+        "data availability", "code availability", "availability", "supplement",
+        "appendix", "acknowledg", "funding", "declaration", "competing interest",
+        "conflict of interest", "reproducibility", "references", "author contribution",
+    )):
+        return "supplement"
+    if "limitation" in t:
+        return "limitations"
+    if "introduction" in t or "background" in t:
+        return "introduction"
+    if any(k in t for k in (
+        "method", "material", "statistical analys", "study design",
+        "patients and", "data collection", "study population",
+    )):
+        return "methods"
+    if "result" in t or "finding" in t:
+        return "results"
+    if "discussion" in t:
+        return "discussion"
+    if "conclusion" in t:
+        return "conclusion"
+    return "other"
+
+
+def segment(text: str) -> list[tuple[str, str]]:
+    """Return an ordered list of (region, body_text) pairs. Text before the first
+    heading is a 'preamble' region. Region names follow classify_heading()."""
+    matches = list(HEADING_RE.finditer(text))
+    regions: list[tuple[str, str]] = []
+    if not matches:
+        return [("preamble", text)]
+    if matches[0].start() > 0:
+        pre = text[: matches[0].start()].strip()
+        if pre:
+            regions.append(("preamble", pre))
+    for i, m in enumerate(matches):
+        start = m.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        body = text[start:end].strip()
+        regions.append((classify_heading(m.group(2)), body))
+    return regions
+
+
+def region_text(regions: list[tuple[str, str]], names: set[str]) -> str:
+    return "\n".join(b for r, b in regions if r in names)
+
+
+def abstract_text(regions: list[tuple[str, str]], full: str) -> str:
+    """The Abstract region; fall back to the text before the first Introduction/Methods
+    heading (a structured abstract without its own heading), capped to ~350 words."""
+    abs_regions = [b for r, b in regions if r == "abstract"]
+    if abs_regions:
+        return "\n".join(abs_regions)
+    # Fallback: preamble + everything up to the first intro/methods region.
+    out: list[str] = []
+    for r, b in regions:
+        if r in ("introduction", "methods", "results", "discussion"):
+            break
+        if r in ("preamble", "other"):
+            out.append(b)
+    joined = "\n".join(out)
+    words = joined.split()
+    return " ".join(words[:350]) if len(words) > 350 else joined
+
+
+def word_count(text: str) -> int:
+    return sum(1 for w in text.split() if any(c.isalpha() for c in w))
+
+
+def sentences(text: str) -> list[str]:
+    # Lightweight sentence split on ., !, ? followed by whitespace.
+    parts = re.split(r"(?<=[.!?])\s+", text.strip())
+    return [s.strip() for s in parts if s.strip()]
+
+
+# --------------------------------------------------------------------------- #
+# Lexicons
+# --------------------------------------------------------------------------- #
+
+# Defensive caveats — explicitly hedging phrases, not ordinary modal verbs. Stacking
+# these is the defensiveness tell HEDGE_DENSITY measures.
+CAVEAT = re.compile(
+    r"\bcaveats?\b|should be interpreted with caution|with caution\b|"
+    r"must be interpreted|interpreted? with care|"
+    r"cannot be (?:inferred|established|excluded|determined|generaliz\w+|ruled out|drawn|assumed)|"
+    r"no (?:causal|deployable|clinical|definitive) (?:claim|inference|conclusion|relationship)|"
+    r"not (?:be )?(?:generaliz\w+|definitive|conclusive|deployable|warranted)|"
+    r"\bpreliminary\b|\bexploratory\b|hypothesis[-\s]generating|"
+    r"warrants? (?:caution|further (?:study|validation|research|investigation))|"
+    r"remains? (?:unclear|uncertain|to be (?:established|determined|confirmed))|"
+    r"\blimited (?:by|generaliz\w+|sample|to|in scope)|"
+    r"single[-\s](?:cent(?:er|re)|institution|site)|retrospective (?:design|nature)|"
+    r"should not be (?:used|interpreted|construed)|"
+    r"do(?:es)? not (?:establish|imply|permit|support|prove)|"
+    r"not (?:yet )?(?:ready|validated|intended) for (?:clinical|deployment|practice)|"
+    r"\bunderpowered\b|\bmodest\b|no (?:firm|strong) (?:conclusion|inference)",
+    re.IGNORECASE)
+
+# Repeated caveat motifs (HEDGE_REPEAT): family key -> regex. A family repeating across
+# body + abstract above the threshold should be stated once, firmly.
+MOTIFS: dict[str, re.Pattern] = {
+    "no_deployable_claim": re.compile(
+        r"no (?:deployable|deployment|clinical|practice|diagnostic) (?:claim|use|recommendation)|"
+        r"not (?:ready|intended|validated) for (?:clinical|deployment|practice)",
+        re.IGNORECASE),
+    "not_generalizable": re.compile(r"not (?:be )?generaliz\w+|limited generaliz\w+", re.IGNORECASE),
+    "none_evaluated_here": re.compile(
+        r"(?:none|not|no \w+) (?:were |was |are |is )?evaluated (?:here|in this (?:study|work|analysis))|"
+        r"not (?:assessed|examined|tested) (?:here|in this (?:study|work))", re.IGNORECASE),
+    "no_causal": re.compile(r"no causal (?:claim|inference|relationship|conclusion|interpretation)", re.IGNORECASE),
+    "hypothesis_generating": re.compile(r"hypothesis[-\s]generating", re.IGNORECASE),
+    "interpret_with_caution": re.compile(
+        r"interpret\w* with caution|should be interpreted with caution|with caution", re.IGNORECASE),
+    "single_center": re.compile(r"single[-\s](?:cent(?:er|re)|institution|site)", re.IGNORECASE),
+    "retrospective_design": re.compile(r"retrospective (?:design|nature|study|cohort)", re.IGNORECASE),
+    "preliminary": re.compile(r"\bpreliminary\b", re.IGNORECASE),
+}
+
+# Motifs that are factual study-design descriptors rather than defensive caveats. A
+# single-centre / retrospective study must state its design in Methods, and naming it
+# again in the Abstract and Limitations is normal, not over-hedging. Count these only
+# in the non-Methods narrative so an honestly-written single-centre retrospective study
+# (the most common observational design) is not flagged for stating a true fact.
+FACTUAL_DESCRIPTOR_MOTIFS = {"single_center", "retrospective_design"}
+
+# Provenance / audit minutiae that belong in Methods or a supplement, not the narrative.
+AUDIT = re.compile(
+    r"\bsha-?256\b|\bmd5\b|\bchecksum\b|(?:git\s+)?(?:commit|hash|sha)\s*[:=]?\s*[0-9a-f]{7,40}\b|"
+    r"\bcommit\s+[0-9a-f]{7,40}\b|\bunit[-\s]?test(?:s|ing|ed)?\b|\bpost[-\s]?lock\b|"
+    r"seed\s*=\s*\d+|\brandom seed\s+\d+\b|\baudit trail\b|"
+    r"reproducibility (?:manifest|hash|record)|data lock(?:ed)? on|\bcontent[-\s]hash\b",
+    re.IGNORECASE)
+
+# Robustness / sensitivity vocabulary (for BURIED_DEFENSE).
+ROBUST = re.compile(
+    r"sensitivity analys\w+|robustness|leave[-\s]one[-\s]out|leave[-\s]pair[-\s]out|"
+    r"\bE[-\s]?value\b|remained (?:significant|robust|consistent|unchanged|stable)|"
+    r"did not (?:materially |substantially |meaningfully )?(?:change|alter|differ)|"
+    r"results were (?:similar|consistent|robust|unchanged)|consistent across|"
+    r"after (?:excluding|adjusting for|accounting for)|tipping[-\s]point", re.IGNORECASE)
+
+# A strong numeric token next to a robustness statement makes it Results-worthy.
+NUMERIC = re.compile(
+    r"\b\d+\.\d+\b|\b\d{1,3}%|95%\s*ci|(?:OR|HR|RR|AUC|aHR|aOR)\s*[=:]?\s*\d|"
+    r"p\s*[<=>]\s*0?\.\d+", re.IGNORECASE)
+
+ORDINALS = ["first", "second", "third", "fourth", "fifth", "sixth", "seventh",
+            "eighth", "ninth", "tenth"]
+
+
+# --------------------------------------------------------------------------- #
+# Probes
+# --------------------------------------------------------------------------- #
+
+def probe_hedge_density(regions, body, threshold) -> list[dict]:
+    words = word_count(body)
+    if words < 80:  # too little narrative to judge density reliably
+        return []
+    n = len(CAVEAT.findall(body))
+    density = n / words * 1000
+    if density > threshold:
+        return [{
+            "verdict": "HEDGE_DENSITY", "severity": "Minor", "action": "TIGHTEN",
+            "detail": (f"defensive-caveat density is {density:.1f} per 1,000 body words "
+                       f"({n} caveat tokens / {words} words; threshold {threshold:.0f}); the "
+                       f"prose hedges faster than it asserts — keep the load-bearing caveats, "
+                       f"cut the reflexive ones"),
+            "where": f"body narrative ({words} words)",
+        }]
+    return []
+
+
+def probe_hedge_repeat(regions, full, threshold) -> list[dict]:
+    non_methods = "\n".join(b for r, b in regions if r != "methods")
+    claims = []
+    for key, rx in MOTIFS.items():
+        # Factual design descriptors are not over-hedging when stated in Methods;
+        # count them only in the non-Methods narrative.
+        hay = non_methods if key in FACTUAL_DESCRIPTOR_MOTIFS else full
+        n = len(rx.findall(hay))
+        if n >= threshold:
+            m = rx.search(hay)
+            phrase = m.group(0).strip() if m else key
+            claims.append({
+                "verdict": "HEDGE_REPEAT", "severity": "Minor", "action": "TIGHTEN",
+                "detail": (f"the caveat '{phrase}' (motif: {key}) appears {n} times across "
+                           f"the narrative; state it once, firmly, and remove the repeats"),
+                "where": phrase[:120],
+            })
+    return claims
+
+
+def probe_audit_in_body(regions) -> list[dict]:
+    body = region_text(regions, BODY_NARRATIVE)
+    claims = []
+    seen = set()
+    for m in AUDIT.finditer(body):
+        tok = m.group(0).strip().lower()
+        norm = re.sub(r"[0-9a-f]{7,40}", "<hash>", tok)
+        if norm in seen:
+            continue
+        seen.add(norm)
+        claims.append({
+            "verdict": "AUDIT_IN_BODY", "severity": "Minor", "action": "MOVE",
+            "detail": (f"provenance/audit token '{m.group(0).strip()}' appears in the "
+                       f"Introduction/Results/Discussion narrative; move reproducibility "
+                       f"detail to a Methods statement or a supplement"),
+            "where": body[max(0, m.start() - 40):m.end() + 40].strip()[:160],
+        })
+    return claims
+
+
+def probe_limitations_volume(regions, full, max_items) -> list[dict]:
+    lim = region_text(regions, {"limitations"})
+    if not lim:
+        # Inline limitations paragraph inside Discussion.
+        disc = region_text(regions, {"discussion", "conclusion"})
+        m = re.search(r"(?:our |this )?stud(?:y|ies) (?:has|have)[^.]{0,40}limitations?|"
+                      r"several (?:important )?limitations|limitations? (?:of this|warrant)",
+                      disc, re.IGNORECASE)
+        if not m:
+            return []
+        lim = disc[m.start():]
+    # Count discrete items: max of ordinal markers, (N) enumerators, bullet lines.
+    low = lim.lower()
+    n_ord = sum(1 for o in ORDINALS if re.search(rf"(?:^|[\s(,;])\b{o}\b\s*,", low))
+    n_enum = len(set(re.findall(r"\((\d{1,2})\)", lim)))
+    n_bullet = len(re.findall(r"^\s*[-*]\s+\S", lim, re.MULTILINE))
+    n = max(n_ord, n_enum, n_bullet)
+    if n > max_items:
+        return [{
+            "verdict": "LIMITATIONS_VOLUME", "severity": "Minor", "action": "TIGHTEN",
+            "detail": (f"the Limitations passage enumerates {n} discrete items "
+                       f"(threshold {max_items}); consolidate related items so the section "
+                       f"reads as honest disclosure, not a rebuttal letter"),
+            "where": f"Limitations ({n} items)",
+        }]
+    return []
+
+
+def probe_abstract_caveat_load(regions, full, max_caveats) -> list[dict]:
+    abs_t = abstract_text(regions, full)
+    if word_count(abs_t) < 40:
+        return []
+    caveat_sents = [s for s in sentences(abs_t) if CAVEAT.search(s)]
+    n = len(caveat_sents)
+    if n > max_caveats:
+        return [{
+            "verdict": "ABSTRACT_CAVEAT_LOAD", "severity": "Minor", "action": "TIGHTEN",
+            "detail": (f"the Abstract carries {n} caveat-bearing clauses (threshold "
+                       f"{max_caveats}); lead with the result and keep at most one or two "
+                       f"essential qualifiers so the headline is not buried"),
+            "where": (caveat_sents[0][:140] if caveat_sents else "Abstract"),
+        }]
+    return []
+
+
+def probe_buried_defense(regions) -> list[dict]:
+    results = region_text(regions, {"results"})
+    buried_src = region_text(regions, {"limitations", "supplement"})
+    if not buried_src:
+        return []
+    # If Results already discusses robustness, nothing is buried.
+    if ROBUST.search(results):
+        return []
+    claims = []
+    for s in sentences(buried_src):
+        if ROBUST.search(s) and NUMERIC.search(s):
+            claims.append({
+                "verdict": "BURIED_DEFENSE", "severity": "Minor", "action": "MOVE",
+                "detail": ("a numeric robustness/sensitivity result sits in the "
+                           "Limitations/supplement with no robustness mention in Results; "
+                           "promote it into Results — it is evidence for the finding, not a "
+                           "caveat against it"),
+                "where": s[:160],
+            })
+            break  # one promotion recommendation is enough
+    return claims
+
+
+# --------------------------------------------------------------------------- #
+# Driver
+# --------------------------------------------------------------------------- #
+
+def check(text: str, *, hedge_per_1k: float, repeat_threshold: int,
+          limitations_max: int, abstract_caveat_max: int) -> list[dict]:
+    regions = segment(text)
+    body = region_text(regions, BODY_NARRATIVE)
+    if not body:  # no IMRAD headings — degrade to a whole-document read (minus supplement)
+        body = region_text(regions, {"preamble", "other"}) or text
+    claims: list[dict] = []
+    claims += probe_hedge_density(regions, body, hedge_per_1k)
+    claims += probe_hedge_repeat(regions, text, repeat_threshold)
+    claims += probe_audit_in_body(regions)
+    claims += probe_limitations_volume(regions, text, limitations_max)
+    claims += probe_abstract_caveat_load(regions, text, abstract_caveat_max)
+    claims += probe_buried_defense(regions)
+    return claims
+
+
+def analyze(manuscript: str, **kw) -> 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"), **kw)
+    by_action = {"REMOVE": 0, "MOVE": 0, "TIGHTEN": 0}
+    for c in claims:
+        by_action[c["action"]] = by_action.get(c["action"], 0) + 1
+    return {
+        "manuscript": str(p),
+        "claims": claims,
+        "summary": {
+            "n_claims": len(claims),
+            "by_action": by_action,
+            "verdict": "IMPRESSION_FLAGS" if claims else "OK",
+        },
+    }
+
+
+def render(result: dict) -> str:
+    lines = ["| Check | Action | Detail |", "|---|---|---|"]
+    for c in result["claims"]:
+        lines.append(f"| {c['verdict']} | {c['action']} | {c['detail']} |")
+    if len(lines) == 2:
+        lines.append("| (none) | — | narrative reads confidently; no subtraction needed |")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="Editorial-impression / defensiveness gate (§L) — advisory, non-blocking.")
+    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="accepted for CLI parity; this gate emits no Major, so it never blocks")
+    ap.add_argument("--quiet", action="store_true", help="suppress stdout table")
+    ap.add_argument("--hedge-per-1k", type=float, default=10.0,
+                    help="HEDGE_DENSITY: caveat tokens per 1,000 body words before firing (default 10)")
+    ap.add_argument("--repeat-threshold", type=int, default=3,
+                    help="HEDGE_REPEAT: motif occurrences across body+abstract before firing (default 3)")
+    ap.add_argument("--limitations-max", type=int, default=6,
+                    help="LIMITATIONS_VOLUME: discrete Limitations items allowed (default 6)")
+    ap.add_argument("--abstract-caveat-max", type=int, default=2,
+                    help="ABSTRACT_CAVEAT_LOAD: caveat clauses allowed in the Abstract (default 2)")
+    args = ap.parse_args()
+
+    result = analyze(
+        args.manuscript,
+        hedge_per_1k=args.hedge_per_1k,
+        repeat_threshold=args.repeat_threshold,
+        limitations_max=args.limitations_max,
+        abstract_caveat_max=args.abstract_caveat_max,
+    )
+
+    if not args.quiet:
+        print("=" * 41)
+        print(" Editorial Impression / Defensiveness (§L)")
+        print("=" * 41)
+        print(render(result))
+        print()
+        s = result["summary"]
+        if s["n_claims"]:
+            ba = s["by_action"]
+            print(f"IMPRESSION flags: {s['n_claims']} advisory finding(s) "
+                  f"(REMOVE {ba['REMOVE']} / MOVE {ba['MOVE']} / TIGHTEN {ba['TIGHTEN']}). "
+                  f"Non-blocking — these raise the ceiling, they do not gate submission.")
+        else:
+            print("OK: narrative reads confidently; no subtraction recommended.")
+
+    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}")
+
+    # Advisory: never blocks. --strict is accepted for parity but this gate has no Major.
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/self-review/skill.yml

@@ -22,6 +22,7 @@ outputs:
   - qc/reference_adequacy.json
 deterministic_scripts:
   - scripts/check_reference_adequacy.py
+  - scripts/check_editorial_impression.py
 side_effects:
   - may_edit_manuscript_when_fix_flag_set
 downstream_consumers:
@@ -44,5 +45,6 @@ validation_commands:
   - "python3 scripts/check_domain_probe_sync.py --strict"
   - "bash tests/test_panel_mode.sh"
   - "bash tests/test_reference_adequacy.sh"
+  - "bash tests/test_editorial_impression.sh"
   - "feed R0-numbered output into /revise"
 evidence_surface: demo

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

@@ -0,0 +1,29 @@
+# A Deep-Learning Marker for Synthetic Outcome X: Development and Internal Validation
+
+## Abstract
+
+**Background:** Marker X may aid early triage of outcome X. **Methods:** We developed and internally validated a model on a patient-level split. **Results:** The model discriminated outcome X with an area under the curve of 0.84 (95% CI 0.79–0.89) and was well calibrated. **Conclusion:** Marker X identifies patients at higher risk of outcome X and supports triage. These findings are preliminary and require external validation.
+
+## Introduction
+
+Outcome X is common and its early identification changes triage. Existing tools rely on manual scoring, which is slow and operator-dependent. We asked whether a deep-learning marker derived from routine inputs could identify patients at higher risk and inform the triage decision. This study develops such a marker and tests it on a held-out internal cohort, addressing a gap left by prior manual approaches.
+
+## Methods
+
+We assembled a cohort and split it at the patient level into development and held-out sets before any preprocessing. A regularised model was trained with five-fold cross-validation. All analysis code, the dataset schema, and a content-hash manifest are archived (see Data Availability).
+
+## Results
+
+The model discriminated outcome X with an area under the curve of 0.84 (95% CI 0.79–0.89). Calibration was good, with a slope of 0.97 and a Brier score of 0.12. At the triage threshold, sensitivity was 0.82 and specificity was 0.79. In a sensitivity analysis excluding the 41 borderline cases, the adjusted odds ratio was unchanged at 2.18 (95% CI 1.40–3.39), and results were consistent across the two recruitment years. Decision-curve analysis showed net benefit over the manual score across the clinically relevant threshold range.
+
+## Discussion
+
+A routine-input marker identified patients at higher risk of outcome X and added net benefit over the existing manual score, which is the decision it is meant to inform. The effect size corresponds to a clinically meaningful shift in pretest probability. The marker is reproducible and its calibration supports use at the stated threshold.
+
+## Limitations
+
+This single-centre study has three main limitations: it was developed on retrospective data, the marker was measured once, and external validation in an independent cohort is the necessary next step before deployment.
+
+## Data Availability
+
+The analysis code, the dataset schema, the patient-level split assignment, and a reproducibility manifest with the dataset content hash are archived in the project repository, so every reported number can be regenerated from a single committed pipeline.

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

@@ -0,0 +1,25 @@
+# A Deep-Learning Marker for Synthetic Outcome X: A Preliminary Single-Centre Study
+
+## Abstract
+
+**Background:** Marker X has been proposed as a screening adjunct. **Methods:** We trained a model on a retrospective cohort. **Results:** The model reached an area under the curve of 0.84. **Conclusion:** These findings are preliminary and exploratory and should be interpreted with caution. The results are hypothesis-generating and not generalizable beyond this single-centre cohort, and no deployable claim is made. Because the analysis is underpowered, no causal inference can be inferred.
+
+## Introduction
+
+Marker X is of interest, although the evidence remains uncertain and the prior literature is limited by small samples. We hypothesise that a model may help, but the work is exploratory and any conclusion should be interpreted with caution. We make no deployable claim and the results are not generalizable; the study is hypothesis-generating only.
+
+## Methods
+
+We used a retrospective cohort and fit a regularised model. Splits were at the patient level.
+
+## Results
+
+The model reached an area under the curve of 0.84 (95% CI 0.79–0.89). The reproducibility manifest and the sha256 checksum of the locked dataset are reported. Every metric in this paragraph was produced by a committed unit-test against the post-lock data with seed=42, and the git commit a1b2c3d4e5f6 pins the exact run. The audit trail for each figure is recorded.
+
+## Discussion
+
+Our marker may help, but the finding is preliminary and modest and cannot be established as causal. The result is not generalizable and remains uncertain; it is hypothesis-generating only and warrants further study. We reiterate that no deployable claim is made and that any inference should be interpreted with caution. The exact manifest hash and the post-lock timeline are given above for full auditability.
+
+## Limitations
+
+This study has several limitations. First, the design is retrospective and single-centre, so selection bias cannot be excluded. Second, the sample is limited and the analysis is underpowered. Third, the marker was measured once. Fourth, no external validation was performed. Fifth, residual confounding cannot be ruled out. Sixth, the outcome label is registry-derived. Seventh, generalizability is uncertain. In a sensitivity analysis excluding the 41 borderline cases, the adjusted odds ratio remained 2.18 (95% CI 1.40–3.39), which we note here for completeness.

package/skills/self-review/tests/test_editorial_impression.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Regression test for the editorial-impression / defensiveness gate (self-review §L).
+# Synthetic, PII-free fixtures: (a) an over-defensive manuscript that trips all six
+# probes (HEDGE_DENSITY, HEDGE_REPEAT, AUDIT_IN_BODY, LIMITATIONS_VOLUME,
+# ABSTRACT_CAVEAT_LOAD, BURIED_DEFENSE); (b) a confident clean manuscript that trips
+# none (false-positive guard). The gate is advisory and non-blocking — it must exit 0
+# even under --strict, since it emits no Major.
+# Stdlib-only (python3).
+set -u
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT="$HERE/../scripts/check_editorial_impression.py"
+DEF="$HERE/fixtures/editorial_defensive.md"
+CLEAN="$HERE/fixtures/editorial_clean.md"
+OUT="$(mktemp -t editorial_XXXX).json"
+trap 'rm -f "$OUT"' EXIT
+
+fail=0
+check() { local label="$1"; shift
+    if "$@" >/dev/null 2>&1; then printf '  PASS  %s\n' "$label"
+    else printf '  FAIL  %s\n' "$label"; fail=$((fail+1)); fi
+}
+has_verdict() { python3 -c "
+import json
+d=json.load(open('$OUT'))
+assert any(c['verdict']=='$1' for c in d['claims']), '$1 not found'
+"; }
+
+[[ -f "$SCRIPT" ]] || { echo "ENV-ERR: script missing" >&2; exit 2; }
+
+# (1) defensive fixture -> all six verdicts fire
+python3 "$SCRIPT" --manuscript "$DEF" --out "$OUT" --quiet >/dev/null 2>&1
+for v in HEDGE_DENSITY HEDGE_REPEAT AUDIT_IN_BODY LIMITATIONS_VOLUME ABSTRACT_CAVEAT_LOAD BURIED_DEFENSE; do
+    check "$v detected (defensive)" has_verdict "$v"
+done
+
+# (2) every claim carries a SUBTRACTION action in {REMOVE, MOVE, TIGHTEN}
+check "every claim has a REMOVE/MOVE/TIGHTEN action" python3 -c "
+import json
+d=json.load(open('$OUT'))
+assert d['claims'], 'expected findings'
+assert all(c.get('action') in ('REMOVE','MOVE','TIGHTEN') for c in d['claims']), 'bad action'
+assert all(c.get('severity')=='Minor' for c in d['claims']), 'all findings must be Minor (advisory)'
+"
+
+# (3) advisory / non-blocking: exit 0 even under --strict on a fully-flagged manuscript
+python3 "$SCRIPT" --manuscript "$DEF" --strict --quiet >/dev/null 2>&1
+check "exit 0 under --strict (non-blocking)" test "$?" -eq 0
+
+# (4) clean fixture -> zero claims (false-positive guard)
+python3 "$SCRIPT" --manuscript "$CLEAN" --out "$OUT" --quiet >/dev/null 2>&1
+check "clean manuscript yields no flags" python3 -c "
+import json
+d=json.load(open('$OUT'))
+assert d['summary']['n_claims']==0, d['claims']
+"
+python3 "$SCRIPT" --manuscript "$CLEAN" --strict --quiet >/dev/null 2>&1
+check "exit 0 on clean manuscript" test "$?" -eq 0
+
+echo "fail=$fail"; [[ "$fail" -eq 0 ]] && echo "ALL PASS" || echo "FAILURES: $fail"
+exit "$fail"