easy-coding-harness 0.5.3 → 0.6.1

package/CHANGELOG.md

@@ -6,6 +6,33 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.6.1
+
+- 状态迁移按是否需要用户决策分层：`INIT → ANALYSIS` 在 INIT 工作完成后自动流转，`MEMORY → COMPLETE` 在记忆处理检查点完成后自动流转；这两条机械边不再创建 `pending_transition`，也不再展示确认或交接选项。
+- 新增受限的 `auto-transition` 状态 API，只允许上述两条自动边；其他前进、修复和重规划边继续通过 `request-transition` / `confirm-transition` 显式确认，Hook 仍保持只读。
+- IMPLEMENT 完成后允许用户选择进入 REVIEW，或明确跳过 REVIEW 直接进入 VERIFICATION；交接和 free-form Other 仍保留，跳过 REVIEW 不能绕过 VERIFICATION 硬门控。
+- ANALYSIS 改为先原样落盘无阶段标签的 dev-spec 骨架，再在分析过程中即时询问并解决技术路线、接口、范围等决策问题，最后才填充完整方案；最终报告不再包含“待用户决策”章节。
+- `ANALYSIS → IMPLEMENT` 在申请和确认迁移时都会校验完整 dev-spec 和最新有效 execution plan；代码任务还必须提供非空 test strategy，只读任务则禁止生成 `test-strategy.md`。必填章节正文、实施单元任务卡字段和并行分组均需完整，原始骨架、空章节、无界单元或缺失产物不能进入实施。
+- dev-spec 骨架使用专用 `[[EC_TODO:...]]` 占位标记，既能可靠拦截未填字段，也不会把方案中合法的 `{title}`、`{type}` 等模板文本误判为残留占位符。
+- execution plan 门禁校验依赖图无环及并行层级顺序；`doc` / `analysis` / `report` 显式无代码任务允许受限空文件范围并通过 `deliverable` 返回只读结果，代码任务仍禁止无界实施。
+- 无代码 IMPLEMENT 单元必须返回非空 `deliverable` 且不得修改文件；主 Agent 在展示摘要或迁移选项前必须向用户原样输出完整 deliverable，避免结果只留在执行日志中。
+- 无代码任务展示完整 deliverable 后直接通过受限 `IMPLEMENT → COMPLETE` 自动边结束；状态 API 会校验 single 空文件计划、匹配的 dispatch/result、零文件改动、非空 deliverable 和无遗留问题，不生成 `test-strategy.md`，不进入 REVIEW、VERIFICATION、MEMORY，也不写任务记忆。
+- 介绍页展示版本与 `package.json` 保持一致，并由版本元数据测试防止后续发布再次漂移。
+- 升级遗留的自动 `pending_transition` 在状态上下文中标记为 `auto-transition-ready`，不再错误注入用户确认提示。
+- `single` / `sequential` / `parallel` 三种执行策略统一派发子代理，仅编排形态不同；技术方案骨架不再生成“主 Agent 直接执行”的冲突指令。
+- 工作流 skills、主约束、README、设计/介绍/使用文档和状态 API 测试统一对齐新的自动边与可选 REVIEW 语义。
+
+## 0.6.0
+
+- 状态机移除无实际工作内容的 `WAITING_CONFIRM`；阶段完成后通过 `task.json.pending_transition` 记录待确认边，状态仍停留在当前阶段，直到用户明确确认。
+- 所有合法阶段迁移默认统一提供“确认进入/返回目标阶段、交接给其他智能体、Other”三分支；优先使用智能体原生选项功能，纯文本编号仅作为无原生能力时的回退；handoff 会保留待确认边，下一智能体 claim 后可直接恢复该门禁。
+- 合并 `MEMORY_SHORT` 与 `MEMORY_LONG` 为单一 `MEMORY`：先写并检查点化短期记忆，再由状态 API 计算长期记忆 `no-op/distill` 指令，原阈值门禁保持不变。
+- MEMORY 短期记忆检查点校验 `memory_schema: 2`、`source_task` 当前任务归属和 SHA-256 内容指纹；长期记忆指令冻结 `candidate_files/kept_files`，只有明确候选允许被消费，保留项缺失或候选未清理均不能完成归档；旧 `MEMORY_LONG` 恢复通过显式兼容标记保留。
+- MEMORY 配置强制满足 `0 <= short_term_keep <= short_term_max`；非法窗口直接阻断并提示修正 config.yaml，避免超过阈值后出现零候选、无法收敛的空蒸馏循环。
+- 状态 API 新增 `request-transition`、`confirm-transition`、`cancel-transition` 以及 MEMORY 进度命令；hook 对用户输入完全只读，不再从原生选项、裸编号或自然语言自动写状态，所有确认均由智能体核对当前任务和目标状态后显式执行。
+- `easy-coding upgrade` 幂等迁移 0.5.x 活跃任务和 session：`WAITING_CONFIRM → ANALYSIS`、`MEMORY_SHORT/MEMORY_LONG → MEMORY`，同步清洗阶段历史并保留记忆恢复进度。
+- 工作流 skills、主约束、README、设计/介绍/使用文档及生成后 hook 测试全面对齐新状态模型。
+
 ## 0.5.3
 
 - 根治 `task.json` 绝对路径泄漏：`.easy-coding/tasks/project-init/task.json` 不再写入本机仓库绝对路径。该 `project_path` 字段无任何消费方，直接移除，可提交产物彻底去本地化。

