flower-trellis 0.5.0-beta.6 → 0.5.1-beta.0

package/enhancements/0.6/.agents/skills/trellis-auto-loop/SKILL.md

@@ -22,11 +22,19 @@ description: "启动、恢复和推进 Trellis 自动任务循环。用于用户
 - auto-loop 启动前若 implement 与 check 都缺 route，优先展示 auto-loop 专用的合并选择，不要把 `trellis-route` 的两套完整 fallback 原样贴给用户。仍允许用户回复高级格式 `implement 1, check 1`。
 - 检查深度由 run 级 `--check-depth auto|light|full` 控制，默认 `auto`，与 `--route-check` 独立；历史 run 缺少该字段时按 `full` 兼容。
 - 代码提交必须复用 `trellis-push` 的内部 commit-only 执行能力；auto-loop 自己负责预授权校验和 runner 回写，不要裸 `git commit` / `git push`。
+- `Open Questions` 的确定性状态由 runner 处理：`- [ ]` 阻塞，`- [x]` 不阻塞，无章节或空章节放行。历史无 checkbox 列表只能按 `review_open_questions` action 做语义复核，不能自行跳过 runner 回写。
+- 启动或恢复 validated auto-loop 前先运行 `python3 ./.trellis/scripts/pre_check_state.py clear`，静默清除当前任务的交互式 Check-All 前暂缓偏好。清理返回 miss 或 task mismatch 视为无状态；runtime 损坏只记录诊断，不得阻断 runner，也不得让 runner 读取该偏好。
 
 ## 启动
 
 用户给了任务列表时，按原顺序传入；用户只说当前任务时，用 `task.py current --source` 的当前任务。
 
+启动前先静默清理交互式暂缓偏好：
+
+```bash
+python3 ./.trellis/scripts/pre_check_state.py clear
+```
+
 启动前对当前任务执行 route 准备度检查：
 
 ```bash
@@ -81,6 +89,7 @@ python3 ./.trellis/scripts/auto_loop.py next
 压缩、重开会话、用户说“继续自动跑 / continue auto loop”时：
 
 ```bash
