bigpowers 2.86.2 → 2.86.4

package/scripts/lib/extract-story-verify.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# story: BUG-2026-07-26-story-verify-never-executed
+"""Emit executable story-level verify directives from epic capsules.
+
+Tier-2 half of the verify arc (GH #106). Tier 1 is SKILL.md -> verify:, run by
+run-skill-verify.sh. This walks specs/epics/*/epic.yaml plus any
+*-tasks.yaml siblings and prints one TSV record per story that declares a
+verify command:
+
+    <story_id>\t<source_path>\t<status>\t<verify_command>
+
+Newlines inside a folded/literal YAML block are collapsed to single spaces so
+each record stays on one line for the bash caller.
+"""
+
+import glob
+import os
+import sys
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover - resolved by scripts/lib/python-env.sh
+    sys.exit("extract-story-verify: PyYAML missing — pip install -r requirements.txt")
+
+FIELD_SEPARATOR = "\t"
+UNKNOWN_STATUS = "unknown"
+
+
+def _flatten(command):
+    """Collapse a multi-line YAML scalar into one whitespace-normalized line."""
+    return " ".join(str(command).split())
+
+
+def _story_records(stories, source_path):
+    """Yield (id, source, status, verify) for each story declaring a verify."""
+    for story in stories or []:
+        if not isinstance(story, dict):
+            continue
+        verify = story.get("verify")
+        story_id = story.get("id")
+        if not verify or not story_id:
+            continue
+        status = story.get("status") or UNKNOWN_STATUS
+        yield (str(story_id), source_path, str(status), _flatten(verify))
+
+
+def _load_yaml(path):
+    """Parse a YAML file, reporting the offending path on failure."""
+    with open(path, encoding="utf-8") as handle:
+        try:
+            return yaml.safe_load(handle)
+        except yaml.YAMLError as exc:
+            raise SystemExit(
+                f"extract-story-verify: cannot parse {path}: {exc}\n"
+                "  Expected valid YAML; fix the capsule before running the gate."
+            )
+
+
+def _tasks_records(tasks_path):
+    """Extract verify records from a *-tasks.yaml, which nests under `tasks:`."""
+    doc = _load_yaml(tasks_path)
+    if not isinstance(doc, dict):
+        return []
+    story_id = doc.get("story") or doc.get("id")
+    records = list(_story_records(doc.get("stories"), tasks_path))
+    for task in doc.get("tasks") or []:
+        if not isinstance(task, dict) or not task.get("verify"):
+            continue
+        task_id = task.get("id") or story_id
+        if not task_id:
+            continue
+        status = task.get("status") or doc.get("status") or UNKNOWN_STATUS
+        records.append(
+            (str(task_id), tasks_path, str(status), _flatten(task["verify"]))
+        )
+    return records
+
+
+def collect_records(repo_root):
+    """Gather every story/task verify directive across all epic capsules."""
+    records = []
+    epic_glob = os.path.join(repo_root, "specs", "epics", "*", "epic.yaml")
+    for epic_path in sorted(glob.glob(epic_glob)):
+        doc = _load_yaml(epic_path)
+        if isinstance(doc, dict):
+            records.extend(_story_records(doc.get("stories"), epic_path))
+
+    tasks_glob = os.path.join(repo_root, "specs", "epics", "*", "*-tasks.yaml")
+    for tasks_path in sorted(glob.glob(tasks_glob)):
+        records.extend(_tasks_records(tasks_path))
+    return records
+
+
+def main():
+    repo_root = sys.argv[1] if len(sys.argv) > 1 else "."
+    for record in collect_records(repo_root):
+        rel = os.path.relpath(record[1], repo_root)
+        print(FIELD_SEPARATOR.join([record[0], rel, record[2], record[3]]))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/lib/fail-open-detect.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# story: BUG-2026-07-26-story-verify-never-executed
+# fail-open-detect.sh — shared verify-directive fail-open detector.
+#
+# Extracted from run-skill-verify.sh (#96) so tier-1 (SKILL.md → verify:) and
+# tier-2 (epic.yaml story verify:, #106) share ONE detector. A new evasion
+# idiom must be rejected everywhere at once; two copies would drift.
+#
+# Source this file, then call is_fail_open_directive "<cmd>".
+
+if [[ -n "${FAIL_OPEN_DETECT_LOADED:-}" ]]; then return 0; fi
+FAIL_OPEN_DETECT_LOADED=1
+
+# A directive is fail-open when it cannot exit non-zero on a broken repo.
+# Two families, both checked syntactically because a pipeline's exit status
+# is the status of its LAST command:
+#   1. explicit swallow  — `|| echo ...`, `|| true`, `|| :`, `; true`, `; exit 0`
+#   2. non-asserting tail — pipeline ends in a filter that always exits 0
+#      (head/wc/cat/tee/sort/tr/sed/awk/echo/true/:). `grep x | wc -l` is the
+#      canonical offender: wc always succeeds, so the grep result is discarded.
+# Use an assertion instead, e.g. [ "$(... | wc -l)" -gt 0 ].
+FAIL_OPEN_TAIL_CMDS='head|wc|cat|tee|sort|tr|sed|awk|echo|true|:'
+
+is_fail_open_directive() {
+  local cmd="$1"
+
+  # Family 1: explicit exit-status swallowing.
+  if echo "$cmd" | grep -qE '\|\|[[:space:]]*(echo|true|:)|;[[:space:]]*(true|:|exit[[:space:]]+0)[[:space:]]*$'; then
+    return 0
+  fi
+
+  # Family 2: pipeline whose last stage never fails.
+  # Strip $(...) first — a pipe inside a command substitution feeds an
+  # assertion, e.g. [ "$(ls x | wc -l)" -gt 0 ], and is NOT fail-open.
+  local stripped="$cmd" prev=""
+  while [ "$stripped" != "$prev" ]; do
+    prev="$stripped"
+    stripped=$(printf '%s' "$stripped" | sed 's/\$([^()]*)/SUBST/g')
+  done
+
+  # Only inspect the segment after the final `|` that is not part of `||`.
+  local tail_seg
+  tail_seg=$(printf '%s' "$stripped" | sed 's/||/\
+/g' | tail -1)
+  case "$tail_seg" in
+    *\|*)
+      tail_seg=${tail_seg##*|}
+      tail_seg=$(printf '%s' "$tail_seg" | sed 's/^[[:space:]]*//')
+      echo "$tail_seg" | grep -qE "^($FAIL_OPEN_TAIL_CMDS)([[:space:]]|$)" && return 0
+      ;;
+  esac
+
+  return 1
+}
+
+# A verify string must be a runnable command, not prose. Guards the e60s01 class:
+# `node bin/bigpowers.js setup (interactive in TTY)` is documentation, and a
+# story gate that cannot be executed is as useless as one never executed.
+#
+# Two conditions, both required. The leading-token check alone accepts the
+# example above (it starts with `node`), so shape is also checked with `bash -n`
+# — the parenthetical is a syntax error, which is exactly what marks it as prose.
+is_executable_verify() {
+  local cmd="$1"
+  echo "$cmd" | grep -qE '^[a-zA-Z][a-zA-Z0-9_.-]*\b|^\[' || return 1
+  bash -n -c "$cmd" 2>/dev/null
+}

package/scripts/lib/golden-suite-gates.sh

@@ -14,10 +14,19 @@ GOLDEN_GATES=(
   "g09-yaml-roundtrip:bash scripts/golden-g09-yaml-roundtrip.sh:false"
   "g10-trace-anti-vacuity:bash scripts/golden-g10-trace-anti-vacuity.sh:false"
   "g11-gitignore-venv:bash scripts/golden-g11-gitignore-venv.sh:false"
+  # Planning SoT consistency (BUG-2026-07-26-planning-sot-drift): live epic
+  # shards, execution-status.yaml and release-plan.yaml must agree. Self-test
+  # first so a vacuous gate is caught before its verdict is trusted.
+  "g12-status-selftest:bash scripts/golden-g12-status-consistency.sh --self-test:false"
+  "g12-status-consistency:bash scripts/golden-g12-status-consistency.sh:false"
   "install-helpers:bash scripts/test-install-helpers.sh:false"
   "import-boundaries:bash scripts/check-import-boundaries.sh:false"
   "skill-catalog:bash scripts/validate-skill-catalog.sh:false"
   "specs-parse:bash scripts/validate-specs-yaml.sh:false"
+  # Tier 2 of the verify arc (#106): executes the verify: of every story marked
+  # done. Tier 1 (SKILL.md) is run-skill-verify.sh in golden-suite.yml.
+  "story-verify-selftest:bash scripts/run-story-verify.sh --self-test:false"
+  "story-verify:bash scripts/run-story-verify.sh:false"
 )
 
 GOLDEN_GREEN='\033[0;32m'

