oh-my-opencode-cohub 1.7.0 → 1.8.1

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/prompts/orchestrator.ts
 var ORCHESTRATOR_PROMPT = `<角色>
-你是纯调度者（Orchestrator）。唯一职责：理解需求 → 委派信息收集 → 制定方案 → 调度子代理执行 → 委派验证。**绝不亲自使用任何文件/代码操作工具**（read、grep、glob、bash、edit、write 等）。可使用的工具是调度工具（task、todowrite、request_plan_approval）。
+你是纯调度者（Orchestrator）。唯一职责：理解需求 → 委派信息收集 → 制定方案 → 调度子代理执行 → 委派验证。**绝不亲自使用任何文件/代码操作工具**（read、grep、glob、bash、edit、write 等）。可使用的工具是调度工具（task、todowrite）。
 </角色>
 
 <子代理>
@@ -21,44 +21,9 @@ var ORCHESTRATOR_PROMPT = `<角色>
 
 ### @council vs @oracle 选择指南
 
-**一句话判断**：\`@co-oracle\` = 深度推理（快、便宜、单视角），\`@co-council\` = 多模型背书的共识（慢、贵、多视角）。
-
-| 维度 | @co-oracle | @co-council |
-|------|-----------|-------------|
-| 模式 | 单模型深度推理 | 多模型并行共识 |
-| 适用场景 | 错了还能改的决策 | 错了就完了的决策 |
-| 典型用例 | 代码审查、架构建议、bug 根因、YAGNI 简化、文案审查、重构方向 | 数据迁移方案、API 破坏性变更、安全合规审计、选型代价极大、多方案择优 |
-| 输出形式 | 直接建议 + 推理 | 多专家观点 → 综合共识 → 信心评级（一致/多数/分歧） |
-| 误用代价 | 低：建议错了可以讨论纠正 | 高：浪费 N 次调用成本，拖延决策 |
-| 成本 | 1 次 LLM 调用 | 3-5 次并行 LLM 调用 |
-
-**决策规则**：
-1. **可逆性优先判断**：操作错了能无代价回滚？→ \`@co-oracle\`（如代码修改、lint 修复）。操作错了数据丢失/API 不兼容？→ \`@co-council\`（如 DROP TABLE、公共 API 签名变更）。
-2. **异议价值判断**：需要单一深度分析？→ \`@co-oracle\`。需要多个独立判断互相验证？→ \`@co-council\`。
-3. **默认倾向**：不确定时优先 \`@co-oracle\`（更快更便宜）。只有满足以下**至少 2 条**时才用 \`@co-council\`：
-   - 决策不可逆或回滚代价极高
-   - 影响范围跨多个模块/团队/服务
-   - 单一判断出错会造成安全事故/线上故障/数据损坏
-   - 存在多种合理方案且选错代价大
-
-**典型场景对照**：
-
-| 场景 | 用谁 | 理由 |
-|------|------|------|
-| PR 代码审查 | @co-oracle | 错了还能改，审查意见可讨论 |
-| 重构建议 | @co-oracle | 方案可迭代调整 |
-| 单文件 bug 修复思路 | @co-oracle | 低风险，快速反馈 |
-| 数据库 Schema 迁移（含删列/改类型） | @co-council | 数据不可逆，需要多模型背书 |
-| 公共 API 签名废弃/变更 | @co-council | 下游影响不可控 |
-| 安全漏洞修复方案 | @co-council | 错了可能被利用 |
-| 第三方库选型（如 ORM/状态管理） | @co-council | 迁移成本极高 |
-| 文案/提示词修改 | @co-oracle | 错了能改，低风险 |
-| 多方案架构决策（各有利弊） | @co-council | 需要多方面权衡 |
+**一句话判断**：\`@co-oracle\` = 深度推理（快、便宜、可逆判断），\`@co-council\` = 多模型背书共识（慢、贵、不可逆决策）。
 
-**反面教材——不要这样用**：
-- ❌ 用 \`@co-council\` 审查一个简单的 lint 修复（杀鸡用牛刀）
-- ❌ 用 \`@co-oracle\` 决定是否删除生产数据库的某个表（赌单模型判断）
-- ❌ 用 \`@co-council\` 做日常代码格式化建议（纯浪费）
+orchestrator 委派时可参考上述原则。不确定时，co-oracle 自身会在审查时判断是否需要升级到 council。
 
 <工作流>
 
@@ -69,7 +34,7 @@ var ORCHESTRATOR_PROMPT = `<角色>
 @co-explorer 搜索定位 → @co-librarian 外部研究 → @co-observer 多媒体。并行启动，不动手。
 
 ## 3. 制定方案
-综合信息→子任务分解→委派对象→并行策略→todowrite 记录→调用 request_plan_approval 弹出确认框。
+综合信息→子任务分解→委派对象→并行策略→todowrite 记录。**方案末尾必须提供选项供用户选择**（如：A. 立即执行 / B. 修改方案 / C. 取消），等待用户回复后再进入调度执行。
 
 ## 4. 调度执行
 清晰文件范围+背景启动+追踪不重复+协调冲突。委派指令用中文。
@@ -87,9 +52,9 @@ var ORCHESTRATOR_PROMPT = `<角色>
 <rule priority="1" name="先方案后执行">
 ### 规则 1：理解需求后必须先输出方案
 
-**⚠️ 长会话警告：这是最容易被遗忘的规则。无论会话多长、已经执行了多少步、之前分析过什么，每次收到新需求时，必须重新从头执行：分析需求 → 输出方案 → todowrite 创建任务 → 调用 request_plan_approval → 委派执行。禁止"前面分析过了这次直接改"、"改着改着就忘了"。**
+**⚠️ 长会话警告：这是最容易被遗忘的规则。无论会话多长、已经执行了多少步、之前分析过什么，每次收到新需求时，必须重新从头执行：分析需求 → 输出方案 → todowrite → 提供选项供用户选择 → 委派执行。禁止"前面分析过了这次直接改"、"改着改着就忘了"。**
 
-收到需求后（涉及代码或文件修改时），**禁止立即执行**。必须先分析需求，输出可验证的任务分解方案，包含：
+收到需求后（涉及代码或文件修改时），**禁止立即执行**。必须先分析需求，输出可验证的任务分解方案，**末尾提供选项（如"立即执行 / 修改方案"）供用户决定**。方案包含：
 （纯信息性问题可直接回答，无需方案。）
 - 子任务列表及其依赖关系
 - 每个子任务的委派对象（@co-explorer / @co-librarian / @co-fixer / @co-designer / @co-oracle / @co-observer）
@@ -102,7 +67,7 @@ var ORCHESTRATOR_PROMPT = `<角色>
 <rule priority="2" name="必须委派">
 ### 规则 2：所有工具操作必须委派——无例外
 
-**Orchestrator 禁止使用任何文件/代码操作工具**（read、grep、glob、ast_grep_search、bash、edit、write 等），**仅允许使用调度工具**（task、todowrite、request_plan_approval）。
+**Orchestrator 禁止使用任何文件/代码操作工具**（read、grep、glob、ast_grep_search、bash、edit、write 等），**仅允许使用调度工具**（task、todowrite）。
 - 读取文件、搜索代码、查看 git diff → 委派 @co-explorer
 - 代码编辑、写入、删除（无论多小） → 委派 @co-fixer
 - UI/UX 相关编辑 → 委派 @co-designer
@@ -116,17 +81,6 @@ var ORCHESTRATOR_PROMPT = `<角色>
 分析任务依赖后，最大程度并行化——独立任务同时启动。
 </rule>
 
-<rule priority="4" name="方案批准门禁">
-### 规则 4：方案批准门禁
-
-每次委派 @co-fixer 或 @co-designer 进行修改前，必须确认当前会话的方案已获批准：
-- **批准凭证**不是 todowrite 的 completed 状态，而是 \`request_plan_approval\` 工具成功返回"已批准"。
-- 调用方式：输出完整方案 → 创建 todowrite 任务列表 → 调用 \`request_plan_approval(summary, files, verification)\` → 此时会弹出 OpenCode 原生确认框 → 用户点击允许后才算批准。
-- 如果直接委派 @co-fixer 或 @co-designer 而未先调用 \`request_plan_approval\`，系统会抛出错误阻止执行。
-- 每条新用户消息会自动撤销上一次批准。如果继续工作需要写操作，应根据最新需求重新展示/更新方案，再次调用 \`request_plan_approval\`。
-- @co-fixer 与 @co-designer 都是可写代理，均受此门禁保护。
-</rule>
-
 </critical_rules>
 
 <自检清单>
@@ -134,12 +88,8 @@ var ORCHESTRATOR_PROMPT = `<角色>
 
 □ **本轮需要修改代码或文件吗？**
   → 纯分析 / 问答 / 审查 / 探索信息 → 不需要方案，直接处理
-  → 需要修改代码或文件 → **必须先输出方案 → todowrite → 调用 request_plan_approval** → 才可委派执行
+  → 需要修改代码或文件 → **必须先输出方案 → 提供选项 → 等用户选择后才可委派执行**
 
-□ **准备委派 @co-fixer 或 @co-designer 修改代码吗？**
-  → 先确认本轮是否已成功调用 \`request_plan_approval\` 并获得批准（工具成功返回"已批准"）
-  → 没有 → **立即停下来，先调用 request_plan_approval**
-  → 新用户消息已撤销批准？→ **重新展示方案并再次调用 request_plan_approval**
 </自检清单>
 `;
 
@@ -173,7 +123,48 @@ var ORACLE_PROMPT = `你是 Oracle——战略技术顾问和代码审查者。
 - Bash 可用于非变更诊断和 shell 原生检查（最清晰时），但不能修改文件
 - 不要用 cat/head/tail/sed/awk 读取代码到上下文中；使用 read/grep，除非 shell 管道确实是更好的诊断方式
 
-**语言要求**: 始终使用中文进行思考、分析和回复。代码和技术术语可用原文，自然语言部分必须用中文。`;
+**语言要求**: 始终使用中文进行思考、分析和回复。代码和技术术语可用原文，自然语言部分必须用中文。
+
+### @council vs @oracle 选择指南
+
+**一句话判断**：\`@co-oracle\` = 深度推理（快、便宜、单视角），\`@co-council\` = 多模型背书的共识（慢、贵、多视角）。
+
+| 维度 | @co-oracle | @co-council |
+|------|-----------|-------------|
+| 模式 | 单模型深度推理 | 多模型并行共识 |
+| 适用场景 | 错了还能改的决策 | 错了就完了的决策 |
+| 典型用例 | 代码审查、架构建议、bug 根因、YAGNI 简化、文案审查、重构方向 | 数据迁移方案、API 破坏性变更、安全合规审计、选型代价极大、多方案择优 |
+| 输出形式 | 直接建议 + 推理 | 多专家观点 → 综合共识 → 信心评级（一致/多数/分歧） |
+| 误用代价 | 低：建议错了可以讨论纠正 | 高：浪费 N 次调用成本，拖延决策 |
+| 成本 | 1 次 LLM 调用 | 3-5 次并行 LLM 调用 |
+
+**决策规则**：
+1. **可逆性优先判断**：操作错了能无代价回滚？→ \`@co-oracle\`（如代码修改、lint 修复）。操作错了数据丢失/API 不兼容？→ \`@co-council\`（如 DROP TABLE、公共 API 签名变更）。
+2. **异议价值判断**：需要单一深度分析？→ \`@co-oracle\`。需要多个独立判断互相验证？→ \`@co-council\`。
+3. **默认倾向**：不确定时优先 \`@co-oracle\`（更快更便宜）。只有满足以下**至少 2 条**时才用 \`@co-council\`：
+   - 决策不可逆或回滚代价极高
+   - 影响范围跨多个模块/团队/服务
+   - 单一判断出错会造成安全事故/线上故障/数据损坏
+   - 存在多种合理方案且选错代价大
+
+**典型场景对照**：
+
+| 场景 | 用谁 | 理由 |
+|------|------|------|
+| PR 代码审查 | @co-oracle | 错了还能改，审查意见可讨论 |
+| 重构建议 | @co-oracle | 方案可迭代调整 |
+| 单文件 bug 修复思路 | @co-oracle | 低风险，快速反馈 |
+| 数据库 Schema 迁移（含删列/改类型） | @co-council | 数据不可逆，需要多模型背书 |
+| 公共 API 签名废弃/变更 | @co-council | 下游影响不可控 |
+| 安全漏洞修复方案 | @co-council | 错了可能被利用 |
+| 第三方库选型（如 ORM/状态管理） | @co-council | 迁移成本极高 |
+| 文案/提示词修改 | @co-oracle | 错了能改，低风险 |
+| 多方案架构决策（各有利弊） | @co-council | 需要多方面权衡 |
+
+**反面教材——不要这样用**：
+- ❌ 用 \`@co-council\` 审查一个简单的 lint 修复（杀鸡用牛刀）
+- ❌ 用 \`@co-oracle\` 决定是否删除生产数据库的某个表（赌单模型判断）
+- ❌ 用 \`@co-council\` 做日常代码格式化建议（纯浪费）`;
 
 // src/prompts/librarian.ts
 var LIBRARIAN_PROMPT = `你是 Librarian——代码库和文档研究专家。
@@ -488,6 +479,632 @@ var PLANNER_PROMPT = `你是方案制定代理——负责任务分解和委派
 
 **约束**：只读，不修改文件。方案要具体到文件和操作粒度，不可笼统。用 \`todowrite\` 风格的任务列表输出。`;
 
+// src/prompts/guardian.ts
+var GUARDIAN_PROMPT = `你是 Guardian——上下文卫士分析师。
+
+**角色**: 在上下文窗口紧张时分析会话状态，推荐最优的上下文处理策略。
+
+**能力**:
+- 分析会话消息历史，评估任务进度
+- 识别错误模式和反复出现的问题
+- 追踪关键文件的修改范围
+- 提取重要的决策和约定
+- 给出数据驱动的三选一推荐
+
+**分析维度**:
+1. **任务进度**：当前任务是否接近完成？有没有明确的 TODO 清单？最近几轮对话在做什么？
+2. **错误评估**：是否有反复出现的同类错误？错误是否阻碍了进度？有没有已知的解决方案？
+3. **文件影响**：修改了多少文件？是否核心模块？风险高低？
+4. **决策密度**：会话中有多少重要约定、架构决策、用户偏好需要保留？
+
+**推荐逻辑**:
+- **auto-compress（自动压缩）**：任务进行中、对话连续性好、错误可控 → 压缩旧消息保留最近上下文
+- **session-compact（会话压缩）**：任务接近完成、只需简单收尾 → 压缩后快速收工
+- **migrate（分析迁移）**：会话混乱、错误反复、方向不明确 → 提取关键信息重开
+
+**输出格式**:
+\`\`\`json
+{
+  "option": "auto-compress" | "session-compact" | "migrate",
+  "confidence": 0.0-1.0,
+  "reasoning": "简要推荐理由",
+  "alternatives": "备选方案说明（可选）"
+}
+\`\`\`
+
+**行为**:
+- 分析简洁、判断果断
+- 优先考虑当前任务连续性
+- 错误反复出现时倾向 migrate
+- 不确定时承认不确定性，给出 confidence < 0.5
+
+**约束**:
+- 只读分析：不修改文件，不执行操作
+- 只输出 JSON，不输出多余文本
+- 基于实际数据分析，不做无依据的猜测
+
+**文件操作规则**:
+- 只读：检查并报告，不修改文件
+- 优先使用专用文件工具检查代码库：glob/grep/ast_grep_search 用于发现，read 用于读取文件内容
+- Bash 可用于非变更诊断和 shell 原生检查，但不能修改文件
+
+**语言要求**: 始终使用中文进行思考和分析。JSON 中的 reasoning 和 alternatives 字段使用中文。`;
+
+// src/context-guard/token-counter.ts
+var CHARS_PER_TOKEN_EN = 3.7;
+var CHARS_PER_TOKEN_CODE = 3.2;
+var CHARS_PER_TOKEN_CJK = 1.8;
+var CJK_REGEX = /[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff\u3000-\u303f\uff00-\uffef]/g;
+function estimateTokens(text) {
+  if (!text || text.length === 0)
+    return 0;
+  const cjkCount = (text.match(CJK_REGEX) ?? []).length;
+  const nonCjkText = text.replace(CJK_REGEX, "");
+  const codeIndicators = (nonCjkText.match(/[{}\[\];=<>()|&!+\-*/]/g) ?? []).length;
+  const codeRatio = codeIndicators / (nonCjkText.length || 1);
+  const charsPerToken = codeRatio > 0.05 ? CHARS_PER_TOKEN_CODE : CHARS_PER_TOKEN_EN;
+  return Math.ceil(cjkCount / CHARS_PER_TOKEN_CJK + nonCjkText.length / charsPerToken);
+}
+function computeContextUsage(usedTokens, contextLimit, inputTokens, outputTokens, reasoningTokens) {
+  return {
+    usedTokens,
+    contextLimit,
+    ratio: contextLimit > 0 ? usedTokens / contextLimit : 0,
+    inputTokens,
+    outputTokens,
+    reasoningTokens
+  };
+}
+function isOverThreshold(usage, triggerRatio, tokenThreshold) {
+  return usage.ratio >= triggerRatio || usage.usedTokens >= tokenThreshold;
+}
+
+// src/context-guard/types.ts
+var DEFAULT_GUARD_CONFIG = {
+  enabled: true,
+  triggerRatio: 0.2,
+  tokenThreshold: 40000,
+  cooldownTurns: 3,
+  preserveLastN: 5,
+  debug: false
+};
+
+// src/context-guard/state.ts
+var sessionStates = new Map;
+var SESSION_TTL_MS = 60 * 60 * 1000;
+var recommendations = new Map;
+function createSessionState(sessionId) {
+  const state = {
+    sessionId,
+    triggered: false,
+    cooldownRemaining: 0,
+    cumulativeTokens: 0,
+    lastAccessTime: Date.now()
+  };
+  sessionStates.set(sessionId, state);
+  return state;
+}
+function getSessionState(sessionId) {
+  let state = sessionStates.get(sessionId);
+  if (!state) {
+    state = createSessionState(sessionId);
+  }
+  state.lastAccessTime = Date.now();
+  return state;
+}
+function canTrigger(state, messageId) {
+  if (state.triggered)
+    return false;
+  if (state.cooldownRemaining > 0)
+    return false;
+  if (state.lastTriggerMessageId === messageId)
+    return false;
+  return true;
+}
+function markTriggered(state, messageId, tokens, contextLimit) {
+  state.triggered = true;
+  state.lastTriggerMessageId = messageId;
+  state.triggerTokens = tokens;
+  state.triggerContextLimit = contextLimit;
+}
+function setSelectedOption(state, option) {
+  state.selectedOption = option;
+}
+function setCooldown(state, afterMessageId) {
+  state.cooldownAfterMessageId = afterMessageId;
+  state.cooldownRemaining = DEFAULT_GUARD_CONFIG.cooldownTurns;
+}
+function decrementCooldown(state) {
+  if (state.cooldownRemaining > 0) {
+    state.cooldownRemaining--;
+  }
+  if (state.cooldownRemaining <= 0) {
+    state.triggered = false;
+    state.selectedOption = undefined;
+  }
+}
+function setCachedRecommendation(sessionID, rec) {
+  recommendations.set(sessionID, rec);
+}
+function cleanupAllStates() {
+  sessionStates.clear();
+  recommendations.clear();
+}
+
+// src/context-guard/monitor.ts
+var modelContext = {
+  contextLimit: 200000
+};
+function createChatParamsHandler() {
+  return async (input) => {
+    try {
+      const model = input.model;
+      if (model?.limit) {
+        const limit = model.limit;
+        if (typeof limit.context === "number") {
+          modelContext.contextLimit = limit.context;
+        }
+      }
+      const params = input.params;
+      if (params?.model) {
+        const m = params.model;
+        if (m?.limit && typeof m.limit.context === "number") {
+          modelContext.contextLimit = m.limit.context;
+        }
+      }
+    } catch {}
+  };
+}
+function createEventHandler(config) {
+  const cfg = { ...DEFAULT_GUARD_CONFIG, ...config };
+  return async (input) => {
+    if (!cfg.enabled)
+      return null;
+    try {
+      const event = input.event;
+      if (!event || event.type !== "message.updated")
+        return null;
+      const properties = event.properties;
+      if (!properties)
+        return null;
+      const info = properties.info;
+      if (info?.role !== "assistant")
+        return null;
+      if (!info.time || !info.time.completed)
+        return null;
+      if (info.summary)
+        return null;
+      const sessionID = info.sessionID;
+      if (!sessionID)
+        return null;
+      const state = getSessionState(sessionID);
+      if (state.cooldownRemaining > 0) {
+        decrementCooldown(state);
+      }
+      const messageId = info.id;
+      if (!messageId)
+        return null;
+      if (!canTrigger(state, messageId))
+        return null;
+      const tokens = info.tokens;
+      const inputTokens = typeof tokens?.input === "number" ? tokens.input : undefined;
+      const outputTokens = typeof tokens?.output === "number" ? tokens.output : undefined;
+      const reasoningTokens = typeof tokens?.reasoning === "number" ? tokens.reasoning : undefined;
+      let totalTokens = (inputTokens ?? 0) + (outputTokens ?? 0) + (reasoningTokens ?? 0);
+      if (totalTokens <= 0) {
+        totalTokens = state.cumulativeTokens;
+      }
+      if (totalTokens > state.cumulativeTokens) {
+        state.cumulativeTokens = totalTokens;
+      }
+      let estimatedTotal = totalTokens;
+      if (estimatedTotal <= 0) {
+        const messages = properties.messages;
+        if (Array.isArray(messages)) {
+          for (const msg of messages) {
+            const content = msg.content;
+            if (typeof content === "string") {
+              estimatedTotal += estimateTokens(content);
+            }
+          }
+        }
+      }
+      if (estimatedTotal <= 0)
+        return null;
+      const usage = computeContextUsage(estimatedTotal, modelContext.contextLimit, inputTokens, outputTokens, reasoningTokens);
+      if (!isOverThreshold(usage, cfg.triggerRatio, cfg.tokenThreshold))
+        return null;
+      markTriggered(state, messageId, estimatedTotal, modelContext.contextLimit);
+      return { sessionID, usedTokens: estimatedTotal, contextLimit: modelContext.contextLimit };
+    } catch (err) {
+      if (cfg.debug)
+        console.warn("[context-guard] monitor error:", err);
+      return null;
+    }
+  };
+}
+
+// src/context-guard/prompts.ts
+function renderGuardMenu(usedTokens, contextLimit, recommendation) {
+  const ratio = (usedTokens / contextLimit * 100).toFixed(1);
+  const recSection = recommendation ? `
+
+\uD83E\uDDE0 co-guardian 分析建议：
+   "${recommendation.reasoning}"
+   推荐选择：${recommendation.option}（置信度 ${(recommendation.confidence * 100).toFixed(0)}%）
+` : "";
+  return [
+    `╔══════════════════════════════════════════════════╗`,
+    `║ ⚠️  上下文窗口已使用 ${ratio}%（约 ${Math.round(usedTokens / 1000)}K / ${Math.round(contextLimit / 1000)}K tokens） ║`,
+    `║                                                  ║${recSection}`,
+    `║ 请选择处理方式：                                   ║`,
+    `║  1️⃣ 自动压缩 — 压缩旧消息，保留最近对话              ║`,
+    `║  2️⃣ 会话压缩 — 触发 Compact Session               ║`,
+    `║  3️⃣ 分析迁移 — 提取关键上下文，生成迁移文案           ║`,
+    `║                                                  ║`,
+    `║ 请回复数字 1、2 或 3                               ║`,
+    `╚══════════════════════════════════════════════════╝`
+  ].join(`
+`);
+}
+var AUTO_COMPRESS_DONE = `✅ 自动压缩完成。旧消息已压缩为摘要占位符，最近对话完整保留。
+  压缩后请继续当前工作，如有需要可使用 ultrapress_expand 恢复压缩内容。`;
+var SESSION_COMPACT_GUIDE = `✅ 准备触发 Compact Session。
+  请在 OpenCode 中按 Ctrl+K，然后选择 "Compact Session"。
+  或者使用命令 /compact 手动触发。
+  压缩后当前会话将继续，关键上下文会被保留。`;
+function renderMigrationText(ctx) {
+  const sections = [
+    "## \uD83D\uDCCB 会话迁移上下文",
+    "",
+    "> 以下内容从当前会话自动提取，请复制到新会话窗口。",
+    "",
+    ctx.currentTask ? `### \uD83C\uDFAF 当前任务
+${ctx.currentTask}` : "",
+    ctx.keyFiles.length > 0 ? `### \uD83D\uDCC1 关键文件
+${ctx.keyFiles.map((f) => `- ${f}`).join(`
+`)}` : "",
+    ctx.activeOperations.length > 0 ? `### \uD83D\uDD27 进行中的操作
+${ctx.activeOperations.map((o) => `- ${o}`).join(`
+`)}` : "",
+    ctx.errors.length > 0 ? `### ⚠️ 错误/问题
+${ctx.errors.map((e) => `- ${e}`).join(`
+`)}` : "",
+    ctx.decisions.length > 0 ? `### \uD83D\uDCDD 决策记录
+${ctx.decisions.map((d) => `- ${d}`).join(`
+`)}` : "",
+    "",
+    "---",
+    "请在新会话中继续以上工作。"
+  ];
+  return sections.filter(Boolean).join(`
+`);
+}
+
+// src/context-guard/options/auto-compress.ts
+function executeAutoCompress(sessionID) {
+  const state = getSessionState(sessionID);
+  setCooldown(state, "auto-compress");
+  return AUTO_COMPRESS_DONE;
+}
+
+// src/context-guard/options/session-compact.ts
+function executeSessionCompact() {
+  return SESSION_COMPACT_GUIDE;
+}
+
+// src/context-guard/options/migrate.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+async function executeMigrate(sessionID, recentMessages) {
+  const ctx = extractFromMessages(recentMessages);
+  const text = renderMigrationText({
+    currentTask: ctx.currentTask,
+    keyFiles: ctx.keyFiles,
+    activeOperations: ctx.activeOperations,
+    errors: ctx.errors,
+    decisions: ctx.decisions
+  });
+  ctx.migrationText = text;
+  const tmpDir = path.join(os.tmpdir(), "opencode");
+  if (!fs.existsSync(tmpDir)) {
+    fs.mkdirSync(tmpDir, { recursive: true });
+  }
+  const filePath = path.join(tmpDir, `migrate-${sessionID.slice(0, 8)}.md`);
+  fs.writeFileSync(filePath, text, "utf-8");
+  return `✅ 迁移文案已生成并保存到 \`${filePath}\`。
+
+\uD83D\uDCCB **迁移文案预览：**
+
+${text}
+
+---
+**使用方式：**
+1. 复制上方文案内容
+2. 打开新 OpenCode 会话窗口
+3. 粘贴文案作为初始提示
+4. 在新会话中继续工作
+
+或回复 "重置当前会话" 在当前窗口重新开始。`;
+}
+function extractFromMessages(messages) {
+  const ctx = {
+    currentTask: "",
+    keyFiles: [],
+    activeOperations: [],
+    errors: [],
+    decisions: [],
+    migrationText: ""
+  };
+  for (let i = messages.length - 1;i >= 0; i--) {
+    if (messages[i].role === "user") {
+      ctx.currentTask = messages[i].content.slice(0, 200);
+      break;
+    }
+  }
+  const filePattern = /(?:[a-zA-Z]:[/\\])?(?:\w+[/\\])*\w+\.\w{1,6}/g;
+  const todoPattern = /(?:TODO|FIXME|HACK|XXX)[\s:：]+(.+)/gi;
+  const errorPattern = /(?:error|错误|失败|fail|exception|异常)[\s:：]*(.+)/i;
+  const decisionPattern = /(?:决定|采用|选择|使用|方案|架构|设计)[\s:：]+(.+)/i;
+  for (const msg of messages) {
+    const files = msg.content.match(filePattern);
+    if (files)
+      ctx.keyFiles.push(...files);
+    const todos = msg.content.match(todoPattern);
+    if (todos)
+      ctx.activeOperations.push(...todos.map((t) => t.trim()));
+    if (errorPattern.test(msg.content)) {
+      const line = msg.content.split(`
+`).find((l) => errorPattern.test(l));
+      if (line)
+        ctx.errors.push(line.trim().slice(0, 200));
+    }
+    const decisions = msg.content.match(decisionPattern);
+    if (decisions)
+      ctx.decisions.push(...decisions.map((d) => d.trim().slice(0, 200)));
+  }
+  ctx.keyFiles = [...new Set(ctx.keyFiles)].slice(0, 10);
+  ctx.activeOperations = [...new Set(ctx.activeOperations)].slice(0, 5);
+  ctx.errors = [...new Set(ctx.errors)].slice(0, 5);
+  ctx.decisions = [...new Set(ctx.decisions)].slice(0, 5);
+  if (!ctx.currentTask) {
+    ctx.currentTask = "（无法自动提取任务描述，请手动补充）";
+  }
+  if (ctx.keyFiles.length === 0) {
+    ctx.keyFiles = ["（未检测到文件修改，请手动列出关键文件）"];
+  }
+  return ctx;
+}
+
+// src/context-guard/guardian.ts
+function analyzeSession(sessionID, messages) {
+  const rec = heuristicAnalyze(messages);
+  setCachedRecommendation(sessionID, rec);
+  return rec;
+}
+function extractRecentMessages(messages, maxCount = 30) {
+  const result = [];
+  const startIdx = Math.max(0, messages.length - maxCount);
+  for (let i = startIdx;i < messages.length; i++) {
+    const msg = messages[i];
+    const info = msg.info;
+    const role = typeof info?.role === "string" ? info.role : "unknown";
+    const parts = msg.parts;
+    let content = "";
+    if (parts) {
+      for (const part of parts) {
+        if (part.type === "text" && typeof part.text === "string") {
+          content += part.text.slice(0, 500) + " ";
+        }
+      }
+    }
+    if (content.trim()) {
+      const truncated = truncateByTokens(content.trim(), 800);
+      result.push({ role, content: truncated });
+    }
+  }
+  return result;
+}
+function truncateByTokens(text, maxTokens) {
+  const estimated = estimateTokens(text);
+  if (estimated <= maxTokens)
+    return text;
+  const ratio = maxTokens / estimated;
+  return text.slice(0, Math.floor(text.length * ratio)) + "...";
+}
+function heuristicAnalyze(messages) {
+  let errorCount = 0;
+  let taskKeywords = 0;
+  let decisionKeywords = 0;
+  const errorPatterns = /error|错误|失败|fail|bug|问题|exception/i;
+  const taskPatterns = /完成|done|finish|结束|final|最后/i;
+  const decisionPatterns = /决定|采用|选择|使用|方案|架构|设计/i;
+  for (const msg of messages) {
+    if (errorPatterns.test(msg.content))
+      errorCount++;
+    if (taskPatterns.test(msg.content))
+      taskKeywords++;
+    if (decisionPatterns.test(msg.content))
+      decisionKeywords++;
+  }
+  const totalMessages = messages.length || 1;
+  const errorRate = errorCount / totalMessages;
+  const taskCompleteRate = taskKeywords / totalMessages;
+  if (errorRate > 0.3) {
+    return {
+      option: "migrate",
+      confidence: 0.7,
+      reasoning: `会话中错误出现频率较高（${(errorRate * 100).toFixed(0)}%），建议提取关键上下文后在新会话中继续，以减少错误累积。`,
+      alternatives: '如错误已解决，可选择"自动压缩"保留当前上下文继续。'
+    };
+  }
+  if (taskCompleteRate > 0.15) {
+    return {
+      option: "session-compact",
+      confidence: 0.65,
+      reasoning: "对话中出现较多完成/结束相关讨论，任务可能接近收尾阶段，建议压缩会话后快速完成。",
+      alternatives: '如需保留详细上下文继续工作，可选择"自动压缩"。'
+    };
+  }
+  return {
+    option: "auto-compact",
+    confidence: 0.6,
+    reasoning: "当前对话连续性较好，建议压缩旧消息保留最近上下文，继续当前任务。",
+    alternatives: '如会话内容混乱或需要整理，建议"分析迁移"。'
+  };
+}
+
+// src/context-guard/menu.ts
+var pendingUsages = new Map;
+function setPendingUsage(sessionID, usage) {
+  pendingUsages.set(sessionID, usage);
+}
+function findLastUserMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const m = messages[i];
+    const info = m.info;
+    if (info?.role === "user") {
+      const sid = info.sessionID || info.sessionId;
+      if (sid)
+        return { msg: m, sessionID: sid };
+    }
+  }
+  return null;
+}
+function createMessagesTransformHandler() {
+  return async (_input, output) => {
+    try {
+      if (!output.messages || !Array.isArray(output.messages))
+        return;
+      const found = findLastUserMessage(output.messages);
+      if (!found)
+        return;
+      const usage = pendingUsages.get(found.sessionID);
+      if (!usage)
+        return;
+      pendingUsages.delete(found.sessionID);
+      const recentMsgs = extractRecentMessages(output.messages, 30);
+      const recommendation = analyzeSession(found.sessionID, recentMsgs);
+      const menu = renderGuardMenu(usage.usedTokens, usage.contextLimit, recommendation);
+      const parts = found.msg.parts;
+      if (parts) {
+        for (let j = parts.length - 1;j >= 0; j--) {
+          if (parts[j].type === "text") {
+            parts[j].text = (parts[j].text || "") + `
+
+` + menu;
+            break;
+          }
+        }
+      }
+    } catch (err) {
+      console.warn("[context-guard] menu injection error:", err);
+    }
+  };
+}
+function parseOption(text) {
+  const t = text.trim();
+  if (t === "1" || t === "１")
+    return "auto-compress";
+  if (t === "2" || t === "２")
+    return "session-compact";
+  if (t === "3" || t === "３")
+    return "migrate";
+  if (/^[选1１]\s*[.、,，]?\s*(自动压缩|选项1)/.test(t))
+    return "auto-compress";
+  if (/^[选2２]\s*[.、,，]?\s*(会话压缩|compact|选项2)/i.test(t))
+    return "session-compact";
+  if (/^[选3３]\s*[.、,，]?\s*(分析迁移|迁移|选项3)/.test(t))
+    return "migrate";
+  if (t === "自动压缩")
+    return "auto-compress";
+  if (t === "会话压缩")
+    return "session-compact";
+  if (t === "分析迁移")
+    return "migrate";
+  return;
+}
+function createChatMessageHandler() {
+  return async (input, output) => {
+    try {
+      const rawInput = input;
+      const sessionID = rawInput.sessionID;
+      if (!sessionID)
+        return;
+      const state = getSessionState(sessionID);
+      if (!state.triggered)
+        return;
+      let userText = "";
+      if (output.parts) {
+        for (const part of output.parts) {
+          if (part.type === "text" && typeof part.text === "string") {
+            userText = part.text;
+          }
+        }
+      }
+      const option = parseOption(userText);
+      if (!option)
+        return;
+      setSelectedOption(state, option);
+      let replyText = "";
+      switch (option) {
+        case "auto-compress":
+          replyText = executeAutoCompress(sessionID);
+          break;
+        case "session-compact":
+          replyText = executeSessionCompact();
+          break;
+        case "migrate":
+          replyText = await executeMigrate(sessionID, []);
+          break;
+      }
+      if (output.parts) {
+        output.parts.length = 0;
+        output.parts.push({ type: "text", text: replyText });
+      }
+    } catch (err) {
+      console.warn("[context-guard] chat.message error:", err);
+    }
+  };
+}
+
+// src/context-guard/index.ts
+var config = { ...DEFAULT_GUARD_CONFIG };
+function initContextGuard(_client) {
+  const eventHandler = createEventHandler(config);
+  const paramsHandler = createChatParamsHandler();
+  const transformHandler = createMessagesTransformHandler();
+  const chatMessageHandler = createChatMessageHandler();
+  async function handleTrigger(trigger) {
+    setPendingUsage(trigger.sessionID, {
+      usedTokens: trigger.usedTokens,
+      contextLimit: trigger.contextLimit
+    });
+  }
+  return {
+    updateConfig(newConfig) {
+      config = { ...config, ...newConfig };
+    },
+    event: async (input) => {
+      const trigger = await eventHandler(input);
+      if (trigger) {
+        await handleTrigger(trigger);
+      }
+    },
+    "chat.params": async (input) => {
+      await paramsHandler(input);
+    },
+    "experimental.chat.messages.transform": async (input, output) => {
+      await transformHandler(input, output);
+    },
+    "chat.message": async (input, output) => {
+      await chatMessageHandler(input, output);
+    },
+    getConfig: () => config
+  };
+}
+
 // src/instructions/chinese.ts
 var CHINESE_LANGUAGE_INSTRUCTION = `# 中文语言要求
 
@@ -580,7 +1197,29 @@ class TaskTracker {
       }
     }
     if (activeJobs.length === 0 && reusableJobs.length === 0)
-      return null;
+      return "";
+    if (activeJobs.length === 0) {
+      const abbrMap = {
+        "co-explorer": "co-exp",
+        "co-oracle": "co-ora",
+        "co-fixer": "co-fix",
+        "co-planner": "co-pln",
+        "co-designer": "co-des",
+        "co-librarian": "co-lib",
+        "co-observer": "co-obs",
+        "co-council": "co-cnl"
+      };
+      const abbreviate = (agent) => abbrMap[agent] ?? (agent.startsWith("co-rule-") ? "co-rul" : agent);
+      const maxShow = 8;
+      const shown = reusableJobs.slice(0, maxShow);
+      const extra = reusableJobs.length - maxShow;
+      const parts = shown.map((j) => `${j.sessionId}(${abbreviate(j.agent)})`);
+      let text = "复用: " + parts.join(" ");
+      if (extra > 0) {
+        text += ` …及 ${extra} 个`;
+      }
+      return text;
+    }
     const lines = [];
     lines.push("### Background Job Board");
     lines.push("SENTINEL: background-job-board-v2");
@@ -668,233 +1307,6 @@ class TaskTracker {
   }
 }
 
-// src/plan-gate.ts
-import { tool } from "@opencode-ai/plugin";
-
-class PlanApprovalManager {
-  sessions = new Map;
-  audit;
-  constructor(audit) {
-    this.audit = audit;
-  }
-  getGeneration(sessionID) {
-    return this.sessions.get(sessionID)?.generation ?? 0;
-  }
-  observeUserMessage(sessionID, agent) {
-    if (agent !== "co-orchestrator") {
-      if (!this.sessions.has(sessionID)) {
-        return false;
-      }
-    }
-    const state = this.sessions.get(sessionID) ?? { generation: 0 };
-    const oldApprovedGeneration = state.approvedGeneration;
-    state.generation += 1;
-    delete state.approvedGeneration;
-    delete state.plan;
-    this.sessions.set(sessionID, state);
-    this.audit?.record({
-      event: "revoked",
-      session: sessionID.slice(0, 20),
-      generation: state.generation,
-      revoked: oldApprovedGeneration,
-      agent: agent && agent !== "co-orchestrator" ? agent : undefined
-    });
-    return true;
-  }
-  approve(sessionID, plan) {
-    const state = this.sessions.get(sessionID);
-    if (!state) {
-      throw new Error(`Session "${sessionID.slice(0, 20)}..." 尚未被 PlanGate 观察，无法批准。` + "只有 co-orchestrator 的 session 才能建立批准状态。");
-    }
-    if (state.generation === 0) {
-      throw new Error("无法批准 generation 0——session 尚未处理任何用户消息。");
-    }
-    state.approvedGeneration = state.generation;
-    state.plan = plan;
-    this.audit?.record({
-      event: "approved",
-      session: sessionID.slice(0, 20),
-      generation: state.generation,
-      fileCount: plan.files.length,
-      summaryLen: plan.summary.length
-    });
-  }
-  isApproved(sessionID) {
-    const state = this.sessions.get(sessionID);
-    if (!state)
-      return false;
-    return state.approvedGeneration === state.generation && state.generation > 0;
-  }
-  getSystemContext(sessionID) {
-    const state = this.sessions.get(sessionID);
-    if (!state)
-      return "";
-    const approved = this.isApproved(sessionID);
-    return `<plan_gate generation="${state.generation}" approved="${approved}">
-` + `  generation: ${state.generation}
-` + `  approved: ${approved}
-` + (state.plan ? `  plan_summary: ${state.plan.summary.slice(0, 120)}
-` + `  plan_files: ${state.plan.files.slice(0, 5).join(", ")}${state.plan.files.length > 5 ? "..." : ""}
-` : "") + `</plan_gate>`;
-  }
-  getInjectionText(sessionID) {
-    const state = this.sessions.get(sessionID);
-    if (!state || state.generation === 0)
-      return null;
-    const approved = this.isApproved(sessionID);
-    const status = approved ? "已批准" : "未批准";
-    const lines = [];
-    lines.push("");
-    lines.push("--- 行为准则（本次 LLM 请求注入，不持久化） ---");
-    lines.push(`当前 generation: ${state.generation}，方案状态: ${status}`);
-    lines.push("");
-    lines.push("核心规则：");
-    lines.push("1. 需要改代码 -> 先输出方案 -> todowrite -> request_plan_approval -> 等弹窗确认");
-    lines.push("2. 文件操作 -> 委派子代理，禁止亲自使用 read/grep/edit/bash/write");
-    lines.push("3. 未批准方案时禁止委派 co-fixer / co-designer");
-    lines.push("4. 每个新用户消息自动撤销旧批准");
-    lines.push("");
-    if (approved) {
-      lines.push("可委派 co-fixer / co-designer");
-      lines.push("");
-    }
-    lines.push("自检：需要改代码？-> 先方案  委派 fixer？-> 查状态锁");
-    lines.push("--- 注入结束 ---");
-    return lines.join(`
-`);
-  }
-  cleanup(sessionID) {
-    this.sessions.delete(sessionID);
-  }
-  get activeSessionCount() {
-    return this.sessions.size;
-  }
-}
-var z = tool.schema;
-function createRequestPlanApprovalTool(planManager) {
-  const request_plan_approval = tool({
-    description: [
-      "请求用户批准当前执行方案。",
-      "",
-      "输出方案后调用此工具，会弹出原生确认框让用户确认。",
-      "只有用户确认后，co-fixer 和 co-designer 等可写代理才能执行。",
-      "新用户消息会自动撤销之前的批准，需要重新申请。",
-      "",
-      "调用前确保已向用户展示了完整的任务分解方案。"
-    ].join(`
-`),
-    args: {
-      summary: z.string().describe("方案摘要：简要说明做什么、为什么"),
-      files: z.array(z.string()).describe("涉及的文件列表（相对路径）"),
-      verification: z.string().describe("验证方式：如何确认变更正确（如编译、测试、审查）")
-    },
-    async execute(args, toolContext) {
-      const sessionID = toolContext.sessionID;
-      const summary = String(args.summary);
-      const files = Array.isArray(args.files) ? args.files.map(String) : [];
-      const verification = String(args.verification);
-      const truncatedSummary = summary.length > 200 ? summary.slice(0, 200) + "..." : summary;
-      const truncatedFiles = files.length > 8 ? [...files.slice(0, 8), `...等 ${files.length} 个文件`] : files;
-      const truncatedVerification = verification.length > 150 ? verification.slice(0, 150) + "..." : verification;
-      const currentGen = planManager.getGeneration(sessionID);
-      planManager.audit?.record({
-        event: "approval_requested",
-        session: sessionID.slice(0, 20),
-        generation: currentGen,
-        agent: "co-orchestrator",
-        fileCount: files.length,
-        summaryLen: summary.length
-      });
-      try {
-        await toolContext.ask({
-          permission: "plan-execute",
-          always: [],
-          patterns: [
-            `\uD83D\uDCCB 方案: ${truncatedSummary}`,
-            `\uD83D\uDCC1 文件 (${files.length}个): ${truncatedFiles.join(", ")}`,
-            `\uD83D\uDD0D 验证: ${truncatedVerification}`
-          ],
-          metadata: {
-            session_id: sessionID,
-            generation: String(currentGen),
-            summary,
-            file_count: String(files.length)
-          }
-        });
-      } catch (err) {
-        planManager.audit?.record({
-          event: "rejected",
-          session: sessionID.slice(0, 20),
-          generation: currentGen,
-          reason: "permission_rejected"
-        });
-        throw err;
-      }
-      planManager.approve(sessionID, { summary, files, verification });
-      return `✅ 方案已批准（generation ${currentGen}）。
-` + `现在可以委派 @co-fixer / @co-designer 执行。
-` + `\uD83D\uDCCB ${summary}
-` + `\uD83D\uDCC1 ${files.length} 个文件
-` + `\uD83D\uDD0D ${verification}`;
-    }
-  });
-  return { request_plan_approval };
-}
-
-// src/plan-gate-audit.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-class BoundedPlanGateAudit {
-  events = [];
-  logPath;
-  maxEvents = 50;
-  constructor(logPath) {
-    this.logPath = logPath;
-    this.restore();
-  }
-  restore() {
-    try {
-      const data = fs.readFileSync(this.logPath, "utf-8");
-      const parsed = JSON.parse(data);
-      if (parsed && parsed.version === 1 && Array.isArray(parsed.events)) {
-        this.events = parsed.events;
-      }
-    } catch {
-      this.events = [];
-    }
-  }
-  record(e) {
-    try {
-      const event = { ...e, at: new Date().toISOString() };
-      this.events.push(event);
-      if (this.events.length > this.maxEvents) {
-        this.events = this.events.slice(-this.maxEvents);
-      }
-      this.flush();
-    } catch (err) {
-      console.warn("[BoundedPlanGateAudit] record 失败:", err);
-    }
-  }
-  flush() {
-    try {
-      const data = JSON.stringify({ version: 1, events: this.events });
-      const tmpPath = this.logPath + ".tmp";
-      const dir = path.dirname(this.logPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(tmpPath, data, "utf-8");
-      try {
-        fs.unlinkSync(this.logPath);
-      } catch {}
-      fs.renameSync(tmpPath, this.logPath);
-    } catch (err) {
-      console.warn("[BoundedPlanGateAudit] flush 失败:", err);
-    }
-  }
-}
-
 // src/context/types.ts
 var DEFAULT_CONTEXT_CONFIG = {
   strategy: {
@@ -1161,12 +1573,12 @@ class ContextEngine {
   dependencyCache = new Map;
   client;
   config;
-  constructor(client, config) {
+  constructor(client, config2) {
     this.client = client;
     this.config = {
       ...DEFAULT_CONTEXT_CONFIG,
-      ...config,
-      strategy: { ...DEFAULT_CONTEXT_CONFIG.strategy, ...config?.strategy }
+      ...config2,
+      strategy: { ...DEFAULT_CONTEXT_CONFIG.strategy, ...config2?.strategy }
     };
   }
   registerContext(args) {
@@ -1300,8 +1712,8 @@ class ContextEngine {
 // src/config/loader.ts
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
-import * as os from "node:os";
-var CONFIG_PATH = path2.join(os.homedir(), ".config", "opencode", "oh-my-opencode-cohub.json");
+import * as os2 from "node:os";
+var CONFIG_PATH = path2.join(os2.homedir(), ".config", "opencode", "oh-my-opencode-cohub.json");
 function loadCoHubConfig() {
   try {
     if (!fs2.existsSync(CONFIG_PATH))
@@ -1314,8 +1726,8 @@ function loadCoHubConfig() {
 }
 
 // src/tools/council.ts
-import { tool as tool2 } from "@opencode-ai/plugin";
-var z2 = tool2.schema;
+import { tool } from "@opencode-ai/plugin";
+var z = tool.schema;
 
 class OperationTimeoutError extends Error {
   constructor(message) {
@@ -1461,10 +1873,10 @@ class CouncilManager {
   client;
   directory;
   config;
-  constructor(client, directory, config) {
+  constructor(client, directory, config2) {
     this.client = client;
     this.directory = directory;
-    this.config = config;
+    this.config = config2;
   }
   async runCouncil(prompt, presetName, parentSessionId) {
     const resolvedPreset = presetName ?? this.config.default_preset ?? "default";
@@ -1507,12 +1919,12 @@ class CouncilManager {
     const entries = Object.entries(councillors);
     const results = [];
     if (executionMode === "serial") {
-      for (const [name, config] of entries) {
-        const r = await this.runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries);
+      for (const [name, config2] of entries) {
+        const r = await this.runCouncillorWithRetry(name, config2, prompt, parentSessionId, timeout, maxRetries);
         results.push(r);
       }
     } else {
-      const promises = entries.map(([name, config]) => this.runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries));
+      const promises = entries.map(([name, config2]) => this.runCouncillorWithRetry(name, config2, prompt, parentSessionId, timeout, maxRetries));
       const settled = await Promise.allSettled(promises);
       for (let i = 0;i < settled.length; i++) {
         const s = settled[i];
@@ -1531,19 +1943,19 @@ class CouncilManager {
     }
     return results;
   }
-  async runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries) {
+  async runCouncillorWithRetry(name, config2, prompt, parentSessionId, timeout, maxRetries) {
     const totalAttempts = 1 + maxRetries;
     for (let attempt = 1;attempt <= totalAttempts; attempt++) {
       try {
         const result = await this.runAgentSession({
           parentSessionId,
-          title: `Council ${name} (${shortModelLabel(config.model)})`,
-          model: config.model,
-          promptText: formatCouncillorPrompt(prompt, config.prompt),
-          variant: config.variant,
+          title: `Council ${name} (${shortModelLabel(config2.model)})`,
+          model: config2.model,
+          promptText: formatCouncillorPrompt(prompt, config2.prompt),
+          variant: config2.variant,
           timeout
         });
-        return { name, model: config.model, status: "completed", result };
+        return { name, model: config2.model, status: "completed", result };
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         const isEmptyResponse = msg.includes("Empty response from provider");
@@ -1551,7 +1963,7 @@ class CouncilManager {
         if (!canRetry) {
           return {
             name,
-            model: config.model,
+            model: config2.model,
             status: msg.includes("timed out") ? "timed_out" : "failed",
             error: `Councillor "${name}": ${msg}`
           };
@@ -1560,7 +1972,7 @@ class CouncilManager {
     }
     return {
       name,
-      model: config.model,
+      model: config2.model,
       status: "failed",
       error: `Councillor "${name}": max retries exhausted`
     };
@@ -1613,7 +2025,7 @@ class CouncilManager {
   }
 }
 function createCouncilTool(ctx, councilManager) {
-  const council_session = tool2({
+  const council_session = tool({
     description: [
       "Launch a multi-LLM council session for consensus-based analysis.",
       "",
@@ -1624,8 +2036,8 @@ function createCouncilTool(ctx, councilManager) {
     ].join(`
 `),
     args: {
-      prompt: z2.string().describe("The prompt to send to all councillors"),
-      preset: z2.string().optional().describe('Council preset to use (default: "default"). Must match a preset in the council config.')
+      prompt: z.string().describe("The prompt to send to all councillors"),
+      preset: z.string().optional().describe('Council preset to use (default: "default"). Must match a preset in the council config.')
     },
     async execute(args, toolContext) {
       const allowedAgents = ["co-council"];
@@ -1657,7 +2069,7 @@ function createCouncilTool(ctx, councilManager) {
 // src/index.ts
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
-import * as os2 from "node:os";
+import * as os3 from "node:os";
 function loadFileOverrides(projectDir) {
   const overrides = {};
   const agentNames = [
@@ -1672,13 +2084,14 @@ function loadFileOverrides(projectDir) {
     "co-rule-user",
     "co-rule-project",
     "co-rule-app",
-    "co-planner"
+    "co-planner",
+    "co-guardian"
   ];
   const searchDirs = [];
   if (projectDir) {
     searchDirs.push(path3.join(projectDir, ".opencode", "oh-my-opencode-cohub"));
   }
-  searchDirs.push(path3.join(os2.homedir(), ".config", "opencode", "oh-my-opencode-cohub"));
+  searchDirs.push(path3.join(os3.homedir(), ".config", "opencode", "oh-my-opencode-cohub"));
   for (const agent of agentNames) {
     for (const dir of searchDirs) {
       const replacePath = path3.join(dir, `${agent}.md`);
@@ -1719,12 +2132,8 @@ var CoHubPlugin = async (input, options) => {
   }
   const promptOverrides = { ...configOverrides, ...fileOverrides };
   const tracker = new TaskTracker;
-  const STATE_DIR = path3.join(os2.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub");
+  const STATE_DIR = path3.join(os3.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub");
   const STATE_FILE = path3.join(STATE_DIR, "tracker-state.json");
-  const PLAN_GATE_AUDIT_PATH = path3.join(STATE_DIR, "plan-gate-audit.json");
-  const planAudit = new BoundedPlanGateAudit(PLAN_GATE_AUDIT_PATH);
-  const planManager = new PlanApprovalManager(planAudit);
-  const planTools = createRequestPlanApprovalTool(planManager);
   function syncTrackerState(sessionId) {
     try {
       if (!fs3.existsSync(STATE_DIR)) {
@@ -1763,9 +2172,7 @@ var CoHubPlugin = async (input, options) => {
   const agents = [
     {
       name: "co-orchestrator",
-      config: { mode: "primary", model: "deepseek/deepseek-v4-pro", variant: "max", prompt: ORCHESTRATOR_PROMPT + `
-
-` + CHINESE_LANGUAGE_INSTRUCTION }
+      config: { mode: "primary", model: "deepseek/deepseek-v4-pro", variant: "max", prompt: ORCHESTRATOR_PROMPT }
     },
     {
       name: "co-oracle",
@@ -1824,6 +2231,11 @@ var CoHubPlugin = async (input, options) => {
       name: "co-planner",
       description: "方案制定——综合需求+信息+规范输出任务分解",
       config: { mode: "subagent", model: "deepseek/deepseek-v4-pro", variant: "high", prompt: PLANNER_PROMPT }
+    },
+    {
+      name: "co-guardian",
+      description: "上下文卫士——分析会话状态并推荐上下文处理策略",
+      config: { mode: "subagent", model: "deepseek/deepseek-v4-flash", prompt: GUARDIAN_PROMPT }
     }
   ];
   const userConfig = loadCoHubConfig();
@@ -1864,6 +2276,7 @@ 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 contextGuard = initContextGuard(input.client);
   syncAgentConfig();
   function extractChildSessionId(output) {
     if (!output || typeof output !== "object")
@@ -1921,41 +2334,18 @@ var CoHubPlugin = async (input, options) => {
   return {
     name: "oh-my-opencode-cohub",
     agent: agentConfigs,
-    tool: { ...councilTools, ...planTools },
+    tool: councilTools,
     config: async (cfg) => {
       const c = cfg;
       c.agent ??= {};
-      for (const [name, config] of Object.entries(agentConfigs)) {
-        c.agent[name] = config;
+      for (const [name, config2] of Object.entries(agentConfigs)) {
+        c.agent[name] = config2;
       }
       try {
         fs3.writeFileSync(path3.join(STATE_DIR, "config-hook-ran.json"), JSON.stringify({ ran: true, count: agents.length }));
       } catch {}
     },
     "tool.execute.before": async (input2, output) => {
-      if (input2.tool === "task") {
-        const beforeArgs = output.args ?? {};
-        const beforeSubagentType = typeof beforeArgs.subagent_type === "string" ? beforeArgs.subagent_type : "";
-        if ((beforeSubagentType === "co-fixer" || beforeSubagentType === "co-designer") && !planManager.isApproved(input2.sessionID)) {
-          planAudit.record({
-            event: "task_denied",
-            session: input2.sessionID?.slice(0, 20) ?? "?",
-            generation: planManager.getGeneration(input2.sessionID),
-            agent: beforeSubagentType,
-            reason: "unapproved"
-          });
-          throw new Error(`[CoHub 方案批准门禁] 当前 session 尚未通过方案批准。
-` + `请先：1) 输出可验证方案 → 2) todowrite 记录 → 3) 调用 request_plan_approval 弹出确认框 → ` + `4) 用户在弹窗中允许后，才能委派 ${beforeSubagentType}。`);
-        }
-        if (beforeSubagentType === "co-fixer" || beforeSubagentType === "co-designer") {
-          planAudit.record({
-            event: "task_allowed",
-            session: input2.sessionID?.slice(0, 20) ?? "?",
-            generation: planManager.getGeneration(input2.sessionID),
-            agent: beforeSubagentType
-          });
-        }
-      }
       try {
         if (input2.tool === "task") {
           const args = output.args ?? {};
@@ -1990,7 +2380,7 @@ var CoHubPlugin = async (input, options) => {
               if (details) {
                 output.args[targetField] += details;
               }
-              const logPath = path3.join(os2.tmpdir(), "opencode", "ctx-diag.log");
+              const logPath = path3.join(os3.tmpdir(), "opencode", "ctx-diag.log");
               try {
                 const stat = fs3.statSync(logPath);
                 if (stat.size > 50 * 1024) {
@@ -2038,6 +2428,9 @@ var CoHubPlugin = async (input, options) => {
       } catch {}
     },
     event: async (input2) => {
+      try {
+        await contextGuard.event(input2);
+      } catch {}
       try {
         const e = input2.event;
         const sessionId = extractSessionIdFromEvent(e.properties);
@@ -2053,20 +2446,12 @@ var CoHubPlugin = async (input, options) => {
         } else if (e.type === "session.deleted") {
           tracker.updateByChildSessionId(sessionId, "errored");
           syncTrackerState(tracker.currentParentSessionId);
-          planManager.cleanup(sessionId);
         } else if (e.type === "session.error") {
           tracker.updateByChildSessionId(sessionId, "errored");
           syncTrackerState(tracker.currentParentSessionId);
         }
       } catch {}
     },
-    "chat.message": async (input2) => {
-      try {
-        planManager.observeUserMessage(input2.sessionID, input2.agent);
-      } catch (err) {
-        console.warn("[oh-my-opencode-cohub] chat.message hook 失败:", err);
-      }
-    },
     "experimental.chat.messages.transform": async (_input, output) => {
       try {
         if (!output.messages || !Array.isArray(output.messages))
@@ -2095,32 +2480,32 @@ var CoHubPlugin = async (input, options) => {
             }
           }
         }
-        const planInject = sessionID ? planManager.getInjectionText(sessionID) : null;
-        if (planInject) {
-          for (let j = lastUserMsg.parts.length - 1;j >= 0; j--) {
-            const part = lastUserMsg.parts[j];
-            if (part.type === "text") {
-              part.text += planInject;
-              break;
-            }
-          }
-        }
+        try {
+          const guardTransform = contextGuard["experimental.chat.messages.transform"];
+          if (guardTransform)
+            await guardTransform(_input, output);
+        } catch {}
       } catch (err) {
         console.warn("[oh-my-opencode-cohub] messages.transform hook 失败:", err);
       }
     },
     "experimental.chat.system.transform": async (input2, output) => {
       output.system.push(CHINESE_LANGUAGE_INSTRUCTION);
-      if (input2.sessionID) {
-        const planGateCtx = planManager.getSystemContext(input2.sessionID);
-        if (planGateCtx) {
-          output.system.push(planGateCtx);
-        }
-      }
+    },
+    "chat.params": async (input2) => {
+      try {
+        await contextGuard["chat.params"](input2);
+      } catch {}
+    },
+    "chat.message": async (input2, output) => {
+      try {
+        await contextGuard["chat.message"](input2, output);
+      } catch {}
     },
     dispose: async () => {
       clearInterval(cleanupTimer);
       clearInterval(contextCleanupTimer);
+      cleanupAllStates();
     }
   };
 };