cowork-flow 0.0.47 → 0.0.49

package/template/skills/task-review/scripts/review_check.py

@@ -7,6 +7,7 @@ import argparse
 import ast
 import json
 import re
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -35,6 +36,7 @@ from runtime.session_state import is_main_session
 PROTECTED_PREFIX = "Protected workflow/spec file changed outside main session: "
 UNLISTED_PREFIX = "Modified file not listed in implement.jsonl: "
 TEST_SUFFIXES = {".py", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
+FUNCTION_LINE_SOFT_LIMIT = 60
 CODE_SUFFIXES = {
     ".py",
     ".js",
@@ -119,12 +121,71 @@ def _infer_dev_type(task_data: dict[str, Any], changed_files: list[str]) -> str:
     return ""
 
 
+def _normalized_issue(
+    *,
+    code: str,
+    severity: str,
+    path: str,
+    message: str,
+    source: str,
+    **extra: str,
+) -> dict[str, str]:
+    issue = {
+        "code": code,
+        "severity": severity,
+        "path": path,
+        "message": message,
+        "source": source,
+    }
+    issue.update(extra)
+    return issue
+
+
+def _lifecycle_issue_fact(issue: Any) -> dict[str, str]:
+    return _normalized_issue(
+        code=str(getattr(issue, "code", "") or "lifecycle_issue"),
+        severity="error",
+        path=str(getattr(issue, "path", "") or ""),
+        message=str(getattr(issue, "message", "") or ""),
+        source="lifecycle",
+    )
+
+
+def _fallback_lifecycle_issue(
+    *,
+    code: str,
+    path: str,
+    message: str,
+) -> dict[str, str]:
+    return _normalized_issue(
+        code=code,
+        severity="error",
+        path=path,
+        message=message,
+        source="lifecycle",
+    )
+
+
 def _scope_facts(
     repo_root: Path,
     task_dir: Path,
     *,
     allow_spec_file_modifications: bool,
 ) -> dict[str, Any]:
+    scope_facts, _ = _scope_facts_with_issues(
+        repo_root,
+        task_dir,
+        allow_spec_file_modifications=allow_spec_file_modifications,
+    )
+    return scope_facts
+
+
+def _scope_facts_with_issues(
+    repo_root: Path,
+    task_dir: Path,
+    *,
+    allow_spec_file_modifications: bool,
+) -> tuple[dict[str, Any], list[dict[str, str]]]:
     result = LifecycleCheckRunner(repo_root).review(
         task_dir,
         allow_spec_file_modifications=allow_spec_file_modifications,
@@ -132,19 +193,62 @@ def _scope_facts(
     protected: list[str] = []
     unlisted: list[str] = []
     context_issues: list[str] = []
-    for message in result.blockers:
-        if message.startswith(PROTECTED_PREFIX):
-            protected.append(message.removeprefix(PROTECTED_PREFIX))
-        elif message.startswith(UNLISTED_PREFIX):
-            unlisted.append(message.removeprefix(UNLISTED_PREFIX))
-        else:
-            context_issues.append(message)
-    return {
-        "unlistedChangedFiles": unlisted,
-        "protectedWorkflowFiles": protected,
-        "contextIssues": context_issues,
-        "lifecycleMessages": list(result.blockers),
-    }
+    normalized_issues: list[dict[str, str]] = []
+    issues = tuple(getattr(result, "issues", ()) or ())
+    if issues:
+        for issue in issues:
+            code = str(getattr(issue, "code", "") or "")
+            path = getattr(issue, "path", None)
+            message = str(getattr(issue, "message", "") or "")
+            normalized_issues.append(_lifecycle_issue_fact(issue))
+            if code == "protected_workflow_file":
+                protected.append(str(path or message.removeprefix(PROTECTED_PREFIX)))
+            elif code == "unlisted_changed_file":
+                normalized = str(path or message.removeprefix(UNLISTED_PREFIX))
+                if normalized not in protected:
+                    unlisted.append(normalized)
+            else:
+                context_issues.append(message)
+    else:
+        for message in result.blockers:
+            if message.startswith(PROTECTED_PREFIX):
+                path = message.removeprefix(PROTECTED_PREFIX)
+                protected.append(path)
+                normalized_issues.append(
+                    _fallback_lifecycle_issue(
+                        code="protected_workflow_file",
+                        path=path,
+                        message=message,
+                    )
+                )
+            elif message.startswith(UNLISTED_PREFIX):
+                path = message.removeprefix(UNLISTED_PREFIX)
+                unlisted.append(path)
+                normalized_issues.append(
+                    _fallback_lifecycle_issue(
+                        code="unlisted_changed_file",
+                        path=path,
+                        message=message,
+                    )
+                )
+            else:
+                context_issues.append(message)
+                normalized_issues.append(
+                    _fallback_lifecycle_issue(
+                        code="lifecycle_context_issue",
+                        path="",
+                        message=message,
+                    )
+                )
+    return (
+        {
+            "unlistedChangedFiles": unlisted,
+            "protectedWorkflowFiles": protected,
+            "contextIssues": context_issues,
+            "lifecycleMessages": list(result.blockers),
+        },
+        normalized_issues,
+    )
 
 
 def _check_context_sources(repo_root: Path, task_dir: Path) -> list[dict[str, Any]]:
@@ -214,6 +318,124 @@ def _is_code_file(path: str) -> bool:
     return Path(path).suffix in CODE_SUFFIXES
 
 
+def _python_function_lengths(content: str) -> dict[str, dict[str, int]]:
+    try:
+        tree = ast.parse(content.lstrip("\ufeff"))
+    except SyntaxError:
+        return {}
+
+    functions: dict[str, dict[str, int]] = {}
+
+    def visit_nodes(nodes: list[ast.stmt], prefix: tuple[str, ...]) -> None:
+        for node in nodes:
+            if isinstance(node, ast.ClassDef):
+                visit_nodes(node.body, (*prefix, node.name))
+                continue
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                end_lineno = getattr(node, "end_lineno", node.lineno)
+                name = ".".join((*prefix, node.name))
+                functions[name] = {
+                    "line": node.lineno,
+                    "lines": end_lineno - node.lineno + 1,
+                }
+                visit_nodes(node.body, (*prefix, node.name))
+
+    visit_nodes(tree.body, ())
+    return functions
+
+
+def _git_baseline_text(repo_root: Path, path: str) -> str | None:
+    result = subprocess.run(
+        ["git", "show", f"HEAD:{path}"],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+    return result.stdout
+
+
+def _complexity_signals(repo_root: Path, changed_files: list[str]) -> list[dict[str, str]]:
+    signals: list[dict[str, str]] = []
+    for raw_path in changed_files:
+        normalized = raw_path.replace("\\", "/").removeprefix("./")
+        if Path(normalized).suffix != ".py":
+            continue
+        full_path = repo_root / normalized
+        if not full_path.is_file():
+            continue
+        try:
+            current_functions = _python_function_lengths(
+                full_path.read_text(encoding="utf-8")
+            )
+        except (OSError, UnicodeDecodeError):
+            continue
+        baseline_text = _git_baseline_text(repo_root, normalized)
+        baseline_functions = (
+            _python_function_lengths(baseline_text) if baseline_text is not None else {}
+        )
+        for function_name, current in sorted(current_functions.items()):
+            current_lines = current["lines"]
+            if current_lines <= FUNCTION_LINE_SOFT_LIMIT:
+                continue
+            baseline_lines = baseline_functions.get(function_name, {}).get("lines", 0)
+            budget_baseline = (
+                baseline_lines if baseline_lines > FUNCTION_LINE_SOFT_LIMIT else 0
+            )
+            if budget_baseline == 0:
+                code = "complexity_new_long_function"
+                message = (
+                    f"Function {function_name} is {current_lines} lines; "
+                    f"soft budget is {FUNCTION_LINE_SOFT_LIMIT} lines."
+                )
+            elif current_lines > baseline_lines:
+                code = "complexity_hotspot_grew"
+                message = (
+                    f"Function {function_name} grew from {baseline_lines} "
+                    f"to {current_lines} lines; split responsibilities or record intent."
+                )
+            else:
+                code = "complexity_existing_hotspot"
+                message = (
+                    f"Existing hotspot {function_name} remains {current_lines} lines; "
+                    "warning only for reviewer awareness."
+                )
+            signals.append(
+                {
+                    "code": code,
+                    "file": normalized,
+                    "function": function_name,
+                    "line": str(current["line"]),
+                    "baselineLines": str(budget_baseline),
+                    "currentLines": str(current_lines),
+                    "limitLines": str(FUNCTION_LINE_SOFT_LIMIT),
+                    "reason": message,
+                }
+            )
+    return signals
+
+
+def _complexity_issues(signals: list[dict[str, str]]) -> list[dict[str, str]]:
+    return [
+        _normalized_issue(
+            code=signal["code"],
+            severity="warning",
+            path=signal["file"],
+            message=signal["reason"],
+            source="complexity",
+            function=signal["function"],
+            line=signal["line"],
+            baselineLines=signal["baselineLines"],
+            currentLines=signal["currentLines"],
+            limitLines=signal["limitLines"],
+        )
+        for signal in signals
+    ]
+
+
 def _python_test_names(content: str) -> list[str]:
     try:
         tree = ast.parse(content.lstrip("\ufeff"))
@@ -284,7 +506,28 @@ def _test_intent_signals(repo_root: Path, changed_files: list[str]) -> dict[str,
     }
 
 
-def _verification_hints(changed_files: list[str], test_signals: dict[str, Any]) -> list[str]:
+def _test_intent_issues(test_signals: dict[str, Any]) -> list[dict[str, str]]:
+    issues: list[dict[str, str]] = []
+    for signal in test_signals["shallowAssertionSignals"]:
+        issues.append(
+            _normalized_issue(
+                code="shallow_assertion_signal",
+                severity="warning",
+                path=str(signal.get("file") or ""),
+                message=str(signal.get("reason") or "shallow test intent signal"),
+                source="test-intent",
+                testName=str(signal.get("testName") or ""),
+                signal=str(signal.get("signal") or ""),
+            )
+        )
+    return issues
+
+
+def _verification_hints(
+    changed_files: list[str],
+    test_signals: dict[str, Any],
+    complexity_signals: list[dict[str, str]],
+) -> list[str]:
     hints: list[str] = []
     code_files = [
         path
@@ -298,6 +541,8 @@ def _verification_hints(changed_files: list[str], test_signals: dict[str, Any])
         )
     if test_signals["shallowAssertionSignals"]:
         hints.append("Review shallowAssertionSignals before accepting test intent.")
+    if complexity_signals:
+        hints.append("Review complexity soft-budget warnings before accepting large functions.")
     return hints
 
 
@@ -306,6 +551,12 @@ def build_report(repo_root: Path, task_dir: Path) -> dict[str, Any]:
     changed_files = collect_changed_paths(repo_root)
     dev_type = _infer_dev_type(task_data, changed_files)
     test_signals = _test_intent_signals(repo_root, changed_files)
+    complexity_signals = _complexity_signals(repo_root, changed_files)
+    scope_facts, scope_issues = _scope_facts_with_issues(
+        repo_root,
+        task_dir,
+        allow_spec_file_modifications=is_main_session(repo_root),
+    )
     return {
         "reportVersion": 1,
         "mode": "advisory",
@@ -315,11 +566,12 @@ def build_report(repo_root: Path, task_dir: Path) -> dict[str, Any]:
             "devType": dev_type,
         },
         "changedFiles": changed_files,
-        "scopeFacts": _scope_facts(
-            repo_root,
-            task_dir,
-            allow_spec_file_modifications=is_main_session(repo_root),
-        ),
+        "scopeFacts": scope_facts,
+        "normalizedIssues": [
+            *scope_issues,
+            *_test_intent_issues(test_signals),
+            *_complexity_issues(complexity_signals),
+        ],
         "specSources": _spec_sources(
             repo_root,
             task_dir,
@@ -327,7 +579,12 @@ def build_report(repo_root: Path, task_dir: Path) -> dict[str, Any]:
             changed_files=changed_files,
         ),
         "testIntentSignals": test_signals,
-        "verificationHints": _verification_hints(changed_files, test_signals),
+        "complexitySignals": complexity_signals,
+        "verificationHints": _verification_hints(
+            changed_files,
+            test_signals,
+            complexity_signals,
+        ),
         "notes": [
             "This report is advisory and does not mutate task state.",
             "Do not treat natural-language spec review as a runtime lifecycle gate.",

package/template/skills/test-first/SKILL.md

@@ -9,9 +9,13 @@ Use this Skill to practice test-first implementation inside the active cowork-fl
 
 ## Trigger
 
-Use for behavior, state, protocol, CLI, data-format, permission, or error-handling changes when a failing test is the clearest way to pin expected behavior. For docs/comment/format-only work, skip TDD and run the smallest relevant verification command.
+Use for behavior, state, protocol, CLI, data-format, permission, or error-handling changes. Behavior changes default to a red test before implementation: first pin the expected behavior with the smallest meaningful failing test, then make the minimum code change needed to turn it green.
 
-## Red-Green-Refactor
+For docs/comment/format-only work, skip TDD and run the smallest relevant verification command.
+
+## Red test before implementation
+
+Do not modify production code before the red test for a behavior change unless a documented exception applies. The normal path is:
 
 1. Map the behavior to a `decision-anchor.md` acceptance ID when one exists.
 2. Write the smallest meaningful test that fails because the target behavior is missing or wrong.
@@ -20,6 +24,17 @@ Use for behavior, state, protocol, CLI, data-format, permission, or error-handli
 5. Run the same test to green, then run directly dependent tests.
 6. Refactor only after the behavior is pinned green.
 
+Tests added after implementation are regression tests, not evidence that a red-green cycle happened. They may still be useful, but do not describe them as test-first work unless the red failure was observed before the implementation change.
+
+## Exceptions
+
+If red-first is skipped, state the reason before or with the implementation summary and name the substitute verification. Acceptable reasons are limited to:
+
+- docs/comment/format-only changes where no behavior changes.
+- an existing precise failing test already reproduces the target behavior.
+- the behavior cannot be reproduced locally after a focused attempt; describe the attempted command and observed result.
+- no usable test entry point exists; explain the gap and use the narrowest manual or static verification available.
+
 ## Output
 
 Do not write TDD evidence objects to `check.jsonl`, do not create `tdd.jsonl`, and do not create TDD exemption records. Report the exact red/green commands in the agent response or task review narrative when useful; the workflow does not validate them as separate evidence artifacts.
@@ -32,6 +47,6 @@ Do not use these excuses to skip meaningful behavior tests:
 |---|---|---|
 | "This logic is simple, no test needed" | Simple logic still breaks on edge cases and later edits. | Write the smallest behavior test, or state the concrete non-test verification used. |
 | "Other tests already cover this" | Invisible coverage is hard to review. | Name the exact existing test command and behavior it covers. |
-| "I'll add tests after implementation" | Post-implementation tests can miss the original failure mode. | Prefer red first, then green when behavior is new or risky. |
+| "I'll add tests after implementation" | Post-implementation tests can miss the original failure mode and is not test-first. | Red first, then green; if this already happened, call the new test a regression test. |
 | "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/test-first/manifest.json

@@ -3,10 +3,14 @@
   "skill": "test-first",
   "context": [
     {
-      "contexts": ["implement", "check"],
-      "devTypes": ["test"],
-      "pathPatterns": ["test/**", "tests/**", "**/*.test.js", "**/*_test.py"],
-      "reason": "Auto-routed Test First guide"
+      "contexts": [
+        "implement",
+        "check"
+      ],
+      "devTypes": [
+        "*"
+      ],
+      "reason": "Auto-routed context-only red-green guide"
     }
   ]
 }

package/template/.cowork-flow/changes/archive/.gitkeep

@@ -1 +0,0 @@
-