@weotro/dx 0.1.11 → 0.1.12

package/agent-references/ship-issue-pr-core.md

@@ -17,6 +17,15 @@
 
 外部专家永远不写 Git 历史和 GitHub。它只在工作树落改动或返回报告，最终结论由主进程核验。
 
+## 委派活性与接管
+
+适用于方案讨论、实现、审查、修复和 follow-up。派发时记录执行者 ID、工作目录、日志或输出位置及责任文件基线；后续始终观察同一任务。
+
+- 新增有效日志、工具调用进展、输出内容或责任文件修改，任一出现就更新最后活动记录并继续等待。同一文件反复编辑也算变化；只读任务可以只有日志。总耗时、单次等待超时、尚无最终答复都不能作为终止或替换依据。
+- 静默阈值只触发诊断：检查原任务日志、当前子命令、进程状态及权限/依赖等待，必要时向原执行者询问进度。静默推理、长测试和观测渠道不可用都不等于死亡；重复报错或空心跳也不等于有效进展。
+- 明确失败退出，或持续无有效进展且诊断证实无法继续（例如死锁、失联且执行进程已不存在、不可恢复错误），才进入恢复或接管。能够解除阻塞时优先恢复原任务；证据不足时保留任务并报告未知状态。用户明确取消时按取消要求处理。
+- 接管前记录诊断证据，确认原任务及其写入子进程已停止，再核对现有 diff、新文件和验证结果。交接仅包含剩余工作；保留已完成成果，不从头重放，也不让两个执行者同时写同一范围。
+
 ## 复杂度门禁
 
 每次派发外部专家前先过这道门禁。命中任一信号即**重改动**，走外部专家；一个都不命中即**轻改动**，主进程直接做。派发往返成本高于轻改动直改，门禁结果和命中/未命中的信号编号必须记入审查报告。
@@ -102,7 +111,7 @@ dx test e2e backend <file-or-dir>; rc=$?
 rmdir /tmp/ship-issue-pr-e2e.lock; exit $rc
 ```
 
-整段使用入口技能声明的后台执行方式运行。锁目录 mtime 超过 30 分钟即认定上一条线已死，`rmdir` 后重抢。
+整段使用入口技能声明的后台执行方式运行。记录持锁任务与进程身份；等待过久时检查持锁者日志和进程状态。只有确认持锁者及其测试子进程已结束才清理遗留锁，不能仅凭锁目录 mtime 判死或抢占。
 
 同时在跑的 follow-up subagent 最多 3 个。超出的由主进程记在待派清单里，等某条线的完成通知到达后再派下一个——排队没有别的执行者，主进程不记就等于丢了。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weotro/dx",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "type": "module",
   "license": "MIT",
   "repository": {

package/skills/ask_cc/SKILL.md

@@ -7,10 +7,14 @@ description: 仅在用户显式调用 $ask_cc 或明确要求使用 ask_cc 技
 
 使用 [delegate-cc](../delegate-cc/SKILL.md) 的咨询流程获取答案或第二意见，默认不授予工具权限。
 
+调用前完整读取该技能，按其中的活性监控、诊断和接续规则执行。咨询没有文件修改是正常现象，以本次会话的流式输出和进程状态辅助判断；静默只触发排查，不能仅因尚无答案就停止或换模型。
+
 若用户明确要求修改代码或执行开发任务，转入该技能的 `task` 模式，按任务范围完成实现和验收。
 
 旧命令 `scripts/ask_cc.py --prompt-file /绝对路径/问题.txt` 继续可用，仅运行咨询模式；模型顺序和降级逻辑复用 `delegate-cc`。
 
+旧入口的 `--timeout` 同样表示无活动告警阈值（默认 120 秒），不是答复截止时间。通过宿主异步工具保留原会话并持续取结果；只有原调用已退出且结果无效或失败时，脚本才尝试下一个模型。
+
 `dx initial` 会同时安装这两个技能。使用当前 `SKILL.md` 所在目录下的脚本；默认安装后的调用方式：
 
 ```bash

package/skills/cc-ship-issue-pr/references/runtime.md

@@ -57,30 +57,19 @@ PY
 
 定位到 job 后读取同目录 `jobs/<id>.json`。只有 `status=completed` 且 `phase=done` 才算返回，报告正文取 `result.rawOutput`。
 
