@boyingliu01/xp-gate 0.9.4 → 0.10.0

package/mutation/runners/mutmut-runner.ts

@@ -0,0 +1,220 @@
+import { spawn, execSync } from 'child_process';
+import { writeFileSync, unlinkSync, readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import type {
+  MutationRunner,
+  RunMutationOptions,
+  MutationRunOutcome,
+  MutationRunResult,
+} from './types';
+
+/**
+ * mutmut mutation runner for Python files.
+ *
+ * Uses `mutmut run` to generate mutants and parses emoji progress output.
+ * Supports mutmut v3.x (primary) with fallback to v2.x behavior.
+ *
+ * v3.x changes (GitHub issue #339):
+ * - Removed `--paths-to-mutate` CLI flag
+ * - Uses `source_paths` in `[tool.mutmut]` section of pyproject.toml
+ * - Results stored in SQLite; `mutmut results` outputs per-mutant status lines
+ * - `mutmut run` stdout shows emoji progress: 🎉 N 🫥 N ⏰ N 🤔 N 🙁 N
+ */
+export class MutmutRunner implements MutationRunner {
+  readonly name = 'mutmut';
+  readonly extensions = ['py'];
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      execSync('mutmut --version', { stdio: 'pipe', timeout: 5000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async run(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    // Extract unique directories from file list
+    const sourceDirs = this.extractUniqueDirs(options.files);
+
+    const pyprojectPath = join(options.cwd, 'pyproject.toml');
+    const backupPath = join(options.cwd, 'pyproject.toml.xp-gate-backup');
+    let hadExisting = false;
+
+    try {
+      if (existsSync(pyprojectPath)) {
+        hadExisting = true;
+        const existing = readFileSync(pyprojectPath, 'utf-8');
+        writeFileSync(backupPath, existing, { encoding: 'utf-8' });
+      }
+      this.writeMutmutConfig(pyprojectPath, sourceDirs);
+
+      return await this.runMutmut(options);
+    } finally {
+      try {
+        if (hadExisting && existsSync(backupPath)) {
+          const backup = readFileSync(backupPath, 'utf-8');
+          writeFileSync(pyprojectPath, backup, { encoding: 'utf-8' });
+          unlinkSync(backupPath);
+        } else if (!hadExisting && existsSync(pyprojectPath)) {
+          unlinkSync(pyprojectPath);
+        }
+      } catch {
+        // Best effort cleanup
+      }
+    }
+  }
+
+  private async runMutmut(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    return new Promise((resolve) => {
+      const child = spawn('mutmut', ['run'], {
+        stdio: 'pipe',
+        shell: false,
+        cwd: options.cwd,
+      });
+
+      let stderr = '';
+      let stdout = '';
+
+      child.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        setTimeout(() => {
+          if (!child.killed) child.kill('SIGKILL');
+        }, 5000);
+      }, options.timeoutMs);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+
+        if (code === null) {
+          resolve({ report: null, timedOut: true });
+          return;
+        }
+
+        // Parse results from mutmut run stdout (v3.x emoji progress)
+        const report = this.parseEmojiProgress(stdout);
+        resolve({
+          report,
+          timedOut: false,
+          error: code !== 0 ? stderr || stdout : undefined,
+        });
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutId);
+        resolve({ report: null, timedOut: false, error: err.message });
+      });
+    });
+  }
+
+  /**
+   * Parse v3.x emoji progress line from mutmut run stdout.
+   *
+   * mutmut v3.x prints a progress summary like:
+   *   38/38  🎉 9 🫥 29  ⏰ 0  🤔 0  🙁 0  🔇 0  🧙 0
+   *
+   * Emoji mapping:
+   *   🎉 = killed
+   *   🫥 = not checked (untested)
+   *   ⏰ = timeout
+   *   🤔 = suspicious
+   *   🙁 = survived
+   *   🔇 = unknown (counted as survived)
+   *   🧙 = unknown (counted as survived)
+   */
+  private parseEmojiProgress(stdout: string): MutationRunResult | null {
+    // Find the last progress line (contains 🎉)
+    const lines = stdout.split('\n');
+    let progressLine = '';
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i].includes('🎉')) {
+        progressLine = lines[i];
+        break;
+      }
+    }
+    if (!progressLine) return null;
+
+    // Parse emoji counts: 🎉 N 🫥 N ⏰ N 🤔 N 🙁 N 🔇 N 🧙 N
+    const killed = this.extractEmojiCount(progressLine, '🎉');
+    const untested = this.extractEmojiCount(progressLine, '🫥');
+    const timeout = this.extractEmojiCount(progressLine, '⏰');
+    const suspicious = this.extractEmojiCount(progressLine, '🤔');
+    const survived = this.extractEmojiCount(progressLine, '🙁');
+    const unknown1 = this.extractEmojiCount(progressLine, '🔇');
+    const unknown2 = this.extractEmojiCount(progressLine, '🧙');
+
+    const nrOfKilledMutants = killed;
+    const nrOfSurvivedMutants =
+      survived + timeout + suspicious + untested + unknown1 + unknown2;
+    const nrOfMutants = nrOfKilledMutants + nrOfSurvivedMutants;
+
+    if (nrOfMutants === 0) return null;
+
+    return {
+      mutationScore: (nrOfKilledMutants / nrOfMutants) * 100,
+      nrOfMutants,
+      nrOfKilledMutants,
+      nrOfSurvivedMutants,
+    };
+  }
+
+  /**
+   * Extract count after an emoji in a progress line.
+   * e.g., "🎉 9" → 9
+   */
+  private extractEmojiCount(line: string, emoji: string): number {
+    const escapedEmoji = emoji.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = line.match(new RegExp(`${escapedEmoji}\\s*(\\d+)`));
+    return parseInt(match?.[1] ?? '0', 10);
+  }
+
+  /**
+   * Extract unique directories from file paths.
+   * e.g., ['src/foo.py', 'src/bar.py', 'tests/baz.py'] → ['src', 'tests']
+   */
+  private extractUniqueDirs(files: string[]): string[] {
+    const dirs = new Set<string>();
+    for (const file of files) {
+      const dir = dirname(file);
+      if (dir && dir !== '.') {
+        dirs.add(dir);
+      }
+    }
+    // If no directories found, use current directory
+    return dirs.size > 0 ? Array.from(dirs) : ['.'];
+  }
+
+  private writeMutmutConfig(pyprojectPath: string, sourceDirs: string[]): void {
+    const sourcePaths = sourceDirs.map((d) => `"${d}"`).join(', ');
+    const sourcePathsLine = `source_paths = [${sourcePaths}]`;
+
+    let content = '';
+    if (existsSync(pyprojectPath)) {
+      content = readFileSync(pyprojectPath, 'utf-8');
+      if (content.includes('[tool.mutmut]')) {
+        const sourcePathsRegex = /source_paths\s*=\s*\[.*?\]/;
+        if (sourcePathsRegex.test(content)) {
+          content = content.replace(sourcePathsRegex, sourcePathsLine);
+        } else {
+          content = content.replace(
+            '[tool.mutmut]',
+            `[tool.mutmut]\n${sourcePathsLine}`,
+          );
+        }
+      } else {
+        content = content.trimEnd() + `\n\n[tool.mutmut]\n${sourcePathsLine}\n`;
+      }
+    } else {
+      content = `[tool.mutmut]\n${sourcePathsLine}\n`;
+    }
+    writeFileSync(pyprojectPath, content, { encoding: 'utf-8' });
+  }
+}

