cowork-flow 0.0.32 → 0.0.33

package/package.json

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

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.32
+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:

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

@@ -1,11 +1,21 @@
 #!/usr/bin/env python3
-"""Spec-driven coding standards — gates honor user-edited spec files.
+"""Coding-standard gates — context-injection model.
 
-Files under ``.cowork-flow/spec/backend/``, ``spec/frontend/`` and
-``spec/guides/`` are parsed at runtime into review-checklist rules and matched
-against a small registry of registered validators. Anything a user adds to
-those files is activated at the next gate run — the gate re-reads the
-markdown every time.
+Under Approach A, rules authored under ``.cowork-flow/spec/backend/*.md`` and
+``spec/frontend/*.md`` are machine-parsed into checklist items, then surfaced to
+the LLM via ``get_coding_standards_summary`` (already wired into the check/
+review gates). The LLM is trusted to verify its own code against these items.
+
+Only machine-decidable checks run here as hard blocks:
+
+* Phase 1 — UTF-8 / IO-encoding (``validate_changed_files``).
+* ``validate_complexity_signals`` — oversize Python functions (warn).
+
+A separate ``collect_machine_checks`` helper is exposed for callers that want
+additional regex-style warnings (hardcoded secrets, debug prints, silent
+excepts, trailing comments...) WITHOUT hard-blocking the workflow. These are
+emitted at severity=advisory so they can be rendered for the LLM without being a
+wall the user must satisfy.
 """
 
 from __future__ import annotations
@@ -14,7 +24,7 @@ import json
 import re
 import sys
 from pathlib import Path
-from typing import Callable, Iterable, Sequence
+from typing import Sequence
 
 from common.gates.coding_standards import validate_changed_files
 from common.git.git_snapshot import collect_changed_files, collect_changed_paths
@@ -39,84 +49,6 @@ def _is_frontend_file(rel_path: str) -> bool:
     return bool(_FRONTEND_SUFFIXES.search(rel_path))
 
 
-# ---------------------------------------------------------------------------
-# Registered NL-backed validators
-# ---------------------------------------------------------------------------
-
-# Each entry: (compiled-pattern, category, validator-fn).
-# ``validator(content, rel_path)`` yields ``(lineno, message, fix_hint)``.
-_NL_VALIDATORS: list[tuple[re.Pattern, str, Callable[[str, str], Iterable[tuple[int, str, str]]]]] = []
-
-
-def register_nl_validator(pattern: str) -> Callable[[Callable], Callable]:
-    def decorator(fn: Callable) -> Callable:
-        category = getattr(fn, "_nl_category", "backend")
-        _NL_VALIDATORS.append((re.compile(pattern, re.IGNORECASE), category, fn))
-        return fn
-    return decorator
-
-
-def nl_category(category: str) -> Callable[[Callable], Callable]:
-    def decorator(fn: Callable) -> Callable:
-        fn._nl_category = category
-        return fn
-    return decorator
-
-
-@register_nl_validator(r"(硬编码|hardcode|hard.code|secret|password|api[_\s]?key|token)")
-@nl_category("backend")
-def _no_hardcoded_secrets(content: str, rel_path: str) -> Iterable[tuple[int, str, str]]:
-    pattern = re.compile(
-        r"""(?ix)
-        (?:password|passwd|secret|api[_\s]?key|token|access[_\s]?key|aws_access_key_id|aws_secret_access_key)
-        \s*[:=]\s*["'][^"'}{)($]{3,}["']
-        """
-    )
-    for lineno, raw in enumerate(content.splitlines(), start=1):
-        if pattern.search(raw) and "process.env" not in raw and "os.environ" not in raw:
-            yield (lineno,
-                   "Possible hard-coded secret in source; spec forbids it.",
-                   "Read from configuration or environment variables.")
-
-
-@register_nl_validator(r"(print\b|console\.(log|info|debug)|日志|logger|logging|结构化日志)")
-@nl_category("backend")
-def _no_debug_prints(content: str, rel_path: str) -> Iterable[tuple[int, str, str]]:
-    if rel_path.endswith(".py"):
-        pat = re.compile(r"(?<!\w)print\s*\(")
-    elif rel_path.endswith((".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx")):
-        pat = re.compile(r"\bconsole\.(log|info|debug)\s*\(")
-    else:
-        return
-    for lineno, raw in enumerate(content.splitlines(), start=1):
-        if pat.search(raw):
-            yield (lineno, "Debug print found; spec prefers structured logger.",
-                   "Use a structured logger instead.")
-
-
-@register_nl_validator(r"(吞|swallow|静默|except|空\s*except)")
-@nl_category("backend")
-def _no_silent_except(content: str, rel_path: str) -> Iterable[tuple[int, str, str]]:
-    if not rel_path.endswith(".py"):
-        return
-    lines = content.splitlines()
-    for lineno, raw in enumerate(lines, start=1):
-        if re.match(r"^\s*except\b\s*.*:\s*(#.*)?$", raw):
-            nxt = lines[lineno].strip() if lineno < len(lines) else ""
-            if nxt in {"pass", "...", ""} or nxt.startswith(("pass ", "...")):
-                yield (lineno, "Empty exception handler silently swallows errors.",
-                       "Log or re-raise the exception, or narrow the except types.")
-
-
-@register_nl_validator(r"(硬编码|hardcode|明文|magic\s+number)")
-@nl_category("frontend")
-def _no_magic_values_frontend(content: str, rel_path: str) -> Iterable[tuple[int, str, str]]:
-    pat = re.compile(r"""(?ix)(?:magic\s+number|hardcode|硬编码)""")
-    for lineno, raw in enumerate(content.splitlines(), start=1):
-        if pat.search(raw):
-            yield (lineno, "Hard-coded magic value in frontend source; spec forbids it.")
-
-
 # ---------------------------------------------------------------------------
 # Spec parser
 # ---------------------------------------------------------------------------
@@ -148,6 +80,8 @@ def load_spec_rules(
     """Return every natural-language rule declared under ``spec/<category>/``.
 
     Re-reads markdown on every call, so user edits take effect without restart.
+    ``validators`` is preserved as an empty list (legacy field kept so external
+    tooling that inspects the rule dict does not break).
     """
     out: list[dict] = []
     repo_root = Path(repo_root)
@@ -168,10 +102,7 @@ def load_spec_rules(
                     "source": f".cowork-flow/spec/{category}/{md.name}",
                     "line": lineno,
                     "text": rule,
-                    "validators": [
-                        pat.pattern for pat, cat, _ in _NL_VALIDATORS
-                        if cat in (category, "backend") and re.search(pat, rule)
-                    ],
+                    "validators": [],
                 })
     return out
 
@@ -180,12 +111,15 @@ def load_spec_rules(
 # Public API
 # ---------------------------------------------------------------------------
 
-
 def get_coding_standards_summary(
     repo_root: Path,
     task_dir: Path,
 ) -> str:
-    """Render the active user-authored rules as a checklist (read-only)."""
+    """Render the active user-authored rules as a review checklist (read-only).
+
+    Calls whose changed paths cover neither backend nor frontend files return
+    an empty string — there is nothing actionable for the LLM to review.
+    """
     changed = collect_changed_paths(repo_root)
     if not changed:
         return ""
@@ -199,13 +133,13 @@ def get_coding_standards_summary(
     if backend:
         rules = load_spec_rules(repo_root, ("backend",))
         if rules:
-            out.append("=== Backend spec rules — VALIDATED during check gate ===")
+            out.append("=== Backend spec rules — LLM review checklist ===")
             for r in rules:
                 out.append(f"- [{r['source']}:{r['line']}] {r['text']}")
     if frontend:
         rules = load_spec_rules(repo_root, ("frontend",))
         if rules:
-            out.append("=== Frontend spec rules — VALIDATED during check gate ===")
+            out.append("=== Frontend spec rules — LLM review checklist ===")
             for r in rules:
                 out.append(f"- [{r['source']}:{r['line']}] {r['text']}")
     return "\n".join(out)
@@ -215,28 +149,44 @@ def validate_coding_standards(
     repo_root: Path,
     task_dir: Path | None = None,
 ) -> list[dict]:
-    """Run all coding-standard checks — hardcoded UTF-8 + spec-activated NL rules.
+    """Run hard machine-checkable coding-standard gates.
 
-    The NL rules only run when the user's spec files declare a matching rule
-    text, making spec files genuinely editable quality gates.
+    Approach A keeps only the UTF-8 / IO-encoding check here. All natural
+    language rules authored in the spec tree are surfaced to the LLM via the
+    checklist in ``get_coding_standards_summary``; they do not block the
+    workflow from this function. Optional advisory warnings live in
+    ``collect_machine_checks``.
     """
-    violations: list[dict] = []
+    return list(validate_changed_files(repo_root, collect_changed_files(repo_root)))
 
-    # Phase 1: hardcoded UTF-8 / IO checks always run.
-    violations.extend(validate_changed_files(repo_root, collect_changed_files(repo_root)))
 
-    # Phase 2: spec-driven validators — activated by user-edited spec text.
-    spec_rules = load_spec_rules(repo_root)
-    if not spec_rules:
-        return violations
+def collect_machine_checks(
+    repo_root: Path,
+    task_dir: Path | None = None,
+) -> list[dict]:
+    """Emit regex-style advisory signals (severity=advisory).
 
-    activated: set[str] = set()
-    for rule in spec_rules:
-        activated.update(rule.get("validators", []))
-    if not activated:
+    The LLM decides how to act on them; the workflow never blocks on a hit.
+    Kept separate from ``validate_coding_standards`` so callers can choose
+    whether to render them in a gate log, inject them into context, or ignore.
+    """
+    violations: list[dict] = []
+    try:
+        changed_files = collect_changed_files(repo_root)
+    except Exception:  # noqa: BLE001 — defensively isolate git errors
         return violations
 
-    for changed_file in collect_changed_files(repo_root):
+    secret_re = re.compile(
+        r"""(?ix)
+        (?:password|passwd|secret|api[_\s]?key|token|access[_\s]?key)
+        \s*[:=]\s*["'][^"'}{)($]{3,}["']
+        """
+    )
+    silent_except_re = re.compile(r"^\s*except\b\s*.*:\s*(#.*)?$")
+    bare_print_re = re.compile(r"(?<!\w)print\s*\(")
+    console_re = re.compile(r"\bconsole\.(log|info|debug)\s*\(")
+
+    for changed_file in changed_files:
         file_path = repo_root / changed_file.path
         if not file_path.is_file():
             continue
@@ -247,38 +197,125 @@ def validate_coding_standards(
             content = file_path.read_text(encoding="utf-8")
         except (OSError, UnicodeDecodeError):
             continue
-        for pat, _category, validator in _NL_VALIDATORS:
-            if pat.pattern not in activated:
-                continue
-            try:
-                results = validator(content, changed_file.path)
-            except Exception:  # noqa: BLE001 — defensively isolate parsing
-                continue
-            for lineno, msg, *rest in results:
-                fix_hint = rest[0] if rest else ""
-                violations.append({
-                    "rule_id": f"SPEC-{validator.__name__}",
-                    "type": "spec_coding_standard",
-                    "severity": "block",
-                    "passed": False,
-                    "message": msg,
-                    "file": changed_file.path,
-                    "line": lineno,
-                    "fix_hint": fix_hint,
-                })
-
+        lines = content.splitlines()
+        for lineno, raw in enumerate(lines, start=1):
+            # Low-signal heuristic: only flag if the line also has an
+            # assignment / call so variable-name mentions do not trip it.
+            if (secret_re.search(raw)
+                    and "process.env" not in raw
+                    and "os.environ" not in raw):
+                violations.append(_adv(
+                    "MACHINE-HARDCODED-SECRET-001",
+                    "Possible hard-coded secret in source",
+                    changed_file.path, lineno,
+                    "Read the value from configuration or environment variables.",
+                ))
+            if suffix == ".py" and bare_print_re.search(raw):
+                violations.append(_adv(
+                    "MACHINE-DEBUG-PRINT-001",
+                    "Debug print on changed line",
+                    changed_file.path, lineno,
+                    "Use a structured logger or remove the print.",
+                ))
+            if suffix in {".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"} and console_re.search(raw):
+                violations.append(_adv(
+                    "MACHINE-CONSOLE-LOG-001",
+                    "console.{log,info,debug} on changed line",
+                    changed_file.path, lineno,
+                    "Use the project logger or remove the call.",
+                ))
+            if (suffix == ".py"
+                    and silent_except_re.match(raw)
+                    and lineno < len(lines)
+                    and lines[lineno].strip() in {"pass", "...", ""}):
+                violations.append(_adv(
+                    "MACHINE-SILENT-EXCEPT-001",
+                    "Empty exception handler silently swallows errors",
+                    changed_file.path, lineno,
+                    "Log or re-raise the exception, or narrow the except types.",
+                ))
     return violations
 
 
+def _adv(
+    rule_id: str,
+    message: str,
+    file_path: str,
+    line: int,
+    fix_hint: str,
+) -> dict:
+    return {
+        "rule_id": rule_id,
+        "type": "machine_check",
+        "severity": "advisory",
+        "passed": False,
+        "message": message,
+        "file": file_path,
+        "line": line,
+        "fix_hint": fix_hint,
+    }
+
+
+def validate_complexity_signals(repo_root: Path, task_dir: Path | None) -> list[dict]:
+    """Detect over-complexity signals in modified files (warn-level)."""
+    import ast
+    import subprocess
+    warnings: list[dict] = []
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "--diff-filter=ACMR", "HEAD~"],
+            cwd=str(repo_root), capture_output=True, text=True,
+            encoding="utf-8", timeout=10,
+        )
+        changed_files = [f for f in result.stdout.splitlines() if f]
+    except (subprocess.SubprocessError, OSError):
+        return warnings
+
+    for rel_path in changed_files:
+        if not rel_path.endswith(".py"):
+            continue
+        full_path = repo_root / rel_path
+        if not full_path.is_file():
+            continue
+        try:
+            source = full_path.read_text(encoding="utf-8")
+            tree = ast.parse(source)
+        except (OSError, SyntaxError, UnicodeDecodeError):
+            continue
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                end = getattr(node, "end_lineno", None) or node.lineno
+                func_lines = end - node.lineno
+                if func_lines > 50:
+                    warnings.append({
+                        "rule_id": "COMPLEX-FUNC-001",
+                        "type": "coding_standard",
+                        "severity": "warn",
+                        "passed": False,
+                        "message": (
+                            f"{rel_path}:{node.name} function is "
+                            f"{func_lines} lines (< 50 recommended)"
+                        ),
+                        "file": str(rel_path),
+                        "fix_hint": (
+                            "Split into multiple named functions "
+                            "by responsibility."
+                        ),
+                    })
+    return warnings
+
+
 def main() -> None:
     import argparse
 
-    parser = argparse.ArgumentParser(description="Spec-driven coding gate")
+    parser = argparse.ArgumentParser(description="Coding-standard gate")
     parser.add_argument("--task-dir", help="Task directory")
     parser.add_argument("--repo-root", default=".", help="Repo root path")
     parser.add_argument("--summarize", action="store_true")
     parser.add_argument("--list", action="store_true", help="List parsed spec rules")
-    parser.add_argument("--validate", action="store_true", help="Run spec validators vs changed files")
+    parser.add_argument("--validate", action="store_true")
+    parser.add_argument("--machine-checks", action="store_true",
+                        help="Also emit advisory machine-check warnings")
 
     args = parser.parse_args()
     repo_root = Path(args.repo_root).resolve()
@@ -293,9 +330,11 @@ def main() -> None:
         return
     if args.validate:
         v = validate_coding_standards(repo_root, task_dir)
+        if args.machine_checks:
+            v.extend(collect_machine_checks(repo_root, task_dir))
         for x in v:
             print(json.dumps(x, ensure_ascii=False))
-        sys.exit(1 if v else 0)
+        sys.exit(1 if any(x["severity"] == "block" for x in v) else 0)
     print(get_coding_standards_summary(repo_root, task_dir) or "No spec rules activated.")