openfeel 1.2.0 → 1.2.3

package/dist/core/flow-manager.js

@@ -13,15 +13,16 @@ 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, FastTransitionsSchema, } from './pipeline-schema.js';
+import { PipelineConfigSchema, PipelinePhaseSchema, PIPELINE_PHASES, MetaPhaseSchema, META_PHASES, transitionKeyMatches, parseTransitionKey, FastTransitionsSchema, TIER_PRUNED_PHASES, } from './pipeline-schema.js';
 import { PublicLogger, formatDate } from './public-logger.js';
 import { t, getCliLang } from './i18n.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 { DEFAULT_CONFIG, ConfigDefaultsSchema, STAGE_FIELD_BY_CONFIG_KEY, WORKFLOW_MODES } from './config.js';
 import { getGlobalProfilePath } from './global-paths.js';
 import { syncRequirementStatus } from './req/aggregate.js'; // 需求聚合回写入口（stage-83 T2；纯内存）
+import { getSessionId } from './session.js'; // 会话标识（stage-86 T4；core→core 零环）
 /** flow.json 乐观并发冲突：磁盘 revision 与本次加载时不一致（存在并发写入） */
 export class FlowConcurrentModificationError extends Error {
     /** 本次实例加载时的 revision */
@@ -40,6 +41,20 @@ export function isFlowConcurrentError(err) {
     return err instanceof FlowConcurrentModificationError
         || (typeof err === 'object' && err !== null && err.name === 'FlowConcurrentModificationError');
 }
+/**
+ * 过滤指定阶段域的阻塞 open REV（单点谓词）。
+ * 阶段域：r.op === stage 或 r.op.startsWith(stage + '.')（`.` 分隔防前缀重叠）。
+ * 阻塞判定：r.blocking !== false（undefined 视为阻塞）且 r.status === 'open'。
+ * 纯只读；空 stage → []。
+ */
+export function listStageBlockingOpenReviews(reviews, stage) {
+    if (!stage) {
+        return [];
+    }
+    return reviews.filter((r) => (r.op === stage || r.op.startsWith(stage + '.'))
+        && r.blocking !== false
+        && r.status === 'open');
+}
 /** 阶段目录冲突：两个不同 stageId 映射同一 (series, stageDir)（cli/BUG-002） */
 export class StageDirConflictError extends Error {
     /** 本次冲突检测的 stageId */
@@ -181,6 +196,17 @@ const FAST_TRANSITIONS = {
     archiving: ['done'],
     done: [],
 };
+/**
+ * 工作流模式 → 派生的审查档位（**单源常量**；stage-92 D-92-3）。
+ * 仅用于「展示 / 提示」（`flow phases` 档位分节行与 `--json.reviewTier`）；**不参与推进语义**
+ * （`flow advance` 的有效档位 = 显式声明 ?? full，缺省恒零裁剪 ⟹ 既有流程零回归）。
+ * general（无流水线）恒全量语义，不特判。
+ */
+export const MODE_DERIVED_TIER = {
+    full: 'full',
+    fast: 'lean',
+    general: 'full',
+};
 // ── 核心类 ──
 export class FlowManager {
     projectPath;
@@ -1050,14 +1076,48 @@ export class FlowManager {
         }
         return synced;
     }
+    /**
+     * T4：跨会话恢复判定。从 log 尾部回扫（本次条目尚未写入）取该 stage 最近一条
+     * advance_stage_phase / reset_stage_phase 条目（要求 detail.to === exitedPhase）；
+     * 任一侧不可信 / 缺失 → 返回 null（调用方省略 resumed 字段，不臆断；proc: 级不参与跨会话判定）。
+     * @param log 审计日志（本次条目尚未 append）
+     * @param stageKey 阶段键（完整 stageId）
+     * @param exitedPhase 本次转换退出的 phase（= 上一次转换进入的 phase）
+     * @param currentId 本次会话标识（含来源前缀）
+     * @returns true = 异会话恢复；false = 同会话；null = 不可判定（省略字段）
+     */
+    computeResumed(log, stageKey, exitedPhase, currentId) {
+        // 可信判定：仅 env: / project: 前缀参与跨会话判定；proc: → 不可判定
+        if (!(currentId.startsWith('env:') || currentId.startsWith('project:'))) {
+            return null;
+        }
+        for (let k = log.length - 1; k >= 0; k--) {
+            const e = log[k];
+            if (e.action !== 'advance_stage_phase' && e.action !== 'reset_stage_phase') {
+                continue;
+            }
+            const detail = e.detail;
+            if (detail.stageName !== stageKey || detail.to !== exitedPhase) {
+                continue;
+            }
+            const prevId = typeof detail.session_id === 'string' ? detail.session_id : '';
+            // 旧条目无 session_id / 值非法 / 上一侧不可信 → 不可判定
+            if (!(prevId.startsWith('env:') || prevId.startsWith('project:'))) {
+                return null;
+            }
+            return prevId !== currentId; // 同值 → 同会话（false）；异值 → 跨会话恢复（true）
+        }
+        return null; // 无历史转换条目 → 不可判定
+    }
     /**
      * 推进指定阶段到目标流水线阶段（新 API）
      * @param stageName 阶段名（如 stage-01）
      * @param phase 目标流水线阶段（PipelinePhase）
      * @param triggeredBy 触发者标识（如 'cli' / 'Feel'），默认 'flow-manager'
+     * @param opts.reviewTier 本次调用的审查档位（**仅显式声明时写审计键** `review_tier`；缺省不写 ⟹ 既有条目逐字不变）
      * @returns 是否触发 done 归档（true = 本次推进将阶段变为 done 且之前非 done，需在 save 后执行归档 commit）
      */
-    advanceStagePhase(stageName, phase, triggeredBy) {
+    advanceStagePhase(stageName, phase, triggeredBy, opts) {
         if (!this.data) {
             return false;
         }
@@ -1123,12 +1183,21 @@ export class FlowManager {
         const allDone = Object.keys(this.data.stages).length > 0
             && Object.values(this.data.stages).every((s) => s.phase === 'done');
         this.data.pipeline.phase = (allDone ? 'done' : 'active');
+        // T4：跨会话恢复标注（可选字段；任一侧不可信 / 缺失 → 省略 resumed，不臆断）
+        // 计算在 appendLog 之前 → 回扫天然排除本次条目
+        const sessionId = getSessionId({ projectPath: this.projectPath });
+        const resumed = this.computeResumed(this.data.log, key, fromPhase, sessionId);
         // 追加日志（使用实际触发者名，而非硬编码 'flow-manager'）
+        // 审查档位留痕（stage-92 D-92-4）：review_tier **仅显式声明时**追加（既有键逐字保留，缺省条目字节级不变）
         this.appendLog({
             time: '',
             agent: actualTrigger,
             action: 'advance_stage_phase',
-            detail: { stageName: key, from: fromPhase, to: targetPhase },
+            detail: {
+                stageName: key, from: fromPhase, to: targetPhase, session_id: sessionId,
+                ...(resumed === null ? {} : { resumed }),
+                ...(opts?.reviewTier === undefined ? {} : { review_tier: opts.reviewTier }),
+            },
         });
         // REV-003: advance_stage_phase 改为 endStage 时批量聚合，取消逐条写入
         // this.publicLogger.logPhaseChange({...});
@@ -1204,11 +1273,14 @@ export class FlowManager {
         stage.phase = targetPhase;
         stage.status = projectedStatus;
         // 审计日志：reset 为修复而非里程碑推进
+        // T4：跨会话恢复标注（与 advanceStagePhase 同款；计算在 appendLog 之前）
+        const resetSessionId = getSessionId({ projectPath: this.projectPath });
+        const resetResumed = this.computeResumed(this.data.log, key, fromPhase, resetSessionId);
         this.appendLog({
             time: '',
             agent: 'flow-manager',
             action: 'reset_stage_phase',
-            detail: { stageName: key, from: fromPhase, to: targetPhase },
+            detail: { stageName: key, from: fromPhase, to: targetPhase, session_id: resetSessionId, ...(resetResumed === null ? {} : { resumed: resetResumed }) },
         });
         // 需求聚合对称回退（T2）：聚合视图重算——聚合 ≠ done ∧ 需求 status === done → 回退 in_progress；
         // 纯内存；dryRun / no-op 已在 :1585 早退（本点不可达）；不新增写盘点。
@@ -1504,10 +1576,11 @@ export class FlowManager {
      * 无 '|' 的简单 key 保持单条件原行为（精确相等）。
      * @param fromPhase 当前源 phase
      * @param mode 工作流模式（**必传**；由调用点经 resolveStageWorkflowMode 从 stage 派生——禁止默认 mode）
+     * @param tier 审查档位（可选，缺省 'full' = 零裁剪 ⟹ 既有调用逐字零回归）
      * @returns 去重后的可达目标 phase 列表
      */
-    getValidTargets(fromPhase, mode) {
-        const transitions = this.resolveTransitionsForMode(mode);
+    getValidTargets(fromPhase, mode, tier = 'full') {
+        const transitions = this.resolveTransitionsForMode(mode, tier);
         const result = new Set();
         for (const [key, targets] of Object.entries(transitions)) {
             if (transitionKeyMatches(key, fromPhase)) {
@@ -1537,8 +1610,9 @@ export class FlowManager {
      * 获取当前阶段的所有可达下一阶段（基于 transitions 表，支持组合条件）
      * 供 flow wizard 交互模式使用
      * @param stageName 可选阶段名，提供时使用该阶段 phase 进行查找；否则使用 current.stage 的 phase
+     * @param tier 审查档位（可选，缺省 'full' = 零裁剪）
      */
-    getAvailablePhases(stageName) {
+    getAvailablePhases(stageName, tier = 'full') {
         if (!this.data) {
             return [];
         }
@@ -1549,7 +1623,7 @@ export class FlowManager {
         if (!currentPhase)
             return [];
         const mode = this.resolveStageWorkflowMode(stageName).value;
-        return this.getValidTargets(currentPhase, mode);
+        return this.getValidTargets(currentPhase, mode, tier);
     }
     /**
      * 在运行时 transitions 上求 stageName 当前 phase → to 的**唯一**可达路径（B5-1）。
@@ -1557,9 +1631,10 @@ export class FlowManager {
      * 纯只读：不写盘、不改内存。
      * @param stageName 阶段 ID
      * @param to 目标 phase
+     * @param tier 审查档位（可选，缺省 'full' = 零裁剪；显式声明时按裁剪表求路径）
      * @returns 路径与原因（no-path/ambiguous/depth-exceeded 供命令层报错；already-at-target 按 no-op）
      */
-    findPhasePath(stageName, to) {
+    findPhasePath(stageName, to, tier = 'full') {
         // REV-005：归一化 stageId（短名 → 全名），与 setStageDeps / plan scheme * 同范式
         // 双键回退：兼容以短名建键的存量 / 测试数据（归一化键不存在时回退原始键）
         const normalized = normalizeStageId(stageName) ?? stageName;
@@ -1585,7 +1660,7 @@ export class FlowManager {
                 if (node.path.length >= PHASE_PATH_MAX_DEPTH) {
                     continue;
                 }
-                for (const target of this.getValidTargets(node.phase, mode)) {
+                for (const target of this.getValidTargets(node.phase, mode, tier)) {
                     const path = [...node.path, target];
                     if (target === to) {
                         hits.push(path);
@@ -1622,24 +1697,85 @@ export class FlowManager {
         const phases = this.pipelineConfig?.phases ?? this.getDefaultPipelineConfig().phases;
         return [...phases];
     }
+    /**
+     * ═══ 审查档位裁剪（stage-92 D-92-2 / D-92-3；**唯一调用点** = resolveTransitionsForMode）═══
+     * 纯函数：不改入参（不污染 FAST_TRANSITIONS 常量 / pipelineConfig），恒返回新对象 + 新数组。
+     * 算法：
+     * ① `tier === 'full'` → 深拷贝原样返回（零裁剪 ⟹ 既有调用逐字零回归）；
+     * ② 各 key 的 targets 过滤被裁剪相位（目标侧裁剪 = 跳过该审查关）；
+     * ③ **边收缩回退**——若某 key 过滤后 targets 为空且原 targets 非空，则并入「被删目标的 targets」
+     *    （再过滤被裁剪项与自身）后去重。该回退保证 fast 基表裁 `plan_review` 后 `plan_pending` 非空集
+     *    （`['plan_review']` → 收缩 `plan_review` 的 targets → `plan_pending → ['plan_passed']`）。
+     * **裁剪只作用于入边 / 目标侧**：被裁剪相位保留出边（阶段已处于被裁剪关时可向该档位下游推进）；
+     * 「**进入**被裁剪关」仍被目标侧过滤裁掉。
+     * 边界（登记）：含被裁剪相位的**组合 key**（如 `'scheme_review|x'`）按 ② 过滤 targets（不再整键删除）；
+     * 内置 full/fast 表与本仓运行时表均无此类键（唯一组合键 `'review_passed|test_passed'` 不含被裁剪相位）。
+     * @param table 模式基表（由 resolveTransitionsForMode 按既有三分支解析所得）
+     * @param tier 审查档位
+     * @returns 裁剪后的新表
+     */
+    pruneTransitionsByTier(table, tier) {
+        // 全量档：零裁剪（深拷贝返回，防调用方改内存污染基表）
+        if (tier === 'full') {
+            return Object.fromEntries(Object.entries(table).map(([k, v]) => [k, [...v]]));
+        }
+        const pruned = TIER_PRUNED_PHASES[tier];
+        const isPruned = (p) => pruned.includes(p);
+        const result = {};
+        for (const [key, targets] of Object.entries(table)) {
+            const keyConds = parseTransitionKey(key);
+            // ② 目标侧过滤被裁剪相位（裁剪只作用于入边 / 目标侧——被裁剪相位作源键时保留，其出边可推进）
+            let filtered = targets.filter((t) => !isPruned(t));
+            // ③ 边收缩回退：过滤后为空且原 targets 非空 → 并入被删目标的 targets（过滤被裁剪项与自身后去重）
+            if (filtered.length === 0 && targets.length > 0) {
+                const merged = new Set();
+                for (const dropped of targets) {
+                    if (!isPruned(dropped)) {
+                        continue;
+                    }
+                    for (const cascaded of table[dropped] ?? []) {
+                        if (!isPruned(cascaded) && !keyConds.includes(cascaded)) {
+                            merged.add(cascaded);
+                        }
+                    }
+                }
+                filtered = [...merged];
+            }
+            result[key] = filtered;
+        }
+        return result;
+    }
     /**
      * 按模式解析运行时转移表（唯一取表法则；校验/推进/路径 与 展示 同经本函数 ⇒ 单一信源）。
      * full → 运行时 pipelineConfig.transitions（pipeline.yaml 覆盖线）；fast → fast_transitions ?? 内置快线表。
+     * general → 空表（无流水线；模式语义本身，非「缺省回落」）。
+     * 审查档位为**第二参延伸**（stage-92 D-92-3）：末尾统一经 pruneTransitionsByTier 裁剪；
+     * 缺省 tier='full' = 零裁剪 ⟹ 与原逻辑等价（唯一取表点不变，禁第二份层序 / 取表）。
      * 说明：pipelineConfig 构造期恒已加载（constructor 无条件调用），`?? 内置` 保留既有访问器回退语义。
      */
-    resolveTransitionsForMode(mode) {
+    resolveTransitionsForMode(mode, tier = 'full') {
+        let raw;
         if (mode === 'fast') {
-            return this.fastTransitions ?? this.getDefaultPipelineConfig('fast').transitions;
+            raw = this.fastTransitions ?? this.getDefaultPipelineConfig('fast').transitions;
+        }
+        else if (mode === 'general') {
+            // general（无流水线）：空表为**模式语义**的忠实表达（D-90-3；与 pipeline.yaml fast_transitions:{} 的「配置层空值回落」路径 / 语义均不同）
+            raw = {};
         }
-        return this.pipelineConfig?.transitions ?? this.getDefaultPipelineConfig().transitions;
+        else {
+            raw = this.pipelineConfig?.transitions ?? this.getDefaultPipelineConfig().transitions;
+        }
+        // 档位裁剪统一落此处（唯一取表点的单一裁剪入口；general 空表裁剪后仍空表）
+        return this.pruneTransitionsByTier(raw, tier);
     }
     /**
      * 获取运行时生效的 phase 转移表（key 可含 '|' 组合条件）。
      * 缺省/解析失败时回退内置默认配置。返回浅拷贝。
      * **无参 = full**（零回归既有消费点）；fast 供 stage-75 `flow phases` 模式分节消费。
+     * @param tier 审查档位（可选，缺省 'full' = 零裁剪）
      */
-    getPipelineTransitions(mode = 'full') {
-        const transitions = this.resolveTransitionsForMode(mode);
+    getPipelineTransitions(mode = 'full', tier = 'full') {
+        const transitions = this.resolveTransitionsForMode(mode, tier);
         return Object.fromEntries(Object.entries(transitions).map(([k, v]) => [k, [...v]]));
     }
     /**
@@ -1809,7 +1945,8 @@ export class FlowManager {
                     // 匹配执行模式、自动推进、工作流模式
                     const execMatch = content.match(/\*\*执行模式\*\*[：:]\s*(manual|auto)/);
                     const autoMatch = content.match(/\*\*自动推进\*\*[：:]\s*(disabled|enabled)/);
-                    const modeMatch = content.match(/\*\*工作流模式\*\*[：:]\s*(full|fast)/);
+                    // 值域自 WORKFLOW_MODES 派生（单源；stage-90——漏改本行即第 1 层丢弃、静默回落 config）
+                    const modeMatch = content.match(new RegExp(`\\*\\*工作流模式\\*\\*[：:]\\s*(${WORKFLOW_MODES.join('|')})`));
                     if (execMatch) {
                         statusOverrides['execution_mode'] = execMatch[1];
                     }
@@ -1839,6 +1976,11 @@ export class FlowManager {
         const cascade = this.buildCascadeConfig();
         const result = {};
         for (const key of EFFECTIVE_CONFIG_KEYS) {
+            if (key === 'workflow_mode') {
+                // Q4 定稿（D-90-6）：委托单点层级函数（无参 = 当前阶段域，与 config effective 语义域一致）；禁第二份层序判定
+                result[key] = this.resolveStageWorkflowMode();
+                continue;
+            }
             if (cascade.statusOverrides[key] !== undefined) {
                 result[key] = { value: cascade.statusOverrides[key], source: 'status.md' };
             }
@@ -1858,11 +2000,11 @@ export class FlowManager {
     /**
      * 解析指定阶段的工作流模式（裁定 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）。
+     *   > 需求级（关联需求携带的 workflow_mode）> 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
+     * @returns { value, source }，source ∈ status.md | requirement | config.yaml | profile.yaml | builtin
      */
     resolveStageWorkflowMode(stageId) {
         const cascade = this.buildCascadeConfig(stageId);
@@ -1870,6 +2012,18 @@ export class FlowManager {
         if (cascade.statusOverrides[key] !== undefined) {
             return { value: cascade.statusOverrides[key], source: 'status.md' };
         }
+        // ── 需求级层（stage-90 T2.2）：阶段关联需求携带的模式属性 ──
+        // 读侧宽容：缺失 / 悬空 / 非法 → 自然回落下一层（零报错）；阶段定位与 status.md 层同域（归一 + 键回退）
+        const reqTarget = stageId ?? this.data?.pipeline.current.stage;
+        const reqStageRec = reqTarget ? this.data?.stages?.[normalizeStageId(reqTarget) ?? reqTarget] : undefined;
+        const reqId = reqStageRec?.requirement_id ?? null;
+        if (reqId) {
+            const reqRec = (Array.isArray(this.data?.requirements) ? this.data.requirements : []).find((r) => r?.id === reqId);
+            const reqMode = reqRec?.workflow_mode;
+            if (reqMode !== undefined && WORKFLOW_MODES.includes(reqMode)) {
+                return { value: reqMode, source: 'requirement' };
+            }
+        }
         if (cascade.configDefaults[key] !== undefined) {
             return { value: cascade.configDefaults[key], source: 'config.yaml' };
         }
@@ -1950,6 +2104,14 @@ export class FlowManager {
         }
         return result;
     }
+    /**
+     * 公开单点：将 PipelinePhase 映射为负责 Agent 标识。
+     * 命令层 / 适配器一律经本方法消费，禁止复制映射；内部委托 mapPhaseToAgent。
+     * 与 flow status --verbose 的 downstreamPhases.responsibleAgent 同源。
+     */
+    getResponsibleAgent(phase) {
+        return this.mapPhaseToAgent(phase);
+    }
     /** 将 PipelinePhase 映射为负责 Agent 标识（返回新名，供新写入使用） */
     mapPhaseToAgent(phase) {
         const prefix = phase.split('_')[0];
@@ -2005,6 +2167,9 @@ export class FlowManager {
         const stageIdOfOp = this.parseOpId(opId)?.stageId;
         if (result === 'pass') {
             op.state = 'done';
+            // T3：op 级埋点（唯一写入点 = recordAttempt；pass 同时进入 done 终态）
+            op.attempted_at = new Date().toISOString();
+            op.completed_at = op.attempted_at;
             if (stageIdOfOp) {
                 this.syncCurrentOp(stageIdOfOp);
             }
@@ -2026,6 +2191,8 @@ export class FlowManager {
         // result === 'fail'
         if (op.attempts < op.max_attempts) {
             op.state = 'pending'; // 回到 pending 等待重试
+            // T3：仅记 attempted_at（未进入终态 → completed_at 缺省）
+            op.attempted_at = new Date().toISOString();
             if (stageIdOfOp) {
                 this.syncCurrentOp(stageIdOfOp);
             }
@@ -2046,6 +2213,9 @@ export class FlowManager {
         }
         // 重试耗尽
         op.state = 'failed';
+        // T3：重试耗尽 = 进入 failed 终态 → 双写
+        op.attempted_at = new Date().toISOString();
+        op.completed_at = op.attempted_at;
         this.data.pipeline.retry += 1;
         this.appendLog({
             time: '',
@@ -3624,6 +3794,7 @@ export class FlowManager {
      * 当 pipeline.yaml 不存在或解析失败时使用。
      * @param mode 工作流模式；**无参 = full**（内置 full 表逐字等于历史现状，零回归既有消费点）；
      *             'fast' 返回快线表（FAST_TRANSITIONS 常量引用）。phases / checkpoint_mapping / phase_corrections 两模式共用。
+     *             'general' 返回空转移表（无流水线；phases 仍 15 项）。
      */
     getDefaultPipelineConfig(mode = 'full') {
         return {
@@ -3636,25 +3807,27 @@ export class FlowManager {
             ],
             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: [],
-                },
+                : mode === 'general'
+                    ? {} // general：无流水线（空表；phases 仍 15 项，不新增 phase）
+                    : {
+                        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',