-## 等待与假死
+## 等待与活性排查
 
-等待期间工作树由 Codex 独占，主进程只做不写工作树的并行事项。没别的工作时每 2 分钟取一次活性指纹：
+所有通道（含 follow-up）遵守共享流程的「委派活性与接管」规则。等待期间工作树由 Codex 独占，主进程只做不写工作树的并行事项。
 
-```bash
-python3 - <<'LIVE'
-import glob, json, os, subprocess
-root = os.path.realpath(os.getcwd())
-rows = []
-for f in glob.glob(os.path.expanduser('~/.claude/plugins/data/codex-openai-codex/state/*/state.json')):
-    for j in json.load(open(f)).get('jobs', []):
-        if os.path.realpath(j.get('workspaceRoot', '')) == root:
-            rows.append((j.get('createdAt'), j.get('id'), j.get('status'), j.get('phase'), f))
-if not rows:
-    raise SystemExit('no job for this workspace')
-created, jid, status, phase, statefile = sorted(rows)[-1]
-jf = os.path.join(os.path.dirname(statefile), 'jobs', jid + '.json')
-size, mtime = (os.path.getsize(jf), int(os.path.getmtime(jf))) if os.path.exists(jf) else (0, 0)
-dirty = len([l for l in subprocess.run(['git', 'status', '--porcelain'], capture_output=True, text=True).stdout.splitlines() if l.strip()])
-print(f'{jid} status={status} phase={phase} out={size}/{mtime} dirty={dirty}')
-LIVE
-```
+派发后保存本次 job/agent ID、worktree 和日志路径；上方按仓库列举 job 的脚本只用于发现候选，结合派发时间与任务信息确认后固定 ID，后续不得自动改查最新 job。保存派发基线，约每 2 分钟比较：
+
+- 本次 job 的新增日志、工具事件、输出正文，以及 `status` / `phase` 的实际变化。状态文件 mtime 刷新但内容未变不算进展。
+- 本次责任文件的内容变化：比较 `git diff --binary HEAD` 的内容指纹，并记录相关未跟踪文件的内容指纹；删除、新增、同一脏文件的再次修改都应被识别。只读审查不要求有文件修改。
+- 当前子命令与进程状态、权限请求或外部依赖等待。观测失败记为未知，不能当作无活动。
+
+连续多个观测窗口没有进展时，读取日志尾部和子命令状态，向原 agent 查询当前步骤及阻塞点；这个条件只触发排查，不触发停止或换执行者。重复错误、空心跳或无关文件变化不能证明任务在推进。
 
-连续 3 次（约 6 分钟）三项全不变且仍为 running，按假死阻塞，报告 job id 与 phase。companion 的 `review --wait` / `adversarial-review --wait` 是前台阻塞调用，不走此轮询。
+companion 的 `review --wait` / `adversarial-review --wait` 也通过宿主异步工具启动，保留会话 ID 并读取输出和本次 job；宿主单次等待结束后继续观察同一会话，不给前台命令套固定时长的自动终止器。只有确认失败或排查证实无法推进，才按共享接管规则处理；正常运行但尚未返回不算通道不可用。
 
 ## 阶段与报告映射
 

package/skills/delegate-cc/SKILL.md

@@ -23,10 +23,10 @@ description: 仅在用户显式调用 $delegate-cc 或明确要求使用 delegat
 运行当前 `SKILL.md` 所在目录下的 `scripts/delegate_cc.py`。以下路径适用于 `dx initial` 的默认安装位置；通过其他方式安装时使用实际技能目录：
 
 ```bash
-# 咨询：默认模式，单个模型默认超时 120 秒。
+# 咨询：默认模式，无活动告警阈值默认 120 秒。
 python3 "$HOME/.agents/skills/delegate-cc/scripts/delegate_cc.py" --prompt-file /绝对路径/问题.txt
 
-# 执行：必须指定工作目录，单次默认超时 900 秒。
+# 执行：必须指定工作目录，无活动告警阈值默认 900 秒。
 python3 "$HOME/.agents/skills/delegate-cc/scripts/delegate_cc.py" --mode task --cwd /绝对路径/工作区 --prompt-file /绝对路径/任务.txt
 ```
 
