cowork-flow 0.0.47 → 0.0.49

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

@@ -98,6 +98,9 @@ def _host_context_prefix(host: str) -> str:
 def _suggest_host_context_key(host: str, runtime_context_id: str) -> str:
     return f"{_host_context_prefix(host)}_{runtime_context_id}"
 
+def _print_runtime_error(error: RuntimeContextError) -> None:
+    print(f"Error: {error.code}: {error.detail}", file=sys.stderr)
+
 def _resolve_agent_type(role: str, agent_type: str | None) -> tuple[str, str]:
     normalized_role = role.strip()
     requested = agent_type.strip() if isinstance(agent_type, str) else ""
@@ -178,7 +181,7 @@ def cmd_init(args: argparse.Namespace) -> int:
             context,
         )
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     logical_context_key = initialized.logical_context_key
     host_context_key = _suggest_host_context_key(host, runtime_context_id)
@@ -244,7 +247,7 @@ def cmd_update(args: argparse.Namespace) -> int:
             note=args.note,
         )
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     if context is None:
         print(f"Error: subagent not found: {args.subagent_id}", file=sys.stderr)
@@ -261,7 +264,7 @@ def cmd_bind(args: argparse.Namespace) -> int:
             args.context_key,
         )
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     if context is None:
         print(f"Error: cannot bind runtime context: {args.subagent_id}", file=sys.stderr)
@@ -275,7 +278,7 @@ def cmd_close(args: argparse.Namespace) -> int:
     try:
         closed = RuntimeContextService(repo_root).close(args.subagent_id)
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     if not closed:
         print(f"Error: subagent not found: {args.subagent_id}", file=sys.stderr)

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