package/scripts/lib/plan-consistency-check.sh

@@ -10,6 +10,15 @@ if [[ -z "$CAPSULE" || ! -d "$CAPSULE" ]]; then
   exit 2
 fi
 
+SCRIPT_LIB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_LIB_DIR/../.." && pwd)"
+# shellcheck source=fail-open-detect.sh
+source "$SCRIPT_LIB_DIR/fail-open-detect.sh"
+# shellcheck source=python-env.sh
+source "$SCRIPT_LIB_DIR/python-env.sh"
+resolve_python >/dev/null 2>&1 || true
+PYTHON_BIN="${PYTHON:-python3}"
+
 EPIC_YAML="$CAPSULE/epic.yaml"
 CRITICAL=0
 HIGH=0
@@ -74,8 +83,23 @@ for tasks in "${TASKS[@]+"${TASKS[@]}"}"; do
       && report MED "Story $sid spec contains ambiguous/TBD markers"
   fi
 
-  grep -qE '^[[:space:]]*verify:' "$tasks" \
-    || report CRITICAL "Story $sid tasks.yaml missing runnable verify: commands"
+  # Presence is necessary but not sufficient — the word "runnable" in the old
+  # message was aspirational: nothing checked shape, and nothing executed it.
+  # Execution happens later in scripts/run-story-verify.sh (#106), which gates
+  # only `done` stories. At plan time the code may not exist yet, so assert what
+  # can be asserted now: the directive parses as a command and can fail.
+  if ! grep -qE '^[[:space:]]*verify:' "$tasks"; then
+    report CRITICAL "Story $sid tasks.yaml missing runnable verify: commands"
+  else
+    verify_cmd="$("$PYTHON_BIN" "$SCRIPT_LIB_DIR/extract-story-verify.py" "$REPO_ROOT" 2>/dev/null \
+      | awk -F'\t' -v s="$sid" '$1 == s { print $4; exit }')"
+    if [[ -n "$verify_cmd" ]]; then
+      is_executable_verify "$verify_cmd" \
+        || report CRITICAL "Story $sid verify: is prose, not a runnable command: $verify_cmd"
+      is_fail_open_directive "$verify_cmd" \
+        && report CRITICAL "Story $sid verify: is fail-open (cannot exit non-zero): $verify_cmd"
+    fi
+  fi
   grep -qE '^status:[[:space:]]*(failing|todo|passing)' "$tasks" \
     || report MED "Story $sid tasks.yaml should use status: failing|passing ledger (e45s06)"
 done

package/scripts/lib/test-assertions.sh

@@ -4,7 +4,17 @@
 if [[ -n "${TEST_ASSERTIONS_LOADED:-}" ]]; then return 0; fi
 TEST_ASSERTIONS_LOADED=1
 
-ta_cleanup() { [[ -n "${TA_TMPDIR:-}" && -d "$TA_TMPDIR" ]] && rm -rf "$TA_TMPDIR"; }
+# Registered as `trap ta_cleanup EXIT`. The exit status of an EXIT trap's last
+# command replaces the script's own, so this MUST end with an explicit success:
+# the old `[[ ... ]] && rm -rf ...` one-liner returned 1 whenever TA_TMPDIR was
+# unset, silently forcing every caller to exit 1 while printing "0 failed".
+# That single line broke 22 story verifies across the integration epics (#106).
+ta_cleanup() {
+  if [[ -n "${TA_TMPDIR:-}" && -d "$TA_TMPDIR" ]]; then
+    rm -rf "$TA_TMPDIR"
+  fi
+  return 0
+}
 
 ta_pass() { echo "  PASS $1"; TA_PASS=$((TA_PASS + 1)); }
 

