oh-my-opencode-cohub 1.12.13 → 1.13.0-beta.0

package/dist/index.js

@@ -560,6 +560,62 @@ var CHINESE_LANGUAGE_INSTRUCTION = `# 中文语言要求
 - 跨所有项目生效，优先级高于项目级规则`;
 
 // src/task-manager/tracker.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+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 defaultStrategyFor(agent) {
+  return AGENT_DEFAULT_STRATEGY[agent] ?? "none";
+}
+function computeStats(records, window = DEFAULT_STATS_WINDOW) {
+  const recent = records.slice(-Math.max(1, window));
+  const buckets = new Map;
+  for (const r of recent) {
+    const key = r.strategy + "\x00" + r.agent;
+    let bucket = buckets.get(key);
+    if (!bucket) {
+      bucket = {
+        strategy: r.strategy,
+        agent: r.agent,
+        count: 0,
+        successCount: 0,
+        successRate: 0,
+        avgLatencyMs: 0,
+        latencySamples: 0,
+        avgTokens: 0,
+        tokenSamples: 0
+      };
+      buckets.set(key, bucket);
+    }
+    bucket.count += 1;
+    if (r.status === "completed")
+      bucket.successCount += 1;
+    if (typeof r.latencyMs === "number") {
+      bucket.avgLatencyMs = (bucket.avgLatencyMs * bucket.latencySamples + r.latencyMs) / (bucket.latencySamples + 1);
+      bucket.latencySamples += 1;
+    }
+    if (r.tokens && typeof r.tokens.input === "number" && typeof r.tokens.output === "number") {
+      const total = r.tokens.input + r.tokens.output;
+      bucket.avgTokens = (bucket.avgTokens * bucket.tokenSamples + total) / (bucket.tokenSamples + 1);
+      bucket.tokenSamples += 1;
+    }
+  }
+  const result = Array.from(buckets.values());
+  for (const b of result) {
+    b.successRate = b.count > 0 ? b.successCount / b.count * 100 : 0;
+  }
+  result.sort((a, b) => a.strategy.localeCompare(b.strategy) || a.agent.localeCompare(b.agent));
+  return result;
+}
+
 class TaskTracker {
   jobs = new Map;
   counters = new Map;
@@ -592,6 +648,7 @@ class TaskTracker {
       sessionId: args.task_id ?? "",
       parentSessionId,
       agent,
+      contextStrategy: defaultStrategyFor(agent),
       label,
       status: "running",
       background: args.background ?? false,
@@ -618,12 +675,16 @@ class TaskTracker {
       latest.terminalReconciled = true;
       if (sessionId)
         latest.sessionId = sessionId;
+      this.finalize(latest);
+      this.persistStats();
     }
   }
   updateByChildSessionId(sessionId, status) {
     for (const job of this.jobs.values()) {
       if (job.sessionId === sessionId && job.background && job.status === "running") {
         job.status = status;
+        this.finalize(job);
+        this.persistStats();
         return;
       }
     }
@@ -702,8 +763,10 @@ class TaskTracker {
     for (const job of this.jobs.values()) {
       if (job.background && job.status === "running" && now - job.createdAt > timeoutMs) {
         job.status = "errored";
+        this.finalize(job);
       }
     }
+    this.persistStats();
   }
   isReusable(alias) {
     const job = this.jobs.get(alias);
@@ -730,11 +793,49 @@ class TaskTracker {
   getJobBySessionId(sessionId) {
     for (const job of this.jobs.values()) {
       if (job.sessionId === sessionId) {
-        return { alias: job.alias, agent: job.agent };
+        return job;
       }
     }
     return;
   }
+  updateQuality(sessionId, quality) {
+    for (const job of this.jobs.values()) {
+      if (job.sessionId === sessionId) {
+        job.quality = quality;
+        this.finalize(job);
+        this.persistStats();
+        return;
+      }
+    }
+  }
+  finalize(job) {
+    const latencyMs = Date.now() - job.createdAt;
+    if (!job.quality) {
+      job.quality = { latencyMs };
+    } else if (job.quality.latencyMs === undefined) {
+      job.quality.latencyMs = latencyMs;
+    }
+  }
+  collectStatsRecords() {
+    const jobs = Array.from(this.jobs.values()).filter((j) => j.status !== "running").sort((a, b) => a.createdAt - b.createdAt);
+    return jobs.map((job) => ({
+      agent: job.agent,
+      strategy: job.contextStrategy ?? defaultStrategyFor(job.agent),
+      status: job.status,
+      ...job.quality?.latencyMs !== undefined ? { latencyMs: job.quality.latencyMs } : {},
+      ...job.quality?.tokens ? { tokens: job.quality.tokens } : {}
+    }));
+  }
+  getStats(window = DEFAULT_STATS_WINDOW) {
+    return computeStats(this.collectStatsRecords(), window);
+  }
+  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");
+    } catch {}
+  }
   markCancelled(taskId) {
     let job = this.jobs.get(taskId);
     if (!job) {
@@ -748,10 +849,162 @@ class TaskTracker {
     if (job) {
       job.status = "cancelled";
       job.terminalReconciled = true;
+      this.finalize(job);
+      this.persistStats();
     }
   }
 }
 
+// src/task-manager/quality.ts
+var DEFAULT_QUALITY_CONFIG = {
+  enabled: true
+};
+var ERROR_KEYWORDS = [
+  "error",
+  "failed",
+  "failure",
+  "exception",
+  "traceback",
+  "unable to",
+  "失败",
+  "错误",
+  "异常",
+  "无法完成",
+  "未能"
+];
+var BOUNDARY_KEYWORDS = new Set(["error", "failed", "failure", "exception"]);
+var NEGATION_PHRASES = [
+  "no error",
+  "no errors",
+  "no failure",
+  "no failures",
+  "no exception",
+  "no exceptions",
+  "without error",
+  "without errors",
+  "without any error",
+  "without any errors",
+  "without failure",
+  "without failures",
+  "without exception",
+  "without exceptions",
+  "without any failure",
+  "without any failures",
+  "without any exception",
+  "without any exceptions",
+  "with no error",
+  "with no errors",
+  "with no failure",
+  "with no failures",
+  "not an error",
+  "not a failure",
+  "is not an error",
+  "never failed",
+  "never fails",
+  "did not fail",
+  "does not fail",
+  "not failed",
+  "无错误",
+  "没有错误",
+  "未失败",
+  "没有失败",
+  "未发现错误",
+  "未出现错误",
+  "未发生错误",
+  "不存在错误",
+  "无异常",
+  "没有异常",
+  "未发现异常",
+  "未出现异常",
+  "没有发现错误",
+  "没有发现任何错误",
+  "未发现任何错误",
+  "无任何错误",
+  "未出现任何错误",
+  "未发生任何错误",
+  "不存在任何错误",
+  "没有发现异常",
+  "未发现任何异常",
+  "无任何异常",
+  "未遇到错误",
+  "未产生错误",
+  "未遇到异常",
+  "未产生异常"
+];
+var NEGATION_WINDOW = 16;
+function isNegated(lower, hitStart, hitLength) {
+  const windowStart = Math.max(0, hitStart - NEGATION_WINDOW);
+  const window = lower.slice(windowStart, hitStart + hitLength);
+  return NEGATION_PHRASES.some((phrase) => window.includes(phrase));
+}
+function hasErrorKeywords(text) {
+  const lower = text.toLowerCase();
+  for (const kw of BOUNDARY_KEYWORDS) {
+    const re = new RegExp(`\\b${kw}\\b`, "g");
+    let m;
+    while ((m = re.exec(lower)) !== null) {
+      const before = m.index > 0 ? lower[m.index - 1] : "";
+      const after = lower[m.index + kw.length] ?? "";
+      if (before === "." || after === "(")
+        continue;
+      if (isNegated(lower, m.index, kw.length))
+        continue;
+      return true;
+    }
+  }
+  for (const kw of ERROR_KEYWORDS) {
+    if (BOUNDARY_KEYWORDS.has(kw))
+      continue;
+    let idx = lower.indexOf(kw);
+    while (idx !== -1) {
+      if (!isNegated(lower, idx, kw.length))
+        return true;
+      idx = lower.indexOf(kw, idx + kw.length);
+    }
+  }
+  return false;
+}
+function assessQuality(input) {
+  const outputOk = input.output.trim().length > 0;
+  const exitOk = input.exitCode === undefined || input.exitCode === 0;
+  const keywordOk = !hasErrorKeywords(input.output);
+  const decisionsOk = input.decisions >= 1;
+  const timedOut = input.timedOut === true;
+  let score = 0;
+  if (outputOk)
+    score += 0.25;
+  if (exitOk && !timedOut)
+    score += 0.25;
+  if (keywordOk && !timedOut)
+    score += 0.25;
+  if (decisionsOk && !timedOut)
+    score += 0.25;
+  if (!outputOk)
+    score = 0;
+  const passed = !timedOut && outputOk && exitOk && keywordOk && decisionsOk;
+  let failureCategory;
+  if (!passed) {
+    if (timedOut)
+      failureCategory = "timeout";
+    else if (!outputOk)
+      failureCategory = "empty";
+    else if (!exitOk || !keywordOk)
+      failureCategory = "error";
+    else
+      failureCategory = "quality-low";
+  }
+  return {
+    score,
+    passed,
+    ...failureCategory ? { failureCategory } : {},
+    ...input.latencyMs !== undefined ? { latencyMs: input.latencyMs } : {},
+    ...input.tokens ? { tokens: input.tokens } : {}
+  };
+}
+function isQualityEnabled(config) {
+  return config?.enabled ?? DEFAULT_QUALITY_CONFIG.enabled;
+}
+
 // src/context/types.ts
 var DEFAULT_CONTEXT_CONFIG = {
   strategy: {
@@ -776,6 +1029,9 @@ var DEFAULT_CONTEXT_CONFIG = {
   relevantMessageWindow: 20
 };
 
+// src/context/engine.ts
+import * as fs2 from "node:fs";
+
 // src/context/extractor.ts
 var KNOWN_EXTENSIONS = new Set([
   "ts",
@@ -827,12 +1083,12 @@ function extractRelevantFiles(messages, maxFiles, windowSize) {
       if (part.type === "tool" && part.state) {
         const state = part.state;
         const input = state.input ?? {};
-        const path = extractPath(input);
-        if (path) {
-          if (!fileMap.has(path)) {
-            fileMap.set(path, { path, summary: "" });
+        const path2 = extractPath(input);
+        if (path2) {
+          if (!fileMap.has(path2)) {
+            fileMap.set(path2, { path: path2, summary: "" });
           }
-          const existing = fileMap.get(path);
+          const existing = fileMap.get(path2);
           if (typeof input.offset === "number") {
             const limit = typeof input.limit === "number" ? input.limit : 50;
             existing.lines = `${input.offset}-${input.offset + limit}`;
@@ -952,6 +1208,25 @@ function extractErrors(messages, maxErrors, windowSize) {
   }
   return errors;
 }
+function truncateByTokens(text, maxTokens) {
+  if (!text || maxTokens <= 0)
+    return "";
+  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;
+    }
+  }
+  if (cut >= text.length)
+    return text;
+  return text.slice(0, cut) + `
+… [正文已按 token 预算截断]`;
+}
 
 // src/context/formatter.ts
 var CONTEXT_MARKER_PATTERN = /<!-- CONTEXT:ID=([a-f0-9-]+) -->/;
@@ -1043,6 +1318,7 @@ class ContextEngine {
       return;
     if (args.strategy === "none")
       return;
+    context.strategy = args.strategy;
     try {
       const windowSize = this.config.relevantMessageWindow;
       const messagesResult = await this.client.session.messages({
@@ -1055,11 +1331,25 @@ class ContextEngine {
         context.decisions = extractDecisions(messages, this.config.maxDecisions, windowSize);
         context.errors = extractErrors(messages, this.config.maxErrors, windowSize);
       }
+      if (args.strategy === "summary") {
+        this.attachTruncatedBodies(context.relevantFiles);
+      }
       if (this.config.dependencyPropagation && this.dependencyCache.size > 0) {
         context.dependencies = Array.from(this.dependencyCache.values()).slice(-this.config.maxDependencies);
       }
     } catch {}
   }
+  attachTruncatedBodies(files) {
+    if (files.length === 0)
+      return;
+    const budgetPerFile = Math.max(1, Math.floor(this.config.summarizeMaxTokens / files.length));
+    for (const file of files) {
+      try {
+        const content = fs2.readFileSync(file.path, "utf-8");
+        file.body = truncateByTokens(content, budgetPerFile);
+      } catch {}
+    }
+  }
   consumeMarkedContext(messageText) {
     const markerMatch = messageText.match(CONTEXT_MARKER_PATTERN);
     if (!markerMatch)
@@ -1078,10 +1368,23 @@ class ContextEngine {
     if (!context)
       return "";
     const parts = [];
+    const isSummary = context.strategy === "summary";
     if (context.relevantFiles.length > 0) {
-      parts.push("### \uD83D\uDCC1 相关文件");
-      for (const file of context.relevantFiles) {
-        parts.push(`- \`${file.path}\`` + (file.summary ? ` — ${file.summary}` : ""));
+      if (isSummary) {
+        parts.push("### \uD83D\uDCC1 相关文件（正文按 token 预算截断）");
+        for (const file of context.relevantFiles) {
+          const loc = file.lines ? ":" + file.lines : "";
+          if (file.body) {
+            parts.push("- `" + file.path + loc + "`:\n```text\n" + file.body + "\n```");
+          } else {
+            parts.push("- `" + file.path + loc + "` — " + (file.summary || "(正文不可用)"));
+          }
+        }
+      } else {
+        parts.push("### \uD83D\uDCC1 相关文件");
+        for (const file of context.relevantFiles) {
+          parts.push("- `" + file.path + "`" + (file.summary ? " — " + file.summary : ""));
+        }
       }
     }
     if (context.decisions.length > 0) {
@@ -1108,27 +1411,31 @@ class ContextEngine {
 ` : "";
   }
   async captureResult(childSessionId, alias, agent) {
-    if (!this.config.dependencyPropagation)
-      return;
     try {
       const messagesResult = await this.client.session.messages({
         path: { id: childSessionId }
       });
       const messages = messagesResult.data ?? [];
       let keyOutput = "";
+      let tokens;
       for (let i = messages.length - 1;i >= 0; i--) {
-        if (messages[i].info?.role === "assistant") {
-          for (const part of messages[i].parts ?? []) {
-            if (part.type === "text" && part.text) {
-              keyOutput = part.text.slice(0, 500).replace(/\n/g, " ");
-              break;
-            }
-          }
-          if (keyOutput)
+        const info = messages[i].info;
+        if (!info || info.role !== "assistant")
+          continue;
+        if (typeof info.tokens?.input === "number" && typeof info.tokens?.output === "number") {
+          tokens = { input: info.tokens.input, output: info.tokens.output };
+        }
+        for (const part of messages[i].parts ?? []) {
+          if (part.type === "text" && part.text) {
+            keyOutput = part.text.slice(0, 500).replace(/\n/g, " ");
             break;
+          }
         }
+        if (keyOutput)
+          break;
       }
-      if (keyOutput) {
+      const decisions = extractDecisions(messages, this.config.maxDecisions, this.config.relevantMessageWindow);
+      if (keyOutput && this.config.dependencyPropagation) {
         this.dependencyCache.set(alias, {
           alias,
           agent,
@@ -1136,7 +1443,14 @@ class ContextEngine {
           capturedAt: Date.now()
         });
       }
-    } catch {}
+      return {
+        output: keyOutput,
+        decisions: decisions.length,
+        ...tokens ? { tokens } : {}
+      };
+    } catch {
+      return null;
+    }
   }
   formatMarker(contextId) {
     return formatContextMarker(contextId);
@@ -1155,15 +1469,15 @@ class ContextEngine {
 }
 
 // src/config/loader.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-var USER_CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "oh-my-opencode-cohub.json");
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+import * as os2 from "node:os";
+var USER_CONFIG_PATH = path2.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 = path.join(projectDir, ".opencode", "oh-my-opencode-cohub.json");
+  const projectPath = path2.join(projectDir, ".opencode", "oh-my-opencode-cohub.json");
   const project = readJSON(projectPath);
   if (!project || Object.keys(project).length === 0)
     return base;
@@ -1177,13 +1491,16 @@ function loadCoHubConfig(projectDir) {
   if (project.context) {
     merged.context = { ...base.context, ...project.context };
   }
+  if (project.quality) {
+    merged.quality = { ...base.quality, ...project.quality };
+  }
   return merged;
 }
 function readJSON(filePath) {
   try {
-    if (!fs.existsSync(filePath))
+    if (!fs3.existsSync(filePath))
       return {};
-    const raw = fs.readFileSync(filePath, "utf-8");
+    const raw = fs3.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -1194,10 +1511,10 @@ function readJSON(filePath) {
 import { tool } from "@opencode-ai/plugin";
 
 // src/utils/log.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-import * as os2 from "os";
-var LOG_DIR = path2.join(os2.homedir(), ".local", "share", "opencode", "log");
+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 = "";
@@ -1207,7 +1524,7 @@ function getLogPath() {
   const today = new Date().toISOString().slice(0, 10).replace(/-/g, "");
   if (today !== _today) {
     _today = today;
-    _logPath = path2.join(LOG_DIR, `${LOG_PREFIX}.${today}.log`);
+    _logPath = path3.join(LOG_DIR, `${LOG_PREFIX}.${today}.log`);
     _cleanedToday = false;
   }
   return _logPath;
@@ -1220,7 +1537,7 @@ async function cleanOldLogsOnce() {
     const cutoff = new Date;
     cutoff.setUTCDate(cutoff.getUTCDate() - KEEP_DAYS);
     const cutoffStr = cutoff.toISOString().slice(0, 10).replace(/-/g, "");
-    const files = await fs2.readdir(LOG_DIR);
+    const files = await fs4.readdir(LOG_DIR);
     for (const file of files) {
       if (!file.startsWith(LOG_PREFIX + "."))
         continue;
@@ -1229,7 +1546,7 @@ async function cleanOldLogsOnce() {
       if (!match)
         continue;
       if (match[1] < cutoffStr) {
-        await fs2.unlink(path2.join(LOG_DIR, file)).catch(() => {});
+        await fs4.unlink(path3.join(LOG_DIR, file)).catch(() => {});
       }
     }
   } catch {}
@@ -1237,7 +1554,7 @@ async function cleanOldLogsOnce() {
 async function appendLog(tag, message, err) {
   try {
     const logPath = getLogPath();
-    await fs2.mkdir(LOG_DIR, { recursive: true });
+    await fs4.mkdir(LOG_DIR, { recursive: true });
     const now = new Date().toISOString();
     let line = `[${now}] [oh-my-opencode-cohub] [${tag}] ${message}`;
     if (err instanceof Error) {
@@ -1249,13 +1566,158 @@ async function appendLog(tag, message, err) {
     }
     line += `
 `;
-    await fs2.appendFile(logPath, line, "utf-8");
+    await fs4.appendFile(logPath, line, "utf-8");
     await cleanOldLogsOnce();
   } catch {}
 }
 
+// src/tools/model-stats.ts
+var DEFAULT_MODEL_STATS_CONFIG = {
+  windowSize: 20,
+  highFailureRate: 0.5,
+  minSamples: 5
+};
+var config = { ...DEFAULT_MODEL_STATS_CONFIG };
+var history = new Map;
+function recordModelResult(model, category) {
+  const window = history.get(model) ?? [];
+  window.push(category);
+  if (window.length > config.windowSize) {
+    window.splice(0, window.length - config.windowSize);
+  }
+  history.set(model, window);
+}
+function getModelStats(model) {
+  const window = history.get(model) ?? [];
+  let successes = 0;
+  let empty = 0;
+  let timeout = 0;
+  let error = 0;
+  let qualityLow = 0;
+  for (const c of window) {
+    if (c === "success") {
+      successes += 1;
+    } else if (c === "empty") {
+      empty += 1;
+    } else if (c === "timeout") {
+      timeout += 1;
+    } else if (c === "error") {
+      error += 1;
+    } else {
+      qualityLow += 1;
+    }
+  }
+  const total = window.length;
+  const failures = total - successes;
+  return {
+    model,
+    total,
+    successes,
+    failures,
+    empty,
+    timeout,
+    error,
+    qualityLow,
+    failureRate: total === 0 ? 0 : failures / total,
+    successRate: total === 0 ? 1 : successes / total
+  };
+}
+function orderCouncillorsByFailure(entries, statsProvider = getModelStats, cfg = config) {
+  const isHighRisk = ([, c]) => {
+    const s = statsProvider(c.model);
+    return s.total >= cfg.minSamples && s.failureRate > cfg.highFailureRate;
+  };
+  const preferred = entries.filter((entry) => !isHighRisk(entry));
+  const chosen = preferred.length > 0 ? preferred : [...entries];
+  return chosen.sort((a, b) => statsProvider(a[1].model).failureRate - statsProvider(b[1].model).failureRate);
+}
+
+// src/tools/adaptive-params.ts
+var DEFAULT_ADAPTIVE_CONFIG = {
+  highRate: 0.8,
+  lowRate: 0.5,
+  minSamples: 5,
+  hysteresisSamples: 5,
+  minRetries: 1,
+  maxRetries: 5,
+  minTimeoutMs: 60000,
+  maxTimeoutMs: 300000,
+  defaultRetries: 3,
+  defaultTimeoutMs: 180000,
+  timeoutStepMs: 30000,
+  windowSize: 20
+};
+var config2 = { ...DEFAULT_ADAPTIVE_CONFIG };
+var samples = new Map;
+function evaluateAdjustment(successRate, sampleCount, cfg = config2) {
+  if (sampleCount < cfg.minSamples)
+    return 0;
+  if (successRate > cfg.highRate)
+    return -1;
+  if (successRate < cfg.lowRate)
+    return 1;
+  return 0;
+}
+function clampAdaptiveParams(params, cfg = config2) {
+  return {
+    retries: Math.min(cfg.maxRetries, Math.max(cfg.minRetries, Math.round(params.retries))),
+    timeoutMs: Math.min(cfg.maxTimeoutMs, Math.max(cfg.minTimeoutMs, Math.round(params.timeoutMs)))
+  };
+}
+function adjustAdaptiveParams(current, direction, cfg = config2) {
+  if (direction === 0)
+    return clampAdaptiveParams(current, cfg);
+  return clampAdaptiveParams({
+    retries: current.retries + direction,
+    timeoutMs: current.timeoutMs + direction * cfg.timeoutStepMs
+  }, cfg);
+}
+function recordAdaptiveSample(key, success, cfg = config2) {
+  let st = samples.get(key);
+  if (!st) {
+    st = {
+      recent: [],
+      current: { retries: cfg.defaultRetries, timeoutMs: cfg.defaultTimeoutMs },
+      lastDirection: 0,
+      streak: 0
+    };
+    samples.set(key, st);
+  }
+  st.recent.push(success);
+  if (st.recent.length > cfg.windowSize) {
+    st.recent.splice(0, st.recent.length - cfg.windowSize);
+  }
+  const total = st.recent.length;
+  if (total < cfg.minSamples)
+    return;
+  const successes = st.recent.filter(Boolean).length;
+  const direction = evaluateAdjustment(successes / total, total, cfg);
+  if (direction === st.lastDirection) {
+    st.streak += 1;
+  } else {
+    st.lastDirection = direction;
+    st.streak = 1;
+  }
+  if (st.streak >= cfg.hysteresisSamples) {
+    st.current = adjustAdaptiveParams(st.current, direction, cfg);
+    st.streak = 0;
+  }
+}
+function getAdaptiveParams(key, cfg = config2) {
+  const st = samples.get(key);
+  if (!st)
+    return { retries: cfg.defaultRetries, timeoutMs: cfg.defaultTimeoutMs };
+  return { ...st.current };
+}
+
 // src/tools/council.ts
 var z = tool.schema;
+var RETRY_LIMITS = {
+  empty: 3,
+  timeout: 1,
+  error: 0,
+  "quality-low": 1
+};
 
 class OperationTimeoutError extends Error {
   constructor(message) {
@@ -1285,12 +1747,12 @@ async function abortSession(client, sessionId) {
     appendLog("abortSession", "中止会话失败", err);
   }
 }
-async function promptWithTimeout(client, path3, body, timeoutMs, directory) {
-  const sessionId = path3.id;
+async function promptWithTimeout(client, path4, body, timeoutMs, directory) {
+  const sessionId = path4.id;
   let timer;
   try {
     const promptPromise = client.session.prompt({
-      path: path3,
+      path: path4,
       body,
       query: directory ? { directory } : undefined
     });
@@ -1316,6 +1778,7 @@ async function promptWithTimeout(client, path3, body, timeoutMs, directory) {
 }
 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 }
   });
@@ -1332,7 +1795,8 @@ async function extractSessionResult(client, sessionId, options) {
       }
     }
   }
-  const text = extractedContent.filter((t) => t.length > 0).join(`
+  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 };
@@ -1395,18 +1859,254 @@ ${cr.result}`;
   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(config3) {
+  return `${config3.variant ?? "default"}\x00${config3.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 = [
+  "综上",
+  "结论",
+  "因此",
+  "总之",
+  "建议",
+  "推荐",
+  "我认为",
+  "最终",
+  "关键结论",
+  "conclusion",
+  "therefore",
+  "in summary",
+  "in conclusion",
+  "recommend",
+  "suggest",
+  "overall"
+];
+var ENTITY_MARKERS = [
+  "决策",
+  "决定",
+  "方案",
+  "采用",
+  "选择",
+  "关键",
+  "实体",
+  "要点",
+  "关键决策",
+  "decision",
+  "entity",
+  "key point",
+  "option",
+  "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",
+  "an",
+  "and",
+  "or",
+  "of",
+  "to",
+  "in",
+  "on",
+  "for",
+  "with",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "this",
+  "that",
+  "it",
+  "as",
+  "at",
+  "by",
+  "from",
+  "我们",
+  "的",
+  "了",
+  "是",
+  "在",
+  "和",
+  "与",
+  "及",
+  "或",
+  "一个",
+  "这个",
+  "进行",
+  "以及",
+  "结论",
+  "综上",
+  "总之",
+  "因此",
+  "建议",
+  "推荐",
+  "最终",
+  "我认为",
+  "关键",
+  "要点",
+  "采用",
+  "方案",
+  "决策",
+  "决定",
+  "选择",
+  "实体",
+  "conclusion",
+  "therefore",
+  "summary",
+  "recommend",
+  "suggest",
+  "overall",
+  "decision",
+  "option",
+  "recommendation",
+  "key",
+  "point",
+  "entity",
+  "error"
+]);
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9\u4e00-\u9fff]+/).filter((t) => t.length > 0 && !STOPWORDS.has(t));
+}
+function jaccard(x, y) {
+  if (x.length === 0 || y.length === 0)
+    return 0;
+  const xs = new Set(x);
+  const ys = new Set(y);
+  const inter = [...xs].filter((t) => ys.has(t)).length;
+  const union = new Set([...xs, ...ys]).size;
+  return union === 0 ? 0 : inter / union;
+}
+function pairwiseAgreement(a, b) {
+  const aConcl = tokenize(a.conclusions.join(" "));
+  const bConcl = tokenize(b.conclusions.join(" "));
+  const aEnt = tokenize(a.entities.join(" "));
+  const bEnt = tokenize(b.entities.join(" "));
+  return 0.5 * jaccard(aConcl, bConcl) + 0.5 * jaccard(aEnt, bEnt);
+}
+function computeConsensus(inputs, threshold) {
+  const n = inputs.length;
+  if (n === 0)
+    return { consensus: false, agreementScores: {}, averageAgreement: 0 };
+  if (n === 1) {
+    return { consensus: true, agreementScores: { [inputs[0].name]: 1 }, averageAgreement: 1 };
+  }
+  const agreementScores = {};
+  for (const a of inputs) {
+    let sum = 0;
+    for (const b of inputs) {
+      if (a.name === b.name)
+        continue;
+      sum += pairwiseAgreement(a.summary, b.summary);
+    }
+    agreementScores[a.name] = sum / (n - 1);
+  }
+  const values = Object.values(agreementScores);
+  const averageAgreement = values.reduce((acc, v) => acc + v, 0) / values.length;
+  const agreeing = values.filter((v) => v >= threshold).length;
+  const required = Math.ceil(2 * n / 3);
+  return { consensus: agreeing >= required, agreementScores, averageAgreement };
+}
+function decideRetryAction(category, consecutiveStreak, categoryRetriesUsed, budgetAvailable, categoryLimit = RETRY_LIMITS[category]) {
+  if (!budgetAvailable)
+    return "budget-exhausted";
+  if (consecutiveStreak >= 2)
+    return "needs-human";
+  if (categoryRetriesUsed >= categoryLimit)
+    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}
+
+[retry] 上次尝试超时。请精炼作答：先给出结论与关键决策，避免冗长过程。`;
+  }
+  if (category === "quality-low") {
+    return `${prompt}
+
+[retry] 上次回答缺少明确的结论与关键实体/决策。请以"结论：..."开头，并列出关键决策/实体要点。`;
+  }
+  return prompt;
+}
+
+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;
+  }
+}
 
 class CouncilManager {
   client;
   directory;
   config;
-  constructor(client, directory, config) {
+  constructor(client, directory, config3) {
     this.client = client;
     this.directory = directory;
-    this.config = config;
+    this.config = config3;
   }
   async runCouncil(prompt, presetName, parentSessionId) {
     const resolvedPreset = presetName ?? this.config.default_preset ?? "default";
@@ -1428,8 +2128,10 @@ class CouncilManager {
     }
     const timeout = this.config.timeout ?? 180000;
     const executionMode = this.config.councillor_execution_mode ?? "parallel";
-    const maxRetries = this.config.councillor_retries ?? 3;
-    const councillorResults = await this.runCouncillors(prompt, preset, parentSessionId, timeout, executionMode, maxRetries);
+    const maxRounds = this.config.max_rounds ?? 2;
+    const consensusThreshold = this.config.consensus_threshold ?? 0.6;
+    const budget = new RetryBudget(this.config.max_total_retries ?? 6, this.config.max_elapsed_ms ?? 3 * timeout);
+    const councillorResults = await this.runCouncillors(prompt, preset, parentSessionId, timeout, executionMode, budget, { maxRounds, consensusThreshold });
     const completedCount = councillorResults.filter((r) => r.status === "completed").length;
     if (completedCount === 0) {
       return {
@@ -1438,23 +2140,56 @@ class CouncilManager {
         councillorResults
       };
     }
+    const consensusInputs = councillorResults.filter((r) => r.status === "completed" && !!r.summary).map((r) => ({ name: r.name, summary: r.summary }));
+    const consensus = computeConsensus(consensusInputs, consensusThreshold);
     const formatted = formatCouncillorResults(prompt, councillorResults);
     return {
       success: true,
       result: formatted,
-      councillorResults
+      councillorResults,
+      consensus: consensus.consensus,
+      agreement: consensus.averageAgreement
     };
   }
-  async runCouncillors(prompt, councillors, parentSessionId, timeout, executionMode, maxRetries) {
-    const entries = Object.entries(councillors);
+  async runCouncillors(prompt, councillors, parentSessionId, timeout, executionMode, budget, options) {
+    const entries = orderCouncillorsByFailure(Object.entries(councillors));
     const results = [];
+    const explicitTimeout = this.config.timeout;
+    const explicitRetries = this.config.councillor_retries;
+    const resolveParams = (config3) => {
+      const p = getAdaptiveParams(adaptiveKey(config3), {
+        ...DEFAULT_ADAPTIVE_CONFIG,
+        defaultTimeoutMs: explicitTimeout ?? timeout,
+        defaultRetries: explicitRetries ?? 3
+      });
+      return {
+        timeout: explicitTimeout ?? p.timeoutMs,
+        retries: explicitRetries ?? p.retries
+      };
+    };
     if (executionMode === "serial") {
-      for (const [name, config] of entries) {
-        const r = await this.runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries);
-        results.push(r);
+      let lastRound = [];
+      for (let round = 1;round <= options.maxRounds; round++) {
+        const roundResults = [];
+        const firstAttemptIsExtra = round > 1;
+        for (const [name, config3] of entries) {
+          const params = resolveParams(config3);
+          const roundPrompt = round > 1 ? buildDeliberationPrompt(prompt, lastRound, name) : prompt;
+          const r = await this.runCouncillorWithRetry(name, config3, roundPrompt, parentSessionId, params.timeout, budget, { firstAttemptIsExtra, retries: params.retries });
+          roundResults.push(r);
+        }
+        lastRound = roundResults;
+        const consensusInputs = roundResults.filter((r) => r.status === "completed" && !!r.summary).map((r) => ({ name: r.name, summary: r.summary }));
+        if (computeConsensus(consensusInputs, options.consensusThreshold).consensus) {
+          break;
+        }
       }
+      results.push(...lastRound);
     } else {
-      const promises = entries.map(([name, config]) => this.runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries));
+      const promises = entries.map(([name, config3]) => {
+        const params = resolveParams(config3);
+        return this.runCouncillorWithRetry(name, config3, prompt, parentSessionId, params.timeout, budget, { retries: params.retries });
+      });
       const settled = await Promise.allSettled(promises);
       for (let i = 0;i < settled.length; i++) {
         const s = settled[i];
@@ -1473,39 +2208,80 @@ class CouncilManager {
     }
     return results;
   }
-  async runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries) {
-    const totalAttempts = 1 + maxRetries;
-    for (let attempt = 1;attempt <= totalAttempts; attempt++) {
+  async runCouncillorWithRetry(name, config3, prompt, parentSessionId, timeout, budget, options) {
+    let attemptPrompt = formatCouncillorPrompt(prompt, config3.prompt);
+    let attemptVariant = config3.variant;
+    let lastCategory = null;
+    let streak = 0;
+    const categoryRetries = {};
+    let attempt = 1;
+    for (;; ) {
+      if (budget.expired()) {
+        return { name, model: config3.model, status: "error", error: "budget-exhausted" };
+      }
+      const isExtraAttempt = attempt > 1 || options?.firstAttemptIsExtra === true;
+      if (isExtraAttempt && !budget.consumeRetry()) {
+        return { name, model: config3.model, status: "error", error: "budget-exhausted" };
+      }
+      let category;
+      let errorInfo;
       try {
-        const result = await this.runAgentSession({
+        const session = 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(config3.model)})`,
+          model: config3.model,
+          promptText: attemptPrompt,
+          variant: attemptVariant,
           timeout
         });
-        return { name, model: config.model, status: "completed", result };
+        const quality = assessQuality({ output: session.text, decisions: session.summary.entities.length });
+        if (quality.passed) {
+          recordModelResult(config3.model, "success");
+          recordAdaptiveSample(adaptiveKey(config3), true);
+          return { name, model: config3.model, status: "completed", result: session.text, summary: session.summary };
+        }
+        category = quality.failureCategory ?? "quality-low";
+        errorInfo = `Councillor "${name}": quality score ${quality.score} (${category})`;
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        const isEmptyResponse = msg.includes("Empty response from provider");
-        const canRetry = attempt < totalAttempts && isEmptyResponse;
-        if (!canRetry) {
-          return {
-            name,
-            model: config.model,
-            status: msg.includes("timed out") ? "timed_out" : "failed",
-            error: `Councillor "${name}": ${msg}`
-          };
-        }
+        category = classifyFailure(msg);
+        errorInfo = `Councillor "${name}": ${msg}`;
+      }
+      recordModelResult(config3.model, category);
+      recordAdaptiveSample(adaptiveKey(config3), false);
+      streak = lastCategory === category ? streak + 1 : 1;
+      lastCategory = category;
+      const used = categoryRetries[category] ?? 0;
+      const categoryLimit = category === "empty" ? options?.retries ?? this.config.councillor_retries ?? 3 : RETRY_LIMITS[category];
+      const action = decideRetryAction(category, streak, used, budget.retriesLeft > 0 && !budget.expired(), categoryLimit);
+      if (action === "needs-human") {
+        return {
+          name,
+          model: config3.model,
+          status: "needs_human",
+          error: `${errorInfo} — ${streak} consecutive ${category} failures, needs human review`
+        };
+      }
+      if (action === "budget-exhausted") {
+        return { name, model: config3.model, status: "error", error: "budget-exhausted" };
+      }
+      if (action === "give-up") {
+        return {
+          name,
+          model: config3.model,
+          status: category === "timeout" ? "timed_out" : "failed",
+          error: errorInfo
+        };
+      }
+      categoryRetries[category] = used + 1;
+      if (category === "timeout") {
+        attemptVariant = downgradeVariant(attemptVariant);
+        attemptPrompt = appendRetryContext(attemptPrompt, "timeout");
+      } else if (category === "quality-low") {
+        attemptPrompt = appendRetryContext(attemptPrompt, "quality-low");
       }
+      attempt += 1;
     }
-    return {
-      name,
-      model: config.model,
-      status: "failed",
-      error: `Councillor "${name}": max retries exhausted`
-    };
   }
   async runAgentSession(options) {
     const modelRef = parseModelReference(options.model);
@@ -1545,11 +2321,15 @@ class CouncilManager {
         promptBody.variant = options.variant;
       }
       await promptWithTimeout(this.client, { id: sessionId }, promptBody, options.timeout, this.directory);
-      const extraction = await extractSessionResult(this.client, sessionId);
+      const extraction = await extractSessionResult(this.client, sessionId, {
+        includeReasoning: false,
+        lastTextOnly: true
+      });
       if (extraction.empty) {
         throw new Error("[oh-my-opencode-cohub] Empty response from provider");
       }
-      return extraction.text;
+      const summary = extractCouncillorSummary(extraction.text);
+      return { text: extraction.text, summary };
     } finally {
       if (sessionId) {
         abortSession(this.client, sessionId).catch(() => {});
@@ -1593,6 +2373,10 @@ function createCouncilTool(ctx, councilManager) {
 
 ---
 *Council: ${completed}/${total} councillors responded (${composition})*`;
+      const agreementNum = typeof result.agreement === "number" ? result.agreement : 0;
+      const consensusLabel = result.consensus === true ? agreementNum >= 0.8 ? "unanimous" : "majority" : "split";
+      output += `
+*Consensus: ${consensusLabel} (${agreementNum.toFixed(2)})*`;
       return output;
     }
   });
@@ -1600,9 +2384,9 @@ function createCouncilTool(ctx, councilManager) {
 }
 
 // src/index.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import * as os3 from "node:os";
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
+import * as os4 from "node:os";
 function loadFileOverrides(projectDir) {
   const overrides = {};
   const agentNames = [
@@ -1621,23 +2405,23 @@ function loadFileOverrides(projectDir) {
   ];
   const searchDirs = [];
   if (projectDir) {
-    searchDirs.push(path3.join(projectDir, ".opencode", "oh-my-opencode-cohub"));
+    searchDirs.push(path4.join(projectDir, ".opencode", "oh-my-opencode-cohub"));
   }
-  searchDirs.push(path3.join(os3.homedir(), ".config", "opencode", "oh-my-opencode-cohub"));
+  searchDirs.push(path4.join(os4.homedir(), ".config", "opencode", "oh-my-opencode-cohub"));
   for (const agent of agentNames) {
     for (const dir of searchDirs) {
-      const replacePath = path3.join(dir, `${agent}.md`);
-      if (!overrides[agent]?.replace && fs3.existsSync(replacePath)) {
+      const replacePath = path4.join(dir, `${agent}.md`);
+      if (!overrides[agent]?.replace && fs5.existsSync(replacePath)) {
         try {
-          overrides[agent] = { ...overrides[agent], replace: fs3.readFileSync(replacePath, "utf-8") };
+          overrides[agent] = { ...overrides[agent], replace: fs5.readFileSync(replacePath, "utf-8") };
         } catch (err) {
           appendLog("loadFileOverrides", "读取replace文件失败", err);
         }
       }
-      const appendPath = path3.join(dir, `${agent}_append.md`);
-      if (!overrides[agent]?.append && fs3.existsSync(appendPath)) {
+      const appendPath = path4.join(dir, `${agent}_append.md`);
+      if (!overrides[agent]?.append && fs5.existsSync(appendPath)) {
         try {
-          overrides[agent] = { ...overrides[agent], append: fs3.readFileSync(appendPath, "utf-8") };
+          overrides[agent] = { ...overrides[agent], append: fs5.readFileSync(appendPath, "utf-8") };
         } catch (err) {
           appendLog("loadFileOverrides", "读取append文件失败", err);
         }
@@ -1668,26 +2452,26 @@ var CoHubPlugin = async (input, options) => {
   }
   const promptOverrides = { ...configOverrides, ...fileOverrides };
   const tracker = new TaskTracker;
-  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 STATE_DIR = path4.join(os4.homedir(), ".local", "share", "opencode", "storage", "oh-my-opencode-cohub");
+  const STATE_FILE = path4.join(STATE_DIR, "tracker-state.json");
   function syncTrackerState(sessionId) {
     try {
-      if (!fs3.existsSync(STATE_DIR)) {
-        fs3.mkdirSync(STATE_DIR, { recursive: true });
+      if (!fs5.existsSync(STATE_DIR)) {
+        fs5.mkdirSync(STATE_DIR, { recursive: true });
       }
       const state = {
         updatedAt: Date.now(),
         runningAgents: tracker.getRunningAgents(sessionId),
         runningCount: tracker.getRunningCount(sessionId)
       };
-      fs3.writeFileSync(STATE_FILE, JSON.stringify(state), "utf-8");
+      fs5.writeFileSync(STATE_FILE, JSON.stringify(state), "utf-8");
     } catch {}
   }
-  const AGENT_CONFIG_FILE = path3.join(STATE_DIR, "cohub-state.json");
+  const AGENT_CONFIG_FILE = path4.join(STATE_DIR, "cohub-state.json");
   function syncAgentConfig() {
     try {
-      if (!fs3.existsSync(STATE_DIR)) {
-        fs3.mkdirSync(STATE_DIR, { recursive: true });
+      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;
@@ -1702,7 +2486,7 @@ var CoHubPlugin = async (input, options) => {
           provider
         };
       });
-      fs3.writeFileSync(AGENT_CONFIG_FILE, JSON.stringify({ updatedAt: Date.now(), agents: configs }), "utf-8");
+      fs5.writeFileSync(AGENT_CONFIG_FILE, JSON.stringify({ updatedAt: Date.now(), agents: configs }), "utf-8");
       appendLog("syncAgentConfig", `已同步 ${configs.length} 个 agent: ${JSON.stringify(configs.map((c) => ({ name: c.name, model: c.model, variant: c.variant })))}`);
     } catch {}
   }
@@ -1853,12 +2637,18 @@ var CoHubPlugin = async (input, options) => {
     }
   }, 60000);
   const agentConfigs = {};
+  const COUNCIL_ONLY_TOOLS = { council_session: "deny" };
   for (const agent of agents) {
-    agentConfigs[agent.name] = {
+    const base = {
       ...agent.config,
       name: agent.name,
       description: agent.description
     };
+    if (agent.name !== "co-council") {
+      const existingPermission = base.permission ?? {};
+      base.permission = { ...existingPermission, ...COUNCIL_ONLY_TOOLS };
+    }
+    agentConfigs[agent.name] = base;
   }
   return {
     name: "oh-my-opencode-cohub",
@@ -1878,10 +2668,17 @@ var CoHubPlugin = async (input, options) => {
           merged.model = pc.model;
         if (pc.variant)
           merged.variant = pc.variant;
+        if (name !== "co-council") {
+          const existingPerm = merged.permission ?? {};
+          merged.permission = { ...existingPerm, ...COUNCIL_ONLY_TOOLS };
+        } else {
+          const existingPerm = merged.permission ?? {};
+          merged.permission = { ...existingPerm, council_session: "allow" };
+        }
         c.agent[name] = merged;
       }
       try {
-        fs3.writeFileSync(path3.join(STATE_DIR, "config-hook-ran.json"), JSON.stringify({ ran: true, count: agents.length }));
+        fs5.writeFileSync(path4.join(STATE_DIR, "config-hook-ran.json"), JSON.stringify({ ran: true, count: agents.length }));
       } catch (err) {
         appendLog("config", "双重注册写入文件失败", err);
       }
@@ -1932,19 +2729,19 @@ var CoHubPlugin = async (input, options) => {
               if (details) {
                 output.args[targetField] += details;
               }
-              const logPath = path3.join(os3.tmpdir(), "opencode", "ctx-diag.log");
+              const logPath = path4.join(os4.tmpdir(), "opencode", "ctx-diag.log");
               try {
-                const stat = fs3.statSync(logPath);
+                const stat = fs5.statSync(logPath);
                 if (stat.size > 50 * 1024) {
-                  const lines = fs3.readFileSync(logPath, "utf-8").trim().split(`
+                  const lines = fs5.readFileSync(logPath, "utf-8").trim().split(`
 `);
-                  fs3.writeFileSync(logPath, lines.slice(-30).join(`
+                  fs5.writeFileSync(logPath, lines.slice(-30).join(`
 `) + `
 `);
                 }
               } catch {}
               const finalPrompt = typeof output.args?.prompt === "string" ? output.args.prompt : "";
-              fs3.appendFileSync(logPath, JSON.stringify({
+              fs5.appendFileSync(logPath, JSON.stringify({
                 time: new Date().toISOString(),
                 session: input2.sessionID?.slice(0, 20) ?? "?",
                 subagent: subagentType,
@@ -1992,7 +2789,25 @@ var CoHubPlugin = async (input, options) => {
           syncTrackerState(tracker.currentParentSessionId);
           const job = tracker.getJobBySessionId(sessionId);
           if (job) {
-            contextEngine.captureResult(sessionId, job.alias, job.agent);
+            contextEngine.captureResult(sessionId, job.alias, job.agent).then((captured) => {
+              if (!captured)
+                return;
+              if (!isQualityEnabled(userConfig.quality))
+                return;
+              const quality = assessQuality({
+                output: captured.output,
+                decisions: captured.decisions,
+                latencyMs: Date.now() - job.createdAt,
+                tokens: captured.tokens
+              });
+              tracker.updateQuality(sessionId, {
+                score: quality.score,
+                ...quality.failureCategory ? { failureCategory: quality.failureCategory } : {},
+                ...quality.latencyMs !== undefined ? { latencyMs: quality.latencyMs } : {},
+                ...quality.tokens ? { tokens: quality.tokens } : {}
+              });
+              syncTrackerState(tracker.currentParentSessionId);
+            }).catch((err) => appendLog("event", "质量回送失败", err));
           }
         } else if (e.type === "session.deleted") {
           tracker.updateByChildSessionId(sessionId, "errored");
@@ -2096,6 +2911,6 @@ var CoHubPlugin = async (input, options) => {
 var server = CoHubPlugin;
 var src_default = CoHubPlugin;
 export {
-  server,
-  src_default as default
+  src_default as default,
+  server
 };