@pennixrv/trellis 0.7.1-beta.9 → 0.7.2-beta.0

package/dist/templates/trellis/scripts/common/task_workflow.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import copy
 from datetime import datetime, timezone
 import hashlib
 import json
@@ -133,6 +134,10 @@ def implementation_start_ready(data: dict, task_dir: Path) -> bool:
     phase_ids = state.get("phase_ids")
     if not isinstance(phase_ids, list) or PHASE_IDS[3] not in phase_ids:
         return False
+    phases = state.get("phases")
+    implementation = phases.get(PHASE_IDS[3]) if isinstance(phases, dict) else None
+    if not isinstance(implementation, dict) or implementation.get("status") != "active":
+        return False
     if state.get("task_kind") not in {"implementation", "combined"}:
         return False
     authorization = state.get("implementation_authorization")
@@ -228,20 +233,23 @@ def _phase(state: dict, phase_id: str | None = None) -> tuple[str, dict]:
     return current, record
 
 
-def _require_current_requirements_confirmation(task_dir: Path, state: dict) -> None:
-    if PHASE_IDS[0] not in state["phase_ids"]:
-        return
+def _is_withdrawal_route(state: dict) -> bool:
     requirements = state["phases"].get(PHASE_IDS[0], {})
     withdrawal = state.get("return_record")
     skip_records = state.get("skip_records")
     skipped_requirements = skip_records.get(PHASE_IDS[0]) if isinstance(skip_records, dict) else None