package/README.md

@@ -69,20 +69,22 @@ easy-coding init --submodules packages/a,packages/b
 ## 工作流
 
 ```text
-INIT -> ANALYSIS -> WAITING_CONFIRM -> IMPLEMENT -> REVIEW -> VERIFICATION
-                          ^                ^                      |
-                          |                +---- repair loop -----+
-                          +--- revision ---+                      |
-                                                        [user acceptance]
-                                                                  |
-                                          MEMORY_SHORT -> MEMORY_LONG -> COMPLETE
+INIT --[auto]--> ANALYSIS -> IMPLEMENT -> REVIEW -> VERIFICATION -> MEMORY --[auto]--> COMPLETE
+                                    \----------------> VERIFICATION
+                                    \--[read-only auto]------------------------------> COMPLETE
+                 ^            ^          |             |
+                 +-- replan ---+          +--- fix -----+
+                              ^                         |
+                              +------- repair ----------+
+user-decision edge --[confirm / handoff / Other]--> target stage
 any stage --[user abort via ec-task-close]--> CLOSED
 ```
 
-- `WAITING_CONFIRM` 是计划确认硬门控，未确认不进入实现。
+- `INIT → ANALYSIS` 与完成记忆处理后的 `MEMORY → COMPLETE` 自动流转，不生成 `pending_transition`，也不展示确认或交接。
+- 其余用户关联边通过 `pending_transition` 等待明确确认；代码 IMPLEMENT 完成后可选择进入 REVIEW、跳过 REVIEW 直接进入 VERIFICATION，或交接给其他智能体。
+- 显式 `doc` / `analysis` / `report` 只读任务不生成 `test-strategy.md`；IMPLEMENT 留下匹配的 dispatch/result 并展示完整报告后自动进入 COMPLETE，不执行 REVIEW、VERIFICATION 或 MEMORY，也不写任务记忆。
 - `VERIFICATION` 是验证硬门控，未实际运行的 lint、typecheck、test 不算通过。
-- `MEMORY_SHORT` 写入本次任务短期记忆。
-- `MEMORY_LONG` 只有短期记忆数量超过阈值时才沉淀长期记忆，否则 no-op。
+- `MEMORY` 先写入本次任务短期记忆，再执行长期记忆阈值门禁；未超过阈值时长期沉淀为 no-op。
 
 ## Supermodule 模型
 
@@ -117,7 +119,7 @@ any stage --[user abort via ec-task-close]--> CLOSED
 | `ec-workflow` | 统一入口，负责任务创建、恢复、阶段流转和 stage skill 调度 |
 | `ec-brainstorming` | 实现前的设计探索和方案发散 |
 | `ec-analysis` | 生成 dev-spec、执行计划和测试策略 |
-| `ec-implementing` | 按确认后的计划执行代码实现 |
+| `ec-implementing` | 按确认后的计划执行代码实现或显式无代码只读交付 |
 | `ec-reviewing` | 多维度代码审查，输出 accept / fix / replan / blocked 结论 |
 | `ec-verification` | 执行 lint、typecheck、test 等验证硬门控，并处理验收修复循环 |
 | `ec-memory` | 写短期记忆，并在超过阈值时沉淀长期记忆 |

package/dist/cli.js

