pi-dev-team 0.2.0

package/skills/stryker-xunit-v2-shim/scripts/generate_shim.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Scaffold a xunit.v2 Stryker shim beside a real xunit.v3 test project.
+
+The shim is a second test project that recompiles the SAME test sources under
+xunit.v2 (classic VSTest), which Stryker.NET can observe — xunit.v3 runs on the
+Microsoft Testing Platform and yields a false ~0% mutation score (stryker-net
+issues 3237/3629/3094). This script performs the mechanical part of the howto
+(references/shim-howto.md, step 3 + step 6): it reads the real test .csproj and
+emits the shim .csproj and a stryker-config.json.
+
+It deliberately does NOT port v3-only source constructs (step 4) — that needs
+judgment. Run the scope probe first (see SKILL.md) and port anything it flags in
+the REAL test project's sources before building the shim.
+
+Usage:
+    python3 generate_shim.py <path-to-real-test.csproj> [--mutate-exclude GLOB ...]
+
+Writes <real-dir>/../<Name>.Mutation/<Name>.Mutation.csproj and stryker-config.json,
+then prints the next steps. Stdlib only.
+"""
+import argparse
+import json
+import os
+import re
+import sys
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="ignore") as fh:
+        return fh.read()
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Scaffold a xunit.v2 Stryker shim.")
+    ap.add_argument("csproj", help="path to the real xunit.v3 test .csproj")
+    ap.add_argument("--mutate-exclude", action="append", default=[],
+                    help="extra mutate exclude glob (repeatable), e.g. '**/gRPC/**/*.cs'")
+    ap.add_argument("--compile-exclude", action="append", default=[],
+                    help="operator-selected v3-feature test file to drop from the shim's "
+                         "<Compile> set (repeatable), from the #1160 always-ask gate. Path "
+                         "relative to the real project, e.g. '..\\Foo.Tests\\ExplicitTests.cs'")
+    args = ap.parse_args()
+
+    real = os.path.abspath(args.csproj)
+    if not os.path.isfile(real):
+        sys.exit(f"error: no such file: {real}")
+    xml = read(real)
+    if "xunit.v3" not in xml:
+        sys.exit("error: this .csproj does not reference xunit.v3 — a shim is only needed "
+                 "for xunit.v3 projects. Nothing to do.")
+
+    real_dir = os.path.dirname(real)
+    name = os.path.splitext(os.path.basename(real))[0]
+    shim_dir = os.path.join(os.path.dirname(real_dir), name + ".Mutation")
+    shim_csproj = os.path.join(shim_dir, name + ".Mutation.csproj")
+
+    tfm = (re.search(r"<TargetFramework>([^<]+)</TargetFramework>", xml) or [None, "net10.0"])[1]
+    ns = (re.search(r"<RootNamespace>([^<]+)</RootNamespace>", xml) or [None, name])[1]
+
+    pkgs = re.findall(r"<PackageReference\b[^>]*?/>|<PackageReference\b.*?</PackageReference>",
+                      xml, re.DOTALL)
+    # Keep every non-xunit dependency verbatim; the xunit stack + Test.Sdk are replaced below.
+    kept = [p for p in pkgs if "xunit" not in p.lower() and "Microsoft.NET.Test.Sdk" not in p]
+    projrefs = re.findall(r"<ProjectReference\b[^>]*?/>|<ProjectReference\b.*?</ProjectReference>",
+                          xml, re.DOTALL)
+    if not projrefs:
+        print("warning: the real test .csproj has no <ProjectReference> to the product — "
+              "add the product reference to the shim manually.", file=sys.stderr)
+
+    lines = ['<Project Sdk="Microsoft.NET.Sdk">', "",
+             f"  <!-- xunit.v2 Stryker shim of {name}. Keep out of the .sln and CI test discovery.",
+             "       Delete once stryker-net fixes MTP mutation observation (issues 3237/3629/3094). -->", "",
+             "  <PropertyGroup>",
+             f"    <TargetFramework>{tfm}</TargetFramework>",
+             "    <IsPackable>false</IsPackable>",
+             f"    <RootNamespace>{ns}</RootNamespace>",
+             f"    <AssemblyName>{name}.Mutation</AssemblyName>",
+             "    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>",
+             "    <NoWarn>$(NoWarn);IDE0028;RCS1163;CS8032;NU1701</NoWarn>",
+             "    <GenerateProgramFile>true</GenerateProgramFile>",
+             "  </PropertyGroup>", "",
+             "  <ItemGroup>",
+             '    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />',
+             '    <PackageReference Include="xunit" Version="2.9.2" />',
+             '    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">',
+             "      <PrivateAssets>all</PrivateAssets>",
+             "      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>",
+             "    </PackageReference>"]
+    lines += ["    " + " ".join(p.split()) for p in kept]
+    lines += ["  </ItemGroup>", ""]
+    if projrefs:
+        lines += ["  <ItemGroup>"]
+        lines += ["    " + " ".join(pr.split()) for pr in projrefs]
+        lines += ["  </ItemGroup>", ""]
+    # Always exclude build output; append operator-selected v3-feature files
+    # (#1160) so the shim compiles without the constructs that break under v2.
+    compile_excludes = [f"..\\{name}\\obj\\**\\*.cs", f"..\\{name}\\bin\\**\\*.cs"]
+    compile_excludes += [g.strip() for g in args.compile_exclude if g.strip()]
+    exclude_attr = ";".join(compile_excludes)
+    lines += ["  <ItemGroup>",
+              f'    <Compile Include="..\\{name}\\**\\*.cs"',
+              f'             Exclude="{exclude_attr}">',
+              "      <Link>Linked\\%(RecursiveDir)%(FileName)%(Extension)</Link>",
+              "    </Compile>",
+              "  </ItemGroup>", "", "</Project>", ""]
+
+    os.makedirs(shim_dir, exist_ok=True)
+    with open(shim_csproj, "w", encoding="utf-8") as fh:
+        fh.write("\n".join(lines))
+
+    mutate = ["**/*.cs", "!obj/**/*.cs"] + [f"!{g}" for g in args.mutate_exclude]
+    # Pin test-projects to the shim and deliberately set NO SolutionPath: with
+    # both set, Stryker enumerates the solution and prefers the real xunit.v3
+    # project over the shim (the SolutionPath trap, #557/#1156) — so the shim's
+    # kills never register. test-projects alone keeps Stryker on the shim.
+    config = {"stryker-config": {
+        "test-projects": [f"{name}.Mutation.csproj"],
+        "mutate": mutate,
+        "mutation-level": "Standard",
+        "coverage-analysis": "perTest",
+        "additional-timeout": 30000,
+        "target-framework": tfm,
+        "reporters": ["html", "json", "progress"],
+        "thresholds": {"high": 80, "low": 60, "break": 0},
+    }}
+    config_path = os.path.join(shim_dir, "stryker-config.json")
+    with open(config_path, "w", encoding="utf-8") as fh:
+        json.dump(config, fh, indent=2)
+
+    rel = os.path.relpath(shim_dir)
+    print(f"Wrote {os.path.relpath(shim_csproj)}")
+    print(f"Wrote {os.path.relpath(config_path)}")
+    print()
+    print("Next (see SKILL.md / references/shim-howto.md):")
+    print(f'  1. If the product uses InternalsVisibleTo, add [assembly: InternalsVisibleTo("{name}.Mutation")].')
+    print(f"  2. Green baseline:  dotnet build {rel} -c Release  &&  dotnet test {rel} -c Release --no-build")
+    print(f"     (expect the SAME test count as {name}, 0 failed)")
+    print(f"  3. Kills-register gate: scope mutate to one small covered file, then  cd {rel} && dotnet-stryker")
+    print(f"  4. Widen mutate, then run the full mutation FROM the shim dir:  cd {rel} && dotnet-stryker")
+
+
+if __name__ == "__main__":
+    main()

package/skills/systematic-debugging/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: systematic-debugging
+description: Four-phase debugging protocol (reproduce, investigate, root-cause, fix) that prevents guess-and-fix thrashing. Use this skill whenever a test fails, a bug is reported, an error occurs during implementation, or any unexpected behavior is encountered. Prevents the common LLM failure mode of guessing at fixes without understanding the problem.
+role: worker
+user-invocable: true
+---
+
+# Systematic Debugging
+
+## Overview
+
+When LLMs hit failures, they tend to guess at fixes — changing code, re-running, changing more code. This thrashing wastes context and often makes things worse. This skill enforces a four-phase protocol that requires understanding before action. Systematic debugging resolves issues in 15-30 minutes; guess-and-fix typically takes 2-3 hours with a 40% first-attempt success rate vs 95% systematic.
+
+## Iron Law
+
+**Find root cause before attempting fixes. Symptom fixes are failure.** No fixes without root cause investigation first.
+
+## Constraints
+- Do not change code until you have a root cause hypothesis
+- Do not apply more than one fix at a time
+- Do not skip the reproduction step — a bug you can't reproduce is a bug you can't verify as fixed
+- Do not guess. Investigate.
+- After 3+ failed fix attempts, question the architecture — stop patching
+
+## The Four Phases
+
+### Phase 1: Reproduce
+**Goal**: See the failure with your own eyes (tool output).
+
+1. Run the failing test or trigger the error condition
+2. Read error messages thoroughly — don't skim. Stack traces contain line numbers, file paths, and often the solution.
+3. Identify the minimal reproduction — strip away everything unrelated
+4. Determine if the issue is consistent or intermittent
+5. **Gate**: paste the reproduction output. If you can't reproduce it, gather more data — don't speculate.
+
+### Phase 2: Investigate & Pattern Analysis
+**Goal**: Gather facts and find working reference points.
+
+**Investigate** (use as many techniques as needed):
+- **Read the error**: Parse the stack trace. What file, line, and function? What's the actual error type?
+- **Trace the data flow**: Follow the input from entry point to failure point. Where does the actual value diverge from the expected value?
+- **Graph-assisted tracing**: prefer CodeGraph/Repowise over hand-walking the codebase to trace the call path from symptom to source — see [`knowledge/codegraph-vs-graphify.md`](../../knowledge/codegraph-vs-graphify.md) for tool selection and the fallback contract.
+- **Check recent changes**: What changed since this last worked? (`git diff`, `git log`)
+- **Add observation points**: Temporary logging or print statements at key points to see actual values
+- **Multi-component systems**: Add diagnostics at each component boundary — log data entering and exiting each layer to find which layer fails
+- **Bisect**: If the failure surface is large, narrow it down by testing midpoints
+
+**Pattern Analysis**:
+- **Find working examples**: Locate similar functioning code in the same codebase
+- **Compare against references**: Read reference implementations completely — don't skim
+- **Identify differences**: List every distinction between working and broken code, no matter how minor
+- **Understand dependencies**: What components, settings, and assumptions are required?
+
+**Gate**: state what you know and don't know. List the facts, not guesses.
+
+### Phase 3: Root Cause Hypothesis
+**Goal**: Identify the single underlying cause using the scientific method.
+
+1. Form a single hypothesis: "I think X is the root cause because Y"
+2. Predict what you would see if the hypothesis is correct (a test you haven't run yet)
+3. Run that prediction test — make the smallest possible change, one variable at a time
+4. If the prediction fails, your hypothesis is wrong — return to Phase 2 with new information
+5. Do not compound fixes — test one hypothesis at a time
+6. **Gate**: state the root cause in one sentence. If you can't, you don't have it yet.
+
+### Phase 4: Fix
+**Goal**: Make the smallest change that addresses the root cause.
+
+**Iron Law of Phase 4: no fix without a failing test that reproduces the defect first.** This is a hard gate, not the advisory test-driven-development skill's opt-in discipline — it applies to every defect fix regardless of the build's cadence.
+
+1. Write or modify a test that captures the bug (it should fail now) — do not write fix code before this test exists and fails for the right reason
+2. Apply the fix — one change, targeting the root cause
+3. Run the test — it should pass
+4. Run the full suite — no regressions
+5. **Gate**: paste the test output showing the fix works and nothing else broke
+
+**If the fix doesn't work**: Stop and reassess. After fewer than 3 attempts, return to Phase 1. After 3+ failures, question the architecture itself — when each fix reveals new problems elsewhere, the bug is architectural, not local. Discuss fundamentals with the human before attempting more fixes.
+
+### After the fix: capture the pattern (Improve)
+
+A bug class you had to debug once should be cheaper next time — this is the "improve" step of the ownership loop. When a root cause reflects a recurring pattern (a timezone helper, a boundary off-by-one, a shared-state leak), leave the loop better than you found it: the regression test from Phase 4 pins it, and if the pattern is likely to recur, note it where the next engineer will see it — a comment at the fault site, or a `learn:`/`remember:` via [Feedback & Learning](../feedback-learning/SKILL.md). Skipping this means re-discovering the same bug.
+
+## Red Flags Requiring Process Restart
+
+Stop immediately and return to Phase 1 if you notice:
+- Planning "quick fix for now, investigate later"
+- Attempting changes without understanding why they'd work
+- Adding multiple modifications simultaneously
+- Skipping testing in favor of "just checking manually"
+- Fixing without investigation
+- Not understanding something but proceeding anyway
+- Adapting patterns differently than reference implementations
+- Proposing solutions before tracing data flow
+- Attempting a fourth or subsequent fix on the same issue
+- Each fix revealing new problems in different locations
+
+## Rationalization Prevention
+
+| Excuse | Reality |
+|--------|---------|
+| "I think I know what's wrong, let me just try this" | That's guessing. Investigate first — it takes less time than three wrong guesses. |
+| "The fix is obvious from the error message" | Then it'll be fast to verify your hypothesis before coding. Do it. |
+| "I'll just try a few things and see what sticks" | Each attempt burns context and may introduce new bugs. One investigated fix beats five guesses. |
+| "This is probably a race condition / timing issue" | "Probably" isn't a root cause. Add observation points and prove it. |
+| "Let me revert everything and start over" | You'll hit the same bug again. Understand it first, then decide whether to revert. |
+| "It's a simple issue, I don't need the full process" | Root causes exist in simple bugs too. The process handles simple issues quickly — just do it. |
+| "We're under time pressure, just fix it fast" | Systematic debugging actually beats guess-and-check even under time pressure. |
+| "Try fixing first, investigate if it doesn't work" | How you start establishes the pattern. Start correctly. |
+| "Multiple simultaneous fixes save time" | You can't isolate what worked. You'll create new bugs. One fix at a time. |
+| "I can see the problem, the cause is obvious" | Symptoms differ from root causes. What you see is the symptom. Investigate the cause. |
+
+## Success Indicators
+
+| Phase | You're Doing It Right When... |
+|-------|-------------------------------|
+| Reproduce | You have consistent reproduction with exact error output |
+| Investigate | You can list facts (not guesses) about what's happening and have working reference code |
+| Root Cause | You have a confirmed or revised hypothesis with prediction test results |
+| Fix | Issue is resolved with a passing test and no regressions |
+
+## When to Use This Skill
+- A test that was passing now fails
+- An error occurs during implementation
+- Unexpected behavior is observed
+- A bug report comes in
+- A fix you applied didn't work (re-enter at Phase 2)
+- You're under time pressure (especially then)
+
+## Output
+Root cause analysis with evidence: reproduction output, investigation findings, root cause statement, fix applied, and verification output showing the fix works without regressions.

package/skills/telemetry/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: telemetry
+description: >-
+  Manage and report the opt-in, privacy-clean usage telemetry beacon. Use when
+  the user asks to "enable/disable telemetry", "show telemetry", "usage stats",
+  "which commands do I use", or "how often is the commit gate bypassed".
+argument-hint: "[on|off|status|report]"
+user-invocable: true
+allowed-tools: >-
+  Bash(python3 *, jq *, cat *, mkdir *, ls *), Read, Write
+---
+
+# Telemetry (#106, #1405)
+
+Role: worker. Manages consent for and reports the local, opt-in telemetry
+beacon. The beacon (`hooks/telemetry.py`) records MINIMAL events — a command
+NAME, a skill NAME (including agent-/auto-invoked skills), a gate name +
+outcome, and the plugin version — to `~/.claude/metrics/telemetry.jsonl`. No
+prompts, paths, code, or payloads are ever recorded, and there is **no network
+egress**: everything stays local.
+
+Telemetry is **OFF by default**. It activates only when the user-level
+`~/.claude/telemetry.json` contains `{"enabled": true}`. This is a
+config-file-only, home-scoped switch: it is read and written at this one path
+regardless of which project directory the command runs from.
+
+## Scope — keep this small (#106)
+
+This beacon is intentionally a **cheap, always-on local counter**: which
+commands/skills run, how often the commit gate is bypassed. It is **not** the
+self-improvement loop and must not grow into one. The loop is `/session-review`,
+whose digest already extracts a superset of these signals (token, rework,
+accuracy, utilization) from transcripts and routes suggestions to governed
+machinery. Cross-machine aggregation also belongs to the **session-digest**
+(Delta D / #178), not this beacon. If you find yourself adding analysis or
+network egress here, that work belongs in `/session-review` instead.
+
+## Argument: $ARGUMENTS
+
+- `status` (default): report whether telemetry is enabled and what's collected.
+- `on`: enable by writing `~/.claude/telemetry.json` with `{"enabled": true}`
+  (confirm with the user first — this starts local recording).
+- `off`: disable by writing `{"enabled": false}` (recording stops; the existing
+  log is left in place for the user to inspect or delete).
+- `report`: print the usage summary.
+
+## Steps
+
+1. **status** — check `~/.claude/telemetry.json`; state on/off, and list
+   exactly what is and isn't collected (events: command/skill name, gate
+   fired/bypassed, plugin version; never: prompt text, paths, code, network).
+
+2. **on / off** — write `~/.claude/telemetry.json`:
+
+   ```json
+   { "enabled": true }
+   ```
+
+   For `on`, confirm consent first. Recording is local-only; the event log
+   `~/.claude/metrics/telemetry.jsonl` lives outside any project directory so
+   it can never be committed.
+
+3. **report** — summarize the event log:
+
+   ```bash
+   python3 "${CLAUDE_PLUGIN_ROOT}/hooks/lib/telemetry_report.py" \
+     --log "$HOME/.claude/metrics/telemetry.jsonl"
+   ```
+
+   Shows command usage, skill usage (including agent-/auto-invoked skills,
+   counted distinctly from user-typed commands), and the pre-commit review
+   gate's bypass rate. If the log doesn't exist, the report says telemetry is
+   off and nothing has left the machine.
+
+Report exactly what the tool emits; do not invent counts.

package/skills/test-audit-disable/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: test-audit-disable
+description: >-
+  Standalone worker. Audits the existing test suite for
+  tests that cannot fail — no assertions, assertions on constants, expect-true,
+  swallowed exceptions, self-equality — and disables each one by skip-and-tag
+  (never deletes). Records each disabled test plus its reason in a JSON log
+  under `.claude/memory/<workflow>/<slug>/` so a later phase can repair them. Pairs with
+  `/coverage-baseline` to produce a true baseline coverage number.
+argument-hint: "<repo-path> [--repo-slug <slug>] [--dry-run]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Edit, Write
+---
+
+# Test Audit + Disable
+
+Role: worker. Identifies tests that cannot fail and disables them so the next coverage run measures a true baseline, not a false positive inflated by tautologies. Tests are skipped + tagged, never deleted — Phase 4 repairs them.
+
+You have been invoked with the `/test-audit-disable` command.
+
+## Parse Arguments
+
+Arguments: $ARGUMENTS
+
+- Positional: `<repo-path>` — the repo under modernization.
+- `--repo-slug <slug>` — namespace under `.claude/memory/<workflow>/`. Defaults to the last path segment.
+- `--dry-run` — print the cannot-fail list and exit without disabling.
+
+## Steps
+
+### 1. Detect language + test framework
+
+Probe the repo root for the test stack. Take the first match:
+
+- `package.json` → JS/TS — `jest`, `vitest`, `mocha`, `playwright`. Skip helpers per framework: `it.skip` / `test.skip` / `xit` / `xdescribe`.
+- `pyproject.toml` / `setup.py` / `setup.cfg` → Python — `pytest`, `unittest`. Skip helpers: `@pytest.mark.skip(reason=...)`, `@unittest.skip(...)`.
+- `pom.xml` / `build.gradle*` → JVM — `JUnit5`, `JUnit4`, `TestNG`, `Kotest`. Skip helpers: `@Disabled("...")`, `@Ignore("...")`, `@Test(enabled=false)`.
+- `*.csproj` → .NET — `xunit`, `nunit`, `mstest`. Skip: `[Fact(Skip="…")]`, `[Test, Ignore("…")]`.
+- `Cargo.toml` → Rust — `#[ignore = "…"]`.
+- `go.mod` → Go — `t.Skip("…")`.
+
+If multiple stacks are present, process each. If none, ask the operator which to use.
+
+### 2. Detect cannot-fail tests
+
+For each test file, search for the cannot-fail patterns. The set is language-agnostic conceptually but the regex differs per framework — use these signal patterns:
+
+| Pattern | Example | Reason |
+|---|---|---|
+| No assertion at all | `it('does X', () => { service.doX(); })` | nothing to fail on |
+| Assertion on a literal | `expect(1).toBe(1)`, `assertEquals(true, true)` | self-evaluating |
+| Expect-truthy on a constant | `expect(true).toBeTruthy()` | tautology |
+| Self-equality | `expect(x).toBe(x)`, `assertEquals(obj, obj)` | always true |
+| Swallowed exception with no assertion in the catch | `try { … } catch { }` | masks failures |
+| Assertion only inside a never-entered branch | `if (false) { assert … }` | dead test |
+| `expect.anything()` / `expect.any(*)` as the only assertion | | matches anything |
+| Negative assertion on a never-thrown error | `expect(() => fn()).not.toThrow()` with no throw path | tautology unless fn can throw |
+
+For Python add: `assert True`, `self.assertTrue(True)`, `self.assertIsNotNone(self)`. For JVM add: `assertTrue(true)`, `assertEquals(x, x)`. For Go add: `if err != nil { t.Errorf(…) }` blocks with no error-path coverage and `t.Log` as the only call.
+
+A finding requires **file path + line + snippet + reason**. Use `Grep` (ripgrep) with file globs scoped to the framework's test conventions.
+
+**Graph-assisted lookup.** Prefer CodeGraph/Repowise over raw `Grep` for locating
+test files and confirming a suspect assertion has no real call path behind it
+(e.g. a swallowed-exception catch block that never reaches production error
+handling) — see [`knowledge/codegraph-vs-graphify.md`](../../knowledge/codegraph-vs-graphify.md)
+for tool selection and the fallback contract.
+
+### 3. Build the cannot-fail list
+
+Collect all findings into a JSON array:
+
+```json
+[
+  {
+    "file": "src/widget/widget.test.ts",
+    "line": 42,
+    "test": "renders without crashing",
+    "snippet": "it('renders without crashing', () => { render(<Widget/>) });",
+    "reason": "no-assertion"
+  },
+  …
+]
+```
+
+### 4. Preview + confirm
+
+Print the count by reason and the first ~20 entries. Ask:
+
+> Disable these N cannot-fail tests? (yes / no / show all)
+
+If `--dry-run`, print and exit zero without modifying anything.
+
+### 5. Disable in place
+
+For each finding, use `Edit` to insert the framework's skip helper at the matching test boundary, with the reason as the skip message:
+
+- JS/TS: `it(...)` → `it.skip(...)` and add a leading comment `// disabled by /test-audit-disable: <reason> — repair in Phase 4`.
+- Python: prepend `@pytest.mark.skip(reason="cannot-fail: <reason> — repair in Phase 4")`.
+- JVM: prepend `@Disabled("cannot-fail: <reason> — repair in Phase 4")`.
+- .NET: change `[Fact]` → `[Fact(Skip="cannot-fail: <reason> — repair in Phase 4")]`.
+- Rust: prepend `#[ignore = "cannot-fail: <reason> — repair in Phase 4"]`.
+- Go: insert `t.Skip("cannot-fail: <reason> — repair in Phase 4")` at the top of the test body.
+
+**Never** delete the test body. Phase 4 needs the original implementation to repair against the public-interface Gherkin.
+
+### 6. Persist phase-3 progress + the disabled-tests log
+
+Write:
+
+- `.claude/memory/<workflow>/<slug>/disabled-tests.json` — the array from Step 3, augmented with the disabling tag inserted at each site.
+- `.claude/memory/<workflow>/<slug>/phase-3-audit.md` — counts by reason, framework, file. Lists any test files the worker could not parse (call out as "needs hand-audit").
+
+The orchestrator's Phase-3 progress file is owned by `/coverage-baseline`, which runs immediately after this worker.
+
+### 7. Report
+
+Print:
+
+- Total tests disabled, broken down by reason.
+- The first ~10 disabled tests (file + line) for sanity-check.
+- Any files flagged for hand-audit.
+- The log path.
+
+## Notes
+
+- The disabled tag carries the reason and the "repair in Phase 4" hint so the operator can see the audit history in source control, not only in `.claude/memory/`.
+- Test-file detection follows framework conventions; configurable extensions / patterns can be added later, but the defaults cover the matrix above.
+- Tests that pass for the wrong reason but DO assert (e.g. brittle snapshot tests, over-mocked tests with no real-behavior assertion) are out of scope here — those land in Phase 5 `[Re-scope]` Stories, not the cannot-fail audit.

package/skills/test-design/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: test-design
+description: >-
+  Deep test-design review and forward-design advisor. Dispatches test-review
+  (tactical quality) and test-smell-review (xUnit smells, double selection,
+  pyramid placement) in parallel, and runs the test-design-advisor worker
+  to recommend how to test hard-to-test code. Use when the user says "review
+  my tests", "how should I test this", "is this testable", "design tests for
+  this", "what's the right test for X", "test design review", or before
+  writing a suite for an untested module. For a single unit, pass
+  --advise --path <file>. Advisory — it recommends, it does not edit.
+argument-hint: "[--path <dir>] [--since <ref>] [--advise]"
+role: orchestrator
+user-invocable: true
+allowed-tools: Read, Grep, Glob, Bash(git diff *), Skill, Agent
+---
+
+# Test Design
+
+Role: orchestrator. This command dispatches the two test review agents as
+sub-agents and the test-design-advisor skill, then aggregates one report. It
+does not review files itself — it coordinates.
+
+This command is executed under orchestrator direction. Dispatch each agent with
+its `model:`/`effort:` frontmatter as declared — the harness resolves both
+fields natively before dispatch, per Model/Effort Resolution in
+`agents/orchestrator.md` (ADR 0026).
+
+## Orchestrator constraints
+
+1. **Advisory only.** Aggregate findings and recommendations. Do not edit
+   production code or write test files. Hand actionable fixes to `/apply-fixes`
+   or `/build`.
+2. **Dispatch in parallel.** `test-review` and `test-smell-review` are
+   independent — spawn them in one batch for context isolation; each returns
+   structured JSON, not file dumps.
+3. **No double-reporting.** Apply `knowledge/test-review-division-of-labor.md`:
+   when the same line appears in both `test-review` and `test-smell-review`,
+   keep the design-level framing and drop the duplicate — record every such
+   drop in the report's `### Suppressed duplicates` section (see step 6).
+   For `test-smell-review` and `test-design-advisor`, no de-duplication is
+   required: per the "test-smell-review ↔ test-design-advisor — remedy
+   division" section of the knowledge doc, the smell agent cites the remedy
+   family (via `remedyFamily`) and the advisor names the specific remedy
+   pattern and refactor sequence — smell rows and advisor rows join
+   structurally on `remedyFamily`, not by prose match.
+4. **Be concise.** One aggregated report. Issue messages one sentence;
+   recommendations map to a concrete next edit.
+5. **MinimumCD vocabulary.** Layer labels in the aggregated report use the
+   MinimumCD six test types (static analysis / unit / component / contract /
+   integration / E2E) from `knowledge/cd-test-architecture.md`. Prefer
+   "contract test" over "narrow integration test"; if you must use the
+   alias, gloss it once: `contract test (also called narrow integration
+   test)`. Define each test type on first use (one-line gloss inline or
+   a "Test type definitions used in this report" block at the top).
+6. **No target-shape tables.** Per
+   `knowledge/cd-test-architecture.md#the-pyramid-is-a-cost-heuristic-not-a-target-shape`,
+   do not emit "current shape vs recommended shape" tables or per-layer target
+   counts; the aggregated report carries the advisor's per-behavior placement
+   table, not a silhouette target.
+7. **E2E justification gate.** Forward the advisor's four-condition E2E verdict
+   verbatim (the gate is canonical in
+   `knowledge/cd-test-architecture.md#the-e2e-justification-gate`). Never
+   recommend E2E in the rollup without it.
+
+## Parse Arguments
+
+Arguments: $ARGUMENTS
+
+Optional:
+
+- `--path <dir>`: target directory (default: current working directory)
+- `--since <ref>`: target files changed since a git ref (`git diff --name-only <ref>...HEAD`)
+- `--advise`: also run the test-design-advisor skill for forward-looking design (default on when the target has untested production code or few/no test files, **or when the target resolves to a single production file** — via `--path <file>` or a `--since` diff that touches exactly one production file; this is the path for forward-design on a single unit — the `test-design-advisor` skill has no user-facing slash command)
+
+## Steps
+
+### 1. Determine target files
+
+Same auto-scope logic as `/code-review`: uncommitted changes if present, else
+all source files; honor `--since` and `--path`. Identify test files and the
+production code they cover.
+
+**Single-file → auto-`--advise`.** If the resolved target is exactly one
+production file (`--path <file>` pointing at a production source file, or a
+`--since` diff whose production set has one file), set `--advise` on for this
+run and record it in the report header. This is the entry path for
+forward-design on a single unit (the `test-design-advisor` worker skill has
+no user-facing slash command).
+
+### 2. Dispatch review agents (parallel)
+
+Spawn both as sub-agents in one batch:
+
+- `test-review` — tactical quality gate (assertions, hygiene, non-determinism mechanics, testability blockers)
+- `test-smell-review` — xUnit smells, test-double selection, pyramid-layer placement
+
+Each returns its standard JSON (`status`/`issues`/`summary`). If no test files
+exist, both skip — proceed to Step 4 with `--advise`.
+
+### 3. Score the in-scope tests (Farley Score)
+
+Using the file set already resolved in Step 1 (Step 1 is the single
+scope-resolution authority in this skill), invoke `Skill(farley-score ...)`
+to produce the Farley Score, rating, and distribution. Label the score with
+the scope it was computed over:
+
+- No `--path` / no `--since` → every test file in the repository (test-file
+  indicators in `knowledge/test-file-indicators.md`); label `all tests`.
+- `--path <dir>` → tests under `<dir>` or covering production code under
+  `<dir>`; label `under <dir>`.
+- `--since <ref>` → tests touched in the diff plus tests covering production
+  files touched in the diff; label `changed since <ref>`.
+- `--path <dir>` and `--since <ref>` together → tests under `<dir>` that are
+  also touched (directly or via covered production code) since `<ref>` — the
+  intersection of both sets; label `under <dir>, changed since <ref>`.
+- Empty in-scope test set → skip the score and print `no in-scope test files`
+  in the report instead of a number.
+
+### 4. Run the advisor (when applicable)
+
+If `--advise` is set (or auto-triggered), use the Skill tool (`Skill(test-design-advisor ...)`) on the production code to produce testability assessment, pyramid
+placement, double strategy, and a behavior-preserving refactor sequence for
+any untestable units.
+
+### 5. Aggregate and de-duplicate
+
+Merge findings. Resolve overlaps per constraint 3. Group by file. Rank:
+behavior/project smells and testability blockers first (they undermine the
+whole suite), then fragile/obscure smells, then suggestions.
+
+### 6. Report
+
+Produce one report (chat for a small target; `.dev-team-reports/test-design-<date>.md`
+for a module):
+
+```markdown
+## Test Design Review — <target>
+
+**Health**: <pass|attention|critical>   **Test files**: N   **Findings**: N
+**Farley Score (<scope>)**: <score> (<rating>) — Exemplary N · Good N · Adequate N · Poor N
+
+`<scope>` is the label produced by Step 3; render it verbatim. Concrete
+forms: `Farley Score (all tests)`, `Farley Score (under <dir>)`,
+`Farley Score (changed since <ref>)`, `Farley Score (under <dir>, changed since <ref>)`.
+When the in-scope set was empty, replace the whole line with
+`**Farley Score**: no in-scope test files`.
+
+### Test type definitions used in this report
+<one-line glosses for MinimumCD terms appearing below; verbatim from
+`knowledge/cd-test-architecture.md` § The Six Test Types — at minimum
+the terms actually used in the report>
+
+### Findings (by severity)
+| File:line | Smell / Issue | Severity | Source | Suggested fix |
+
+### Design recommendations (advisor)
+<testability table · pyramid placement (per-behavior, two-direction
+justification, NO target counts) · double strategy · refactor sequence ·
+E2E justification (only when E2E is recommended)>
+
+### Suppressed duplicates
+<Every drop constraint 3 performed at aggregation time. Each entry cites the
+finding's `file:line`, what was dropped (which agent's finding, keyed by
+smell/message), and the reason (e.g. "mechanics duplicate of Assertion
+Roulette owned by test-smell-review"). test-smell-review ↔ test-design-advisor
+overlaps are never listed here — they are joined structurally on
+`remedyFamily`, not dropped. Emit `_None._` when nothing was dropped.>
+
+### Next steps
+- Mechanical fixes → /apply-fixes
+- Refactor sequence → /plan or /build
+```
+
+Surface only what's actionable. If everything is clean, say so in one line.
+Do NOT include a "current shape vs recommended shape" table — see Orchestrator
+constraint #6.