cowork-flow 0.0.19 → 0.0.21

package/template/.agent/skills/brainstorming/SKILL.md

@@ -5,24 +5,28 @@ description: Use when requirements are unclear, a requested change has multiple
 
 # Brainstorming
 
-Use this skill to turn an idea into a clear change request before code changes begin.
+Use this skill as the active clarification gate for new requirements. Turn an idea into a clear change request before PRD, planning, fixed-agent dispatch, or code changes begin.
 
 ## Flow
 
 1. Read only the context needed to understand the project area: `AGENTS.md`, `.cowork-flow/workflow.md`, and relevant spec indexes.
-2. State assumptions, success criteria, and the smallest useful scope.
-3. Ask one high-value question only when the answer cannot be inferred safely.
-4. Present 2-3 viable approaches when trade-offs matter, with a concrete recommendation.
-5. For L1/L2 work, create or update the change/task artifacts required by `.cowork-flow/workflow.md`.
-6. Hand off to `writing-plans` when the requested behavior and acceptance criteria are clear.
+2. State the goal, non-goals, assumptions, scope boundary, success criteria, and the smallest useful scope.
+3. Ask one high-value question only when the answer cannot be inferred safely; otherwise proceed with explicit assumptions.
+4. Present 2-3 viable approaches when trade-offs matter, with a concrete recommended direction.
+5. Do not write PRD, planning, or fixed-agent dispatch input until the direction and acceptance criteria are clear.
+6. For L1/L2 work, create or update the change/task artifacts required by `.cowork-flow/workflow.md` after the clarification output is stable.
+7. Hand off to `writing-plans` when the requested behavior and acceptance criteria are clear.
 
 ## Output
 
 Keep the result practical:
 
-- Goal and non-goals.
-- Chosen approach and rejected alternatives.
+- Goal.
+- Non-goals.
+- Key assumptions.
+- Scope boundary, including in-scope and out-of-scope work.
+- Recommended direction and rejected alternatives.
 - Acceptance criteria.
-- Open risks or blockers.
+- Open questions, risks, or blockers, with their impact on the next step.
 
 Do not implement during brainstorming unless the user explicitly changes the request to a direct edit.

package/template/.agent/skills/finish-work/SKILL.md

@@ -25,8 +25,8 @@ Before claiming completion, verify:
 2. Run `git diff --check`.
 3. Run focused tests and then broader project verification when appropriate.
 4. Update the plan/task status.
-5. If commit policy allows, stage only expected files and commit.
-6. Archive completed task/change artifacts when requested or required by workflow.
-7. Record the session with `.cowork-flow/run add-session` after code policy is satisfied.
+5. Archive completed task/change artifacts when requested or required by workflow.
+6. Record the session with `.cowork-flow/run add-session --commit "-"` unless a prior commit hash is intentionally being recorded.
+7. If commit policy allows, stage only expected files and commit once.
 
 If the user asks not to commit, stop before staging and report the verified state.

package/template/.agent/skills/meta/SKILL.md

@@ -18,7 +18,7 @@ Keep those copies aligned unless there is a documented reason not to.
 
 ## Rules
 
-- Prefer the current fixed-agent model: main session coordinates, child agents execute bounded tasks, `fork_turns="none"`.
+- Prefer the current fixed-agent model: main session coordinates through the active Host Adapter, child agents execute bounded tasks with fresh context.
 - Do not add compatibility fallback paths for removed workflow models unless the user explicitly asks.
 - Delete stale skills, prompts, tests, and docs when their behavior is no longer valid.
 - Update tests that guard template contents, packaging, hooks, and task context generation.

package/template/.agent/skills/start/SKILL.md

@@ -5,27 +5,38 @@ description: Use when starting or resuming main-session work in a cowork-flow pr
 
 # Start
 
-This skill is for the main session. A bounded delegated task should use `entry-boundary` and then execute the delegated prompt directly.
+This skill is for the main session only. Formal subagents are accepted only after runtime context binding is recorded and must not load this startup flow.
 Main repository changes follow `Plan -> Implement -> Check -> Finish`.
-Before loading state, classify the actual prompt. If it is a bounded delegated task, stop using this skill and execute that delegated prompt. A `任务：` / `约束：` / `输出：` structure is a strong delegated-task signal. Advisory/default subagent prompts should start with a natural-language delegated-task sentence rather than relying on repo bootstrap to infer intent. Keep project rules as constraints only.
+Before loading state, classify only whether the current request is a
+main-session request, read-only question, command-only wrapper, or unclear
+input. Do not infer subagent identity from prompt shape. If a child has
+`cowork_runtime_context_id`, hook/plugin binding may run early; otherwise the
+child must run the explicit shim bind before formal work.
 
 ## Load State
 
 1. Read `AGENTS.md`.
 2. Read `.cowork-flow/workflow.md`.
-3. Run `.cowork-flow/run resume` or `.\.cowork-flow\run.cmd resume` on Windows.
-4. Read the active task PRD and JSONL indexes only when a task is active.
-5. Read relevant `.cowork-flow/spec/*/index.md` files before code changes.
+3. Read `.cowork-flow/config.yaml` for Codex dispatch hints and lifecycle hooks.
+4. Run `.cowork-flow/run resume` or `.\.cowork-flow\run.cmd resume` on Windows.
+5. Read the active task PRD and JSONL indexes only when a task is active.
+6. Read relevant `.cowork-flow/spec/*/index.md` files before code changes.
 
 Report active task, workflow state, blockers, and the next phase.
 
 ## Route
 
-Route in stages. Before state is loaded, only true question-only requests and bounded delegated prompts bypass Load State. Repository-changing main-session requests load state first. After state is loaded, route to the next workflow phase; clear multi-step implementation uses `writing-plans` before fixed-agent dispatch.
+Route in stages. Before state is loaded, true question-only requests may bypass
+Load State. Repository-changing main-session requests load state first. After
+state is loaded, apply the requirement clarification gate from
+`.cowork-flow/workflow.md`, then route to the next workflow phase; clear
+multi-step implementation uses `writing-plans` before fixed-agent dispatch.
+
+New requirements that are unclear, boundary-unclear, multi-approach, behavior-changing, or missing acceptance criteria use `brainstorming` before PRD, planning, or fixed-agent dispatch. Small repository changes proceed directly only when the goal, scope boundary, and acceptance criteria are already clear.
 
 - Question-only work: answer directly.
-- Small repository change: classify by `.cowork-flow/workflow.md`, create/start a task if required, then proceed.
-- Unclear or multi-approach work: use `brainstorming`.
+- Small repository change with clear goal/scope/acceptance: classify by `.cowork-flow/workflow.md`, create/start a task if required, then proceed.
+- Unclear, boundary-unclear, behavior-changing, or multi-approach work: use `brainstorming`.
 - Multi-step implementation: use `writing-plans`, then dispatch fixed agents where appropriate.
 - Before coding: use `before-dev`.
 - After implementation: use `check`, then `finish-work`.
@@ -41,14 +52,27 @@ Route in stages. Before state is loaded, only true question-only requests and bo
 
 The main session owns coordination:
 
-- Research: `spawn_agent(agent_type="cowork-research", fork_turns="none")`
-- Implementation: `spawn_agent(agent_type="cowork-implement", fork_turns="none")`
-- Verification: `spawn_agent(agent_type="cowork-check", fork_turns="none")`
+- Research: dispatch `cowork-research` through the active Host Adapter.
+- Implementation: dispatch `cowork-implement` through the active Host Adapter.
+- Verification: dispatch `cowork-check` through the active Host Adapter.
 
-Every dispatch prompt starts with:
+Every formal dispatch uses runtime-context dispatch:
 
 ```text
-Active task: <task-dir>
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
 ```
 
-After dispatch, use `wait_agent`, review the output, inspect `list_agents`, and `close_agent`.
+Before spawning a formal child, create a runtime context with
+`.cowork-flow/run subagent init` and pass the returned prompt transport through
+the active Host Adapter. The child's first step is
+`.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>`; if a
+hook/plugin already bound the same key, this command is idempotent. The parent
+must verify `status=bound` and `bound_context_key=<host_context_key>` before
+accepting output. If binding is missing, closed, invalid, or mismatched, the
+child fails closed and must not run start/resume/task activation/archive/commit
+or coordinate other agents.
+
+After dispatch, use adapter wait/list/cancel primitives, review the output,
+verify deliverables, and close the runtime context with
+`.cowork-flow/run subagent close <runtime_context_id>`.

