@event4u/agent-config 1.29.0 → 1.32.0

package/.agent-src/skills/subagent-orchestration/prompts/do-competitively.md

@@ -0,0 +1,65 @@
+# Prompt — do-competitively
+
+Mode reference: [`../SKILL.md`](../SKILL.md) § *4. do-competitively*.
+
+## Implementer prompt (per candidate)
+
+```
+You are CANDIDATE {{candidate_id}} of {{n_candidates}} competing on the
+SAME slice. Other implementers are solving the identical problem in
+parallel; the judge will pick exactly one winner.
+
+TASK: {{task_description}}
+CONTEXT FILES: {{file_paths}}
+
+CONSTRAINTS:
+- Do NOT optimize for "what the judge wants to see" — solve the task.
+- Do NOT copy from other candidates; you do not have access to them.
+- Make a real choice: name the algorithm, the API shape, the trade-off.
+  Generic safe answers lose to specific decisive ones.
+
+ON COMPLETION, return ONE envelope per schemas/subagent-status.json:
+  - DONE                — your candidate is complete and tests pass;
+                          evidence[] cites the test output.
+  - DONE_WITH_CONCERNS  — complete but flag the trade-off you made so
+                          the judge can score it.
+  - NEEDS_CONTEXT       — task ambiguity blocks all candidates; if so,
+                          all candidates should converge on the same
+                          blocking_question.
+  - BLOCKED             — task is malformed; explain in blocking_reason.
+```
+
+## Judge prompt (winner selection)
+
+```
+You are the judge picking ONE winner from {{n_candidates}} competing
+diffs for the SAME slice. Losers are rejected, not merged.
+
+CANDIDATE ENVELOPES: {{envelopes_array}}
+CANDIDATE DIFFS: {{diffs_array}}
+TASK: {{task_description}}
+
+SCORING DIMENSIONS (cite each in evidence[]):
+1. Correctness — does it pass tests AND solve the task?
+2. Trade-off clarity — is the choice named and defended?
+3. Maintenance cost — what does the codebase look like in 6 months?
+4. Diff size — smaller wins ties.
+
+VERDICT (one envelope, schemas/subagent-status.json):
+  - DONE                — winner picked; evidence[] cites the four
+                          scoring dimensions and names the winner.
+  - DONE_WITH_CONCERNS  — winner picked but the chosen trade-off has
+                          carry-over costs (concerns[]).
+  - NEEDS_CONTEXT       — all candidates need the same clarification.
+  - BLOCKED             — no candidate is acceptable; rerun with new
+                          implementers or change the task.
+
+NEVER pick a winner because it was the cheapest model. NEVER merge
+two candidates — that is do-in-parallel, not do-competitively.
+```
+
+## Cost-discipline rule
+
+`do-competitively` is N+1 subagent calls per slice. The orchestrator
+confirms budget with the user before dispatch. The losing diffs are
+discarded — that cost is the price of the trade-off survey.

package/.agent-src/skills/subagent-orchestration/prompts/do-in-parallel.md

