@event4u/agent-config 1.31.0 → 1.32.0

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.

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/.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.31.0"
+    "version": "1.32.0"
   },
   "plugins": [
     {

package/CHANGELOG.md

@@ -318,6 +318,30 @@ our recommendation order, not its support status.
   users" tension without removing any path that an existing user
   might rely on.
 
+## [1.32.0](https://github.com/event4u-app/agent-config/compare/1.31.0...1.32.0) (2026-05-09)
+
+### Features
+
+* **roadmap:** bite-sized task granularity gate for structural roadmaps ([b23683d](https://github.com/event4u-app/agent-config/commit/b23683df15dd43229a25cad33882f6a692d92a97))
+* **skills:** add 3-scan self-review to planning skills ([6784fb8](https://github.com/event4u-app/agent-config/commit/6784fb8ad355ef5b2d7f2cebe5d5e26f114cbe4a))
+* **subagent-orchestration:** status taxonomy + externalized prompts + two-stage mode ([6d846a7](https://github.com/event4u-app/agent-config/commit/6d846a74441196b98cabf8cd1c18ca40db0cec89))
+* **skills:** TDD hardening with externalized anti-pattern catalogue ([db2b1a2](https://github.com/event4u-app/agent-config/commit/db2b1a2a550f10fa51742bef360044b9de1bb7ca))
+
+### Bug Fixes
+
+* **investigation:** inline council convergence (council files gitignored) ([ff93aa7](https://github.com/event4u-app/agent-config/commit/ff93aa7ee6f6cffff062838a644047470e1d462e))
+* **skills:** inline council convergence in anti-patterns provenance ([7d7e663](https://github.com/event4u-app/agent-config/commit/7d7e663f8e619882fd59465dfbfdb268132eeb8d))
+* **skills:** drop roadmap reference from anti-patterns provenance ([a49c010](https://github.com/event4u-app/agent-config/commit/a49c0107971a5b70a1fdf33ed1a19c91d075980a))
+
+### Chores
+
+* **ownership:** regenerate matrix after superpowers-harvest landing ([faf4794](https://github.com/event4u-app/agent-config/commit/faf479470db9c83d17e8332dd3498df1e5f4c34b))
+* **index:** regenerate after superpowers-harvest landing ([946f3cc](https://github.com/event4u-app/agent-config/commit/946f3ccad54da3a3898d0aeb4474be0b87e66800))
+* **roadmap:** remove old roadmap path (already archived) ([18f281b](https://github.com/event4u-app/agent-config/commit/18f281bbeb51e93feef40146af3a3b5e5cb916f2))
+* **roadmap:** close superpowers-harvest — Phase 1 LANDED, P1.4b deferred ([a296106](https://github.com/event4u-app/agent-config/commit/a296106c6a846a54c3fe20728203fb3bbae7fffc))
+
+Tests: 2560 (+74 since 1.31.0)
+
 ## [1.31.0](https://github.com/event4u-app/agent-config/compare/1.29.0...1.31.0) (2026-05-09)
 
 ### Features

package/docs/catalog.md

@@ -146,7 +146,7 @@ are excluded.
 | skill | [`skill-reviewer`](../.agent-src/skills/skill-reviewer/SKILL.md) |  | Use when reviewing, auditing, or optimizing skills — validates against the 7 Skill Killers checklist and produces fix recommendations. |
 | skill | [`skill-writing`](../.agent-src/skills/skill-writing/SKILL.md) |  | Use when deciding 'should this be a skill or a rule?', creating/improving/reviewing agent skills, SKILL.md frontmatter, or procedure sections — even without saying 'skill-writing'. |
 | skill | [`sql-writing`](../.agent-src/skills/sql-writing/SKILL.md) |  | Use when writing raw SQL — MariaDB/MySQL syntax, parameterization, raw migrations, seeders with `DB::statement` — even when the user just pastes a query and asks 'why is this slow' without naming SQL. |
-| skill | [`subagent-orchestration`](../.agent-src/skills/subagent-orchestration/SKILL.md) |  | Use when orchestrating implementer/judge subagents — six modes (do-and-judge, do-in-steps, do-in-parallel, do-competitively, judge-with-debate, do-in-worktrees) — models from .agent-settings.yml. |
+| skill | [`subagent-orchestration`](../.agent-src/skills/subagent-orchestration/SKILL.md) |  | Use when orchestrating implementer/judge subagents — seven modes (do-and-judge ±two-stage, do-in-steps/parallel/worktrees, do-competitively, judge-with-debate) — models from .agent-settings.yml. |
 | skill | [`systematic-debugging`](../.agent-src/skills/systematic-debugging/SKILL.md) |  | Use when hitting a bug, test failure, crash, or unexpected behavior — enforces reproduce → isolate → hypothesize → verify before any fix — even when the user just says 'this is broken' or 'quick fix'. |
 | skill | [`technical-specification`](../.agent-src/skills/technical-specification/SKILL.md) |  | Use when the user says "write a spec", "create RFC", "write a PRD", or "document this decision". Writes technical specifications, PRDs, RFCs, and ADRs with clear structure. |
 | skill | [`terraform`](../.agent-src/skills/terraform/SKILL.md) |  | Use when writing Terraform — AWS modules, resources, variables, outputs, remote state — even when the user just says 'provision this infra' or 'add an S3 bucket' without naming Terraform. |