easy-coding-harness 0.8.3 → 0.9.0-beta.0

package/CHANGELOG.md

@@ -6,6 +6,26 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.9.0-beta.0
+
+- 将单一 `behavior.confirm_mode` 拆分为 `behavior.approval_mode` 与
+  `behavior.workflow_mode`：审批等待和执行深度不再耦合；工作流默认使用 `adaptive`，
+  并在 ANALYSIS 结束时解析、展示并冻结为 `fast`、`standard` 或 `strict`。
+- `approval_mode` 新增 `confirm`：仅在 ANALYSIS → IMPLEMENT 等待一次方案确认，确认后
+  REVIEW、VERIFICATION、MEMORY、COMPLETE 在各自机械质量门禁通过后自动推进。
+- 保留完整代码任务状态链，Fast 也必须进入 REVIEW；按模式调整每个状态内部的上下文
+  加载、主 Agent/子 Agent 分工、审查独立性、验证范围和记忆深度，减少无效 Token、
+  固定子 Agent 调度和重复全量检查。
+- 新增工作流模式提案、机械风险下限、原子冻结和只升不降机制；REVIEW 证据绑定最终
+  实现指纹，VERIFICATION 证据绑定实现与配置指纹，相关内容未变化时可复用、变化后
+  自动失效。
+- REVIEW 返工改为按语义单元合并，明确 error/warning/info 阻断语义；同类问题连续两轮
+  未解决时停止盲目返工并回到重新分析。
+- 配置 Schema 升至 3；旧 `lite` 自动迁移为 `approval_mode: guard` 与
+  `workflow_mode: fast`，旧 approve/guard/auto 保留审批语义并默认使用 adaptive；
+  在途任务通过 legacy 标记兼容已有提案与 REVIEW 证据，仅旧 lite 或已持久化直通边
+  保留一次 IMPLEMENT → VERIFICATION；已处于 VERIFICATION 的旧任务仍需新鲜验证证据。
+
 ## 0.8.3
 
 - 正式发布 Codex App thread 级 session 隔离：标准 hook `session_id` 缺失时使用 `CODEX_THREAD_ID`，避免同一 App 进程内多个逻辑会话共享 PPID session。

package/README.md

@@ -70,21 +70,26 @@ easy-coding init --submodules packages/a,packages/b
 
 ```text
 INIT --[always auto]--> ANALYSIS -> IMPLEMENT -> REVIEW -> VERIFICATION -> MEMORY --[always auto]--> COMPLETE
-                                    \----------------> VERIFICATION
                                     \--[read-only, mode-aware]-----------------------> COMPLETE
                  ^            ^          |             |
                  +-- replan ---+          +--- fix -----+
                               ^                         |
                               +------- repair ----------+
-edge behavior --[approve / guard / lite / auto]--> target stage
+approval --[approve / guard / confirm / auto]--> transition wait policy
+workflow --[adaptive => fast / standard / strict]--> stage execution depth
 any stage --[user abort via ec-task-close]--> CLOSED
 ```
 
-- 生效确认模式优先级为 session 覆盖 > 项目 `behavior.confirm_mode` > `guard` 默认值。
-- `approve` 除 `INIT → ANALYSIS`、`MEMORY → COMPLETE` 外逐边确认；`guard` 与 `lite` 只确认 `ANALYSIS → IMPLEMENT`、`VERIFICATION → MEMORY`；`auto` 自动执行全部合法工作流边。任何模式下关闭任务都必须显式执行。
-- `guard` / `auto` 的代码主链在 IMPLEMENT 后默认进入 REVIEW；`lite` 不执行 REVIEW，直接进入 VERIFICATION；`approve` 可明确选择 REVIEW 或跳过它。确认模式不绕过状态合法性、方案产物或验证门控。
+- 审批模式优先级为 session 覆盖 > 项目 `behavior.approval_mode` > `guard`；`approve`
+  逐边确认，`guard` 确认 ANALYSIS → IMPLEMENT 与 VERIFICATION → MEMORY，`confirm` 只在
+  ANALYSIS → IMPLEMENT 确认一次，随后各阶段在质量门禁通过后自动推进，`auto` 从开始即
+  自动推进。
+- 工作流模式优先级为 session 覆盖 > 项目 `behavior.workflow_mode` > `adaptive`。Adaptive 在 ANALYSIS 结束时根据风险解析、展示并冻结为 `fast`、`standard` 或 `strict`，用户可在风险下限之上调整。
+- 所有新代码任务都完整进入 REVIEW；不同工作流模式只调整各状态内部的上下文加载、执行主体、审查独立性、验证范围和记忆深度，不绕过状态或证据门禁。
 - 显式 `doc` / `analysis` / `report` 只读任务不生成 `test-strategy.md`；展示完整报告后按生效模式进入 COMPLETE，不执行 REVIEW、VERIFICATION 或 MEMORY，也不写任务记忆。
