@localsummer/incspec 0.2.6 → 0.3.0

package/src/lib/mode-utils.mjs

@@ -0,0 +1,265 @@
+/**
+ * 工作流模式工具函数
+ * 提供纯函数接口，无副作用
+ */
+
+import { MODE, STEPS } from './workflow.mjs';
+
+// ============ 类型定义 ============
+
+/**
+ * @typedef {'full' | 'quick' | 'minimal'} WorkflowMode
+ * 工作流模式枚举
+ */
+
+/**
+ * @typedef {Object} ModeConfig
+ * @property {number[]} steps - 模式包含的步骤ID列表
+ * @property {number[]} skippedSteps - 模式跳过的步骤ID列表
+ * @property {string} label - 模式的显示标签
+ * @property {string} description - 模式的描述
+ * @property {number[]} archivableSteps - 可归档的步骤ID列表
+ */
+
+/**
+ * @typedef {Object} ValidationResult
+ * @property {boolean} valid - 是否有效
+ * @property {string} [reason] - 无效原因
+ */
+
+// ============ 常量定义 ============
+
+/**
+ * 模式配置映射表
+ * @type {Object.<string, ModeConfig>}
+ */
+export const MODE_CONFIG = {
+  full: {
+    steps: [1, 2, 3, 4, 5, 6, 7],
+    skippedSteps: [],
+    label: '完整模式',
+    description: '7步完整工作流，适合复杂功能开发和架构变更',
+    archivableSteps: [1, 2, 3, 4, 5, 6]  // 步骤7是归档本身，不可归档
+  },
+  quick: {
+    steps: [1, 2, 5, 6, 7],
+    skippedSteps: [3, 4],
+    label: '快速模式',
+    description: '5步简化工作流，跳过依赖采集和增量设计，适合简单功能迭代',
+    archivableSteps: [1, 2, 5, 6]
+  },
+  minimal: {
+    steps: [1, 5, 7],
+    skippedSteps: [2, 3, 4, 6],
+    label: '极简模式',
+    description: '3步最简工作流（分析→应用→归档），适合Bug修复和简单变更',
+    archivableSteps: [1, 5]  // 步骤7是归档本身，步骤6被跳过
+  }
+};
+
+/**
+ * 模式升级顺序（从宽松到严格）
+ */
+export const MODE_UPGRADE_ORDER = ['minimal', 'quick', 'full'];
+
+// ============ 模式判断函数 ============
+
+/**
+ * 判断工作流是否为极简模式
+ * @param {Object} workflow - 工作流状态对象
+ * @returns {boolean}
+ */
+export function isMinimalMode(workflow) {
+  return workflow?.mode === 'minimal';
+}
+
+/**
+ * 判断工作流是否为快速模式
+ * @param {Object} workflow - 工作流状态对象
+ * @returns {boolean}
+ */
+export function isQuickMode(workflow) {
+  return workflow?.mode === 'quick';
+}
+
+/**
+ * 判断工作流是否为完整模式
+ * @param {Object} workflow - 工作流状态对象
+ * @returns {boolean}
+ */
+export function isFullMode(workflow) {
+  return workflow?.mode === 'full';
+}
+
+// ============ 步骤管理函数 ============
+
+/**
+ * 获取指定模式包含的步骤ID列表
+ * @param {string} mode - 模式名称 ('full' | 'quick' | 'minimal')
+ * @returns {number[]} 步骤ID数组
+ * @throws {Error} 如果模式不存在
+ */
+export function getStepsForMode(mode) {
+  const config = MODE_CONFIG[mode];
+  if (!config) {
+    throw new Error(`Unknown mode: ${mode}`);
+  }
+  return [...config.steps];
+}
+
+/**
+ * 获取指定模式跳过的步骤ID列表
+ * @param {string} mode - 模式名称
+ * @returns {number[]} 跳过的步骤ID数组
+ * @throws {Error} 如果模式不存在
+ */
+export function getSkippedStepsForMode(mode) {
+  const config = MODE_CONFIG[mode];
+  if (!config) {
+    throw new Error(`Unknown mode: ${mode}`);
+  }
+  return [...config.skippedSteps];
+}
+
+/**
+ * 判断步骤在指定模式下是否激活（未被跳过）
+ * @param {number} stepId - 步骤ID (1-7)
+ * @param {string} mode - 模式名称
+ * @returns {boolean}
+ */
+export function isStepActiveInMode(stepId, mode) {
+  const steps = getStepsForMode(mode);
+  return steps.includes(stepId);
+}
+
+/**
+ * 获取指定模式下可归档的步骤索引（用于 archive 命令）
+ * @param {string} mode - 模式名称
+ * @returns {number[]} 可归档的步骤索引数组（0-based）
+ */
+export function getArchivableStepsForMode(mode) {
+  const config = MODE_CONFIG[mode];
+  if (!config) {
+    throw new Error(`Unknown mode: ${mode}`);
+  }
+  // 步骤ID转索引：减1
+  return config.archivableSteps.map(id => id - 1);
+}
+
+// ============ 格式化函数 ============
+
+/**
+ * 获取模式的显示标签（中文）
+ * @param {string} mode - 模式名称
+ * @returns {string} 格式化的标签，如 "完整模式 (7步)"
+ */
+export function getModeLabel(mode) {
+  const config = MODE_CONFIG[mode];
+  if (!config) {
+    return '未知模式';
+  }
+  const stepCount = config.steps.length;
+  return `${config.label} (${stepCount}步)`;
+}
+
+/**
+ * 获取模式的详细描述
+ * @param {string} mode - 模式名称
+ * @returns {string}
+ */
+export function getModeDescription(mode) {
+  const config = MODE_CONFIG[mode];
+  return config?.description || '无描述';
+}
+
+/**
+ * 格式化模式信息为多行文本（用于终端输出）
+ * @param {string} mode - 模式名称
+ * @returns {string}
+ */
+export function formatModeInfo(mode) {
+  const config = MODE_CONFIG[mode];
+  if (!config) {
+    return '未知模式';
+  }
+  const lines = [
+    `${config.label} (${config.steps.length}步)`,
+    `描述: ${config.description}`,
+    `步骤: ${config.steps.join(' → ')}`
+  ];
+  if (config.skippedSteps.length > 0) {
+    lines.push(`跳过: 步骤 ${config.skippedSteps.join(', ')}`);
+  }
+  return lines.join('\n');
+}
+
+// ============ 模式转换函数 ============
+
+/**
+ * 验证模式升级是否合法
+ * @param {string} fromMode - 当前模式
+ * @param {string} toMode - 目标模式
+ * @returns {ValidationResult}
+ */
+export function validateModeUpgrade(fromMode, toMode) {
+  if (!MODE_CONFIG[fromMode]) {
+    return { valid: false, reason: `未知的源模式: ${fromMode}` };
+  }
+  if (!MODE_CONFIG[toMode]) {
+    return { valid: false, reason: `未知的目标模式: ${toMode}` };
+  }
+  
+  const fromIndex = MODE_UPGRADE_ORDER.indexOf(fromMode);
+  const toIndex = MODE_UPGRADE_ORDER.indexOf(toMode);
+  
+  if (fromIndex === toIndex) {
+    return { valid: false, reason: '源模式和目标模式相同' };
+  }
+  if (fromIndex > toIndex) {
+    return { valid: false, reason: '只能从宽松模式升级到严格模式（minimal → quick → full）' };
+  }
+  
+  return { valid: true };
+}
+
+/**
+ * 获取模式升级后需要补充的步骤ID
+ * @param {string} fromMode - 当前模式
+ * @param {string} toMode - 目标模式
+ * @returns {number[]} 需要补充的步骤ID数组
+ */
+export function getMissingStepsAfterUpgrade(fromMode, toMode) {
+  const fromSteps = new Set(getStepsForMode(fromMode));
+  const toSteps = getStepsForMode(toMode);
+  return toSteps.filter(step => !fromSteps.has(step));
+}
+
+// ============ 文件路径函数 ============
+
+/**
+ * 获取 apply 命令的输入文件路径（相对于 projectRoot/incspec/）
+ * @param {string} mode - 模式名称
+ * @param {Object} workflow - 工作流状态（用于获取版本号）
+ * @returns {string} 相对路径
+ */
+export function getApplyInputFile(mode, workflow) {
+  if (mode === 'full') {
+    // 完整模式：使用增量设计文件
+    const moduleName = workflow.currentWorkflow?.replace('analyze-', '') || 'default';
+    const version = workflow.incrementVersion || 1;
+    return `increments/${moduleName}-increment-v${version}.md`;
+  } else {
+    // 快速/极简模式：使用结构化需求文件
+    return 'requirements/structured-requirements.md';
+  }
+}
+
+/**
+ * 获取 merge 命令的输出基线文件名（不含路径）
+ * @param {string} moduleName - 模块名称
+ * @param {number} version - 版本号
+ * @returns {string} 文件名
+ */
+export function getMergeOutputFilename(moduleName, version) {
+  return `${moduleName}-baseline-v${version}.md`;
+}

