Retire gemini-cli panel entry + fail-closed blind-review compaction

Two intertwined changes ahead of the gemini-cli free-tier sunset (2026-06-18):

1. Bare "gemini" tail-of-chain entries removed from all 4 panel slots in
config.example.py and the gemini-special-case branch deleted from
_run_panel_chain in review.py. Slots 1/2/3 now end on
or|google/gemma-4-31b-it:free; slot 4 ends on or|google/gemma-4-26b-a4b-it:free
to preserve model-family diversity at the tail. run_gemini_review and
the GEMINI_BIN config knob are kept only as dead code for external-fork
import compatibility and marked DEPRECATED.

2. review_compaction.compact_paper now FAILS CLOSED: on any failure
(model timeout, exception, non-zero exit, unparseable output, empty
input) it returns an EMPTY redacted text, never the original. review.py
detects "_failure" in the manifest, withholds the paper from the panel,
fires a pain signal to ntfy /pain, and returns a PAUSED_AI_FAILURE
aggregate so the worker routes the submission to paused_panel_failure
for curator attention. The previous fail-OPEN behavior would have sent
the un-stripped (author-identified) manuscript to the panel — the exact
integrity violation compaction exists to prevent.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

config.example.py

@@ -87,7 +87,7 @@ OPENROUTER_MODELS = [
         "hf|Qwen/Qwen3-235B-A22B-Instruct-2507:cerebras",
         "or|openai/gpt-oss-120b:free",
         "or|z-ai/glm-4.5-air:free",
-        "gemini",
+        "or|google/gemma-4-31b-it:free",
     ],
     # Slot 2: Groq gpt-oss-120b → Cerebras Qwen3-235B → OR Nvidia/Hermes.
     # nemotron-3-super-120b-a12b excluded (won't emit JSON reliably).
@@ -96,7 +96,7 @@ OPENROUTER_MODELS = [
         "hf|Qwen/Qwen3-235B-A22B-Instruct-2507:cerebras",
         "or|nvidia/nemotron-nano-12b-v2-vl:free",
         "or|nousresearch/hermes-3-llama-3.1-405b:free",
-        "gemini",
+        "or|google/gemma-4-31b-it:free",
     ],
     # Slot 3: Cerebras primary → Groq Llama → OR Google/cross-family.
     [
@@ -104,7 +104,7 @@ OPENROUTER_MODELS = [
         "hf|meta-llama/Llama-3.3-70B-Instruct:groq",
         "or|google/gemma-4-26b-a4b-it:free",
         "or|z-ai/glm-4.5-air:free",
-        "gemini",
+        "or|google/gemma-4-31b-it:free",
     ],
     # Slot 4: HF Groq primary, HF Cerebras fallback, OR tail. Reordered
     # 2026-04-27 after qwen3-next-80b-a3b-instruct:free failed all 4
@@ -122,7 +122,7 @@ OPENROUTER_MODELS = [
         "hf|Qwen/Qwen3-235B-A22B-Instruct-2507:cerebras",
         "or|minimax/minimax-m2.5:free",
         "or|google/gemma-4-31b-it:free",
-        "gemini",
+        "or|google/gemma-4-26b-a4b-it:free",
     ],
 ]
 OPENROUTER_MODELS_API_URL = "https://openrouter.ai/api/v1/models"
@@ -171,6 +171,11 @@ TEMPLATES_DIR = os.path.join(BASE_DIR, "templates")
 SITE_BASE_URL = "https://icsacinstitute.org"
 
 CLAUDE_CMD = "claude"
+# DEPRECATED (2026-05-22): unused. The gemini-cli free tier sunsets
+# 2026-06-18. Blind-review compaction now uses CLAUDE_CMD, and the panel's
+# Gemini-family voice is served via OpenRouter google/gemma :free models.
+# No remaining code path invokes this binary. Kept only to avoid an
+# AttributeError in any external fork that still references it.
 GEMINI_CMD = "gemini"
 
 RUBRIC_DIMENSIONS = [

editorial_workflow.py

@@ -76,7 +76,8 @@ def check_model_availability(timeout: int = 15) -> dict:
                              catalog (the only backend this catalog covers).
       "hf|<model>:<prov>"  → HF Router (Groq/Cerebras) — not in OR's catalog,
                              so it can't be disproven here; treated reachable.
-      "gemini"             → subscription gemini-cli; always reachable.
+    (The "gemini" gemini-cli entry was retired 2026-05-22 ahead of the
+    gemini-cli sunset; no slot ships a bare "gemini" anymore.)
     The pre-2026-05-16 version compared raw prefixed strings against the
     unprefixed OR catalog, so every tagged entry mismatched and all slots
     read 'dead' — falsely skipping reviews on every tick.
@@ -106,8 +107,9 @@ def check_model_availability(timeout: int = 15) -> dict:
 
     def _entry_reachable(entry):
         # Mirror review._run_panel_chain's parsing: bare entries are OR.
-        if entry == "gemini":
-            return True
+        # (The "gemini" gemini-cli special case was retired 2026-05-22; a
+        # stray "gemini" entry now parses as an OR model id and reads as
+        # unreachable, matching the panel chain's post-retirement behavior.)
         kind, sep, model = entry.partition("|")
         if not sep:
             kind, model = "or", entry

review.py

@@ -1,4 +1,10 @@
-"""Multi-model reviewer panel engine using CLI-based AI tooling (claude -p, gemini)."""
+"""Multi-model reviewer panel engine (claude -p, OpenRouter, HF Router).
+
+The gemini-cli tail-of-chain panelist was retired 2026-05-22 ahead of the
+gemini-cli free-tier sunset (2026-06-18); the Gemini-family voice is now an
+OpenRouter google/gemma :free entry. `run_gemini_review` below is retained
+as dead code only for fork compatibility — no live code path calls it.
+"""
 
 import json
 import os
@@ -302,7 +308,13 @@ def run_claude_review(prompt: str, capture_path: str = None) -> dict:
 
 
 def run_gemini_review(prompt: str, capture_path: str = None) -> dict:
-    """Run review via gemini CLI (subscription-backed, no API spend).
+    """DEPRECATED / DEAD CODE (2026-05-22). No live caller — the gemini-cli
+    panelist was retired ahead of the 2026-06-18 free-tier sunset and
+    _run_panel_chain no longer dispatches to it. Retained only so external
+    forks importing this symbol don't break. Will fail at runtime once the
+    gemini binary is gone; do not re-wire it.
+
+    Run review via gemini CLI (subscription-backed, no API spend).
 
     Used as the tail-of-chain fallback for panel slots whose external
     routes (HF Groq, HF Cerebras, OR free) all 413/429 on oversized
@@ -577,6 +589,11 @@ def _run_panel_chain(prompt: str, chain, capture_path: str = None) -> dict:
         return None
 
     for entry in chain:
+        # Backend tag parsing. "hf|<model>:<prov>" → HF Router; everything
+        # else (including legacy untagged entries) → OpenRouter. The bare
+        # "gemini" gemini-cli tail-of-chain was retired 2026-05-22 ahead of
+        # the gemini-cli sunset; the panel's Gemini-family voice is now an
+        # OpenRouter google/gemma :free entry, dispatched like any "or|".
         kind, sep, model = entry.partition("|")
         if not sep:
             kind, model = "or", entry  # legacy bare entry → OR
@@ -1378,6 +1395,32 @@ def _append_citation_verify_audit(record_id: str, citations: list[dict], error)
         pass
 
 
+def _fire_compaction_pain(review_data: dict, reason: str) -> None:
+    """Fire a pain signal when blind-review compaction fails closed.
+
+    Direct ntfy /pain POST so a curator investigates the withheld paper.
+    Best-effort, never raises — the fail-closed PAUSE has already protected
+    author identity by the time this is called; the alert is observability.
+    """
+    url = getattr(config, "NTFY_PAIN_URL", "")
+    if not url:
+        return
+    import urllib.request
+    rec_id = review_data.get("record_id", "?")
+    title = review_data.get("title", "Untitled")
+    body = (
+        f"Blind-review compaction FAILED for {rec_id} ({title}): {reason}. "
+        f"Paper withheld from the panel (fail-closed) and submission PAUSED. "
+        f"Curator must investigate before any review can proceed."
+    )
+    try:
+        req = urllib.request.Request(url, data=body.encode())
+        req.add_header("Title", "ICSAC compaction failure — paper withheld")
+        urllib.request.urlopen(req, timeout=5)
+    except Exception:
+        pass
+
+
 def review_paper(review_data: dict) -> tuple[str, dict]:
     """Run full multi-model review with self-heal + multi-pass aggregation.
 
@@ -1411,33 +1454,55 @@ def review_paper(review_data: dict) -> tuple[str, dict]:
         log=lambda m: print(m, file=__import__("sys").stderr),
     )
     if compaction_manifest.get("_failure"):
+        # FAIL CLOSED. Blind-review compaction failed, so the manuscript
+        # still carries author identifiers. Letting it reach the panel
+        # would leak author identity into a supposedly blind review — the
+        # exact integrity violation compaction exists to prevent. Withhold
+        # the paper, fire a pain signal for a curator, and return a PAUSED
+        # aggregate (the worker routes this to paused_panel_failure).
+        reason = compaction_manifest["_failure"]
         print(
-            f"  compaction: skipped ({compaction_manifest['_failure']}); "
-            f"panel will see un-stripped paper",
-            file=__import__("sys").stderr,
-        )
-    else:
-        pct = compaction_manifest.get("reduction_pct", 0)
-        print(
-            f"  compaction: applied ({compaction_manifest.get('original_chars', 0)} -> "
-            f"{compaction_manifest.get('redacted_chars', 0)} chars, {pct}% reduction)",
-            file=__import__("sys").stderr,
+            f"  compaction: FAILED ({reason}); paper WITHHELD from panel "
+            f"(fail-closed — author identity protected)",
+            file=sys.stderr,
         )
+        _fire_compaction_pain(review_data, reason)
+        aggregate = {
+            "recommendation": "PAUSED_AI_FAILURE",
+            "models_used": [],
+            "failed_models": [],
+            "reason": (
+                f"Blind-review compaction failed ({reason}); manuscript "
+                f"withheld from the panel to prevent author-identity leakage"
+            ),
+            "disagreement": False,
+            "dimension_scores": {},
+            "pass_aggregates": [],
+            "dimension_stdev": {},
+            "passes": 0,
+            "compaction_manifest": compaction_manifest,
+        }
+        markdown = generate_review_markdown(review_data, [], aggregate)
+        path = save_review(review_data, markdown)
+        print(f"  PAUSED — compaction failed, review withheld: {path}")
+        return markdown, aggregate
+
+    pct = compaction_manifest.get("reduction_pct", 0)
+    print(
+        f"  compaction: applied ({compaction_manifest.get('original_chars', 0)} -> "
+        f"{compaction_manifest.get('redacted_chars', 0)} chars, {pct}% reduction)",
+        file=sys.stderr,
+    )
 
     # Build the panel-facing review_data view: redacted text + blinded
     # creators in the SUBMISSION metadata block. The original review_data
     # is left untouched (worker still needs the real creators for audit
-    # and the apply_decision email path).
+    # and the apply_decision email path). Reached only on compaction
+    # success — the failure path above already returned.
     compacted_data = dict(review_data)
-    if compaction_manifest.get("_failure"):
-        # On failure, keep original text but still blind the creators
-        # metadata so the panel does not see author names in the prompt
-        # header even when compaction itself failed.
-        pass
-    else:
-        compacted_data["full_text"] = (
-            review_compaction.panel_notice() + redacted_text
-        )
+    compacted_data["full_text"] = (
+        review_compaction.panel_notice() + redacted_text
+    )
     compacted_data["creators"] = [
         {"name": "[author identity withheld for blind review]"}
     ]

review_compaction.py

@@ -16,25 +16,31 @@ Two intentions, one mechanism:
      Trimming them lets larger manuscripts fit the panel's per-route
      context budgets.
 
-Implementation strategy (extract-not-echo, 2026-05-18 refactor):
+Implementation strategy (extract-not-echo, 2026-05-18 refactor; repointed
+from gemini-cli to `claude -p` 2026-05-22 ahead of the gemini-cli sunset):
 
-  Gemini is asked to IDENTIFY spans to remove (short snippets, section
+  The model is asked to IDENTIFY spans to remove (short snippets, section
   start/end anchors) — never to echo the redacted manuscript back. Python
   performs the actual removal via string operations against the original
-  text. This keeps gemini's output small (a few KB regardless of paper
+  text. This keeps the model's output small (a few KB regardless of paper
   size) and avoids the output-truncation / content-filter trips that hit
   large-paper echo-style runs (see the DET-paper failure mode at 28K
-  tokens: gemini's invalid-content retry exhaustion mid-echo).
+  tokens: invalid-content retry exhaustion mid-echo).
 
-  Tradeoff: if gemini returns a snippet that doesn't string-match in the
+  Tradeoff: if the model returns a snippet that doesn't string-match in the
   original (whitespace drift, hyphenation, OCR artifacts), that category
   silently does not redact. Logged in the manifest as a `match_failures`
   list so curators can spot egregious cases.
 
-Returns (redacted_text, manifest_dict). On gemini failure or empty extract
-output, returns (original_text, {"_failure": "<reason>"}) — the worker
-treats that as a non-fatal warning and proceeds with the un-stripped
-paper. A failed compaction never blocks a real submission.
+Returns (redacted_text, manifest_dict).
+
+FAIL CLOSED (2026-05-22): on ANY compaction failure (model timeout,
+exception, non-zero exit, unparseable output, empty input) this returns
+("", {"_failure": "<reason>"}) — an EMPTY redacted text, never the
+original. Author identity must never reach the blind panel. The caller
+(review.review_paper) detects the "_failure" key, withholds the paper from
+the panel, fires a pain signal, and pauses the submission for a curator.
+A failed compaction blocks the paper rather than leaking identity.
 """
 
 from __future__ import annotations
@@ -133,32 +139,32 @@ _EMPTY_MANIFEST = {
 }
 
 
-def _gemini_call(prompt_input: str, *, timeout_sec: int = 600) -> tuple[str, str, int]:
-    """Invoke gemini-cli, returning (stdout, stderr, returncode).
+def _claude_call(manuscript: str, *, timeout_sec: int = 600) -> tuple[str, str, int]:
+    """Invoke `claude -p`, returning (stdout, stderr, returncode).
 
-    Sets GEMINI_CLI_TRUST_WORKSPACE so headless invocations don't trip the
-    trusted-folders gate. Uses EXTRACT_PROMPT as -p; passes the manuscript
-    on stdin.
+    `claude -p` reads its prompt from stdin, so EXTRACT_PROMPT and the
+    manuscript are concatenated (prompt first, blank line, then manuscript)
+    and fed via input=. EXTRACT_PROMPT is deliberately NOT passed as a
+    positional arg. Claude returns the same JSON manifest schema the rest of
+    this module expects (_extract_json parses it).
     """
-    env = {**os.environ, "GEMINI_CLI_TRUST_WORKSPACE": "true"}
     proc = subprocess.run(
-        [config.GEMINI_CMD, "-p", EXTRACT_PROMPT],
-        input=prompt_input,
+        [config.CLAUDE_CMD, "-p"],
+        input=EXTRACT_PROMPT + "\n\n" + manuscript,
         capture_output=True,
         text=True,
         timeout=timeout_sec,
-        env=env,
     )
     return proc.stdout, proc.stderr, proc.returncode
 
 
 def _extract_json(raw: str) -> dict | None:
-    """Pull a single JSON object out of gemini's stdout.
+    """Pull a single JSON object out of the model's stdout.
 
-    gemini-cli prepends warning lines on first use (256-color, ripgrep
-    missing, etc.). We tolerate those — find the first '{' and parse from
-    there. If the output is wrapped in ```json ... ``` despite the prompt
-    asking otherwise, strip those fences first.
+    The CLI may prepend incidental lines before the JSON. We tolerate
+    those — find the first '{' and parse from there. If the output is
+    wrapped in ```json ... ``` despite the prompt asking otherwise, strip
+    those fences first.
     """
     text = raw.strip()
     if text.startswith("```"):
@@ -317,10 +323,12 @@ def _apply_removals(text: str, spans: dict) -> tuple[str, dict, list]:
 def compact_paper(paper_text: str, *, log=None) -> tuple[str, dict]:
     """Strip author/identifier metadata from a manuscript for blind review.
 
-    Returns (redacted_text, manifest). On any failure path the original
-    text is returned with a manifest carrying a "_failure" reason — the
-    caller treats that as a non-fatal warning and proceeds with the
-    un-stripped paper. Compaction MUST NEVER block a submission.
+    Returns (redacted_text, manifest). FAIL CLOSED: on any failure path the
+    redacted text is the EMPTY STRING (never the original) and the manifest
+    carries a "_failure" reason. The caller (review.review_paper) must treat
+    a "_failure" manifest as a hard stop — withhold the paper from the panel
+    and pause the submission — so author identity can never leak into a
+    "blind" review. Compaction failure BLOCKS the paper.
     """
     def _log(msg: str) -> None:
         if log:
@@ -331,37 +339,38 @@ def compact_paper(paper_text: str, *, log=None) -> tuple[str, dict]:
     if not paper_text or not paper_text.strip():
         manifest = dict(_EMPTY_MANIFEST)
         manifest["_failure"] = "empty input"
-        return paper_text, manifest
+        return "", manifest
 
     try:
-        stdout, stderr, rc = _gemini_call(paper_text)
+        stdout, stderr, rc = _claude_call(paper_text)
     except subprocess.TimeoutExpired:
-        _log("  compaction: gemini timed out; proceeding with un-stripped paper")
+        _log("  compaction: claude timed out; FAILING CLOSED (paper withheld from panel)")
         manifest = dict(_EMPTY_MANIFEST)
-        manifest["_failure"] = "gemini timeout"
-        return paper_text, manifest
+        manifest["_failure"] = "claude timeout"
+        return "", manifest
     except Exception as exc:
-        _log(f"  compaction: gemini call raised {type(exc).__name__}: {exc}")
+        _log(f"  compaction: claude call raised {type(exc).__name__}: {exc}; "
+             f"FAILING CLOSED (paper withheld from panel)")
         manifest = dict(_EMPTY_MANIFEST)
-        manifest["_failure"] = f"gemini exception: {type(exc).__name__}"
-        return paper_text, manifest
+        manifest["_failure"] = f"claude exception: {type(exc).__name__}"
+        return "", manifest
 
     if rc != 0:
-        # Gemini-cli failed but we may still have partial output. Surface
-        # the rc so curators can investigate; treat as a failure.
+        # claude -p failed. Surface the rc so curators can investigate;
+        # treat as a hard failure (fail closed).
         snippet = (stderr or "")[:240].replace("\n", " ")
-        _log(f"  compaction: gemini exited {rc}; stderr: {snippet}")
+        _log(f"  compaction: claude exited {rc}; stderr: {snippet}; FAILING CLOSED")
         manifest = dict(_EMPTY_MANIFEST)
-        manifest["_failure"] = f"gemini exit {rc}"
-        return paper_text, manifest
+        manifest["_failure"] = f"claude exit {rc}"
+        return "", manifest
 
     spans = _extract_json(stdout)
     if spans is None:
-        _log(f"  compaction: gemini output not parseable as JSON "
-             f"({len(stdout)} chars stdout)")
+        _log(f"  compaction: claude output not parseable as JSON "
+             f"({len(stdout)} chars stdout); FAILING CLOSED")
         manifest = dict(_EMPTY_MANIFEST)
-        manifest["_failure"] = "gemini output unparseable"
-        return paper_text, manifest
+        manifest["_failure"] = "claude output unparseable"
+        return "", manifest
 
     redacted, manifest, match_failures = _apply_removals(paper_text, spans)
 
@@ -386,7 +395,9 @@ def render_manifest(manifest: dict) -> str:
     """Render a manifest dict as a plain-text bulleted list for the
     decision email's compaction disclosure block."""
     if manifest.get("_failure"):
-        return f"(Compaction not applied: {manifest['_failure']}. The panel reviewed the un-stripped manuscript.)"
+        return (f"(Compaction failed: {manifest['_failure']}. The manuscript was "
+                f"WITHHELD from the panel to prevent author-identity leakage; "
+                f"the submission was paused for curator review.)")
 
     lines = []
     if manifest.get("author_names"):