@@ -34,7 +34,11 @@ python3 "$HOME/.agents/skills/delegate-cc/scripts/delegate_cc.py" --mode task --
 
 执行模式保留默认编码系统提示，开放 `Read,Glob,Grep,Edit,Write,Bash`，使用 `acceptEdits`，不能获批的工具请求自动拒绝。两种模式都关闭 hooks、MCP 和技能，避免额外任务链；主 agent 应把所需项目规则及技能要求写入任务书。本技能不使用 `bypassPermissions`，也不扩大任务至提交、推送、部署或对外发送消息。
 
-通过工具异步运行，至少每 60 秒向用户汇报进度。`--timeout` 可按任务规模调整；超时会终止执行任务的进程组。完成条件：获得 JSON 结果或明确的执行失败，旧进程已结束。
+通过工具异步运行，至少每 60 秒向用户汇报进度，保留会话 ID。脚本读取流式输出，并比较工作目录中文件的大小和纳秒级修改/变更时间，能识别同一文件持续编辑；stderr 输出 PID、输出字节数、静默时长及观测可用性，不转发原始敏感日志。任务退出后 stdout 仍返回单个 JSON 结果。
+
+`--timeout` 现表示无活动告警阈值，保留参数名和默认秒数；原先依赖它限制总运行时间的调用方应迁移为活性监控。达到阈值仅提示疑似停滞，脚本继续运行，不自动杀进程或换模型。输出或文件变化会重置静默计时；文件观测只覆盖 Git 跟踪及未忽略的新文件，忽略目录中的测试产物需由主进程另查。观测不可用不表示无活动，日志字节增长也需排除重复错误和空心跳。
+
+静默告警后主进程检查原会话、日志和子命令，区分推理/测试、权限等待与实际故障；有进展则继续，无进展但证据不足则报告状态并保持任务。诊断证实无法推进时先尝试恢复原任务，必要时显式中断脚本并确认任务进程组已停止，再按下一节接续。宿主单次等待超时只继续读取同一会话，不设置固定总时长的自动终止器。完成条件：获得 JSON 结果或明确的执行失败，旧进程已结束。
 
 ## 3. 验收或接续
 
@@ -43,7 +47,7 @@ python3 "$HOME/.agents/skills/delegate-cc/scripts/delegate_cc.py" --mode task --
 - `continuation_required`：任务可能已部分执行。先检查现有 diff、测试状态及外部副作用；更新任务书为“保留已完成部分，仅完成剩余工作”。若 `next_model` 有值，以 `--start-model` 传入该值接续；每个模型最多尝试一次。禁止将同一任务从头盲目重放。
 - `fallback_required`、第二模型也失败或 CLI 无法运行：当前执行者已经是 sub-agent 时直接接手；主 agent 则委派一个继承当前模型的 sub-agent，环境不支持委派时自己接手。提供原任务、已完成改动和剩余工作，明确跳过本技能及 CLI，避免递归。权限拒绝不能靠切换模型绕过。
 
-咨询模式由脚本自动依次尝试两个模型；执行模式每次只运行一个模型，由主 agent 检查现场后接续。认证、额度、模型不可用和超时都不等于任务完成。
+咨询模式只有在原调用已退出且失败或结果无效后，脚本才尝试下一个模型；执行模式每次只运行一个模型，由主 agent 检查现场后接续。尚未返回、静默告警和宿主等待超时均不触发降级。认证、额度和模型不可用也不等于任务完成。
 
 完成条件：咨询得到实质答案，或执行任务的代码和验证满足验收标准；仍有缺口时明确列出，而非仅转述 CC 的成功声明。
 

package/skills/delegate-cc/scripts/delegate_cc.py

@@ -10,18 +10,62 @@ import shutil
 import signal
 import subprocess
 import sys
+import time
 
 
 MODELS = ("claude-fable-5-1", "claude-opus-5")
 
 
