cowork-flow 1.9.1 → 2.0.0

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/backend/error-handling.md

@@ -1,19 +1,5 @@
 # 后端异常处理规范
 
-<!--
-本 spec 支持 frontmatter `checks:` 声明检查命令（规范挂命令契约见
-spec/contracts/spec-checks.md）。模板自带的声明由上游维护、sync 会覆盖
-本地修改；请把实际声明写进自建 spec 文件。示例：
-
----
-checks:
-  - cmd: python scripts/check_error_codes.py
-    files: "src/"
-    when: lifecycle
----
-
--->
-
 ## 目标
 
 - 调用方能稳定感知错误

package/template/.cowork-flow/spec/contracts/context-injection.md

@@ -23,7 +23,7 @@ would make the digest self-referential).
 | opencode | plugin `experimental.chat.system.transform` → shim (`cowork-flow/plugin-core.js`) → `inject.py --host opencode`, bare-text stdout | system-prompt section push; `shell.env` exports the context key to shell commands |
 | dsh | preset plugin system-prompt section | named section, replace semantics |
 | kimi-code | user-level `config.toml` (`$KIMI_CODE_HOME`, default `~/.kimi-code/`) `[[hooks]]` row on `UserPromptSubmit` → shim (`cowork-flow-inject.mjs`) → `inject.py --host kimi-code` | bare-text stdout appended to the prompt context, no `hookSpecificOutput` envelope |
-| qoder | machine-level plugin `hooks/hooks.json` (node, `${QODER_PLUGIN_ROOT}/hooks/inject-context.mjs`) → project `.cowork-flow/scripts/.../inject.py --host qoder`, stdout JSON | `hookSpecificOutput.{hookEventName, additionalContext}` plus a top-level `systemMessage` (a CLI-visible trace; the model context is unchanged); `PostToolUse` is not blockable there, so the edit advisory rides `additionalContext` on exit 0 |
+| qoder | machine-level plugin `hooks/hooks.json` (node, `${QODER_PLUGIN_ROOT}/hooks/inject-context.mjs`) → project `.cowork-flow/scripts/.../inject.py --host qoder`, stdout JSON | `hookSpecificOutput.{hookEventName, additionalContext}` plus a top-level `systemMessage` (a CLI-visible trace; the model context is unchanged) |
 
 The qoder row carries one delta beyond the shared envelope: `systemMessage`,
 emitted only on the two injecting events (`SessionStart`, `UserPromptSubmit`)
@@ -260,7 +260,7 @@ review time:
 <stage-contract task=".cowork-flow/tasks/08-30-demo">
 Scope: src/demo.py; src/next.py (+1 more in implement.jsonl) [agent-mutable]
 Specs: .cowork-flow/spec/backend/index.md (+1 more)
-Gates: edits outside Scope are review blockers; CLAUDE.md and workflow files are protected; spec/ edits may be allowed by review policy; scope is agent-mutable (self-declared via task context add)
+Gates: edits outside Scope are review blockers; CLAUDE.md and workflow files are protected; spec/ edits may be allowed by review policy; scope is agent-mutable (declare more in implement.jsonl)
 Verify: npm run test:fast; python3 -m pytest tests/ -q
 </stage-contract>
 ```
@@ -270,38 +270,65 @@ Verify: npm run test:fast; python3 -m pytest tests/ -q
   absolute paths, drive letters, wildcards, unsupported types — authorize
   nothing and are dropped, matching `context_paths.normalize_context_file_scope_entry`),
   first 8 + `(+N more)`. The scope is **agent-mutable** on main
-  (`task context add` can extend it) — it is a self-declared boundary, not a
-  hard fence; the label says so. Delegated sessions inherit the parent
+  (appending a scope entry to `implement.jsonl` extends it) — it is a
+  self-declared boundary, not a hard fence; the label says so. Delegated
+  sessions inherit the parent
   task's scope and see it as `[read-only]` — the child must not believe it
   can self-declare scope on the parent's behalf.
 - **Specs**: `.cowork-flow/spec/` pointer entries from implement.jsonl
   (first 4, same canonicality filter as Scope). Read them before coding; the
-  full files are not injected.
+  full files are not injected. Once the task is `in_progress`, the line
+  upgrades to `Specs: <spec>(<h2 heading tree>); …`: at most 6 h2 entries,
+  each truncated to 24 characters with `();` characters stripped; a missing
+  file adds no annotation. The digest is an entry-name index, not the prose,
+  and is hard-capped by `scope-rules.json` `stageContract.budget`; over
+  budget the whole line yields. The python/zcode output comes from a single
+  Python entrypoint, locked by the `test/stage-contract.test.js` matrix;
+  opencode transports that same entrypoint's output, so byte-exact equality
+  holds by construction.
 - **Gates**: static preview text, identical on all hosts; the delegated
   variant replaces the self-declaration sentence with "scope is inherited
   from the parent task (read-only reference)".
-- **Verify**: `## 验证命令` lines from decision-anchor (first 3, 120 chars
+- **Verify**: `## 验证命令` lines from decision-anchor (first 10, 120 chars
   each) — the agent's own declared self-checks; omitted when none.
