@boyingliu01/xp-gate 0.10.2 → 0.10.4

package/mutation/__tests__/go-mutant-runner.test.ts

@@ -0,0 +1,288 @@
+/**
+ * @test REQ-MUT-005 Go mutation runner
+ * @intent Verify GoMutantRunner registration, availability checks, and JSON report parsing
+ * @covers AC-MUT-005, AC-MUT-006
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { spawn, spawnSync, type ChildProcess } from 'child_process';
+import { writeFileSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  spawnSync: vi.fn(),
+}));
+
+describe('GoMutantRunner', () => {
+  let GoMutantRunner: typeof import('../runners/go-mutant-runner').GoMutantRunner;
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    tmpDir = join(tmpdir(), `xp-gate-go-test-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+    GoMutantRunner = (await import('../runners/go-mutant-runner')).GoMutantRunner;
+  });
+
+  afterEach(() => {
+    try { process.kill(process.pid, 0); } catch { /* noop */ }
+  });
+
+  describe('name and extensions', () => {
+    it('should have name "gomutants"', () => {
+      const runner = new GoMutantRunner();
+      expect(runner.name).toBe('gomutants');
+    });
+
+    it('should handle .go extension', () => {
+      const runner = new GoMutantRunner();
+      expect(runner.extensions).toContain('go');
+      expect(runner.extensions).not.toContain('ts');
+      expect(runner.extensions).not.toContain('py');
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return true when gomutants is installed', async () => {
+      vi.mocked(spawnSync).mockReturnValue({
+        status: 0,
+        output: [],
+        pid: 0,
+        signal: null,
+      } as unknown as ReturnType<typeof spawnSync>);
+
+      const runner = new GoMutantRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(true);
+      expect(spawnSync).toHaveBeenCalledWith('gomutants', ['--version'], {
+        stdio: 'pipe',
+        timeout: 5000,
+      });
+    });
+
+    it('should return false when gomutants is not installed', async () => {
+      vi.mocked(spawnSync).mockReturnValue({
+        status: 1,
+        output: [],
+        pid: 0,
+        signal: null,
+      } as unknown as ReturnType<typeof spawnSync>);
+
+      const runner = new GoMutantRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(false);
+    });
+
+    it('should return false when spawnSync throws', async () => {
+      vi.mocked(spawnSync).mockImplementation(() => {
+        throw new Error('ENOENT');
+      });
+
+      const runner = new GoMutantRunner();
+      const result = await runner.isAvailable();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('run', () => {
+    it('should spawn gomutants with correct args', async () => {
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      writeFileSync(join(tmpDir, '.gomutants-report.json'), JSON.stringify({
+        test_efficacy: 80,
+        mutants_total: 10,
+        mutants_killed: 8,
+        mutants_lived: 2,
+        mutants_not_viable: 0,
+        mutants_not_covered: 0,
+      }));
+
+      const runner = new GoMutantRunner();
+      const promise = runner.run({
+        files: ['src/main.go'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(spawn).toHaveBeenCalledWith('gomutants', [
+        '--output',
+        expect.stringContaining('.gomutants-report.json'),
+        '--quiet',
+      ], expect.objectContaining({ cwd: tmpDir }));
+
+      expect(result.timedOut).toBe(false);
+      expect(result.report!.mutationScore).toBe(80);
+      expect(result.report!.nrOfMutants).toBe(10);
+      expect(result.report!.nrOfKilledMutants).toBe(8);
+      expect(result.report!.nrOfSurvivedMutants).toBe(2);
+    });
+
+    it('should return timedOut=true when killed', async () => {
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') setTimeout(() => cb(null), 10);
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new GoMutantRunner();
+      const result = await runner.run({
+        files: ['src/main.go'],
+        timeoutMs: 100,
+        cwd: tmpDir,
+      });
+
+      expect(result.timedOut).toBe(true);
+      expect(result.report).toBeNull();
+    });
+
+    it('should return error when spawn fails', async () => {
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'error') setTimeout(() => cb(new Error('spawn ENOENT')), 10);
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new GoMutantRunner();
+      const result = await runner.run({
+        files: ['src/main.go'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+      expect(result.error).toBe('spawn ENOENT');
+    });
+
+    it('should handle gomutants exit code 10 (below threshold) with report', async () => {
+      let stderrCb: ((d: Buffer) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn((_event: string, cb: (d: Buffer) => void) => { stderrCb = cb; }) },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') {
+            setTimeout(() => {
+              if (stderrCb) stderrCb(Buffer.from('below threshold'));
+              cb(10);
+            }, 10);
+          }
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      writeFileSync(join(tmpDir, '.gomutants-report.json'), JSON.stringify({
+        test_efficacy: 45,
+        mutants_total: 50,
+        mutants_killed: 22,
+        mutants_lived: 18,
+        mutants_not_covered: 10,
+      }));
+
+      const runner = new GoMutantRunner();
+      const result = await runner.run({
+        files: ['src/main.go'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      expect(result.timedOut).toBe(false);
+      expect(result.report).not.toBeNull();
+      expect(result.report!.mutationScore).toBe(45);
+      expect(result.error).toBeTruthy();
+    });
+
+    it('should return null report when report file does not exist', async () => {
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') setTimeout(() => cb(0), 10);
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      const runner = new GoMutantRunner();
+      const result = await runner.run({
+        files: ['src/main.go'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      expect(result.report).toBeNull();
+      expect(result.timedOut).toBe(false);
+    });
+
+    it('should parse files array from report', async () => {
+      let closeCb: ((code: number | null) => void) | null = null;
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn((event, cb) => {
+          if (event === 'close') closeCb = cb;
+        }),
+        kill: vi.fn(),
+        killed: false,
+      };
+      vi.mocked(spawn).mockReturnValue(mockChild as unknown as ChildProcess);
+
+      writeFileSync(join(tmpDir, '.gomutants-report.json'), JSON.stringify({
+        test_efficacy: 80,
+        mutants_total: 20,
+        mutants_killed: 16,
+        mutants_lived: 4,
+        mutants_not_viable: 0,
+        mutants_not_covered: 0,
+        files: [
+          {
+            file_name: 'calculator.go',
+            mutations: Array(12).fill({ status: 'KILLED' }).concat(Array(8).fill({ status: 'LIVED' })),
+          },
+        ],
+      }));
+
+      const runner = new GoMutantRunner();
+      const promise = runner.run({
+        files: ['src/calculator.go'],
+        timeoutMs: 60000,
+        cwd: tmpDir,
+      });
+
+      closeCb!(0);
+      const result = await promise;
+
+      expect(result.report).not.toBeNull();
+      expect(result.report!.files).toBeDefined();
+      expect(result.report!.files!['calculator.go'].mutationScore).toBe(60);
+      expect(result.report!.files!['calculator.go'].nrOfMutants).toBe(20);
+    });
+  });
+});

package/mutation/gate-m.ts

@@ -126,6 +126,12 @@ async function findTestFileForSource(sourceFile: string): Promise<string | null>
     if (await fileExists(testFile3)) return testFile3;
   }
 
+  if (ext === '.go') {
+    // Go: foo.go → foo_test.go (same directory, idiomatic convention)
+    const testFile1 = sourceFile.replace(/\.go$/, '_test.go');
+    if (await fileExists(testFile1)) return testFile1;
+  }
+
   return null;
 }
 

package/mutation/runners/go-mutant-runner.ts

@@ -0,0 +1,175 @@
+// @no-test-required: Go mutation wrapper — tested via gate-m integration + pre-push Gate M
+import { spawn, spawnSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import type {
+  MutationRunner,
+  RunMutationOptions,
+  MutationRunOutcome,
+  MutationRunResult,
+} from './types';
+
+const GOMUTANTS_REPORT_PATH = '.gomutants-report.json';
+
+/**
+ * gomutants mutation runner for Go files.
+ *
+ * Tool: https://github.com/szhekpisov/gomutants
+ *
+ * Uses `gomutants run --output <json>` to generate mutants and parse report.
+ * Exit codes: 0=pass, 10=below threshold, 11=below coverage.
+ */
+export class GoMutantRunner implements MutationRunner {
+  readonly name = 'gomutants';
+  readonly extensions = ['go'];
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      const result = spawnSync('gomutants', ['--version'], {
+        stdio: 'pipe',
+        timeout: 5000,
+      });
+      return result.status !== null && result.status === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async run(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    return new Promise((resolve) => {
+      const reportPath = join(options.cwd, GOMUTANTS_REPORT_PATH);
+
+      const args = [
+        '--output',
+        reportPath,
+        '--quiet',
+      ];
+
+      const child = spawn('gomutants', 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;
+        }
+
+        // Exit codes: 0=pass, 10=below threshold, 11=below coverage
+        // All three produce a JSON report we can parse
+        const report = this.parseReport(reportPath);
+        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 parseReport(reportPath: string): MutationRunResult | null {
+    try {
+      if (!existsSync(reportPath)) return null;
+      const content = readFileSync(reportPath, 'utf-8');
+      const parsed = JSON.parse(content) as Record<string, unknown>;
+      return this.normalizeReport(parsed);
+    } catch {
+      return null;
+    }
+  }
+
+/**
+ * Normalize gomutants JSON into the shared MutationRunResult format.
+ *
+ * gomutants v0.4.0 output:
+ *   test_efficacy: number (0-100) — KILLED/(KILLED+LIVED)
+ *   mutations_coverage: number (0-100) — (KILLED+LIVED)/(KILLED+LIVED+NOT_COVERED)
+ *   mutants_total: number
+ *   mutants_killed: number
+ *   mutants_lived: number
+ *   mutants_not_viable: number
+ *   mutants_not_covered: number
+ *   files: [{ file_name: string, mutations: [{ status: "KILLED"|"LIVED"|... }] }]
+ */
+  private normalizeReport(parsed: Record<string, unknown>): MutationRunResult | null {
+    const mutationScore = asNumber(parsed.test_efficacy, NaN);
+    const nrOfMutants = asNumber(parsed.mutants_total, NaN);
+    const nrOfKilledMutants = asNumber(parsed.mutants_killed, 0);
+    const nrOfSurvivedMutants = asNumber(parsed.mutants_lived, 0) + asNumber(parsed.mutants_not_covered, 0);
+
+    if (isNaN(mutationScore) || isNaN(nrOfMutants)) return null;
+
+    const result: MutationRunResult = {
+      mutationScore,
+      nrOfMutants,
+      nrOfKilledMutants,
+      nrOfSurvivedMutants,
+    };
+
+    if (parsed.files && Array.isArray(parsed.files)) {
+      result.files = parseFilesArray(parsed.files as Array<Record<string, unknown>>);
+    }
+
+    return result;
+  }
+}
+
+function asNumber(value: unknown, fallback = 0): number {
+  return typeof value === 'number' ? value : fallback;
+}
+
+function parseFilesArray(
+  filesArr: Array<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 entry of filesArr) {
+    const fileName = asString(entry.file_name);
+    if (!fileName) continue;
+    const mutations = Array.isArray(entry.mutations)
+      ? entry.mutations as Array<Record<string, unknown>>
+      : [];
+    const killed = mutations.filter(m => m.status === 'KILLED').length;
+    const lived = mutations.filter(m => m.status === 'LIVED').length;
+    const notCovered = mutations.filter(m => m.status === 'NOT_COVERED').length;
+    const total = mutations.length;
+
+    files[fileName] = {
+      mutationScore: total > 0 ? (killed / total) * 100 : 0,
+      nrOfMutants: total,
+      nrOfKilledMutants: killed,
+      nrOfSurvivedMutants: lived + notCovered,
+    };
+  }
+  return files;
+}
+
+function asString(value: unknown): string {
+  return typeof value === 'string' ? value : '';
+}

package/mutation/runners/index.ts

@@ -11,13 +11,16 @@ export { registerRunner, resolveRunner, runnerRegistry } from './types';
 
 export { StrykerRunner } from './stryker-runner';
 export { MutmutRunner } from './mutmut-runner';
+export { GoMutantRunner } from './go-mutant-runner';
 
 import { StrykerRunner } from './stryker-runner';
 import { MutmutRunner } from './mutmut-runner';
+import { GoMutantRunner } from './go-mutant-runner';
 import { registerRunner } from './types';
 
 /** Auto-register all known runners. */
 export function registerAllRunners(): void {
   registerRunner(new StrykerRunner());
   registerRunner(new MutmutRunner());
+  registerRunner(new GoMutantRunner());
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"
@@ -15,7 +15,8 @@
     "adapter-common.sh",
     "principles/",
     "mutation/",
-    "mock-policy/"
+    "mock-policy/",
+    "build-integrity/"
   ],
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "xp-gate",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "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-22
-**Commit:** dcb5154
+**Commit:** 1cc434d
 **Branch:** main
-**Version:** 0.10.2.0
+**Version:** 0.10.3.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/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
 **Generated:** 2026-06-22
-**Commit:** dcb5154
+**Commit:** 1cc434d
 **Branch:** main
-**Version:** 0.10.2.0
+**Version:** 0.10.3.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/test-specification-alignment/AGENTS.md

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

package/plugins/opencode/__tests__/tui-plugin.test.ts

@@ -12,7 +12,7 @@
 import { describe, it, before, after } from "node:test"
 import assert from "node:assert/strict"
 import { randomUUID } from "node:crypto"
-import { mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs"
+import { mkdirSync, writeFileSync, rmSync } from "node:fs"
 import { join } from "node:path"
 import { tmpdir } from "node:os"
 
@@ -88,7 +88,7 @@ function makeSprintState(overrides: Record<string, unknown> = {}) {
       { phase: "2", status: "in_progress" as const, reqs: { "REQ-001": { name: "JWT auth", status: "completed" as const }, "REQ-002": { name: "OAuth2 flow", status: "in_progress" as const } } },
     ],
   }
-  return { ...base, ...overrides } as any
+  return { ...base, ...overrides } as unknown as Parameters<typeof renderSprintSidebar>[0]
 }
 
 // ── isStale ──

package/plugins/opencode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "type": "module",
   "main": "index.ts",
   "description": "XP-Gate quality gates + AI workflow skills + Sprint Flow TUI sidebar for OpenCode",

package/plugins/opencode/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
 **Generated:** 2026-06-22
-**Commit:** dcb5154
+**Commit:** 1cc434d
 **Branch:** main
-**Version:** 0.10.2.0
+**Version:** 0.10.3.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/opencode/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
 **Generated:** 2026-06-22
-**Commit:** dcb5154
+**Commit:** 1cc434d
 **Branch:** main
-**Version:** 0.10.2.0
+**Version:** 0.10.3.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/opencode/skills/test-specification-alignment/AGENTS.md

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

package/plugins/opencode/tui-plugin.ts

@@ -38,25 +38,6 @@ function parseTime(value: unknown): number {
   return new Date(value as string).getTime();
 }
 
-function maxValid(current: number, candidate: unknown): number {
-  if (!candidate) return current;
-  const t = parseTime(candidate);
-  return !isNaN(t) && t > current ? t : current;
-}
-
-function getLatestTimestamp(state: Record<string, unknown> | null): number {
-  if (!state || !state.started_at) return 0;
-  const started = parseTime(state.started_at);
-  if (isNaN(started)) return 0;
-  let latest = started;
-  if (Array.isArray(state.phase_history)) {
-    for (const ph of state.phase_history) {
-      latest = maxValid(maxValid(latest, (ph as Record<string, unknown>).completed_at), (ph as Record<string, unknown>).started_at);
-    }
-  }
-  return latest;
-}
-
 function isStale(state: SprintState | null): boolean {
   if (!state || !state.started_at) return false;
   const latest = sprintTimestamp(state);

package/plugins/qoder/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
 **Generated:** 2026-06-22
-**Commit:** dcb5154
+**Commit:** 1cc434d
 **Branch:** main
-**Version:** 0.10.2.0
+**Version:** 0.10.3.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/qoder/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
 **Generated:** 2026-06-22
-**Commit:** dcb5154
+**Commit:** 1cc434d
 **Branch:** main
-**Version:** 0.10.2.0
+**Version:** 0.10.3.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.