cowork-flow 1.8.0 → 1.8.1

package/CHANGELOG.md

@@ -5,6 +5,16 @@
 ### Added
 
 
+## [1.8.1] - 2026-10-08
+
+### Added
+
+- **任务收养 `task next --run --adopt`（1.9.0 多执行者协作前置）**：为孤儿/滞留任务提供受支持的接管路径，替代手改 task.json meta。收养是独立动作（不与 review/complete/archive 链式同发）：把 `in_progress`/`review` 状态、由另一执行者占有的任务重绑到收养者（`executor`），把评审基线**重置**到收养时 HEAD（原值记入 `meta.previousBaseline`），保留状态并写审计字段 `meta.previousExecutor` / `meta.previousBaseline` / `meta.adoptedAt`，结果 code `LIFECYCLE-EXECUTOR-ADOPTED`。误用 fail-closed（`LIFECYCLE-ADOPT-001`）：planning/completed、无 executor、自我收养、process-fallback 身份、delegated 上下文、携带 create/plan 或批启动旗标全部拒绝且不改状态。start 路径"基线永不覆盖"不变量原样保留（既有测试零改动），收养是唯一经审计的显式重置路径；成功后 CLI 把会话绑定到该任务。契约见 `.cowork-flow/spec/contracts/task-adopt.md`。
+
+### Fixed
+
+- **`--allow-missing-evidence` 恢复独立解析**（1.8.0 遗留缺陷）：该旗标此前被误注册为 `--allow-unchecked` 的解析别名（同一 `add_argument`、dest 相同），造成两个后果——AC 证据豁免（`LIFECYCLE-AC-002` 的可豁免路径）从 CLI 不可达（`cmd_complete` 读取的属性 argparse 从不创建，恒为 False）；且传入 `--allow-missing-evidence` 会静默获得 spec-check 未检查豁免（语义错误、方向危险：本意只豁免 AC 证据，却放开了缺失/超时的 spec-check 命令）。现在两个旗标各自独立解析，parser 级与命令贯通级回归测试锁定（既有测试手工构造 Namespace 绕过 parser，正是此缺陷漏网原因）。
+
 ## [1.8.0] - 2026-10-08
 
 ### Added
@@ -296,7 +306,8 @@
 
 此版本未保留本地条目正文，详情见 [GitHub Release](https://github.com/fishlikewater/cowork-flow/releases/tag/v0.0.47)。
 
-[Unreleased]: https://github.com/fishlikewater/cowork-flow/compare/v1.8.0...HEAD
+[Unreleased]: https://github.com/fishlikewater/cowork-flow/compare/v1.8.1...HEAD
+[1.8.1]: https://github.com/fishlikewater/cowork-flow/compare/v1.8.0...v1.8.1
 [1.8.0]: https://github.com/fishlikewater/cowork-flow/compare/v1.7.3...v1.8.0
 [1.7.3]: https://github.com/fishlikewater/cowork-flow/compare/v1.7.2...v1.7.3
 [1.7.2]: https://github.com/fishlikewater/cowork-flow/compare/v1.7.1...v1.7.2

package/docs/direction.md

@@ -16,10 +16,11 @@
 | 本规划文档落库 | ✅ 完成 | 08-27-direction-doc | — |
 | 1.5→1.7 宿主广度 + 发布链（七宿主） | ✅ 完成 | CHANGELOG 1.5.0-1.7.2 | — |
 | 1.7.3 维护：ZCode shim .mjs + 项目根查找修复 | ✅ 完成 | 10-04-zcode-shim-mjs（d0716a9） | — |
-| 1.8.0 立项：证据化完成 | 🔄 立项完成，待启动 | 10-05-direction-1-8-0 / 10-05-evidence-completion | 在宿主会话启动主线任务 |
-| 1.8.0 主线实现：证据化完成 | ✅ 完成 | 10-05-evidence-completion（baa386d，CI test + windows-core 全绿） | 真实宿主冒烟后发布 1.8.0 |
-| 1.8.x 收尾：Skill 证据补课 | 🔄 进行中 | 10-06-skill-evidence-training | 合入后与冒烟共同构成 1.8.0 发布判据 |
-| 1.9.0 前置：task adopt 命令 | 📋 立项 | 10-06-task-adopt-command | 下一会话实现（agent-teams 就绪的地基） |
+| 1.8.0 立项：证据化完成 | ✅ 完成 | 10-05-direction-1-8-0 / 10-05-evidence-completion | — |
+| 1.8.0 主线实现：证据化完成 | ✅ 完成 | 10-05-evidence-completion（baa386d，CI test + windows-core 全绿）；已随 1.8.0 发布（cfe1ac1） | — |
+| 1.8.x 收尾：Skill 证据补课 + spec-check 采纳闭环 | ✅ 完成 | 10-06-skill-evidence-training（09937d0）、10-08 spec-check 闭环（08f9d9b） | — |
+| 1.9.0 前置：task adopt 命令 | ✅ 完成 | 10-06-task-adopt-command（e6e5132）：`--adopt` 重绑执行者 + 基线重置 + 审计；契约 task-adopt.md | 1.9.0 主线（多执行者协作）立项 |
+| 1.8.1 补丁：`--allow-missing-evidence` 解析修复 + adopt | 🔄 本次发布 | 10-08-fix-evidence-flag-parser（dc594a4）；tag v1.8.1 → CI 发布 npm | 确认 CI 全绿与 npm latest=1.8.1 |
 
 **当前结论**：方向路线图阶段 0-3 全部落地。项目当前形态：「多主机 Agent 协作的运行时上下文与协作事实层」——事实视图（CLI + MCP）、结构化注入、跨宿主一致性治理、执行者归属与证据位均已就绪并有测试锁定。后续演进见「不做什么」边界与观察期事项。
 
@@ -177,3 +178,4 @@
 - 2026-08-29：MCP 全局入口补充——npm CLI 新增 `cowork-flow mcp-state` 透传命令（cwd 向上定位项目运行时、stdio inherit、退出码透传），MCP 客户端全局注册一次即可服务所有项目，消除逐项目 `.mcp.json` 配置（9a1fa86）。
 - 2026-08-29：后续方向 P0-P3 执行完毕。**P0**：1.1.0 发布——dev→master 合并、CHANGELOG 1.1.0 段（含 1.0.0 载体错位注明）、tag v1.1.0 与 GitHub Release 创建；publish CI 首跑曝光 node:full 存量问题（dsh-hook 依赖 gitignored 运行时、Windows 无法 exec shebang 脚本、test runner IPC 崩溃）并全部修复——双平台门禁现已全绿。**发布确认：npm registry `cowork-flow@1.1.0` 已上线（dist-tag latest），AC-004 闭合，发版任务归档。** **P1**：`docs/mcp-client-setup.md`（codex/opencode/claude-code/zcode 真实注册格式）+ `test/mcp-client-matrix.test.js` 客户端等效启动验证。**P1'**：publish.yml 链路实测核对并写入 README 发布节。**P2**：flaky 组合复跑 5 轮未复现（记录为单次现象）；doctor 会话卫生无残留。**P3**：观察期边界维持——MCP 写工具默认拒绝，AGNTCY 等协议收敛后按薄壳接入。- 2026-10-05：2026-10 修订落库（任务 10-05-direction-1-8-0）。1.7.3 维护完成（10-04-zcode-shim-mjs，d0716a9：ZCode shim 改 .mjs、findWorkflowRoot off-by-one 修复）；1.8.0 主线定为**证据化完成**，主线任务 10-05-evidence-completion 立项（planning 就绪待启动）；候选 B（agent-teams 就绪）列为 1.9.0 候选主线；文档英文化列为待决项，待维护者拍板。方向文档自本次起恢复版本控制（087ef72 untrack 后首次入库）。
 - 2026-10-06：10.5 增补落库（任务 10-06-direction-post-1-8-0）。1.8.0 主线实现完成（10-05-evidence-completion，baa386d，CI 双平台全绿）；立项 10-06-skill-evidence-training（1.8.0 收尾）与 10-06-task-adopt-command（1.9.0 前置）；1.8.0 发布判据 = CI + 真实宿主冒烟 + Skill 补课。
+- 2026-10-08：1.8.0 已发布（cfe1ac1，tag v1.8.0，CI publish 全绿，npm latest=1.8.0）。发布后排查发现 `--allow-missing-evidence` 被误注册为 `--allow-unchecked` 解析别名的遗留缺陷（AC 证据豁免从 CLI 不可达 + 误授 spec-check 豁免），修复入库（10-08-fix-evidence-flag-parser，dc594a4，parser 级与命令贯通级回归测试锁定）。1.9.0 前置 task adopt 完成（10-06-task-adopt-command，e6e5132）：`task next --run --adopt` 独立动作——重绑执行者、评审基线重置到收养时 HEAD（审计保留原值）、状态不变、误用 fail-closed（`LIFECYCLE-ADOPT-001`）；契约 `spec/contracts/task-adopt.md`，含与 `--takeover` 的边界。本次发布 1.8.1 同时携带两项交付（CHANGELOG 分列 Added/Fixed）；1.9.0 主线（多执行者协作就绪）待立项。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "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.8.0",
+  "version": "1.8.1",
   "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.8.0",
+  "version": "1.8.1",
   "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.8.0",
+  "version": "1.8.1",
   "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.8.0",
+  "version": "1.8.1",
   "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.8.0",
+  "version": "1.8.1",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 ZCode。",
   "author": {
     "name": "fishlikewater",

package/template/.cowork-flow/.version

@@ -1 +1 @@
-1.8.0
+1.8.1

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

@@ -38,6 +38,7 @@ from adapters.cli.task_context_commands import (
 from adapters.cli.task_create_command import cmd_create, ensure_tasks_dir
 from adapters.cli import task_navigation
 from adapters.cli.task_lifecycle_commands import (
+    cmd_adopt,
     cmd_complete,
     cmd_current,
     cmd_finish,
@@ -152,6 +153,7 @@ def cmd_next(args: argparse.Namespace) -> int:
                 review=cmd_review,
                 complete=cmd_complete,
                 archive=cmd_archive,
+                adopt=cmd_adopt,
             ),
         )
     return task_navigation.cmd_next(args)

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

@@ -30,6 +30,7 @@ from runtime.session_state import (
     PROVENANCE_PROCESS_FALLBACK,
     clear_active_task,
     get_active_task,
+    set_active_task,
 )
 
 
@@ -284,6 +285,50 @@ def cmd_start(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_adopt(args: argparse.Namespace) -> int:
+    """Adopt an active task from another executor."""
+    repo_root = get_repo_root()
+    execution_context = execution_context_from_namespace(args)
+    task_input = getattr(args, "dir", None)
+    if not task_input:
+        print(
+            colored("Error: task directory or name required", Colors.RED),
+            file=sys.stderr,
+        )
+        return 1
+
+    full_path = _resolve_start_task(task_input, repo_root)
+    if full_path is None:
+        return 1
+
+    service = TaskLifecycleService(repo_root)
+    result = service.adopt(
+        full_path,
+        executor=getattr(args, "executor", None),
+        execution_context=execution_context,
+    )
+    if not result.ok:
+        if result.code == "LIFECYCLE-ADOPT-001":
+            print(
+                colored("Error: task adoption blocked", Colors.RED),
+                file=sys.stderr,
+            )
+            for blocker in result.blockers:
+                print(f"  - {blocker}", file=sys.stderr)
+            return 1
+        if result.title:
+            return _report_lifecycle_preflight(result)
+        if result.repository_error is not None:
+            return _report_lifecycle_repository_error(result)
+        return 1
+
+    task_path = _display_task_path(repo_root, full_path)
+    set_active_task(repo_root, task_path)
+    print(colored(f"[OK] Task adopted: {task_path}", Colors.GREEN))
+    print(f"Next: ./.cowork-flow/run task next {task_path} --run")
+    return 0
+
+
 def cmd_review(args: argparse.Namespace) -> int:
     """Mark a task ready for check."""
     repo_root = get_repo_root()

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

@@ -18,6 +18,7 @@ from runtime.session_state import (
     get_active_task,
 )
 from services.plan_binding import PlanBindingError, bind_task_plan
+from services.task_lifecycle import ADOPTABLE_STATUSES
 
 
 LifecycleCommand = Callable[[argparse.Namespace], int]
@@ -30,6 +31,7 @@ class NextActionHandlers:
     review: LifecycleCommand
     complete: LifecycleCommand
     archive: LifecycleCommand
+    adopt: LifecycleCommand
 
 
 def namespace_with(args: argparse.Namespace, **overrides) -> argparse.Namespace:
@@ -270,7 +272,62 @@ def _run_plan_bind_action(args: argparse.Namespace, task_path: str) -> int:
     return 0
 
 
+def _run_adopt_action(
+    args: argparse.Namespace,
+    handlers: NextActionHandlers,
+) -> int:
+    """`--adopt` is its own action: it repairs ownership and the review
+    baseline without running any lifecycle transition."""
+    repo_root = get_repo_root()
+    if _create_input_names(args) or getattr(args, "from_plan", None):
+        print(
+            colored(
+                "Error: --adopt takes over an existing task; create/plan "
+                "inputs cannot run with it",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
+    if getattr(args, "auto", False) or getattr(args, "approved", False):
+        print(
+            colored(
+                "Error: --adopt does not run batch start; adopt first, then "
+                "re-run with --auto --approved",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
+    task_dir, task_path, _active_target = _next_target_for_run(args, repo_root)
+    if task_dir is None or task_path is None:
+        blockers = _fallback_binding_blockers(args, repo_root)
+        for blocker in blockers or ["no task target for --adopt; pass a task dir"]:
+            print(colored(f"Error: {blocker}", Colors.RED), file=sys.stderr)
+        return 1
+    if not task_dir.is_dir():
+        print(
+            colored(f"Error: task directory not found: {task_path}", Colors.RED),
+            file=sys.stderr,
+        )
+        return 1
+    status = task_navigation._status(repo_root, task_dir)
+    if status not in ADOPTABLE_STATUSES:
+        print(
+            colored(
+                "Error: --adopt only applies to an active task "
+                f"({'/'.join(ADOPTABLE_STATUSES)}); current status: {status}",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
+    return handlers.adopt(namespace_with(args, dir=task_path))
+
+
 def run_next_action(args: argparse.Namespace, handlers: NextActionHandlers) -> int:
+    if bool(getattr(args, "adopt", False)):
+        return _run_adopt_action(args, handlers)
     action, error_code = _validated_next_action(args)
     if action is None:
         return error_code

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

@@ -31,6 +31,8 @@ Action inputs for `next --run`:
   --parent <dir>        Optional parent task directory for create_task
   --from-plan <path>    Plan path for create_task or planning-phase rebind
   --auto --approved     Optional batch start flags for start_task
+  --adopt              Adopt an active task from another executor (rebind
+                       executor + reset review baseline; status unchanged)
   --commit             Optional archive auto-commit flag for archive_task
 
 Examples:
@@ -86,12 +88,18 @@ def _add_next_output_options(parser: argparse.ArgumentParser) -> None:
     )
     parser.add_argument(
         "--allow-unchecked",
-        "--allow-missing-evidence",
         dest="allow_unchecked",
         action="store_true",
         help="With task completion: allow unchecked spec-check commands "
         "(missing/timeout) and record the exemption in task.json meta",
     )
+    parser.add_argument(
+        "--allow-missing-evidence",
+        dest="allow_missing_evidence",
+        action="store_true",
+        help="With task completion: allow checked acceptance criteria "
+        "without evidence and record the exemption in task.json meta",
+    )
     parser.add_argument(
         "--list",
         dest="list_tasks",
@@ -157,6 +165,12 @@ def _add_next_runtime_inputs(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Take the task over from its current executor on start_task",
     )
+    parser.add_argument(
+        "--adopt",
+        action="store_true",
+        help="Adopt an active task from another executor: rebind executor, "
+        "reset the review baseline to HEAD, keep status, record audit fields",
+    )
 
 
 def _add_next_command(subparsers: argparse._SubParsersAction) -> None:

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

@@ -60,6 +60,10 @@ COMPLETE_STAGE = LifecycleStage(
     records_completion_date=True,
 )
 
+# Adoption repairs ownership on an unfinished task; finished or unstarted
+# tasks have nothing to hand over.
+ADOPTABLE_STATUSES = ("in_progress", "review")
+
 
 @dataclass(frozen=True)
 class LifecyclePreflightFailure:
@@ -139,6 +143,73 @@ class TaskLifecycleService:
             execution_context=execution_context,
         )
 
+    def adopt(
+        self,
+        task: str | Path,
+        *,
+        executor: str | None = None,
+        execution_context: object | None = None,
+    ) -> LifecycleResult:
+        """Take over an active task owned by another executor: rebind the
+        executor, reset the review baseline to HEAD, keep status, record
+        audit fields. Adoption repairs ownership; it is not a transition."""
+        task_dir = self.repository.resolve(task)
+        task_data_or_failure = self._load_transition_task(START_STAGE, task_dir)
+        if isinstance(task_data_or_failure, LifecycleResult):
+            return task_data_or_failure
+        task_data = task_data_or_failure
+
+        resolved, failure = self._adopt_gate(
+            START_STAGE,
+            task_dir,
+            task_data,
+            executor,
+            execution_context,
+        )
+        if failure is not None:
+            return failure
+        current_task, failure = self._takeover_snapshot(
+            START_STAGE, task_dir, task_data
+        )
+        if failure is not None:
+            return failure
+
+        current = str(task_data.get("executor")).strip()
+        meta = dict(task_data.get("meta") or {})
+        adoption = {
+            "previousExecutor": current,
+            "previousBaseline": meta.get("baselineCommit"),
+            "adoptedAt": datetime.now(timezone.utc).strftime(
+                "%Y-%m-%dT%H:%M:%SZ"
+            ),
+            # Reset, not preserve: the adopter's review window starts at the
+            # adoption HEAD. No HEAD (no git) degrades to status-only.
+            "baselineCommit": current_head(self.repo_root),
+        }
+        failure = self._write_takeover(
+            START_STAGE,
+            task_dir,
+            task_data,
+            resolved,
+            current_task,
+            adoption=adoption,
+            operation_tag="adopt",
+        )
+        if failure is not None:
+            return failure
+        return LifecycleResult(
+            ok=True,
+            code="LIFECYCLE-EXECUTOR-ADOPTED",
+            stage=START_STAGE,
+            task_dir=task_dir,
+            active_task_path=self._display_task_path(task_dir),
+            transition=LifecycleTransition(
+                previous_status=task_data.get("status"),
+                next_status=task_data.get("status"),
+                changed=False,
+            ),
+        )
+
     def review(
         self,
         task: str | Path,
@@ -717,6 +788,103 @@ class TaskLifecycleService:
             return None
         return key or None
 
+    def _adopt_gate(
+        self,
+        stage: LifecycleStage,
+        task_dir: Path,
+        task_data: dict,
+        executor: str | None,
+        execution_context: object | None,
+    ) -> tuple[str | None, LifecycleResult | None]:
+        """Fail-closed adoption gate: only an active task owned by another
+        executor can be adopted, and only by a real (non-shared) identity."""
+        if self._delegated_mutation_request(execution_context):
+            return None, self._failure(
+                stage,
+                task_dir,
+                "TASK-EXECUTION-001",
+                title="Delegated execution cannot mutate task lifecycle",
+                blockers=(
+                    "delegated execution context cannot mutate main-session "
+                    "task lifecycle state",
+                ),
+            )
+        status = task_data.get("status")
+        if status not in ADOPTABLE_STATUSES:
+            return None, self._failure(
+                stage,
+                task_dir,
+                "LIFECYCLE-ADOPT-001",
+                title="task is not active",
+                blockers=(
+                    "--adopt only applies to an active task "
+                    f"({'/'.join(ADOPTABLE_STATUSES)}); current status: "
+                    f"{status!r}",
+                ),
+            )
+        current = task_data.get("executor")
+        current = (
+            current.strip()
+            if isinstance(current, str) and current.strip()
+            else None
+        )
+        if current is None:
+            return None, self._failure(
+                stage,
+                task_dir,
+                "LIFECYCLE-ADOPT-001",
+                title="task has no executor",
+                blockers=("task has no recorded executor; nothing to adopt",),
+            )
+        explicit = executor.strip() if executor and executor.strip() else None
+        if explicit:
+            resolved = explicit
+        else:
+            try:
+                from runtime.session_state import (
+                    PROVENANCE_PROCESS_FALLBACK,
+                    resolve_context_key_with_provenance,
+                )
+
+                resolved, provenance = resolve_context_key_with_provenance()
+            except Exception:
+                resolved, provenance = None, None
+            if resolved and provenance == PROVENANCE_PROCESS_FALLBACK:
+                return None, self._failure(
+                    stage,
+                    task_dir,
+                    "LIFECYCLE-ADOPT-001",
+                    title="adoption requires an explicit identity",
+                    blockers=(
+                        f"process-fallback identity '{resolved}' cannot adopt "
+                        "a task; set COWORK_FLOW_CONTEXT_ID or pass "
+                        "--executor <label>",
+                    ),
+                )
+        if not resolved:
+            return None, self._failure(
+                stage,
+                task_dir,
+                "LIFECYCLE-ADOPT-001",
+                title="no executor identity resolved",
+                blockers=(
+                    "no executor identity resolved; set "
+                    "COWORK_FLOW_CONTEXT_ID or pass --executor <label>",
+                ),
+            )
+        if resolved == current:
+            return None, self._failure(
+                stage,
+                task_dir,
+                "LIFECYCLE-ADOPT-001",
+                title=f"task is already owned by '{current}'",
+                blockers=(
+                    f"task is already owned by '{current}'; --adopt is for "
+                    "taking over another executor's task",
+                ),
+            )
+        return resolved, None
+
     def _apply_takeover_on_idempotent(
         self,
         stage: LifecycleStage,
@@ -787,6 +955,9 @@ class TaskLifecycleService:
         task_data: dict,
         resolved: str,
         current_task: StateSnapshot,
+        *,
+        adoption: dict | None = None,
+        operation_tag: str = "takeover",
     ) -> LifecycleResult | None:
         identity = "|".join(
             (
@@ -800,12 +971,16 @@ class TaskLifecycleService:
         digest = hashlib.sha256(identity.encode("utf-8")).hexdigest()[:16]
         unit = UnitOfWork(
             self.repo_root,
-            operation_id=f"task-{stage.name}-takeover-{digest}",
-            kind=f"task-lifecycle-{stage.name}-takeover",
+            operation_id=f"task-{stage.name}-{operation_tag}-{digest}",
+            kind=f"task-lifecycle-{stage.name}-{operation_tag}",
             fault_injector=self.fault_injector,
         )
         persisted = dict(task_data)
         persisted["executor"] = resolved
+        if adoption is not None:
+            meta = dict(persisted.get("meta") or {})
+            meta.update(adoption)
+            persisted["meta"] = meta
         unit.replace(
             self.repository.task_json_path(task_dir),
             persisted,

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

@@ -17,3 +17,4 @@
 - `error-output-as-data.md`: 外部错误输出按数据分析而非指令执行（`ERROR_OUTPUT_AS_DATA_V1`）。
 - `fact-layer-access.md`: 无注入 hook 的宿主与外部工具读取任务事实的通道（`FACT_LAYER_ACCESS_V1`）。
 - `evidence-completion.md`: 证据化完成——`evidence.jsonl` schema、`LIFECYCLE-AC-001/002` 完成门禁、`--allow-missing-evidence` 豁免留痕与注入覆盖行。
+- `task-adopt.md`: 任务收养——`task next --run --adopt` 的入口边界、前置条件（`LIFECYCLE-ADOPT-001`）、重绑+基线重置+审计写入，与 `--takeover` 的区别。

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

@@ -0,0 +1,64 @@
+# Task Adopt Contract
+
+**收养（adopt）是显式的归属修复动作：把一个由其它执行者占有、且已激活未完成的任务接管过来——重绑 executor、把评审基线重置到收养时 HEAD、保留状态、留下审计字段。**
+
+收养不是生命周期迁移：它不推进 status、不豁免任何检查，也不与其它动作链式同发。它是 1.9.0 多执行者协作就绪的前置（多执行者生命周期领地），承载 2026-10-06 归档两个滞留任务时只能手改 task.json meta 的操作。
+
+## 入口与动作边界
+
+```bash
+./.cowork-flow/run task next <task-dir> --run --adopt
+```
+
+- `--adopt` 由 `task next --run` 的投递层（`task_next_runner`）在动作解析前拦截，直接执行收养动作；不进入导航默认动作序列，也不与 review/complete/archive 迁移同发（下一步由使用者显式发起）。
+- 无 `--run` 时 `--adopt` 与其它执行旗标一致：只读导航，不产生副作用。
+- 组合拒绝（fail-closed，退出码 1，不改状态）：携带 create/plan 输入（`--title`/`--slug`/`--assignee`/`--priority`/`--description`/`--parent`/`--from-plan`）或批启动旗标（`--auto`/`--approved`）——收养与创建/批启动语义不同，需分两步。
+
+## 前置条件（`LIFECYCLE-ADOPT-001`）
+
+| 事实 | 要求 |
+|---|---|
+| 任务状态 | `in_progress` 或 `review`（已激活未完成；planning/completed/stale 拒绝） |
+| 任务 executor | 已记录且非空（无归属的任务没有可收养对象） |
+| 收养者身份 | 可解析且 ≠ 当前 executor；显式 `--executor <label>` 优先，否则取会话身份 |
+| 身份来源 | process-fallback（共享进程标签）拒绝收养——归属必须来自真实会话身份或显式 label |
+| 执行上下文 | delegated（worker/subagent）拒绝收养（`TASK-EXECUTION-001`，与其它生命周期变更一致） |
+
+拒绝时不写 task.json、不改状态、不动会话绑定；blockers 说明具体原因。
+
+## 收养写入（单次 UnitOfWork）
+
+| 字段 | 写入 |
+|---|---|
+| `executor` | 收养者身份 |
+| `meta.previousExecutor` | 原 executor（审计：原执行者） |
+| `meta.previousBaseline` | 原 `meta.baselineCommit`（无则 `null`） |
+| `meta.adoptedAt` | UTC 时间戳 `YYYY-MM-DDTHH:MM:SSZ` |
+| `meta.baselineCommit` | **重置**为收养时 HEAD；无 git/无 HEAD 时写 `null`（降级 status-only） |
+| `status` | 不变 |
+| `_state.revision` / `_state.operation_id` | 修订递增，operation_id 含 `adopt` 标记（审计可追溯） |
+
+结果 code `LIFECYCLE-EXECUTOR-ADOPTED`；`transition.changed=false`（不推进状态的事实位）；`check_result` 为 `null`（不豁免检查）。
+
+## 基线与"永不覆盖"不变量的关系
+
+- start 路径的写一次逻辑不变：**重复 start 永不覆盖已有 `meta.baselineCommit`**，既有测试零改动锁定该不变量。
+- 收养是唯一经审计的显式重置路径：重置前把原值记入 `meta.previousBaseline`。
+- 重置后的评审窗口 = 收养时未提交改动 + 收养之后的提交。收养前**已提交**的改动不进入本任务窗口（它们在 git 历史中，需由提交记录单独追溯）——这是收养的已知边界。
+- 收养后基线再次回到"写一次"语义：后续 start 不会再次滑动。
+
+## 会话绑定
+
+收养成功后 CLI 把收养者会话绑定到该任务（与 `task next <dir>` 改绑、`task create` 创建后绑定同型），使后续 `task next <dir> --run` 可省略目录继续 review/complete/archive 链。
+
+## 与 `--takeover` 的区别
+
+| | `--takeover` | `--adopt` |
+|---|---|---|
+| 适用动作 | start_task（含幂等重跑） | 独立动作（本契约） |
+| 状态要求 | 任意（只在 start 激活点生效） | `in_progress` / `review` |
+| 基线 | 不动 | 重置到 HEAD（审计保留原值） |
+| 审计字段 | 无 | `previousExecutor` / `previousBaseline` / `adoptedAt` |
+| 结果 code | `LIFECYCLE-EXECUTOR-TAKEN-OVER` | `LIFECYCLE-EXECUTOR-ADOPTED` |
+
+`--takeover` 语义保持原样；`--adopt` 是超集动作但不改写 takeover 路径（不变量与既有测试零改动）。