cowork-flow 0.0.38 → 0.0.40

package/package.json

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

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.38
+0.0.40

package/template/.cowork-flow/scripts/application/task_archive.py

@@ -3,6 +3,8 @@
 
 from __future__ import annotations
 
+import json
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
@@ -15,6 +17,7 @@ from common.task.task_utils import find_task_by_name
 
 
 DONE_STATUSES = ("completed", "done")
+ArchiveFinalizer = Callable[[], bool]
 
 
 class TaskArchiveError(RuntimeError):
@@ -53,7 +56,38 @@ class TaskArchiveService:
         task: str | Path,
         *,
         archived_at: str | None = None,
+        finalize: ArchiveFinalizer | None = None,
     ) -> TaskArchiveResult:
+        task_dir, task_data = self._load_completed_task(task)
+        archive_date = archived_at or datetime.now().strftime("%Y-%m-%d")
+        destination = self._archive_destination(task_dir, archive_date)
+        relationship_updates = self._relationship_updates(
+            task_dir.name,
+            task_data,
+        )
+        context_snapshots = self._context_snapshots(task_dir)
+        self._move_task(task_dir, destination)
+        self._apply_archive_state(
+            task_dir,
+            destination,
+            task_data,
+            relationship_updates,
+            context_snapshots,
+            archive_date,
+            finalize,
+        )
+        clear_task_from_sessions(
+            self.repo_root,
+            task_dir.relative_to(self.repo_root).as_posix(),
+        )
+        return TaskArchiveResult(
+            source=task_dir,
+            destination=destination,
+            task_name=task_dir.name,
+            archived_at=archive_date,
+        )
+
+    def _load_completed_task(self, task: str | Path) -> tuple[Path, dict]:
         task_dir = self.repository.resolve(task)
         if not task_dir.is_dir():
             raise TaskArchiveError(
@@ -78,19 +112,18 @@ class TaskArchiveService:
                 task_dir,
                 f"task status is {status}",
             )
+        return task_dir, task_data
 
-        archive_date = archived_at or datetime.now().strftime("%Y-%m-%d")
-        destination = (
+    def _archive_destination(self, task_dir: Path, archive_date: str) -> Path:
+        return (
             self.tasks_dir
             / DIR_ARCHIVE
             / archive_date[:7]
             / task_dir.name
         )
-        relationship_updates = self._relationship_updates(
-            task_dir.name,
-            task_data,
-        )
 
+    @staticmethod
+    def _move_task(task_dir: Path, destination: Path) -> None:
         move_result = archive_directory_resumable(task_dir, destination)
         if not move_result.ok:
             raise TaskArchiveError(
@@ -99,6 +132,16 @@ class TaskArchiveService:
                 move_result.message,
             )
 
+    def _apply_archive_state(
+        self,
+        task_dir: Path,
+        destination: Path,
+        task_data: dict,
+        relationship_updates: list[tuple[Path, dict, dict]],
+        context_snapshots: dict[str, bytes],
+        archive_date: str,
+        finalize: ArchiveFinalizer | None,
+    ) -> None:
         try:
             self.repository.save(
                 destination,
@@ -108,32 +151,35 @@ class TaskArchiveService:
                 },
             )
             self._apply_relationship_updates(relationship_updates)
-        except (TaskRepositoryError, TaskArchiveError) as error:
+            self._normalize_context_paths(task_dir, destination)
+            if finalize is not None and not finalize():
+                raise TaskArchiveError(
+                    "TASK-ARCHIVE-FINALIZE-001",
+                    destination,
+                    "linked change archive failed",
+                )
+        except Exception as error:
             self._rollback(
                 task_dir,
                 destination,
                 task_data,
                 relationship_updates,
+                context_snapshots,
             )
             if isinstance(error, TaskArchiveError):
                 raise
+            if isinstance(error, TaskRepositoryError):
+                raise TaskArchiveError(
+                    "TASK-ARCHIVE-WRITE-001",
+                    error.path,
+                    error.detail,
+                ) from error
             raise TaskArchiveError(
-                "TASK-ARCHIVE-WRITE-001",
-                error.path,
-                error.detail,
+                "TASK-ARCHIVE-FINALIZE-001",
+                destination,
+                f"archive finalizer failed: {error}",
             ) from error
 
-        clear_task_from_sessions(
-            self.repo_root,
-            task_dir.relative_to(self.repo_root).as_posix(),
-        )
-        return TaskArchiveResult(
-            source=task_dir,
-            destination=destination,
-            task_name=task_dir.name,
-            archived_at=archive_date,
-        )
-
     def _relationship_updates(
         self,
         task_name: str,
@@ -177,6 +223,81 @@ class TaskArchiveService:
             )
         return updates
 
+    @staticmethod
+    def _context_snapshots(task_dir: Path) -> dict[str, bytes]:
+        try:
+            return {
+                path.name: path.read_bytes()
+                for path in task_dir.glob("*.jsonl")
+                if path.is_file()
+            }
+        except OSError as error:
+            raise TaskArchiveError(
+                "TASK-ARCHIVE-CONTEXT-001",
+                task_dir,
+                f"failed to snapshot task context: {error}",
+            ) from error
+
+    def _normalize_context_paths(
+        self,
+        source: Path,
+        destination: Path,
+    ) -> None:
+        source_path = source.relative_to(self.repo_root).as_posix()
+        destination_path = destination.relative_to(self.repo_root).as_posix()
+        for context_file in sorted(destination.glob("*.jsonl")):
+            self._normalize_context_file(
+                context_file,
+                source_path,
+                destination_path,
+            )
+
+    @staticmethod
+    def _normalize_context_file(
+        context_file: Path,
+        source_path: str,
+        destination_path: str,
+    ) -> None:
+        original = context_file.read_text(encoding="utf-8")
+        rendered: list[str] = []
+        changed = False
+        for line in original.splitlines(keepends=True):
+            content = line.rstrip("\r\n")
+            ending = line[len(content):]
+            try:
+                entry = json.loads(content)
+            except json.JSONDecodeError:
+                rendered.append(line)
+                continue
+            file_path = entry.get("file") if isinstance(entry, dict) else None
+            normalized = TaskArchiveService._archived_context_path(
+                file_path,
+                source_path,
+                destination_path,
+            )
+            if normalized == file_path:
+                rendered.append(line)
+                continue
+            entry["file"] = normalized
+            rendered.append(
+                json.dumps(entry, ensure_ascii=False) + ending
+            )
+            changed = True
+        if changed:
+            context_file.write_text("".join(rendered), encoding="utf-8")
+
+    @staticmethod
+    def _archived_context_path(
+        file_path: object,
+        source_path: str,
+        destination_path: str,
+    ) -> object:
+        if file_path == source_path:
+            return destination_path
+        if isinstance(file_path, str) and file_path.startswith(f"{source_path}/"):
+            return destination_path + file_path[len(source_path):]
+        return file_path
+
     def _apply_relationship_updates(
         self,
         updates: list[tuple[Path, dict, dict]],
@@ -204,6 +325,7 @@ class TaskArchiveService:
         destination: Path,
         task_data: dict,
         relationship_updates: list[tuple[Path, dict, dict]],
+        context_snapshots: dict[str, bytes],
     ) -> None:
         for task_dir, original, _ in relationship_updates:
             try:
@@ -214,6 +336,11 @@ class TaskArchiveService:
         if destination.is_dir() and not source.exists():
             archive_directory_resumable(destination, source)
         if source.is_dir():
+            for name, content in context_snapshots.items():
+                try:
+                    (source / name).write_bytes(content)
+                except OSError:
+                    pass
             try:
                 self.repository.replace(source, task_data)
             except TaskRepositoryError:

package/template/.cowork-flow/scripts/application/task_context.py

@@ -21,6 +21,11 @@ from common.core.paths import (
 
 CONTEXT_JSONL_FILES = ("implement.jsonl", "check.jsonl", "debug.jsonl")
 CONTEXT_ENTRY_TYPES = frozenset(("file", "directory", "planned-file"))
+PLANNED_FILE_HINT = (
+    "If this is a planned new file, run "
+    "./.cowork-flow/run task add-planned-file <dir> <jsonl> <path> "
+    '"reason" or add "type": "planned-file" to the JSONL entry.'
+)
 
 
 class TaskContextError(RuntimeError):
@@ -40,6 +45,15 @@ def normalize_context_path(
 ) -> tuple[str, Path]:
     """Return a canonical repo-relative context path and its absolute target."""
     candidate = Path(repo_root) / str(path)
+    _validate_context_entry_type(candidate, entry_type)
+    normalized = _normalized_context_path(path, entry_type)
+    segments = normalized.split("/")
+    _validate_context_path(candidate, normalized, segments, path, entry_type)
+    repo_root, full_path = _resolved_context_target(repo_root, segments)
+    return _typed_context_path(normalized, full_path, repo_root, entry_type)
+
+
+def _validate_context_entry_type(candidate: Path, entry_type: str) -> None:
     if entry_type not in CONTEXT_ENTRY_TYPES:
         raise TaskContextError(
             "TASK-CONTEXT-TYPE-001",
@@ -47,14 +61,38 @@ def normalize_context_path(
             f"unsupported context entry type: {entry_type}",
         )
 
+
+def _normalized_context_path(path: str, entry_type: str) -> str:
     normalized = str(path).replace("\\", "/")
     while normalized.startswith("./"):
         normalized = normalized[2:]
     if entry_type == "directory" and normalized.endswith("/"):
         normalized = normalized[:-1]
+    return normalized
 
-    segments = normalized.split("/")
-    invalid_path = (
+
+def _validate_context_path(
+    candidate: Path,
+    normalized: str,
+    segments: list[str],
+    path: str,
+    entry_type: str,
+) -> None:
+    if not _is_valid_context_path(normalized, segments, path, entry_type):
+        raise TaskContextError(
+            "TASK-CONTEXT-PATH-002",
+            candidate,
+            "context path must be a canonical repository-relative path",
+        )
+
+
+def _is_valid_context_path(
+    normalized: str,
+    segments: list[str],
+    path: str,
+    entry_type: str,
+) -> bool:
+    return not (
         not normalized
         or normalized.startswith("/")
         or re.match(r"^[A-Za-z]:", normalized) is not None
@@ -62,15 +100,22 @@ def normalize_context_path(
         or any(character in normalized for character in "*?[]")
         or (entry_type == "planned-file" and str(path).endswith(("/", "\\")))
     )
-    if invalid_path:
-        raise TaskContextError(
-            "TASK-CONTEXT-PATH-002",
-            candidate,
-            "context path must be a canonical repository-relative path",
-        )
 
-    repo_root = Path(repo_root).resolve()
-    full_path = repo_root.joinpath(*segments).resolve(strict=False)
+
+def _resolved_context_target(
+    repo_root: Path,
+    segments: list[str],
+) -> tuple[Path, Path]:
+    resolved_root = Path(repo_root).resolve()
+    return resolved_root, resolved_root.joinpath(*segments).resolve(strict=False)
+
+
+def _typed_context_path(
+    normalized: str,
+    full_path: Path,
+    repo_root: Path,
+    entry_type: str,
+) -> tuple[str, Path]:
     try:
         full_path.relative_to(repo_root)
     except ValueError as error:
@@ -150,31 +195,43 @@ def validate_context_entry(
         )
 
     entry_type = data.get("type", "file")
+    normalized = str(data["file"])
     try:
         normalized_path, full_path = normalize_context_path(
             repo_root,
-            str(data["file"]),
+            normalized,
             entry_type,
         )
     except TaskContextError as error:
-        code = (
-            "invalid_entry_type"
-            if error.code == "TASK-CONTEXT-TYPE-001"
-            else "invalid_path"
-        )
+        code = _context_error_issue_code(error)
         return _context_issue(context_file, line, code, error.detail)
 
     if is_skill_path(normalized_path):
         return None
+    return _validate_context_entry_target(
+        context_file,
+        line,
+        entry_type,
+        normalized_path,
+        full_path,
+    )
+
+
+def _context_error_issue_code(error: TaskContextError) -> str:
+    if error.code == "TASK-CONTEXT-TYPE-001":
+        return "invalid_entry_type"
+    return "invalid_path"
+
+
+def _validate_context_entry_target(
+    context_file: str,
+    line: int,
+    entry_type: str,
+    normalized_path: str,
+    full_path: Path,
+) -> ContextValidationIssue | None:
     if entry_type == "planned-file":
-        if full_path.is_dir():
-            return _context_issue(
-                context_file,
-                line,
-                "invalid_path",
-                f"Planned file is a directory: {normalized_path}",
-            )
-        return None
+        return _planned_file_issue(context_file, line, normalized_path, full_path)
     if entry_type == "directory" and not full_path.is_dir():
         return _context_issue(
             context_file,
@@ -187,11 +244,27 @@ def validate_context_entry(
             context_file,
             line,
             "file_not_found",
-            f"File not found: {normalized_path}",
+            f"File not found: {normalized_path}. {PLANNED_FILE_HINT}",
         )
     return None
 
 
+def _planned_file_issue(
+    context_file: str,
+    line: int,
+    normalized_path: str,
+    full_path: Path,
+) -> ContextValidationIssue | None:
+    if not full_path.is_dir():
+        return None
+    return _context_issue(
+        context_file,
+        line,
+        "invalid_path",
+        f"Planned file is a directory: {normalized_path}",
+    )
+
+
 @dataclass(frozen=True)
 class ContextInitializationResult:
     created: tuple[str, ...]
@@ -463,6 +536,7 @@ class TaskContextService:
             created.append(file_name)
             entry_counts[file_name] = len(entries)
 
+        self.ensure_task_artifact_placeholders(task_dir)
         return ContextInitializationResult(
             created=tuple(created),
             skipped=tuple(skipped),
@@ -607,6 +681,33 @@ class TaskContextService:
                 )
         return tuple(summaries)
 
+    def ensure_task_artifact_placeholders(self, task_dir: Path) -> tuple[str, ...]:
+        """Create empty placeholders for planned task-local context files."""
+        task_dir = Path(task_dir)
+        created: list[str] = []
+        for entry in self.entries(task_dir, "implement"):
+            if entry.get("type") == "planned-file":
+                continue
+            file_path = str(entry.get("file", "")).strip()
+            if not file_path:
+                continue
+            try:
+                normalized, full_path = normalize_context_path(
+                    self.repo_root,
+                    file_path,
+                    "planned-file",
+                )
+            except TaskContextError:
+                continue
+            if not _is_task_local_artifact(task_dir, full_path):
+                continue
+            if full_path.exists():
+                continue
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text("", encoding="utf-8")
+            created.append(normalized)
+        return tuple(created)
+
     def _implement_entries(self, dev_type: str) -> list[dict]:
         entries = get_implement_base()
         entries.extend(
@@ -654,3 +755,11 @@ class TaskContextService:
         if context_name.endswith(".jsonl"):
             return context_name
         return f"{context_name}.jsonl"
+
+
+def _is_task_local_artifact(task_dir: Path, full_path: Path) -> bool:
+    try:
+        full_path.resolve(strict=False).relative_to(task_dir.resolve(strict=False))
+    except ValueError:
+        return False
+    return not full_path.exists() or full_path.is_file()

package/template/.cowork-flow/scripts/application/task_lifecycle.py

@@ -124,11 +124,13 @@ class TaskLifecycleService:
         task: str | Path,
         *,
         completed_at: str | None = None,
+        allow_spec_file_modifications: bool = False,
     ) -> LifecycleResult:
         return self.execute(
             COMPLETE_STAGE,
             task,
             completed_at=completed_at,
+            allow_spec_file_modifications=allow_spec_file_modifications,
         )
 
     def execute(
@@ -308,7 +310,7 @@ class TaskLifecycleService:
         task_dir: Path,
         already_at_target: bool,
     ) -> LifecycleResult | None:
-        if not already_at_target or stage.name == REVIEW_STAGE.name:
+        if not already_at_target or stage.name != START_STAGE.name:
             return None
         return LifecycleResult(
             ok=True,