cowork-flow 0.0.48 → 0.0.49

package/template/.cowork-flow/scripts/adapters/cli/task.py

@@ -38,8 +38,6 @@ from adapters.cli.task_context_commands import (
 from adapters.cli.task_create_command import cmd_create, ensure_tasks_dir
 from adapters.cli import task_navigation
 from adapters.cli.task_lifecycle_commands import (
-    _optional_readiness_blockers,
-    _task_start_blockers,
     cmd_complete,
     cmd_current,
     cmd_finish,

package/template/.cowork-flow/scripts/adapters/cli/task_archive_commands.py

@@ -94,6 +94,17 @@ def _archive_error_message(task_name: str, error: TaskArchiveError) -> str:
     return f"Failed to archive task: {error.detail}"
 
 
+def _print_rollback_issues(error: TaskArchiveError) -> None:
+    if not error.rollback_issues:
+        return
+    print("Rollback issues:", file=sys.stderr)
+    for issue in error.rollback_issues:
+        print(
+            f"- {issue.stage}: {issue.path} ? {issue.detail}",
+            file=sys.stderr,
+        )
+
+
 def _archive_task(repo_root, task_name: str, task_dir):
     try:
         return TaskArchiveService(repo_root).archive(
@@ -103,6 +114,7 @@ def _archive_task(repo_root, task_name: str, task_dir):
     except TaskArchiveError as error:
         message = _archive_error_message(task_name, error)
         print(colored(f"Error: {message}", Colors.RED), file=sys.stderr)
+        _print_rollback_issues(error)
         return None
 
 

package/template/.cowork-flow/scripts/adapters/cli/task_lifecycle_commands.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 
 import argparse
 import sys
-from datetime import datetime
 from pathlib import Path
 
 if __package__:
@@ -14,13 +13,7 @@ if __package__:
 else:
     import _bootstrap  # noqa: F401
 
-from adapters.cli.task_context_commands import PLANNED_FILE_HINT
-from services.task_context import TaskContextService
-from services.task_lifecycle import (
-    LifecyclePreflightFailure,
-    LifecycleResult,
-    TaskLifecycleService,
-)
+from services.task_lifecycle import LifecycleResult, TaskLifecycleService
 from adapters.cli.task_support import (
     Colors,
     colored,
@@ -33,13 +26,7 @@ from infra.paths import (
     FILE_TASK_JSON,
     get_repo_root,
 )
-from runtime.session_state import clear_active_task, get_active_task, is_main_session
-
-
-def _allow_spec_file_modifications(repo_root: Path, execution_context) -> bool:
-    if execution_context.is_worker or execution_context.is_subagent:
-        return False
-    return is_main_session(repo_root)
+from runtime.session_state import clear_active_task, get_active_task
 
 
 def _report_check_block(title: str, blockers: tuple[str, ...]) -> int:
@@ -116,102 +103,8 @@ def _resolve_status_task_dir(
     return task_dir
 
 
-def _task_start_blockers(task_dir: Path) -> list[str]:
-    return list(
-        TaskContextService(get_repo_root(task_dir)).start_blockers(task_dir)
-    )
-
-
-def _task_context_validation_issues(
-    task_dir: Path,
-    repo_root: Path,
-    quiet: bool = False,
-) -> list[str]:
-    del quiet
-    return list(
-        TaskContextService(repo_root).validation_issue_summaries(task_dir)
-    )
-
-
-def _refresh_task_artifact_placeholders(
-    task_dir: Path,
-    repo_root: Path,
-) -> list[str]:
-    service = TaskContextService(repo_root)
-    service.ensure_task_artifact_placeholders(task_dir)
-    return _task_context_validation_issues(task_dir, repo_root)
-
-
-def _optional_readiness_blockers(
-    repo_root: Path,
-    task_dir: Path,
-) -> list[str]:
-    try:
-        from services.readiness import task_readiness_blockers
-    except Exception:
-        return []
-    try:
-        blockers = task_readiness_blockers(repo_root, task_dir)
-    except Exception:
-        return [
-            "readiness check failed; run task next <dir> --validate and inspect "
-            "task readiness artifacts"
-        ]
-    return [str(blocker) for blocker in blockers if str(blocker).strip()]
-
-
-def _start_preflight(
-    task_dir: Path,
-    repo_root: Path,
-) -> LifecyclePreflightFailure | None:
-    blockers = _task_start_blockers(task_dir)
-    if blockers:
-        return LifecyclePreflightFailure(
-            code="TASK-START-001",
-            title="Task is not ready to start yet",
-            blockers=tuple(blockers),
-            hint=(
-                "write decision-anchor.md and required context JSONL files, "
-                "then retry `task next <dir> --run`"
-            ),
-        )
-
-    validation_issues = _task_context_validation_issues(
-        task_dir,
-        repo_root,
-    )
-    if validation_issues:
-        validation_issues = _refresh_task_artifact_placeholders(task_dir, repo_root)
-    if validation_issues:
-        return LifecyclePreflightFailure(
-            code="TASK-CONTEXT-001",
-            title="Task context validation failed",
-            blockers=tuple(validation_issues),
-            hint=(
-                "run ./.cowork-flow/run task next <dir> --validate and fix the "
-                f"reported issues. {PLANNED_FILE_HINT}"
-            ),
-        )
-
-    readiness_blockers = _optional_readiness_blockers(
-        repo_root,
-        task_dir,
-    )
-    if readiness_blockers:
-        return LifecyclePreflightFailure(
-            code="TASK-READINESS-001",
-            title="Task readiness failed",
-            blockers=tuple(readiness_blockers),
-            hint=(
-                "run ./.cowork-flow/run task next <dir> and complete the "
-                "reported readiness artifacts"
-            ),
-        )
-    return None
-
-
 def _report_lifecycle_preflight(
-    result: LifecyclePreflightFailure | LifecycleResult,
+    result: LifecycleResult,
 ) -> int:
     print(colored(f"Error: {result.title}", Colors.RED), file=sys.stderr)
     for blocker in result.blockers:
@@ -264,11 +157,11 @@ def _resolve_start_task(
 def _run_auto_start(
     args: argparse.Namespace,
     full_path: Path,
-    preflight,
+    service: TaskLifecycleService,
 ) -> int:
-    failure = preflight(full_path)
-    if failure is not None:
-        return _report_lifecycle_preflight(failure)
+    readiness = service.start_readiness(full_path)
+    if not readiness.ok:
+        return _report_lifecycle_preflight(readiness)
     from adapters.cli.batch_mode import run_batch_entry
 
     return run_batch_entry(get_repo_root(), full_path, args)
@@ -276,9 +169,7 @@ def _run_auto_start(
 
 def _report_start_failure(
     result: LifecycleResult,
-    service: TaskLifecycleService,
 ) -> int:
-    del service
     if result.title:
         return _report_lifecycle_preflight(result)
     if result.code == "LIFECYCLE-TRANSITION-001":
@@ -354,21 +245,17 @@ def cmd_start(args: argparse.Namespace) -> int:
     if full_path is None:
         return 1
 
-    def preflight(
-        task_dir: Path,
-    ) -> LifecyclePreflightFailure | None:
-        return _start_preflight(task_dir, repo_root)
-
+    service = TaskLifecycleService(repo_root)
     if getattr(args, "auto", False):
-        return _run_auto_start(args, full_path, preflight)
+        return _run_auto_start(args, full_path, service)
 
-    service = TaskLifecycleService(repo_root)
-    result = service.start(full_path, preflight=preflight)
+    result = service.start(full_path)
     if not result.ok:
-        return _report_start_failure(result, service)
+        return _report_start_failure(result)
 
     _report_start_success(result, repo_root, full_path)
-    _run_hooks("after_start", full_path / FILE_TASK_JSON, repo_root)
+    if "after_start" in getattr(result, "emitted_events", ()):
+        _run_hooks("after_start", full_path / FILE_TASK_JSON, repo_root)
     return 0
 
 
@@ -383,10 +270,7 @@ def cmd_review(args: argparse.Namespace) -> int:
     service = TaskLifecycleService(repo_root)
     result = service.review(
         task_dir,
-        allow_spec_file_modifications=_allow_spec_file_modifications(
-            repo_root,
-            execution_context,
-        ),
+        execution_context=execution_context,
     )
     if not result.ok:
         if result.code == "LIFECYCLE-TRANSITION-001":
@@ -415,6 +299,7 @@ def cmd_review(args: argparse.Namespace) -> int:
 def cmd_complete(args: argparse.Namespace) -> int:
     """Mark a task completed after final check."""
     repo_root = get_repo_root()
+    execution_context = execution_context_from_namespace(args)
     task_dir = _resolve_status_task_dir(args, repo_root)
     if task_dir is None:
         return 1
@@ -422,8 +307,7 @@ def cmd_complete(args: argparse.Namespace) -> int:
     service = TaskLifecycleService(repo_root)
     result = service.complete(
         task_dir,
-        completed_at=datetime.now().strftime("%Y-%m-%d"),
-        allow_spec_file_modifications=is_main_session(repo_root),
+        execution_context=execution_context,
     )
     if not result.ok:
         if result.code == "LIFECYCLE-TRANSITION-001":
@@ -475,7 +359,8 @@ def cmd_finish(args: argparse.Namespace) -> int:
             Colors.GREEN,
         )
     )
-    if task_json_path.is_file():
+    emitted_events = ("after_finish",) if task_json_path.is_file() else ()
+    if "after_finish" in emitted_events:
         _run_hooks("after_finish", task_json_path, repo_root)
     return 0
 

package/template/.cowork-flow/scripts/adapters/cli/task_navigation.py

@@ -165,6 +165,76 @@ def _attach_recovery(payload: dict[str, object], repo_root: Path) -> dict[str, o
     return payload
 
 
+def _add_read_first_entry(
+    entries: list[dict[str, str]],
+    seen: set[str],
+    file_path: str,
+    reason: str,
+) -> None:
+    normalized = file_path.replace("\\", "/").strip()
+    if not normalized or normalized in seen:
+        return
+    seen.add(normalized)
+    entry = {"file": normalized}
+    if reason.strip():
+        entry["reason"] = reason.strip()
+    entries.append(entry)
+
+
+def _attach_implement_read_first(
+    payload: dict[str, object],
+    repo_root: Path,
+    task_path: str | None,
+) -> dict[str, object]:
+    action = payload.get("action")
+    if not isinstance(action, dict) or action.get("id") != "implement_change":
+        return payload
+    if not task_path:
+        return payload
+
+    task_dir = repo_root / task_path
+    if not task_dir.is_dir():
+        return payload
+
+    entries: list[dict[str, str]] = []
+    seen: set[str] = set()
+    task_prefix = task_path.rstrip("/")
+    _add_read_first_entry(
+        entries,
+        seen,
+        f"{task_prefix}/decision-anchor.md",
+        "Task decision anchor",
+    )
+    try:
+        task_data = TaskRepository(repo_root).load(task_dir)
+    except TaskRepositoryError:
+        task_data = {}
+    meta = task_data.get("meta") if isinstance(task_data, dict) else None
+    plan_file = meta.get("planFile") if isinstance(meta, dict) else None
+    if isinstance(plan_file, str):
+        _add_read_first_entry(entries, seen, plan_file, "Linked implementation plan")
+    _add_read_first_entry(
+        entries,
+        seen,
+        f"{task_prefix}/implement.jsonl",
+        "Implementation context index",
+    )
+    for context_entry in TaskContextService(repo_root).entries(task_dir, "implement"):
+        file_value = context_entry.get("file")
+        if not isinstance(file_value, str):
+            continue
+        reason = context_entry.get("reason")
+        _add_read_first_entry(
+            entries,
+            seen,
+            file_value,
+            reason if isinstance(reason, str) else "Implementation context",
+        )
+    if entries:
+        payload["readFirst"] = entries
+    return payload
+
+
 def _print_recovery(payload: dict[str, object]) -> None:
     recovery = payload.get("recovery")
     if not isinstance(recovery, dict):
@@ -206,20 +276,24 @@ def build_navigation_payload(
     blockers: list[str],
     active_target: bool,
     task_path: str | None = None,
+    repo_root: Path | None = None,
 ) -> dict[str, object]:
     intent = getattr(args, "intent", None) or _default_intent(
         status,
         blockers,
         active_target,
     )
-    return route_request(
+    root = repo_root if repo_root is not None else get_repo_root()
+    payload = route_request(
         status=status,
         intent=intent,
         context=_routing_context(args),
         blockers=blockers,
         active_target=active_target,
         task_path=task_path,
+        repo_root=root,
     )
+    return _attach_implement_read_first(payload, root, task_path)
 
 
 def _print_json_route(
@@ -229,6 +303,7 @@ def _print_json_route(
     blockers: list[str],
     active_target: bool,
     task_path: str | None = None,
+    repo_root: Path | None = None,
 ) -> None:
     payload = build_navigation_payload(
         args=args,
@@ -236,6 +311,7 @@ def _print_json_route(
         blockers=blockers,
         active_target=active_target,
         task_path=task_path,
+        repo_root=repo_root,
     )
     print(json.dumps(payload, ensure_ascii=False, sort_keys=False))
 
@@ -274,6 +350,7 @@ def _navigation_target(args, repo_root: Path, structured: bool):
             blockers=[],
             active_target=False,
             task_path=None,
+            repo_root=repo_root,
         )
         _attach_recovery(payload, repo_root)
         print(json.dumps(payload, ensure_ascii=False, sort_keys=False))
@@ -286,6 +363,7 @@ def _navigation_target(args, repo_root: Path, structured: bool):
             task_path=None,
             blockers=[],
             active_target=False,
+            repo_root=repo_root,
         )
         _attach_recovery(payload, repo_root)
         _print_text_payload(payload)
@@ -302,6 +380,7 @@ def _print_stale_route(args, task_path: str, source: str, active_target: bool) -
             blockers=blockers,
             active_target=active_target,
             task_path=task_path,
+            repo_root=get_repo_root(),
         )
         return
     print("Status: stale")
@@ -332,6 +411,7 @@ def _print_text_route(
         task_path=task_path,
         blockers=blockers,
         active_target=active_target,
+        repo_root=get_repo_root(),
     )
     _print_text_payload(payload)
 
@@ -361,6 +441,7 @@ def cmd_next(args) -> int:
             blockers=blockers,
             active_target=active_target,
             task_path=task_path,
+            repo_root=repo_root,
         )
         return 0