-    if (
+    return (
         state["phase_ids"] == [PHASE_IDS[0], PHASE_IDS[4]]
-        and state.get("current_phase_id") == PHASE_IDS[4]
+        and state.get("current_phase_id") in {PHASE_IDS[4], None}
         and isinstance(requirements, dict)
-        and requirements.get("status") == "skipped"
-        and isinstance(skipped_requirements, dict)
-        and skipped_requirements.get("task_route_revision") == state.get("task_route_revision")
+        and (
+            requirements.get("status") == "accepted"
+            or (
+                requirements.get("status") == "skipped"
+                and isinstance(skipped_requirements, dict)
+                and skipped_requirements.get("task_route_revision") == state.get("task_route_revision")
+            )
+        )
         and isinstance(withdrawal, dict)
         and isinstance(withdrawal.get("from"), str)
         and withdrawal["from"] in PHASE_ID_SET
@@ -249,7 +257,14 @@ def _require_current_requirements_confirmation(task_dir: Path, state: dict) -> N
         and withdrawal.get("task_route_revision") == state.get("task_route_revision")
         and isinstance(withdrawal.get("evidence_refs"), list)
         and bool(withdrawal["evidence_refs"])
-    ):
+    )
+
+
+def _require_current_requirements_confirmation(task_dir: Path, state: dict) -> None:
+    if PHASE_IDS[0] not in state["phase_ids"]:
+        return
+    requirements = state["phases"].get(PHASE_IDS[0], {})
+    if requirements.get("status") == "skipped" and _is_withdrawal_route(state):
         return
     acceptance = requirements.get("acceptance") if isinstance(requirements, dict) else None
     if (
@@ -441,6 +456,31 @@ def _show(state: dict) -> int:
     return 0
 
 
+def _require_acceptance_coverage(task_dir: Path, contract_ref: str) -> None:
+    _artifact_digest(task_dir, [contract_ref])
+    lines = (task_dir / contract_ref).read_text(encoding="utf-8").splitlines()
+    heading = next((index for index, line in enumerate(lines) if line.strip() == "## 验收覆盖"), None)
+    headers = ["接受条件", "工作包", "Owner", "验证入口", "交付证据", "停止条件"]
+    if heading is not None:
+        section = []
+        for line in lines[heading + 1:]:
+            if line.startswith("#"):
+                break
+            if line.strip():
+                section.append(line.strip())
+        rows = [line.strip("|").split("|") for line in section if line.startswith("|") and line.endswith("|")]
+        rows = [[cell.strip() for cell in row] for row in rows]
+        if (
+            len(rows) >= 3
+            and rows[0] == headers
+            and len(rows[1]) == len(headers)
+            and all(re.fullmatch(r":?-{3,}:?", cell) for cell in rows[1])
+            and all(len(row) == len(headers) and all(row) for row in rows[2:])
+        ):
+            return
+    raise TaskWorkflowError("TASK_PHASE_COVERAGE_REQUIRED", "implementation contract requires ## 验收覆盖 with nonempty rows: " + " | ".join(headers))
+
+
 def _update(args: argparse.Namespace, task_dir: Path, data: dict, state: dict) -> int:
     action = args.phase_action
     child_dispositions: dict[str, str] = {}
@@ -460,11 +500,12 @@ def _update(args: argparse.Namespace, task_dir: Path, data: dict, state: dict) -
         current, record = PHASE_IDS[4], state["phases"][PHASE_IDS[4]]
     else:
         current, record = _phase(state)
+    accepted_design_return = action == "return" and current == PHASE_IDS[2] and record.get("status") == "accepted"
     returning_to_requirements = action == "return" and args.target_phase == PHASE_IDS[0]
     rerouting_to_requirements = action == "route" and args.target_phase == PHASE_IDS[0]
     if current != PHASE_IDS[0] and not returning_to_requirements and not rerouting_to_requirements:
         _require_current_requirements_confirmation(task_dir, state)
-    if action not in {"show", "resume", "route", "authorize", "admission"} and record.get("status") != "active" and not reviewed_delivery:
+    if action not in {"show", "resume", "route", "authorize", "admission"} and record.get("status") != "active" and not reviewed_delivery and not accepted_design_return:
         raise TaskWorkflowError("TASK_PHASE_INVALID_TRANSITION", "only the active phase can be changed")
 
     if action == "artifact":
@@ -526,6 +567,8 @@ def _update(args: argparse.Namespace, task_dir: Path, data: dict, state: dict) -
             raise TaskWorkflowError("TASK_PHASE_INVALID_TRANSITION", "Solution Design and Convergence Phase must remain active for pending_user_decision or deferred; accept implementation_contract, analysis_conclusion, or no_go")
         if result_ref not in record["artifact_refs"]:
             raise TaskWorkflowError("TASK_PHASE_RESULT_NOT_BOUND", "--result-ref must be included in the current phase artifact refs")
+        if current == PHASE_IDS[2] and outcome == "implementation_contract":
+            _require_acceptance_coverage(task_dir, result_ref)
         if current == PHASE_IDS[3]:
             authorization = state.get("implementation_authorization")
             if not isinstance(authorization, dict) or authorization.get("task_route_revision") != state["task_route_revision"]:
@@ -536,8 +579,7 @@ def _update(args: argparse.Namespace, task_dir: Path, data: dict, state: dict) -
             if outcome != args.closeout_disposition:
                 raise TaskWorkflowError("TASK_PHASE_INVALID_INPUT", "Delivery Review and On-Site Closeout Phase outcome must match --closeout-disposition")
             if args.closeout_disposition == "cancelled":
-                withdrawal = state.get("return_record")
-                if not isinstance(withdrawal, dict) or withdrawal.get("to") != PHASE_IDS[4] or not withdrawal.get("evidence_refs"):
+                if not _is_withdrawal_route(state):
                     raise TaskWorkflowError("TASK_PHASE_USER_CONFIRMATION_REQUIRED", "cancellation closeout requires a user-confirmed route to Delivery Review and On-Site Closeout Phase")
             child_dispositions = _validate_child_dispositions(
                 task_dir, data, args.closeout_disposition, args.child_disposition
@@ -563,17 +605,38 @@ def _update(args: argparse.Namespace, task_dir: Path, data: dict, state: dict) -
             _advance(state, current)
     elif action == "return":
         target = _required_text(args.target_phase, "--target-phase")
+        return_kind = args.return_kind
+        execution_rework = return_kind == "execution_rework"
         if target not in state["phase_ids"] or (
             state["phase_ids"].index(target) >= state["phase_ids"].index(current)
-            and not (reviewed_delivery and target == current)
+            and not ((reviewed_delivery or accepted_design_return or execution_rework) and target == current)
         ):
             raise TaskWorkflowError("TASK_PHASE_INVALID_TRANSITION", "return target must be an earlier phase in the current route")
         reason = _required_text(args.reason, "--reason")
         evidence = _refs(args.evidence_ref, "--evidence-ref", required=True)
+        authorization = state.get("implementation_authorization")
+        admission = state.get("route_dependency_admission")
+        if execution_rework:
+            if current not in PHASE_IDS[3:] or target not in PHASE_IDS[3:] or PHASE_IDS[3] not in state["phase_ids"]:
+                raise TaskWorkflowError("TASK_PHASE_INVALID_TRANSITION", "execution_rework is limited to implementation and delivery phases")
+            candidate = copy.deepcopy(data)
+            candidate_state = candidate["meta"]["task_workflow"]
+            _invalidate_from(candidate_state, target, keep_first=True)
+            candidate_state["implementation_authorization"] = authorization
+            _require_current_accepted_artifacts(task_dir, candidate_state)
+            candidate_state["current_phase_id"] = PHASE_IDS[3]
+            candidate_state["phases"][PHASE_IDS[3]]["status"] = "active"
+            if not implementation_start_ready(candidate, task_dir):
+                raise TaskWorkflowError("TASK_PHASE_IMPLEMENTATION_NOT_AUTHORIZED", "execution_rework requires the unchanged authorized implementation contract")
+            if admission is not None and (admission.get("admission_state") != "ready" or admission.get("task_route_revision") != state["task_route_revision"]):
+                raise TaskWorkflowError("TASK_PHASE_ADMISSION_REQUIRED", "execution_rework requires current ready dependency admission")
         state["input_revision"] = _increment(state["input_revision"])
         _invalidate_from(state, target, keep_first=True)
+        if execution_rework:
+            state["implementation_authorization"] = authorization
+            state["route_dependency_admission"] = admission
         state["phases"][target]["input_revision"] = state["input_revision"]
-        state["return_record"] = {"from": current, "to": target, "reason": reason, "evidence_refs": evidence, "task_route_revision": state["task_route_revision"]}
+        state["return_record"] = {"from": current, "to": target, "return_kind": return_kind, "authorization_retained": execution_rework, "reason": reason, "evidence_refs": evidence, "task_route_revision": state["task_route_revision"]}
     elif action == "route":
         phases = _validate_route(args.phase_ids)
         task_kind = args.task_kind if args.task_kind is not None else state["task_kind"]
@@ -685,6 +748,7 @@ def _update(args: argparse.Namespace, task_dir: Path, data: dict, state: dict) -
                 raise TaskWorkflowError("TASK_PHASE_STALE_ARTIFACT", "Solution Design and Convergence Phase implementation contract changed after acceptance; refresh and accept the current artifact before authorization")
         elif contract_ref not in state.get("skip_records", {}).get(PHASE_IDS[2], {}).get("evidence_refs", []):
             raise TaskWorkflowError("TASK_PHASE_CONTRACT_NOT_ACCEPTED", "when Solution Design and Convergence Phase is omitted, the implementation contract must be among its route evidence")
+        _require_acceptance_coverage(task_dir, contract_ref)
         state["implementation_authorization"] = {"contract_ref": contract_ref, "contract_revision": _artifact_digest(task_dir, [contract_ref]), "approval_ref": approval_ref, "task_route_revision": state["task_route_revision"]}
         if current == PHASE_IDS[2]:
             _advance(state, current)
@@ -745,6 +809,56 @@ def _paseo_list(args: list[str], cwd: Path, code: str) -> list[dict]:
     return value
 
 
+def _delegation_binding(repo_root: Path, child_dir: Path, child_data: dict, result_path: str) -> dict:
+    if not isinstance(result_path, str) or Path(result_path).is_absolute() or ".." in Path(result_path).parts or not result_path.startswith(".trellis/delegated-results/"):
+        raise TaskWorkflowError("TASK_DELEGATE_CONTRACT_INVALID", "result path must stay under .trellis/delegated-results/")
+    try:
+        contract_path = (child_dir / "prd.md").resolve(strict=True)
+        contract_path.relative_to(child_dir.resolve())
+        role_path = (repo_root / ".trellis/agents/delegated-worktree-primary-agent.md").resolve(strict=True)
+        role_path.relative_to((repo_root / ".trellis/agents").resolve())
+        if not contract_path.is_file() or not role_path.is_file() or contract_path.stat().st_size + role_path.stat().st_size > 1048576:
+            raise ValueError("delegated contract and role must be regular files within the size budget")
+        contract = contract_path.read_bytes()
+        role = role_path.read_bytes()
+    except (OSError, ValueError) as error:
+        raise TaskWorkflowError("TASK_DELEGATE_CONTRACT_INVALID", str(error)) from error
+    if not contract.strip() or not role.strip():
+        raise TaskWorkflowError("TASK_DELEGATE_CONTRACT_INVALID", "child PRD and delegated role must be nonempty")
+    return {
+        "contract_sha256": hashlib.sha256(contract).hexdigest(),
+        "role_sha256": hashlib.sha256(role).hexdigest(),
+        "branch": _required_text(child_data.get("branch"), "child branch"),
+        "base_commit": _git_output(["rev-parse", "--verify", "--end-of-options", f"{_required_text(child_data.get('base_branch'), 'child base_branch')}^{{commit}}"], repo_root),
+        "result_path": result_path,
+    }
+
+
+def cmd_delegate_bind(args: argparse.Namespace) -> int:
+    try:
+        repo_root = get_repo_root().resolve()
+        child_dir = _task_dir(args.child_task)
+        child, _ = _load(child_dir)
+        if not isinstance(child.get("parent"), str) or not child["parent"].strip():
+            raise TaskWorkflowError("TASK_DELEGATE_PARENT_LINK_INVALID", "child task has no parent link")
+        parent_dir = _task_dir(child["parent"])
+        parent, meta = _load(parent_dir)
+        if child_dir.name not in parent.get("children", []) or not implementation_start_ready(parent, parent_dir):
+            raise TaskWorkflowError("TASK_DELEGATE_IMPLEMENTATION_NOT_AUTHORIZED", "bind only a linked child within current parent implementation authorization")
+        state = _state(meta)
+        authorization = state["implementation_authorization"]
+        result_path = args.result_path or f".trellis/delegated-results/{child_dir.name}.md"
+        binding = _delegation_binding(repo_root, child_dir, child, result_path)
+        binding.update({"authorization_ref": authorization["approval_ref"], "parent_contract_revision": authorization["contract_revision"], "task_route_revision": state["task_route_revision"]})
+        meta.setdefault("delegation_authorizations", {})[child_dir.name] = binding
+        _save(parent_dir / FILE_TASK_JSON, parent)
+        print(json.dumps(binding, ensure_ascii=False))
+        return 0
+    except TaskWorkflowError as error:
+        print(f"{error.code}: {error}", file=sys.stderr)
+        return 1
+
+
 def cmd_delegate_start(args: argparse.Namespace) -> int:
     try:
         repo_root = get_repo_root().resolve()
@@ -760,6 +874,11 @@ def cmd_delegate_start(args: argparse.Namespace) -> int:
             child_data, child_meta = _load(child_dir)
             if child_data.get("parent") != parent_dir.name or child_dir.name not in parent_data.get("children", []):
                 raise TaskWorkflowError("TASK_DELEGATE_PARENT_LINK_INVALID", "parent and child task links do not match")
+            from .task_continuity import assert_task_mutation_allowed
+
+            assert_task_mutation_allowed(repo_root, parent_dir, parent_data)
+            if child_data.get("status") not in {"planning", "in_progress"}:
+                raise TaskWorkflowError("TASK_DELEGATE_CHILD_TERMINAL", "only a planning or in-progress child task can be delegated")
             if parent_data.get("status") != "in_progress" or not implementation_start_ready(parent_data, parent_dir):
                 raise TaskWorkflowError("TASK_DELEGATE_IMPLEMENTATION_NOT_AUTHORIZED", "parent task is not at an authorized Task Implementation and Test Verification Phase entry")
 
@@ -813,6 +932,7 @@ def cmd_delegate_start(args: argparse.Namespace) -> int:
                 raise TaskWorkflowError("TASK_DELEGATE_PASEO_UNAVAILABLE", f"could not run Paseo: {error}") from error
             if version.returncode != 0:
                 raise TaskWorkflowError("TASK_DELEGATE_PASEO_UNAVAILABLE", (version.stderr or version.stdout).strip() or "Paseo CLI preflight failed")
+            _paseo_list(["agent", "ls", "--all", "--global", "--background", "--json"], repo_root, "TASK_DELEGATE_PASEO_UNAVAILABLE")
             role_path = repo_root / ".trellis" / "agents" / "delegated-worktree-primary-agent.md"
             try:
                 role = role_path.read_text(encoding="utf-8")
@@ -823,6 +943,16 @@ def cmd_delegate_start(args: argparse.Namespace) -> int:
             if not isinstance(authorization, dict) or not isinstance(authorization.get("approval_ref"), str):
                 raise TaskWorkflowError("TASK_DELEGATE_AUTHORIZATION_INVALID", "current implementation authorization is invalid")
             contract_digest = hashlib.sha256(contract_bytes).hexdigest()
+            bindings = parent_meta.get("delegation_authorizations", {})
+            binding = bindings.get(child_dir.name) if isinstance(bindings, dict) else None
+            if not isinstance(binding, dict):
+                raise TaskWorkflowError("TASK_DELEGATE_CONTRACT_NOT_BOUND", "freeze this child through delegate-bind before dispatch")
+            actual = _delegation_binding(repo_root, child_dir, child_data, binding.get("result_path", ""))
+            if any(binding.get(key) != value for key, value in actual.items()) or actual["contract_sha256"] != contract_digest or actual["role_sha256"] != hashlib.sha256(role.encode("utf-8")).hexdigest() or binding.get("authorization_ref") != authorization["approval_ref"] or binding.get("parent_contract_revision") != authorization["contract_revision"] or binding.get("task_route_revision") != state["task_route_revision"]:
+                raise TaskWorkflowError("TASK_DELEGATE_STALE_CONTRACT", "child PRD, role, Git base, output path, or parent authorization changed; review and bind the child again")
+            prompt_bytes = len((role + contract).encode("utf-8"))
+            if prompt_bytes > (24000 if os.name == "nt" else 96000):
+                raise TaskWorkflowError("TASK_DELEGATE_PROMPT_TOO_LARGE", "delegated prompt exceeds the native Paseo argv budget; narrow the contract before creating resources")
             previous = child_meta.get("delegated_worktree_execution_record")
             reuse_workspace = False
             workspace_id = None
@@ -846,7 +976,7 @@ def cmd_delegate_start(args: argparse.Namespace) -> int:
                 previous_worktree = Path(previous_worktree_path).expanduser().resolve()
                 agents = _paseo_list([
                     "agent", "ls", "--all", "--global", "--background", "--json",
-                    "--label", f"trellis.task_id={child_dir.name}",
+                    "--label", f"trellis.task_id={previous.get('label_task_id', child_dir.name)}",
                 ], repo_root, "TASK_DELEGATE_RECONCILIATION_REQUIRED")
                 for agent in agents:
                     agent_id = agent.get("id")
@@ -897,9 +1027,14 @@ def cmd_delegate_start(args: argparse.Namespace) -> int:
                 "workspace_id": workspace_id,
                 "worktree_path": str(worktree) if worktree else None,
                 "agent_id": None,
+                "label_task_id": child_dir.name,
+                "role_sha256": actual["role_sha256"],
+                "result_path": actual["result_path"],
                 "status": "starting",
                 "started_at": datetime.now(timezone.utc).isoformat(),
             }
+            if previous is not None:
+                child_meta.setdefault("delegated_worktree_execution_history", []).append(previous)
             child_meta["delegated_worktree_execution_record"] = record
             _save(child_dir / FILE_TASK_JSON, child_data)
 
@@ -940,6 +1075,7 @@ def cmd_delegate_start(args: argparse.Namespace) -> int:
                     "the parent authorization and Git baseline are execution metadata. Do not accept task phases or change task lifecycle state.\n\n"
                     f"Parent task: {parent_dir.name}\nParent route revision: {state['task_route_revision']}\n"
                     f"Authorized contract: prd.md\nBranch: {branch}\nBase commit: {base_commit}\n\n"
+                    f"Assigned result artifact: {actual['result_path']}\n"
                     f"{role}\n\n## Child task prd.md\n{contract}"
                 )
                 agent = _paseo_json([
@@ -1001,6 +1137,56 @@ def cmd_cancel_task(args: argparse.Namespace) -> int:
         return 1
 
 
+def cmd_reopen_task(args: argparse.Namespace) -> int:
+    try:
+        task_dir = _task_dir(args.task_dir)
+        with _task_lock(task_dir):
+            data, meta = _load(task_dir)
+            previous_status = data.get("status")
+            if previous_status not in {"completed", "cancelled"}:
+                raise TaskWorkflowError("TASK_PHASE_REOPEN_INVALID_STATUS", "only completed or cancelled tasks can be reopened")
+            reason = _required_text(args.reason, "--reason")
+            evidence = _refs(args.evidence_ref, "--evidence-ref", required=True)
+            _assert_delegated_resources_closed(task_dir, data)
+            recoveries = meta.setdefault("task_lifecycle_recoveries", [])
+            if not isinstance(recoveries, list) or any(not isinstance(record, dict) for record in recoveries):
+                raise TaskWorkflowError("TASK_PHASE_TASK_INVALID", "task lifecycle recovery history is malformed")
+            recovery = {
+                "from_status": previous_status,
+                "to_status": "planning",
+                "reason": reason,
+                "evidence_refs": evidence,
+                "reopened_at": datetime.now(timezone.utc).isoformat(),
+                "terminal_completed_at": data.get("completedAt"),
+                "terminal_cancellation": copy.deepcopy(meta.get("task_cancellation")),
+            }
+            state = meta.get("task_workflow")
+            if state is not None:
+                state = _state(meta)
+                state["implementation_authorization"] = None
+                state["route_dependency_admission"] = None
+                state["closeout_disposition"] = None
+            recoveries.append(recovery)
+            data["status"] = "planning"
+            data["completedAt"] = None
+            from .task_move import relocate_task
+            from .active_task import clear_task_from_sessions
+            from .task_continuity import clear_task_runtime_records
+
+            repo_root = get_repo_root()
+            # Relocation rewrites runtime paths; terminal runtime must be discarded first.
+            for runtime_dir in (task_dir, repo_root / ".trellis/tasks/planning" / task_dir.name):
+                clear_task_from_sessions(str(runtime_dir), repo_root)
+                if not clear_task_runtime_records(repo_root, runtime_dir.relative_to(repo_root).as_posix()):
+                    raise TaskWorkflowError("TASK_PHASE_RUNTIME_CLEANUP_FAILED", "could not discard terminal task runtime; task remains terminal")
+            task_dir = relocate_task(repo_root, task_dir, data)
+            print(json.dumps({"status": "planning", "task_lifecycle_recovery": recovery, "runtime_records_cleared": True}, ensure_ascii=False))
+            return 0
+    except TaskWorkflowError as error:
+        print(f"{error.code}: {error}", file=sys.stderr)
+        return 1
+
+
 def task_closeout_readiness(data: dict, disposition: str) -> str | None:
     if "meta" in data and not isinstance(data["meta"], dict):
         return "task metadata is malformed"
@@ -1022,8 +1208,7 @@ def task_closeout_readiness(data: dict, disposition: str) -> str | None:
     if state.get("closeout_disposition") != disposition:
         return f"Delivery Review and On-Site Closeout Phase disposition is {state.get('closeout_disposition')}; expected {disposition}"
     if disposition == "cancelled":
-        withdrawal = state.get("return_record")
-        if not isinstance(withdrawal, dict) or withdrawal.get("to") != PHASE_IDS[4] or not withdrawal.get("evidence_refs"):
+        if not _is_withdrawal_route(state):
             return "cancellation requires a user-confirmed route to Delivery Review and On-Site Closeout Phase"
     return None
 
@@ -1073,6 +1258,67 @@ def _validate_child_dispositions(
     return choices
 
 
+def cmd_delegate_reconcile(args: argparse.Namespace) -> int:
+    try:
+        root = get_repo_root().resolve()
+        task_dir = _task_dir(args.child_task)
+        data, meta = _load(task_dir)
+        record = meta.get("delegated_worktree_execution_record")
+        if not isinstance(record, dict):
+            raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "no valid delegated execution mapping")
+        if record.get("status") == "retired" and isinstance(record.get("closure_evidence"), dict):
+            print(json.dumps(record, ensure_ascii=False))
+            return 0
+        label = record.get("label_task_id", task_dir.name)
+        agents = _paseo_list(["agent", "ls", "--all", "--global", "--background", "--json", "--label", f"trellis.task_id={label}"], root, "TASK_DELEGATE_RECONCILIATION_REQUIRED")
+        if any(agent.get("status") != "closed" for agent in agents):
+            raise TaskWorkflowError("TASK_PHASE_RESOURCE_ACTIVE", "a delegated Paseo agent is still active or unknown")
+        agent_id = record.get("agent_id")
+        if agent_id and not any(agent.get("id") == agent_id for agent in agents):
+            raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "recorded agent is not available; preserve its mapping until native closure evidence is available")
+        worktree_path = record.get("worktree_path")
+        workspace_id = record.get("workspace_id")
+        workspaces = _paseo_list(["workspace", "ls", "--background", "--json"], root, "TASK_DELEGATE_RECONCILIATION_REQUIRED")
+        workspace = next((row for row in workspaces if row.get("workspaceId") == workspace_id), None) if workspace_id else None
+        if workspace and (not isinstance(worktree_path, str) or Path(workspace.get("cwd", "")).resolve() != Path(worktree_path).resolve()):
+            raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "workspace mapping does not match")
+        head = None
+        if isinstance(worktree_path, str) and Path(worktree_path).is_dir():
+            worktree = Path(worktree_path).resolve()
+            common = Path(_git_output(["rev-parse", "--git-common-dir"], worktree))
+            common = (common if common.is_absolute() else worktree / common).resolve()
+            expected_common = Path(_git_output(["rev-parse", "--git-common-dir"], root))
+            expected_common = (expected_common if expected_common.is_absolute() else root / expected_common).resolve()
+            if common != expected_common or _git_output(["branch", "--show-current"], worktree) != record.get("branch"):
+                raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "worktree does not belong to the recorded repository and branch")
+            dirty = _git_output(["status", "--porcelain", "--untracked-files=all"], worktree)
+            allowed = "?? " + record.get("result_path", "")
+            if any(line != allowed for line in dirty.splitlines()):
+                raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "worktree contains unintegrated changes; preserve and integrate them before retiring")
+            head = _git_output(["rev-parse", "HEAD"], worktree)
+            if run_git(["merge-base", "--is-ancestor", head, "HEAD"], cwd=root)[0] != 0:
+                raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "worktree commits are not integrated into the coordinator checkout")
+        elif workspace:
+            raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "workspace still exists but its worktree cannot be inspected")
+        elif not agent_id:
+            branch = record.get("branch")
+            if not isinstance(branch, str) or run_git(["show-ref", "--verify", "--quiet", f"refs/heads/{branch}"], cwd=root)[0] != 1:
+                raise TaskWorkflowError("TASK_DELEGATE_RECONCILIATION_REQUIRED", "incomplete mapping still has an unresolved branch")
+        evidence = {"agent_ids": [agent.get("id") for agent in agents], "workspace_id": workspace_id, "head": head, "checked_at": datetime.now(timezone.utc).isoformat()}
+        if not args.execute:
+            print(json.dumps({"status": "ready", "evidence": evidence}, ensure_ascii=False))
+            return 0
+        reason = _required_text(args.reason, "--reason")
+        approval_ref = _required_text(args.approval_ref, "--approval-ref")
+        record.update({"status": "retired", "closure_evidence": {**evidence, "reason": reason, "approval_ref": approval_ref}})
+        _save(task_dir / FILE_TASK_JSON, data)
+        print(json.dumps(record, ensure_ascii=False))
+        return 0
+    except TaskWorkflowError as error:
+        print(f"{error.code}: {error}", file=sys.stderr)
+        return 1
+
+
 def _assert_delegated_resources_closed(task_dir: Path, data: dict) -> None:
     children = data.get("children", [])
     if not isinstance(children, list):
