cc-devflow 4.5.9 → 4.5.11

package/.claude/skills/cc-do/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cc-do
-version: 1.6.5
+version: 1.6.8
 description: Use when implementing planned tasks, resuming interrupted work, applying a frozen investigation handoff, or landing review feedback after cc-plan or cc-investigate.
 triggers:
   - 开始做 T003
@@ -17,9 +17,6 @@ reads:
   - references/parallel-dispatch.md
   - docs/guides/project-postmortem.md
 writes:
-  - path: devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json
-    durability: durable
-    required: true
   - path: devflow/changes/<change-key>/execution/tasks/<task-id>/events.jsonl
     durability: durable
     required: false
@@ -35,20 +32,21 @@ writes:
 effects:
   - code changes
   - test changes
-  - workspace scratch runtime updates
+  - task status updates in planning/tasks.md and planning/task-manifest.json
 entry_gate:
-  - Read planning/design.md or planning/analysis.md, then planning/tasks.md, planning/task-manifest.json, change-meta.json, related capability specs, and the latest checkpoint before changing code.
+  - Run `cc-devflow query workflow-context --change <changeId> --change-key <changeKey> --data-only --no-trace --compact` first and follow its context-index `packetOnly`, `mustNotForget`, `sourceHashes`, `defaultOpen`, `currentTask`, `commandsToTrust`, and `openWhen.conditions` fields before opening deep artifacts.
+  - Before editing, read the direct caller, exported surface, shared helper, and local convention for the touched path.
+  - Read `planning/tasks.md`, `planning/task-manifest.json`, `change-meta.json`, related specs, Git state, and CLI logs only when workflow-context says the deep section is needed; legacy `planning/design.md` / `planning/analysis.md` are fallback inputs only.
   - Select only ready tasks whose dependencies, wave, touched paths, and file ownership are clear.
   - Reject parallel execution when touched paths overlap by exact path or parent/child path; submodule touches must be isolated unless the task explicitly owns that submodule.
   - If the current task cannot be restated from canonical artifacts, run a context reset before coding.
-  - Before each single-task execution, run a quick Project Postmortem search against `devflow/postmortems` using the task's touched files, capability, failure class, and model-risk terms; record applicable reminders or `no-project-postmortems-yet` in the checkpoint/events.
+  - Before each single-task execution, run a quick Project Postmortem search against `devflow/postmortems` using the task's touched files, capability, failure class, and model-risk terms; apply applicable reminders to the code path and mention only blocking/failure facts in CLI events.
   - "Validate the current task's TDD shape before coding: spec-style test name, one logical behavior, public verification path, allowed boundary mocks, Green minimality guard, and refactor candidates."
 exit_criteria:
-  - The current task has red/green evidence, public-seam test quality evidence, review evidence, and a resumable checkpoint trail.
+  - The current task has red/green evidence, public-seam test quality evidence, review evidence, and synchronized task status.
   - Red evidence proves one observable behavior through a public verification path; Green evidence shows only the minimal production change; Refactor evidence names the concrete smell removed or says why none was needed.
   - The completed task was closed through `scripts/mark-task-complete.sh`; manual checkbox/status edits are not valid completion evidence.
-  - Execution leaves the next verifier enough runtime truth to judge the task without chat memory.
-  - The task checkpoint or event log records the postmortem recall result for this task, including relevant principle/incident links or an explicit no-match verdict.
+  - Execution leaves the next verifier enough code, Git, task-status, verification-command, and CLI-log truth to judge the task without chat memory.
   - The honest next step is cc-check or an explicit reroute.
 reroutes:
   - when: Three failed repair attempts or new evidence show the investigation contract is wrong.
@@ -58,12 +56,12 @@ reroutes:
   - when: Implementation and reviews are complete for the current task set.
     target: cc-check
 recovery_modes:
-  - name: resume-from-checkpoint
+  - name: resume-from-task-state
     when: Work was interrupted but the current design contract is still valid.
-    action: Reload the latest checkpoint, rebuild task context, and continue from the last confirmed red/green/review milestone.
+    action: Reload workflow-context, planning/tasks.md, task-manifest.json, current Git state, and CLI logs; continue from the first pending or failed task.
   - name: context-reset
     when: The conversation history is noisy, stale, or cannot reproduce the exact task state.
-    action: Discard chat memory, reread planning/design.md or planning/analysis.md plus planning/tasks.md/planning/task-manifest.json and the latest checkpoint, then restate the next action before coding.
+    action: Discard chat memory, reread planning/tasks.md, planning/task-manifest.json, change-meta.json, current Git state, and CLI logs; use legacy design/analysis only as fallback.
 tool_budget:
   read_files: 9
   search_steps: 6
@@ -86,14 +84,14 @@ tool_budget:
 
 写入任何 durable Markdown 或 JSON metadata 前，先运行 `cc-devflow config resolve --format policy`。
 
-- `Output language` 是机器约束，checkpoint、events、team-state 中新增的人类可读摘要必须记录并遵守它。
+- `Output language` 是机器约束；如果失败或 debug CLI 日志需要人类可读摘要，必须记录并遵守它。
 - `agent_preferences` 是用户偏好建议，只影响表达方式和结构选择，不覆盖本 Skill 的工作流边界。
 - 如果配置解析失败，先修配置或向用户说明阻塞，不要用默认语言继续生成正式文档。
 
-上游冻结合同可以来自两条路：
+上游冻结合同来自 `planning/tasks.md`：
 
-- `cc-plan` 产出的 `planning/design.md`
-- `cc-investigate` 产出的 `planning/analysis.md`
+- `cc-plan` 产出的 `planning/tasks.md#Contract Summary`
+- `cc-investigate` 产出的 `planning/tasks.md#Root Cause Contract`
 
 ## Read First
 
@@ -124,15 +122,23 @@ tool_budget:
 | bug 还没搞清根因 | reroute 到 `cc-investigate` |
 | 收到 review comment，要在既定范围内修正 | `review-fix` |
 
-如果连“当前 task 是什么”都说不清，先别写代码，先跑 `scripts/select-ready-tasks.sh` 和 `scripts/build-task-context.sh`。
+如果连“当前 task 是什么”都说不清，先别写代码，先跑 `cc-devflow query workflow-context`。只有它的 `openWhen` 指向 scheduling 或 recovery 时，才继续跑 `scripts/select-ready-tasks.sh`；`scripts/build-task-context.sh` 只能输出 stdout，不得生成 `context.md`。
 
 ## Harness Contract
 
-- Allowed actions: implement ready tasks, debug inside frozen scope, write runtime evidence, and apply review feedback that does not reopen design.
+- Allowed actions: implement ready tasks, debug inside frozen scope, update task status through the completion script, and apply review feedback that does not reopen design.
 - Forbidden actions: re-planning the requirement in place, blindly rerunning the whole requirement, or delegating tasks without full task context.
-- Required evidence: every task must leave red/green/review checkpoints plus objective failure notes when blocked.
+- Required evidence: every task must leave objective code/Git/test evidence; blocked or failed work may leave compact CLI events, but must not create AI-written process files.
 - Reroute rule: after repeated failed repairs or root-cause drift, stop patching and go back to `cc-investigate`; if scope or design truth breaks, go back to `cc-plan`; after task closure, hand off to `cc-check`.
 
+## Execution Discipline
+
+- Make the smallest task-scoped diff; do not add features, abstractions, or adjacent cleanup outside the frozen task. Clean only traces introduced by this task.
+- Match existing style and conventions even when another pattern looks nicer; harmful conventions require reroute/discussion, not private divergence.
+- Deterministic state changes use scripts (`mark-task-complete.sh`, ready-task selectors); the model does not hand-edit status JSON.
+- Tests must prove the behavior's intent through a public seam; tests that would pass after the wrong business behavior changes are invalid.
+- Blockers, skipped tests, stale context, or unclear ownership are reported loudly before continuing.
+
 ## TDD Iron Law
 
 ```text
@@ -144,13 +150,13 @@ NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
 1. Red：先写一个最小失败测试，运行并确认它因为目标行为缺失而失败。
 2. Green：只写让当前失败测试通过的最小生产代码。
 3. Refactor：只有 Green 之后才能清理命名、重复、结构和坏味道。
-4. Record：每一站都写入 `checkpoint.json`，必要时写入 `events.jsonl`。
+4. Record：任务状态只通过 `mark-task-complete.sh` 同步到 `planning/tasks.md` 与 `planning/task-manifest.json`；失败或 debug 时才写 `events.jsonl`。
 
 Red 不是形式上的红，而是公共 seam 上的行为缺失证明。测试必须通过公共接口、调用方流程、CLI/API/UI 路径或其它真实边界进入系统；只验证私有函数、内部调用次数、临时数据结构或 mock 自己控制的内部协作者，不算 TDD 证据。
 
 一个 Red 只证明一个逻辑行为。测试名要像规格说明，而不是实现步骤；结果要从同一类公共入口读回。直接查数据库、读内部状态、扫描临时文件或绕过 API 来证明行为，只在那个边界本身就是被测对象时成立。
 
-例外只能用于 throwaway prototype、纯生成文件、纯配置改动；例外必须写进 checkpoint 的 `tddException`，包含原因、风险和替代验证命令。测试第一次就绿，说明测试没有证明新行为，必须修测试而不是继续写生产代码。
+例外只能用于 throwaway prototype、纯生成文件、纯配置改动；例外必须写在当前 task block 或 manifest task context 中，包含原因、风险和替代验证命令。测试第一次就绿，说明测试没有证明新行为，必须修测试而不是继续写生产代码。
 
 禁止水平切片：不要先写一批测试，再写一批实现。每次只推进一个 tracer bullet：一个可观察行为的 Red -> 让它变绿的最小实现 -> 必要重构 -> 记录证据，然后再进入下一个行为。
 
@@ -162,14 +168,15 @@ Refactor 只能发生在 Green 之后。优先处理当前 slice 暴露出的重
 
 ## Entry Gate
 
-1. 先读 `planning/design.md` 或 `planning/analysis.md`，再读 `planning/tasks.md`、`planning/task-manifest.json`；如果是恢复执行，再补读最近 checkpoint 或已有 `handoff/resume-index.md`。
-2. 先用 `scripts/select-ready-tasks.sh` 判断现在到底哪几个任务真的 ready。
-3. 只锁定当前 ready task，或一组经依赖、wave、精确触点与父子路径触点校验后可并行的 ready tasks。
-4. 如果这次来自 `cc-investigate`，必须把 `planning/analysis.md` 当成 canonical contract，而不是一边实现一边重新调查。
-5. 没有任务上下文，不准把任务扔给 subagent；先用 `scripts/build-task-context.sh` 从 `planning/design.md` 或 `planning/analysis.md`、`planning/tasks.md`、`planning/task-manifest.json`、`change-meta.json` 与相关 capability spec 组装上下文。
-6. 如果 `task-manifest.json.metadata.lane == "quick"`，仍然必须有 current task、verification、checkpoint 和 handoff；quick 只缩短文档密度，不跳过证据。
-7. 如果仓库含 `.gitmodules` 或 manifest 提供 `submodulePaths`，先用 `scripts/detect-file-conflicts.sh` 标出 `submoduleTouches`；只有触达该 submodule 的任务失去默认 worktree 隔离资格，未触达任务不能被无辜串行化。
-8. 每个单 task 开工前，用当前 task 的 touched files、capability、错误类型、模型风险词快速检索 `devflow/postmortems`；命中时把相关原则转成当前 task 的 guardrail，未命中也要在 checkpoint / events 里记录。
+1. 先运行 `cc-devflow query workflow-context --change <changeId> --change-key <changeKey> --data-only --no-trace --compact`，把 `nextAction.skill == "cc-do"` 和 `currentTask.id` 作为执行入口。
+2. 先只用 `workflow-context.progressiveDisclosure.packetOnly` 和 `mustNotForget` 做导航与护栏，必要时打开 `defaultOpen` 的 section / JSON refs；如果 `sourceHashes` 不匹配、命令缺失、scope/依赖/触点不确定，必须按 `openWhen.conditions` 打开 `deepOpen`，不能靠猜。
+3. 先用 `workflow-context.queues.readyTasks` 判断现在到底哪几个任务真的 ready；需要 shell 复核时再跑 `scripts/select-ready-tasks.sh`。
+4. 只锁定当前 ready task，或一组经依赖、wave、精确触点与父子路径触点校验后可并行的 ready tasks。
+5. 如果这次来自 `cc-investigate`，必须把 `planning/tasks.md#Root Cause Contract` 当成 canonical contract，而不是一边实现一边重新调查。
+6. 没有任务上下文，不准把任务扔给 subagent；先用 `workflow-context.currentTask`，不够时再用 `scripts/build-task-context.sh` 从 canonical artifacts 组装上下文。
+7. 如果 `task-manifest.json.metadata.lane == "quick"`，仍然必须有 current task、verification、task status 和唯一 next action；quick 只缩短文档密度，不跳过证据。
+8. 如果仓库含 `.gitmodules` 或 manifest 提供 `submodulePaths`，先用 `scripts/detect-file-conflicts.sh` 标出 `submoduleTouches`；只有触达该 submodule 的任务失去默认 worktree 隔离资格，未触达任务不能被无辜串行化。
+9. 每个单 task 开工前，用当前 task 的 touched files、capability、错误类型、模型风险词快速检索 `devflow/postmortems`；命中时把相关原则转成当前 task 的 guardrail。不要为 no-match 生成过程文件。
 
 ## Loop
 
@@ -184,7 +191,7 @@ Refactor 只能发生在 Green 之后。优先处理当前 slice 暴露出的重
 9. 按 `Red -> Green -> Refactor` 推进，Green 只允许最小实现，不预铺未来测试尚未要求的分支、状态或 API。
 10. 如果当前 Red 需要新的 fixture 或 mock，先证明它仍从公共 seam 触发真实行为；fixture 缺字段、类型强转或内部 mock 都要写入 `tdd.testQuality.fixtureRisk` 或先修 seam。
 11. Refactor 后必须重跑相关测试，保持 Green；Red 状态下不重构。
-12. 每次推进都写 task runtime：`events.jsonl` + `checkpoint.json`，并记录 `postmortemRecall`、`tdd.testQuality`、`tdd.greenMinimality`、`tdd.refactorCandidates` 或 `tddException`。
+12. 每次推进都以代码 diff、Git 状态、验证命令输出和 task 状态为真相源；只有失败、阻塞或 debug 需要机器日志时才写 `events.jsonl`。
 13. 任务实现后，先过 `spec review`，再过 `code review`，两道门都过才算任务收口；这里只验证 spec delta，不回写长期 spec。
 14. 当前任务完成后，把可验证证据留给 `cc-check`。
 
@@ -192,8 +199,8 @@ Refactor 只能发生在 Green 之后。优先处理当前 slice 暴露出的重
 
 - 代码变更
 - 测试变更
-- `devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json`
-- `devflow/changes/<change-key>/execution/tasks/<task-id>/events.jsonl`（仅 debug / failed 默认保留）
+- `planning/tasks.md` 与 `planning/task-manifest.json` 的 task 状态
+- `devflow/changes/<change-key>/execution/tasks/<task-id>/events.jsonl`（仅 debug / failed 默认保留；CLI 自动日志，不写叙事 Markdown）
 - `planning/task-manifest.json` 里的 task review verdict
 
 ## Good Output
@@ -205,8 +212,8 @@ Refactor 只能发生在 Green 之后。优先处理当前 slice 暴露出的重
 - Green 证据说明 minimality guard：本轮只满足当前红灯，没有提前实现未来分支
 - Refactor 证据说明清掉了哪个具体坏味道，或者为什么当前 slice 不需要 refactor
 - 测试 fixture 说明真实 contract 字段和测试填充字段，没有用类型欺骗或内部 mock 制造假绿
-- runtime / checkpoint 足够让下一位接手者无损恢复
-- quick lane 也有 mini manifest、checkpoint、verification 和唯一 next action，不靠聊天记录继续
+- task status、Git diff、验证命令和必要 CLI 日志足够让下一位接手者恢复
+- quick lane 也有 mini manifest、verification 和唯一 next action，不靠聊天记录继续
 - reviewer 能顺着 review 记录和验证命令复盘这次实现
 
 ## Bundled Resources
@@ -217,8 +224,8 @@ Refactor 只能发生在 Green 之后。优先处理当前 slice 暴露出的重
 - 恢复分析：`scripts/recover-workflow.sh`
 - 任务状态：`scripts/check-task-status.sh`
 - ready 任务选择：`scripts/select-ready-tasks.sh`
-- 任务上下文组装：`scripts/build-task-context.sh`
-- checkpoint 记录：`scripts/write-task-checkpoint.sh`
+- 任务上下文组装：`scripts/build-task-context.sh`（stdout only，不落盘）
+- 旧 checkpoint 兼容入口：`scripts/write-task-checkpoint.sh`（不写 checkpoint，只在失败 / debug 时写事件）
 - review 记录：`scripts/record-review-decision.sh`
 - 任务闭环校验：`scripts/verify-task-gates.sh`
 - 任务勾选：`scripts/mark-task-complete.sh`
@@ -242,7 +249,7 @@ Refactor 只能发生在 Green 之后。优先处理当前 slice 暴露出的重
 14. 给 subagent 的输入必须包含：当前进度、当前任务全文、依赖状态、必读文件、验收标准、可信命令。
 15. 三次失败修补后必须先质疑调查合同或设计合同，而不是继续堆补丁。
 16. 完成任务后必须调用 `scripts/mark-task-complete.sh` 同步 `planning/task-manifest.json` 和 `planning/tasks.md`；禁止手工改 checkbox、status、currentTaskId 来冒充完成。
-17. 如果 `mark-task-complete.sh` 失败，说明 checkpoint、review gate 或任务依赖还没闭合；先修证据，再重跑脚本，不准绕过。
+17. 如果 `mark-task-complete.sh` 失败，说明 review gate 或任务依赖还没闭合；先修证据，再重跑脚本，不准绕过。
 
 ## Task Status Protocol
 