@@ -1,13 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""Task workflow entry point and lifecycle adapters."""
+"""Task workflow entry point and CLI command composition."""
 
 from __future__ import annotations
 
 import argparse
 import sys
-from datetime import datetime
-from pathlib import Path
 
 if __package__:
     from . import _bootstrap as _bootstrap  # noqa: F401
@@ -15,8 +13,6 @@ else:
     import _bootstrap  # noqa: F401
 
 from services.task_context import (
-    PLANNED_FILE_HINT,
-    TaskContextService,
     detect_installed_platforms as _detect_installed_platforms,
     discover_spec_files as _discover_spec_files,
     get_check_context,
@@ -31,11 +27,6 @@ from services.task_context import (
     use_claude_skill_context as _use_claude_skill_context,
     write_jsonl as _write_jsonl,
 )
-from services.task_lifecycle import (
-    LifecyclePreflightFailure,
-    LifecycleResult,
-    TaskLifecycleService,
-)
 from adapters.cli.task_archive_commands import cmd_archive
 from adapters.cli.task_context_commands import (
     cmd_add_planned_file,
@@ -46,6 +37,13 @@ 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 (
+    cmd_complete,
+    cmd_current,
+    cmd_finish,
+    cmd_review,
+    cmd_start,
+)
 from adapters.cli.task_parser import build_parser, show_usage
 from adapters.cli.task_next_runner import (
     NextActionHandlers,
@@ -56,7 +54,6 @@ from adapters.cli.task_support import (
     Colors,
     colored,
     resolve_task_dir as _resolve_task_dir,
-    run_hooks as _run_hooks,
 )
 from adapters.cli.task_tree_commands import (
     cmd_add_subtask,
@@ -67,479 +64,6 @@ from adapters.cli.task_tree_commands import (
 )
 from adapters.cli.execution_context_args import execution_context_from_namespace
 from adapters.cli.execution_resume import worker_command_block_message
-from infra.paths import (
-    DIR_WORKFLOW,
-    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)
-
-
-def _report_check_block(title: str, blockers: tuple[str, ...]) -> int:
-    print(colored(f"Error: {title}", Colors.RED), file=sys.stderr)
-    for blocker in blockers:
-        print(f"  - {blocker}", file=sys.stderr)
-    return 1
-
-
-def _print_transition_blockers(blockers: list[str]) -> None:
-    print(
-        colored("Error: Task state transition blocked", Colors.RED),
-        file=sys.stderr,
-    )
-    for blocker in blockers:
-        print(f"  - {blocker}", file=sys.stderr)
-
-
-def _display_task_path(repo_root: Path, task_dir: Path) -> str:
-    try:
-        return task_dir.resolve().relative_to(repo_root.resolve()).as_posix()
-    except ValueError:
-        return str(task_dir)
-
-
-def _resolve_status_task_dir(
-    args: argparse.Namespace,
-    repo_root: Path,
-) -> Path | None:
-    target_input = getattr(args, "dir", None)
-    if target_input:
-        task_dir = _resolve_task_dir(target_input, repo_root)
-    else:
-        active = get_active_task(repo_root)
-        if not active.context_key:
-            print(
-                colored(
-                    "Error: Missing session context. Set "
-                    "COWORK_FLOW_CONTEXT_ID or pass a task dir.",
-                    Colors.RED,
-                ),
-                file=sys.stderr,
-            )
-            return None
-        if not active.task_path:
-            print(
-                colored(
-                    "Error: No active task set for this session",
-                    Colors.RED,
-                ),
-                file=sys.stderr,
-            )
-            return None
-        task_dir = repo_root / active.task_path
-
-    if not task_dir.is_dir():
-        print(
-            colored(
-                f"Error: Task not found: {target_input or task_dir}",
-                Colors.RED,
-            ),
-            file=sys.stderr,
-        )
-        return None
-    if not (task_dir / FILE_TASK_JSON).is_file():
-        print(
-            colored(
-                f"Error: task.json not found: {task_dir}",
-                Colors.RED,
-            ),
-            file=sys.stderr,
-        )
-        return None
-    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 "
-            "linked change"
-        ]
-    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,
-) -> int:
-    print(colored(f"Error: {result.title}", Colors.RED), file=sys.stderr)
-    for blocker in result.blockers:
-        print(f"  - {blocker}", file=sys.stderr)
-    if result.hint:
-        print(f"Hint: {result.hint}", file=sys.stderr)
-    return 1
-
-
-def _report_lifecycle_repository_error(
-    result: LifecycleResult,
-) -> int:
-    error = result.repository_error
-    action = (
-        "read"
-        if error is not None and error.code.startswith("TASK-LOAD-")
-        else "write"
-    )
-    task_json = result.task_dir / FILE_TASK_JSON
-    print(
-        colored(
-            f"Error: Failed to {action} task metadata: {task_json}",
-            Colors.RED,
-        ),
-        file=sys.stderr,
-    )
-    return 1
-
-
-def _resolve_start_task(
-    task_input: str,
-    repo_root: Path,
-) -> Path | None:
-    full_path = _resolve_task_dir(task_input, repo_root)
-    if full_path.is_dir():
-        return full_path
-    print(
-        colored(
-            f"Error: Task not found: {task_input}",
-            Colors.RED,
-        )
-    )
-    print(
-        "Hint: Use task name (e.g., 'my-task') or full path "
-        f"(e.g., '{DIR_WORKFLOW}/tasks/01-31-my-task')"
-    )
-    return None
-
-
-def _run_auto_start(
-    args: argparse.Namespace,
-    full_path: Path,
-    preflight,
-) -> int:
-    failure = preflight(full_path)
-    if failure is not None:
-        return _report_lifecycle_preflight(failure)
-    from adapters.cli.batch_mode import run_batch_entry
-
-    return run_batch_entry(get_repo_root(), full_path, args)
-
-
-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":
-        _print_transition_blockers(list(result.blockers))
-        return 1
-    if result.code == "LIFECYCLE-CHECK-001":
-        return _report_check_block(
-            "Lifecycle checks blocked start_task action",
-            result.blockers,
-        )
-    if result.code == "LIFECYCLE-CONTEXT-001":
-        return _report_missing_session_context()
-    if result.repository_error is not None:
-        return _report_lifecycle_repository_error(result)
-    print(
-        colored("Error: Task lifecycle failed", Colors.RED),
-        file=sys.stderr,
-    )
-    return 1
-
-
-def _report_missing_session_context() -> int:
-    print(
-        colored(
-            "Error: Missing session context. Set "
-            "COWORK_FLOW_CONTEXT_ID or run inside a "
-            "supported host session.",
-            Colors.RED,
-        ),
-        file=sys.stderr,
-    )
-    return 1
-
-
-def _report_start_success(
-    result: LifecycleResult,
-    repo_root: Path,
-    full_path: Path,
-) -> None:
-    task_dir = result.active_task_path or _display_task_path(
-        repo_root,
-        full_path,
-    )
-    print(
-        colored(
-            f"[OK] Active session task set to: {task_dir}",
-            Colors.GREEN,
-        )
-    )
-    print()
-    print(
-        colored(
-            "Fixed agents will load context from this task's jsonl files.",
-            Colors.BLUE,
-        )
-    )
-
-
-def cmd_start(args: argparse.Namespace) -> int:
-    """Set the active task for this session."""
-    repo_root = get_repo_root()
-    task_input = args.dir
-    if not task_input:
-        print(
-            colored(
-                "Error: task directory or name required",
-                Colors.RED,
-            )
-        )
-        return 1
-
-    full_path = _resolve_start_task(task_input, repo_root)
-    if full_path is None:
-        return 1
-
-    def preflight(
-        task_dir: Path,
-    ) -> LifecyclePreflightFailure | None:
-        return _start_preflight(task_dir, repo_root)
-
-    if getattr(args, "auto", False):
-        return _run_auto_start(args, full_path, preflight)
-
-    service = TaskLifecycleService(repo_root)
-    result = service.start(full_path, preflight=preflight)
-    if not result.ok:
-        return _report_start_failure(result, service)
-
-    _report_start_success(result, repo_root, full_path)
-    _run_hooks("after_start", full_path / FILE_TASK_JSON, repo_root)
-    return 0
-
-
-def cmd_review(args: argparse.Namespace) -> int:
-    """Mark a task ready for 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
-
-    service = TaskLifecycleService(repo_root)
-    result = service.review(
-        task_dir,
-        allow_spec_file_modifications=_allow_spec_file_modifications(
-            repo_root,
-            execution_context,
-        ),
-    )
-    if not result.ok:
-        if result.code == "LIFECYCLE-TRANSITION-001":
-            _print_transition_blockers(list(result.blockers))
-            return 1
-        if result.code == "LIFECYCLE-CHECK-001":
-            return _report_check_block(
-                "Lifecycle checks blocked review",
-                result.blockers,
-            )
-        if result.repository_error is not None:
-            return _report_lifecycle_repository_error(result)
-        return 1
-
-    task_path = _display_task_path(repo_root, task_dir)
-    print(
-        colored(
-            f"[OK] Task marked for check: {task_path}",
-            Colors.GREEN,
-        )
-    )
-    print(f"Next: ./.cowork-flow/run task next {task_path}")
-    return 0
-
-
-def cmd_complete(args: argparse.Namespace) -> int:
-    """Mark a task completed after final check."""
-    repo_root = get_repo_root()
-    task_dir = _resolve_status_task_dir(args, repo_root)
-    if task_dir is None:
-        return 1
-
-    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),
-    )
-    if not result.ok:
-        if result.code == "LIFECYCLE-TRANSITION-001":
-            _print_transition_blockers(list(result.blockers))
-            print(
-                "Hint: run ./.cowork-flow/run task next <task-dir> "
-                "--run --intent review to mark the task ready for check",
-                file=sys.stderr,
-            )
-            return 1
-        if result.code == "LIFECYCLE-CHECK-001":
-            return _report_check_block(
-                "Lifecycle checks blocked completion",
-                result.blockers,
-            )
-        if result.repository_error is not None:
-            return _report_lifecycle_repository_error(result)
-        return 1
-
-    task_path = _display_task_path(repo_root, task_dir)
-    print(
-        colored(
-            f"[OK] Task marked completed: {task_path}",
-            Colors.GREEN,
-        )
-    )
-    print(f"Next: ./.cowork-flow/run task next {task_path}")
-    return 0
-
-
-def cmd_finish(args: argparse.Namespace) -> int:
-    """Clear the active task for this session."""
-    repo_root = get_repo_root()
-    active = get_active_task(repo_root)
-    if not active.task_path:
-        print(
-            colored(
-                "No active task set for this session",
-                Colors.YELLOW,
-            )
-        )
-        return 0
-
-    task_json_path = repo_root / active.task_path / FILE_TASK_JSON
-    clear_active_task(repo_root)
-    print(
-        colored(
-            f"[OK] Cleared active session task (was: {active.task_path})",
-            Colors.GREEN,
-        )
-    )
-    if task_json_path.is_file():
-        _run_hooks("after_finish", task_json_path, repo_root)
-    return 0
-
-
-def cmd_current(args: argparse.Namespace) -> int:
-    """Show the active task for this session."""
-    repo_root = get_repo_root()
-    active = get_active_task(repo_root)
-    if not active.context_key:
-        print(
-            colored(
-                "Error: Missing session context. Set "
-                "COWORK_FLOW_CONTEXT_ID or run inside a "
-                "supported host session.",
-                Colors.RED,
-            ),
-            file=sys.stderr,
-        )
-        return 1
-    if not active.task_path:
-        print("Active task: (none)")
-        return 0
-    print(f"Active task: {active.task_path}")
-    print(f"Source: {active.source}:{active.context_key}")
-    return 0
 
 
 def cmd_next(args: argparse.Namespace) -> int: