cowork-flow 1.9.1 → 1.9.2

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Added
 
+## [1.9.2] - 2026-10-14
+
+### Added
+
+- **子代理切片机检与派发工具（派发默认化 M2）**：把"并行切片互不踩"从计划措辞变成运行时事实。① **切片所有权机检**：`subagent init --slice <name> --owns <path>...` 把所有权声明写进 `assignment`；同一任务内，若新 implement 上下文声明的 `owned_paths` 与任一未关闭 implement 上下文的声明相等或互为目录前缀（`\`/`/` 与尾斜杠归一，绝对与相对 `--execution-task-dir` 按同一把钥匙比较），初始化 fail-closed 报 `SUBAGENT-SLICE-001` 且被拒上下文不落盘；关闭（close）即释放路径，未声明 `--owns` 的既有调用不受任何影响。② **派发 prompt 渲染**：`subagent prompt <runtime_context_id>` 输出可直接粘贴的子代理提示——transport 两行原文 + "先读 assignment"指引 + goal/expected_output/切片，保持宿主无关（不写宿主专有协议串）。③ **敞口盘点**：`subagent list [--task <dir>] [--open]` 列上下文 id / status / agent_type / 任务 / slice 与 owns 摘要。④ **卫生提示**：doctor 对"completed 任务仍有未关闭子代理上下文"新增 warning `TASK-HYGIENE-COMPLETED-WITH-OPEN-SUBAGENTS`（只提示不门禁，exit 语义不变；hint 指向 `subagent list --task`）。契约同步：`subagent-dispatch.md` 新增 Implement Slices 段、`error-codes.md` 登记 `SUBAGENT-SLICE-001`、`agent-dispatch` 技能补 owned_paths 编辑边界。
+- **派发等待语义转为 converge（异步派发默认化）**：`subagent-dispatch.md` 的 Return Acceptance 首条从"用 wait 原语等待"改为汇合点语义——只要求收敛到子代理结果（wait 原语或宿主完成信号），前台/后台由宿主决定，不再暗示同步阻塞；路由技能 `cowork-flow` 的 Delegation 段新增三条：长任务优先后台派发（完成信号即汇合点、acceptance 在汇合后）；等待期主会话可做安全区工作（只读调查、运行时目录产物、独立 worktree）；汇合前不进子代理的场地（不改 tracked 树与本任务 anchor/计划、不做当前树 git 写与生命周期转换、不新开任务）。
+
 ## [1.9.1] - 2026-10-14
 
 ### Fixed
@@ -338,6 +345,7 @@
 此版本未保留本地条目正文，详情见 [GitHub Release](https://github.com/fishlikewater/cowork-flow/releases/tag/v0.0.47)。
 
 [Unreleased]: https://github.com/fishlikewater/cowork-flow/compare/v1.9.1...HEAD
+[1.9.2]: https://github.com/fishlikewater/cowork-flow/compare/v1.9.1...v1.9.2
 [1.9.1]: https://github.com/fishlikewater/cowork-flow/compare/v1.9.0...v1.9.1
 [1.9.0]: https://github.com/fishlikewater/cowork-flow/compare/v1.8.1...v1.9.0
 [1.8.1]: https://github.com/fishlikewater/cowork-flow/compare/v1.8.0...v1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "keywords": [
     "ai-agent",

package/presets/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Claude Code。",
   "displayName": "Cowork Flow",
   "author": {

package/presets/codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Codex。",
   "author": {
     "name": "fishlikewater",

package/presets/kimi-code/.kimi-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Kimi Code。",
   "author": {
     "name": "fishlikewater",

package/presets/qoder/.qoder-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Qoder。",
   "displayName": "Cowork Flow",
   "author": {

package/presets/zcode/.zcode-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 ZCode。",
   "author": {
     "name": "fishlikewater",

package/template/.cowork-flow/.version

@@ -1 +1 @@
-1.9.1
+1.9.2

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

@@ -34,6 +34,7 @@ from services.review_receipt import ReviewReceiptError, submit_review_receipt
 from services.workflow_runtime import (
     RuntimeContextError,
     RuntimeContextService,
+    normalize_relative_path,
 )
 from adapters.cli.execution_context_args import build_internal_execution_context_parser
 from infra.paths import get_repo_root
@@ -201,6 +202,23 @@ def _initial_context(
         {"file": item, "reason": "prompt-named context"}
         for item in args.allowed_context
     ]
+    assignment: dict = {
+        "title": args.title,
+        "goal": args.goal or args.title,
+        "allowed_context": allowed_context,
+        "expected_output": args.expected_output,
+        "source": args.source,
+    }
+    slice_name = (getattr(args, "slice", None) or "").strip()
+    if slice_name:
+        assignment["slice"] = slice_name
+    owned_paths: list[str] = []
+    for path in getattr(args, "owns", None) or []:
+        normalized = normalize_relative_path(path)
+        if normalized:
+            owned_paths.append(normalized)
+    if owned_paths:
+        assignment["owned_paths"] = owned_paths
     return {
         "schema_version": 2,
         "runtime_context_id": runtime_context_id,
@@ -215,13 +233,7 @@ def _initial_context(
             "kind": "prompt",
             "key": "cowork_runtime_context_id",
         },
-        "assignment": {
-            "title": args.title,
-            "goal": args.goal or args.title,
-            "allowed_context": allowed_context,
-            "expected_output": args.expected_output,
-            "source": args.source,
-        },
+        "assignment": assignment,
         "authority": {
             "may_start_task": False,
             "may_resume_main": False,
@@ -293,6 +305,76 @@ def cmd_status(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_prompt(args: argparse.Namespace) -> int:
+    """Render a paste-ready dispatch prompt for one runtime context.
+
+    Host-neutral by design: the two transport lines the runtime parses,
+    then generic pointers the child resolves itself via the CLI.
+    """
+    repo_root = get_repo_root()
+    try:
+        context = _find_subagent(repo_root, args.subagent_id)
+    except FileNotFoundError:
+        print(f"Error: subagent not found: {args.subagent_id}", file=sys.stderr)
+        return 1
+    assignment = context.get("assignment")
+    assignment = assignment if isinstance(assignment, dict) else {}
+    host_context_key = _suggest_host_context_key(
+        str(context.get("host") or ""),
+        args.subagent_id,
+    )
+    lines = [
+        f"cowork_runtime_context_id: {args.subagent_id}",
+        f"cowork_host_context_key: {host_context_key}",
+        "",
+        "First read your assignment; do not infer it from this prompt:",
+        f".cowork-flow/run subagent status {args.subagent_id}",
+        f"Goal: {assignment.get('goal') or context.get('title') or ''}",
+        f"Expected output: {assignment.get('expected_output') or ''}",
+    ]
+    slice_name = assignment.get("slice")
+    owned = [str(path) for path in (assignment.get("owned_paths") or [])]
+    if slice_name or owned:
+        lines.append(f"Slice: {slice_name or '(unnamed)'}")
+        if owned:
+            lines.append(f"Owned paths: {', '.join(owned)}")
+    print("\n".join(lines))
+    return 0
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    repo_root = get_repo_root()
+    task_dir = getattr(args, "task", None)
+    if task_dir:
+        candidate = Path(task_dir)
+        if candidate.is_absolute():
+            try:
+                candidate = candidate.resolve().relative_to(repo_root.resolve())
+            except ValueError:
+                pass
+        task_dir = candidate.as_posix()
+    contexts = RuntimeContextService(repo_root).list_contexts(
+        task_dir=task_dir,
+        open_only=bool(getattr(args, "open", False)),
+    )
+    if not contexts:
+        print("no subagent contexts")
+        return 0
+    for context in contexts:
+        assignment = context.get("assignment")
+        assignment = assignment if isinstance(assignment, dict) else {}
+        owned = [str(path) for path in (assignment.get("owned_paths") or [])]
+        print(
+            f"{context.get('runtime_context_id', '?')}  "
+            f"{context.get('status', 'unknown')}  "
+            f"{context.get('agent_type', 'unknown')}  "
+            f"{context.get('task_dir') or '-'}  "
+            f"slice={assignment.get('slice') or '-'}  "
+            f"owns={','.join(owned) or '-'}"
+        )
+    return 0
+
+
 def cmd_update(args: argparse.Namespace) -> int:
     if args.status not in VALID_STATUSES:
         print(f"Error: status must be one of {', '.join(sorted(VALID_STATUSES))}", file=sys.stderr)
@@ -421,6 +503,13 @@ def build_parser() -> argparse.ArgumentParser:
     init.add_argument("--goal")
     init.add_argument("--expected-output", default="Files changed, validation commands, and blockers.")
     init.add_argument("--allowed-context", action="append", default=[])
+    init.add_argument("--slice", default=None, help="Slice name this child owns")
+    init.add_argument(
+        "--owns",
+        action="append",
+        default=[],
+        help="Owned repository-relative path (repeatable); overlapping claims of an open implement context fail closed",
+    )
     init.add_argument("--host", default=None)
     init.add_argument("--adapter", default=None)
     init.set_defaults(func=cmd_init)
@@ -429,6 +518,21 @@ def build_parser() -> argparse.ArgumentParser:
     status.add_argument("subagent_id")
     status.set_defaults(func=cmd_status)
 
+    prompt = subparsers.add_parser(
+        "prompt",
+        help="Render a paste-ready dispatch prompt for a runtime context",
+    )
+    prompt.add_argument("subagent_id")
+    prompt.set_defaults(func=cmd_prompt)
+
+    listing = subparsers.add_parser(
+        "list",
+        help="List subagent runtime contexts (open-first inventory)",
+    )
+    listing.add_argument("--task", default=None, help="Only contexts of this task directory")
+    listing.add_argument("--open", action="store_true", help="Only contexts not yet closed")
+    listing.set_defaults(func=cmd_list)
+
     update = subparsers.add_parser("update", help="Update subagent runtime status")
     update.add_argument("subagent_id")
     update.add_argument("--status", required=True)

package/template/.cowork-flow/scripts/runtime/session_state.py

@@ -207,6 +207,25 @@ def _read_json(path: Path) -> dict:
     return data if isinstance(data, dict) else {}
 
 
+def iter_subagent_contexts(repo_root: Path) -> list[dict]:
+    """Every readable subagent runtime context, ordered by context id.
+
+    The id falls back to the file name when the record omits it, so a
+    record still lists under the id its callers already know.
+    """
+    directory = subagent_contexts_dir(repo_root)
+    if not directory.is_dir():
+        return []
+    contexts: list[dict] = []
+    for path in sorted(directory.glob("*.json")):
+        data = _read_json(path)
+        if not data:
+            continue
+        data.setdefault("runtime_context_id", path.stem)
+        contexts.append(data)
+    return contexts
+
+
 def _write_json(
     path: Path,
     data: dict,

package/template/.cowork-flow/scripts/services/workflow_runtime.py

@@ -20,6 +20,7 @@ from runtime.session_state import (
     FIELD_RUNTIME_CONTEXT_ID,
     FIELD_SCOPE,
     SCOPE_SUBAGENT,
+    iter_subagent_contexts,
     logical_subagent_context_key,
     platform_from_context_key,
     resolve_context_key,
@@ -38,6 +39,38 @@ class RuntimeContextError(RuntimeError):
         super().__init__(f"{code}: {detail}")
 
 
+def normalize_relative_path(path: str) -> str:
+    """Repository-relative form used to compare ownership claims."""
+    normalized = path.strip().replace("\\", "/")
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    return normalized.strip("/")
+
+
+def slice_paths_overlap(left: str, right: str) -> bool:
+    """True when two owned paths are equal or one contains the other."""
+    a = normalize_relative_path(left)
+    b = normalize_relative_path(right)
+    if not a or not b:
+        return False
+    return a == b or a.startswith(b + "/") or b.startswith(a + "/")
+
+
+def owned_paths_overlap(
+    left: tuple[str, ...] | list[str],
+    right: tuple[str, ...] | list[str],
+) -> list[tuple[str, str]]:
+    """Every overlapping (left, right) pair of owned-path claims."""
+    overlaps: list[tuple[str, str]] = []
+    for a in left:
+        if not isinstance(a, str):
+            continue
+        for b in right:
+            if isinstance(b, str) and slice_paths_overlap(a, b):
+                overlaps.append((a, b))
+    return overlaps
+
+
 @dataclass(frozen=True)
 class RuntimeContextInitResult:
     """Files created for one runtime-context initialization."""
@@ -105,6 +138,17 @@ class RuntimeContextService:
                 logical_context_key=logical_context_key,
             )
 
+        conflicts = self.slice_conflicts(runtime_context_id, context)
+        if conflicts:
+            raise RuntimeContextError(
+                "SUBAGENT-SLICE-001",
+                "owned_paths overlap an open implement context of this task: "
+                + "; ".join(
+                    f"{other_id} owns {other_path}, overlaps {claimed_path}"
+                    for other_id, claimed_path, other_path in conflicts
+                ),
+            )
+
         unit = self._unit(
             self._operation_id("init", runtime_context_id),
             "runtime-context-init",
@@ -120,6 +164,102 @@ class RuntimeContextService:
             logical_context_key=logical_context_key,
         )
 
+    def slice_conflicts(
+        self,
+        runtime_context_id: str,
+        context: dict,
+    ) -> list[tuple[str, str, str]]:
+        """(other_id, claimed_path, conflicting_path) for open sibling slices.
+
+        Only implement contexts that declare `owned_paths` take part: an
+        init without an ownership claim can neither conflict nor be
+        conflicted with, and a closed context has released its paths.
+        """
+        if context.get("agent_type") != "cowork-implement":
+            return []
+        claimed = self._owned_paths(context)
+        if not claimed:
+            return []
+        task_dir = self._normalized_task_dir(str(context.get("task_dir") or ""))
+        if not task_dir:
+            return []
+        conflicts: list[tuple[str, str, str]] = []
+        for other in iter_subagent_contexts(self.repo_root):
+            other_id = str(other.get("runtime_context_id") or "")
+            if not other_id or other_id == runtime_context_id:
+                continue
+            if other.get("agent_type") != "cowork-implement":
+                continue
+            if other.get("status") == "closed":
+                continue
+            if self._normalized_task_dir(str(other.get("task_dir") or "")) != task_dir:
+                continue
+            for claimed_path, other_path in owned_paths_overlap(
+                claimed,
+                self._owned_paths(other),
+            ):
+                conflicts.append((other_id, claimed_path, other_path))
+        return conflicts
+
+    @staticmethod
+    def _task_dir_is_absolute(value: str) -> bool:
+        """Decide on the raw value, before any slash stripping.
+
+        Stripping first would turn a slash-rooted POSIX path into a
+        relative-looking one and silently disable the same-task comparison.
+        """
+        raw = value.strip().replace("\\", "/")
+        if raw.startswith("/"):
+            return True
+        return Path(raw).is_absolute()
+
+    def _normalized_task_dir(self, value: str) -> str:
+        """One task, one key: `--execution-task-dir` may arrive absolute."""
+        raw = value.strip().replace("\\", "/")
+        if self._task_dir_is_absolute(raw):
+            try:
+                return normalize_relative_path(
+                    str(
+                        Path(raw)
+                        .resolve()
+                        .relative_to(self.repo_root.resolve())
+                    )
+                )
+            except ValueError:
+                return normalize_relative_path(raw)
+        return normalize_relative_path(raw)
+
+    @staticmethod
+    def _owned_paths(context: dict) -> list[str]:
+        assignment = context.get("assignment")
+        owned = (
+            assignment.get("owned_paths")
+            if isinstance(assignment, dict)
+            else None
+        )
+        if not isinstance(owned, list):
+            return []
+        return [path for path in owned if isinstance(path, str) and path.strip()]
+
+    def list_contexts(
+        self,
+        *,
+        task_dir: str | None = None,
+        open_only: bool = False,
+    ) -> list[dict]:
+        """Subagent runtime contexts for inventory views (read-only)."""
+        wanted = self._normalized_task_dir(task_dir) if task_dir else None
+        contexts: list[dict] = []
+        for context in iter_subagent_contexts(self.repo_root):
+            if open_only and context.get("status") == "closed":
+                continue
+            if wanted is not None and self._normalized_task_dir(
+                str(context.get("task_dir") or "")
+            ) != wanted:
+                continue
+            contexts.append(context)
+        return contexts
+
     def update(
         self,
         runtime_context_id: str,

package/template/.cowork-flow/spec/contracts/error-codes.md

@@ -1,7 +1,7 @@
 # Runtime Error Codes
 
-Every `LIFECYCLE-*` error code the runtime can put in a result's `code` field, with
-the condition that produces it. A code is a stable contract: consumers match on the
+Every runtime error code that can reach a result's `code` field, with the
+condition that produces it. A code is a stable contract: consumers match on the
 code, never on the message text.
 
 Codes are defined in `scripts/services/*.py` and surface in CLI output, `--json`
@@ -28,6 +28,7 @@ results, and the closeout blockers.
 | `LIFECYCLE-TASK-001` | The task directory passed to a lifecycle command does not exist. | `services/task_lifecycle.py:529` |
 | `LIFECYCLE-TRANSITION-001` | The task's current status cannot transition to the target status of the stage being run. | `services/task_lifecycle.py:641` |
 | `LIFECYCLE-UOW-001` | The `UnitOfWork` write fails: task metadata cannot be re-read before commit/takeover, changed under it (optimistic-concurrency conflict), or `unit.commit()` raises. | `services/task_lifecycle.py:942` (also `:949`, `:998`, `:1051`, `:1059`, `:1095`) |
+| `SUBAGENT-SLICE-001` | A `cowork-implement` runtime context is initialized with `owned_paths` that equal, or nest with, the `owned_paths` of an open (not yet closed) implement context of the same task; nothing is written for the rejected context. | `services/workflow_runtime.py:144` |
 
 ## Non-error `LIFECYCLE-*` codes
 

package/template/.cowork-flow/spec/contracts/index.md

@@ -20,4 +20,4 @@ Current contracts:
 - `evidence-completion.md`: evidence-based completion — the `evidence.jsonl` schema, the `LIFECYCLE-AC-001/002/003/004` completion gate, `--allow-missing-evidence` exemption traces, and the injected coverage row.
 - `task-adopt.md`: task adoption — the entry boundary of `task next --run --adopt`, its preconditions (`LIFECYCLE-ADOPT-001`), the rebind + baseline reset + audit write, and how it differs from `--takeover`.
 - `task-board.md`: the shared board and dependency edges — the list/MCP board fields (executor / ownerSessionActive / evidenceCoverage / blocked), `--depends-on` declaration and validation, the start dependency gate (`LIFECYCLE-DEPENDENCY-001`), and the adopt handover receipt.
-- `error-codes.md`: the registry of every runtime `LIFECYCLE-*` error code with the condition that produces it: `LIFECYCLE-AC-001/002/003/004`, `LIFECYCLE-ADOPT-001`, `LIFECYCLE-CHECK-001`, `LIFECYCLE-CONTEXT-001`, `LIFECYCLE-DEPENDENCY-001`, `LIFECYCLE-EXECUTOR-001`, `LIFECYCLE-RECOVERY-001`, `LIFECYCLE-REVIEW-001/002/003/004`, `LIFECYCLE-TASK-001`, `LIFECYCLE-TRANSITION-001`, `LIFECYCLE-UOW-001`.
+- `error-codes.md`: the registry of every runtime error code with the condition that produces it: `LIFECYCLE-AC-001/002/003/004`, `LIFECYCLE-ADOPT-001`, `LIFECYCLE-CHECK-001`, `LIFECYCLE-CONTEXT-001`, `LIFECYCLE-DEPENDENCY-001`, `LIFECYCLE-EXECUTOR-001`, `LIFECYCLE-RECOVERY-001`, `LIFECYCLE-REVIEW-001/002/003/004`, `LIFECYCLE-TASK-001`, `LIFECYCLE-TRANSITION-001`, `LIFECYCLE-UOW-001`, `SUBAGENT-SLICE-001`.

package/template/.cowork-flow/spec/contracts/subagent-dispatch.md

@@ -38,6 +38,28 @@ verifies that support. If `subagent init` emits a suggested host context key,
 the parent may use that key unless the host adapter has a stronger stable child
 session key.
 
+## Implement Slices
+
+An implement context may declare the ownership slice it works on inside
+`assignment`: `slice` (a name) and `owned_paths` (repository-relative paths),
+recorded by `subagent init --slice <name> --owns <path>...`. The runtime then
+machine-checks slice cleanliness instead of leaving it to prose:
+
+- Initializing an implement context whose `owned_paths` equal, or nest with,
+  those of an open (not yet closed) implement context of the same task fails
+  closed with `SUBAGENT-SLICE-001`; nothing is written for the rejected
+  context.
+- A context that declares no `owned_paths` claims nothing, so it neither
+  conflicts with nor blocks anyone — existing plain `init` calls keep working
+  unchanged.
+- Closing a context releases its paths; a finished slice no longer blocks a
+  re-run of the same slice.
+
+`subagent list [--task <task-dir>] [--open]` inventories contexts with their
+status and ownership summary, and `subagent prompt <runtime_context_id>`
+renders the transport lines plus the assignment pointers as a paste-ready
+dispatch prompt.
+
 ## Binding Gate
 
 The child hook or plugin may resolve `cowork_runtime_context_id` early and bind
@@ -105,7 +127,9 @@ blocks completion regardless.
 
 ## Return Acceptance And Closeout
 
-- Wait for the child result with the adapter wait primitive.
+- Converge on the child result before acceptance — via the wait primitive or
+  the host's completion signal; the dispatch form (foreground or background)
+  is host-determined.
 - Confirm no stray running children with the adapter list primitive.
 - Verify the child report by checking files, commands, and results; do not
   trust completed text alone.

package/template/skills/agent-dispatch/SKILL.md

@@ -25,6 +25,8 @@ Use this Skill only inside fixed subagents such as `cowork-implement`,
 - Act as a leaf executor: do not spawn, wait for, list, or close other agents.
 - Do not start, finish, archive, resume, commit, or push workflow state.
 - Keep edits and reads inside the assigned runtime context and task scope.
+- When the assignment names `owned_paths`, keep every edit inside them; report
+  a needed edit outside the slice instead of making it.
 - Treat runtime gates as CLI adapters backed by kernel services; this Skill may
   explain when to run or report them, but does not enforce them.
 

package/template/skills/cowork-flow/SKILL.md

@@ -56,6 +56,15 @@ Dispatch follows the plan's execution strategy:
   requires — do not wait for the blocker to tell you.
 - Research-heavy work: dispatch two or three `cowork-research` children for
   independent questions instead of widening the main context.
+- Long-running children: prefer background dispatch when the host supports it;
+  the completion signal is the convergence point and acceptance runs after it.
+  Use foreground dispatch for short work or hosts without a background mode.
+- While a child runs, the main session keeps working on things that never
+  touch the child's ground: read-only investigation, runtime-directory work
+  (evidence, board, plan drafts, follow-up task drafts), separate worktrees.
+- Until convergence, stay off the child's ground: no edits to the tracked
+  worktree or this task's anchor/plan, no current-tree git writes or lifecycle
+  transitions, and do not start other tasks.
 
 Public Skills carry workflow guidance. Runtime Gates carry hard enforcement.
 Do not recreate an internal protocol layer or another process authority.

package/template/skills/runtime-health/scripts/doctor.py

@@ -233,6 +233,46 @@ def _session_task_paths(repo_root: Path) -> set[str]:
     return active
 
 
+def _normalized_task_path(value: str, repo_root: Path) -> str:
+    """One task, one key: recorded task dirs may be absolute.
+
+    Absoluteness is decided on the raw value before any slash stripping, so
+    a slash-rooted POSIX path is not mistaken for a relative one.
+    """
+    raw = value.strip().replace("\\", "/")
+    if raw.startswith("/") or Path(raw).is_absolute():
+        try:
+            return (
+                Path(raw).resolve().relative_to(repo_root.resolve()).as_posix()
+            )
+        except ValueError:
+            pass
+    normalized = raw
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    return normalized.strip("/")
+
+
+def _open_subagent_contexts_by_task(repo_root: Path) -> dict[str, list[str]]:
+    """Open subagent runtime contexts, keyed by their task directory."""
+    directory = repo_root / ".cowork-flow" / ".runtime" / "subagents"
+    open_by_task: dict[str, list[str]] = {}
+    if not directory.is_dir():
+        return open_by_task
+    for path in sorted(directory.glob("*.json")):
+        data = _task_metadata(path)
+        if data.get("status") == "closed":
+            continue
+        task_path = data.get("task_dir")
+        if not isinstance(task_path, str) or not task_path.strip():
+            continue
+        context_id = str(data.get("runtime_context_id") or path.stem)
+        open_by_task.setdefault(
+            _normalized_task_path(task_path, repo_root), []
+        ).append(context_id)
+    return open_by_task
+
+
 def _task_hygiene_issue(
     *,
     kind: str,
@@ -268,6 +308,7 @@ def check_task_hygiene(repo_root: Path) -> list[dict[str, str]]:
     if not tasks_dir.is_dir():
         return []
     bound_tasks = _session_task_paths(repo_root)
+    open_subagents = _open_subagent_contexts_by_task(repo_root)
     issues: list[dict[str, str]] = []
     for task_dir in sorted(tasks_dir.iterdir()):
         if not task_dir.is_dir() or task_dir.name == "archive":
@@ -301,6 +342,22 @@ def check_task_hygiene(repo_root: Path) -> list[dict[str, str]]:
                     hint=f"./.cowork-flow/run task next {task} --run --intent archive",
                 )
             )
+            open_ids = open_subagents.get(
+                _normalized_task_path(task, repo_root)
+            )
+            if open_ids:
+                issues.append(
+                    _task_hygiene_issue(
+                        kind="completed_with_open_subagents",
+                        task=task,
+                        status=status,
+                        message=(
+                            "completed task still has open subagent context(s): "
+                            + ", ".join(open_ids)
+                        ),
+                        hint=f"./.cowork-flow/run subagent list --task {task}",
+                    )
+                )
         if status in {"in_progress", "review"} and task not in bound_tasks:
             issues.append(
                 _task_hygiene_issue(