feat(hygiene): perf aggregates all Heart dev-loop timing legs (#94)

Generalizes the perf Heart-consult from import_time only to the whole hygiene-perf
timing family: import_time + unit_test_timing + workspace_testmode_timing, each
read only when its ~/.pyauto-heart/<leg>.json sidecar exists, aggregated into one
regression count (red+yellow across present legs). Falls back to the one-shot
subprocess import timing when no leg has a reading. This means new legs (4a #63,
4b) light up in perf with no further conductor change.

Tests: existing import_time consult test updated for the aggregated format; new
multi-leg aggregation test. PyAutoBrain 38 pass.


Claude-Session: https://claude.ai/code/session_01Tw3EwV55k6VzxorYng3Kfn

Co-authored-by: Jammy2211 <JNightingale2211@gmail.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 3 people

agents/conductors/hygiene/AGENTS.md

@@ -32,7 +32,7 @@ kinds, which is what makes its count comparable (or not):
 
 | Mode | Pre-scan (kind) | Delegates to |
 |------|-----------------|--------------|
-| `perf` | import cost — prefers Heart's tracked **`import_time`** leg when present, else times `import <pkg>` per library in a **subprocess** (**timing**); heavy test/script timing is read from Heart's `script_timing` / `test_run` | `/refactor` / `/bug` (+ Heart timing legs) |
+| `perf` | dev-loop timing — prefers Heart's tracked timing legs when present (`import_time`, `unit_test_timing`, `workspace_testmode_timing`), else times `import <pkg>` per library in a **subprocess** (**timing**) | `/refactor` / `/bug` (+ Heart timing legs) |
 | `tidy` | git debris — stale branches, stashes, `[gone]` refs, dirty checkouts (**debris**) | `/repo_cleanup` (Brain) |
 | `noise` | none — needs a pytest + workspace-script run (**advisory**) | `/cli_noise_clean` (Heart) |
 | `deps` | capped/pinned specifiers in library `pyproject.toml` (**surface**) | `/dep_audit` (Heart, hits PyPI) |

agents/conductors/hygiene/hygiene.sh

@@ -128,32 +128,37 @@ prescan_noise() {
   echo "-1|no cheap local signal — runs pytest + workspace scripts (PYAUTO_TEST_MODE=2)"
 }
 
-# perf: prefer PyAutoHeart's tracked `import_time` leg (baseline + regression
-# over time — the standing signal) when present; otherwise fall back to a
+# perf: prefer PyAutoHeart's tracked dev-loop timing legs (baseline + regression
+# over time — the standing signals) when present; otherwise fall back to a
 # one-shot import-cost timing, timing `import <pkg>` per library in a SUBPROCESS
-# (the conductor never imports the science stack itself). Heavy dev-loop timing
-# (slow tests / integration scripts) is already observed by PyAutoHeart's
-# script_timing / test_run legs — perf points there and routes.
+# (the conductor never imports the science stack itself). The legs are the
+# hygiene-perf family shipped alongside the conductor: import_time (import cost),
+# unit_test_timing (slow unit tests), workspace_testmode_timing (TEST_MODE
+# scripts) — each read only when its sidecar exists.
+PERF_HEART_LEGS=(import_time unit_test_timing workspace_testmode_timing)
 prescan_perf() {
-  # --- Heart import_time leg (preferred): the tracked over-time view. --------
-  local heart_json="${HEART_STATE_DIR:-$HOME/.pyauto-heart}/import_time.json"
-  if [[ -f "$heart_json" ]]; then
-    local counts
-    counts=$(python3 - "$heart_json" <<'PY' 2>/dev/null
+  # --- Heart timing legs (preferred): the tracked over-time view. ------------
+  local hs="${HEART_STATE_DIR:-$HOME/.pyauto-heart}" leg jf present=0 total=0 parts="" counts r y
+  for leg in "${PERF_HEART_LEGS[@]}"; do
+    jf="$hs/${leg}.json"
+    [[ -f "$jf" ]] || continue
+    counts=$(python3 - "$jf" <<'PY' 2>/dev/null
 import json, sys
 try:
     d = json.load(open(sys.argv[1]))
-    print(int(d.get("red_count", 0)), int(d.get("yellow_count", 0)),
-          int(d.get("green_count", 0)), int(d.get("packages_measured", 0)))
+    print(int(d.get("red_count", 0)), int(d.get("yellow_count", 0)))
 except Exception:
     pass
 PY
 )
-    if [[ -n "$counts" ]]; then
-      local r y g m; read -r r y g m <<< "$counts"
-      echo "$((r + y))|Heart import_time leg: ${r} regressions / ${y} slow / ${g} within baseline (${m} libs tracked); refresh: python -m heart.checks.import_time"
-      return
-    fi
+    [[ -n "$counts" ]] || continue
+    read -r r y <<< "$counts"
+    present=$((present + 1)); total=$((total + r + y))
+    parts+="${leg}:${r}r/${y}y "
+  done
+  if [[ "$present" -gt 0 ]]; then
+    echo "${total}|Heart timing legs (${present}): ${parts}(regressions = red+yellow); refresh via the leg drivers (python -m heart.checks.<leg>)"
+    return
   fi
   # --- Fallback: one-shot subprocess timing (no Heart reading available). -----
   local slow=0 measured=0 detail="" pkg rc start end t

tests/test_hygiene_conductor.py

@@ -81,20 +81,29 @@ def test_perf_advisory_when_nothing_importable(tmp_path):
     assert row["status"] == "advisory" and row["count"] is None
 
 
-def test_perf_prefers_heart_import_time_leg_when_present(tmp_path):
-    # When Heart's import_time leg has produced a reading, perf surfaces the
+def test_perf_prefers_heart_timing_legs_when_present(tmp_path):
+    # When a Heart dev-loop timing leg has produced a reading, perf surfaces the
     # tracked baseline/regression view instead of its own one-shot timing.
     heart = tmp_path / "heart"
     heart.mkdir()
-    (heart / "import_time.json").write_text(json.dumps({
-        "red_count": 1, "yellow_count": 1, "green_count": 3, "packages_measured": 5,
-    }))
+    (heart / "import_time.json").write_text(json.dumps({"red_count": 1, "yellow_count": 1}))
     r = _run(["perf", "--json"], tmp_path, extra={"HEART_STATE_DIR": str(heart)})
     assert r.returncode == 0, r.stderr
     row = json.loads(r.stdout)["row"]
     assert row["mode"] == "perf" and row["kind"] == "timing"
     assert row["count"] == 2  # red + yellow regressions
-    assert "import_time leg" in row["summary"]
+    assert "import_time" in row["summary"]
+
+
+def test_perf_aggregates_multiple_heart_timing_legs(tmp_path):
+    heart = tmp_path / "heart"
+    heart.mkdir()
+    (heart / "import_time.json").write_text(json.dumps({"red_count": 1, "yellow_count": 1}))
+    (heart / "unit_test_timing.json").write_text(json.dumps({"red_count": 2, "yellow_count": 0}))
+    r = _run(["perf", "--json"], tmp_path, extra={"HEART_STATE_DIR": str(heart)})
+    row = json.loads(r.stdout)["row"]
+    assert row["count"] == 4  # 2 + 2 regressions across both legs
+    assert "import_time" in row["summary"] and "unit_test_timing" in row["summary"]
 
 
 def test_unknown_mode_exits_2(tmp_path):