cowork-flow 0.0.39 → 0.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.39",
+  "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.39
+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_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,

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

@@ -196,6 +196,42 @@ def generate_session_content(
 """
 
 
+def _replace_index_section(
+    lines: list[str],
+    start_marker: str,
+    end_marker: str,
+    replacement: list[str],
+) -> list[str]:
+    rendered: list[str] = []
+    inside = False
+    for line in lines:
+        if start_marker in line:
+            rendered.extend((line, *replacement))
+            inside = True
+        elif end_marker in line:
+            rendered.append(line)
+            inside = False
+        elif not inside:
+            rendered.append(line)
+    return rendered
+
+
+def _insert_session_history(lines: list[str], row: str) -> list[str]:
+    rendered: list[str] = []
+    inside = False
+    inserted = False
+    for line in lines:
+        if MARKER_SESSION_HISTORY_START in line:
+            inside = True
+        elif MARKER_SESSION_HISTORY_END in line:
+            inside = False
+        rendered.append(line)
+        if inside and re.match(r"^\|\s*-", line) and not inserted:
+            rendered.append(row)
+            inserted = True
+    return rendered
+
+
 def update_index(
     index_file: Path,
     dev_dir: Path,
@@ -207,8 +243,6 @@ def update_index(
 ) -> bool:
     """Update index.md with new session info."""
     commit_display = _format_commit_display(commit)
-
-    # Get file number from active_file name
     match = re.search(r"(\d+)", active_file)
     active_num = int(match.group(1)) if match else 0
     files_table = count_journal_files(dev_dir, active_num)
@@ -225,69 +259,26 @@ def update_index(
         print("Error: index.md is missing auto-update markers. Please restore the template first.", file=sys.stderr)
         return False
 
-    # Process sections
     lines = content.splitlines()
-    new_lines = []
-
-    in_current_status = False
-    in_active_documents = False
-    in_session_history = False
-    header_written = False
-
-    for line in lines:
-        if MARKER_CURRENT_STATUS_START in line:
-            new_lines.append(line)
-            in_current_status = True
-            new_lines.append(f"- **Current file**: `{active_file}`")
-            new_lines.append(f"- **Total Sessions**: {new_session}")
-            new_lines.append(f"- **Last Active**: {today}")
-            continue
-
-        if MARKER_CURRENT_STATUS_END in line:
-            in_current_status = False
-            new_lines.append(line)
-            continue
-
-        if MARKER_ACTIVE_DOCUMENTS_START in line:
-            new_lines.append(line)
-            in_active_documents = True
-            new_lines.append("| File | Lines | Status |")
-            new_lines.append("|------|------|------|")
-            new_lines.append(files_table)
-            continue
-
-        if MARKER_ACTIVE_DOCUMENTS_END in line:
-            in_active_documents = False
-            new_lines.append(line)
-            continue
-
-        if MARKER_SESSION_HISTORY_START in line:
-            new_lines.append(line)
-            in_session_history = True
-            header_written = False
-            continue
-
-        if MARKER_SESSION_HISTORY_END in line:
-            in_session_history = False
-            new_lines.append(line)
-            continue
-
-        if in_current_status:
-            continue
-
-        if in_active_documents:
-            continue
-
-        if in_session_history:
-            new_lines.append(line)
-            if re.match(r"^\|\s*-", line) and not header_written:
-                new_lines.append(f"| {new_session} | {today} | {title} | {commit_display} |")
-                header_written = True
-            continue
-
-        new_lines.append(line)
-
-    index_file.write_text("\n".join(new_lines), encoding="utf-8")
+    lines = _replace_index_section(
+        lines,
+        MARKER_CURRENT_STATUS_START,
+        MARKER_CURRENT_STATUS_END,
+        [
+            f"- **Current file**: `{active_file}`",
+            f"- **Total Sessions**: {new_session}",
+            f"- **Last Active**: {today}",
+        ],
+    )
+    lines = _replace_index_section(
+        lines,
+        MARKER_ACTIVE_DOCUMENTS_START,
+        MARKER_ACTIVE_DOCUMENTS_END,
+        ["| File | Lines | Status |", "|------|------|------|", files_table],
+    )
+    row = f"| {new_session} | {today} | {title} | {commit_display} |"
+    lines = _insert_session_history(lines, row)
+    index_file.write_text("\n".join(lines), encoding="utf-8")
     print("[OK] index.md updated.", file=sys.stderr)
     return True
 
@@ -326,87 +317,109 @@ def _auto_commit_workspace(repo_root: Path) -> None:
         print(f"[WARN] Metadata auto-commit failed: {commit_result.stderr.strip()}", file=sys.stderr)
 
 
-def add_session(
-    title: str,
-    commit: str = "-",
-    summary: str = "(add summary)",
-    extra_content: str = "(add details)",
-    auto_commit: bool = False,
-) -> int:
-    """Add a new session."""
-    repo_root = get_repo_root()
-    ensure_developer(repo_root)
-
+def _session_workspace(repo_root: Path):
     developer = get_developer(repo_root)
     if not developer:
         print("Error: developer identity has not been initialized.", file=sys.stderr)
-        return 1
-
+        return None
     dev_dir = get_workspace_dir(repo_root)
-    if not dev_dir:
+    if dev_dir is None or not dev_dir.is_dir():
         print("Error: workspace directory not found.", file=sys.stderr)
-        return 1
-
-    max_lines = get_max_journal_lines(repo_root)
-
+        return None
     index_file = dev_dir / "index.md"
-    today = datetime.now().strftime("%Y-%m-%d")
-
     journal_file, current_num, current_lines = get_latest_journal_info(dev_dir)
-    current_session = get_current_session(index_file)
-    new_session = current_session + 1
+    if not index_file.is_file():
+        print(f"Error: workspace index is missing: {index_file}", file=sys.stderr)
+        return None
+    if journal_file is None:
+        print(f"Error: workspace journal is missing: {dev_dir}", file=sys.stderr)
+        return None
+    return developer, dev_dir, index_file, journal_file, current_num, current_lines
 
-    session_content = generate_session_content(
-        new_session, title, commit, summary, extra_content, today
-    )
-    content_lines = len(session_content.splitlines())
 
-    print("========================================", file=sys.stderr)
-    print("Add Session Record", file=sys.stderr)
-    print("========================================", file=sys.stderr)
-    print("", file=sys.stderr)
-    print(f"Session: {new_session}", file=sys.stderr)
+def _print_session_preview(
+    new_session: int,
+    title: str,
+    commit: str,
+    current_num: int,
+    current_lines: int,
+    content_lines: int,
+) -> None:
+    print("=" * 40, "Add Session Record", "=" * 40, sep="\n", file=sys.stderr)
+    print(f"\nSession: {new_session}", file=sys.stderr)
     print(f"Title: {title}", file=sys.stderr)
-    print(f"Commit: {commit}", file=sys.stderr)
-    print("", file=sys.stderr)
+    print(f"Commit: {commit}\n", file=sys.stderr)
     print(f"Current journal file: {FILE_JOURNAL_PREFIX}{current_num}.md", file=sys.stderr)
     print(f"Current lines: {current_lines}", file=sys.stderr)
     print(f"New content lines: {content_lines}", file=sys.stderr)
-    print(f"Total lines after append: {current_lines + content_lines}", file=sys.stderr)
-    print("", file=sys.stderr)
-
-    target_file = journal_file
-    target_num = current_num
+    print(f"Total lines after append: {current_lines + content_lines}\n", file=sys.stderr)
 
-    if current_lines + content_lines > max_lines:
-        target_num = current_num + 1
-        print(f"[!] Over {max_lines} lines, creating {FILE_JOURNAL_PREFIX}{target_num}.md", file=sys.stderr)
-        target_file = create_new_journal_file(dev_dir, target_num, developer, today, max_lines)
-        print(f"Created: {target_file}", file=sys.stderr)
 
-    # Append session content
-    if target_file:
-        with target_file.open("a", encoding="utf-8") as f:
-            f.write(session_content)
-        print(f"[OK] Appended session to {target_file.name}", file=sys.stderr)
-
-    print("", file=sys.stderr)
+def _session_target(
+    journal_file: Path,
+    current_num: int,
+    current_lines: int,
+    content_lines: int,
+    max_lines: int,
+    dev_dir: Path,
+    developer: str,
+    today: str,
+) -> tuple[Path, int]:
+    if current_lines + content_lines <= max_lines:
+        return journal_file, current_num
+    target_num = current_num + 1
+    print(f"[!] Over {max_lines} lines, creating {FILE_JOURNAL_PREFIX}{target_num}.md", file=sys.stderr)
+    target_file = create_new_journal_file(
+        dev_dir, target_num, developer, today, max_lines
+    )
+    print(f"Created: {target_file}", file=sys.stderr)
+    return target_file, target_num
 
-    # Update index.md
-    active_file = f"{FILE_JOURNAL_PREFIX}{target_num}.md"
-    if not update_index(index_file, dev_dir, title, commit, new_session, active_file, today):
-        return 1
 
-    print("", file=sys.stderr)
-    print("========================================", file=sys.stderr)
+def _print_session_success(new_session: int, target_file: Path) -> None:
+    print("\n" + "=" * 40, file=sys.stderr)
     print(f"[OK] Session {new_session} recorded successfully.", file=sys.stderr)
-    print("========================================", file=sys.stderr)
-    print("", file=sys.stderr)
+    print("=" * 40 + "\n", file=sys.stderr)
     print("Updated files:", file=sys.stderr)
-    print(f"  - {target_file.name if target_file else 'journal'}", file=sys.stderr)
+    print(f"  - {target_file.name}", file=sys.stderr)
     print("  - index.md", file=sys.stderr)
 
-    # Auto-commit workspace changes only when explicitly requested.
+
+def add_session(
+    title: str,
+    commit: str = "-",
+    summary: str = "(add summary)",
+    extra_content: str = "(add details)",
+    auto_commit: bool = False,
+) -> int:
+    """Add a new session."""
+    repo_root = get_repo_root()
+    ensure_developer(repo_root)
+    workspace = _session_workspace(repo_root)
+    if workspace is None:
+        return 1
+    developer, dev_dir, index_file, journal_file, current_num, current_lines = workspace
+    max_lines = get_max_journal_lines(repo_root)
+    today = datetime.now().strftime("%Y-%m-%d")
+    new_session = get_current_session(index_file) + 1
+    session_content = generate_session_content(
+        new_session, title, commit, summary, extra_content, today
+    )
+    content_lines = len(session_content.splitlines())
+    _print_session_preview(
+        new_session, title, commit, current_num, current_lines, content_lines
+    )
+    target_file, target_num = _session_target(
+        journal_file, current_num, current_lines, content_lines,
+        max_lines, dev_dir, developer, today,
+    )
+    with target_file.open("a", encoding="utf-8") as stream:
+        stream.write(session_content)
+    print(f"[OK] Appended session to {target_file.name}\n", file=sys.stderr)
+    active_file = f"{FILE_JOURNAL_PREFIX}{target_num}.md"
+    if not update_index(index_file, dev_dir, title, commit, new_session, active_file, today):
+        return 1
+    _print_session_success(new_session, target_file)
     if auto_commit:
         print("", file=sys.stderr)
         _auto_commit_workspace(repo_root)

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

@@ -561,6 +561,7 @@ def cmd_complete(args: argparse.Namespace) -> int:
     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":