cowork-flow 0.0.31 → 0.0.33

package/package.json

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

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

@@ -38,6 +38,13 @@ Rules:
 - MUST NOT commit, archive, or mutate cowork-flow task state.
 - Report findings, changed files, and exact verification commands.
 - Include test intent findings that map tests back to PRD acceptance or regression behavior.
+- BEFORE declaring PRD acceptance passed, run the spec-driven coding gate and
+  treat a nonzero exit as a hard blocker:
+  ./.cowork-flow/run python .cowork-flow/scripts/common/gates/validate_coding_standaries.py --validate --repo-root .
+  This naturally enforces every rule the user added to
+  .cowork-flow/spec/backend/*.md and spec/frontend/*.md — they are not just
+  documentation but active validators. On violation, either fix the code or
+  explicitly discard the rule from the spec; do not skip the gate.
 """
 
 [features]

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

@@ -40,6 +40,12 @@ Rules:
 - Keep edits inside requested scope.
 - Do not treat shallow tests as TDD evidence; red-green-refactor proof must include redCommand, redExitCode, greenCommand, greenExitCode, and PRD acceptance ID mapping.
 - Report changed files and exact verification commands.
+- BEFORE editing any source file, run the spec-driven coding gate and treat a
+  nonzero exit as a hard blocker:
+  ./.cowork-flow/run python .cowork-flow/scripts/common/gates/validate_coding_standaries.py --validate --repo-root .
+  Parse every *.md under .cowork-flow/spec/backend and spec/frontend; rules
+  declared there activate validators dynamically. On violation, fix the code
+  (do not disable the rule) and re-run until exit code 0.
 """
 
 [features]

package/template/.codex/hooks.json

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": ".cowork-flow/run python .codex/hooks/inject-workflow-state.py",
+            "command": ".codex/hooks/inject-workflow-state.py",
             "timeout": 5
           }
         ]

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.31
+0.0.33

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

@@ -988,6 +988,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 +1355,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 +1494,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 +1561,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:
@@ -1938,6 +1961,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/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

@@ -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]]:
@@ -343,6 +339,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: