cowork-flow 0.0.42 → 0.0.43

package/README.md

@@ -68,7 +68,7 @@ Skills 维护在 `template/skills/` 唯一源码，`init` 时按平台分发到
 | `codex` / `opencode` | `.agents/skills/` |
 | `claude-code` | `.claude/skills/` |
 
-分发动作：`batch-mode`、`brainstorming`、`break-loop`、`cowork-flow`、`doubt-review`、`game-design`、`party-mode`、`writing-plans`
+分发动作：`batch-mode`、`brainstorming`、`break-loop`、`cowork-flow`、`doubt-review`、`game-design`、`party-mode`、`tdd`、`writing-plans`
 
 ## CLI 命令
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "type": "module",
   "bin": {

package/template/.claude/agents/cowork-implement.md

@@ -42,8 +42,7 @@ Load context before editing:
 6. Read the plan file linked from this task (check `<task>/task.json` `relatedFiles` for a plan path, or search `.cowork-flow/plans/` for a plan file referencing this task directory). Follow the plan steps in order — each step has Files, Action, Verify, and Expected fields.
 7. Read quality source entries from context; backend/frontend natural-language
    specs are review checklists, not dynamic hard validators.
-8. For behavior-change tasks, create or verify `<task>/tdd.jsonl` before
-   implementation or record a documented exemption.
+8. For behavior-change tasks, write the failing test before implementation and record any red/green evidence in `<task>/check.jsonl`, or record a documented exemption there.
 9. Before reporting completion, write `<task>/quality-review.jsonl` with
    checklist, machine warning, and Definition of Done evidence.
 
@@ -52,7 +51,7 @@ Authoritative internal protocols:
 - `.cowork-flow/spec/protocols/decision-review.md`
 - `.cowork-flow/spec/protocols/spec-maintenance.md`
 
-Apply their output contracts exactly. Implementation reports and `tdd.jsonl`
+Apply their output contracts exactly. Implementation reports and TDD entries in `check.jsonl`
 must preserve `acceptanceId`, `redCommand`, `redExitCode`, `greenCommand`,
 `greenExitCode`, and `specUpdates`.
 

package/template/.codex/agents/cowork-implement.toml

@@ -33,7 +33,7 @@ Load context before editing:
 6. Read the plan file linked from this task (check `<task>/task.json` `relatedFiles` for a plan path, or search `.cowork-flow/plans/` for a plan file referencing this task directory). Follow the plan steps in order — each step has Files, Action, Verify, and Expected fields.
 7. Read quality source entries from context; backend/frontend natural-language
    specs are review checklists, not dynamic hard validators.
-8. For behavior-change tasks, create or verify `<task>/tdd.jsonl` before implementation or record a documented exemption.
+8. For behavior-change tasks, write the failing test before implementation and record any red/green evidence in `<task>/check.jsonl`, or record a documented exemption there.
 9. Before reporting completion, write `<task>/quality-review.jsonl` with
    checklist, machine warning, and Definition of Done evidence.
 
@@ -42,7 +42,7 @@ Authoritative internal protocols:
 - `.cowork-flow/spec/protocols/decision-review.md`
 - `.cowork-flow/spec/protocols/spec-maintenance.md`
 
-Apply their output contracts exactly. Implementation reports and `tdd.jsonl`
+Apply their output contracts exactly. Implementation reports and TDD entries in `check.jsonl`
 must preserve `acceptanceId`, `redCommand`, `redExitCode`, `greenCommand`,
 `greenExitCode`, and `specUpdates`.
 

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.42
+0.0.43

package/template/.cowork-flow/scripts/application/batch_execution.py

@@ -25,6 +25,7 @@ BATCH_STEPS = (
     "init_check_context",
     "await_check_result",
     "complete_task",
+    "archive_task",
     "commit_task",
 )
 STEP_PHASES = {
@@ -33,12 +34,14 @@ STEP_PHASES = {
     "review_task": "review",
     "await_check_result": "check",
     "complete_task": "complete",
+    "archive_task": "archive",
     "commit_task": "commit",
 }
 LIFECYCLE_STATUSES = {
     "start_task": "in_progress",
     "review_task": "review",
     "complete_task": "completed",
+    "archive_task": "completed",
 }
 RUNTIME_ROLES = {
     "init_implement_context": "implement",
@@ -322,6 +325,9 @@ class BatchExecutionService:
                     f"commit could not be verified: {commit_id}",
                 )
             return
+        if action_type == "archive_task":
+            self._verify_archive_result(task_name, result)
+            return
         raise BatchExecutionError(
             "BATCH-ACTION-UNKNOWN-001",
             f"unsupported Batch action: {action_type}",
@@ -364,6 +370,21 @@ class BatchExecutionService:
                 f"expected {expected_status}",
             )
 
+    def _verify_archive_result(
+        self,
+        task_name: str,
+        result: dict,
+    ) -> None:
+        destination = self._optional_text(result, "archive_destination")
+        if destination is None:
+            return
+        archive_path = self.repo_root / destination
+        if not archive_path.exists():
+            raise BatchExecutionError(
+                "BATCH-ARCHIVE-VERIFY-001",
+                f"archive destination does not exist: {destination}",
+            )
+
     def _verify_runtime_initialized(
         self,
         state: dict,

package/template/.cowork-flow/scripts/commands/task_navigation.py

@@ -96,7 +96,7 @@ def _print_blockers(blockers: list[str]) -> None:
 
 def _implementation(task_path: str) -> None:
     print("Next action: execute implementation plan")
-    print(f"TDD reminder: for behavior changes, write a failing test and record red evidence in {task_path}/tdd.jsonl before modifying code.")
+    print(f"TDD reminder: for behavior changes, write the failing test first and record any red/green evidence in {task_path}/check.jsonl.")
     print(
         f"Command: ./.cowork-flow/run subagent init --role implement "
         f"--agent-type cowork-implement --execution-task-dir {task_path} "

package/template/.cowork-flow/scripts/common/gates/anti_rationalization.py

@@ -43,7 +43,7 @@ def validate_exemption_rationalization(reason: str) -> list[dict]:
                     f"'{pattern}'. Replace with a concrete behavior test or "
                     f"specific verification command."
                 ),
-                "file": "<task>/tdd.jsonl",
+                "file": "<task>/check.jsonl",
                 "fix_hint": (
                     "Remove rationalization from exemption reason. "
                     "Either write a failing behavior test for this AC "

package/template/.cowork-flow/scripts/common/gates/gates.py

@@ -130,6 +130,7 @@ def _core_gate_definitions() -> tuple[GateDefinition, ...]:
             validator_key="tdd_evidence",
             required=True,
             block_message="TDD evidence gate blocked lifecycle transition",
+            warning_message="TDD evidence advisories",
         ),
         GateDefinition(
             id="test_intent",

package/template/.cowork-flow/scripts/common/gates/tdd_evidence.py

@@ -2,10 +2,9 @@
 """
 TDD 红绿证据校验（task_review / task_complete 阶段）。
 
-读取 <task>/tdd.jsonl，验证每条 evidence 或 exemption 记录的结构完整
-性与业务意图。验证结果分两类出口：
-- validate_tdd_evidence: 全量校验（review 阶段）
-- validate_tdd_red_evidence: 仅检查 red 证据完整性（implement 入口提醒）
+新任务从 <task>/check.jsonl 读取 TDD evidence 记录，旧任务已有
+<task>/tdd.jsonl 时继续兼容读取并校验。普通行为变更缺少显式 red/green
+证据只产生 warning；高风险行为变更仍要求显式 red/green evidence。
 
 acceptanceId 的提取同时支持 AC-001、AC-1、验收标准：1 三种写法。
 """
@@ -16,7 +15,12 @@ import json
 import re
 from pathlib import Path
 
-EVIDENCE_FILE = "tdd.jsonl"
+CHECK_EVIDENCE_FILE = "check.jsonl"
+LEGACY_EVIDENCE_FILE = "tdd.jsonl"
+EVIDENCE_FILE = CHECK_EVIDENCE_FILE
+
+TDD_EVIDENCE_TYPES = frozenset({"tdd", "tdd_evidence"})
+TDD_EXEMPTION_TYPES = frozenset({"tdd_exemption", "exemption"})
 
 REQUIRED_EVIDENCE_FIELDS = (
     "acceptanceId",
@@ -65,6 +69,25 @@ TDD_REQUIRED_MARKERS = (
     "修改",
 )
 
+STRICT_TDD_MARKERS = (
+    "security",
+    "permission",
+    "auth",
+    "protocol",
+    "state machine",
+    "migration",
+    "public contract",
+    "file format",
+    "安全",
+    "权限",
+    "认证",
+    "协议",
+    "状态机",
+    "迁移",
+    "公共契约",
+    "文件格式",
+)
+
 NON_BEHAVIOR_MARKERS = (
     "docs-only",
     "documentation_only",
@@ -92,75 +115,134 @@ def validate_tdd_evidence(task_dir: Path) -> list[dict]:
     """Return TDD evidence violations for a task directory."""
     task_dir = Path(task_dir)
     decision_anchor_text = _read_text(task_dir / "decision-anchor.md")
-    evidence_path = task_dir / EVIDENCE_FILE
-
-    if not evidence_path.is_file():
-        if _task_requires_tdd(decision_anchor_text):
-            return [
-                _violation(
-                    "TDD-RED-001",
-                    "TDD evidence file is missing for a behavior-change task",
-                    evidence_path,
-                    "Create tdd.jsonl with red/green evidence. For doc-only tasks, add an exemption: "
-                    '{"acceptanceId":"AC-001","type":"exemption","exemptionType":"doc_only",'
-                    '"reason":"why no behavior test","verificationCommand":"ls <expected files>"}',
-                )
-            ]
-        return []
-
-    entries, parse_violations = _read_jsonl(evidence_path)
+    records, parse_violations, legacy_file_present, legacy_entry_count = _load_tdd_records(task_dir)
     if parse_violations:
         return parse_violations
 
-    if not entries:
+    if legacy_file_present and legacy_entry_count == 0:
         return [
             _violation(
                 "TDD-RED-002",
-                "TDD evidence file is empty",
-                evidence_path,
-                "Add at least one evidence or exemption record.",
+                "Legacy TDD evidence file is empty",
+                task_dir / LEGACY_EVIDENCE_FILE,
+                "Remove the empty legacy file or record TDD evidence in check.jsonl.",
             )
         ]
 
+    if not records:
+        if _task_requires_explicit_tdd(decision_anchor_text):
+            return [_missing_red_evidence_violation(task_dir / CHECK_EVIDENCE_FILE)]
+        if _task_requires_tdd(decision_anchor_text):
+            return [_missing_red_evidence_warning(task_dir / CHECK_EVIDENCE_FILE)]
+        return []
+
     acceptance_ids = _acceptance_ids(decision_anchor_text)
     violations: list[dict] = []
-    for index, entry in enumerate(entries, start=1):
-        if entry.get("type") == "exemption":
-            violations.extend(_validate_exemption(entry, evidence_path, index, acceptance_ids))
+    for record_index, (evidence_path, _line_number, entry) in enumerate(records, start=1):
+        if is_tdd_exemption(entry):
+            violations.extend(_validate_exemption(entry, evidence_path, record_index, acceptance_ids))
         else:
-            violations.extend(_validate_evidence(entry, evidence_path, index, acceptance_ids))
+            violations.extend(_validate_evidence(entry, evidence_path, record_index, acceptance_ids))
 
     return violations
 
 
 def validate_tdd_red_evidence(task_dir: Path) -> list[dict]:
-    """Return violations when implementation would start without red evidence."""
+    """Return violations or warnings for missing red evidence before implementation."""
     task_dir = Path(task_dir)
     decision_anchor_text = _read_text(task_dir / "decision-anchor.md")
     if not _task_requires_tdd(decision_anchor_text):
         return []
 
-    evidence_path = task_dir / EVIDENCE_FILE
-    if not evidence_path.is_file():
-        return [_missing_red_evidence_violation(evidence_path)]
-
-    entries, parse_violations = _read_jsonl(evidence_path)
+    records, parse_violations, _legacy_file_present, _legacy_entry_count = _load_tdd_records(task_dir)
     if parse_violations:
         return parse_violations
 
-    red_entries = [entry for entry in entries if entry.get("type") != "exemption"]
-    if not red_entries:
-        return [_missing_red_evidence_violation(evidence_path)]
+    red_records = [
+        record
+        for record in records
+        if not is_tdd_exemption(record[2])
+    ]
+    if not red_records:
+        if _task_requires_explicit_tdd(decision_anchor_text):
+            return [_missing_red_evidence_violation(task_dir / CHECK_EVIDENCE_FILE)]
+        return [_missing_red_evidence_warning(task_dir / CHECK_EVIDENCE_FILE)]
 
     acceptance_ids = _acceptance_ids(decision_anchor_text)
     violations: list[dict] = []
-    for index, entry in enumerate(entries, start=1):
-        if entry.get("type") == "exemption":
-            continue
-        violations.extend(_validate_red_evidence(entry, evidence_path, index, acceptance_ids))
+    for record_index, (evidence_path, _line_number, entry) in enumerate(red_records, start=1):
+        violations.extend(_validate_red_evidence(entry, evidence_path, record_index, acceptance_ids))
     return violations
 
 
+def tdd_evidence_records(task_dir: Path) -> list[tuple[Path, int, dict]]:
+    """Return check.jsonl and legacy tdd.jsonl records that represent TDD evidence."""
+    records, _violations, _legacy_file_present, _legacy_entry_count = _load_tdd_records(Path(task_dir))
+    return records
+
+
+def migrate_legacy_tdd_records(task_dir: Path) -> dict:
+    """Migrate legacy tdd.jsonl records to check.jsonl and remove the legacy file.
+
+    Returns a summary dict with:
+      - migrated: number of records moved
+      - skipped: number of duplicate acceptanceIds already in check.jsonl
+      - legacy_removed: whether the legacy file was deleted
+    """
+    task_dir = Path(task_dir)
+    legacy_path = task_dir / LEGACY_EVIDENCE_FILE
+    check_path = task_dir / CHECK_EVIDENCE_FILE
+
+    if not legacy_path.is_file():
+        return {"migrated": 0, "skipped": 0, "legacy_removed": False}
+
+    migrated = 0
+    skipped = 0
+
+    # Load existing check.jsonl acceptanceIds for dedup
+    existing_ids: set[str] = set()
+    if check_path.is_file():
+        check_entries, _ = _read_jsonl(check_path, report_invalid=False)
+        for _, entry in check_entries:
+            aid = str(entry.get("acceptanceId", "")).strip()
+            if aid:
+                existing_ids.add(aid)
+
+    # Read legacy records
+    legacy_entries, _ = _read_jsonl(legacy_path, report_invalid=True)
+    new_records: list[dict] = []
+
+    for _, entry in legacy_entries:
+        aid = str(entry.get("acceptanceId", "")).strip()
+        if aid and aid in existing_ids:
+            skipped += 1
+            continue
+        new_records.append(entry)
+        if aid:
+            existing_ids.add(aid)
+        migrated += 1
+
+    # Append to check.jsonl
+    if new_records:
+        with check_path.open("a", encoding="utf-8") as stream:
+            for record in new_records:
+                stream.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+    # Remove legacy file
+    legacy_path.unlink()
+
+    return {
+        "migrated": migrated,
+        "skipped": skipped,
+        "legacy_removed": True,
+    }
+
+
+def is_tdd_exemption(entry: dict) -> bool:
+    entry_type = str(entry.get("type") or "").strip()
+    return entry_type in TDD_EXEMPTION_TYPES and _has_value(entry, "exemptionType")
+
+
 def _task_requires_tdd(decision_anchor_text: str) -> bool:
     lower = decision_anchor_text.lower()
     if not lower:
@@ -170,23 +252,82 @@ def _task_requires_tdd(decision_anchor_text: str) -> bool:
     return any(marker.lower() in lower for marker in TDD_REQUIRED_MARKERS)
 
 
+def _task_requires_explicit_tdd(decision_anchor_text: str) -> bool:
+    lower = decision_anchor_text.lower()
+    if not _task_requires_tdd(decision_anchor_text):
+        return False
+    return any(marker.lower() in lower for marker in STRICT_TDD_MARKERS)
+
+
 from common.core.files import read_text_utf8 as _read_text
 
 
-def _read_jsonl(path: Path) -> tuple[list[dict], list[dict]]:
-    entries: list[dict] = []
+def _load_tdd_records(task_dir: Path) -> tuple[list[tuple[Path, int, dict]], list[dict], bool, int]:
+    records: list[tuple[Path, int, dict]] = []
+    violations: list[dict] = []
+
+    legacy_path = task_dir / LEGACY_EVIDENCE_FILE
+    legacy_entry_count = 0
+    if legacy_path.is_file():
+        legacy_entries, legacy_violations = _read_jsonl(legacy_path, report_invalid=True)
+        violations.extend(legacy_violations)
+        legacy_entry_count = len(legacy_entries)
+        records.extend((legacy_path, line_number, entry) for line_number, entry in legacy_entries)
+        violations.append(
+            {
+                "rule_id": "TDD-LEGACY-001",
+                "type": "tdd_legacy_detection",
+                "severity": "warn",
+                "passed": False,
+                "message": (
+                    "Legacy tdd.jsonl detected. Migrate evidence to check.jsonl "
+                    "using migrate_legacy_tdd_records(task_dir)."
+                ),
+                "file": str(legacy_path),
+                "fix_hint": (
+                    "Run migrate_legacy_tdd_records(task_dir) to move records "
+                    "to check.jsonl and remove the legacy file."
+                ),
+            }
+        )
+
+    check_path = task_dir / CHECK_EVIDENCE_FILE
+    if check_path.is_file():
+        check_entries, _check_violations = _read_jsonl(check_path, report_invalid=False)
+        records.extend(
+            (check_path, line_number, entry)
+            for line_number, entry in check_entries
+            if _is_tdd_check_record(entry)
+        )
+
+    return records, violations, legacy_path.is_file(), legacy_entry_count
+
+
+def _is_tdd_check_record(entry: dict) -> bool:
+    entry_type = str(entry.get("type") or "").strip()
+    if entry_type in TDD_EVIDENCE_TYPES or entry_type == "tdd_exemption":
+        return True
+    if is_tdd_exemption(entry):
+        return True
+    return any(field in entry for field in ("redCommand", "greenCommand", "redExitCode", "greenExitCode"))
+
+
+def _read_jsonl(path: Path, *, report_invalid: bool) -> tuple[list[tuple[int, dict]], list[dict]]:
+    entries: list[tuple[int, dict]] = []
     violations: list[dict] = []
     try:
         lines = path.read_text(encoding="utf-8").splitlines()
     except (OSError, UnicodeDecodeError):
-        return entries, [
-            _violation(
-                "TDD-READ-001",
-                "Failed to read TDD evidence as UTF-8",
-                path,
-                "Rewrite tdd.jsonl with UTF-8 encoding.",
+        if report_invalid:
+            violations.append(
+                _violation(
+                    "TDD-READ-001",
+                    "Failed to read TDD evidence as UTF-8",
+                    path,
+                    "Rewrite the evidence file with UTF-8 encoding.",
+                )
             )
-        ]
+        return entries, violations
 
     for line_number, line in enumerate(lines, start=1):
         if not line.strip():
@@ -194,26 +335,28 @@ def _read_jsonl(path: Path) -> tuple[list[dict], list[dict]]:
         try:
             data = json.loads(line)
         except json.JSONDecodeError:
-            violations.append(
-                _violation(
-                    "TDD-FORMAT-001",
-                    f"Invalid JSON in tdd.jsonl line {line_number}",
-                    path,
-                    "Write one valid JSON object per line.",
+            if report_invalid:
+                violations.append(
+                    _violation(
+                        "TDD-FORMAT-001",
+                        f"Invalid JSON in TDD evidence line {line_number}",
+                        path,
+                        "Write one valid JSON object per line.",
+                    )
                 )
-            )
             continue
         if not isinstance(data, dict):
-            violations.append(
-                _violation(
-                    "TDD-FORMAT-002",
-                    f"tdd.jsonl line {line_number} must be a JSON object",
-                    path,
-                    "Replace non-object entries with structured evidence records.",
+            if report_invalid:
+                violations.append(
+                    _violation(
+                        "TDD-FORMAT-002",
+                        f"TDD evidence line {line_number} must be a JSON object",
+                        path,
+                        "Replace non-object entries with structured evidence records.",
+                    )
                 )
-            )
             continue
-        entries.append(data)
+        entries.append((line_number, data))
 
     return entries, violations
 
@@ -316,9 +459,19 @@ def _validate_red_evidence(
 def _missing_red_evidence_violation(evidence_path: Path) -> dict:
     return _violation(
         "TDD-RED-001",
-        "TDD red evidence is missing for a behavior-change task",
+        "TDD red-green evidence is missing for a high-risk behavior-change task",
+        evidence_path,
+        "Record a tdd evidence object in check.jsonl with redCommand, redExitCode, greenCommand, greenExitCode, and acceptanceId.",
+    )
+
+
+def _missing_red_evidence_warning(evidence_path: Path) -> dict:
+    return _violation(
+        "TDD-RED-WARN-001",
+        "TDD red-green evidence is not recorded for this behavior-change task",
         evidence_path,
-        "Write a failing behavior test and record its red command before implementation.",
+        "Prefer recording red/green evidence in check.jsonl when the change was developed TDD-first.",
+        severity="warn",
     )
 
 
@@ -366,11 +519,18 @@ def _has_value(entry: dict, field: str) -> bool:
     return True
 
 
-def _violation(rule_id: str, message: str, file_path: Path, fix_hint: str) -> dict:
+def _violation(
+    rule_id: str,
+    message: str,
+    file_path: Path,
+    fix_hint: str,
+    *,
+    severity: str = "block",
+) -> dict:
     return {
         "rule_id": rule_id,
         "type": "tdd_evidence",
-        "severity": "block",
+        "severity": severity,
         "passed": False,
         "message": message,
         "file": str(file_path),

package/template/.cowork-flow/scripts/common/gates/test_intent.py

@@ -5,11 +5,10 @@ from __future__ import annotations
 
 import ast
 import io
-import json
 import tokenize
 from pathlib import Path
 
-from .tdd_evidence import EVIDENCE_FILE
+from .tdd_evidence import is_tdd_exemption, tdd_evidence_records
 
 REPORT_FIELD = "test_intent_review"
 
@@ -47,15 +46,14 @@ BLOCK_MARKERS = (
 
 
 def validate_test_intent(repo_root: Path, task_dir: Path) -> list[dict]:
-    """Return test intent warnings or blocks for the task's TDD evidence."""
-    evidence_path = Path(task_dir) / EVIDENCE_FILE
-    entries = _read_tdd_entries(evidence_path)
-    if not entries:
+    """Return test intent warnings or blocks for TDD evidence records."""
+    records = tdd_evidence_records(Path(task_dir))
+    if not records:
         return []
 
     violations: list[dict] = []
-    for index, entry in enumerate(entries, start=1):
-        if entry.get("type") == "exemption":
+    for index, (evidence_path, _line_number, entry) in enumerate(records, start=1):
+        if is_tdd_exemption(entry):
             continue
 
         test_file = entry.get("testFile")
@@ -121,28 +119,6 @@ def validate_test_intent(repo_root: Path, task_dir: Path) -> list[dict]:
     return violations
 
 
-def _read_tdd_entries(path: Path) -> list[dict]:
-    if not path.is_file():
-        return []
-
-    entries: list[dict] = []
-    try:
-        lines = path.read_text(encoding="utf-8").splitlines()
-    except (OSError, UnicodeDecodeError):
-        return []
-
-    for line in lines:
-        if not line.strip():
-            continue
-        try:
-            data = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(data, dict):
-            entries.append(data)
-    return entries
-
-
 from common.core.files import read_text_utf8 as _read_text
 
 

package/template/.cowork-flow/spec/contracts/decision-anchor.md

@@ -50,9 +50,9 @@
 
 ## 产物压缩
 
-合并前（6个文件）：`prd.md` + `implement.jsonl` + `check.jsonl` + `debug.jsonl` + `tdd.jsonl` + `task.json`
+合并前（6个文件）：`prd.md` + `implement.jsonl` + `check.jsonl` + `debug.jsonl` + `task.json`
 
-合并后（5个文件）：`decision-anchor.md` + `implement.jsonl` + `check.jsonl` + `debug.jsonl` + `tdd.jsonl` + `task.json`
+合并后（5个文件）：`decision-anchor.md` + `implement.jsonl` + `check.jsonl` + `debug.jsonl` + `task.json`
 
 **净减 1 个文件类型。相关文件追踪现在由 implement.jsonl 统一负责。**
 

package/template/.cowork-flow/spec/protocols/tdd.md

@@ -20,7 +20,7 @@ This section is the authoritative red-green-refactor contract.
 
 ## Output
 
-Write one JSON object per line to `<task>/tdd.jsonl` with:
+When red/green evidence is useful or required, write one JSON object per line to `<task>/check.jsonl` with `type: "tdd"` and:
 
 - `acceptanceId`, `testFile`, `testName`
 - `redCommand`, `redExitCode`, `redOutputExcerpt`, `failureReason`
@@ -31,12 +31,12 @@ Only docs/comment/format-only work may use a documented `exemption`.
 
 ## Anti-Rationalization
 
-The following excuses do not exempt the TDD evidence requirement:
+The following excuses do not exempt meaningful behavior testing or required high-risk TDD evidence:
 
 | Excuse | Why It Fails | Required Alternative |
 |---|---|---|
 | "This logic is simple, no test needed" | Simple logic still breaks on edge cases and later edits. | Write the smallest behavior test for the acceptance ID. |
-| "Other tests already cover this" | Invisible coverage is not red-green evidence. | Point to the exact redCommand and acceptanceId in `tdd.jsonl`. |
+| "Other tests already cover this" | Invisible coverage is not red-green evidence. | Point to the exact redCommand and acceptanceId in `check.jsonl`. |
 | "I'll add tests after implementation" | Post-implementation tests are not a red-green cycle. | Red first, then green; record both commands. |
 | "It looks correct" | Visual inspection misses scenarios that tests can pin down. | Turn the expected behavior and edge case into assertions. |
 | "I've written similar tests" | Similar structure is not the same behavior. | Re-run the redCommand for this acceptanceId. |

package/template/.cowork-flow/spec/references/definition-of-done.md

@@ -7,7 +7,7 @@
 | # | 检查项 | 验证 |
 |---|---|---|
 | G1 | 代码实现符合 decision-anchor acceptance criteria | AC 全部为 verified |
-| G2 | L1/L2: tdd.jsonl 有 red-green evidence | ./cowork-flow/run task validate |
+| G2 | 行为变更有对应测试；高风险任务在 check.jsonl 有 red-green evidence | ./cowork-flow/run task validate |
 | G3 | check phase 完成，无 unresolved blocker | check.jsonl status=pass |
 | G4 | 无新引入 lint/type/build 警告 | lint / build 命令通过 |
 | G5 | Git status snapshot 仅含任务相关变更，包括 staged、unstaged、untracked | git status --porcelain=v1 -uall |

package/template/.cowork-flow/spec/runtime/host-assets.json

@@ -194,7 +194,6 @@
       ".agents/skills/finish-work",
       ".agents/skills/party-mode-v2",
       ".agents/skills/start",
-      ".agents/skills/tdd",
       ".agents/skills/update-spec",
       ".agents/skills/using-cowork-flow",
       ".claude/skills/before-dev",
@@ -204,7 +203,6 @@
       ".claude/skills/finish-work",
       ".claude/skills/party-mode-v2",
       ".claude/skills/start",
-      ".claude/skills/tdd",
       ".claude/skills/update-spec",
       ".claude/skills/using-cowork-flow"
     ]

package/template/.cowork-flow/spec/runtime/skill-registry.json

@@ -324,6 +324,29 @@
       "source": ".cowork-flow/scripts/common/gates/gates.py",
       "managedPaths": []
     },
+    {
+      "id": "tdd",
+      "displayName": "TDD",
+      "aliases": [],
+      "kind": "protocol",
+      "visibility": "public",
+      "status": "active",
+      "statuses": [
+        "in_progress"
+      ],
+      "intents": [
+        "apply_tdd"
+      ],
+      "enforcement": "advisory",
+      "runtimeGate": null,
+      "runtimeCommand": null,
+      "evidenceArtifact": "check.jsonl",
+      "source": "skills/tdd/SKILL.md",
+      "managedPaths": [
+        ".agents/skills/tdd/",
+        ".claude/skills/tdd/"
+      ]
+    },
     {
       "id": "tdd-protocol",
       "displayName": "TDD Protocol",
@@ -340,7 +363,7 @@
       "enforcement": "mandatory",
       "runtimeGate": "tdd-evidence",
       "runtimeCommand": null,
-      "evidenceArtifact": "tdd.jsonl",
+      "evidenceArtifact": "check.jsonl",
       "source": ".cowork-flow/spec/protocols/tdd.md",
       "managedPaths": []
     },
@@ -356,7 +379,7 @@
       "enforcement": "runtime",
       "runtimeGate": null,
       "runtimeCommand": "task review",
-      "evidenceArtifact": "tdd.jsonl",
+      "evidenceArtifact": "check.jsonl",
       "source": ".cowork-flow/scripts/common/gates/tdd_evidence.py",
       "managedPaths": []
     },

package/template/.cowork-flow/workflow.md

@@ -21,7 +21,7 @@ changes -> brainstorming -> read spec -> plan -> tasks -> implement -> check ->
 
 `cowork-flow` 只保存项目状态、任务上下文、宿主适配器契约和恢复线索；实际执行由主会话和固定 `cowork-*` 代理完成。宿主工具名只写在 `.cowork-flow/adapters/<host>/adapter.yaml`，不进入流程分支。
 
-`task next` 是主会话的阶段导航器。进入任务阶段、恢复会话、派发实现、进入检查、完成收口前，先运行 `./.cowork-flow/run task next` 或 `.\.cowork-flow\run.cmd task next`，用当前任务和 `task.json.status` 决定下一步。该命令只读，不推进状态，也不阻断固定代理派发；实现阶段会提示行为变更先补 TDD red evidence。
+`task next` 是主会话的阶段导航器。进入任务阶段、恢复会话、派发实现、进入检查、完成收口前，先运行 `./.cowork-flow/run task next` 或 `.\.cowork-flow\run.cmd task next`，用当前任务和 `task.json.status` 决定下一步。该命令只读，不推进状态，也不阻断固定代理派发；实现阶段会提示行为变更先写失败测试，并把必要的 red/green evidence 记录到 `check.jsonl`。
 
 ## 1.1 状态注入与入口分类
 
@@ -188,12 +188,12 @@ L2 任务在 `task start` 前必须通过 readiness gate；同一 blocker 列表
 ## 6. 实现阶段
 
 1. 先运行 `task next` 确认当前状态和下一步命令。
-2. 行为变更任务先写失败测试并记录 `<task>/tdd.jsonl` 的 red evidence；`task next` 会在实现步骤给出非阻断提醒。
+2. 行为变更任务先写失败测试；普通任务可把 red/green evidence 作为 `type: "tdd"` 记录写入 `<task>/check.jsonl`，高风险任务必须显式记录。`task next` 会在实现步骤给出非阻断提醒。
 3. 默认通过宿主适配器派发 `cowork-implement`。派发必须使用新鲜子上下文，并遵守 `.cowork-flow/spec/contracts/subagent-dispatch.md`。
 4. 派发内容应包含当前计划步骤、范围边界和期望验证命令。
 5. 如果用户明确要求主会话内联执行，或当前任务正在修改子代理/运行时行为，可以不派发 `cowork-implement`，但必须说明原因，并仍按计划与测试循环推进。
 6. 涉及行为变化时，先写失败测试，再实现，再验证变绿。
-7. 实现完成并通过本阶段验证后运行 `./.cowork-flow/run task review [task-dir]`，由 review 门禁验收完整 `tdd.jsonl`，再把任务推进到检查阶段。
+7. 实现完成并通过本阶段验证后运行 `./.cowork-flow/run task review [task-dir]`，由 review 门禁验收测试意图、TDD/check evidence 和实现范围，再把任务推进到检查阶段。
 
 ## 7. 检查阶段
 
@@ -237,6 +237,7 @@ L2 任务在 `task start` 前必须通过 readiness gate；同一 blocker 列表
    第二个提交是明确的 follow-up metadata commit；session 中的 `commit` 始终指向前一个真实实现提交，不使用永久占位值。
    `task archive <task-name>` 会归档 task，并自动归档 `change.yaml.task`
    指向该 task 的 active change；无法通过 `change validate` 的 change 不会被自动归档。
+   注：batch 模式（`task start <parent> --auto --approved`）已在 `complete_task` 与 `commit_task` 之间自动执行 `archive_task`，无需手动归档。
 
 ## 9. 恢复规则
 

package/template/.opencode/agents/cowork-implement.md

@@ -43,7 +43,7 @@ Read and apply:
 - `.cowork-flow/spec/protocols/decision-review.md`
 - `.cowork-flow/spec/protocols/spec-maintenance.md`
 
-Their contracts are Host-neutral. Implementation reports and `tdd.jsonl` must
+Their contracts are Host-neutral. Implementation reports and TDD entries in `check.jsonl` must
 preserve `acceptanceId`, `redCommand`, `redExitCode`, `greenCommand`,
 `greenExitCode`, and `specUpdates`. A behavior change requires
 red-green-refactor evidence or a valid documented exemption.

package/template/.zcode/.zcode-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 ZCode。",
   "author": {
     "name": "fisklikewater"

package/template/.zcode/scaffold/.cowork-flow/workflow.md

@@ -21,7 +21,7 @@ changes -> brainstorming -> read spec -> plan -> tasks -> implement -> check ->
 
 `cowork-flow` 只保存项目状态、任务上下文、宿主适配器契约和恢复线索；实际执行由主会话和固定 `cowork-*` 代理完成。宿主工具名只写在 `.cowork-flow/adapters/<host>/adapter.yaml`，不进入流程分支。
 
-`task next` 是主会话的阶段导航器。进入任务阶段、恢复会话、派发实现、进入检查、完成收口前，先运行 `./.cowork-flow/run task next` 或 `.\.cowork-flow\run.cmd task next`，用当前任务和 `task.json.status` 决定下一步。该命令只读，不推进状态，也不阻断固定代理派发；实现阶段会提示行为变更先补 TDD red evidence。
+`task next` 是主会话的阶段导航器。进入任务阶段、恢复会话、派发实现、进入检查、完成收口前，先运行 `./.cowork-flow/run task next` 或 `.\.cowork-flow\run.cmd task next`，用当前任务和 `task.json.status` 决定下一步。该命令只读，不推进状态，也不阻断固定代理派发；实现阶段会提示行为变更先写失败测试，并把必要的 red/green evidence 记录到 `check.jsonl`。
 
 ## 1.1 状态注入与入口分类
 
@@ -188,12 +188,12 @@ L2 任务在 `task start` 前必须通过 readiness gate；同一 blocker 列表
 ## 6. 实现阶段
 
 1. 先运行 `task next` 确认当前状态和下一步命令。
-2. 行为变更任务先写失败测试并记录 `<task>/tdd.jsonl` 的 red evidence；`task next` 会在实现步骤给出非阻断提醒。
+2. 行为变更任务先写失败测试；普通任务可把 red/green evidence 作为 `type: "tdd"` 记录写入 `<task>/check.jsonl`，高风险任务必须显式记录。`task next` 会在实现步骤给出非阻断提醒。
 3. 默认通过宿主适配器派发 `cowork-implement`。派发必须使用新鲜子上下文，并遵守 `.cowork-flow/spec/contracts/subagent-dispatch.md`。
 4. 派发内容应包含当前计划步骤、范围边界和期望验证命令。
 5. 如果用户明确要求主会话内联执行，或当前任务正在修改子代理/运行时行为，可以不派发 `cowork-implement`，但必须说明原因，并仍按计划与测试循环推进。
 6. 涉及行为变化时，先写失败测试，再实现，再验证变绿。
-7. 实现完成并通过本阶段验证后运行 `./.cowork-flow/run task review [task-dir]`，由 review 门禁验收完整 `tdd.jsonl`，再把任务推进到检查阶段。
+7. 实现完成并通过本阶段验证后运行 `./.cowork-flow/run task review [task-dir]`，由 review 门禁验收测试意图、TDD/check evidence 和实现范围，再把任务推进到检查阶段。
 
 ## 7. 检查阶段
 
@@ -237,6 +237,7 @@ L2 任务在 `task start` 前必须通过 readiness gate；同一 blocker 列表
    第二个提交是明确的 follow-up metadata commit；session 中的 `commit` 始终指向前一个真实实现提交，不使用永久占位值。
    `task archive <task-name>` 会归档 task，并自动归档 `change.yaml.task`
    指向该 task 的 active change；无法通过 `change validate` 的 change 不会被自动归档。
+   注：batch 模式（`task start <parent> --auto --approved`）已在 `complete_task` 与 `commit_task` 之间自动执行 `archive_task`，无需手动归档。
 
 ## 9. 恢复规则
 

package/template/skills/batch-mode/SKILL.md

@@ -1,66 +1,64 @@
 ---
 name: batch-mode
-description: 用户批准完整计划并要求按任务图连续执行时使用；每个任务仍独立经过 Gate、实现、检查、完成和提交。
+description: Use when the user approves a full plan and asks for continuous execution across the task graph; each task still goes through Gate, implementation, check, completion, and commit independently.
 ---
 
 # Batch Mode
 
-## 核心契约
+## Core Contract
 
-Batch Scheduler 是持久化状态机，不在 CLI 内模拟实现或检查完成。
+Batch Scheduler is a persistent state machine. Do **not** simulate or check completion inside the CLI.
 
-- 任务顺序只来自 change/task graph 的叶子任务拓扑序。
-- `implement.jsonl`、`check.jsonl` 和 `tdd.jsonl` 只作为当前任务上下文与 Gate 证据，
-  不能作为 Batch 任务列表。
-- 每次只发布一个 host-neutral `next_action`。
-- Host 执行真实动作后，必须回写结果；状态机验证仓库状态后才推进。
-- 任何 Gate、绑定、实现、检查、测试、完成或提交失败都会暂停。
-- 已完成的任务、阶段和提交不会在恢复时重复执行。
+- Task ordering comes **only** from the topological order of leaf tasks in the change/task graph.
+- `implement.jsonl` and `check.jsonl` serve **only** as current-task context and Gate evidence; they must **not** be used as the Batch task list.
+- Only one host-neutral `next_action` is published at a time.
+- After the host executes a real action, results must be written back; the state machine validates repository state before advancing.
+- Any failure in Gate, binding, implementation, check, test, completion, or commit **pauses** the batch.
+- Completed tasks, phases, and commits are never re-executed on resume.
 
-## 启动条件
+## Startup Conditions
 
-仅在以下条件全部满足时启动：
+Start only when **all** conditions are met:
 
-1. 用户明确批准计划并要求自动连续执行。
-2. parent task 与所有叶子任务已建立有效 task graph。
-3. 当前会话是 main/coordinator，不是 worker 或 delegated subagent。
-4. Host 能执行 task、subagent 和 Git 动作。
+1. The user explicitly approves the plan and asks for automatic continuous execution.
+2. A valid task graph links the parent task and all leaf tasks.
+3. The current session is main/coordinator — not a worker or delegated subagent.
+4. The host can perform task, subagent, and Git actions.
 
-启动命令：
+Startup command:
 
 ```bash
 ./.cowork-flow/run task start <parent-task> --auto --approved
 ```
 
-命令返回完整 Batch 状态，其中 `next_action` 是唯一允许执行的下一步。
+The command returns the full Batch state, where `next_action` is the **only** allowed next step.
 
-## Host Action 循环
+## Host Action Loop
 
-每次按以下顺序处理：
+Each cycle processes in this order:
 
-1. 读取 `next_action`，核对 `action_id`、`type`、`task` 和 `task_dir`。
-2. 只执行该动作，不提前执行后续阶段。
-3. 将结果写入 UTF-8 JSON 文件。
-4. 回写结果：
+1. Read `next_action`; verify `action_id`, `type`, `task`, and `task_dir`.
+2. Execute **only** that action — do not advance to later phases prematurely.
+3. Write the result to a UTF-8 JSON file.
+4. Write back the result:
 
 ```bash
 ./.cowork-flow/run task batch-record-result <batch-id> --file <result.json>
 ```
 
-5. 读取新状态；若为 `awaiting_host`，继续新的 `next_action`；若为 `paused`，
-   停止后续任务。
+5. Read the new state. If `awaiting_host`, continue with the new `next_action`. If `paused`, halt all subsequent tasks.
 
-## Action 类型
+## Action Types
 
 ### `start_task`
 
-运行真实任务启动命令并通过 readiness/spec/TDD Gate：
+Run the real task startup command and pass through the readiness/spec/TDD Gate:
 
 ```bash
 ./.cowork-flow/run task start <task_dir>
 ```
 
-成功结果必须包含：
+A successful result must contain:
 
 ```json
 {
@@ -71,11 +69,11 @@ Batch Scheduler 是持久化状态机，不在 CLI 内模拟实现或检查完
 }
 ```
 
-状态机同时读取 `task.json`，仅相信真实的 `in_progress` 状态。
+The state machine also reads `task.json` and trusts only the genuine `in_progress` status.
 
 ### `init_implement_context` / `init_check_context`
 
-按 action 中的 `role`、`agent_type`、`task_dir` 和 `title` 运行：
+Run with `role`, `agent_type`, `task_dir`, and `title` from the action:
 
 ```bash
 ./.cowork-flow/run subagent init \
@@ -85,11 +83,9 @@ Batch Scheduler 是持久化状态机，不在 CLI 内模拟实现或检查完
   --title "<title>"
 ```
 
-Host 必须使用返回的 `cowork_runtime_context_id` 与
-`cowork_host_context_key` 派发对应 worker，并让 worker 首步执行
-`subagent bind`。
+The host must use the returned `cowork_runtime_context_id` and `cowork_host_context_key` to dispatch the matching worker, and the worker's first step must run `subagent bind`.
 
-初始化结果必须回写：
+Write back the initialization result:
 
 ```json
 {
@@ -101,39 +97,58 @@ Host 必须使用返回的 `cowork_runtime_context_id` 与
 }
 ```
 
-检查阶段将 `type` 改为 `init_check_context`。
+For the check phase, change `type` to `init_check_context`.
 
 ### `await_implement_result` / `await_check_result`
 
-等待对应 worker 完成，验证输出属于当前任务且 runtime context 已绑定到预期 Host。
+Wait for the corresponding worker to finish, and verify the output belongs to the current task and the runtime context is bound to the expected host.
 
-成功结果必须包含 action 中相同的 `runtime_context_id` 和
-`host_context_key`。状态机验证 `status=bound` 后关闭 runtime context；
-如果关闭成功但 Batch checkpoint 尚未落盘，重复回写仍可恢复。
+A successful result must contain the same `runtime_context_id` and `host_context_key` as the action. The state machine verifies `status=bound` before closing the runtime context. If close succeeds but the Batch checkpoint has not yet been flushed, repeating the write-back can still recover.
 
 ### `review_task`
 
-运行：
+Run:
 
 ```bash
 ./.cowork-flow/run task review <task_dir>
 ```
 
-成功结果的 `task_status` 必须为 `review`，状态机还会读取真实 `task.json`。
+The successful result's `task_status` must be `review`; the state machine also reads the genuine `task.json`.
 
 ### `complete_task`
 
-运行：
+Run:
 
 ```bash
 ./.cowork-flow/run task complete <task_dir>
 ```
 
-成功结果的 `task_status` 必须为 `completed`，状态机还会读取真实 `task.json`。
+The successful result's `task_status` must be `completed`; the state machine also reads the genuine `task.json`.
+
+### `archive_task`
+
+Run the real task archive command to move the completed task to `archive/<year-month>/`:
+
+```bash
+./.cowork-flow/run task archive <task_name>
+```
+
+The host must verify the task directory has been moved to the archive location. A successful result must contain:
+
+```json
+{
+  "action_id": "<action-id>",
+  "type": "archive_task",
+  "outcome": "success",
+  "archive_destination": ".cowork-flow/tasks/archive/<year-month>/<task_name>"
+}
+```
+
+The state machine verifies the destination directory exists on disk. If the archive fails (task directory not found, move conflict, or linked-change validation failure), write back a failure result and the batch pauses. On resume, only `archive_task` is retried — `complete_task` is not re-executed.
 
 ### `commit_task`
 
-只提交当前任务已验证的改动，并回写真实 commit id：
+Commit only the current task's verified changes, and write back the real commit id:
 
 ```json
 {
@@ -144,12 +159,11 @@ Host 必须使用返回的 `cowork_runtime_context_id` 与
 }
 ```
 
-状态机使用 Git 验证该对象确实是 commit；空值、占位字符串或不存在的 commit
-都会暂停。
+The state machine uses Git to verify the object is genuinely a commit. Empty values, placeholder strings, or non-existent commits all cause a pause.
 
-## 失败与恢复
+## Failure and Recovery
 
-Host 不可用或任一动作失败时，回写非 success 结果：
+When the host is unavailable or any action fails, write back a non-success result:
 
 ```json
 {
@@ -160,22 +174,21 @@ Host 不可用或任一动作失败时，回写非 success 结果：
 }
 ```
 
-状态会变为 `paused`，失败任务与所有后续任务不会被标记 completed。
+The state becomes `paused`. The failed task and all subsequent tasks are **not** marked completed.
 
-修复原因后运行：
+After fixing the cause, run:
 
 ```bash
 ./.cowork-flow/run task batch-resume <batch-id>
 ```
 
-恢复会生成新的 `action_id`，但保留已完成任务、阶段、runtime 证据和 commit。
-不要跳过失败任务，不要手工修改 Batch 状态文件。
+Resume generates a new `action_id` but preserves completed tasks, phases, runtime evidence, and commits. Do **not** skip the failed task. Do **not** manually edit the Batch state file.
 
-## 完成验证
+## Completion Verification
 
-Batch 状态变为 `completed` 后：
+Once the Batch state becomes `completed`:
 
-1. 运行项目完整测试与构建命令。
-2. 核对 `completed_tasks`、`task_phases` 与 `commits` 一一对应。
-3. 核对每个叶子任务都有独立 commit。
-4. 运行 spec sync、doctor 和发布前检查。
+1. Run the project's full test and build commands.
+2. Verify `completed_tasks`, `task_phases`, and `commits` correspond one-to-one.
+3. Verify each leaf task has its own independent commit.
+4. Run spec sync, doctor, and pre-release checks.

package/template/skills/tdd/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: tdd
+description: Use when implementing behavior changes with red-green-refactor discipline. Guides test-first development and records optional or high-risk red/green evidence in check.jsonl without replacing cowork-flow routing.
+---
+
+# TDD
+
+Use this Skill to practice test-first implementation inside the active cowork-flow task. This Skill does not start, review, complete, archive, dispatch, or route tasks; use `cowork-flow` for lifecycle state.
+
+## Trigger
+
+Use for behavior, state, protocol, CLI, data-format, permission, or error-handling changes. For docs/comment/format-only work, skip TDD and record the verification method in `check.jsonl`.
+
+## Red-Green-Refactor
+
+1. Map the behavior to a `decision-anchor.md` acceptance ID.
+2. Write the smallest meaningful test that fails because the target behavior is missing or wrong.
+3. Run the test and confirm the red failure is about target behavior, not setup/import/environment noise.
+4. Implement the minimum change.
+5. Run the same test to green, then run directly dependent tests.
+6. Refactor only after the behavior is pinned green.
+
+## Evidence
+
+For ordinary behavior changes, recording red/green evidence is recommended when it helps review but is not a separate artifact requirement. For high-risk changes such as protocol, state-machine, permission, security, migration, public-contract, or file-format changes, record a `type: "tdd"` object in `<task>/check.jsonl` with:
+
+- `acceptanceId`, `testFile`, `testName`
+- `redCommand`, `redExitCode`, `redOutputExcerpt`, `failureReason`
+- `whyThisTestMatters`
+- `greenCommand`, `greenExitCode`, `broaderVerification`
+
+Only docs/comment/format-only work may use a documented `type: "tdd_exemption"` record in `check.jsonl`.
+
+## Anti-Rationalization
+
+Do not use these excuses to skip meaningful behavior tests:
+
+| Excuse | Why It Fails | Required Alternative |
+|---|---|---|
+| "This logic is simple, no test needed" | Simple logic still breaks on edge cases and later edits. | Write the smallest behavior test for the acceptance ID. |
+| "Other tests already cover this" | Invisible coverage is not red-green evidence. | Point to the exact test command and acceptance ID in `check.jsonl`. |
+| "I'll add tests after implementation" | Post-implementation tests are not a red-green cycle. | Red first, then green; record both commands when evidence is required. |
+| "It looks correct" | Visual inspection misses scenarios that tests can pin down. | Turn expected behavior and edge cases into assertions. |
+| "This is internal only" | Internal behavior still affects callers and workflow state. | Test through the public entry point, or directly test the narrow internal contract. |

package/template/skills/writing-plans/SKILL.md

@@ -29,11 +29,26 @@ Start with:
 
 > For formal fixed-agent work: create a runtime context with `.cowork-flow/run subagent init`, pass `cowork_runtime_context_id: <runtime_context_id>` through the active Host Adapter, then dispatch `cowork-implement` or `cowork-check`. Close the runtime context after verification.
 
-**Goal:** <one sentence>
-**Architecture:** <2-3 sentences>
-**Verification:** <commands or checks>
+| 项 | 内容 |
+|----|------|
+| **目标** | <一句话> |
+| **架构** | <2-3 句> |
+| **验证** | `<命令>` → exit 0；`<命令>` → exit 0 |
+| **策略** | 串行 / 并行（文件所有权：A 组 / B 组） |
+| **范围** | N 步 / N 文件 / N AC |
+| **风险** | 无显著风险 / 见尾部风险表 §高-N |
+
+## 概览
+
+| Step | AC | 标题 | 状态 |
+|------|----|------|------|
+| 1.1 | AC-001 | <标题> | ⬜ |
+| 1.2 | AC-002 | <标题> | ⬜ |
+| 2.1 | — | <标题> | ⬜ |
 ```
 
+Then list acceptance criteria, then steps.
+
 ## Task Rules
 
 - Each task names exact files to create, modify, or test.
@@ -41,25 +56,37 @@ Start with:
 - **Every step MUST follow the executable format below** so subagents never guess:
 
   ```markdown
-  ### Step N.M: <short description>
+  ### Step N.M [AC-XXX] ⬜: <一句话描述，中文>
+
+  - **改动**: `path/a.py`, `path/b.py`（×2 = template + root 两份）
+  - **做了什么**: <一句话具体变更>
+  - **验证**: `<命令>` → exit 0（实现前 exit 1 → 实现后 exit 0 | AC-XXX）
+  - **回滚**: <一句话或"仅增测试，无回滚成本">
+  ```
 
-  - **Files**: <exact file paths, one per line or comma-separated>
-  - **Action**: <one sentence describing the concrete change>
-  - **Verify**: `<command>` → `<expected output or exit code>`
-  - **Expected**: <what the file/state/system looks like after the step succeeds>
+  For steps covering multiple AC:
+
+  ```markdown
+  - **同时覆盖**: AC-002
   ```
 
-  For behavior-change steps, add TDD evidence:
+  For steps without an AC (e.g. integrated verification):
 
   ```markdown
-  - **TDD**: RED → GREEN
-    - redCommand: `<command>`
-    - redExitCode: 1
-    - greenCommand: `<command>`
-    - greenExitCode: 0
-    - acceptanceId: AC-001
+  ### Step N.M — ⬜: <一句话描述，中文>
   ```
 
+  In the overview table, fill AC column with `—` for no-AC steps.
+
+- TDD evidence is inlined in Verify parentheses: `实现前 exit 1 → 实现后 exit 0`. When red and green commands differ, use two-line form:
+  ```
+  - **验证**: `red command` → exit 1 | `green command` → exit 0 | AC-XXX
+  ```
+- Expected/断言 field is retired. Its responsibility moves into Verify parentheses — describe state changes that exit code alone cannot cover:
+  ```
+  - **验证**: `pytest tests/test_archive.py -q` → exit 0（覆盖：归档成功的 JSONL 自路径规范化 + 失败路径的字节级回滚）
+  ```
+- Rollback is always local — write recovery directly in the step. No cross-reference to risk table.
 - Include commands and expected results in every step.
 - Include a failing test before implementation when behavior can be tested.
 - Do not add shallow tests just to satisfy process. Avoid tests that only assert existence, mirror implementation details, count mocks without behavior, or snapshot empty structure.
@@ -73,7 +100,7 @@ Start with:
 | Agent Rationalization | Rebuttal | Alternative |
 |---|---|---|
 | "This task is too small, let's merge it." | Task granularity is determined by acceptance criteria, not line count. Merge only when AC cannot be split; otherwise keep independent. | Split until each step has a distinct AC; keep them as independent steps even when short. |
-| "Write a rough plan first, refine during implementation." | Rough plan = no constraints during implementation. Implementation without constraints = scope creep or rework. | Write the plan to the full executable format (Files / Action / Verify / Expected) before any code is touched. |
+| "Write a rough plan first, refine during implementation." | Rough plan = no constraints during implementation. Implementation without constraints = scope creep or rework. | Write the plan to the full executable format (改动 / 做了什么 / 验证 / 回滚) before any code is touched. |
 | "Skip the plan and start directly since we have decision-anchor." | decision-anchor.md defines "what to do"; the plan defines "how to do it and in what order." Tasks without a plan incur doubled rework cost when dependency errors surface midway. | Use decision-anchor.md to derive the AC list, then produce plan steps that map each AC to a concrete file + verify command. |
 | "This task doesn't need a verify command." | No verify = no completion signal. Every task must have an executable verification command. | Add at least one automated check (typecheck, test, lint, build) as the Verify step so completion is observable. |
 
@@ -113,4 +140,4 @@ Before handoff:
 1. Confirm every decision-anchor.md acceptance criterion maps to a plan step.
 2. Search the plan for placeholders.
 3. Check names, paths, command syntax, and expected outputs.
-4. Record remaining risks or blockers.
+4. Record remaining risks or blocklers.