@boyingliu01/xp-gate 0.5.1 → 0.5.3

package/bin/xp-gate.js

@@ -48,6 +48,11 @@ const COMMANDS = {
     description: 'Diagnose xp-gate installation health',
     fn: doctor,
     usage: 'xp-gate doctor [--fix]'
+  },
+  'ui-review': {
+    description: 'Run UI review for non-sprint developers (generates .ui-gate-result.json)',
+    fn: null,
+    usage: 'xp-gate ui-review'
   }
 };
 
@@ -136,6 +141,18 @@ function main() {
     doctor(subargs).then(code => process.exit(code));
     return;
   }
+
+  if (command === 'ui-review') {
+    const { execSync } = require('child_process');
+    const path = require('path');
+    const uiReviewPath = path.join(__dirname, '..', 'lib', 'ui-review.ts');
+    try {
+      execSync(`npx -y tsx "${uiReviewPath}"`, { stdio: 'inherit' });
+      process.exit(0);
+    } catch (err) {
+      process.exit(1);
+    }
+  }
   
   console.error(`Unknown command: ${command}`);
   printHelp();

package/lib/audit-log.ts

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { join } from 'path';
+
+export interface AuditEntry {
+  timestamp: string;
+  branch: string;
+  commit: string;
+  user: string;
+  reason: string;
+  bypass_type: string;
+  gate_count: number;
+}
+
+const AUDIT_LOG_FILE = '.audit-log.jsonl';
+const MAX_ENTRIES = 100;
+const ROLLING_WINDOW_DAYS = 30;
+const MAX_BYPASS_THRESHOLD = 3;
+
+export function appendAuditEntry(entry: Omit<AuditEntry, 'gate_count'>, repoRoot: string = process.cwd()): AuditEntry {
+  const logPath = join(repoRoot, AUDIT_LOG_FILE);
+  const existing = readAllEntries(logPath);
+  const gate_count = countRecentBypasses(existing, entry.bypass_type, entry.timestamp);
+  
+  const fullEntry: AuditEntry = { ...entry, gate_count };
+  appendFileSync(logPath, JSON.stringify(fullEntry) + '\n', 'utf8');
+
+  trimLog(logPath);
+  return fullEntry;
+}
+
+export function readAllEntries(logPath: string = join(process.cwd(), AUDIT_LOG_FILE)): AuditEntry[] {
+  if (!existsSync(logPath)) return [];
+  const content = readFileSync(logPath, 'utf8').trim();
+  if (!content) return [];
+  return content.split('\n').map(line => JSON.parse(line) as AuditEntry);
+}
+
+export function countBypassesInWindow(entries: AuditEntry[], bypassType: string, windowDays: number = ROLLING_WINDOW_DAYS): number {
+  const cutoff = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1000);
+  return entries.filter(e => e.bypass_type === bypassType && new Date(e.timestamp) >= cutoff).length;
+}
+
+export function exceedsBypassThreshold(entries: AuditEntry[], bypassType: string, threshold: number = MAX_BYPASS_THRESHOLD): { exceeded: boolean; count: number } {
+  const count = countBypassesInWindow(entries, bypassType);
+  return { exceeded: count > threshold, count };
+}
+
+export function formatRetroReport(entries: AuditEntry[], bypassType: string = 'ui-gates'): string {
+  const total = entries.filter(e => e.bypass_type === bypassType);
+  const count30d = countBypassesInWindow(entries, bypassType);
+  const { exceeded } = exceedsBypassThreshold(entries, bypassType);
+
+  let report = `UI Gate Bypass Report (${bypassType})\n`;
+  report += `  Last 30 days: ${count30d} bypasses\n`;
+  if (exceeded) {
+    report += `  ⚠️  EXCEEDS threshold (${MAX_BYPASS_THRESHOLD}) — retro discussion required\n`;
+  }
+  if (total.length > 0) {
+    report += `  Recent bypasses:\n`;
+    total.slice(-5).forEach(e => {
+      report += `    - ${e.timestamp} | ${e.branch} | ${e.user}: "${e.reason}"\n`;
+    });
+  }
+  return report;
+}
+
+function countRecentBypasses(entries: AuditEntry[], bypassType: string, currentTimestamp: string): number {
+  const cutoff = new Date(currentTimestamp).getTime() - ROLLING_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+  return entries.filter(e => e.bypass_type === bypassType && new Date(e.timestamp).getTime() >= cutoff).length;
+}
+
+function trimLog(logPath: string): void {
+  if (!existsSync(logPath)) return;
+  const entries = readAllEntries(logPath);
+  if (entries.length > MAX_ENTRIES) {
+    const trimmed = entries.slice(-MAX_ENTRIES);
+    writeFileSync(logPath, trimmed.map(e => JSON.stringify(e)).join('\n') + '\n', 'utf8');
+  }
+}

package/lib/ui-detector.ts

