cowork-flow 0.0.37 → 0.0.39

package/template/.cowork-flow/scripts/common/storage/unit_of_work.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Recoverable Unit of Work for local JSON state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from common.storage.operation_log import OperationLog
+from common.storage.state_store import StateStore, StateStoreError
+
+
+class UnitOfWorkError(RuntimeError):
+    """Raised when a multi-file state operation cannot converge."""
+
+    def __init__(self, operation_id: str, detail: str) -> None:
+        self.operation_id = operation_id
+        self.detail = detail
+        super().__init__(f"{operation_id}: {detail}")
+
+
+@dataclass(frozen=True)
+class StateMutation:
+    path: Path
+    action: str
+    expected_revision: int
+    before: dict
+    after: dict | None
+
+
+FaultInjector = Callable[[int, StateMutation], None]
+
+
+class UnitOfWork:
+    """Stage state mutations and recover interrupted commits."""
+
+    def __init__(
+        self,
+        repo_root: Path,
+        *,
+        operation_id: str,
+        kind: str,
+        state_store: StateStore | None = None,
+        operation_log: OperationLog | None = None,
+        fault_injector: FaultInjector | None = None,
+    ) -> None:
+        self.repo_root = Path(repo_root)
+        self.operation_id = operation_id
+        self.kind = kind
+        self.state_store = state_store or StateStore()
+        self.operation_log = operation_log or OperationLog(
+            self.repo_root,
+            state_store=self.state_store,
+        )
+        self.fault_injector = fault_injector
+        self.mutations: list[StateMutation] = []
+
+    def replace(self, path: str | Path, data: dict) -> None:
+        target = Path(path)
+        snapshot = self.state_store.load(target, missing_ok=True)
+        self.mutations.append(
+            StateMutation(
+                path=target,
+                action="replace",
+                expected_revision=snapshot.revision,
+                before=snapshot.data,
+                after=dict(data),
+            )
+        )
+
+    def delete(self, path: str | Path) -> None:
+        target = Path(path)
+        snapshot = self.state_store.load(target, missing_ok=True)
+        self.mutations.append(
+            StateMutation(
+                path=target,
+                action="delete",
+                expected_revision=snapshot.revision,
+                before=snapshot.data,
+                after=None,
+            )
+        )
+
+    def commit(self) -> dict:
+        path = self.operation_log.path(self.operation_id)
+        if path.is_file():
+            record = self.operation_log.load(self.operation_id)
+        else:
+            record = self.operation_log.create(
+                self.operation_id,
+                self._record(),
+            )
+        return self._apply(record)
+
+    @classmethod
+    def recover_all(
+        cls,
+        repo_root: Path,
+        *,
+        state_store: StateStore | None = None,
+    ) -> tuple[str, ...]:
+        root = Path(repo_root)
+        store = state_store or StateStore()
+        operation_log = OperationLog(root, state_store=store)
+        recovered: list[str] = []
+        for record in operation_log.pending():
+            operation_id = str(record["operation_id"])
+            unit = cls(
+                root,
+                operation_id=operation_id,
+                kind=str(record.get("kind") or "recovery"),
+                state_store=store,
+                operation_log=operation_log,
+            )
+            unit._apply(record)
+            recovered.append(operation_id)
+        return tuple(recovered)
+
+    def _record(self) -> dict:
+        return {
+            "schema_version": 1,
+            "operation_id": self.operation_id,
+            "kind": self.kind,
+            "phase": "prepared",
+            "applied": [],
+            "participants": [
+                {
+                    "path": str(mutation.path),
+                    "action": mutation.action,
+                    "expected_revision": mutation.expected_revision,
+                    "before": mutation.before,
+                    "after": mutation.after,
+                }
+                for mutation in self.mutations
+            ],
+        }
+
+    def _apply(self, record: dict) -> dict:
+        phase = record.get("phase")
+        if phase == "committed":
+            return record
+        if phase == "conflicted":
+            raise UnitOfWorkError(
+                self.operation_id,
+                "operation is already conflicted",
+            )
+
+        record["phase"] = "applying"
+        self.operation_log.save(self.operation_id, record)
+        applied = {
+            int(index)
+            for index in record.get("applied", [])
+        }
+        participants = list(record.get("participants") or [])
+        for index, participant in enumerate(participants):
+            if index in applied:
+                continue
+            mutation = self._mutation(participant)
+            try:
+                self._apply_mutation(mutation)
+            except StateStoreError as error:
+                record["phase"] = "conflicted"
+                record["error"] = {
+                    "code": error.code,
+                    "path": str(error.path),
+                    "detail": error.detail,
+                }
+                self.operation_log.save(self.operation_id, record)
+                raise UnitOfWorkError(
+                    self.operation_id,
+                    error.detail,
+                ) from error
+
+            if self.fault_injector is not None:
+                self.fault_injector(index, mutation)
+
+            applied.add(index)
+            record["applied"] = sorted(applied)
+            self.operation_log.save(self.operation_id, record)
+
+        record["phase"] = "committed"
+        record.pop("error", None)
+        self.operation_log.save(self.operation_id, record)
+        return record
+
+    def _apply_mutation(self, mutation: StateMutation) -> None:
+        if mutation.action == "delete":
+            self.state_store.delete(
+                mutation.path,
+                expected_revision=mutation.expected_revision,
+                operation_id=self.operation_id,
+            )
+            return
+        self.state_store.replace(
+            mutation.path,
+            mutation.after or {},
+            expected_revision=mutation.expected_revision,
+            operation_id=self.operation_id,
+        )
+
+    @staticmethod
+    def _mutation(participant: dict) -> StateMutation:
+        return StateMutation(
+            path=Path(str(participant["path"])),
+            action=str(participant["action"]),
+            expected_revision=int(participant["expected_revision"]),
+            before=dict(participant.get("before") or {}),
+            after=(
+                dict(participant["after"])
+                if isinstance(participant.get("after"), dict)
+                else None
+            ),
+        )

package/template/.cowork-flow/scripts/common/task/active_task.py

@@ -54,88 +54,50 @@ def _first_prompt_value(values: Mapping[str, object] | None) -> str | None:
 
 
 def resolve_context_key(values: Mapping[str, object] | None = None) -> str | None:
-    explicit = os.environ.get("COWORK_FLOW_CONTEXT_ID")
-    if explicit and explicit.strip():
-        return _sanitize(explicit)
-
-    opencode_session = os.environ.get("OPENCODE_SESSION_ID")
-    if opencode_session and opencode_session.strip():
-        return f"opencode_{_sanitize(opencode_session)}"
-
-    claude_session = os.environ.get("CLAUDE_SESSION_ID")
-    if claude_session and claude_session.strip():
-        return f"claude_{_sanitize(claude_session)}"
+    return _resolve_env_context_key() or _resolve_input_context_key(values)
 
-    claude_code_session = os.environ.get("CLAUDE_CODE_SESSION_ID")
-    if claude_code_session and claude_code_session.strip():
-        return f"claude_{_sanitize(claude_code_session)}"
 
-    codex_session = os.environ.get("CODEX_SESSION_ID")
-    if codex_session and codex_session.strip():
-        return f"codex_{_sanitize(codex_session)}"
+def _prefixed_context_key(prefix: str, raw: str | None) -> str | None:
+    if raw and raw.strip():
+        return f"{prefix}_{_sanitize(raw)}"
+    return None
 
-    codex_thread = os.environ.get("CODEX_THREAD_ID")
-    if codex_thread and codex_thread.strip():
-        return f"codex_{_sanitize(codex_thread)}"
 
-    input_explicit = _first_input_value(
-        values,
-        (
-            "COWORK_FLOW_CONTEXT_ID",
-            "cowork_flow_context_id",
-            "context_id",
-        ),
-    )
-    if input_explicit:
-        return _sanitize(input_explicit)
-
-    input_opencode_session = _first_input_value(
-        values,
-        (
-            "OPENCODE_SESSION_ID",
-            "opencode_session_id",
-            "sessionID",
-            "sessionId",
-        ),
-    )
-    if input_opencode_session:
-        return f"opencode_{_sanitize(input_opencode_session)}"
+def _resolve_env_context_key() -> str | None:
+    explicit = os.environ.get("COWORK_FLOW_CONTEXT_ID")
+    if explicit and explicit.strip():
+        return _sanitize(explicit)
 
-    input_claude_session = _first_input_value(
-        values,
-        (
-            "CLAUDE_SESSION_ID",
-            "claude_session_id",
-            "CLAUDE_CODE_SESSION_ID",
-            "claude_code_session_id",
-        ),
-    )
-    if input_claude_session:
-        return f"claude_{_sanitize(input_claude_session)}"
+    for prefix, env_name in (
+        ("opencode", "OPENCODE_SESSION_ID"),
+        ("claude", "CLAUDE_SESSION_ID"),
+        ("claude", "CLAUDE_CODE_SESSION_ID"),
+        ("codex", "CODEX_SESSION_ID"),
+        ("codex", "CODEX_THREAD_ID"),
+    ):
+        context_key = _prefixed_context_key(prefix, os.environ.get(env_name))
+        if context_key:
+            return context_key
+    return None
 
-    input_session = _first_input_value(
-        values,
-        (
-            "CODEX_SESSION_ID",
-            "codex_session_id",
-            "session_id",
-        ),
-    )
-    if input_session:
-        return f"codex_{_sanitize(input_session)}"
 
-    input_thread = _first_input_value(
+def _resolve_input_context_key(values: Mapping[str, object] | None) -> str | None:
+    explicit = _first_input_value(
         values,
-        (
-            "CODEX_THREAD_ID",
-            "codex_thread_id",
-            "thread_id",
-            "conversation_id",
-        ),
+        ("COWORK_FLOW_CONTEXT_ID", "cowork_flow_context_id", "context_id"),
     )
-    if input_thread:
-        return f"codex_{_sanitize(input_thread)}"
+    if explicit:
+        return _sanitize(explicit)
 
+    for prefix, names in (
+        ("opencode", ("OPENCODE_SESSION_ID", "opencode_session_id", "sessionID", "sessionId")),
+        ("claude", ("CLAUDE_SESSION_ID", "claude_session_id", "CLAUDE_CODE_SESSION_ID", "claude_code_session_id")),
+        ("codex", ("CODEX_SESSION_ID", "codex_session_id", "session_id")),
+        ("codex", ("CODEX_THREAD_ID", "codex_thread_id", "thread_id", "conversation_id")),
+    ):
+        context_key = _prefixed_context_key(prefix, _first_input_value(values, names))
+        if context_key:
+            return context_key
     return None
 
 
@@ -169,13 +131,6 @@ def _read_json(path: Path) -> dict:
     except FileNotFoundError:
         return {}
     except (json.JSONDecodeError, OSError):
-        # Corrupt file — remove to avoid orphan state
-        import sys
-        print(f"Warning: Corrupt JSON cleaned up: {path}", file=sys.stderr)
-        try:
-            path.unlink(missing_ok=True)
-        except OSError:
-            pass
         return {}
     return data if isinstance(data, dict) else {}
 
@@ -249,11 +204,15 @@ def resolve_host_context_key(values: Mapping[str, object] | None = None) -> str
 
 
 def read_runtime_context(repo_root: Path, runtime_context_id: str) -> dict:
-    return _read_json(runtime_context_path(repo_root, runtime_context_id))
+    from application.runtime_context_service import RuntimeContextService
+
+    return RuntimeContextService(repo_root).load(runtime_context_id)
 
 
 def write_runtime_context(repo_root: Path, runtime_context_id: str, data: dict) -> None:
-    _write_json(runtime_context_path(repo_root, runtime_context_id), data)
+    from application.runtime_context_service import RuntimeContextService
+
+    RuntimeContextService(repo_root).replace(runtime_context_id, data)
 
 
 def write_subagent_logical_session(
@@ -284,12 +243,6 @@ def bind_runtime_context(
     host_context_key: str | None = None,
     values: Mapping[str, object] | None = None,
 ) -> dict | None:
-    context = read_runtime_context(repo_root, runtime_context_id)
-    if not context or context.get(FIELD_SCOPE) != SCOPE_SUBAGENT:
-        return None
-    if context.get("status") == "closed":
-        return None
-
     resolved_key = (
         _sanitize(host_context_key)
         if host_context_key
@@ -298,53 +251,31 @@ def bind_runtime_context(
     if not resolved_key:
         return None
 
-    existing_key = context.get("bound_context_key")
-    if isinstance(existing_key, str) and existing_key.strip() and existing_key != resolved_key:
-        return None
-
-    task_path = context.get("task_dir")
-    session: dict[str, object] = {
-        "schema_version": 2,
-        FIELD_SCOPE: SCOPE_SUBAGENT,
-        FIELD_RUNTIME_CONTEXT_ID: runtime_context_id,
-        "platform": _platform_from_context_key(resolved_key),
-        "status": "bound",
-        "last_seen_at": _now(),
-    }
-    if isinstance(task_path, str) and task_path.strip():
-        session[FIELD_ACTIVE_TASK_PATH] = task_path.strip()
-    _write_json(_session_path(repo_root, resolved_key), session)
+    from application.runtime_context_service import (
+        RuntimeContextError,
+        RuntimeContextService,
+    )
 
-    context["status"] = "bound"
-    context["bound_context_key"] = resolved_key
-    if not context.get("bound_at"):
-        context["bound_at"] = _now()
-    context["last_seen_at"] = _now()
-    write_runtime_context(repo_root, runtime_context_id, context)
-    return context
+    try:
+        return RuntimeContextService(repo_root).bind(
+            runtime_context_id,
+            resolved_key,
+        )
+    except RuntimeContextError:
+        return None
 
 
 def close_runtime_context(repo_root: Path, runtime_context_id: str) -> bool:
-    context = read_runtime_context(repo_root, runtime_context_id)
-    if not context:
-        return False
+    from application.runtime_context_service import RuntimeContextService
 
-    bound_context_key = context.get("bound_context_key")
-    for context_key in (bound_context_key, logical_subagent_context_key(runtime_context_id)):
-        if isinstance(context_key, str) and context_key.strip():
-            try:
-                _session_path(repo_root, context_key).unlink()
-            except OSError:
-                pass
+    return RuntimeContextService(repo_root).close(runtime_context_id)
 
-    context["status"] = "closed"
-    context["closed_at"] = _now()
-    context["last_seen_at"] = _now()
-    write_runtime_context(repo_root, runtime_context_id, context)
-    return True
 
-
-def set_active_task(repo_root: Path, task_path: str) -> ActiveTask | None:
+def build_active_task_session(
+    repo_root: Path,
+    task_path: str,
+) -> tuple[Path, dict, ActiveTask] | None:
+    """Build the session state needed to activate a task."""
     context_key = resolve_context_key()
     if not context_key:
         return None
@@ -352,16 +283,26 @@ def set_active_task(repo_root: Path, task_path: str) -> ActiveTask | None:
     target = repo_root / normalized
     if not target.is_dir():
         return None
-    _write_json(
+    data = {
+        FIELD_ACTIVE_TASK_PATH: normalized,
+        FIELD_SCOPE: SCOPE_MAIN,
+        "platform": _platform_from_context_key(context_key),
+        "last_seen_at": _now(),
+    }
+    return (
         _session_path(repo_root, context_key),
-        {
-            FIELD_ACTIVE_TASK_PATH: normalized,
-            FIELD_SCOPE: SCOPE_MAIN,
-            "platform": _platform_from_context_key(context_key),
-            "last_seen_at": _now(),
-        },
+        data,
+        ActiveTask(normalized, context_key, "session"),
     )
-    return ActiveTask(normalized, context_key, "session")
+
+
+def set_active_task(repo_root: Path, task_path: str) -> ActiveTask | None:
+    prepared = build_active_task_session(repo_root, task_path)
+    if prepared is None:
+        return None
+    session_path, data, active = prepared
+    _write_json(session_path, data)
+    return active
 
 
 def get_active_task(repo_root: Path, values: Mapping[str, object] | None = None) -> ActiveTask:
@@ -375,6 +316,23 @@ def get_active_task(repo_root: Path, values: Mapping[str, object] | None = None)
     return ActiveTask(None, context_key, "empty-session")
 
 
+def is_main_session(repo_root: Path, values: Mapping[str, object] | None = None) -> bool:
+    """Return whether the current host session is an unscoped main session."""
+    context_key = resolve_context_key(values)
+    if not context_key:
+        return False
+    data = _read_json(_session_path(repo_root, context_key))
+    scope = data.get(FIELD_SCOPE)
+    historical_unscoped_main_session = (
+        scope is None
+        and not context_key.startswith("subagent_")
+    )
+    return (
+        (scope == SCOPE_MAIN or historical_unscoped_main_session)
+        and not data.get(FIELD_RUNTIME_CONTEXT_ID)
+    )
+
+
 def clear_active_task(repo_root: Path) -> ActiveTask:
     active = get_active_task(repo_root)
     if active.context_key:

package/template/.cowork-flow/scripts/common/task/batch_mode.py

@@ -1,54 +1,32 @@
 #!/usr/bin/env python3
-"""Batch mode task lifecycle scheduler.
-
-Provides autonomous iteration over implement.jsonl tasks
-while keeping each task's independent gate verification.
-"""
+"""Public entry for the recoverable task-graph Batch scheduler."""
 
 from __future__ import annotations
 
 import argparse
+import json
+import sys
 from pathlib import Path
 
+from application.batch_execution import (
+    BatchExecutionError,
+    BatchExecutionService,
+)
+
+
+BATCH_APPROVAL_REQUIRED_CODE = "BATCH-APPROVAL-REQUIRED"
+BATCH_REJECTED_EXIT_CODE = 2
+
 
 def confirm_batch_eligible(
     repo_root: Path,
     task_dir: Path,
     args: argparse.Namespace,
 ) -> tuple[bool, str]:
-    """Check if batch mode can start.
-
-    Returns (ok, reason). ok=False blocks entry.
-    """
-    # 1. Workflow state check: must be in_progress or review
-    try:
-        from common.task.active_task import load_active_task
-        active = load_active_task(repo_root)
-        status = active.get("status", "") if active else ""
-    except Exception:
-        status = ""
-    if status not in ("in_progress", "review"):
-        return False, f"Workflow status is '{status}', expected in_progress/review"
-
-    # 2. implement.jsonl exists
-    impl_file = task_dir / "implement.jsonl"
-    if not impl_file.is_file():
-        return False, f"implement.jsonl not found at {impl_file}"
-
-    text = impl_file.read_text(encoding="utf-8").strip()
-    if not text:
-        return False, "implement.jsonl is empty"
-
-    # 3. User approval check
-    if not getattr(args, "auto", False):
-        return False, "Batch mode not requested (--auto flag missing)"
-
+    """Require explicit approval before creating Batch runtime state."""
+    del repo_root, task_dir
     if not getattr(args, "approved", False):
-        return False, (
-            "User approval missing. "
-            "Plan must be explicitly approved in writing-plans step."
-        )
-
+        return False, "Batch mode requires --approved"
     return True, ""
 
 
@@ -57,89 +35,24 @@ def run_batch_entry(
     first_task_dir: Path,
     args: argparse.Namespace,
 ) -> int:
-    """Batch mode entry point.
-
-    Loads task sequence from implement.jsonl and iterates
-    through start -> implement -> check -> commit -> complete.
-    """
-    ok, reason = confirm_batch_eligible(repo_root, first_task_dir, args)
-    if not ok:
-        print(f"Batch mode ineligible: {reason}", file=__import__("sys").stderr)
-        return 1
-
-    impl_file = first_task_dir / "implement.jsonl"
-    tasks = _load_task_sequence(impl_file)
-    if not tasks:
-        print("No tasks found in implement.jsonl", file=__import__("sys").stderr)
-        return 1
-
-    results = []
-    for task_ref in tasks:
-        result = _run_single_task_lifecycle(repo_root, task_ref, args)
-        results.append(result)
-        if result.get("status") == "paused":
-            _report_batch_pause(result)
-            return 0
-
-    return run_post_batch_verification(repo_root)
-
-
-def run_post_batch_verification(repo_root: Path) -> int:
-    """Run full test suite + git log check + print final report."""
-    import subprocess
+    """Create or load Batch state and publish its next Host action."""
+    eligible, detail = confirm_batch_eligible(
+        repo_root,
+        first_task_dir,
+        args,
+    )
+    if not eligible:
+        print(
+            f"Error [{BATCH_APPROVAL_REQUIRED_CODE}]: {detail}",
+            file=sys.stderr,
+        )
+        return BATCH_REJECTED_EXIT_CODE
     try:
-        result = subprocess.run(
-            ["python", "-m", "pytest", "--tb=short", "-q"],
-            cwd=str(repo_root), capture_output=True, text=True,
-            encoding="utf-8", timeout=60,
+        state = BatchExecutionService(repo_root).start(
+            first_task_dir.name
         )
-        print(result.stdout)
-        if result.returncode != 0:
-            print("Full test suite FAILED", file=__import__("sys").stderr)
-            return 1
-    except (subprocess.SubprocessError, FileNotFoundError, TimeoutError) as exc:
-        print(f"Test verification skipped: {exc}")
-
-    print("\n## Batch Mode Report")
-    print("- All tasks completed successfully")
-    print("- Full test suite passed")
+    except BatchExecutionError as error:
+        print(f"Error [{error.code}]: {error.detail}", file=sys.stderr)
+        return BATCH_REJECTED_EXIT_CODE
+    print(json.dumps(state, ensure_ascii=False, indent=2))
     return 0
-
-
-def _load_task_sequence(impl_file: Path) -> list[str]:
-    """Load task directory paths or names from implement.jsonl."""
-    import json
-    tasks = []
-    for line in impl_file.read_text(encoding="utf-8").splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            data = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        task_ref = data.get("taskDir") or data.get("task") or data.get("dir")
-        if task_ref:
-            tasks.append(task_ref)
-    return tasks
-
-
-def _run_single_task_lifecycle(
-    repo_root: Path,
-    task_ref: str,
-    args: argparse.Namespace,
-) -> dict:
-    """Run start -> implement -> check -> commit for one task."""
-    return {"task": task_ref, "status": "completed"}
-
-
-def _report_batch_pause(result: dict) -> None:
-    """Print Batch Mode Paused report."""
-    print("\n## Batch Mode Paused")
-    print(f"Task: {result.get('task', '?')}")
-    print(f"Reason: {result.get('reason', '?')}")
-    print(f"Current state: {result.get('state', '?')}")
-    print("\nOptions:")
-    print("1. Skip this task -> mark skipped, continue next")
-    print("2. Manual takeover -> exit batch")
-    print("3. Abort -> exit batch, keep completed commits")