@zqagent/core 0.2.5 → 0.2.7

package/dist/cli/index.js

@@ -552,9 +552,9 @@ var init_wire = __esm({
 // src/cli/index.ts
 init_esm_shims();
 import "dotenv/config";
-import * as fs32 from "fs";
+import * as fs34 from "fs";
 import * as readline2 from "readline";
-import * as path41 from "path";
+import * as path43 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
@@ -920,8 +920,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;
@@ -944,9 +947,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 = [];
@@ -1096,10 +1112,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;
@@ -1123,8 +1140,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;
 }
@@ -1138,9 +1155,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;
@@ -1251,6 +1276,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 path44;
+  let start;
+  let end;
+  try {
+    const obj = JSON.parse(body);
+    path44 = obj.path;
+    start = obj.start_line;
+    end = obj.end_line;
+  } catch {
+    const str2 = (key) => new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(body)?.[1];
+    const num2 = (key) => {
+      const m = new RegExp(`"${key}"\\s*:\\s*(\\d+)`).exec(body);
+      return m ? Number(m[1]) : void 0;
+    };
+    path44 = str2("path");
+    start = num2("start_line");
+    end = num2("end_line");
+  }
+  if (typeof path44 !== "string" || !path44) return null;
+  if (typeof start !== "number" || typeof end !== "number") return null;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
+  return { path: path44, 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",
@@ -1266,9 +1451,116 @@ function isContextOverflow(exc) {
   return OVERFLOW_MARKERS.some((m) => text.includes(m));
 }
 
+// src/engine/toolResultBudget.ts
+init_esm_shims();
+import * as fs from "fs";
+import * as path3 from "path";
+
+// src/paths.ts
+init_esm_shims();
+import * as os from "os";
+import * as path2 from "path";
+var APP_DIR_NAME = "zqagent";
+var DEFAULT_DATA_DIR = ".zqagent_data";
+var DEFAULT_HUB_URL = "https://hub.cd-zq.com";
+var IS_WINDOWS = process.platform === "win32";
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || os.tmpdir();
+}
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME || (IS_WINDOWS ? process.env.APPDATA : void 0) || path2.join(homeDir(), ".config");
+  return path2.join(base, APP_DIR_NAME);
+}
+function stateDir() {
+  const base = process.env.XDG_STATE_HOME || (IS_WINDOWS ? process.env.LOCALAPPDATA : void 0) || path2.join(homeDir(), ".local", "state");
+  return path2.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 env3 = process.env.TOOL_RESULT_DIR?.trim();
+  return env3 || path3.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 safe2 = tool.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40) || "tool";
+    const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}-${safe2}.txt`;
+    const file = path3.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
@@ -1394,13 +1686,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
   };
 }
@@ -1511,12 +1807,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;
@@ -1568,7 +1874,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 });
@@ -1624,6 +1938,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 */,
@@ -2340,7 +2655,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,
@@ -2403,7 +2720,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,
@@ -2438,13 +2757,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 {
@@ -2462,6 +2809,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({
@@ -2503,18 +2859,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,
@@ -2561,63 +2935,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 failed2 = 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
         );
-        failed2 = false;
-        break;
-      } catch {
-        failed2 = 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 (failed2 || 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) {
@@ -2627,9 +3020,9 @@ var TurnEngine = class _TurnEngine {
       return;
     }
     if (result && typeof result === "object") {
-      const path42 = result.path;
-      if (path42) {
-        this._producedFiles.push(path42);
+      const path44 = result.path;
+      if (path44) {
+        this._producedFiles.push(path44);
         return;
       }
       const changed = result.changed_files;
@@ -2653,7 +3046,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;
     }
@@ -2676,7 +3069,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;
         }
@@ -2691,7 +3084,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))
@@ -2713,8 +3106,8 @@ var TurnEngine = class _TurnEngine {
 
 // src/providers/OpenAIProvider.ts
 init_esm_shims();
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 import OpenAI from "openai";
 
 // src/terminal.ts
@@ -2900,7 +3293,7 @@ var OpenAIProvider = class {
     });
     if (opts.logDir) {
       this._logDir = opts.logDir;
-      fs2.mkdirSync(opts.logDir, { recursive: true });
+      fs3.mkdirSync(opts.logDir, { recursive: true });
     }
   }
   // =====================================================================
@@ -3053,6 +3446,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, {
@@ -3151,6 +3546,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 }
@@ -3264,8 +3661,8 @@ var OpenAIProvider = class {
     if (!this._logDir) return;
     try {
       const today = logTime?.split("T")[0];
-      const dir = path2.join(this._logDir, today);
-      fs2.mkdirSync(dir, { recursive: true });
+      const dir = path4.join(this._logDir, today);
+      fs3.mkdirSync(dir, { recursive: true });
       const entry = {
         reqId,
         ts: logTime,
@@ -3277,8 +3674,8 @@ var OpenAIProvider = class {
           toolNames: tools?.map((t) => t.function.name) ?? []
         }
       };
-      fs2.writeFileSync(
-        path2.join(dir, `${reqId}.json`),
+      fs3.writeFileSync(
+        path4.join(dir, `${reqId}.json`),
         JSON.stringify(entry, null, 2),
         "utf-8"
       );
@@ -3297,9 +3694,9 @@ var OpenAIProvider = class {
     if (!this._logDir) return;
     try {
       const today = logTime?.split("T")[0];
-      const filePath = path2.join(this._logDir, today, `${reqId}.json`);
-      if (!fs2.existsSync(filePath)) return;
-      const entry = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+      const filePath = path4.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;
@@ -3307,7 +3704,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);
     }
@@ -3770,62 +4167,62 @@ init_esm_shims();
 
 // src/tools/pathSafety.ts
 init_esm_shims();
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 function isInsideRelative(rel) {
-  return !path3.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path3.sep}`);
+  return !path5.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path5.sep}`);
 }
 function isFilesystemRoot(p) {
-  return path3.parse(p).root === p;
+  return path5.parse(p).root === p;
 }
 function resolveWithinRoot(workspace, target) {
-  const abs = path3.resolve(workspace, target);
+  const abs = path5.resolve(workspace, target);
   let rootReal;
   try {
-    rootReal = fs3.realpathSync(workspace);
+    rootReal = fs4.realpathSync(workspace);
   } catch {
-    const rootAbs = path3.resolve(workspace);
-    if (!isInsideRelative(path3.relative(rootAbs, abs))) return null;
+    const rootAbs = path5.resolve(workspace);
+    if (!isInsideRelative(path5.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 = path3.join(fs3.realpathSync(probe), ...tail);
+          real = path5.join(fs4.realpathSync(probe), ...tail);
           break;
         } catch {
           return null;
         }
       }
-      tail.unshift(path3.basename(probe));
-      const parent = path3.dirname(probe);
+      tail.unshift(path5.basename(probe));
+      const parent = path5.dirname(probe);
       if (parent === probe) return null;
       probe = parent;
     }
   }
-  if (!isInsideRelative(path3.relative(rootReal, real))) return null;
+  if (!isInsideRelative(path5.relative(rootReal, real))) return null;
   return { root: rootReal, real };
 }
 function isWithinRoot(workspace, target) {
   return resolveWithinRoot(workspace, target) !== null;
 }
 function resolveEntryWithinRoot(workspace, target) {
-  const abs = path3.resolve(workspace, target);
-  const parent = resolveWithinRoot(workspace, path3.dirname(abs));
+  const abs = path5.resolve(workspace, target);
+  const parent = resolveWithinRoot(workspace, path5.dirname(abs));
   if (!parent) return null;
-  return { root: parent.root, real: path3.join(parent.real, path3.basename(abs)) };
+  return { root: parent.root, real: path5.join(parent.real, path5.basename(abs)) };
 }
 
 // src/permissions/PermissionEngine.ts
-import * as path4 from "path";
+import * as path6 from "path";
 var READ_ONLY_MODES = /* @__PURE__ */ new Set(["discuss" /* DISCUSS */, "plan" /* PLAN */]);
 var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "write_file",
@@ -3875,7 +4272,7 @@ var PermissionEngine = class {
   /** 会话级「总是允许此命令」集合 */
   sessionAllowCommands;
   constructor(opts) {
-    this.workspaceRoot = path4.resolve(opts.workspaceRoot);
+    this.workspaceRoot = path6.resolve(opts.workspaceRoot);
     this.mode = opts.mode;
     this.allowedCommands = Array.isArray(opts.allowedCommands) ? opts.allowedCommands : [];
     this.sessionAllowTools = /* @__PURE__ */ new Set();
@@ -4801,14 +5198,14 @@ function approvalToHtmlTable(input, maxLen = APPROVAL_VALUE_MAX) {
 
 // src/engine/FileLogHook.ts
 init_esm_shims();
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path7 from "path";
 var FileLogHook = class {
   constructor(sessionId, stateDir2) {
     this.sessionId = sessionId;
-    fs4.mkdirSync(stateDir2, { recursive: true });
-    this._logPath = path5.join(stateDir2, `${sessionId}.jsonl`);
-    this._statePath = path5.join(stateDir2, `${sessionId}_state.json`);
+    fs5.mkdirSync(stateDir2, { recursive: true });
+    this._logPath = path7.join(stateDir2, `${sessionId}.jsonl`);
+    this._statePath = path7.join(stateDir2, `${sessionId}_state.json`);
   }
   sessionId;
   _logPath;
@@ -4902,13 +5299,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, stateDir2) {
-    const p = path5.join(stateDir2, `${sessionId}_state.json`);
+    const p = path7.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);
@@ -4917,9 +5314,9 @@ var FileLogHook = class {
   }
   /** 读取事件日志 */
   static loadEvents(sessionId, stateDir2) {
-    const p = path5.join(stateDir2, `${sessionId}.jsonl`);
+    const p = path7.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);
@@ -4930,7 +5327,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);
     }
@@ -5358,12 +5755,12 @@ var McpManager = class {
 
 // src/tools/files.ts
 init_esm_shims();
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
 var DEFAULT_MAX_LINES = 2e3;
 var MAX_LINE_CHARS = 500;
 function makeReadFile(workspace) {
-  const root = path6.resolve(workspace);
+  const root = path8.resolve(workspace);
   return function read_file(args) {
     const filePath = String(args.path ?? "");
     const startLine = Math.max(1, Number(args.start_line ?? 1));
@@ -5373,13 +5770,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++) {
@@ -5394,7 +5791,7 @@ function makeReadFile(workspace) {
     }
     const end = startLine + selected.length - 1;
     const result = {
-      path: path6.relative(resolved.root, target),
+      path: path8.relative(resolved.root, target),
       start_line: startLine,
       end_line: end,
       total_lines: total,
@@ -5407,7 +5804,7 @@ function makeReadFile(workspace) {
   };
 }
 function makeWriteFile(workspace) {
-  const root = path6.resolve(workspace);
+  const root = path8.resolve(workspace);
   return function write_file(args) {
     const filePath = String(args.path ?? "");
     const content = String(args.content ?? "");
@@ -5417,34 +5814,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(path6.dirname(target), { recursive: true });
-      fs5.writeFileSync(target, content, "utf-8");
+      fs6.mkdirSync(path8.dirname(target), { recursive: true });
+      fs6.writeFileSync(target, content, "utf-8");
     } catch (exc) {
       return { error: `\u5199\u5165\u5931\u8D25: ${String(exc)}` };
     }
-    return path6.relative(resolved.root, target);
+    return path8.relative(resolved.root, target);
   };
 }
 function makeListFiles(workspace) {
-  const root = path6.resolve(workspace);
+  const root = path8.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;
@@ -5453,14 +5850,14 @@ function makeListFiles(workspace) {
         results.push(e.isDirectory() ? `${e.name}/` : e.name);
       }
       results.sort();
-      return { path: path6.relative(resolved.root, target), entries: results.slice(0, maxResults) };
+      return { path: path8.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 = path6.resolve(workspace);
+  const root = path8.resolve(workspace);
   return function replace_in_file(args) {
     const filePath = String(args.path ?? "");
     const oldStr = String(args.old ?? "");
@@ -5470,19 +5867,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: path6.relative(resolved.root, target),
+        path: path8.relative(resolved.root, target),
         replacements: count,
         chars_before: content.length,
         chars_after: updated.length
@@ -5583,8 +5980,8 @@ function registerFileTools(registry, workspace) {
 
 // src/tools/shell.ts
 init_esm_shims();
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path10 from "path";
 
 // src/tools/execAsync.ts
 init_esm_shims();
@@ -5749,15 +6146,15 @@ function execAsync(file, argv, opts = {}) {
 
 // src/tools/shellRuntime.ts
 init_esm_shims();
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 var WINDOWS_SUFFIXES = [".exe", ".cmd", ".bat", ".com", ""];
 function pathApi(platform) {
-  return platform === "win32" ? path7.win32 : path7.posix;
+  return platform === "win32" ? path9.win32 : path9.posix;
 }
 function defaultFileExists(p) {
   try {
-    return fs6.statSync(p).isFile();
+    return fs7.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -5788,7 +6185,7 @@ function kindFromBasename(base) {
   return "sh";
 }
 function busyboxArgs(file, command) {
-  const base = (file ? path7.win32.basename(file) : "busybox").toLowerCase().replace(/\.(exe|cmd|bat|com)$/, "");
+  const base = (file ? path9.win32.basename(file) : "busybox").toLowerCase().replace(/\.(exe|cmd|bat|com)$/, "");
   return base === "busybox" ? ["sh", "-c", command] : ["-c", command];
 }
 function argsFor(kind, command) {
@@ -6055,7 +6452,7 @@ var MAX_STDERR = 5e3;
 var MAX_BUFFER = 1024 * 1024 * 5;
 var shellSessions = /* @__PURE__ */ new Map();
 function sessionFor(workspace) {
-  const key = path8.resolve(workspace);
+  const key = path10.resolve(workspace);
   let s = shellSessions.get(key);
   if (!s) {
     s = { cwd: key };
@@ -6112,8 +6509,8 @@ function makeRunShell(workspace, spec, tasks, scope) {
     let toRun = command;
     if (target) {
       try {
-        const resolved = path8.resolve(session.cwd, target);
-        if (fs7.existsSync(resolved) && fs7.statSync(resolved).isDirectory()) {
+        const resolved = path10.resolve(session.cwd, target);
+        if (fs8.existsSync(resolved) && fs8.statSync(resolved).isDirectory()) {
           session.cwd = resolved;
         }
       } catch {
@@ -6248,8 +6645,8 @@ init_esm_shims();
 
 // src/tools/nodeGrep.ts
 init_esm_shims();
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path11 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -6274,27 +6671,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 = path9.resolve(opts.workspace, opts.target);
-  if (!fs8.existsSync(target)) {
+  const target = path11.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 = path9.relative(opts.workspace, file) || path9.basename(file);
+    const rel = path11.relative(opts.workspace, file) || path11.basename(file);
     const lines = buf.toString("utf-8").split("\n");
     for (let i = 0; i < lines.length; i++) {
       const raw = lines[i].replace(/\r$/, "");
@@ -6305,7 +6702,7 @@ function nodeGrep(opts) {
     }
     return false;
   };
-  const stat = fs8.statSync(target);
+  const stat = fs9.statSync(target);
   if (stat.isFile()) {
     scanFile(target);
     return matches;
@@ -6315,12 +6712,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 = path9.join(dir, entry.name);
+      const full = path11.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) stack.push(full);
       } else if (entry.isFile()) {
@@ -6333,22 +6730,22 @@ function nodeGrep(opts) {
 
 // src/tools/ripgrep.ts
 init_esm_shims();
-import * as fs9 from "fs";
-import * as os from "os";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as os2 from "os";
+import * as path12 from "path";
 import { createRequire } from "module";
 var cached2;
 function extractBundledRipgrep() {
   try {
-    const req2 = typeof __require === "function" ? __require : createRequire(path10.join(process.cwd(), "__zqagent__.js"));
+    const req2 = typeof __require === "function" ? __require : createRequire(path12.join(process.cwd(), "__zqagent__.js"));
     const sea = req2("node:sea");
     if (!sea?.isSea?.() || typeof sea.getAsset !== "function") return null;
     const asset = sea.getAsset("rg");
     if (!asset) return null;
-    const dir = fs9.mkdtempSync(path10.join(os.tmpdir(), "zqagent-rg-"));
-    const file = path10.join(dir, process.platform === "win32" ? "rg.exe" : "rg");
-    fs9.writeFileSync(file, Buffer.from(asset));
-    fs9.chmodSync(file, 493);
+    const dir = fs10.mkdtempSync(path12.join(os2.tmpdir(), "zqagent-rg-"));
+    const file = path12.join(dir, process.platform === "win32" ? "rg.exe" : "rg");
+    fs10.writeFileSync(file, Buffer.from(asset));
+    fs10.chmodSync(file, 493);
     return file;
   } catch {
     return null;
@@ -6357,7 +6754,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;
   }
@@ -6371,7 +6768,7 @@ function resolveRipgrep() {
     env: process.env,
     fileExists: (p) => {
       try {
-        return fs9.statSync(p).isFile();
+        return fs10.statSync(p).isFile();
       } catch {
         return false;
       }
@@ -6920,8 +7317,8 @@ function registerWebTools(registry) {
 
 // src/tools/git.ts
 init_esm_shims();
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 async function runGit(repoDir, args, timeout = 15e3) {
   const res = await execAsync("git", ["-c", "core.quotepath=false", ...args], {
     cwd: repoDir,
@@ -6938,9 +7335,9 @@ async function runGit(repoDir, args, timeout = 15e3) {
 async function resolveRepoRoot(workspace, pathArg) {
   let dir = workspace;
   if (pathArg) {
-    const abs = path11.resolve(workspace, pathArg);
+    const abs = path13.resolve(workspace, pathArg);
     try {
-      dir = fs10.statSync(abs).isDirectory() ? abs : path11.dirname(abs);
+      dir = fs11.statSync(abs).isDirectory() ? abs : path13.dirname(abs);
     } catch {
       dir = abs;
     }
@@ -6953,24 +7350,24 @@ function repoDirArg(workspace, raw) {
   if (typeof raw !== "string") return void 0;
   const v = raw.trim();
   if (!v) return void 0;
-  const base = path11.resolve(workspace);
-  const abs = path11.resolve(base, v);
-  const rel = path11.relative(base, abs);
-  if (rel.startsWith("..") || path11.isAbsolute(rel)) return void 0;
+  const base = path13.resolve(workspace);
+  const abs = path13.resolve(base, v);
+  const rel = path13.relative(base, abs);
+  if (rel.startsWith("..") || path13.isAbsolute(rel)) return void 0;
   return abs;
 }
 function toPathspec(repoRoot, workspace, pathArg) {
   if (!pathArg) return null;
-  const abs = path11.resolve(workspace, pathArg);
-  let rel = path11.relative(repoRoot, abs);
+  const abs = path13.resolve(workspace, pathArg);
+  let rel = path13.relative(repoRoot, abs);
   if (rel === "") return ".";
-  if (rel.startsWith("..") || path11.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path13.isAbsolute(rel)) {
     try {
-      const realRepo = fs10.realpathSync(repoRoot);
-      const realAbs = fs10.realpathSync(abs);
-      const rel2 = path11.relative(realRepo, realAbs);
+      const realRepo = fs11.realpathSync(repoRoot);
+      const realAbs = fs11.realpathSync(abs);
+      const rel2 = path13.relative(realRepo, realAbs);
       if (rel2 === "") return ".";
-      if (!rel2.startsWith("..") && !path11.isAbsolute(rel2)) return rel2;
+      if (!rel2.startsWith("..") && !path13.isAbsolute(rel2)) return rel2;
     } catch {
     }
     return null;
@@ -7396,18 +7793,18 @@ var SCAN_SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".s
 var SCAN_DEFAULT_DEPTH = 3;
 var SCAN_MAX_DIRS = 2e3;
 function readRepoHead(repoDir) {
-  const dotGit = path11.join(repoDir, ".git");
+  const dotGit = path13.join(repoDir, ".git");
   try {
     let headFile;
-    if (fs10.statSync(dotGit).isDirectory()) {
-      headFile = path11.join(dotGit, "HEAD");
+    if (fs11.statSync(dotGit).isDirectory()) {
+      headFile = path13.join(dotGit, "HEAD");
     } else {
-      const raw = fs10.readFileSync(dotGit, "utf-8");
+      const raw = fs11.readFileSync(dotGit, "utf-8");
       const m = /^gitdir:\s*(.+)$/m.exec(raw);
       if (!m) return {};
-      headFile = path11.join(path11.resolve(repoDir, m[1].trim()), "HEAD");
+      headFile = path13.join(path13.resolve(repoDir, m[1].trim()), "HEAD");
     }
-    const head = fs10.readFileSync(headFile, "utf-8").trim();
+    const head = fs11.readFileSync(headFile, "utf-8").trim();
     const prefix = "ref: refs/heads/";
     if (head.startsWith(prefix)) return { branch: head.slice(prefix.length), detached: false };
     if (/^[0-9a-f]{7,40}$/i.test(head)) return { branch: head.slice(0, 7), detached: true };
@@ -7416,7 +7813,7 @@ function readRepoHead(repoDir) {
   return {};
 }
 function scanGitRepos(workspace, depth = SCAN_DEFAULT_DEPTH) {
-  const root = path11.resolve(workspace);
+  const root = path13.resolve(workspace);
   const maxDepth = Number.isFinite(depth) ? Math.min(Math.max(Math.floor(depth), 0), 6) : SCAN_DEFAULT_DEPTH;
   const repos = [];
   const stack = [{ dir: root, depth: 0 }];
@@ -7429,24 +7826,24 @@ function scanGitRepos(workspace, depth = SCAN_DEFAULT_DEPTH) {
       truncated = true;
       break;
     }
-    const rel = path11.relative(root, dir).split(path11.sep).join("/");
-    if (fs10.existsSync(path11.join(dir, ".git"))) {
+    const rel = path13.relative(root, dir).split(path13.sep).join("/");
+    if (fs11.existsSync(path13.join(dir, ".git"))) {
       repos.push({
         path: rel,
-        name: rel ? path11.basename(dir) : path11.basename(root),
+        name: rel ? path13.basename(dir) : path13.basename(root),
         ...readRepoHead(dir)
       });
     }
     if (d >= maxDepth) continue;
     let entries;
     try {
-      entries = fs10.readdirSync(dir, { withFileTypes: true });
+      entries = fs11.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
       if (!e.isDirectory() || SCAN_SKIP_DIRS.has(e.name)) continue;
-      stack.push({ dir: path11.join(dir, e.name), depth: d + 1 });
+      stack.push({ dir: path13.join(dir, e.name), depth: d + 1 });
     }
   }
   repos.sort(
@@ -7456,9 +7853,9 @@ function scanGitRepos(workspace, depth = SCAN_DEFAULT_DEPTH) {
 }
 function makeGitRepos(workspace) {
   return async function git_repos(args) {
-    const root = path11.resolve(workspace);
+    const root = path13.resolve(workspace);
     try {
-      if (!fs10.statSync(root).isDirectory()) return { root, repos: [], error: "\u5DE5\u4F5C\u533A\u4E0D\u662F\u76EE\u5F55" };
+      if (!fs11.statSync(root).isDirectory()) return { root, repos: [], error: "\u5DE5\u4F5C\u533A\u4E0D\u662F\u76EE\u5F55" };
     } catch {
       return { root, repos: [], error: "\u5DE5\u4F5C\u533A\u76EE\u5F55\u4E0D\u5B58\u5728" };
     }
@@ -7470,10 +7867,10 @@ function makeGitRepos(workspace) {
 
 // src/tools/diff.ts
 init_esm_shims();
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 function makeApplyPatch(workspace) {
-  const root = path12.resolve(workspace);
+  const root = path14.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" };
@@ -7512,12 +7909,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(path12.dirname(target), { recursive: true });
-        fs11.writeFileSync(target, contentLines.join("\n") + "\n", "utf-8");
-        const rel = path12.relative(resolved.root, target);
+        fs12.mkdirSync(path14.dirname(target), { recursive: true });
+        fs12.writeFileSync(target, contentLines.join("\n") + "\n", "utf-8");
+        const rel = path14.relative(resolved.root, target);
         changedFiles.push(rel);
         addedFiles.push(rel);
         fileCount++;
@@ -7530,11 +7927,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(path12.relative(entry.root, target));
+        fs12.unlinkSync(target);
+        deletedFiles.push(path14.relative(entry.root, target));
         fileCount++;
         i++;
         continue;
@@ -7570,10 +7967,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) {
@@ -7584,20 +7981,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(path12.dirname(finalTarget), { recursive: true });
-        fs11.writeFileSync(finalTarget, newLines.join("\n"), "utf-8");
+        fs12.mkdirSync(path14.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(path12.relative(resolved.root, target));
+          fs12.unlinkSync(entry.real);
+          deletedFiles.push(path14.relative(resolved.root, target));
         }
-        changedFiles.push(path12.relative(finalResolved.root, finalTarget));
+        changedFiles.push(path14.relative(finalResolved.root, finalTarget));
         fileCount++;
         continue;
       }
@@ -7609,18 +8006,18 @@ function makeApplyPatch(workspace) {
     return { changed_files: changedFiles, added_files: addedFiles, deleted_files: deletedFiles, file_count: fileCount };
   };
 }
-function applyPatchHunks(oldLines, chunks, path42) {
+function applyPatchHunks(oldLines, chunks, path44) {
   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: ${path42}`);