@@ -1,4 +1,6 @@
 import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
 
 export interface UiDetectionResult {
   isUiSprint: boolean;
@@ -19,6 +21,60 @@ const UI_PATH_PATTERNS = [
   'src/pages/',
 ];
 
+// Default built-in exclusions — always ignored regardless of .ui-gate-ignore
+const UI_GATE_DEFAULT_EXCLUSIONS = [
+  '**/node_modules/**',
+  '**/__tests__/**',
+  '**/*.test.*',
+  '**/coverage/**',
+  '**/dist/**',
+  '**/build/**',
+];
+
+/**
+ * Check if a file path matches any glob pattern in the exclusions list.
+ * Simplified glob matching: ** → wildcard, * → single segment wildcard.
+ */
+export function isExcluded(filePath: string, exclusions: string[]): boolean {
+  const normalized = filePath.toLowerCase();
+  for (const pattern of exclusions) {
+    const p = pattern.toLowerCase().replace(/\*\*/g, '_STARSTAR_').replace(/\*/g, '_STAR_');
+    if (matchGlob(normalized, p)) return true;
+  }
+  return false;
+}
+
+function matchGlob(filePath: string, pattern: string): boolean {
+  // Convert simplified glob to regex
+  const regex = pattern
+    .replace(/_STARSTAR_/g, '.*')
+    .replace(/_STAR_/g, '[^/]*')
+    .replace(/\./g, '\\.');
+  const re = new RegExp(`^${regex}$`);
+  return re.test(filePath);
+}
+
+/**
+ * Load .ui-gate-ignore file from repo root.
+ * Returns array of glob patterns (one per line), excluding comments and empty lines.
+ */
+export function loadUiGateIgnore(repoRoot: string = process.cwd()): string[] {
+  const ignorePath = join(repoRoot, '.ui-gate-ignore');
+  if (!existsSync(ignorePath)) return [];
+  const content = readFileSync(ignorePath, 'utf8');
+  return content
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.length > 0 && !line.startsWith('#'));
+}
+
+/**
+ * Full exclusion list: default exclusions + .ui-gate-ignore patterns.
+ */
+function getFullExclusions(repoRoot?: string): string[] {
+  return [...UI_GATE_DEFAULT_EXCLUSIONS, ...loadUiGateIgnore(repoRoot)];
+}
+
 export function detectUiSprint(baseBranch: string = 'main'): UiDetectionResult {
   try {
     const files = getChangedFiles(baseBranch);
@@ -51,11 +107,13 @@ export function parseRenamedFile(file: string): string {
   return file.includes('→') ? file.split('→')[1].trim() : file;
 }
 
-export function collectUiMatches(files: string[]): UiDetectionResult {
+export function collectUiMatches(files: string[], repoRoot?: string): UiDetectionResult {
+  const exclusions = getFullExclusions(repoRoot);
   const matchedFiles: string[] = [];
   const matchedRules = new Set<string>();
 
   for (const filePath of files) {
+    if (isExcluded(filePath, exclusions)) continue;
     const rules = getFileMatchRules(filePath);
     if (rules.length > 0) {
       matchedFiles.push(filePath);
@@ -97,3 +155,70 @@ export function getFileExtension(filePath: string): string {
 export function hasUiPathPattern(normalizedPath: string): boolean {
   return UI_PATH_PATTERNS.some((pattern) => normalizedPath.includes(pattern));
 }
+
+// ─── CLI Entry Point ────────────────────────────────────────────────
+
+if (require.main === module) {
+  runCli();
+}
+
+function runCli(): void {
+  const args = process.argv.slice(2);
+  const repoRoot = process.cwd();
+
+  if (args.includes('--push-mode')) {
+    runPushMode(repoRoot);
+  } else if (args.includes('--check-branch')) {
+    runCheckBranch(repoRoot);
+  } else {
+    runDefault(repoRoot);
+  }
+}
+
+function runPushMode(repoRoot: string): void {
+  let input = '';
+  if (process.stdin.isTTY) {
+    // If args has --from-stdin but no TTY input, try reading file list from args
+    const filesIdx = process.argv.indexOf('--files');
+    if (filesIdx !== -1 && process.argv[filesIdx + 1]) {
+      input = process.argv[filesIdx + 1];
+      processOutput(input, repoRoot);
+      return;
+    }
+    input = '';
+  } else {
+    const chunks: string[] = [];
+    process.stdin.on('data', (chunk) => chunks.push(chunk.toString('utf8')));
+    process.stdin.on('end', () => {
+      input = chunks.join('').trim();
+      processOutput(input, repoRoot);
+    });
+    return; // async — wait for stdin end
+  }
+  processOutput(input, repoRoot);
+}
+
+function processOutput(input: string, repoRoot: string): void {
+  const files = input
+    .split('\n')
+    .map(parseRenamedFile)
+    .filter((f) => f.length > 0);
+  const result = collectUiMatches(files, repoRoot);
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(result.isUiSprint ? 0 : 1);
+}
+
+function runCheckBranch(repoRoot: string): void {
+  const result = detectUiSprint('HEAD');
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(result.isUiSprint ? 0 : 1);
+}
+
+function runDefault(repoRoot: string): void {
+  const result = detectUiSprint();
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(result.isUiSprint ? 0 : 1);
+}

package/lib/ui-review.ts

@@ -0,0 +1,109 @@
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { collectUiMatches, parseRenamedFile } from './ui-detector';
+
+const RESULT_FILE = '.ui-gate-result.json';
+
+interface UiReviewResult {
+  commit: string;
+  verdict: string;
+  expires: string;
+  design_review: string;
+  browser_qa: string;
+  ui_changes_detected: string[];
+}
+
+function main(): void {
+  // eslint-disable-next-line no-console
+  console.log('═══ xp-gate ui-review ═══');
+  // eslint-disable-next-line no-console
+  console.log('');
+
+  // Get staged + modified files
+  let files = '';
+  try {
+    files = execSync('git diff --cached --name-only && git diff --name-only', { encoding: 'utf8' }).trim();
+  } catch {
+    // eslint-disable-next-line no-console
+    console.log('⚠️ No git repo or no changes. Running in current directory.');
+  }
+
+  const fileList = files
+    .split('\n')
+    .map(parseRenamedFile)
+    .filter(f => f.length > 0);
+
+  if (fileList.length === 0) {
+    // eslint-disable-next-line no-console
+    console.log('No files staged or modified. Checking all tracked files.');
+    try {
+      files = execSync('git ls-files', { encoding: 'utf8' }).trim();
+    } catch {
+      files = execSync('find . -maxdepth 3 -type f -name "*.ts" -o -name "*.html" -o -name "*.css" -o -name "*.scss" -o -name "*.tsx" -o -name "*.vue" -o -name "*.svelte" 2>/dev/null | grep -v node_modules | grep -v .git', { encoding: 'utf8' }).trim();
+    }
+    fileList.push(...files.split('\n').filter(f => f.length > 0));
+  }
+
+  const result = collectUiMatches(fileList);
+
+  if (!result.isUiSprint) {
+    // eslint-disable-next-line no-console
+    console.log('ℹ️ No UI changes detected in staged/modified files.');
+    // eslint-disable-next-line no-console
+    console.log('  Nothing to review. Exiting.');
+    process.exit(0);
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`🎨 UI changes detected (${result.matchedFiles.length} files):`);
+  result.matchedFiles.forEach(f => console.log(`  - ${f}`));
+  // eslint-disable-next-line no-console
+  console.log('');
+
+  // eslint-disable-next-line no-console
+  console.log('Next steps required before push:');
+  // eslint-disable-next-line no-console
+  console.log('  1. Run /design-review in your AI agent session');
+  // eslint-disable-next-line no-console
+  console.log('  2. Run /qa or /qa-only in your AI agent session');
+  // eslint-disable-next-line no-console
+  console.log('  3. Ensure you have .delphi-config.json configured for Delphi review');
+  // eslint-disable-next-line no-console
+  console.log('');
+
+  const commit = execSync('git rev-parse HEAD 2>/dev/null || echo "no-commit"', { encoding: 'utf8' }).trim();
+  const expires = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
+
+  const uiResult: UiReviewResult = {
+    commit,
+    verdict: 'APPROVED',
+    expires,
+    design_review: 'APPROVED',
+    browser_qa: 'APPROVED',
+    ui_changes_detected: result.matchedFiles,
+  };
+
+  writeFileSync(join(process.cwd(), RESULT_FILE), JSON.stringify(uiResult, null, 2) + '\n', 'utf8');
+
+  // eslint-disable-next-line no-console
+  console.log(`✅ Generated ${RESULT_FILE} with APPROVED verdict (template)`);
+  // eslint-disable-next-line no-console
+  console.log(`   Commit: ${commit}`);
+  // eslint-disable-next-line no-console
+  console.log(`   Expires: ${expires}`);
+  // eslint-disable-next-line no-console
+  console.log('');
+  // eslint-disable-next-line no-console
+  console.log('⚠️  REVIEW THIS FILE before push:');
+  // eslint-disable-next-line no-console
+  console.log('   - Ensure design_review and browser_qa are actually APPROVED');
+  // eslint-disable-next-line no-console
+  console.log('   - Edit verdict to REJECTED if issues found');
+  // eslint-disable-next-line no-console
+  console.log('');
+  // eslint-disable-next-line no-console
+  console.log('Then: git push (pre-push will validate this file)');
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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.5.1",
+  "version": "0.5.3",
   "displayName": "XP-Gate",
   "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 6 quality gates, Sprint Flow, and Delphi multi-expert review.",
   "author": {

package/skills/sprint-flow/SKILL.md

@@ -53,6 +53,10 @@ maturity: beta
 ```
 Phase -1: ISOLATE → ⚠️ 检测保护分支(main/master/develop/trunk/mainline) → 强制创建 git worktree
             → 已在 worktree 中 → 跳过 → 项目 setup → .gitignore 校验 → sprint-state isolation 记录
+Phase -0.5: AUTO-ESTIMATE → 自动评估需求规模 → ⚠️ 展示评估结果，用户确认
+            → 轻量：跳过 brainstorming + delphi-review，直接 Phase 2 BUILD
+            → 标准：正常流程 Phase 0-4
+            → 复杂：完整流程 Phase 0-8 + 风险警告
 Phase 0: THINK → brainstorming → ⚠️ HARD-GATE: 设计未批准 → 不可进入实现 → Design Document (AI编辑行为约束: 原则3 Surgical Changes, 验证循环要求: 原则4 Goal-Driven Execution - 见 AGENTS.md "## AI CODING DISCIPLINE (Karpathy Principles)")
 Phase 1: PLAN → autoplan → ⚠️ (如有taste_decisions，暂停等用户确认)
            → delphi-review → ⚠️ (等待 APPROVED)
@@ -82,6 +86,7 @@ Phase 8: CLEANUP → git worktree remove + sprint-state.json update → status:
 | 暂停点位置 | 触发条件 | 用户操作 | 自动恢复条件 |
 |-----------|---------|---------|-------------|
 | **Phase -1** | ⚠️ **保护分支强制隔离 / --no-isolate 跳过** | 输出 ⚠️ 警告或自动创建 worktree | 自动创建或用户确认后继续 |
+| **Phase -0.5** | **AUTO-ESTIMATE 结果展示** | 接受建议 / 修改流程 / 取消 | 用户确认后按路由继续 |
 | **Phase 0** | ⚠️ **设计未 APPROVED (HARD-GATE)** | 根据反馈修改设计 | 设计 APPROVED 后继续 |
 | Phase 1 | autoplan surfacing taste_decisions | 用户确认每个决策 | 确认后自动继续 |
 | Phase 1 | delphi-review 未 APPROVED | 修复并重新评审 | APPROVED 后自动继续 |
@@ -155,16 +160,78 @@ Phase 8: CLEANUP → git worktree remove + sprint-state.json update → status:
 
 > **清理提示**: Sprint 完成（Phase 6 SHIP）后，执行 `git worktree remove <worktree_path>` 清理 worktree 目录，同时保留 `.sprint-state/` 中的历史记录。
 
+### Phase -0.5: AUTO-ESTIMATE（自动化规模评估与流程路由）
+
+**执行时机**: Phase -1 ISOLATE 完成后、Phase 0 THINK 之前。**自动执行**。
+
+**目的**: 自动评估需求规模，匹配适度流程，避免小需求走重量级流程造成资源浪费。不依赖人/AI 主观判断，而是通过代码结构分析提供客观指标。
+
+**详细指令**: 参见 `references/phase-minus-0-5-auto-estimate.md`
+
+#### 快速参考
+
+**步骤**:
+1. **识别需求类型** — 删除/修改已存在代码 → 立即分析；新增功能 → brainstorming 后分析
+2. **收集指标** — 引用计数 (`grep -rn`)、跨模块依赖 (目录分布)、循环依赖、Public API 暴露、测试文件数
+3. **汇总评估** — 综合打分 → 轻量 / 标准 / 复杂
+4. **输出结果** — 使用 `templates/auto-estimate-output-template.md` 标准格式
+5. **用户确认** — 接受建议 / 修改流程 / 取消
+6. **路由执行** — 按最终级别进入对应 Phase
+
+**路由决策表**:
+
+| 评估结果 | 路由 | 说明 |
+|---------|------|------|
+| **轻量** (引用 ≤3, 同模块，无循环依赖) | 跳过 Phase 0 brainstorming + Phase 1 delphi-review → 直接进入 Phase 2 BUILD | 小改动不需要完整流程 |
+| **标准** (引用 4-10, 跨 1-2 模块) | 正常流程 Phase 0-4 | 标准 sprint |
+| **复杂** (引用 >10 或 循环依赖 或 跨 3+ 模块) | 完整 Phase 0-8 + 风险警告 | 高风险需求 |
+
+**输出模板**: `templates/auto-estimate-output-template.md`
+**学习日志**: `templates/auto-estimate-learning-log.md`（记录用户 override，用于阈值优化）
+
+**输出格式**:
+```
++-------------------------------------------------------------+
+| AUTO-ESTIMATE 评估结果                                        |
++-------------------------------------------------------------+
+| 需求：{task_description}                                      |
+| 类型：{change_type}                                          |
+|                                                             |
+| [{impact_level}] Impact: {impact_label}                      |
+|                                                             |
+| 引用：{ref_count} 处                                          |
+| 跨模块：{cross_module_count} 个 ({module_list})               |
+| 循环依赖：{circular_dep_status}                               |
+| Public API：{public_api_count} 个                             |
+|                                                             |
+| 建议流程：{recommended_flow}                                  |
+|                                                             |
+| {risk_warning}                                               |
+|                                                             |
+| [接受建议]  [修改流程]  [取消]                                 |
++-------------------------------------------------------------+
+```
+
+**纠偏机制**:
+- **接受建议**: 按推荐流程执行，记录 `user_decision: "accepted"`
+- **修改流程**: 用户选择其他级别，记录 `override_reason` 到 `.sprint-state/auto-estimate-learning.json`
+- **取消**: 停止本次 sprint
+
+**⚠️ 轻量路由的特殊处理**:
+- 轻量路由跳过 Phase 0 brainstorming 和 Phase 1 delphi-review
+- 但仍然执行 Phase 1→2 的 GITHOOKS-GATE 检查
+- Phase 2 BUILD 仍然执行完整 TDD + 盲评 + 验证
+
 ### Phase 0: THINK（需求探索与设计）
-- `brainstorming` (superpowers) — **HARD-GATE**: 设计未批准 → 不可进入实现
+- **Subagent dispatch**: orchestrator 通过 `task(category="deep", load_skills=["brainstorming"])` 启动独立 session
+- 输入: Phase -1 summary（worktree 路径）+ 用户原始需求
 - 输出: 结构化设计文档 → 直接作为 Phase 1 PLAN 的输入
-- 替代原因: office-hours 的 YC 六问适合新产品方向验证，brainstorming 的"设计批准才可进入实现"机制更适合 sprint-flow 场景
+- **HARD-GATE**: 设计未批准 → 不可进入实现
 
 ### Phase 1: PLAN（共识评审）
-- `autoplan` (gstack) — CEO → Design → Eng 自动流水线
-- `delphi-review` — 多轮匿名评审直到共识
-- `to-issues` — 将 APPROVED 的 PRD/spec 拆解为垂直切片 Issue（HITL/AFK + 依赖图 + effort 估算）
-- **specification.yaml** — 自动生成（含 User Stories 段）
+- **Subagent dispatch**: orchestrator 通过 `task(category="deep", load_skills=["autoplan", "delphi-review", "to-issues"])` 启动独立 session
+- 输入: phase-0-summary.md + 设计文档
+- 输出: `specification.yaml`（含 user_stories[]）+ `slices-manifest.json`
 
 **条件分支逻辑**:
 - IF autoplan AUTO_APPROVED + 无 taste_decisions → 跳过 delphi-review
@@ -236,7 +303,10 @@ Phase 2 第一步必须执行 DELPHI-GATE 检查。没有 delphi-review APPROVED
 - Phase 3 Gate M 会在 push 时验证 mock 密度
 
 ### Phase 3: REVIEW + TEST（验证）
-- `delphi-review --mode code-walkthrough` — 多专家匿名代码走查（代替 cross-model-review）
+- **Subagent dispatch**: orchestrator 通过 `task(category="deep", load_skills=["delphi-review", "test-specification-alignment"])` 启动独立 session
+- 输入: phase-2-summary.md + MVP 代码
+- 输出: 评审报告 + 测试对齐结果
+- `delphi-review --mode code-walkthrough` — 多专家匿名代码走查
 - `test-specification-alignment` — 测试与 Spec 对齐验证
 - `browse` (gstack) — 浏览器自动化测试
 - `k6` / `locust` / `gatling` — 负载/压力测试（可选，后端项目）
@@ -255,21 +325,32 @@ Phase 2 第一步必须执行 DELPHI-GATE 检查。没有 delphi-review APPROVED
 - 即使用户说"赶时间"、"跳过验收"、"直接发布"，也必须暂停等待用户确认
 - 使用 `@templates/emergent-issues-template.md` 检查清单
 
-### Phase 5: FEEDBACK CAPTURE（反馈捕获）
-- ⚠️ **HARD-GATE: Phase 5 不可跳过。Phase 4 完成后（无论验收通过/跳过/推迟）→ 必须进入 Phase 5 → 完成后才能进入 Phase 6。**
-- `learn` (gstack) — 模式记录
-- `retro` (gstack) — 工程回顾：提交历史、工作模式、代码质量趋势
-- `systematic-debugging` (superpowers) — 根因调试（反馈中的 bug 做根因分析，Iron Law：无调查无修复）
+### Phase 5: FEEDBACK CAPTURE（反馈获取）
+- **Subagent dispatch**: orchestrator 通过 `task(category="quick", load_skills=["learn", "retro", "systematic-debugging"])` 启动独立 session
+- 输入: phase-4-summary.md（验收结果）+ emergent-issues.md（如有）
+- 输出: `feedback-log.md`
+- **HARD-GATE**: Phase 5 不可跳过。Phase 4 完成后 → 必须进入 Phase 5 → 完成后才能进入 Phase 6。
+- **`learn` (gstack)** — Sprint 级复盘（这是 /learn 在本项目中的主要调用时机）
+  - ralph-loop 已在 BUILD Phase 内部实现 per-REQ learn（permanent/contextual 分类）
+  - Phase 5 额外进行 Sprint 级复盘，总结全 Phase 经验
+- **`retro` (gstack)** — 工程回顾：提交历史、工作模式、代码质量趋势
+- **`systematic-debugging` (superpowers)** — 根因调试
 
 ### Phase 6: SHIP（发布准备）
-- ⚠️ **HARD-GATE: Phase 5 未完成 → 不可进入 Phase 6。验证 `.sprint-state/phase-outputs/feedback-log.md` 存在。**
+- **Subagent dispatch**: orchestrator 通过 `task(category="quick", load_skills=["finishing-a-development-branch", "ship"])` 启动独立 session
+- 输入: phase-5-summary.md + feedback-log.md
+- 输出: PR URL
+- **HARD-GATE**: Phase 5 未完成 → 不可进入 Phase 6。验证 `.sprint-state/phase-outputs/feedback-log.md` 存在。
 - **⚠️ GITHOOKS-GATE**: 再次验证 hooks 完整性（Phase 2 的 TDD 编码已触发提交，SHIP 阶段还会再次提交）
   - 运行 `githooks/verify.sh` → 缺失 → `githooks/install.sh` → 阻断直至修复
 - **`finishing-a-development-branch`** (superpowers) — 结构化完成流：4 选项（merge / PR / discard / keep）
 - `ship` (gstack) — 创建 PR（PR 路径时使用）
 - Phase 6 输出：PR URL（用于 Phase 7 输入）
 
-### Phase 7: ⚠️ LAND（合并 + 部署）
+### Phase 7:  LAND（合并 + 部署）
+- **Subagent dispatch**: orchestrator 通过 `task(category="deep", load_skills=["land-and-deploy"])` 启动独立 session
+- 输入: phase-6-summary.md + PR URL
+- 输出: 部署状态 + Canary 报告
 - 输入：Phase 6 输出的 PR URL
 - 调用：`land-and-deploy` skill
 - 流程：
@@ -302,7 +383,149 @@ Phase 2 第一步必须执行 DELPHI-GATE 检查。没有 delphi-review APPROVED
 
 ---
 
-## Output Format (MANDATORY)
+## 编排层规则（Orchestration Rules）
+
+### Agent Dispatch Rules
+
+| Agent Type | 适用场景 | 不适用场景 | 超时处理 |
+|-----------|---------|-----------|---------|
+| `explore` (bare) | **窄搜索**：单个关键词/pattern，已知文件位置 | 多角度宽泛搜索，读取大文件，3+ search angles | >5min → cancel + 用 `deep` 重试 |
+| `librarian` (bare) | **外部参考**：API 文档、OSS 示例 | 内部代码库宽泛探索 | >5min → cancel + 用 `deep` 重试 |
+| `task(category="deep")` | **复杂研究**：多模块分析，架构决策 | 单文件 trivial fix | 无限制 |
+| `task(category="unspecified-high")` | **高 effort 实现**：新模块、重构 | 单行修改 | 无限制 |
+
+**关键规则**：
+
+1. Bare `explore` agent 本质是 contextual grep，**不是研究 agent**。如果任务涉及：
+   - 3+ 个独立搜索角度
+   - 读取多个大文件（>200 行）
+   - 需要跨层分析（如"查 ralph-loop + .sprint-state/ + token 阈值 + phase transition"）
+   
+   → **必须用 `task(category="deep", load_skills=[...])` 替代**
+
+2. 如果 `explore` agent >5 分钟未返回 → cancel 并立即用 `task(category="deep")` 重试。不要等待。
+
+3. **并行 explore 仍然是正确模式**。2-4 个窄搜索 explore agent 并行执行是高效且推荐的。问题在于给单一 explore agent 分配宽泛任务。
+
+**issue #83 根因**：`bg_1abf2ed9` 被分配了 4 个独立搜索角度的宽泛任务（ralph-loop context + .sprint-state/ + token threshold + phase transition），bare explore agent 超时丢失 session。同批的 `bg_5ecf590d`（窄搜索 OpenCode compaction API）3m35s 正常完成。
+
+### Phase Subagent Dispatch Matrix
+
+| Phase | 名称 | Subagent? | Category | load_skills | 执行者 |
+|-------|------|:---------:|----------|-------------|--------|
+| -1 | ISOLATE | ❌ | Bash（直接执行） | 无 | orchestrator |
+| -0.5 | AUTO-ESTIMATE | ❌ | Bash（直接执行） | 无 | orchestrator |
+| 0 | THINK | ✅ | `deep` | `["brainstorming"]` | subagent |
+| 1 | PLAN | ✅ | `deep` | `["autoplan", "delphi-review", "to-issues"]` | subagent |
+| 2 | BUILD | ✅(已有) | ralph-loop | `["test-driven-development"]` | subagent |
+| 3 | REVIEW | ✅ | `deep` | `["delphi-review", "test-specification-alignment"]` | subagent |
+| 4 | USER ACCEPT | ❌ | **强制人工** | 无 | 用户 |
+| 5 | FEEDBACK | ✅ | `quick` | `["learn", "retro", "systematic-debugging"]` | subagent |
+| 6 | SHIP | ✅ | `quick` | `["finishing-a-development-branch", "ship"]` | subagent |
+| 7 | LAND | ✅ | `deep` | `["land-and-deploy"]` | subagent |
+| 8 | CLEANUP | ❌ | Bash（直接执行） | 无 | orchestrator |
+
+**上下文隔离原则**：
+- 每个 Subagent 在**独立 session** 中启动，不继承 orchestrator 的对话历史
+- orchestrator session 仅接收 subagent 的最终结果摘要（~13,000 tokens/sprint）
+- 现代模型百万 token 上下文 + 缓存命中 → 单 sprint 不会触发 overflow
+
+### CONTEXT INHERITANCE
+
+每个 Phase subagent 启动时，上下文仅通过以下路径继承：
+
+| Phase | 加载来源 | 内容 |
+|-------|---------|------|
+| Phase -1 | 无前置（Bash 操作） | 用户原始需求 + 当前分支状态 |
+| Phase 0 | phase--1-summary（仅路径） | 隔离环境信息（worktree 路径） |
+| Phase 1 | phase-0-summary.md + design-doc | 设计决策 + 结构化规格 |
+| Phase 2 | phase-1-summary.md + specification.yaml | 评审结论 + REQ 列表 |
+| Phase 3 | phase-2-summary.md + MVP 代码 | 构建结果 |
+| Phase 4 | — | **人工验收**。Phase 4 不产生 subagent summary，但用户验收结果记录在 `.sprint-state/phase-outputs/emergent-issues.md`（如有 emergent issues）。Phase 5 加载此文件。 |
+| Phase 5 | phase-4-summary.md + emergent-issues.md | 验收结论 |
+| Phase 6 | phase-5-summary.md + feedback-log.md | 复盘结论 |
+| Phase 7 | phase-6-summary.md + PR URL | 发布准备 |
+| Phase 8 | phase-7-summary（Bash 操作） | 部署结果 |
+
+**隔离原则**：每个 Phase subagent 在干净上下文中启动。
+输入仅限上表对应的摘要文件和一级产出物。
+不包含前一 Phase 的完整对话、中间文件、失败尝试。
+
+**特殊场景**：
+- `--resume-from <phase>`：跳过前置 Phase，直接从指定 Phase 启动。此时要求该 Phase 的前置摘要文件已存在。例如 `--resume-from build` 要求 `phase-1-summary.md` 和 `specification.yaml` 已存在。orchestrator 仍执行 Phase Transition Gate 验证。
+- `--no-isolate`：跳过 Phase -1 ISOLATE，直接在当前分支执行。Phase 0 无 `phase--1-summary` 可用，上下文继承来源为用户原始需求 + 当前 git 状态。所有后续 Phase 的 worktree enforcement 不适用（无 worktree），但仍需保持代码隔离。
+- `next_phase_context` 中的 `{path}` 等变量占位符在实际写入时被替换为具体值。示例中的 `{path}` 应替换为实际 worktree 路径（如 `.worktrees/sprint/sprint-2026-06-01-01`）。
+
+### PHASE TRANSITION RULES
+
+每个 Phase subagent 完成后，必须按顺序执行以下步骤：
+
+1. **写入 Phase 摘要**：创建 `.sprint-state/phase-outputs/phase-{N}-summary.md`
+   - 格式：YAML frontmatter + Markdown body（body ≤ 50 行）
+   - 大小限制：≤ 40,000 字符（≈ 10,000 tokens）
+
+2. **更新 sprint-state.json**：
+   - `phase`: 当前阶段编号
+   - `outputs`: 新增当前阶段输出文件路径
+
+3. **等待用户确认 checkpoint**（如适用）
+
+### Phase Summary 格式（YAML Frontmatter Schema）
+
+每个 `phase-N-summary.md` 必须包含以下 YAML frontmatter：
+
+```markdown
+---
+phase: -1
+phase_name: ISOLATE
+status: completed
+outputs:
+  - path: ".worktrees/sprint/sprint-YYYY-MM-DD-NN"
+    type: directory
+decisions:
+  - title: "Worktree isolation enabled"
+    rationale: "Prevent main branch pollution"
+unresolved_issues: []
+next_phase_context: "Worktree created at {path}. All subsequent edits MUST use this workdir."
+---
+
+## Phase Summary
+{简明摘要，不超过 50 行}
+```
+
+**必填字段**: `phase`, `phase_name`, `status`, `outputs`, `decisions`, `next_phase_context`
+**可选字段**: `unresolved_issues`
+
+### Phase Transition Gate
+
+Orchestrator dispatch 下一 Phase 前必须执行验证：
+
+```bash
+SUMMARY=".sprint-state/phase-outputs/phase-${N}-summary.md"
+[ -f "$SUMMARY" ] || { echo "[BLOCK] phase-${N}-summary 不存在"; exit 1; }
+FRONTMARKERS=$(grep -c "^---" "$SUMMARY" 2>/dev/null || echo 0)
+[ "$FRONTMARKERS" -ge 2 ] || { echo "[BLOCK] YAML frontmatter 格式不完整"; exit 1; }
+grep -q "^phase:" "$SUMMARY" || { echo "[BLOCK] 缺少 phase 字段"; exit 1; }
+grep -q "^phase_name:" "$SUMMARY" || { echo "[BLOCK] 缺少 phase_name 字段"; exit 1; }
+grep -q "^status:" "$SUMMARY" || { echo "[BLOCK] 缺少 status 字段"; exit 1; }
+grep -q "^decisions:" "$SUMMARY" || { echo "[BLOCK] 缺少 decisions 字段"; exit 1; }
+grep -q "^outputs:" "$SUMMARY" || { echo "[BLOCK] 缺少 outputs 字段"; exit 1; }
+grep -q "^next_phase_context:" "$SUMMARY" || { echo "[BLOCK] 缺少 next_phase_context"; exit 1; }
+CHARS=$(wc -c < "$SUMMARY" | tr -d ' ')
+[ "$CHARS" -le 40000 ] || { echo "[BLOCK] 摘要超出大小限制 (${CHARS}/40000 chars)"; exit 1; }
+```
+
+**由 orchestrator 强制执行**，不依赖 subagent 自觉遵守。
+验证失败 → BLOCK，不可 dispatch 下一 Phase。
+
+### WORKTREE ENFORCEMENT（Issue #84）
+
+Phase -1 执行完毕后，**所有后续操作（Phase 0 到 Phase 8）的文件编辑、命令执行 MUST 在 worktree 目录下执行**：
+
+- **工作目录**：所有 Bash 命令必须通过 `workdir` 参数或 `&&` 链式命令在 worktree 路径下执行
+- **文件写入**：所有 `write`、`edit` 工具的 `filePath` 必须位于 `isolation.worktree_path` 下
+- **验证步骤**：Phase 0 开始前，输出 `[WORKTREE] 后续所有操作将在 {worktree_path} 中进行`
+- **例外**：`.gitignore` 校验（Phase -1 表步 4）和 `git worktree remove`（Phase 8 清理）在仓库根目录执行
 Sprint state is persisted as JSON in `.sprint-state/sprint-state.json`:
 ```json
 {
@@ -315,6 +538,22 @@ Sprint state is persisted as JSON in `.sprint-state/sprint-state.json`:
     "created_from": "main",
     "created_from_commit": "abc123def..."
   },
+  "auto_estimate": {
+    "change_type": "删除已存在代码|修改已存在代码|新增功能|Bug修复",
+    "metrics": {
+      "ref_count": 12,
+      "cross_module_count": 3,
+      "modules": ["auth", "user", "admin"],
+      "circular_dep": true,
+      "public_api_count": 5,
+      "test_file_count": 4
+    },
+    "estimated_level": "轻量|标准|复杂",
+    "recommended_flow": "轻量流程 (Phase 2-3)|标准流程 (Phase 0-4)|完整 Sprint Flow (Phase 0-8)",
+    "risk_warnings": ["循环依赖: user ↔ plane"],
+    "user_decision": "accepted|overridden|cancelled",
+    "override_reason": null
+  },
   "outputs": {
     "pain_document": "docs/pain-document.md",
     "specification": "specification.yaml",

package/skills/sprint-flow/evals/evals.json

@@ -51,12 +51,64 @@
       "name": "stop-at-plan",
       "category": "boundary",
       "prompt": "我想先看看方案再决定要不要继续开发。执行/sprint-flow '给XP-Gate添加代码覆盖率趋势分析功能' --stop-at plan",
-      "expected_output": "只执行到Phase 1(Plan)就停止，输出specification.yaml后等待用户决定。不应自动进入Phase 2。",
+      "expected_output": "只执行到Phase 1(Plan)后停止，输出specification.yaml并等待用户决定。不应自动进入Phase 2。",
       "files": [],
       "assertions": [
         {"name": "stops-at-plan", "type": "contains", "value": "specification.yaml"},
         {"name": "no-build-phase", "type": "not_contains", "value": "Phase 2"}
       ]
+    },
+    {
+      "id": 5,
+      "name": "phase-subagent-dispatch",
+      "category": "normal",
+      "prompt": "sprint-flow '开发一个用户反馈表单功能'，请执行 Phase 0 THINK 阶段",
+      "expected_output": "Phase 0 THINK 必须通过独立 subagent 执行（task with category=deep 和 load_skills=['brainstorming']），而不是在同一 session 内。subagent 输入应包含 phase--1-summary 的 worktree 路径。输出设计文档。",
+      "files": [],
+      "assertions": [
+        {"name": "subagent-dispatch-think", "type": "contains", "value": "category"},
+        {"name": "brainstorming-skill-loaded", "type": "contains", "value": "brainstorming"},
+        {"name": "design-doc-output", "type": "contains", "value": "设计文"}
+      ]
+    },
+    {
+      "id": 6,
+      "name": "context-inheritance-across-phases",
+      "category": "normal",
+      "prompt": "sprint-flow 进入 Phase 3 REVIEW 阶段，前两个阶段已完成。Phase 1 产出了 specification.yaml，Phase 2 产出了 MVP 代码。",
+      "expected_output": "Phase 3 必须加载 phase-2-summary.md 和 MVP 作为输入。Phase summary 应包含 YAML frontmatter 和必填字段（phase, decisions, next_phase_context）。",
+      "files": [],
+      "assertions": [
+        {"name": "load-phase-2-summary", "type": "contains", "value": "phase-2-summary"},
+        {"name": "yaml-frontmatter-schema", "type": "contains", "value": "frontmatter"},
+        {"name": "reviews-existing-code", "type": "contains", "value": "MVP"}
+      ]
+    },
+    {
+      "id": 7,
+      "name": "phase-transition-gate-enforcement",
+      "category": "boundary",
+      "prompt": "sprint-flow Phase 1 完成后，Phase summary 文件忘记写了，直接要进入 Phase 2。会发生什么？",
+      "expected_output": "Phase Transition Gate 检查 phase-1-summary.md 是否存在。如果缺失，必须 BLOCK 不可 dispatch Phase 2。orchestrator 强制执行验证。",
+      "files": [],
+      "assertions": [
+        {"name": "gate-blocks-missing-summary", "type": "contains", "value": "BLOCK"},
+        {"name": "summary-required", "type": "contains", "value": "summary"},
+        {"name": "orchestrator-enforces", "type": "contains", "value": "orchestrator"}
+      ]
+    },
+    {
+      "id": 8,
+      "name": "worktree-enforcement-issue-84",
+      "category": "boundary",
+      "prompt": "sprint-flow Phase -1 创建了 worktree，但 agent 开始在主目录编辑文件而不是在 worktree 目录下。这有什么问题？",
+      "expected_output": "指出 Phase -1 完成后，所有后续文件编辑必须在 worktree 目录下执行。主目录编辑不会同步到 worktree，导致 merge conflicts 和文件遗漏。",
+      "files": [],
+      "assertions": [
+        {"name": "worktree-required", "type": "contains", "value": "worktree"},
+        {"name": "all-edits-in-worktree", "type": "contains", "value": "所有"},
+        {"name": "merge-conflict-risk", "type": "contains", "value": "merge"}
+      ]
     }
   ],
   "trigger_evals": {

package/skills/sprint-flow/references/phase-minus-0-5-auto-estimate.md

@@ -0,0 +1,238 @@
+# Phase -0.5: AUTO-ESTIMATE（自动化规模评估与流程路由）
+
+**执行时机**: Phase -1 ISOLATE 完成后、Phase 0 THINK 之前。**自动执行**。
+
+**目的**: 自动评估需求规模，匹配适度流程，避免小需求走重量级流程造成资源浪费。
+
+**核心原则**: 
+- **客观指标 > 主观判断**：依赖代码结构分析，不依赖人/AI 的主观直觉
+- **显式告知**：用户看到客观指标，不是 AI 主观结论
+- **可纠偏**：用户可接受/修改/取消
+- **学习闭环**：记录用户 override，优化阈值
+
+---
+
+## 执行流程
+
+### 步骤 1: 识别需求类型
+
+分析用户输入的需求描述，判定变更类型：
+
+| 关键词模式 | 变更类型 | AUTO-ESTIMATE 时机 |
+|-----------|---------|-------------------|
+| 删除、移除、去掉、砍掉、清理 + 已有模块名 | 删除已存在代码 | 立即执行 |
+| 修改、改、调整、重构、优化 + 已有模块名 | 修改已存在代码 | 立即执行 |
+| 新增、添加、开发、实现、创建 + 新模块名 | 新增功能 | brainstorming 后执行 |
+| 修复、fix、bug | Bug 修复 | 立即执行 |
+| 无法判断 | 询问用户 | — |
+
+**IF 新增功能**: 跳过当前 AUTO-ESTIMATE，先执行 Phase 0 brainstorming，brainstorming 完成后以设计文档为输入重新执行 AUTO-ESTIMATE。
+
+**IF 删除/修改/Bug 修复**: 继续执行以下步骤。
+
+### 步骤 2: 收集指标
+
+#### 2.1 引用计数
+
+```bash
+# 从用户输入中提取目标关键词（模块名、函数名、类名）
+# 示例：删除平面维护界面 → target="plane", "平面"
+grep -rn "{target_pattern}" --include="*.{ext}" . | grep -v node_modules | grep -v .git | wc -l
+```
+
+**阈值**：
+- ≤3: 轻量
+- 4-10: 标准
+- >10: 复杂
+
+#### 2.2 跨模块依赖
+
+分析引用出现的目录分布：
+
+```bash
+# 提取引用所在的目录（取前两级目录）
+grep -rn "{target_pattern}" --include="*.{ext}" . | grep -v node_modules | grep -v .git | \
+  awk -F: '{print $1}' | sed 's|/[^/]*$||' | sort -u
+```
+
+**阈值**：
+- 1 个目录: 轻量
+- 2 个目录: 标准
+- 3+ 个目录: 复杂
+
+#### 2.3 循环依赖检测
+
+简单检查：如果 A 引用 B 且 B 引用 A，则存在循环依赖。
+
+```bash
+# 简化检测：检查目标是否导入其调用者
+# 这需要根据具体语言调整。对于 TS/JS:
+grep -rn "import.*{target}" --include="*.ts" --include="*.tsx" .
+grep -rn "import.*{caller}" --include="*.ts" --include="*.tsx" {target_dir}/
+```
+
+**阈值**：
+- 无: 正常
+- 存在: 高风险 → 无论如何输出风险警告
+
+#### 2.4 Public API 暴露
+
+```bash
+# 统计目标模块中 export 的数量
+grep -rn "^export " {target_dir}/ --include="*.ts" | wc -l
+```
+
+**阈值**：
+- ≤2: 低影响
+- 3-5: 中影响
+- >5: 高影响 → 输出风险警告
+
+#### 2.5 相关测试文件
+
+```bash
+# 统计与目标相关的测试文件数
+find . -name "*{target}*.test.*" -o -name "*{target}*.spec.*" | grep -v node_modules | wc -l
+```
+
+**阈值**：
+- 0: 无测试覆盖（风险提示）
+- 1-2: 正常
+- >3: 重构工作量大 → 提示
+
+### 步骤 3: 汇总评估
+
+根据各指标得分，汇总整体评估结果：
+
+```
+总分计算：
+- 引用计数：轻量=1, 标准=2, 复杂=3
+- 跨模块：轻量=1, 标准=2, 复杂=3
+- 循环依赖：无=0, 存在=5（强制复杂）
+- Public API：低=0, 中=1, 高=2
+- 测试文件：正常=0, 多=1
+
+总分：1-3 = 轻量 | 4-6 = 标准 | 7+ 或 循环依赖存在 = 复杂
+```
+
+### 步骤 4: 输出评估结果
+
+使用 `templates/auto-estimate-output-template.md` 的标准格式向用户展示评估结果。
+
+**MUST** 遵循模板格式，包含：
+- 需求描述 + 变更类型
+- 影响级别标识
+- 各项指标的具体数值
+- 建议流程
+- 风险警告（如有）
+- 用户操作选项
+
+### 步骤 5: 处理用户选择
+
+#### 用户选择「接受建议」
+
+> 按推荐流程执行。保存评估结果到 sprint-state.json。
+
+```json
+{
+  "auto_estimate": {
+    "change_type": "删除已存在代码",
+    "metrics": {
+      "ref_count": 12,
+      "cross_module_count": 3,
+      "modules": ["auth", "user", "admin"],
+      "circular_dep": true,
+      "public_api_count": 5,
+      "test_file_count": 4
+    },
+    "estimated_level": "复杂",
+    "recommended_flow": "完整 Sprint Flow (Phase 0-8)",
+    "risk_warnings": ["循环依赖: user ↔ plane"],
+    "user_decision": "accepted"
+  }
+}
+```
+
+#### 用户选择「修改流程」
+
+> 展示修改流程子菜单（3 个选项：轻量/标准/完整）。
+> 要求用户输入修改原因（必填）。
+
+记录到学习日志：
+```json
+{
+  "sprint_id": "{sprint_id}",
+  "task_description": "{需求描述}",
+  "estimated_level": "标准",
+  "user_override_level": "轻量",
+  "override_reason": "{用户输入原因}",
+  "timestamp": "{当前时间}"
+}
+```
+
+数据写入 `.sprint-state/auto-estimate-learning.json`（追加模式）。
+
+#### 用户选择「取消」
+
+> 停止本次 sprint。
+> 输出：`[CANCELLED] 用户取消 Sprint，AUTO-ESTIMATE 评估结果为 {estimated_level}`。
+
+### 步骤 6: 路由执行
+
+根据最终确定的流程级别，进入对应 Phase：
+
+| 流程级别 | 路由 |
+|---------|------|
+| **轻量** | → Phase 2 BUILD（跳过 Phase 0 brainstorming、Phase 1 delphi-review） |
+| **标准** | → Phase 0 THINK（正常流程） |
+| **复杂** | → Phase 0 THINK（完整流程 + 风险警告提示） |
+
+---
+
+## 特殊场景处理
+
+### 场景 1: 小改动（总计 < 20 行新增/删除代码）
+
+```bash
+# 检查预估改动量
+git diff --stat HEAD 2>/dev/null  # 如果有局部修改
+```
+
+**处理**: 如果预估改动 < 20 行且涉及 ≤ 2 个文件，自动判定为「轻量」并告知用户，不强制展示完整 AUTO-ESTIMATE 面板。
+
+### 场景 2: 无法提取目标关键词
+
+**处理**: 询问用户「无法自动识别目标模块，请指定要分析的关键词（函数名/类名/模块名）：」
+
+### 场景 3: 用户输入包含多个独立需求
+
+**处理**: 提示用户「检测到多个独立需求，建议分别执行 sprint。是否拆分？」→ 等待确认
+
+---
+
+## 与学习循环的集成
+
+### 数据收集
+
+每次 sprint 完成（Phase 8 CLEANUP）后，将以下数据记录到 `.sprint-state/auto-estimate-learning.json`：
+
+```json
+{
+  "entries": [
+    {
+      "sprint_id": "sprint-YYYY-MM-DD-NN",
+      "estimated_level": "标准",
+      "user_decision": "accepted",
+      "actual_effort_phase_count": 5,
+      "actual_duration_minutes": 45,
+      "was_accurate": true
+    }
+  ]
+}
+```
+
+### 阈值优化
+
+当积累 ≥ 20 条记录后，提示用户可以运行阈值分析：
+
+> 已积累 {n} 条 AUTO-ESTIMATE 记录。是否运行阈值优化分析？
+> 分析会检查：过度估计（建议标准但实际轻量）、低估（建议轻量但实际复杂），并推荐阈值调整。

package/skills/sprint-flow/templates/auto-estimate-learning-log.md

@@ -0,0 +1,136 @@
+# AUTO-ESTIMATE 学习日志
+
+本文件记录 AUTO-ESTIMATE 的用户纠偏历史和完成数据，用于阈值迭代优化。
+
+## 文件位置
+
+`.sprint-state/auto-estimate-learning.json`
+
+## JSON Schema
+
+```json
+{
+  "entries": [
+    {
+      "sprint_id": "sprint-2026-06-01-14",
+      "task_description": "实现issue92 auto-estimate",
+      "change_type": "新增功能",
+      "estimated_level": "标准",
+      "estimated_metrics": {
+        "ref_count": null,
+        "cross_module_count": 2,
+        "circular_dep": false,
+        "public_api_count": 0,
+        "test_file_count": 0
+      },
+      "user_decision": "accepted",
+      "override_reason": null,
+      "actual_outcome": {
+        "phase_count": 3,
+        "duration_estimate": "30-45min",
+        "was_accurate": true,
+        "notes": "纯文档修改，实际确实为标准级别"
+      },
+      "timestamp": "2026-06-01T23:35:00+08:00"
+    }
+  ],
+  "summary": {
+    "total_entries": 1,
+    "accepted_count": 1,
+    "overridden_count": 0,
+    "accurate_count": 1,
+    "over_estimate_count": 0,
+    "under_estimate_count": 0,
+    "last_updated": "2026-06-01T23:35:00+08:00"
+  }
+}
+```
+
+## 字段说明
+
+### Entry 级别
+
+| 字段 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `sprint_id` | string | ✅ | Sprint 标识符 |
+| `task_description` | string | ✅ | 需求描述 |
+| `change_type` | string | ✅ | 变更类型：`删除已存在代码` / `修改已存在代码` / `新增功能` / `Bug修复` |
+| `estimated_level` | string | ✅ | 评估级别：`轻量` / `标准` / `复杂` |
+| `estimated_metrics` | object | ✅ | 评估时的指标数据 |
+| `user_decision` | string | ✅ | 用户决定：`accepted` / `overridden` / `cancelled` |
+| `override_reason` | string | 条件 | 当 `user_decision` 为 `overridden` 时必填 |
+| `actual_outcome` | object | 条件 | Sprint 完成后回填 |
+| `timestamp` | string | ✅ | ISO 8601 时间戳 |
+
+### actual_outcome 级别
+
+| 字段 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `phase_count` | number | ✅ | 实际执行的 phase 数 |
+| `duration_estimate` | string | 推荐 | 实际耗时估算 |
+| `was_accurate` | boolean | ✅ | 评估是否准确 |
+| `notes` | string | 推荐 | 备注说明 |
+
+### summary 级别
+
+| 字段 | 类型 | 说明 |
+|------|------|------|
+| `total_entries` | number | 总条目数 |
+| `accepted_count` | number | 接受建议数 |
+| `overridden_count` | number | 用户修改数 |
+| `accurate_count` | number | 评估准确数 |
+| `over_estimate_count` | number | 高估数（建议标准但实际轻量） |
+| `under_estimate_count` | number | 低估数（建议轻量但实际复杂） |
+
+## 初始化
+
+新 sprint 创建时，自动创建 `.sprint-state/auto-estimate-learning.json`：
+
+```json
+{
+  "entries": [],
+  "summary": {
+    "total_entries": 0,
+    "accepted_count": 0,
+    "overridden_count": 0,
+    "accurate_count": 0,
+    "over_estimate_count": 0,
+    "under_estimate_count": 0,
+    "last_updated": null
+  }
+}
+```
+
+## 阈值优化触发
+
+当 `total_entries >= 20` 时，在 Phase 8 CLEANUP 阶段提示用户：
+
+```
+已积累 20 条 AUTO-ESTIMATE 记录。是否运行阈值优化分析？
+
+当前准确率：{accurate_count / total_entries * 100}%
+高估率：{over_estimate_count / total_entries * 100}%
+低估率：{under_estimate_count / total_entries * 100}%
+
+[运行分析] [跳过]
+```
+
+## 阈值优化规则
+
+### 高估模式检测
+
+IF `over_estimate_count / total_entries > 30%`:
+→ 建议降低「标准」→「复杂」的引用计数阈值（当前 >10）
+→ 分析高估的共性：是否某个指标权重过高？
+
+### 低估模式检测
+
+IF `under_estimate_count / total_entries > 20%`:
+→ 建议增加额外检查项（如循环依赖、测试文件数）
+→ 分析低估的共性：是否遗漏了关键复杂度信号？
+
+### 纠偏频率检测
+
+IF `overridden_count / total_entries > 30%`:
+→ 用户频繁修改建议 → 阈值体系可能有问题
+→ 建议全面阈值校准

package/skills/sprint-flow/templates/auto-estimate-output-template.md

@@ -0,0 +1,130 @@
+# AUTO-ESTIMATE 输出模板
+
+本模板定义了 Phase -0.5 在终端向用户展示 AUTO-ESTIMATE 结果的标准格式。
+
+## 输出格式
+
+```
++-------------------------------------------------------------+
+| AUTO-ESTIMATE 评估结果                                        |
++-------------------------------------------------------------+
+| 需求：{task_description}                                      |
+| 类型：{change_type}                                          |
+|                                                             |
+| [{impact_level}] Impact: {impact_label}                      |
+|                                                             |
+| 引用：{ref_count} 处                                          |
+| 跨模块：{cross_module_count} 个 ({module_list})               |
+| 循环依赖：{circular_dep_status}                               |
+| Public API：{public_api_count} 个                             |
+| {additional_metrics}                                         |
+|                                                             |
+| 建议流程：{recommended_flow}                                  |
+|                                                             |
+| {risk_warning}                                               |
+|                                                             |
+| [接受建议]  [修改流程]  [取消]                                 |
++-------------------------------------------------------------+
+```
+
+## 字段说明
+
+| 字段 | 说明 | 示例 |
+|------|------|------|
+| `{task_description}` | 用户输入的需求描述 | 删除平面维护界面 |
+| `{change_type}` | 变更类型 | 删除/修改已存在代码 或 新增功能 |
+| `{impact_level}` | 影响级别标识 | `[轻量]` / `[标准]` / `[复杂]` |
+| `{impact_label}` | 影响级别标签 | 低 / 中 / 高 |
+| `{ref_count}` | 引用出现次数 | 12 |
+| `{cross_module_count}` | 跨模块数量 | 3 |
+| `{module_list}` | 涉及模块名列表 | auth, user, admin |
+| `{circular_dep_status}` | 循环依赖状态 | ✅ 无 / ⚠️ 存在 (A ↔ B) |
+| `{public_api_count}` | Public API 暴露数 | 5 |
+| `{additional_metrics}` | 附加指标（可选行） | 测试文件：4 个 / 影响范围：3 层调用 |
+| `{recommended_flow}` | 建议流程描述 | 轻量流程 (Phase 2-3) |
+| `{risk_warning}` | 风险警告（可选块） | ⚠️ 此操作涉及循环依赖… |
+| 操作按钮 | 用户确认选项 | 接受建议 / 修改流程 / 取消 |
+
+## 风险警告格式
+
+当检测到高风险信号时（循环依赖、大范围 Public API、>10 处引用），追加风险警告块：
+
+```
+|                                                             |
+| ⚠️ {risk_description}                                        |
+|   {mitigation_suggestion}                                    |
+|                                                             |
+```
+
+示例：
+```
+|                                                             |
+| ⚠️ 此操作涉及循环依赖，建议保留层级结构作为过渡方案           |
+|   避免直接删除导致编译失败                                    |
+|                                                             |
+```
+
+## 修改流程子菜单
+
+当用户选择「修改流程」时，展示以下选项：
+
+```
++-------------------------------------------------------------+
+| 选择流程级别：                                                |
+|                                                             |
+| [1] 轻量流程 — 直接编码 + 基础验证 (Phase 2-3)               |
+| [2] 标准流程 — brainstorming + BUILD + REVIEW (Phase 0-4)    |
+| [3] 完整流程 — 完整 Sprint Flow (Phase 0-8)                  |
+|                                                             |
+| 修改原因（必填）：____________________                        |
+|                                                             |
+| [确认]  [取消]                                                |
++-------------------------------------------------------------+
+```
+
+## 指标计算规则
+
+### 对于删除/修改已存在代码
+
+| 指标 | 计算方式 | 工具 |
+|------|---------|------|
+| 引用计数 | `grep -rn "{target_pattern}" --include="*.{ext}" | wc -l` | bash |
+| 跨模块依赖 | 分析 import 语句中不同目录层级的引用 | bash + grep |
+| 循环依赖 | 检查 import 图是否存在环（简单检查：A imports B, B imports A） | bash |
+| Public API 暴露 | `grep -rn "^export "` 计数 | bash |
+| 测试文件数 | `find . -name "*{target}*.test.*" | wc -l` | bash |
+
+### 对于新增功能（brainstorming 后）
+
+| 指标 | 计算方式 | 来源 |
+|------|---------|------|
+| 新增模块数 | 设计文档中列出的模块数 | Phase 0 输出 |
+| 跨系统集成 | 涉及 API/DB/外部 数量 | Phase 0 输出 |
+| 状态复杂度 | 状态机状态数 | Phase 0 输出 |
+| REQ 数量 | user_stories 数量 | Phase 1 输出 |
+
+## 路由决策表
+
+| 评估结果 | 路由 | 说明 |
+|---------|------|------|
+| **轻量** (引用 ≤3, 同模块，无循环依赖) | Phase 2-3（跳过 brainstorming + delphi-review） | 直接编码 + 基础验证 |
+| **标准** (引用 4-10, 跨 1-2 模块) | Phase 0-4（完整 THINK → BUILD → REVIEW） | 标准 sprint |
+| **复杂** (引用 >10 或 循环依赖 或 跨 3+ 模块) | Phase 0-8（完整 sprint-flow） | 完整流程 + 风险警告 |
+
+## 学习闭环
+
+当用户选择「修改流程」时，记录 override 数据：
+
+```json
+{
+  "sprint_id": "sprint-YYYY-MM-DD-NN",
+  "task_description": "原始需求描述",
+  "estimated_level": "标准",
+  "user_override_level": "轻量",
+  "override_reason": "用户输入原因",
+  "actual_effort": "TBD",
+  "timestamp": "ISO 8601"
+}
+```
+
+数据写入 `.sprint-state/auto-estimate-learning.json`（追加模式），用于阈值迭代优化。