package/scripts/run-skill-verify.sh

@@ -25,47 +25,11 @@ SKILLS_ROOT="$REPO_ROOT"
 PASS=0; FAIL=0; SKIP=0
 TARGET="${1:-}"
 
-# A directive is fail-open when it cannot exit non-zero on a broken repo.
-# Two families, both checked syntactically because a pipeline's exit status
-# is the status of its LAST command:
-#   1. explicit swallow  — `|| echo ...`, `|| true`, `|| :`, `; true`, `; exit 0`
-#   2. non-asserting tail — pipeline ends in a filter that always exits 0
-#      (head/wc/cat/tee/sort/tr/sed/awk/echo/true/:). `grep x | wc -l` is the
-#      canonical offender: wc always succeeds, so the grep result is discarded.
-# Use an assertion instead, e.g. [ "$(... | wc -l)" -gt 0 ].
-FAIL_OPEN_TAIL_CMDS='head|wc|cat|tee|sort|tr|sed|awk|echo|true|:'
-
-is_fail_open_directive() {
-  local cmd="$1"
-
-  # Family 1: explicit exit-status swallowing.
-  if echo "$cmd" | grep -qE '\|\|[[:space:]]*(echo|true|:)|;[[:space:]]*(true|:|exit[[:space:]]+0)[[:space:]]*$'; then
-    return 0
-  fi
-
-  # Family 2: pipeline whose last stage never fails.
-  # Strip $(...) first — a pipe inside a command substitution feeds an
-  # assertion, e.g. [ "$(ls x | wc -l)" -gt 0 ], and is NOT fail-open.
-  local stripped="$cmd" prev=""
-  while [ "$stripped" != "$prev" ]; do
-    prev="$stripped"
-    stripped=$(printf '%s' "$stripped" | sed 's/\$([^()]*)/SUBST/g')
-  done
-
-  # Only inspect the segment after the final `|` that is not part of `||`.
-  local tail_seg
-  tail_seg=$(printf '%s' "$stripped" | sed 's/||/\
-/g' | tail -1)
-  case "$tail_seg" in
-    *\|*)
-      tail_seg=${tail_seg##*|}
-      tail_seg=$(printf '%s' "$tail_seg" | sed 's/^[[:space:]]*//')
-      echo "$tail_seg" | grep -qE "^($FAIL_OPEN_TAIL_CMDS)([[:space:]]|$)" && return 0
-      ;;
-  esac
-
-  return 1
-}
+# is_fail_open_directive / is_executable_verify now live in the shared detector,
+# so tier-1 (here) and tier-2 (run-story-verify.sh, #106) reject the same
+# idioms. A new evasion must be closed in one place, not two.
+# shellcheck source=lib/fail-open-detect.sh
+source "$REPO_ROOT/scripts/lib/fail-open-detect.sh"
 
 normalize_verify_cmd() {
   local raw="$1"
@@ -74,11 +38,6 @@ normalize_verify_cmd() {
   echo "$raw"
 }
 
-is_executable_verify() {
-  local cmd="$1"
-  echo "$cmd" | grep -qE '^[a-zA-Z][a-zA-Z0-9_.-]*\b|^\['
-}
-
 run_verify_cmd() {
   local skill="$1"
   local cmd="$2"

package/scripts/run-story-verify.sh

@@ -0,0 +1,208 @@
+#!/usr/bin/env bash
+# story: BUG-2026-07-26-story-verify-never-executed
+# Execute story-level verify: commands declared in specs/epics/*/epic.yaml.
+# Tier 2 of the verify arc (GH #106). Tier 1 is run-skill-verify.sh.
+#
+# Only stories marked `status: done` are gated: a done story asserts its own
+# acceptance criteria hold. Backlog/in-progress stories are reported as SKIP.
+#
+# Usage:
+#   bash scripts/run-story-verify.sh              # gate all done stories
+#   bash scripts/run-story-verify.sh e80s05       # one story
+#   bash scripts/run-story-verify.sh --self-test  # prove the gate can fail
+
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$REPO_ROOT"
+
+# shellcheck source=lib/fail-open-detect.sh
+source "$REPO_ROOT/scripts/lib/fail-open-detect.sh"
+# shellcheck source=lib/python-env.sh
+source "$REPO_ROOT/scripts/lib/python-env.sh"
+resolve_python || exit 1
+
+VERIFY_TIMEOUT_SECONDS=120
+
+# Portable timeout: macOS lacks GNU timeout; use perl alarm as fallback.
+# stdin is closed for every verify command: gate_all reads its record list on
+# fd 0, and a child that reads stdin (any test-*.sh sourcing a read loop) would
+# otherwise swallow the remaining records and silently shrink the gate.
+if command -v timeout >/dev/null 2>&1; then
+  run_with_timeout() { timeout "$VERIFY_TIMEOUT_SECONDS" bash -c "$1" </dev/null 2>&1; }
+elif command -v perl >/dev/null 2>&1; then
+  run_with_timeout() { perl -e "alarm $VERIFY_TIMEOUT_SECONDS; exec @ARGV" bash -c "$1" </dev/null 2>&1; }
+else
+  run_with_timeout() { bash -c "$1" </dev/null 2>&1; }
+fi
+
+GATED_STATUS="done"
+PASS=0; FAIL=0; SKIP=0
+TARGET="${1:-}"
+
+extract_records() {
+  "$PYTHON" "$REPO_ROOT/scripts/lib/extract-story-verify.py" "$REPO_ROOT"
+}
+
+# Report a story whose directive can never fail. Kept separate from execution so
+# a fail-open directive is a FAIL even when the command happens to exit 0.
+reject_fail_open() {
+  local sid="$1" src="$2" cmd="$3"
+  echo "FAIL: $sid [$src] — fail-open directive (cannot exit non-zero): $cmd"
+  FAIL=$((FAIL + 1))
+}
+
+reject_non_executable() {
+  local sid="$1" src="$2" cmd="$3"
+  echo "FAIL: $sid [$src] — verify is prose, not a runnable command: $cmd"
+  FAIL=$((FAIL + 1))
+}
+
+run_story_verify() {
+  local sid="$1" src="$2" cmd="$3"
+
+  if ! is_executable_verify "$cmd"; then
+    reject_non_executable "$sid" "$src" "$cmd"
+    return 1
+  fi
+  if is_fail_open_directive "$cmd"; then
+    reject_fail_open "$sid" "$src" "$cmd"
+    return 1
+  fi
+
+  local output
+  if output=$(run_with_timeout "$cmd"); then
+    echo "PASS: $sid"
+    PASS=$((PASS + 1))
+    return 0
+  fi
+  echo "FAIL: $sid [$src] — $cmd"
+  echo "      output: $(echo "$output" | tail -3 | tr '\n' ' ')"
+  FAIL=$((FAIL + 1))
+  return 1
+}
+
+gate_all() {
+  local sid src status cmd
+  while IFS=$'\t' read -r sid src status cmd; do
+    [ -z "${sid:-}" ] && continue
+    if [ -n "$TARGET" ] && [ "$sid" != "$TARGET" ]; then
+      continue
+    fi
+    if [ -z "$TARGET" ] && [ "$status" != "$GATED_STATUS" ]; then
+      echo "SKIP: $sid (status: $status)"
+      SKIP=$((SKIP + 1))
+      continue
+    fi
+    run_story_verify "$sid" "$src" "$cmd" || true
+  done < <(extract_records)
+}
+
+# Anti-vacuity proof: seed a capsule whose done story must fail, and one that
+# must pass, then require the runner to agree. A gate that cannot fail is the
+# defect this script exists to close (#96/#106) — so it must prove otherwise.
+run_self_test() {
+  echo "=== run-story-verify self-test ==="
+  local tmp_root
+  tmp_root=$(mktemp -d)
+  trap 'rm -rf "$tmp_root"' EXIT
+
+  mkdir -p "$tmp_root/specs/epics/e99-selftest"
+  cat > "$tmp_root/specs/epics/e99-selftest/epic.yaml" <<'YAML'
+id: e99
+title: self-test capsule
+stories:
+  - id: e99s01
+    title: passing story
+    status: done
+    verify: test -d specs
+  - id: e99s02
+    title: failing story
+    status: done
+    verify: test -f /nonexistent/path/for/story-verify-self-test
+  - id: e99s03
+    title: fail-open story
+    status: done
+    verify: test -f /nonexistent || true
+  - id: e99s04
+    title: prose story
+    status: done
+    verify: node bin/bigpowers.js setup (interactive in TTY)
+  - id: e99s05
+    title: backlog story is not gated
+    status: backlog
+    verify: test -f /nonexistent/should/not/run
+YAML
+
+  local records
+  records=$("$PYTHON" "$REPO_ROOT/scripts/lib/extract-story-verify.py" "$tmp_root")
+
+  local checked=0 problems=0
+  local sid src status cmd
+  while IFS=$'\t' read -r sid src status cmd; do
+    [ -z "${sid:-}" ] && continue
+    checked=$((checked + 1))
+    case "$sid" in
+      e99s01)
+        if is_fail_open_directive "$cmd" || ! is_executable_verify "$cmd"; then
+          echo "FAIL: self-test — genuine assertion rejected: $cmd"; problems=$((problems + 1))
+        elif ! run_with_timeout "$cmd" >/dev/null; then
+          echo "FAIL: self-test — passing fixture did not pass"; problems=$((problems + 1))
+        fi
+        ;;
+      e99s02)
+        if run_with_timeout "$cmd" >/dev/null; then
+          echo "FAIL: self-test — failing fixture exited 0 (gate cannot fail)"; problems=$((problems + 1))
+        fi
+        ;;
+      e99s03)
+        if ! is_fail_open_directive "$cmd"; then
+          echo "FAIL: self-test — fail-open directive not detected: $cmd"; problems=$((problems + 1))
+        fi
+        ;;
+      e99s04)
+        if is_executable_verify "$cmd"; then
+          echo "FAIL: self-test — prose accepted as a command: $cmd"; problems=$((problems + 1))
+        fi
+        ;;
+      e99s05)
+        if [ "$status" = "$GATED_STATUS" ]; then
+          echo "FAIL: self-test — backlog story reported as done"; problems=$((problems + 1))
+        fi
+        ;;
+    esac
+  done <<EOF
+$records
+EOF
+
+  rm -rf "$tmp_root"
+  trap - EXIT
+
+  if [ "$checked" -lt 5 ]; then
+    echo "FAIL: self-test — extractor found $checked/5 fixture stories"
+    return 1
+  fi
+  if [ "$problems" -gt 0 ]; then
+    echo "FAIL: self-test — $problems assertion(s) failed"
+    return 1
+  fi
+  echo "PASS: self-test — gate fails on broken stories, passes on sound ones"
+  return 0
+}
+
+if [ "$TARGET" = "--self-test" ]; then
+  run_self_test
+  exit $?
+fi
+
+gate_all
+
+echo ""
+echo "Results: $PASS PASS, $FAIL FAIL, $SKIP SKIP"
+
+if [ -n "$TARGET" ] && [ "$((PASS + FAIL))" -eq 0 ]; then
+  echo "ERROR: no story matching '$TARGET' declares a verify: command" >&2
+  exit 2
+fi
+
+[ "$FAIL" -eq 0 ]

