@boyingliu01/opencode-plugin 0.8.6 → 0.8.9

package/README.md

@@ -4,9 +4,21 @@ OpenCode plugin exposing xp-gate quality gates and AI workflow skills.
 
 ## Tools
 
-- **gate-check**: Run all 6 quality gates on a file/directory
-- **gate-principles**: Run Clean Code + SOLID principles checker
-- **gate-arch**: Run architecture validation
+These three tools are **dual-surface**: callable both as OpenCode tools (from
+inside an OpenCode session) and as `xp-gate` CLI subcommands (from any shell).
+Both paths produce identical output. See repo README for the matching CLI table.
+
+- **gate-check** ⇄ `xp-gate check <path>`: Run user-invokable quality gates
+  (Gate 4 Principles + Gate 6 Architecture) on a file or directory.
+- **gate-principles** ⇄ `xp-gate principles <path>`: Run Clean Code + SOLID
+  principles checker (Gate 4 standalone).
+- **gate-arch** ⇄ `xp-gate arch`: Run architecture validation (Gate 6
+  standalone, layer boundary checks).
+
+> Earlier docs said "all 6 quality gates" — that was inaccurate. `gate-check`
+> intentionally runs only the two user-invokable gates (Principles + Arch); the
+> full 10-gate pre-commit suite (Gate 0-9) is enforced by `xp-gate init`'s git
+> hooks, not by this tool. Fixes #208.
 
 ## Installation
 
@@ -29,10 +41,14 @@ Or via local path (development):
 ## Requirements
 
 - OpenCode v0.11+
-- xp-gate npm package installed globally (for `gate-check` tool)
-- Repository with `src/principles/index.ts` (for `gate-principles` tool)
-- `architecture.yaml` in repo root (for `gate-arch` tool)
+- One of:
+  - `xp-gate` CLI installed globally (`npm install -g @boyingliu01/xp-gate`) — **preferred**, or
+  - the xp-gate repo checked out locally with `src/principles/index.ts` reachable — **fallback** (the tool will shell out via `npx -y tsx`)
+- `architecture.yaml` in repo root (for `gate-arch` only)
 
 ## Graceful Degradation
 
-If xp-gate CLI is unavailable, tools return helpful install instructions instead of failing.
+Every tool runs a chained shell-out: it first tries `xp-gate <subcommand>` and,
+only if that's not on `PATH`, falls back to invoking the underlying checker
+source directly. If both paths fail, the tool returns install instructions
+instead of throwing.

package/index.ts

@@ -1,75 +1,91 @@
 /**
  * XP-Gate OpenCode Plugin
  *
- * Exposes 3 custom tools for OpenCode users:
- *  - gate-check:      Run all xp-gate quality checks on a file or directory
- *  - gate-principles: Run Clean Code + SOLID principles checker
- *  - gate-arch:       Run architecture validation
+ * Exposes 3 OpenCode tools that mirror the equivalent `xp-gate` CLI subcommands:
+ *  - gate-check:      Run user-invokable quality gates (Gate 4 Principles + Gate 6 Arch) on a path
+ *  - gate-principles: Run Clean Code + SOLID principles checker (Gate 4 standalone)
+ *  - gate-arch:       Run architecture validation (Gate 6 standalone)
  *
- * Graceful degradation: if xp-gate CLI not installed, tools return install instructions.
+ * Dual-surface design (fixes #208): every tool is callable BOTH from inside an
+ * OpenCode session (as these tools) AND from a plain shell (as `xp-gate check`,
+ * `xp-gate principles`, `xp-gate arch`). The tools prefer the global `xp-gate`
+ * CLI when available, but fall back to running the checker source directly via
+ * `npx -y tsx` so they work even before `npm install -g @boyingliu01/xp-gate`.
  */
-import type { Plugin, PluginModule } from "@opencode-ai/plugin"
 import { tool } from "@opencode-ai/plugin"
 import { z } from "zod"
 