+      throw new Error(`\u8865\u4E01 hunk \u5FC5\u987B\u5305\u542B\u4E0A\u4E0B\u6587\u6216\u5220\u9664\u884C: ${path44}`);
     }
     const matchStart = findBlockMatch(newLines, oldBlock, cursor);
     if (matchStart === -1) {
-      throw new Error(`\u8865\u4E01\u4E0A\u4E0B\u6587\u4E0D\u5339\u914D: ${path42}`);
+      throw new Error(`\u8865\u4E01\u4E0A\u4E0B\u6587\u4E0D\u5339\u914D: ${path44}`);
     }
     const matchEnd = matchStart + oldBlock.length;
     newLines.splice(matchStart, oldBlock.length, ...newBlock);
@@ -7637,7 +8034,7 @@ function findBlockMatch(lines, block, start) {
   return -1;
 }
 function makeApplyUnifiedDiff(workspace) {
-  const root = path12.resolve(workspace);
+  const root = path14.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" };
@@ -7656,26 +8053,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(path12.relative(resolved.root, target));
+        deletedFiles.push(path14.relative(resolved.root, target));
         continue;
       }
-      fs11.mkdirSync(path12.dirname(target), { recursive: true });
-      fs11.writeFileSync(target, newLines.join("\n"), "utf-8");
-      const rel = path12.relative(resolved.root, target);
+      fs12.mkdirSync(path14.dirname(target), { recursive: true });
+      fs12.writeFileSync(target, newLines.join("\n"), "utf-8");
+      const rel = path14.relative(resolved.root, target);
       changedFiles.push(rel);
       if (oldIsDevNull) addedFiles.push(rel);
     }
@@ -7939,7 +8336,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) {
@@ -7951,7 +8349,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";
@@ -8012,14 +8411,14 @@ function registerExploreTool(registry, opts) {
 
 // src/tools/media.ts
 init_esm_shims();
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path16 from "path";
 
 // src/tools/ffmpegRuntime.ts
 init_esm_shims();
-import * as fs12 from "fs";
-import * as os2 from "os";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as os3 from "os";
+import * as path15 from "path";
 import { createRequire as createRequire2 } from "module";
 import { createHash } from "crypto";
 import { pipeline } from "stream/promises";
@@ -8042,29 +8441,29 @@ if (PROXY_ENV2) {
 }
 var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
 function agentBinDir(workspace) {
-  return path13.join(path13.resolve(workspace), ".agent", "bin");
+  return path15.join(path15.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 req2 = typeof __require === "function" ? __require : createRequire2(path13.join(process.cwd(), "__zqagent__.js"));
+    const req2 = typeof __require === "function" ? __require : createRequire2(path15.join(process.cwd(), "__zqagent__.js"));
     const sea = req2("node:sea");
     if (!sea?.isSea?.() || typeof sea.getAsset !== "function") return null;
     const asset = sea.getAsset(name);
     if (!asset) return null;
-    const dir = fs12.mkdtempSync(path13.join(os2.tmpdir(), `zqagent-${name}-`));
-    const file = path13.join(dir, exeName(name, platform));
-    fs12.writeFileSync(file, Buffer.from(asset));
-    fs12.chmodSync(file, 493);
+    const dir = fs13.mkdtempSync(path15.join(os3.tmpdir(), `zqagent-${name}-`));
+    const file = path15.join(dir, exeName(name, platform));
+    fs13.writeFileSync(file, Buffer.from(asset));
+    fs13.chmodSync(file, 493);
     return file;
   } catch {
     return null;
@@ -8074,7 +8473,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 = path13.join(agentBinDir(workspace), exeName(name, o.platform));
+  const local = path15.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" };
@@ -8088,7 +8487,7 @@ function resolveOne(name, workspace, o) {
 var cache = /* @__PURE__ */ new Map();
 function resolveMedia(workspace, opts = {}) {
   const platform = opts.platform ?? process.platform;
-  const key = `${platform}:${path13.resolve(workspace)}`;
+  const key = `${platform}:${path15.resolve(workspace)}`;
   const hit = cache.get(key);
   if (hit) return hit;
   const ctx = {
@@ -8194,7 +8593,7 @@ function parseChecksumFile(text, filename) {
     if (!m) continue;
     const hash = m[1].toLowerCase();
     const name = m[2]?.trim() ?? "";
-    if (!name || name === filename || path13.basename(name) === filename) return hash;
+    if (!name || name === filename || path15.basename(name) === filename) return hash;
   }
   const single = lines[0]?.trim();
   if (lines.length === 1 && single && /^[0-9a-f]{32,128}$/i.test(single)) {
@@ -8204,7 +8603,7 @@ function parseChecksumFile(text, filename) {
 }
 async function computeChecksum(file, algo) {
   const hash = createHash(algo);
-  await pipeline(fs12.createReadStream(file), hash);
+  await pipeline(fs13.createReadStream(file), hash);
   return hash.digest("hex");
 }
 function fetchInit() {
@@ -8219,7 +8618,7 @@ async function downloadToFile(url, dest) {
   const resp = await nodeFetch3(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 pipeline(resp.body, fs12.createWriteStream(dest));
+  await pipeline(resp.body, fs13.createWriteStream(dest));
 }
 async function resolveComponentUrl(c) {
   if (c.url) return c.url;
@@ -8236,12 +8635,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 = path13.join(cur, e.name);
+      const full = path15.join(cur, e.name);
       if (e.isDirectory()) {
         stack.push(full);
       } else if (names.includes(e.name)) {
@@ -8252,7 +8651,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]);
@@ -8288,7 +8687,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
       error: `\u6682\u4E0D\u652F\u6301\u81EA\u52A8\u4E0B\u8F7D\u7684\u5E73\u53F0: ${platform}/${arch}`
     };
   }
-  const tmp = fs12.mkdtempSync(path13.join(os2.tmpdir(), "zqagent-ffmpeg-"));
+  const tmp = fs13.mkdtempSync(path15.join(os3.tmpdir(), "zqagent-ffmpeg-"));
   const binDir = agentBinDir(workspace);
   const installed = {};
   try {
@@ -8302,7 +8701,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
       }
       let archive = fetched.get(url);
       if (!archive) {
-        const archivePath = path13.join(tmp, path13.basename(new URL(url).pathname) || `${c.name}.${c.archive}`);
+        const archivePath = path15.join(tmp, path15.basename(new URL(url).pathname) || `${c.name}.${c.archive}`);
         log(`\u4E0B\u8F7D ${url}`);
         try {
           await downloadToFile(url, archivePath);
@@ -8312,7 +8711,7 @@ async function downloadFfmpeg(workspace, opts = {}) {
         if (c.checksumUrl) {
           const algo = c.checksumAlgo ?? "sha256";
           try {
-            const expected = parseChecksumFile(await fetchText(c.checksumUrl), path13.basename(archivePath));
+            const expected = parseChecksumFile(await fetchText(c.checksumUrl), path15.basename(archivePath));
             if (!expected) {
               notes.push(`\u672A\u80FD\u4ECE ${c.checksumUrl} \u89E3\u6790\u51FA\u6821\u9A8C\u548C\uFF0C\u5DF2\u8DF3\u8FC7\u6821\u9A8C`);
             } else {
@@ -8329,24 +8728,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(`${path13.basename(archivePath)} \u672A\u63D0\u4F9B\u6821\u9A8C\u548C\uFF08\u4EC5 HTTPS \u4F20\u8F93\u4FDD\u62A4\uFF09`);
+          notes.push(`${path15.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(path13.join(tmp, "x-"));
+      const extractDir = fs13.mkdtempSync(path15.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}: ${path13.basename(archive.file)}` };
+        return { ok: false, error: `\u5F52\u6863\u5185\u672A\u627E\u5230 ${c.name}: ${path15.basename(archive.file)}` };
       }
-      fs12.mkdirSync(binDir, { recursive: true });
-      const target = path13.join(binDir, exeName(c.name, platform));
+      fs13.mkdirSync(binDir, { recursive: true });
+      const target = path15.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();
@@ -8355,7 +8754,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) {
@@ -8620,13 +9019,13 @@ function resolveTarget(workspace, value) {
   return { abs: resolved.real, root: resolved.root };
 }
 function relOut(workspace, abs) {
-  return path14.relative(workspace, abs) || abs;
+  return path16.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 = path14.resolve(workspace);
+    const root = path16.resolve(workspace);
     const op = str(args["op"]);
     if (!op) {
       return { error: `\u7F3A\u5C11\u53C2\u6570 op\u3002\u53EF\u9009\u503C\uFF1A${OPS.join(" / ")}` };
@@ -8671,7 +9070,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;
@@ -8683,7 +9082,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(path14.dirname(r.abs), { recursive: true });
+      fs14.mkdirSync(path16.dirname(r.abs), { recursive: true });
       outputAbs = r.abs;
       relRoot = r.root;
     }
@@ -8733,7 +9132,7 @@ function registerMediaTool(registry, workspace, opts = {}) {
     };
     if (outputAbs) {
       try {
-        result["size_bytes"] = fs13.statSync(outputAbs).size;
+        result["size_bytes"] = fs14.statSync(outputAbs).size;
       } catch {
       }
     }
@@ -8976,7 +9375,9 @@ function createDefaultEngine(opts) {
     subagentHookFactory,
     contextWindow,
     thresholdPct,
+    softThresholdPct,
     capTokens,
+    toolResultDir: toolResultDir2,
     logDir
   } = opts;
   const envEffort = process.env.OPENAI_REASONING_EFFORT?.toLowerCase();
@@ -8999,7 +9400,8 @@ function createDefaultEngine(opts) {
     workspace,
     provider: effectiveProvider,
     model,
-    hookFactory: subagentHookFactory
+    hookFactory: subagentHookFactory,
+    toolResultDir: toolResultDir2
   });
   const permissions = new PermissionEngine({
     workspaceRoot: workspace,
@@ -9021,7 +9423,9 @@ function createDefaultEngine(opts) {
     hook,
     contextWindow,
     thresholdPct,
-    capTokens
+    softThresholdPct,
+    capTokens,
+    toolResultDir: toolResultDir2
   });
   return engine;
 }
@@ -9031,8 +9435,8 @@ init_esm_shims();
 
 // src/llmConfig.ts
 init_esm_shims();
-import * as fs15 from "fs";
-import * as path17 from "path";
+import * as fs16 from "fs";
+import * as path18 from "path";
 import * as crypto3 from "crypto";
 
 // src/crypto/secrets.ts
@@ -9041,8 +9445,8 @@ init_esm_shims();
 // ../shared/src/secrets.ts
 init_esm_shims();
 import * as crypto2 from "crypto";
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path17 from "path";
 function encryptWithKey(key, plain) {
   const iv = crypto2.randomBytes(12);
   const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
@@ -9073,16 +9477,16 @@ function decryptWithKey(key, payload) {
   }
 }
 function loadOrCreateMasterKey(masterKeyFile) {
-  if (fs14.existsSync(masterKeyFile)) {
-    const hex = fs14.readFileSync(masterKeyFile, "utf8").trim();
+  if (fs15.existsSync(masterKeyFile)) {
+    const hex = fs15.readFileSync(masterKeyFile, "utf8").trim();
     if (/^[0-9a-f]{64}$/i.test(hex)) {
       return Buffer.from(hex, "hex");
     }
     console.warn(`\u26A0\uFE0F  \u4E3B\u5BC6\u94A5\u6587\u4EF6\u635F\u574F\uFF0C\u5DF2\u91CD\u65B0\u751F\u6210\uFF08\u65E7\u5BC6\u6587\u5C06\u65E0\u6CD5\u89E3\u5BC6\uFF09`);
   }
   const key = crypto2.randomBytes(32);
-  fs14.mkdirSync(path15.dirname(masterKeyFile), { recursive: true, mode: 448 });
-  fs14.writeFileSync(masterKeyFile, key.toString("hex"), {
+  fs15.mkdirSync(path17.dirname(masterKeyFile), { recursive: true, mode: 448 });
+  fs15.writeFileSync(masterKeyFile, key.toString("hex"), {
     mode: 384,
     encoding: "utf8"
   });
@@ -9300,26 +9704,6 @@ async function probeModel(baseURL, apiKey, model) {
   }
 }
 
-// src/paths.ts
-init_esm_shims();
-import * as os3 from "os";
-import * as path16 from "path";
-var APP_DIR_NAME = "zqagent";
-var DEFAULT_DATA_DIR = ".zqagent_data";
-var DEFAULT_HUB_URL = "https://hub.cd-zq.com";
-var IS_WINDOWS = process.platform === "win32";
-function homeDir() {
-  return process.env.HOME || process.env.USERPROFILE || os3.homedir() || os3.tmpdir();
-}
-function configDir() {
-  const base = process.env.XDG_CONFIG_HOME || (IS_WINDOWS ? process.env.APPDATA : void 0) || path16.join(homeDir(), ".config");
-  return path16.join(base, APP_DIR_NAME);
-}
-function stateDir() {
-  const base = process.env.XDG_STATE_HOME || (IS_WINDOWS ? process.env.LOCALAPPDATA : void 0) || path16.join(homeDir(), ".local", "state");
-  return path16.join(base, APP_DIR_NAME);
-}
-
 // ../shared/src/llm-presets.ts
 init_esm_shims();
 var LLM_PRESETS = [
@@ -9384,11 +9768,11 @@ function llmPreset(id) {
 function llmConfigFile() {
   const override = process.env.ZQAGENT_LLM_CONFIG_FILE?.trim();
   if (override) return override;
-  return path17.join(configDir(), "connections.json");
+  return path18.join(configDir(), "connections.json");
 }
 var keyCache = /* @__PURE__ */ new Map();
 function masterKeyFileFor(file) {
-  return path17.join(path17.dirname(file), "secret.key");
+  return path18.join(path18.dirname(file), "secret.key");
 }
 function getMasterKey(file) {
   const keyFile = masterKeyFileFor(file);
@@ -9493,10 +9877,10 @@ function normalize(f) {
   return { ...f, providers, activeId };
 }
 function readRaw(file, keyFile = file) {
-  if (!fs15.existsSync(file)) return null;
+  if (!fs16.existsSync(file)) return null;
   let raw;
   try {
-    raw = JSON.parse(fs15.readFileSync(file, "utf8"));
+    raw = JSON.parse(fs16.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -9544,19 +9928,19 @@ function readLlmConfig(opts = {}) {
     f = r.config;
     changed = changed || r.changed;
   }
-  if (changed || !fs15.existsSync(file)) writeLlmConfig(f, file);
+  if (changed || !fs16.existsSync(file)) writeLlmConfig(f, file);
   return f;
 }
 function writeLlmConfig(f, file = llmConfigFile()) {
   const next = normalize(f);
-  fs15.mkdirSync(path17.dirname(file), { recursive: true, mode: 448 });
-  fs15.writeFileSync(file, JSON.stringify(next, null, 2) + "\n", {
+  fs16.mkdirSync(path18.dirname(file), { recursive: true, mode: 448 });
+  fs16.writeFileSync(file, JSON.stringify(next, null, 2) + "\n", {
     mode: 384,
     encoding: "utf8"
   });
 }
 function commonLegacyFiles() {
-  return [path17.join(stateDir(), "data", "node-llm.json")];
+  return [path18.join(stateDir(), "data", "node-llm.json")];
 }
 
 // src/cli/connection.ts
@@ -9989,17 +10373,17 @@ function renderBanner(opts = {}) {
 // src/cli/terminalSetup.ts
 init_esm_shims();
 import { existsSync as existsSync13 } from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 var TERM_SETUP_ENV = "ZQAGENT_TERM_SETUP";
 var FALSE_FLAGS = ["0", "false", "no", "off"];
 var TRUE_FLAGS = ["1", "true", "yes", "on"];
 function hasWindowsTerminal(env3 = process.env, fileExists = existsSync13) {
   const raw = env3.PATH ?? env3.Path ?? "";
-  const dirs = raw.split(path18.delimiter).filter(Boolean);
+  const dirs = raw.split(path19.delimiter).filter(Boolean);
   if (env3.LOCALAPPDATA) {
-    dirs.push(path18.join(env3.LOCALAPPDATA, "Microsoft", "WindowsApps"));
+    dirs.push(path19.join(env3.LOCALAPPDATA, "Microsoft", "WindowsApps"));
   }
-  return dirs.some((dir) => fileExists(path18.join(dir, "wt.exe")));
+  return dirs.some((dir) => fileExists(path19.join(dir, "wt.exe")));
 }
 function detectTerminalSetup(input = {}) {
   const env3 = input.env ?? process.env;
@@ -10080,13 +10464,13 @@ function renderTerminalTutorial() {
 
 // src/cli/link.ts
 init_esm_shims();
-import * as path21 from "path";
+import * as path22 from "path";
 
 // src/server/store.ts
 init_esm_shims();
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as fsp from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 import { randomUUID } from "crypto";
 
 // src/server/dbgTrace.ts
@@ -10140,57 +10524,57 @@ var Store = class {
   sessionCache = /* @__PURE__ */ new Map();
   // ===================== 租户 =====================
   tenantDir(tenantId) {
-    return path19.join(this.root, "tenants", tenantId);
+    return path20.join(this.root, "tenants", tenantId);
   }
   listTenants() {
-    const dir = path19.join(this.root, "tenants");
+    const dir = path20.join(this.root, "tenants");
     try {
-      return fs16.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      return fs17.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
       return [];
     }
   }
   loadTenant(tenantId) {
-    return this._readJson(path19.join(this.tenantDir(tenantId), "config.json"));
+    return this._readJson(path20.join(this.tenantDir(tenantId), "config.json"));
   }
   saveTenant(config) {
     const dir = this.tenantDir(config.id);
-    fs16.mkdirSync(dir, { recursive: true });
-    fs16.writeFileSync(path19.join(dir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+    fs17.mkdirSync(dir, { recursive: true });
+    fs17.writeFileSync(path20.join(dir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
   }
   deleteTenant(tenantId) {
-    fs16.rmSync(this.tenantDir(tenantId), { recursive: true, force: true });
+    fs17.rmSync(this.tenantDir(tenantId), { recursive: true, force: true });
   }
   // ===================== 会话 =====================
   workspaceDir(tenantId, sessionId) {
-    return path19.join(this.tenantDir(tenantId), "workspaces", sessionId);
+    return path20.join(this.tenantDir(tenantId), "workspaces", sessionId);
   }
   /** 创建（或复用）会话工作区沙箱目录 */
   ensureWorkspace(tenantId, sessionId) {
     const dir = this.workspaceDir(tenantId, sessionId);
-    fs16.mkdirSync(dir, { recursive: true });
+    fs17.mkdirSync(dir, { recursive: true });
     return dir;
   }
   sessionDir(tenantId, sessionId) {
-    return path19.join(this.tenantDir(tenantId), "sessions", sessionId);
+    return path20.join(this.tenantDir(tenantId), "sessions", sessionId);
   }
   listSessions(tenantId) {
-    const dir = path19.join(this.tenantDir(tenantId), "sessions");
+    const dir = path20.join(this.tenantDir(tenantId), "sessions");
     try {
-      return fs16.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      return fs17.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
       return [];
     }
   }
   loadSession(tenantId, sessionId) {
-    const p = path19.join(this.sessionDir(tenantId, sessionId), "session.json");
+    const p = path20.join(this.sessionDir(tenantId, sessionId), "session.json");
     try {
-      const st = fs16.statSync(p);
+      const st = fs17.statSync(p);
       const key = `${st.mtimeMs}:${st.size}`;
       const hit = this.sessionCache.get(p);
       if (hit && hit.key === key) return hit.rec;
       const __t0 = dbgNow();
-      const rec = JSON.parse(fs16.readFileSync(p, "utf-8"));
+      const rec = JSON.parse(fs17.readFileSync(p, "utf-8"));
       dbgMs("store.loadSession(\u89E3\u6790)", __t0, `bytes=${st.size}`);
       this.sessionCache.set(p, { key, rec });
       if (this.sessionCache.size > 300) {
@@ -10206,8 +10590,8 @@ var Store = class {
   saveSession(record) {
     record.savedAt = (/* @__PURE__ */ new Date()).toISOString();
     const dir = this.sessionDir(record.tenantId, record.sessionId);
-    fs16.mkdirSync(dir, { recursive: true });
-    const file = path19.join(dir, "session.json");
+    fs17.mkdirSync(dir, { recursive: true });
+    const file = path20.join(dir, "session.json");
     const snapshot = JSON.stringify(record, null, 2);
     const tmp = `${file}.${randomUUID()}.tmp`;
     const prev = this.writeChains.get(file) ?? Promise.resolve();
@@ -10222,34 +10606,34 @@ var Store = class {
   saveSessionSync(record) {
     record.savedAt = (/* @__PURE__ */ new Date()).toISOString();
     const dir = this.sessionDir(record.tenantId, record.sessionId);
-    fs16.mkdirSync(dir, { recursive: true });
-    fs16.writeFileSync(
-      path19.join(dir, "session.json"),
+    fs17.mkdirSync(dir, { recursive: true });
+    fs17.writeFileSync(
+      path20.join(dir, "session.json"),
       JSON.stringify(record, null, 2),
       "utf-8"
     );
   }
   deleteSession(tenantId, sessionId) {
-    this.sessionCache.delete(path19.join(this.sessionDir(tenantId, sessionId), "session.json"));
-    fs16.rmSync(this.sessionDir(tenantId, sessionId), { recursive: true, force: true });
-    fs16.rmSync(this.workspaceDir(tenantId, sessionId), { recursive: true, force: true });
+    this.sessionCache.delete(path20.join(this.sessionDir(tenantId, sessionId), "session.json"));
+    fs17.rmSync(this.sessionDir(tenantId, sessionId), { recursive: true, force: true });
+    fs17.rmSync(this.workspaceDir(tenantId, sessionId), { recursive: true, force: true });
   }
   // ===================== 事件日志 =====================
   appendEvent(tenantId, sessionId, entry) {
     const dir = this.sessionDir(tenantId, sessionId);
-    fs16.mkdirSync(dir, { recursive: true });
+    fs17.mkdirSync(dir, { recursive: true });
     return fsp.appendFile(
-      path19.join(dir, "events.jsonl"),
+      path20.join(dir, "events.jsonl"),
       JSON.stringify(entry) + "\n",
       "utf-8"
     ).catch(() => {
     });
   }
   loadEvents(tenantId, sessionId) {
-    const p = path19.join(this.sessionDir(tenantId, sessionId), "events.jsonl");
+    const p = path20.join(this.sessionDir(tenantId, sessionId), "events.jsonl");
     const __t0 = dbgNow();
     try {
-      const raw = fs16.readFileSync(p, "utf-8");
+      const raw = fs17.readFileSync(p, "utf-8");
       const out = raw.trim().split("\n").filter(Boolean).map((l) => JSON.parse(l));
       dbgMs("store.loadEvents(\u6574\u6587\u4EF6)", __t0, `bytes=${raw.length} evts=${out.length}`);
       return out;
@@ -10267,15 +10651,15 @@ var Store = class {
    * 窗口内一条完整记录都没有时回退为整文件读取。
    */
   loadEventsTail(tenantId, sessionId, maxBytes = 1024 * 1024) {
-    const p = path19.join(this.sessionDir(tenantId, sessionId), "events.jsonl");
+    const p = path20.join(this.sessionDir(tenantId, sessionId), "events.jsonl");
     const __t0 = dbgNow();
     let fd = null;
     try {
-      const size = fs16.statSync(p).size;
+      const size = fs17.statSync(p).size;
       if (size <= maxBytes) return this.loadEvents(tenantId, sessionId);
-      fd = fs16.openSync(p, "r");
+      fd = fs17.openSync(p, "r");
       const buf = Buffer.allocUnsafe(maxBytes);
-      const read2 = fs16.readSync(fd, buf, 0, maxBytes, size - maxBytes);
+      const read2 = fs17.readSync(fd, buf, 0, maxBytes, size - maxBytes);
       let text = buf.subarray(0, read2).toString("utf-8");
       const nl = text.indexOf("\n");
       if (nl < 0) return this.loadEvents(tenantId, sessionId);
@@ -10300,7 +10684,7 @@ var Store = class {
     } finally {
       if (fd !== null) {
         try {
-          fs16.closeSync(fd);
+          fs17.closeSync(fd);
         } catch {
         }
       }
@@ -10309,26 +10693,26 @@ var Store = class {
   // ===================== 节点身份 & 管理员密钥 =====================
   /** 节点稳定标识：{root}/node.json（首次启动生成后长期固定） */
   loadNodeId() {
-    const v = this._readJson(path19.join(this.root, "node.json"));
+    const v = this._readJson(path20.join(this.root, "node.json"));
     return v?.id && typeof v.id === "string" ? v.id : null;
   }
   saveNodeId(id) {
-    fs16.mkdirSync(this.root, { recursive: true });
-    const file = path19.join(this.root, "node.json");
+    fs17.mkdirSync(this.root, { recursive: true });
+    const file = path20.join(this.root, "node.json");
     const cur = this._readJson(file) ?? {};
-    fs16.writeFileSync(file, JSON.stringify({ ...cur, id }, null, 2), "utf-8");
+    fs17.writeFileSync(file, JSON.stringify({ ...cur, id }, null, 2), "utf-8");
   }
   /** 节点展示名：{root}/node.json 的 label（Hub 下发或本地设置） */
   loadNodeLabel() {
-    const v = this._readJson(path19.join(this.root, "node.json"));
+    const v = this._readJson(path20.join(this.root, "node.json"));
     return v?.label && typeof v.label === "string" ? v.label : null;
   }
   /** 写入/更新节点展示名（保留 id 等既有字段） */
   saveNodeLabel(label) {
-    fs16.mkdirSync(this.root, { recursive: true });
-    const file = path19.join(this.root, "node.json");
+    fs17.mkdirSync(this.root, { recursive: true });
+    const file = path20.join(this.root, "node.json");
     const cur = this._readJson(file) ?? {};
-    fs16.writeFileSync(file, JSON.stringify({ ...cur, label }, null, 2), "utf-8");
+    fs17.writeFileSync(file, JSON.stringify({ ...cur, label }, null, 2), "utf-8");
   }
   /**
    * 节点级 LLM 配置：统一存放于本机 `~/.config/zqagent/connections.json`
@@ -10339,7 +10723,7 @@ var Store = class {
     const file = this.llmFile();
     const cfg = readLlmConfig({
       file,
-      legacyFiles: [path19.join(this.root, "node-llm.json")]
+      legacyFiles: [path20.join(this.root, "node-llm.json")]
     });
     return {
       providers: cfg.providers.map((p) => ({
@@ -10361,7 +10745,7 @@ var Store = class {
     const file = this.llmFile();
     const cur = readLlmConfig({
       file,
-      legacyFiles: [path19.join(this.root, "node-llm.json")]
+      legacyFiles: [path20.join(this.root, "node-llm.json")]
     });
     const old = new Map(cur.providers.map((p) => [p.id, p]));
     const providers = cfg.providers.map((p) => {
@@ -10393,13 +10777,13 @@ var Store = class {
   }
   /** 管理员密钥：{root}/admin.json（可跨项目操作；桌面外壳注入） */
   loadAdminKey() {
-    const v = this._readJson(path19.join(this.root, "admin.json"));
+    const v = this._readJson(path20.join(this.root, "admin.json"));
     return v?.apiKey && typeof v.apiKey === "string" ? v.apiKey : null;
   }
   saveAdminKey(apiKey) {
-    fs16.mkdirSync(this.root, { recursive: true });
-    fs16.writeFileSync(
-      path19.join(this.root, "admin.json"),
+    fs17.mkdirSync(this.root, { recursive: true });
+    fs17.writeFileSync(
+      path20.join(this.root, "admin.json"),
       JSON.stringify({ apiKey }, null, 2),
       "utf-8"
     );
@@ -10409,18 +10793,18 @@ var Store = class {
    * 节点凭注册码接入后写入；启动时优先于环境变量读取。
    */
   loadFleetCredential() {
-    return this._readJson(path19.join(this.root, "fleet.json"));
+    return this._readJson(path20.join(this.root, "fleet.json"));
   }
   saveFleetCredential(cred) {
-    fs16.mkdirSync(this.root, { recursive: true });
-    fs16.writeFileSync(
-      path19.join(this.root, "fleet.json"),
+    fs17.mkdirSync(this.root, { recursive: true });
+    fs17.writeFileSync(
+      path20.join(this.root, "fleet.json"),
       JSON.stringify(cred, null, 2),
       { encoding: "utf-8", mode: 384 }
     );
   }
   clearFleetCredential() {
-    fs16.rmSync(path19.join(this.root, "fleet.json"), { force: true });
+    fs17.rmSync(path20.join(this.root, "fleet.json"), { force: true });
   }
   /** 数据根目录（只读；节点管理配置等辅助文件定位用） */
   get rootDir() {
@@ -10429,7 +10813,7 @@ var Store = class {
   // ===================== 工具 =====================
   _readJson(p) {
     try {
-      return JSON.parse(fs16.readFileSync(p, "utf-8"));
+      return JSON.parse(fs17.readFileSync(p, "utf-8"));
     } catch {
       return null;
     }
@@ -10442,13 +10826,13 @@ var baseUrlResolver = null;
 function resolveBase(baseUrl) {
   return baseUrlResolver ? baseUrlResolver(baseUrl) : baseUrl;
 }
-async function req(baseUrl, token, path42, init = {}) {
+async function req(baseUrl, token, path44, init = {}) {
   const headers = {
     ...init.body ? { "Content-Type": "application/json" } : {},
     ...init.headers ?? {}
   };
   if (token) headers.Authorization = `Bearer ${token}`;
-  const res = await fetch(`${resolveBase(baseUrl).replace(/\/$/, "")}${path42}`, {
+  const res = await fetch(`${resolveBase(baseUrl).replace(/\/$/, "")}${path44}`, {
     ...init,
     headers
   });
@@ -10491,8 +10875,8 @@ async function hubEnrollByAccount(baseUrl, input) {
 // src/cli/serve-instances.ts
 init_esm_shims();
 import { spawnSync as spawnSync2 } from "child_process";
-import * as fs17 from "fs";
-import * as path20 from "path";
+import * as fs18 from "fs";
+import * as path21 from "path";
 var DEFAULT_SERVE_HOST = "127.0.0.1";
 var DEFAULT_SERVE_PORT = 8787;
 function serveSubcommandIndex(argv) {
@@ -10530,9 +10914,9 @@ function parseServeArgs(argv) {
 }
 function buildHotCandidates(explicitDataDir, discovered, fallback) {
   if (explicitDataDir) {
-    return [{ dataDir: path20.resolve(explicitDataDir), ...fallback }];
+    return [{ dataDir: path21.resolve(explicitDataDir), ...fallback }];
   }
-  const out = [{ dataDir: path20.resolve(DEFAULT_DATA_DIR), ...fallback }];
+  const out = [{ dataDir: path21.resolve(DEFAULT_DATA_DIR), ...fallback }];
   for (const inst of discovered) {
     if (!out.some((o) => o.dataDir === inst.dataDir)) out.push(inst);
   }
@@ -10540,7 +10924,7 @@ function buildHotCandidates(explicitDataDir, discovered, fallback) {
 }
 function processCwd(pid) {
   try {
-    return fs17.readlinkSync(`/proc/${pid}/cwd`);
+    return fs18.readlinkSync(`/proc/${pid}/cwd`);
   } catch {
     return null;
   }
@@ -10548,7 +10932,7 @@ function processCwd(pid) {
 function processEnv(pid) {
   const out = {};
   try {
-    const raw = fs17.readFileSync(`/proc/${pid}/environ`, "utf-8");
+    const raw = fs18.readFileSync(`/proc/${pid}/environ`, "utf-8");
     for (const entry of raw.split("\0")) {
       const eq = entry.indexOf("=");
       if (eq > 0) out[entry.slice(0, eq)] = entry.slice(eq + 1);
@@ -10559,14 +10943,14 @@ function processEnv(pid) {
 }
 function resolveDataDir(rawDataDir, cwd, env3) {
   const pick = rawDataDir ?? env3.DATA_DIR ?? null;
-  if (pick) return path20.isAbsolute(pick) ? path20.normalize(pick) : cwd ? path20.resolve(cwd, pick) : null;
-  return cwd ? path20.resolve(cwd, DEFAULT_DATA_DIR) : null;
+  if (pick) return path21.isAbsolute(pick) ? path21.normalize(pick) : cwd ? path21.resolve(cwd, pick) : null;
+  return cwd ? path21.resolve(cwd, DEFAULT_DATA_DIR) : null;
 }
 function discoverFromProc() {
   const out = [];
   let pids;
   try {
-    pids = fs17.readdirSync("/proc");
+    pids = fs18.readdirSync("/proc");
   } catch {
     return out;
   }
@@ -10576,7 +10960,7 @@ function discoverFromProc() {
     if (pid === process.pid) continue;
     let argv;
     try {
-      argv = fs17.readFileSync(`/proc/${pid}/cmdline`, "utf-8").split("\0").filter(Boolean);
+      argv = fs18.readFileSync(`/proc/${pid}/cmdline`, "utf-8").split("\0").filter(Boolean);
     } catch {
       continue;
     }
@@ -10597,11 +10981,11 @@ function discoverFromPs() {
     const m = /--data-dir(?:=|\s+)(.+?)(?=\s+--|\s*$)/.exec(line);
     if (!m) continue;
     const raw = m[1].trim();
-    if (!raw || !path20.isAbsolute(raw)) continue;
+    if (!raw || !path21.isAbsolute(raw)) continue;
     const host = /--host(?:=|\s+)(\S+)/.exec(line)?.[1] ?? DEFAULT_SERVE_HOST;
     const port = Number(/--port(?:=|\s+)(\d+)/.exec(line)?.[1] ?? DEFAULT_SERVE_PORT);
     out.push({
-      dataDir: path20.normalize(raw),
+      dataDir: path21.normalize(raw),
       host: host === "0.0.0.0" || host === "::" ? DEFAULT_SERVE_HOST : host,
       port: Number.isFinite(port) && port > 0 ? port : DEFAULT_SERVE_PORT
     });
@@ -10704,7 +11088,7 @@ async function linkNode(opts) {
     const status = await enrollViaServer(inst.host, inst.port, adminKey, opts);
     return { mode: "hot", ...status, dataDir: inst.dataDir };
   }
-  const dataDir = path21.resolve(explicitDataDir ?? DEFAULT_DATA_DIR);
+  const dataDir = path22.resolve(explicitDataDir ?? DEFAULT_DATA_DIR);
   const store = new Store(dataDir);
   const nodeId = ensureNodeId(store);
   const cred = await hubEnrollByCode(opts.hubUrl, {
@@ -10786,25 +11170,26 @@ init_esm_shims();
 
 // src/server/runtime.ts
 init_esm_shims();
-import * as fs29 from "fs";
-import * as path36 from "path";
+import * as fs31 from "fs";
+import * as path38 from "path";
 
 // src/server/session.ts
 init_esm_shims();
+import * as path25 from "path";
 import { AsyncLocalStorage } from "async_hooks";
 
 // src/server/mcpConfig.ts
 init_esm_shims();
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path23 from "path";
 function isValidMcpConfig(v) {
   return !!v && typeof v === "object" && typeof v.name === "string" && (v.type === "stdio" || v.type === "http");
 }
 function readConfigFile(file) {
   if (!file) return [];
   try {
-    if (!fs18.existsSync(file)) return [];
-    const raw = JSON.parse(fs18.readFileSync(file, "utf8"));
+    if (!fs19.existsSync(file)) return [];
+    const raw = JSON.parse(fs19.readFileSync(file, "utf8"));
     const list = Array.isArray(raw) ? raw : raw && typeof raw === "object" && Array.isArray(raw.servers) ? raw.servers : [];
     return list.filter(isValidMcpConfig);
   } catch (err) {
@@ -10816,7 +11201,7 @@ function hasServerMcpConfig() {
   if (readConfigFile(process.env.MCP_CONFIG_PATH).length > 0) return true;
   const workspace = process.env.WORKSPACE;
   if (!workspace) return false;
-  return readConfigFile(path22.join(workspace, ".agent", "mcp.json")).length > 0;
+  return readConfigFile(path23.join(workspace, ".agent", "mcp.json")).length > 0;
 }
 function loadServerMcpConfigs(tenant) {
   const fromEnv = readConfigFile(process.env.MCP_CONFIG_PATH);
@@ -10826,7 +11211,7 @@ function loadServerMcpConfigs(tenant) {
   }
   const workspace = tenant.workspaceRoot ?? process.env.WORKSPACE;
   if (workspace)
-    return readConfigFile(path22.join(workspace, ".agent", "mcp.json"));
+    return readConfigFile(path23.join(workspace, ".agent", "mcp.json"));
   return [];
 }
 
@@ -10971,8 +11356,8 @@ function resolveSessionProvider(store, tenant, providerId) {
 
 // src/server/usage.ts
 init_esm_shims();
-import * as fs19 from "fs";
-import * as path23 from "path";
+import * as fs20 from "fs";
+import * as path24 from "path";
 var LEDGER_RETENTION_MONTHS = 12;
 var USAGE_SCHEMA = 1;
 var DEFAULT_PRICING = {
@@ -11053,15 +11438,15 @@ function retainedMonths(now = /* @__PURE__ */ new Date()) {
   return out;
 }
 function atomicWrite(file, content) {
-  fs19.mkdirSync(path23.dirname(file), { recursive: true });
+  fs20.mkdirSync(path24.dirname(file), { recursive: true });
   const tmp = `${file}.tmp`;
-  fs19.writeFileSync(tmp, content, "utf-8");
-  fs19.renameSync(tmp, file);
+  fs20.writeFileSync(tmp, content, "utf-8");
+  fs20.renameSync(tmp, file);
 }
 var UsageLedger = class {
   constructor(root) {
     this.root = root;
-    this.dir = path23.join(root, "usage");
+    this.dir = path24.join(root, "usage");
   }
   root;
   dir;
@@ -11074,18 +11459,18 @@ var UsageLedger = class {
     return this.dir;
   }
   ledgerFile(month) {
-    return path23.join(this.ledgerDir, `ledger-${month}.jsonl`);
+    return path24.join(this.ledgerDir, `ledger-${month}.jsonl`);
   }
   get rollupFile() {
-    return path23.join(this.ledgerDir, "rollup.json");
+    return path24.join(this.ledgerDir, "rollup.json");
   }
   get pricingFile() {
-    return path23.join(this.ledgerDir, "pricing.json");
+    return path24.join(this.ledgerDir, "pricing.json");
   }
   // ===================== 初始化 =====================
   init(now = /* @__PURE__ */ new Date()) {
     if (this.inited) return;
-    fs19.mkdirSync(this.ledgerDir, { recursive: true });
+    fs20.mkdirSync(this.ledgerDir, { recursive: true });
     this.pricing = this.loadPricing();
     this.rollup = this.loadRollup(now);
     this.pruneLedgers(now);
@@ -11093,7 +11478,7 @@ var UsageLedger = class {
   }
   loadPricing() {
     try {
-      const raw = fs19.readFileSync(this.pricingFile, "utf-8");
+      const raw = fs20.readFileSync(this.pricingFile, "utf-8");
       const parsed = JSON.parse(raw);
       const vendors = {};
       for (const v of /* @__PURE__ */ new Set([
@@ -11122,7 +11507,7 @@ var UsageLedger = class {
   }
   loadRollup(now) {
     try {
-      const raw = fs19.readFileSync(this.rollupFile, "utf-8");
+      const raw = fs20.readFileSync(this.rollupFile, "utf-8");
       const parsed = JSON.parse(raw);
       return {
         schema: USAGE_SCHEMA,
@@ -11149,10 +11534,10 @@ var UsageLedger = class {
     const keep = retainedMonths(now);
     let changed = false;
     try {
-      for (const f of fs19.readdirSync(this.ledgerDir)) {
+      for (const f of fs20.readdirSync(this.ledgerDir)) {
         const m = /^ledger-(\d{4}-\d{2})\.jsonl$/.exec(f);
         if (m && !keep.has(m[1])) {
-          fs19.unlinkSync(path23.join(this.ledgerDir, f));
+          fs20.unlinkSync(path24.join(this.ledgerDir, f));
         }
       }
     } catch {
@@ -11229,7 +11614,7 @@ var UsageLedger = class {
     };
     const line = JSON.stringify(rec) + "\n";
     try {
-      fs19.appendFileSync(this.ledgerFile(monthOf(rec.ts)), line);
+      fs20.appendFileSync(this.ledgerFile(monthOf(rec.ts)), line);
     } catch (e) {
       console.error(`[usage] \u5199\u8D26\u672C\u5931\u8D25: ${String(e)}`);
     }
@@ -11401,10 +11786,10 @@ var UsageLedger = class {
     const rows = [];
     for (const month of months) {
       const file = this.ledgerFile(month);
-      if (!fs19.existsSync(file)) continue;
+      if (!fs20.existsSync(file)) continue;
       let content = "";
       try {
-        content = fs19.readFileSync(file, "utf-8");
+        content = fs20.readFileSync(file, "utf-8");
       } catch {
         continue;
       }
@@ -11513,10 +11898,10 @@ var UsageLedger = class {
     const seen = /* @__PURE__ */ new Set();
     for (const month of this.monthsInRange("", "")) {
       const file = this.ledgerFile(month);
-      if (!fs19.existsSync(file)) continue;
+      if (!fs20.existsSync(file)) continue;
       let content = "";
       try {
-        content = fs19.readFileSync(file, "utf-8");
+        content = fs20.readFileSync(file, "utf-8");
       } catch {
         continue;
       }
@@ -12824,7 +13209,10 @@ data: ${JSON.stringify(entry.data)}
       // 上下文窗口：环境变量显式覆盖 > 供应商 /models 提供的真实长度 > 引擎内置表
       contextWindow: parseOptionalPositiveNumber(process.env.CONTEXT_WINDOW) ?? modelContextWindow(eff.modelMeta, activeModel),
       thresholdPct: parseRatio(process.env.COMPACTION_THRESHOLD_PCT),
-      capTokens: parseOptionalPositiveNumber(process.env.COMPACTION_CAP_TOKENS) ?? null
+      softThresholdPct: parseRatio(process.env.COMPACTION_SOFT_THRESHOLD_PCT),
+      capTokens: parseOptionalPositiveNumber(process.env.COMPACTION_CAP_TOKENS) ?? null,
+      // 超预算工具结果按租户/工作区隔离落盘（多租户共用一个状态目录会混内容）
+      toolResultDir: path25.join(workspace, ".agent", "tool-results")
     });
     engine.setApprover(this._makeApprover(rt));
     const mcpConfigs = loadServerMcpConfigs(tenant);
@@ -13005,11 +13393,11 @@ var ApiError = class extends Error {
 // src/server/routes.ts
 init_esm_shims();
 import { createServer } from "http";
-import * as path28 from "path";
+import * as path30 from "path";
 
 // src/server/projects.ts
 init_esm_shims();
-import * as path24 from "path";
+import * as path26 from "path";
 var DEFAULT_MODEL = () => process.env.OPENAI_MODEL || process.env.MODEL || "gpt-4o";
 function toProjectSummary(store, tenant) {
   return {
@@ -13142,9 +13530,9 @@ function createProject(store, input) {
   if (store.loadTenant(id)) {
     throw new ApiError(409, "project_exists", `\u9879\u76EE ${id} \u5DF2\u5B58\u5728`);
   }
-  const workspaceRoot = typeof raw.workspaceRoot === "string" && raw.workspaceRoot.trim() ? path24.resolve(raw.workspaceRoot.trim()) : void 0;
+  const workspaceRoot = typeof raw.workspaceRoot === "string" && raw.workspaceRoot.trim() ? path26.resolve(raw.workspaceRoot.trim()) : void 0;
   const explicitName = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : "";
-  const defaultName = workspaceRoot ? path24.basename(workspaceRoot) : id;
+  const defaultName = workspaceRoot ? path26.basename(workspaceRoot) : id;
   const tenant = {
     id,
     name: explicitName || defaultName,
@@ -13174,7 +13562,7 @@ function buildNodeInfo(store, opts) {
     nodeId: opts.nodeId ?? ensureNodeId2(store),
     platform: process.platform,
     mode: process.env.NODE_MODE ?? "standalone",
-    version: "0.2.5",
+    version: "0.2.7",
     admin: opts.admin,
     projects: opts.projects
   };
@@ -13258,8 +13646,8 @@ function hubProxyEnabled(host) {
   const h = (host ?? "127.0.0.1").trim();
   return h === "127.0.0.1" || h === "localhost" || h === "::1";
 }
-function isHubProxyPath(path42) {
-  return path42.startsWith(HUB_PROXY_PREFIX);
+function isHubProxyPath(path44) {
+  return path44.startsWith(HUB_PROXY_PREFIX);
 }
 function decodeTarget(enc) {
   try {
@@ -13353,34 +13741,34 @@ async function handleHubProxy(req2, res) {
 
 // src/server/fsBrowser.ts
 init_esm_shims();
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as os4 from "os";
-import * as path25 from "path";
+import * as path27 from "path";
 var MAX_ENTRIES = 2e3;
 var DEFAULT_SEARCH_LIMIT = 200;
 var MAX_SEARCH_LIMIT = 1e3;
 function listDirs(input) {
   const base = (input ?? "").trim() || os4.homedir();
-  const target = path25.resolve(base);
+  const target = path27.resolve(base);
   let st;
   try {
-    st = fs20.statSync(target);
+    st = fs21.statSync(target);
   } catch {
     throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728: ${target}`);
   }
   if (!st.isDirectory()) throw new Error(`\u4E0D\u662F\u76EE\u5F55: ${target}`);
   let dirents;
   try {
-    dirents = fs20.readdirSync(target, { withFileTypes: true });
+    dirents = fs21.readdirSync(target, { withFileTypes: true });
   } catch {
     throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55\uFF08\u6743\u9650\u4E0D\u8DB3\uFF1F\uFF09: ${target}`);
   }
   const entries = dirents.map((d) => {
-    const full = path25.join(target, d.name);
+    const full = path27.join(target, d.name);
     let isDir = d.isDirectory();
     if (d.isSymbolicLink()) {
       try {
-        isDir = fs20.statSync(full).isDirectory();
+        isDir = fs21.statSync(full).isDirectory();
       } catch {
       }
     }
@@ -13389,7 +13777,7 @@ function listDirs(input) {
   entries.sort(
     (a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "dir" ? -1 : 1
   );
-  const parentDir = path25.dirname(target);
+  const parentDir = path27.dirname(target);
   return {
     path: target,
     parent: parentDir !== target ? parentDir : null,
@@ -13420,7 +13808,7 @@ var NAME_CACHE_MAX_DIRS = 4;
 var NAME_CACHE_MAX_ENTRIES = 5e4;
 var nameCache = /* @__PURE__ */ new Map();
 function invalidateDirNames(target) {
-  nameCache.delete(path25.resolve(target));
+  nameCache.delete(path27.resolve(target));
 }
 async function loadDirNames(target) {
   const now = Date.now();
@@ -13432,7 +13820,7 @@ async function loadDirNames(target) {
   }
   let dirents;
   try {
-    dirents = await fs20.promises.readdir(target, { withFileTypes: true });
+    dirents = await fs21.promises.readdir(target, { withFileTypes: true });
   } catch {
     throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55\uFF08\u6743\u9650\u4E0D\u8DB3\uFF1F\uFF09: ${target}`);
   }
@@ -13455,11 +13843,11 @@ async function loadDirNames(target) {
   return entries;
 }
 async function toDirEntry(dir, e) {
-  const full = path25.join(dir, e.name);
+  const full = path27.join(dir, e.name);
   let isDir = e.isDir;
   if (e.isLink) {
     try {
-      isDir = (await fs20.promises.stat(full)).isDirectory();
+      isDir = (await fs21.promises.stat(full)).isDirectory();
     } catch {
     }
   }
@@ -13467,10 +13855,10 @@ async function toDirEntry(dir, e) {
 }
 async function searchDirs(input, query, limit) {
   const base = (input ?? "").trim() || os4.homedir();
-  const target = path25.resolve(base);
+  const target = path27.resolve(base);
   let st;
   try {
-    st = await fs20.promises.stat(target);
+    st = await fs21.promises.stat(target);
   } catch {
     throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728: ${target}`);
   }
@@ -13500,7 +13888,7 @@ async function searchDirs(input, query, limit) {
   );
   const hit = scored.slice(0, max);
   const entries = await Promise.all(hit.map(({ entry }) => toDirEntry(target, entry)));
-  const parentDir = path25.dirname(target);
+  const parentDir = path27.dirname(target);
   return {
     path: target,
     parent: parentDir !== target ? parentDir : null,
@@ -13511,52 +13899,52 @@ async function searchDirs(input, query, limit) {
   };
 }
 function makeDirIn(parentInput, name) {
-  const parent = path25.resolve((parentInput ?? "").trim() || os4.homedir());
+  const parent = path27.resolve((parentInput ?? "").trim() || os4.homedir());
   const clean = (name ?? "").trim();
   if (!clean) throw new Error("\u76EE\u5F55\u540D\u4E0D\u80FD\u4E3A\u7A7A");
   if (clean === "." || clean === "..") throw new Error("\u76EE\u5F55\u540D\u975E\u6CD5");
-  const target = path25.resolve(parent, clean);
-  const rel = path25.relative(parent, target);
-  if (!rel || rel.startsWith("..") || path25.isAbsolute(rel)) {
+  const target = path27.resolve(parent, clean);
+  const rel = path27.relative(parent, target);
+  if (!rel || rel.startsWith("..") || path27.isAbsolute(rel)) {
     throw new Error("\u76EE\u5F55\u540D\u4E0D\u80FD\u8D8A\u51FA\u5F53\u524D\u76EE\u5F55");
   }
   let st = null;
   try {
-    st = fs20.statSync(target);
+    st = fs21.statSync(target);
   } catch {
     st = null;
   }
   if (st && !st.isDirectory()) throw new Error(`\u5DF2\u5B58\u5728\u540C\u540D\u6587\u4EF6: ${target}`);
   try {
-    fs20.mkdirSync(target, { recursive: true });
+    fs21.mkdirSync(target, { recursive: true });
   } catch (e) {
     throw new Error(`\u521B\u5EFA\u76EE\u5F55\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
   }
   invalidateDirNames(parent);
-  return { name: path25.basename(target), path: target, type: "dir" };
+  return { name: path27.basename(target), path: target, type: "dir" };
 }
 
 // src/server/projectFiles.ts
 init_esm_shims();
-import * as fs21 from "fs";
-import * as path26 from "path";
+import * as fs22 from "fs";
+import * as path28 from "path";
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 var MAX_DOWNLOAD_BYTES = 16 * 1024 * 1024;
 var MAX_ENTRIES2 = 2e3;
 function toPosix(p) {
-  return p.split(path26.sep).join("/");
+  return p.split(path28.sep).join("/");
 }
 function projectRoot(workspaceRoot) {
   const r = (workspaceRoot ?? "").trim();
   if (!r) {
     throw new Error("\u9879\u76EE\u672A\u8BBE\u7F6E\u5DE5\u4F5C\u533A\u76EE\u5F55\uFF08workspaceRoot\uFF09\uFF0C\u65E0\u6CD5\u6D4F\u89C8\u6587\u4EF6");
   }
-  const abs = path26.resolve(r);
-  if (!fs21.existsSync(abs)) {
+  const abs = path28.resolve(r);
+  if (!fs22.existsSync(abs)) {
     throw new Error(`\u5DE5\u4F5C\u533A\u76EE\u5F55\u4E0D\u5B58\u5728: ${abs}`);
   }
   try {
-    return fs21.realpathSync(abs);
+    return fs22.realpathSync(abs);
   } catch {
     return abs;
   }
@@ -13574,37 +13962,37 @@ function listProjectFiles(workspaceRoot, relPath) {
   const dir = resolveWithin(base, relPath ?? "");
   let st;
   try {
-    st = fs21.statSync(dir);
+    st = fs22.statSync(dir);
   } catch {
-    throw new Error(`\u76EE\u5F55\u4E0D\u5B58\u5728: ${toPosix(path26.relative(base, dir)) || "/"}`);
+    throw new Error(`\u76EE\u5F55\u4E0D\u5B58\u5728: ${toPosix(path28.relative(base, dir)) || "/"}`);
   }
   if (!st.isDirectory()) throw new Error("\u76EE\u6807\u4E0D\u662F\u76EE\u5F55");
   let dirents;
   try {
-    dirents = fs21.readdirSync(dir, { withFileTypes: true });
+    dirents = fs22.readdirSync(dir, { withFileTypes: true });
   } catch {
     throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55\uFF08\u6743\u9650\u4E0D\u8DB3\uFF1F\uFF09");
   }
   const entries = dirents.map((d) => {
-    const full = path26.join(dir, d.name);
+    const full = path28.join(dir, d.name);
     let isDir = d.isDirectory();
     if (d.isSymbolicLink()) {
       try {
-        isDir = fs21.statSync(full).isDirectory();
+        isDir = fs22.statSync(full).isDirectory();
       } catch {
       }
     }
     let size = 0;
     let mtime = "";
     try {
-      const s = fs21.statSync(full);
+      const s = fs22.statSync(full);
       size = s.size;
       mtime = s.mtime.toISOString();
     } catch {
     }
     return {
       name: d.name,
-      path: toPosix(path26.relative(base, full)),
+      path: toPosix(path28.relative(base, full)),
       type: isDir ? "dir" : "file",
       size,
       mtime
@@ -13613,12 +14001,12 @@ function listProjectFiles(workspaceRoot, relPath) {
   entries.sort(
     (a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "dir" ? -1 : 1
   );
-  const relDir = toPosix(path26.relative(base, dir));
-  const parentAbs = path26.dirname(dir);
+  const relDir = toPosix(path28.relative(base, dir));
+  const parentAbs = path28.dirname(dir);
   return {
     root: base,
     path: relDir,
-    parent: isWithinRoot(base, parentAbs) ? toPosix(path26.relative(base, parentAbs)) : null,
+    parent: isWithinRoot(base, parentAbs) ? toPosix(path28.relative(base, parentAbs)) : null,
     entries: entries.slice(0, MAX_ENTRIES2)
   };
 }
@@ -13627,17 +14015,17 @@ function readProjectFile(workspaceRoot, relPath) {
   const file = resolveWithin(base, relPath ?? "");
   let st;
   try {
-    st = fs21.statSync(file);
+    st = fs22.statSync(file);
   } catch {
     throw new Error("\u6587\u4EF6\u4E0D\u5B58\u5728");
   }
   if (!st.isFile()) throw new Error("\u76EE\u6807\u4E0D\u662F\u6587\u4EF6");
-  const buf = fs21.readFileSync(file);
+  const buf = fs22.readFileSync(file);
   const binary = isBinary(buf);
   const truncated = buf.length > MAX_FILE_BYTES;
   const slice = truncated ? buf.subarray(0, MAX_FILE_BYTES) : buf;
   return {
-    path: toPosix(path26.relative(base, file)),
+    path: toPosix(path28.relative(base, file)),
     size: st.size,
     binary,
     truncated,
@@ -13649,7 +14037,7 @@ function downloadProjectFile(workspaceRoot, relPath) {
   const file = resolveWithin(base, relPath ?? "");
   let st;
   try {
-    st = fs21.statSync(file);
+    st = fs22.statSync(file);
   } catch {
     throw new Error("\u6587\u4EF6\u4E0D\u5B58\u5728");
   }
@@ -13657,10 +14045,10 @@ function downloadProjectFile(workspaceRoot, relPath) {
   if (st.size > MAX_DOWNLOAD_BYTES) {
     throw new Error(`\u6587\u4EF6\u8D85\u8FC7\u4E0B\u8F7D\u4E0A\u9650\uFF08${MAX_DOWNLOAD_BYTES / (1024 * 1024)}MB\uFF09`);
   }
-  const buf = fs21.readFileSync(file);
+  const buf = fs22.readFileSync(file);
   return {
-    path: toPosix(path26.relative(base, file)),
-    name: path26.basename(file),
+    path: toPosix(path28.relative(base, file)),
+    name: path28.basename(file),
     size: buf.length,
     base64: buf.toString("base64")
   };
@@ -13682,12 +14070,12 @@ function writeProjectFile(workspaceRoot, relPath, content) {
     throw new Error("\u5185\u5BB9\u8D85\u8FC7 2MB \u4E0A\u9650\uFF0C\u65E0\u6CD5\u4FDD\u5B58");
   }
   try {
-    fs21.mkdirSync(path26.dirname(file), { recursive: true });
-    fs21.writeFileSync(file, buf);
+    fs22.mkdirSync(path28.dirname(file), { recursive: true });
+    fs22.writeFileSync(file, buf);
   } catch (e) {
     throw new Error(`\u5199\u5165\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
   }
-  return { path: toPosix(path26.relative(base, file)), size: buf.length };
+  return { path: toPosix(path28.relative(base, file)), size: buf.length };
 }
 function createProjectDir(workspaceRoot, relPath) {
   const base = projectRoot(workspaceRoot);
@@ -13695,26 +14083,26 @@ function createProjectDir(workspaceRoot, relPath) {
   if (!rel) throw new Error("\u76EE\u5F55\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
   const dir = resolveWithin(base, rel);
   try {
-    fs21.mkdirSync(dir, { recursive: true });
+    fs22.mkdirSync(dir, { recursive: true });
   } catch (e) {
     throw new Error(`\u521B\u5EFA\u76EE\u5F55\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
   }
-  return { path: toPosix(path26.relative(base, dir)) };
+  return { path: toPosix(path28.relative(base, dir)) };
 }
 function createProjectFile(workspaceRoot, relPath, content = "") {
   const base = projectRoot(workspaceRoot);
   const rel = (relPath ?? "").trim();
   if (!rel) throw new Error("\u6587\u4EF6\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
   const file = resolveWithin(base, rel);
-  if (fs21.existsSync(file)) throw new Error("\u6587\u4EF6\u5DF2\u5B58\u5728");
+  if (fs22.existsSync(file)) throw new Error("\u6587\u4EF6\u5DF2\u5B58\u5728");
   const buf = Buffer.from(String(content ?? ""), "utf-8");
   try {
-    fs21.mkdirSync(path26.dirname(file), { recursive: true });
-    fs21.writeFileSync(file, buf);
+    fs22.mkdirSync(path28.dirname(file), { recursive: true });
+    fs22.writeFileSync(file, buf);
   } catch (e) {
     throw new Error(`\u521B\u5EFA\u6587\u4EF6\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}`);
   }
-  return { path: toPosix(path26.relative(base, file)), size: buf.length };
+  return { path: toPosix(path28.relative(base, file)), size: buf.length };
 }
 function searchProjectFiles(workspaceRoot, query) {
   const base = projectRoot(workspaceRoot);
@@ -13737,7 +14125,7 @@ function searchProjectFiles(workspaceRoot, query) {
     if (out.length >= LIMIT) return;
     let dirents;
     try {
-      dirents = fs21.readdirSync(dir, { withFileTypes: true });
+      dirents = fs22.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -13748,7 +14136,7 @@ function searchProjectFiles(workspaceRoot, query) {
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          isDir = fs21.statSync(path26.join(dir, d.name)).isDirectory();
+          isDir = fs22.statSync(path28.join(dir, d.name)).isDirectory();
         } catch {
           isDir = false;
         }
@@ -13756,7 +14144,7 @@ function searchProjectFiles(workspaceRoot, query) {
       if (d.name.toLowerCase().includes(q)) {
         out.push({ path: rel, type: isDir ? "dir" : "file" });
       }
-      if (isDir) walk(path26.join(dir, d.name), rel);
+      if (isDir) walk(path28.join(dir, d.name), rel);
     }
   };
   walk(base, "");
@@ -13766,7 +14154,7 @@ function searchProjectFiles(workspaceRoot, query) {
 // src/server/projectOps.ts
 init_esm_shims();
 import * as os5 from "os";
-import * as path27 from "path";
+import * as path29 from "path";
 var MAX_STDOUT2 = 2e4;
 var MAX_STDERR2 = 1e4;
 var MAX_BUFFER3 = 1024 * 1024 * 5;
@@ -13780,7 +14168,7 @@ function resolveInvocation2(spec, prepared) {
 }
 function workRoot(workspaceRoot) {
   const r = (workspaceRoot ?? "").trim();
-  return r ? path27.resolve(r) : os5.homedir();
+  return r ? path29.resolve(r) : os5.homedir();
 }
 async function runProjectCommand(workspaceRoot, command, timeoutSeconds) {
   const cmd = String(command ?? "");
@@ -13900,6 +14288,92 @@ async function projectGitPush(workspaceRoot, repoPath) {
   });
 }
 
+// src/server/gitCommitMessage.ts
+init_esm_shims();
+import * as crypto5 from "crypto";
+var MAX_DIFF_CHARS = 12e3;
+var MAX_MESSAGE_CHARS = 200;
+var GEN_COMMIT_MESSAGE_INSTRUCTIONS = `\u4F60\u662F Git \u63D0\u4EA4\u8BF4\u660E\u751F\u6210\u52A9\u624B\u3002\u6839\u636E\u7ED9\u5B9A\u7684\u4EE3\u7801\u5DEE\u5F02\uFF0C\u751F\u6210\u4E00\u6761\u51C6\u786E\u3001\u7B80\u6D01\u7684\u63D0\u4EA4\u8BF4\u660E\u3002
+
+\u8981\u6C42\uFF1A
+1. \u4F7F\u7528 Conventional Commits \u98CE\u683C\uFF1Atype(scope): \u63CF\u8FF0\uFF08type \u5982 feat / fix / refactor / docs / test / chore / perf / build / ci\uFF09\uFF1B
+2. scope \u53D6\u53D8\u66F4\u6700\u96C6\u4E2D\u7684\u6A21\u5757\u6216\u76EE\u5F55\uFF0C\u65E0\u6CD5\u5224\u65AD\u65F6\u7701\u7565\uFF1B
+3. \u63CF\u8FF0\u4F7F\u7528\u4E2D\u6587\uFF0C\u6982\u62EC\u672C\u6B21\u53D8\u66F4\u7684\u76EE\u7684\u6216\u6548\u679C\uFF0C\u4E0D\u8981\u9010\u6587\u4EF6\u7F57\u5217\uFF1B
+4. \u53EA\u8F93\u51FA\u63D0\u4EA4\u8BF4\u660E\u672C\u8EAB\uFF0C\u4E0D\u8981\u5F15\u53F7\u3001\u4EE3\u7801\u5757\u3001\u6362\u884C\u6216\u4EFB\u4F55\u89E3\u91CA\uFF1B
+5. \u4E0D\u8D85\u8FC7 72 \u4E2A\u5B57\u7B26\u3002`;
+function genReqId2() {
+  return crypto5.randomBytes(6).toString("base64url");
+}
+function cleanCommitMessage(raw) {
+  let text = String(raw ?? "").trim();
+  if (!text) return "";
+  text = text.replace(/^```[^\n]*\n?/, "").replace(/\n?```$/, "").trim();
+  const first = text.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "";
+  return first.replace(/^(commit message|提交说明|提交信息|message)\s*[:：]\s*/i, "").replace(/^["'“”`]+|["'“”`]+$/g, "").replace(/\s+/g, " ").trim().slice(0, MAX_MESSAGE_CHARS);
+}
+async function collectDiff(workspaceRoot, repo) {
+  const staged = await projectGitDiff(workspaceRoot, void 0, true, repo);
+  if (!staged.error && String(staged.diff ?? "").trim()) {
+    return { text: String(staged.diff), source: "staged" };
+  }
+  const worktree = await projectGitDiff(workspaceRoot, void 0, false, repo);
+  if (!worktree.error && String(worktree.diff ?? "").trim()) {
+    return { text: String(worktree.diff), source: "worktree" };
+  }
+  const status = await projectGitStatus(workspaceRoot, void 0, repo);
+  if (status.error) throw new ApiError(400, "git_error", String(status.error));
+  const entries = status.entries ?? [];
+  if (entries.length === 0) throw new ApiError(400, "no_changes", "\u6CA1\u6709\u53EF\u63D0\u4EA4\u7684\u53D8\u66F4");
+  return {
+    text: entries.map((e) => `${e.status ?? ""} ${e.file ?? ""}`.trim()).join("\n"),
+    source: "worktree"
+  };
+}
+async function generateGitCommitMessage(opts) {
+  const { store, tenant } = opts;
+  const { text, source } = await collectDiff(opts.workspaceRoot, opts.repo);
+  const truncated = text.length > MAX_DIFF_CHARS;
+  const clipped = text.slice(0, MAX_DIFF_CHARS);
+  const eff = resolveSessionProvider(store, tenant);
+  const apiKey = eff.apiKey || process.env.OPENAI_API_KEY || "";
+  const model = (eff.model || tenant.model || process.env.OPENAI_MODEL || process.env.MODEL || "").trim();
+  if (!apiKey) {
+    throw new ApiError(
+      400,
+      "llm_not_configured",
+      "\u5F53\u524D\u8282\u70B9\u672A\u914D\u7F6E\u53EF\u7528\u7684 LLM\uFF0C\u8BF7\u5148\u5728\u8282\u70B9\u914D\u7F6E\u4E2D\u6DFB\u52A0\u6A21\u578B\u4E0E API Key"
+    );
+  }
+  if (!model) {
+    throw new ApiError(
+      400,
+      "llm_not_configured",
+      "\u5F53\u524D\u8282\u70B9\u672A\u914D\u7F6E\u6A21\u578B\uFF0C\u8BF7\u5148\u5728\u8282\u70B9\u914D\u7F6E\u4E2D\u9009\u62E9\u6A21\u578B"
+    );
+  }
+  const provider = new OpenAIProvider({ apiKey, baseURL: eff.baseURL });
+  const raw = await provider.chat(
+    model,
+    [
+      { role: "system", content: GEN_COMMIT_MESSAGE_INSTRUCTIONS },
+      {
+        role: "user",
+        content: `\u4EE5\u4E0B\u662F\u672C\u6B21\u5F85\u63D0\u4EA4\u7684\u53D8\u66F4${source === "staged" ? "\uFF08\u5DF2\u6682\u5B58\uFF09" : "\uFF08\u5DE5\u4F5C\u533A\uFF0C\u5C1A\u672A\u6682\u5B58\uFF09"}${truncated ? "\uFF0C\u5185\u5BB9\u8FC7\u957F\u5DF2\u622A\u65AD" : ""}\uFF1A
+
+${clipped}`
+      }
+    ],
+    {},
+    { reqId: `llm_commit_${Date.now()}_${genReqId2()}`, logTime: (/* @__PURE__ */ new Date()).toISOString() },
+    // 不设 maxTokens：推理模型的思考会占用输出配额，过小会导致 content 为空；
+    // 提示词已约束只输出一行短说明。
+    {}
+  );
+  const message = cleanCommitMessage(raw ?? "");
+  if (!message) throw new ApiError(502, "llm_empty", "AI \u672A\u8FD4\u56DE\u6709\u6548\u7684\u63D0\u4EA4\u8BF4\u660E\uFF0C\u8BF7\u91CD\u8BD5");
+  return message;
+}
+
 // src/server/toolsCatalog.ts
 init_esm_shims();
 function buildToolCatalog(workspace) {
@@ -14005,11 +14479,11 @@ function projectStats(manager, tenantId) {
 
 // src/server/nodeHost.ts
 init_esm_shims();
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as os6 from "os";
 function diskInfo(pathStr) {
   try {
-    const st = fs22.statfsSync(pathStr);
+    const st = fs23.statfsSync(pathStr);
     return {
       path: pathStr,
       total: Number(st.blocks) * Number(st.bsize),
@@ -14081,7 +14555,7 @@ function buildNodeHost(store, manager, diskPath) {
     arch: process.arch,
     release: os6.release(),
     uptimeSec: Math.round(os6.uptime()),
-    version: "0.2.5",
+    version: "0.2.7",
     mode: process.env.NODE_MODE ?? "standalone",
     cpu: {
       count: cpus2.length,
@@ -14656,7 +15130,7 @@ function createApp(store, manager, opts = {}) {
         applyProvidersPatch(tenant, raw);
         if (typeof raw.workspaceRoot === "string") {
           const ws = raw.workspaceRoot.trim();
-          if (ws) tenant.workspaceRoot = path28.resolve(ws);
+          if (ws) tenant.workspaceRoot = path30.resolve(ws);
           else delete tenant.workspaceRoot;
         }
         if (typeof raw.name === "string" && raw.name.trim()) {
@@ -15065,6 +15539,25 @@ function createApp(store, manager, opts = {}) {
         }
       }
     },
+    {
+      method: "POST",
+      pattern: ["git", "commit-message"],
+      fn: async (_req, res, { tenant, body }) => {
+        const raw = body ?? {};
+        try {
+          const message = await generateGitCommitMessage({
+            store,
+            tenant,
+            workspaceRoot: tenant.workspaceRoot ?? null,
+            repo: String(raw.repo ?? "") || void 0
+          });
+          ok(res, { message });
+        } catch (e) {
+          if (e instanceof ApiError) throw e;
+          throw new ApiError(400, "bad_request", e instanceof Error ? e.message : String(e));
+        }
+      }
+    },
     {
       method: "POST",
       pattern: ["git", "checkout"],
@@ -15588,10 +16081,10 @@ function createApp(store, manager, opts = {}) {
   function handle(req2, res) {
     const startedAt2 = Date.now();
     const url = new URL(req2.url ?? "/", "http://localhost");
-    const path42 = url.pathname;
+    const path44 = url.pathname;
     const method = req2.method ?? "GET";
     console.log(
-      `[api] ${(/* @__PURE__ */ new Date()).toISOString()} \u2192 ${method} ${path42}${url.search}`
+      `[api] ${(/* @__PURE__ */ new Date()).toISOString()} \u2192 ${method} ${path44}${url.search}`
     );
     let tenantId = null;
     let logged = false;
@@ -15599,7 +16092,7 @@ function createApp(store, manager, opts = {}) {
       if (logged) return;
       logged = true;
       console.log(
-        `[api] ${(/* @__PURE__ */ new Date()).toISOString()} \u2190 ${method} ${path42} ${extra} (${Date.now() - startedAt2}ms) tenant=${tenantId ?? "-"}`
+        `[api] ${(/* @__PURE__ */ new Date()).toISOString()} \u2190 ${method} ${path44} ${extra} (${Date.now() - startedAt2}ms) tenant=${tenantId ?? "-"}`
       );
     };
     res.on("finish", () => logDone(`HTTP ${res.statusCode}`));
@@ -15610,16 +16103,16 @@ function createApp(store, manager, opts = {}) {
       res.end();
       return;
     }
-    if (req2.method === "GET" && path42 === "/healthz") {
+    if (req2.method === "GET" && path44 === "/healthz") {
       json(res, 200, {
         status: "ok",
         // 版本让运维/探针能确认线上跑的是哪个构建（更新与回滚据此判断）
-        version: "0.2.5",
+        version: "0.2.7",
         features: { mcp: hasServerMcpConfig() }
       });
       return;
     }
-    if (hubProxyEnabled(opts.host) && isHubProxyPath(path42)) {
+    if (hubProxyEnabled(opts.host) && isHubProxyPath(path44)) {
       void handleHubProxy(req2, res).catch(() => {
         if (!res.headersSent) {
           res.writeHead(502, { "Content-Type": "application/json; charset=utf-8" });
@@ -15630,11 +16123,11 @@ function createApp(store, manager, opts = {}) {
       });
       return;
     }
-    if (!path42.startsWith(API_PREFIX)) {
+    if (!path44.startsWith(API_PREFIX)) {
       json(res, 404, { error: { code: "not_found", message: "\u672A\u77E5\u8DEF\u5F84" } });
       return;
     }
-    const segs = path42.slice(API_PREFIX.length).split("/").filter(Boolean);
+    const segs = path44.slice(API_PREFIX.length).split("/").filter(Boolean);
     const apiKey = extractApiKey(req2);
     if (!apiKey) {
       json(res, 401, {
@@ -15699,7 +16192,7 @@ function createApp(store, manager, opts = {}) {
     ).catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       console.log(
-        `[api] ${(/* @__PURE__ */ new Date()).toISOString()} ! ${method} ${path42} ERROR: ${msg}`
+        `[api] ${(/* @__PURE__ */ new Date()).toISOString()} ! ${method} ${path44} ERROR: ${msg}`
       );
       error(res, err);
     });
@@ -16214,6 +16707,17 @@ async function dispatchFleetCommand(deps, env3) {
           )
         );
       }
+      case "git_commit_message": {
+        const t = project();
+        return ok2({
+          message: await generateGitCommitMessage({
+            store,
+            tenant: t,
+            workspaceRoot: t.workspaceRoot ?? null,
+            repo: gitRepo(payload.repo)
+          })
+        });
+      }
       case "git_checkout": {
         const t = project();
         return ok2(
@@ -16854,6 +17358,18 @@ var READONLY_CMD_TYPES = /* @__PURE__ */ new Set([
   "git_show"
 ]);
 var CMD_CACHE_TTL_MS = 1500;
+var STATE_CHANGING_EVENTS = /* @__PURE__ */ new Set([
+  "turn_start",
+  "turn_end",
+  "permission_required",
+  "ask_user_question",
+  "plan_proposed",
+  "directory_requested",
+  "error",
+  "interrupted",
+  "queue_steering",
+  "session_named"
+]);
 var READONLY_CONCURRENCY = 4;
 var BATCH_MAX_SUBS = 64;
 var BATCH_SUB_TIMEOUT_MS = 7e3;
@@ -17089,6 +17605,20 @@ var FleetNodeBridge = class {
     this.writeEpoch += 1;
     this.cmdResultCache.clear();
   }
+  /**
+   * 会话快照缓存失效（事件/通知驱动的状态变化）。
+   *
+   * 与写操作不同，这些变化只影响会话相关查询；文件树 / Git 等重查询的缓存
+   * 保持有效，避免多会话并行运行时把整个只读缓存反复清空。
+   */
+  _invalidateSessionCache() {
+    this.writeEpoch += 1;
+    for (const key of [...this.cmdResultCache.keys()]) {
+      if (/^(get_state|get_events|list_sessions|get_session_states)\|/.test(key)) {
+        this.cmdResultCache.delete(key);
+      }
+    }
+  }
   close() {
     this.closing = true;
     if (this.usageTimer) {
@@ -17117,6 +17647,7 @@ var FleetNodeBridge = class {
   }
   /** 通知广播（SessionManager 注入的 notify 回调） */
   notify(tenantId, ev) {
+    this._invalidateSessionCache();
     const payload = ev.kind === "approval_request" ? {
       ...ev,
       projectId: tenantId,
@@ -17129,6 +17660,7 @@ var FleetNodeBridge = class {
   }
   /** 事件桥接（SessionManager 注入的 onEvent 回调）；发布按窗口批量合并 */
   onEvent(tenantId, sessionId, entry) {
+    if (STATE_CHANGING_EVENTS.has(entry.type)) this._invalidateSessionCache();
     if (entry.type === "turn_end") this.stats.turns += 1;
     else if (entry.type === "tool_finished") this.stats.toolCalls += 1;
     else if (entry.type === "error") this.stats.errors += 1;
@@ -17213,7 +17745,7 @@ var FleetNodeBridge = class {
       label: this.opts.deps.store.loadNodeLabel() ?? void 0,
       platform: process.platform,
       mode: process.env.NODE_MODE ?? "standalone",
-      version: "0.2.5",
+      version: "0.2.7",
       ip: primaryIp()
     };
   }
@@ -17247,7 +17779,10 @@ var FleetNodeBridge = class {
             sessionId: s.sessionId,
             name: s.name ?? null,
             status: s.status,
-            lastUserMessage: lastUserMessage(s)
+            lastUserMessage: lastUserMessage(s),
+            // 控制面的聚合邮件靠它判断「这台机器最近有没有在干活」；
+            // 状态跃迁可能被 info 节流跳过，完成时间不会。
+            lastCompletedAt: s.lastCompletedAt ?? null
           });
         }
       } catch {
@@ -17265,7 +17800,7 @@ var FleetNodeBridge = class {
         label: this.opts.deps.store.loadNodeLabel() ?? void 0,
         platform: process.platform,
         mode: process.env.NODE_MODE ?? "standalone",
-        version: "0.2.5",
+        version: "0.2.7",
         ip: primaryIp(),
         projects,
         totals,
@@ -18034,8 +18569,8 @@ init_esm_shims();
 
 // src/server/qq/bindings.ts
 init_esm_shims();
-import * as fs23 from "fs";
-import * as path29 from "path";
+import * as fs24 from "fs";
+import * as path31 from "path";
 function conversationKey(target) {
   switch (target.kind) {
     case "c2c":
@@ -18074,12 +18609,12 @@ var QqBindingsStore = class _QqBindingsStore {
   cache = null;
   /** 基于 DATA_DIR 构造 */
   static in(dataDir) {
-    return new _QqBindingsStore(path29.join(dataDir, "qq", "bindings.json"));
+    return new _QqBindingsStore(path31.join(dataDir, "qq", "bindings.json"));
   }
   load() {
     if (this.cache) return this.cache;
     try {
-      const raw = JSON.parse(fs23.readFileSync(this.file, "utf-8"));
+      const raw = JSON.parse(fs24.readFileSync(this.file, "utf-8"));
       this.cache = {
         conversations: raw.conversations ?? {}
       };
@@ -18111,8 +18646,8 @@ var QqBindingsStore = class _QqBindingsStore {
     return null;
   }
   persist() {
-    fs23.mkdirSync(path29.dirname(this.file), { recursive: true });
-    fs23.writeFileSync(this.file, JSON.stringify(this.cache, null, 2), "utf-8");
+    fs24.mkdirSync(path31.dirname(this.file), { recursive: true });
+    fs24.writeFileSync(this.file, JSON.stringify(this.cache, null, 2), "utf-8");
   }
 };
 
@@ -18524,8 +19059,8 @@ ${lines.join("\n")}`, msgId);
 
 // src/server/qq/QqManager.ts
 init_esm_shims();
-import * as fs24 from "fs";
-import * as path30 from "path";
+import * as fs25 from "fs";
+import * as path32 from "path";
 var QqManager = class {
   constructor(opts) {
     this.opts = opts;
@@ -18534,7 +19069,7 @@ var QqManager = class {
   adapter = null;
   config = null;
   get configFile() {
-    return path30.join(this.opts.dataDir, "qq", "config.json");
+    return path32.join(this.opts.dataDir, "qq", "config.json");
   }
   /** 启动：读配置（env 优先，其次文件），有则建连接 */
   start() {
@@ -18572,7 +19107,7 @@ var QqManager = class {
   /** 清空配置：删除文件 + 断开 */
   clearConfig() {
     try {
-      fs24.rmSync(this.configFile, { force: true });
+      fs25.rmSync(this.configFile, { force: true });
     } catch {
     }
     this.stop();
@@ -18614,7 +19149,7 @@ var QqManager = class {
   }
   _readConfigFile() {
     try {
-      const raw = JSON.parse(fs24.readFileSync(this.configFile, "utf-8"));
+      const raw = JSON.parse(fs25.readFileSync(this.configFile, "utf-8"));
       if (raw.appId && raw.appSecret) {
         return {
           appId: raw.appId,
@@ -18627,18 +19162,18 @@ var QqManager = class {
     return null;
   }
   _persistConfig(cfg) {
-    fs24.mkdirSync(path30.dirname(this.configFile), { recursive: true });
-    fs24.writeFileSync(this.configFile, JSON.stringify(cfg, null, 2), "utf-8");
+    fs25.mkdirSync(path32.dirname(this.configFile), { recursive: true });
+    fs25.writeFileSync(this.configFile, JSON.stringify(cfg, null, 2), "utf-8");
   }
 };
 
 // src/server/qq/pairingCodes.ts
 init_esm_shims();
-import * as crypto5 from "crypto";
+import * as crypto6 from "crypto";
 var PAIRING_CODE_TTL_MS = 5 * 60 * 1e3;
 function randomCode(len = 8) {
   const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-  const bytes = crypto5.randomBytes(len);
+  const bytes = crypto6.randomBytes(len);
   let out = "";
   for (let i = 0; i < len; i++) {
     out += alphabet[bytes[i] % alphabet.length];
@@ -18676,17 +19211,17 @@ var PairingCodeStore = class {
 
 // src/update/controller.ts
 init_esm_shims();
-import * as fs28 from "fs";
-import * as path35 from "path";
+import * as fs30 from "fs";
+import * as path37 from "path";
 
 // src/update/downloader.ts
 init_esm_shims();
 import { createHash as createHash3 } from "crypto";
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import { Readable as Readable2 } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 import { spawnSync as spawnSync3 } from "child_process";
-import * as path31 from "path";
+import * as path33 from "path";
 
 // src/update/manifest.ts
 init_esm_shims();
@@ -18861,8 +19396,8 @@ async function fetchManifest(url, publicKey, opts = {}) {
 async function downloadBinary(bin, destPath, log = () => {
 }) {
   const partPath = `${destPath}.part`;
-  fs25.mkdirSync(path31.dirname(destPath), { recursive: true });
-  fs25.rmSync(partPath, { force: true });
+  fs26.mkdirSync(path33.dirname(destPath), { recursive: true });
+  fs26.rmSync(partPath, { force: true });
   let res;
   try {
     res = await fetch(bin.url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS2) });
@@ -18887,25 +19422,25 @@ async function downloadBinary(bin, destPath, log = () => {
           yield chunk;
         }
       },
-      fs25.createWriteStream(partPath, { mode: 493 })
+      fs26.createWriteStream(partPath, { mode: 493 })
     );
   } catch (err) {
-    fs25.rmSync(partPath, { force: true });
+    fs26.rmSync(partPath, { force: true });
     return { error: `\u4E0B\u8F7D\u4E2D\u65AD\uFF1A${err.message}` };
   }
   const actual = hash.digest("hex");
   if (actual !== bin.sha256) {
-    fs25.rmSync(partPath, { force: true });
+    fs26.rmSync(partPath, { force: true });
     return { error: `SHA-256 \u4E0D\u5339\u914D\uFF08\u671F\u671B ${bin.sha256.slice(0, 12)}\u2026\uFF0C\u5B9E\u9645 ${actual.slice(0, 12)}\u2026\uFF09` };
   }
   if (expected && bytes !== expected) {
-    fs25.rmSync(partPath, { force: true });
+    fs26.rmSync(partPath, { force: true });
     return { error: `\u4EA7\u7269\u5927\u5C0F\u4E0D\u5339\u914D\uFF08\u671F\u671B ${expected}\uFF0C\u5B9E\u9645 ${bytes}\uFF09` };
   }
-  fs25.rmSync(destPath, { force: true });
-  fs25.renameSync(partPath, destPath);
-  fs25.chmodSync(destPath, 493);
-  log(`\u5DF2\u4E0B\u8F7D ${path31.basename(destPath)}\uFF08${Math.round(bytes / 1024 / 1024)}MB\uFF0C\u6821\u9A8C\u901A\u8FC7\uFF09`);
+  fs26.rmSync(destPath, { force: true });
+  fs26.renameSync(partPath, destPath);
+  fs26.chmodSync(destPath, 493);
+  log(`\u5DF2\u4E0B\u8F7D ${path33.basename(destPath)}\uFF08${Math.round(bytes / 1024 / 1024)}MB\uFF0C\u6821\u9A8C\u901A\u8FC7\uFF09`);
   return { bytes };
 }
 function selfCheck(binPath, expectedVersion) {
@@ -18929,10 +19464,11 @@ function selfCheck(binPath, expectedVersion) {
 
 // src/update/platform.ts
 init_esm_shims();
-import * as path32 from "path";
+import * as fs27 from "fs";
+import * as path34 from "path";
 import { createRequire as createRequire3 } from "module";
 function currentVersion() {
-  const injected = "0.2.5"?.trim();
+  const injected = "0.2.7"?.trim();
   if (injected) return injected;
   try {
     const req2 = createRequire3(import.meta.url);
@@ -18944,12 +19480,36 @@ function currentVersion() {
 }
 function isSeaRuntime() {
   if (process.env.ZQAGENT_SEA === "1") return true;
-  const base = path32.basename(process.execPath).toLowerCase().replace(/\.exe$/, "");
+  const base = path34.basename(process.execPath).toLowerCase().replace(/\.exe$/, "");
   return base !== "node" && base !== "nodejs";
 }
+var DEFAULT_SERVICE_NAME = "zqagent";
+function serviceManagerFromCgroup(cgroup, serviceName = DEFAULT_SERVICE_NAME) {
+  const unitName = `${serviceName}.service`;
+  for (const line of cgroup.split("\n")) {
+    const idx = line.lastIndexOf(":");
+    if (idx < 0) continue;
+    const unitPath = line.slice(idx + 1).trim();
+    if (unitPath.split("/").includes(unitName)) return "systemd";
+  }
+  return null;
+}
+function detectServiceManager() {
+  if (process.platform !== "linux") return null;
+  const serviceName = process.env.ZQAGENT_SERVICE_NAME?.trim() || DEFAULT_SERVICE_NAME;
+  try {
+    return serviceManagerFromCgroup(
+      fs27.readFileSync("/proc/self/cgroup", "utf8"),
+      serviceName
+    );
+  } catch {
+    return null;
+  }
+}
 function serviceManager() {
   const v = process.env.ZQAGENT_SERVICE_MANAGER?.trim().toLowerCase();
-  return v === "systemd" || v === "launchd" ? v : null;
+  if (v === "systemd" || v === "launchd") return v;
+  return detectServiceManager();
 }
 function selfUpdateCapability(hasPublicKey) {
   if (!isSeaRuntime()) {
@@ -18972,22 +19532,22 @@ function selfUpdateCapability(hasPublicKey) {
 
 // src/update/installer.ts
 init_esm_shims();
-import * as fs27 from "fs";
-import * as path34 from "path";
+import * as fs29 from "fs";
+import * as path36 from "path";
 
 // src/update/state.ts
 init_esm_shims();
-import * as fs26 from "fs";
-import * as path33 from "path";
+import * as fs28 from "fs";
+import * as path35 from "path";
 function updatesDir(dataDir) {
-  return path33.join(dataDir, "updates");
+  return path35.join(dataDir, "updates");
 }
 function statePath(dataDir) {
-  return path33.join(updatesDir(dataDir), "state.json");
+  return path35.join(updatesDir(dataDir), "state.json");
 }
 function loadState(dataDir) {
   try {
-    const raw = fs26.readFileSync(statePath(dataDir), "utf-8");
+    const raw = fs28.readFileSync(statePath(dataDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null) return parsed;
   } catch {
@@ -18996,11 +19556,11 @@ function loadState(dataDir) {
 }
 function saveState(dataDir, state) {
   const dir = updatesDir(dataDir);
-  fs26.mkdirSync(dir, { recursive: true });
+  fs28.mkdirSync(dir, { recursive: true });
   const file = statePath(dataDir);
   const tmp = `${file}.tmp`;
-  fs26.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
-  fs26.renameSync(tmp, file);
+  fs28.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  fs28.renameSync(tmp, file);
 }
 function patchState(dataDir, patch) {
   const next = { ...loadState(dataDir), ...patch };
@@ -19010,36 +19570,36 @@ function patchState(dataDir, patch) {
 
 // src/update/installer.ts
 function backupDir(dataDir) {
-  return path34.join(updatesDir(dataDir), "backup");
+  return path36.join(updatesDir(dataDir), "backup");
 }
 function backupCurrent(dataDir, execPath, version) {
   const dir = backupDir(dataDir);
-  fs27.mkdirSync(dir, { recursive: true });
-  const target = path34.join(dir, `zqagent-${version}${process.platform === "win32" ? ".exe" : ""}`);
-  fs27.copyFileSync(execPath, target);
-  fs27.chmodSync(target, 493);
+  fs29.mkdirSync(dir, { recursive: true });
+  const target = path36.join(dir, `zqagent-${version}${process.platform === "win32" ? ".exe" : ""}`);
+  fs29.copyFileSync(execPath, target);
+  fs29.chmodSync(target, 493);
   return target;
 }
 function replaceExecutable(execPath, stagedPath) {
   if (process.platform === "win32") {
     const oldPath = `${execPath}.old`;
-    fs27.rmSync(oldPath, { force: true });
-    fs27.renameSync(execPath, oldPath);
-    fs27.copyFileSync(stagedPath, execPath);
-    fs27.chmodSync(execPath, 493);
+    fs29.rmSync(oldPath, { force: true });
+    fs29.renameSync(execPath, oldPath);
+    fs29.copyFileSync(stagedPath, execPath);
+    fs29.chmodSync(execPath, 493);
     return;
   }
   const tmp = `${execPath}.new`;
-  fs27.rmSync(tmp, { force: true });
+  fs29.rmSync(tmp, { force: true });
   try {
-    fs27.copyFileSync(stagedPath, tmp);
-    fs27.chmodSync(tmp, 493);
-    fs27.renameSync(tmp, execPath);
+    fs29.copyFileSync(stagedPath, tmp);
+    fs29.chmodSync(tmp, 493);
+    fs29.renameSync(tmp, execPath);
   } catch (err) {
-    fs27.rmSync(tmp, { force: true });
+    fs29.rmSync(tmp, { force: true });
     throw err;
   }
-  fs27.rmSync(stagedPath, { force: true });
+  fs29.rmSync(stagedPath, { force: true });
 }
 function installStaged(opts) {
   const log = opts.log ?? (() => {
@@ -19047,7 +19607,7 @@ function installStaged(opts) {
   const from = currentVersion();
   log(`\u6B63\u5728\u5B89\u88C5 v${opts.version}\uFF08\u5F53\u524D v${from}\uFF09`);
   const backupPath = backupCurrent(opts.dataDir, opts.execPath, from);
-  log(`\u5DF2\u5907\u4EFD\u5F53\u524D\u7248\u672C\u5230 ${path34.basename(backupPath)}`);
+  log(`\u5DF2\u5907\u4EFD\u5F53\u524D\u7248\u672C\u5230 ${path36.basename(backupPath)}`);
   replaceExecutable(opts.execPath, opts.stagedPath);
   return patchState(opts.dataDir, {
     stagedVersion: void 0,
@@ -19066,18 +19626,18 @@ function rollback(dataDir, execPath, log = () => {
 }) {
   const state = readRollbackTarget(dataDir);
   if (!state?.backupPath || !state.backupVersion) return null;
-  if (!fs27.existsSync(state.backupPath)) return null;
+  if (!fs29.existsSync(state.backupPath)) return null;
   log(`\u6B63\u5728\u56DE\u6EDA\u5230 v${state.backupVersion}`);
   if (process.platform === "win32") {
-    fs27.rmSync(`${execPath}.old`, { force: true });
-    fs27.renameSync(execPath, `${execPath}.old`);
-    fs27.copyFileSync(state.backupPath, execPath);
-    fs27.chmodSync(execPath, 493);
+    fs29.rmSync(`${execPath}.old`, { force: true });
+    fs29.renameSync(execPath, `${execPath}.old`);
+    fs29.copyFileSync(state.backupPath, execPath);
+    fs29.chmodSync(execPath, 493);
   } else {
     const tmp = `${execPath}.rollback`;
-    fs27.copyFileSync(state.backupPath, tmp);
-    fs27.chmodSync(tmp, 493);
-    fs27.renameSync(tmp, execPath);
+    fs29.copyFileSync(state.backupPath, tmp);
+    fs29.chmodSync(tmp, 493);
+    fs29.renameSync(tmp, execPath);
   }
   patchState(dataDir, {
     pendingVersion: state.backupVersion,
@@ -19091,7 +19651,7 @@ function rollback(dataDir, execPath, log = () => {
 }
 function readRollbackTarget(dataDir) {
   try {
-    const raw = fs27.readFileSync(path34.join(updatesDir(dataDir), "state.json"), "utf-8");
+    const raw = fs29.readFileSync(path36.join(updatesDir(dataDir), "state.json"), "utf-8");
     const s = JSON.parse(raw);
     if (s.backupPath && s.backupVersion) return s;
   } catch {
@@ -19174,7 +19734,7 @@ var UpdateController = class {
   reconcile() {
     const state = loadState(this.opts.dataDir);
     const current = this.currentVersion;
-    if (state.stagedPath && !fs28.existsSync(state.stagedPath)) {
+    if (state.stagedPath && !fs30.existsSync(state.stagedPath)) {
       patchState(this.opts.dataDir, { stagedVersion: void 0, stagedPath: void 0 });
     }
     const patch = { runningVersion: current };
@@ -19189,7 +19749,7 @@ var UpdateController = class {
     }
     patchState(this.opts.dataDir, patch);
     if (process.platform === "win32") {
-      fs28.rmSync(`${process.execPath}.old`, { force: true });
+      fs30.rmSync(`${process.execPath}.old`, { force: true });
     }
   }
   schedule(delayMs) {
@@ -19265,8 +19825,8 @@ var UpdateController = class {
       const bin = manifest.binaries[platformKey()];
       if (!bin) return `\u6E05\u5355\u6CA1\u6709\u5F53\u524D\u5E73\u53F0\uFF08${platformKey()}\uFF09\u7684\u4EA7\u7269`;
       let stagedPath = state.stagedPath;
-      if (!(state.stagedVersion === manifest.version && stagedPath && fs28.existsSync(stagedPath))) {
-        stagedPath = path35.join(
+      if (!(state.stagedVersion === manifest.version && stagedPath && fs30.existsSync(stagedPath))) {
+        stagedPath = path37.join(
           updatesDir(this.opts.dataDir),
           "staged",
           `zqagent-${manifest.version}${process.platform === "win32" ? ".exe" : ""}`
@@ -19278,7 +19838,7 @@ var UpdateController = class {
         }
         const selfTest = selfCheck(stagedPath, manifest.version);
         if (!selfTest.ok) {
-          fs28.rmSync(stagedPath, { force: true });
+          fs30.rmSync(stagedPath, { force: true });
           this.recordFailure(manifest.version, selfTest.error ?? "\u81EA\u68C0\u5931\u8D25");
           return `\u5B89\u88C5\u5305\u81EA\u68C0\u5931\u8D25\uFF1A${selfTest.error}`;
         }
@@ -19419,7 +19979,7 @@ function pemFile(key) {
   const p = env2(key);
   if (!p) return void 0;
   try {
-    return fs29.readFileSync(p);
+    return fs31.readFileSync(p);
   } catch (e) {
     console.warn(`[tls] \u8BFB\u53D6 ${key}=${p} \u5931\u8D25: ${e instanceof Error ? e.message : e}`);
     return void 0;
@@ -19441,7 +20001,7 @@ function seedDemoTenant(store) {
       apiKey: env2("OPENAI_API_KEY"),
       baseURL: env2("OPENAI_BASE_URL")
     },
-    workspaceRoot: workspace ? path36.resolve(workspace) : void 0,
+    workspaceRoot: workspace ? path38.resolve(workspace) : void 0,
     allowedCommands: []
   };
   store.saveTenant(demo);
@@ -19495,9 +20055,9 @@ function syncTenantModels(store) {
       tenant.model = model;
       changed = true;
     }
-    if (workspace && tenant.workspaceRoot !== path36.resolve(workspace)) {
-      console.log(`[sync] \u79DF\u6237 ${id} workspaceRoot \u5DF2\u540C\u6B65: ${tenant.workspaceRoot ?? "(\u6C99\u7BB1)"} \u2192 ${path36.resolve(workspace)}`);
-      tenant.workspaceRoot = path36.resolve(workspace);
+    if (workspace && tenant.workspaceRoot !== path38.resolve(workspace)) {
+      console.log(`[sync] \u79DF\u6237 ${id} workspaceRoot \u5DF2\u540C\u6B65: ${tenant.workspaceRoot ?? "(\u6C99\u7BB1)"} \u2192 ${path38.resolve(workspace)}`);
+      tenant.workspaceRoot = path38.resolve(workspace);
       changed = true;
     }
     if (apiKey && tenant.provider.apiKey !== apiKey) {
@@ -19529,7 +20089,7 @@ function exitWhenOrphaned() {
   timer.unref();
 }
 function startServer(opts = {}) {
-  const dataDir = path36.resolve(opts.dataDir ?? env2("DATA_DIR") ?? DEFAULT_DATA_DIR);
+  const dataDir = path38.resolve(opts.dataDir ?? env2("DATA_DIR") ?? DEFAULT_DATA_DIR);
   const port = opts.port ?? Number(env2("PORT") ?? 8787);
   const host = opts.host ?? env2("HOST") ?? "127.0.0.1";
   exitWhenOrphaned();
@@ -19559,7 +20119,7 @@ function startServer(opts = {}) {
   }
   const adminKey = ensureAdminKey();
   const secretKey = env2("SECRET_KEY");
-  const secretBox = secretKey ? SecretBox.fromHex(secretKey) : SecretBox.fromFile(path36.join(dataDir, "secret.key"));
+  const secretBox = secretKey ? SecretBox.fromHex(secretKey) : SecretBox.fromFile(path38.join(dataDir, "secret.key"));
   if (secretKey && !secretBox) {
     console.warn("[crypto] SECRET_KEY \u975E\u6CD5\uFF08\u9700 64 \u4F4D hex\uFF09\uFF0C\u901A\u77E5\u51ED\u636E\u5C06\u9000\u5316\u4E3A\u660E\u6587");
   }
@@ -19788,7 +20348,7 @@ function printReady(info, qq) {
     `zqagent server \u76D1\u542C http://${info.host}:${info.port}`,
     `\u6570\u636E\u76EE\u5F55: ${info.dataDir}`,
     `\u5BA1\u6279\u6302\u8D77\u8D85\u65F6: ${env2("APPROVAL_TIMEOUT_SECONDS") ?? 900}s\uFF08\u8D85\u65F6\u540E\u56DE\u6536\u5185\u5B58\u4EFB\u52A1\uFF0C\u53EF\u7ECF resume \u6062\u590D\uFF09`,
-    env2("ZQAGENT_LOG_ADMIN_KEY") === "0" ? `\u7BA1\u7406\u5458\u5BC6\u94A5: ${maskKey(info.adminKey)}\uFF08\u5DF2\u8131\u654F\uFF0C\u5B8C\u6574\u503C\u89C1 ${path36.join(info.dataDir, "admin.json")}\uFF09` : `\u7BA1\u7406\u5458\u5BC6\u94A5: ${info.adminKey}\uFF08\u63A7\u5236\u53F0\u591A\u9879\u76EE\u5165\u53E3\uFF1A/api/v1/projects\uFF1B\u9879\u76EE\u7EA7\u63A5\u53E3\u52A0 X-Project-Id \u5934\uFF09`
+    env2("ZQAGENT_LOG_ADMIN_KEY") === "0" ? `\u7BA1\u7406\u5458\u5BC6\u94A5: ${maskKey(info.adminKey)}\uFF08\u5DF2\u8131\u654F\uFF0C\u5B8C\u6574\u503C\u89C1 ${path38.join(info.dataDir, "admin.json")}\uFF09` : `\u7BA1\u7406\u5458\u5BC6\u94A5: ${info.adminKey}\uFF08\u63A7\u5236\u53F0\u591A\u9879\u76EE\u5165\u53E3\uFF1A/api/v1/projects\uFF1B\u9879\u76EE\u7EA7\u63A5\u53E3\u52A0 X-Project-Id \u5934\uFF09`
   ];
   if (info.fleetNodeId) {
     lines.push(
@@ -19809,7 +20369,7 @@ function printReady(info, qq) {
 
 // src/cli/account-enroll.ts
 init_esm_shims();
-import * as path37 from "path";
+import * as path39 from "path";
 import * as readline from "readline/promises";
 var SKIP_ANSWERS = /* @__PURE__ */ new Set(["-", "skip", "none", "no"]);
 function resolveDefaultHub(hubUrl, env3 = process.env) {
@@ -19821,7 +20381,7 @@ function parseHubAnswer(answer, fallback) {
   return (a || fallback).replace(/\/$/, "");
 }
 function resolveDataDir2(dataDir) {
-  return path37.resolve(dataDir ?? process.env.DATA_DIR ?? DEFAULT_DATA_DIR);
+  return path39.resolve(dataDir ?? process.env.DATA_DIR ?? DEFAULT_DATA_DIR);
 }
 async function maybeAccountEnroll(opts = {}) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) return;
@@ -20027,7 +20587,7 @@ async function runServeCommand(argv) {
 
 // src/cli/update.ts
 init_esm_shims();
-import * as path38 from "path";
+import * as path40 from "path";
 function parse3(argv) {
   const out = { status: false, check: false, now: false, rollback: false };
   for (let i = 0; i < argv.length; i++) {
@@ -20056,7 +20616,7 @@ function restartHint() {
 }
 async function runUpdateCommand(argv) {
   const args = parse3(argv);
-  const dataDir = path38.resolve(args.dataDir ?? process.env.DATA_DIR ?? DEFAULT_DATA_DIR);
+  const dataDir = path40.resolve(args.dataDir ?? process.env.DATA_DIR ?? DEFAULT_DATA_DIR);
   const controller = new UpdateController({ dataDir, isIdle: () => true });
   if (args.rollback) {
     const restored = controller.rollbackNow();
@@ -20104,17 +20664,17 @@ async function runUpdateCommand(argv) {
 
 // src/cli/sessionMeta.ts
 init_esm_shims();
-import * as fs30 from "fs";
-import * as path39 from "path";
+import * as fs32 from "fs";
+import * as path41 from "path";
 function updateSessionMetaFile(stateDir2, sessionId, patch) {
-  const file = path39.join(stateDir2, `${sessionId}_state.json`);
+  const file = path41.join(stateDir2, `${sessionId}_state.json`);
   try {
-    const raw = fs30.readFileSync(file, "utf8");
+    const raw = fs32.readFileSync(file, "utf8");
     const state = JSON.parse(raw);
     if (patch.name !== void 0) state.name = patch.name;
     if (patch.nameSource !== void 0) state.nameSource = patch.nameSource;
     if (patch.taskCount !== void 0) state.taskCount = patch.taskCount;
-    fs30.writeFileSync(file, JSON.stringify(state, null, 2), "utf8");
+    fs32.writeFileSync(file, JSON.stringify(state, null, 2), "utf8");
     return true;
   } catch {
     return false;
@@ -20123,9 +20683,9 @@ function updateSessionMetaFile(stateDir2, sessionId, patch) {
 
 // src/cli/debug.ts
 init_esm_shims();
-import * as fs31 from "fs";
+import * as fs33 from "fs";
 import * as os8 from "os";
-import * as path40 from "path";
+import * as path42 from "path";
 var LOG_NAME = "zqagent-debug.log";
 var TRUTHY = /^(1|true|yes|on)$/i;
 function bootRef() {
@@ -20136,9 +20696,9 @@ var logFile = null;
 var startedAt = Date.now();
 function resolveLogFile() {
   const explicit = process.env.ZQAGENT_DEBUG_LOG;
-  if (explicit) return path40.resolve(explicit);
+  if (explicit) return path42.resolve(explicit);
   const dir = process.env.ZQAGENT_DEBUG_DIR;
-  return path40.join(dir ? path40.resolve(dir) : os8.tmpdir(), LOG_NAME);
+  return path42.join(dir ? path42.resolve(dir) : os8.tmpdir(), LOG_NAME);
 }
 function enableDebug(argv = process.argv) {
   if (enabled) return true;
@@ -20154,8 +20714,8 @@ function enableDebug(argv = process.argv) {
   enabled = true;
   logFile = resolveLogFile();
   try {
-    fs31.mkdirSync(path40.dirname(logFile), { recursive: true });
-    fs31.writeFileSync(logFile, "");
+    fs33.mkdirSync(path42.dirname(logFile), { recursive: true });
+    fs33.writeFileSync(logFile, "");
   } catch {
     logFile = null;
   }
@@ -20172,7 +20732,7 @@ function dlog(stage, message = "") {
   const line = `[+${String(Date.now() - startedAt).padStart(6)}ms] [${stage}] ${message}`;
   if (logFile) {
     try {
-      fs31.appendFileSync(logFile, line + "\n");
+      fs33.appendFileSync(logFile, line + "\n");
     } catch {
     }
   }
@@ -20332,18 +20892,18 @@ if (enableDebug(process.argv)) {
   logEnvironment();
 }
 var MODEL = process.env.OPENAI_MODEL ?? "gpt-4o";
-var WORKSPACE = path41.resolve(process.env.WORKSPACE ?? ".");
+var WORKSPACE = path43.resolve(process.env.WORKSPACE ?? ".");
 var MAX_ITERATIONS = parseMaxIterations(process.env.MAX_ITERATIONS, 300);
 var STATE_DIR = stateDir();
 function listSessions() {
   try {
-    const files = fs32.readdirSync(STATE_DIR);
+    const files = fs34.readdirSync(STATE_DIR);
     const sessions = [];
     for (const f of files) {
       if (!f.endsWith("_state.json")) continue;
       try {
         const parsed = JSON.parse(
-          fs32.readFileSync(path41.join(STATE_DIR, f), "utf8")
+          fs34.readFileSync(path43.join(STATE_DIR, f), "utf8")
         );
         if (parsed && typeof parsed.sessionId === "string") {
           sessions.push(parsed);
@@ -20377,11 +20937,11 @@ function printLastAssistantMessage(messages) {
   out += renderer.flush();
   cliWrite(out + "\n");
 }
-var AGENTS_FILE = path41.join(WORKSPACE, ".agent", "agents.json");
+var AGENTS_FILE = path43.join(WORKSPACE, ".agent", "agents.json");
 function loadAgentsFromFile() {
   try {
-    if (!fs32.existsSync(AGENTS_FILE)) return [];
-    const raw = fs32.readFileSync(AGENTS_FILE, "utf8");
+    if (!fs34.existsSync(AGENTS_FILE)) return [];
+    const raw = fs34.readFileSync(AGENTS_FILE, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed.filter(
@@ -20393,8 +20953,8 @@ function loadAgentsFromFile() {
 }
 function saveAgentsToFile(defs) {
   try {
-    fs32.mkdirSync(path41.dirname(AGENTS_FILE), { recursive: true });
-    fs32.writeFileSync(AGENTS_FILE, JSON.stringify(defs, null, 2) + "\n", "utf8");
+    fs34.mkdirSync(path43.dirname(AGENTS_FILE), { recursive: true });
+    fs34.writeFileSync(AGENTS_FILE, JSON.stringify(defs, null, 2) + "\n", "utf8");
   } catch (err) {
     cliErr(`\u26A0\uFE0F  \u4FDD\u5B58 agents \u914D\u7F6E\u5931\u8D25: ${err}`);
   }
@@ -20403,12 +20963,12 @@ var agentRegistry = new AgentRegistry([
   ...BUILTIN_AGENTS,
   ...loadAgentsFromFile()
 ]);
-var MCP_FILE = path41.join(WORKSPACE, ".agent", "mcp.json");
-var COMMAND_TOOLS_FILE = path41.join(WORKSPACE, ".agent", "tools.json");
+var MCP_FILE = path43.join(WORKSPACE, ".agent", "mcp.json");
+var COMMAND_TOOLS_FILE = path43.join(WORKSPACE, ".agent", "tools.json");
 function loadJsonArray(file, validate) {
   try {
-    if (!fs32.existsSync(file)) return [];
-    const parsed = JSON.parse(fs32.readFileSync(file, "utf8"));
+    if (!fs34.existsSync(file)) return [];
+    const parsed = JSON.parse(fs34.readFileSync(file, "utf8"));
     if (!Array.isArray(parsed)) return [];
     if (!validate) return parsed;
     return parsed.filter((v) => validate(v));
@@ -20418,8 +20978,8 @@ function loadJsonArray(file, validate) {
 }
 function saveJsonFile(file, data) {
   try {
-    fs32.mkdirSync(path41.dirname(file), { recursive: true });
-    fs32.writeFileSync(file, JSON.stringify(data, null, 2) + "\n", "utf8");
+    fs34.mkdirSync(path43.dirname(file), { recursive: true });
+    fs34.writeFileSync(file, JSON.stringify(data, null, 2) + "\n", "utf8");
   } catch (err) {
     cliErr(`\u26A0\uFE0F  \u4FDD\u5B58\u914D\u7F6E\u5931\u8D25: ${err}`);
   }
@@ -20520,7 +21080,7 @@ function pruneEmptySessions(keepSessionId) {
     if (!isEmptySession(s) || s.sessionId === keepSessionId) continue;
     for (const suffix of ["_state.json", ".jsonl"]) {
       try {
-        fs32.unlinkSync(path41.join(STATE_DIR, `${s.sessionId}${suffix}`));
+        fs34.unlinkSync(path43.join(STATE_DIR, `${s.sessionId}${suffix}`));
       } catch {
       }
     }
@@ -20710,6 +21270,7 @@ function buildEngine(sessionId, savedState) {
     // 引擎内置表（lookupContextWindow 兜底，见 TurnEngine._contextWindow）
     contextWindow: parseOptionalPositiveNumber(process.env.CONTEXT_WINDOW) ?? modelContextWindow(conn?.modelMeta, model),
     thresholdPct: parseRatio(process.env.COMPACTION_THRESHOLD_PCT),
+    softThresholdPct: parseRatio(process.env.COMPACTION_SOFT_THRESHOLD_PCT),
     capTokens: parseOptionalPositiveNumber(process.env.COMPACTION_CAP_TOKENS) ?? null,
     // 系统提示词按当前 agent 组装（agent prompt + 叙述规则 + 环境信息）
     instructions: agentRegistry.buildSystemPrompt(
@@ -21052,7 +21613,7 @@ async function offerTerminalSetup(engine, canUseAgent) {
 }
 var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["link", "serve", "update"]);
 function cliVersion() {
-  const env3 = "0.2.5"?.trim();
+  const env3 = "0.2.7"?.trim();
   if (env3) return env3;
   try {
     const req2 = createRequire4(import.meta.url);
@@ -21256,8 +21817,8 @@ async function main() {
     }
   });
   const savedState = resumeId ? FileLogHook.loadState(resumeId, STATE_DIR) : null;
-  const metaStateFile = path41.join(STATE_DIR, `${SESSION_ID}_state.json`);
-  const stateForMeta = savedState ?? (fs32.existsSync(metaStateFile) ? FileLogHook.loadState(SESSION_ID, STATE_DIR) : null);
+  const metaStateFile = path43.join(STATE_DIR, `${SESSION_ID}_state.json`);
+  const stateForMeta = savedState ?? (fs34.existsSync(metaStateFile) ? FileLogHook.loadState(SESSION_ID, STATE_DIR) : null);
   sessionMeta = {
     sessionId: SESSION_ID,
     name: stateForMeta?.name,