-- `VERIFICATION` 是验证硬门控，未实际运行的 lint、typecheck、test 不算通过。
+- `VERIFICATION` 是验证硬门控：Fast 运行最小充分检查，Standard 运行受影响范围检查，
+  Strict 运行项目适用的完整 lint/typecheck/test/build；所选模式要求的检查未真实执行
+  并留下当前指纹下的绿色证据，就不算通过。
 - `MEMORY` 先写入本次任务短期记忆，再执行长期记忆阈值门禁；未超过阈值时长期沉淀为 no-op。
 
 ## Supermodule 模型
@@ -108,7 +113,7 @@ any stage --[user abort via ec-task-close]--> CLOSED
 | `easy-coding add-agent` | 给已接入项目追加 Claude Code、Codex 或 Qoder 支持；supermodule 父仓可按已初始化子仓分层追加 |
 | `easy-coding upgrade` | CLI 升级后同步项目内生成文件，生成区覆盖，用户资产保留；supermodule 父仓会同步升级已初始化子仓 |
 | `easy-coding update` | 更新全局 CLI 到最新发布版 |
-| `easy-coding config` | 交互修改当前项目的 `confirm_mode` |
+| `easy-coding config` | 交互修改当前项目的 `approval_mode` 与 `workflow_mode` |
 | `easy-coding status` | 查看已安装平台、harness 版本、当前任务状态 |
 | `easy-coding clear` | 移除 harness 安装物，保留 tasks、spec、memory、project.yaml 等用户资产；supermodule 父仓支持交互选择、`--submodules` 和 `--no-submodules` |
 
@@ -158,10 +163,11 @@ easy-coding upgrade
 
 `upgrade` 会刷新生成区内的 skills、hooks、agents、主约束模板和运行时模板，不会删除已有任务、spec、memory、project.yaml 或项目知识文件。
 
-升级到 0.7.0 时，旧 `strict_confirm` / `auto_mode` 会一次性迁移为
-`behavior.confirm_mode` 并从配置中删除。项目级模式用 `easy-coding config` 修改（要求
+升级到 0.9.0 时，旧 `strict_confirm` / `auto_mode` / `confirm_mode` 会一次性迁移为
+`behavior.approval_mode` 与 `behavior.workflow_mode`；旧 `lite` 映射为 `guard + fast`。
+项目级模式用 `easy-coding config` 修改（要求
 项目 Harness 与 CLI 版本完全一致，否则先执行 `easy-coding upgrade` 或更新 CLI）；当前
-session 的临时覆盖通过 `ec-task-management` 对话修改。
+session 的两类临时覆盖通过 `ec-task-management` 对话修改。
 
 若当前会话不希望 Harness 接管，显式调用 `/ec-no-harness`（Codex 使用
 `$ec-no-harness`）。它只旁路 Easy Coding，不关闭其他 hooks，也不忽略其他 skills；

package/dist/cli.js

@@ -103,8 +103,9 @@ async function isDirectory(filePath) {
 }
 
 // src/utils/config-yaml.ts
-var CONFIG_SCHEMA_VERSION = 2;
-var CONFIRM_MODES = ["approve", "guard", "lite", "auto"];
+var CONFIG_SCHEMA_VERSION = 3;
+var APPROVAL_MODES = ["approve", "guard", "confirm", "auto"];
+var CONFIGURED_WORKFLOW_MODES = ["adaptive", "fast", "standard", "strict"];
 function createDefaultConfig(params) {
   const config2 = {
     version: CONFIG_SCHEMA_VERSION,
@@ -123,7 +124,8 @@ function createDefaultConfig(params) {
       auto_archive_days: 30
     },
     behavior: {
-      confirm_mode: "guard"
+      approval_mode: "guard",
+      workflow_mode: "adaptive"
     }
   };
   if (params.supermodule) {
@@ -171,38 +173,37 @@ async function updateHarnessVersion(filePath, version) {
     config2.harness_version = version;
   });
 }
-function isConfirmMode(value) {
-  return typeof value === "string" && CONFIRM_MODES.includes(value);
+function isApprovalMode(value) {
+  return typeof value === "string" && APPROVAL_MODES.includes(value);
 }
-function resolveLegacyConfirmMode(config2) {
+function isConfiguredWorkflowMode(value) {
+  return typeof value === "string" && CONFIGURED_WORKFLOW_MODES.includes(value);
+}
+function resolveLegacyBehavior(config2) {
   const behavior = config2.behavior ?? {};
-  if (isConfirmMode(behavior.confirm_mode)) {
-    return behavior.confirm_mode;
-  }
-  if (behavior.auto_mode === true) {
-    return "auto";
-  }
-  if (behavior.strict_confirm === true) {
-    return "approve";
-  }
-  return "guard";
+  const legacyLite = behavior.confirm_mode === "lite";
+  const approvalMode = isApprovalMode(behavior.approval_mode) ? behavior.approval_mode : isApprovalMode(behavior.confirm_mode) ? behavior.confirm_mode : behavior.auto_mode === true ? "auto" : behavior.strict_confirm === true ? "approve" : "guard";
+  const workflowMode = isConfiguredWorkflowMode(behavior.workflow_mode) ? behavior.workflow_mode : legacyLite ? "fast" : "adaptive";
+  return { approvalMode, workflowMode };
 }
-async function setConfirmMode(filePath, mode) {
+async function setBehaviorModes(filePath, approvalMode, workflowMode) {
   return updateConfigYaml(filePath, (config2) => {
     const legacyBehavior = config2.behavior ?? {};
     const behavior = Object.fromEntries(
       Object.entries(legacyBehavior).filter(
-        ([key]) => key !== "strict_confirm" && key !== "auto_mode"
+        ([key]) => key !== "strict_confirm" && key !== "auto_mode" && key !== "confirm_mode" && key !== "approval_mode" && key !== "workflow_mode"
       )
     );
-    behavior.confirm_mode = mode;
+    behavior.approval_mode = approvalMode;
+    behavior.workflow_mode = workflowMode;
     config2.behavior = behavior;
     config2.version = CONFIG_SCHEMA_VERSION;
   });
 }
-async function migrateConfirmModeConfig(filePath) {
+async function migrateBehaviorConfig(filePath) {
   const config2 = await readConfigYaml(filePath);
-  return setConfirmMode(filePath, resolveLegacyConfirmMode(config2));
+  const { approvalMode, workflowMode } = resolveLegacyBehavior(config2);
+  return setBehaviorModes(filePath, approvalMode, workflowMode);
 }
 async function ensureProjectId(filePath) {
   let projectId = "";
@@ -805,8 +806,105 @@ function migrateTaskWorkflowState(task) {
     task.memory_progress = progress;
     changed = true;
   }
+  const status2 = String(task.status ?? "");
+  const taskType = String(task.type ?? "").toLowerCase();
+  const isActive = !["", "PENDING", "COMPLETE", "CLOSED"].includes(status2);
+  if (isActive && taskType !== "project-init" && !["fast", "standard", "strict"].includes(String(task.workflow_mode ?? ""))) {
+    task.workflow_mode = ["analysis", "doc", "report"].includes(taskType) ? "fast" : "strict";
+    task.workflow_mode_confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+    task.workflow_mode_confirmed_by = "upgrade-migration";
+    task.workflow_mode_legacy = true;
+    changed = true;
+  }
+  return changed;
+}
+function migrateSessionBehavior(session) {
+  let changed = false;
+  const legacyMode = session.confirm_mode;
+  const legacyLite = legacyMode === "lite";
+  if (!["approve", "guard", "confirm", "auto"].includes(String(session.approval_mode ?? ""))) {
+    if (legacyLite) {
+      session.approval_mode = "guard";
+      changed = true;
+    } else if (["approve", "guard", "confirm", "auto"].includes(String(legacyMode ?? ""))) {
+      session.approval_mode = legacyMode;
+      changed = true;
+    }
+  }
+  if (!["adaptive", "fast", "standard", "strict"].includes(String(session.workflow_mode ?? ""))) {
+    if (legacyLite) {
+      session.workflow_mode = "fast";
+      session.workflow_mode_legacy_confirm_override = true;
+      session.workflow_mode_legacy_alias_override = void 0;
+      changed = true;
+    } else if (["approve", "guard", "confirm", "auto"].includes(String(legacyMode ?? ""))) {
+      session.workflow_mode = "adaptive";
+      session.workflow_mode_legacy_alias_override = true;
+      session.workflow_mode_legacy_confirm_override = void 0;
+      changed = true;
+    }
+  }
+  if (legacyLite && session.workflow_mode_legacy_alias_override === true) {
+    session.workflow_mode_legacy_alias_override = void 0;
+    changed = true;
+  } else if (["approve", "guard", "confirm", "auto"].includes(String(legacyMode ?? "")) && session.workflow_mode_legacy_confirm_override === true) {
+    session.workflow_mode_legacy_confirm_override = void 0;
+    changed = true;
+  }
+  if ("confirm_mode" in session) {
+    session.confirm_mode = void 0;
+    changed = true;
+  }
   return changed;
 }
+var WORKFLOW_MODE_RANK = {
+  fast: 0,
+  standard: 1,
+  strict: 2
+};
+function sessionMigrationCandidate(session) {
+  if (typeof session.current_task !== "string") return null;
+  const workflowMode = ["adaptive", "fast", "standard", "strict"].includes(
+    String(session.workflow_mode ?? "")
+  ) ? session.workflow_mode : void 0;
+  return {
+    currentTask: session.current_task,
+    agent: typeof session.agent === "string" ? session.agent : void 0,
+    lastAgent: typeof session.last_agent === "string" ? session.last_agent : void 0,
+    workflowMode,
+    legacyLite: session.workflow_mode_legacy_confirm_override === true
+  };
+}
+function relevantSessionMigrationCandidates(task, candidates) {
+  const taskAgent = String(task.last_agent ?? "");
+  const ownerCandidates = candidates.filter(
+    (candidate) => candidate.agent === taskAgent || candidate.lastAgent === taskAgent
+  );
+  return ownerCandidates.length > 0 ? ownerCandidates : candidates;
+}
+function migrationWorkflowMode(task, candidates, projectWorkflowMode) {
+  const taskType = String(task.type ?? "").toLowerCase();
+  if (["analysis", "doc", "report"].includes(taskType)) return "fast";
+  const relevantCandidates = relevantSessionMigrationCandidates(task, candidates);
+  const fallbackMode = projectWorkflowMode === "adaptive" ? "strict" : projectWorkflowMode;
+  const concreteModes = relevantCandidates.map(
+    (candidate) => candidate.workflowMode === "adaptive" ? "strict" : candidate.workflowMode ?? fallbackMode
+  );
+  if (concreteModes.length === 0) return fallbackMode;
+  return concreteModes.reduce(
+    (highest, mode) => WORKFLOW_MODE_RANK[mode] > WORKFLOW_MODE_RANK[highest] ? mode : highest
+  );
+}
+function preserveLegacyDirectEdge(task, candidates, projectLegacyLite) {
+  if (task.status !== "IMPLEMENT") return false;
+  const pending = task.pending_transition && typeof task.pending_transition === "object" && !Array.isArray(task.pending_transition) ? task.pending_transition : null;
+  if (pending?.from === "IMPLEMENT" && pending.to === "VERIFICATION") return true;
+  const relevantCandidates = relevantSessionMigrationCandidates(task, candidates);
+  if (relevantCandidates.length > 0) {
+    return relevantCandidates.every((candidate) => candidate.legacyLite);
+  }
+  return projectLegacyLite;
+}
 async function taskFiles(cwd) {
   const tasksDir = path7.join(cwd, EASY_CODING_DIR, TASKS_DIR);
   if (!await pathExists(tasksDir)) return [];
@@ -832,7 +930,7 @@ async function hasLegacyWorkflowState(cwd) {
     if (!await pathExists(filePath)) continue;
     const task = await readJsonRecord(filePath);
     if (!task) continue;
-    if (isLegacyStage(task.status) || Array.isArray(task.stage_history) && task.stage_history.some(
+    if (isLegacyStage(task.status) || !["PENDING", "COMPLETE", "CLOSED"].includes(String(task.status ?? "")) && String(task.type ?? "") !== "project-init" && !["fast", "standard", "strict"].includes(String(task.workflow_mode ?? "")) || Array.isArray(task.stage_history) && task.stage_history.some(
       (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && isLegacyStage(entry.stage)
     )) {
       return true;
@@ -841,13 +939,26 @@ async function hasLegacyWorkflowState(cwd) {
   for (const filePath of await sessionFiles(cwd)) {
     const session = await readJsonRecord(filePath);
     if (!session) continue;
-    if (isLegacyStage(session.last_seen_stage)) return true;
+    if (isLegacyStage(session.last_seen_stage) || "confirm_mode" in session) return true;
   }
   return false;
 }
 async function migrateLegacyWorkflowState(cwd) {
   let tasksUpdated = 0;
   let sessionsUpdated = 0;
+  const updatedTaskPaths = /* @__PURE__ */ new Set();
+  let projectWorkflowMode = "adaptive";
+  let projectLegacyLite = false;
+  const configPath2 = path7.join(cwd, EASY_CODING_DIR, "config.yaml");
+  if (await pathExists(configPath2)) {
+    try {
+      const config2 = await readConfigYaml(configPath2);
+      projectWorkflowMode = resolveLegacyBehavior(config2).workflowMode;
+      const behavior = config2.behavior ?? {};
+      projectLegacyLite = behavior.confirm_mode === "lite";
+    } catch {
+    }
+  }
   for (const filePath of await taskFiles(cwd)) {
     if (!await pathExists(filePath)) continue;
     const task = await readJsonRecord(filePath);
@@ -855,15 +966,68 @@ async function migrateLegacyWorkflowState(cwd) {
     if (!migrateTaskWorkflowState(task)) continue;
     await writeTextFile(filePath, JSON.stringify(task, null, 2));
     tasksUpdated += 1;
+    updatedTaskPaths.add(filePath);
   }
+  const sessionCandidates = [];
   for (const filePath of await sessionFiles(cwd)) {
     const session = await readJsonRecord(filePath);
     if (!session) continue;
     const mappedStage = migrateStage(session.last_seen_stage);
-    if (mappedStage === session.last_seen_stage) continue;
-    session.last_seen_stage = mappedStage;
-    await writeTextFile(filePath, JSON.stringify(session, null, 2));
-    sessionsUpdated += 1;
+    let changed = false;
+    if (mappedStage !== session.last_seen_stage) {
+      session.last_seen_stage = mappedStage;
+      changed = true;
+    }
+    changed = migrateSessionBehavior(session) || changed;
+    const candidate = sessionMigrationCandidate(session);
+    if (candidate) sessionCandidates.push(candidate);
+    if (changed) {
+      await writeTextFile(filePath, JSON.stringify(session, null, 2));
+      sessionsUpdated += 1;
+    }
+  }
+  const candidatesByTask = /* @__PURE__ */ new Map();
+  for (const candidate of sessionCandidates) {
+    const candidates = candidatesByTask.get(candidate.currentTask) ?? [];
+    candidates.push(candidate);
+    candidatesByTask.set(candidate.currentTask, candidates);
+  }
+  for (const filePath of await taskFiles(cwd)) {
+    const task = await readJsonRecord(filePath);
+    if (!task) continue;
+    const migrationOwned = task.workflow_mode_legacy === true && task.workflow_mode_confirmed_by === "upgrade-migration";
+    if (!migrationOwned) continue;
+    const taskId = path7.basename(path7.dirname(filePath));
+    const mode = migrationWorkflowMode(
+      task,
+      candidatesByTask.get(taskId) ?? [],
+      projectWorkflowMode
+    );
+    let changed = false;
+    if (task.workflow_mode !== mode) {
+      task.workflow_mode = mode;
+      task.workflow_mode_confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+      changed = true;
+    }
+    const keepDirectEdge = preserveLegacyDirectEdge(
+      task,
+      candidatesByTask.get(taskId) ?? [],
+      projectLegacyLite
+    );
+    if (keepDirectEdge && task.workflow_mode_legacy_direct_edge !== true) {
+      task.workflow_mode_legacy_direct_edge = true;
+      changed = true;
+    } else if (!keepDirectEdge && "workflow_mode_legacy_direct_edge" in task) {
+      task.workflow_mode_legacy_direct_edge = void 0;
+      changed = true;
+    }
+    if (changed) {
+      await writeTextFile(filePath, JSON.stringify(task, null, 2));
+      if (!updatedTaskPaths.has(filePath)) {
+        tasksUpdated += 1;
+        updatedTaskPaths.add(filePath);
+      }
+    }
   }
   return { tasksUpdated, sessionsUpdated };
 }
@@ -2676,10 +2840,10 @@ async function config() {
       `Project harness ${projectConfig.harness_version} does not exactly match CLI ${VERSION}. Upgrade the harness or update the CLI before changing config.`
     );
   }
-  const current = resolveLegacyConfirmMode(projectConfig);
-  const selected = await select({
-    message: `Select project confirm mode (current: ${current})`,
-    initialValue: current,
+  const current = resolveLegacyBehavior(projectConfig);
+  const approvalMode = await select({
+    message: `Select project approval mode (current: ${current.approvalMode})`,
+    initialValue: current.approvalMode,
     options: [
       {
         value: "approve",
@@ -2692,9 +2856,9 @@ async function config() {
         hint: "ANALYSIS -> IMPLEMENT and VERIFICATION -> MEMORY"
       },
       {
-        value: "lite",
-        label: "lite \u2014 guard gates without code review",
-        hint: "IMPLEMENT -> VERIFICATION"
+        value: "confirm",
+        label: "confirm \u2014 confirm the plan once",
+        hint: "only ANALYSIS -> IMPLEMENT; later stages advance after quality gates"
       },
       {
         value: "auto",
@@ -2703,20 +2867,50 @@ async function config() {
       }
     ]
   });
-  if (typeof selected === "symbol") {
+  if (typeof approvalMode === "symbol") {
+    cancel4("Configuration cancelled.");
+    return;
+  }
+  const workflowMode = await select({
+    message: `Select project workflow mode (current: ${current.workflowMode})`,
+    initialValue: current.workflowMode,
+    options: [
+      {
+        value: "adaptive",
+        label: "adaptive \u2014 choose by task risk (default)",
+        hint: "freezes to fast, standard, or strict after ANALYSIS"
+      },
+      {
+        value: "fast",
+        label: "fast \u2014 compact execution for low-risk tasks",
+        hint: "all workflow stages still run"
+      },
+      {
+        value: "standard",
+        label: "standard \u2014 balanced execution",
+        hint: "independent review and impacted verification"
+      },
+      {
+        value: "strict",
+        label: "strict \u2014 maximum assurance",
+        hint: "multi-dimensional review and full verification"
+      }
+    ]
+  });
+  if (typeof workflowMode === "symbol") {
     cancel4("Configuration cancelled.");
     return;
   }
   const shouldSave = await confirm3({
-    message: `Set behavior.confirm_mode to ${selected}?`,
+    message: `Set behavior.approval_mode to ${approvalMode} and behavior.workflow_mode to ${workflowMode}?`,
     initialValue: true
   });
   if (typeof shouldSave === "symbol" || !shouldSave) {
     cancel4("Configuration cancelled.");
     return;
   }
-  await setConfirmMode(configPath2, selected);
-  outro3(chalk4.green(`Project confirm mode updated to ${selected}.`));
+  await setBehaviorModes(configPath2, approvalMode, workflowMode);
+  outro3(chalk4.green(`Project modes updated: approval=${approvalMode}, workflow=${workflowMode}.`));
 }
 
 // src/commands/init.ts
@@ -3021,22 +3215,34 @@ async function status() {
   }
   console.log(`  agents: ${config2.agents.join(", ") || "(none)"}`);
   console.log(`  project: ${config2.project.name}`);
-  const projectConfirmMode = isConfirmMode(config2.behavior?.confirm_mode) ? config2.behavior.confirm_mode : "guard";
-  console.log(`  confirm_mode: ${projectConfirmMode}`);
+  const migratedBehavior = resolveLegacyBehavior(config2);
+  const projectApprovalMode = isApprovalMode(config2.behavior?.approval_mode) ? config2.behavior.approval_mode : migratedBehavior.approvalMode;
+  const projectWorkflowMode = isConfiguredWorkflowMode(config2.behavior?.workflow_mode) ? config2.behavior.workflow_mode : migratedBehavior.workflowMode;
+  console.log(`  approval_mode: ${projectApprovalMode}`);
+  console.log(`  workflow_mode: ${projectWorkflowMode}`);
   console.log("");
   console.log(chalk6.bold("Sessions"));
-  console.log(`  project_confirm_mode: ${projectConfirmMode}`);
-  console.log(`  effective_confirm_mode: ${projectConfirmMode} (without a session override)`);
+  console.log(`  project_approval_mode: ${projectApprovalMode}`);
+  console.log(`  project_workflow_mode: ${projectWorkflowMode}`);
+  console.log(`  effective_approval_mode: ${projectApprovalMode} (without a session override)`);
+  console.log(`  configured_workflow_mode: ${projectWorkflowMode} (without a session override)`);
   if (sessions.length === 0) {
     console.log("  no session files");
   }
   for (const { key, session } of sessions) {
-    const sessionConfirmMode = session.confirm_mode;
+    const legacySessionMode = session.confirm_mode;
+    const hasLegacySessionMode = ["approve", "guard", "confirm", "auto"].includes(
+      String(legacySessionMode ?? "")
+    );
+    const sessionApprovalMode = session.approval_mode ?? (legacySessionMode === "lite" ? "guard" : legacySessionMode);
+    const sessionWorkflowMode = session.workflow_mode ?? (legacySessionMode === "lite" ? "fast" : hasLegacySessionMode ? "adaptive" : void 0);
     console.log(`  - ${key}`);
     console.log(`    agent: ${session.agent ?? "legacy/unknown"}`);
     console.log(`    source: ${session.session_source ?? "legacy"}`);
-    console.log(`    confirm_mode: ${sessionConfirmMode ?? "project default"}`);
-    console.log(`    effective_confirm_mode: ${sessionConfirmMode ?? projectConfirmMode}`);
+    console.log(`    approval_mode: ${sessionApprovalMode ?? "project default"}`);
+    console.log(`    workflow_mode: ${sessionWorkflowMode ?? "project default"}`);
+    console.log(`    effective_approval_mode: ${sessionApprovalMode ?? projectApprovalMode}`);
+    console.log(`    configured_workflow_mode: ${sessionWorkflowMode ?? projectWorkflowMode}`);
     console.log(
       `    harness: ${session.harness_disabled ? "disabled for this session" : "enabled"}`
     );
@@ -3049,6 +3255,9 @@ async function status() {
       const task = await readTaskJson(taskPath);
       console.log(`    current_task: ${session.current_task}`);
       console.log(`    current_stage: ${task.status}`);
+      console.log(
+        `    task_workflow_mode: ${task.workflow_mode ?? task.workflow_mode_proposal?.selected_mode ?? "not resolved"}`
+      );
       console.log(`    last_agent: ${task.last_agent}`);
     } else {
       console.log(`    current_task: ${session.current_task} (task.json missing)`);
@@ -3162,7 +3371,7 @@ async function upgrade(opts) {
     ].filter(Boolean) : [],
     "Will overwrite managed skills, hooks, agents, templates, and generated main-constraint regions.",
     "Will update project-init task to recommend ec-init re-run for version adaptation.",
-    "Will migrate behavior.strict_confirm/auto_mode to behavior.confirm_mode and remove the old keys.",
+    "Will migrate legacy confirmation settings to behavior.approval_mode and behavior.workflow_mode.",
     "Will migrate legacy workflow stage metadata; memory content, spec, and project knowledge files remain untouched."
   ].join("\n");
   if (opts.dryRun) {
@@ -3195,7 +3404,7 @@ async function upgrade(opts) {
     await ensureEasyCodingSessionsIgnored(target.dir);
     await ensureHookBytecodeIgnored(target.dir);
     await migrateLegacyWorkflowState(target.dir);
-    await migrateConfirmModeConfig(target.configPath);
+    await migrateBehaviorConfig(target.configPath);
     await updateHarnessVersion(target.configPath, VERSION);
     await updateSupermoduleConfig(target.configPath, target.supermodule);
     await setPendingInitSince(target.dir, VERSION);