@@ -1085,17 +1331,23 @@ def _assert_delegated_resources_closed(task_dir: Path, data: dict) -> None:
 def _assert_delegated_record_closed(task_id: str, record) -> None:
     if record is None:
         return
+    if isinstance(record, dict) and record.get("status") == "retired" and isinstance(record.get("closure_evidence"), dict):
+        return
     agent_id = record.get("agent_id") if isinstance(record, dict) else None
     if not isinstance(agent_id, str) or not agent_id.strip():
         raise TaskWorkflowError("TASK_PHASE_RESOURCE_ACTIVE", f"delegated execution status is unknown for {task_id}; preserve the current state")
     agents = _paseo_list(
-        ["agent", "ls", "--all", "--global", "--background", "--json", "--label", f"trellis.task_id={task_id}"],
+        ["agent", "ls", "--all", "--global", "--background", "--json", "--label", f"trellis.task_id={record.get('label_task_id', task_id)}"],
         get_repo_root(),
         "TASK_PHASE_RESOURCE_ACTIVE",
     )
     agent = next((item for item in agents if item.get("id") == agent_id), None)
     if agent is None or agent.get("status") != "closed":
         raise TaskWorkflowError("TASK_PHASE_RESOURCE_ACTIVE", f"delegated Paseo agent for {task_id} is not confirmed closed; preserve the current state")