@@ -261,13 +268,13 @@ bash "$SCRIPT_ROOT/mark-task-complete.sh" --manifest devflow/changes/<change-key
 ```
 
 4. 脚本会先跑任务 gate，再同步 manifest、checkbox、`currentTaskId` 和整体状态。不要手动改这些字段。
-5. 如果任务不能完成，写 checkpoint / event / blocker；不要把失败任务标成完成。
+5. 如果任务不能完成，只在失败 / debug 需要时写 CLI event；不要生成过程 Markdown，也不要把失败任务标成完成。
 
 ## Exit Criteria
 
 - 当前任务有 Red/Green 证据
 - 当前任务有 `spec review` / `code review` 两道门证据
-- 恢复点已更新到 `devflow/changes/<change-key>/execution/tasks/<task-id>/`
+- 恢复点可从 `planning/tasks.md`、`planning/task-manifest.json`、Git 状态和必要 CLI 日志判断
 - 阻塞原因已写清楚
 - 下一步应进入 `cc-check`，或明确退回 `cc-investigate` / `cc-plan`
 

package/.claude/skills/cc-do/references/execution-recovery.md

@@ -22,19 +22,24 @@
 2. 为什么停在这
 3. 下一步必须先做什么
 
-如果这三件事不能只靠规范产物和最新 checkpoint 回答，就先做 context reset，不准继续依赖聊天记忆。
+如果这三件事不能只靠规范产物、Git 状态和 CLI 日志回答，就先做 context reset，不准继续依赖聊天记忆。
 
 ## Runtime Layout
 
-运行态证据按任务落在：
+默认执行真相来自：
 
-- `devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json`
-- `devflow/changes/<change-key>/execution/tasks/<task-id>/events.jsonl`（仅 debug / failed 默认保留）
+- 代码和测试 diff
+- Git 状态
+- `planning/tasks.md` 的 checkbox
+- `planning/task-manifest.json` 的 task status / reviews / currentTaskId
+- `devflow/changes/<change-key>/execution/tasks/<task-id>/events.jsonl`（仅 debug / failed 默认保留；CLI 自动日志）
 - `planning/task-manifest.json` 里的 `tasks[*].reviews`
 
-## Required Event Spine
+不得生成 `context.md`、`checkpoint.json`、review markdown 或其它 AI 手写过程文件。需要复盘时重新读取代码、Git、task 状态和 CLI 自动日志。
 
-一个健康任务最少要看见这些事件：
+## Optional Event Spine
+
+`events.jsonl` 只在 debug 或 failed 时存在。存在时可以包含这些事件：
 
 1. `context_ready`
 2. `red_failed`
@@ -48,11 +53,11 @@
 10. `spec_review_pass`
 11. `code_review_pass`
 
-如果 `events.jsonl` 没开启，至少仍要有最新 `checkpoint.json` 和 manifest review verdict。
+如果 `events.jsonl` 没开启，使用 manifest task status、`tasks.md` checkbox、review verdict 和验证命令输出恢复。
 
-## Checkpoint TDD Fields
+## Task Evidence Fields
 
-最新 checkpoint 至少能回答：
+当前 task block / manifest task / 验证输出至少能回答：
 
 - `red.command`
 - `red.exitStatus`
@@ -80,7 +85,7 @@
 - `review.spec.status`
 - `review.code.status`
 
-如果跳过 TDD，必须有 `tddException`，并写清替代验证。没有这些字段时，恢复执行先补证据，不准直接继续实现。
+如果跳过 TDD，必须有 `tddException` 或 task-level exception 说明，并写清替代验证。没有这些字段时，恢复执行先补证据，不准直接继续实现。
 
 ## Bug Rule
 
@@ -92,7 +97,7 @@
 ## Local Recovery Ladder
 
 1. 先重试当前命令或当前 task，而不是重跑整条 requirement
-2. 两次失败后回看证据链和 task context
+2. 两次失败后回看证据链、task block、Git diff 和 CLI 日志
 3. 三次失败后默认怀疑上游合同：根因漂移回 `cc-investigate`，范围 / 设计漂移回 `cc-plan`
 
 ## Subagent Rule
@@ -100,10 +105,10 @@
 给 subagent 的上下文至少包含：
 
 - 当前任务全文
-- 当前进度与最近 checkpoint
+- 当前进度与 manifest task status
 - 已满足 / 未满足的依赖
 - 必读文件
 - 验收标准
 - 验证命令
 - 不做项 / 边界
-- quick lane 是否仍有 mini manifest、checkpoint、verification 和唯一 next action
+- quick lane 是否仍有 mini manifest、verification 和唯一 next action

package/.claude/skills/cc-do/scripts/build-task-context.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 # ------------------------------------------------------------
-# 组装当前任务的执行上下文，并记录 context_ready 事件
+# 组装当前任务的执行上下文，只输出到 stdout
 # ------------------------------------------------------------
 
 usage() {
@@ -51,12 +51,8 @@ if [[ -z "$task_json" ]]; then
 fi
 
 change_id="$(jq -r '.changeId // .requirementId // "REQ-UNKNOWN"' "$manifest")"
-runtime_task_dir="$(req_do_task_runtime_dir "$CHANGE_DIR" "$TASK_ID")"
-output_path="$runtime_task_dir/context.md"
 ready_json="$("$SCRIPT_DIR/select-ready-tasks.sh" --manifest "$manifest")"
 
-mkdir -p "$runtime_task_dir"
-
 list_or_none() {
   local value="$1"
   if [[ -z "${value//$'\n'/}" ]]; then
@@ -168,21 +164,12 @@ sync_status="$(jq -r '.spec.syncStatus // "unknown"' "$spec_source" 2>/dev/null
   echo
   echo "## Context Reset"
   echo
-  echo "- If chat context drifts, discard conversational memory and reload only the canonical files above plus the latest checkpoint."
-  echo "- Do not continue from memory if the current task, active phase, or latest checkpoint summary cannot be restated exactly."
+  echo "- If chat context drifts, discard conversational memory and reload only the canonical files above, current Git state, and CLI logs."
+  echo "- Do not continue from memory if the current task, active phase, or latest verification status cannot be restated exactly."
   echo
   if [[ -f "$resume_index" ]]; then
     echo "## Optional Resume Index"
     echo
     cat "$resume_index"
   fi
-} > "$output_path"
-
-"$SCRIPT_DIR/write-task-checkpoint.sh" \
-  --dir "$CHANGE_DIR" \
-  --task "$TASK_ID" \
-  --status pending \
-  --summary "Task context assembled" \
-  --next-action "Write the failing test for $TASK_ID" >/dev/null
-
-cat "$output_path"
+}

package/.claude/skills/cc-do/scripts/record-review-decision.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 # ------------------------------------------------------------
-# 记录 spec / code review 结论，并同步 runtime / manifest
+# 记录 spec / code review 结论，并同步 manifest；失败时保留 CLI 事件
 # ------------------------------------------------------------
 
 usage() {
@@ -46,12 +46,9 @@ fi
 CHANGE_DIR="$(req_do_resolve_change_dir "$REQ_DIR")"
 manifest="$(req_do_manifest_path "$CHANGE_DIR")"
 change_id="$(jq -r '.changeId // .requirementId // "REQ-UNKNOWN"' "$manifest" 2>/dev/null || basename "$CHANGE_DIR")"
-runtime_task_dir="$(req_do_task_runtime_dir "$CHANGE_DIR" "$TASK_ID")"
 timestamp="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
 event_name="${GATE}_review_${VERDICT}"
 
-mkdir -p "$runtime_task_dir"
-
 if [[ -f "$manifest" ]]; then
   tmp_manifest="$(mktemp)"
   jq --arg task "$TASK_ID" --arg gate "$GATE" --arg verdict "$VERDICT" '
@@ -66,7 +63,9 @@ if [[ -f "$manifest" ]]; then
   mv "$tmp_manifest" "$manifest"
 fi
 
-if [[ -f "$runtime_task_dir/events.jsonl" || "$VERDICT" != "pass" ]]; then
+if [[ "$VERDICT" != "pass" ]]; then
+  runtime_task_dir="$(req_do_task_runtime_dir "$CHANGE_DIR" "$TASK_ID")"
+  mkdir -p "$runtime_task_dir"
   jq -nc \
     --arg type "$event_name" \
     --arg changeId "$change_id" \

package/.claude/skills/cc-do/scripts/recover-workflow.sh

@@ -68,17 +68,15 @@ if [[ -f "$report" ]]; then
   echo "- Latest check verdict: $verdict"
 fi
 
-if [[ -n "$change_id" ]]; then
-  runtime_dir="$(req_do_execution_dir "$CHANGE_DIR")/tasks"
+if [[ -f "$manifest" ]]; then
+  echo
+  echo "## Task Status"
+  jq -r '.tasks[]? | "- " + .id + ": " + (.status // "pending") + (if .lastError then " - " + .lastError else "" end)' "$manifest" 2>/dev/null || true
 fi
 
-if [[ -n "${runtime_dir:-}" && -d "$runtime_dir" ]]; then
-  echo "- Runtime dir: $runtime_dir"
-
-  while IFS= read -r checkpoint_path; do
-    task_id="$(jq -r '.taskId // "unknown"' "$checkpoint_path" 2>/dev/null || echo unknown)"
-    checkpoint_status="$(jq -r '.status // "unknown"' "$checkpoint_path" 2>/dev/null || echo unknown)"
-    checkpoint_summary="$(jq -r '.summary // ""' "$checkpoint_path" 2>/dev/null || echo "")"
-    echo "- Checkpoint $task_id: $checkpoint_status ${checkpoint_summary:+- $checkpoint_summary}"
-  done < <(find "$runtime_dir" -name checkpoint.json | sort)
+if git -C "$CHANGE_DIR" rev-parse --show-toplevel >/dev/null 2>&1; then
+  repo_root="$(git -C "$CHANGE_DIR" rev-parse --show-toplevel)"
+  echo
+  echo "## Git State"
+  git -C "$repo_root" status --short
 fi

package/.claude/skills/cc-do/scripts/verify-task-gates.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 # ------------------------------------------------------------
-# 校验任务是否完成 Red / Green / Refactor / Review 闭环
+# 校验任务状态、依赖和可选 CLI 事件顺序
 # ------------------------------------------------------------
 
 usage() {
@@ -36,19 +36,21 @@ CHANGE_DIR="$(req_do_resolve_change_dir "$REQ_DIR")"
 manifest="$(req_do_manifest_path "$CHANGE_DIR")"
 runtime_task_dir="$(req_do_task_runtime_dir "$CHANGE_DIR" "$TASK_ID")"
 events_file="$runtime_task_dir/events.jsonl"
-checkpoint_file="$runtime_task_dir/checkpoint.json"
 
-if [[ ! -f "$checkpoint_file" ]]; then
-  echo "Missing $checkpoint_file" >&2
-  exit 1
-fi
-
-checkpoint_status="$(jq -r '.status // "unknown"' "$checkpoint_file" 2>/dev/null || echo unknown)"
-[[ "$checkpoint_status" == "passed" ]] || {
-  echo "Task $TASK_ID checkpoint status is not passed" >&2
+task_json="$(jq -c --arg task "$TASK_ID" '.tasks[] | select(.id == $task)' "$manifest" 2>/dev/null || true)"
+[[ -n "$task_json" ]] || {
+  echo "Task $TASK_ID not found in manifest" >&2
   exit 1
 }
 
+while IFS= read -r dependency; do
+  dep_status="$(jq -r --arg dep "$dependency" '.tasks[] | select(.id == $dep) | .status // "pending"' "$manifest" 2>/dev/null || echo pending)"
+  [[ "$dep_status" == "passed" || "$dep_status" == "completed" || "$dep_status" == "done" || "$dep_status" == "verified" ]] || {
+    echo "Task $TASK_ID dependency $dependency is not complete" >&2
+    exit 1
+  }
+done < <(jq -r '(.dependsOn // [])[]?' <<<"$task_json")
+
 spec_verdict="$(jq -r --arg task "$TASK_ID" '.tasks[] | select(.id == $task) | .reviews.spec // "pending"' "$manifest" 2>/dev/null || echo pending)"
 code_verdict="$(jq -r --arg task "$TASK_ID" '.tasks[] | select(.id == $task) | .reviews.code // "pending"' "$manifest" 2>/dev/null || echo pending)"
 

package/.claude/skills/cc-do/scripts/write-task-checkpoint.sh

@@ -3,13 +3,13 @@
 set -euo pipefail
 
 # ------------------------------------------------------------
-# 写入 task checkpoint.json / events.jsonl
+# 兼容旧入口：只写必要的 CLI 事件，不再生成 checkpoint.json
 # ------------------------------------------------------------
 
 usage() {
   cat <<'EOF'
 Usage:
-  write-task-checkpoint.sh --dir path/to/change --task T001 --status pending|running|passed|failed|skipped --summary "..." [--event context_ready] [--attempt 0] [--session session-id] [--next-action "..."] [--tdd-json '{"red":...}']
+  write-task-checkpoint.sh --dir path/to/change --task T001 --status pending|running|passed|failed|skipped [--summary "..."] [--event context_ready] [--attempt 0] [--session session-id] [--next-action "..."] [--tdd-json '{"red":...}']
 EOF
 }
 
@@ -41,7 +41,7 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-if [[ -z "$REQ_DIR" || -z "$TASK_ID" || -z "$STATUS" || -z "$SUMMARY" ]]; then
+if [[ -z "$REQ_DIR" || -z "$TASK_ID" || -z "$STATUS" ]]; then
   usage
   exit 1
 fi
@@ -49,12 +49,9 @@ fi
 CHANGE_DIR="$(req_do_resolve_change_dir "$REQ_DIR")"
 manifest="$(req_do_manifest_path "$CHANGE_DIR")"
 change_id="$(jq -r '.changeId // .requirementId // "REQ-UNKNOWN"' "$manifest" 2>/dev/null || basename "$REQ_DIR")"
-plan_version="$(jq -r '.metadata.planVersion // 1' "$manifest" 2>/dev/null || echo 1)"
 timestamp="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
 runtime_task_dir="$(req_do_task_runtime_dir "$CHANGE_DIR" "$TASK_ID")"
 
-mkdir -p "$runtime_task_dir"
-
 if [[ -z "$SESSION_ID" ]]; then
   SESSION_ID="${TASK_ID}-$(date -u +%s)"
 fi
@@ -68,28 +65,8 @@ if [[ -n "$TDD_JSON" ]]; then
   fi
 fi
 
-jq -nc \
-  --arg changeId "$change_id" \
-  --arg taskId "$TASK_ID" \
-  --arg sessionId "$SESSION_ID" \
-  --arg planVersion "$plan_version" \
-  --arg status "$STATUS" \
-  --arg summary "$SUMMARY" \
-  --arg timestamp "$timestamp" \
-  --arg attempt "$ATTEMPT" \
-  --argjson tdd "$tdd_payload" \
-  '{
-    changeId: $changeId,
-    taskId: $taskId,
-    sessionId: $sessionId,
-    planVersion: ($planVersion | tonumber),
-    status: $status,
-    summary: $summary,
-    timestamp: $timestamp,
-    attempt: ($attempt | tonumber)
-  } + (if $tdd == null then {} else {tdd: $tdd} end)' > "$runtime_task_dir/checkpoint.json"
-
 if [[ -n "$EVENT_TYPE" || "$STATUS" == "failed" ]]; then
+  mkdir -p "$runtime_task_dir"
   jq -nc \
     --arg type "${EVENT_TYPE:-status_$STATUS}" \
     --arg changeId "$change_id" \
@@ -99,6 +76,7 @@ if [[ -n "$EVENT_TYPE" || "$STATUS" == "failed" ]]; then
     --arg summary "$SUMMARY" \
     --arg nextAction "$NEXT_ACTION" \
     --arg timestamp "$timestamp" \
+    --argjson tdd "$tdd_payload" \
     '{
       type: $type,
       changeId: $changeId,
@@ -108,7 +86,7 @@ if [[ -n "$EVENT_TYPE" || "$STATUS" == "failed" ]]; then
       summary: $summary,
       nextAction: $nextAction,
       timestamp: $timestamp
-    }' >> "$runtime_task_dir/events.jsonl"
+    } + (if $tdd == null then {} else {tdd: $tdd} end)' >> "$runtime_task_dir/events.jsonl"
 fi
 
-echo "Wrote $runtime_task_dir/checkpoint.json"
+echo "No checkpoint written; task truth lives in planning/tasks.md and planning/task-manifest.json"

package/.claude/skills/cc-investigate/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CC-Investigate Skill Changelog
 
+## v1.5.1 - 2026-05-13
+
+- slim the public `SKILL.md` entrypoint into a thin root-cause contract with conditional escalation packs
+- make CLI-owned machine artifacts a hard rule: AI writes `planning/tasks.md#Root Cause Contract`, then runs `cc-devflow task-contract compile` / `validate` for `task-manifest.json` and `change-meta.json`
+- add CLI compile support for Root Cause Contract handoffs so investigations do not require hand-authored JSON
+- internalize investigation operating rules: assumptions first, evidence over guesses, explicit conflict choice, reroute spec/roadmap ambiguity, and loud Evidence Requests
+
+## v1.5.0 - 2026-05-13
+
+- collapse default investigation output to `planning/tasks.md` plus CLI-generated `task-manifest.json` and `change-meta.json`
+- move root-cause truth into `planning/tasks.md#Root Cause Contract` so `planning/analysis.md` is legacy fallback only
+- archive the legacy analysis template under `assets/legacy/` and keep repair handoffs rooted in `assets/TASKS_TEMPLATE.md`
+
+## v1.4.3 - 2026-05-13
+
+- add the Worktree Branch Contract so new `FIX` investigations anchor detached worktrees to `FIX/<task>` before artifacts are written
+- treat investigations on `main` / the default branch as a setup blocker instead of allowing the main checkout to accumulate repair state
+- require analysis, tasks, and change metadata to record the canonical work branch for downstream `cc-do`
+
+## v1.4.2 - 2026-05-12
+
+- require IDCA repair handoffs to be consumable by `cc-devflow query workflow-context`
+- add the compact runtime reset to investigation task templates so `cc-do`, `cc-check`, and `cc-act` continue from the frozen root-cause packet instead of chat history
+
 ## v1.4.1 - 2026-05-11
 
 - add the Project Postmortem Recall Gate so investigations search `devflow/postmortems` before final hypotheses are frozen