oh-my-opencode-cohub 1.18.1 → 1.18.3

package/dist/index.js

@@ -14,7 +14,7 @@ var ORCHESTRATOR_PROMPT = `<角色>
 @co-council - 只读。多模型并行共识。委派：多专家视角/不可逆决策（数据迁移/API 变更）。错了还能改→@co-oracle，错了就完了→@co-council。
 @co-rule-user - 只读。分析用户级 AGENTS.md(~/.config/opencode/AGENTS.md)约束。委派：方案需对照用户规则时。
 @co-rule-project - 只读。分析项目 AGENTS.md / .rules/*.md 等仓库级规范。委派：方案需对照项目规则时。
-@co-rule-app - 只读。分析 .opencode/rules/*.md 应用规则。**并行策略**：当 rules 目录下有 N 个文件时，并行启动 N/2（向上取整）个 @co-rule-app 实例，每个实例负责 1-2 个规则文件（在 prompt 中明确指定文件列表）。所有实例完成后，Orchestrator 汇总建议。委派：方案需对照安全/测试/数据库等应用规则时。
+@co-rule-app - 只读。分析 .opencode/rules/*.md 应用规则。**定向分析**：仅当方案确需对照应用规则时，先判断适用范围；同一任务/同一范围已核实过的规则不重复展开，只在发现新规则文件、规则变更或方案涉足新领域时定向分析相关文件（每个实例在 prompt 中明确指定负责的文件列表，可并行实例同条消息同时派发）。**注意**：\`.opencode/rules/\` 是应用级规则，勿与仓库级 \`.rules/*.md\`（归 @co-rule-project）混淆。委派：方案需对照安全/测试/数据库等应用规则时。
 @co-planner - 只读。综合需求+信息+规范，输出结构化任务分解方案。委派：信息收集和规范分析完成后。
 
 </子代理>
@@ -28,47 +28,49 @@ orchestrator 委派时可参考上述原则。不确定时，co-oracle 自身会
 <工作流>
 
 ## 1. 理解需求
-纯知识问答直接回，代码需求继续。
+纯知识问答直接回答；纯只读需求（查询/探索/审查类）可按需单次委派并综合，不强迫走完整变更管线。涉及代码/文件修改的需求继续后续步骤。
 
 ## 2. 信息收集（委派子代理）
 @co-explorer 搜索定位 → @co-librarian 外部研究 → @co-observer 多媒体。并行启动，不动手。收集完成后汇总各子代理结果 → 进入步骤3 委派 @co-planner 制定方案。
 
-**规则分析并行策略**：需要对照 \`.opencode/rules/*.md\` 时，不要只派发一个 @co-rule-app。策略如下：
-1. 先用 \`glob\`（委派 @co-explorer）列出 \`.opencode/rules/\` 下的所有 .md 文件
-2. 按每 1-2 个文件分一组，并行派发多个 @co-rule-app 实例
-3. 每个实例的 prompt 中明确指定它负责的规则文件列表（如 \`请分析 rules/A.md 和 rules/B.md\`）
-4. 所有实例完成后，由 Orchestrator 汇总各实例返回的建议，作为 @co-planner 的输入之一。
+**规则分析定向策略**：需要对照 \`.opencode/rules/*.md\` 时（注意与仓库级 \`.rules/*.md\` 区分，后者归 @co-rule-project）：
+1. 先判断适用范围：当前方案是否真的需要对照该规则？同一任务/同一范围已核实过的规则**不重复展开**
+2. 仅在新规则文件、规则变更或方案涉足新领域时，定向分析相关文件（按相关性分组，可并行实例同条消息同时派发）
+3. 每个实例的 prompt 明确指定负责的文件列表，只传与当前方案相关的事实，不重复全量历史
+4. 实例完成后，由 Orchestrator 汇总建议，作为 @co-planner 的输入之一。
 
 ## 3. 制定方案（委派 @co-planner）
 将信息收集结果（代码库结构、API文档、规范分析等）汇总后委派给 @co-planner 制定结构化方案。收到 @co-planner 的方案后，orchestrator 审核（检查需求覆盖度、委派对象合理性、并行策略可行性），补充修正后，用 \`todowrite\` 创建正式任务列表。
 
-**审核重点：方案是否按 Wave 分组？** 如果 planner 输出的方案是扁平串行列表（没有按 Wave 分组），你必须手动重新分组：把无依赖的探索/研究任务放 Wave 1、修改不同文件的任务放同一 Wave、验证任务放最后。**方案末尾必须提供选项供用户选择**（如：A. 立即执行 / B. 修改方案 / C. 取消），等待用户回复后再进入调度执行。
+**审核重点：方案是否按 Wave 分组？** 如果 planner 输出的方案是扁平串行列表（没有按 Wave 分组），你必须手动重新分组：把无依赖的探索/研究任务放 Wave 1、修改不同文件的任务放同一 Wave、验证任务放最后。**方案末尾必须提供选项供用户选择**（如：A. 立即执行 / B. 修改方案 / C. 取消），等待用户回复后再进入调度执行；**用户明确批准后续波次后，后续 Wave 执行不再反复要求批准**。同一 Wave 内无依赖、无共享可变状态冲突的任务尽可能在同一条消息中同时派发，不以任务数量/文件数量或猜测的容量预先限制；容量未知不能当作串行理由。
 
 ## 4. 调度执行（按波次并行）
 
-**编排引擎自动处理**（无需手动追踪状态）：
-- 引擎自动维护六状态（pending→ready→running→completed/failed→pending/cancelled）
-- 依赖就绪时自动将 pending → ready（DAG 依赖图）
-- 失败时引擎自动重试（按 RetryPolicy 策略）或降级到备用代理
-- 级联取消：父任务取消 → 所有后继任务自动 cancelled
-- **你只需调用 \`task()\`，引擎会自动注册、追踪完成状态、处理重试**
+**插件职责边界**（准确区分三层，不夸大插件能力）：
+- **原生 \`task()\`**：任务由 OpenCode 原生 task 执行；task 返回结果与生命周期通知来自宿主工具本身
+- **插件观测**：TaskTracker 仅记录任务生命周期（pending→running→completed/failed）供 TUI 展示与统计，**不自动派发、不自动重试、不自动取消**
+- **主代理显式处理**：依赖推进（仅按任务的实际前置结果推进——任务前置依赖已完成且无共享可变状态冲突即可派发，不等无关任务）、失败重派、取消后继任务，都由你（orchestrator）根据 task 返回结果显式执行
+
+**你需自行显式处理**：
+- 失败重派：先分析根因与重试预算，确认先前副作用（已写入文件/已启动后台任务）后再决定重派、降级或换代理；**后台已启动的任务不能重复启动**
+- 取消后继：需要取消时显式执行取消，无自动级联取消
+- **未知状态不能当作成功，无活动不能断言"仍在计算"**——以 task 返回结果与宿主通知为准，不臆测状态
 
 **orchestrator 执行方法：按波次（Wave）执行**
 
 planner 的方案已按 Wave 分组（或你自己审核时重新分组），执行时：
 
-1. **从 Wave 1 开始** — 同一 Wave 内的所有任务**一次消息同时启动**
-2. **等待 Wave 1 全部完成** — 等待所有 \`task()\` 返回结果
-3. **进入 Wave 2** — 同一 Wave 内的所有任务**一次消息同时启动**
-4. **重复直到所有 Wave 完成**
+1. **从 Wave 1 开始** — 同一 Wave 内无依赖、无共享可变状态冲突的任务**在同一条消息中同时派发**（不按数量/容量预先分批）
+2. **按实际前置结果推进** — 一个任务的**全部实际前置依赖已完成且无共享可变状态冲突，即可派发**，不必等本 Wave / 其他 Wave 的无关任务；同次所有已就绪任务同一条消息同时启动
+3. **进入下一批已就绪任务** — 按同样的方式派发，重复直到所有任务完成
+4. **Wave 只展示依赖层次，不构成整体等待屏障** — 若 Wave 1 的 B 已完成、C 仍慢，Wave 2 中只依赖 B 的任务可立即派发，不等 C
 
-**关键：同一 Wave 内的任务必须同时启动，绝不逐个串行。**
+**关键：可并行任务必须同时启动，绝不逐个串行；等待仅因任务自身的真实前置依赖与共享状态冲突，不因 Wave 序号或默认批次人为制造等待。**
 
-✅ 正确示例（Wave 1 有 3 个独立探索任务）：
+✅ 正确示例（3 个独立探索 + 2 个依赖修改）：
 \`\`\`
 → 同时发起：task(@explorer 搜索A) + task(@explorer 搜索B) + task(@librarian 查文档)
-→ 等全部返回
-→ 同时发起：task(@fixer 修改A) + task(@fixer 修改B)  // Wave 2
+→ 搜索A、搜索B 已返回（查文档仍慢）→ 立即发起：task(@fixer 修改A) + task(@fixer 修改B)  // 只等实际前置，不等无关的查文档
 \`\`\`
 
 ❌ 错误示例（串行）：
@@ -80,13 +82,14 @@ planner 的方案已按 Wave 分组（或你自己审核时重新分组），执
 
 **⚠️ 执行前并行检查清单——每次准备派发 task 前，必须逐条确认（不可跳过）：**
 
-□ **找出当前 Wave 的所有任务**：从 planner 方案中提取当前 Wave 的全部任务列表
-□ **识别不同文件的任务**：涉及不同文件？→ **必须并行派发，一次消息同时启动所有**
-□ **识别同文件的任务**：涉及同一文件？→ **必须串行排队，当前 Wave 的所有任务完成后，再启动下一批**
+□ **找出当前已就绪的任务**：从 planner 方案中找出**实际前置依赖已完成且无共享可变状态冲突**的任务（不等本 Wave / 其他 Wave 的无关任务）
+□ **识别不同文件的任务**：涉及不同文件且无依赖？→ **同一条消息中同时派发**；独立任务不按数量/猜测容量预先限制，容量未知不能当串行理由
+□ **识别同文件的任务**：涉及同一文件？→ **独立只读可并行**（多个 reader 同时读同文件无冲突）；**同文件多写、或要求特定文件版本/读取结果的读写任务**按实际冲突与依赖串行（后一任务等前一任务完成后再派发，不把单文件任务拆给多个 writer），**其他任务不陪等**
+□ **检查背压信号**：收到 429/TPM 限流等背压 → **暂停新增同类委派**，尊重宿主提供的重试时间（retry.next / Retry-After）；不无限重派/轮询，不取消他人任务；插件未实现自动退避
 □ **区分修改 Wave 与验证 Wave**：当前 Wave 是修改 Wave（只改文件不编译）？→ **委派 fixer 时必须注明"本轮只修改不验证，编译/测试统一在后续 Wave 执行"**。当前 Wave 是验证 Wave？→ 正常委派 fixer 执行编译/测试。
-□ **确认派发方式**：以上确认完成后 → **一次消息中同时发起当前 Wave 的所有 task 调用，绝不逐个串行**
+□ **确认派发方式**：以上确认完成后 → **发起所有已就绪任务的 task 调用，同条消息同时启动，绝不逐个串行**
 
-清晰文件范围+背景启动+追踪不重复+协调冲突。委派指令用中文。
+委派指令用中文，子代理 prompt 只传与当前子任务相关的事实/接口/文件，不重复全历史和无关依赖结果。后台启动使用 OpenCode 原生 \`task.background\`，不虚构自定义参数（如 run_in_background）。轻量任务走已有低成本路由，不私改 provider/variant 配置。
 
 ## 5. 验证（全部委派）
 @co-fixer 编译测试 →（编译通过后）@co-oracle 代码审查 与 @co-designer UI审查 并行。发现问题重新委派。
@@ -102,9 +105,9 @@ planner 的方案已按 Wave 分组（或你自己审核时重新分组），执
 <rule priority="1" name="先方案后执行">
 ### 规则 1：理解需求后必须先输出方案
 
-**⚠️ 长会话警告：这是最容易被遗忘的规则。无论会话多长、已经执行了多少步、之前分析过什么，每次收到新需求时，必须重新从头执行：分析需求 → 委派信息收集 → 委派 @co-planner 制定方案 → 审核 → todowrite → 提供选项供用户选择 → 委派执行。禁止"前面分析过了这次直接改"、"改着改着就忘了"。**
+**⚠️ 增量流程边界（避免重复全量分析）：这是最容易被遗忘的规则。涉及代码/文件修改的需求，禁止未经方案直接执行；但分析按增量进行——同一任务/同一范围的已核实事实（代码位置、API 行为、规则结论）与已获批准的计划**可直接复用**，无需重新探索；仅当需求变化、代码基线变化或关键文件变化时，定向补充缺失信息，不重复全量规则分析。仍必须走：分析需求 →（必要时定向信息收集）→ 委派 @co-planner 制定方案 → 审核 → todowrite → 提供选项供用户选择 → 委派执行。**
 
-收到需求后（涉及代码或文件修改时），**禁止立即执行**。必须先分析需求，委派 @co-planner 制定方案，orchestrator 审核后输出可验证的任务分解方案，**末尾提供选项（如"立即执行 / 修改方案"）供用户决定**。方案包含：
+收到需求后（涉及代码或文件修改时），**禁止立即执行**。必须先分析需求，委派 @co-planner 制定方案，orchestrator 审核后输出可验证的任务分解方案，**末尾提供选项（如"立即执行 / 修改方案"）供用户决定**。单文件小改仍输出简化但可验证的计划并等待批准；用户明确批准后续波次后，后续 Wave 执行不再反复要求批准。方案包含：
 （纯信息性问题可直接回答，无需方案。）
 - 子任务列表及其依赖关系
 - 每个子任务的委派对象（@co-explorer / @co-librarian / @co-fixer / @co-designer / @co-oracle / @co-observer）
@@ -127,16 +130,19 @@ planner 的方案已按 Wave 分组（或你自己审核时重新分组），执
 </rule>
 
 <rule priority="3" name="并行优先">
-### 规则 3：并行优先
-分析任务依赖后，最大程度并行化——独立任务同时启动。不确定是否独立时，宁可并行（发现冲突再修正比串行等待快）。
+### 规则 3：并行优先（真实依赖与共享状态为界）
+分析任务依赖后，最大化并行收益——无依赖、无共享可变状态冲突的独立任务**同一条消息中同时派发**，不按数量/文件数量/猜测容量预先限制（容量未知不能当作串行理由）；不确定是否独立时，先确认依赖与文件冲突，而不是盲目串行。
 
 **并行决策框架**：
-- 信息收集阶段：@co-explorer + @co-librarian + @co-observer 总是并行
-- 规则分析阶段：多个 @co-rule-app 实例总是并行
-- 执行阶段：修改不同文件的 @co-fixer 任务可并行；同一文件必须串行
+- 信息收集阶段：@co-explorer + @co-librarian + @co-observer 按需并行（定向补充，不重复全量）
+- 规则分析阶段：多个 @co-rule-app 实例按需定向并行（只分析适用规则，已核实事实复用）
+- 执行阶段：修改不同文件的 @co-fixer 任务可并行；同文件独立只读可并行；同文件多写或要求特定版本/读取结果的读写任务按实际冲突与依赖串行（其他任务不陪等）
 - 验证阶段：编译通过后，@co-oracle 代码审查 与 @co-designer UI审查 可并行
+- **背压信号**：收到 429/TPM 限流等背压 → 暂停新增同类委派，尊重宿主提供的重试时间；不无限重派/轮询，不取消他人任务
 
 **⚠️ 并行退火警告**：长会话中，模型易陷入"一次只做一件事"的串行惯性。**每当你准备只发起一个 task 调用时，必须先自问："还有没有其他可以同时完成的独立任务？"** 如果有——无论多小——必须立即找到并同时发起。单个 task 调用是最后手段，不是默认行为。
+
+**收敛重复审查**：审查类委派先交付具体文件与验收标准，一次集中验证后按风险一次主审；仅当存在未解决问题或新增变更时复审，不对同一事实让多代理反复全量调查。
 </rule>
 
 </critical_rules>
@@ -149,7 +155,7 @@ planner 的方案已按 Wave 分组（或你自己审核时重新分组），执
   → 需要修改代码或文件 → **必须先输出方案 → 提供选项 → 等用户选择后才可委派执行**
 
 □ **本轮需要同时发起多个独立操作吗？**
-  → 有 2+ 个修改不同文件的任务 / 探索任务 / 验证任务 → **必须一次消息同时发起所有 task，不得逐个串行**
+  → 有 2+ 个无依赖任务 → **同一条消息中同时派发，不得逐个串行**
   → 仅 1 个任务（确认无其他独立任务可并行） → 可以单个发起
 
 </自检清单>
@@ -235,6 +241,7 @@ var ORACLE_PROMPT = `你是 Oracle——战略技术顾问和代码审查者。
 - 简要解释推理
 - 存在不确定性时承认
 - 除非复杂度明确有收益，否则优先简单设计
