openfeel 1.1.6 → 1.2.0

package/dist/core/flow-manager.js

@@ -13,14 +13,15 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, readd
 import { resolve, dirname, basename } from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { parse as parseYaml } from 'yaml';
-import { PipelineConfigSchema, PipelinePhaseSchema, PIPELINE_PHASES, MetaPhaseSchema, META_PHASES, transitionKeyMatches, } from './pipeline-schema.js';
+import { PipelineConfigSchema, PipelinePhaseSchema, PIPELINE_PHASES, MetaPhaseSchema, META_PHASES, transitionKeyMatches, FastTransitionsSchema, } from './pipeline-schema.js';
 import { PublicLogger, formatDate } from './public-logger.js';
 import { t, getCliLang } from './i18n.js';
-import { findStageStatusPath, findStageDirConflict, parseStageId, normalizeStageId } from './plan/path.js';
+import { findStageStatusPath, findStageDirConflict, parseStageId, normalizeStageId, isArchivedVersionOf } from './plan/path.js';
 import { atomicWriteFileSync } from './fs/atomic-write.js';
 import { withFileLock, projectLockPath } from './fs/file-lock.js';
 import { DEFAULT_CONFIG, ConfigDefaultsSchema, STAGE_FIELD_BY_CONFIG_KEY } from './config.js';
 import { getGlobalProfilePath } from './global-paths.js';
+import { syncRequirementStatus } from './req/aggregate.js'; // 需求聚合回写入口（stage-83 T2；纯内存）
 /** flow.json 乐观并发冲突：磁盘 revision 与本次加载时不一致（存在并发写入） */
 export class FlowConcurrentModificationError extends Error {
     /** 本次实例加载时的 revision */
@@ -52,8 +53,8 @@ export class StageDirConflictError extends Error {
         this.other = other;
     }
 }
-/** `openfeel config effective` 的三个受管键（与 DEFAULT_CONFIG 一致） */
-const EFFECTIVE_CONFIG_KEYS = ['execution_mode', 'auto_advance', 'merge_mode'];
+/** `openfeel config effective` 的四个受管键（与 DEFAULT_CONFIG 一致） */
+const EFFECTIVE_CONFIG_KEYS = ['execution_mode', 'auto_advance', 'merge_mode', 'workflow_mode'];
 // ── 默认值 ──
 /** 创建默认的 Checkpoints */
 function defaultCheckpoints() {
@@ -163,6 +164,23 @@ export function findOrphanOps(projectPath) {
 }
 /** findPhasePath BFS 深度上限（B5-1；超出按拒绝处理） */
 export const PHASE_PATH_MAX_DEPTH = 8;
+/**
+ * fast 模式内置快线转移表（裁定 C）：8 条流转键 + `done` 终止项（共 9 条目）。
+ * 单一来源：仅 getDefaultPipelineConfig('fast') 消费；禁止在命令层/模板层复制（R-74-1）。
+ * `plan_review` 在 fast 下必经（plan_pending → plan_review → plan_passed；通过 → plan_passed，问题退回 → plan_pending）。
+ * review_failed 双出口 = 失败回环（重审 或 回执行修复，对应 full 表 scheme_pending 位）；Q3 收紧项留审查裁定。
+ */
+const FAST_TRANSITIONS = {
+    plan_pending: ['plan_review'],
+    plan_review: ['plan_passed', 'plan_pending'],
+    plan_passed: ['exec_running'],
+    exec_running: ['review_pending'],
+    review_pending: ['review_failed', 'review_passed'],
+    review_failed: ['review_pending', 'exec_running'],
+    review_passed: ['archiving'],
+    archiving: ['done'],
+    done: [],
+};
 // ── 核心类 ──
 export class FlowManager {
     projectPath;
@@ -172,6 +190,8 @@ export class FlowManager {
     filePath;
     /** 从 pipeline.yaml 加载的流水线配置（含后备默认值） */
     pipelineConfig = null;
+    /** 从 pipeline.yaml 加载的可选快线表（fast_transitions）；null = 缺失/非法/空对象 → 回退内置快线表 [REV-74-009 修订] */
+    fastTransitions = null;
     /** 公共日志写入器（审计链） */
     publicLogger;
     constructor(projectPath) {
@@ -1123,6 +1143,9 @@ export class FlowManager {
         // 阶段完成时自动结束计时
         if (targetPhase === 'done' && prevStatus !== 'done') {
             this.endStage(key);
+            // 需求聚合回写（T2）：仅 done 分支触发（非 done 推进不触发——REV-83-005）；
+            // 纯内存，落盘由命令层既有单次 save() 承担（同事务，不新增写盘点）；不改控制流与返回值。
+            syncRequirementStatus(this.data, key);
             // 归档 git commit 移出本方法：必须在 flow.json save 之后执行（否则 commit 不含本次 phase 变更）。
             // 返回 true 由命令层在 save 后调用 autoCommitOnDone。
             return true;
@@ -1187,6 +1210,9 @@ export class FlowManager {
             action: 'reset_stage_phase',
             detail: { stageName: key, from: fromPhase, to: targetPhase },
         });
+        // 需求聚合对称回退（T2）：聚合视图重算——聚合 ≠ done ∧ 需求 status === done → 回退 in_progress；
+        // 纯内存；dryRun / no-op 已在 :1585 早退（本点不可达）；不新增写盘点。
+        syncRequirementStatus(this.data, key);
         // 仅当 current 指向该阶段时同步 op 指针（其它阶段的 current 不被动）
         const curStage = this.data.pipeline.current.stage;
         const normCur = curStage ? (normalizeStageId(curStage) ?? curStage) : '';
@@ -1477,10 +1503,11 @@ export class FlowManager {
      * 遍历 transitions 表，key 与 fromPhase 匹配（组合 key 如 'test_passed|review_passed' 任一条件匹配即可）即收集其目标。
      * 无 '|' 的简单 key 保持单条件原行为（精确相等）。
      * @param fromPhase 当前源 phase
+     * @param mode 工作流模式（**必传**；由调用点经 resolveStageWorkflowMode 从 stage 派生——禁止默认 mode）
      * @returns 去重后的可达目标 phase 列表
      */
-    getValidTargets(fromPhase) {
-        const transitions = this.pipelineConfig?.transitions ?? {};
+    getValidTargets(fromPhase, mode) {
+        const transitions = this.resolveTransitionsForMode(mode);
         const result = new Set();
         for (const [key, targets] of Object.entries(transitions)) {
             if (transitionKeyMatches(key, fromPhase)) {
@@ -1503,7 +1530,8 @@ export class FlowManager {
         const phase = this.resolveCurrentPhase(stageName);
         if (!phase)
             return false;
-        return this.getValidTargets(phase).includes(to);
+        const mode = this.resolveStageWorkflowMode(stageName).value;
+        return this.getValidTargets(phase, mode).includes(to);
     }
     /**
      * 获取当前阶段的所有可达下一阶段（基于 transitions 表，支持组合条件）
@@ -1520,7 +1548,8 @@ export class FlowManager {
         const currentPhase = this.resolveCurrentPhase(stageName);
         if (!currentPhase)
             return [];
-        return this.getValidTargets(currentPhase);
+        const mode = this.resolveStageWorkflowMode(stageName).value;
+        return this.getValidTargets(currentPhase, mode);
     }
     /**
      * 在运行时 transitions 上求 stageName 当前 phase → to 的**唯一**可达路径（B5-1）。
@@ -1542,6 +1571,8 @@ export class FlowManager {
         if (start === to) {
             return { path: [], reason: 'already-at-target' };
         }
+        // 模式在 BFS 外解析一次（stage 派生；同一 T 内 mode 恒定——单 stage 只读一张表）
+        const mode = this.resolveStageWorkflowMode(key).value;
         // BFS 逐层扩展；visitedDepth 记录各 phase 首次到达的最小深度（剪枝，避免重复/环）
         const visitedDepth = new Map();
         visitedDepth.set(start, 0);
@@ -1554,7 +1585,7 @@ export class FlowManager {
                 if (node.path.length >= PHASE_PATH_MAX_DEPTH) {
                     continue;
                 }
-                for (const target of this.getValidTargets(node.phase)) {
+                for (const target of this.getValidTargets(node.phase, mode)) {
                     const path = [...node.path, target];
                     if (target === to) {
                         hits.push(path);
@@ -1591,21 +1622,34 @@ export class FlowManager {
         const phases = this.pipelineConfig?.phases ?? this.getDefaultPipelineConfig().phases;
         return [...phases];
     }
+    /**
+     * 按模式解析运行时转移表（唯一取表法则；校验/推进/路径 与 展示 同经本函数 ⇒ 单一信源）。
+     * full → 运行时 pipelineConfig.transitions（pipeline.yaml 覆盖线）；fast → fast_transitions ?? 内置快线表。
+     * 说明：pipelineConfig 构造期恒已加载（constructor 无条件调用），`?? 内置` 保留既有访问器回退语义。
+     */
+    resolveTransitionsForMode(mode) {
+        if (mode === 'fast') {
+            return this.fastTransitions ?? this.getDefaultPipelineConfig('fast').transitions;
+        }
+        return this.pipelineConfig?.transitions ?? this.getDefaultPipelineConfig().transitions;
+    }
     /**
      * 获取运行时生效的 phase 转移表（key 可含 '|' 组合条件）。
      * 缺省/解析失败时回退内置默认配置。返回浅拷贝。
+     * **无参 = full**（零回归既有消费点）；fast 供 stage-75 `flow phases` 模式分节消费。
      */
-    getPipelineTransitions() {
-        const transitions = this.pipelineConfig?.transitions ?? this.getDefaultPipelineConfig().transitions;
+    getPipelineTransitions(mode = 'full') {
+        const transitions = this.resolveTransitionsForMode(mode);
         return Object.fromEntries(Object.entries(transitions).map(([k, v]) => [k, [...v]]));
     }
     /**
      * 获取内置默认 phase 转移表（不受项目 pipeline.yaml 影响）。
      * 供 `flow phases` 做「运行时 vs 默认」差异报告（T19）。
+     * **无参 = full**（零回归既有消费点）；fast 供 stage-75 `flow phases` 模式分节消费。
      * @returns 默认 transitions 的深拷贝
      */
-    getDefaultTransitions() {
-        return Object.fromEntries(Object.entries(this.getDefaultPipelineConfig().transitions).map(([k, v]) => [k, [...v]]));
+    getDefaultTransitions(mode = 'full') {
+        return Object.fromEntries(Object.entries(this.getDefaultPipelineConfig(mode).transitions).map(([k, v]) => [k, [...v]]));
     }
     /**
      * 解析当前阶段 phase：优先使用传入的 stageName，其次 current.stage，最后 fallback
@@ -1698,10 +1742,13 @@ export class FlowManager {
     }
     /**
      * 构建配置级联信息（优先级：profileDefaults < configDefaults < statusOverrides）
-     * 全局画像仅作最低优先级兜底（P2），且只取 preferences.auto_advance 单值，
-     * 不对 preferences 做整体替换（与 config.yaml defaults 键集重叠的仅 auto_advance）。
+     * 全局画像仅作最低优先级兜底（P2），且只取 preferences.auto_advance 单值，**不扩展** workflow_mode。
+     * @param stageId 可选目标阶段（stage 形参唯一入口）；缺省 = pipeline.current.stage
+     *   （**当前阶段域**，无参行为逐字不变）。任意阶段域由 resolveStageWorkflowMode(stageId) 显式传入。
+     * 静态约束（REV-74-001/002）：无参调用**仅允许**出现在既有两出口 resolveEffectiveConfig()
+     *   与 verboseSummary()；新增消费点一律显式传 stage。
      */
-    buildCascadeConfig() {
+    buildCascadeConfig(stageId) {
         const profileDefaults = {};
         const configDefaults = {};
         const statusOverrides = {};
@@ -1752,22 +1799,26 @@ export class FlowManager {
                 // 解析失败则用空值
             }
         }
-        // 最高优先级：当前 stage 的 status.md（如果存在）
-        if (this.data && this.data.pipeline.current.stage) {
-            const stageId = this.data.pipeline.current.stage;
-            const statusPath = this.findStatusPath(stageId);
+        // 最高优先级：目标 stage 的 status.md（缺省 = pipeline.current.stage；stage 形参路径读该阶段）
+        const targetStage = stageId ?? this.data?.pipeline.current.stage;
+        if (targetStage) {
+            const statusPath = this.findStatusPath(targetStage);
             if (statusPath) {
                 try {
                     const content = readFileSync(statusPath, 'utf-8');
-                    // 匹配执行模式、自动推进
+                    // 匹配执行模式、自动推进、工作流模式
                     const execMatch = content.match(/\*\*执行模式\*\*[：:]\s*(manual|auto)/);
                     const autoMatch = content.match(/\*\*自动推进\*\*[：:]\s*(disabled|enabled)/);
+                    const modeMatch = content.match(/\*\*工作流模式\*\*[：:]\s*(full|fast)/);
                     if (execMatch) {
                         statusOverrides['execution_mode'] = execMatch[1];
                     }
                     if (autoMatch) {
                         statusOverrides['auto_advance'] = autoMatch[1];
                     }
+                    if (modeMatch) {
+                        statusOverrides['workflow_mode'] = modeMatch[1];
+                    }
                 }
                 catch {
                     // 读取失败则跳过
@@ -1779,7 +1830,7 @@ export class FlowManager {
         return { profileDefaults, configDefaults, statusOverrides, effective };
     }
     /**
-     * 解析三个受管配置键的「有效值 + 生效来源」（`openfeel config effective`，P9）。
+     * 解析四个受管配置键的「有效值 + 生效来源」（`openfeel config effective`，P9）。
      * 复用 buildCascadeConfig（单一权威，避免第二套解析），优先级：
      * status.md > config.yaml > profile.yaml > builtin。
      * @returns key → { value, source }
@@ -1804,6 +1855,30 @@ export class FlowManager {
         }
         return result;
     }
+    /**
+     * 解析指定阶段的工作流模式（裁定 E：「stage → mode」表选择解析入口；stage-75 `flow mode` 契约）。
+     * 带 stage 形参独立解析（REV-74-001）：该阶段 status.md（findStatusPath(stageId)）
+     *   > config.yaml defaults > profile.yaml（**有意不承载**，实际不产出）> builtin（DEFAULT_CONFIG.workflow_mode = fast）。
+     * 语义边界：`config effective` / `flow status --verbose` = **当前阶段域**（无参）；
+     *   本方法显式 stageId = **任意阶段域**（flow mode --stage / 表选择）。
+     * @param stageId 目标阶段 ID（缺省 = pipeline.current.stage；无该阶段 status.md → 自然回落下一层）
+     * @returns { value, source }，source ∈ status.md | config.yaml | profile.yaml | builtin
+     */
+    resolveStageWorkflowMode(stageId) {
+        const cascade = this.buildCascadeConfig(stageId);
+        const key = 'workflow_mode';
+        if (cascade.statusOverrides[key] !== undefined) {
+            return { value: cascade.statusOverrides[key], source: 'status.md' };
+        }
+        if (cascade.configDefaults[key] !== undefined) {
+            return { value: cascade.configDefaults[key], source: 'config.yaml' };
+        }
+        if (cascade.profileDefaults[key] !== undefined) {
+            // profile 层有意不承载 workflow_mode（画像 = 个人偏好层，REV-74-005）；此分支为对称性保留，实际不产出
+            return { value: cascade.profileDefaults[key], source: 'profile.yaml' };
+        }
+        return { value: DEFAULT_CONFIG.workflow_mode, source: 'builtin' };
+    }
     /** 查找 status.md 的路径（三级回退：plan/{series}/ 精确 → plan 递归 → stages 兜底） */
     findStatusPath(stageId) {
         return findStageStatusPath(this.projectPath, stageId);
@@ -1861,7 +1936,7 @@ export class FlowManager {
         // 返回最近 N 条（倒序取最后）
         return results.slice(-maxChanges);
     }
-    /** 构建下游阶段列表（当前 phase 的可达下一阶段 + Agent 映射） */
+    /** 构建下游阶段列表（当前阶段的可达下一阶段 + Agent 映射；模式经 getAvailablePhases() 无参 → current.stage 派生） */
     buildDownstreamPhases() {
         const available = this.getAvailablePhases();
         const labels = this.getPhaseLabels();
@@ -2187,8 +2262,10 @@ export class FlowManager {
             return false;
         }
         const currentPhase = this.data.stages[parts.stageId].phase;
+        // stage 派生 mode：opId 解析出的 stage（src 内无生产调用方，仅测试；仍为 mode 透传必改点）
+        const mode = this.resolveStageWorkflowMode(parts.stageId).value;
         // 检查从当前 phase 到目标 phase 的流转是否合法（支持组合条件 key）
-        const validTargets = this.getValidTargets(currentPhase);
+        const validTargets = this.getValidTargets(currentPhase, mode);
         if (!validTargets.includes(to)) {
             return false;
         }
@@ -2817,6 +2894,10 @@ export class FlowManager {
         if (!quick) {
             this.checkEmptyTemplates(items);
         }
+        // ── 10. 工作流模式冗余字段一致性（stage-75 op-003；仅 warn，不 fail、不自动修复）──
+        if (!quick) {
+            this.checkWorkflowModeRedundancy(items);
+        }
         const ok = items.every((i) => i.status !== 'fail');
         return { items, ok };
     }
@@ -2902,23 +2983,106 @@ export class FlowManager {
             return true;
         });
     }
+    /**
+     * status.md 字段「插入」写（原子写 + 按阶段目录加锁）。
+     * 与 `writeStatusField`（替换语义）并列的**独立**实现，禁双重语义：
+     * 字段行已存在 → `exists`（不写盘）；锚点链「自动推进」后 → 回退「执行模式」后 → 皆缺 `no-anchor`（不写盘 / 无 `.bak`）。
+     * 备份 `.openfeel/tmp/status.{stageId}.bak` 仅在**确认插入**时生成。
+     * 不依赖 `this.data`（flow.json 未加载的存量项目也可仅凭 `this.projectPath` 定位锁/备份）。
+     * @param statusPath status.md 绝对路径
+     * @param stageId 备份文件名中的阶段 ID（单阶段 = 用户输入原值；批量 = flow.json 注册键）
+     * @param key 字段名（如「工作流模式」）
+     * @param value 目标值
+     * @returns `inserted` 已插入 | `exists` 字段已存在（竞态防御，调用方可回退替换）| `no-anchor` 锚点缺失
+     */
+    insertStatusField(statusPath, stageId, key, value) {
+        const stageDir = basename(dirname(statusPath));
+        const lockPath = projectLockPath(this.projectPath, `status-${stageDir}`);
+        return withFileLock(lockPath, () => {
+            const content = readFileSync(statusPath, 'utf-8');
+            // 锁内复查：字段行已存在 → 不写盘（探针与写之间的竞态防御）
+            const fieldRegex = new RegExp(`^-\\s*(?:\\*\\*)?${escapeRegex(key)}(?:\\*\\*)?[：:]`, 'm');
+            if (fieldRegex.test(content)) {
+                return 'exists';
+            }
+            // 锚点链：「自动推进」行后优先；缺失则回退「执行模式」行后；皆缺 = no-anchor
+            const anchor = content.match(/^-\s*(?:\*\*)?自动推进(?:\*\*)?[：:]/m) ??
+                content.match(/^-\s*(?:\*\*)?执行模式(?:\*\*)?[：:]/m);
+            if (!anchor || anchor.index === undefined) {
+                return 'no-anchor';
+            }
+            const newLine = `- **${key}**：${value}`;
+            const lineEnd = content.indexOf('\n', anchor.index + anchor[0].length);
+            let updated;
+            if (lineEnd === -1) {
+                // 错误路径：锚点行位于文件末行（无尾换行）→ 换行后追加
+                updated = `${content}\n${newLine}`;
+            }
+            else {
+                // 保留锚点行原行尾风格（CRLF 感知），其余字节逐字保留
+                const isCrlf = content[lineEnd - 1] === '\r';
+                const eol = isCrlf ? '\r\n' : '\n';
+                updated = `${content.slice(0, lineEnd + 1)}${newLine}${eol}${content.slice(lineEnd + 1)}`;
+            }
+            // 备份仅在确认插入时生成
+            const tmpDir = resolve(this.projectPath, '.openfeel', 'tmp');
+            if (!existsSync(tmpDir)) {
+                mkdirSync(tmpDir, { recursive: true });
+            }
+            copyFileSync(statusPath, resolve(tmpDir, `status.${stageId}.bak`));
+            atomicWriteFileSync(statusPath, updated);
+            return 'inserted';
+        });
+    }
     /**
      * 将受管配置键批量同步到所有已注册阶段的 status.md 对应字段（`config set --sync-stages`）。
-     * 仅 auto_advance→「自动推进」、execution_mode→「执行模式」有阶段级字段；
-     * 其它键无阶段字段 → 全部 skipped-no-field（D-config 裁定，跳过并报告）。
-     * 复用 writeStatusField 的定向写 + 按阶段锁；同值 → noop（零写盘）。
-     * 只读 flow.json 的阶段枚举，不写 flow.json。
+     * 仅 auto_advance→「自动推进」、execution_mode→「执行模式」、workflow_mode→「工作流模式」
+     * 三个映射键有阶段级字段；其它键无阶段字段 → 全部 skipped-no-field（D-config 裁定，跳过并报告）。
+     * `workflow_mode` 字段缺失时复用 `insertStatusField`（插入语义，单一实现），锚点缺失 → skipped-no-anchor。
+     * 复用 writeStatusField / insertStatusField 的定向写 + 按阶段锁；同值 → noop（零写盘）。
+     * **冗余写入（裁定 G）**：`workflow_mode` 实际写入（updated / inserted）时同步 `stages[id].workflow_mode`
+     * 并 save 一次；noop / skipped 全量运行 → flow.json 零写盘。
      * @param configKey 已归一的受管配置键（如 auto_advance）
      * @param value 目标值
-     * @returns 每阶段一条结果（updated/noop/skipped-no-field/skipped-no-status）
+     * @param options 可选作用域：`onlyStages` 限定阶段 ID 列表（已归一化；缺省 = 全量现状）
+     * @returns 每阶段一条结果（updated/inserted/noop/skipped-no-field/skipped-no-status/skipped-no-anchor）
      */
-    syncConfigFieldToStages(configKey, value) {
+    syncConfigFieldToStages(configKey, value, options) {
         const out = [];
         if (!this.data) {
             return out;
         }
         const field = STAGE_FIELD_BY_CONFIG_KEY[configKey];
-        for (const stageId of Object.keys(this.data.stages)) {
+        const targets = options?.onlyStages;
+        // 冗余写入标记：仅实际写入（updated / inserted）时置位，循环后 save 一次（D6）
+        let flowJsonDirty = false;
+        // 遍历集构造（REV-80-009）：仅 targets 时 = 命中 targets 的活跃键（既有 filter 语义逐字保留，顺序 = stages 键序）
+        //   + 未被任何活跃键覆盖的 off-set 目标（已归档/未注册——status.md 仍照常同步，flow.json 冗余跳过）
+        // 注（REV-80-015）：纯 off-set 运行不置 flowJsonDirty → 不 save；appendLog（status.md 写审计）仅内存态、无 flow.json 写入
+        const loopIds = [];
+        if (targets) {
+            const covered = new Set();
+            for (const stageId of Object.keys(this.data.stages)) {
+                const norm = normalizeStageId(stageId) ?? stageId;
+                if (!targets.includes(norm)) {
+                    continue;
+                }
+                loopIds.push(stageId);
+                covered.add(norm);
+            }
+            // off-set 目标（未命中任何活跃键）：仅 status.md 同步，冗余写入跳过
+            for (const t of targets) {
+                if (!covered.has(t)) {
+                    loopIds.push(t);
+                }
+            }
+        }
+        else {
+            loopIds.push(...Object.keys(this.data.stages));
+        }
+        for (const stageId of loopIds) {
+            // 注册守卫（REV-80-009）：off-set 目标无 data.stages 条目 → 冗余写入三点须跳过（防越界解引用）
+            const registered = Object.prototype.hasOwnProperty.call(this.data.stages, stageId);
             // 错误路径：该 config 键无阶段级字段 → 跳过并报告
             if (!field) {
                 out.push({ stage: stageId, result: 'skipped-no-field' });
@@ -2931,8 +3095,37 @@ export class FlowManager {
                 continue;
             }
             const current = readStatusFieldValue(readFileSync(statusPath, 'utf-8'), field);
-            // 错误路径：字段行缺失 → 跳过（不新建字段）
+            // 错误路径：字段行缺失 →
+            //   workflow_mode 走「插入」语义（复用 op-001 单一实现）；其余键保持 skipped-no-field（零回归）
             if (current === null) {
+                if (configKey === 'workflow_mode') {
+                    const r = this.insertStatusField(statusPath, stageId, field, value);
+                    if (r === 'inserted') {
+                        this.appendLog({ time: '', agent: 'cli', action: 'config_sync_stage', detail: { stage: stageId, field, value } });
+                        out.push({ stage: stageId, result: 'inserted' });
+                        // 冗余写入点①：注册守卫（REV-80-009）——off-set 目标不新建冗余键、不置 dirty
+                        if (registered) {
+                            this.data.stages[stageId].workflow_mode = value;
+                            flowJsonDirty = true;
+                        }
+                        continue;
+                    }
+                    if (r === 'exists') {
+                        // 竞态防御：锁内发现字段已就位 → 回退替换语义（不产生双行）
+                        this.writeStatusField(statusPath, field, value);
+                        this.appendLog({ time: '', agent: 'cli', action: 'config_sync_stage', detail: { stage: stageId, field, value } });
+                        out.push({ stage: stageId, result: 'updated' });
+                        // 冗余写入点②：注册守卫（REV-80-009）
+                        if (registered) {
+                            this.data.stages[stageId].workflow_mode = value;
+                            flowJsonDirty = true;
+                        }
+                        continue;
+                    }
+                    // 锚点链均缺失 → 跳过类（不写盘、不审计）
+                    out.push({ stage: stageId, result: 'skipped-no-anchor' });
+                    continue;
+                }
                 out.push({ stage: stageId, result: 'skipped-no-field' });
                 continue;
             }
@@ -2944,6 +3137,15 @@ export class FlowManager {
             this.writeStatusField(statusPath, field, value);
             this.appendLog({ time: '', agent: 'cli', action: 'config_sync_stage', detail: { stage: stageId, field, value } });
             out.push({ stage: stageId, result: 'updated' });
+            // 冗余写入点③：仅实际写入时同步（noop / skipped 不写）；注册守卫（REV-80-009）——off-set 目标跳过
+            if (configKey === 'workflow_mode' && registered) {
+                this.data.stages[stageId].workflow_mode = value;
+                flowJsonDirty = true;
+            }
+        }
+        // 仅在实际发生写入时保存（幂等：全 noop → flow.json 零写盘）
+        if (flowJsonDirty) {
+            this.save();
         }
         return out;
     }
@@ -2962,9 +3164,15 @@ export class FlowManager {
         for (const [stageId, stage] of Object.entries(this.data.stages)) {
             const deps = Array.isArray(stage.deps) ? stage.deps : [];
             for (const d of deps) {
-                if (!known.has(normalizeStageId(d) ?? d)) {
-                    dangling.push(`${stageId} → ${d}`);
+                if (known.has(normalizeStageId(d) ?? d)) {
+                    continue; // 已注册优先
                 }
+                // 读侧与写侧同口径（REV-80-002）：显式版本前缀 ∧ 已归档 → 视为已满足，不报悬空；
+                // 恒传原始 d（短名不参与归档判定——REV-80-001）
+                if (isArchivedVersionOf(d, this.data.meta?.archived_versions)) {
+                    continue;
+                }
+                dangling.push(`${stageId} → ${d}`);
             }
         }
         if (dangling.length > 0) {
@@ -2977,6 +3185,37 @@ export class FlowManager {
         }
         items.push({ section: '悬空依赖', status: 'pass', message: '未检测到悬空依赖' });
     }
+    /**
+     * 10. 工作流模式冗余字段一致性：flow.json `stages[].workflow_mode` 与级联解析值不一致 → warn（stage-75 op-003）。
+     * 冗余字段不参与级联（裁定 G），读取权威恒为 status.md/级联；字段缺失（旧 flow.json）零报错；
+     * 仅告警不 fail、不自动修复。无不一致时不产生条目（保持输出精简）——与 checkOrphanOps 同风格。
+     * @param items 健康检查结果收集数组
+     */
+    checkWorkflowModeRedundancy(items) {
+        if (!this.data) {
+            return;
+        }
+        const mismatched = [];
+        for (const [stageId, stage] of Object.entries(this.data.stages)) {
+            const redundant = stage.workflow_mode;
+            // 错误路径：旧 flow.json 无该字段 → 直接跳过（零报错）
+            if (redundant === undefined) {
+                continue;
+            }
+            const resolved = this.resolveStageWorkflowMode(stageId).value;
+            if (redundant !== resolved) {
+                mismatched.push(`${stageId}（冗余 ${redundant} ≠ 解析 ${resolved}）`);
+            }
+        }
+        if (mismatched.length === 0) {
+            return;
+        }
+        items.push({
+            section: '工作流模式',
+            status: 'warn',
+            message: `检出 ${mismatched.length} 个阶段的 flow.json 冗余 workflow_mode 与权威解析值不一致（冗余不参与级联，可执行 openfeel config set workflow_mode <v> --sync-stages 修复）：${mismatched.slice(0, 5).join('; ')}${mismatched.length > 5 ? ' …' : ''}`,
+        });
+    }
     /**
      * 8. 孤儿 op 检测：flow.json 的 op 键与 ops/ 目录文件是否一致（N1-3）
      * 仅作数据卫生告警（warn），不阻断；退出码不受影响（仅 fail 决定）。
@@ -3361,6 +3600,19 @@ export class FlowManager {
             const raw = readFileSync(pipelinePath, 'utf-8');
             const parsed = parseYaml(raw);
             this.pipelineConfig = PipelineConfigSchema.parse(parsed);
+            // 可选快线表：独立容错解析（非法类型 → 忽略该键 + 告警，不 fail 整体配置；缺失/空对象 → 内置快线表）
+            const fastRaw = parsed?.['fast_transitions'];
+            if (fastRaw !== undefined) {
+                const fastParsed = FastTransitionsSchema.safeParse(fastRaw);
+                if (fastParsed.success) {
+                    // [REV-74-009 修订] 空对象 {} 等同缺失（空表使 fast 全链不可推进，无合法用途）→ 回落内置快线表
+                    this.fastTransitions = Object.keys(fastParsed.data).length > 0 ? fastParsed.data : null;
+                }
+                else {
+                    this.fastTransitions = null;
+                    console.warn(t('flow.manager.fastTransitionsInvalid', getCliLang(this.projectPath)));
+                }
+            }
         }
         catch {
             // 解析失败时回退到内置默认值
@@ -3369,9 +3621,11 @@ export class FlowManager {
     }
     /**
      * 获取内置默认流水线配置（等价于硬编码常量 + 3 个 Bug 修复）
-     * 当 pipeline.yaml 不存在或解析失败时使用
+     * 当 pipeline.yaml 不存在或解析失败时使用。
+     * @param mode 工作流模式；**无参 = full**（内置 full 表逐字等于历史现状，零回归既有消费点）；
+     *             'fast' 返回快线表（FAST_TRANSITIONS 常量引用）。phases / checkpoint_mapping / phase_corrections 两模式共用。
      */
-    getDefaultPipelineConfig() {
+    getDefaultPipelineConfig(mode = 'full') {
         return {
             phases: [
                 'plan_pending', 'plan_review', 'plan_passed',
@@ -3380,25 +3634,27 @@ export class FlowManager {
                 'review_passed', 'test_pending', 'test_failed',
                 'test_passed', 'archiving', 'done',
             ],
-            transitions: {
-                plan_pending: ['plan_review', 'plan_passed'],
-                plan_review: ['plan_passed', 'plan_pending'],
-                plan_passed: ['scheme_pending'],
-                scheme_pending: ['scheme_review', 'scheme_passed'],
-                scheme_review: ['scheme_passed', 'scheme_pending'],
-                scheme_passed: ['exec_running'],
-                exec_running: ['review_pending', 'scheme_pending'], // BUG 修复：增加 scheme_pending
-                review_pending: ['review_failed', 'review_passed'],
-                review_failed: ['review_pending', 'scheme_pending'], // BUG 修复：增加 scheme_pending
-                review_passed: ['test_pending'],
-                test_pending: ['test_failed', 'test_passed'],
-                test_failed: ['test_pending', 'scheme_pending'], // BUG 修复：增加 scheme_pending
-                test_passed: ['archiving'],
-                // 组合条件示例：审查通过 或 测试通过 任一即可推进到 archiving（多 Agent 并行场景，任一完成即推进）
-                'review_passed|test_passed': ['archiving'],
-                archiving: ['done'],
-                done: [],
-            },
+            transitions: mode === 'fast'
+                ? FAST_TRANSITIONS
+                : {
+                    plan_pending: ['plan_review', 'plan_passed'],
+                    plan_review: ['plan_passed', 'plan_pending'],
+                    plan_passed: ['scheme_pending'],
+                    scheme_pending: ['scheme_review', 'scheme_passed'],
+                    scheme_review: ['scheme_passed', 'scheme_pending'],
+                    scheme_passed: ['exec_running'],
+                    exec_running: ['review_pending', 'scheme_pending'], // BUG 修复：增加 scheme_pending
+                    review_pending: ['review_failed', 'review_passed'],
+                    review_failed: ['review_pending', 'scheme_pending'], // BUG 修复：增加 scheme_pending
+                    review_passed: ['test_pending'],
+                    test_pending: ['test_failed', 'test_passed'],
+                    test_failed: ['test_pending', 'scheme_pending'], // BUG 修复：增加 scheme_pending
+                    test_passed: ['archiving'],
+                    // 组合条件示例：审查通过 或 测试通过 任一即可推进到 archiving（多 Agent 并行场景，任一完成即推进）
+                    'review_passed|test_passed': ['archiving'],
+                    archiving: ['done'],
+                    done: [],
+                },
             checkpoint_mapping: {
                 plan: 'plan',
                 scheme: 'scheme',