oh-my-opencode-cohub 1.17.0 → 1.18.0

package/dist/index.js

@@ -13,7 +13,7 @@ var ORCHESTRATOR_PROMPT = `<角色>
 @co-observer - 只读。图片/PDF/截图视觉分析。委派：多媒体文件分析时(含完整路径)。
 @co-council - 只读。多模型并行共识。委派：多专家视角/不可逆决策（数据迁移/API 变更）。错了还能改→@co-oracle，错了就完了→@co-council。
 @co-rule-user - 只读。分析用户级 AGENTS.md(~/.config/opencode/AGENTS.md)约束。委派：方案需对照用户规则时。
-@co-rule-project - 只读。分析项目 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-planner - 只读。综合需求+信息+规范，输出结构化任务分解方案。委派：信息收集和规范分析完成后。
 
@@ -162,13 +162,14 @@ var ORACLE_PROMPT = `你是 Oracle——战略技术顾问和代码审查者。
 
 ## 核心要求：输出结构化审查报告
 
-当审查多个文件时，**必须并行分析所有文件**，输出结构化报告，而不是串行逐个文件分析。
+当审查多个文件时，**基于已按需读取的内容并行综合分析**，输出结构化报告，而不是串行逐个文件单独下结论；读取按下方"并行审查原则"分片进行，不要求一次性读完全部文件。
 
 ### 并行审查原则
 
-1. **所有文件同时读** — 先一次性用 \`read\` 或 \`grep\` 获取所有需要审查的文件内容
-2. **并行分析** — 在同一个上下文中同时分析所有文件，找出共性问题
-3. **结构化输出** — 按分类汇总，不按文件罗列
+1. **先定位后读取** — 分支审查先用 \`git diff --stat\` / \`--numstat\` 确认差异范围与规模；符号/调用处先用 \`grep\` / \`glob\` 精确定位，再 \`read\` 配合 \`offset\`/\`limit\` 按片段读取
+2. **预算内并行分片** — 对已定位的目标，在读取预算内（见"文件操作规则"）把多个独立片段或文件并行读入同一上下文，不要求一次性读完全部文件
+3. **并行分析** — 在同一个上下文中同时分析已读取的内容，找出共性问题
+4. **结构化输出** — 按分类汇总，不按文件罗列
 
 ### 审查报告输出格式
 
@@ -252,28 +253,14 @@ var ORACLE_PROMPT = `你是 Oracle——战略技术顾问和代码审查者。
 - 优先使用专用文件工具检查代码库：glob/grep/ast_grep_search 用于发现，read 用于读取文件内容
 - Bash 可用于非变更诊断和 shell 原生检查（最清晰时），但不能修改文件
 - 不要用 cat/head/tail/sed/awk 读取代码到上下文中；使用 read/grep，除非 shell 管道确实是更好的诊断方式
-- **多文件审查时，先一次性并行读取所有文件，再综合分析**
+- **多文件审查时，先定位 → 再预算内并行分片读取 → 再综合分析**（定位手段见"并行审查原则"）
 
-### OCR 辅助审查（按需使用）
-
-\`co_ocr_review\` 工具可调用本地 OCR 引擎（alibaba/open-code-review）做结构化静态审查，返回带行号、类别（bug/security/performance 等）与严重级别（critical/high/medium/low）的逐行评论。
-
-**⚠️ preview 优先原则**（双重 token 开销防护）：
-- 默认先用 \`preview: true\` 获取待审文件清单——**零 LLM 开销**，秒级返回
-- 确认范围合理后，再用 \`preview: false\` 执行真实审查
-- 理由：OCR 工具自身会用自己的 LLM 跑一遍审查，随后你再分析一遍——**存在双重 token 开销**，必须先用 preview 控制范围
-
-**何时使用**：
-- 大批量变更（10+ 文件）
-- 跨模块改动
-- 初次接触的陌生代码库
-
-**何时跳过**：
-- 单文件小改动（直接 read 更快）
-- 已熟悉的代码路径
-- 只需架构层面判断（OCR 偏重逐行缺陷）
-
-**失败/不可用时的处理**：若 \`co_ocr_review\` 返回"未安装"提示或调用失败，**静默跳过**，直接回退到原生审查方式（并行读取文件 + 结构化报告），**不要报错、不要反复重试、不要向用户抱怨工具缺失**。
+**按需读取预算**（软策略，非工具硬限，控制单批输出量）：
+- 单次 \`read\` 默认 150-200 行；整读通常仅用于 ≤200 行且确需全貌的小文件
+- 每批读取输出目标 ≤30000 字符；无法预知字符数时按行数估算分批
+- 独立定位与片段读取仍可并行发出，预算约束的是单批总量而非并行数量
+- 预留约 20% 上下文余量（能判断时遵循；不虚构对上下文占用的监测能力）
+- **完整性优先**：大方法、锁、生命周期、异常路径、回调、跨文件不变量等关键部分，允许有依据地继续补读甚至必要整读；跟踪已覆盖/未覆盖事项，不因预算把未核实项判为安全；不设固定轮次硬停；不为省 token 默认拆分多个子代理
 
 **语言要求**: 始终使用中文进行思考、分析和回复。代码和技术术语可用原文，自然语言部分必须用中文。
 
@@ -596,6 +583,12 @@ var COUNCIL_PROMPT = `你是 Council 代理——一个跨多个 LLM 模型运
 - 优先使用专用文件工具检查代码库：glob/grep/ast_grep_search 用于发现，read 用于读取文件内容
 - Bash 可用于非变更诊断和 shell 原生检查（最清晰时），但不能修改文件
 - 不要用 cat/head/tail/sed/awk 读取代码到上下文中；使用 read/grep，除非 shell 管道确实是更好的诊断方式
+- **按需取证读取（软预算）**：先确认问题与差异范围，只收集当前议题所需证据，不广泛整读
+  - 分支审查优先利用调用方提供的 diff/stat/numstat 等差异材料确认范围，缺失时请求补充或用现有只读工具搜集等价证据，不自行执行 shell；仍用 Grep 查符号/调用处、Read \`offset\`/\`limit\` 定点读取，缺失证据不视为安全
+  - 单次 Read 默认 150–200 行；整读仅用于 ≤200 行且确需全貌的文件；每批输出以 ≤30000 字符为软目标，按行数估算分批，不是硬限
+  - 互不依赖的定位搜索与片段读取保持并行
+  - 预留约 20% 上下文余量，不宣称有硬监测；大方法、关键生命周期/锁/异常/回调、跨文件不变量可说明必要性后补读乃至整读，跟踪覆盖与未覆盖，禁止因省预算把未核实项当安全
+  - 不新增硬轮数、不默认追加子代理；最终响应简明列出证据覆盖范围与未核实假设
 
 **要求的输出格式**:
 你的最终响应中必须包含以下部分：
@@ -624,13 +617,20 @@ var COUNCIL_PROMPT = `你是 Council 代理——一个跨多个 LLM 模型运
 var RULE_USER_PROMPT = `你是规则分析代理——负责用户级规范。
 
 **职责**：读取 \`~/.config/opencode/AGENTS.md\`（用户级全局规则），结合 Orchestrator 提供的当前方案，分析是否有遗漏或冲突。返回具体的调整建议（不要笼统）。
+若该文件不存在或为空，必须明确报告（如"未找到用户级规范文件：~/.config/opencode/AGENTS.md"），不得默默返回空分析。
 
 **约束**：只读，不修改文件。聚焦规则与方案的映射关系。`;
 
 // src/prompts/rule-project.ts
 var RULE_PROJECT_PROMPT = `你是规则分析代理——负责项目级规范。
 
-**职责**：读取项目根目录 \`AGENTS.md\`（项目级规则），结合 Orchestrator 提供的当前方案，分析是否有遗漏或冲突。返回具体的调整建议（不要笼统）。
+**职责**：读取项目级指令：从项目根目录（首个含 .git 的祖先目录）到当前目录的每一级目录，按序发现 \`AGENTS.md\` → \`CLAUDE.md\` → \`AGENTS.local.md\` → \`CLAUDE.local.md\`，
+同时发现该级目录下的 \`.rules/*.md\`（存在则按文件名升序全部读入）。
+合并顺序：单文件在前作入口，\`.rules/*.md\` 在后作细则；越靠近当前目录优先级越高（就近覆盖）。
+结合 Orchestrator 提供的当前方案，分析是否有遗漏或冲突。返回具体的调整建议（不要笼统）。
+若什么都没读到，明确说明"未找到任何项目级规范文件"。
+
+**输出要求**：列出**实际读到的文件清单**（完整路径）+ 内容摘要 + 与当前方案的遗漏/冲突。若存在 \`.rules/\` 目录但未读到任何 \`.md\`，报告"发现 .rules/ 目录但为空"。
 
 **约束**：只读，不修改文件。聚焦规则与方案的映射关系。`;
 