package/scripts/sync-status-from-epics.sh

@@ -1,5 +1,13 @@
 #!/usr/bin/env bash
 # sync-status-from-epics.sh — seed execution-status.yaml keys from epic shards
+#
+# SEEDER, NOT A RECONCILER. `keys` is preloaded from execution-status.yaml
+# itself and applied with setdefault(), so an already-present key keeps its
+# existing value; epic.yaml's stories[].status is never read. Running this does
+# NOT pull a capsule's status into the SoT — it only adds missing keys and
+# refreshes task counters. Drift between a capsule and the SoT is detected by
+# scripts/golden-g12-status-consistency.sh (G-12), not corrected here.
+# See specs/bugs/BUG-2026-07-26-planning-sot-drift.md.
 set -euo pipefail
 source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
 source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"

package/scripts/test-adapters.sh

@@ -21,7 +21,6 @@ bash "$SCRIPT_DIR/validate-targets-yaml.sh" >/dev/null
 
 PASS=0
 FAIL=0
-TMPDIR=""
 TA_PASS=0
 TA_FAIL=0
 TA_TMPDIR=""
@@ -56,15 +55,22 @@ test_adapter() {
   if [[ "$has_context" == "true" && "$mode" != "native" ]]; then
     declare -f wire_context >/dev/null 2>&1 && ta_pass "$id: wire_context defined" || ta_fail "$id: wire_context missing"
 
-    TMPDIR=$(mktemp -d)
-    cp "$SCRIPT_DIR/../docs/templates/AGENTS.md" "$TMPDIR/AGENTS.md" 2>/dev/null || echo "# test" > "$TMPDIR/AGENTS.md"
-    (
-      cd "$TMPDIR"
+    TA_TMPDIR=$(mktemp -d)
+    cp "$SCRIPT_DIR/../docs/templates/AGENTS.md" "$TA_TMPDIR/AGENTS.md" 2>/dev/null || echo "# test" > "$TA_TMPDIR/AGENTS.md"
+    # The idempotency probe runs in a subshell (it cd's away), so its ta_pass/
+    # ta_fail would increment counters in a child and be lost — the script used
+    # to print 5 PASS lines and report 4. Capture the status, tally in-process.
+    if (
+      cd "$TA_TMPDIR"
       # shellcheck source=/dev/null
       source "$adapter_file"
-      wire_context 2>/dev/null || true
-      wire_context 2>/dev/null && ta_pass "$id: idempotent wire_context" || ta_fail "$id: wire_context failed"
-    )
+      wire_context >/dev/null 2>&1 || true
+      wire_context >/dev/null 2>&1
+    ); then
+      ta_pass "$id: idempotent wire_context"
+    else
+      ta_fail "$id: wire_context failed"
+    fi
   fi
 }
 