@@ -0,0 +1,62 @@
+# Prompt — do-in-parallel
+
+Mode reference: [`../SKILL.md`](../SKILL.md) § *3. do-in-parallel*.
+
+## Implementer prompt (per slice)
+
+```
+You are the implementer for SLICE {{slice_id}} in a parallel-dispatch
+run. {{n_slices}} slices run concurrently. Slices are guaranteed
+independent — different files, no shared state.
+
+SLICE: {{slice_description}}
+CONTEXT FILES (this slice only): {{file_paths}}
+SHARED-STATE BAN: {{shared_paths_to_avoid}}
+
+CONSTRAINTS:
+- Do NOT touch any file outside the cited paths. The orchestrator
+  verified independence — violating it causes a merge race.
+- Do NOT communicate with other slices. They are doing their own work.
+- Write tests scoped to your slice; do not assert on slice-cross
+  behavior.
+
+ON COMPLETION, return ONE envelope per schemas/subagent-status.json:
+  - DONE                — slice shipped clean; evidence[] required.
+  - DONE_WITH_CONCERNS  — shipped but mark concerns[] for the
+                          aggregating judge to surface.
+  - NEEDS_CONTEXT       — paused; orchestrator must answer
+                          blocking_question. Other slices keep running.
+  - BLOCKED             — slice cannot complete in isolation; explain
+                          in blocking_reason. Other slices keep running;
+                          aggregating judge handles partial outcome.
+```
+
+## Judge prompt (run once on aggregate)
+
+```
+You are the judge running ONCE over the merged output of N parallel
+slices. Per-slice judges were skipped to keep cost linear.
+
+SLICE ENVELOPES: {{envelopes_array}}
+AGGREGATED DIFF: {{merged_diff}}
+TEST OUTPUT (full suite): {{test_output}}
+
+VERDICT (one envelope, schemas/subagent-status.json):
+  - DONE                — every slice DONE or DONE_WITH_CONCERNS that
+                          you accept; evidence[] cites the merge being
+                          test-green.
+  - DONE_WITH_CONCERNS  — accept the aggregate, but consolidated
+                          concerns[] from all slices need caller action.
+  - NEEDS_CONTEXT       — one or more slices need clarification before
+                          the aggregate can land; cite which.
+  - BLOCKED             — aggregate is broken; cite the slice(s) that
+                          must be re-run.
+
+INDEPENDENCE-VIOLATION CHECK: scan for files touched by more than one
+slice. If found, return BLOCKED — the dispatch was unsafe.
+```
+
+## Failure-isolation rule
+
+A slice returning BLOCKED does not abort the other slices. The
+aggregating judge decides whether the partial result lands.

package/.agent-src/skills/subagent-orchestration/prompts/do-in-steps.md

@@ -0,0 +1,62 @@
+# Prompt — do-in-steps
+
+Mode reference: [`../SKILL.md`](../SKILL.md) § *2. do-in-steps*.
+
+## Implementer prompt (per step)
+
+```
+You are the implementer for STEP {{step_number}} of {{total_steps}} in a
+sequential plan. Earlier steps that PASSED judgment are committed; their
+diffs are read-only context.
+
+PLAN: {{plan_summary}}
+THIS STEP: {{step_description}}
+PRIOR STEP DIFFS (read-only): {{prior_diffs}}
+CONTEXT FILES: {{file_paths}}
+
+CONSTRAINTS:
+- Do NOT modify code from prior steps; their tests must still pass.
+- Do NOT preempt later steps; one step at a time.
+- Write the test for THIS step before the production code.
+
+ON COMPLETION, return ONE envelope per schemas/subagent-status.json:
+  - DONE                — step complete, gate green; cite evidence[].
+  - DONE_WITH_CONCERNS  — step complete but flag carry-over concerns
+                          for later steps.
+  - NEEDS_CONTEXT       — paused; blocking_question must be answered
+                          before this step can complete.
+  - BLOCKED             — step cannot complete on the current plan;
+                          blocking_reason explains why. The orchestrator
+                          may revise the plan and re-dispatch.
+```
+
+## Judge prompt (between steps)
+
+```
+You are the judge reviewing STEP {{step_number}} before STEP
+{{step_number_plus_one}} starts. A failing step here cascades into the
+next, so verdicts are stricter than a one-shot do-and-judge.
+
+STEP DIFF: {{diff}}
+STEP TESTS: {{test_output}}
+PRIOR STEPS: {{prior_step_summaries}}
+NEXT STEP DESCRIPTION: {{next_step_description}}
+
+VERDICT — return ONE envelope per schemas/subagent-status.json:
+  - DONE                — proceed to next step; evidence[] required.
+  - DONE_WITH_CONCERNS  — proceed, but next step's prompt MUST surface
+                          the concerns[] so the implementer compensates.
+  - NEEDS_CONTEXT       — pause; orchestrator answers blocking_question
+                          before next step.
+  - BLOCKED             — do not start next step; this step is wrong.
+
+DOWNSTREAM IMPACT CHECK: name one way this diff could break the next
+step. If you cannot, return DONE. If you can but the implementer
+already mitigated, DONE. Otherwise DONE_WITH_CONCERNS.
+```
+
+## Cascade rule
+
+A step that returns BLOCKED stops the chain. The orchestrator does not
+"jump ahead" or re-order — it surfaces the BLOCKED envelope to the user
+and waits.

package/.agent-src/skills/subagent-orchestration/prompts/do-in-worktrees.md

@@ -0,0 +1,70 @@
+# Prompt — do-in-worktrees
+
+Mode reference: [`../SKILL.md`](../SKILL.md) § *6. do-in-worktrees*.
+Worktree creation/destruction lives in [`../../using-git-worktrees/SKILL.md`](../../using-git-worktrees/SKILL.md).
+
+## Implementer prompt (per worktree step)
+
+```
+You are the implementer for STEP {{step_id}} in a cross-wing chain.
+You are running INSIDE a fresh git worktree at {{worktree_path}} on
+branch {{branch_name}}. Prior step's open files / branch state cannot
+leak into this worktree — that is the whole point.
+
+STEP TYPED INPUT (from prior step's ## Output): {{typed_input}}
+STEP DESCRIPTION: {{step_description}}
+EXPECTED ## Output (next step's ## Input): {{expected_output_shape}}
+
+CONSTRAINTS:
+- Stay inside the worktree path. Do NOT cd to the parent repo.
+- Do NOT touch branches other than {{branch_name}}.
+- Produce the expected ## Output shape literally — the next worktree's
+  implementer consumes it as ## Input.
+- Run the chain-end test for THIS step before signaling completion.
+
+ON COMPLETION, return ONE envelope per schemas/subagent-status.json:
+  - DONE                — step output produced and validated; evidence[]
+                          cites the typed-output file path.
+  - DONE_WITH_CONCERNS  — output produced but flag carry-over for next
+                          worktree; concerns[] surfaces in next step's
+                          dispatch.
+  - NEEDS_CONTEXT       — paused; chain pauses until orchestrator
+                          answers blocking_question. Other worktrees
+                          are NOT running concurrently in this mode.
+  - BLOCKED             — step cannot complete; chain halts. The
+                          orchestrator decides whether to drop the
+                          worktree or rescope.
+```
+
+## Chain-end judge prompt (run once after final worktree)
+
+```
+You are the chain-end judge. The chain produced N typed outputs, one
+per worktree. Validate the final integration PR against the chain's
+goal.
+
+CHAIN STEPS: {{step_summaries_array}}
+TYPED OUTPUTS: {{outputs_array}}
+INTEGRATION PR DIFF: {{integration_diff}}
+
+VERDICT (one envelope, schemas/subagent-status.json):
+  - DONE                — chain landed cleanly; evidence[] cites each
+                          step's typed output and the integration test
+                          run.
+  - DONE_WITH_CONCERNS  — chain landed but consolidated concerns[]
+                          across steps need follow-up.
+  - NEEDS_CONTEXT       — integration is unclear; cite which step(s)
+                          need clarification.
+  - BLOCKED             — integration is broken; cite the worktree(s)
+                          that must be redone. Do NOT silently rewrite.
+
+WORKTREE-LEAK CHECK: scan the integration diff for branch names or
+files belonging to a different worktree's step. If found, BLOCKED —
+isolation was violated.
+```
+
+## Sequential-not-parallel rule
+
+`do-in-worktrees` runs steps sequentially across isolated worktrees.
+Parallel concurrent worktrees are `do-in-parallel` with explicit
+isolation, not this mode.

package/.agent-src/skills/subagent-orchestration/prompts/judge-with-debate.md

@@ -0,0 +1,63 @@
+# Prompt — judge-with-debate
+
+Mode reference: [`../SKILL.md`](../SKILL.md) § *5. judge-with-debate*.
+
+## Judge-A / Judge-B prompt (run twice in parallel)
+
+```
+You are JUDGE {{judge_letter}} reviewing a high-stakes diff (security,
+data integrity, public API). Another judge is independently reviewing
+the same diff. A meta-judge will reconcile your verdicts.
+
+DO NOT reach for the safe answer. Disagreement IS the value.
+
+TASK: {{task_description}}
+DIFF: {{diff}}
+TEST OUTPUT: {{test_output}}
+SENSITIVITY: {{security_or_data_or_api}}
+
+VERDICT (one envelope, schemas/subagent-status.json):
+  - DONE                — diff is correct and safe; evidence[] cites
+                          the specific defenses you verified.
+  - DONE_WITH_CONCERNS  — correct but the failure modes you can name
+                          go in concerns[].
+  - NEEDS_CONTEXT       — paused; meta-judge will adjudicate after
+                          orchestrator answers blocking_question.
+  - BLOCKED             — diff is wrong; explain in blocking_reason.
+
+NAME ONE FAILURE MODE you actively looked for, even if you did not
+find it. "I looked for X, did not find it" is stronger evidence than
+"this looks fine".
+```
+
+## Meta-judge prompt (run once after Judge-A and Judge-B return)
+
+```
+You are the META-JUDGE reconciling two independent verdicts. Both
+judges saw the same diff; their envelopes are below.
+
+JUDGE-A ENVELOPE: {{envelope_a}}
+JUDGE-B ENVELOPE: {{envelope_b}}
+DIFF: {{diff}}
+
+RECONCILIATION RULES:
+1. Both DONE → your verdict is DONE.
+2. Either BLOCKED → your verdict is BLOCKED. No tiebreaker.
+3. One DONE, one DONE_WITH_CONCERNS → DONE_WITH_CONCERNS (carry the
+   concerns).
+4. One NEEDS_CONTEXT → consolidate blocking_question(s); your status
+   is NEEDS_CONTEXT.
+5. Mixed otherwise → DONE_WITH_CONCERNS, listing every concern from
+   both judges.
+
+DISAGREEMENT IS THE VALUE: do NOT average. The strict-er verdict wins.
+
+VERDICT (one envelope, schemas/subagent-status.json) using the rules
+above. Cite both judges' evidence[] in your evidence[].
+```
+
+## High-stakes-only rule
+
+`judge-with-debate` is two-judges-plus-meta = three subagent calls per
+review. Reserve for security, data migration, public API, or
+cross-tenant boundaries. Routine refactors use plain `do-and-judge`.

package/.agent-src/skills/subagent-orchestration/schemas/subagent-status.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema#",
+  "$id": "https://event4u.dev/agent-config/schemas/subagent-status.json",
+  "title": "Subagent Status Envelope",
+  "description": "Required wire format for every implementer or judge subagent return. Loaded by /do-and-judge, /do-in-steps, and the subagent-orchestration skill. Hand-validated by tests/test_subagent_status_schema.py (no jsonschema runtime dep).",
+  "type": "object",
+  "required": ["status", "summary"],
+  "additionalProperties": false,
+  "properties": {
+    "status": {
+      "type": "string",
+      "enum": ["DONE", "DONE_WITH_CONCERNS", "NEEDS_CONTEXT", "BLOCKED"],
+      "description": "DONE = work shipped, gate green. DONE_WITH_CONCERNS = work shipped but caller must read concerns[]. NEEDS_CONTEXT = paused, blocking_question[] must be answered. BLOCKED = halted, blocking_reason describes why no path forward."
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1,
+      "description": "One- or two-sentence outcome. Required for every status."
+    },
+    "evidence": {
+      "type": "array",
+      "items": {"type": "string", "minLength": 1},
+      "description": "Citations: file:line, command output, test name, contract section. Required for DONE / DONE_WITH_CONCERNS."
+    },
+    "concerns": {
+      "type": "array",
+      "items": {"type": "string", "minLength": 1},
+      "description": "Caller-actionable concerns. Required when status = DONE_WITH_CONCERNS, must be empty otherwise."
+    },
+    "blocking_question": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Single specific question whose answer would unblock. Required when status = NEEDS_CONTEXT."
+    },
+    "blocking_reason": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Why no path forward exists. Required when status = BLOCKED. Distinguish from NEEDS_CONTEXT (where caller can supply context)."
+    },
+    "next_action": {
+      "type": "string",
+      "description": "What the caller does now. Optional; orchestrator infers from status when omitted."
+    }
+  },
+  "allOf": [
+    {
+      "if": {"properties": {"status": {"const": "DONE"}}, "required": ["status"]},
+      "then": {"required": ["evidence"], "not": {"required": ["concerns"]}}
+    },
+    {
+      "if": {"properties": {"status": {"const": "DONE_WITH_CONCERNS"}}, "required": ["status"]},
+      "then": {"required": ["evidence", "concerns"]}
+    },
+    {
+      "if": {"properties": {"status": {"const": "NEEDS_CONTEXT"}}, "required": ["status"]},
+      "then": {"required": ["blocking_question"]}
+    },
+    {
+      "if": {"properties": {"status": {"const": "BLOCKED"}}, "required": ["status"]},
+      "then": {"required": ["blocking_reason"]}
+    }
+  ]
+}

package/.agent-src/skills/test-driven-development/SKILL.md

@@ -64,6 +64,20 @@ stay on plain TDD — the section above.
 If step 2 is skipped, the test is not trusted — a test that has never
 failed proves nothing about the code under test.
 
+### Iron Law — delete-and-restart over keep-as-reference
+
+```
+WHEN UNTESTED CODE EXISTS AND A TEST IS NEEDED — DELETE THE CODE,
+WRITE THE TEST, REIMPLEMENT. NEVER KEEP IT "AS REFERENCE".
+```
+
+Reading the existing implementation while writing its test is
+test-after-the-fact with extra steps. The 12-row anti-rationalization
+table that follows expands the most common ways this Iron Law gets
+talked-around. Externalized to
+[`testing-anti-patterns/process-anti-patterns.md`](../testing-anti-patterns/process-anti-patterns.md)
+to keep this skill under the 400-line sunset trigger.
+
 ## Procedure
 
 ### 1. Identify the behavior to test
@@ -140,22 +154,20 @@ Back to step 1 with the next single-sentence behavior.
 3. Captured green-run output
 4. Any refactor diff (optional)
 
-## Anti-rationalizations table
+## Anti-rationalizations
 
-The urge to skip TDD is strongest on tasks where TDD matters most. Name
-the rationalization and reject it:
+Twelve common rationalizations that fire *before* the test is written —
+plus the delete-and-restart Iron Law — live in
+[`testing-anti-patterns/process-anti-patterns.md`](../testing-anti-patterns/process-anti-patterns.md).
+Read the table when:
 
-| Thought | Reality |
-|---|---|
-| "This is too simple to need a test" | Simple code still breaks. A test takes less time than one debug cycle. |
-| "I'll add the test after the code works" | A test written after code passes on the first run — it has never failed. It does not prove the code is correct. |
-| "I already ran it manually" | Manual runs are not repeatable. The next edit breaks it silently. |
-| "Deleting this code I just wrote is wasteful" | Sunk cost. The cheap path is: delete, write the test, reimplement minimally. |
-| "I'll keep the code as reference while I write the test" | You will read it and adapt it. That is test-after-the-fact with extra steps. Delete it. |
-| "I just need to explore the API first" | Spike it on a throwaway branch. Then delete it and restart with TDD. |
-| "The test is too hard to write" | That signals a design problem in the code, not in the test. Listen to it. |
-| "This bug is urgent, no time for a test" | The test **is** the fastest path to a verified fix. Guessing takes longer. |
+- You catch yourself thinking "I'll add the test after" — row 2.
+- You want to keep the code "as reference" while writing the test — row 5.
+- "CI is red, patch first, test later" — row 9.
+- "Follow-up PR will add the test" — row 12.
 
+For mock-isolation failure modes (separate concern), see
+[`testing-anti-patterns`](../testing-anti-patterns/SKILL.md).
 
 ## Examples
 

package/.agent-src/skills/testing-anti-patterns/SKILL.md

@@ -8,6 +8,13 @@ source: package
 
 Tests must verify real behavior, not mock behavior. Mocks isolate; they are not the thing under test. This skill is the **prevention** layer; [`judge-test-coverage`](../judge-test-coverage/SKILL.md) catches what slips through afterwards.
 
+For the **process / rationalization** failure modes that fire *before* a
+test is written (the urges to skip TDD, keep code "as reference", patch
+without a regression test), see the sibling reference table in
+[`process-anti-patterns.md`](process-anti-patterns.md). Both layers are
+required — a correctly-mocked test that was written *after* the code is
+still test-after-the-fact.
+
 ## When to use
 
 - About to write a new test that mocks a collaborator.
@@ -34,6 +41,10 @@ Do NOT use when:
 
 ## Procedure: Run the gate before each anti-pattern
 
+### 1. Inspect the diff before any new mock
+
+Before writing or extending a test, **inspect** the code under test and identify which collaborators are real, which are mocked, and which produce side effects the assertion depends on. Open the file, read the dependency chain, and write the chain down. Do not start mocking until the chain is on paper.
+
 ### Anti-Pattern 1 — Asserting on mock elements
 
 Symptom: `expect(screen.getByTestId('sidebar-mock')).toBeInTheDocument()` or `$this->assertSee('mock-sidebar')`. Test passes when the mock is present, fails when it is not — proves nothing about the component.
@@ -102,6 +113,8 @@ BEFORE creating a mock response object:
   3. If the shape is unknown, capture a real response into `tests/fixtures/` instead of inventing one.
 ```
 
+**Concrete capture tools** for recording the real shape: `curl -s <url> | jq '.'` against a staging endpoint, Postman's "Save Response", Laravel's `Http::fake()` in record mode, or a Playwright network-trace export. Filter the captured payload with `jq` / `grep` to keep only the fields your fixture documents — **do not** dump unredacted secrets into `tests/fixtures/`.
+
 ### Anti-Pattern 5 — Tests as an afterthought
 
 Symptom: "Implementation complete, ready for testing." Implementation went in without tests. TDD was skipped, anti-patterns 1–4 are now likely.
@@ -120,6 +133,7 @@ Gate: a feature is not complete until a failing-then-passing test cycle ran for
 - A "complete" mock that mirrors a v1 API silently rots when v2 ships — link mock fixtures to a real recorded response and re-record on schema changes.
 - Layer 3 environment guards from [`defense-in-depth`](../defense-in-depth/SKILL.md) often expose anti-pattern 2: if a production guard fires only in tests, the test setup is wrong, not the guard.
 - Long mock setups (> 50% of the test) are a signal that integration tests would be simpler — consider it before piling on more mocks.
+- **Diagnose, do not brute-force.** If a test fails after a mock change, **never guess** at another mock tweak — drop a debugger / Xdebug breakpoint at the seam, observe the real call shape, then mock minimally. Two retries without a root-cause hypothesis = STOP and rethink.
 
 ## Do NOT
 

package/.agent-src/skills/testing-anti-patterns/process-anti-patterns.md

@@ -0,0 +1,67 @@
+# Testing process anti-patterns — reference table
+
+Sibling reference for [`testing-anti-patterns`](SKILL.md) and
+[`test-driven-development`](../test-driven-development/SKILL.md).
+
+`testing-anti-patterns/SKILL.md` covers **mock-isolation** failure modes
+(mocking-the-mock, production pollution, partial mocks). This doc covers
+the **process / rationalization** failure modes — the urges that fire
+*before* the test is written and convince you to skip TDD entirely.
+
+Both layers are required. A correctly-mocked test that was written *after*
+the code is still test-after-the-fact. A TDD-first test that mocks itself
+is still mocking the mock.
+
+## The Iron Law (delete-and-restart)
+
+```
+WHEN YOU FIND YOURSELF KEEPING UNTESTED CODE "AS REFERENCE" WHILE WRITING
+A TEST FOR IT — DELETE THE CODE. WRITE THE TEST. THEN REIMPLEMENT.
+```
+
+The cheap path is one extra round-trip. The expensive path is a test that
+silently encodes the bug it was supposed to catch.
+
+## 12-row anti-rationalization table
+
+The urge to skip TDD is strongest on tasks where TDD matters most. Name
+the rationalization, then reject it:
+
+| # | Thought | Reality |
+|---|---|---|
+| 1 | "This is too simple to need a test" | Simple code still breaks. A test takes less time than one debug cycle. |
+| 2 | "I'll add the test after the code works" | A test written after code that passed first try has never failed. It does not prove the code is correct. |
+| 3 | "I already ran it manually" | Manual runs are not repeatable. The next edit breaks it silently. |
+| 4 | "Deleting code I just wrote is wasteful" | Sunk cost. The cheap path: delete, write the test, reimplement minimally. |
+| 5 | "I'll keep the code as reference while I write the test" | You will read it and adapt to it. That is test-after-the-fact with extra steps. Delete it. |
+| 6 | "I just need to explore the API first" | Spike on a throwaway branch. Then delete the spike and restart with TDD. |
+| 7 | "The test is too hard to write" | That signals a design problem in the code, not the test. Listen to it — refactor the seam, then test. |
+| 8 | "This bug is urgent, no time for a test" | The test **is** the fastest path to a verified fix. Guessing takes longer and re-occurs. |
+| 9 | "CI is red — patch first, test later" | A red CI is the cheapest moment to write the regression test. The patch without the test invites the same bug back. |
+| 10 | "The test is just proof-of-work for the PR review" | A test that exists to placate review is not a test — it is theater. Either it asserts behavior or delete it. |
+| 11 | "The dependency is too awkward to seam" | The seam discomfort *is* the design feedback. A constructor-injection refactor pays for itself the second time you change the dependency. |
+| 12 | "We'll add the test in a follow-up PR" | Follow-up PRs that add tests to merged code arrive 0% of the time. The test ships with the change or never. |
+
+## When to use this doc
+
+- Reviewing your own draft before writing a test — read the table, check
+  none of the 12 are firing in your head.
+- Reviewing a teammate's PR — if the PR description matches one of the 12
+  patterns, surface the row number in the review.
+- Onboarding — pair with [`test-driven-development`](../test-driven-development/SKILL.md)
+  to give new devs the *why* behind the discipline.
+
+## Cross-references
+
+- Mock-specific anti-patterns: [`testing-anti-patterns`](SKILL.md)
+- TDD discipline: [`test-driven-development`](../test-driven-development/SKILL.md)
+- Coverage hygiene on a finished diff: [`judge-test-coverage`](../judge-test-coverage/SKILL.md)
+- Pest conventions: [`pest-testing`](../pest-testing/SKILL.md)
+- Quality tooling: [`quality-tools`](../quality-tools/SKILL.md)
+
+## Provenance
+
+- Adapted from `obra/superpowers@v5.1.0` `testing/anti-patterns.md`.
+- Council convergence (anthropic/claude-sonnet-4-5 + openai/gpt-4o,
+  2026-05-07): both members ADOPT — the catalogue surfaces specific
+  rationalization patterns that would otherwise leak past code review.

package/.agent-src/templates/AGENTS.md

@@ -1,25 +1,24 @@
 # {{project_name}}
 
 <!--
-  AGENTS.md entry point for AI coding agents. Installed by
-  `event4u/agent-config`. Fill placeholders (or run `/copilot-agents-init`)
-  and delete this comment. Keep thin; bulk prose belongs in the linked guide.
+  Fill placeholders or run `/agents init`, then delete this
+  comment. Iron Law — capability bullets, not path lists; paths rot.
+  Tool stubs (`CLAUDE.md`, `GEMINI.md`, `.cursorrules`) link here.
+  Anatomy + recipes: `.augment/contexts/contracts/agents-md-anatomy.md`.
 -->
 
-{{project_description}}
+> {{project_description}}
 
 ## Layers
 
-| Layer | Location | Purpose |
+| Layer | Location | Edits |
 |---|---|---|
-| **Shared package** | `.augment/`, `.agent-src/` | Installed skills / rules / commands — do not hand-edit |
-| **Project overrides** | `agents/overrides/` | Customizations of shared resources |
-| **Project docs** | `agents/` | Architecture, features, roadmaps, sessions, contexts |
-| **Agent settings** | `.agent-settings.yml` | Project-specific config consumed by skills |
+| Installed package | `.augment/`, `.agent-src/` | hands-off — managed by `event4u/agent-config` |
+| Project layer | `agents/`, `agents/overrides/`, `.agent-settings.yml` | your customizations and config |
 
 ## Pointers
 
-- **Filling out this AGENTS.md** — tech-stack / dev-setup / testing / quality / project-structure templates plus `/work` + `/implement-ticket` entry flow and multi-agent matrix: [`.augment/contexts/contracts/consumer-agents-md-guide.md`](.augment/contexts/contracts/consumer-agents-md-guide.md).
+- **Filling out this AGENTS.md** — section templates, capability bullets, multi-agent entry flow, monorepo per-package layout: [`.augment/contexts/contracts/consumer-agents-md-guide.md`](.augment/contexts/contracts/consumer-agents-md-guide.md).
 - **Behavior rules (always active)** — Iron Laws and routed rules that fire automatically while you work in this project: [`.augment/rules/`](.augment/rules/).
 - **Skills (on-demand expertise)** — domain skills surfaced by description; invoked when their trigger fires: [`.augment/skills/`](.augment/skills/).
 - **Commands (workflows)** — slash-commands the agent runs end-to-end (`/work`, `/implement-ticket`, `/commit`, `/create-pr`, …): [`.augment/commands/`](.augment/commands/).

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Shared agent configuration \u2014 skills for AI coding tools (Claude Code, Augment, Cursor, Cline, Windsurf, Gemini CLI).",
-    "version": "1.29.0"
+    "version": "1.32.0"
   },
   "plugins": [
     {
@@ -22,9 +22,9 @@
         "./.claude/skills/agent-status",
         "./.claude/skills/agents",
         "./.claude/skills/agents-audit",
-        "./.claude/skills/agents-cleanup",
+        "./.claude/skills/agents-init",
         "./.claude/skills/agents-md-thin-root",
-        "./.claude/skills/agents-prepare",
+        "./.claude/skills/agents-optimize",
         "./.claude/skills/ai-council",
         "./.claude/skills/analysis-autonomous-mode",
         "./.claude/skills/analysis-skill-router",
@@ -64,10 +64,7 @@
         "./.claude/skills/context-document",
         "./.claude/skills/context-refactor",
         "./.claude/skills/conventional-commits-writing",
-        "./.claude/skills/copilot-agents",
-        "./.claude/skills/copilot-agents-init",
         "./.claude/skills/copilot-agents-optimization",
-        "./.claude/skills/copilot-agents-optimize",
         "./.claude/skills/copilot-config",
         "./.claude/skills/cost-report",
         "./.claude/skills/council",
@@ -169,7 +166,7 @@
         "./.claude/skills/onboard",
         "./.claude/skills/openapi",
         "./.claude/skills/optimize",
-        "./.claude/skills/optimize-agents",
+        "./.claude/skills/optimize-agents-dir",
         "./.claude/skills/optimize-augmentignore",
         "./.claude/skills/optimize-prompt",
         "./.claude/skills/optimize-rtk",
@@ -213,7 +210,7 @@
         "./.claude/skills/receiving-code-review",
         "./.claude/skills/refine-prompt",
         "./.claude/skills/refine-ticket",
-        "./.claude/skills/repomix",
+        "./.claude/skills/repomix-packer",
         "./.claude/skills/requesting-code-review",
         "./.claude/skills/research",
         "./.claude/skills/review-changes",

package/AGENTS.md

@@ -19,8 +19,7 @@ task ci                # full pipeline — green before PR
 - **Package self-orientation** — identity, four-wing cognition map, repo layout, tech stack, key-rules table, telemetry, command-suggester: [`docs/contracts/package-self-orientation.md`](docs/contracts/package-self-orientation.md).
 - **Kernel + Router** — 9 always-loaded Iron-Law rules, tier-1 / tier-2 routing, cost profiles, per-rule char caps enforced by `task lint-rule-budget`: [`kernel-membership`](docs/contracts/kernel-membership.md) + [`rule-router`](docs/contracts/rule-router.md).
 - **Multi-tool projection** — Augment, Claude Code, Cursor, Cline, Windsurf, Gemini CLI, Claude.ai bundle pipeline that ships from `.agent-src/` to consumer surfaces: [`docs/architecture.md`](docs/architecture.md#cloud-bundle-pipeline).
-- **Iron-Law rules when editing this repo** — portability, source-of-truth, skill-quality: [`augment-portability`](.agent-src/rules/augment-portability.md), [`augment-source-of-truth`](.agent-src/rules/augment-source-of-truth.md), [`skill-quality`](.agent-src/rules/skill-quality.md).
-- **Thin-Root contract** governing **this** file (cap, pointer ratio, emergency-triage block) — read before editing AGENTS.md: [`agents-md-thin-root`](.agent-src/skills/agents-md-thin-root/SKILL.md).
+- **Editing this repo** — Iron-Law rules (portability, source-of-truth, skill-quality) and the Thin-Root contract (caps · pointer-ratio · triage block) governing AGENTS.md: [`augment-portability`](.agent-src/rules/augment-portability.md), [`augment-source-of-truth`](.agent-src/rules/augment-source-of-truth.md), [`skill-quality`](.agent-src/rules/skill-quality.md), [`agents-md-thin-root`](.agent-src/skills/agents-md-thin-root/SKILL.md).
 - **Consumer story + architecture deep-dive** — what the package does for installers and how it ships: [`README.md`](README.md), [`docs/architecture.md`](docs/architecture.md).
 
 ## Emergency triage — read this when nothing else is reachable