+- **收敛复审**：一次集中验证后按风险一次主审；仅当存在未解决问题或新增变更时复审，不对同一事实重复全量调查
 
 **约束**:
 - 只读：你提出建议，不实施
@@ -700,9 +707,9 @@ var PLANNER_PROMPT = `你是方案制定代理——负责任务分解和委派
 
 | 波次 | 含义 | 执行方式 |
 |------|------|---------|
-| Wave 1 | 无前置依赖的任务 | **全部并行启动** |
-| Wave 2 | 依赖 Wave 1 的任务 | 等 Wave 1 全部完成后**全部并行启动** |
-| Wave N | 依赖 Wave N-1 的任务 | 等上一波全部完成后**全部并行启动** |
+| Wave 1 | 无前置依赖的任务 | **同一条消息同时派发**（真实无依赖、无共享可变状态冲突，不按数量/容量预先分批） |
+| Wave 2 | 依赖 Wave 1 的任务 | **任务实际前置依赖完成后即派发**（不等本波无关任务；同次所有已就绪任务同一消息同时启动） |
+| Wave N | 依赖 Wave N-1 的任务 | **任务实际前置依赖完成后即派发**（不等本波无关任务；同次所有已就绪任务同一消息同时启动） |
 
 ### 输出格式
 
@@ -712,7 +719,7 @@ var PLANNER_PROMPT = `你是方案制定代理——负责任务分解和委派
 - 波次：M 个
 - 涉及文件：文件列表
 
-## Wave 1（无依赖，全并行）
+## Wave 1（无依赖，同 Wave 并行）
 - 任务 1.1：@explorer 搜索定位 xxx 文件中的关键代码
   - 依赖：无
   - 文件：xxx
@@ -750,11 +757,11 @@ var PLANNER_PROMPT = `你是方案制定代理——负责任务分解和委派
 
 ## 关键原则
 
-1. **同一 Wave 内的任务数 = 并行度** — 尽量把更多无依赖的任务塞进同一个 Wave
+1. **同 Wave 并行** — 无依赖、无共享可变状态冲突的任务放同一 Wave，同一条消息同时派发；任务实际前置依赖完成即可派发（Wave 不构成整体等待屏障，不等无关任务）；不按数量/文件数量/猜测容量预先分批（容量未知不能当串行理由），真实 429/TPM 背压按服务反馈处理
 2. **不同文件的任务 → 同 Wave 并行** — 修改 a.ts 和 b.ts 无冲突，放同一 Wave
-3. **同一文件的任务 → 分不同 Wave 串行** — 先读后写必须分两波
-4. **探索任务永远放 Wave 1** — 搜索/查文档无依赖，先全部并行跑完
-5. **验证任务放最后 Wave** — 所有修改完成后才编译/测试/审查。修改 Wave 中的 fixer 任务仅做文件修改，不包含编译/测试步骤
+3. **同文件冲突按实际粒度判定** — 同文件**独立只读可并行**（多个 reader 同文件无冲突）；同文件**多写、或要求特定文件版本/读取结果的读写任务**按实际冲突与依赖串行（如先读后写必须等读完成），**其他任务不陪等**
+4. **探索任务定向放 Wave 1** — 搜索/查文档无依赖，先并行跑；但只收集尚未核实、与需求直接相关的信息，同范围已核实信息直接复用，不重复全量扫描
+5. **验证任务放最后 Wave** — 所有涉及修改完成后才编译/测试/审查（这是真实依赖：编译必须看到全部修改），但不等与验证无关的任务。修改 Wave 中的 fixer 任务仅做文件修改，不包含编译/测试步骤
 
 **约束**：只读，不修改文件。方案要具体到文件和操作粒度，不可笼统。`;
 
@@ -824,6 +831,7 @@ var DEFAULT_CONTEXT_CONFIG = {
   maxDependencies: 8,
   dependencyPropagation: true,
   summarizeMaxTokens: 2000,
+  summaryReadMode: "bounded",
   relevantMessageWindow: 20,
   maxErrorTotalChars: 600,
   dependencyKeyOutputChars: 200
@@ -878,20 +886,29 @@ function computeStats(records, window = DEFAULT_STATS_WINDOW) {
 
 class TaskTracker {
   jobs = new Map;
+  callIndex = new Map;
   counters = new Map;
   _currentParentSessionId = "";
   _reconciledForParent = "";
   get currentParentSessionId() {
     return this._currentParentSessionId;
   }
+  callKey(parentSessionId, callID) {
+    return parentSessionId + "\x00" + callID;
+  }
   alias(agentType) {
     const short = agentType.slice(0, 4).replace(/[^a-z]/gi, "");
     const n = (this.counters.get(agentType) ?? 0) + 1;
     this.counters.set(agentType, n);
     return `${short}-${n}`;
   }
-  registerBeforeTask(parentSessionId, args) {
+  registerBeforeTask(parentSessionId, args, callID) {
     this._currentParentSessionId = parentSessionId;
+    if (callID) {
+      const existing = this.getJobByCall(parentSessionId, callID);
+      if (existing)
+        return existing.alias;
+    }
     if (this._reconciledForParent !== parentSessionId) {
       this._reconciledForParent = parentSessionId;
       for (const job of this.jobs.values()) {
@@ -903,7 +920,7 @@ class TaskTracker {
     const agent = args.subagent_type ?? "unknown";
     const alias = this.alias(agent);
     const label = typeof args.description === "string" && args.description ? args.description : alias;
-    this.jobs.set(alias, {
+    const job = {
       alias,
       sessionId: args.task_id ?? "",
       parentSessionId,
@@ -914,40 +931,154 @@ class TaskTracker {
       background: args.background ?? false,
       terminalReconciled: false,
       createdAt: Date.now()
-    });
+    };
+    if (callID)
+      job.callID = callID;
+    this.jobs.set(alias, job);
+    if (callID)
+      this.callIndex.set(this.callKey(parentSessionId, callID), alias);
     return alias;
   }
+  getJobByCall(parentSessionId, callID) {
+    const alias = this.callIndex.get(this.callKey(parentSessionId, callID));
+    return alias ? this.jobs.get(alias) : undefined;
+  }
+  updateAfterTaskByCall(parentSessionId, callID, status, sessionId) {
+    const job = this.getJobByCall(parentSessionId, callID);
+    if (!job)
+      return { ok: false, reason: "no-match" };
+    return this.applyCallUpdate(job, status, sessionId);
+  }
+  setBackgroundByCall(parentSessionId, callID, bg) {
+    const job = this.getJobByCall(parentSessionId, callID);
+    if (!job)
+      return { ok: false, reason: "no-match" };
+    if (job.status !== "running") {
+      return { ok: true, reason: "idempotent", alias: job.alias };
+    }
+    job.background = bg;
+    return { ok: true, reason: "ok", alias: job.alias };
+  }
+  getJobByAlias(alias) {
+    return this.jobs.get(alias);
+  }
+  updateByAlias(alias, status, sessionId) {
+    const job = this.jobs.get(alias);
+    if (!job)
+      return { ok: false, reason: "no-match" };
+    return this.applyCallUpdate(job, status, sessionId);
+  }
+  applyCallUpdate(job, status, sessionId) {
+    if (!job.background) {
+      if (job.status !== "running") {
+        return { ok: true, reason: "idempotent", alias: job.alias };
+      }
+      job.status = status;
+      job.terminalReconciled = true;
+      if (sessionId)
+        job.sessionId = sessionId;
+      this.finalize(job);
+      this.persistStats();
+      return { ok: true, reason: "ok", alias: job.alias };
+    }
+    if (sessionId)
+      job.sessionId = sessionId;
+    return { ok: true, reason: "ok", alias: job.alias };
+  }
   updateAfterTask(parentSessionId, status, sessionId) {
     this._currentParentSessionId = parentSessionId;
-    let latest;
+    const running = [];
     for (const job of this.jobs.values()) {
-      if (job.parentSessionId === parentSessionId && job.status === "running" && (!latest || job.createdAt > latest.createdAt)) {
-        latest = job;
+      if (job.parentSessionId === parentSessionId && job.status === "running") {
+        running.push(job);
       }
     }
-    if (latest) {
-      if (latest.background) {
-        if (sessionId)
-          latest.sessionId = sessionId;
-        return;
+    if (running.length === 0)
+      return { ok: false, reason: "no-match" };
+    if (running.length > 1)
+      return { ok: false, reason: "ambiguous" };
+    return this.applyCallUpdate(running[0], status, sessionId);
+  }
+  updateByChildSessionId(sessionId, status) {
+    let allWithSession = 0;
+    let runningBg;
+    for (const job of this.jobs.values()) {
+      if (job.sessionId === sessionId) {
+        allWithSession++;
+        if (job.background && job.status === "running")
+          runningBg = job;
       }
-      latest.status = status;
-      latest.terminalReconciled = true;
-      if (sessionId)
-        latest.sessionId = sessionId;
-      this.finalize(latest);
-      this.persistStats();
     }
+    if (allWithSession === 0)
+      return { ok: false, reason: "no-match" };
+    if (allWithSession > 1)
+      return { ok: false, reason: "ambiguous" };
+    if (!runningBg)
+      return { ok: false, reason: "no-match" };
+    runningBg.status = status;
+    this.finalize(runningBg);
+    this.persistStats();
+    return { ok: true, reason: "ok", alias: runningBg.alias };
   }
-  updateByChildSessionId(sessionId, status) {
+  noteChildSessionIdle(sessionId) {
+    let allWithSession = 0;
+    let runningBg;
     for (const job of this.jobs.values()) {
-      if (job.sessionId === sessionId && job.background && job.status === "running") {
-        job.status = status;
-        this.finalize(job);
-        this.persistStats();
-        return;
+      if (job.sessionId === sessionId) {
+        allWithSession++;
+        if (job.background && job.status === "running")
+          runningBg = job;
+      }
+    }
+    if (allWithSession === 0)
+      return { ok: false, reason: "no-match" };
+    if (allWithSession > 1)
+      return { ok: false, reason: "ambiguous" };
+    if (!runningBg)
+      return { ok: false, reason: "no-match" };
+    return { ok: true, reason: "observed", alias: runningBg.alias };
+  }
+  findActiveByChildSessionId(sessionId) {
+    let active;
+    for (const job of this.jobs.values()) {
+      if (job.sessionId === sessionId && job.status === "running") {
+        if (active)
+          return { ok: false, reason: "ambiguous" };
+        active = job;
+      }
+    }
+    return active ? { ok: true, job: active } : { ok: false, reason: "no-match" };
+  }
+  finalizeByCall(parentSessionId, callID, expectedChildId, status) {
+    const job = this.getJobByCall(parentSessionId, callID);
+    if (!job)
+      return { ok: false, reason: "no-match" };
+    if (job.status !== "running") {
+      return { ok: true, reason: "idempotent", alias: job.alias };
+    }
+    if (status === "running") {
+      return { ok: false, reason: "no-match" };
+    }
+    if (expectedChildId !== undefined) {
+      if (job.sessionId !== "" && job.sessionId !== expectedChildId) {
+        return { ok: false, reason: "no-match" };
+      }
+      if (job.sessionId === "")
+        job.sessionId = expectedChildId;
+      let runningShare = 0;
+      for (const j of this.jobs.values()) {
+        if (j.sessionId === expectedChildId && j.status === "running")
+          runningShare++;
       }
+      if (runningShare === 0)
+        return { ok: false, reason: "no-match" };
+      if (runningShare > 1)
+        return { ok: false, reason: "ambiguous" };
     }
+    job.status = status;
+    this.finalize(job);
+    this.persistStats();
+    return { ok: true, reason: "ok", alias: job.alias };
   }
   getBoardText(parentSessionId) {
     if (typeof parentSessionId !== "string" || parentSessionId === "")
@@ -1054,6 +1185,10 @@ class TaskTracker {
       }
     }
     for (const alias of toDelete) {
+      const job = this.jobs.get(alias);
+      if (job?.callID) {
+        this.callIndex.delete(this.callKey(job.parentSessionId, job.callID));
+      }
       this.jobs.delete(alias);
     }
     return toDelete.length;
@@ -1089,14 +1224,28 @@ class TaskTracker {
     return;
   }
   updateQuality(sessionId, quality) {
+    let hit;
     for (const job of this.jobs.values()) {
       if (job.sessionId === sessionId) {
-        job.quality = quality;
-        this.finalize(job);
-        this.persistStats();
-        return;
+        if (hit)
+          return;
+        hit = job;
       }
     }
+    if (hit) {
+      hit.quality = quality;
+      this.finalize(hit);
+      this.persistStats();
+    }
+  }
+  updateQualityByAlias(alias, quality) {
+    const job = this.jobs.get(alias);
+    if (!job)
+      return { ok: false, reason: "no-match" };
+    job.quality = quality;
+    this.finalize(job);
+    this.persistStats();
+    return { ok: true, reason: "ok", alias };
   }
   finalize(job) {
     if (job.status !== "running") {
@@ -1145,18 +1294,60 @@ class TaskTracker {
       this.persistStats();
     }
   }
-  abortJob(taskId) {
-    let job = this.jobs.get(taskId);
-    if (!job) {
-      for (const j of this.jobs.values()) {
-        if (j.sessionId === taskId) {
-          job = j;
-          break;
-        }
+  resolveCancelTarget(taskId) {
+    const byAlias = this.jobs.get(taskId);
+    if (byAlias)
+      return { ok: true, job: byAlias };
+    let active;
+    for (const job of this.jobs.values()) {
+      if (job.sessionId === taskId && job.status === "running") {
+        if (active)
+          return { ok: false, reason: "ambiguous" };
+        active = job;
       }
     }
+    return active ? { ok: true, job: active } : { ok: false, reason: "no-match" };
+  }
+  markCancelledByAlias(alias) {
+    const job = this.jobs.get(alias);
     if (!job)
-      return;
+      return { ok: false, reason: "no-match" };
+    if (job.status !== "running") {
+      return { ok: true, reason: "idempotent", alias };
+    }
+    job.status = "cancelled";
+    job.terminalReconciled = true;
+    this.finalize(job);
+    this.persistStats();
+    return { ok: true, reason: "ok", alias };
+  }
+  abortJob(taskId) {
+    const byAlias = this.jobs.get(taskId);
+    if (byAlias)
+      return this.abortFound(byAlias);
+    let active;
+    let firstHistory;
+    let historyCount = 0;
+    for (const j of this.jobs.values()) {
+      if (j.sessionId !== taskId)
+        continue;
+      if (j.status === "running") {
+        if (active)
+          return;
+        active = j;
+      } else {
+        if (!firstHistory)
+          firstHistory = j;
+        historyCount++;
+      }
+    }
+    if (active)
+      return this.abortFound(active);
+    if (historyCount === 1)
+      return this.abortFound(firstHistory);
+    return;
+  }
+  abortFound(job) {
     if (job.status !== "running") {
       return { sessionId: job.sessionId || undefined, job };
     }
@@ -1603,7 +1794,44 @@ function replaceMarkerWithContext(messageText, context) {
   return messageText.replace(CONTEXT_MARKER_PATTERN, formatted);
 }
 
+// src/context/prompt-budget.ts
+var SUMMARY_READ_MAX_BYTES_PER_FILE = 1024 * 1024;
+var SUMMARY_READ_LOOKAHEAD_BYTES = 4;
+function tokenBudgetToByteLimit(budgetTokens) {
+  const n = Number(budgetTokens);
+  if (!Number.isFinite(n) || n <= 0)
+    return 4;
+  const raw = Math.ceil(n * 4 * 2);
+  return Math.min(SUMMARY_READ_MAX_BYTES_PER_FILE, Math.max(4, raw));
+}
+function utf8TrimIncomplete(buf) {
+  if (buf.length === 0)
+    return buf;
+  const last = buf[buf.length - 1];
+  if (last < 128)
+    return buf;
+  let i = buf.length - 1;
+  while (i > 0 && (buf[i] & 192) === 128)
+    i--;
+  const head = buf[i];
+  let seqLen = 0;
+  if ((head & 224) === 192)
+    seqLen = 2;
+  else if ((head & 240) === 224)
+    seqLen = 3;
+  else if ((head & 248) === 240)
+    seqLen = 4;
+  else
+    return buf;
+  if (buf.length - i < seqLen)
+    return buf.subarray(0, i);
+  return buf;
+}
+
 // src/context/engine.ts
+var READ_LIMIT_TRUNCATION_SUFFIX = `
+… [正文已按读取上限截断]`;
+
 class ContextEngine {
   registry = new Map;
   registryTouchedAt = new Map;
@@ -1682,11 +1910,39 @@ class ContextEngine {
     const budgetPerFile = Math.max(1, Math.floor(this.config.summarizeMaxTokens / files.length));
     for (const file of files) {
       try {
-        const content = fs2.readFileSync(file.path, "utf-8");
-        file.body = truncateByTokens(content, budgetPerFile);
+        if (this.config.summaryReadMode === "full") {
+          const content = fs2.readFileSync(file.path, "utf-8");
+          file.body = truncateByTokens(content, budgetPerFile);
+        } else {
+          const { text, truncatedByReadLimit } = this.readBoundedUtf8(file.path, tokenBudgetToByteLimit(budgetPerFile));
+          file.body = truncateByTokens(text, budgetPerFile);
+          if (truncatedByReadLimit && estimateTokens(file.body) <= budgetPerFile) {
+            file.body += READ_LIMIT_TRUNCATION_SUFFIX;
+          }
+        }
       } catch {}
     }
   }
+  readBoundedUtf8(filePath, byteLimit) {
+    const fd = fs2.openSync(filePath, "r");
+    try {
+      const { size } = fs2.fstatSync(fd);
+      const toRead = Math.min(size, byteLimit + SUMMARY_READ_LOOKAHEAD_BYTES);
+      const buf = Buffer.allocUnsafe(Math.max(0, toRead));
+      let filled = 0;
+      while (filled < toRead) {
+        const n = fs2.readSync(fd, buf, filled, toRead - filled, filled);
+        if (n <= 0)
+          break;
+        filled += n;
+      }
+      const truncatedByReadLimit = filled > byteLimit;
+      const raw = buf.subarray(0, Math.min(filled, byteLimit));
+      return { text: utf8TrimIncomplete(raw).toString("utf-8"), truncatedByReadLimit };
+    } finally {
+      fs2.closeSync(fd);
+    }
+  }
   consumeMarkedContext(messageText) {
     const markerMatch = messageText.match(CONTEXT_MARKER_PATTERN);
     if (!markerMatch)
@@ -1973,6 +2229,47 @@ function appendCtxDiag(record, filePath) {
     } catch {}
   });
 }
+var TASK_DIAG_STRING_MAX = 64;
+var TASK_DIAG_STRING_KEYS = ["callID", "session", "alias", "event", "status"];
+var TASK_DIAG_NUMBER_KEYS = [
+  "durationMs",
+  "lastActivityAt",
+  "retryAttempt",
+  "retryNextMs",
+  "retryAfterMs",
+  "budgetChars",
+  "budgetTokens"
+];
+function sanitizeTaskDiagRecord(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input))
+    return null;
+  const src = input;
+  const out = { t: "task" };
+  for (const key of TASK_DIAG_STRING_KEYS) {
+    const v = src[key];
+    if (typeof v === "string") {
+      const trimmed = v.trim();
+      if (trimmed !== "")
+        out[key] = trimmed.slice(0, TASK_DIAG_STRING_MAX);
+    }
+  }
+  for (const key of TASK_DIAG_NUMBER_KEYS) {
+    const v = src[key];
+    if (typeof v === "number" && Number.isFinite(v))
+      out[key] = v;
+  }
+  const kind = src["rateLimitKind"];
+  if (kind === "rate_limit" || kind === "retryable_network" || kind === "other") {
+    out.rateLimitKind = kind;
+  }
+  return out;
+}
+function appendTaskDiag(record, filePath) {
+  const safe = sanitizeTaskDiagRecord(record);
+  if (!safe)
+    return;
+  appendCtxDiag(safe, filePath);
+}
 
 // src/tools/council.ts
 import { tool } from "@opencode-ai/plugin";
@@ -2073,6 +2370,119 @@ function createLogger(cfg) {
   return appendLogSync;
 }
 
+// src/orchestration/rate-limit.ts
+var RATE_LIMIT_TEXT = ["tokens per minute", "rate limit", "quota"];
+var NETWORK_TEXT = ["econnreset", "socket hang up", "timeout", "etimedout"];
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function normalizeError(error) {
+  if (!isPlainObject(error))
+    return null;
+  const obj = error;
+  const data = isPlainObject(obj["data"]) ? obj["data"] : undefined;
+  const pick = (key) => {
+    if (obj[key] !== undefined)
+      return obj[key];
+    if (data && data[key] !== undefined)
+      return data[key];
+    return;
+  };
+  const statusCode = pick("statusCode");
+  const isRetryable = pick("isRetryable");
+  const headers = pick("responseHeaders");
+  const body = pick("responseBody");
+  const message = pick("message");
+  const cause = pick("cause");
+  const headersOut = {};
+  if (isPlainObject(headers)) {
+    for (const [k, v] of Object.entries(headers)) {
+      if (typeof v === "string")
+        headersOut[k] = v;
+    }
+  }
+  const causeCode = isPlainObject(cause) && typeof cause["code"] === "string" ? cause["code"] : undefined;
+  return {
+    statusCode: typeof statusCode === "number" && Number.isFinite(statusCode) ? statusCode : undefined,
+    isRetryable: typeof isRetryable === "boolean" ? isRetryable : false,
+    responseHeaders: headersOut,
+    responseBody: typeof body === "string" ? body : undefined,
+    message: typeof message === "string" ? message : undefined,
+    causeCode
+  };
+}
+function findRetryAfter(headers) {
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === "retry-after" && v.trim() !== "")
+      return v.trim();
+  }
+  return;
+}
+function parseRetryAfter(headers, nowMs) {
+  const raw = findRetryAfter(headers);
+  if (raw === undefined)
+    return { retryAfterSource: "none" };
+  if (/^\d+$/.test(raw)) {
+    const secs = Number(raw);
+    if (secs > 0)
+      return { retryAfterMs: secs * 1000, retryAfterSource: "header-seconds" };
+    return { retryAfterSource: "none" };
+  }
+  const dateMs = Date.parse(raw);
+  if (Number.isNaN(dateMs))
+    return { retryAfterSource: "none" };
+  const waitMs = dateMs - nowMs;
+  if (waitMs > 0)
+    return { retryAfterMs: waitMs, retryAfterSource: "header-date" };
+  return { retryAfterSource: "none" };
+}
+function classifyRateLimit(error, now) {
+  const norm = normalizeError(error);
+  if (!norm) {
+    return {
+      kind: "other",
+      retryAfterSource: "none",
+      isRetryable: false,
+      maskedMessage: "non-object-input"
+    };
+  }
+  const nowMs = typeof now === "number" && Number.isFinite(now) ? now : Date.now();
+  if (norm.statusCode === 429) {
+    const ra = parseRetryAfter(norm.responseHeaders, nowMs);
+    return {
+      kind: "rate_limit",
+      ...ra,
+      isRetryable: norm.isRetryable,
+      maskedMessage: "rate-limit-classified (http-429)"
+    };
+  }
+  const text = [norm.message, norm.responseBody].filter((s) => typeof s === "string" && s !== "").join(`
+`).toLowerCase();
+  if (RATE_LIMIT_TEXT.some((t) => text.includes(t))) {
+    return {
+      kind: "rate_limit",
+      retryAfterSource: "none",
+      isRetryable: norm.isRetryable,
+      maskedMessage: "rate-limit-classified (text-signal)"
+    };
+  }
+  const causeText = norm.causeCode?.toLowerCase() ?? "";
+  if (NETWORK_TEXT.some((t) => text.includes(t)) || NETWORK_TEXT.some((t) => causeText.includes(t))) {
+    return {
+      kind: "retryable_network",
+      retryAfterSource: "none",
+      isRetryable: norm.isRetryable,
+      maskedMessage: "retryable-network-error (socket/timeout)"
+    };
+  }
+  return {
+    kind: "other",
+    retryAfterSource: "none",
+    isRetryable: norm.isRetryable,
+    maskedMessage: "unclassified-error"
+  };
+}
+
 // src/utils/log.ts
 var LOG_DIR = path6.join(os4.homedir(), ".local", "share", "opencode", "log");
 var appendLog = createLogger({
@@ -2083,6 +2493,14 @@ var appendLog = createLogger({
   keepDays: 7,
   async: true
 });
+function appendSafeLog(tag, message, err) {
+  if (err === undefined) {
+    appendLog(tag, message);
+    return;
+  }
+  const { maskedMessage } = classifyRateLimit(err);
+  appendLog(tag, `${message} — ${maskedMessage}`);
+}
 
 // src/tools/model-stats.ts
 var DEFAULT_MODEL_STATS_CONFIG = {
@@ -2907,7 +3325,7 @@ function createCouncilTool(ctx, councilManager) {
 // src/tools/job-control.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 var z2 = tool2.schema;
-function createCloseJobTool(ctx, tracker, onClosed) {
+function createCloseJobTool(ctx, tracker, onClosed, onCancelled) {
   const close_job = tool2({
     description: "Close (abort) a stuck or unnecessary subagent background task. " + "Accepts the child Session ID (e.g. ses_xxx, shown in the Background Job Board) or the task alias (e.g. coe-1). " + "The underlying subagent session is aborted via session.abort() and the task is marked cancelled. " + "Only the co-orchestrator (primary) agent may invoke this tool.",
     args: {
@@ -2917,28 +3335,68 @@ function createCloseJobTool(ctx, tracker, onClosed) {
       if (toolContext.agent !== "co-orchestrator") {
         throw new Error(`[oh-my-opencode-cohub] close_job can only be invoked by co-orchestrator. Current agent: ${toolContext.agent}`);
       }
-      const hit = tracker.abortJob(args.task_id);
-      if (!hit) {
-        return JSON.stringify({ ok: false, task_id: args.task_id, reason: "not_found" }, null, 2);
+      const target = tracker.resolveCancelTarget(args.task_id);
+      if (!target.ok) {
+        return JSON.stringify({ ok: false, task_id: args.task_id, reason: target.reason, session_aborted: false }, null, 2);
+      }
+      const job = target.job;
+      const alias = job.alias;
+      if (job.status !== "running") {
+        return JSON.stringify({
+          ok: true,
+          task_id: args.task_id,
+          alias,
+          agent: job.agent,
+          session_aborted: false,
+          status: job.status,
+          reason: "idempotent"
+        }, null, 2);
       }
       let aborted = false;
-      if (hit.sessionId) {
-        const res = await ctx.client.session.abort({ path: { id: hit.sessionId } });
-        if (res.error) {
-          appendLog("job-control", `abort session ${hit.sessionId} 失败`, res.error);
+      if (job.sessionId) {
+        try {
+          const res = await ctx.client.session.abort({ path: { id: job.sessionId } });
+          aborted = !res.error;
+          if (res.error) {
+            appendLog("job-control", `abort session ${job.sessionId} 失败`, res.error);
+          }
+        } catch (err) {
+          appendLog("job-control", `abort session ${job.sessionId} 抛出异常`, err);
           aborted = false;
-        } else {
-          aborted = true;
+        }
+      }
+      if (job.sessionId && !aborted) {
+        return JSON.stringify({
+          ok: false,
+          task_id: args.task_id,
+          alias,
+          agent: job.agent,
+          session_aborted: false,
+          status: job.status,
+          reason: "abort_failed"
+        }, null, 2);
+      }
+      const up = tracker.markCancelledByAlias(alias);
+      if (!up.ok) {
+        return JSON.stringify({ ok: false, task_id: args.task_id, alias, session_aborted: aborted, status: job.status, reason: "stale" }, null, 2);
+      }
+      if (up.reason === "ok") {
+        try {
+          onCancelled?.(alias);
+        } catch (err) {
+          appendLog("job-control", `onCancelled 回调异常（不影响取消结果）`, err);
         }
       }
       onClosed?.();
+      const actualStatus = up.reason === "ok" ? "cancelled" : tracker.getJobByAlias(alias)?.status ?? job.status;
       return JSON.stringify({
-        ok: true,
+        ok: up.reason === "ok" || up.reason === "idempotent",
         task_id: args.task_id,
-        alias: hit.job?.alias,
-        agent: hit.job?.agent,
+        alias,
+        agent: job.agent,
         session_aborted: aborted,
-        status: "cancelled"
+        status: actualStatus,
+        reason: up.reason
       }, null, 2);
     }
   });
@@ -3047,10 +3505,27 @@ class OrchestrationEngine {
     const task = this.dag.tasks.get(alias);
     if (!task)
       throw new Error(`Task ${alias} not found`);
+    if (task.state === to)
+      return;
     const allowed = VALID_TRANSITIONS[task.state];
     if (!allowed.includes(to)) {
       throw new Error(`Invalid transition: ${task.state} → ${to} for ${alias}`);
     }
+    this.setState(task, to);
+  }
+  applyLifecycleEvent(alias, to) {
+    const task = this.dag.tasks.get(alias);
+    if (!task)
+      return { ok: false, reason: "unknown-task" };
+    if (task.state === to)
+      return { ok: true, reason: "idempotent" };
+    const allowed = VALID_TRANSITIONS[task.state];
+    if (!allowed.includes(to))
+      return { ok: false, reason: "invalid-transition" };
+    this.setState(task, to);
+    return { ok: true, reason: "applied" };
+  }
+  setState(task, to) {
     task.state = to;
     if (to === "completed") {
       for (const depAlias of task.dependents) {
@@ -3058,7 +3533,7 @@ class OrchestrationEngine {
       }
     }
     if (to === "cancelled") {
-      this.cascadeCancel(alias);
+      this.cascadeCancel(task.alias);
     }
   }
   checkDependencies(alias) {
@@ -3368,6 +3843,7 @@ ${append}`;
   return base;
 }
 var CoHubPlugin = async (input, options) => {
+  const pluginClient = input.client;
   const projectDir = input.directory || process.cwd();
   const fileOverrides = loadFileOverrides(projectDir);
   const configOverrides = {};
@@ -3377,7 +3853,6 @@ var CoHubPlugin = async (input, options) => {
   const promptOverrides = { ...configOverrides, ...fileOverrides };
   const tracker = new TaskTracker;
   const orchestrationLayer = createOrchestrationLayer(tracker, {});
-  let _lastAlias = "";
   const STATE_DIR = path7.join(os5.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub");
   const STATE_FILE = path7.join(STATE_DIR, "tracker-state.json");
   function syncTrackerState(sessionId) {
@@ -3508,26 +3983,29 @@ var CoHubPlugin = async (input, options) => {
   const councilConfig = userConfig.council ?? DEFAULT_COUNCIL_CONFIG;
   const councilManager = new CouncilManager(input.client, input.directory, councilConfig);
   const councilTools = createCouncilTool(input, councilManager);
-  const jobTools = createCloseJobTool(input, tracker, () => syncTrackerState(tracker.currentParentSessionId));
+  const jobTools = createCloseJobTool(input, tracker, undefined, (alias) => {
+    const job = tracker.getJobByAlias(alias);
+    if (job && orchestrationLayer) {
+      orchestrationLayer.engine.applyLifecycleEvent(alias, "cancelled");
+      syncTrackerState(job.parentSessionId);
+    }
+  });
   function extractChildSessionId(output) {
     if (!output || typeof output !== "object")
       return;
     const o = output;
     const meta = o.metadata;
     if (meta) {
-      if (typeof meta.sessionId === "string")
-        return meta.sessionId;
-      if (typeof meta.taskId === "string")
-        return meta.taskId;
-      if (typeof meta.task_id === "string")
-        return meta.task_id;
-      if (typeof meta.id === "string")
-        return meta.id;
+      for (const key of ["sessionId", "taskId", "task_id", "id"]) {
+        const v = meta[key];
+        if (typeof v === "string" && v.startsWith("ses_"))
+          return v;
+      }
     }
     const text = typeof o.output === "string" ? o.output : "";
-    const m = text.match(/\b(session|task)[_\s]?(?:id|ID)[:\s]+(\S+)/i);
+    const m = text.match(/\b(?:session|task)[_\s]?id[:\s]+(ses_\S+)/i);
     if (m)
-      return m[2];
+      return m[1];
     return;
   }
   function extractSessionIdFromEvent(props) {
@@ -3543,6 +4021,130 @@ var CoHubPlugin = async (input, options) => {
       return p.sessionId;
     return;
   }
+  async function verifyChildTerminal(client, sessionId, jobCreatedAt) {
+    try {
+      const res = await client.session.messages({ path: { id: sessionId }, query: { limit: 10 } });
+      if (res.error)
+        return "unknown";
+      const msgs = res.data;
+      if (!Array.isArray(msgs) || msgs.length === 0)
+        return "unknown";
+      let latest;
+      let latestCreated = -1;
+      for (const item of msgs) {
+        const info = item?.info;
+        if (!info || info.role !== "assistant")
+          continue;
+        const t = info.time;
+        const created = typeof t?.created === "number" ? t.created : -1;
+        if (created > latestCreated) {
+          latestCreated = created;
+          latest = item;
+        }
+      }
+      if (!latest)
+        return "unknown";
+      const info = latest.info;
+      const time = info.time;
+      const created = typeof time?.created === "number" ? time.created : undefined;
+      if (created !== undefined && created < jobCreatedAt)
+        return "unknown";
+      if (info.error)
+        return isAbortLikeError(info.error) ? "cancelled" : "errored";
+      const parts = latest.parts ?? [];
+      const hasOpenTool = parts.some((p) => {
+        if (p.type !== "tool")
+          return false;
+        const st = p.state;
+        return st?.status !== "completed" && st?.status !== "error";
+      });
+      if (hasOpenTool)
+        return "unknown";
+      const finish = info.finish;
+      if (typeof finish === "string" && finish !== "") {
+        const f = finish.toLowerCase();
+        if (f === "tool-calls" || f === "tool_calls")
+          return "unknown";
+        if (f === "abort" || f === "cancel" || f === "cancelled")
+          return "cancelled";
+        if (f === "length" || f === "content-filter" || f === "content_filter")
+          return "errored";
+        if (KNOWN_SUCCESS_FINISH.some((m) => m === f))
+          return "completed";
+        return "unknown";
+      }
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  const KNOWN_SUCCESS_FINISH = ["finish", "stop", "end_turn", "end", "success", "done", "completed"];
+  function isAbortLikeError(err) {
+    if (!err || typeof err !== "object")
+      return false;
+    return err.name === "MessageAbortedError";
+  }
+  function taskDiag(record) {
+    if (ctxDiag.enabled)
+      appendTaskDiag(record, ctxDiag.filePath);
+  }
+  function classifyTaskAfter(output) {
+    if (output && typeof output === "object") {
+      const meta = output.metadata;
+      if (meta && typeof meta === "object") {
+        if (meta.status === "cancelled" || meta.cancelled === true)
+          return { status: "cancelled" };
+        if (meta.status === "failed" || meta.status === "error" || meta.status === "errored" || meta.error !== undefined) {
+          return { status: "errored" };
+        }
+        if (meta.status === "running" || meta.status === "pending")
+          return { status: "running" };
+      }
+    }
+    return { status: "unknown" };
+  }
+  async function reconcileJobTerminal(job) {
+    const parentAtCall = job.parentSessionId;
+    const callAtCall = job.callID;
+    const aliasAtCall = job.alias;
+    const childId = job.sessionId;
+    if (!childId)
+      return;
+    const verdict = await verifyChildTerminal(pluginClient, childId, job.createdAt);
+    const nowJob = callAtCall ? tracker.getJobByCall(parentAtCall, callAtCall) : tracker.getJobBySessionId(childId);
+    if (!nowJob || nowJob.alias !== aliasAtCall || nowJob.sessionId !== childId || nowJob.status !== "running") {
+      appendSafeLog("event", `收尾竞态：候选已变更，不更新新调用 (session=${childId.slice(0, 20)})`);
+      return;
+    }
+    if (verdict === "completed" || verdict === "errored" || verdict === "cancelled") {
+      const term = verdict === "completed" ? "completed" : verdict === "cancelled" ? "cancelled" : "errored";
+      const up = callAtCall ? tracker.finalizeByCall(parentAtCall, callAtCall, childId, term) : tracker.updateByChildSessionId(childId, term);
+      syncTrackerState(tracker.currentParentSessionId);
+      const alias = up.ok ? up.alias : aliasAtCall;
+      if (up.ok && up.alias && orchestrationLayer) {
+        orchestrationLayer.engine.applyLifecycleEvent(up.alias, verdict === "completed" ? "completed" : verdict === "cancelled" ? "cancelled" : "failed");
+      }
+      taskDiag({
+        t: "task",
+        session: childId.slice(0, 20),
+        alias,
+        event: verdict === "completed" ? "task_completed" : verdict === "cancelled" ? "task_cancelled" : "task_failed",
+        status: verdict === "completed" ? "completed" : verdict === "cancelled" ? "cancelled" : "failed",
+        durationMs: Date.now() - job.createdAt,
+        lastActivityAt: Date.now()
+      });
+    } else {
+      appendSafeLog("event", `无终态证据，保持 running (session=${childId.slice(0, 20)})`);
+      taskDiag({
+        t: "task",
+        session: childId.slice(0, 20),
+        alias: aliasAtCall,
+        event: "state_changed",
+        status: "running",
+        lastActivityAt: Date.now()
+      });
+    }
+  }
   const cleanupTimer = setInterval(() => {
     try {
       const staleSessions = tracker.cleanupStaleJobs(STALE_TASK_MS);
@@ -3660,13 +4262,14 @@ var CoHubPlugin = async (input, options) => {
             subagent_type: subagentType,
             task_id: typeof output.args.task_id === "string" && output.args.task_id.startsWith("ses_") ? output.args.task_id : undefined,
             background: typeof args.background === "boolean" ? args.background : undefined
-          });
-          _lastAlias = alias;
+          }, input.callID);
           syncTrackerState(input.sessionID ?? "");
           tracker.pruneTerminalJobs(STALE_TASK_MS);
           if (orchestrationLayer && subagentType && description) {
             try {
-              orchestrationLayer.engine.registerTask(alias, subagentType, description, []);
+              if (!orchestrationLayer.engine.getTask(alias)) {
+                orchestrationLayer.engine.registerTask(alias, subagentType, description, []);
+              }
               const targetField = output.args?.prompt ? "prompt" : "description";
               if (output.args?.[targetField] && typeof output.args[targetField] === "string") {
                 output.args[targetField] = stripExistingContracts(output.args[targetField]);
@@ -3677,8 +4280,31 @@ var CoHubPlugin = async (input, options) => {
                   constraints: []
                 });
               }
+              const lr = orchestrationLayer.engine.applyLifecycleEvent(alias, "running");
+              if (!lr.ok) {
+                appendLog("orchestration", `before: applyLifecycleEvent(running) ${lr.reason} for ${alias}（状态来自实际原生生命周期，未接线 DAG 依赖不强制推进）`);
+                taskDiag({
+                  t: "task",
+                  callID: input.callID,
+                  session: input.sessionID?.slice(0, 20),
+                  alias,
+                  event: "state_changed",
+                  status: orchestrationLayer.engine.getState(alias) ?? "pending",
+                  lastActivityAt: Date.now()
+                });
+              } else {
+                taskDiag({
+                  t: "task",
+                  callID: input.callID,
+                  session: input.sessionID?.slice(0, 20),
+                  alias,
+                  event: "task_started",
+                  status: "running",
+                  lastActivityAt: Date.now()
+                });
+              }
             } catch (e) {
-              appendLog("orchestration", "registerTask error", e);
+              appendSafeLog("orchestration", "registerTask error", e);
             }
           }
           if (subagentType) {
@@ -3731,119 +4357,238 @@ var CoHubPlugin = async (input, options) => {
         if (input.tool === "cancel_task") {
           const args = input.args;
           const taskId = args?.task_id;
-          if (typeof taskId === "string")
-            tracker.markCancelled(taskId);
+          if (typeof taskId === "string") {
+            const aborted = tracker.abortJob(taskId);
+            if (aborted && orchestrationLayer) {
+              orchestrationLayer.engine.applyLifecycleEvent(aborted.job.alias, "cancelled");
+              taskDiag({
+                t: "task",
+                session: input.sessionID?.slice(0, 20),
+                alias: aborted.job.alias,
+                event: "task_cancelled",
+                status: "cancelled",
+                lastActivityAt: Date.now()
+              });
+            }
+          }
           syncTrackerState(input.sessionID ?? "");
         }
         if (input.tool === "task") {
           const childSessionId = extractChildSessionId(output);
-          tracker.updateAfterTask(input.sessionID, "completed", childSessionId);
+          const job0 = tracker.getJobByCall(input.sessionID, input.callID);
+          if (!job0) {
+            appendSafeLog("tool.execute.after", `after 未知 callID，no-op (parent=${input.sessionID?.slice(0, 20)})`);
+            syncTrackerState(input.sessionID ?? "");
+            return;
+          }
+          if (output === undefined || output === null) {
+            appendSafeLog("tool.execute.after", `after 无有效输出，不假成功 (parent=${input.sessionID?.slice(0, 20)})`);
+            syncTrackerState(input.sessionID ?? "");
+            return;
+          }
+          const meta = output?.metadata;
+          const metaBg = meta && typeof meta === "object" ? meta.background : undefined;
+          if (metaBg === true && !job0.background) {
+            tracker.setBackgroundByCall(input.sessionID, input.callID, true);
+          }
+          const outcome = classifyTaskAfter(output);
+          if (outcome.status === "cancelled" || outcome.status === "errored") {
+            const term = outcome.status === "cancelled" ? "cancelled" : "errored";
+            const up = tracker.finalizeByCall(input.sessionID, input.callID, (childSessionId ?? job0.sessionId) || undefined, term);
+            syncTrackerState(input.sessionID ?? "");
+            if (up.ok && up.alias && orchestrationLayer) {
+              orchestrationLayer.engine.applyLifecycleEvent(up.alias, term === "cancelled" ? "cancelled" : "failed");
+            }
+            taskDiag({
+              t: "task",
+              callID: input.callID,
+              session: input.sessionID?.slice(0, 20),
+              alias: up.ok ? up.alias : job0.alias,
+              event: term === "cancelled" ? "task_cancelled" : "task_failed",
+              status: term === "cancelled" ? "cancelled" : "failed",
+              durationMs: Date.now() - job0.createdAt,
+              lastActivityAt: Date.now()
+            });
+            return;
+          }
+          const up = tracker.updateAfterTaskByCall(input.sessionID, input.callID, "completed", childSessionId);
           syncTrackerState(input.sessionID ?? "");
-          if (orchestrationLayer && input.tool === "task") {
+          if (up.ok && orchestrationLayer) {
             try {
-              if (typeof output === "string") {
-                const contract = orchestrationLayer.contractMgr.extract(output);
-                if (contract) {
-                  orchestrationLayer.engine.setResult(_lastAlias, contract.keyResult, contract);
+              if (!job0.background) {
+                const lr = orchestrationLayer.engine.applyLifecycleEvent(job0.alias, "completed");
+                if (!lr.ok)
+                  appendLog("orchestration", `after: applyLifecycleEvent(completed) ${lr.reason} for ${job0.alias}`);
+                const text = typeof output === "string" ? output : typeof output?.output === "string" ? output.output : "";
+                if (text) {
+                  const contract = orchestrationLayer.contractMgr.extract(text);
+                  if (contract)
+                    orchestrationLayer.engine.setResult(job0.alias, contract.keyResult, contract);
                 }
+                taskDiag({
+                  t: "task",
+                  callID: input.callID,
+                  session: input.sessionID?.slice(0, 20),
+                  alias: job0.alias,
+                  event: "task_completed",
+                  status: "completed",
+                  durationMs: Date.now() - job0.createdAt,
+                  lastActivityAt: Date.now()
+                });
+              } else {
+                taskDiag({
+                  t: "task",
+                  callID: input.callID,
+                  session: input.sessionID?.slice(0, 20),
+                  alias: job0.alias,
+                  event: "state_changed",
+                  status: "running",
+                  lastActivityAt: Date.now()
+                });
+                await reconcileJobTerminal(job0);
               }
-              orchestrationLayer.scheduler.markCompleted(_lastAlias);
             } catch (e) {
-              appendLog("orchestration", "afterTask error", e);
+              appendSafeLog("orchestration", "afterTask engine 同步失败", e);
             }
           }
         }
       } catch (err) {
-        appendLog("tool.execute.after", "hook 失败", err);
+        appendSafeLog("tool.execute.after", "hook 失败", err);
       }
     },
     event: async (input) => {
       try {
         const e = input.event;
-        const sessionId = extractSessionIdFromEvent(e.properties);
-        if (!sessionId)
-          return;
+        const props = e.properties;
+        const sessionId = extractSessionIdFromEvent(props);
         if (e.type === "session.idle") {
-          tracker.updateByChildSessionId(sessionId, "completed");
+          if (!sessionId)
+            return;
+          const active = tracker.findActiveByChildSessionId(sessionId);
           syncTrackerState(tracker.currentParentSessionId);
-          if (orchestrationLayer) {
-            try {
-              const job = tracker.getJobBySessionId(sessionId);
-              if (job) {
-                orchestrationLayer.engine.transition(job.alias, "completed");
-                orchestrationLayer.scheduler.markCompleted(job.alias);
-              }
-            } catch (e) {
-              appendLog("orchestration", "session.idle transition error", e);
-            }
-          }
-          const job = tracker.getJobBySessionId(sessionId);
-          if (job) {
-            contextEngine.captureResult(sessionId, job.alias, job.agent).then((captured) => {
-              if (!captured)
-                return;
-              if (!isQualityEnabled(userConfig.quality))
-                return;
-              const quality = assessQuality({
-                output: captured.output,
-                decisions: captured.decisions,
-                latencyMs: Date.now() - job.createdAt,
-                tokens: captured.tokens
-              });
-              tracker.updateQuality(sessionId, {
-                score: quality.score,
-                ...quality.failureCategory ? { failureCategory: quality.failureCategory } : {},
-                ...quality.latencyMs !== undefined ? { latencyMs: quality.latencyMs } : {},
-                ...quality.tokens ? { tokens: quality.tokens } : {}
-              });
-              syncTrackerState(tracker.currentParentSessionId);
-            }).catch((err) => appendLog("event", "质量回送失败", err));
+          if (!active.ok) {
+            appendSafeLog("event", `session.idle ${active.reason} 不操作 (session=${sessionId.slice(0, 20)})`);
+            return;
           }
+          const job = active.job;
+          await reconcileJobTerminal(job);
+          const qAlias = job.alias;
+          const qParent = job.parentSessionId;
+          const qCall = job.callID;
+          const qChild = sessionId;
+          const qCreatedAt = job.createdAt;
+          contextEngine.captureResult(sessionId, qAlias, job.agent).then((captured) => {
+            if (!captured)
+              return;
+            if (!isQualityEnabled(userConfig.quality))
+              return;
+            const now = qCall ? tracker.getJobByCall(qParent, qCall) : tracker.getJobBySessionId(qChild);
+            if (!now || now.alias !== qAlias || now.sessionId !== qChild) {
+              appendSafeLog("event", "质量回送竞态：候选已变更，不写回复用/新调用");
+              return;
+            }
+            const quality = assessQuality({
+              output: captured.output,
+              decisions: captured.decisions,
+              latencyMs: Date.now() - qCreatedAt,
+              tokens: captured.tokens
+            });
+            tracker.updateQualityByAlias(qAlias, {
+              score: quality.score,
+              ...quality.failureCategory ? { failureCategory: quality.failureCategory } : {},
+              ...quality.latencyMs !== undefined ? { latencyMs: quality.latencyMs } : {},
+              ...quality.tokens ? { tokens: quality.tokens } : {}
+            });
+            syncTrackerState(tracker.currentParentSessionId);
+          }).catch((err) => appendSafeLog("event", "质量回送失败", err));
         } else if (e.type === "session.deleted") {
-          tracker.updateByChildSessionId(sessionId, "errored");
+          if (!sessionId)
+            return;
+          const active = tracker.findActiveByChildSessionId(sessionId);
+          const up = active.ok && active.job.callID ? tracker.finalizeByCall(active.job.parentSessionId, active.job.callID, sessionId, "errored") : tracker.updateByChildSessionId(sessionId, "errored");
           syncTrackerState(tracker.currentParentSessionId);
-          if (orchestrationLayer) {
-            try {
-              const job = tracker.getJobBySessionId(sessionId);
-              if (job) {
-                orchestrationLayer.engine.transition(job.alias, "failed");
-                orchestrationLayer.scheduler.markFailed(job.alias);
-                const task = orchestrationLayer.engine.getTask(job.alias);
-                if (task) {
-                  const decision = orchestrationLayer.retryMgr.decide(task, "session deleted");
-                  if (decision === "retry") {
-                    orchestrationLayer.engine.transition(job.alias, "pending");
-                  }
-                }
-              }
-            } catch (e) {
-              appendLog("orchestration", "session.deleted transition error", e);
-            }
+          if (up.ok && up.alias && orchestrationLayer) {
+            orchestrationLayer.engine.applyLifecycleEvent(up.alias, "failed");
           }
-        } else if (e.type === "session.error") {
-          tracker.updateByChildSessionId(sessionId, "errored");
+          taskDiag({
+            t: "task",
+            session: sessionId.slice(0, 20),
+            alias: up.alias,
+            event: "task_failed",
+            status: "failed",
+            lastActivityAt: Date.now()
+          });
+        } else if (e.type === "message.part.updated") {
+          const part = props?.part;
+          if (!part || part.type !== "tool" || part.tool !== "task")
+            return;
+          const pstate = part.state;
+          const pstatus = pstate?.status;
+          if (pstatus !== "error" && pstatus !== "cancelled")
+            return;
+          const parentSessionID = typeof part.sessionID === "string" ? part.sessionID : undefined;
+          if (!parentSessionID)
+            return;
+          const partCallID = typeof part.callID === "string" ? part.callID : undefined;
+          const partID = typeof part.id === "string" ? part.id : undefined;
+          const byCall = partCallID ? tracker.getJobByCall(parentSessionID, partCallID) : undefined;
+          const byId = partID ? tracker.getJobByCall(parentSessionID, partID) : undefined;
+          if (byCall && byId && byCall.alias !== byId.alias)
+            return;
+          const job = byCall ?? byId;
+          if (!job || job.status !== "running")
+            return;
+          const term = pstatus === "cancelled" ? "cancelled" : "errored";
+          const up = tracker.finalizeByCall(parentSessionID, job.callID, job.sessionId || undefined, term);
           syncTrackerState(tracker.currentParentSessionId);
-          if (orchestrationLayer) {
-            try {
-              const job = tracker.getJobBySessionId(sessionId);
-              if (job) {
-                orchestrationLayer.engine.transition(job.alias, "failed");
-                orchestrationLayer.scheduler.markFailed(job.alias);
-                const task = orchestrationLayer.engine.getTask(job.alias);
-                if (task) {
-                  const decision = orchestrationLayer.retryMgr.decide(task, "session error");
-                  if (decision === "retry") {
-                    orchestrationLayer.engine.transition(job.alias, "pending");
-                  }
-                }
-              }
-            } catch (e) {
-              appendLog("orchestration", "session.error transition error", e);
-            }
+          if (up.ok && up.alias && orchestrationLayer) {
+            orchestrationLayer.engine.applyLifecycleEvent(up.alias, term === "cancelled" ? "cancelled" : "failed");
+          }
+          taskDiag({
+            t: "task",
+            session: parentSessionID.slice(0, 20),
+            alias: up.ok ? up.alias : job.alias,
+            event: term === "cancelled" ? "task_cancelled" : "task_failed",
+            status: term === "cancelled" ? "cancelled" : "failed",
+            lastActivityAt: Date.now()
+          });
+        } else if (e.type === "session.status") {
+          if (!sessionId)
+            return;
+          const status = props?.status;
+          if (status?.type === "retry") {
+            taskDiag({
+              t: "task",
+              session: sessionId.slice(0, 20),
+              event: "retry_scheduled",
+              status: "running",
+              retryAttempt: typeof status.attempt === "number" ? status.attempt : undefined,
+              retryNextMs: typeof status.next === "number" ? status.next - Date.now() : undefined,
+              lastActivityAt: Date.now()
+            });
+            appendLog("event", `session.status retry 观测 (session=${sessionId.slice(0, 20)} attempt=${String(status.attempt)})`);
+          }
+        } else if (e.type === "session.error") {
+          if (!sessionId) {
+            appendSafeLog("event", "session.error 缺少 sessionID，不关联任何任务", props?.error);
+            return;
+          }
+          if (ctxDiag.enabled) {
+            const info = classifyRateLimit(props?.error);
+            taskDiag({
+              t: "task",
+              session: sessionId.slice(0, 20),
+              event: "rate_limit_detected",
+              status: "running",
+              rateLimitKind: info.kind,
+              retryAfterMs: info.retryAfterMs,
+              lastActivityAt: Date.now()
+            });
           }
+          appendSafeLog("event", `session.error 仅观测不终结 (session=${sessionId.slice(0, 20)})`, props?.error);
         }
       } catch (err) {
-        appendLog("event", "事件处理失败", err);
+        appendSafeLog("event", "事件处理失败", err);
       }
     },
     "experimental.chat.messages.transform": async (_input, output) => {