bigpowers 2.91.0 → 2.92.0

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

@@ -76,6 +76,8 @@ GOLDEN_GATES=(
   "import-boundaries:bash scripts/check-import-boundaries.sh:false"
   "security-dashboard-render:node tests/security/dashboard-render.cjs:false"
   "skill-catalog:bash scripts/validate-skill-catalog.sh:false"
+  # Guard-git judges git argv, not substrings; shell and TS must agree (#184).
+  "guard-git-normalize:bash scripts/test-guard-git-normalize.sh:false"
   "specs-parse:bash scripts/validate-specs-yaml.sh:false"
   # The runner itself: failing output is shown, skips are named and reasoned.
   "golden-gate-runner:bash scripts/test-golden-gate-runner.sh:false"

package/scripts/omp-guard-probe.ts

@@ -0,0 +1,46 @@
+// story: BUG-2026-11-03-guard-git-flag-normalize
+// story: BUG-2026-11-03-guard-normalize-branch-context
+// omp-guard-probe.ts — evaluate shell commands through the extension's guard,
+// so the TypeScript rules can be held to the same fixture table as
+// hooks/pre-tool-use.sh (scripts/test-guard-git-normalize.sh).
+//
+// Usage: echo '[{"command":"git status","branch":"main"}, …]' | node scripts/omp-guard-probe.ts
+// Prints a JSON array of "block" | "allow", one per input row.
+//
+// It calls evaluateBashCall(), the same pure function the tool_call handler
+// calls — destructive argv rules AND the protected-branch/commit rules. Probing
+// only dangerousGitCommand() compared one rule against a whole hook, which is
+// how "git push --force-with-lease origin main" passed here and failed there.
+//
+// The branch context is supplied per row instead of fixed: protected-branch
+// rules answer differently on `main` than on a feature branch, so a hardcoded
+// branch made the table agree in one direction only and the gate went red the
+// moment it ran on `main`. The harness gives the shell hook the same per-row
+// branch (a throwaway repo checked out on it) and strips GIT_BIGPOWERS_LAND, so
+// neither verdict can depend on the machine or the checked-out branch.
+
+import { readFileSync } from "node:fs";
+import { evaluateBashCall } from "../extensions/omp-hooks.ts";
+
+const source = readFileSync(new URL("../extensions/omp-hooks.ts", import.meta.url), "utf8");
+const handlerStart = source.indexOf('pi.on("tool_call"');
+if (handlerStart < 0) throw new Error("tool_call handler not found in extensions/omp-hooks.ts");
+if (!source.slice(handlerStart).includes("evaluateBashCall(")) {
+  throw new Error("tool_call handler does not call evaluateBashCall() — the guard is not wired");
+}
+
+const DEFAULT_BRANCH = "fix/guard-git-normalize";
+type Row = { command: string; branch?: string };
+
+const input = JSON.parse(readFileSync(0, "utf8")) as Array<Row | string>;
+const rows: Row[] = input.map((row) => (typeof row === "string" ? { command: row } : row));
+const verdicts = rows.map((row) =>
+  evaluateBashCall(row.command, {
+    landMode: false,
+    hasRepo: true,
+    branchFor: () => row.branch ?? DEFAULT_BRANCH,
+  })
+    ? "block"
+    : "allow",
+);
+process.stdout.write(`${JSON.stringify(verdicts)}\n`);

package/scripts/test-adapter-render.sh

@@ -60,7 +60,7 @@ for adapter in scripts/adapters/*.sh; do
         IR_DESC_ESCAPED="test desc"; IR_MODEL=""
         declare -f render_skill >/dev/null || exit 1
         render_skill
-      ' _ "$PWD/$adapter" "$nm" >/dev/null 2>&1 )
+      ' _ "$PWD/$adapter" "$nm" </dev/null >/dev/null 2>&1 )
   }
 
   dest="$TMP_ROOT/$id"

package/scripts/test-guard-git-normalize.sh

@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+# story: BUG-2026-11-03-guard-git-flag-normalize
+# test-guard-git-normalize.sh — the guard must judge git ARGV, not substrings (#184).
+#
+# Literal patterns miss `git -C repo <destructive>` and `reset -q --hard`: the
+# destructive tokens survive, only their position changes. One fixture table
+# pins four things:
+#
+#   (a) the shell hook (hooks/pre-tool-use.sh) reaches the expected verdict
+#   (b) the TS extension reaches the same verdict — through evaluateBashCall(),
+#       the function the tool_call handler calls, so protected-branch and commit
+#       rules are compared too, not only the destructive-argv table
+#   (c) the two agree with each other on every row — that is what "consistent
+#       across Claude Code, Cursor and Gemini CLI modes" means
+#   (d) the rules that share the hook (commits, protected branch, JSON
+#       envelopes, the pi/OMP fallback) still behave
+#
+# Both sides run with GIT_BIGPOWERS_LAND stripped: land mode disables the
+# protected-branch block, so an inherited value would let a developer's shell
+# turn a red gate green (BUG-2026-11-03-guard-normalize-parity-vacuous).
+#
+# Both sides also run in a throwaway repo checked out on the row's `branch:`
+# (default: a feature branch). Protected-branch rules answer differently on
+# `main`, so pinning only the probe to a feature branch made the table agree in
+# one direction and go red as soon as CI ran it on `main`
+# (BUG-2026-11-03-guard-normalize-branch-context).
+#
+# The row loop runs inside one Python process: every row x (hook + probe) with a
+# Python start per row cost ~70s on a pyenv host, which is too much for a gate.
+#
+# Usage: bash scripts/test-guard-git-normalize.sh
+
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"
+resolve_repo_root
+cd "$REPO_ROOT"
+source scripts/lib/python-env.sh
+source scripts/lib/test-assertions.sh
+resolve_python
+TA_PASS=0
+TA_FAIL=0
+FIXTURE="specs/verifications/fixtures/guard-git-normalize.yaml"
+
+echo "=== test-guard-git-normalize.sh ==="
+
+if [[ ! -f "$FIXTURE" ]]; then
+  ta_fail "fixture missing: $FIXTURE"
+  echo "$TA_PASS passed, $TA_FAIL failed"
+  exit 1
+fi
+
+REPORT=$($PYTHON - "$FIXTURE" <<'PY'
+import json, os, subprocess, sys, tempfile, yaml
+
+fixture = sys.argv[1]
+# Ambient LAND mode disables the protected-branch block. A gate that depends on
+# the developer's shell is not a gate (this masked a CI failure once).
+ENV = {k: v for k, v in os.environ.items() if k != "GIT_BIGPOWERS_LAND"}
+DEFAULT_BRANCH = "fix/guard-git-normalize"
+cases = yaml.safe_load(open(fixture, encoding="utf-8"))["cases"]
+rows = [{"command": c["command"], "branch": c.get("branch", DEFAULT_BRANCH)} for c in cases]
+
+# (b) one node start for every row.
+probe = subprocess.run(
+    ["node", "scripts/omp-guard-probe.ts"],
+    input=json.dumps(rows), capture_output=True, text=True,
+)
+if probe.returncode != 0:
+    print(f"PROBE_ERROR {probe.stderr.strip().splitlines()[-1][:300] if probe.stderr.strip() else 'no stderr'}")
+    sys.exit(0)
+ts = json.loads(probe.stdout.strip().splitlines()[-1])
+
+
+def make_repo(root, branch):
+    """A throwaway repo on `branch`, so the hook resolves that branch as HEAD."""
+    path = os.path.join(root, f"repo-{len(os.listdir(root))}")
+    def git(*args):
+        subprocess.run(["git", "-C", path, *args], check=True, capture_output=True)
+    subprocess.run(["git", "init", "-q", "-b", "main", path], check=True, capture_output=True)
+    git("config", "user.email", "fixture@example.com")
+    git("config", "user.name", "fixture")
+    git("commit", "-q", "--allow-empty", "-m", "init")
+    if branch != "main":
+        git("checkout", "-q", "-b", branch)
+    return path
+
+
+hook = os.path.abspath("hooks/pre-tool-use.sh")
+shell_fails = ts_fails = disagree = 0
+with tempfile.TemporaryDirectory() as tmp:
+    repos = {}
+    for case, row, ts_verdict in zip(cases, rows, ts):
+        branch = row["branch"]
+        if branch not in repos:
+            repos[branch] = make_repo(tmp, branch)
+        payload = json.dumps({"command": row["command"]})
+        run = subprocess.run(
+            ["bash", hook], input=payload, capture_output=True, text=True,
+            env=ENV, cwd=repos[branch],
+        )
+        shell_verdict = "block" if run.returncode == 2 else "allow"
+        expected = case["verdict"]
+        if shell_verdict != expected:
+            shell_fails += 1
+            print(f"SHELL_FAIL expected={expected} got={shell_verdict} :: {row['command']}")
+        if ts_verdict != expected:
+            ts_fails += 1
+            print(f"TS_FAIL expected={expected} got={ts_verdict} :: {row['command']}")
+        if shell_verdict != ts_verdict:
+            disagree += 1
+            print(f"PARITY_FAIL shell={shell_verdict} ts={ts_verdict} :: {row['command']}")
+
+print(f"RESULT rows={len(cases)} shell_fails={shell_fails} ts_fails={ts_fails} disagree={disagree}")
+PY
+)
+
+if [[ "$REPORT" == PROBE_ERROR* ]]; then
+  ta_fail "TS probe failed: ${REPORT#PROBE_ERROR }"
+else
+  # sed, not grep: grep exits 1 when there is nothing to show, and pipefail
+  # would turn a perfectly green run into a failure.
+  printf '%s\n' "$REPORT" | sed -n 's/^\(SHELL_FAIL\|TS_FAIL\|PARITY_FAIL\)/  \1/p'
+  read -r _ ROWS SHELL_FAILS TS_FAILS DISAGREE <<< "$(grep '^RESULT' <<< "$REPORT")"
+  ROWS=${ROWS#rows=}; SHELL_FAILS=${SHELL_FAILS#shell_fails=}
+  TS_FAILS=${TS_FAILS#ts_fails=}; DISAGREE=${DISAGREE#disagree=}
+
+  [ "${SHELL_FAILS:-1}" -eq 0 ] \
+    && ta_pass "(a) shell hook matches all $ROWS fixture rows" \
+    || ta_fail "(a) shell hook missed $SHELL_FAILS of $ROWS rows (see above)"
+  [ "${TS_FAILS:-1}" -eq 0 ] \
+    && ta_pass "(b) TS extension matches all $ROWS fixture rows" \
+    || ta_fail "(b) TS extension missed $TS_FAILS of $ROWS rows (see above)"
+  [ "${DISAGREE:-1}" -eq 0 ] \
+    && ta_pass "(c) shell and TS agree on all $ROWS rows" \
+    || ta_fail "(c) shell and TS disagree on $DISAGREE of $ROWS rows (see above)"
+fi
+
+# ── (d) the rules that share this hook must keep working ────────────────────
+# The normalizer replaced the pattern loop in the same handler; a regression in
+# the neighbouring checks (protected branches, Conventional Commits, the gemini
+# JSON envelope, the pi/OMP fallback) would be invisible to the rows above.
+#
+# These run in a throwaway repo on a feature branch, like the rows: "a commit is
+# allowed" is only true off `main`, and the gate itself runs on `main` after a
+# merge. Duplicating the repo setup here keeps each block self-contained.
+json_cmd() { $PYTHON -c 'import json,sys;print(json.dumps({"command": sys.argv[1]}))' "$1"; }
+FEATURE_REPO="$($PYTHON - "$(mktemp -d)" <<'PY'
+import subprocess, sys
+path = sys.argv[1]
+def git(*args):
+    subprocess.run(["git", "-C", path, *args], check=True, capture_output=True)
+subprocess.run(["git", "init", "-q", "-b", "main", path], check=True, capture_output=True)
+git("config", "user.email", "fixture@example.com")
+git("config", "user.name", "fixture")
+git("commit", "-q", "--allow-empty", "-m", "init")
+git("checkout", "-q", "-b", "fix/guard-git-normalize")
+print(path)
+PY
+)"
+adjacent() { # name want_rc command [hook]
+  local name="$1" want="$2" command="$3" hook="${4:-}" rc
+  hook="${hook:-$REPO_ROOT/hooks/pre-tool-use.sh}"
+  cd "$FEATURE_REPO" || ta_fail "(d) $name: cannot enter fixture repo"
+  json_cmd "$command" | env -u GIT_BIGPOWERS_LAND bash "$hook" >/dev/null 2>&1 && rc=0 || rc=$?
+  cd "$REPO_ROOT" || true
+  [ "$rc" -eq "$want" ] || ta_fail "(d) $name: rc=$rc (want $want) — $command"
+}
+adjacent "plain status allowed" 0 "git status"
+adjacent "conventional commit allowed" 0 'git commit -m "fix(scope): subject"'
+adjacent "feature push allowed" 0 "git push origin feature/x"
+adjacent "non-conventional commit blocked" 2 'git commit -m "bad message"'
+rm -rf "$FEATURE_REPO"
+
+DESTRUCTIVE="git reset --hard"
+GEMINI_OUT=$(json_cmd "$DESTRUCTIVE" | env -u GIT_BIGPOWERS_LAND GIT_GUARDRAILS_MODE=gemini bash hooks/pre-tool-use.sh 2>&1)
+echo "$GEMINI_OUT" | grep -q '"decision": *"deny"' \
+  || ta_fail "(d) gemini mode must emit deny JSON, got: $(echo "$GEMINI_OUT" | head -c 120)"
+
+PI_OUT=$(json_cmd "$DESTRUCTIVE" | env -u GIT_BIGPOWERS_LAND bash hooks/pre/bash.sh 2>&1)
+echo "$PI_OUT" | grep -q '"decision":"block"' \
+  || ta_fail "(d) pi/OMP fallback must emit block JSON, got: $(echo "$PI_OUT" | head -c 120)"
+
+bash -n hooks/pre/bash.sh || ta_fail "(d) hooks/pre/bash.sh must parse"
+grep -q "classify_git_argv" hooks/pre/bash.sh \
+  || ta_fail "(d) pi/OMP fallback must use the normalized classifier"
+ta_pass "(d) adjacent rules: commits, pushes, gemini JSON, pi fallback"
+
+echo "$TA_PASS passed, $TA_FAIL failed"
+[[ "$TA_FAIL" -eq 0 ]]

package/scripts/test-test-lock-hook.sh

@@ -10,7 +10,7 @@ HOOK="$REPO_ROOT/hooks/pre-tool-use.sh"
 pass_count=0
 fail_count=0
 
-assert_denied() {
+lock_assert_denied() {
   local label="$1"
   local input="$2"
   local expected_substr="${3:-}"
@@ -30,7 +30,7 @@ assert_denied() {
   fi
 }
 
-assert_allowed() {
+lock_assert_allowed() {
   local label="$1"
   local input="$2"
   local output exit_code=0
@@ -64,7 +64,7 @@ git add .
 git commit -q -m "feat(app): initial commit"
 
 # 1. Without a RED commit yet during fix_bug, test edits should be allowed (to author the RED test)
-assert_allowed "Test file edit allowed when authoring RED test" \
+lock_assert_allowed "Test file edit allowed when authoring RED test" \
   '{"tool": "Edit", "file_path": "test/app.test.js"}'
 
 # 2. Commit a RED test
@@ -73,23 +73,23 @@ git add test/app.test.js
 git commit -q -m "test(app): red test reproducing defect"
 
 # 3. Now that a RED commit exists and active_flow is fix_bug, test edits must be LOCKED
-assert_denied "Test file edit denied after RED commit in fix_bug" \
+lock_assert_denied "Test file edit denied after RED commit in fix_bug" \
   '{"tool": "Edit", "file_path": "test/app.test.js"}' \
   "locked"
 
-assert_denied "Test file write denied after RED commit in fix_bug" \
+lock_assert_denied "Test file write denied after RED commit in fix_bug" \
   '{"tool": "Write", "file_path": "tests/test_other.py"}' \
   "locked"
 
 # 4. Source file edits must remain allowed
-assert_allowed "Source file edit allowed after RED commit in fix_bug" \
+lock_assert_allowed "Source file edit allowed after RED commit in fix_bug" \
   '{"tool": "Edit", "file_path": "src/app.js"}'
 
 # 5. When active_flow is not fix_bug, test edits are allowed
 cat > specs/state.yaml <<'YAML'
 active_flow: build_epic
 YAML
-assert_allowed "Test file edit allowed when active_flow is not fix_bug" \
+lock_assert_allowed "Test file edit allowed when active_flow is not fix_bug" \
   '{"tool": "Edit", "file_path": "test/app.test.js"}'
 
 echo ""

package/scripts/verify-adversarial.sh

@@ -109,9 +109,16 @@ fi
 DEFECTS_FOUND=0
 mkdir -p specs/verifications
 
+# A JS/TS source file that exists and is not a test: the files the boundary scan inspects.
+is_scannable_source() {
+  local file="$1"
+  [[ "$file" =~ \.(js|ts|mjs)$ && -f "$file" ]] || return 1
+  [[ ! "$file" =~ (^|/)test/ && ! "$file" =~ \.test\. ]]
+}
+
 # 2. Check for common unsafe property access patterns on JS/TS files
 for file in $CHANGED_FILES; do
-  if [[ "$file" =~ \.(js|ts|mjs)$ ]] && [[ -f "$file" ]] && [[ ! "$file" =~ (^|/)test/ ]] && [[ ! "$file" =~ \.test\. ]]; then
+  if is_scannable_source "$file"; then
     # Look for unsafe chained property access like item.brand.toLowerCase() or item.prop.subprop
     if grep -nE '\.[a-zA-Z0-9_]+\.(toLowerCase|toUpperCase|trim|length|slice)\(' "$file" | grep -v '\?\.' >/dev/null 2>&1; then
       echo "WARNING [boundary-mutation]: Potential unhandled undefined access without optional chaining in $file:"

package/skills/guard-git/SKILL.md

@@ -13,7 +13,8 @@ Installs a shared hook that blocks destructive git operations and enforces workf
 
 ## What gets blocked/enforced
 
-- **Safety**: `git push --force`, `git reset --hard`, `git clean -f`, `git branch -D`, `git checkout .`, `git restore .`.
+- **Safety**: force push (`-f`, `--force`, `+refspec`), `reset` with `--hard`, `clean` with any `-f*`, `branch -D` / `--delete --force`, `checkout`/`restore` that discard work (`-f`, `.` pathspec).
+- **Argv, not substrings**: the hook tokenizes each command, strips git's global options (`-C <path>`, `-c k=v`, `--no-pager`, `--git-dir=…`) and judges the `(subcommand, arguments)` pair — so `git -C repo reset -q --hard` is blocked, while `git push --force-with-lease` is allowed. Rules live in `scripts/lib/git-argv.py`, mirrored in `extensions/omp-hooks.ts`; `scripts/test-guard-git-normalize.sh` fails if the two disagree.
 - **Discipline**: Blocks direct commits or pushes to protected branches (`main`, `master`) unless `GIT_BIGPOWERS_LAND=1` (set only by `scripts/land-branch.sh`).
 - **Allows**: `git push origin <feature-branch>` for backup/CI; solo land push to `main` only inside `land-branch.sh`.
 - **Standardization**: Enforces [Conventional Commits](https://www.conventionalcommits.org/) for all `git commit` commands.
@@ -38,7 +39,11 @@ Installs a shared hook that blocks destructive git operations and enforces workf
 
 ## Customization
 
-To add or remove patterns or protected branches, edit `pre-tool-use.sh`.
+The rule table lives in `scripts/lib/git-argv.py` (shell hooks) and is mirrored in `extensions/omp-hooks.ts`. Add a rule to both and a row to `specs/verifications/fixtures/guard-git-normalize.yaml`.
+
+The TS side is judged through `evaluateBashCall()` — the single pure function the `tool_call` handler calls — so the fixture covers **every** rule (destructive argv, protected-branch push, Conventional Commits), not just the argv table. The gate (`bash scripts/test-guard-git-normalize.sh`) runs both implementations with `GIT_BIGPOWERS_LAND` unset and fails if they disagree, so a verdict can never depend on the developer's shell.
+
+Protected-branch rules answer differently on `main` than on a feature branch, so a row that touches commit/push semantics states its `branch:` and both sides are run in it (the shell hook in a throwaway repo checked out on that branch). A row without `branch:` is judged on a feature branch. Do not pin the branch inside either implementation — that is what made the gate pass on PRs and fail on `main`.
 
 ## Advanced
 

package/skills-lock.json

@@ -158,7 +158,7 @@
     },
     "guard-git": {
       "description": "Block dangerous git commands (push, force push, reset --hard, clean, branch -D, checkout/restore .) and enforce Conventional Commits & Branch Protection before an AI agent runs them. Installs hook scripts for Claude Code, Cursor, Cursor CLI, and Gemini CLI; documents Google Antigravity Terminal deny lists. Use when the user wants git safety hooks, to block git push or destructive git in agents, or to mirror the same policy across AI coding tools.",
-      "sha256": "e7083cba6d95a15f",
+      "sha256": "08b4b14a1134032e",
       "path": "skills/guard-git/SKILL.md"
     },
     "harden-vps": {

package/tests/test_ab_eval.py

@@ -9,7 +9,6 @@ import importlib.util
 import io
 import json
 import shutil
-import subprocess
 import sys
 import tempfile
 import unittest
@@ -249,49 +248,6 @@ class TestCli(Sandbox):
         self.assertIsNone(report["delta"])
 
 
-@unittest.skipUnless(shutil.which("node"), "node is needed for the starter tasks")
-class TestStarterTasks(unittest.TestCase):
-    """Each shipped task must fail as given and pass with its reference solution."""
-
-    TASKS = REPO_ROOT / "specs" / "benchmarks" / "ab" / "tasks"
-
-    def grade_copy(self, task_dir: Path, with_solution: bool) -> bool:
-        task = yaml.safe_load((task_dir / "task.yaml").read_text())
-        work = Path(tempfile.mkdtemp(prefix="ab-starter-"))
-        try:
-            shutil.copytree(task_dir / "fixture", work, dirs_exist_ok=True)
-            if with_solution:
-                shutil.copytree(task_dir / "solution", work, dirs_exist_ok=True)
-            shutil.copytree(task_dir / "hidden", work, dirs_exist_ok=True)
-            res = subprocess.run(["bash", "-c", task["grade"]], cwd=work, capture_output=True)
-            return res.returncode == 0
-        finally:
-            shutil.rmtree(work, ignore_errors=True)
-
-    def test_eight_tasks_ship(self):
-        self.assertGreaterEqual(len(list(self.TASKS.glob("*/task.yaml"))), 8)
-
-    def test_fixture_fails_and_solution_passes(self):
-        for task_yaml in sorted(self.TASKS.glob("*/task.yaml")):
-            with self.subTest(task=task_yaml.parent.name):
-                self.assertFalse(self.grade_copy(task_yaml.parent, with_solution=False))
-                self.assertTrue(self.grade_copy(task_yaml.parent, with_solution=True))
-
-    def test_prompts_never_name_bigpowers(self):
-        for task_yaml in self.TASKS.glob("*/task.yaml"):
-            self.assertNotIn("bigpowers", yaml.safe_load(task_yaml.read_text())["prompt"].lower())
-
-    def test_grade_commands_never_pass_a_bare_directory(self):
-        """`node --test test/` exits 1 on node 24 (it resolves the directory as a module path), so
-        such a task can never pass however good the solution is, while a hidden-only `score`
-        command still looks healthy (BUG found in e58s07: ab-11 and ab-13 read pass=0 forever)."""
-        for task_yaml in self.TASKS.glob("*/task.yaml"):
-            with self.subTest(task=task_yaml.parent.name):
-                for token in yaml.safe_load(task_yaml.read_text())["grade"].split():
-                    self.assertNotIn(token.rstrip("/"), ("test", "test-hidden"),
-                                     f"{task_yaml.parent.name} grades a directory, not a glob")
-
-
 class TestRunBenchmarkHonesty(unittest.TestCase):
     def test_without_skill_arm_is_unmeasured_not_zero(self):
         sc = {"id": "s1", "grader": {"type": "code", "command": "true"}}

package/tests/test_ab_lean.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# story: e58s10
+"""tests/test_ab_lean.py — lean views: per-arm VSM and waste summary, deltas, bars, redundant tests.
+
+Run: python3 tests/test_ab_lean.py
+"""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_ab_eval import load_module, rep  # noqa: E402
+from test_ab_waste import Stream, waste  # noqa: E402
+
+lean = load_module("ab_lean", "ab_lean.py")
+
+
+def run(arm, lead, build, test, passed=True, cost=0.01, test_runs=3, rework=0):
+    stages = {"plan": {"s": lead * 0.1}, "design": {"s": lead * 0.2}, "build": {"s": build}, "test": {"s": test}}
+    vsm = {"lead_time_s": lead, "time_to_first_build_s": lead * 0.3, "switches": 4, "stages": stages}
+    w = {"test_runs": test_runs, "redundant_test_runs": 1, "rework_loops": rework, "reedits": 0,
+         "rereads": 0, "repeated_commands": 0, "review_load": 50, "diff_ratio": 1.2, "ftt": rework == 0,
+         "pce": round((build + test) / lead, 3), "leftovers": [], "extra_files": []}
+    return {"task": "t", "arm": arm, "pass": passed, "score": None, "tampered": False, "agent_error": False,
+            "cost_usd": cost, "input_tokens": None, "output_tokens": None, "turns": 5, "duration_s": lead,
+            "diff_lines": 5, "vsm": vsm, "waste": w}
+
+
+def records():
+    return ([run("vanilla", 70, 28, 21) for _ in range(5)]
+            + [run("bigpowers", 140, 20, 70, cost=0.02, test_runs=8, rework=1) for _ in range(5)])
+
+
+class TestLeanSummary(unittest.TestCase):
+    def test_per_arm_summary_and_deltas(self):
+        summary = lean.lean_summary(records(), ["vanilla", "bigpowers"])
+        va, bp = summary["arms"]["vanilla"], summary["arms"]["bigpowers"]
+        self.assertEqual(va["lead_time_s"], 70)
+        self.assertEqual(round(va["stage_share"]["build"], 2), 0.4)
+        self.assertEqual(bp["waste"]["test_runs"], 8)
+        self.assertEqual(bp["ftt_rate"], 0.0)
+        self.assertEqual(va["cost_per_pass"], 0.01)
+        d = summary["deltas"]["bigpowers"]
+        self.assertEqual(d["lead_time_s"]["delta"], 70)
+        self.assertEqual(d["test_runs"]["delta"], 5)
+        self.assertEqual(len(d["build_share"]["ci95"]), 2)
+
+    def test_old_records_give_none(self):
+        old = [{k: v for k, v in r.items() if k not in ("vsm", "waste")} for r in records()]
+        self.assertIsNone(lean.lean_summary(old, ["vanilla", "bigpowers"]))
+        self.assertEqual(lean.lean_lines(None), [])
+
+    def test_report_carries_lean(self):
+        result = rep.aggregate(records(), ["vanilla", "bigpowers"], ["t"])
+        self.assertIn("bigpowers", result["lean"]["deltas"])
+
+
+class TestViews(unittest.TestCase):
+    def test_bars_scale_with_lead_time(self):
+        lines = lean.lean_lines(lean.lean_summary(records(), ["vanilla", "bigpowers"]))
+        bars = {line.split()[0]: line for line in lines if line.split() and line.split()[0] in ("vanilla", "bigpowers")}
+        va_len = bars["vanilla"].count("|") and len(bars["vanilla"].split("|")[1].rstrip())
+        bp_len = len(bars["bigpowers"].split("|")[1].rstrip())
+        self.assertAlmostEqual(bp_len / va_len, 2, delta=0.2)
+        self.assertIn("T", bars["bigpowers"])
+        self.assertTrue(any("rework" in line for line in lines))
+
+
+class TestRedundantTestRuns(unittest.TestCase):
+    def test_repeated_green_run_without_edit_is_redundant(self):
+        stream = (Stream()
+                  .call("edit", {"path": "/work/src/a.js"})
+                  .call("bash", {"command": "npm test"}, "# pass 3\n# fail 0\n")
+                  .call("bash", {"command": "npm test 2>&1 | tail -3"}, "# pass 3\n# fail 0\n")
+                  .call("edit", {"path": "/work/src/a.js"})
+                  .call("bash", {"command": "npm test"}, "# pass 3\n# fail 0\n"))
+        self.assertEqual(waste.transcript_waste(stream.text())["redundant_test_runs"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=1)

package/tests/test_ab_score.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# story: e58s03
+# story: e58s03 e58s11
 """tests/test_ab_score.py — partial-credit scoring and the hard tasks (ab-11, ab-13).
 
 Run: python3 tests/test_ab_score.py
@@ -18,7 +18,17 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
 from test_ab_eval import REPO_ROOT, Sandbox, met, rep  # noqa: E402
 
 TASKS = REPO_ROOT / "specs" / "benchmarks" / "ab" / "tasks"
-HARD_TASKS = ["ab-11-ledger-rounding", "ab-13-orders-split"]
+HARD_TASKS = [
+    "ab-09-inventory-reservations",
+    "ab-11-ledger-rounding",
+    "ab-12-todo-due-dates",
+    "ab-13-orders-split",
+    "ab-15-config-precedence",
+    "ab-16-site-tags-rss",
+    "ab-17-payment-alias",
+    "ab-19-catalog-segregation",
+    "ab-20-brand-discount",
+]
 
 
 class TestTapScore(unittest.TestCase):

package/tests/test_ab_tasks.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# story: e58s01 e58s02 e58s07 e58s09
+"""tests/test_ab_tasks.py — every shipped A/B task is calibrated: its fixture fails, its reference
+solution passes, its prompt never names bigpowers, and its grade command uses file globs.
+
+Run: python3 tests/test_ab_tasks.py
+Split from test_ab_eval.py (300-line cap).
+"""
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_ab_eval import REPO_ROOT  # noqa: E402
+
+
+@unittest.skipUnless(shutil.which("node"), "node is needed for the starter tasks")
+class TestStarterTasks(unittest.TestCase):
+    """Each shipped task must fail as given and pass with its reference solution."""
+
+    TASKS = REPO_ROOT / "specs" / "benchmarks" / "ab" / "tasks"
+
+    def grade_copy(self, task_dir: Path, with_solution: bool) -> bool:
+        task = yaml.safe_load((task_dir / "task.yaml").read_text())
+        work = Path(tempfile.mkdtemp(prefix="ab-starter-"))
+        try:
+            shutil.copytree(task_dir / "fixture", work, dirs_exist_ok=True)
+            if with_solution:
+                shutil.copytree(task_dir / "solution", work, dirs_exist_ok=True)
+            shutil.copytree(task_dir / "hidden", work, dirs_exist_ok=True)
+            res = subprocess.run(["bash", "-c", task["grade"]], cwd=work, capture_output=True)
+            return res.returncode == 0
+        finally:
+            shutil.rmtree(work, ignore_errors=True)
+
+    def test_eight_tasks_ship(self):
+        self.assertGreaterEqual(len(list(self.TASKS.glob("*/task.yaml"))), 8)
+
+    def test_fixture_fails_and_solution_passes(self):
+        for task_yaml in sorted(self.TASKS.glob("*/task.yaml")):
+            with self.subTest(task=task_yaml.parent.name):
+                self.assertFalse(self.grade_copy(task_yaml.parent, with_solution=False))
+                self.assertTrue(self.grade_copy(task_yaml.parent, with_solution=True))
+
+    def test_prompts_never_name_bigpowers(self):
+        for task_yaml in self.TASKS.glob("*/task.yaml"):
+            self.assertNotIn("bigpowers", yaml.safe_load(task_yaml.read_text())["prompt"].lower())
+
+    def test_fixture_test_scripts_never_pass_a_bare_directory(self):
+        """`npm test` must work in every fixture: a `node --test test/` script fails on node 24, and
+        agents then spend the run repairing the harness (found by e58s09 waste metrics)."""
+        for package in self.TASKS.glob("*/fixture/package.json"):
+            with self.subTest(task=package.parent.parent.name):
+                script = json.loads(package.read_text()).get("scripts", {}).get("test", "")
+                self.assertNotRegex(script, r"--test\s+\S*/(\s|$)", script)
+
+    def test_grade_commands_never_pass_a_bare_directory(self):
+        """`node --test test/` exits 1 on node 24 (it resolves the directory as a module path), so
+        such a task can never pass however good the solution is, while a hidden-only `score`
+        command still looks healthy (BUG found in e58s07: ab-11 and ab-13 read pass=0 forever)."""
+        for task_yaml in self.TASKS.glob("*/task.yaml"):
+            with self.subTest(task=task_yaml.parent.name):
+                for token in yaml.safe_load(task_yaml.read_text())["grade"].split():
+                    self.assertNotIn(token.rstrip("/"), ("test", "test-hidden"),
+                                     f"{task_yaml.parent.name} grades a directory, not a glob")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=1)