@zqagent/core 0.2.5 → 0.2.7

package/dist/index.cjs

@@ -471,8 +471,11 @@ function formatTokens(tokens) {
   return `${tokens}`;
 }
 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;
@@ -495,9 +498,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 = [];
@@ -647,10 +663,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;
@@ -674,8 +691,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;
 }
@@ -689,9 +706,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;
@@ -802,6 +827,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 path16;
+  let start;
+  let end;
+  try {
+    const obj = JSON.parse(body);
+    path16 = obj.path;
+    start = obj.start_line;
+    end = obj.end_line;
+  } catch {
+    const str2 = (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;
+    };
+    path16 = str2("path");
+    start = num("start_line");
+    end = num("end_line");
+  }
+  if (typeof path16 !== "string" || !path16) return null;
+  if (typeof start !== "number" || typeof end !== "number") return null;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
+  return { path: path16, 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",
@@ -817,9 +1002,108 @@ function isContextOverflow(exc) {
   return OVERFLOW_MARKERS.some((m) => text.includes(m));
 }
 
+// src/engine/toolResultBudget.ts
+var fs = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/paths.ts
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+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
 var crypto = __toESM(require("crypto"), 1);
-var fs = __toESM(require("fs"), 1);
+var fs2 = __toESM(require("fs"), 1);
 var _path = __toESM(require("path"), 1);
 
 // src/prompts/index.ts
@@ -946,13 +1230,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
   };
 }
@@ -1063,12 +1351,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;
@@ -1120,7 +1418,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 });
@@ -1176,6 +1482,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 */,
@@ -1892,7 +2199,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,
@@ -1955,7 +2264,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,
@@ -1990,13 +2301,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 {
@@ -2014,6 +2353,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({
@@ -2055,18 +2403,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,
@@ -2113,63 +2479,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 (state) {
-      this.compactionState = state;
-      this._lastContextTokens = null;
+        if (!trimmed) break;
+        this.compactionState = trimmed;
+        lastState = trimmed;
+        method = "trimmed";
+        progressed = true;
+      }
+      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) {
@@ -2179,9 +2564,9 @@ var TurnEngine = class _TurnEngine {
       return;
     }
     if (result && typeof result === "object") {
-      const path14 = result.path;
-      if (path14) {
-        this._producedFiles.push(path14);
+      const path16 = result.path;
+      if (path16) {
+        this._producedFiles.push(path16);
         return;
       }
       const changed = result.changed_files;
@@ -2205,7 +2590,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;
     }
@@ -2228,7 +2613,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;
         }
@@ -2243,7 +2628,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))
@@ -2264,8 +2649,8 @@ var TurnEngine = class _TurnEngine {
 };
 
 // src/providers/OpenAIProvider.ts
-var fs2 = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
 var import_openai = __toESM(require("openai"), 1);
 
 // src/terminal.ts
@@ -2443,7 +2828,7 @@ var OpenAIProvider = class {
     });
     if (opts.logDir) {
       this._logDir = opts.logDir;
-      fs2.mkdirSync(opts.logDir, { recursive: true });
+      fs3.mkdirSync(opts.logDir, { recursive: true });
     }
   }
   // =====================================================================
@@ -2596,6 +2981,8 @@ var OpenAIProvider = class {
           tools: this._toResponsesTools(tools, model),
           // 推理强度：DeepSeek 不支持，跳过
           ...opts.reasoningEffort && !this._isDeepSeek(model) ? { reasoning: { effort: opts.reasoningEffort } } : {},
+          // 限制输出长度（摘要器等轻量请求）
+          ...opts.maxTokens ? { max_output_tokens: opts.maxTokens } : {},
           stream: true
         }, requestOptions);
         return this._responsesStream(reqId, startTime, rawStream, {
@@ -2694,6 +3081,8 @@ var OpenAIProvider = class {
         })),
         // 推理强度：DeepSeek 不支持，跳过
         ...opts.reasoningEffort && !this._isDeepSeek(model) ? { reasoning_effort: opts.reasoningEffort } : {},
+        // 限制输出长度：o 系列 / gpt-5 推理模型仅支持 max_completion_tokens
+        ...opts.maxTokens ? isReasoningModel(model) ? { max_completion_tokens: opts.maxTokens } : { max_tokens: opts.maxTokens } : {},
         stream: true,
         // 要求返回 Token 用量统计（在流结束前的一个 chunk 中携带）
         stream_options: { include_usage: true }
@@ -2807,8 +3196,8 @@ var OpenAIProvider = class {
     if (!this._logDir) return;
     try {
       const today = logTime?.split("T")[0];
-      const dir = path.join(this._logDir, today);
-      fs2.mkdirSync(dir, { recursive: true });
+      const dir = path3.join(this._logDir, today);
+      fs3.mkdirSync(dir, { recursive: true });
       const entry = {
         reqId,
         ts: logTime,
@@ -2820,8 +3209,8 @@ var OpenAIProvider = class {
           toolNames: tools?.map((t) => t.function.name) ?? []
         }
       };
-      fs2.writeFileSync(
-        path.join(dir, `${reqId}.json`),
+      fs3.writeFileSync(
+        path3.join(dir, `${reqId}.json`),
         JSON.stringify(entry, null, 2),
         "utf-8"
       );
@@ -2840,9 +3229,9 @@ var OpenAIProvider = class {
     if (!this._logDir) return;
     try {
       const today = logTime?.split("T")[0];
-      const filePath = path.join(this._logDir, today, `${reqId}.json`);
-      if (!fs2.existsSync(filePath)) return;
-      const entry = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+      const filePath = path3.join(this._logDir, today, `${reqId}.json`);
+      if (!fs3.existsSync(filePath)) return;
+      const entry = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
       entry.elapsedMs = Date.now() - startTime;
       if (data.response) {
         entry.response = data.response;
@@ -2850,7 +3239,7 @@ var OpenAIProvider = class {
       if (data.error) {
         entry.error = data.error;
       }
-      fs2.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf-8");
+      fs3.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf-8");
     } catch (e) {
       console.error(e);
     }
@@ -3315,62 +3704,62 @@ var ToolRegistry = class {
 };
 
 // src/tools/pathSafety.ts
-var fs3 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
 function isInsideRelative(rel) {
-  return !path2.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path2.sep}`);
+  return !path4.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path4.sep}`);
 }
 function isFilesystemRoot(p) {
-  return path2.parse(p).root === p;
+  return path4.parse(p).root === p;
 }
 function resolveWithinRoot(workspace, target) {
-  const abs = path2.resolve(workspace, target);
+  const abs = path4.resolve(workspace, target);
   let rootReal;
   try {
-    rootReal = fs3.realpathSync(workspace);
+    rootReal = fs4.realpathSync(workspace);
   } catch {
-    const rootAbs = path2.resolve(workspace);
-    if (!isInsideRelative(path2.relative(rootAbs, abs))) return null;
+    const rootAbs = path4.resolve(workspace);
+    if (!isInsideRelative(path4.relative(rootAbs, abs))) return null;
     return { root: rootAbs, real: abs };
   }
   if (isFilesystemRoot(rootReal)) return null;
   let real;
   try {
-    real = fs3.realpathSync(abs);
+    real = fs4.realpathSync(abs);
   } catch {
     let probe = abs;
     const tail = [];
     for (; ; ) {
-      const exists = fs3.existsSync(probe) || fs3.lstatSync(probe, { throwIfNoEntry: false }) !== void 0;
+      const exists = fs4.existsSync(probe) || fs4.lstatSync(probe, { throwIfNoEntry: false }) !== void 0;
       if (exists) {
         try {
-          real = path2.join(fs3.realpathSync(probe), ...tail);
+          real = path4.join(fs4.realpathSync(probe), ...tail);
           break;
         } catch {
           return null;
         }
       }
-      tail.unshift(path2.basename(probe));
-      const parent = path2.dirname(probe);
+      tail.unshift(path4.basename(probe));
+      const parent = path4.dirname(probe);
       if (parent === probe) return null;
       probe = parent;
     }
   }
-  if (!isInsideRelative(path2.relative(rootReal, real))) return null;
+  if (!isInsideRelative(path4.relative(rootReal, real))) return null;
   return { root: rootReal, real };
 }
 function isWithinRoot(workspace, target) {
   return resolveWithinRoot(workspace, target) !== null;
 }
 function resolveEntryWithinRoot(workspace, target) {
-  const abs = path2.resolve(workspace, target);
-  const parent = resolveWithinRoot(workspace, path2.dirname(abs));
+  const abs = path4.resolve(workspace, target);
+  const parent = resolveWithinRoot(workspace, path4.dirname(abs));
   if (!parent) return null;
-  return { root: parent.root, real: path2.join(parent.real, path2.basename(abs)) };
+  return { root: parent.root, real: path4.join(parent.real, path4.basename(abs)) };
 }
 
 // src/permissions/PermissionEngine.ts
-var path3 = __toESM(require("path"), 1);
+var path5 = __toESM(require("path"), 1);
 var Mode = /* @__PURE__ */ ((Mode2) => {
   Mode2["DISCUSS"] = "discuss";
   Mode2["PLAN"] = "plan";
@@ -3427,7 +3816,7 @@ var PermissionEngine = class {
   /** 会话级「总是允许此命令」集合 */
   sessionAllowCommands;
   constructor(opts) {
-    this.workspaceRoot = path3.resolve(opts.workspaceRoot);
+    this.workspaceRoot = path5.resolve(opts.workspaceRoot);
     this.mode = opts.mode;
     this.allowedCommands = Array.isArray(opts.allowedCommands) ? opts.allowedCommands : [];
     this.sessionAllowTools = /* @__PURE__ */ new Set();
@@ -4342,14 +4731,14 @@ function approvalToHtmlTable(input, maxLen = APPROVAL_VALUE_MAX) {
 }
 
 // src/engine/FileLogHook.ts
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
 var FileLogHook = class {
-  constructor(sessionId, stateDir) {
+  constructor(sessionId, stateDir2) {
     this.sessionId = sessionId;
-    fs4.mkdirSync(stateDir, { recursive: true });
-    this._logPath = path4.join(stateDir, `${sessionId}.jsonl`);
-    this._statePath = path4.join(stateDir, `${sessionId}_state.json`);
+    fs5.mkdirSync(stateDir2, { recursive: true });
+    this._logPath = path6.join(stateDir2, `${sessionId}.jsonl`);
+    this._statePath = path6.join(stateDir2, `${sessionId}_state.json`);
   }
   sessionId;
   _logPath;
@@ -4443,13 +4832,13 @@ var FileLogHook = class {
       ...meta?.nameSource !== void 0 ? { nameSource: meta.nameSource } : {},
       ...meta?.taskCount !== void 0 ? { taskCount: meta.taskCount } : {}
     };
-    fs4.writeFileSync(this._statePath, JSON.stringify(state, null, 2), "utf-8");
+    fs5.writeFileSync(this._statePath, JSON.stringify(state, null, 2), "utf-8");
   }
   /** 读取保存的引擎状态 */
-  static loadState(sessionId, stateDir) {
-    const p = path4.join(stateDir, `${sessionId}_state.json`);
+  static loadState(sessionId, stateDir2) {
+    const p = path6.join(stateDir2, `${sessionId}_state.json`);
     try {
-      const raw = fs4.readFileSync(p, "utf-8");
+      const raw = fs5.readFileSync(p, "utf-8");
       return JSON.parse(raw);
     } catch (e) {
       console.error(e);
@@ -4457,10 +4846,10 @@ var FileLogHook = class {
     }
   }
   /** 读取事件日志 */
-  static loadEvents(sessionId, stateDir) {
-    const p = path4.join(stateDir, `${sessionId}.jsonl`);
+  static loadEvents(sessionId, stateDir2) {
+    const p = path6.join(stateDir2, `${sessionId}.jsonl`);
     try {
-      const raw = fs4.readFileSync(p, "utf-8");
+      const raw = fs5.readFileSync(p, "utf-8");
       return raw.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
     } catch (e) {
       console.error(e);
@@ -4471,7 +4860,7 @@ var FileLogHook = class {
   _append(entry) {
     entry["ts"] = (/* @__PURE__ */ new Date()).toISOString();
     try {
-      fs4.appendFileSync(this._logPath, JSON.stringify(entry) + "\n", "utf-8");
+      fs5.appendFileSync(this._logPath, JSON.stringify(entry) + "\n", "utf-8");
     } catch (e) {
       console.error(e);
     }
@@ -4895,12 +5284,12 @@ var McpManager = class {
 };
 
 // src/tools/files.ts
-var fs5 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
 var DEFAULT_MAX_LINES = 2e3;
 var MAX_LINE_CHARS = 500;
 function makeReadFile(workspace) {
-  const root = path5.resolve(workspace);
+  const root = path7.resolve(workspace);
   return function read_file(args) {
     const filePath = String(args.path ?? "");
     const startLine = Math.max(1, Number(args.start_line ?? 1));
@@ -4910,13 +5299,13 @@ function makeReadFile(workspace) {
       return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     }
     const target = resolved.real;
-    if (!fs5.existsSync(target) || !fs5.statSync(target).isFile()) {
+    if (!fs6.existsSync(target) || !fs6.statSync(target).isFile()) {
       return { error: `\u4E0D\u662F\u6587\u4EF6: ${filePath}` };
     }
     const selected = [];
     let total = 0;
     try {
-      const content = fs5.readFileSync(target, "utf-8");
+      const content = fs6.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++) {
@@ -4931,7 +5320,7 @@ function makeReadFile(workspace) {
     }
     const end = startLine + selected.length - 1;
     const result = {
-      path: path5.relative(resolved.root, target),
+      path: path7.relative(resolved.root, target),
       start_line: startLine,
       end_line: end,
       total_lines: total,
@@ -4944,7 +5333,7 @@ function makeReadFile(workspace) {
   };
 }
 function makeWriteFile(workspace) {
-  const root = path5.resolve(workspace);
+  const root = path7.resolve(workspace);
   return function write_file(args) {
     const filePath = String(args.path ?? "");
     const content = String(args.content ?? "");
@@ -4954,34 +5343,34 @@ function makeWriteFile(workspace) {
       return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     }
     const target = resolved.real;
-    if (fs5.existsSync(target) && fs5.statSync(target).isDirectory()) {
+    if (fs6.existsSync(target) && fs6.statSync(target).isDirectory()) {
       return { error: "\u8DEF\u5F84\u662F\u76EE\u5F55\uFF0C\u4E0D\u662F\u6587\u4EF6" };
     }
-    if (fs5.existsSync(target) && !overwrite) {
+    if (fs6.existsSync(target) && !overwrite) {
       return { error: "\u6587\u4EF6\u5DF2\u5B58\u5728 (overwrite=false)" };
     }
     try {
-      fs5.mkdirSync(path5.dirname(target), { recursive: true });
-      fs5.writeFileSync(target, content, "utf-8");
+      fs6.mkdirSync(path7.dirname(target), { recursive: true });
+      fs6.writeFileSync(target, content, "utf-8");
     } catch (exc) {
       return { error: `\u5199\u5165\u5931\u8D25: ${String(exc)}` };
     }
-    return path5.relative(resolved.root, target);
+    return path7.relative(resolved.root, target);
   };
 }
 function makeListFiles(workspace) {
-  const root = path5.resolve(workspace);
+  const root = path7.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 (!fs5.existsSync(target) || !fs5.statSync(target).isDirectory()) {
+    if (!fs6.existsSync(target) || !fs6.statSync(target).isDirectory()) {
       return { error: `\u4E0D\u662F\u76EE\u5F55: ${dirPath}` };
     }
     try {
-      const entries = fs5.readdirSync(target, { withFileTypes: true });
+      const entries = fs6.readdirSync(target, { withFileTypes: true });
       const results = [];
       for (const e of entries) {
         if (results.length >= maxResults) break;
@@ -4990,14 +5379,14 @@ function makeListFiles(workspace) {
         results.push(e.isDirectory() ? `${e.name}/` : e.name);
       }
       results.sort();
-      return { path: path5.relative(resolved.root, target), entries: results.slice(0, maxResults) };
+      return { path: path7.relative(resolved.root, target), entries: results.slice(0, maxResults) };
     } catch (exc) {
       return { error: `\u5217\u51FA\u6587\u4EF6\u5931\u8D25: ${String(exc)}` };
     }
   };
 }
 function makeReplaceInFile(workspace) {
-  const root = path5.resolve(workspace);
+  const root = path7.resolve(workspace);
   return function replace_in_file(args) {
     const filePath = String(args.path ?? "");
     const oldStr = String(args.old ?? "");
@@ -5007,19 +5396,19 @@ function makeReplaceInFile(workspace) {
     const resolved = resolveWithinRoot(root, filePath);
     if (!resolved) return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     const target = resolved.real;
-    if (!fs5.existsSync(target) || !fs5.statSync(target).isFile()) {
+    if (!fs6.existsSync(target) || !fs6.statSync(target).isFile()) {
       return { error: `\u4E0D\u662F\u6587\u4EF6: ${filePath}` };
     }
     try {
-      const content = fs5.readFileSync(target, "utf-8");
+      const content = fs6.readFileSync(target, "utf-8");
       const count = content.split(oldStr).length - 1;
       if (count !== expectedReplacements) {
         return { error: `\u671F\u671B ${expectedReplacements} \u5904\u66FF\u6362\uFF0C\u5B9E\u9645\u627E\u5230 ${count} \u5904: ${filePath}` };
       }
       const updated = content.replaceAll(oldStr, newStr);
-      fs5.writeFileSync(target, updated, "utf-8");
+      fs6.writeFileSync(target, updated, "utf-8");
       return {
-        path: path5.relative(resolved.root, target),
+        path: path7.relative(resolved.root, target),
         replacements: count,
         chars_before: content.length,
         chars_after: updated.length
@@ -5119,8 +5508,8 @@ function registerFileTools(registry, workspace) {
 }
 
 // src/tools/shell.ts
-var fs7 = __toESM(require("fs"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
 
 // src/tools/execAsync.ts
 var import_node_child_process2 = require("child_process");
@@ -5282,15 +5671,15 @@ function execAsync(file, argv, opts = {}) {
 }
 
 // src/tools/shellRuntime.ts
-var fs6 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
 var WINDOWS_SUFFIXES = [".exe", ".cmd", ".bat", ".com", ""];
 function pathApi(platform) {
-  return platform === "win32" ? path6.win32 : path6.posix;
+  return platform === "win32" ? path8.win32 : path8.posix;
 }
 function defaultFileExists(p) {
   try {
-    return fs6.statSync(p).isFile();
+    return fs7.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -5321,7 +5710,7 @@ function kindFromBasename(base) {
   return "sh";
 }
 function busyboxArgs(file, command) {
-  const base = (file ? path6.win32.basename(file) : "busybox").toLowerCase().replace(/\.(exe|cmd|bat|com)$/, "");
+  const base = (file ? path8.win32.basename(file) : "busybox").toLowerCase().replace(/\.(exe|cmd|bat|com)$/, "");
   return base === "busybox" ? ["sh", "-c", command] : ["-c", command];
 }
 function argsFor(kind, command) {
@@ -5587,7 +5976,7 @@ var MAX_STDERR = 5e3;
 var MAX_BUFFER = 1024 * 1024 * 5;
 var shellSessions = /* @__PURE__ */ new Map();
 function sessionFor(workspace) {
-  const key = path7.resolve(workspace);
+  const key = path9.resolve(workspace);
   let s = shellSessions.get(key);
   if (!s) {
     s = { cwd: key };
@@ -5644,8 +6033,8 @@ function makeRunShell(workspace, spec, tasks, scope) {
     let toRun = command;
     if (target) {
       try {
-        const resolved = path7.resolve(session.cwd, target);
-        if (fs7.existsSync(resolved) && fs7.statSync(resolved).isDirectory()) {
+        const resolved = path9.resolve(session.cwd, target);
+        if (fs8.existsSync(resolved) && fs8.statSync(resolved).isDirectory()) {
           session.cwd = resolved;
         }
       } catch {
@@ -5770,8 +6159,8 @@ function registerShellTool(registry, workspace, scope) {
 }
 
 // src/tools/nodeGrep.ts
-var fs8 = __toESM(require("fs"), 1);
-var path8 = __toESM(require("path"), 1);
+var fs9 = __toESM(require("fs"), 1);
+var path10 = __toESM(require("path"), 1);
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -5796,27 +6185,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 = path8.resolve(opts.workspace, opts.target);
-  if (!fs8.existsSync(target)) {
+  const target = path10.resolve(opts.workspace, opts.target);
+  if (!fs9.existsSync(target)) {
     throw new Error(`\u641C\u7D22\u8DEF\u5F84\u4E0D\u5B58\u5728: ${opts.target}`);
   }
   const matches = [];
   const scanFile = (file) => {
     let stat2;
     try {
-      stat2 = fs8.statSync(file);
+      stat2 = fs9.statSync(file);
     } catch {
       return false;
     }
     if (!stat2.isFile() || stat2.size > maxFileBytes) return false;
     let buf;
     try {
-      buf = fs8.readFileSync(file);
+      buf = fs9.readFileSync(file);
     } catch {
       return false;
     }
     if (looksBinary(buf)) return false;
-    const rel = path8.relative(opts.workspace, file) || path8.basename(file);
+    const rel = path10.relative(opts.workspace, file) || path10.basename(file);
     const lines = buf.toString("utf-8").split("\n");
     for (let i = 0; i < lines.length; i++) {
       const raw = lines[i].replace(/\r$/, "");
@@ -5827,7 +6216,7 @@ function nodeGrep(opts) {
     }
     return false;
   };
-  const stat = fs8.statSync(target);
+  const stat = fs9.statSync(target);
   if (stat.isFile()) {
     scanFile(target);
     return matches;
@@ -5837,12 +6226,12 @@ function nodeGrep(opts) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = path8.join(dir, entry.name);
+      const full = path10.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) stack.push(full);
       } else if (entry.isFile()) {
@@ -5854,22 +6243,22 @@ function nodeGrep(opts) {
 }
 
 // src/tools/ripgrep.ts
-var fs9 = __toESM(require("fs"), 1);
-var os = __toESM(require("os"), 1);
-var path9 = __toESM(require("path"), 1);
+var fs10 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+var path11 = __toESM(require("path"), 1);
 var import_node_module = require("module");
 var cached2;
 function extractBundledRipgrep() {
   try {
-    const req = typeof require === "function" ? require : (0, import_node_module.createRequire)(path9.join(process.cwd(), "__zqagent__.js"));
+    const req = typeof require === "function" ? require : (0, import_node_module.createRequire)(path11.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 = fs9.mkdtempSync(path9.join(os.tmpdir(), "zqagent-rg-"));
-    const file = path9.join(dir, process.platform === "win32" ? "rg.exe" : "rg");
-    fs9.writeFileSync(file, Buffer.from(asset));
-    fs9.chmodSync(file, 493);
+    const dir = fs10.mkdtempSync(path11.join(os2.tmpdir(), "zqagent-rg-"));
+    const file = path11.join(dir, process.platform === "win32" ? "rg.exe" : "rg");
+    fs10.writeFileSync(file, Buffer.from(asset));
+    fs10.chmodSync(file, 493);
     return file;
   } catch {
     return null;
@@ -5878,7 +6267,7 @@ function extractBundledRipgrep() {
 function resolveRipgrep() {
   if (cached2 !== void 0) return cached2;
   const explicit = (process.env.ZQAGENT_RG ?? "").trim();
-  if (explicit && fs9.existsSync(explicit)) {
+  if (explicit && fs10.existsSync(explicit)) {
     cached2 = explicit;
     return cached2;
   }
@@ -5892,7 +6281,7 @@ function resolveRipgrep() {
     env: process.env,
     fileExists: (p) => {
       try {
-        return fs9.statSync(p).isFile();
+        return fs10.statSync(p).isFile();
       } catch {
         return false;
       }
@@ -6439,8 +6828,8 @@ function registerWebTools(registry) {
 }
 
 // src/tools/git.ts
-var fs10 = __toESM(require("fs"), 1);
-var path10 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs"), 1);
+var path12 = __toESM(require("path"), 1);
 async function runGit(repoDir, args, timeout = 15e3) {
   const res = await execAsync("git", ["-c", "core.quotepath=false", ...args], {
     cwd: repoDir,
@@ -6457,9 +6846,9 @@ async function runGit(repoDir, args, timeout = 15e3) {
 async function resolveRepoRoot(workspace, pathArg) {
   let dir = workspace;
   if (pathArg) {
-    const abs = path10.resolve(workspace, pathArg);
+    const abs = path12.resolve(workspace, pathArg);
     try {
-      dir = fs10.statSync(abs).isDirectory() ? abs : path10.dirname(abs);
+      dir = fs11.statSync(abs).isDirectory() ? abs : path12.dirname(abs);
     } catch {
       dir = abs;
     }
@@ -6472,24 +6861,24 @@ function repoDirArg(workspace, raw) {
   if (typeof raw !== "string") return void 0;
   const v = raw.trim();
   if (!v) return void 0;
-  const base = path10.resolve(workspace);
-  const abs = path10.resolve(base, v);
-  const rel = path10.relative(base, abs);
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) return void 0;
+  const base = path12.resolve(workspace);
+  const abs = path12.resolve(base, v);
+  const rel = path12.relative(base, abs);
+  if (rel.startsWith("..") || path12.isAbsolute(rel)) return void 0;
   return abs;
 }
 function toPathspec(repoRoot, workspace, pathArg) {
   if (!pathArg) return null;
-  const abs = path10.resolve(workspace, pathArg);
-  let rel = path10.relative(repoRoot, abs);
+  const abs = path12.resolve(workspace, pathArg);
+  let rel = path12.relative(repoRoot, abs);
   if (rel === "") return ".";
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path12.isAbsolute(rel)) {
     try {
-      const realRepo = fs10.realpathSync(repoRoot);
-      const realAbs = fs10.realpathSync(abs);
-      const rel2 = path10.relative(realRepo, realAbs);
+      const realRepo = fs11.realpathSync(repoRoot);
+      const realAbs = fs11.realpathSync(abs);
+      const rel2 = path12.relative(realRepo, realAbs);
       if (rel2 === "") return ".";
-      if (!rel2.startsWith("..") && !path10.isAbsolute(rel2)) return rel2;
+      if (!rel2.startsWith("..") && !path12.isAbsolute(rel2)) return rel2;
     } catch {
     }
     return null;
@@ -6634,10 +7023,10 @@ function registerGitTools(registry, workspace) {
 }
 
 // src/tools/diff.ts
-var fs11 = __toESM(require("fs"), 1);
-var path11 = __toESM(require("path"), 1);
+var fs12 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
 function makeApplyPatch(workspace) {
-  const root = path11.resolve(workspace);
+  const root = path13.resolve(workspace);
   return function apply_patch(args) {
     const patch = String(args.patch ?? "");
     if (!patch.trim()) return { error: "\u8865\u4E01\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A" };
@@ -6676,12 +7065,12 @@ function makeApplyPatch(workspace) {
           contentLines.push(current.slice(1));
           i++;
         }
-        if (fs11.existsSync(target)) {
+        if (fs12.existsSync(target)) {
           return { error: `\u6587\u4EF6\u5DF2\u5B58\u5728: ${filePath}` };
         }
-        fs11.mkdirSync(path11.dirname(target), { recursive: true });
-        fs11.writeFileSync(target, contentLines.join("\n") + "\n", "utf-8");
-        const rel = path11.relative(resolved.root, target);
+        fs12.mkdirSync(path13.dirname(target), { recursive: true });
+        fs12.writeFileSync(target, contentLines.join("\n") + "\n", "utf-8");
+        const rel = path13.relative(resolved.root, target);
         changedFiles.push(rel);
         addedFiles.push(rel);
         fileCount++;
@@ -6694,11 +7083,11 @@ function makeApplyPatch(workspace) {
           return { error: `\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916: ${filePath}` };
         }
         const target = entry.real;
-        if (!fs11.existsSync(target)) {
+        if (!fs12.existsSync(target)) {
           return { error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}` };
         }
-        fs11.unlinkSync(target);
-        deletedFiles.push(path11.relative(entry.root, target));
+        fs12.unlinkSync(target);
+        deletedFiles.push(path13.relative(entry.root, target));
         fileCount++;
         i++;
         continue;
@@ -6734,10 +7123,10 @@ function makeApplyPatch(workspace) {
         if (!chunkLines.length) {
           return { error: `\u8865\u4E01\u66F4\u65B0\u6CA1\u6709 hunks: ${filePath}` };
         }
-        if (!fs11.existsSync(target)) {
+        if (!fs12.existsSync(target)) {
           return { error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}` };
         }
-        const oldLines = fs11.readFileSync(target, "utf-8").split("\n");
+        const oldLines = fs12.readFileSync(target, "utf-8").split("\n");
         const newLines = applyPatchHunks(oldLines, chunkLines, filePath);
         let finalResolved = resolved;
         if (moveTo) {
@@ -6748,20 +7137,20 @@ function makeApplyPatch(workspace) {
           finalResolved = moved;
         }
         const finalTarget = finalResolved.real;
-        if (moveTo && fs11.existsSync(finalTarget) && finalTarget !== target) {
+        if (moveTo && fs12.existsSync(finalTarget) && finalTarget !== target) {
           return { error: `\u6587\u4EF6\u5DF2\u5B58\u5728: ${moveTo}` };
         }
-        fs11.mkdirSync(path11.dirname(finalTarget), { recursive: true });
-        fs11.writeFileSync(finalTarget, newLines.join("\n"), "utf-8");
+        fs12.mkdirSync(path13.dirname(finalTarget), { recursive: true });
+        fs12.writeFileSync(finalTarget, newLines.join("\n"), "utf-8");
         if (moveTo && finalTarget !== target) {
           const entry = resolveEntryWithinRoot(root, filePath);
           if (!entry) {
             return { error: `\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916: ${filePath}` };
           }
-          fs11.unlinkSync(entry.real);
-          deletedFiles.push(path11.relative(resolved.root, target));
+          fs12.unlinkSync(entry.real);
+          deletedFiles.push(path13.relative(resolved.root, target));
         }
-        changedFiles.push(path11.relative(finalResolved.root, finalTarget));
+        changedFiles.push(path13.relative(finalResolved.root, finalTarget));
         fileCount++;
         continue;
       }
@@ -6773,18 +7162,18 @@ function makeApplyPatch(workspace) {
     return { changed_files: changedFiles, added_files: addedFiles, deleted_files: deletedFiles, file_count: fileCount };
   };
 }
-function applyPatchHunks(oldLines, chunks, path14) {
+function applyPatchHunks(oldLines, chunks, path16) {
   let newLines = [...oldLines];
   let cursor = 0;
   for (const chunk of chunks) {
     const oldBlock = chunk.filter((l) => l[0] === " " || l[0] === "-").map((l) => l.slice(1));
     const newBlock = chunk.filter((l) => l[0] === " " || l[0] === "+").map((l) => l.slice(1));
     if (!oldBlock.length) {
-      throw new Error(`\u8865\u4E01 hunk \u5FC5\u987B\u5305\u542B\u4E0A\u4E0B\u6587\u6216\u5220\u9664\u884C: ${path14}`);
+      throw new Error(`\u8865\u4E01 hunk \u5FC5\u987B\u5305\u542B\u4E0A\u4E0B\u6587\u6216\u5220\u9664\u884C: ${path16}`);
     }
     const matchStart = findBlockMatch(newLines, oldBlock, cursor);
     if (matchStart === -1) {
-      throw new Error(`\u8865\u4E01\u4E0A\u4E0B\u6587\u4E0D\u5339\u914D: ${path14}`);
+      throw new Error(`\u8865\u4E01\u4E0A\u4E0B\u6587\u4E0D\u5339\u914D: ${path16}`);
     }
     const matchEnd = matchStart + oldBlock.length;
     newLines.splice(matchStart, oldBlock.length, ...newBlock);
@@ -6801,7 +7190,7 @@ function findBlockMatch(lines, block, start) {
   return -1;
 }
 function makeApplyUnifiedDiff(workspace) {
-  const root = path11.resolve(workspace);
+  const root = path13.resolve(workspace);
   return function apply_unified_diff(args) {
     const diff = String(args.diff ?? "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     if (!diff.trim()) return { error: "diff \u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A" };
@@ -6820,26 +7209,26 @@ function makeApplyUnifiedDiff(workspace) {
         return { error: `\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916: ${targetPath}` };
       }
       const target = resolved.real;
-      const oldLines = oldIsDevNull ? [] : fs11.existsSync(target) ? fs11.readFileSync(target, "utf-8").split("\n") : [];
+      const oldLines = oldIsDevNull ? [] : fs12.existsSync(target) ? fs12.readFileSync(target, "utf-8").split("\n") : [];
       const newLines = applyDiffHunks(oldLines, patch.hunks, targetPath);
       hunkCount += patch.hunks.length;
       if (newIsDevNull) {
-        if (fs11.existsSync(target)) {
-          if (!fs11.statSync(target).isFile()) {
+        if (fs12.existsSync(target)) {
+          if (!fs12.statSync(target).isFile()) {
             return { error: `\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${targetPath}` };
           }
           const entry = resolveEntryWithinRoot(root, targetPath);
           if (!entry) {
             return { error: `\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916: ${targetPath}` };
           }
-          fs11.unlinkSync(entry.real);
+          fs12.unlinkSync(entry.real);
         }
-        deletedFiles.push(path11.relative(resolved.root, target));
+        deletedFiles.push(path13.relative(resolved.root, target));
         continue;
       }
-      fs11.mkdirSync(path11.dirname(target), { recursive: true });
-      fs11.writeFileSync(target, newLines.join("\n"), "utf-8");
-      const rel = path11.relative(resolved.root, target);
+      fs12.mkdirSync(path13.dirname(target), { recursive: true });
+      fs12.writeFileSync(target, newLines.join("\n"), "utf-8");
+      const rel = path13.relative(resolved.root, target);
       changedFiles.push(rel);
       if (oldIsDevNull) addedFiles.push(rel);
     }
@@ -7084,7 +7473,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) {
@@ -7096,7 +7486,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";
@@ -7156,13 +7547,13 @@ function registerExploreTool(registry, opts) {
 }
 
 // src/tools/media.ts
-var fs13 = __toESM(require("fs"), 1);
-var path13 = __toESM(require("path"), 1);
+var fs14 = __toESM(require("fs"), 1);
+var path15 = __toESM(require("path"), 1);
 
 // src/tools/ffmpegRuntime.ts
-var fs12 = __toESM(require("fs"), 1);
-var os2 = __toESM(require("os"), 1);
-var path12 = __toESM(require("path"), 1);
+var fs13 = __toESM(require("fs"), 1);
+var os3 = __toESM(require("os"), 1);
+var path14 = __toESM(require("path"), 1);
 var import_node_module2 = require("module");
 var import_node_crypto = require("crypto");
 var import_promises = require("stream/promises");
@@ -7185,29 +7576,29 @@ if (PROXY_ENV2) {
 }
 var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
 function agentBinDir(workspace) {
-  return path12.join(path12.resolve(workspace), ".agent", "bin");
+  return path14.join(path14.resolve(workspace), ".agent", "bin");
 }
 function exeName(name, platform) {
   return platform === "win32" ? `${name}.exe` : name;
 }
 function defaultFileExists2(p) {
   try {
-    return fs12.statSync(p).isFile();
+    return fs13.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function extractBundled(name, platform) {
   try {
-    const req = typeof require === "function" ? require : (0, import_node_module2.createRequire)(path12.join(process.cwd(), "__zqagent__.js"));
+    const req = typeof require === "function" ? require : (0, import_node_module2.createRequire)(path14.join(process.cwd(), "__zqagent__.js"));
     const sea = req("node:sea");
     if (!sea?.isSea?.() || typeof sea.getAsset !== "function") return null;
     const asset = sea.getAsset(name);
     if (!asset) return null;
-    const dir = fs12.mkdtempSync(path12.join(os2.tmpdir(), `zqagent-${name}-`));
-    const file = path12.join(dir, exeName(name, platform));
-    fs12.writeFileSync(file, Buffer.from(asset));
-    fs12.chmodSync(file, 493);
+    const dir = fs13.mkdtempSync(path14.join(os3.tmpdir(), `zqagent-${name}-`));
+    const file = path14.join(dir, exeName(name, platform));
+    fs13.writeFileSync(file, Buffer.from(asset));
+    fs13.chmodSync(file, 493);
     return file;
   } catch {
     return null;
@@ -7217,7 +7608,7 @@ function resolveOne(name, workspace, o) {
   const envKey = name === "ffmpeg" ? ENV_FFMPEG : ENV_FFPROBE;
   const explicit = (o.env[envKey] ?? "").trim();
   if (explicit && o.fileExists(explicit)) return { path: explicit, source: "env" };
-  const local = path12.join(agentBinDir(workspace), exeName(name, o.platform));
+  const local = path14.join(agentBinDir(workspace), exeName(name, o.platform));
   if (o.fileExists(local)) return { path: local, source: "agent-bin" };
   const bundled = extractBundled(name, o.platform);
   if (bundled) return { path: bundled, source: "bundled" };
@@ -7231,7 +7622,7 @@ function resolveOne(name, workspace, o) {
 var cache = /* @__PURE__ */ new Map();
 function resolveMedia(workspace, opts = {}) {
   const platform = opts.platform ?? process.platform;
-  const key = `${platform}:${path12.resolve(workspace)}`;
+  const key = `${platform}:${path14.resolve(workspace)}`;
   const hit = cache.get(key);
   if (hit) return hit;
   const ctx = {
@@ -7337,7 +7728,7 @@ function parseChecksumFile(text, filename) {
     if (!m) continue;
     const hash = m[1].toLowerCase();
     const name = m[2]?.trim() ?? "";
-    if (!name || name === filename || path12.basename(name) === filename) return hash;
+    if (!name || name === filename || path14.basename(name) === filename) return hash;
   }
   const single = lines[0]?.trim();
   if (lines.length === 1 && single && /^[0-9a-f]{32,128}$/i.test(single)) {
@@ -7347,7 +7738,7 @@ function parseChecksumFile(text, filename) {
 }
 async function computeChecksum(file, algo) {
   const hash = (0, import_node_crypto.createHash)(algo);
-  await (0, import_promises.pipeline)(fs12.createReadStream(file), hash);
+  await (0, import_promises.pipeline)(fs13.createReadStream(file), hash);
   return hash.digest("hex");
 }
 function fetchInit() {
@@ -7362,7 +7753,7 @@ async function downloadToFile(url, dest) {
   const resp = await (0, import_node_fetch3.default)(url, fetchInit());
   if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
   if (!resp.body) throw new Error("\u54CD\u5E94\u6CA1\u6709\u5185\u5BB9");
-  await (0, import_promises.pipeline)(resp.body, fs12.createWriteStream(dest));
+  await (0, import_promises.pipeline)(resp.body, fs13.createWriteStream(dest));
 }
 async function resolveComponentUrl(c) {
   if (c.url) return c.url;
@@ -7379,12 +7770,12 @@ function findBinaryInTree(dir, names) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs12.readdirSync(cur, { withFileTypes: true });
+      entries = fs13.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path12.join(cur, e.name);
+      const full = path14.join(cur, e.name);
       if (e.isDirectory()) {
         stack.push(full);
       } else if (names.includes(e.name)) {
@@ -7395,7 +7786,7 @@ function findBinaryInTree(dir, names) {
   return null;
 }
 async function extractArchive(archive, dest, kind, platform) {
-  fs12.mkdirSync(dest, { recursive: true });
+  fs13.mkdirSync(dest, { recursive: true });
   let res;
   if (kind === "tar.xz") {
     res = await execAsync("tar", ["-xJf", archive, "-C", dest]);
@@ -7431,7 +7822,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
       error: `\u6682\u4E0D\u652F\u6301\u81EA\u52A8\u4E0B\u8F7D\u7684\u5E73\u53F0: ${platform}/${arch}`
     };
   }
-  const tmp = fs12.mkdtempSync(path12.join(os2.tmpdir(), "zqagent-ffmpeg-"));
+  const tmp = fs13.mkdtempSync(path14.join(os3.tmpdir(), "zqagent-ffmpeg-"));
   const binDir = agentBinDir(workspace);
   const installed = {};
   try {
@@ -7445,7 +7836,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
       }
       let archive = fetched.get(url);
       if (!archive) {
-        const archivePath = path12.join(tmp, path12.basename(new URL(url).pathname) || `${c.name}.${c.archive}`);
+        const archivePath = path14.join(tmp, path14.basename(new URL(url).pathname) || `${c.name}.${c.archive}`);
         log(`\u4E0B\u8F7D ${url}`);
         try {
           await downloadToFile(url, archivePath);
@@ -7455,7 +7846,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
         if (c.checksumUrl) {
           const algo = c.checksumAlgo ?? "sha256";
           try {
-            const expected = parseChecksumFile(await fetchText(c.checksumUrl), path12.basename(archivePath));
+            const expected = parseChecksumFile(await fetchText(c.checksumUrl), path14.basename(archivePath));
             if (!expected) {
               notes.push(`\u672A\u80FD\u4ECE ${c.checksumUrl} \u89E3\u6790\u51FA\u6821\u9A8C\u548C\uFF0C\u5DF2\u8DF3\u8FC7\u6821\u9A8C`);
             } else {
@@ -7472,24 +7863,24 @@ async function downloadFfmpeg(workspace, opts = {}) {
             notes.push(`\u6821\u9A8C\u548C\u83B7\u53D6\u5931\u8D25 (${c.checksumUrl}): ${String(e instanceof Error ? e.message : e)}`);
           }
         } else {
-          notes.push(`${path12.basename(archivePath)} \u672A\u63D0\u4F9B\u6821\u9A8C\u548C\uFF08\u4EC5 HTTPS \u4F20\u8F93\u4FDD\u62A4\uFF09`);
+          notes.push(`${path14.basename(archivePath)} \u672A\u63D0\u4F9B\u6821\u9A8C\u548C\uFF08\u4EC5 HTTPS \u4F20\u8F93\u4FDD\u62A4\uFF09`);
         }
         archive = { file: archivePath, kind: c.archive };
         fetched.set(url, archive);
       }
-      const extractDir = fs12.mkdtempSync(path12.join(tmp, "x-"));
+      const extractDir = fs13.mkdtempSync(path14.join(tmp, "x-"));
       const err = await extractArchive(archive.file, extractDir, archive.kind, platform);
       if (err) return { ok: false, error: err };
       const found = findBinaryInTree(extractDir, [exeName(c.name, platform), c.name]);
       if (!found) {
-        return { ok: false, error: `\u5F52\u6863\u5185\u672A\u627E\u5230 ${c.name}: ${path12.basename(archive.file)}` };
+        return { ok: false, error: `\u5F52\u6863\u5185\u672A\u627E\u5230 ${c.name}: ${path14.basename(archive.file)}` };
       }
-      fs12.mkdirSync(binDir, { recursive: true });
-      const target = path12.join(binDir, exeName(c.name, platform));
+      fs13.mkdirSync(binDir, { recursive: true });
+      const target = path14.join(binDir, exeName(c.name, platform));
       const staging = `${target}.tmp-${process.pid}`;
-      fs12.copyFileSync(found, staging);
-      fs12.chmodSync(staging, 493);
-      fs12.renameSync(staging, target);
+      fs13.copyFileSync(found, staging);
+      fs13.chmodSync(staging, 493);
+      fs13.renameSync(staging, target);
       installed[c.name] = target;
     }
     resetFfmpegCache();
@@ -7498,7 +7889,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
   } catch (e) {
     return { ok: false, error: `\u5B89\u88C5\u5931\u8D25: ${String(e instanceof Error ? e.message : e)}` };
   } finally {
-    fs12.rmSync(tmp, { recursive: true, force: true });
+    fs13.rmSync(tmp, { recursive: true, force: true });
   }
 }
 function canAutoDownload(platform, arch) {
@@ -7763,13 +8154,13 @@ function resolveTarget(workspace, value) {
   return { abs: resolved.real, root: resolved.root };
 }
 function relOut(workspace, abs) {
-  return path13.relative(workspace, abs) || abs;
+  return path15.relative(workspace, abs) || abs;
 }
 function registerMediaTool(registry, workspace, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const arch = process.arch;
   const media = async (args) => {
-    const root = path13.resolve(workspace);
+    const root = path15.resolve(workspace);
     const op = str(args["op"]);
     if (!op) {
       return { error: `\u7F3A\u5C11\u53C2\u6570 op\u3002\u53EF\u9009\u503C\uFF1A${OPS.join(" / ")}` };
@@ -7814,7 +8205,7 @@ function registerMediaTool(registry, workspace, opts = {}) {
       if (!input) return { error: `\u64CD\u4F5C ${op} \u9700\u8981\u53C2\u6570 input\uFF08\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF09` };
       const r = resolveTarget(root, input);
       if ("error" in r) return { error: r.error };
-      if (!fs13.existsSync(r.abs) || !fs13.statSync(r.abs).isFile()) {
+      if (!fs14.existsSync(r.abs) || !fs14.statSync(r.abs).isFile()) {
         return { error: `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728: ${input}` };
       }
       inputAbs = r.abs;
@@ -7826,7 +8217,7 @@ function registerMediaTool(registry, workspace, opts = {}) {
       if (!output) return { error: `\u64CD\u4F5C ${op} \u9700\u8981\u53C2\u6570 output\uFF08\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF09` };
       const r = resolveTarget(root, output);
       if ("error" in r) return { error: r.error };
-      fs13.mkdirSync(path13.dirname(r.abs), { recursive: true });
+      fs14.mkdirSync(path15.dirname(r.abs), { recursive: true });
       outputAbs = r.abs;
       relRoot = r.root;
     }
@@ -7876,7 +8267,7 @@ function registerMediaTool(registry, workspace, opts = {}) {
     };
     if (outputAbs) {
       try {
-        result["size_bytes"] = fs13.statSync(outputAbs).size;
+        result["size_bytes"] = fs14.statSync(outputAbs).size;
       } catch {
       }
     }
@@ -8116,7 +8507,9 @@ function createDefaultEngine(opts) {
     subagentHookFactory,
     contextWindow,
     thresholdPct,
+    softThresholdPct,
     capTokens,
+    toolResultDir: toolResultDir2,
     logDir
   } = opts;
   const envEffort = process.env.OPENAI_REASONING_EFFORT?.toLowerCase();
@@ -8139,7 +8532,8 @@ function createDefaultEngine(opts) {
     workspace,
     provider: effectiveProvider,
     model,
-    hookFactory: subagentHookFactory
+    hookFactory: subagentHookFactory,
+    toolResultDir: toolResultDir2
   });
   const permissions = new PermissionEngine({
     workspaceRoot: workspace,
@@ -8161,7 +8555,9 @@ function createDefaultEngine(opts) {
     hook,
     contextWindow,
     thresholdPct,
-    capTokens
+    softThresholdPct,
+    capTokens,
+    toolResultDir: toolResultDir2
   });
   return engine;
 }