+def workspace_activity(cwd):
+    """记录文件本身的变化，同一脏文件继续编辑也算活动。"""
+    if cwd is None:
+        return ()
+    try:
+        files = subprocess.run(
+            ["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+            cwd=cwd, capture_output=True, timeout=10, check=True,
+        ).stdout.split(b"\0")
+        rows = []
+        for name in sorted(set(files) - {b""}):
+            try:
+                stat = (Path(cwd) / os.fsdecode(name)).lstat()
+                rows.append((name, stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns))
+            except FileNotFoundError:
+                rows.append((name, None))
+        return tuple(rows)
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
 def run_task(command, prompt, timeout, cwd):
-    """超时或中断时终止整个任务进程组，避免后台写入与接续任务竞争。"""
+    """静默阈值只告警；仅显式中断或异常才回收任务进程组。"""
+    fingerprint = workspace_activity(cwd)
+    last_activity = last_notice = time.monotonic()
+    output_size = (0, 0)
     with subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE, text=True, encoding="utf-8",
                           errors="replace", cwd=cwd, start_new_session=True) as process:
         try:
-            stdout, stderr = process.communicate(prompt, timeout=timeout)
+            pending_input = prompt
+            while True:
+                try:
+                    stdout, stderr = process.communicate(pending_input, timeout=min(30, timeout))
+                    break
+                except subprocess.TimeoutExpired as pending:
+                    pending_input = None
+                    now = time.monotonic()
+                    current = workspace_activity(cwd)
+                    sizes = (len(pending.output or b""), len(pending.stderr or b""))
+                    if sizes != output_size or (current is not None and current != fingerprint):
+                        last_activity = now
+                    fingerprint, output_size = current, sizes
+                    if now - last_notice >= min(60, timeout):
+                        idle = now - last_activity
+                        state = "疑似停滞，请检查日志、子进程或权限等待；保持运行" if idle >= timeout else "继续等待"
+                        print(f"pid={process.pid} 静默={idle:.0f}s 输出字节={sizes} "
+                              f"文件观测={'不可用' if current is None else '可用'}；{state}",
+                              file=sys.stderr, flush=True)
+                        last_notice = now
         except BaseException:
             try:
                 os.killpg(process.pid, signal.SIGKILL)
@@ -49,7 +93,8 @@ def ask(prompt, timeout=120, *, mode="consult", cwd=None, start_model=None, allo
             raise ValueError("模型不在委派链中")
         print(f"正在调用 {model}（{mode}）…", file=sys.stderr, flush=True)
         command = [
-            cli, "--print", "--model", model, "--output-format", "json",
+            cli, "--print", "--model", model, "--output-format", "stream-json",
+            "--verbose", "--include-partial-messages",
             "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
             "--disable-slash-commands", "--no-session-persistence",
             "--settings", '{"disableAllHooks":true}',
@@ -69,18 +114,16 @@ def ask(prompt, timeout=120, *, mode="consult", cwd=None, start_model=None, allo
             if allow_commands:
                 command += ["--allowedTools", *[f"Bash({item})" for item in allow_commands]]
         try:
-            process = run_task(command, prompt, timeout, cwd) if mode == "task" else subprocess.run(
-                command, input=prompt, text=True, encoding="utf-8",
-                errors="replace", capture_output=True, timeout=timeout, cwd=cwd,
-            )
-        except subprocess.TimeoutExpired:
-            attempts.append({"requested_model": model, "reason": "调用超时"})
-            continue
+            process = run_task(command, prompt, timeout, cwd)
         except OSError as error:
             attempts.append({"requested_model": model, "reason": f"无法运行 CLI：{type(error).__name__}"})
             break
         try:
-            payload = json.loads(process.stdout)
+            payload = {}
+            for line in process.stdout.splitlines():
+                event = json.loads(line)
+                if isinstance(event, dict) and event.get("type") == "result":
+                    payload = event
         except (ValueError, TypeError):
             payload = {}
         if not isinstance(payload, dict):
@@ -118,7 +161,7 @@ def main(argv=None):
     parser.add_argument("--cwd", type=Path)
     parser.add_argument("--start-model", choices=MODELS)
     parser.add_argument("--allow-command", action="append", default=[])
-    parser.add_argument("--timeout", type=float)
+    parser.add_argument("--timeout", type=float, help="无活动告警阈值（秒），不终止或切换模型")
     args = parser.parse_args(argv)
     if args.timeout is None:
         args.timeout = 900 if args.mode == "task" else 120

package/skills/delegate-cc/scripts/test_delegate_cc.py

@@ -1,7 +1,10 @@
 """复现 CLI 模型校验失败，覆盖模型顺序及错误分类。"""
 
 import json
+import io
+import os
 import subprocess
+import sys
 import unittest
 import tempfile
 from pathlib import Path
@@ -18,6 +21,44 @@ def result(answer, failed=False):
 
 
 class AskCCTest(unittest.TestCase):
+    def test_cli_entrypoints_do_not_switch_models_after_idle_threshold(self):
+        skills = Path(__file__).resolve().parents[2]
+        entries = [
+            (skills / "ask_cc/scripts/ask_cc.py", "consult"),
+            (skills / "delegate-cc/scripts/delegate_cc.py", "consult"),
+            (skills / "delegate-cc/scripts/delegate_cc.py", "task"),
+        ]
+        for entry, mode in entries:
+            with self.subTest(entry=entry, mode=mode), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp)
+                fake_cli = root / "claude"
+                fake_cli.write_text(
+                    f"#!{sys.executable}\n"
+                    "import json, os, sys, time\n"
+                    "from pathlib import Path\n"
+                    "sys.stdin.read()\n"
+                    "with Path(os.environ['DELEGATE_TEST_CALLS']).open('a') as log:\n"
+                    " log.write(sys.argv[sys.argv.index('--model') + 1] + '\\n')\n"
+                    "time.sleep(0.2)\n"
+                    "print(json.dumps({'type': 'result', 'subtype': 'success', 'result': 'done'}))\n"
+                )
+                fake_cli.chmod(0o700)
+                prompt = root / "prompt.txt"
+                prompt.write_text("test")
+                calls = root / "calls.txt"
+                env = dict(os.environ, PATH=str(root) + os.pathsep + os.environ.get("PATH", ""),
+                           DELEGATE_TEST_CALLS=str(calls))
+                command = [sys.executable, str(entry), "--prompt-file", str(prompt), "--timeout", "0.05"]
+                if mode == "task":
+                    command += ["--mode", "task", "--cwd", tmp]
+                completed = subprocess.run(command, env=env, capture_output=True, text=True, timeout=10)
+                self.assertEqual(completed.returncode, 0, completed.stderr)
+                response = json.loads(completed.stdout)
+                self.assertEqual(response["status"], "review_required" if mode == "task" else "ok")
+                self.assertEqual(response["attempts"], [])
+                self.assertEqual(calls.read_text().splitlines(), [ask_cc.MODELS[0]])
+                self.assertIn("疑似停滞", completed.stderr)
+
     @patch.object(ask_cc.shutil, "which", return_value="/fake/claude")
     def test_task_permissions_and_review(self, _which):
         with tempfile.TemporaryDirectory() as cwd, patch.object(ask_cc, "run_task", return_value=result("完成")) as run:
@@ -33,7 +74,7 @@ class AskCCTest(unittest.TestCase):
         with tempfile.TemporaryDirectory() as cwd:
             def partial(*args):
                 Path(cwd, "partial.txt").write_text("已完成部分")
-                raise subprocess.TimeoutExpired("claude", 1)
+                raise OSError("CLI connection failed")
             with patch.object(ask_cc, "run_task", side_effect=partial) as run:
                 response = ask_cc.ask("修改代码", mode="task", cwd=cwd)
             self.assertEqual(run.call_count, 1)
@@ -56,7 +97,7 @@ class AskCCTest(unittest.TestCase):
     def test_supported_model_ids_and_fallback(self, _which):
         seen = []
 
-        def cli(command, **kwargs):
+        def cli(command, *args):
             model = command[command.index("--model") + 1]
             seen.append(model)
             if model == "claude-fable-5-1":
@@ -65,7 +106,7 @@ class AskCCTest(unittest.TestCase):
                 return result("OK")
             return result(f"There's an issue with the selected model ({model}).", True)
 
-        with patch.object(ask_cc.subprocess, "run", side_effect=cli):
+        with patch.object(ask_cc, "run_task", side_effect=cli):
             response = ask_cc.ask("仅回答 OK")
         self.assertEqual(response["status"], "ok")
         self.assertEqual(seen, ["claude-fable-5-1", "claude-opus-5"])
@@ -74,17 +115,54 @@ class AskCCTest(unittest.TestCase):
     @patch.object(ask_cc.shutil, "which", return_value="/fake/claude")
     def test_unrecognized_model_is_reported(self, _which):
         failure = result("There's an issue with the selected model (fable-5.1). It may not exist or you may not have access to it.", True)
-        with patch.object(ask_cc.subprocess, "run", return_value=failure):
+        with patch.object(ask_cc, "run_task", return_value=failure):
             response = ask_cc.ask("问题")
         self.assertEqual(response["status"], "fallback_required")
         self.assertEqual(response["attempts"][0]["reason"], "模型名称无效或当前账户无权访问")
 
     @patch.object(ask_cc.shutil, "which", return_value="/fake/claude")
     def test_login_error_is_distinct(self, _which):
-        with patch.object(ask_cc.subprocess, "run", return_value=result("Not logged in · Please run /login", True)):
+        with patch.object(ask_cc, "run_task", return_value=result("Not logged in · Please run /login", True)):
             response = ask_cc.ask("问题")
         self.assertEqual(response["attempts"][0]["reason"], "认证不可用")
 
+    def test_silent_process_survives_idle_warning(self):
+        command = [sys.executable, "-c", "import time; time.sleep(0.2); print('done')"]
+        with patch.object(ask_cc.sys, "stderr", new_callable=io.StringIO) as log:
+            completed = ask_cc.run_task(command, "", 0.05, None)
+        self.assertEqual(completed.returncode, 0)
+        self.assertEqual(completed.stdout.strip(), "done")
+        self.assertIn("疑似停滞", log.getvalue())
+
+    def test_streaming_process_survives_total_duration(self):
+        command = [sys.executable, "-u", "-c",
+                   "import time\nfor i in range(8):\n print(i)\n time.sleep(0.04)"]
+        with patch.object(ask_cc.sys, "stderr", new_callable=io.StringIO):
+            completed = ask_cc.run_task(command, "", 0.1, None)
+        self.assertEqual(completed.returncode, 0)
+        self.assertEqual(completed.stdout.splitlines(), [str(i) for i in range(8)])
+
+    def test_repeated_same_size_file_edit_changes_activity(self):
+        with tempfile.TemporaryDirectory() as cwd:
+            subprocess.run(["git", "init", "-q", cwd], check=True)
+            file = Path(cwd, "work.txt")
+            file.write_text("before")
+            before = ask_cc.workspace_activity(cwd)
+            file.write_text("after!")
+            self.assertNotEqual(before, ask_cc.workspace_activity(cwd))
+            before = ask_cc.workspace_activity(cwd)
+            file.unlink()
+            self.assertNotEqual(before, ask_cc.workspace_activity(cwd))
+
+    @patch.object(ask_cc.shutil, "which", return_value="/fake/claude")
+    def test_stream_events_resolve_final_result(self, _which):
+        output = result("完成")
+        output.stdout = json.dumps({"type": "assistant", "message": "working"}) + "\n" + output.stdout
+        with patch.object(ask_cc, "run_task", return_value=output) as run:
+            response = ask_cc.ask("问题")
+        self.assertEqual(response["answer"], "完成")
+        self.assertIn("stream-json", run.call_args.args[0])
+
 
 if __name__ == "__main__":
     unittest.main()

package/skills/oo-ship-issue-pr/references/runtime.md

@@ -15,6 +15,8 @@
 
 本入口只补充交付上下文与验收要求。CLI 参数、模型顺序、权限配置、等待与超时、状态解析、接续及降级统一按依赖技能执行，不在这里另写调用脚本或重试链。依赖文件缺失时先运行 `dx initial` 恢复；仍无法读取时报告缺失路径，不临时仿写该技能。
 
+所有通道（含 follow-up）遵守共享流程的「委派活性与接管」规则。依赖脚本的 `--timeout` 是无活动告警阈值；读取其 PID、输出字节和文件观测摘要，疑似停滞时检查原会话与工作树。宿主单次等待结束后继续观察同一会话，不设置按总耗时自动终止的外层超时器，也不把尚未返回当作降级依据。
+
 ## 交接上下文
 
 每次交接包含当前 worktree 绝对路径、阶段、Issue 原文与逐条验收标准、base，以及该阶段所需的方案、代码和验证证据。任务仅覆盖当前阶段，不运行完整 `oo-ship-issue-pr`；Git 历史、GitHub 操作、权威验证和最终事实核验由 Codex 主进程负责。