@zqagent/core 0.2.5 → 0.2.7

package/dist/tools/explore.js

@@ -283,8 +283,11 @@ function lookupContextWindow(modelId) {
   return DEFAULT_CONTEXT_WINDOW;
 }
 var KEEP_RECENT_FRACTION = 0.25;
-var SPAN_TOOL_RESULT_CLIP = 400;
-var SPAN_BUDGET_CHARS = 4e5;
+var SOFT_THRESHOLD_RATIO = 0.75;
+var ELIDE_KEEP_FRACTION = 0.15;
+var SUMMARY_MAX_TOKENS = 3e3;
+var SPAN_TOOL_RESULT_CLIP = 200;
+var SPAN_BUDGET_CHARS = 8e4;
 var USER_MESSAGE_CLIP = 600;
 var USER_MESSAGES_MAX = 40;
 var TRIM_FRACTION = 0.1;
@@ -307,9 +310,22 @@ function triggerTokens(contextWindow, thresholdPct = DEFAULT_THRESHOLD_PCT, capT
   }
   return base;
 }
+function softTriggerTokens(contextWindow, thresholdPct = DEFAULT_THRESHOLD_PCT, capTokens, softThresholdPct) {
+  const hard = triggerTokens(contextWindow, thresholdPct, capTokens);
+  if (softThresholdPct != null && Number.isFinite(softThresholdPct) && softThresholdPct > 0) {
+    return Math.min(
+      triggerTokens(contextWindow, softThresholdPct, capTokens),
+      Math.floor(hard * 0.95)
+    );
+  }
+  return Math.floor(hard * SOFT_THRESHOLD_RATIO);
+}
 function shouldCompact(signal, contextWindow, thresholdPct, capTokens) {
   return signal >= triggerTokens(contextWindow, thresholdPct, capTokens);
 }
+function elisionKeepChars(hardTriggerTokens, fraction = ELIDE_KEEP_FRACTION) {
+  return Math.max(4e3, Math.floor(hardTriggerTokens * fraction * 4));
+}
 function turnStarts(messages, start) {
   const users = [];
   const assistants = [];
@@ -459,10 +475,11 @@ var SUMMARY_SYSTEM_PROMPT = `\u4F60\u6B63\u5728\u538B\u7F29\u4E00\u4E2A AI \u534
 
 \u89C4\u5219\uFF1A
 - \u4E0D\u8981\u5C06\u5B8C\u6574\u7684\u6587\u4EF6\u5185\u5BB9\u5F53\u4F5C\u771F\u7406\u3002\u53EA\u8BB0\u5F55\u67D0\u4E2A\u6587\u4EF6\u88AB\u8BFB\u53D6/\u7F16\u8F91\u8FC7\u8FD9\u4E00\u4E8B\u5B9E\uFF1B\u534F\u4F5C\u8005\u5982\u679C\u9700\u8981\u518D\u6B21\u83B7\u53D6\u5185\u5BB9\u4F1A\u91CD\u65B0\u8BFB\u53D6\u3002\u9648\u65E7\u7684\u6587\u4EF6\u8BB0\u5FC6\u6BD4\u6CA1\u6709\u8BB0\u5FC6\u66F4\u7CDF\u7CD5\u3002
+- \u82E5\u63D0\u4F9B\u4E86\u4E0A\u4E00\u7248\u6458\u8981\uFF1A\u53EA\u628A\u5B83\u4ECD\u7136\u6709\u6548\u7684\u7ED3\u8BBA\u5E76\u5165\u5BF9\u5E94\u7AE0\u8282\uFF0C\u4E0D\u8981\u6574\u6BB5\u590D\u8FF0\u6216\u9010\u6761\u8F6C\u6284\u3002
 - \u8981\u5177\u4F53\uFF1A\u8DEF\u5F84\u3001\u540D\u79F0\u3001\u547D\u4EE4\u3001id\u2014\u2014\u800C\u4E0D\u662F\u6A21\u7CCA\u7684\u5F15\u7528\u3002
 - \u4EC5\u8F93\u51FA\u6458\u8981\u7AE0\u8282\uFF0C\u4E0D\u9644\u52A0\u524D\u8A00\u3002`;
 var CONTINUATION_CONTRACT = "\u4ECE\u4F60\u4E4B\u524D\u4E2D\u65AD\u7684\u5730\u65B9\u7EE7\u7EED\uFF1A\u5B8C\u5168\u6309\u7167\u63CF\u8FF0\u63A5\u7EED\u5F53\u524D\u5DE5\u4F5C\u548C\u4E0B\u4E00\u6B65\u3002\u4E0D\u8981\u91CD\u65B0\u8BE2\u95EE\u5DF2\u56DE\u7B54\u7684\u95EE\u9898\uFF0C\u4E0D\u8981\u56DE\u987E\uFF0C\u4E0D\u8981\u63D0\u53CA\u4E0A\u4E0B\u6587\u5DF2\u88AB\u538B\u7F29\u3002\u5982\u679C\u4F60\u9700\u8981\u4E0A\u8FF0\u63D0\u5230\u7684\u6587\u4EF6\u7684\u5185\u5BB9\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u5B83\u3002";
-function renderSpan(span, budgetChars = SPAN_BUDGET_CHARS) {
+function renderSpan(span, budgetChars2 = SPAN_BUDGET_CHARS) {
   const lines = [];
   for (const m of span) {
     const role = m.role;
@@ -486,8 +503,8 @@ function renderSpan(span, budgetChars = SPAN_BUDGET_CHARS) {
     if (text) lines.push(`[${role}] ${text}`);
   }
   let rendered = lines.join("\n");
-  if (rendered.length > budgetChars) {
-    rendered = "(\u2026oldest turns elided\u2026)\n" + rendered.slice(-budgetChars);
+  if (rendered.length > budgetChars2) {
+    rendered = "(\u2026oldest turns elided\u2026)\n" + rendered.slice(-budgetChars2);
   }
   return rendered;
 }
@@ -501,9 +518,17 @@ function summarizerMessages(span, priorSummary = "") {
     { role: "user", content: body }
   ];
 }
+function summarizerReasoningEffort() {
+  const v = process.env.COMPACTION_REASONING_EFFORT?.toLowerCase();
+  if (v === "low" || v === "medium" || v === "high") return v;
+  return "low";
+}
 async function summarizeSpan(provider, model, span, priorSummary = "", opts) {
   const msgs = summarizerMessages(span, priorSummary);
-  const chunks = await provider.stream(model, msgs, [], opts);
+  const chunks = await provider.stream(model, msgs, [], {
+    ...opts,
+    maxTokens: SUMMARY_MAX_TOKENS
+  });
   let text = "";
   for await (const chunk of chunks) {
     if (chunk.content) text += chunk.content;
@@ -614,6 +639,166 @@ function applyToOutbound(messages, state) {
   head.push({ role: "user", content: compactedBlock(state) });
   return [...head, ...messages.slice(boundary)];
 }
+var ELIDE_EXEMPT_TOOLS = /* @__PURE__ */ new Set([
+  "explore",
+  "ask_user",
+  "propose_plan",
+  "request_directory",
+  "todo_write"
+]);
+function elidedToolContent(m) {
+  const name = m.tool_call_name || "tool";
+  const size = m.content.length;
+  const saved = /full output saved to ([^\]]+)/.exec(m.content)?.[1]?.trim();
+  return saved ? `[old tool result elided: ${name}, ${size} chars; full output saved to ${saved}]` : `[old tool result elided: ${name}, ${size} chars; re-run the tool if its content is still needed]`;
+}
+function isPlaceholder(content) {
+  return content.startsWith("[old tool result elided") || content.startsWith("[superseded by a later read_file");
+}
+var ONE_SHOT_TOOLS = /* @__PURE__ */ new Set(["git_diff"]);
+var ONE_SHOT_KEEP_RECENT = 1;
+function applyOneShotElision(messages, keepRecent = ONE_SHOT_KEEP_RECENT, tools = ONE_SHOT_TOOLS) {
+  const out = [...messages];
+  let seen = 0;
+  let elided = 0;
+  let freed = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool" || !tools.has(m.tool_call_name ?? "")) continue;
+    if (isPlaceholder(m.content)) continue;
+    seen++;
+    if (seen <= keepRecent) continue;
+    const placeholder = elidedToolContent(m);
+    freed += m.content.length - placeholder.length;
+    out[i] = { ...m, content: placeholder };
+    elided++;
+  }
+  return elided > 0 ? { messages: out, elided, freedChars: freed } : { messages, elided: 0, freedChars: 0 };
+}
+function applyToolResultElision(messages, keepChars, exempt = ELIDE_EXEMPT_TOOLS) {
+  let total = 0;
+  for (const m of messages) {
+    if (m.role === "tool" && !exempt.has(m.tool_call_name ?? "")) {
+      total += m.content.length;
+    }
+  }
+  if (total <= keepChars) return { messages, elided: 0, freedChars: 0 };
+  const out = [...messages];
+  let budget = 0;
+  let elided = 0;
+  let freed = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool") continue;
+    if (exempt.has(m.tool_call_name ?? "")) continue;
+    if (elided === 0 && budget === 0 && m.content.length > keepChars) {
+      const kept = m.content.slice(0, keepChars) + "\n\u2026(truncated)";
+      freed += m.content.length - kept.length;
+      out[i] = { ...m, content: kept };
+      budget = keepChars;
+      continue;
+    }
+    if (budget + m.content.length <= keepChars) {
+      budget += m.content.length;
+      continue;
+    }
+    const placeholder = elidedToolContent(m);
+    freed += m.content.length - placeholder.length;
+    out[i] = { ...m, content: placeholder };
+    elided++;
+  }
+  return { messages: out, elided, freedChars: freed };
+}
+function normalizeToolPath(p) {
+  let s = p.trim().replace(/\\/g, "/");
+  while (s.startsWith("./")) s = s.slice(2);
+  return s.replace(/\/{2,}/g, "/");
+}
+var MUTATING_TOOLS = /* @__PURE__ */ new Set([
+  "write_file",
+  "replace_in_file",
+  "apply_patch",
+  "apply_unified_diff",
+  "run_shell"
+]);
+function parseReadFileSpan(content) {
+  const body = content.replace(/^\[tool output truncated:[^\n]*\]\n\n/, "");
+  let path10;
+  let start;
+  let end;
+  try {
+    const obj = JSON.parse(body);
+    path10 = obj.path;
+    start = obj.start_line;
+    end = obj.end_line;
+  } catch {
+    const str = (key) => new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(body)?.[1];
+    const num = (key) => {
+      const m = new RegExp(`"${key}"\\s*:\\s*(\\d+)`).exec(body);
+      return m ? Number(m[1]) : void 0;
+    };
+    path10 = str("path");
+    start = num("start_line");
+    end = num("end_line");
+  }
+  if (typeof path10 !== "string" || !path10) return null;
+  if (typeof start !== "number" || typeof end !== "number") return null;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
+  return { path: path10, start, end };
+}
+function addSpan(spans, start, end) {
+  spans.push([start, end]);
+  spans.sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const cur of spans) {
+    const last = merged[merged.length - 1];
+    if (last && cur[0] <= last[1] + 1) {
+      last[1] = Math.max(last[1], cur[1]);
+    } else {
+      merged.push([...cur]);
+    }
+  }
+  spans.length = 0;
+  spans.push(...merged);
+}
+function coversSpans(spans, start, end) {
+  return spans.some(([a, b]) => a <= start && b >= end);
+}
+function applyReadFileDedup(messages) {
+  let candidates = 0;
+  for (const m of messages) {
+    if (m.role === "tool" && m.tool_call_name === "read_file") candidates++;
+  }
+  if (candidates < 2) return { messages, elided: 0 };
+  const out = [...messages];
+  const covered = /* @__PURE__ */ new Map();
+  let elided = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role === "assistant") {
+      if (m.tool_calls?.some((tc) => MUTATING_TOOLS.has(tc.function.name))) {
+        covered.clear();
+      }
+      continue;
+    }
+    if (m.role !== "tool" || m.tool_call_name !== "read_file") continue;
+    const span = parseReadFileSpan(m.content);
+    if (!span) continue;
+    const key = normalizeToolPath(span.path);
+    const seen = covered.get(key) ?? [];
+    if (coversSpans(seen, span.start, span.end)) {
+      out[i] = {
+        ...m,
+        content: `[superseded by a later read_file of ${span.path} (lines ${span.start}-${span.end})]`
+      };
+      elided++;
+      continue;
+    }
+    addSpan(seen, span.start, span.end);
+    covered.set(key, seen);
+  }
+  return { messages: elided > 0 ? out : messages, elided };
+}
 var OVERFLOW_MARKERS = [
   "context_length_exceeded",
   "maximum context length",
@@ -629,9 +814,108 @@ function isContextOverflow(exc) {
   return OVERFLOW_MARKERS.some((m) => text.includes(m));
 }
 
+// src/engine/toolResultBudget.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/paths.ts
+import * as os from "os";
+import * as path from "path";
+var APP_DIR_NAME = "zqagent";
+var IS_WINDOWS = process.platform === "win32";
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || os.tmpdir();
+}
+function stateDir() {
+  const base = process.env.XDG_STATE_HOME || (IS_WINDOWS ? process.env.LOCALAPPDATA : void 0) || path.join(homeDir(), ".local", "state");
+  return path.join(base, APP_DIR_NAME);
+}
+
+// src/engine/toolResultBudget.ts
+var DEFAULT_TOOL_RESULT_MAX_CHARS = 24e3;
+var HEAD_RATIO = 0.6;
+function budgetChars() {
+  const n = Number(process.env.TOOL_RESULT_MAX_CHARS);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_TOOL_RESULT_MAX_CHARS;
+}
+function toolResultDir() {
+  const env = process.env.TOOL_RESULT_DIR?.trim();
+  return env || path2.join(stateDir(), "tool-results");
+}
+function clipText(text, budget) {
+  if (text.length <= budget) return text;
+  const room = Math.max(
+    0,
+    budget - `
+
+\u2026 [${text.length} characters omitted] \u2026
+
+`.length
+  );
+  const headLen = Math.floor(room * HEAD_RATIO);
+  const tailLen = room - headLen;
+  const omitted = text.length - headLen - tailLen;
+  return text.slice(0, headLen) + `
+
+\u2026 [${omitted} characters omitted] \u2026
+
+` + text.slice(-tailLen);
+}
+function clipDeep(value, perField) {
+  if (typeof value === "string") {
+    return value.length <= perField ? value : clipText(value, perField);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => clipDeep(v, perField));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = clipDeep(v, perField);
+    return out;
+  }
+  return value;
+}
+function saveRaw(tool, raw, dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    const safe = tool.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40) || "tool";
+    const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}-${safe}.txt`;
+    const file = path2.join(dir, name);
+    fs.writeFileSync(file, raw, "utf-8");
+    return file;
+  } catch {
+    return void 0;
+  }
+}
+function applyToolResultBudget(tool, result, opts = {}) {
+  const budget = opts.maxChars ?? budgetChars();
+  const raw = typeof result === "string" ? result : JSON.stringify(result, null, 2) ?? String(result);
+  if (raw.length <= budget) {
+    return { content: raw, truncated: false };
+  }
+  let content = raw;
+  if (typeof result === "object" && result !== null) {
+    let perField = Math.floor(budget * 0.7);
+    let clipped = JSON.stringify(clipDeep(result, perField), null, 2);
+    for (let i = 0; i < 6 && clipped && clipped.length > budget && perField > 128; i++) {
+      perField = Math.floor(perField / 2);
+      clipped = JSON.stringify(clipDeep(result, perField), null, 2);
+    }
+    if (clipped && clipped.length <= budget) content = clipped;
+  }
+  if (content.length > budget) content = clipText(content, budget);
+  const savedPath = saveRaw(tool, raw, opts.dir ?? toolResultDir());
+  if (savedPath) {
+    content = `[tool output truncated: ${raw.length} chars, full output saved to ${savedPath}]
+
+` + content;
+  }
+  return { content, truncated: true, savedPath };
+}
+
 // src/engine/TurnEngine.ts
 import * as crypto from "crypto";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as _path from "path";
 
 // src/prompts/index.ts
@@ -676,13 +960,17 @@ var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set([
   "propose_plan",
   "request_directory"
 ]);
-function toolResultMessage(tc, result, taskId) {
-  const content = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+var MAX_COMPACT_ROUNDS = 4;
+var OVERFLOW_TARGET_RATIO = 0.5;
+var OVERFLOW_TRIM_FRACTION = 0.5;
+var COMPACT_STALL_RETRY_DELTA = 20;
+function toolResultMessage(tc, result, taskId, toolResultDir2) {
+  const budgeted = applyToolResultBudget(tc.name, result, { dir: toolResultDir2 });
   return {
     role: "tool",
     tool_call_id: tc.id,
     tool_call_name: tc.name,
-    content,
+    content: budgeted.content,
     taskId
   };
 }
@@ -793,12 +1081,22 @@ var TurnEngine = class _TurnEngine {
   // 上下文压缩
   compactionState = null;
   _lastContextTokens = null;
+  /** 压缩无进展时的消息条数快照；-1 表示无冷却 */
+  _compactStalledAt = -1;
   /** 显式配置的上下文窗口大小（token 数），未设置时为 undefined（走自动检测） */
   _contextWindow;
   /** 压缩触发阈值比例（默认 0.8） */
   _thresholdPct;
+  /** 软阈值比例（undefined = 取硬阈值的 75%） */
+  _softThresholdPct;
+  /** 是否启用软阈值淘汰（COMPACTION_ELIDE=0 可关闭） */
+  _elisionEnabled;
+  /** 是否启用重复读取去重（COMPACTION_DEDUP=0 可关闭） */
+  _dedupEnabled;
   /** 压缩触发阈值绝对上限（null = 不限制） */
   _capTokens;
+  /** 超预算工具结果的落盘目录（undefined = 使用默认状态目录） */
+  _toolResultDir;
   // 产出文件追踪（本轮 Turn 中成功写入的文件）
   _producedFiles = [];
   _turnStartTime = 0;
@@ -850,7 +1148,15 @@ var TurnEngine = class _TurnEngine {
     this._hook = opts.hook;
     this._contextWindow = opts.contextWindow;
     this._thresholdPct = opts.thresholdPct ?? DEFAULT_THRESHOLD_PCT;
+    this._softThresholdPct = opts.softThresholdPct;
+    this._elisionEnabled = !/^(0|false|off|no)$/i.test(
+      (process.env.COMPACTION_ELIDE ?? "").trim()
+    );
+    this._dedupEnabled = !/^(0|false|off|no)$/i.test(
+      (process.env.COMPACTION_DEDUP ?? "").trim()
+    );
     this._capTokens = opts.capTokens ?? null;
+    this._toolResultDir = opts.toolResultDir;
     this._reasoningEffort = opts.reasoningEffort;
     if (this.messages.length === 0 || this.messages[0].role !== "system") {
       this.messages.unshift({ role: "system", content: this.instructions });
@@ -906,6 +1212,7 @@ var TurnEngine = class _TurnEngine {
     this._cancel = false;
     this._producedFiles = [];
     this._turnStartTime = Date.now();
+    this._compactStalledAt = -1;
     this._emitHook((h) => h.onTurnStart?.(userInput));
     yield {
       type: "turn_start" /* TURN_START */,
@@ -1622,7 +1929,9 @@ var TurnEngine = class _TurnEngine {
       for (let i = 0; i < concurrent.length; i++) {
         const tc = concurrent[i];
         const { result, status } = results[i];
-        this.messages.push(toolResultMessage(tc, result, this.taskId));
+        this.messages.push(
+          toolResultMessage(tc, result, this.taskId, this._toolResultDir)
+        );
         this._trackProducedFile(
           tc,
           result,
@@ -1685,7 +1994,9 @@ var TurnEngine = class _TurnEngine {
         };
         status = "error";
       }
-      this.messages.push(toolResultMessage(tc, result, this.taskId));
+      this.messages.push(
+        toolResultMessage(tc, result, this.taskId, this._toolResultDir)
+      );
       this._trackProducedFile(
         tc,
         result,
@@ -1720,13 +2031,41 @@ var TurnEngine = class _TurnEngine {
    * 过滤 notice 消息；tool 消息只保留必要字段；
    * 其余消息剥离 display-only sidecar 字段（source/_display/ts/
    * reasoning/usage），避免污染模型上下文。
+   *
+   * 达到软阈值时先淘汰旧工具结果（零 LLM 成本），再产出最终视图。
    */
   _outboundMessages() {
-    const _STRIP = /* @__PURE__ */ new Set(["source", "_display", "ts", "reasoning", "usage"]);
-    const sourceMessages = applyToOutbound(
-      this.messages,
-      this.compactionState
+    const base = applyToOutbound(this.messages, this.compactionState);
+    const deduped = this._dedupEnabled ? applyReadFileDedup(base).messages : base;
+    let view = this._finalizeOutbound(deduped);
+    if (!this._elisionEnabled) return view;
+    if (estimateTokens(view) < this._softTriggerTokens()) {
+      return view;
+    }
+    const oneShot = applyOneShotElision(deduped);
+    if (oneShot.freedChars > 0) {
+      view = this._finalizeOutbound(oneShot.messages);
+      if (estimateTokens(view) < this._softTriggerTokens()) {
+        return view;
+      }
+    }
+    const keepChars = elisionKeepChars(
+      triggerTokens(
+        this._getContextWindow(),
+        this._thresholdPct,
+        this._capTokens
+      )
     );
+    const elided = applyToolResultElision(
+      oneShot.messages,
+      keepChars
+    );
+    if (elided.freedChars === 0) return view;
+    return this._finalizeOutbound(elided.messages);
+  }
+  /** 过滤 notice + 剥离 display-only 字段，得到最终发送视图 */
+  _finalizeOutbound(sourceMessages) {
+    const _STRIP = /* @__PURE__ */ new Set(["source", "_display", "ts", "reasoning", "usage"]);
     return sourceMessages.filter((m) => m.role !== "notice").map((m) => {
       if (m.role === "tool") {
         return {
@@ -1744,6 +2083,15 @@ var TurnEngine = class _TurnEngine {
       return stripped;
     });
   }
+  /** 软阈值（token 数）：达到它只淘汰旧工具结果 */
+  _softTriggerTokens() {
+    return softTriggerTokens(
+      this._getContextWindow(),
+      this._thresholdPct,
+      this._capTokens,
+      this._softThresholdPct
+    );
+  }
   /** 通知消息：仅用于日志/展示，不发给模型 */
   _appendNotice(kind, text) {
     this.messages.push({
@@ -1785,18 +2133,36 @@ var TurnEngine = class _TurnEngine {
     return false;
   }
   // ===================== 自动压缩 =====================
-  /** 当前上下文 token 用量：优先采信 API 返回的精确数量，否则用 chars/4 估算 */
+  /**
+   * 当前上下文 token 用量。
+   *
+   * API 返回的 `usage.input` 是精确值，但反映的是「上一次请求」——工具结果
+   * 与淘汰/压缩都会让它过时。因此同时估算当前 outbound 视图，取较大者：
+   * 宁可早一点压缩，也不要漏判导致溢出。
+   */
   _compactionTokens() {
-    if (this._lastContextTokens != null) {
-      return { tokens: this._lastContextTokens, estimated: false };
+    const estimated = estimateTokens(this._outboundMessages());
+    if (this._lastContextTokens == null) {
+      return { tokens: estimated, estimated: true };
     }
-    return {
-      tokens: estimateTokens(this._outboundMessages()),
-      estimated: true
-    };
+    if (estimated > this._lastContextTokens) {
+      return { tokens: estimated, estimated: true };
+    }
+    return { tokens: this._lastContextTokens, estimated: false };
+  }
+  /** 压缩后重置精确计数：后续按估算值判断 */
+  _resetContextTokens() {
+    this._lastContextTokens = null;
+  }
+  /** 当前 outbound 视图的估算 token 数 */
+  _estimateContextTokens() {
+    return estimateTokens(this._outboundMessages());
   }
   /** 检查是否需要压缩（每轮 LLM 调用前） */
   _compactionDue() {
+    if (this._compactStalledAt >= 0 && this.messages.length < this._compactStalledAt + COMPACT_STALL_RETRY_DELTA) {
+      return false;
+    }
     const { tokens } = this._compactionTokens();
     return shouldCompact(
       tokens,
@@ -1843,63 +2209,82 @@ var TurnEngine = class _TurnEngine {
   async _compactNow(reqId, force = false) {
     const contextWindow = this._getContextWindow();
     const messagesBefore = this._outboundMessages().length;
-    const keep = Math.floor(
-      KEEP_RECENT_FRACTION * triggerTokens(
-        contextWindow,
-        this._thresholdPct,
-        this._capTokens
-      )
+    const trigger = triggerTokens(
+      contextWindow,
+      this._thresholdPct,
+      this._capTokens
     );
-    const model = this.model;
-    let state = null;
-    let failed = false;
-    for (let attempt = 0; attempt < 2; attempt++) {
-      try {
-        const logTime = (/* @__PURE__ */ new Date()).toISOString();
-        state = await buildState(
+    const target = Math.floor(
+      trigger * (force ? OVERFLOW_TARGET_RATIO : 0.9)
+    );
+    const model = process.env.COMPACTION_MODEL?.trim() || this.model;
+    const reasoningEffort = summarizerReasoningEffort();
+    let keep = Math.floor(KEEP_RECENT_FRACTION * trigger);
+    let method = null;
+    let lastState = null;
+    let progressed = false;
+    for (let round = 0; round < MAX_COMPACT_ROUNDS; round++) {
+      if (round > 0 && this._estimateContextTokens() <= target) break;
+      let state = null;
+      for (let attempt = 0; attempt < 2 && !state; attempt++) {
+        try {
+          const logTime = (/* @__PURE__ */ new Date()).toISOString();
+          state = await buildState(
+            this.messages,
+            this.provider,
+            model,
+            keep,
+            this.compactionState,
+            { reqId, logTime, reasoningEffort }
+          );
+        } catch {
+        }
+      }
+      if (state) {
+        this.compactionState = state;
+        lastState = state;
+        method = "summarized";
+        progressed = true;
+      } else {
+        const trimmed = trimState(
           this.messages,
-          this.provider,
-          model,
-          keep,
           this.compactionState,
-          { reqId, logTime, reasoningEffort: this._reasoningEffort }
+          force ? OVERFLOW_TRIM_FRACTION : 0.25
         );
-        failed = false;
-        break;
-      } catch {
-        failed = true;
+        if (!trimmed) break;
+        this.compactionState = trimmed;
+        lastState = trimmed;
+        method = "trimmed";
+        progressed = true;
       }
-    }
-    if (state) {
-      this.compactionState = state;
-      this._lastContextTokens = null;
+      this._resetContextTokens();
+      if (this._estimateContextTokens() <= trigger) break;
+      keep = Math.max(Math.floor(trigger * 0.05), Math.floor(keep / 2));
+    }
+    if (!progressed || !lastState) return { notice: null, method: null };
+    this._compactStalledAt = this._estimateContextTokens() >= trigger ? this.messages.length : -1;
+    const messagesAfter = this._outboundMessages().length;
+    const common = {
+      boundaryIndex: lastState.boundaryIndex,
+      messagesBefore,
+      messagesAfter
+    };
+    if (method === "summarized") {
       return {
         notice: "\u4E0A\u4E0B\u6587\u5DF2\u538B\u7F29 \u2014 \u65E9\u671F\u8F6E\u6B21\u5DF2\u6458\u8981",
         method: "summarized",
-        modelUsed: state.modelUsed,
-        boundaryIndex: state.boundaryIndex,
-        summaryPreview: state.summaryText.slice(0, 200),
-        keptUserMessages: state.userMessages.length,
-        droppedUserMessages: state.userMessagesDropped,
-        messagesBefore,
-        messagesAfter: this._outboundMessages().length
+        modelUsed: lastState.modelUsed,
+        summaryPreview: lastState.summaryText.slice(0, 200),
+        keptUserMessages: lastState.userMessages.length,
+        droppedUserMessages: lastState.userMessagesDropped,
+        ...common
       };
     }
-    if (failed || force) {
-      const trimmed = trimState(this.messages, this.compactionState);
-      if (trimmed) {
-        this.compactionState = trimmed;
-        this._lastContextTokens = null;
-        return {
-          notice: "\u4E0A\u4E0B\u6587\u5DF2\u88C1\u526A \u2014 \u6700\u65E7\u7684\u8F6E\u6B21\u5DF2\u4E22\u5F03\uFF08\u6458\u8981\u4E0D\u53EF\u7528\uFF09",
-          method: "trimmed",
-          boundaryIndex: trimmed.boundaryIndex,
-          messagesBefore,
-          messagesAfter: this._outboundMessages().length
-        };
-      }
-    }
-    return { notice: null, method: null };
+    return {
+      notice: "\u4E0A\u4E0B\u6587\u5DF2\u88C1\u526A \u2014 \u6700\u65E7\u7684\u8F6E\u6B21\u5DF2\u4E22\u5F03\uFF08\u6458\u8981\u4E0D\u53EF\u7528\uFF09",
+      method: "trimmed",
+      ...common
+    };
   }
   /** 追踪文件写入工具成功产生的文件 */
   _trackProducedFile(tc, result, status) {
@@ -1909,9 +2294,9 @@ var TurnEngine = class _TurnEngine {
       return;
     }
     if (result && typeof result === "object") {
-      const path8 = result.path;
-      if (path8) {
-        this._producedFiles.push(path8);
+      const path10 = result.path;
+      if (path10) {
+        this._producedFiles.push(path10);
         return;
       }
       const changed = result.changed_files;
@@ -1935,7 +2320,7 @@ var TurnEngine = class _TurnEngine {
   _fileExists(f, ws) {
     if (!ws && !_path.isAbsolute(f)) return true;
     try {
-      return fs.existsSync(_path.isAbsolute(f) ? f : _path.join(ws, f));
+      return fs2.existsSync(_path.isAbsolute(f) ? f : _path.join(ws, f));
     } catch {
       return false;
     }
@@ -1958,7 +2343,7 @@ var TurnEngine = class _TurnEngine {
         if (depth > 4 || results.length >= 50) return;
         let entries;
         try {
-          entries = fs.readdirSync(dir, { withFileTypes: true });
+          entries = fs2.readdirSync(dir, { withFileTypes: true });
         } catch {
           return;
         }
@@ -1973,7 +2358,7 @@ var TurnEngine = class _TurnEngine {
             const ext = dotIdx !== -1 ? e.name.slice(dotIdx).toLowerCase() : "";
             if (!_TurnEngine.SCAN_SUFFIXES.has(ext)) continue;
             try {
-              const st = fs.statSync(full);
+              const st = fs2.statSync(full);
               if (st.mtimeMs >= since) {
                 results.push(
                   _path.relative(_path.resolve(ws), _path.resolve(full))
@@ -2004,48 +2389,48 @@ function parseMaxIterations(value, fallback) {
 }
 
 // src/tools/pathSafety.ts
-import * as fs2 from "fs";
-import * as path from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 function isInsideRelative(rel) {
-  return !path.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path.sep}`);
+  return !path3.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path3.sep}`);
 }
 function isFilesystemRoot(p) {
-  return path.parse(p).root === p;
+  return path3.parse(p).root === p;
 }
 function resolveWithinRoot(workspace, target) {
-  const abs = path.resolve(workspace, target);
+  const abs = path3.resolve(workspace, target);
   let rootReal;
   try {
-    rootReal = fs2.realpathSync(workspace);
+    rootReal = fs3.realpathSync(workspace);
   } catch {
-    const rootAbs = path.resolve(workspace);
-    if (!isInsideRelative(path.relative(rootAbs, abs))) return null;
+    const rootAbs = path3.resolve(workspace);
+    if (!isInsideRelative(path3.relative(rootAbs, abs))) return null;
     return { root: rootAbs, real: abs };
   }
   if (isFilesystemRoot(rootReal)) return null;
   let real;
   try {
-    real = fs2.realpathSync(abs);
+    real = fs3.realpathSync(abs);
   } catch {
     let probe = abs;
     const tail = [];
     for (; ; ) {
-      const exists = fs2.existsSync(probe) || fs2.lstatSync(probe, { throwIfNoEntry: false }) !== void 0;
+      const exists = fs3.existsSync(probe) || fs3.lstatSync(probe, { throwIfNoEntry: false }) !== void 0;
       if (exists) {
         try {
-          real = path.join(fs2.realpathSync(probe), ...tail);
+          real = path3.join(fs3.realpathSync(probe), ...tail);
           break;
         } catch {
           return null;
         }
       }
-      tail.unshift(path.basename(probe));
-      const parent = path.dirname(probe);
+      tail.unshift(path3.basename(probe));
+      const parent = path3.dirname(probe);
       if (parent === probe) return null;
       probe = parent;
     }
   }
-  if (!isInsideRelative(path.relative(rootReal, real))) return null;
+  if (!isInsideRelative(path3.relative(rootReal, real))) return null;
   return { root: rootReal, real };
 }
 function isWithinRoot(workspace, target) {
@@ -2053,7 +2438,7 @@ function isWithinRoot(workspace, target) {
 }
 
 // src/permissions/PermissionEngine.ts
-import * as path2 from "path";
+import * as path4 from "path";
 var READ_ONLY_MODES = /* @__PURE__ */ new Set(["discuss" /* DISCUSS */, "plan" /* PLAN */]);
 var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "write_file",
@@ -2103,7 +2488,7 @@ var PermissionEngine = class {
   /** 会话级「总是允许此命令」集合 */
   sessionAllowCommands;
   constructor(opts) {
-    this.workspaceRoot = path2.resolve(opts.workspaceRoot);
+    this.workspaceRoot = path4.resolve(opts.workspaceRoot);
     this.mode = opts.mode;
     this.allowedCommands = Array.isArray(opts.allowedCommands) ? opts.allowedCommands : [];
     this.sessionAllowTools = /* @__PURE__ */ new Set();
@@ -2195,12 +2580,12 @@ var PermissionEngine = class {
 };
 
 // src/tools/files.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 var DEFAULT_MAX_LINES = 2e3;
 var MAX_LINE_CHARS = 500;
 function makeReadFile(workspace) {
-  const root = path3.resolve(workspace);
+  const root = path5.resolve(workspace);
   return function read_file(args) {
     const filePath = String(args.path ?? "");
     const startLine = Math.max(1, Number(args.start_line ?? 1));
@@ -2210,13 +2595,13 @@ function makeReadFile(workspace) {
       return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     }
     const target = resolved.real;
-    if (!fs3.existsSync(target) || !fs3.statSync(target).isFile()) {
+    if (!fs4.existsSync(target) || !fs4.statSync(target).isFile()) {
       return { error: `\u4E0D\u662F\u6587\u4EF6: ${filePath}` };
     }
     const selected = [];
     let total = 0;
     try {
-      const content = fs3.readFileSync(target, "utf-8");
+      const content = fs4.readFileSync(target, "utf-8");
       const lines = content.split("\n");
       total = lines.length;
       for (let i = startLine - 1; i < Math.min(startLine - 1 + maxLines, lines.length); i++) {
@@ -2231,7 +2616,7 @@ function makeReadFile(workspace) {
     }
     const end = startLine + selected.length - 1;
     const result = {
-      path: path3.relative(resolved.root, target),
+      path: path5.relative(resolved.root, target),
       start_line: startLine,
       end_line: end,
       total_lines: total,
@@ -2244,18 +2629,18 @@ function makeReadFile(workspace) {
   };
 }
 function makeListFiles(workspace) {
-  const root = path3.resolve(workspace);
+  const root = path5.resolve(workspace);
   return function list_files(args) {
     const dirPath = String(args.path ?? ".");
     const maxResults = Math.min(Number(args.max_results ?? 100), 100);
     const resolved = resolveWithinRoot(root, dirPath);
     if (!resolved) return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     const target = resolved.real;
-    if (!fs3.existsSync(target) || !fs3.statSync(target).isDirectory()) {
+    if (!fs4.existsSync(target) || !fs4.statSync(target).isDirectory()) {
       return { error: `\u4E0D\u662F\u76EE\u5F55: ${dirPath}` };
     }
     try {
-      const entries = fs3.readdirSync(target, { withFileTypes: true });
+      const entries = fs4.readdirSync(target, { withFileTypes: true });
       const results = [];
       for (const e of entries) {
         if (results.length >= maxResults) break;
@@ -2264,7 +2649,7 @@ function makeListFiles(workspace) {
         results.push(e.isDirectory() ? `${e.name}/` : e.name);
       }
       results.sort();
-      return { path: path3.relative(resolved.root, target), entries: results.slice(0, maxResults) };
+      return { path: path5.relative(resolved.root, target), entries: results.slice(0, maxResults) };
     } catch (exc) {
       return { error: `\u5217\u51FA\u6587\u4EF6\u5931\u8D25: ${String(exc)}` };
     }
@@ -2473,10 +2858,10 @@ function execAsync(file, argv, opts = {}) {
 }
 
 // src/tools/shellRuntime.ts
-import * as path4 from "path";
+import * as path6 from "path";
 var WINDOWS_SUFFIXES = [".exe", ".cmd", ".bat", ".com", ""];
 function pathApi(platform) {
-  return platform === "win32" ? path4.win32 : path4.posix;
+  return platform === "win32" ? path6.win32 : path6.posix;
 }
 function joinPath(platform, ...parts) {
   return pathApi(platform).join(...parts);
@@ -2642,8 +3027,8 @@ function decodeOutput(buf) {
 var shellTasks = new ShellTaskManager();
 
 // src/tools/nodeGrep.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path7 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -2668,27 +3053,27 @@ function nodeGrep(opts) {
   } catch (err) {
     throw new Error(`\u65E0\u6548\u7684\u6B63\u5219\u8868\u8FBE\u5F0F: ${opts.pattern}\uFF08${String(err)}\uFF09`);
   }
-  const target = path5.resolve(opts.workspace, opts.target);
-  if (!fs4.existsSync(target)) {
+  const target = path7.resolve(opts.workspace, opts.target);
+  if (!fs5.existsSync(target)) {
     throw new Error(`\u641C\u7D22\u8DEF\u5F84\u4E0D\u5B58\u5728: ${opts.target}`);
   }
   const matches = [];
   const scanFile = (file) => {
     let stat2;
     try {
-      stat2 = fs4.statSync(file);
+      stat2 = fs5.statSync(file);
     } catch {
       return false;
     }
     if (!stat2.isFile() || stat2.size > maxFileBytes) return false;
     let buf;
     try {
-      buf = fs4.readFileSync(file);
+      buf = fs5.readFileSync(file);
     } catch {
       return false;
     }
     if (looksBinary(buf)) return false;
-    const rel = path5.relative(opts.workspace, file) || path5.basename(file);
+    const rel = path7.relative(opts.workspace, file) || path7.basename(file);
     const lines = buf.toString("utf-8").split("\n");
     for (let i = 0; i < lines.length; i++) {
       const raw = lines[i].replace(/\r$/, "");
@@ -2699,7 +3084,7 @@ function nodeGrep(opts) {
     }
     return false;
   };
-  const stat = fs4.statSync(target);
+  const stat = fs5.statSync(target);
   if (stat.isFile()) {
     scanFile(target);
     return matches;
@@ -2709,12 +3094,12 @@ function nodeGrep(opts) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = path5.join(dir, entry.name);
+      const full = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) stack.push(full);
       } else if (entry.isFile()) {
@@ -2726,22 +3111,22 @@ function nodeGrep(opts) {
 }
 
 // src/tools/ripgrep.ts
-import * as fs5 from "fs";
-import * as os from "os";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as os2 from "os";
+import * as path8 from "path";
 import { createRequire } from "module";
 var cached;
 function extractBundledRipgrep() {
   try {
-    const req = typeof __require === "function" ? __require : createRequire(path6.join(process.cwd(), "__zqagent__.js"));
+    const req = typeof __require === "function" ? __require : createRequire(path8.join(process.cwd(), "__zqagent__.js"));
     const sea = req("node:sea");
     if (!sea?.isSea?.() || typeof sea.getAsset !== "function") return null;
     const asset = sea.getAsset("rg");
     if (!asset) return null;
-    const dir = fs5.mkdtempSync(path6.join(os.tmpdir(), "zqagent-rg-"));
-    const file = path6.join(dir, process.platform === "win32" ? "rg.exe" : "rg");
-    fs5.writeFileSync(file, Buffer.from(asset));
-    fs5.chmodSync(file, 493);
+    const dir = fs6.mkdtempSync(path8.join(os2.tmpdir(), "zqagent-rg-"));
+    const file = path8.join(dir, process.platform === "win32" ? "rg.exe" : "rg");
+    fs6.writeFileSync(file, Buffer.from(asset));
+    fs6.chmodSync(file, 493);
     return file;
   } catch {
     return null;
@@ -2750,7 +3135,7 @@ function extractBundledRipgrep() {
 function resolveRipgrep() {
   if (cached !== void 0) return cached;
   const explicit = (process.env.ZQAGENT_RG ?? "").trim();
-  if (explicit && fs5.existsSync(explicit)) {
+  if (explicit && fs6.existsSync(explicit)) {
     cached = explicit;
     return cached;
   }
@@ -2764,7 +3149,7 @@ function resolveRipgrep() {
     env: process.env,
     fileExists: (p) => {
       try {
-        return fs5.statSync(p).isFile();
+        return fs6.statSync(p).isFile();
       } catch {
         return false;
       }
@@ -2849,8 +3234,8 @@ function registerSearchTool(registry, workspace) {
 }
 
 // src/tools/git.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 async function runGit(repoDir, args, timeout = 15e3) {
   const res = await execAsync("git", ["-c", "core.quotepath=false", ...args], {
     cwd: repoDir,
@@ -2867,9 +3252,9 @@ async function runGit(repoDir, args, timeout = 15e3) {
 async function resolveRepoRoot(workspace, pathArg) {
   let dir = workspace;
   if (pathArg) {
-    const abs = path7.resolve(workspace, pathArg);
+    const abs = path9.resolve(workspace, pathArg);
     try {
-      dir = fs6.statSync(abs).isDirectory() ? abs : path7.dirname(abs);
+      dir = fs7.statSync(abs).isDirectory() ? abs : path9.dirname(abs);
     } catch {
       dir = abs;
     }
@@ -2882,24 +3267,24 @@ function repoDirArg(workspace, raw) {
   if (typeof raw !== "string") return void 0;
   const v = raw.trim();
   if (!v) return void 0;
-  const base = path7.resolve(workspace);
-  const abs = path7.resolve(base, v);
-  const rel = path7.relative(base, abs);
-  if (rel.startsWith("..") || path7.isAbsolute(rel)) return void 0;
+  const base = path9.resolve(workspace);
+  const abs = path9.resolve(base, v);
+  const rel = path9.relative(base, abs);
+  if (rel.startsWith("..") || path9.isAbsolute(rel)) return void 0;
   return abs;
 }
 function toPathspec(repoRoot, workspace, pathArg) {
   if (!pathArg) return null;
-  const abs = path7.resolve(workspace, pathArg);
-  let rel = path7.relative(repoRoot, abs);
+  const abs = path9.resolve(workspace, pathArg);
+  let rel = path9.relative(repoRoot, abs);
   if (rel === "") return ".";
-  if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path9.isAbsolute(rel)) {
     try {
-      const realRepo = fs6.realpathSync(repoRoot);
-      const realAbs = fs6.realpathSync(abs);
-      const rel2 = path7.relative(realRepo, realAbs);
+      const realRepo = fs7.realpathSync(repoRoot);
+      const realAbs = fs7.realpathSync(abs);
+      const rel2 = path9.relative(realRepo, realAbs);
       if (rel2 === "") return ".";
-      if (!rel2.startsWith("..") && !path7.isAbsolute(rel2)) return rel2;
+      if (!rel2.startsWith("..") && !path9.isAbsolute(rel2)) return rel2;
     } catch {
     }
     return null;
@@ -3064,7 +3449,8 @@ function buildExplorerEngine(opts) {
     model: opts.model,
     instructions: EXPLORER_INSTRUCTIONS,
     maxIterations: parseMaxIterations(process.env.EXPLORE_MAX_ITERATIONS, 30),
-    hook: opts.hook
+    hook: opts.hook,
+    toolResultDir: opts.toolResultDir
   });
 }
 function makeExploreTool(opts) {
@@ -3076,7 +3462,8 @@ function makeExploreTool(opts) {
       provider: opts.provider,
       model: opts.model,
       readonlyRegistrars: opts.readonlyRegistrars,
-      hook: opts.hookFactory?.()
+      hook: opts.hookFactory?.(),
+      toolResultDir: opts.toolResultDir
     });
     let report = "";
     let status = "unknown";