+python3 ./.trellis/scripts/pre_check_state.py clear
 python3 ./.trellis/scripts/auto_loop.py resume
 python3 ./.trellis/scripts/auto_loop.py next
 ```
@@ -107,7 +116,10 @@ python3 ./.trellis/scripts/auto_loop.py next
 
 | runner action | 主 agent 动作 | 成功 record |
 | --- | --- | --- |
-| `refresh_brief` | 使用 `trellis-task-brief` 生成并展示 brief | `record --action refresh_brief --result ok` |
+| `review_open_questions` | 结合 PRD 语义判断历史裸列表是已解决、仍阻塞或无法确定 | 已解决：`record --action review_open_questions --result ok --review-verdict resolved --summary "<摘要>"`；仍阻塞/无法确定：使用 `--result blocked --review-verdict blocking|ambiguous` |
+| `review_planning_readiness` | 按 `trellis-brainstorm` Quality Bar 复核验收标准可测试、范围明确、关键决策收敛、仓库问题已研究 | ready：`record --action review_planning_readiness --result ok --readiness-verdict ready --summary "<摘要>"`；仍阻塞/无法确定：使用 `--result blocked --readiness-verdict blocking|ambiguous` |
+| `refresh_brief` | 使用 `trellis-task-brief` 刷新并展示 brief；这一步不代表用户确认 | `record --action refresh_brief --result ok` |
+| `confirm_brief` | 再次展示 action 对应的完整 brief，并等待用户显式确认 | 收到确认后：`record --action confirm_brief --result ok --summary "<确认摘要>"`；未确认时停止，不得 record |
 | `start_task` | 执行返回的 `task.py start ...` 命令 | `record --action start_task --result ok` |
 | `run_implement` | 进入 Phase 2.1，先用 `trellis-route(target=implement)` 决定 inline/subagent，再实现 | `record --action run_implement --result ok --route-mode <mode> --route-source <source>` |
 | `run_check_all` | 进入 Phase 2.2，先用 `trellis-route(target=check)`，按 action 的 requested depth 执行 Check-All | `record --action run_check_all --result ok --route-mode <mode> --route-source <source> --effective-check-depth <light|full> --check-depth-reason "<摘要>"` |
@@ -143,6 +155,12 @@ python3 ./.trellis/scripts/auto_loop.py record \
 
 runner 会按 3 轮 fix/recheck 预算决定继续、跳过当前任务或结束队列。
 
+`review_open_questions` 必须只依据 action 返回的 `questions` 和当前 PRD 判断。runner 会把结果绑定到 action 发出时的 PRD SHA-256；PRD 在复核期间发生变化时，record 会返回 `stale-open-questions-review`，此时重新运行 `next`，不得复用旧判断。`ambiguous` 必须保守阻塞，交由用户或 planning 收敛。
+
+`review_planning_readiness` 必须读取 action 指向的当前 planning artifacts，并按 Brainstorm Gate 的语义质量线复核，不能把文件存在、章节存在或 route context 已 curated 当作 ready。runner 会把结论绑定到 `prd.md`、存在时的 `design.md`/`implement.md` 内容；任一文件变化后旧结论失效。
+
+`refresh_brief` 成功后必须立即 `next`。runner 随后返回 `confirm_brief`，主 agent 要展示当前完整 brief 并停止等待用户；启动 auto-loop、选择 route 或生成 brief 都不构成确认。`confirm_brief` 只在收到明确确认后回写，且确认绑定 planning artifacts 与 brief 内容；任一文件变化后必须重新展示并确认。
+
 `record` 默认只返回当前 item 的 `task`、`item_status`、`current_step`、`commit` 和紧凑 `summary`；只有排查状态漂移时才加 `--verbose` 查看完整 `item`。
 
 route action 成功回写时必须带上 `trellis-route` 输出里的真实 `mode` / `source`，例如

package/enhancements/0.6/.agents/skills/trellis-push/SKILL.md

@@ -28,6 +28,16 @@ description: "按确认的精确文件范围提交普通变更或完成已就绪
 
 内部 `commit-only` 不接受临时扩大文件范围、远端推送或其他附加动作。安全条件不满足时返回失败，由调用方决定后续状态。
 
+## Step 0：交互式完成链门禁
+
+除 auto-loop 内部 `commit-only` 外，任何普通 push 或用户 `commit-only` 在读取 Git 提交计划前，都必须确认当前工作内容已经通过 Check-All，且该结论之后存在当前有效的 `spec_update_result`：
+
+- `status=no-op|written`：继续本 skill 的 Git 预检与计划。
+- 缺失，或实际 diff、Check-All 结论、用户 spec 意图已变化：先加载 `trellis-update-spec`，只有新的 `no-op|written` 才能回到本 skill。
+- `status=needs-review`：停止，不生成提交计划。
+
+用户直接说 push/提交不构成跳过 Phase 3.3 的授权。auto-loop 内部 `commit-only` 已由 runner 的 `run_spec_update -> commit_only` 状态机和预授权保证顺序，因此不得重复进入本门禁。
+
 ## Step 1：发现仓库与任务
 
 候选仓库包括：

package/enhancements/0.6/.agents/skills/trellis-route/SKILL.md

@@ -177,11 +177,13 @@ helper 写入规则：保留另一个 target 的 runtime 决策和偏好；覆
 
 | 路由决定 | 主 agent 应执行 |
 |---------|----------------|
-| `inline implement` | `Skill({skill: "trellis-before-dev"})` 加载 spec → 读任务文档 → 主线程实施 → 跑必要验证 |
-| `subagent implement` | `Agent({subagent_type: "trellis-implement"})`；若 `subagent_skip_compile=true`，dispatch prompt 附加“跳过 mvn install / npm run build / tsc 等耗时编译类检查（已由主 agent 验证或最终统一执行）” |
+| `inline implement` | `Skill({skill: "trellis-before-dev"})` 加载 spec → 读任务文档 → 主线程实施 → 跑必要验证 → 回到 Phase 2.1 completion contract 解析 Pre-Check，不得在局部验证后直接结束 |
+| `subagent implement` | `Agent({subagent_type: "trellis-implement"})`；若 `subagent_skip_compile=true`，dispatch prompt 附加“跳过 mvn install / npm run build / tsc 等耗时编译类检查（已由主 agent 验证或最终统一执行）”；主 agent 收到结果后回到 Phase 2.1 completion contract 解析 Pre-Check |
 | `inline check-all` | `Skill({skill: "trellis-check-all"})` |
 | `subagent check-all` | 优先使用明确 audit-only 的 `trellis-check-all` agent；不存在时使用平台通用 subagent，并用下方 dispatch 契约执行本地 `trellis-check-all`。禁止 fallback 到会直接修改工作区的 `trellis-check` agent；无兼容 subagent 时停止并请用户改选 inline |
 
+implement 路由只决定执行位置，不拥有实现后的停止策略。无论 inline 或 subagent，focused validation 完成后都必须返回 workflow Phase 2.1 的 completion contract；由该 owner 处理 auto-loop、用户显式继续/暂缓、已有 hold 和默认立即 Check-All 的优先级。
+
 ### Subagent Check-All Dispatch 契约
 
 使用专用或通用 subagent 时，dispatch prompt 第一行必须是当前任务路径，并包含以下完整边界：

package/enhancements/0.6/.agents/skills/trellis-route/scripts/route_state.py

@@ -5,8 +5,10 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import subprocess
 import sys
+import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -50,22 +52,45 @@ def _utc_now() -> str:
     )
 
 
-def _read_json(path: Path) -> dict[str, Any]:
-    """读取 JSON 对象，失败时返回空对象。"""
+def _read_json_result(path: Path) -> dict[str, Any]:
+    """读取 runtime JSON，并区分缺失、损坏和 I/O 错误。"""
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
-    except (FileNotFoundError, json.JSONDecodeError, OSError):
-        return {}
+    except FileNotFoundError:
+        return {"status": "missing", "data": None, "error": None}
+    except json.JSONDecodeError as exc:
+        return {"status": "corrupt", "data": None, "error": str(exc)}
+    except OSError as exc:
+        return {"status": "io_error", "data": None, "error": str(exc)}
+    if not isinstance(data, dict):
+        return {"status": "corrupt", "data": None, "error": "JSON 根节点不是对象"}
+    return {"status": "ok", "data": data, "error": None}
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    """兼容非关键扫描；仅返回成功解析的 JSON 对象。"""
+    result = _read_json_result(path)
+    data = result.get("data")
     return data if isinstance(data, dict) else {}
 
 
 def _write_json(path: Path, data: dict[str, Any]) -> None:
-    """原子性要求不高的 runtime 状态写入。"""
+    """使用同目录临时文件原子写入 runtime 状态。"""
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        json.dumps(data, indent=2, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
+    fd, temp_name = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp", dir=path.parent)
+    temp_path = Path(temp_name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp_path, path)
+    except Exception:
+        try:
+            temp_path.unlink()
+        except FileNotFoundError:
+            pass
+        raise
 
 
 def _print(data: dict[str, Any]) -> int:
@@ -187,7 +212,27 @@ def _auto_state_path(repo_root: Path, run_id: Any) -> Path | None:
     return _auto_loop_dir(repo_root) / f"{run_id.strip()}.json"
 
 
-def _auto_route_mode(repo_root: Path, context_key: str, target: str) -> tuple[str | None, Path | None, str | None]:
+def _run_contains_task(state: dict[str, Any], current_task: str) -> bool:
+    """判断当前任务是否属于 run 的未完成队列。"""
+    queue = state.get("queue")
+    if not isinstance(queue, list):
+        return False
+    normalized = current_task.replace("\\", "/")
+    for item in queue:
+        if not isinstance(item, dict) or item.get("status") not in {"pending", "running"}:
+            continue
+        task = item.get("task")
+        if isinstance(task, str) and task.replace("\\", "/") == normalized:
+            return True
+    return False
+
+
+def _auto_route_mode(
+    repo_root: Path,
+    context_key: str,
+    current_task: str,
+    target: str,
+) -> tuple[str | None, Path | None, str | None]:
     """读取当前 running auto-loop run 的临时 route 授权。
 
     auto 授权低于个人 `.route-prefs.tmp`，只在当前 session runtime 绑定了
@@ -195,15 +240,26 @@ def _auto_route_mode(repo_root: Path, context_key: str, target: str) -> tuple[st
     如果这些指针 stale，则忽略 stale pointer，并 fallback 到唯一 running run。
     """
     session_path = _session_path(repo_root, context_key)
-    session = _read_json(session_path)
+    session_result = _read_json_result(session_path)
+    if session_result["status"] in {"corrupt", "io_error"}:
+        return None, session_path, f"session-runtime-{session_result['status']}"
+    session = session_result["data"] if isinstance(session_result.get("data"), dict) else {}
     candidate_paths: list[Path] = []
     stale_paths: list[Path] = []
 
-    for run_id in (session.get("current_auto_run"), _read_json(_auto_loop_pointer(repo_root)).get("run_id")):
+    pointer_result = _read_json_result(_auto_loop_pointer(repo_root))
+    pointer = pointer_result["data"] if isinstance(pointer_result.get("data"), dict) else {}
+    for source, run_id in (
+        ("session", session.get("current_auto_run")),
+        ("pointer", pointer.get("run_id")),
+    ):
         path = _auto_state_path(repo_root, run_id)
         if path is None:
             continue
-        state = _read_json(path)
+        result = _read_json_result(path)
+        if source == "session" and result["status"] in {"corrupt", "io_error"}:
+            return None, path, f"session-auto-run-{result['status']}"
+        state = result["data"] if isinstance(result.get("data"), dict) else {}
         if state.get("status") == "running":
             candidate_paths.append(path)
         else:
@@ -227,6 +283,8 @@ def _auto_route_mode(repo_root: Path, context_key: str, target: str) -> tuple[st
 
     path = unique_paths[0]
     state = _read_json(path)
+    if not _run_contains_task(state, current_task):
+        return None, path, "auto-run-task-mismatch"
 
     auth = state.get("route_authorization")
     if not isinstance(auth, dict):
@@ -302,7 +360,10 @@ def _write_runtime_decision(
 ) -> tuple[Path, dict[str, str]]:
     """写入 session runtime 文件中的 route_decisions 字段。"""
     path = _session_path(repo_root, context_key)
-    context = _read_json(path)
+    context_result = _read_json_result(path)
+    if context_result["status"] in {"corrupt", "io_error"}:
+        raise ValueError(f"session-runtime-{context_result['status']}")
+    context = context_result["data"] if isinstance(context_result.get("data"), dict) else {}
     now = _utc_now()
     context.setdefault("platform", context_key.split("_", 1)[0] if "_" in context_key else "session")
     context["last_seen_at"] = now
@@ -349,7 +410,14 @@ def read_runtime(args: argparse.Namespace) -> int:
     assert current_task is not None and context_key is not None
 
     path = _session_path(repo_root, context_key)
-    context = _read_json(path)
+    context_result = _read_json_result(path)
+    if context_result["status"] in {"corrupt", "io_error"}:
+        return _output(
+            args,
+            {"status": "miss", "reason": f"session-runtime-{context_result['status']}"},
+            {"path": _rel_path(repo_root, path), "error": context_result.get("error")},
+        )
+    context = context_result["data"] if isinstance(context_result.get("data"), dict) else {}
     decision = context.get("route_decisions", {}).get(args.target)
     normalized = _normalized_decision(decision, args.target, current_task)
     if normalized is not None:
@@ -393,7 +461,14 @@ def resolve_route(args: argparse.Namespace) -> int:
     assert current_task is not None and context_key is not None
 
     path = _session_path(repo_root, context_key)
-    context = _read_json(path)
+    context_result = _read_json_result(path)
+    if context_result["status"] in {"corrupt", "io_error"}:
+        return _output(
+            args,
+            {"status": "miss", "reason": f"session-runtime-{context_result['status']}"},
+            {"path": _rel_path(repo_root, path), "error": context_result.get("error")},
+        )
+    context = context_result["data"] if isinstance(context_result.get("data"), dict) else {}
     decision = context.get("route_decisions", {}).get(args.target)
     normalized = _normalized_decision(decision, args.target, current_task)
     if normalized is not None:
@@ -451,7 +526,12 @@ def resolve_route(args: argparse.Namespace) -> int:
             }
         )
 
-    auto_mode, auto_path, auto_reason = _auto_route_mode(repo_root, context_key, args.target)
+    auto_mode, auto_path, auto_reason = _auto_route_mode(
+        repo_root,
+        context_key,
+        current_task,
+        args.target,
+    )
     if auto_mode in PREF_MODES[args.target]:
         written_path, auto_decision = _write_runtime_decision(
             repo_root,
@@ -535,14 +615,17 @@ def write_route(args: argparse.Namespace) -> int:
     if not context_key:
         return _print({"status": "skipped", "reason": "no-session-context", "source": source})
 
-    path, decision = _write_runtime_decision(
-        repo_root,
-        context_key,
-        current_task,
-        args.target,
-        mode,
-        args.source,
-    )
+    try:
+        path, decision = _write_runtime_decision(
+            repo_root,
+            context_key,
+            current_task,
+            args.target,
+            mode,
+            args.source,
+        )
+    except (OSError, ValueError) as exc:
+        return _print({"status": "error", "reason": "runtime-write-failed", "message": str(exc)})
     return _output(
         args,
         {
@@ -617,7 +700,10 @@ def main() -> int:
     """脚本入口。"""
     parser = build_parser()
     args = parser.parse_args()
-    return args.func(args)
+    try:
+        return args.func(args)
+    except (OSError, ValueError) as exc:
+        return _print({"status": "error", "reason": "runtime-io-error", "message": str(exc)})
 
 
 if __name__ == "__main__":

package/enhancements/0.6/.claude/skills/trellis-auto-loop/SKILL.md

@@ -22,11 +22,19 @@ description: "启动、恢复和推进 Trellis 自动任务循环。用于用户
 - auto-loop 启动前若 implement 与 check 都缺 route，优先展示 auto-loop 专用的合并选择，不要把 `trellis-route` 的两套完整 fallback 原样贴给用户。仍允许用户回复高级格式 `implement 1, check 1`。
 - 检查深度由 run 级 `--check-depth auto|light|full` 控制，默认 `auto`，与 `--route-check` 独立；历史 run 缺少该字段时按 `full` 兼容。
 - 代码提交必须复用 `trellis-push` 的内部 commit-only 执行能力；auto-loop 自己负责预授权校验和 runner 回写，不要裸 `git commit` / `git push`。
+- `Open Questions` 的确定性状态由 runner 处理：`- [ ]` 阻塞，`- [x]` 不阻塞，无章节或空章节放行。历史无 checkbox 列表只能按 `review_open_questions` action 做语义复核，不能自行跳过 runner 回写。
+- 启动或恢复 validated auto-loop 前先运行 `python3 ./.trellis/scripts/pre_check_state.py clear`，静默清除当前任务的交互式 Check-All 前暂缓偏好。清理返回 miss 或 task mismatch 视为无状态；runtime 损坏只记录诊断，不得阻断 runner，也不得让 runner 读取该偏好。
 
 ## 启动
 
 用户给了任务列表时，按原顺序传入；用户只说当前任务时，用 `task.py current --source` 的当前任务。
 
+启动前先静默清理交互式暂缓偏好：
+
+```bash
+python3 ./.trellis/scripts/pre_check_state.py clear
+```
+
 启动前对当前任务执行 route 准备度检查：
 
 ```bash
