cowork-flow 0.0.39 → 0.0.40

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

@@ -24,19 +24,18 @@ from common.core.paths import (
     get_repo_root,
 )
 from common.git.git_context import _run_git_command
+from common.task.archive_utils import archive_directory_resumable
 
 
 DONE_STATUSES = ("completed", "done")
 
 
 def is_git_dirty(repo_root) -> bool:
-    try:
-        return _run_git_command(
-            ["status", "--porcelain"],
-            cwd=repo_root,
-        )[0] != 0
-    except (OSError, Exception):
-        return False
+    rc, stdout, _ = _run_git_command(
+        ["status", "--porcelain"],
+        cwd=repo_root,
+    )
+    return rc != 0 or bool(stdout.strip())
 
 
 def linked_active_changes_for_task(repo_root, task_dir) -> list[str]:
@@ -62,9 +61,76 @@ def linked_changes_ready_for_archive(repo_root, slugs: list[str]) -> bool:
     return ready
 
 
+def _linked_change_paths(repo_root, slug: str):
+    source = repo_root / DIR_WORKFLOW / DIR_CHANGES / slug
+    month = datetime.now().astimezone().strftime("%Y-%m")
+    destination = (
+        repo_root
+        / DIR_WORKFLOW
+        / DIR_CHANGES
+        / DIR_ARCHIVE
+        / month
+        / slug
+    )
+    return source, destination
+
+
+def _restore_linked_changes(
+    repo_root,
+    slugs: list[str],
+    metadata: dict[str, bytes],
+) -> bool:
+    restored = True
+    for slug in reversed(slugs):
+        source, destination = _linked_change_paths(repo_root, slug)
+        if destination.is_dir():
+            result = archive_directory_resumable(destination, source)
+            if not result.ok:
+                print(
+                    colored(
+                        f"Error: Failed to restore linked change: {slug}: "
+                        f"{result.message}",
+                        Colors.RED,
+                    ),
+                    file=sys.stderr,
+                )
+                restored = False
+                continue
+        if source.is_dir():
+            try:
+                (source / "change.yaml").write_bytes(metadata[slug])
+            except OSError as error:
+                print(
+                    colored(
+                        f"Error: Failed to restore linked change metadata: "
+                        f"{slug}: {error}",
+                        Colors.RED,
+                    ),
+                    file=sys.stderr,
+                )
+                restored = False
+    return restored
+
+
 def archive_linked_changes(repo_root, slugs: list[str]) -> bool:
     from commands.change import archive_change_by_slug
 
+    metadata: dict[str, bytes] = {}
+    try:
+        for slug in slugs:
+            source, _ = _linked_change_paths(repo_root, slug)
+            metadata[slug] = (source / "change.yaml").read_bytes()
+    except OSError as error:
+        print(
+            colored(
+                f"Error: Failed to snapshot linked change metadata: {error}",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return False
+
+    archived: list[str] = []
     for slug in slugs:
         if archive_change_by_slug(repo_root, slug) is None:
             print(
@@ -74,7 +140,11 @@ def archive_linked_changes(repo_root, slugs: list[str]) -> bool:
                 ),
                 file=sys.stderr,
             )
+            _restore_linked_changes(repo_root, slugs, metadata)
             return False
+        archived.append(slug)
+
+    for slug in archived:
         print(
             colored(f"Archived linked change: {slug}", Colors.GREEN),
             file=sys.stderr,
@@ -111,15 +181,13 @@ def auto_commit_archive(task_name: str, repo_root) -> None:
         print(f"[WARN] Auto-commit failed: {error.strip()}", file=sys.stderr)
 
 
-def cmd_archive(args) -> int:
-    repo_root = get_repo_root()
-    task_name = args.name
+def _resolve_archive_task(repo_root, task_name: str):
     if not task_name:
         print(
             colored("Error: Task name is required", Colors.RED),
             file=sys.stderr,
         )
-        return 1
+        return None
 
     task_dir = resolve_task_dir(task_name, repo_root)
     if not task_dir.is_dir():
@@ -129,46 +197,40 @@ def cmd_archive(args) -> int:
         )
         print("Active tasks:", file=sys.stderr)
         cmd_list(argparse.Namespace(mine=False, status=None))
-        return 1
+        return None
+    return task_dir
 
-    linked_changes = linked_active_changes_for_task(repo_root, task_dir)
-    if linked_changes and not linked_changes_ready_for_archive(
-        repo_root,
-        linked_changes,
-    ):
-        return 1
 
-    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,
+def _archive_error_message(task_name: str, error: TaskArchiveError) -> str:
+    if error.code == "TASK-ARCHIVE-LOAD-001":
+        return f"Task '{task_name}' task.json is unreadable — refusing archive."
+    if error.code == "TASK-ARCHIVE-STATUS-001":
+        status = error.detail.removeprefix("task status is ")
+        return (
+            f"Task '{task_name}' is in status '{status}', not in "
+            f"{DONE_STATUSES}. Run `task complete` first, then retry archive."
         )
+    return f"Failed to archive task: {error.detail}"
+
 
+def _archive_task(repo_root, task_name: str, task_dir, linked_changes: list[str]):
     try:
-        result = TaskArchiveService(repo_root).archive(
+        return TaskArchiveService(repo_root).archive(
             task_dir,
             archived_at=datetime.now().strftime("%Y-%m-%d"),
+            finalize=(
+                lambda: archive_linked_changes(repo_root, linked_changes)
+            )
+            if linked_changes
+            else None,
         )
     except TaskArchiveError as error:
-        if error.code == "TASK-ARCHIVE-LOAD-001":
-            message = (
-                f"Task '{task_name}' task.json is unreadable — refusing archive."
-            )
-        elif error.code == "TASK-ARCHIVE-STATUS-001":
-            status = error.detail.removeprefix("task status is ")
-            message = (
-                f"Task '{task_name}' is in status '{status}', not in "
-                f"{DONE_STATUSES}. Run `task complete` first, then retry archive."
-            )
-        else:
-            message = f"Failed to archive task: {error.detail}"
+        message = _archive_error_message(task_name, error)
         print(colored(f"Error: {message}", Colors.RED), file=sys.stderr)
-        return 1
+        return None
+
 
+def _print_archive_result(result, repo_root) -> None:
     archive_dest = result.destination
     year_month = archive_dest.parent.name
     print(
@@ -178,18 +240,42 @@ def cmd_archive(args) -> int:
         ),
         file=sys.stderr,
     )
-    if linked_changes and not archive_linked_changes(repo_root, linked_changes):
-        return 1
-    if getattr(args, "commit", False):
-        auto_commit_archive(result.task_name, repo_root)
-
     print(
         f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}/"
         f"{year_month}/{result.task_name}"
     )
-    run_hooks(
-        "after_archive",
-        archive_dest / FILE_TASK_JSON,
+    run_hooks("after_archive", archive_dest / FILE_TASK_JSON, repo_root)
+
+
+def cmd_archive(args) -> int:
+    repo_root = get_repo_root()
+    task_name = args.name
+    task_dir = _resolve_archive_task(repo_root, task_name)
+    if task_dir is None:
+        return 1
+
+    linked_changes = linked_active_changes_for_task(repo_root, task_dir)
+    if linked_changes and not linked_changes_ready_for_archive(
         repo_root,
-    )
+        linked_changes,
+    ):
+        return 1
+
+    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,
+        )
+
+    result = _archive_task(repo_root, task_name, task_dir, linked_changes)
+    if result is None:
+        return 1
+
+    if getattr(args, "commit", False):
+        auto_commit_archive(result.task_name, repo_root)
+    _print_archive_result(result, repo_root)
     return 0

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

@@ -25,6 +25,7 @@ USER_INTENTS = (
     "clarify",
     "plan",
     "implement",
+    "archive",
     "review",
     "debug",
     "discuss",
@@ -35,6 +36,7 @@ INTENT_REGISTRY_KEYS = {
     "clarify": "clarify_requirement",
     "plan": "write_plan",
     "implement": "route_workflow",
+    "archive": "route_workflow",
     "review": "route_workflow",
     "debug": "analyze_repeated_failure",
     "discuss": "discuss_options",
@@ -45,11 +47,10 @@ INTENT_OPERATIONS = {
     "clarify": {"edit_planning_artifacts"},
     "plan": {"edit_planning_artifacts"},
     "implement": {
-        "create_task",
-        "start_task",
         "implement_change",
         "execute_delegated_work",
     },
+    "archive": {"archive_task"},
     "review": {"request_review", "verify_change", "complete_task"},
     "debug": {"debug_failure"},
     "discuss": {"discuss_options"},
@@ -204,12 +205,39 @@ def route_request(
     if context not in {"main", "delegated"}:
         raise ValueError(f"unsupported workflow context: {context}")
 
+    route_blockers, operations, intent_allowed, matches = _resolve_route(
+        registry,
+        status=status,
+        intent=intent,
+        context=context,
+        blockers=blockers,
+        active_target=active_target,
+    )
+    protocols = _route_protocols(status, intent, intent_allowed)
+    return {
+        "status": status,
+        "allowedOperations": operations,
+        "requiredArtifacts": _required_artifacts(status),
+        "recommendedSkill": matches[0] if len(matches) == 1 else None,
+        "internalProtocols": protocols,
+        "blockers": route_blockers,
+    }
+
+
+def _resolve_route(
+    registry: SkillRegistry,
+    *,
+    status: str,
+    intent: str,
+    context: str,
+    blockers: tuple[str, ...] | list[str],
+    active_target: bool,
+) -> tuple[list[str], list[str], bool, list[str]]:
     route_blockers = [str(blocker) for blocker in blockers]
-    blocker_tuple = tuple(route_blockers)
     operations = _allowed_operations(
         status,
         context,
-        blocker_tuple,
+        tuple(route_blockers),
         active_target,
     )
     intent_allowed = _intent_is_allowed(intent, operations)
@@ -233,24 +261,22 @@ def route_request(
         )
     if intent == "batch" and not matches:
         route_blockers.append("batch-mode is disabled")
+    return route_blockers, operations, intent_allowed, matches
 
-    protocols: list[str] = []
+
+def _route_protocols(
+    status: str,
+    intent: str,
+    intent_allowed: bool,
+) -> list[str]:
     if intent_allowed and intent == "implement" and status in {
         "in_progress",
         "delegated_subtask",
     }:
-        protocols.append("tdd")
-    elif intent_allowed and intent == "review" and status in CHECK_STATUSES:
-        protocols.append("check")
-
-    return {
-        "status": status,
-        "allowedOperations": operations,
-        "requiredArtifacts": _required_artifacts(status),
-        "recommendedSkill": matches[0] if len(matches) == 1 else None,
-        "internalProtocols": protocols,
-        "blockers": route_blockers,
-    }
+        return ["tdd"]
+    if intent_allowed and intent == "review" and status in CHECK_STATUSES:
+        return ["check"]
+    return []
 
 
 def _default_intent(
@@ -266,6 +292,8 @@ def _default_intent(
         return "implement"
     if status in CHECK_STATUSES:
         return "review"
+    if status in DONE_STATUSES:
+        return "archive"
     if status == "delegated_subtask":
         return "implement"
     if active_target:
@@ -308,70 +336,60 @@ def _print_json_route(
     print(json.dumps(payload, ensure_ascii=False, sort_keys=False))
 
 
-def cmd_next(args) -> int:
-    repo_root = get_repo_root()
+def _navigation_target(args, repo_root: Path, structured: bool):
     target = getattr(args, "dir", None)
-    active_target = False
-    structured = bool(getattr(args, "json", False))
-    if not structured:
-        print("Workflow Next")
     if target:
         task_dir = resolve_task_dir(target, repo_root)
         task_path = _display(repo_root, task_dir)
-        source = "argument"
-    else:
-        active = get_active_task(repo_root)
-        source = f"{active.source}:{active.context_key or '-'}"
-        if not active.task_path:
-            if structured:
-                _print_json_route(
-                    args=args,
-                    status="no_task",
-                    blockers=[],
-                    active_target=False,
-                )
-                return 0
-            print("Status: no_task")
-            print(f"Source: {source}")
-            print("Next action: create or start a task before repository changes")
-            print('Command: ./.cowork-flow/run task create "<title>" --slug <task-name>')
-            print("Then: ./.cowork-flow/run task start <task-dir>")
-            print("Runtime-context subagent state is injected by hook/plugin; do not infer it from prompt text.")
-            return 0
-        task_path = active.task_path
-        task_dir = repo_root / task_path
-        active_target = True
+        return task_dir, task_path, "argument", False
 
-    if not structured:
-        print(f"Task: {task_path}")
-    if not task_dir.is_dir():
-        if structured:
-            _print_json_route(
-                args=args,
-                status="stale",
-                blockers=[f"task directory not found: {task_path}"],
-                active_target=active_target,
-            )
-            return 0
-        print("Status: stale")
+    active = get_active_task(repo_root)
+    source = f"{active.source}:{active.context_key or '-'}"
+    if active.task_path:
+        return repo_root / active.task_path, active.task_path, source, True
+    if structured:
+        _print_json_route(
+            args=args,
+            status="no_task",
+            blockers=[],
+            active_target=False,
+        )
+    else:
+        print("Status: no_task")
         print(f"Source: {source}")
-        print("Next action: clear or replace the missing active task")
-        print("Command: ./.cowork-flow/run task list")
-        print("Blockers:")
-        print(f"  - task directory not found: {task_path}")
-        return 0
+        print("Next action: create or start a task before repository changes")
+        print('Command: ./.cowork-flow/run task create "<title>" --slug <task-name>')
+        print("Then: ./.cowork-flow/run task start <task-dir>")
+        print("Runtime-context subagent state is injected by hook/plugin; do not infer it from prompt text.")
+    return None
 
-    status = _status(repo_root, task_dir)
-    blockers = _blockers(repo_root, task_dir)
-    if structured:
+
+def _print_stale_route(args, task_path: str, source: str, active_target: bool) -> None:
+    if bool(getattr(args, "json", False)):
         _print_json_route(
             args=args,
-            status=status,
-            blockers=blockers,
+            status="stale",
+            blockers=[f"task directory not found: {task_path}"],
             active_target=active_target,
         )
-        return 0
+        return
+    print("Status: stale")
+    print(f"Source: {source}")
+    print("Next action: clear or replace the missing active task")
+    print("Command: ./.cowork-flow/run task list")
+    print("Blockers:")
+    print(f"  - task directory not found: {task_path}")
+
 
+def _print_text_route(
+    repo_root: Path,
+    task_path: str,
+    task_dir: Path,
+    status: str,
+    source: str,
+    blockers: list[str],
+    active_target: bool,
+) -> None:
     print(f"Status: {status}")
     print(f"Source: {source}")
     if status == "planning":
@@ -387,21 +405,67 @@ def cmd_next(args) -> int:
     elif status == "in_progress":
         _implementation(task_path)
     elif status in CHECK_STATUSES:
-        print("Next action: verify implementation")
-        print(f"Command: ./.cowork-flow/run subagent init --role check --agent-type cowork-check --execution-task-dir {task_path} --title \"Check {Path(task_path).name}\"")
-        print("Then: pass cowork_runtime_context_id and cowork_host_context_key through the active Host Adapter or run equivalent inline check")
-        print("Then: child first step runs ./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>")
-        print("Then: verify status=bound and bound_context_key before accepting output")
-        print(f"Then: ./.cowork-flow/run task complete {task_path}")
+        _print_check_route(task_path)
     elif status in DONE_STATUSES:
-        print("Next action: finalize, archive, commit, and record session")
-        print("Command: git status --short")
-        changes = linked_active_changes_for_task(repo_root, task_dir)
-        print(f"Then: ./.cowork-flow/run task archive {Path(task_path).name}")
-        for slug in changes:
-            print(f"Then: ./.cowork-flow/run change archive {slug} (handled by task archive)")
+        _print_archive_route(repo_root, task_path, task_dir)
     else:
         print("Next action: inspect task status and repair workflow state")
         print(f"Command: ./.cowork-flow/run task validate {task_path}")
     _print_blockers(blockers)
+
+
+def _print_check_route(task_path: str) -> None:
+    print("Next action: verify implementation")
+    print(f"Command: ./.cowork-flow/run subagent init --role check --agent-type cowork-check --execution-task-dir {task_path} --title \"Check {Path(task_path).name}\"")
+    print("Then: pass cowork_runtime_context_id and cowork_host_context_key through the active Host Adapter or run equivalent inline check")
+    print("Then: child first step runs ./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>")
+    print("Then: verify status=bound and bound_context_key before accepting output")
+    print(f"Then: ./.cowork-flow/run task complete {task_path}")
+
+
+def _print_archive_route(repo_root: Path, task_path: str, task_dir: Path) -> None:
+    print("Next action: finalize, archive, commit, and record session")
+    print("Command: git status --short")
+    changes = linked_active_changes_for_task(repo_root, task_dir)
+    print(f"Then: ./.cowork-flow/run task archive {Path(task_path).name}")
+    for slug in changes:
+        print(f"Then: ./.cowork-flow/run change archive {slug} (handled by task archive)")
+
+
+def cmd_next(args) -> int:
+    repo_root = get_repo_root()
+    structured = bool(getattr(args, "json", False))
+    if not structured:
+        print("Workflow Next")
+    target = _navigation_target(args, repo_root, structured)
+    if target is None:
+        return 0
+    task_dir, task_path, source, active_target = target
+
+    if not structured:
+        print(f"Task: {task_path}")
+    if not task_dir.is_dir():
+        _print_stale_route(args, task_path, source, active_target)
+        return 0
+
+    status = _status(repo_root, task_dir)
+    blockers = _blockers(repo_root, task_dir) if status == "planning" else []
+    if structured:
+        _print_json_route(
+            args=args,
+            status=status,
+            blockers=blockers,
+            active_target=active_target,
+        )
+        return 0
+
+    _print_text_route(
+        repo_root,
+        task_path,
+        task_dir,
+        status,
+        source,
+        blockers,
+        active_target,
+    )
     return 0

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

@@ -245,6 +245,7 @@ def _add_next_command(subparsers: argparse._SubParsersAction) -> None:
             "clarify",
             "plan",
             "implement",
+            "archive",
             "review",
             "debug",
             "discuss",

package/template/.cowork-flow/scripts/common/core/paths.py

@@ -89,7 +89,10 @@ def get_developer(repo_root: Path | None = None) -> str | None:
         content = dev_file.read_text(encoding="utf-8")
         for line in content.splitlines():
             if line.startswith("name="):
-                return line.split("=", 1)[1].strip()
+                name = line.split("=", 1)[1].strip()
+                if not name or (name.startswith("<") and name.endswith(">")):
+                    return None
+                return name
     except (OSError, IOError):
         pass