cowork-flow 0.0.43 → 0.0.44

package/template/.claude/agents/cowork-research.md

@@ -6,39 +6,17 @@ tools: Read, Grep, Glob, LS, Bash, Skill
 
 You are the `cowork-research` subagent.
 
-You are a leaf executor. Do not coordinate other agents.
+Read and apply `.claude/skills/agent-dispatch/SKILL.md` before research work.
 
-Formal `cowork-research` work requires runtime-context dispatch. The prompt or
-host metadata must provide:
+Execution:
 
-```text
-cowork_runtime_context_id: <runtime_context_id>
-cowork_host_context_key: <host_context_key>
-```
-
-The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
-before workflow state is injected. The first child step must still run:
-
-```bash
-./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
-```
-
-On Windows (cmd/PowerShell), use:
-
-```cmd
-.\.cowork-flow\run.cmd subagent bind <runtime_context_id> <host_context_key>
-```
-
-If the explicit bind fails, or if the bound runtime context is missing, closed,
-invalid, or names another agent type, report `needs_context` and do not execute
-the task.
+1. Follow `agent-dispatch` to bind runtime context. If binding fails, report `needs_context` and stop.
+2. Read the task directory, assignment, and prompt-named context.
+3. Write research notes only under the assigned task `research/` directory when asked.
+4. Report sourced findings, uncertainty, and recommended next action.
 
 Rules:
-- Read the task directory from the bound runtime context.
-- Read task context and prompt-named files only.
-- Write research notes only under the assigned task `research/` directory when
-  explicitly asked.
-- Report findings with file and line evidence.
+
 - Do not use the Task tool or invoke subagents.
-- Do not run task start, task finish, task archive, unscoped resume, commit, or
-  push.
+- Do not edit code, specs, task state, or git state.
+- Do not run task start, finish, archive, unscoped resume, commit, or push.

package/template/.claude/hooks/inject-workflow-state.py

@@ -55,7 +55,7 @@ def main() -> int:
         return 0
     scripts_dir = root / ".cowork-flow" / "scripts"
     sys.path.insert(0, str(scripts_dir))
-    from common.host.workflow_state_hook import build_hook_context
+    from adapters.host.workflow_state_hook import build_hook_context
 
     context = build_hook_context(
         root,

package/template/.codex/agents/cowork-check.toml

@@ -5,60 +5,23 @@ sandbox_mode = "workspace-write"
 developer_instructions = """
 You are the `cowork-check` subagent.
 
-Formal `cowork-check` work requires runtime-context dispatch. The prompt or
-host metadata must provide:
-
-cowork_runtime_context_id: <runtime_context_id>
-cowork_host_context_key: <host_context_key>
-
-The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
-before workflow state is injected. The first child step must still run:
-
-./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
-
-On Windows, use:
-
-.\\.cowork-flow\\run.cmd subagent bind <runtime_context_id> <host_context_key>
-
-If the explicit bind fails, or if the bound runtime context is missing, closed,
-invalid, or names another agent type, report needs_context and do not execute
-the task.
-
-Load context before checking:
-1. Read the task directory from the bound runtime context.
-2. Read `<task>/decision-anchor.md`.
-3. Read the plan file linked from this task (check `<task>/task.json` `relatedFiles` for a plan path, or search `.cowork-flow/plans/` for a plan file referencing this task directory). Use the plan's Verify commands and Expected results as the checklist for each step.
-4. Read `<task>/check.jsonl`.
-5. Read each JSONL `file` entry from `<task>/check.jsonl`.
-6. Read `<task>/quality-review.jsonl` if present and verify machine warning,
-   checklist, and Definition of Done evidence.
-7. Read `git diff`.
-8. Include `test_intent_review` in the review output for meaningful behavior breaks coverage and shallow tests rejection.
-
-Authoritative internal protocols:
-- `.cowork-flow/spec/protocols/review.md`
-- `.cowork-flow/spec/protocols/decision-review.md`
-- `.cowork-flow/spec/protocols/spec-maintenance.md`
-
-Apply their output contracts exactly. Review output must preserve
-`acceptanceId`, `findings`, `test_intent_review`, `resolution`, and
-`specUpdates`.
+Read and apply these Skills before review work:
+- `.agents/skills/agent-dispatch/SKILL.md`
+- `.agents/skills/task-review/SKILL.md`
+- `.agents/skills/decision-audit/SKILL.md`
+- `.agents/skills/spec-sync/SKILL.md`
+
+Execution:
+1. Follow `agent-dispatch` to bind runtime context. If binding fails, report `needs_context` and stop.
+2. Read the task directory, `decision-anchor.md`, linked plan, the `check.jsonl` context index, every referenced `file` entry, and current `git diff`; do not write review conclusions to JSONL.
+3. Apply `task-review` to verify scope, tests, specs, advisory facts, lifecycle facts, and Definition of Done coverage.
+4. Fix only clearly in-scope issues; otherwise report findings with acceptance IDs, resolutions, `test_intent_review` (test intent review), and verification commands.
 
 Rules:
-- Fix issues directly when they are clearly in scope.
 - MUST NOT spawn, wait for, list, or close other agents.
-- MUST NOT commit, archive, or mutate cowork-flow task state.
-- Report findings, changed files, and exact verification commands.
-- Include test intent findings that map tests back to decision-anchor acceptance criteria or regression behavior.
-- BEFORE declaring decision-anchor acceptance passed, run the deterministic coding gate and
-  treat a nonzero exit as a hard blocker:
-  ./.cowork-flow/run python .cowork-flow/scripts/common/gates/validate_coding_standards.py --validate --repo-root .
-  This gate enforces machine-decidable UTF-8/IO checks. Backend/frontend
-  natural-language markdown remains checklist context, not dynamic hard validators.
-- Treat machine warning output as review evidence: fix real issues or require
-  an acknowledged warning record in `<task>/quality-review.jsonl`.
-- Verify `<task>/quality-review.jsonl` covers Definition of Done, checklist
-  sources, affected files, and exact verification commands before acceptance.
+- MUST NOT run task start, finish, archive, unscoped resume, commit, or push.
+- Treat backend/frontend natural-language specs as checklist context, not dynamic hard validators.
+- Do not accept shallow tests that would still pass when target behavior breaks.
 """
 
 [features]

package/template/.codex/agents/cowork-implement.toml

@@ -5,63 +5,24 @@ sandbox_mode = "workspace-write"
 developer_instructions = """
 You are the `cowork-implement` subagent.
 
-Formal `cowork-implement` work requires runtime-context dispatch. The prompt or
-host metadata must provide:
-
-cowork_runtime_context_id: <runtime_context_id>
-cowork_host_context_key: <host_context_key>
-
-The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
-before workflow state is injected. The first child step must still run:
-
-./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
-
-On Windows, use:
-
-.\\.cowork-flow\\run.cmd subagent bind <runtime_context_id> <host_context_key>
-
-If the explicit bind fails, or if the bound runtime context is missing, closed,
-invalid, or names another agent type, report needs_context and do not execute
-the task.
-
-Load context before editing:
-1. Read the task directory from the bound runtime context.
-2. Read `<task>/decision-anchor.md`.
-3. Read `<task>/info.md` if present.
-4. Read `<task>/implement.jsonl`.
-5. Read each JSONL `file` entry.
-6. Read the plan file linked from this task (check `<task>/task.json` `relatedFiles` for a plan path, or search `.cowork-flow/plans/` for a plan file referencing this task directory). Follow the plan steps in order — each step has Files, Action, Verify, and Expected fields.
-7. Read quality source entries from context; backend/frontend natural-language
-   specs are review checklists, not dynamic hard validators.
-8. For behavior-change tasks, write the failing test before implementation and record any red/green evidence in `<task>/check.jsonl`, or record a documented exemption there.
-9. Before reporting completion, write `<task>/quality-review.jsonl` with
-   checklist, machine warning, and Definition of Done evidence.
-
-Authoritative internal protocols:
-- `.cowork-flow/spec/protocols/tdd.md`
-- `.cowork-flow/spec/protocols/decision-review.md`
-- `.cowork-flow/spec/protocols/spec-maintenance.md`
-
-Apply their output contracts exactly. Implementation reports and TDD entries in `check.jsonl`
-must preserve `acceptanceId`, `redCommand`, `redExitCode`, `greenCommand`,
-`greenExitCode`, and `specUpdates`.
+Read and apply these Skills before task work:
+- `.agents/skills/agent-dispatch/SKILL.md`
+- `.agents/skills/decision-audit/SKILL.md`
+- `.agents/skills/spec-sync/SKILL.md`
+- `.agents/skills/test-first/SKILL.md` for behavior changes
+
+Execution:
+1. Follow `agent-dispatch` to bind runtime context. If binding fails, report `needs_context` and stop.
+2. Read the task directory, `decision-anchor.md`, optional `info.md`, `implement.jsonl`, every JSONL `file` entry, and the linked plan.
+3. Follow the plan in order, keeping edits inside assigned scope.
+4. Use project specs and quality sources as checklist context; runtime gates remain kernel-owned commands.
+5. Run the planned verification commands and report changed files, acceptance IDs, verification commands, and spec updates or why none were needed.
 
 Rules:
 - MUST NOT spawn, wait for, list, or close other agents.
-- MUST NOT run task start, task finish, task archive, or unscoped resume.
-- MUST NOT commit or push.
-- Keep edits inside requested scope.
-- Do not treat shallow tests as TDD evidence; red-green-refactor proof must include redCommand, redExitCode, greenCommand, greenExitCode, and decision-anchor acceptance ID mapping.
-- Report changed files and exact verification commands.
-- BEFORE editing any source file, run the deterministic coding gate and treat a
-  nonzero exit as a hard blocker:
-  ./.cowork-flow/run python .cowork-flow/scripts/common/gates/validate_coding_standards.py --validate --repo-root .
-  This gate enforces machine-decidable UTF-8/IO checks. Backend/frontend
-  natural-language markdown remains checklist context, not dynamic hard validators.
-- Run or inspect machine warning output, fix real issues, and record any
-  acknowledged warning in `<task>/quality-review.jsonl`.
-- Record Definition of Done coverage and quality checklist evidence in
-  `<task>/quality-review.jsonl`.
+- MUST NOT run task start, finish, archive, unscoped resume, commit, or push.
+- Do not create task-local review artifacts, `tdd.jsonl`, or TDD evidence records in `check.jsonl`.
+- Do not claim completion without current verification.
 """
 
 [features]

package/template/.codex/agents/cowork-research.toml

@@ -5,32 +5,18 @@ sandbox_mode = "workspace-write"
 developer_instructions = """
 You are the `cowork-research` subagent.
 
-Formal `cowork-research` work requires runtime-context dispatch. The prompt or
-host metadata must provide:
+Read and apply `.agents/skills/agent-dispatch/SKILL.md` before research work.
 
-cowork_runtime_context_id: <runtime_context_id>
-cowork_host_context_key: <host_context_key>
-
-The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
-before workflow state is injected. The first child step must still run:
-
-./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
-
-On Windows, use:
-
-.\\.cowork-flow\\run.cmd subagent bind <runtime_context_id> <host_context_key>
-
-If the explicit bind fails, or if the bound runtime context is missing, closed,
-invalid, or names another agent type, report needs_context and do not execute
-the task.
+Execution:
+1. Follow `agent-dispatch` to bind runtime context. If binding fails, report `needs_context` and stop.
+2. Read the task directory, assignment, and prompt-named context.
+3. Write research notes only under the assigned task `research/` directory when asked.
+4. Report sourced findings, uncertainty, and recommended next action.
 
 Rules:
-- Read the task directory from the bound runtime context.
-- Write only under `<task>/research/`.
-- Do not modify code, specs, task state, or git.
-- Persist findings to Markdown files.
 - MUST NOT spawn, wait for, list, or close other agents.
-- Report created research files and the evidence they contain.
+- MUST NOT edit code, specs, task state, or git state.
+- MUST NOT run task start, finish, archive, unscoped resume, commit, or push.
 """
 
 [features]

package/template/.codex/hooks/inject-workflow-state.py

@@ -49,7 +49,7 @@ def main() -> int:
         return 0
     scripts_dir = root / ".cowork-flow" / "scripts"
     sys.path.insert(0, str(scripts_dir))
-    from common.host.workflow_state_hook import (
+    from adapters.host.workflow_state_hook import (
         build_hook_context,
         codex_dispatch_mode,
     )

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.43
+0.0.44

package/template/.cowork-flow/scripts/adapters/__init__.py

@@ -0,0 +1 @@
+"""External adapters for cowork-flow runtime integrations."""

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

@@ -0,0 +1,14 @@
+"""Allow CLI adapter scripts to import the scripts package when run directly."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[2]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+from adapters.cli.encoding import configure_cli_encoding
+
+configure_cli_encoding()

package/template/.cowork-flow/scripts/{commands → adapters/cli}/add_session.py

@@ -21,7 +21,7 @@ if __package__:
     from . import _bootstrap as _bootstrap  # noqa: F401
 else:
     import _bootstrap  # noqa: F401
-from common.core.paths import (
+from infra.paths import (
     DIR_TASKS,
     DIR_WORKFLOW,
     DIR_WORKSPACE,
@@ -31,8 +31,8 @@ from common.core.paths import (
     get_developer,
     get_workspace_dir,
 )
-from common.core.developer import ensure_developer
-from common.core.config import get_session_commit_message, get_max_journal_lines
+from infra.developer_profile import ensure_developer
+from infra.config import get_session_commit_message, get_max_journal_lines
 
 MARKER_CURRENT_STATUS_START = "@@@auto:current-status"
 MARKER_CURRENT_STATUS_END = "@@@/auto:current-status"

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

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Thin adapter for the Batch-execution Skill runtime."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from infra.skill_manifest import SkillManifestError, skill_command_scripts
+
+
+BATCH_APPROVAL_REQUIRED_CODE = "BATCH-APPROVAL-REQUIRED"
+BATCH_REJECTED_EXIT_CODE = 2
+
+
+class BatchExecutionError(RuntimeError):
+    """Raised when the Skill runtime cannot be loaded."""
+
+    code = "BATCH-RUNTIME-UNAVAILABLE"
+
+    def __init__(self, detail: str) -> None:
+        self.detail = detail
+        super().__init__(detail)
+
+
+def _batch_action_script(repo_root: Path) -> Path:
+    try:
+        script = skill_command_scripts(repo_root).get("batch-action")
+    except SkillManifestError as error:
+        raise BatchExecutionError(f"Skill manifest invalid: {error}") from error
+    if script is None:
+        raise BatchExecutionError("batch-action Skill command is missing")
+    return script
+
+
+def _run_batch_action(
+    repo_root: Path,
+    *args: str,
+) -> int:
+    script = _batch_action_script(repo_root)
+    try:
+        completed = subprocess.run(
+            [sys.executable, str(script), *args],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+    except OSError as error:
+        raise BatchExecutionError(f"cannot execute batch-action: {error}") from error
+    if completed.stdout:
+        print(completed.stdout, end="")
+    if completed.stderr:
+        print(completed.stderr, end="", file=sys.stderr)
+    return int(completed.returncode)
+
+
+def confirm_batch_eligible(
+    repo_root: Path,
+    task_dir: Path,
+    args: argparse.Namespace,
+) -> tuple[bool, str]:
+    """Require explicit approval before creating Batch runtime state."""
+    del repo_root, task_dir
+    if not getattr(args, "approved", False):
+        return False, "Batch mode requires --approved"
+    return True, ""
+
+
+def run_batch_entry(
+    repo_root: Path,
+    first_task_dir: Path,
+    args: argparse.Namespace,
+) -> int:
+    """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:
+        return _run_batch_action(repo_root, "start", first_task_dir.name)
+    except BatchExecutionError as error:
+        code = getattr(error, "code", "BATCH-RUNTIME-ERROR")
+        detail = getattr(error, "detail", str(error))
+        print(f"Error [{code}]: {detail}", file=sys.stderr)
+        return BATCH_REJECTED_EXIT_CODE

package/template/.cowork-flow/scripts/{commands → adapters/cli}/change.py

@@ -15,8 +15,8 @@ if __package__:
     from . import _bootstrap as _bootstrap  # noqa: F401
 else:
     import _bootstrap  # noqa: F401
-from common.task.archive_utils import archive_directory_resumable
-from common.core.paths import (
+from infra.archive_utils import archive_directory_resumable
+from infra.paths import (
     DIR_ARCHIVE,
     DIR_CHANGES,
     DIR_WORKFLOW,

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

@@ -0,0 +1,28 @@
+"""CLI stream encoding setup."""
+
+from __future__ import annotations
+
+import io
+import sys
+
+
+def _configure_stream(stream: object) -> object:
+    if hasattr(stream, "reconfigure"):
+        stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
+        return stream
+    if hasattr(stream, "detach"):
+        return io.TextIOWrapper(
+            stream.detach(),  # type: ignore[union-attr]
+            encoding="utf-8",
+            errors="replace",
+        )
+    return stream
+
+
+def configure_cli_encoding() -> None:
+    """Configure stdio for UTF-8 when CLI scripts run on Windows."""
+    if sys.platform != "win32":
+        return
+    sys.stdout = _configure_stream(sys.stdout)  # type: ignore[assignment]
+    sys.stderr = _configure_stream(sys.stderr)  # type: ignore[assignment]
+    sys.stdin = _configure_stream(sys.stdin)  # type: ignore[assignment]

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

@@ -0,0 +1,121 @@
+"""CLI argument adapters for execution context flags."""
+
+from __future__ import annotations
+
+import argparse
+
+from runtime.execution_context import (
+    MODE_COORDINATOR,
+    MODE_NONE,
+    MODE_SUBAGENT,
+    MODE_WORKER,
+    ExecutionContext,
+    ExecutionContextError,
+    execution_context_from_values,
+)
+
+
+PUBLIC_CONTEXT_FLAGS = {
+    "--mode",
+    "--assignment",
+    "--task-dir",
+    "--prompt-file",
+    "--context-file",
+}
+
+
+def _build_parser(
+    *,
+    add_help: bool,
+    mode_flag: str,
+    assignment_flag: str,
+    task_dir_flag: str,
+    prompt_file_flag: str,
+    context_file_flag: str,
+) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(add_help=add_help)
+    parser.add_argument(
+        mode_flag,
+        choices=[MODE_NONE, MODE_COORDINATOR, MODE_WORKER, MODE_SUBAGENT],
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(assignment_flag, help=argparse.SUPPRESS)
+    parser.add_argument(task_dir_flag, help=argparse.SUPPRESS)
+    parser.add_argument(prompt_file_flag, help=argparse.SUPPRESS)
+    parser.add_argument(context_file_flag, help=argparse.SUPPRESS)
+    return parser
+
+
+def build_public_execution_context_parser(add_help: bool = False) -> argparse.ArgumentParser:
+    return _build_parser(
+        add_help=add_help,
+        mode_flag="--mode",
+        assignment_flag="--assignment",
+        task_dir_flag="--task-dir",
+        prompt_file_flag="--prompt-file",
+        context_file_flag="--context-file",
+    )
+
+
+def build_internal_execution_context_parser(add_help: bool = False) -> argparse.ArgumentParser:
+    return _build_parser(
+        add_help=add_help,
+        mode_flag="--execution-mode",
+        assignment_flag="--execution-assignment",
+        task_dir_flag="--execution-task-dir",
+        prompt_file_flag="--execution-prompt-file",
+        context_file_flag="--execution-context-file",
+    )
+
+
+def parse_public_execution_context_args(argv: list[str]) -> tuple[ExecutionContext, list[str]]:
+    parser = build_public_execution_context_parser(add_help=False)
+    leading: list[str] = []
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+        if token in PUBLIC_CONTEXT_FLAGS:
+            if index + 1 >= len(argv):
+                raise ExecutionContextError(f"missing value for {token}")
+            leading.extend([token, argv[index + 1]])
+            index += 2
+            continue
+        break
+
+    namespace, leftover = parser.parse_known_args(leading)
+    if leftover:
+        raise ExecutionContextError(f"unsupported execution context arguments: {' '.join(leftover)}")
+    context = execution_context_from_values(
+        mode=getattr(namespace, "mode", None),
+        assignment=getattr(namespace, "assignment", None),
+        task_dir=getattr(namespace, "task_dir", None),
+        prompt_file=getattr(namespace, "prompt_file", None),
+        context_file=getattr(namespace, "context_file", None),
+    )
+    return context, argv[index:]
+
+
+def execution_context_from_namespace(namespace: argparse.Namespace) -> ExecutionContext:
+    return execution_context_from_values(
+        mode=getattr(namespace, "execution_mode", None),
+        assignment=getattr(namespace, "execution_assignment", None),
+        task_dir=getattr(namespace, "execution_task_dir", None),
+        prompt_file=getattr(namespace, "execution_prompt_file", None),
+        context_file=getattr(namespace, "execution_context_file", None),
+    )
+
+
+def context_to_internal_cli_args(context: ExecutionContext) -> list[str]:
+    if context.is_default:
+        return []
+    if context.context_file:
+        return ["--execution-context-file", context.context_file]
+
+    args = ["--execution-mode", context.mode]
+    if context.task_dir:
+        args.extend(["--execution-task-dir", context.task_dir])
+    if context.assignment:
+        args.extend(["--execution-assignment", context.assignment])
+    if context.prompt_file:
+        args.extend(["--execution-prompt-file", context.prompt_file])
+    return args