@@ -81,6 +89,7 @@ python3 ./.trellis/scripts/auto_loop.py next
 压缩、重开会话、用户说“继续自动跑 / continue auto loop”时：
 
 ```bash
+python3 ./.trellis/scripts/pre_check_state.py clear
 python3 ./.trellis/scripts/auto_loop.py resume
 python3 ./.trellis/scripts/auto_loop.py next
 ```
@@ -107,7 +116,10 @@ python3 ./.trellis/scripts/auto_loop.py next
 
 | runner action | 主 agent 动作 | 成功 record |
 | --- | --- | --- |
-| `refresh_brief` | 使用 `trellis-task-brief` 生成并展示 brief | `record --action refresh_brief --result ok` |
+| `review_open_questions` | 结合 PRD 语义判断历史裸列表是已解决、仍阻塞或无法确定 | 已解决：`record --action review_open_questions --result ok --review-verdict resolved --summary "<摘要>"`；仍阻塞/无法确定：使用 `--result blocked --review-verdict blocking|ambiguous` |
+| `review_planning_readiness` | 按 `trellis-brainstorm` Quality Bar 复核验收标准可测试、范围明确、关键决策收敛、仓库问题已研究 | ready：`record --action review_planning_readiness --result ok --readiness-verdict ready --summary "<摘要>"`；仍阻塞/无法确定：使用 `--result blocked --readiness-verdict blocking|ambiguous` |
+| `refresh_brief` | 使用 `trellis-task-brief` 刷新并展示 brief；这一步不代表用户确认 | `record --action refresh_brief --result ok` |
+| `confirm_brief` | 再次展示 action 对应的完整 brief，并等待用户显式确认 | 收到确认后：`record --action confirm_brief --result ok --summary "<确认摘要>"`；未确认时停止，不得 record |
 | `start_task` | 执行返回的 `task.py start ...` 命令 | `record --action start_task --result ok` |
 | `run_implement` | 进入 Phase 2.1，先用 `trellis-route(target=implement)` 决定 inline/subagent，再实现 | `record --action run_implement --result ok --route-mode <mode> --route-source <source>` |
 | `run_check_all` | 进入 Phase 2.2，先用 `trellis-route(target=check)`，按 action 的 requested depth 执行 Check-All | `record --action run_check_all --result ok --route-mode <mode> --route-source <source> --effective-check-depth <light|full> --check-depth-reason "<摘要>"` |
@@ -143,6 +155,12 @@ python3 ./.trellis/scripts/auto_loop.py record \
 
 runner 会按 3 轮 fix/recheck 预算决定继续、跳过当前任务或结束队列。
 
+`review_open_questions` 必须只依据 action 返回的 `questions` 和当前 PRD 判断。runner 会把结果绑定到 action 发出时的 PRD SHA-256；PRD 在复核期间发生变化时，record 会返回 `stale-open-questions-review`，此时重新运行 `next`，不得复用旧判断。`ambiguous` 必须保守阻塞，交由用户或 planning 收敛。
+
+`review_planning_readiness` 必须读取 action 指向的当前 planning artifacts，并按 Brainstorm Gate 的语义质量线复核，不能把文件存在、章节存在或 route context 已 curated 当作 ready。runner 会把结论绑定到 `prd.md`、存在时的 `design.md`/`implement.md` 内容；任一文件变化后旧结论失效。
+
+`refresh_brief` 成功后必须立即 `next`。runner 随后返回 `confirm_brief`，主 agent 要展示当前完整 brief 并停止等待用户；启动 auto-loop、选择 route 或生成 brief 都不构成确认。`confirm_brief` 只在收到明确确认后回写，且确认绑定 planning artifacts 与 brief 内容；任一文件变化后必须重新展示并确认。
+
 `record` 默认只返回当前 item 的 `task`、`item_status`、`current_step`、`commit` 和紧凑 `summary`；只有排查状态漂移时才加 `--verbose` 查看完整 `item`。
 
 route action 成功回写时必须带上 `trellis-route` 输出里的真实 `mode` / `source`，例如

package/enhancements/0.6/.claude/skills/trellis-push/SKILL.md

@@ -28,6 +28,16 @@ description: "按确认的精确文件范围提交普通变更或完成已就绪
 
 内部 `commit-only` 不接受临时扩大文件范围、远端推送或其他附加动作。安全条件不满足时返回失败，由调用方决定后续状态。
 
+## Step 0：交互式完成链门禁
+
+除 auto-loop 内部 `commit-only` 外，任何普通 push 或用户 `commit-only` 在读取 Git 提交计划前，都必须确认当前工作内容已经通过 Check-All，且该结论之后存在当前有效的 `spec_update_result`：
+
+- `status=no-op|written`：继续本 skill 的 Git 预检与计划。
+- 缺失，或实际 diff、Check-All 结论、用户 spec 意图已变化：先加载 `trellis-update-spec`，只有新的 `no-op|written` 才能回到本 skill。
+- `status=needs-review`：停止，不生成提交计划。
+
+用户直接说 push/提交不构成跳过 Phase 3.3 的授权。auto-loop 内部 `commit-only` 已由 runner 的 `run_spec_update -> commit_only` 状态机和预授权保证顺序，因此不得重复进入本门禁。
+
 ## Step 1：发现仓库与任务
 
 候选仓库包括：

package/enhancements/0.6/.claude/skills/trellis-route/SKILL.md

@@ -177,11 +177,13 @@ helper 写入规则：保留另一个 target 的 runtime 决策和偏好；覆
 
 | 路由决定 | 主 agent 应执行 |
 |---------|----------------|
-| `inline implement` | `Skill({skill: "trellis-before-dev"})` 加载 spec → 读任务文档 → 主线程实施 → 跑必要验证 |
-| `subagent implement` | `Agent({subagent_type: "trellis-implement"})`；若 `subagent_skip_compile=true`，dispatch prompt 附加“跳过 mvn install / npm run build / tsc 等耗时编译类检查（已由主 agent 验证或最终统一执行）” |
+| `inline implement` | `Skill({skill: "trellis-before-dev"})` 加载 spec → 读任务文档 → 主线程实施 → 跑必要验证 → 回到 Phase 2.1 completion contract 解析 Pre-Check，不得在局部验证后直接结束 |
+| `subagent implement` | `Agent({subagent_type: "trellis-implement"})`；若 `subagent_skip_compile=true`，dispatch prompt 附加“跳过 mvn install / npm run build / tsc 等耗时编译类检查（已由主 agent 验证或最终统一执行）”；主 agent 收到结果后回到 Phase 2.1 completion contract 解析 Pre-Check |
 | `inline check-all` | `Skill({skill: "trellis-check-all"})` |
 | `subagent check-all` | 优先使用明确 audit-only 的 `trellis-check-all` agent；不存在时使用平台通用 subagent，并用下方 dispatch 契约执行本地 `trellis-check-all`。禁止 fallback 到会直接修改工作区的 `trellis-check` agent；无兼容 subagent 时停止并请用户改选 inline |
 
+implement 路由只决定执行位置，不拥有实现后的停止策略。无论 inline 或 subagent，focused validation 完成后都必须返回 workflow Phase 2.1 的 completion contract；由该 owner 处理 auto-loop、用户显式继续/暂缓、已有 hold 和默认立即 Check-All 的优先级。
+
 ### Subagent Check-All Dispatch 契约
 
 使用专用或通用 subagent 时，dispatch prompt 第一行必须是当前任务路径，并包含以下完整边界：

package/enhancements/0.6/.claude/skills/trellis-route/scripts/route_state.py

@@ -5,8 +5,10 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import subprocess
 import sys
+import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -50,22 +52,45 @@ def _utc_now() -> str:
     )
 
 
-def _read_json(path: Path) -> dict[str, Any]:
-    """读取 JSON 对象，失败时返回空对象。"""
+def _read_json_result(path: Path) -> dict[str, Any]:
+    """读取 runtime JSON，并区分缺失、损坏和 I/O 错误。"""
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
-    except (FileNotFoundError, json.JSONDecodeError, OSError):
-        return {}
+    except FileNotFoundError:
+        return {"status": "missing", "data": None, "error": None}
+    except json.JSONDecodeError as exc:
+        return {"status": "corrupt", "data": None, "error": str(exc)}
+    except OSError as exc:
+        return {"status": "io_error", "data": None, "error": str(exc)}
+    if not isinstance(data, dict):
+        return {"status": "corrupt", "data": None, "error": "JSON 根节点不是对象"}
+    return {"status": "ok", "data": data, "error": None}
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    """兼容非关键扫描；仅返回成功解析的 JSON 对象。"""
+    result = _read_json_result(path)
+    data = result.get("data")
     return data if isinstance(data, dict) else {}
 
 
 def _write_json(path: Path, data: dict[str, Any]) -> None:
-    """原子性要求不高的 runtime 状态写入。"""
+    """使用同目录临时文件原子写入 runtime 状态。"""
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        json.dumps(data, indent=2, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
+    fd, temp_name = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp", dir=path.parent)
+    temp_path = Path(temp_name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp_path, path)
+    except Exception:
+        try:
+            temp_path.unlink()
+        except FileNotFoundError:
+            pass
+        raise
 
 
 def _print(data: dict[str, Any]) -> int:
@@ -187,7 +212,27 @@ def _auto_state_path(repo_root: Path, run_id: Any) -> Path | None:
     return _auto_loop_dir(repo_root) / f"{run_id.strip()}.json"
 
 
-def _auto_route_mode(repo_root: Path, context_key: str, target: str) -> tuple[str | None, Path | None, str | None]:
+def _run_contains_task(state: dict[str, Any], current_task: str) -> bool:
+    """判断当前任务是否属于 run 的未完成队列。"""
+    queue = state.get("queue")
+    if not isinstance(queue, list):
+        return False
+    normalized = current_task.replace("\\", "/")
+    for item in queue:
+        if not isinstance(item, dict) or item.get("status") not in {"pending", "running"}:
+            continue
+        task = item.get("task")
+        if isinstance(task, str) and task.replace("\\", "/") == normalized:
+            return True
+    return False
+
+
+def _auto_route_mode(
+    repo_root: Path,
+    context_key: str,
+    current_task: str,
+    target: str,
+) -> tuple[str | None, Path | None, str | None]:
     """读取当前 running auto-loop run 的临时 route 授权。
 
     auto 授权低于个人 `.route-prefs.tmp`，只在当前 session runtime 绑定了
@@ -195,15 +240,26 @@ def _auto_route_mode(repo_root: Path, context_key: str, target: str) -> tuple[st
     如果这些指针 stale，则忽略 stale pointer，并 fallback 到唯一 running run。
     """
     session_path = _session_path(repo_root, context_key)
-    session = _read_json(session_path)
+    session_result = _read_json_result(session_path)
+    if session_result["status"] in {"corrupt", "io_error"}:
+        return None, session_path, f"session-runtime-{session_result['status']}"
+    session = session_result["data"] if isinstance(session_result.get("data"), dict) else {}
     candidate_paths: list[Path] = []
     stale_paths: list[Path] = []
 
-    for run_id in (session.get("current_auto_run"), _read_json(_auto_loop_pointer(repo_root)).get("run_id")):
+    pointer_result = _read_json_result(_auto_loop_pointer(repo_root))
+    pointer = pointer_result["data"] if isinstance(pointer_result.get("data"), dict) else {}
+    for source, run_id in (
+        ("session", session.get("current_auto_run")),
+        ("pointer", pointer.get("run_id")),
+    ):
         path = _auto_state_path(repo_root, run_id)
         if path is None:
             continue
-        state = _read_json(path)
+        result = _read_json_result(path)
+        if source == "session" and result["status"] in {"corrupt", "io_error"}:
+            return None, path, f"session-auto-run-{result['status']}"
+        state = result["data"] if isinstance(result.get("data"), dict) else {}
         if state.get("status") == "running":
             candidate_paths.append(path)
         else:
@@ -227,6 +283,8 @@ def _auto_route_mode(repo_root: Path, context_key: str, target: str) -> tuple[st
 
     path = unique_paths[0]
     state = _read_json(path)
+    if not _run_contains_task(state, current_task):
+        return None, path, "auto-run-task-mismatch"
 
     auth = state.get("route_authorization")
     if not isinstance(auth, dict):
@@ -302,7 +360,10 @@ def _write_runtime_decision(
 ) -> tuple[Path, dict[str, str]]:
     """写入 session runtime 文件中的 route_decisions 字段。"""
     path = _session_path(repo_root, context_key)
-    context = _read_json(path)
+    context_result = _read_json_result(path)
+    if context_result["status"] in {"corrupt", "io_error"}:
+        raise ValueError(f"session-runtime-{context_result['status']}")
+    context = context_result["data"] if isinstance(context_result.get("data"), dict) else {}
     now = _utc_now()
     context.setdefault("platform", context_key.split("_", 1)[0] if "_" in context_key else "session")
     context["last_seen_at"] = now
@@ -349,7 +410,14 @@ def read_runtime(args: argparse.Namespace) -> int:
     assert current_task is not None and context_key is not None
 
     path = _session_path(repo_root, context_key)
-    context = _read_json(path)
+    context_result = _read_json_result(path)
+    if context_result["status"] in {"corrupt", "io_error"}:
+        return _output(
+            args,
+            {"status": "miss", "reason": f"session-runtime-{context_result['status']}"},
+            {"path": _rel_path(repo_root, path), "error": context_result.get("error")},
+        )
+    context = context_result["data"] if isinstance(context_result.get("data"), dict) else {}
     decision = context.get("route_decisions", {}).get(args.target)
     normalized = _normalized_decision(decision, args.target, current_task)
     if normalized is not None:
@@ -393,7 +461,14 @@ def resolve_route(args: argparse.Namespace) -> int:
     assert current_task is not None and context_key is not None
 
     path = _session_path(repo_root, context_key)
-    context = _read_json(path)
+    context_result = _read_json_result(path)
+    if context_result["status"] in {"corrupt", "io_error"}:
+        return _output(
+            args,
+            {"status": "miss", "reason": f"session-runtime-{context_result['status']}"},
+            {"path": _rel_path(repo_root, path), "error": context_result.get("error")},
+        )
+    context = context_result["data"] if isinstance(context_result.get("data"), dict) else {}
     decision = context.get("route_decisions", {}).get(args.target)
     normalized = _normalized_decision(decision, args.target, current_task)
     if normalized is not None:
@@ -451,7 +526,12 @@ def resolve_route(args: argparse.Namespace) -> int:
             }
         )
 
-    auto_mode, auto_path, auto_reason = _auto_route_mode(repo_root, context_key, args.target)
+    auto_mode, auto_path, auto_reason = _auto_route_mode(
+        repo_root,
+        context_key,
+        current_task,
+        args.target,
+    )
     if auto_mode in PREF_MODES[args.target]:
         written_path, auto_decision = _write_runtime_decision(
             repo_root,
@@ -535,14 +615,17 @@ def write_route(args: argparse.Namespace) -> int:
     if not context_key:
         return _print({"status": "skipped", "reason": "no-session-context", "source": source})
 
-    path, decision = _write_runtime_decision(
-        repo_root,
-        context_key,
-        current_task,
-        args.target,
-        mode,
-        args.source,
-    )
+    try:
+        path, decision = _write_runtime_decision(
+            repo_root,
+            context_key,
+            current_task,
+            args.target,
+            mode,
+            args.source,
+        )
+    except (OSError, ValueError) as exc:
+        return _print({"status": "error", "reason": "runtime-write-failed", "message": str(exc)})
     return _output(
         args,
         {
@@ -617,7 +700,10 @@ def main() -> int:
     """脚本入口。"""
     parser = build_parser()
     args = parser.parse_args()
-    return args.func(args)
+    try:
+        return args.func(args)
+    except (OSError, ValueError) as exc:
+        return _print({"status": "error", "reason": "runtime-io-error", "message": str(exc)})
 
 
 if __name__ == "__main__":

package/enhancements/0.6/overrides/bundles/control-plane-integrity.json

@@ -0,0 +1,10 @@
+{
+  "schemaVersion": 1,
+  "id": "control-plane-integrity",
+  "aliases": [],
+  "installMode": "full-only",
+  "patches": [
+    "scripts/task-store-write-integrity",
+    "scripts/runtime-state-integrity"
+  ]
+}