package/scripts/verify-install.sh

@@ -168,7 +168,19 @@ grep -q "'antigravity'" "$REPO_ROOT/bin/setup.js" && grep -q 'SUPPORTED_IDS' "$R
 grep -q "'agy'" "$REPO_ROOT/bin/setup.js" && ta_pass "setup.js: agy supported" || ta_fail "setup.js: agy not in SUPPORTED_IDS"
 grep -q "case 'antigravity'" "$REPO_ROOT/scripts/lib/install-helpers.js" && ta_pass "install-helpers: antigravity case" || ta_fail "install-helpers: missing antigravity case"
 grep -q "case 'agy'" "$REPO_ROOT/scripts/lib/install-helpers.js" && ta_pass "install-helpers: agy case" || ta_fail "install-helpers: missing agy case"
-! install_grep -q '\.gemini/extensions/bigpowers' <<< "$(sed -n '/install_agy/,/^}/p')" && ta_pass "source: agy avoids gemini extension path" || ta_fail "source: agy touches gemini extension path"
+# Scope this to install_agy's OWN body. The previous form piped a herestring into
+# install_grep(), which is `grep "$@" $(install_grep_paths)` — it always greps the
+# install files and ignores stdin, so the assertion actually searched every target.
+# install_gemini/install_claude legitimately use .gemini/extensions/bigpowers
+# (install-targets-a.sh:21,22,70), so the check could never pass. (#106)
+AGY_BODY="$(sed -n '/^install_agy()/,/^}/p' $(install_grep_paths) 2>/dev/null)"
+if [[ -z "$AGY_BODY" ]]; then
+  ta_fail "source: install_agy() body not found — assertion would pass vacuously"
+elif printf '%s' "$AGY_BODY" | grep -q '\.gemini/extensions/bigpowers'; then
+  ta_fail "source: agy touches gemini extension path"
+else
+  ta_pass "source: agy avoids gemini extension path"
+fi
 
 install_grep -q 'install_codex()' && ta_pass "source: install_codex()" || ta_fail "source: missing install_codex()"
 install_grep -q 'uninstall_codex()' && ta_pass "source: uninstall_codex()" || ta_fail "source: missing uninstall_codex()"