@boyingliu01/xp-gate 0.12.9 → 0.12.12

package/plugins/claude-code/skills/sprint-flow/__tests__/sprint-flow.test.cjs

@@ -0,0 +1,444 @@
+/**
+ * @test REQ-SF-001 Sprint Flow Trigger Accuracy
+ * @intent Verify that sprint-flow SKILL.md trigger detection correctly distinguishes
+ *        between valid sprint-flow requests and unrelated queries
+ * @covers AC-SF-001-01, AC-SF-001-02, AC-SF-001-03
+ */
+const fs = require('fs');
+const path = require('path');
+
+const SKILL_MD_PATH = path.join(__dirname, '..', 'SKILL.md');
+const REFERENCES_DIR = path.join(__dirname, '..', 'references');
+const PHASE_2_BUILD_PATH = path.join(REFERENCES_DIR, 'phase-2-build.md');
+const ORCHESTRATION_RULES_PATH = path.join(REFERENCES_DIR, 'orchestration-rules.md');
+
+let skillContent = '';
+
+function loadSkillMd() {
+  skillContent = fs.readFileSync(SKILL_MD_PATH, 'utf-8');
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const yaml = match[1];
+  const result = {};
+  // Parse simple YAML key-value pairs and lists
+  const lines = yaml.split('\n');
+  let currentKey = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '' || trimmed.startsWith('#')) continue;
+    const kvMatch = trimmed.match(/^(\w[\w_]*):\s*(.*)/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      const val = kvMatch[2].trim();
+      if (val === '') {
+        result[currentKey] = [];
+      } else if (val.startsWith('"') || val.startsWith("'")) {
+        result[currentKey] = val.slice(1, -1);
+      } else {
+        result[currentKey] = val;
+      }
+    } else if (trimmed.startsWith('- ') && currentKey) {
+      const item = trimmed.slice(2).trim().replace(/^["'](.*)["'].*$/, '$1');
+      if (!Array.isArray(result[currentKey])) result[currentKey] = [];
+      result[currentKey].push(item);
+    }
+  }
+  return result;
+}
+
+// === Trigger Accuracy Tests ===
+
+function testPositiveTriggersArePresent() {
+  const frontmatter = parseFrontmatter(skillContent);
+  const triggers = frontmatter.triggers || [];
+  const required = ['/sprint-flow', 'start sprint', '开发新功能', '一键开发'];
+  const missing = required.filter(r => !triggers.some(t => t.includes(r)));
+  if (missing.length > 0) {
+    throw new Error(`Missing positive triggers: ${missing.join(', ')}`);
+  }
+  console.log('  ✓ Positive triggers are present');
+}
+
+function testNegativeTriggersArePresent() {
+  const frontmatter = parseFrontmatter(skillContent);
+  const negTriggers = frontmatter.triggers_negative_examples || [];
+  if (negTriggers.length < 8) {
+    throw new Error(`triggers_negative_examples must have at least 8 entries, got ${negTriggers.length}`);
+  }
+  console.log(`  ✓ Negative triggers have ${negTriggers.length} entries (>= 8 required)`);
+}
+
+function testNegativeTriggerPhrases() {
+  // These phrases must NOT trigger sprint-flow
+  const shouldNotTrigger = [
+    '实现排序算法',
+    '实现一下',
+    '帮我实现这个函数',
+    '怎么实现登录功能',
+    'start spring boot',
+    '开发环境配置',
+    '一键部署',
+    '新功能建议',
+    'implement a sort function',
+    'how to implement auth',
+  ];
+  for (const phrase of shouldNotTrigger) {
+    // Verify phrase is in triggers_negative_examples
+    const frontmatter = parseFrontmatter(skillContent);
+    const negTriggers = frontmatter.triggers_negative_examples || [];
+    const found = negTriggers.some(n => n.includes(phrase) || phrase.includes(n));
+    if (!found) {
+      throw new Error(`Negative trigger phrase "${phrase}" not found in triggers_negative_examples`);
+    }
+  }
+  console.log(`  ✓ All ${shouldNotTrigger.length} negative trigger phrases verified`);
+}
+
+function testPositiveTriggerPhrases() {
+  const shouldTrigger = [
+    '开发用户认证模块',
+    '/sprint-flow',
+    '一键开发 REST API',
+  ];
+  for (const phrase of shouldTrigger) {
+    const frontmatter = parseFrontmatter(skillContent);
+    const triggers = frontmatter.triggers || [];
+    // Match against frontmatter triggers OR check body trigger table for broader patterns
+    const matched = triggers.some(t =>
+      phrase.includes(t) || t.includes(phrase) || phrase.includes('/sprint-flow')
+    ) || skillContent.includes(phrase);
+    if (!matched) {
+      throw new Error(`Positive trigger phrase "${phrase}" should match at least one trigger`);
+    }
+  }
+  console.log(`  ✓ All ${shouldTrigger.length} positive trigger phrases verified`);
+}
+
+function testNegativeTestCasesExist() {
+  // Count test case entries by matching "input:" lines in triggers_negative_test_cases YAML block
+  const fmMatch = skillContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) throw new Error('Frontmatter not found');
+  const yaml = fmMatch[1];
+
+  // Find triggers_negative_test_cases block and count "- input:" lines within it
+  const testCasesSection = yaml.split('triggers_negative_test_cases:')[1];
+  if (!testCasesSection) throw new Error('triggers_negative_test_cases not found in frontmatter');
+
+  const count = (testCasesSection.match(/^\s+- input:/gm) || []).length;
+  if (count < 11) {
+    throw new Error(`triggers_negative_test_cases must have at least 11 entries, got ${count}`);
+  }
+  console.log(`  ✓ Negative test cases have ${count} entries (>= 11 required)`);
+}
+
+// === Phase Transition Tests ===
+
+function testWorkflowStepsOrder() {
+  const frontmatter = parseFrontmatter(skillContent);
+  const steps = frontmatter.workflow_steps || [];
+  if (steps.length !== 11) {
+    throw new Error(`workflow_steps must have exactly 11 entries, got ${steps.length}`);
+  }
+
+  const expectedOrder = [
+    'ISOLATE', 'AUTO-ESTIMATE', 'THINK', 'PLAN', 'BUILD',
+    'REVIEW', 'FEEDBACK', 'SHIP', 'LAND', 'USER ACCEPTANCE', 'CLEANUP',
+  ];
+
+  for (let i = 0; i < expectedOrder.length; i++) {
+    if (!steps[i].includes(expectedOrder[i])) {
+      throw new Error(
+        `workflow_steps[${i}] should contain "${expectedOrder[i]}", got "${steps[i]}"`
+      );
+    }
+  }
+  console.log('  ✓ workflow_steps order matches canonical 11-phase sequence');
+}
+
+function testPhaseFlowDiagramOrder() {
+  // The Phase Flow diagram in the body must show: ISOLATE → ... → FEEDBACK → SHIP → LAND → USER ACCEPTANCE → CLEANUP
+  const flowMatch = skillContent.match(/ISOLATE →.*CLEANUP/);
+  if (!flowMatch) {
+    throw new Error('Phase Flow diagram not found in SKILL.md body');
+  }
+  const flow = flowMatch[0];
+
+  // Verify FEEDBACK comes before SHIP (not after USER ACCEPTANCE)
+  const feedbackPos = flow.indexOf('FEEDBACK');
+  const shipPos = flow.indexOf('SHIP');
+  const userAcceptPos = flow.indexOf('USER ACCEPT');
+  if (feedbackPos === -1 || shipPos === -1 || userAcceptPos === -1) {
+    throw new Error('Phase Flow diagram missing required phases');
+  }
+  if (feedbackPos > shipPos) {
+    throw new Error('FEEDBACK must come before SHIP in phase flow diagram');
+  }
+  if (shipPos > userAcceptPos) {
+    throw new Error('SHIP must come before USER ACCEPTANCE in phase flow diagram');
+  }
+  console.log('  ✓ Phase Flow diagram has correct ordering');
+}
+
+function testPhaseFlowConsistencySectionExists() {
+  if (!skillContent.includes('Phase Flow Consistency')) {
+    throw new Error('SKILL.md must contain "Phase Flow Consistency" section');
+  }
+  console.log('  ✓ Phase Flow Consistency section exists');
+}
+
+function testCanonicalPhaseOrderTableExists() {
+  if (!skillContent.includes('Canonical Phase Order')) {
+    throw new Error('SKILL.md must contain "Canonical Phase Order" table');
+  }
+  console.log('  ✓ Canonical Phase Order table exists');
+}
+
+function testAll11PhasesInPhaseFlowConsistency() {
+  const section = skillContent.split('Phase Flow Consistency')[1];
+  const requiredPhases = [
+    'ISOLATE', 'AUTO-ESTIMATE', 'THINK', 'PLAN', 'BUILD',
+    'REVIEW', 'FEEDBACK', 'SHIP', 'LAND', 'USER ACCEPTANCE', 'CLEANUP',
+  ];
+  for (const phase of requiredPhases) {
+    if (!section.includes(phase)) {
+      throw new Error(`Phase Flow Consistency section missing phase: ${phase}`);
+    }
+  }
+  console.log('  ✓ All 11 phases referenced in Phase Flow Consistency section');
+}
+
+// === Force Levels Tests ===
+
+function testForceLevelsDocumentExists() {
+  const forceLevelsPath = path.join(REFERENCES_DIR, 'force-levels.md');
+  if (!fs.existsSync(forceLevelsPath)) {
+    throw new Error('references/force-levels.md must exist');
+  }
+  const content = fs.readFileSync(forceLevelsPath, 'utf-8');
+  if (!content.includes('轻量') || !content.includes('标准') || !content.includes('复杂')) {
+    throw new Error('force-levels.md must document lightweight/standard/complex levels');
+  }
+  console.log('  ✓ force-levels.md exists and documents three levels');
+}
+
+function testForceLevelsRequiresDelphi() {
+  const forceLevelsContent = fs.readFileSync(
+    path.join(REFERENCES_DIR, 'force-levels.md'), 'utf-8'
+  );
+  if (!forceLevelsContent.includes('Delphi') && !forceLevelsContent.includes('delphi')) {
+    throw new Error('force-levels.md must reference Delphi review requirement');
+  }
+  console.log('  ✓ force-levels.md requires Delphi review for all levels');
+}
+
+// === Value Proposition Tests ===
+
+function testUniqueValuePropositionExists() {
+  if (!skillContent.includes('Unique Value Proposition')) {
+    throw new Error('SKILL.md must contain "Unique Value Proposition" section');
+  }
+  console.log('  ✓ Unique Value Proposition section exists');
+}
+
+function testUvpMentionsTokenSavings() {
+  const section = skillContent.split('Unique Value Proposition')[1];
+  if (!section.includes('40') || !section.includes('67') || !section.includes('token')) {
+    throw new Error('Unique Value Proposition must mention 40-67% token savings');
+  }
+  console.log('  ✓ UVP mentions 40-67% token savings');
+}
+
+function testUvpMentionsHardGate() {
+  const section = skillContent.split('Unique Value Proposition')[1];
+  if (!section.includes('HARD-GATE')) {
+    throw new Error('Unique Value Proposition must mention HARD-GATE discipline');
+  }
+  console.log('  ✓ UVP mentions HARD-GATE discipline');
+}
+
+function testUvpMentionsEmergentRequirements() {
+  const section = skillContent.split('Unique Value Proposition')[1];
+  if (!section.toLowerCase().includes('emergent')) {
+    throw new Error('Unique Value Proposition must mention emergent requirements');
+  }
+  console.log('  ✓ UVP mentions emergent requirements');
+}
+
+// === Phase Timing Tests ===
+
+function testTimingSectionExists() {
+  const phase2BuildContent = fs.readFileSync(PHASE_2_BUILD_PATH, 'utf-8');
+  if (!phase2BuildContent.includes('Timing & Stability')) {
+    throw new Error('phase-2-build.md must contain "Timing & Stability" section');
+  }
+  console.log('  ✓ Timing & Stability section exists in phase-2-build.md');
+}
+
+function testTimeoutRecommendationsExist() {
+  const phase2BuildContent = fs.readFileSync(PHASE_2_BUILD_PATH, 'utf-8');
+  const timeoutSection = phase2BuildContent.split('Timing & Stability')[1];
+  if (!timeoutSection || !timeoutSection.includes('Timeout')) {
+    throw new Error('Timing & Stability section must include timeout recommendations');
+  }
+  console.log('  ✓ Timeout recommendations exist');
+}
+
+function testExecutionTimeEstimatesExist() {
+  const phase2BuildContent = fs.readFileSync(PHASE_2_BUILD_PATH, 'utf-8');
+  if (!phase2BuildContent.includes('Expected Time')) {
+    throw new Error('phase-2-build.md must include expected execution time estimates');
+  }
+  console.log('  ✓ Expected execution time estimates exist');
+}
+
+// === Orchestration Rules Tests ===
+
+function testOrchestrationRulesExists() {
+  if (!fs.existsSync(ORCHESTRATION_RULES_PATH)) {
+    throw new Error('references/orchestration-rules.md must exist');
+  }
+  console.log('  ✓ orchestration-rules.md exists');
+}
+
+function testPhaseSubagentMatrixOrder() {
+  const orchContent = fs.readFileSync(ORCHESTRATION_RULES_PATH, 'utf-8');
+  const expectedOrder = [
+    'ISOLATE', 'AUTO-ESTIMATE', 'THINK', 'PLAN', 'BUILD',
+    'REVIEW', 'USER ACCEPT', 'FEEDBACK', 'SHIP', 'LAND', 'CLEANUP',
+  ];
+  // The matrix order reflects file names, but phases should all be present
+  for (const phase of ['ISOLATE', 'THINK', 'PLAN', 'BUILD', 'REVIEW', 'CLEANUP']) {
+    if (!orchContent.includes(phase)) {
+      throw new Error(`orchestration-rules.md missing phase: ${phase}`);
+    }
+  }
+  console.log('  ✓ Orchestration rules covers all key phases');
+}
+
+// === Run All Tests ===
+
+function runTests(opts = {}) {
+  const { exitOnFail = false } = opts;
+  let passed = 0;
+  let failed = 0;
+  const errors = [];
+
+  const tests = [
+    { name: 'Positive triggers are present', fn: testPositiveTriggersArePresent },
+    { name: 'Negative triggers have >= 8 entries', fn: testNegativeTriggersArePresent },
+    { name: 'Negative trigger phrases verified', fn: testNegativeTriggerPhrases },
+    { name: 'Positive trigger phrases verified', fn: testPositiveTriggerPhrases },
+    { name: 'Negative test cases exist (>= 11)', fn: testNegativeTestCasesExist },
+    { name: 'workflow_steps order matches canonical', fn: testWorkflowStepsOrder },
+    { name: 'Phase Flow diagram has correct ordering', fn: testPhaseFlowDiagramOrder },
+    { name: 'Phase Flow Consistency section exists', fn: testPhaseFlowConsistencySectionExists },
+    { name: 'Canonical Phase Order table exists', fn: testCanonicalPhaseOrderTableExists },
+    { name: 'All 11 phases in consistency section', fn: testAll11PhasesInPhaseFlowConsistency },
+    { name: 'force-levels.md exists with three levels', fn: testForceLevelsDocumentExists },
+    { name: 'force-levels.md requires Delphi review', fn: testForceLevelsRequiresDelphi },
+    { name: 'Unique Value Proposition exists', fn: testUniqueValuePropositionExists },
+    { name: 'UVP mentions 40-67% token savings', fn: testUvpMentionsTokenSavings },
+    { name: 'UVP mentions HARD-GATE', fn: testUvpMentionsHardGate },
+    { name: 'UVP mentions emergent requirements', fn: testUvpMentionsEmergentRequirements },
+    { name: 'Timing & Stability section exists', fn: testTimingSectionExists },
+    { name: 'Timeout recommendations exist', fn: testTimeoutRecommendationsExist },
+    { name: 'Execution time estimates exist', fn: testExecutionTimeEstimatesExist },
+    { name: 'orchestration-rules.md exists', fn: testOrchestrationRulesExists },
+    { name: 'Orchestration covers all key phases', fn: testPhaseSubagentMatrixOrder },
+    { name: 'Uncommitted Changes Gate section exists', fn: testUncommittedGateExists },
+    { name: 'Uncommitted gate has escape valve', fn: testUncommittedGateEscapeValve },
+    { name: 'Uncommitted gate has log path', fn: testUncommittedGateLogPath },
+  ];
+
+  loadSkillMd();
+
+  for (const { name, fn } of tests) {
+    try {
+      fn();
+      passed++;
+    } catch (e) {
+      failed++;
+      errors.push(`FAIL: ${name}: ${e.message}`);
+    }
+  }
+
+  console.log(`\n=== Results: ${passed} passed, ${failed} failed ===\n`);
+  errors.forEach(e => console.log(e));
+
+  if (exitOnFail && failed > 0) {
+    process.exit(1);
+  }
+  return failed > 0 ? 1 : 0;
+}
+
+// Uncommitted Changes Gate tests (must run after the section is added)
+function testUncommittedGateExists() {
+  const phase2BuildContent = fs.readFileSync(PHASE_2_BUILD_PATH, 'utf-8');
+  if (!phase2BuildContent.includes('Uncommitted Changes Gate')) {
+    throw new Error('phase-2-build.md must contain "Uncommitted Changes Gate" section');
+  }
+  console.log('  ✓ Uncommitted Changes Gate section exists');
+}
+
+function testUncommittedGateEscapeValve() {
+  const phase2BuildContent = fs.readFileSync(PHASE_2_BUILD_PATH, 'utf-8');
+  if (!phase2BuildContent.includes('SKIP_UNCOMMITTED_GATE')) {
+    throw new Error('Uncommitted Changes Gate must provide SKIP_UNCOMMITTED_GATE escape valve');
+  }
+  console.log('  ✓ Uncommitted gate has SKIP_UNCOMMITTED_GATE escape valve');
+}
+
+function testUncommittedGateLogPath() {
+  const phase2BuildContent = fs.readFileSync(PHASE_2_BUILD_PATH, 'utf-8');
+  if (!phase2BuildContent.includes('.sprint-state/uncommitted-gate-log.json')) {
+    throw new Error('Uncommitted Changes Gate must log to .sprint-state/uncommitted-gate-log.json');
+  }
+  console.log('  ✓ Uncommitted gate logs to .sprint-state/uncommitted-gate-log.json');
+}
+
+// When run directly (node script.js), call with exitOnFail for CLI behavior.
+if (require.main === module) {
+  const exitCode = runTests({ exitOnFail: true });
+  process.exit(exitCode);
+}
+
+// Vitest discovery — wrap each test function as a vitest it() block
+describe('sprint-flow SKILL.md', () => {
+  beforeAll(() => { loadSkillMd(); });
+
+  const tests = [
+    { name: 'Positive triggers are present', fn: testPositiveTriggersArePresent },
+    { name: 'Negative triggers have >= 8 entries', fn: testNegativeTriggersArePresent },
+    { name: 'Negative trigger phrases verified', fn: testNegativeTriggerPhrases },
+    { name: 'Positive trigger phrases verified', fn: testPositiveTriggerPhrases },
+    { name: 'Negative test cases exist (>= 11)', fn: testNegativeTestCasesExist },
+    { name: 'workflow_steps order matches canonical', fn: testWorkflowStepsOrder },
+    { name: 'Phase Flow diagram has correct ordering', fn: testPhaseFlowDiagramOrder },
+    { name: 'Phase Flow Consistency section exists', fn: testPhaseFlowConsistencySectionExists },
+    { name: 'Canonical Phase Order table exists', fn: testCanonicalPhaseOrderTableExists },
+    { name: 'All 11 phases in consistency section', fn: testAll11PhasesInPhaseFlowConsistency },
+    { name: 'force-levels.md exists with three levels', fn: testForceLevelsDocumentExists },
+    { name: 'force-levels.md requires Delphi review', fn: testForceLevelsRequiresDelphi },
+    { name: 'Unique Value Proposition exists', fn: testUniqueValuePropositionExists },
+    { name: 'UVP mentions 40-67% token savings', fn: testUvpMentionsTokenSavings },
+    { name: 'UVP mentions HARD-GATE', fn: testUvpMentionsHardGate },
+    { name: 'UVP mentions emergent requirements', fn: testUvpMentionsEmergentRequirements },
+    { name: 'Timing & Stability section exists', fn: testTimingSectionExists },
+    { name: 'Timeout recommendations exist', fn: testTimeoutRecommendationsExist },
+    { name: 'Execution time estimates exist', fn: testExecutionTimeEstimatesExist },
+    { name: 'orchestration-rules.md exists', fn: testOrchestrationRulesExists },
+    { name: 'Orchestration covers all key phases', fn: testPhaseSubagentMatrixOrder },
+    { name: 'Uncommitted Changes Gate section exists', fn: testUncommittedGateExists },
+    { name: 'Uncommitted gate has escape valve', fn: testUncommittedGateEscapeValve },
+    { name: 'Uncommitted gate has log path', fn: testUncommittedGateLogPath },
+  ];
+
+  for (const { name, fn } of tests) {
+    it(name, () => { fn(); });
+  }
+});
+
+module.exports = { runTests };

package/plugins/claude-code/skills/sprint-flow/references/phase-2-build.md

@@ -20,6 +20,65 @@
 
 ---
 
+---
+
+## Uncommitted Changes Gate
+
+**Purpose**: Prevent entering BUILD with uncommitted changes that could mix with sprint work.
+
+**Execution**: Before entering Phase 2 BUILD, the orchestrator MUST check for uncommitted changes in the worktree.
+
+### Gate Logic
+
+```bash
+# Check for uncommitted changes
+UNCOMMITTED=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+
+if [ "$SKIP_UNCOMMITTED_GATE" = "1" ]; then
+  echo "[UNCOMMITTED-GATE] Skipped (SKIP_UNCOMMITTED_GATE=1)"
+  echo "{\"skipped\":true,\"reason\":\"SKIP_UNCOMMITTED_GATE=1\",\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" > .sprint-state/uncommitted-gate-log.json
+elif [ "$UNCOMMITTED" -gt 0 ]; then
+  echo "⚠️ [UNCOMMITTED-GATE] Found ${UNCOMMITTED} uncommitted files in worktree:"
+  git status --short 2>/dev/null | head -20
+  echo ""
+  echo "Uncommitted changes may conflict with sprint work. Recommended actions:"
+  echo "  1. Commit changes: git add -A && git commit -m 'pre-sprint: save work before BUILD'"
+  echo "  2. Stash changes: git stash push -m 'pre-sprint stash'"
+  echo "  3. Skip gate: export SKIP_UNCOMMITTED_GATE=1 (not recommended)"
+  echo ""
+  echo "Logging to .sprint-state/uncommitted-gate-log.json"
+  echo "{\"blocked\":true,\"uncommitted_files\":${UNCOMMITTED},\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" > .sprint-state/uncommitted-gate-log.json
+  echo "[BLOCK] Uncommitted changes detected. Please commit, stash, or set SKIP_UNCOMMITTED_GATE=1 to continue."
+  exit 1
+else
+  echo "✅ [UNCOMMITTED-GATE] Worktree clean. Proceeding to BUILD."
+  echo "{\"clean\":true,\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" > .sprint-state/uncommitted-gate-log.json
+fi
+```
+
+### Escape Valve
+
+```bash
+# Skip the uncommitted changes gate (use with caution)
+SKIP_UNCOMMITTED_GATE=1
+```
+
+### Log Format (`.sprint-state/uncommitted-gate-log.json`)
+
+```json
+{
+  "clean": true,
+  "blocked": false,
+  "skipped": false,
+  "uncommitted_files": 0,
+  "timestamp": "2026-07-05T10:00:00Z"
+}
+```
+
+**Log location**: `.sprint-state/uncommitted-gate-log.json` — written on every gate execution for audit trail.
+
+---
+
 ## TDD 强制执行
 
 ### Gate 5a-BLOCK: 新增文件测试强制
@@ -41,3 +100,48 @@
 # 非 main/master 分支临时跳过 Gate 5a-BLOCK
 SKIP_GATE_5A_BLOCK=1 git commit -m "message"
 ```
+
+---
+
+## Timing & Stability
+
+This section documents expected execution times and timeout handling for each Phase 2 sub-step to reduce execution timing stddev and prevent pipeline stalls.
+
+### Expected Execution Times
+
+| Step | Description | Expected Time | Timeout | On Timeout |
+|------|-------------|--------------|---------|------------|
+| DELPHI-GATE | Verify delphi-reviewed.json exists | 1-2s | 10s | BLOCK (critical gate) |
+| ralph-loop (per REQ) | TDD + verification per requirement | 5-15 min | 30 min/REQ | Mark REQ as `timeout`, continue next REQ |
+| parallel dispatch | Multi-agent parallel build | 10-30 min | 45 min | Collect partial results, continue |
+| TDD cycle (per unit) | RED → GREEN → REFACTOR | 2-5 min | 10 min | Skip unit, log failure |
+| freeze + blind-review | Code review in isolation | 5-10 min | 20 min | WARNING, continue |
+| verification | Test suite + coverage check | 2-5 min | 15 min | Retry once, then BLOCK |
+| cost monitor | Token cost accounting | <1s | 5s | Skip, log warning |
+| Phase 2 total (lightweight) | ≤3 REQs | 15-30 min | 45 min | — |
+| Phase 2 total (standard) | 4-10 REQs | 30-120 min | 150 min | — |
+| Phase 2 total (complex) | >10 REQs | 60-240 min | 300 min | — |
+
+### Stability Guidelines
+
+1. **Timeout handling**: All Phase 2 sub-steps MUST have explicit timeouts. If a step times out, log the failure to `.sprint-state/phase-outputs/phase-2-errors.json` and continue to the next step (except DELPHI-GATE which is a hard BLOCK).
+
+2. **Retry strategy**: For recoverable failures (verification, TDD cycle):
+   - First failure: log warning, retry once
+   - Second failure: log error, BLOCK and prompt user decision
+   - Do NOT retry more than twice for any single sub-step
+
+3. **Parallel dispatch stability**: When using `--mode parallel`, if any agent fails:
+   - Collect partial results from successful agents
+   - Rerun failed agent(s) individually with `--mode ralph-loop`
+   - Do NOT rerun the entire parallel batch
+
+4. **Cost monitor thresholds**: 
+   - Token cost per REQ > 50,000 → WARNING (review REQ scope)
+   - Token cost per REQ > 100,000 → BLOCK (REQ too large, split into smaller units)
+
+5. **StdDev reduction**: To reduce execution timing variability:
+   - Cache dependency installation results between REQs
+   - Reuse TDD scaffolding across similar REQ types
+   - Pre-compute code structure analysis once at Phase start
+   - Batch lint/format operations at the end, not per REQ

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

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-07-05
-**Commit:** a620d9b
+**Generated:** 2026-07-06
+**Commit:** 132a12e
 **Branch:** main
-**Version:** 0.12.9.0
+**Version:** 0.12.12.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/plugins/opencode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.12.9",
+  "version": "0.12.12",
   "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-07-05
-**Commit:** a620d9b
+**Generated:** 2026-07-06
+**Commit:** 132a12e
 **Branch:** main
-**Version:** 0.12.9.0
+**Version:** 0.12.12.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-07-05
-**Commit:** a620d9b
+**Generated:** 2026-07-06
+**Commit:** 132a12e
 **Branch:** main
-**Version:** 0.12.9.0
+**Version:** 0.12.12.0
 
 ## OVERVIEW
 **11-phase** development pipeline: ISOLATE → AUTO-ESTIMATE → THINK → PLAN → BUILD → REVIEW → SHIP → LAND → USER ACCEPTANCE → FEEDBACK → 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.