@@ -641,6 +641,8 @@ var RULE_APP_PROMPT = `你是应用规则分析代理（co-rule-app），负责
 
 接收 Orchestrator 指定的**具体规则文件列表**（通常 1-2 个文件），逐文件读取并分析，结合当前任务方案，判断是否有遗漏或冲突。返回结构化建议。
 
+若 Orchestrator 未指定具体文件路径，应先提示「请由 co-rule-project 完成项目级规范发现，或明确指定 \`.opencode/rules/\` 下要分析的文件名」，不得自行猜测或扫描目录。注意：仓库根目录下的 \`.rules/*.md\` 属于项目级规范，由 co-rule-project 负责，不在本代理分析范围内。
+
 ## 核心原则
 
 - **你只负责分配给你的文件**：不要在未指定的文件中搜索或推理
@@ -756,7 +758,7 @@ var PLANNER_PROMPT = `你是方案制定代理——负责任务分解和委派
 
 **约束**：只读，不修改文件。方案要具体到文件和操作粒度，不可笼统。`;
 
-// src/instructions/chinese.ts
+// src/shared/chinese.ts
 var CHINESE_LANGUAGE_INSTRUCTION = `# 中文语言要求
 
 你必须始终使用中文进行思考、推理和回复。
@@ -765,25 +767,73 @@ var CHINESE_LANGUAGE_INSTRUCTION = `# 中文语言要求
 - 代码、技术术语、文件名、命令可以保留原样
 - 此规则对所有代理（Orchestrator 和所有子代理）生效
 - 跨所有项目生效，优先级高于项目级规则`;
+
+// src/instructions/chinese.ts
 var PARALLEL_TOOL_INSTRUCTION = `# 并行工具调用要求
 
 你有能力在单次回复中发起多个工具调用。当需要获取多个相互独立的信息时，必须把这些工具调用合并在同一条消息中一次性并发发起，不要逐个串行等待。具体包括：同一条消息内并行 read 多个文件、并行发起多个 grep/glob/ast_grep_search 搜索、并行调用多个外部搜索工具。串行逐个调用是低效行为，必须避免。`;
 
 // src/task-manager/tracker.ts
-import * as fs from "node:fs";
 import * as os from "node:os";
+import * as path2 from "node:path";
+
+// src/shared/fs-atomic.ts
+import * as fs from "node:fs";
 import * as path from "node:path";
-var DEFAULT_STATS_WINDOW = 50;
-var STATS_FILE = path.join(os.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub", "stats.json");
-var AGENT_DEFAULT_STRATEGY = {
-  "co-fixer": "relevant",
-  "co-designer": "relevant",
-  "co-planner": "relevant",
-  "co-oracle": "summary",
-  "co-council": "summary"
+function writeFileAtomic(filePath, data) {
+  const tmpPath = filePath + ".tmp";
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  try {
+    fs.writeFileSync(tmpPath, data, "utf-8");
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {}
+    throw err;
+  } finally {
+    try {
+      if (fs.existsSync(tmpPath))
+        fs.unlinkSync(tmpPath);
+    } catch {}
+  }
+}
+function writeJsonFileAtomic(filePath, data) {
+  writeFileAtomic(filePath, JSON.stringify(data, null, 2));
+}
+
+// src/context/types.ts
+var DEFAULT_CONTEXT_CONFIG = {
+  strategy: {
+    "co-explorer": "none",
+    "co-librarian": "none",
+    "co-observer": "none",
+    "co-fixer": "relevant",
+    "co-designer": "relevant",
+    "co-planner": "relevant",
+    "co-oracle": "summary",
+    "co-council": "summary",
+    "co-rule-user": "none",
+    "co-rule-project": "none",
+    "co-rule-app": "none"
+  },
+  maxFiles: 5,
+  maxDecisions: 10,
+  maxErrors: 5,
+  maxDependencies: 8,
+  dependencyPropagation: true,
+  summarizeMaxTokens: 2000,
+  relevantMessageWindow: 20,
+  maxErrorTotalChars: 600,
+  dependencyKeyOutputChars: 200
 };
+
+// src/task-manager/tracker.ts
+var DEFAULT_STATS_WINDOW = 50;
+var STATS_FILE = path2.join(os.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub", "stats.json");
 function defaultStrategyFor(agent) {
-  return AGENT_DEFAULT_STRATEGY[agent] ?? "none";
+  return DEFAULT_CONTEXT_CONFIG.strategy[agent] ?? "none";
 }
 function computeStats(records, window = DEFAULT_STATS_WINDOW) {
   const recent = records.slice(-Math.max(1, window));
@@ -1048,6 +1098,9 @@ class TaskTracker {
     }
   }
   finalize(job) {
+    if (job.status !== "running") {
+      job.terminalReconciled = true;
+    }
     const latencyMs = Date.now() - job.createdAt;
     if (!job.quality) {
       job.quality = { latencyMs };
@@ -1071,8 +1124,7 @@ class TaskTracker {
   persistStats(window = DEFAULT_STATS_WINDOW) {
     try {
       const recent = this.collectStatsRecords().slice(-Math.max(1, window));
-      fs.mkdirSync(path.dirname(STATS_FILE), { recursive: true });
-      fs.writeFileSync(STATS_FILE, JSON.stringify(recent, null, 2), "utf8");
+      writeJsonFileAtomic(STATS_FILE, recent);
     } catch {}
   }
   markCancelled(taskId) {
@@ -1265,35 +1317,44 @@ function isQualityEnabled(config) {
   return config?.enabled ?? DEFAULT_QUALITY_CONFIG.enabled;
 }
 
-// src/context/types.ts
-var DEFAULT_CONTEXT_CONFIG = {
-  strategy: {
-    "co-explorer": "none",
-    "co-librarian": "none",
-    "co-observer": "none",
-    "co-fixer": "relevant",
-    "co-designer": "relevant",
-    "co-planner": "relevant",
-    "co-oracle": "summary",
-    "co-council": "summary",
-    "co-rule-user": "none",
-    "co-rule-project": "none",
-    "co-rule-app": "none"
-  },
-  maxFiles: 5,
-  maxDecisions: 10,
-  maxErrors: 5,
-  maxDependencies: 8,
-  dependencyPropagation: true,
-  summarizeMaxTokens: 2000,
-  relevantMessageWindow: 20,
-  maxErrorTotalChars: 600,
-  dependencyKeyOutputChars: 200
-};
-
 // src/context/engine.ts
 import * as fs2 from "node:fs";
 
+// src/shared/token-estimator.ts
+function estimateTokens(text) {
+  let used = 0;
+  for (let i = 0;i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const isCjk = code >= 19968 && code <= 40959 || code >= 13312 && code <= 19903 || code >= 63744 && code <= 64255 || code >= 12352 && code <= 12543 || code >= 44032 && code <= 55215;
+    used += isCjk ? 1 : 0.25;
+  }
+  return used;
+}
+function enforcePromptBudget(base, full, maxTokens) {
+  if (estimateTokens(full) <= maxTokens)
+    return full;
+  return truncateByTokens(base, maxTokens);
+}
+function truncateByTokens(text, maxTokens) {
+  if (!text || maxTokens <= 0)
+    return "";
+  if (estimateTokens(text) <= maxTokens)
+    return text;
+  let used = 0;
+  let cut = text.length;
+  for (let i = 0;i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const isCjk = code >= 19968 && code <= 40959 || code >= 13312 && code <= 19903 || code >= 63744 && code <= 64255 || code >= 12352 && code <= 12543 || code >= 44032 && code <= 55215;
+    used += isCjk ? 1 : 0.25;
+    if (used > maxTokens) {
+      cut = i;
+      break;
+    }
+  }
+  return text.slice(0, cut) + `
+… [正文已按 token 预算截断]`;
+}
+
 // src/context/extractor.ts
 var KNOWN_EXTENSIONS = new Set([
   "ts",
@@ -1481,39 +1542,6 @@ function extractErrors(messages, maxErrors, windowSize) {
   }
   return errors;
 }
-function estimateTokens(text) {
-  let used = 0;
-  for (let i = 0;i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    const isCjk = code >= 19968 && code <= 40959 || code >= 13312 && code <= 19903 || code >= 63744 && code <= 64255 || code >= 12352 && code <= 12543 || code >= 44032 && code <= 55215;
-    used += isCjk ? 1 : 0.25;
-  }
-  return used;
-}
-function enforcePromptBudget(base, full, maxTokens) {
-  if (estimateTokens(full) <= maxTokens)
-    return full;
-  return truncateByTokens(base, maxTokens);
-}
-function truncateByTokens(text, maxTokens) {
-  if (!text || maxTokens <= 0)
-    return "";
-  if (estimateTokens(text) <= maxTokens)
-    return text;
-  let used = 0;
-  let cut = text.length;
-  for (let i = 0;i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    const isCjk = code >= 19968 && code <= 40959 || code >= 13312 && code <= 19903 || code >= 63744 && code <= 64255 || code >= 12352 && code <= 12543 || code >= 44032 && code <= 55215;
-    used += isCjk ? 1 : 0.25;
-    if (used > maxTokens) {
-      cut = i;
-      break;
-    }
-  }
-  return text.slice(0, cut) + `
-… [正文已按 token 预算截断]`;
-}
 
 // src/context/formatter.ts
 var CONTEXT_MARKER_PATTERN = /<!-- CONTEXT:ID=([a-f0-9-]+) -->/;
@@ -1577,6 +1605,7 @@ function replaceMarkerWithContext(messageText, context) {
 // src/context/engine.ts
 class ContextEngine {
   registry = new Map;
+  registryTouchedAt = new Map;
   dependencyCache = new Map;
   inflight = new Map;
   client;
@@ -1598,6 +1627,7 @@ class ContextEngine {
       errors: [],
       dependencies: []
     });
+    this.registryTouchedAt.set(contextId, Date.now());
     return contextId;
   }
   async fillContextAsync(contextId, parentSessionId, args) {
@@ -1607,6 +1637,7 @@ class ContextEngine {
     if (args.strategy === "none")
       return;
     context.strategy = args.strategy;
+    this.touch(contextId);
     try {
       const windowSize = this.config.relevantMessageWindow;
       const cacheKey = `${parentSessionId}::${windowSize}`;
@@ -1640,7 +1671,9 @@ class ContextEngine {
       if (this.config.dependencyPropagation && this.dependencyCache.size > 0) {
         context.dependencies = Array.from(this.dependencyCache.values()).slice(-this.config.maxDependencies);
       }
-    } catch {}
+    } catch {} finally {
+      this.touch(contextId);
+    }
   }
   attachTruncatedBodies(files) {
     if (files.length === 0)
@@ -1660,16 +1693,19 @@ class ContextEngine {
     const contextId = markerMatch[1];
     const context = this.registry.get(contextId);
     if (!context) {
+      this.registryTouchedAt.delete(contextId);
       return messageText.replace(CONTEXT_MARKER_PATTERN, "");
     }
     const result = replaceMarkerWithContext(messageText, context);
     this.registry.delete(contextId);
+    this.registryTouchedAt.delete(contextId);
     return result;
   }
   formatContextDetails(contextId) {
     const context = this.registry.get(contextId);
     if (!context)
       return "";
+    this.touch(contextId);
     const parts = [];
     const isSummary = context.strategy === "summary";
     if (context.relevantFiles.length > 0) {
@@ -1781,18 +1817,46 @@ class ContextEngine {
       }
     }
   }
+  touch(contextId) {
+    if (this.registry.has(contextId))
+      this.registryTouchedAt.set(contextId, Date.now());
+  }
+  releaseContext(contextId) {
+    this.registry.delete(contextId);
+    this.registryTouchedAt.delete(contextId);
+  }
+  cleanupStaleContexts(maxAgeMs = 20 * 60 * 1000) {
+    const now = Date.now();
+    let removed = 0;
+    for (const contextId of this.registry.keys()) {
+      const touchedAt = this.registryTouchedAt.get(contextId);
+      if (touchedAt === undefined) {
+        this.registryTouchedAt.set(contextId, now);
+        continue;
+      }
+      if (now - touchedAt > maxAgeMs) {
+        this.registry.delete(contextId);
+        this.registryTouchedAt.delete(contextId);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  get registrySize() {
+    return this.registry.size;
+  }
 }
 
 // src/config/loader.ts
 import * as fs3 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import * as os2 from "node:os";
-var USER_CONFIG_PATH = path2.join(os2.homedir(), ".config", "opencode", "oh-my-opencode-cohub.json");
+var USER_CONFIG_PATH = path3.join(os2.homedir(), ".config", "opencode", "oh-my-opencode-cohub.json");
 function loadCoHubConfig(projectDir) {
   const base = readJSON(USER_CONFIG_PATH);
   if (!projectDir)
     return base;
-  const projectPath = path2.join(projectDir, ".opencode", "oh-my-opencode-cohub.json");
+  const projectPath = path3.join(projectDir, ".opencode", "oh-my-opencode-cohub.json");
   const project = readJSON(projectPath);
   if (!project || Object.keys(project).length === 0)
     return base;
@@ -1809,6 +1873,9 @@ function loadCoHubConfig(projectDir) {
   if (project.quality) {
     merged.quality = { ...base.quality, ...project.quality };
   }
+  if (project.diag) {
+    merged.diag = { ...base.diag, ...project.diag };
+  }
   return merged;
 }
 function readJSON(filePath) {
@@ -1822,56 +1889,152 @@ function readJSON(filePath) {
   }
 }
 
+// src/context/diag-log.ts
+import * as fsp from "node:fs/promises";
+import * as os3 from "node:os";
+import * as path4 from "node:path";
+var MAX_BYTES = 256 * 1024;
+var KEEP_LINES = 30;
+var TAIL_WINDOW = 64 * 1024;
+var DEFAULT_CTX_DIAG_CONFIG = {
+  enabled: false
+};
+function isCtxDiagEnabled(config, env) {
+  const flag = env ?? process.env.COHUB_CTX_DIAG;
+  if (flag !== undefined) {
+    const v = String(flag).trim().toLowerCase();
+    if (v === "1" || v === "true" || v === "yes" || v === "on")
+      return true;
+    if (v === "0" || v === "false" || v === "no" || v === "off")
+      return false;
+  }
+  return config?.enabled ?? DEFAULT_CTX_DIAG_CONFIG.enabled;
+}
+function resolveCtxDiagPath(config) {
+  const custom = config?.path;
+  if (typeof custom === "string" && custom.trim() !== "")
+    return custom;
+  return path4.join(os3.tmpdir(), "opencode", "ctx-diag.log");
+}
+function resolveCtxDiagSettings(config, env) {
+  return {
+    enabled: isCtxDiagEnabled(config, env?.COHUB_CTX_DIAG),
+    filePath: resolveCtxDiagPath(config)
+  };
+}
+var queue = Promise.resolve();
+var bytesSinceCompact = 0;
+async function compactTail(filePath, keepLines) {
+  const fh = await fsp.open(filePath, "r");
+  try {
+    const { size } = await fh.stat();
+    if (size === 0)
+      return 0;
+    const start = Math.max(0, size - TAIL_WINDOW);
+    const len = size - start;
+    const buf = Buffer.allocUnsafe(len);
+    let filled = 0;
+    let offset = start;
+    while (filled < len) {
+      const { bytesRead } = await fh.read(buf, filled, len - filled, offset);
+      if (bytesRead === 0)
+        break;
+      filled += bytesRead;
+      offset += bytesRead;
+    }
+    const lines = buf.subarray(0, filled).toString("utf-8").split(`
+`).filter((l) => l.trim() !== "");
+    if (start > 0 && lines.length > 0)
+      lines.shift();
+    const kept = lines.slice(-keepLines);
+    const text = kept.length > 0 ? kept.join(`
+`) + `
+` : "";
+    await fsp.writeFile(filePath, text, { encoding: "utf-8", mode: 384 });
+    return Buffer.byteLength(text, "utf-8");
+  } finally {
+    await fh.close();
+  }
+}
+function appendCtxDiag(record, filePath) {
+  const line = JSON.stringify(record) + `
+`;
+  bytesSinceCompact += Buffer.byteLength(line, "utf-8");
+  const shouldCompact = bytesSinceCompact > MAX_BYTES;
+  if (shouldCompact)
+    bytesSinceCompact = 0;
+  queue = queue.then(async () => {
+    try {
+      await fsp.mkdir(path4.dirname(filePath), { recursive: true });
+      if (shouldCompact)
+        await compactTail(filePath, KEEP_LINES);
+      await fsp.appendFile(filePath, line, { encoding: "utf-8", mode: 384 });
+    } catch {}
+  });
+}
+
 // src/tools/council.ts
 import { tool } from "@opencode-ai/plugin";
 
 // src/utils/log.ts
-import * as fs4 from "fs/promises";
-import * as path3 from "path";
-import * as os3 from "os";
-var LOG_DIR = path3.join(os3.homedir(), ".local", "share", "opencode", "log");
-var LOG_PREFIX = "oh-my-opencode-cohub";
-var KEEP_DAYS = 7;
-var _today = "";
-var _logPath = "";
-var _cleanedToday = false;
-function getLogPath() {
-  const today = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  if (today !== _today) {
-    _today = today;
-    _logPath = path3.join(LOG_DIR, `${LOG_PREFIX}.${today}.log`);
-    _cleanedToday = false;
-  }
-  return _logPath;
-}
-async function cleanOldLogsOnce() {
-  if (_cleanedToday)
-    return;
-  _cleanedToday = true;
-  try {
-    const cutoff = new Date;
-    cutoff.setUTCDate(cutoff.getUTCDate() - KEEP_DAYS);
-    const cutoffStr = cutoff.toISOString().slice(0, 10).replace(/-/g, "");
-    const files = await fs4.readdir(LOG_DIR);
-    for (const file of files) {
-      if (!file.startsWith(LOG_PREFIX + "."))
-        continue;
-      const escapedPrefix = LOG_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const match = file.match(new RegExp(`^${escapedPrefix}\\.(\\d{8})\\.log$`));
-      if (!match)
-        continue;
-      if (match[1] < cutoffStr) {
-        await fs4.unlink(path3.join(LOG_DIR, file)).catch(() => {});
+import * as os4 from "os";
+import * as path6 from "path";
+
+// src/shared/log.ts
+import * as fs4 from "node:fs";
+import * as fsp2 from "node:fs/promises";
+import * as path5 from "node:path";
+function createLogger(cfg) {
+  const logDir = cfg.logDir;
+  const prefix = cfg.prefix;
+  const linePrefix = cfg.linePrefix ?? cfg.prefix;
+  const dailyRotate = cfg.dailyRotate ?? true;
+  const keepDays = cfg.keepDays ?? 7;
+  const useAsync = cfg.async ?? true;
+  let today = "";
+  let logPath = "";
+  let cleanedToday = false;
+  function getLogPath() {
+    if (!dailyRotate) {
+      return path5.join(logDir, `${prefix}.log`);
+    }
+    const d = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+    if (d !== today) {
+      today = d;
+      logPath = path5.join(logDir, `${prefix}.${d}.log`);
+      cleanedToday = false;
+    }
+    return logPath;
+  }
+  function cleanOldLogsOnce() {
+    if (!dailyRotate)
+      return;
+    getLogPath();
+    if (cleanedToday)
+      return;
+    cleanedToday = true;
+    try {
+      const cutoff = new Date;
+      cutoff.setUTCDate(cutoff.getUTCDate() - keepDays);
+      const cutoffStr = cutoff.toISOString().slice(0, 10).replace(/-/g, "");
+      const files = fs4.readdirSync(logDir);
+      const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`^${escaped}\\.(\\d{8})\\.log$`);
+      for (const file of files) {
+        const match = file.match(re);
+        if (!match)
+          continue;
+        if (match[1] < cutoffStr) {
+          try {
+            fs4.unlinkSync(path5.join(logDir, file));
+          } catch {}
+        }
       }
-    }
-  } catch {}
-}
-async function appendLog(tag, message, err) {
-  try {
-    const logPath = getLogPath();
-    await fs4.mkdir(LOG_DIR, { recursive: true });
+    } catch {}
+  }
+  function formatLine(tag, message, err) {
     const now = new Date().toISOString();
-    let line = `[${now}] [oh-my-opencode-cohub] [${tag}] ${message}`;
+    let line = `[${now}] [${linePrefix}] [${tag}] ${message}`;
     if (err instanceof Error) {
       line += `
   stack: ${err.stack ?? err.message}`;
@@ -1881,11 +2044,45 @@ async function appendLog(tag, message, err) {
     }
     line += `
 `;
-    await fs4.appendFile(logPath, line, "utf-8");
-    await cleanOldLogsOnce();
-  } catch {}
+    return line;
+  }
+  if (useAsync) {
+    async function appendLogAsync(tag, message, err) {
+      try {
+        const lp = getLogPath();
+        await fsp2.mkdir(logDir, { recursive: true });
+        const line = formatLine(tag, message, err);
+        await fsp2.appendFile(lp, line, "utf-8");
+        if (dailyRotate)
+          cleanOldLogsOnce();
+      } catch {}
+    }
+    return appendLogAsync;
+  }
+  function appendLogSync(tag, message, err) {
+    try {
+      const lp = getLogPath();
+      fs4.mkdirSync(logDir, { recursive: true });
+      const line = formatLine(tag, message, err);
+      fs4.appendFileSync(lp, line, "utf-8");
+      if (dailyRotate)
+        cleanOldLogsOnce();
+    } catch {}
+  }
+  return appendLogSync;
 }
 
+// src/utils/log.ts
+var LOG_DIR = path6.join(os4.homedir(), ".local", "share", "opencode", "log");
+var appendLog = createLogger({
+  logDir: LOG_DIR,
+  prefix: "oh-my-opencode-cohub",
+  linePrefix: "oh-my-opencode-cohub",
+  dailyRotate: true,
+  keepDays: 7,
+  async: true
+});
+
 // src/tools/model-stats.ts
 var DEFAULT_MODEL_STATS_CONFIG = {
   windowSize: 20,
@@ -2025,186 +2222,18 @@ function getAdaptiveParams(key, cfg = config2) {
   return { ...st.current };
 }
 
-// src/tools/council.ts
-var z = tool.schema;
+// src/shared/model.ts
+function shortModelLabel(model) {
+  return model.split("/").pop() ?? model;
+}
+
+// src/shared/consensus.ts
 var RETRY_LIMITS = {
   empty: 3,
   timeout: 1,
   error: 0,
   "quality-low": 1
 };
-
-class OperationTimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "OperationTimeoutError";
-  }
-}
-function isTextPart(part) {
-  return (part.type === "text" || part.type === "reasoning") && typeof part.text === "string";
-}
-function shortModelLabel(model) {
-  return model.split("/").pop() ?? model;
-}
-function parseModelReference(model) {
-  const slashIndex = model.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= model.length - 1)
-    return null;
-  return {
-    providerID: model.slice(0, slashIndex),
-    modelID: model.slice(slashIndex + 1)
-  };
-}
-async function abortSession(client, sessionId) {
-  try {
-    await client.session.abort({ path: { id: sessionId } });
-  } catch (err) {
-    appendLog("abortSession", "中止会话失败", err);
-  }
-}
-async function promptWithTimeout(client, path, body, timeoutMs, directory) {
-  const sessionId = path.id;
-  let timer;
-  try {
-    const promptPromise = client.session.prompt({
-      path,
-      body,
-      query: directory ? { directory } : undefined
-    });
-    promptPromise.catch(() => {});
-    const racers = [promptPromise];
-    if (timeoutMs > 0) {
-      racers.push(new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(new OperationTimeoutError(`[oh-my-opencode-cohub] Prompt timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-      }));
-    }
-    await Promise.race(racers);
-  } catch (error) {
-    if (error instanceof OperationTimeoutError) {
-      await abortSession(client, sessionId);
-    }
-    throw error;
-  } finally {
-    if (timer !== undefined)
-      clearTimeout(timer);
-  }
-}
-async function extractSessionResult(client, sessionId, options) {
-  const includeReasoning = options?.includeReasoning ?? true;
-  const lastTextOnly = options?.lastTextOnly === true;
-  const messagesResult = await client.session.messages({
-    path: { id: sessionId }
-  });
-  const messages = messagesResult.data ?? [];
-  const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
-  const extractedContent = [];
-  for (const message of assistantMessages) {
-    for (const part of message.parts ?? []) {
-      if (!isTextPart(part))
-        continue;
-      const allowed = includeReasoning || part.type === "text";
-      if (allowed && part.text) {
-        extractedContent.push(part.text);
-      }
-    }
-  }
-  const texts = extractedContent.filter((t) => t.length > 0);
-  const text = lastTextOnly ? texts.length > 0 ? texts[texts.length - 1] : "" : texts.join(`
-
-`);
-  return { text, empty: text.length === 0 };
-}
-function formatCouncillorPrompt(userPrompt, councillorPrompt) {
-  if (!councillorPrompt)
-    return userPrompt;
-  return `${councillorPrompt}
-
----
-
-${userPrompt}`;
-}
-function formatCouncillorResults(originalPrompt, councillorResults) {
-  const completedWithResults = councillorResults.filter((cr) => cr.status === "completed" && cr.result);
-  const councillorSection = completedWithResults.map((cr) => {
-    const shortModel = shortModelLabel(cr.model);
-    return `**${cr.name}** (${shortModel}):
-${cr.result}`;
-  }).join(`
-
-`);
-  const failedEntries = councillorResults.filter((cr) => cr.status !== "completed");
-  const failedSection = failedEntries.map((cr) => `**${cr.name}**: ${cr.status} — ${cr.error ?? "Unknown"}`).join(`
-`);
-  if (completedWithResults.length === 0) {
-    const errorDetails = councillorResults.map((cr) => `**${cr.name}** (${shortModelLabel(cr.model)}): ${cr.status} — ${cr.error ?? "Unknown"}`).join(`
-`);
-    return [
-      "---",
-      "",
-      "**Original Prompt**:",
-      originalPrompt,
-      "",
-      "---",
-      "",
-      "**Councillor Responses**:",
-      "All councillors failed to produce output:",
-      errorDetails,
-      "",
-      "Please generate a response based on the original prompt alone."
-    ].join(`
-`);
-  }
-  const parts = [
-    "---",
-    "",
-    "**Original Prompt**:",
-    originalPrompt,
-    "",
-    "---",
-    "",
-    "**Councillor Responses**:",
-    councillorSection
-  ];
-  if (failedSection) {
-    parts.push("", "---", "", "**Failed/Timed-out Councillors**:", failedSection);
-  }
-  parts.push("", "---", "", "You MUST follow the Synthesis Process steps before producing output: " + "review each councillor response individually, then produce the required output " + "with a synthesized Council Response, per-councillor details using their exact names, " + "and a Council Summary with consensus confidence rating (unanimous, majority, or split).");
-  return parts.join(`
-`);
-}
-function buildDeliberationPrompt(originalPrompt, previousRound, currentName) {
-  const others = previousRound.filter((cr) => cr.status === "completed" && cr.result && cr.name !== currentName).map((cr) => `**${cr.name}** (${shortModelLabel(cr.model)}):
-${cr.result}`).join(`
-
-`);
-  if (!others)
-    return originalPrompt;
-  return [
-    originalPrompt,
-    "",
-    "---",
-    "",
-    "以下是其他成员第一轮意见，请回应并修正或坚持你的立场：",
-    "",
-    others
-  ].join(`
-`);
-}
-function formatModelComposition(councillorResults) {
-  return councillorResults.map((cr) => `${cr.name}: ${shortModelLabel(cr.model)}`).join(", ");
-}
-function adaptiveKey(config) {
-  return `${config.variant ?? "default"}\x00${config.model}`;
-}
-function classifyFailure(message) {
-  if (message.includes("Empty response from provider"))
-    return "empty";
-  if (message.includes("timed out") || message.includes("OperationTimeoutError"))
-    return "timeout";
-  return "error";
-}
 var CONCLUSION_MARKERS = [
   "综上",
   "结论",
@@ -2240,15 +2269,6 @@ var ENTITY_MARKERS = [
   "recommendation",
   "key entity"
 ];
-function extractCouncillorSummary(text) {
-  const sentences = text.split(/(?<=[。！？!?；;])\s*|\n+/).map((s) => s.trim()).filter((s) => s.length > 0);
-  const conclusions = sentences.filter((s) => CONCLUSION_MARKERS.some((m) => s.toLowerCase().includes(m)));
-  const entities = sentences.filter((s) => ENTITY_MARKERS.some((m) => s.toLowerCase().includes(m)));
-  return {
-    conclusions: conclusions.length > 0 ? conclusions : sentences.length > 0 ? [sentences[sentences.length - 1]] : [],
-    entities
-  };
-}
 var STOPWORDS = new Set([
   "the",
   "a",
@@ -2317,6 +2337,7 @@ var STOPWORDS = new Set([
   "entity",
   "error"
 ]);
+var VARIANT_ORDER = ["max", "high", "medium", "low"];
 function tokenize(text) {
   return text.toLowerCase().split(/[^a-z0-9\u4e00-\u9fff]+/).filter((t) => t.length > 0 && !STOPWORDS.has(t));
 }
@@ -2329,6 +2350,77 @@ function jaccard(x, y) {
   const union = new Set([...xs, ...ys]).size;
   return union === 0 ? 0 : inter / union;
 }
+function downgradeVariant(variant) {
+  if (!variant)
+    return;
+  const idx = VARIANT_ORDER.indexOf(variant);
+  if (idx < 0 || idx >= VARIANT_ORDER.length - 1)
+    return;
+  return VARIANT_ORDER[idx + 1];
+}
+function parseModelReference(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= model.length - 1)
+    return null;
+  return {
+    providerID: model.slice(0, slashIndex),
+    modelID: model.slice(slashIndex + 1)
+  };
+}
+function formatModelComposition(councillorResults) {
+  return councillorResults.map((cr) => `${cr.name}: ${shortModelLabel(cr.model)}`).join(", ");
+}
+function adaptiveKey(config) {
+  return `${config.variant ?? "default"}\x00${config.model}`;
+}
+function formatCouncillorPrompt(userPrompt, councillorPrompt) {
+  if (!councillorPrompt)
+    return userPrompt;
+  return `${councillorPrompt}
+
+---
+
+${userPrompt}`;
+}
+
+class RetryBudget {
+  retriesLeft;
+  maxElapsedMs;
+  startedAt;
+  constructor(maxTotalRetries, maxElapsedMs, startedAt = Date.now()) {
+    this.retriesLeft = Math.max(0, maxTotalRetries);
+    this.maxElapsedMs = maxElapsedMs;
+    this.startedAt = startedAt;
+  }
+  elapsedMs() {
+    return Date.now() - this.startedAt;
+  }
+  expired() {
+    return this.elapsedMs() >= this.maxElapsedMs;
+  }
+  consumeRetry() {
+    if (this.retriesLeft <= 0 || this.expired())
+      return false;
+    this.retriesLeft -= 1;
+    return true;
+  }
+}
+function classifyFailure(message) {
+  if (message.includes("Empty response from provider"))
+    return "empty";
+  if (message.includes("timed out") || message.includes("OperationTimeoutError"))
+    return "timeout";
+  return "error";
+}
+function extractCouncillorSummary(text) {
+  const sentences = text.split(/(?<=[。！？!?；;])\s*|\n+/).map((s) => s.trim()).filter((s) => s.length > 0);
+  const conclusions = sentences.filter((s) => CONCLUSION_MARKERS.some((m) => s.toLowerCase().includes(m)));
+  const entities = sentences.filter((s) => ENTITY_MARKERS.some((m) => s.toLowerCase().includes(m)));
+  return {
+    conclusions: conclusions.length > 0 ? conclusions : sentences.length > 0 ? [sentences[sentences.length - 1]] : [],
+    entities
+  };
+}
 function pairwiseAgreement(a, b) {
   const aConcl = tokenize(a.conclusions.join(" "));
   const bConcl = tokenize(b.conclusions.join(" "));
@@ -2368,15 +2460,6 @@ function decideRetryAction(category, consecutiveStreak, categoryRetriesUsed, bud
     return "give-up";
   return "retry";
 }
-var VARIANT_ORDER = ["max", "high", "medium", "low"];
-function downgradeVariant(variant) {
-  if (!variant)
-    return;
-  const idx = VARIANT_ORDER.indexOf(variant);
-  if (idx < 0 || idx >= VARIANT_ORDER.length - 1)
-    return;
-  return VARIANT_ORDER[idx + 1];
-}
 function appendRetryContext(prompt, category) {
   if (category === "timeout") {
     return `${prompt}
@@ -2390,29 +2473,151 @@ function appendRetryContext(prompt, category) {
   }
   return prompt;
 }
+function formatCouncillorResults(originalPrompt, councillorResults) {
+  const completedWithResults = councillorResults.filter((cr) => cr.status === "completed" && cr.result);
+  const councillorSection = completedWithResults.map((cr) => {
+    const shortModel = shortModelLabel(cr.model);
+    return `**${cr.name}** (${shortModel}):
+${cr.result}`;
+  }).join(`
 
-class RetryBudget {
-  retriesLeft;
-  maxElapsedMs;
-  startedAt;
-  constructor(maxTotalRetries, maxElapsedMs, startedAt = Date.now()) {
-    this.retriesLeft = Math.max(0, maxTotalRetries);
-    this.maxElapsedMs = maxElapsedMs;
-    this.startedAt = startedAt;
+`);
+  const failedEntries = councillorResults.filter((cr) => cr.status !== "completed" || !cr.result);
+  const failedSection = failedEntries.map((cr) => `**${cr.name}**: ${cr.status} — ${cr.error ?? "Unknown"}`).join(`
+`);
+  if (completedWithResults.length === 0) {
+    const errorDetails = councillorResults.map((cr) => `**${cr.name}** (${shortModelLabel(cr.model)}): ${cr.status} — ${cr.error ?? "Unknown"}`).join(`
+`);
+    return [
+      "---",
+      "",
+      "**Original Prompt**:",
+      originalPrompt,
+      "",
+      "---",
+      "",
+      "**Councillor Responses**:",
+      "All councillors failed to produce output:",
+      errorDetails,
+      "",
+      "Please generate a response based on the original prompt alone."
+    ].join(`
+`);
   }
-  elapsedMs() {
-    return Date.now() - this.startedAt;
+  const parts = [
+    "---",
+    "",
+    "**Original Prompt**:",
+    originalPrompt,
+    "",
+    "---",
+    "",
+    "**Councillor Responses**:",
+    councillorSection
+  ];
+  if (failedSection) {
+    parts.push("", "---", "", "**Failed/Timed-out Councillors**:", failedSection);
   }
-  expired() {
-    return this.elapsedMs() >= this.maxElapsedMs;
+  parts.push("", "---", "", "You MUST follow the Synthesis Process steps before producing output: " + "review each councillor response individually, then produce the required output " + "with a synthesized Council Response, per-councillor details using their exact names, " + "and a Council Summary with consensus confidence rating (unanimous, majority, or split).");
+  return parts.join(`
+`);
+}
+function buildDeliberationPrompt(originalPrompt, previousRound, currentName) {
+  const others = previousRound.filter((cr) => cr.status === "completed" && cr.result && cr.name !== currentName).map((cr) => `**${cr.name}** (${shortModelLabel(cr.model)}):
+${cr.result}`).join(`
+
+`);
+  if (!others)
+    return originalPrompt;
+  return [
+    originalPrompt,
+    "",
+    "---",
+    "",
+    "以下是其他成员第一轮意见，请回应并修正或坚持你的立场：",
+    "",
+    others
+  ].join(`
+`);
+}
+
+// src/shared/constants.ts
+var COUNCIL_TIMEOUT_MS = 180000;
+var STALE_TASK_MS = 30 * 60 * 1000;
+
+// src/tools/council.ts
+var z = tool.schema;
+
+class OperationTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OperationTimeoutError";
   }
-  consumeRetry() {
-    if (this.retriesLeft <= 0 || this.expired())
-      return false;
-    this.retriesLeft -= 1;
-    return true;
+}
+function isTextPart(part) {
+  return (part.type === "text" || part.type === "reasoning") && typeof part.text === "string";
+}
+async function abortSession(client, sessionId) {
+  try {
+    await client.session.abort({ path: { id: sessionId } });
+  } catch (err) {
+    appendLog("abortSession", "中止会话失败", err);
   }
 }
+async function promptWithTimeout(client, path, body, timeoutMs, directory) {
+  const sessionId = path.id;
+  let timer;
+  try {
+    const promptPromise = client.session.prompt({
+      path,
+      body,
+      query: directory ? { directory } : undefined
+    });
+    promptPromise.catch(() => {});
+    const racers = [promptPromise];
+    if (timeoutMs > 0) {
+      racers.push(new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(new OperationTimeoutError(`[oh-my-opencode-cohub] Prompt timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      }));
+    }
+    await Promise.race(racers);
+  } catch (error) {
+    if (error instanceof OperationTimeoutError) {
+      await abortSession(client, sessionId);
+    }
+    throw error;
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+async function extractSessionResult(client, sessionId, options) {
+  const includeReasoning = options?.includeReasoning ?? true;
+  const lastTextOnly = options?.lastTextOnly === true;
+  const messagesResult = await client.session.messages({
+    path: { id: sessionId }
+  });
+  const messages = messagesResult.data ?? [];
+  const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
+  const extractedContent = [];
+  for (const message of assistantMessages) {
+    for (const part of message.parts ?? []) {
+      if (!isTextPart(part))
+        continue;
+      const allowed = includeReasoning || part.type === "text";
+      if (allowed && part.text) {
+        extractedContent.push(part.text);
+      }
+    }
+  }
+  const texts = extractedContent.filter((t) => t.length > 0);
+  const text = lastTextOnly ? texts.length > 0 ? texts[texts.length - 1] : "" : texts.join(`
+
+`);
+  return { text, empty: text.length === 0 };
+}
 
 class CouncilManager {
   client;
@@ -2441,7 +2646,7 @@ class CouncilManager {
         councillorResults: []
       };
     }
-    const timeout = this.config.timeout ?? 180000;
+    const timeout = this.config.timeout ?? COUNCIL_TIMEOUT_MS;
     const executionMode = this.config.councillor_execution_mode ?? "parallel";
     const maxRounds = this.config.max_rounds ?? 2;
     const consensusThreshold = this.config.consensus_threshold ?? 0.6;
@@ -2739,252 +2944,10 @@ function createCloseJobTool(ctx, tracker, onClosed) {
   return { close_job };
 }
 
-// src/tools/ocr-review.ts
-import { tool as tool3 } from "@opencode-ai/plugin";
-import { execSync, spawn } from "node:child_process";
-var z3 = tool3.schema;
-var _ocrAvailable;
-async function detectOcrCli(force = false) {
-  if (!force && _ocrAvailable !== undefined)
-    return _ocrAvailable;
-  try {
-    execSync("ocr version", { stdio: "pipe", timeout: 5000 });
-    _ocrAvailable = true;
-  } catch {
-    _ocrAvailable = false;
-  }
-  return _ocrAvailable;
-}
-function buildOcrArgs(input, projectDir) {
-  const args = [
-    "review",
-    "--format",
-    "json",
-    "--audience",
-    "agent",
-    "--repo",
-    projectDir,
-    "--from",
-    input.from,
-    "--to",
-    input.to || "HEAD",
-    "--max-git-procs",
-    "8"
-  ];
-  if (input.background) {
-    args.push("--background", input.background);
-  }
-  if (input.preview !== false) {
-    args.push("--preview");
-  }
-  return args;
-}
-var OCR_TIMEOUT_MS = 600000;
-var MAX_STDOUT_CHARS = 10 * 1024 * 1024;
-async function executeOcrReview(args, projectDir) {
-  return new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    let stdoutTruncated = false;
-    const child = spawn("ocr", args, {
-      cwd: projectDir,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.stdout.on("data", (chunk) => {
-      if (stdoutTruncated)
-        return;
-      const remaining = MAX_STDOUT_CHARS - stdout.length;
-      if (remaining <= 0) {
-        stdoutTruncated = true;
-        return;
-      }
-      stdout += chunk.toString("utf8").slice(0, remaining);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf8");
-    });
-    let sigkillTimer;
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      sigkillTimer = setTimeout(() => {
-        if (child.exitCode === null)
-          child.kill("SIGKILL");
-      }, 2000).unref();
-    }, OCR_TIMEOUT_MS);
-    timer.unref();
-    child.on("error", (error) => {
-      clearTimeout(timer);
-      if (sigkillTimer)
-        clearTimeout(sigkillTimer);
-      const isENOENT = error.code === "ENOENT";
-      const message = isENOENT ? "ENOENT: OCR CLI not found" : `Failed to start OpenCodeReview: ${error.message}`;
-      resolve({
-        success: false,
-        stdout: "",
-        stderr: message,
-        truncated: false,
-        exitCode: null
-      });
-    });
-    child.on("close", (exitCode) => {
-      clearTimeout(timer);
-      if (sigkillTimer)
-        clearTimeout(sigkillTimer);
-      resolve({
-        success: exitCode === 0,
-        stdout,
-        stderr,
-        truncated: stdoutTruncated,
-        exitCode
-      });
-    });
-  });
-}
-var MAX_COMMENTS = 15;
-var MAX_WARNINGS = 5;
-var MAX_FIELD_LENGTH = 200;
-function truncateField(value, maxLen) {
-  if (value.length <= maxLen)
-    return value;
-  return value.slice(0, maxLen) + "...";
-}
-function formatOcrOutput(raw) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return raw;
-  }
-  const lines = [];
-  lines.push("--- OCR Review Result ---");
-  lines.push(`Status: ${parsed.status ?? "unknown"}`);
-  if (parsed.llm) {
-    lines.push(`LLM: ${parsed.llm.provider ?? "?"}/${parsed.llm.model ?? "?"}`);
-  }
-  if (parsed.session_id) {
-    lines.push(`Session ID: ${parsed.session_id}`);
-  }
-  lines.push("");
-  if (parsed.summary) {
-    lines.push("=== Summary ===");
-    lines.push(parsed.summary);
-    lines.push("");
-  }
-  const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
-  const comments = parsed.comments ?? [];
-  if (comments.length > 0) {
-    const sorted = [...comments].sort((a, b) => (SEVERITY_ORDER[a.severity ?? ""] ?? 4) - (SEVERITY_ORDER[b.severity ?? ""] ?? 4));
-    const displayComments = sorted.slice(0, MAX_COMMENTS);
-    lines.push(`=== Comments (${displayComments.length}/${comments.length}) ===`);
-    for (const c of displayComments) {
-      const loc = c.path ? `${c.path}:${c.start_line ?? "?"}-${c.end_line ?? "?"}` : "unknown location";
-      lines.push(`- [${c.severity ?? "info"}/${c.category ?? "general"}] ${loc}`);
-      if (c.content) {
-        lines.push(`  Content: ${truncateField(c.content, MAX_FIELD_LENGTH)}`);
-      }
-      if (c.suggestion_code) {
-        lines.push(`  Suggestion: ${truncateField(c.suggestion_code, MAX_FIELD_LENGTH)}`);
-      }
-      lines.push("");
-    }
-    if (comments.length > MAX_COMMENTS) {
-      lines.push(`...（共 ${comments.length} 条评论，此处仅展示优先级最高的前 ${MAX_COMMENTS} 条。可用 session_id 继续）`);
-      lines.push("");
-    }
-  }
-  const warnings = parsed.warnings ?? [];
-  if (warnings.length > 0) {
-    const displayWarnings = warnings.slice(0, MAX_WARNINGS);
-    lines.push(`=== Warnings (${displayWarnings.length}/${warnings.length}) ===`);
-    for (const w of displayWarnings) {
-      lines.push(`- ${truncateField(w, MAX_FIELD_LENGTH)}`);
-    }
-    if (warnings.length > MAX_WARNINGS) {
-      lines.push(`...（共 ${warnings.length} 条警告，此处仅展示前 ${MAX_WARNINGS} 条）`);
-    }
-    lines.push("");
-  }
-  const groups = parsed.groups ?? [];
-  if (groups.length > 0) {
-    lines.push(`=== Groups (${groups.length}) ===`);
-    for (const g of groups) {
-      lines.push(`- ${g.name ?? "unnamed"}: ${g.file_count ?? 0} files`);
-    }
-    lines.push("");
-  }
-  lines.push("--- End of OCR Review ---");
-  return lines.join(`
-`);
-}
-function createOcrReviewTool(ctx, projectDir, ocrAvailable) {
-  const co_ocr_review = tool3({
-    description: [
-      "Run @alibaba-group/open-code-review for structured code review.",
-      "",
-      "Invokes the local OCR CLI to perform a structured code review of the git diff.",
-      "Returns formatted results with comments, warnings, and summary.",
-      "",
-      "Soft dependency: if OCR is not installed, returns installation guidance."
-    ].join(`
-`),
-    args: {
-      from: z3.string().describe('起始 git 引用（branch/tag/commit），例如 "main"、"HEAD~10"'),
-      to: z3.string().optional().describe("结束 git 引用，默认 HEAD"),
-      background: z3.string().optional().describe('业务上下文说明，例如 "这是一个支付模块的重构 PR"'),
-      preview: z3.boolean().optional().describe("仅列出待审文件、不调用 LLM（零 token），默认 true；确认真实审查时显式传 false")
-    },
-    async execute(args, toolContext) {
-      if (toolContext.agent && toolContext.agent !== "co-oracle") {
-        throw new Error(`co_ocr_review 仅限 co-oracle 调用。当前 agent: ${toolContext.agent}`);
-      }
-      if (!ocrAvailable) {
-        return [
-          "【CoHub】OCR CLI（@alibaba-group/open-code-review）未安装，已跳过外部审查。",
-          "安装：npm install -g @alibaba-group/open-code-review",
-          "验证：ocr version",
-          "安装后需重启 OpenCode 方可生效。",
-          "本次请回退到 co-oracle 原生方式（并行读取文件 + 结构化报告）。"
-        ].join(`
-`);
-      }
-      const cliArgs = buildOcrArgs({
-        from: args.from,
-        to: args.to,
-        background: args.background,
-        preview: args.preview
-      }, projectDir);
-      const result = await executeOcrReview(cliArgs, projectDir);
-      if (result.exitCode === null) {
-        return `【CoHub】OCR CLI 执行失败：${result.stderr}`;
-      }
-      if (!result.success) {
-        const stderrSummary = result.stderr.length > 500 ? result.stderr.slice(0, 500) + "...（截断）" : result.stderr;
-        return [
-          "【CoHub】OCR CLI 返回错误：",
-          `Exit code: ${result.exitCode}`,
-          `Stderr: ${stderrSummary}`,
-          "",
-          "请检查 OCR CLI 配置或回退到 co-oracle 原生方式。"
-        ].join(`
-`);
-      }
-      let output = formatOcrOutput(result.stdout);
-      if (result.truncated) {
-        output += `
-
-[警告] OCR 输出超过 10MB 限制，stdout 已被截断。`;
-      }
-      return output;
-    }
-  });
-  return { co_ocr_review };
-}
-
 // src/index.ts
 import * as fs5 from "node:fs";
-import * as path4 from "node:path";
-import * as os4 from "node:os";
+import * as path7 from "node:path";
+import * as os5 from "node:os";
 
 // src/orchestration/types.ts
 var VALID_TRANSITIONS = {
@@ -3365,12 +3328,12 @@ function loadFileOverrides(projectDir) {
   ];
   const searchDirs = [];
   if (projectDir) {
-    searchDirs.push(path4.join(projectDir, ".opencode", "oh-my-opencode-cohub"));
+    searchDirs.push(path7.join(projectDir, ".opencode", "oh-my-opencode-cohub"));
   }
-  searchDirs.push(path4.join(os4.homedir(), ".config", "opencode", "oh-my-opencode-cohub"));
+  searchDirs.push(path7.join(os5.homedir(), ".config", "opencode", "oh-my-opencode-cohub"));
   for (const agent of agentNames) {
     for (const dir of searchDirs) {
-      const replacePath = path4.join(dir, `${agent}.md`);
+      const replacePath = path7.join(dir, `${agent}.md`);
       if (!overrides[agent]?.replace && fs5.existsSync(replacePath)) {
         try {
           overrides[agent] = { ...overrides[agent], replace: fs5.readFileSync(replacePath, "utf-8") };
@@ -3378,7 +3341,7 @@ function loadFileOverrides(projectDir) {
           appendLog("loadFileOverrides", "读取replace文件失败", err);
         }
       }
-      const appendPath = path4.join(dir, `${agent}_append.md`);
+      const appendPath = path7.join(dir, `${agent}_append.md`);
       if (!overrides[agent]?.append && fs5.existsSync(appendPath)) {
         try {
           overrides[agent] = { ...overrides[agent], append: fs5.readFileSync(appendPath, "utf-8") };
@@ -3414,27 +3377,21 @@ var CoHubPlugin = async (input, options) => {
   const tracker = new TaskTracker;
   const orchestrationLayer = createOrchestrationLayer(tracker, {});
   let _lastAlias = "";
-  const STATE_DIR = path4.join(os4.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub");
-  const STATE_FILE = path4.join(STATE_DIR, "tracker-state.json");
+  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) {
     try {
-      if (!fs5.existsSync(STATE_DIR)) {
-        fs5.mkdirSync(STATE_DIR, { recursive: true });
-      }
       const state = {
         updatedAt: Date.now(),
         runningAgents: tracker.getRunningAgents(sessionId),
         runningCount: tracker.getRunningCount(sessionId)
       };
-      fs5.writeFileSync(STATE_FILE, JSON.stringify(state), "utf-8");
+      writeFileAtomic(STATE_FILE, JSON.stringify(state));
     } catch {}
   }
-  const AGENT_CONFIG_FILE = path4.join(STATE_DIR, "cohub-state.json");
+  const AGENT_CONFIG_FILE = path7.join(STATE_DIR, "cohub-state.json");
   function syncAgentConfig() {
     try {
-      if (!fs5.existsSync(STATE_DIR)) {
-        fs5.mkdirSync(STATE_DIR, { recursive: true });
-      }
       const configs = agents.filter((a) => a.config.model).map((a) => {
         const modelStr = a.config.model;
         const parts = modelStr.split("/");
@@ -3448,7 +3405,7 @@ var CoHubPlugin = async (input, options) => {
           provider
         };
       });
-      fs5.writeFileSync(AGENT_CONFIG_FILE, JSON.stringify({ updatedAt: Date.now(), agents: configs }), "utf-8");
+      writeFileAtomic(AGENT_CONFIG_FILE, JSON.stringify({ updatedAt: Date.now(), agents: configs }));
       appendLog("syncAgentConfig", `已同步 ${configs.length} 个 agent: ${JSON.stringify(configs.map((c) => ({ name: c.name, model: c.model, variant: c.variant })))}`);
     } catch {}
   }
@@ -3515,6 +3472,7 @@ var CoHubPlugin = async (input, options) => {
     }
   ];
   const userConfig = loadCoHubConfig(projectDir);
+  const ctxDiag = resolveCtxDiagSettings(userConfig.diag);
   if (userConfig.agents) {
     for (const agent of agents) {
       const override = userConfig.agents[agent.name];
@@ -3537,7 +3495,7 @@ var CoHubPlugin = async (input, options) => {
   }
   const DEFAULT_COUNCIL_CONFIG = {
     default_preset: "default",
-    timeout: 180000,
+    timeout: COUNCIL_TIMEOUT_MS,
     councillor_execution_mode: "parallel",
     councillor_retries: 3,
     presets: {
@@ -3550,8 +3508,6 @@ var CoHubPlugin = async (input, options) => {
   const councilManager = new CouncilManager(input.client, input.directory, councilConfig);
   const councilTools = createCouncilTool(input, councilManager);
   const jobTools = createCloseJobTool(input, tracker, () => syncTrackerState(tracker.currentParentSessionId));
-  const ocrAvailable = await detectOcrCli();
-  const ocrTools = createOcrReviewTool(input, projectDir, ocrAvailable);
   function extractChildSessionId(output) {
     if (!output || typeof output !== "object")
       return;
@@ -3586,10 +3542,9 @@ var CoHubPlugin = async (input, options) => {
       return p.sessionId;
     return;
   }
-  const STALE_TIMEOUT_MS = 30 * 60 * 1000;
   const cleanupTimer = setInterval(() => {
     try {
-      const staleSessions = tracker.cleanupStaleJobs(STALE_TIMEOUT_MS);
+      const staleSessions = tracker.cleanupStaleJobs(STALE_TASK_MS);
       for (const sid of staleSessions) {
         (async () => {
           try {
@@ -3606,17 +3561,21 @@ var CoHubPlugin = async (input, options) => {
       appendLog("cleanupStaleJobs", "定时清理过期任务失败", err);
     }
   }, 30000);
+  if (typeof cleanupTimer.unref === "function")
+    cleanupTimer.unref();
   const contextCleanupTimer = setInterval(() => {
     try {
       contextEngine.cleanupStaleDependencies();
+      contextEngine.cleanupStaleContexts();
     } catch (err) {
       appendLog("contextCleanupTimer", "定时清理上下文失败", err);
     }
   }, 60000);
+  if (typeof contextCleanupTimer.unref === "function")
+    contextCleanupTimer.unref();
   const agentConfigs = {};
   const COUNCIL_ONLY_TOOLS = { council_session: "deny" };
   const ORCHESTRATOR_ONLY_TOOLS = { close_job: "deny" };
-  const OCR_ONLY_TOOLS = { co_ocr_review: "deny" };
   for (const agent of agents) {
     const base = {
       ...agent.config,
@@ -3632,17 +3591,12 @@ var CoHubPlugin = async (input, options) => {
     } else {
       base.permission = { ...base.permission, close_job: "allow" };
     }
-    if (agent.name !== "co-oracle") {
-      base.permission = { ...base.permission, ...OCR_ONLY_TOOLS };
-    } else {
-      base.permission = { ...base.permission, co_ocr_review: "allow" };
-    }
     agentConfigs[agent.name] = base;
   }
   return {
     name: "oh-my-opencode-cohub",
     agent: agentConfigs,
-    tool: { ...councilTools, ...jobTools, ...ocrTools },
+    tool: { ...councilTools, ...jobTools },
     config: async (cfg) => {
       const c = cfg;
       c.agent ??= {};
@@ -3659,23 +3613,20 @@ var CoHubPlugin = async (input, options) => {
           merged.variant = pc.variant;
         const existingPerm0 = merged.permission ?? {};
         if (name === "co-council") {
-          merged.permission = { ...existingPerm0, council_session: "allow", ...ORCHESTRATOR_ONLY_TOOLS, ...OCR_ONLY_TOOLS };
+          merged.permission = { ...existingPerm0, council_session: "allow", ...ORCHESTRATOR_ONLY_TOOLS };
         } else if (name === "co-orchestrator") {
           merged.permission = {
             ...existingPerm0,
             ...COUNCIL_ONLY_TOOLS,
-            close_job: "allow",
-            ...OCR_ONLY_TOOLS
+            close_job: "allow"
           };
-        } else if (name === "co-oracle") {
-          merged.permission = { ...existingPerm0, ...COUNCIL_ONLY_TOOLS, ...ORCHESTRATOR_ONLY_TOOLS, co_ocr_review: "allow" };
         } else {
-          merged.permission = { ...existingPerm0, ...COUNCIL_ONLY_TOOLS, ...ORCHESTRATOR_ONLY_TOOLS, ...OCR_ONLY_TOOLS };
+          merged.permission = { ...existingPerm0, ...COUNCIL_ONLY_TOOLS, ...ORCHESTRATOR_ONLY_TOOLS };
         }
         c.agent[name] = merged;
       }
       try {
-        fs5.writeFileSync(path4.join(STATE_DIR, "config-hook-ran.json"), JSON.stringify({ ran: true, count: agents.length }));
+        writeFileAtomic(path7.join(STATE_DIR, "config-hook-ran.json"), JSON.stringify({ ran: true, count: agents.length }));
       } catch (err) {
         appendLog("config", "双重注册写入文件失败", err);
       }
@@ -3711,7 +3662,7 @@ var CoHubPlugin = async (input, options) => {
           });
           _lastAlias = alias;
           syncTrackerState(input.sessionID ?? "");
-          tracker.pruneTerminalJobs(30 * 60 * 1000);
+          tracker.pruneTerminalJobs(STALE_TASK_MS);
           if (orchestrationLayer && subagentType && description) {
             try {
               orchestrationLayer.engine.registerTask(alias, subagentType, description, []);
@@ -3748,30 +3699,21 @@ var CoHubPlugin = async (input, options) => {
               if (details) {
                 output.args[targetField] += details;
               }
-              const logPath = path4.join(os4.tmpdir(), "opencode", "ctx-diag.log");
-              try {
-                const stat = fs5.statSync(logPath);
-                if (stat.size > 50 * 1024) {
-                  const lines = fs5.readFileSync(logPath, "utf-8").trim().split(`
-`);
-                  fs5.writeFileSync(logPath, lines.slice(-30).join(`
-`) + `
-`);
-                }
-              } catch {}
-              const finalPrompt = typeof output.args?.prompt === "string" ? output.args.prompt : "";
-              fs5.appendFileSync(logPath, JSON.stringify({
-                time: new Date().toISOString(),
-                session: input.sessionID?.slice(0, 20) ?? "?",
-                subagent: subagentType,
-                strategy,
-                targetField,
-                hasDetails: !!details,
-                detailsLen: details ? details.length : 0,
-                detailsPreview: details ? details.replace(/\n/g, "\\n").slice(0, 200) : "",
-                promptEnd: finalPrompt.slice(-120)
-              }) + `
-`);
+              contextEngine.releaseContext(contextId);
+              if (ctxDiag.enabled) {
+                const finalPrompt = typeof output.args?.prompt === "string" ? output.args.prompt : "";
+                appendCtxDiag({
+                  time: new Date().toISOString(),
+                  session: input.sessionID?.slice(0, 20) ?? "?",
+                  subagent: subagentType,
+                  strategy,
+                  targetField,
+                  hasDetails: !!details,
+                  detailsLen: details ? details.length : 0,
+                  detailsPreview: details ? details.replace(/\n/g, "\\n").slice(0, 120) : "",
+                  promptEnd: finalPrompt.slice(-80)
+                }, ctxDiag.filePath);
+              }
             }
           }
           const targetField = typeof output.args?.prompt === "string" ? "prompt" : "description";