@chrono-meta/fh-gate 1.4.16 → 1.4.18

package/plugins/fh-meta/skills/pipeline-conductor/SKILL.md

@@ -49,11 +49,7 @@ Basis:   [one-line summary of deciding factor]
 | `FAIL` | Blocking issue found | Halt chain, surface to user immediately |
 | `ESCALATE` | Ambiguous state requiring human judgment | Pause chain, present three options to user |
 
-`CONDITIONAL_PASS` means proceed, not skip. Items captured under `CONDITIONAL_PASS` accumulate into the final report's Pending section and must be addressed before the sweep is considered clean.
-
-`FAIL` halts the chain. The user decides whether to fix-and-resume or abandon the sweep.
-
-`ESCALATE` pauses the chain. The user chooses one of three paths — the chain resumes or closes based on their decision.
+`CONDITIONAL_PASS` means proceed, not skip — captured items accumulate into the final report's Pending section and must be addressed before the sweep is considered clean. `FAIL` halts the chain (user decides fix-and-resume or abandon). `ESCALATE` pauses the chain pending the user's choice.
 
 ### ESCALATE Handling
 
@@ -72,21 +68,17 @@ When any step returns `ESCALATE`, present:
 
 ## Step 0. Scope, Mode, and Translation
 
-Determine the following before running any pipeline step.
+Determine before running any pipeline step:
 
-**1. Scope**: What is being verified?
-   - Single skill: path to `SKILL.md` (e.g., `plugins/fh-meta/skills/foo/SKILL.md`)
-   - Specific asset: file or directory path
-   - Full harness: all assets under `plugins/` and `templates/`
+1. **Scope**: single skill (path to `SKILL.md`) · specific asset (file/directory) · full harness (`plugins/` + `templates/`)
+2. **Mode**: `--quick`, `--no-sim`, or `--full` (default)
+3. **Branch**: current git branch (used for regression guard and report header)
 
-**2. Mode**: `--quick`, `--no-sim`, or `--full` (default)
+If scope is not specified, ask: *"What should I sweep? (e.g., a specific skill path, a directory, or the full harness)"* **Do not infer scope** — a wrong scope produces misleading verdicts.
 
-**3. Branch**: Current git branch (used for regression guard and report header)
+Output the sweep plan and get Y/N confirmation before running.
 
-If scope is not specified, ask:
-> "What should I sweep? (e.g., a specific skill path, a directory, or the full harness)"
-
-Do not infer scope — a wrong scope produces misleading verdicts.
+> **Detail**: See `SKILL_detail.md §Output-Formats` — sweep plan block, per-step verdict blocks, aggregated report template — read when emitting any step output.
 
 ### Scope Translation Table
 
@@ -98,19 +90,6 @@ The four constituent skills use heterogeneous scope models. Translate the pipeli
 | Specific directory | Check session findings in this domain | Attack all SKILL.md files in directory | Back-trace all claims in directory | Area A + Area D on the domain |
 | Full harness | Check all recent session findings | Attack all harness assets under scope | Back-trace all claims across harness | Area A + Area B + Area D |
 
-### Step 0 Output
-
-```
-pipeline-conductor — Sweep Plan
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Scope:  {scope}
-  Mode:   {--full / --quick / --no-sim}
-  Branch: {branch name}
-  Steps:  {1 → 2 → 3 → 4 / 2 → 3 / 1 → 2 → 3}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Proceed? (Y: run / N: cancel)
-```
-
 ---
 
 ## Step 0.5. return-path-gate — Pre-flight Chain Audit
@@ -125,21 +104,7 @@ Run `/return-path-gate --skill [scope]`.
 | MEDIUM/LOW severity OPEN chains only | `CONDITIONAL_PASS` | Proceed; capture in Pending |
 | 1+ HIGH severity OPEN chains | `FAIL` | **Halt sweep** — fix chains before running pipeline |
 
-**On FAIL (HIGH severity OPEN chains)**:
-
-```
-[Step 0.5 — return-path-gate]
-  Verdict: FAIL
-  Basis:   HIGH severity OPEN chain(s) — inter-step verdicts unreliable with broken chains
-  Open:    [list of OPEN chains with severity]
-
-Fix OPEN chains then re-run pipeline-conductor.
-Skip? (S: override gate — records as degraded, disqualifies CLEAN (--full) status)
-```
-
-`S` (skip) is available but must be declared explicitly. Skipping records as `degraded: return-path-gate (user override)` in the final report and the sweep cannot reach `CLEAN (--full)` status regardless of subsequent step verdicts.
-
-**On CONDITIONAL_PASS (MEDIUM/LOW only)**: Capture OPEN chains in Pending. Continue to Step 1.
+**Skip override rule**: `S` (skip on FAIL) is available but must be declared explicitly. Skipping records as `degraded: return-path-gate (user override)` in the final report and the sweep **cannot reach `CLEAN (--full)` status** regardless of subsequent step verdicts.
 
 ---
 
@@ -147,16 +112,7 @@ Skip? (S: override gate — records as degraded, disqualifies CLEAN (--full) sta
 
 > Skipped in `--quick` mode.
 
-Check for harvest-loop signals in the current session. pipeline-conductor reads session context for harvest-loop findings rather than invoking harvest-loop directly — invoking harvest-loop mid-sweep would start a new harvest cycle that conflicts with the sweep's own pattern collection. If no harvest-loop run exists in this session, pipeline-conductor can invoke harvest-loop in proposal mode (`/harvest-loop`) as a pre-Step-1 option, but this is not automatic.
-
-**What it checks**: Whether recent session learnings have been absorbed, whether duplicate skill candidates are pending, whether knowledge loop integrity issues exist in the current session.
-
-**Invocation path**:
-- If harvest-loop ran in this session: read its output and incorporate findings.
-- If harvest-loop did not run in this session: output `CONDITIONAL_PASS` — knowledge loop not validated in this sweep.
-- If harvest-loop auto-skipped (fewer than 3 patterns found): output `CONDITIONAL_PASS` — sub-threshold, knowledge loop not validated.
-
-**Verdict criteria**:
+Check for harvest-loop signals in the current session — read session context rather than invoking harvest-loop directly (a mid-sweep invocation would conflict with the sweep's own pattern collection).
 
 | harvest-loop result | pipeline-conductor verdict |
 |---|---|
@@ -166,35 +122,19 @@ Check for harvest-loop signals in the current session. pipeline-conductor reads
 | Did not run this session | `CONDITIONAL_PASS` — note: knowledge loop not validated |
 | Auto-skipped (< 3 patterns) | `CONDITIONAL_PASS` — note: sub-threshold, not validated |
 
-**On FAIL**: Output the harvest-loop failure reason. Ask:
-> "harvest-loop reported a blocking issue. Fix and re-run Step 1, or abort the sweep?"
-
-**On CONDITIONAL_PASS**: Log all pending patterns or unvalidated notes. Continue to Step 2.
-
-```
-[Step 1 — harvest-loop]
-  Verdict: {verdict}
-  Basis:   {one-line}
-  Pending: {list of items if CONDITIONAL_PASS, else "none"}
-```
+> **Detail**: See `SKILL_detail.md §Execution-Notes` — harvest-loop invocation path, per-step FAIL prompts, Area B cadence bash, what-each-step-checks reference — read when executing Steps 1–4.
 
 ---
 
 ## Step 2. steel-quench — Adversarial Verification
 
-Run steel-quench against the target scope.
-
-**What it checks**: Design attack surface, trigger phrase collisions, over-engineered steps, self-declaration language, structural flaws surfaced by devil-advocate rounds.
-
-**Invocation**: Run steel-quench in its standard mode. For `--quick`, this is the first step.
+Run steel-quench against the target scope (for `--quick`, this is the first step).
 
 **steel-quench severity vocabulary** (S/A/B grade — not M/S/R):
 - **S-grade**: Immediate blocker — must fix before proceeding
 - **A-grade**: Required before deployment — fix before external release
 - **B-grade**: Improvement recommended — non-blocking
 
-**Verdict criteria**:
-
 | steel-quench result | pipeline-conductor verdict |
 |---|---|
 | 0 S-grade findings | `PASS` |
@@ -202,42 +142,19 @@ Run steel-quench against the target scope.
 | 1+ S-grade findings | `FAIL` |
 | Wave 4 (Meta-Aware Adversary) surfaces structural ambiguity | `ESCALATE` |
 
-**On FAIL**: Output S-grade finding(s) from steel-quench. Ask:
-> "steel-quench found a blocking issue. Fix and re-run Step 2, or abort the sweep?"
-
-**On CONDITIONAL_PASS**: Capture A-grade and B-grade findings. Continue to Step 3.
-
-```
-[Step 2 — steel-quench]
-  Verdict: {verdict}
-  Basis:   {one-line}
-  Findings:
-    S-grade: {count} — {top item or "none"}
-    A-grade: {count} — {top item or "none"}
-    B-grade: {count} — {top item or "none"}
-```
-
 ---
 
 ## Step 3. phantom-quench — Phantom Claim Detection
 
-Run phantom-quench against the target scope.
+Run phantom-quench scoped to the same target as Steps 1 and 2.
 
-**What it checks**: Proper nouns, numerical values, file paths, and branching conditions back-traced to declared source files. Claims not found in source are marked Phantom.
-
-**Invocation**: Run phantom-quench scoped to the same target as Steps 1 and 2.
-
-**Load-bearing Phantom** (binary test — apply mechanically):
-
-A Phantom is load-bearing if it appears in any of:
+**Load-bearing Phantom** (binary test — apply mechanically). A Phantom is load-bearing if it appears in any of:
 - `§Done When` section of the skill under audit
 - Any numbered `§Step N` execution body
 - `§Chains` with mandatory dispatch language (`→ Mandatory next`)
 
 All other locations (§Triggers, advisory §Chains language, frontmatter description) are non-load-bearing by definition.
 
-**Verdict criteria**:
-
 | phantom-quench result | pipeline-conductor verdict |
 |---|---|
 | 0 Phantoms, all claims grounded | `PASS` |
@@ -245,40 +162,15 @@ All other locations (§Triggers, advisory §Chains language, frontmatter descrip
 | 1+ load-bearing Phantoms | `FAIL` |
 | Grounding ambiguous (source file exists but content unclear) | `ESCALATE` |
 
-**On FAIL**: Output the load-bearing Phantom(s). Ask:
-> "phantom-quench found a load-bearing Phantom claim. Fix and re-run Step 3, or abort the sweep?"
-
-**On CONDITIONAL_PASS**: Capture non-load-bearing Phantoms. Continue to Step 4.
-
-```
-[Step 3 — phantom-quench]
-  Verdict: {verdict}
-  Basis:   {one-line}
-  Phantoms: {count} — {load-bearing: Y/N} — {top item or "none"}
-```
-
 ---
 
 ## Step 4. sim-conductor — Pre-Deploy Simulation
 
 > Skipped in `--quick` and `--no-sim` modes.
 
-Run sim-conductor against the target scope.
-
-**What it checks**: Transferability to external users, new-user entry point friction, power-user edge cases, artifact quality from an outside perspective.
-
-**Area B cadence check** (sim-conductor Area B has a once-per-week frequency limit):
-
-```bash
-find tracks/_meta/ -name "*sim_conductor*" -newer "$(date -v-7d +%Y-%m-%d 2>/dev/null || date -d '7 days ago' +%Y-%m-%d 2>/dev/null)" 2>/dev/null | head -1
-```
-
-- Result found (Area B ran within 7 days): skip Area B → run Area A + Area D only. Capture as `CONDITIONAL_PASS` with note: "Area B skipped — within 7-day cadence limit."
-- No result (Area B not run within 7 days): run Area A + Area B + Area D (scope permitting).
+Run sim-conductor against the target scope: Area A + Area B (if cadence allows) + Area D (if scope is a specific SKILL.md or document).
 
-**Invocation**: Area A + Area B (if cadence allows) + Area D (if scope is a specific SKILL.md or document).
-
-**Verdict criteria**:
+**Area B cadence rule (behavioral)**: Area B has a once-per-week frequency limit. If Area B ran within 7 days (detection bash in §Execution-Notes) → skip Area B, run Area A + D only, capture as `CONDITIONAL_PASS` with note "Area B skipped — within 7-day cadence limit."
 
 | sim-conductor result | pipeline-conductor verdict |
 |---|---|
@@ -287,51 +179,11 @@ find tracks/_meta/ -name "*sim_conductor*" -newer "$(date -v-7d +%Y-%m-%d 2>/dev
 | 1+ M-tier findings from any persona | `FAIL` |
 | Persona results conflict, resolution requires human judgment | `ESCALATE` |
 
-**On FAIL**: Output M-tier finding(s) from sim-conductor. Ask:
-> "sim-conductor found a blocking issue. Fix and re-run Step 4, or accept findings and close with FAIL status?"
-
-**On CONDITIONAL_PASS**: Capture S/R-tier findings. Proceed to final report.
-
-```
-[Step 4 — sim-conductor]
-  Verdict: {verdict}
-  Basis:   {one-line}
-  Area B:  {ran / skipped — cadence limit}
-  Findings:
-    M: {count} — {top item or "none"}
-    S: {count} — {top item or "none"}
-    R: {count} — {top item or "none"}
-```
-
 ---
 
 ## Step 5. Aggregated Report
 
-After all steps complete (or after chain halt), output the aggregated report.
-
-```
-pipeline-conductor — Sweep Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Scope:  {scope}
-  Mode:   {mode}
-  Branch: {branch}
-  Date:   {YYYY-MM-DD}
-
-  Step 0.5 — return-path-gate:       {PASS / CONDITIONAL_PASS / FAIL / SKIPPED / degraded}
-  Step 1   — harvest-loop:           {PASS / CONDITIONAL_PASS / FAIL / ESCALATE / SKIPPED}
-  Step 2   — steel-quench:           {verdict}
-  Step 3   — phantom-quench: {verdict}
-  Step 4   — sim-conductor:          {verdict}
-
-  Overall: {CLEAN (--full) / CLEAN (--quick) / CLEAN (--no-sim) / PENDING / BLOCKED}
-
-  ── Pending items (CONDITIONAL_PASS steps + accepted ESCALATE) ──
-  {item list, or "none"}
-
-  ── Blocking items (FAIL steps + unresolved ESCALATE) ──
-  {item list, or "none — sweep completed cleanly"}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
+After all steps complete (or after chain halt), output the aggregated report (template in §Output-Formats).
 
 **Overall verdict logic**:
 
@@ -347,14 +199,7 @@ pipeline-conductor — Sweep Report
 - `PENDING`: Resolve captured items before external release.
 - `BLOCKED`: Do not proceed. Fix blocking items and re-run affected step(s).
 
-### Report Persistence
-
-Save the report to:
-```
-tracks/_meta/pipeline_conductor_{YYYY-MM-DD}_{scope-slug}.md
-```
-
-If `tracks/_meta/` does not exist, output a B-grade warning and skip persistence.
+**Report persistence**: save to `tracks/_meta/pipeline_conductor_{YYYY-MM-DD}_{scope-slug}.md`. If `tracks/_meta/` does not exist, output a B-grade warning and skip persistence.
 
 ---
 
@@ -370,12 +215,7 @@ If `tracks/_meta/` does not exist, output a B-grade warning and skip persistence
 
 Resume is scope-bound — the scope from Step 0 is preserved across resume calls.
 
-**After ESCALATE**:
-
-1. Present the three options (see ESCALATE Handling above).
-2. Option (a) — user provides decision: incorporate as resolution note, re-evaluate the step gate with decision context, continue chain from step N or N+1.
-3. Option (b) — accept and continue: mark ESCALATE item as PENDING, continue chain from step N+1.
-4. Option (c) — abort: close sweep, output BLOCKED report with ESCALATE item in blocking section.
+**After ESCALATE**: present the three options (see ESCALATE Handling above); (a) incorporate decision and continue, (b) mark PENDING and continue from N+1, (c) abort with BLOCKED report.
 
 ---
 

package/plugins/fh-meta/skills/pipeline-conductor/SKILL_detail.md

@@ -0,0 +1,149 @@
+---
+name: pipeline-conductor-detail
+description: Detail reference for pipeline-conductor — per-step output format blocks, aggregated report template, invocation notes, Area B cadence bash. Load when executing a specific step.
+load: on-demand
+---
+
+# pipeline-conductor — Detail Reference
+
+> Load when executing a specific step. SKILL.md contains triggers, modes, the verdict vocabulary + chain behavior, scope translation, per-step gate tables, overall verdict logic, resume rules, and Done When.
+
+---
+
+## §Output-Formats
+
+### Step 0 — Sweep Plan
+
+```
+pipeline-conductor — Sweep Plan
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Scope:  {scope}
+  Mode:   {--full / --quick / --no-sim}
+  Branch: {branch name}
+  Steps:  {1 → 2 → 3 → 4 / 2 → 3 / 1 → 2 → 3}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Proceed? (Y: run / N: cancel)
+```
+
+### Step 0.5 — return-path-gate FAIL block
+
+```
+[Step 0.5 — return-path-gate]
+  Verdict: FAIL
+  Basis:   HIGH severity OPEN chain(s) — inter-step verdicts unreliable with broken chains
+  Open:    [list of OPEN chains with severity]
+
+Fix OPEN chains then re-run pipeline-conductor.
+Skip? (S: override gate — records as degraded, disqualifies CLEAN (--full) status)
+```
+
+### Step 1 — harvest-loop verdict block
+
+```
+[Step 1 — harvest-loop]
+  Verdict: {verdict}
+  Basis:   {one-line}
+  Pending: {list of items if CONDITIONAL_PASS, else "none"}
+```
+
+### Step 2 — steel-quench verdict block
+
+```
+[Step 2 — steel-quench]
+  Verdict: {verdict}
+  Basis:   {one-line}
+  Findings:
+    S-grade: {count} — {top item or "none"}
+    A-grade: {count} — {top item or "none"}
+    B-grade: {count} — {top item or "none"}
+```
+
+### Step 3 — phantom-quench verdict block
+
+```
+[Step 3 — phantom-quench]
+  Verdict: {verdict}
+  Basis:   {one-line}
+  Phantoms: {count} — {load-bearing: Y/N} — {top item or "none"}
+```
+
+### Step 4 — sim-conductor verdict block
+
+```
+[Step 4 — sim-conductor]
+  Verdict: {verdict}
+  Basis:   {one-line}
+  Area B:  {ran / skipped — cadence limit}
+  Findings:
+    M: {count} — {top item or "none"}
+    S: {count} — {top item or "none"}
+    R: {count} — {top item or "none"}
+```
+
+### Step 5 — Aggregated Report
+
+```
+pipeline-conductor — Sweep Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Scope:  {scope}
+  Mode:   {mode}
+  Branch: {branch}
+  Date:   {YYYY-MM-DD}
+
+  Step 0.5 — return-path-gate:       {PASS / CONDITIONAL_PASS / FAIL / SKIPPED / degraded}
+  Step 1   — harvest-loop:           {PASS / CONDITIONAL_PASS / FAIL / ESCALATE / SKIPPED}
+  Step 2   — steel-quench:           {verdict}
+  Step 3   — phantom-quench: {verdict}
+  Step 4   — sim-conductor:          {verdict}
+
+  Overall: {CLEAN (--full) / CLEAN (--quick) / CLEAN (--no-sim) / PENDING / BLOCKED}
+
+  ── Pending items (CONDITIONAL_PASS steps + accepted ESCALATE) ──
+  {item list, or "none"}
+
+  ── Blocking items (FAIL steps + unresolved ESCALATE) ──
+  {item list, or "none — sweep completed cleanly"}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## §Execution-Notes
+
+### Step 1 — harvest-loop invocation path
+
+pipeline-conductor reads session context for harvest-loop findings rather than invoking harvest-loop directly — invoking harvest-loop mid-sweep would start a new harvest cycle that conflicts with the sweep's own pattern collection. If no harvest-loop run exists in this session, pipeline-conductor can invoke harvest-loop in proposal mode (`/harvest-loop`) as a pre-Step-1 option, but this is not automatic.
+
+- If harvest-loop ran in this session: read its output and incorporate findings.
+- If harvest-loop did not run in this session: output `CONDITIONAL_PASS` — knowledge loop not validated in this sweep.
+- If harvest-loop auto-skipped (fewer than 3 patterns found): output `CONDITIONAL_PASS` — sub-threshold, knowledge loop not validated.
+
+### Per-step FAIL prompts
+
+On FAIL the chain halts and asks (insert the failing step's name and finding):
+
+> "{step skill} found a blocking issue. Fix and re-run Step {N}, or abort the sweep?"
+
+(Step 4 variant: "…or accept findings and close with FAIL status?")
+
+On CONDITIONAL_PASS in any step: capture the finding list (Step 2: A/B-grade; Step 3: non-load-bearing Phantoms; Step 4: S/R-tier findings) and continue to the next step.
+
+### Step 4 — Area B cadence check bash
+
+sim-conductor Area B has a once-per-week frequency limit:
+
+```bash
+find tracks/_meta/ -name "*sim_conductor*" -newer "$(date -v-7d +%Y-%m-%d 2>/dev/null || date -d '7 days ago' +%Y-%m-%d 2>/dev/null)" 2>/dev/null | head -1
+```
+
+- Result found (Area B ran within 7 days): skip Area B → run Area A + Area D only. Capture as `CONDITIONAL_PASS` with note: "Area B skipped — within 7-day cadence limit."
+- No result (Area B not run within 7 days): run Area A + Area B + Area D (scope permitting).
+
+### What each step checks (reference)
+
+| Step | Checks |
+|---|---|
+| 1 harvest-loop | Recent session learnings absorbed, duplicate skill candidates pending, knowledge loop integrity in current session |
+| 2 steel-quench | Design attack surface, trigger phrase collisions, over-engineered steps, self-declaration language, devil-advocate structural flaws |
+| 3 phantom-quench | Proper nouns, numerical values, file paths, branching conditions back-traced to declared sources; ungrounded claims = Phantom |
+| 4 sim-conductor | Transferability to external users, new-user entry friction, power-user edge cases, artifact quality from outside perspective |

package/plugins/fh-meta/skills/sim-conductor/SKILL_detail.md

@@ -172,13 +172,19 @@ Run multi-team? (a) Full panel  (b) Claude sub-agents only  (c) Skip to Area B
 | T2 Copilot | `gh copilot suggest` | challenger · expert | `gh copilot suggest -t shell` |
 | T3 Ollama | `ollama run` | challenger | `ollama run llama3 PROMPT` |
 | T4 Codex | `npx @openai/codex exec` | challenger · edge-case-hunter | `echo PROMPT \| npx @openai/codex exec -m gpt-5 -` |
+| T5 agy | `agy -p` (gemini successor) | challenger · beginner | `agy -p "PROMPT"` — argument form only (stdin pipe prints help); timebox+retry hard rule (intermittent hang class); -p auto-approves tools → trusted artifacts only |
 
 ### CLI detection bash
 
 ```bash
 # Detect available external CLIs
 AVAILABLE_CLIS=""
-command -v gemini   &>/dev/null && AVAILABLE_CLIS="$AVAILABLE_CLIS gemini"
+tb() { perl -e 'alarm shift; exec @ARGV' "$@"; }   # portable timebox — darwin ships no `timeout`
+command -v agy      &>/dev/null && AVAILABLE_CLIS="$AVAILABLE_CLIS agy"
+# gemini backend EOL 2026-06-18 — binary outlives the service; liveness probe (timeboxed minimal
+# call) replaces the bare `command -v`, which would pass while pipes silently return empty.
+# Probe uses the same stdin-pipe form T1 dispatch uses; result valid per session (no re-probe).
+command -v gemini   &>/dev/null && [ -n "$(echo ping | tb 20 gemini 2>/dev/null)" ] && AVAILABLE_CLIS="$AVAILABLE_CLIS gemini"
 command -v gh       &>/dev/null && gh copilot --version &>/dev/null && AVAILABLE_CLIS="$AVAILABLE_CLIS copilot"
 command -v ollama   &>/dev/null && AVAILABLE_CLIS="$AVAILABLE_CLIS ollama"
 command -v npx      &>/dev/null && npx @openai/codex --version &>/dev/null 2>&1 && AVAILABLE_CLIS="$AVAILABLE_CLIS codex"

package/plugins/fh-meta/skills/steel-quench/SKILL_detail.md

@@ -243,7 +243,7 @@ claude CLI also absent  → Skip Wave 5, note in residual risk card
 
 ```
 Wave 5 — Multi-Team Panel available.
-Detected external CLIs: [gemini · gh-copilot · ollama | none]
+Detected external CLIs: [agy · gemini · gh-copilot · ollama | none]
 
 Estimated token cost:
   External CLIs: each team ×2-3 personas → ~2K–5K tokens per team (billed to that CLI)
@@ -259,7 +259,15 @@ Run Wave 5?
 
 ```bash
 TEAMS=()
-command -v gemini           &>/dev/null && TEAMS+=("gemini")
+# tb = portable timebox (darwin ships no `timeout`; perl alarm works everywhere)
+tb() { perl -e 'alarm shift; exec @ARGV' "$@"; }
+command -v agy              &>/dev/null && TEAMS+=("agy")
+# gemini backend EOL 2026-06-18 — the binary outlives the service, so a bare `command -v` goes
+# silently stale (pipes return empty behind 2>/dev/null). Liveness probe (one minimal billed
+# call, timeboxed) gates the slot instead. Probe uses the SAME stdin-pipe form the T1 dispatch
+# uses (probing a different invocation path can pass while dispatch fails — agy proved the two
+# forms diverge on one binary). Probe result is valid for the session — skip re-probe on re-runs.
+command -v gemini           &>/dev/null && [ -n "$(echo ping | tb 20 gemini 2>/dev/null)" ] && TEAMS+=("gemini")
 command -v gh               &>/dev/null && gh copilot --version &>/dev/null 2>&1 && TEAMS+=("gh-copilot")
 command -v ollama           &>/dev/null && TEAMS+=("ollama")
 npx @openai/codex --version &>/dev/null 2>&1 && TEAMS+=("codex")
@@ -277,6 +285,7 @@ Default team-persona assignments:
 | **T2 Copilot** | `gh copilot suggest` | devil · expert |
 | **T3 Ollama** | `ollama run {model}` | devil |
 | **T4 Codex** | `npx @openai/codex exec` | devil · edge-case-hunter |
+| **T5 agy** | `agy -p "PROMPT"` (argument form only — stdin pipe prints help, measured 2026-06-13) | devil · beginner · alternatives (gemini successor) |
 
 **Step 1 — Parallel Team Dispatch**:
 
@@ -332,6 +341,46 @@ $ARTIFACT_TAIL" 2>/dev/null) &
 $C_EDGE"
 fi
 
+# ── T5: agy (Antigravity) — gemini successor ──────────────
+# Constraints: argument form only (`agy -p "PROMPT"`); timebox+retry is a hard rule
+# (intermittent hang class, ~50% observed 2026-06-11); -p auto-approves tool execution,
+# so feed only trusted artifacts — never untrusted external content. Serial by design
+# (worst case ~6 min if the hang class fires on every call) — do NOT copy the T1-T4
+# `VAR=$(...) &` pattern: it assigns inside a background subshell.
+if [[ " ${TEAMS[*]} " =~ " agy " ]]; then
+  # tb redefined here — each fenced block must be self-contained when copy-run.
+  # Limitation: alarm kills the exec'd process only; a child holding the stdout
+  # pipe can outlive it (same gap as `timeout` without process-group kill).
+  tb() { perl -e 'alarm shift; exec @ARGV' "$@"; }
+  agy_call() {  # $1=prompt — 60s timebox, 1 retry on empty
+    local out; out=$(tb 60 agy -p "$1" 2>/dev/null)
+    [ -z "$out" ] && out=$(tb 60 agy -p "$1" 2>/dev/null)
+    printf '%s' "$out"
+  }
+  A_DEVIL=$(agy_call "[Devil] Adversarial reviewer, no prior context.
+Find 3 critical structural flaws — especially whether Done When criteria are binary and achievable.
+Format: [issue · location · severity S/A/B]
+---
+$ARTIFACT_TAIL")
+  A_NEW=$(agy_call "[Beginner] First-time user, zero background.
+Find 3 unclear or jargon-heavy points.
+Format: [issue · location · severity]
+---
+$ARTIFACT_TAIL")
+  A_SKEP=$(agy_call "[Alternatives — challenger U1 lens] Pragmatic outsider.
+Find 3 \"why not just X?\" challenges.
+Format: [issue · location · severity]
+---
+$ARTIFACT_TAIL")
+  if [ -n "$A_DEVIL$A_NEW$A_SKEP" ]; then
+    TEAM_RESULTS["agy"]="$A_DEVIL
+$A_NEW
+$A_SKEP"
+  else
+    echo "T5 agy: empty after timebox+retry — dropped (degraded coverage, do not count in synthesis)"
+  fi
+fi
+
 # ── Path B: Cross-session Claude fallback ─────────────────
 if [ ${#TEAMS[@]} -eq 0 ]; then
   TEAM_RESULTS["cross-session-claude"]=$(claude --print \
@@ -356,7 +405,7 @@ Confidence scoring:
   1 team only                       → B-grade (single-team observation)
 
 Claude blind spots (highest value):
-  Issues raised by T1~T4 but absent from Wave 1~4 (T0) results
+  Issues raised by T1~T5 but absent from Wave 1~4 (T0) results
   → flag explicitly as "cross-team delta"
 ```