+    worktree_path = record.get("worktree_path")
+    if isinstance(worktree_path, str) and Path(worktree_path).is_dir():
+        if _git_output(["status", "--porcelain", "--untracked-files=all", "--", ".trellis/tasks", ".trellis/.runtime"], Path(worktree_path)):
+            raise TaskWorkflowError("TASK_DELEGATE_TASK_FACTS_CHANGED", "delegated worktree changed protected task facts; preserve evidence and exclude those changes before integration")
 
 
 def cmd_complete_task(args: argparse.Namespace) -> int:

package/dist/templates/trellis/scripts/task.py

@@ -14,6 +14,7 @@ Usage:
     python3 task.py workflow <id>|--clear       # Set/clear per-task workflow selection
     python3 task.py phase <action> <task-dir>    # Read/update task phase workflow state
     python3 task.py cancel <task-dir> --reason <text> --evidence-ref <ref>  # Cancel task lifecycle
+    python3 task.py reopen <task-dir> --reason <text> --evidence-ref <ref>  # Restore terminal task to planning
     python3 task.py set-branch <dir> <branch>   # Set git branch
     python3 task.py set-base-branch <dir> <branch>  # Set PR target branch
     python3 task.py set-scope <dir> <scope>     # Set scope for PR title
@@ -79,8 +80,11 @@ from common.task_context import (
 from common.task_workflow import (
     TaskWorkflowError,
     cmd_cancel_task,
+    cmd_reopen_task,
     cmd_complete_task,
     cmd_delegate_start,
+    cmd_delegate_bind,
+    cmd_delegate_reconcile,
     cmd_phase,
     implementation_start_ready,
 )
@@ -266,11 +270,11 @@ def cmd_start(args: argparse.Namespace) -> int:
             run_task_hooks("after_start", task_json_path, repo_root)
         return 0
 
+    if task_json_path.is_file():
+        task_json_path = _record_start_state(task_json_path, repo_root)
+        task_dir = task_json_path.parent.relative_to(repo_root).as_posix()
     active = set_active_task(task_dir, repo_root)
     if active:
-        if task_json_path.is_file():
-            task_json_path = _record_start_state(task_json_path, repo_root)
-
         print(colored(f"✓ Current task set to: {task_json_path.parent.relative_to(repo_root).as_posix()}", Colors.GREEN))
         print(f"Source: {active.source}")
         print()
@@ -779,6 +783,7 @@ def main() -> int:
     p_phase.add_argument("--route-reason", help="Reason when initialization omits one or more phases")
     p_phase.add_argument("--route-evidence-ref", action="append", help="Evidence supporting an abbreviated initial route")
     p_phase.add_argument("--target-phase", help="Earlier phase to revisit, or first affected phase for route change")
+    p_phase.add_argument("--return-kind", choices=("contract_change", "execution_rework"), default="contract_change", help="Contract change invalidates authorization; execution rework retains a verified unchanged contract")
     p_phase.add_argument("--artifact-ref", action="append", help="Task-relative file in the current phase output")
     p_phase.add_argument("--artifact-revision", help="Current artifact_revision required for acceptance")
     p_phase.add_argument("--result-ref", help="Task result artifact reference")
@@ -794,6 +799,14 @@ def main() -> int:
 
     p_delegate = subparsers.add_parser("delegate-start", help="Start an authorized child task in a Paseo worktree")
     p_delegate.add_argument("child_task", help="Linked child task directory or name")
+    p_delegate_bind = subparsers.add_parser("delegate-bind", help="Freeze a linked child contract within current parent authorization")
+    p_delegate_bind.add_argument("child_task")
+    p_delegate_bind.add_argument("--result-path", help="Assigned artifact under .trellis/delegated-results/")
+    p_delegate_reconcile = subparsers.add_parser("delegate-reconcile", help="Inspect or explicitly retire a verified delegated execution")
+    p_delegate_reconcile.add_argument("child_task")
+    p_delegate_reconcile.add_argument("--execute", action="store_true")
+    p_delegate_reconcile.add_argument("--reason")
+    p_delegate_reconcile.add_argument("--approval-ref")
 
     add_continuity_commands(subparsers)
 
@@ -803,6 +816,11 @@ def main() -> int:
     p_cancel.add_argument("--reason", required=True, help="Why the task is cancelled")
     p_cancel.add_argument("--evidence-ref", action="append", required=True, help="Task-relative cancellation evidence")
 
+    p_reopen = subparsers.add_parser("reopen", help="Recover a terminal task to planning without implementation authorization")
+    p_reopen.add_argument("task_dir", help="Task directory or task name")
+    p_reopen.add_argument("--reason", required=True, help="Why the same task must continue")
+    p_reopen.add_argument("--evidence-ref", action="append", required=True, help="Recovery decision evidence")
+
     # set-branch
     p_branch = subparsers.add_parser("set-branch", help="Set git branch")
     p_branch.add_argument("dir", help="Task directory")
@@ -878,8 +896,11 @@ def main() -> int:
         "workflow": cmd_workflow,
         "phase": cmd_phase,
         "delegate-start": cmd_delegate_start,
+        "delegate-bind": cmd_delegate_bind,
+        "delegate-reconcile": cmd_delegate_reconcile,
         "complete": cmd_complete_task,
         "cancel": cmd_cancel_task,
+        "reopen": cmd_reopen_task,
         "set-branch": cmd_set_branch,
         "set-base-branch": cmd_set_base_branch,
         "set-scope": cmd_set_scope,
@@ -903,6 +924,9 @@ def main() -> int:
                 return commands[args.command](args)
             show_usage()
             return 1
+    except TaskWorkflowError as error:
+        print(f"{error.code}: {error}", file=sys.stderr)
+        return 1
     except (ValueError, OSError) as error:
         print(f"TASK_LAYOUT_WITHHELD: {error}", file=sys.stderr)
         return 1

package/dist/templates/trellis/teamwork.json

@@ -0,0 +1,10 @@
+{
+  "schema_version": 2,
+  "default_mode": "general",
+  "modes": {
+    "general": { "default_members": 1, "max_concurrency": 8 },
+    "advisor": { "default_members": 3, "max_concurrency": 3 },
+    "committee": { "default_members": 3, "max_concurrency": 3 }
+  },
+  "resources": { "max_live_teammates": 8, "non_batch_reserved": 0 }
+}

package/dist/templates/trellis/workflow.md

@@ -30,12 +30,19 @@ python3 ./.trellis/scripts/task.py validate <task>
 python3 ./.trellis/scripts/task.py start <task>
 python3 ./.trellis/scripts/task.py complete <task>
 python3 ./.trellis/scripts/task.py cancel <task> --reason "<reason>" --evidence-ref <reference>
+python3 ./.trellis/scripts/task.py reopen <task> --reason "<reason>" --evidence-ref <reference>
 ```
 
 使用 `phase artifact`、`accept`、`skip`、`wait`、`block`、`resume`、`return`、`route` 和 `authorize` 执行对应的阶段操作。准确参数以 `task.py --help` 为准。跳过阶段必须提供理由和证据；目标探索与需求核对阶段不可省略。
 
 只有阶段路线已到达获准的实施入口时，`task.py start` 才会将任务从 `planning` 改为 `in_progress`。分析任务可在交付审查与现场收尾阶段后仍处于 `planning` 时完成。`complete` 将任务移入 `completed/YYYY-MM/<task>`，`cancel` 将任务移入 `cancelled/<task>`，并在同一事务中清除任务的运行时会话指针。
 
+工作流阶段回流与原生任务生命周期恢复分别操作。`completed` 或 `cancelled` 任务需要在原线程继续时，先用 `reopen` 恢复到 `planning`，保留终态事实、取消原因和恢复证据，清除旧运行态、实施授权和依赖准入；工作流阶段保持原记录。随后用 `phase return` 回到最早受影响阶段。实现任务重新接受合同、取得新的实施授权并核验准入后，才由 `start` 进入 `in_progress`。`phase return` 不能直接修改终态任务。
+
+`phase return` 默认采用 `contract_change`，使受影响阶段接受和实施授权失效。合同不变的局部实施或证据返工可显式使用 `--return-kind execution_rework`，目标限于实施或交付阶段，可重入当前阶段；CLI 核验需求、已接受合同、授权摘要、路线 revision 和已声明依赖准入仍有效后，保留授权，清理目标阶段及下游的接受事实。不能以此修改目标、合同或绕过待决依赖。普通局部修复可直接在当前活动阶段完成，无需为了记录进展而回流。
+
+新接受的 `implementation_contract`（以及省略设计阶段时新授权的合同）必须包含 `## 验收覆盖` 表，表头固定为 `接受条件 | 工作包 | Owner | 验证入口 | 交付证据 | 停止条件`，至少一行且各单元格非空。CLI 负责结构检查，阶段 Skill 负责逐条核对已接受条件的语义覆盖。既有接受和授权不会因本次升级自动失效；再次接受或授权时执行新检查。
+
 旧布局须先预览 `task.py migrate-layout`，核对后执行 `task.py migrate-layout --apply`；旧 `archive/YYYY-MM` 中已完成的任务保留原月份，其他任务按真实状态放置。迁移会同步 JSON/JSONL 机器引用、会话指针和运行态索引，保留任务身份与父子关系，不重授历史授权。未完成事务会阻止普通任务命令，须用 `task.py migrate-layout --recover` 恢复；输入被外部改动时停止并保留现场。路径或产物内容改变导致接受证据失效时，须经原生阶段接受或 continuity 核对重新收敛。
 
 在支持原生实施或检查 agent 的平台上，任务上下文清单（`implement.jsonl`、`check.jsonl`）用于提供相关规范和研究资料。只有这些 agent 会读取清单时才需要维护；清单不能替代任务资产或阶段证据。

package/dist/utils/asset-backup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-backup.d.ts","sourceRoot":"","sources":["../../src/utils/asset-backup.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,QAAA,MAAM,iBAAiB;;;;;;;oBAGrB,CAAC;AASH,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCT,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACzD,KAAK,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AA+ErD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,CAmCrE;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,QAAQ,CAAC,MAAM,CAAM,GAC3B,MAAM,EAAE,CAIV;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,WAAW,CAAC,QAAQ,CAAY,EACxC,KAAK,WAAyB,GAC7B,WAAW,CA2Db;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAa9D;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAiBD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,EAAE,CA4FpE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAQxD;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,CAAC,EAClB,QAAQ,UAAQ,GACf,CAAC,CAUH;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACV,GACL;IACD,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3C,CA8CA;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;QACjD,OAAO,EAAE,WAAW,CAAC;QACrB,OAAO,EAAE,WAAW,CAAC;KACtB,EAAE,CAAC;CACL;AAsBD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,eAAe,UAAQ,GACtB,gBAAgB,CAsDlB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1E,gBAAgB,CAmDlB"}
+{"version":3,"file":"asset-backup.d.ts","sourceRoot":"","sources":["../../src/utils/asset-backup.ts"],"names":[],"mappings":"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"}