-export const XpGatePlugin: Plugin = async (input) => {
+interface OpenCodePluginInput {
+  directory: string
+  $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<{ text(): Promise<string> }>
+}
+
+export const XpGatePlugin = async (input: OpenCodePluginInput) => {
   const { directory, $ } = input
 
   return {
     tool: {
       "gate-check": tool({
         description:
-          "Run xp-gate quality checks on a file or directory. Requires xp-gate CLI installed globally.",
+          "Run xp-gate user-invokable quality gates (Gate 4 Principles + Gate 6 Architecture) on a file or directory. Prefers global xp-gate CLI; falls back to running checker source directly.",
         args: {
           path: z.string().describe("File or directory path (absolute or relative to workspace)"),
-          gates: z.array(z.string()).optional().describe("Optional gate subset (e.g. ['principles', 'tests'])"),
+          gates: z.array(z.string()).optional().describe("Optional gate subset (e.g. ['principles', 'arch'])"),
         },
         async execute(args, ctx) {
           const cwd = ctx.directory || directory
           const target = args.path.startsWith("/") ? args.path : `${cwd}/${args.path}`
-          const gates = args.gates?.length ? ` --gates ${args.gates.join(",")}` : ""
+          const gatesFlag = args.gates?.length ? ` --gates ${args.gates.join(",")}` : ""
+          // Prefer the installed xp-gate CLI. Fall back to invoking the same
+          // subcommand source directly via npx tsx so the tool still works in
+          // a fresh clone before `npm install -g @boyingliu01/xp-gate`.
+          const cmd = `cd "${cwd}" && (command -v xp-gate >/dev/null 2>&1 && xp-gate check "${target}"${gatesFlag} || node ${directory}/src/npm-package/bin/xp-gate.js check "${target}"${gatesFlag})`
           try {
-            const result = await $`bash -c ${`cd "${cwd}" && command -v xp-gate >/dev/null 2>&1 && xp-gate check "${target}"${gates}`}`
+            const result = await $`bash -c ${cmd}`
             const text = await result.text()
-            return text || "[XP-Gate] Check complete."
-          } catch (err: unknown) {
-            return `[XP-Gate] xp-gate CLI not found.\nInstall: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
+            return text || "[XP-Gate] Check complete (no violations)."
+          } catch (err) {
+            return `[XP-Gate] gate-check failed.\nInstall xp-gate CLI: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
           }
         },
       }),
       "gate-principles": tool({
         description:
-          "Run Clean Code + SOLID principles checker on a file.",
+          "Run Clean Code + SOLID principles checker (Gate 4 standalone) on a file or directory.",
         args: {
-          path: z.string().describe("Source file path to check"),
+          path: z.string().describe("Source file or directory path to check"),
         },
         async execute(args, ctx) {
           const cwd = ctx.directory || directory
           const target = args.path.startsWith("/") ? args.path : `${cwd}/${args.path}`
-          const cmd = `cd "${cwd}" && npx -y tsx src/principles/index.ts --files "${target}" --format console`
+          // Try xp-gate CLI first, fall back to the principles source directly.
+          const cmd = `cd "${cwd}" && (command -v xp-gate >/dev/null 2>&1 && xp-gate principles "${target}" || npx -y tsx ${directory}/src/principles/index.ts --files "${target}" --format console)`
           try {
             const result = await $`bash -c ${cmd}`
             const text = await result.text()
-            return text || "[XP-Gate] Principles check complete."
-          } catch (err: unknown) {
-            return `[XP-Gate] Principles checker failed.\nEnsure src/principles/index.ts exists.\n${err instanceof Error ? err.message : ""}`
+            return text || "[XP-Gate] Principles check complete (no violations)."
+          } catch (err) {
+            return `[XP-Gate] Principles checker failed.\nInstall xp-gate CLI: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
           }
         },
       }),
       "gate-arch": tool({
         description:
-          "Run architecture validation (layer boundary checks) on the repository.",
+          "Run architecture validation (Gate 6 standalone, layer boundary checks) on the repository.",
         args: {
           config: z.string().describe("Path to architecture config file").default("architecture.yaml"),
         },
         async execute(args, ctx) {
           const cwd = ctx.directory || directory
+          // Prefer xp-gate CLI; fall back to @archlinter/cli directly so the tool
+          // also works without xp-gate installed (matches gate-principles pattern).
+          const cmd = `cd "${cwd}" && (command -v xp-gate >/dev/null 2>&1 && xp-gate arch --config ${args.config} || npx -y @archlinter/cli scan . --config ${args.config})`
           try {
-            const result = await $`bash -c ${`cd "${cwd}" && npx archlint check --config ${args.config}`}`
+            const result = await $`bash -c ${cmd}`
             const text = await result.text()
             return text || "[XP-Gate] Architecture check complete."
-          } catch (err: unknown) {
-            return `[XP-Gate] Architecture validation requires archlint + ${args.config}.\n${err instanceof Error ? err.message : ""}`
+          } catch (err) {
+            return `[XP-Gate] Architecture validation failed.\nRequires architecture.yaml in repo root.\nInstall xp-gate CLI: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
           }
         },
       }),
@@ -77,7 +93,7 @@ export const XpGatePlugin: Plugin = async (input) => {
   }
 }
 
-const pluginModule: PluginModule = {
+const pluginModule = {
   id: "xp-gate",
   server: XpGatePlugin,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.8.6",
+  "version": "0.8.9",
   "type": "module",
   "main": "index.ts",
   "description": "XP-Gate quality gates + AI workflow skills for OpenCode",

package/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Commit:** 4517f2b
+**Generated:** 2026-06-11
+**Commit:** c18f82b
 **Branch:** main
-**Version:** v0.8.1
+**Version:** 0.8.9.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥91% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.

package/skills/sprint-flow/AGENTS.md

@@ -1,68 +1,115 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Version:** v0.8.1
+**Generated:** 2026-06-11
+**Commit:** c18f82b
+**Branch:** main
+**Version:** 0.8.9.0
 
 ## OVERVIEW
-7-phase development pipeline: THINK→PLAN→BUILD→REVIEW→USER ACCEPT→FEEDBACK→SHIP, with ralph-loop default build mode.
+**11-phase** development pipeline: ISOLATE → AUTO-ESTIMATE → THINK → PLAN → BUILD → REVIEW → USER ACCEPTANCE → FEEDBACK → SHIP → LAND → CLEANUP. Phase 2 default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE in Phase 1: design must pass Delphi review (≥91% consensus) before any coding.
+
+> **Doc drift**: README/CAPABILITIES still describe a "7-phase" pipeline. The canonical 11-phase model lives in `SKILL.md` and is what actually executes. See root `AGENTS.md` → "Known Drift" #4.
 
 ## STRUCTURE
 ```
 skills/sprint-flow/
-├── SKILL.md              # 7-phase pipeline definition
+├── SKILL.md              # 11-phase pipeline definition (canonical)
+├── AGENTS.md             # This file (mirrored to 7 other locations — DO NOT edit mirrors)
 ├── evals/                # Evaluation test cases
-├── evolution-history.json # Skill evolution tracking
-├── evolution-log.md      # Change history
-├── references/           # Phase reference docs
-│   ├── phase-0-think.md  # THINK phase guidelines
-│   └── ...               # Other phase docs
-└── templates/            # Sprint templates
+├── evolution-history.json
+├── evolution-log.md
+├── references/
+│   ├── phase-minus-0-5-auto-estimate.md  # Phase -0.5: AUTO-ESTIMATE
+│   ├── phase-0-think.md                   # Phase 0: brainstorming → CONTEXT.md + ADR
+│   ├── phase-1-plan.md                    # Phase 1: autoplan + delphi-review (HARD-GATE)
+│   ├── phase-2-build.md                   # Phase 2: ralph-loop default + TDD + test-align
+│   ├── phase-3-review.md                  # Phase 3: code-walkthrough + QA + benchmark
+│   ├── phase-4-uat.md                     # Phase 4: USER ACCEPTANCE
+│   ├── phase-5-feedback.md                # Phase 5: retro + debugging + learn
+│   ├── phase-6-ship.md                    # Phase 6: finishing-dev-branch + PR
+│   ├── phase-7-land.md                    # Phase 7: land + deploy
+│   ├── phase-8-cleanup.md                 # Phase 8: sprint branch cleanup
+│   ├── force-levels.md                    # Phase forcing rules
+│   └── components/                        # Reusable phase building blocks
+└── templates/
+    ├── auto-estimate-output-template.md
+    ├── auto-estimate-learning-log.md
+    ├── pain-document-template.md
+    ├── sprint-progress-template.md
+    ├── sprint-summary-template.md
+    └── emergent-issues-template.md
 ```
 
 ## WHERE TO LOOK
 | Task | Location | Notes |
 |------|----------|-------|
-| Pipeline def | SKILL.md | 7 phases with hard gates |
+| Pipeline definition | SKILL.md | 11 phases with HARD-GATE between Phase 1 and Phase 2 |
+| Auto-estimate phase | references/phase-minus-0-5-auto-estimate.md | Sizing pass before THINK |
 | THINK phase | references/phase-0-think.md | brainstorming → CONTEXT.md + ADR |
-| Build mode | SKILL.md | ralph-loop (default) vs parallel |
+| PLAN phase + HARD-GATE | references/phase-1-plan.md | autoplan → delphi-review → specification.yaml |
+| BUILD phase | references/phase-2-build.md | ralph-loop (default) vs parallel |
+| Force-level rules | references/force-levels.md | Defines when each phase becomes mandatory |
+| Templates | templates/ | Auto-estimate, sprint progress/summary, pain doc, emergent issues |
+
+## THE 11 PHASES
 
-## 7 PHASES
 | Phase | Name | Key Action | Hard Gate |
 |-------|------|-----------|-----------|
-| 0 | THINK | brainstorming, CONTEXT.md, ADR | — |
-| 1 | PLAN | autoplan → delphi-review → specification.yaml | HARD-GATE: design must pass |
-| 2 | BUILD | ralph-loop (REQ-level iteration) + TDD + test-align | — |
+| -1 | ISOLATE | Isolate working tree / worktree creation | — |
+| -0.5 | AUTO-ESTIMATE | Sizing pass; emits estimate template | — |
+| 0 | THINK | brainstorming → CONTEXT.md + ADR | — |
+| 1 | PLAN | autoplan → delphi-review → specification.yaml | **HARD-GATE**: design must reach ≥91% Delphi consensus |
+| 2 | BUILD | ralph-loop (REQ-level, default) + TDD + test-spec-alignment | — |
 | 3 | REVIEW | code-walkthrough + QA + benchmark | — |
-| 4 | USER ACCEPT | Manual verification | — |
-| 5 | FEEDBACK | Retro + debugging + learn | — |
-| 6 | SHIP | finishing-dev-branch + PR/merge | — |
+| 4 | USER ACCEPTANCE | Manual verification | — |
+| 5 | FEEDBACK | retro + debugging + `learn` (Sprint-level) | — |
+| 6 | SHIP | finishing-a-development-branch → PR | — |
+| 7 | LAND | land + deploy + canary | — |
+| 8 | CLEANUP | Sprint branch cleanup (per `docs/plans/2026-06-06-sprint-branch-cleanup-design.md`) | — |
 
 ## CONVENTIONS
-- ralph-loop is Phase 2 **default** mode (saves 40-67% tokens vs parallel)
-- delphi-review HARD-GATE in Phase 1: design unapproved → BLOCK coding
-- Each REQ in ralph-loop gets clean context (no linear accumulation)
-- `learn` called at Phase 5 + each REQ completion
+- **ralph-loop is Phase 2 default**. Each REQ runs in a clean context (no linear accumulation), saving 40-67% tokens vs parallel mode.
+- **delphi-review HARD-GATE in Phase 1**: design must reach ≥91% consensus across ≥2 model providers, domestic models only. Unapproved → BLOCK coding.
+- **`learn` is called twice**: once per REQ in Phase 2 (ralph-loop internal, `progress.log` permanent/contextual classification) and once in Phase 5 (Sprint-level retro).
+- **Phase isolation**: each phase has explicit entry/exit criteria documented in its `references/phase-*.md` file.
+- **Emergent Requirements** discovered in Phase 4 (USER ACCEPTANCE) are explicitly captured via `templates/emergent-issues-template.md` — never silently merged.
+- **Auto-detection**: Phase 0 uses `src/npm-package/lib/ui-detector.ts` to pick the right tech-stack templates.
 
 ## ANTI-PATTERNS (THIS PROJECT)
-- Do NOT skip delphi-review in Phase 1 — HARD-GATE blocks implementation
-- Do NOT use parallel build mode unless explicitly requested
-- Do NOT enter Phase 1 (PLAN) without completing THINK phase
-- DO NOT implement before design approval
+- Do NOT skip `delphi-review` in Phase 1 — HARD-GATE blocks implementation.
+- Do NOT use parallel build mode unless explicitly requested. Ralph-loop is the default for a reason.
+- Do NOT enter Phase 1 (PLAN) without completing Phase 0 (THINK).
+- Do NOT implement before design is APPROVED — Phase 1 must reach Delphi consensus first.
+- Do NOT merge an Emergent Requirement into the original Sprint silently — capture it via the template.
+- Do NOT terminate Delphi review before ≥91% consensus or 5 rounds, whichever first.
 
 ## UNIQUE STYLES
-- Auto-detects UI framework (ui-detector.ts in npm-package/lib/)
-- Supports --type and --lang flags for tech stack selection
-- Phase isolation: each phase has specific entry/exit criteria
-- Emergent Requirements acknowledged: user acceptance phase built in
+- **11 phases** including negative-numbered pre-phases (-1, -0.5) — intentional, captures the work that happens before "real" coding starts.
+- **HARD-GATE** between PLAN and BUILD is enforced both in the SKILL.md instructions and in the Claude Code plugin's PreToolUse hook (`plugins/claude-code/bin/delphi-review-guard.sh`).
+- **Per-REQ clean context in ralph-loop** = the core efficiency mechanism. Sprint-flow specifically chooses this over parallel mode.
+- **Tech-stack auto-detection** via `--type` and `--lang` flags or `ui-detector.ts`.
 
 ## COMMANDS
 ```bash
+/sprint-flow "开发用户登录"                                     # Full 11-phase pipeline
+/sprint-flow "开发用户登录" --type web-nextjs --lang typescript # Pin tech stack
+/sprint-flow "开发用户登录" --phase build-only                  # Skip planning (advanced)
+/sprint-flow "开发用户登录" --mode parallel                     # Legacy all-at-once (NOT default)
 /delphi-review "开发用户登录" --type web-nextjs --lang typescript
-/sprint-flow "开发用户登录" --phase build-only
-/sprint-flow "开发用户登录" --mode parallel  # Legacy all-at-once
 ```
 
 ## NOTES
-- Integrates brainstorming, autoplan, delphi-review, TDD, test-specification-alignment
-- ralph-loop internal learnings via progress.log (permanent/contextual classification)
-- Phase 5 calls gstack/learn for Sprint-level retrospective
+- Integrates: brainstorming, autoplan, delphi-review, TDD, test-specification-alignment, qa, design-review, benchmark, systematic-debugging, retro, learn, finishing-a-development-branch.
+- ralph-loop's internal learnings are persisted via `progress.log` (permanent vs contextual classification).
+- Phase 5 calls `gstack/learn` for Sprint-level retrospective.
+- Phase 8 cleanup behavior is governed by `docs/plans/2026-06-06-sprint-branch-cleanup-design.md`.
+- This `AGENTS.md` is the canonical version. **7 byte-identical mirrors** exist at:
+  - `plugins/claude-code/skills/sprint-flow/AGENTS.md`
+  - `plugins/opencode/skills/sprint-flow/AGENTS.md`
+  - `plugins/qoder/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/plugins/claude-code/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/plugins/opencode/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/plugins/qoder/skills/sprint-flow/AGENTS.md`
+  Mirrors are updated by `scripts/copy-skills.sh`. Do NOT edit them by hand.
+

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

@@ -1,71 +1,371 @@
 ---
 name: test-driven-development
-description: >
-  Test-Driven Development enforcement: RED → GREEN → REFACTOR cycle.
-  Write failing test first, then minimum code to pass, then refactor.
-  Includes Mock Usage Guidelines for integration-first testing.
-
-maturity: stable
+description: Use when implementing any feature or bugfix, before writing implementation code
 ---
 
-# Test-Driven Development
+# Test-Driven Development (TDD)
+
+## Overview
+
+Write the test first. Watch it fail. Write minimal code to pass.
+
+**Core principle:** If you didn't watch the test fail, you don't know if it tests the right thing.
+
+**Violating the letter of the rules is violating the spirit of the rules.**
+
+## When to Use
+
+**Always:**
+- New features
+- Bug fixes
+- Refactoring
+- Behavior changes
+
+**Exceptions (ask your human partner):**
+- Throwaway prototypes
+- Generated code
+- Configuration files
+
+Thinking "skip TDD just this once"? Stop. That's rationalization.
+
+## The Iron Law
+
+```
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+Write code before the test? Delete it. Start over.
+
+**No exceptions:**
+- Don't keep it as "reference"
+- Don't "adapt" it while writing tests
+- Don't look at it
+- Delete means delete
+
+Implement fresh from tests. Period.
+
+## Red-Green-Refactor
+
+```dot
+digraph tdd_cycle {
+    rankdir=LR;
+    red [label="RED\nWrite failing test", shape=box, style=filled, fillcolor="#ffcccc"];
+    verify_red [label="Verify fails\ncorrectly", shape=diamond];
+    green [label="GREEN\nMinimal code", shape=box, style=filled, fillcolor="#ccffcc"];
+    verify_green [label="Verify passes\nAll green", shape=diamond];
+    refactor [label="REFACTOR\nClean up", shape=box, style=filled, fillcolor="#ccccff"];
+    next [label="Next", shape=ellipse];
 
-## Core Principles
+    red -> verify_red;
+    verify_red -> green [label="yes"];
+    verify_red -> red [label="wrong\nfailure"];
+    green -> verify_green;
+    verify_green -> refactor [label="yes"];
+    verify_green -> green [label="no"];
+    refactor -> verify_green [label="stay\ngreen"];
+    verify_green -> next;
+    next -> red;
+}
+```
+
+### RED - Write Failing Test
+
+Write one minimal test showing what should happen.
 
-| Principle | Description |
-|-----------|-------------|
-| **RED First** | Write a failing test before ANY implementation code |
-| **GREEN Minimum** | Write minimum code to pass the test — no extra features |
-| **REFACTOR** | Clean up code while keeping tests green |
-| **Delete & Restart** | If you write code before test — delete it and start over |
+<Good>
+```typescript
+test('retries failed operations 3 times', async () => {
+  let attempts = 0;
+  const operation = () => {
+    attempts++;
+    if (attempts < 3) throw new Error('fail');
+    return 'success';
+  };
 
-## Workflow
+  const result = await retryOperation(operation);
 
+  expect(result).toBe('success');
+  expect(attempts).toBe(3);
+});
 ```
-1. RED: Write failing test (describe/it + expect)
-2. GREEN: Write minimum implementation to pass
-3. REFACTOR: Clean up, extract, simplify — tests stay green
-4. Repeat for next behavior
+Clear name, tests real behavior, one thing
+</Good>
+
+<Bad>
+```typescript
+test('retry works', async () => {
+  const mock = jest.fn()
+    .mockRejectedValueOnce(new Error())
+    .mockRejectedValueOnce(new Error())
+    .mockResolvedValueOnce('success');
+  await retryOperation(mock);
+  expect(mock).toHaveBeenCalledTimes(3);
+});
 ```
+Vague name, tests mock not code
+</Bad>
+
+**Requirements:**
+- One behavior
+- Clear name
+- Real code (no mocks unless unavoidable)
+
+### Verify RED - Watch It Fail
+
+**MANDATORY. Never skip.**
+
+```bash
+npm test path/to/test.test.ts
+```
+
+Confirm:
+- Test fails (not errors)
+- Failure message is expected
+- Fails because feature missing (not typos)
+
+**Test passes?** You're testing existing behavior. Fix test.
+
+**Test errors?** Fix error, re-run until it fails correctly.
+
+### GREEN - Minimal Code
+
+Write simplest code to pass the test.
+
+<Good>
+```typescript
+async function retryOperation<T>(fn: () => Promise<T>): Promise<T> {
+  for (let i = 0; i < 3; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (i === 2) throw e;
+    }
+  }
+  throw new Error('unreachable');
+}
+```
+Just enough to pass
+</Good>
+
+<Bad>
+```typescript
+async function retryOperation<T>(
+  fn: () => Promise<T>,
+  options?: {
+    maxRetries?: number;
+    backoff?: 'linear' | 'exponential';
+    onRetry?: (attempt: number) => void;
+  }
+): Promise<T> {
+  // YAGNI
+}
+```
+Over-engineered
+</Bad>
+
+Don't add features, refactor other code, or "improve" beyond the test.
+
+### Verify GREEN - Watch It Pass
+
+**MANDATORY.**
+
+```bash
+npm test path/to/test.test.ts
+```
+
+Confirm:
+- Test passes
+- Other tests still pass
+- Output pristine (no errors, warnings)
+
+**Test fails?** Fix code, not test.
 
-## Mock Usage Guidelines (MANDATORY)
+**Other tests fail?** Fix now.
 
-### When to use mocks (ONLY these cases):
-1. External API/HTTP calls — use testcontainers or nock
-2. Database I/O — use in-memory DB (sqlite, testcontainers)
-3. File system I/O — use tmpdir / memfs
-4. Time-dependent code — inject clock dependency
-5. Non-deterministic behavior (random, UUID) — inject dependency
+### REFACTOR - Clean Up
 
-### When NOT to use mocks:
-- Pure business logic → test with real values
-- In-memory data transformations → test with real data
-- Validation logic → test with real input/output
-- State machines → test with real state transitions
+After green only:
+- Remove duplication
+- Improve names
+- Extract helpers
 
-### Mock Density Rule:
-If > 30% of test lines contain mock/spy/fn references,
-you are likely over-mocking. Add `// @mock-justified: <reason>` comment
-explaining why integration test is not feasible.
+Keep tests green. Don't add behavior.
 
-### Annotation Format:
+### Repeat
+
+Next failing test for next feature.
+
+## Good Tests
+
+| Quality | Good | Bad |
+|---------|------|-----|
+| **Minimal** | One thing. "and" in name? Split it. | `test('validates email and domain and whitespace')` |
+| **Clear** | Name describes behavior | `test('test1')` |
+| **Shows intent** | Demonstrates desired API | Obscures what code should do |
+
+## Why Order Matters
+
+**"I'll write tests after to verify it works"**
+
+Tests written after code pass immediately. Passing immediately proves nothing:
+- Might test wrong thing
+- Might test implementation, not behavior
+- Might miss edge cases you forgot
+- You never saw it catch the bug
+
+Test-first forces you to see the test fail, proving it actually tests something.
+
+**"I already manually tested all the edge cases"**
+
+Manual testing is ad-hoc. You think you tested everything but:
+- No record of what you tested
+- Can't re-run when code changes
+- Easy to forget cases under pressure
+- "It worked when I tried it" ≠ comprehensive
+
+Automated tests are systematic. They run the same way every time.
+
+**"Deleting X hours of work is wasteful"**
+
+Sunk cost fallacy. The time is already gone. Your choice now:
+- Delete and rewrite with TDD (X more hours, high confidence)
+- Keep it and add tests after (30 min, low confidence, likely bugs)
+
+The "waste" is keeping code you can't trust. Working code without real tests is technical debt.
+
+**"TDD is dogmatic, being pragmatic means adapting"**
+
+TDD IS pragmatic:
+- Finds bugs before commit (faster than debugging after)
+- Prevents regressions (tests catch breaks immediately)
+- Documents behavior (tests show how to use code)
+- Enables refactoring (change freely, tests catch breaks)
+
+"Pragmatic" shortcuts = debugging in production = slower.
+
+**"Tests after achieve the same goals - it's spirit not ritual"**
+
+No. Tests-after answer "What does this do?" Tests-first answer "What should this do?"
+
+Tests-after are biased by your implementation. You test what you built, not what's required. You verify remembered edge cases, not discovered ones.
+
+Tests-first force edge case discovery before implementing. Tests-after verify you remembered everything (you didn't).
+
+30 minutes of tests after ≠ TDD. You get coverage, lose proof tests work.
+
+## Common Rationalizations
+
+| Excuse | Reality |
+|--------|---------|
+| "Too simple to test" | Simple code breaks. Test takes 30 seconds. |
+| "I'll test after" | Tests passing immediately prove nothing. |
+| "Tests after achieve same goals" | Tests-after = "what does this do?" Tests-first = "what should this do?" |
+| "Already manually tested" | Ad-hoc ≠ systematic. No record, can't re-run. |
+| "Deleting X hours is wasteful" | Sunk cost fallacy. Keeping unverified code is technical debt. |
+| "Keep as reference, write tests first" | You'll adapt it. That's testing after. Delete means delete. |
+| "Need to explore first" | Fine. Throw away exploration, start with TDD. |
+| "Test hard = design unclear" | Listen to test. Hard to test = hard to use. |
+| "TDD will slow me down" | TDD faster than debugging. Pragmatic = test-first. |
+| "Manual test faster" | Manual doesn't prove edge cases. You'll re-test every change. |
+| "Existing code has no tests" | You're improving it. Add tests for existing code. |
+
+## Red Flags - STOP and Start Over
+
+- Code before test
+- Test after implementation
+- Test passes immediately
+- Can't explain why test failed
+- Tests added "later"
+- Rationalizing "just this once"
+- "I already manually tested it"
+- "Tests after achieve the same purpose"
+- "It's about spirit not ritual"
+- "Keep as reference" or "adapt existing code"
+- "Already spent X hours, deleting is wasteful"
+- "TDD is dogmatic, I'm being pragmatic"
+- "This is different because..."
+
+**All of these mean: Delete code. Start over with TDD.**
+
+## Example: Bug Fix
+
+**Bug:** Empty email accepted
+
+**RED**
 ```typescript
-// @mock-justified: external API wrapper, no sandbox environment available
+test('rejects empty email', async () => {
+  const result = await submitForm({ email: '' });
+  expect(result.error).toBe('Email required');
+});
 ```
-Reason text must be at least 10 characters. Bare `@mock-justified` without colon+reason is invalid.
 
-## Test Annotations
+**Verify RED**
+```bash
+$ npm test
+FAIL: expected 'Email required', got undefined
+```
 
+**GREEN**
 ```typescript
-/**
- * @test REQ-XXX Feature name
- * @intent Verify specific behavior
- * @covers AC-XXX-01, AC-XXX-02
- */
+function submitForm(data: FormData) {
+  if (!data.email?.trim()) {
+    return { error: 'Email required' };
+  }
+  // ...
+}
 ```
 
-## Coverage Requirements
+**Verify GREEN**
+```bash
+$ npm test
+PASS
+```
+
+**REFACTOR**
+Extract validation for multiple fields if needed.
+
+## Verification Checklist
+
+Before marking work complete:
+
+- [ ] Every new function/method has a test
+- [ ] Watched each test fail before implementing
+- [ ] Each test failed for expected reason (feature missing, not typo)
+- [ ] Wrote minimal code to pass each test
+- [ ] All tests pass
+- [ ] Output pristine (no errors, warnings)
+- [ ] Tests use real code (mocks only if unavoidable)
+- [ ] Edge cases and errors covered
+
+Can't check all boxes? You skipped TDD. Start over.
+
+## When Stuck
+
+| Problem | Solution |
+|---------|----------|
+| Don't know how to test | Write wished-for API. Write assertion first. Ask your human partner. |
+| Test too complicated | Design too complicated. Simplify interface. |
+| Must mock everything | Code too coupled. Use dependency injection. |
+| Test setup huge | Extract helpers. Still complex? Simplify design. |
+
+## Debugging Integration
+
+Bug found? Write failing test reproducing it. Follow TDD cycle. Test proves fix and prevents regression.
+
+Never fix bugs without a test.
+
+## Testing Anti-Patterns
+
+When adding mocks or test utilities, read @testing-anti-patterns.md to avoid common pitfalls:
+- Testing mock behavior instead of real behavior
+- Adding test-only methods to production classes
+- Mocking without understanding dependencies
+
+## Final Rule
+
+```
+Production code → test exists and failed first
+Otherwise → not TDD
+```
 
-- Minimum 80% line coverage
-- All acceptance criteria must have corresponding tests
-- Tests must survive mutation testing (Gate M pre-push)
+No exceptions without your human partner's permission.

package/skills/test-driven-development/testing-anti-patterns.md

@@ -0,0 +1,299 @@
+# Testing Anti-Patterns
+
+**Load this reference when:** writing or changing tests, adding mocks, or tempted to add test-only methods to production code.
+
+## Overview
+
+Tests must verify real behavior, not mock behavior. Mocks are a means to isolate, not the thing being tested.
+
+**Core principle:** Test what the code does, not what the mocks do.
+
+**Following strict TDD prevents these anti-patterns.**
+
+## The Iron Laws
+
+```
+1. NEVER test mock behavior
+2. NEVER add test-only methods to production classes
+3. NEVER mock without understanding dependencies
+```
+
+## Anti-Pattern 1: Testing Mock Behavior
+
+**The violation:**
+```typescript
+// ❌ BAD: Testing that the mock exists
+test('renders sidebar', () => {
+  render(<Page />);
+  expect(screen.getByTestId('sidebar-mock')).toBeInTheDocument();
+});
+```
+
+**Why this is wrong:**
+- You're verifying the mock works, not that the component works
+- Test passes when mock is present, fails when it's not
+- Tells you nothing about real behavior
+
+**your human partner's correction:** "Are we testing the behavior of a mock?"
+
+**The fix:**
+```typescript
+// ✅ GOOD: Test real component or don't mock it
+test('renders sidebar', () => {
+  render(<Page />);  // Don't mock sidebar
+  expect(screen.getByRole('navigation')).toBeInTheDocument();
+});
+
+// OR if sidebar must be mocked for isolation:
+// Don't assert on the mock - test Page's behavior with sidebar present
+```
+
+### Gate Function
+
+```
+BEFORE asserting on any mock element:
+  Ask: "Am I testing real component behavior or just mock existence?"
+
+  IF testing mock existence:
+    STOP - Delete the assertion or unmock the component
+
+  Test real behavior instead
+```
+
+## Anti-Pattern 2: Test-Only Methods in Production
+
+**The violation:**
+```typescript
+// ❌ BAD: destroy() only used in tests
+class Session {
+  async destroy() {  // Looks like production API!
+    await this._workspaceManager?.destroyWorkspace(this.id);
+    // ... cleanup
+  }
+}
+
+// In tests
+afterEach(() => session.destroy());
+```
+
+**Why this is wrong:**
+- Production class polluted with test-only code
+- Dangerous if accidentally called in production
+- Violates YAGNI and separation of concerns
+- Confuses object lifecycle with entity lifecycle
+
+**The fix:**
+```typescript
+// ✅ GOOD: Test utilities handle test cleanup
+// Session has no destroy() - it's stateless in production
+
+// In test-utils/
+export async function cleanupSession(session: Session) {
+  const workspace = session.getWorkspaceInfo();
+  if (workspace) {
+    await workspaceManager.destroyWorkspace(workspace.id);
+  }
+}
+
+// In tests
+afterEach(() => cleanupSession(session));
+```
+
+### Gate Function
+
+```
+BEFORE adding any method to production class:
+  Ask: "Is this only used by tests?"
+
+  IF yes:
+    STOP - Don't add it
+    Put it in test utilities instead
+
+  Ask: "Does this class own this resource's lifecycle?"
+
+  IF no:
+    STOP - Wrong class for this method
+```
+
+## Anti-Pattern 3: Mocking Without Understanding
+
+**The violation:**
+```typescript
+// ❌ BAD: Mock breaks test logic
+test('detects duplicate server', () => {
+  // Mock prevents config write that test depends on!
+  vi.mock('ToolCatalog', () => ({
+    discoverAndCacheTools: vi.fn().mockResolvedValue(undefined)
+  }));
+
+  await addServer(config);
+  await addServer(config);  // Should throw - but won't!
+});
+```
+
+**Why this is wrong:**
+- Mocked method had side effect test depended on (writing config)
+- Over-mocking to "be safe" breaks actual behavior
+- Test passes for wrong reason or fails mysteriously
+
+**The fix:**
+```typescript
+// ✅ GOOD: Mock at correct level
+test('detects duplicate server', () => {
+  // Mock the slow part, preserve behavior test needs
+  vi.mock('MCPServerManager'); // Just mock slow server startup
+
+  await addServer(config);  // Config written
+  await addServer(config);  // Duplicate detected ✓
+});
+```
+
+### Gate Function
+
+```
+BEFORE mocking any method:
+  STOP - Don't mock yet
+
+  1. Ask: "What side effects does the real method have?"
+  2. Ask: "Does this test depend on any of those side effects?"
+  3. Ask: "Do I fully understand what this test needs?"
+
+  IF depends on side effects:
+    Mock at lower level (the actual slow/external operation)
+    OR use test doubles that preserve necessary behavior
+    NOT the high-level method the test depends on
+
+  IF unsure what test depends on:
+    Run test with real implementation FIRST
+    Observe what actually needs to happen
+    THEN add minimal mocking at the right level
+
+  Red flags:
+    - "I'll mock this to be safe"
+    - "This might be slow, better mock it"
+    - Mocking without understanding the dependency chain
+```
+
+## Anti-Pattern 4: Incomplete Mocks
+
+**The violation:**
+```typescript
+// ❌ BAD: Partial mock - only fields you think you need
+const mockResponse = {
+  status: 'success',
+  data: { userId: '123', name: 'Alice' }
+  // Missing: metadata that downstream code uses
+};
+
+// Later: breaks when code accesses response.metadata.requestId
+```
+
+**Why this is wrong:**
+- **Partial mocks hide structural assumptions** - You only mocked fields you know about
+- **Downstream code may depend on fields you didn't include** - Silent failures
+- **Tests pass but integration fails** - Mock incomplete, real API complete
+- **False confidence** - Test proves nothing about real behavior
+
+**The Iron Rule:** Mock the COMPLETE data structure as it exists in reality, not just fields your immediate test uses.
+
+**The fix:**
+```typescript
+// ✅ GOOD: Mirror real API completeness
+const mockResponse = {
+  status: 'success',
+  data: { userId: '123', name: 'Alice' },
+  metadata: { requestId: 'req-789', timestamp: 1234567890 }
+  // All fields real API returns
+};
+```
+
+### Gate Function
+
+```
+BEFORE creating mock responses:
+  Check: "What fields does the real API response contain?"
+
+  Actions:
+    1. Examine actual API response from docs/examples
+    2. Include ALL fields system might consume downstream
+    3. Verify mock matches real response schema completely
+
+  Critical:
+    If you're creating a mock, you must understand the ENTIRE structure
+    Partial mocks fail silently when code depends on omitted fields
+
+  If uncertain: Include all documented fields
+```
+
+## Anti-Pattern 5: Integration Tests as Afterthought
+
+**The violation:**
+```
+✅ Implementation complete
+❌ No tests written
+"Ready for testing"
+```
+
+**Why this is wrong:**
+- Testing is part of implementation, not optional follow-up
+- TDD would have caught this
+- Can't claim complete without tests
+
+**The fix:**
+```
+TDD cycle:
+1. Write failing test
+2. Implement to pass
+3. Refactor
+4. THEN claim complete
+```
+
+## When Mocks Become Too Complex
+
+**Warning signs:**
+- Mock setup longer than test logic
+- Mocking everything to make test pass
+- Mocks missing methods real components have
+- Test breaks when mock changes
+
+**your human partner's question:** "Do we need to be using a mock here?"
+
+**Consider:** Integration tests with real components often simpler than complex mocks
+
+## TDD Prevents These Anti-Patterns
+
+**Why TDD helps:**
+1. **Write test first** → Forces you to think about what you're actually testing
+2. **Watch it fail** → Confirms test tests real behavior, not mocks
+3. **Minimal implementation** → No test-only methods creep in
+4. **Real dependencies** → You see what the test actually needs before mocking
+
+**If you're testing mock behavior, you violated TDD** - you added mocks without watching test fail against real code first.
+
+## Quick Reference
+
+| Anti-Pattern | Fix |
+|--------------|-----|
+| Assert on mock elements | Test real component or unmock it |
+| Test-only methods in production | Move to test utilities |
+| Mock without understanding | Understand dependencies first, mock minimally |
+| Incomplete mocks | Mirror real API completely |
+| Tests as afterthought | TDD - tests first |
+| Over-complex mocks | Consider integration tests |
+
+## Red Flags
+
+- Assertion checks for `*-mock` test IDs
+- Methods only called in test files
+- Mock setup is >50% of test
+- Test fails when you remove mock
+- Can't explain why mock is needed
+- Mocking "just to be safe"
+
+## The Bottom Line
+
+**Mocks are tools to isolate, not things to test.**
+
+If TDD reveals you're testing mock behavior, you've gone wrong.
+
+Fix: Test real behavior or question why you're mocking at all.

package/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Commit:** 4517f2b
+**Generated:** 2026-06-11
+**Commit:** c18f82b
 **Branch:** main
-**Version:** v0.8.1
+**Version:** 0.8.9.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.