package/mutation/runners/stryker-runner.ts

@@ -0,0 +1,146 @@
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import type {
+  MutationRunner,
+  RunMutationOptions,
+  MutationRunOutcome,
+  MutationRunResult,
+} from './types';
+
+const STRYKER_REPORT_PATH = '.stryker-report.json';
+const STRYKER_PREPUSH_CONFIG = 'stryker.prepush.conf.json';
+
+/**
+ * Stryker mutation runner for TypeScript files.
+ * Extracted from gate-m.ts to follow the LangAdapter pattern.
+ */
+export class StrykerRunner implements MutationRunner {
+  readonly name = 'Stryker';
+  readonly extensions = ['ts', 'tsx'];
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      const { spawnSync } = await import('child_process');
+      const result = spawnSync('npx', ['stryker', '--version'], {
+        stdio: 'pipe',
+        shell: false,
+        timeout: 5000,
+      });
+      return result.status !== null && result.status === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async run(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    return new Promise((resolve) => {
+      const args = [
+        'stryker',
+        'run',
+        '--config',
+        this.resolveConfig(options.cwd),
+        ...options.files.flatMap(f => ['--mutate', f]),
+      ];
+
+      const child = spawn('npx', args, {
+        stdio: 'pipe',
+        shell: false,
+        cwd: options.cwd,
+      });
+
+      let stderr = '';
+      let stdout = '';
+
+      child.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        setTimeout(() => {
+          if (!child.killed) child.kill('SIGKILL');
+        }, 5000);
+      }, options.timeoutMs);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+
+        if (code === null) {
+          resolve({ report: null, timedOut: true });
+          return;
+        }
+
+        const report = this.parseReport(options.cwd);
+        resolve({
+          report,
+          timedOut: false,
+          error: code !== 0 ? stderr || stdout : undefined,
+        });
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutId);
+        resolve({ report: null, timedOut: false, error: err.message });
+      });
+    });
+  }
+
+  private resolveConfig(cwd: string): string {
+    return join(cwd, STRYKER_PREPUSH_CONFIG);
+  }
+
+  private parseReport(cwd: string): MutationRunResult | null {
+    try {
+      const content = readFileSync(join(cwd, STRYKER_REPORT_PATH), 'utf-8');
+      return this.parseReportObject(JSON.parse(content));
+    } catch {
+      return null;
+    }
+  }
+
+  private parseReportObject(parsed: Record<string, unknown>): MutationRunResult | null {
+    const mutationScore = asNumber(parsed.mutationScore);
+    const nrOfMutants = asNumber(parsed.nrOfMutants);
+    const nrOfKilledMutants = asNumber(parsed.nrOfKilledMutants);
+    const nrOfSurvivedMutants = asNumber(parsed.nrOfSurvivedMutants);
+
+    if (isNaN(mutationScore) || isNaN(nrOfMutants)) return null;
+
+    const result: MutationRunResult = {
+      mutationScore,
+      nrOfMutants,
+      nrOfKilledMutants,
+      nrOfSurvivedMutants,
+    };
+
+    if (parsed.files && typeof parsed.files === 'object') {
+      result.files = parseFilesObject(parsed.files as Record<string, Record<string, unknown>>);
+    }
+
+    return result;
+  }
+}
+
+function asNumber(value: unknown, fallback = 0): number {
+  return typeof value === 'number' ? value : fallback;
+}
+
+function parseFilesObject(
+  filesObj: Record<string, Record<string, unknown>>
+): Record<string, { mutationScore: number; nrOfMutants: number; nrOfKilledMutants: number; nrOfSurvivedMutants: number }> {
+  const files: Record<string, { mutationScore: number; nrOfMutants: number; nrOfKilledMutants: number; nrOfSurvivedMutants: number }> = {};
+  for (const [file, data] of Object.entries(filesObj)) {
+    files[file] = {
+      mutationScore: asNumber(data.mutationScore),
+      nrOfMutants: asNumber(data.nrOfMutants),
+      nrOfKilledMutants: asNumber(data.nrOfKilledMutants),
+      nrOfSurvivedMutants: asNumber(data.nrOfSurvivedMutants),
+    };
+  }
+  return files;
+}