package/template/.agent/skills/writing-plans/SKILL.md

@@ -27,7 +27,7 @@ Start with:
 ```markdown
 # <Feature> Implementation Plan
 
-> For agentic workers: use `spawn_agent(agent_type="cowork-implement", fork_turns="none")` for implementation and `spawn_agent(agent_type="cowork-check", fork_turns="none")` for verification. Every dispatch prompt starts with `Active task: <task-dir>`.
+> For formal fixed-agent work: create a runtime context with `.cowork-flow/run subagent init`, pass `cowork_runtime_context_id: <runtime_context_id>` through the active Host Adapter, then dispatch `cowork-implement` or `cowork-check`. Close the runtime context after verification.
 
 **Goal:** <one sentence>
 **Architecture:** <2-3 sentences>

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

@@ -0,0 +1,41 @@
+---
+name: cowork-check
+description: Cowork-flow check fixed subagent.
+tools: Read, Write, Edit, MultiEdit, Grep, Glob, LS, Bash
+---
+
+You are the `cowork-check` fixed subagent for Claude Code.
+You are a leaf executor and must not invoke other agents.
+
+Formal `cowork-check` work requires a bound runtime context. The prompt, host
+metadata, or environment must provide:
+
+```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>
+```
+
+If the explicit bind fails, or if the bound context is missing, closed, invalid,
+or names another agent type, report `needs_context` and stop. Do not use
+`COWORK_ENTRY_CONTRACT_V1` to infer subagent identity; that contract classifies
+main-session prompts only.
+
+Rules:
+
+- Read the task directory from the bound runtime context.
+- Read `<task>/prd.md`, `<task>/check.jsonl`, `git diff`, and each JSONL `file`
+  entry.
+- Check acceptance criteria, tests, scope, and spec sync.
+- Fix in-scope issues directly when small and clear.
+- Report findings, fixes, and exact verification commands.
+- Do not use the Task tool or invoke subagents.
+- Do not run task start, task finish, task archive, unscoped resume, commit, or
+  push.

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

@@ -0,0 +1,40 @@
+---
+name: cowork-implement
+description: Cowork-flow implementation fixed subagent.
+tools: Read, Write, Edit, MultiEdit, Grep, Glob, LS, Bash
+---
+
+You are the `cowork-implement` fixed subagent for Claude Code.
+You are a leaf executor and must not invoke other agents.
+
+Formal `cowork-implement` work requires a bound runtime context. The prompt,
+host metadata, or environment must provide:
+
+```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>
+```
+
+If the explicit bind fails, or if the bound context is missing, closed, invalid,
+or names another agent type, report `needs_context` and stop. Do not use
+`COWORK_ENTRY_CONTRACT_V1` to infer subagent identity; that contract classifies
+main-session prompts only.
+
+Rules:
+
+- Read the task directory from the bound runtime context.
+- Read `<task>/prd.md`, `<task>/info.md` if present, `<task>/implement.jsonl`,
+  and each JSONL `file` entry.
+- Keep edits inside the assigned scope.
+- Report changed files and exact verification commands.
+- Do not use the Task tool or invoke subagents.
+- Do not run task start, task finish, task archive, unscoped resume, commit, or
+  push.

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

@@ -0,0 +1,40 @@
+---
+name: cowork-research
+description: Cowork-flow research fixed subagent.
+tools: Read, Grep, Glob, LS
+---
+
+You are the `cowork-research` fixed subagent for Claude Code.
+You are a leaf executor and must not invoke other agents.
+
+Formal `cowork-research` work requires a bound runtime context. The prompt,
+host metadata, or environment must provide:
+
+```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>
+```
+
+If the explicit bind fails, or if the bound context is missing, closed, invalid,
+or names another agent type, report `needs_context` and stop. Do not use
+`COWORK_ENTRY_CONTRACT_V1` to infer subagent identity; that contract classifies
+main-session prompts only.
+
+Rules:
+
+- Read the task directory and assignment 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.

package/template/.claude/commands/cowork-check.md

@@ -0,0 +1,27 @@
+---
+description: Dispatch cowork-flow check fixed subagent.
+argument-hint: "<task-dir>"
+---
+
+Use the `cowork-check` agent for `$ARGUMENTS`.
+
+Before dispatch, create a runtime context:
+
+```bash
+./.cowork-flow/run subagent init --role check --agent-type cowork-check --execution-task-dir "$ARGUMENTS" --title "Check $ARGUMENTS" --host claude-code --adapter claude-code.subagent
+```
+
+Pass the returned prompt transport to the subagent:
+
+```text
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
+```
+
+The child must first bind the runtime context before role work:
+
+```bash
+./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
+```
+
+Missing, closed, invalid, mismatched, or unbound context is `needs_context`.

package/template/.claude/commands/cowork-implement.md

@@ -0,0 +1,27 @@
+---
+description: Dispatch cowork-flow implementation fixed subagent.
+argument-hint: "<task-dir>"
+---
+
+Use the `cowork-implement` agent for `$ARGUMENTS`.
+
+Before dispatch, create a runtime context:
+
+```bash
+./.cowork-flow/run subagent init --role implement --agent-type cowork-implement --execution-task-dir "$ARGUMENTS" --title "Implement $ARGUMENTS" --host claude-code --adapter claude-code.subagent
+```
+
+Pass the returned prompt transport to the subagent:
+
+```text
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
+```
+
+The child must first bind the runtime context before role work:
+
+```bash
+./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
+```
+
+Missing, closed, invalid, mismatched, or unbound context is `needs_context`.

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

@@ -0,0 +1,27 @@
+---
+description: Dispatch cowork-flow research fixed subagent.
+argument-hint: "<task-dir>"
+---
+
+Use the `cowork-research` agent for `$ARGUMENTS`.
+
+Before dispatch, create a runtime context:
+
+```bash
+./.cowork-flow/run subagent init --role research --agent-type cowork-research --execution-task-dir "$ARGUMENTS" --title "Research $ARGUMENTS" --host claude-code --adapter claude-code.subagent
+```
+
+Pass the returned prompt transport to the subagent:
+
+```text
+cowork_runtime_context_id: <runtime_context_id>
+cowork_host_context_key: <host_context_key>
+```
+
+The child must first bind the runtime context before role work:
+
+```bash
+./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
+```
+
+Missing, closed, invalid, mismatched, or unbound context is `needs_context`.

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

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Emit cowork-flow workflow context for Claude Code hooks."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+TAG_RE = re.compile(
+    r"\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n(.*?)\n\s*\[/workflow-state:\1\]",
+    re.DOTALL,
+)
+DEFAULT_CONTRACT_REGISTRY = {
+    "contracts": [
+        {
+            "id": "COWORK_ENTRY_CONTRACT_V1",
+            "path": ".cowork-flow/spec/entry-contract.md",
+            "digest": [
+                "Classify main-session requests before task start, resume, archive, or commit.",
+                "Runtime context, not prompt labels, identifies formal subagent sessions.",
+            ],
+            "readWhen": ["before task start/resume/archive", "when prompt and bootstrap text conflict"],
+        },
+        {
+            "id": "RUNTIME_CONTEXT_DISPATCH_V2",
+            "path": ".cowork-flow/spec/subagent-dispatch.md",
+            "digest": [
+                "Formal subagent work is keyed by cowork_runtime_context_id.",
+                "Explicit shim bind records bound_context_key before formal output is accepted.",
+            ],
+            "readWhen": ["before formal subagent dispatch", "when checking subagent health"],
+        },
+    ]
+}
+
+
+def _find_repo_root(start: Path) -> Path | None:
+    current = start.resolve()
+    while True:
+        if (current / ".cowork-flow").is_dir():
+            return current
+        if current == current.parent:
+            return None
+        current = current.parent
+
+
+def _read_hook_input() -> dict[str, Any]:
+    try:
+        raw = sys.stdin.buffer.read()
+    except AttributeError:
+        text = sys.stdin.read()
+    else:
+        if not raw.strip():
+            return {}
+        try:
+            text = raw.decode("utf-8-sig")
+        except UnicodeDecodeError:
+            encoding = getattr(sys.stdin, "encoding", None) or "utf-8"
+            text = raw.decode(encoding, errors="replace")
+    if not text.strip():
+        return {}
+    try:
+        data = json.loads(text)
+    except (json.JSONDecodeError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _hook_event_name(hook_input: dict[str, Any]) -> str:
+    value = hook_input.get("hook_event_name") or hook_input.get("hookEventName")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return "UserPromptSubmit"
+
+
+def _normalize_hook_input(hook_input: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(hook_input)
+    if "claude_session_id" not in normalized:
+        session_id = normalized.get("session_id")
+        if isinstance(session_id, str) and session_id.strip():
+            normalized["claude_session_id"] = session_id
+    return normalized
+
+
+def _load_breadcrumbs(root: Path) -> dict[str, str]:
+    workflow = root / ".cowork-flow" / "spec" / "workflow-state-templates.md"
+    try:
+        text = workflow.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    return {match.group(1): match.group(2).strip() for match in TAG_RE.finditer(text)}
+
+
+def _as_string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, str) and item.strip()]
+
+
+def _load_contract_registry(root: Path) -> list[dict[str, Any]]:
+    registry_file = root / ".cowork-flow" / "spec" / "registry.json"
+    try:
+        data = json.loads(registry_file.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        data = DEFAULT_CONTRACT_REGISTRY
+    contracts = data.get("contracts") if isinstance(data, dict) else None
+    if not isinstance(contracts, list):
+        contracts = DEFAULT_CONTRACT_REGISTRY["contracts"]
+    return [contract for contract in contracts if isinstance(contract, dict)]
+
+
+def _contract_fingerprint(root: Path, contracts: list[dict[str, Any]]) -> str:
+    digest = hashlib.sha256()
+    digest.update(json.dumps(contracts, ensure_ascii=False, sort_keys=True).encode("utf-8"))
+    for contract in contracts:
+        path = contract.get("path")
+        if not isinstance(path, str) or not path.strip():
+            continue
+        try:
+            digest.update((root / path).read_bytes())
+        except OSError:
+            digest.update(f"missing:{path}".encode("utf-8"))
+    return digest.hexdigest()[:16]
+
+
+def _build_contract_digest(root: Path) -> str:
+    contracts = _load_contract_registry(root)
+    fingerprint = _contract_fingerprint(root, contracts)
+    lines = [
+        '<cowork-runtime host="claude-code" adapter="claude-code.hooks">',
+        f'<contract-digest fingerprint="{fingerprint}">',
+        "policy: repeat this short digest every hook; read full spec files only before listed actions.",
+    ]
+    for contract in contracts:
+        contract_id = contract.get("id")
+        path = contract.get("path")
+        if not isinstance(contract_id, str) or not contract_id.strip():
+            continue
+        path_text = path if isinstance(path, str) and path.strip() else "<missing-path>"
+        lines.append(f"- {contract_id}: {path_text}")
+        for item in _as_string_list(contract.get("digest"))[:2]:
+            lines.append(f"  digest: {item}")
+        read_when = _as_string_list(contract.get("readWhen"))
+        if read_when:
+            lines.append(f"  read_before: {'; '.join(read_when)}")
+    lines.extend(["</contract-digest>", "</cowork-runtime>"])
+    return "\n".join(lines)
+
+
+def _load_common(root: Path) -> None:
+    scripts_dir = root / ".cowork-flow" / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+
+
+def _get_active_task(root: Path, hook_input: dict[str, Any]) -> tuple[str | None, str, str]:
+    _load_common(root)
+    try:
+        from common.active_task import get_active_task  # type: ignore[import-not-found]
+    except Exception:
+        return None, "no_task", "unavailable"
+
+    active = get_active_task(root, hook_input)
+    if not active.task_path:
+        return None, "no_task", active.source
+
+    task_dir = root / active.task_path
+    task_json = task_dir / "task.json"
+    try:
+        data = json.loads(task_json.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return active.task_path, "stale", active.source
+
+    status = data.get("status")
+    if not isinstance(status, str) or not status.strip():
+        status = "unknown"
+    return active.task_path, status.strip(), active.source
+
+
+def _resolve_runtime_context(root: Path, hook_input: dict[str, Any]) -> tuple[dict[str, Any] | None, str | None]:
+    _load_common(root)
+    try:
+        from common.active_task import (  # type: ignore[import-not-found]
+            bind_runtime_context,
+            read_runtime_context,
+            resolve_runtime_context_id,
+        )
+    except Exception:
+        return None, None
+
+    runtime_context_id = resolve_runtime_context_id(hook_input)
+    if not runtime_context_id:
+        return None, None
+
+    context = read_runtime_context(root, runtime_context_id)
+    if not context or context.get("scope") != "subagent" or context.get("status") == "closed":
+        return None, runtime_context_id
+
+    bound = bind_runtime_context(root, runtime_context_id, values=hook_input)
+    return bound or context, runtime_context_id
+
+
+def _subagent_runtime_lines(context: dict[str, Any]) -> list[str]:
+    assignment = context.get("assignment") if isinstance(context.get("assignment"), dict) else {}
+    lines = [
+        f"Runtime context: {context.get('runtime_context_id')}",
+        f"Agent: {context.get('agent_type') or 'unknown'}",
+        "Scope: subagent",
+        "Do not run start/resume/task start/archive/commit/spawn.",
+    ]
+    goal = assignment.get("goal") if isinstance(assignment, dict) else None
+    if isinstance(goal, str) and goal.strip():
+        lines.append(f"Goal: {goal.strip()}")
+    return lines
+
+
+def _build_context(
+    root: Path,
+    task_path: str | None,
+    status: str,
+    source: str,
+    breadcrumbs: dict[str, str],
+    extra_lines: list[str] | None = None,
+) -> str:
+    body = breadcrumbs.get(status) or "Refer to .cowork-flow/workflow.md for the current step."
+    if extra_lines:
+        body = "\n".join([body, *extra_lines])
+    if task_path is None:
+        header = f"Status: {status}\nSource: {source}"
+    else:
+        header = f"Task: {task_path}\nStatus: {status}\nSource: {source}"
+
+    return "\n\n".join(
+        [
+            "<claude-code-runtime>\nhooks: UserPromptSubmit, SessionStart\n</claude-code-runtime>",
+            _build_contract_digest(root),
+            f"<workflow-state>\n{header}\n{body}\n</workflow-state>",
+        ]
+    )
+
+
+def main() -> int:
+    if os.environ.get("COWORK_FLOW_HOOKS") == "0" or os.environ.get("COWORK_FLOW_DISABLE_HOOKS") == "1":
+        return 0
+
+    hook_input = _normalize_hook_input(_read_hook_input())
+    cwd_value = hook_input.get("cwd")
+    cwd = Path(cwd_value) if isinstance(cwd_value, str) and cwd_value.strip() else Path.cwd()
+    root = _find_repo_root(cwd)
+    if root is None:
+        return 0
+
+    event_name = _hook_event_name(hook_input)
+    breadcrumbs = _load_breadcrumbs(root)
+    runtime_context, runtime_context_id = (
+        _resolve_runtime_context(root, hook_input) if event_name == "UserPromptSubmit" else (None, None)
+    )
+    extra_lines: list[str] | None = None
+    if runtime_context is not None:
+        task_dir = runtime_context.get("task_dir")
+        task_path = task_dir.strip() if isinstance(task_dir, str) and task_dir.strip() else None
+        status = "delegated_subtask"
+        source = f"runtime-context:{runtime_context.get('runtime_context_id')}"
+        extra_lines = _subagent_runtime_lines(runtime_context)
+    elif runtime_context_id:
+        task_path = None
+        status = "delegated_subtask"
+        source = f"runtime-context-invalid:{runtime_context_id}"
+        extra_lines = [
+            f"Runtime context: {runtime_context_id}",
+            "Scope: subagent",
+            "Runtime context is missing, closed, or invalid. Do not run start/resume/task start/archive/commit/spawn.",
+        ]
+    else:
+        task_path, status, source = _get_active_task(root, hook_input)
+    additional_context = _build_context(root, task_path, status, source, breadcrumbs, extra_lines)
+
+    print(
+        json.dumps(
+            {
+                "hookSpecificOutput": {
+                    "hookEventName": event_name,
+                    "additionalContext": additional_context,
+                }
+            },
+            ensure_ascii=False,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())