-- **Per-edit warning (zcode only)**: PostToolUse on Edit/Write/MultiEdit
-  injects at most one line when the edited file is outside the scope
-  (`editScopeWarning: plugin`; every other host declares `unsupported` —
-  their fallback is this static stage-contract preview). Bash-initiated
-  writes (redirection, tee) are a declared residual gap: the warning covers
-  Edit/Write/MultiEdit tool invocations only. The PostToolUse matcher text
-  (`Bash|Edit|Write|MultiEdit`) is asserted by template tests but depends on
-  the ZCode runtime's tool names — there is no external runtime contract to
-  verify them against, so a runtime rename would silently disable the
-  warning; the matcher is the single switch. This bullet covers the scope
-  warning only; the spec-check violation line is a separate channel that
-  also reaches codex and opencode sessions (see spec-checks.md).
-- Budget: the whole block stays ≤ 1200 characters. Over-budget inputs
+- **Per-edit warning**: PostToolUse on an edit tool injects at most one
+  line when the edited file is outside the task's declared scope —
+  a frozen single line shared by every host, differing only in transport:
+  zcode / claude-code / codex / qoder return it as
+  `hookSpecificOutput.additionalContext`, opencode (bare-text `emit_text`)
+  appends it to the finished tool output, and dsh attaches it to the tool
+  result as a plugin notice. `editScopeWarning: plugin` is declared for
+  those six hosts; kimi-code declares `unsupported` because the host drops
+  PostToolUse stdout. Silence rules: no active in_progress/review task, a
+  subagent session, an in-scope path, or no extractable path; every failure
+  stays silent and every host exits 0 — the edit has already happened. No
+  host refreshes the workflow-state digest from this hook: the advisory is
+  the whole payload (state refreshes on the next injecting event, or on
+  dsh's `tools/result`).
+  Bash-initiated writes (redirection, tee) are a declared residual gap: the
+  warning covers edit tool invocations only. Each host's matcher text
+  (`Edit|Write|MultiEdit`, codex's `apply_patch|Write|Edit`, qoder's
+  `Edit|Write`) is asserted by template tests but depends on that host's
+  runtime's tool names — there is no external runtime contract to verify
+  them against, so a runtime rename would silently disable the warning; the
+  matcher is the single switch.
+- Budget: the whole block stays ≤ 3400 characters. Over-budget inputs
   degrade by dropping Verify, then Specs, then shrinking Scope entries
-  (min 1) — the closing tag and the Gates row always survive; tests assert
-  the block stays well-formed. The scope-filter rules and the stage-contract
+  (min 1), then truncating the Scope row's own text. The opening tag, the
+  closing tag and the Gates row always survive intact — a body-wide cut
+  would either truncate the tag every consumer matches on (making the block
+  invisible to them) or silently drop the edit-policy row, so neither is
+  allowed. Below the size those fixed rows plus a minimal `Scope: X` row
+  need, or when the cut would shave a `Scope: ` label off any row, the block
+  is returned whole and may exceed the budget: guard rows and parseability
+  outrank the budget.
+  The scope-filter rules and the stage-contract
   budget/limits come from `.cowork-flow/spec/runtime/scope-rules.json`, the
   single source consumed at runtime; a missing or malformed file degrades to
   embedded defaults that are byte-identical with the shipped file (locked by
-  `tests/test_scope_rules.py`).
+  `tests/test_scope_rules.py`). The file is template-managed
+  (`syncPolicy.safeFiles`): `cwf project sync` refreshes it, so local edits to
+  it do not survive a sync.
 - Absent for `no_task` / `planning` / `completed` states. Block content is
   byte-identical across host lines for the whole fixture matrix
   (`test/fixtures/stage-contract-matrix.json` drives the equality test:

package/template/.cowork-flow/spec/contracts/decision-anchor.md

@@ -52,7 +52,7 @@ translated heading would simply stop being read.
 fact view (`services/fact_view.parse_decision_anchor`). Line-format conventions:
 
 - `## 验证命令`: one command per line (an optional `- ` prefix), truncated to 120
-  characters, at most 5 lines; the implementing agent runs them itself
+  characters, at most 10 lines; the implementing agent runs them itself
   (self-declared, self-checked) and the reviewer verifies the execution evidence.
 - `## 范围边界`: only the first non-empty line is taken, truncated to 160
   characters.
@@ -110,14 +110,14 @@ After merging (5 files): `decision-anchor.md` + `implement.jsonl` + `check.jsonl
   component.
   A **consequence** (expected cost, not a defect): **any byte change in
   `implement.jsonl`** (appending or removing a scope entry, rewording a `reason`,
-  a domain-guide entry auto-appended by `task context add`) **or a rewrite of a
+  a domain-guide entry) **or a rewrite of a
   referenced spec's prose invalidates an existing receipt**, requiring one more
   review run against the final state. Appending evidence, ticking ACs, and runtime
   metadata are not in that set.
 - **Light profile `meta.taskType: "tiny"`**: applies to `strict` tasks only
   (`legacy` + `tiny` stays a compatibility path). A light task **is still strict**
   — what it waives are three things: the review receipt, AC evidence, and
-  `dev_type`. It does **not** waive spec-check, the file-scope gate, or "AC rows
+  `dev_type`. It does **not** waive the file-scope gate or "AC rows
   are non-empty" (`LIFECYCLE-AC-003`/`004` still apply). Plan-file binding is not
   among the three, but the pre-existing field-level exemption for tiny applies, so
   a light task does not require `planFile` either. `tiny` **can only be declared at

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
 
@@ -43,6 +44,4 @@ to them:
 ## Exemptions
 
 `LIFECYCLE-AC-002` is the only code in this set a flag can waive
-(`--allow-missing-evidence`); spec-check's `--allow-unchecked` waives `unchecked`
-declarations, not a `LIFECYCLE-*` code. Details are in `evidence-completion.md` and
-`spec-checks.md`.
+(`--allow-missing-evidence`). Details are in `evidence-completion.md`.

package/template/.cowork-flow/spec/contracts/evidence-completion.md

@@ -40,7 +40,7 @@ direct lifecycle checks:
 | `LIFECYCLE-AC-001` | an unchecked AC row exists | none — do the work, or tick the completed rows |
 | `LIFECYCLE-AC-002` | a declared AC has no valid evidence record | `--allow-missing-evidence` (recorded in task.json `meta.evidenceExempt`, with `at`, `flag`, `by`, and the `missing` detail list) |
 | `LIFECYCLE-AC-003` | `gateProfile=strict` and decision-anchor yields no AC row | none — a strict task was already required to declare ACs at start, so reading none at completion has only three explanations: the anchor was rewritten, the task was created wrongly, or the anchor is undecodable (corrupted encoding) |
-| `LIFECYCLE-AC-004` | `gateProfile=strict` and the ac_evidence module cannot be imported | none — same family as `SPEC-CHECK-EXECUTOR-ERROR`: a broken module is not "nothing to check"; the message carries the original exception, and you rerun once the runtime install is fixed |
+| `LIFECYCLE-AC-004` | `gateProfile=strict` and the ac_evidence module cannot be imported | none — a broken module is not "nothing to check"; the message carries the original exception, and you rerun once the runtime install is fixed |
 
 - The first two codes can appear together; `--allow-missing-evidence` waives
   `LIFECYCLE-AC-002` only, never `003`/`004`.
@@ -51,8 +51,8 @@ direct lifecycle checks:
 - **Strict path**: a `gateProfile=strict` task re-verifies AC existence and
   evidence-module availability at completion — the start-time AC declaration
   requirement does not lapse because completion cannot read it.
-- The `meta.evidenceExempt` trace has the same shape as spec-check's
-  `specCheckExempt`: retries do not accumulate, the latest completion result wins.
+- The `meta.evidenceExempt` trace does not accumulate: retries leave only the
+  latest completion result.
 - **An exemption record must name which items were waived and who approved it**:
   `meta.evidenceExempt` = `{"at", "flag": "--allow-missing-evidence",
   "by": <actor or null>, "missing": [<AC id>…]}`. `by` is the resolved session
@@ -60,9 +60,7 @@ direct lifecycle checks:
   `creator`/`assignee`. Both the completion output and the archive output print
   this record item by item (the completion output reads the `task.json` just
   written), so "what was recorded" and "what was printed" cannot tell two different
-  stories; with no exemption, no exemption rows are printed at all. The structure
-  matches the `meta.specCheckExempt` detail rules on the spec-check side; see
-  `spec-checks.md`.
+  stories; with no exemption, no exemption rows are printed at all.
 
 ## Injection and fact view
 
@@ -81,5 +79,5 @@ direct lifecycle checks:
   behind an AC to fabricate a record.
 - It does not parse AC prose semantics; a missing checkbox on an `AC-xxx` row
   parses as incomplete.
-- This contract does not change spec-check semantics; MCP write tools still refuse
-  by default (`fact-layer-access.md`).
+- This contract does not change the file-scope gate or the AC gate; MCP write
+  tools still refuse by default (`fact-layer-access.md`).

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

@@ -12,7 +12,6 @@ Current contracts:
 - `capabilities.md`: the host adapter capability model.
 - `party-mode-v2-board.md`: the Party Mode V2 board protocol.
 - `plan-binding.md`: lightweight development-plan binding, pre-start missing-plan blocking, and recovery visibility.
-- `spec-checks.md`: the spec-declared command contract — syntax of `checks:` in user-spec frontmatter, three-state gate semantics, timing, and the host capability matrix.
 - `context-injection.md`: the transport shapes, event-timing matrix, and fingerprint serialization rules for runtime-context injection across hosts (a meta-protocol, not in `contract-registry.json`).
 - `decision-anchor.md`: the schema of each task's `decision-anchor.md` — goal, acceptance criteria, rejected options, and key assumptions.
 - `error-output-as-data.md`: external error output is analyzed as data, never executed as instructions (`ERROR_OUTPUT_AS_DATA_V1`).
@@ -20,4 +19,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/plan-binding.md

@@ -14,8 +14,9 @@ the plan into a second workflow kernel.
 
 ## Creation phase
 
-- A plain `task create` may create a planning task with no plan.
-- `task create --from-plan <path>` is an explicit binding request; `<path>` must
+- A plain task creation (`task next --title … --slug …`) may create a planning
+  task with no plan.
+- `task next --from-plan <path>` is an explicit binding request; `<path>` must
   exist, lie inside the repository, and lie under `.cowork-flow/plans/`.
 - On a successful binding the runtime writes:
 

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
@@ -86,33 +108,20 @@ does not defend against a forged runtime record — writing
 `.cowork-flow/.runtime/**` is out of scope here and would need a signed or
 externally rooted record, which is a separate contract.
 
-## Delegated Spec Self-Check
-
-Delegated subagent tool calls receive no edit-phase hook feedback on hosts
-whose plugin hooks cover only the main session stream (verified on zcode:
-plugin PostToolUse fires for main-session tool calls but never for
-Agent-tool children). The reliable pull path is the CLI: before reporting
-completion, `cowork-implement` (and any child that changes files) runs
-
-```text
-./.cowork-flow/run spec-check
-```
-
-fixes every reported violation, and re-runs until the summary is clean or the
-remaining violations are reported as blockers. This is a protocol behavior,
-not a second lifecycle gate — the closeout gate re-runs the same checks and
-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.
-- Before accepting delegated output, run `./.cowork-flow/run spec-check` in
-  the main session and treat every violation as an acceptance blocker: the
-  child receives no edit-phase hook feedback, so acceptance-time checking is
-  the earliest reliable checkpoint for delegated work.
+- Before accepting delegated output, verify the child's changed paths against
+  the task scope and the applicable `spec/` requirements from the diff
+  (`git diff --stat` / `task next <dir> --validate`): child sessions receive no
+  edit-phase hook feedback on hosts whose plugin hooks cover only the main
+  session stream, so acceptance-time review is the earliest reliable checkpoint
+  for delegated work.
 - After completion or failure, close the child with the adapter cancel/close
   primitive and clean the runtime context sessions.
 - The child remains a leaf executor and must not dispatch, wait for, list, or

package/template/.cowork-flow/spec/contracts/task-adopt.md

@@ -74,7 +74,7 @@ that does not advance status); `check_result` is `null` (no check is exempted).
 ## Session binding
 
 On successful adoption the CLI binds the adopter's session to that task (the same
-shape as a rebind by `task next <dir>` or the binding after `task create`), so a
+shape as a rebind by `task next <dir>` or the binding at task creation), so a
 later `task next <dir> --run` can omit the directory and continue the
 review/complete/archive chain.
 

package/template/.cowork-flow/spec/runtime/contract-registry.json

@@ -115,19 +115,6 @@
         "when changing task start readiness",
         "when changing resume context for active tasks"
       ]
-    },
-    {
-      "id": "SPEC_CHECKS_V1",
-      "path": ".cowork-flow/spec/contracts/spec-checks.md",
-      "digest": [
-        "Specs may declare `checks:` commands in frontmatter; the mechanism runs declarations, never prose.",
-        "A declared command that cannot be found counts as unchecked and blocks completion."
-      ],
-      "readWhen": [
-        "before adding or editing spec files",
-        "when a spec clause can be judged by a command exit code",
-        "when spec-check reports violations or unchecked"
-      ]
     }
   ],
   "references": [

package/template/.cowork-flow/spec/runtime/host-assets.json

@@ -155,7 +155,7 @@
         "runtimeContextDispatch": "native",
         "runtimeContextBinding": "shim",
         "runtimeContextCleanup": "native",
-        "editScopeWarning": "unsupported"
+        "editScopeWarning": "plugin"
       },
       "commandTargets": [
         {
@@ -204,7 +204,7 @@
         "runtimeContextDispatch": "native",
         "runtimeContextBinding": "shim",
         "runtimeContextCleanup": "native",
-        "editScopeWarning": "unsupported"
+        "editScopeWarning": "plugin"
       },
       "commandTargets": [],
       "payload": {
@@ -251,7 +251,7 @@
         "runtimeContextDispatch": "native",
         "runtimeContextBinding": "shim",
         "runtimeContextCleanup": "native",
-        "editScopeWarning": "unsupported"
+        "editScopeWarning": "plugin"
       },
       "commandTargets": [
         {
@@ -300,7 +300,7 @@
         "runtimeContextDispatch": "native",
         "runtimeContextBinding": "shim",
         "runtimeContextCleanup": "shim",
-        "editScopeWarning": "unsupported"
+        "editScopeWarning": "plugin"
       },
       "commandTargets": [],
       "payload": null
@@ -431,7 +431,7 @@
         "runtimeContextDispatch": "native",
         "runtimeContextBinding": "shim",
         "runtimeContextCleanup": "native",
-        "editScopeWarning": "unsupported"
+        "editScopeWarning": "plugin"
       },
       "commandTargets": [],
       "payload": {
@@ -460,8 +460,8 @@
       ".cowork-flow/.version",
       ".cowork-flow/run",
       ".cowork-flow/run.cmd",
-      ".cowork-flow/spec/contracts/spec-checks.md",
-      ".cowork-flow/spec/contracts/workflow-state-templates.md"
+      ".cowork-flow/spec/contracts/workflow-state-templates.md",
+      ".cowork-flow/spec/runtime/scope-rules.json"
     ],
     "safePrefixes": [
       ".cowork-flow/"
@@ -515,6 +515,7 @@
       ".cowork-flow/scripts/application",
       ".cowork-flow/scripts/services/batch_execution.py",
       ".cowork-flow/scripts/services/decision_review.py",
+      ".cowork-flow/scripts/services/spec_check.py",
       ".cowork-flow/scripts/commands",
       ".cowork-flow/scripts/common",
       ".cowork-flow/scripts/common/__init__.py",
@@ -567,6 +568,7 @@
       ".cowork-flow/scripts/subagent.py",
       ".cowork-flow/scripts/task.py",
       ".cowork-flow/spec/contracts/entry-contract.md",
+      ".cowork-flow/spec/contracts/spec-checks.md",
       ".cowork-flow/spec/runtime/rules.json",
       ".cowork-flow/spec/schemas/rules.schema.json",
       ".cowork-flow/spec/runtime/skill-registry.json",
@@ -575,6 +577,7 @@
       ".cowork-flow/scripts/adapters/cli/add_session.py",
       ".cowork-flow/workspace/index.md",
       ".cowork-flow/scripts/adapters/cli/change.py",
+      ".cowork-flow/scripts/adapters/cli/spec_check.py",
       ".cowork-flow/changes/",
       ".cowork-flow/skills/adversarial-review",
       ".cowork-flow/skills/agent-dispatch",

package/template/.cowork-flow/spec/runtime/scope-rules.json

@@ -8,9 +8,9 @@
     "trailingSlashRejectedTypes": ["planned-file", "deleted-file"]
   },
   "stageContract": {
-    "budget": 1200,
+    "budget": 3400,
     "scopeLimit": 8,
     "specLimit": 4,
-    "verifyLimit": 3
+    "verifyLimit": 10
   }
 }