@@ -655,6 +655,11 @@ async function writeMemoryScaffold(easyCodingDir) {
 // src/utils/task-json.ts
 import { readdir } from "fs/promises";
 import path7 from "path";
+var LEGACY_STAGE_MAP = {
+  WAITING_CONFIRM: "ANALYSIS",
+  MEMORY_SHORT: "MEMORY",
+  MEMORY_LONG: "MEMORY"
+};
 function createProjectInitTask(params) {
   return {
     type: "project-init",
@@ -702,6 +707,132 @@ async function stripInitTaskProjectPath(cwd) {
   await writeTaskJson(filePath, task);
   return true;
 }
+function isLegacyStage(value) {
+  return typeof value === "string" && value in LEGACY_STAGE_MAP;
+}
+function migrateStage(value) {
+  return isLegacyStage(value) ? LEGACY_STAGE_MAP[value] : value;
+}
+function migrateStageHistory(task) {
+  if (!Array.isArray(task.stage_history)) return false;
+  let changed = false;
+  const migrated = [];
+  for (const rawEntry of task.stage_history) {
+    if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+      migrated.push(rawEntry);
+      continue;
+    }
+    const entry = { ...rawEntry };
+    const mappedStage = migrateStage(entry.stage);
+    if (mappedStage !== entry.stage) {
+      entry.stage = mappedStage;
+      changed = true;
+    }
+    const previous = migrated.at(-1);
+    if (previous && typeof previous === "object" && !Array.isArray(previous) && previous.stage === entry.stage) {
+      changed = true;
+      continue;
+    }
+    migrated.push(entry);
+  }
+  if (changed) task.stage_history = migrated;
+  return changed;
+}
+function migrateTaskWorkflowState(task) {
+  const legacyStatus = isLegacyStage(task.status) ? task.status : null;
+  const legacyRequestedAt = Array.isArray(task.stage_history) ? [...task.stage_history].reverse().find(
+    (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && entry.stage === "WAITING_CONFIRM"
+  ) : null;
+  let changed = migrateStageHistory(task);
+  if (legacyStatus) {
+    task.status = LEGACY_STAGE_MAP[legacyStatus];
+    changed = true;
+  }
+  if (legacyStatus === "WAITING_CONFIRM" && !task.pending_transition) {
+    const requestedAt = legacyRequestedAt && typeof legacyRequestedAt === "object" && !Array.isArray(legacyRequestedAt) ? String(
+      legacyRequestedAt.entered_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    ) : (/* @__PURE__ */ new Date()).toISOString();
+    task.pending_transition = {
+      from: "ANALYSIS",
+      to: "IMPLEMENT",
+      requested_at: requestedAt,
+      requested_by: String(task.last_agent ?? "upgrade-migration"),
+      reason: "migrated-from-WAITING_CONFIRM"
+    };
+    changed = true;
+  }
+  if (legacyStatus === "MEMORY_LONG") {
+    const progress = task.memory_progress && typeof task.memory_progress === "object" ? { ...task.memory_progress } : {};
+    if (progress.short_memory_written !== true) {
+      progress.short_memory_written = true;
+    }
+    progress.legacy_short_memory_assumed = true;
+    progress.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    task.memory_progress = progress;
+    changed = true;
+  }
+  return changed;
+}
+async function taskFiles(cwd) {
+  const tasksDir = path7.join(cwd, EASY_CODING_DIR, TASKS_DIR);
+  if (!await pathExists(tasksDir)) return [];
+  const entries = await readdir(tasksDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => path7.join(tasksDir, entry.name, "task.json"));
+}
+async function sessionFiles(cwd) {
+  const sessionsDir = path7.join(cwd, EASY_CODING_DIR, SESSIONS_DIR);
+  if (!await pathExists(sessionsDir)) return [];
+  const entries = await readdir(sessionsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path7.join(sessionsDir, entry.name));
+}
+async function readJsonRecord(filePath) {
+  try {
+    const parsed = JSON.parse(await readTextFile(filePath));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function hasLegacyWorkflowState(cwd) {
+  for (const filePath of await taskFiles(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(
+      (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && isLegacyStage(entry.stage)
+    )) {
+      return true;
+    }
+  }
+  for (const filePath of await sessionFiles(cwd)) {
+    const session = await readJsonRecord(filePath);
+    if (!session) continue;
+    if (isLegacyStage(session.last_seen_stage)) return true;
+  }
+  return false;
+}
+async function migrateLegacyWorkflowState(cwd) {
+  let tasksUpdated = 0;
+  let sessionsUpdated = 0;
+  for (const filePath of await taskFiles(cwd)) {
+    if (!await pathExists(filePath)) continue;
+    const task = await readJsonRecord(filePath);
+    if (!task) continue;
+    if (!migrateTaskWorkflowState(task)) continue;
+    await writeTextFile(filePath, JSON.stringify(task, null, 2));
+    tasksUpdated += 1;
+  }
+  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;
+  }
+  return { tasksUpdated, sessionsUpdated };
+}
 async function setPendingInitSince(cwd, version) {
   const filePath = getTaskJsonPath(cwd, PROJECT_INIT_TASK_ID);
   if (!await pathExists(filePath)) return;
@@ -2849,7 +2980,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 not touch memory, state, spec, or project knowledge files."
+    "Will migrate legacy workflow stage metadata; memory content, spec, and project knowledge files remain untouched."
   ].join("\n");
   if (opts.dryRun) {
     console.log(summary);
@@ -2880,6 +3011,7 @@ async function upgrade(opts) {
     });
     await ensureEasyCodingSessionsIgnored(target.dir);
     await ensureHookBytecodeIgnored(target.dir);
+    await migrateLegacyWorkflowState(target.dir);
     await updateHarnessVersion(target.configPath, VERSION);
     await updateSupermoduleConfig(target.configPath, target.supermodule);
     await setPendingInitSince(target.dir, VERSION);
@@ -2921,7 +3053,7 @@ async function resolvePendingUpgradeTargets(targets) {
         `${target.label} harness version ${installedVersion} is newer than CLI ${VERSION}. Update the CLI first.`
       );
     }
-    if (relation === -1 || relation === 0 && await needsHookConfigRefresh(target, config)) {
+    if (relation === -1 || relation === 0 && (await needsHookConfigRefresh(target, config) || await hasLegacyWorkflowState(target.dir))) {
       pending.push({ target, config });
     }
   }