package/mutation/runners/types.ts

@@ -0,0 +1,99 @@
+/**
+ * Language-agnostic mutation runner interface.
+ *
+ * Each language-specific runner (Stryker for TypeScript, mutmut for Python)
+ * implements this interface so gate-m.ts can route by file extension without
+ * knowing the underlying tool.
+ */
+
+/** Normalized mutation score — all runners emit this shape. */
+export interface MutationFileReport {
+  /** Score as percentage (0–100). */
+  mutationScore: number;
+  /** Total number of mutants generated for this file. */
+  nrOfMutants: number;
+  /** Mutants killed by the test suite. */
+  nrOfKilledMutants: number;
+  /** Mutants that survived. */
+  nrOfSurvivedMutants: number;
+}
+
+/** Aggregated result from a single runner invocation. */
+export interface MutationRunResult {
+  /** Top-level normalized mutation score (0–100). */
+  mutationScore: number;
+  /** Total mutants across all processed files. */
+  nrOfMutants: number;
+  /** Total killed mutants. */
+  nrOfKilledMutants: number;
+  /** Total survived mutants. */
+  nrOfSurvivedMutants: number;
+  /** Per-file breakdown (optional; runner may not support it). */
+  files?: Record<string, MutationFileReport>;
+}
+
+/** Outcome of invoking a mutation runner. */
+export interface MutationRunOutcome {
+  /** Parsed report data. null if the run failed or timed out. */
+  report: MutationRunResult | null;
+  /** Whether the runner exceeded its timeout. */
+  timedOut: boolean;
+  /** Error message (if any). */
+  error?: string;
+}
+
+/** Parameters passed to all runners. */
+export interface RunMutationOptions {
+  /** Source files to mutate (relative paths, no test files). */
+  files: string[];
+  /** Timeout in milliseconds. */
+  timeoutMs: number;
+  /** Project root directory (for config file resolution). */
+  cwd: string;
+}
+
+/**
+ * Language-specific mutation runner.
+ *
+ * Implement this interface for each tool (Stryker, mutmut, etc.).
+ * The runner is responsible for:
+ *   1. Invoking the mutation tool with the correct CLI args.
+ *   2. Parsing tool-specific output into a normalized MutationRunResult.
+ *   3. Enforcing the timeout and returning a MutationRunOutcome.
+ *
+ * Do NOT include threshold logic, baseline comparison, or file filtering here —
+ * those are the responsibility of gate-m.ts (the orchestrator).
+ */
+export interface MutationRunner {
+  /** Human-readable name (e.g. "Stryker", "mutmut"). */
+  readonly name: string;
+
+  /** File extensions this runner handles (without dot, e.g. ["ts", "tsx"]). */
+  readonly extensions: string[];
+
+  /** Whether the tool is available on the system (quick check). */
+  isAvailable(): Promise<boolean>;
+
+  /** Run mutation testing on the given files. */
+  run(options: RunMutationOptions): Promise<MutationRunOutcome>;
+}
+
+/** Registry of runners, keyed by language name. */
+export const runnerRegistry = new Map<string, MutationRunner>();
+
+/** Register a runner so it can be resolved by file extension. */
+export function registerRunner(runner: MutationRunner): void {
+  runnerRegistry.set(runner.name, runner);
+}
+
+/**
+ * Resolve the correct runner for a given file extension.
+ * Returns undefined if no runner supports this extension.
+ */
+export function resolveRunner(ext: string): MutationRunner | undefined {
+  const normalized = ext.replace(/^\./, '');
+  for (const runner of Array.from(runnerRegistry.values())) {
+    if (runner.extensions.includes(normalized)) return runner;
+  }
+  return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"

package/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "xp-gate",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "displayName": "XP-Gate",
   "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 10 quality gates (Gate 0-9), Sprint Flow (11 phases), and Delphi multi-expert review (>=90% consensus).",
   "author": {

package/plugins/claude-code/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-06-19
-**Commit:** b67f7f9
+**Generated:** 2026-06-22
+**Commit:** 984d568
 **Branch:** main
-**Version:** 0.9.4.0
+**Version:** 0.10.0.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.

package/plugins/claude-code/skills/delphi-review/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: delphi-review
 description: "Use when asked to review a design, plan, or architecture; before implementation starts; or when multi-expert consensus is needed. Triggers: 'review this design', '评审这个需求', 'design review', '多专家评审', 'consensus review', 'code walkthrough', 'push review', 'architecture review', 'PR review', or any request for multi-expert evaluation of requirements, design docs, or PRs."
+auto_continue: true
 ---
 
 # Delphi Consensus Review
@@ -109,6 +110,39 @@ Phase 0: 准备 → Round 1: 匿名独立评审 → 共识检查
 
 **Automatic re-review**: 对于常见可控问题（措辞模糊、AC 缺失、格式问题），subagent 应自行修复后自动重评审，无需等待用户。
 
+### ⭐ 自动延续规则（MANDATORY — 防止流程卡住）
+
+当 Delphi Review 启动多轮评审（Round 2+）时，**orchestrator 必须自动延续流程，不得等待用户输入**。
+
+**触发条件**：
+- Round N 完成，但未达到终止条件（100% approved + ≥90% consensus + 所有 Critical/Major 已处理）
+- 存在待处理的背景任务（subagent  dispatched tasks）
+
+**自动延续动作**：
+1. **收集背景任务结果**：等待 `<system-reminder>` 通知后，立即调用 `background_output(task_id="bg_...")` 获取所有 subagent 输出
+2. **合成 Round N 总结**：汇总专家意见、共识度、待处理问题
+3. **自动启动 Round N+1**：立即 dispatch 新一轮 subagent 任务，携带上一轮总结作为上下文
+4. **循环直至终止**：重复步骤 1-3，直到达到终止条件
+
+**终止条件**（满足全部）：
+- ✅ 所有专家状态 = APPROVED
+- ✅ 共识度 ≥ 90%
+- ✅ 所有 Critical 级别问题已解决
+- ✅ 所有 Major 级别问题已处理（或已记录为已知问题）
+
+**例外情况**（直接输出，不进入下一轮）：
+- Round 1 即达到 100% approved + 100% consensus → 直接输出最终报告
+- 已达最大轮数（5 轮）→ 输出"未达成共识"报告，标记为 PROCESS_BLOCK
+
+**禁止行为**：
+- ❌ 询问用户"要继续吗？"
+- ❌ 等待用户手动触发 Round N+1
+- ❌ 在未达到终止条件时停止流程
+
+**错误处理**：
+- 背景任务超时（>10min）→ 标记为 TIMEOUT，输出部分结果并终止
+- 背景任务失败（subagent 错误）→ 重试 1 次，仍失败则输出错误报告并终止
+
 ---
 
 ## 修复与重新评审

package/plugins/claude-code/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-06-19
-**Commit:** b67f7f9
+**Generated:** 2026-06-22
+**Commit:** 984d568
 **Branch:** main
-**Version:** 0.9.4.0
+**Version:** 0.10.0.0
 
 ## OVERVIEW
 **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 (≥90% consensus) before any coding.

package/plugins/claude-code/skills/sprint-flow/SKILL.md

@@ -408,6 +408,58 @@ Sprint Flow: ISOLATE → AUTO-ESTIMATE → THINK → PLAN → BUILD → REVIEW
 
 ---
 
+### ⭐ Phase State Persistence（阶段状态持久化 — MANDATORY）
+
+**编排器必须在每个 Phase 完成后更新 `.sprint-state/sprint-state.json`**：
+
+1. **Phase 完成后立即更新**（每个 Phase 结束前）：
+   - `phase`: 更新为当前 Phase 编号（如 `0`, `1`, `2`...）
+   - `status`: 更新为 `"completed"`（已完成 Phase）
+   - `phase_history`: 追加新条目
+
+2. **`phase_history` 数组条目 schema**：
+   ```json
+   {
+     "phase": 0,
+     "phase_name": "THINK",
+     "status": "completed",
+     "timestamp": "2026-06-20T10:30:00Z"
+   }
+   ```
+
+3. **检查点**：
+   - `--status` 参数读取 `sprint-state.json` 并渲染进度看板
+   - TUI panel 显示当前 Phase 和历史
+   - `--resume-from` 校验 `phase_history` 中的最后完成 Phase
+
+4. **完整 sprint-state.json 示例**：
+   ```json
+   {
+     "id": "sprint-2026-06-20-01",
+     "phase": 2,
+     "status": "in_progress",
+     "phase_history": [
+       {"phase": -1, "phase_name": "ISOLATE", "status": "completed", "timestamp": "2026-06-20T10:00:00Z"},
+       {"phase": -0.5, "phase_name": "AUTO-ESTIMATE", "status": "completed", "timestamp": "2026-06-20T10:05:00Z"},
+       {"phase": 0, "phase_name": "THINK", "status": "completed", "timestamp": "2026-06-20T10:15:00Z"},
+       {"phase": 1, "phase_name": "PLAN", "status": "completed", "timestamp": "2026-06-20T10:30:00Z"}
+     ],
+     "isolation": {
+       "worktree_path": "/home/boyingliu01/projects/xp-gate/.worktrees/sprint/sprint-2026-06-20-01",
+       "branch": "sprint/2026-06-20-01"
+     },
+     "outputs": {
+       "pain_document": "phase-outputs/phase-0-summary.md",
+       "specification": "phase-outputs/specification.yaml"
+     },
+     "metrics": {
+       "coverage_pct": 85.5
+     }
+   }
+   ```
+
+---
+
 ## 使用示例
 
 | 场景 | 命令 | 说明 |
@@ -447,7 +499,7 @@ See [Output Contract](#output-contract) below for the canonical machine-readable
 
 **Phase Summary** (每个 Phase 必须输出 YAML frontmatter): `phase/N`, `phase_name`, `status`, `outputs[]`, `decisions[]`, `next_phase_context` + markdown body (≤50 lines)
 
-**Sprint State JSON**: `{id, phase, status, isolation {worktree_path, branch}, outputs, metrics}` — 存储于 `.sprint-state/sprint-state.json`
+**Sprint State JSON**: `{id, phase, status, phase_history[], isolation {worktree_path, branch}, outputs, metrics}` — 存储于 `.sprint-state/sprint-state.json`
 
 **Final User-Facing Output**: Phase/status, file paths, validation results, next user decision, PR URL or cleanup report
 

package/plugins/claude-code/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-06-19
-**Commit:** b67f7f9
+**Generated:** 2026-06-22
+**Commit:** 984d568
 **Branch:** main
-**Version:** 0.9.4.0
+**Version:** 0.10.0.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/plugins/opencode/__tests__/xp-gate-update.test.ts

@@ -15,7 +15,6 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node
 import { join } from "node:path"
 import { tmpdir, homedir } from "node:os"
 import { execSync, spawn } from "node:child_process"
-import { EventEmitter } from "node:events"
 
 // ── Pure function: semverLt ──
 
@@ -189,16 +188,6 @@ function readXpGateConfig(): { autoUpgrade?: boolean } | null {
   }
 }
 
-/**
- * Wait for a child process to close and resolve with exit code.
- */
-function waitForSpawn(child: ReturnType<typeof spawn>): Promise<number> {
-  return new Promise((resolve, reject) => {
-    child.on("close", (code) => resolve(code ?? -1))
-    child.on("error", (err) => reject(err))
-  })
-}
-
 // ── Tests ──
 
 void describe("semverLt", () => {
@@ -285,6 +274,7 @@ void describe("checkXpGateUpdate — cache & upgrade", () => {
   })
 })
 
+
 // ── UPG-002: spawn-based upgrade tests ──
 
 void describe("checkXpGateUpdate — spawn (UPG-002)", () => {

package/plugins/opencode/index.ts

@@ -150,7 +150,6 @@ function readXpGateConfig(): { autoUpgrade?: boolean } | null {
     return null
   }
 }
-
 // ── OpenCode plugin version check (notification only) ──
 
 async function checkPluginUpdate(pluginDir: string): Promise<void> {