package/src/lib/workflow.mjs

@@ -9,6 +9,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { INCSPEC_DIR, FILES, getTemplatesDir } from './config.mjs';
 import { formatLocalDateTime } from './terminal.mjs';
+import {
+  getStepsForMode,
+  getSkippedStepsForMode,
+  isStepActiveInMode
+} from './mode-utils.mjs';
 
 /** Workflow steps definition */
 export const STEPS = [
@@ -33,14 +38,9 @@ export const STATUS = {
 export const MODE = {
   FULL: 'full',
   QUICK: 'quick',
+  MINIMAL: 'minimal',
 };
 
-/** Quick mode valid steps (1-based) */
-export const QUICK_MODE_STEPS = [1, 2, 5, 6, 7];
-
-/** Quick mode skipped steps (1-based) */
-export const QUICK_MODE_SKIPPED = [3, 4];
-
 function normalizeOutputName(outputFile) {
   if (!outputFile || typeof outputFile !== 'string') {
     return outputFile;
@@ -156,7 +156,13 @@ export function parseWorkflow(content) {
   const modeMatch = content.match(/\*\*工作流模式\*\*:\s*(.+)/);
   if (modeMatch) {
     const modeValue = modeMatch[1].trim().toLowerCase();
-    workflow.mode = modeValue === 'quick' ? MODE.QUICK : MODE.FULL;
+    if (modeValue === 'quick') {
+      workflow.mode = MODE.QUICK;
+    } else if (modeValue === 'minimal') {
+      workflow.mode = MODE.MINIMAL;
+    } else {
+      workflow.mode = MODE.FULL;
+    }
   }
 
   const startMatch = content.match(/\*\*开始时间\*\*:\s*(.+)/);
@@ -380,9 +386,10 @@ export function startWorkflow(projectRoot, workflowName, options = {}) {
   workflow.mode = mode;
   workflow.startTime = now;
 
-  // Initialize steps - mark skipped steps in quick mode
+  // Initialize steps - mark skipped steps based on mode
+  const skippedSteps = getSkippedStepsForMode(mode);
   workflow.steps = STEPS.map((step) => {
-    if (mode === MODE.QUICK && QUICK_MODE_SKIPPED.includes(step.id)) {
+    if (skippedSteps.includes(step.id)) {
       return {
         status: STATUS.SKIPPED,
         output: null,
@@ -529,10 +536,11 @@ export function resetToStep(projectRoot, targetStep) {
     throw new Error(`目标步骤 ${targetStep} 尚未完成，无法回退到此步骤`);
   }
 
-  // Handle quick mode: cannot reset to skipped steps
+  // Handle mode: cannot reset to skipped steps
   const mode = workflow.mode || MODE.FULL;
-  if (mode === MODE.QUICK && QUICK_MODE_SKIPPED.includes(targetStep)) {
-    throw new Error(`快速模式下步骤 ${targetStep} 被跳过，无法回退到此步骤`);
+  const skippedSteps = getSkippedStepsForMode(mode);
+  if (skippedSteps.includes(targetStep)) {
+    throw new Error(`当前模式下步骤 ${targetStep} 被跳过，无法回退到此步骤`);
   }
 
   // Collect outputs from steps that will be reset (targetStep+1 to 7)
@@ -552,8 +560,8 @@ export function resetToStep(projectRoot, targetStep) {
   const now = formatLocalDateTime(new Date());
   for (let i = targetStep; i < STEPS.length; i++) {
     const stepNumber = i + 1;
-    // In quick mode, keep skipped steps as skipped
-    if (mode === MODE.QUICK && QUICK_MODE_SKIPPED.includes(stepNumber)) {
+    // Keep skipped steps as skipped based on mode
+    if (skippedSteps.includes(stepNumber)) {
       workflow.steps[i] = {
         status: STATUS.SKIPPED,
         output: null,
@@ -608,14 +616,16 @@ export function getWorkflowProgress(workflow) {
   }
 
   const mode = workflow.mode || MODE.FULL;
+  const skippedSteps = getSkippedStepsForMode(mode);
+  const activeSteps = getStepsForMode(mode);
   let completed = 0;
   let lastCompletedStep = null;
 
   workflow.steps.forEach((step, index) => {
     const stepNumber = index + 1;
 
-    // Skip counting skipped steps in quick mode
-    if (mode === MODE.QUICK && QUICK_MODE_SKIPPED.includes(stepNumber)) {
+    // Skip counting skipped steps
+    if (skippedSteps.includes(stepNumber)) {
       return;
     }
 
@@ -625,8 +635,7 @@ export function getWorkflowProgress(workflow) {
     }
   });
 
-  // Quick mode has 5 steps (1,2,5,6,7), full mode has 7 steps
-  const total = mode === MODE.QUICK ? QUICK_MODE_STEPS.length : STEPS.length;
+  const total = activeSteps.length;
 
   return {
     completed,
@@ -707,15 +716,12 @@ export function isQuickMode(workflow) {
  * @returns {number|null} - Next step number or null if complete
  */
 export function getNextStep(currentStep, mode) {
-  if (mode === MODE.QUICK) {
-    const currentIndex = QUICK_MODE_STEPS.indexOf(currentStep);
-    if (currentIndex >= 0 && currentIndex < QUICK_MODE_STEPS.length - 1) {
-      return QUICK_MODE_STEPS[currentIndex + 1];
-    }
-    return null; // Workflow complete
+  const activeSteps = getStepsForMode(mode);
+  const currentIndex = activeSteps.indexOf(currentStep);
+  if (currentIndex >= 0 && currentIndex < activeSteps.length - 1) {
+    return activeSteps[currentIndex + 1];
   }
-  // Full mode
-  return currentStep < STEPS.length ? currentStep + 1 : null;
+  return null; // Workflow complete
 }
 
 /**
@@ -725,7 +731,8 @@ export function getNextStep(currentStep, mode) {
  * @returns {boolean}
  */
 export function shouldSkipStep(stepNumber, mode) {
-  return mode === MODE.QUICK && QUICK_MODE_SKIPPED.includes(stepNumber);
+  const skippedSteps = getSkippedStepsForMode(mode);
+  return skippedSteps.includes(stepNumber);
 }
 
 /**
@@ -749,14 +756,11 @@ export function getPrerequisiteSteps(stepNumber, mode = MODE.FULL) {
     return [];
   }
 
-  if (mode === MODE.QUICK) {
-    if (!QUICK_MODE_STEPS.includes(stepNumber)) {
-      return null;
-    }
-    return QUICK_MODE_STEPS.filter(step => step < stepNumber);
+  const activeSteps = getStepsForMode(mode);
+  if (!activeSteps.includes(stepNumber)) {
+    return null;
   }
-
-  return Array.from({ length: stepNumber - 1 }, (_, i) => i + 1);
+  return activeSteps.filter(step => step < stepNumber);
 }
 
 /**

package/src/templates/AGENTS.md

@@ -4,11 +4,11 @@ AI 编码助手使用 IncSpec 进行增量规格驱动开发的操作指南。
 
 ## 快速检查清单
 
-**完整模式 (7步)**:
+**完整模式 (FULL, 7步)**:
 - 按顺序执行: analyze → collect-req → collect-dep → design → apply → merge → archive
 - 适用于: 复杂 UI 功能、多组件交互、需要详细设计审查
 
-**快速模式 (5步)**:
+**快速模式 (QUICK, 5步)**:
 - 启动: `incspec analyze <path> --quick`
 - 按顺序执行: 
   - 步骤1: analyze (代码分析)
@@ -20,23 +20,55 @@ AI 编码助手使用 IncSpec 进行增量规格驱动开发的操作指南。
   - 步骤7: archive (归档)
 - 适用于: Bug 修复、简单功能、不涉及复杂 UI 依赖的变更
 
+**极简模式 (MINIMAL, 3步)**:
+- 启动: `incspec analyze <path> --minimal`
+- 按顺序执行:
+  - 步骤1: analyze (代码分析)
+  - [跳过步骤2: 需求收集]
+  - [跳过步骤3: UI依赖采集]
+  - [跳过步骤4: 增量设计]
+  - 步骤5: apply (直接应用代码变更)
+  - [跳过步骤6: 合并基线]
+  - 步骤7: archive (归档，用户自行决定是否先合并基线)
+- 适用于: 紧急 Bug 修复、单文件小改动、快速实验
+- 注意: 归档时会提醒用户是否需要先生成新基线快照（可选运行 `incspec merge`）
+
 **核心约定**:
 - 初始化: `incspec init`
 - 检查状态: `incspec status`
 - 编号引用: `[S1]` 时序步骤, `[D1]` 依赖, `[C1]` 变更
 - 增量标记: `[N1]` 新增, `[S1-Modified]` 修改, `[S1-Deleted]` 删除
-- 验证时机: 步骤 1/4/6 完成后、归档前执行 `incspec validate`，出错时加 `--strict` 用于 CI
+- 验证时机: 完整/快速模式在步骤 1/4/6 后、归档前执行 `incspec validate`；极简模式在步骤 1 和归档前执行，若先执行 merge 则在合并后验证
 
 ## 七步工作流
 
 ```
 完整模式:  [1分析] → [2需求] → [3UI依赖] → [4设计] → [5应用] → [6合并] → [7归档] → 循环
 快速模式:  [1分析] → [2需求] ─(跳过3,4)─→ [5应用] → [6合并] → [7归档] → 循环
+极简模式:  [1分析] ─(跳过2,3,4,6)─→ [5应用] → [7归档] → 循环
 ```
 
+### 模式对比表
+
+| 维度 | 完整模式 (FULL) | 快速模式 (QUICK) | 极简模式 (MINIMAL) |
+|------|----------------|-----------------|-------------------|
+| 步骤数 | 7 步 | 5 步 | 3 步 |
+| 跳过步骤 | 无 | 步骤 3, 4 | 步骤 2, 3, 4, 6 |
+| 需求收集 | ✓ 5 列结构化需求 | ✓ 5 列结构化需求 | ✗ 直接应用 |
+| 增量设计 | ✓ 完整设计蓝图 | ✗ 直接应用 | ✗ 直接应用 |
+| UI 依赖采集 | ✓ 6 维度分析 | ✗ 跳过 | ✗ 跳过 |
+| 合并基线 | ✓ merge 命令 | ✓ merge 命令 | ✗ 可选（归档时提醒） |
+| 适用场景 | 复杂功能、架构变更 | Bug 修复、简单功能 | 紧急修复、单文件改动 |
+| 审批门禁 | 设计阶段 + 应用前 | 应用前 | 应用前 |
+
 ### 步骤 1: 分析代码工作流
 
-**命令**: `incspec analyze <source-path> [--module=name] [--quick] [--baseline=file]`
+**命令**: `incspec analyze <source-path> [--module=name] [--quick|--minimal] [--baseline=file]`
+
+**选项**:
+- `--quick`: 启动快速模式（跳过步骤 3, 4）
+- `--minimal`: 启动极简模式（跳过步骤 2/3/4，步骤 6 可选）
+- `--baseline=file`: 使用现有基线（跳过分析，直接进入步骤 2；极简模式直接进入 apply）
 
 **目的**: 生成包含 API 调用时序图和依赖关系图的基线快照。
 
@@ -51,6 +83,7 @@ AI 编码助手使用 IncSpec 进行增量规格驱动开发的操作指南。
 **命令**: `incspec collect-req [--force]` (别名: `cr`)
 
 **目的**: 交互式需求收集,转换为 5 列格式。
+**极简模式**: 跳过此步骤。
 
 **输出**: `incspec/requirements/structured-requirements.md`
 
@@ -61,6 +94,7 @@ AI 编码助手使用 IncSpec 进行增量规格驱动开发的操作指南。
 **命令**: `incspec collect-dep [--force]` (别名: `cd`)
 
 **目的**: 映射新增/修改 UI 组件的所有上下文依赖。
+**极简模式**: 跳过此步骤。
 
 **输出**: `incspec/requirements/ui-dependencies.md`
 
@@ -71,6 +105,7 @@ AI 编码助手使用 IncSpec 进行增量规格驱动开发的操作指南。
 **命令**: `incspec design [--feature=name] [--force]` (别名: `d`)
 
 **目的**: 创建全面的增量设计蓝图。
+**极简模式**: 跳过此步骤。
 
 **输出**: `incspec/increments/{feature}-increment-v{n}.md`
 
@@ -93,13 +128,14 @@ AI 编码助手使用 IncSpec 进行增量规格驱动开发的操作指南。
 
 **执行顺序**: Types → Utils → APIs → Store → Components
 
-**审批门禁**: 增量设计必须经过审查批准后才能执行。
+**审批门禁**: 完整/快速模式需审批增量设计；极简模式在 apply 前确认改动范围。
 
 ### 步骤 6: 合并到基线
 
 **命令**: `incspec merge [increment-path] [--force]` (别名: `m`)
 
 **目的**: 将增量整合到新的基线快照中。
+**极简模式**: 可选执行（通常在归档前按需生成新基线）。
 
 **处理**: 移除增量标记 → 合并新节点 → 重新编号为干净序列 → 输出新基线 v{n+1}
 
@@ -143,15 +179,18 @@ incspec init [--force]              # 初始化项目
 incspec status / st                 # 查看工作流状态
 incspec list / ls [-l] [-a]         # 列出规格文件
 
-# 7步工作流
-incspec analyze <path> [--quick] [--module=name] [--baseline=file]  # 步骤1
-incspec collect-req / cr [--force]  # 步骤2 (--force 跳过前置检查)
-incspec collect-dep / cd [--force]  # 步骤3 (快速模式跳过)
-incspec design / d [--feature=name] [--force]  # 步骤4 (快速模式跳过)
+# 7步工作流 (支持三种模式)
+incspec analyze <path> [--quick|--minimal] [--module=name] [--baseline=file]  # 步骤1
+incspec collect-req / cr [--force]  # 步骤2 (--force 跳过前置检查，极简模式跳过)
+incspec collect-dep / cd [--force]  # 步骤3 (快速/极简模式跳过)
+incspec design / d [--feature=name] [--force]  # 步骤4 (快速/极简模式跳过)
 incspec apply / ap [path] [--force] # 步骤5
-incspec merge / m [path] [--force]  # 步骤6
+incspec merge / m [path] [--force]  # 步骤6 (极简模式可选)
 incspec archive [--yes] [--keep]    # 步骤7
 
+# 模式管理
+incspec upgrade <mode> / ug         # 升级工作流模式 (minimal → quick → full)
+
 # 验证与同步
 incspec validate / v [--strict]     # 验证完整性
 incspec sync [--cursor|--claude|--all] [--global|--project]  # IDE集成
@@ -159,6 +198,31 @@ incspec reset                       # 完全重置工作流（归档所有产出
 incspec reset --to=<step>           # 部分回退到指定步骤（保留1-N，重置N+1至7）
 ```
 
+### 模式升级
+
+**命令**: `incspec upgrade <mode>`
+
+**升级路径**: minimal → quick → full (只能从宽松到严格)
+
+**用法示例**:
+```bash
+# 从极简模式升级到快速模式
+incspec upgrade quick
+
+# 从快速模式升级到完整模式
+incspec upgrade full
+```
+
+**升级效果**:
+- 极简 → 快速: 需补充步骤 2 (需求收集) 和步骤 6 (合并基线)
+- 快速 → 完整: 需补充步骤 3 (UI依赖) 和步骤 4 (增量设计)
+- 极简 → 完整: 需补充步骤 2 (需求收集)、步骤 3 (UI依赖)、步骤 4 (增量设计) 和步骤 6 (合并基线)
+
+**注意事项**:
+- 只有在活跃工作流中才能升级
+- 升级后需按提示补充缺失的步骤
+- 不支持降级（full → quick 或 quick → minimal）
+
 ## 文件格式示例
 
 ### 基线文件
@@ -211,6 +275,9 @@ baseline: home-baseline-v1
 **快速模式流程**:
 1. 人类提供简单需求 → AI 执行步骤 1-2 → 人类审批 → AI 执行步骤 5-7 → 循环
 
+**极简模式流程**:
+1. 人类提供紧急修复需求 → AI 执行步骤 1 (分析) → AI 执行步骤 5 (直接应用) → AI 执行步骤 7 (归档，提醒是否合并基线) → 循环
+
 **核心原则**:
 - 增量优于大爆炸 - 小的、经过验证的变更
 - 规格驱动 - 需求先于代码
@@ -231,6 +298,9 @@ baseline: home-baseline-v1
 - 步骤 2-6 执行前会自动检查前置步骤是否完成
 - 若前置步骤未完成，命令会提示并阻止执行
 - 添加 `--force` 可跳过此检查，强制执行当前步骤
+**极简模式**:
+- 默认仅要求步骤 1 完成后才允许执行 apply
+- 若选择执行 merge，将在归档前补齐合并与验证
 
 **工作流重置**:
 - 完全重置: `incspec reset` - 归档所有产出，回到初始状态

package/src/templates/WORKFLOW.md

@@ -6,6 +6,13 @@
 **开始时间**: -
 **最后更新**: {{last_update}}
 
+<!-- 
+工作流模式说明:
+- full: 完整模式 (7步) - 适合复杂功能开发
+- quick: 快速模式 (5步) - 跳过步骤3,4，适合Bug修复和简单功能
+- minimal: 极简模式 (3步) - 跳过步骤2,3,4,6，适合紧急修复或单文件小改动
+-->
+
 ## 步骤进度
 
 | 步骤 | 状态 | 输出文件 | 完成时间 |

package/src/templates/commands/analyze-codeflow.md

@@ -29,6 +29,21 @@ incspec analyze <source-path> --module=<module> --quick
 - 简单功能迭代
 - 不涉及复杂 UI 依赖变更的任务
 
+**启动极简模式工作流** (3步流程):
+
+```bash
+incspec analyze <source-path> --module=<module> --minimal
+```
+
+极简模式跳过步骤 2 (需求收集)、步骤 3 (UI依赖采集)、步骤 4 (增量设计) 和步骤 6 (合并基线)。适用于：
+- 紧急 Bug 修复
+- 单文件小改动
+- 快速实验和原型验证
+
+注意：
+- apply 时基于口头需求直接执行代码变更
+- archive 时会提醒用户是否需要先运行 `incspec merge` 生成新基线（可选）
+
 **使用现有基准报告** (跳过分析):
 
 若已有基准报告文件，可直接使用: