cowork-flow 0.0.32 → 0.0.34

package/package.json

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

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

@@ -35,7 +35,7 @@ the task.
 
 Load context before checking:
 1. Read the task directory from the bound runtime context.
-2. Read `<task>/prd.md`.
+2. Read `<task>/decision-anchor.md`.
 3. 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). Use the plan's Verify commands and Expected results as the checklist for each step.
 4. Read `<task>/check.jsonl`.
 5. Read `git diff`.

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

@@ -35,8 +35,8 @@ the task.
 
 Load context before editing:
 1. Read the task directory from the bound runtime context.
-2. Read `<task>/prd.md`.
-3. Read `<task>/info.md` if present.
+2. Read `<task>/decision-anchor.md`.
+3. Read .
 4. Read `<task>/implement.jsonl`.
 5. Read each JSONL `file` entry.
 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.

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.32
+0.0.34

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

@@ -485,9 +485,13 @@ def _task_start_blockers(task_dir: Path) -> list[str]:
     if not task_json.is_file():
         blockers.append("task.json is missing")
 
-    prd_file = task_dir / "prd.md"
-    if not _read_text_if_present(prd_file):
-        blockers.append("prd.md is missing or empty")
+    # 只检查存在性 — R-WF-008 负责章节内容完整性
+    if _read_text_if_present(task_dir / "prd.md"):
+        # 旧格式：提示需要迁移（cmd_start 会自动迁移）
+        if not _read_text_if_present(task_dir / "decision-anchor.md"):
+            blockers.append("prd.md found; task start will auto-migrate to decision-anchor.md")
+    elif not _read_text_if_present(task_dir / "decision-anchor.md"):
+        blockers.append("decision-anchor.md is missing or empty")
 
     for jsonl_name in CONTEXT_JSONL_FILES:
         jsonl_file = task_dir / jsonl_name
@@ -661,10 +665,29 @@ def cmd_create(args: argparse.Namespace) -> int:
 
                 print(colored(f"Linked as child of: {parent_dir.name}", Colors.GREEN), file=sys.stderr)
 
+    # --from-plan: 自动生成 decision-anchor.md 骨架
+    if getattr(args, "from_plan", None):
+        plan_path = Path(args.from_plan)
+        if plan_path.is_file():
+            plan_text = plan_path.read_text(encoding="utf-8")
+            goal = next(
+                (line.split(":", 1)[1].strip() for line in plan_text.splitlines()
+                 if line.startswith("**Goal:**") or line.startswith("**目标:**")),
+                None,
+            )
+            if goal:
+                anchor_file = task_dir / "decision-anchor.md"
+                if not anchor_file.exists():
+                    anchor_file.write_text(
+                        f"## 目标\n\n{goal}\n\n## 验收标准\n- [ ] \n",
+                        encoding="utf-8",
+                    )
+                    print(f"  {colored('[OK]', Colors.GREEN)} Generated decision-anchor.md from plan")
+
     print(colored(f"Created task: {dir_name}", Colors.GREEN), file=sys.stderr)
     print("", file=sys.stderr)
     print(colored("Next steps:", Colors.BLUE), file=sys.stderr)
-    print("  1. Create prd.md with requirements", file=sys.stderr)
+    print("  1. Create decision-anchor.md with requirements", file=sys.stderr)
     print("  2. Run: ./.cowork-flow/run task init-context <dir> <dev_type>", file=sys.stderr)
     print("  3. Run: ./.cowork-flow/run task start <dir>", file=sys.stderr)
     print("", file=sys.stderr)
@@ -961,11 +984,29 @@ def cmd_start(args: argparse.Namespace) -> int:
         for blocker in blockers:
             print(f"  - {blocker}", file=sys.stderr)
         print(
-            "Hint: write prd.md, run ./.cowork-flow/run task init-context <dir> <dev_type>, then retry",
+            "Hint: write decision-anchor.md, run ./.cowork-flow/run task init-context <dir> <dev_type>, then retry",
             file=sys.stderr,
         )
         return 1
 
+    # 自动迁移旧 prd.md 到 decision-anchor.md
+    prd_file = full_path / "prd.md"
+    anchor_file = full_path / "decision-anchor.md"
+    if prd_file.exists() and not anchor_file.exists():
+        content = prd_file.read_text(encoding="utf-8").strip()
+        if not content:
+            content = "(empty legacy prd.md)"
+        if "## 目标" not in content and "## Goal" not in content:
+            content = "## 目标\n\n" + content
+        if "## 验收标准" not in content and "## Acceptance" not in content:
+            content += "\n\n## 验收标准\n- [ ] \n"
+        anchor_file.write_text(content, encoding="utf-8")
+        prd_file.unlink()
+        print(
+            colored("  [迁移] prd.md → decision-anchor.md", Colors.YELLOW),
+            file=sys.stderr,
+        )
+
     validation_issues = _task_context_validation_issues(full_path, repo_root)
     if validation_issues:
         print(colored("Error: Task context validation failed", Colors.RED), file=sys.stderr)
@@ -988,6 +1029,10 @@ def cmd_start(args: argparse.Namespace) -> int:
         )
         return 1
 
+    if getattr(args, "auto", False):
+        from common.task.batch_mode import run_batch_entry
+        return run_batch_entry(repo_root, full_path, args)
+
     state_blockers = transition_blockers(_load_task_status(full_path), "in_progress")
     if state_blockers:
         _print_transition_blockers(state_blockers)
@@ -1351,6 +1396,17 @@ def _print_blockers(blockers: list[str]) -> None:
         print(f"  - {blocker}")
 
 
+def _is_git_dirty(repo_root: Path) -> bool:
+    """Check if the git working tree has uncommitted changes."""
+    try:
+        rc, _, _ = _run_git_command(
+            ["status", "--porcelain"], cwd=repo_root
+        )
+        return rc != 0
+    except (OSError, Exception):
+        return False
+
+
 def _linked_active_changes_for_task(repo_root: Path, task_dir: Path) -> list[str]:
     from commands.change import linked_active_changes_for_task
 
@@ -1479,7 +1535,7 @@ def cmd_next(args: argparse.Namespace) -> int:
         return 0
 
     if status in DONE_STATUSES:
-        print("Next action: finalize, commit, archive, and record session")
+        print("Next action: finalize, archive, commit, and record session")
         print("Command: git status --short")
         linked_changes = _linked_active_changes_for_task(repo_root, task_dir)
         print(f"Then: ./.cowork-flow/run task archive {Path(task_path).name}")
@@ -1546,6 +1602,14 @@ def cmd_archive(args: argparse.Namespace) -> int:
     if linked_changes and not _linked_changes_ready_for_archive(repo_root, linked_changes):
         return 1
 
+    # R-WF-011: warn if uncommitted changes detected (archive should come before commit)
+    if _is_git_dirty(repo_root):
+        print(colored(
+            "Warning: Uncommitted changes detected. "
+            "Archive the task first, then commit the archived result.",
+            Colors.YELLOW,
+        ), file=sys.stderr)
+
     # Archive
     result = archive_task_complete(task_dir, repo_root)
     if "archived_to" not in result:
@@ -1914,6 +1978,7 @@ def main() -> int:
     p_create.add_argument("--priority", "-p", default="P2", help="Priority (P0-P3)")
     p_create.add_argument("--description", "-d", help="Task description")
     p_create.add_argument("--parent", help="Parent task directory (establishes subtask link)")
+    p_create.add_argument("--from-plan", "-f", help="Path to plan file (auto-generate decision-anchor skeleton)")
 
     # init-context
     p_init = subparsers.add_parser("init-context", help="Initialize context files")
@@ -1938,6 +2003,10 @@ def main() -> int:
     # start
     p_start = subparsers.add_parser("start", help="Set active session task")
     p_start.add_argument("dir", help="Task directory")
+    p_start.add_argument("--auto", action="store_true",
+                         help="Enable batch mode (requires --approved)")
+    p_start.add_argument("--approved", action="store_true",
+                         help="User has approved the plan")
 
     # current
     subparsers.add_parser("current", help="Show active session task")

package/template/.cowork-flow/scripts/common/core/execution_context.py

@@ -268,8 +268,8 @@ def build_worker_resume_text(
             if isinstance(file_value, str) and file_value.strip():
                 suffix = f" - {reason}" if isinstance(reason, str) and reason.strip() else ""
                 lines.append(f"- {file_value}{suffix}")
-    if context.task_dir and (repo_root / context.task_dir / "prd.md").is_file():
-        lines.append(f"- Read task PRD: {context.task_dir}/prd.md")
+    if context.task_dir and (repo_root / context.task_dir / "decision-anchor.md").is_file():
+        lines.append(f"- Read task PRD: {context.task_dir}/decision-anchor.md")
     lines.append("- Follow only the files, steps, and commands named in the worker brief.")
 
     forbidden_actions = context_data.get("forbiddenActions")

package/template/.cowork-flow/scripts/common/core/files.py

@@ -25,6 +25,14 @@ def read_json_file(path: Path) -> dict | None:
         return None
 
 
+def read_text_utf8(path: Path) -> str:
+    """Read a text file as UTF-8; return "" if missing or unreadable."""
+    try:
+        return path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
 def write_json_file(path: Path, data: dict) -> bool:
     """Write dict to JSON file atomically (temp + os.replace)."""
     try:

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Anti-rationalization pattern detection for TDD exemptions."""
+
+from __future__ import annotations
+
+RATIONALIZATION_PATTERNS = (
+    "太简单",
+    "显而易",
+    "没必要",
+    "不需要测试",
+    "已经有其他测试",
+    "肉眼",
+    "self-evident",
+    "trivial",
+    "obvious",
+    "no need to test",
+    "covered elsewhere",
+    "already tested",
+    "just a",
+    "only a",
+)
+
+
+def validate_exemption_rationalization(reason: str) -> list[dict]:
+    """Detect anti-rationalization patterns in TDD exemption reasons.
+
+    Returns violation dicts with rule_id TDD-RATIONALIZE-001.
+    Severity is warn (does not block task start/review).
+    """
+    violations: list[dict] = []
+    if not reason:
+        return violations
+    lower = reason.lower()
+    for pattern in RATIONALIZATION_PATTERNS:
+        if pattern.lower() in lower:
+            violations.append({
+                "rule_id": "TDD-RATIONALIZE-001",
+                "type": "tdd_evidence",
+                "severity": "warn",
+                "passed": False,
+                "message": (
+                    f"TDD exemption reason contains rationalization pattern: "
+                    f"'{pattern}'. Replace with a concrete behavior test or "
+                    f"specific verification command."
+                ),
+                "file": "<task>/tdd.jsonl",
+                "fix_hint": (
+                    "Remove rationalization from exemption reason. "
+                    "Either write a failing behavior test for this AC "
+                    "or provide a verification command that exercises "
+                    "the claimed unchanged behavior."
+                ),
+            })
+            break
+    return violations

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

@@ -58,6 +58,11 @@ class GateRunner:
             violations.extend(
                 validate_coding_standards(self.repo_root, normalized_task_dir)
             )
+            from .validate_coding_standards import validate_complexity_signals
+
+            violations.extend(
+                validate_complexity_signals(self.repo_root, normalized_task_dir)
+            )
         return GateResult.from_violations(scope, violations, normalized_task_dir)
 
     def log(self, result: GateResult) -> None:

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

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Spec markdown section validator for cowork-flow."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+SECTION_CONFIG: dict[str, tuple[str, ...]] = {
+    "contract": ("Goal", "When to Use", "Rules", "Examples"),
+    "skill": ("Overview", "When to Use", "Steps", "Verification"),
+    "guide": ("Goal", "When to Use", "Process", "Anti-Rationalization"),
+    "default": ("Goal", "Rules"),
+}
+
+HEADER_RE = re.compile(r"^##\s+(.+)$", re.MULTILINE)
+
+
+def validate_sections(file_path: Path | str, spec_type: str = "default") -> tuple[bool, list[str]]:
+    """Validate a spec markdown file has all required sections.
+
+    Returns (is_valid, error_messages).
+    """
+    path = Path(file_path)
+    errors: list[str] = []
+
+    if not path.is_file():
+        return False, [f"File not found: {path}"]
+
+    content = path.read_text(encoding="utf-8").strip()
+    if not content:
+        return False, ["File is empty"]
+
+    required = SECTION_CONFIG.get(spec_type)
+    if required is None:
+        return False, [f"Unknown spec type: {spec_type}"]
+
+    matches = list(HEADER_RE.finditer(content))
+    found: dict[str, str] = {}
+    for i, m in enumerate(matches):
+        name = m.group(1).strip()
+        start = m.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(content)
+        body = content[start:end].strip()
+        found[name] = body
+
+    for req in required:
+        if req not in found:
+            errors.append(f"Missing: {req}")
+        elif not found[req]:
+            errors.append(f"Empty: {req}")
+
+    return (not errors, errors)

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

@@ -82,7 +82,7 @@ SETUP_FAILURE_MARKERS = (
 def validate_tdd_evidence(task_dir: Path) -> list[dict]:
     """Return TDD evidence violations for a task directory."""
     task_dir = Path(task_dir)
-    prd_text = _read_text(task_dir / "prd.md")
+    prd_text = _read_text(task_dir / "decision-anchor.md")
     evidence_path = task_dir / EVIDENCE_FILE
 
     if not evidence_path.is_file():
@@ -127,7 +127,7 @@ def validate_tdd_evidence(task_dir: Path) -> list[dict]:
 def validate_tdd_red_evidence(task_dir: Path) -> list[dict]:
     """Return violations when implementation would start without red evidence."""
     task_dir = Path(task_dir)
-    prd_text = _read_text(task_dir / "prd.md")
+    prd_text = _read_text(task_dir / "decision-anchor.md")
     if not _task_requires_tdd(prd_text):
         return []
 
@@ -161,11 +161,7 @@ def _task_requires_tdd(prd_text: str) -> bool:
     return any(marker.lower() in lower for marker in TDD_REQUIRED_MARKERS)
 
 
-def _read_text(path: Path) -> str:
-    try:
-        return path.read_text(encoding="utf-8")
-    except (OSError, UnicodeDecodeError):
-        return ""
+from common.core.files import read_text_utf8 as _read_text
 
 
 def _read_jsonl(path: Path) -> tuple[list[dict], list[dict]]:
@@ -214,7 +210,10 @@ def _read_jsonl(path: Path) -> tuple[list[dict], list[dict]]:
 
 
 def _acceptance_ids(prd_text: str) -> set[str]:
-    return set(re.findall(r"\bAC-\d{3}\b", prd_text))
+    """提取验收标准 ID，支持 AC-001、AC-1、验收标准：1 等格式。"""
+    ids = set(re.findall(r"\bAC-(\d{1,4})\b", prd_text, re.IGNORECASE))
+    ids |= set(re.findall(r"验收标准[：:]\s*(\d+)", prd_text))
+    return {f"AC-{n}" for n in ids}
 
 
 def _validate_evidence(
@@ -343,6 +342,9 @@ def _validate_exemption(
             )
         )
 
+    from .anti_rationalization import validate_exemption_rationalization
+    violations.extend(validate_exemption_rationalization(str(entry.get("reason", ""))))
+
     return violations
 
 

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

@@ -143,11 +143,7 @@ def _read_tdd_entries(path: Path) -> list[dict]:
     return entries
 
 
-def _read_text(path: Path) -> str:
-    try:
-        return path.read_text(encoding="utf-8")
-    except (OSError, UnicodeDecodeError):
-        return ""
+from common.core.files import read_text_utf8 as _read_text
 
 
 def _classify_test_content(content: str, test_name: str) -> str: