nolo-cli 0.11.0 → 0.12.0-alpha.1

package/{chunk-S3GS2PRL.js → chunk-4BTHUYMY.js}

@@ -2,29 +2,34 @@ import {
   buildCurrentTimeBlock,
   buildIdentityBlock,
   buildRuntimeGuidanceBlocks
-} from "./chunk-OUI3ZHYD.js";
+} from "./chunk-6OVCRC72.js";
 import {
   canonicalizeToolNames
-} from "./chunk-4SOKXIW4.js";
+} from "./chunk-43UD5ZP7.js";
 import {
-  clipCompactText
-} from "./chunk-5MMAK75Q.js";
+  clipCompactText,
+  estimateTokenCount,
+  getModelContextWindow,
+  planCompression,
+  planContextUsage,
+  serializeMessageContent
+} from "./chunk-S73OEOHH.js";
 import {
   findModelConfig,
   getProviderByModelName
-} from "./chunk-BBYVOSU2.js";
+} from "./chunk-S3UTETIC.js";
+import {
+  buildDialogSummaryLayer
+} from "./chunk-QLUFR47U.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
-import {
-  compactWhitespace
-} from "./chunk-DWLEOOGR.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
@@ -52,14 +57,27 @@ function readActionGate(value) {
   if (typeof value.id !== "string" || !value.id.trim()) return null;
   if (value.kind !== "confirm" && value.kind !== "handoff" && value.kind !== "input") return null;
   if (typeof value.title !== "string" || !value.title.trim()) return null;
+  const titleParams = readTitleParams(value.titleParams);
   return {
     id: value.id.trim(),
     kind: value.kind,
     title: value.title.trim(),
+    ...titleParams ? { titleParams } : {},
     ...asOptionalTrimmedString(value.body) ? { body: asOptionalTrimmedString(value.body) } : {},
     ...Object.prototype.hasOwnProperty.call(value, "payload") ? { payload: value.payload } : {}
   };
 }
+function readTitleParams(value) {
+  if (!isRecord(value)) return void 0;
+  const entries = Object.entries(value).flatMap(([key, raw]) => {
+    if (typeof raw === "string" || typeof raw === "number") {
+      return [[key, raw]];
+    }
+    return [];
+  });
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+}
 
 // packages/ai/llm/agentCapabilities.ts
 var isCustomAgent = (agent) => {
@@ -273,6 +291,227 @@ function summarizeToolArguments(toolName, rawArgs) {
   );
 }
 
+// packages/agent-runtime/contextBlockScope.ts
+var isContextBlockScope = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.content === "string" && (candidate.cacheScope === "session" || candidate.cacheScope === "turn");
+};
+var normalizeContextBlockScopes = (legacyBlocks = void 0, scopes = void 0) => {
+  const trimmedScopes = (Array.isArray(scopes) ? scopes : []).filter(isContextBlockScope).map((scope) => ({ content: scope.content.trim(), cacheScope: scope.cacheScope })).filter((scope) => scope.content.length > 0);
+  if (trimmedScopes.length > 0) {
+    return trimmedScopes;
+  }
+  return (Array.isArray(legacyBlocks) ? legacyBlocks : []).filter((block) => typeof block === "string").map((block) => block.trim()).filter((block) => block.length > 0).map((block) => ({ content: block, cacheScope: "turn" }));
+};
+
+// packages/ai/agent/toolOutputPolicy.ts
+var MAX_HISTORICAL_TOOL_CONTENT_CHARS = 1600;
+var MAX_IN_TURN_TOOL_CONTENT_CHARS = 4e3;
+var FRESH_TOOL_OUTPUT_MAX_CHARS = 32e3;
+var DEFAULT_TOOL_OUTPUT_PROFILE = {
+  maxChars: MAX_IN_TURN_TOOL_CONTENT_CHARS,
+  headRatio: 0.5
+};
+var TOOL_OUTPUT_PROFILES = {
+  readFile: { maxChars: 4800, headRatio: 0.68 },
+  read_file: { maxChars: 4800, headRatio: 0.68 },
+  readWorkspaceFile: { maxChars: 4800, headRatio: 0.68 },
+  searchFiles: { maxChars: 3600, headRatio: 0.78 },
+  search_files: { maxChars: 3600, headRatio: 0.78 },
+  listFiles: { maxChars: 2800, headRatio: 0.85 },
+  globFiles: { maxChars: 2800, headRatio: 0.85 },
+  execShell: { maxChars: 4e3, headRatio: 0.35 },
+  runCommand: { maxChars: 4e3, headRatio: 0.35 },
+  launchProcess: { maxChars: 2800, headRatio: 0.35 },
+  editFile: { maxChars: 2800, headRatio: 0.62 },
+  writeFile: { maxChars: 2400, headRatio: 0.62 },
+  readPastedText: { maxChars: 4800, headRatio: 0.5 }
+};
+function resolveToolOutputProfile(toolName) {
+  return (toolName ? TOOL_OUTPUT_PROFILES[toolName] : void 0) ?? DEFAULT_TOOL_OUTPUT_PROFILE;
+}
+function projectToolMessageContent(input) {
+  const { content, isFresh, toolName, historicalMaxChars } = input;
+  if (isFresh) {
+    if (content.length <= FRESH_TOOL_OUTPUT_MAX_CHARS) return content;
+    return clipToolText(
+      content,
+      FRESH_TOOL_OUTPUT_MAX_CHARS,
+      resolveToolOutputProfile(toolName).headRatio,
+      `
+\u2026[\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${content.length} \u5B57\u7B26]`
+    );
+  }
+  if (content.length <= historicalMaxChars) return content;
+  return content.slice(0, historicalMaxChars) + `
+\u2026[\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${content.length} \u5B57\u7B26]`;
+}
+function clipToolText(content, maxChars, headRatio, marker = "\n\n[... tool output middle omitted; head/tail preserved ...]\n\n") {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  if (normalized.length <= maxChars) return normalized;
+  if (maxChars <= marker.length + 2) return normalized.slice(0, maxChars);
+  const available = maxChars - marker.length;
+  const headChars = Math.max(1, Math.floor(available * headRatio));
+  const tailChars = Math.max(1, available - headChars);
+  return `${normalized.slice(0, headChars)}${marker}${normalized.slice(-tailChars)}`;
+}
+
+// packages/agent-runtime/localAutoCompaction.ts
+var LOCAL_AUTO_COMPACTION_SYSTEM_PROMPT = `\u4F60\u662F\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u538B\u7F29\u5668\u3002\u6839\u636E\u3010\u73B0\u6709\u8BB0\u5FC6\u3011\u548C\u3010\u65B0\u589E\u5BF9\u8BDD\u3011\uFF0C\u8F93\u51FA\u53EF\u66FF\u4EE3\u539F\u59CB\u6D88\u606F\u7684\u4E8B\u5B9E\u6027\u8981\u70B9\uFF0C\u4F9B\u540E\u7EED\u5BF9\u8BDD\u76F4\u63A5\u4F7F\u7528\u3002
+
+\u4E25\u683C\u53EA\u8F93\u51FA\u4E0B\u9762\u4E24\u90E8\u5206\uFF0C\u6807\u9898\u5FC5\u987B\u5B8C\u5168\u4E00\u81F4\uFF1A
+\u5173\u952E\u4E8B\u5B9E\u6863\u6848
+- ...
+\u5BF9\u8BDD\u8FDB\u5C55\u4E0E\u5F85\u529E
+- ...
+
+\u8981\u6C42\uFF1A
+1) \u4F7F\u7528\u5BF9\u8BDD\u4E3B\u8BED\u8A00\uFF1B\u6DF7\u5408\u8BED\u8A00\u65F6\u4F18\u5148\u7528\u6237\u4E3B\u8981\u8BED\u8A00\uFF1B\u4E13\u6709\u540D\u8BCD\u3001\u6587\u4EF6\u8DEF\u5F84\u3001\u6807\u8BC6\u7B26\u3001\u547D\u4EE4\u4FDD\u7559\u539F\u6587\u3002
+2) \u5173\u952E\u4E8B\u5B9E\u6863\u6848\u53EA\u4FDD\u7559\u4E4B\u540E\u7EE7\u7EED\u5BF9\u8BDD\u4ECD\u6709\u4EF7\u503C\u7684\u4FE1\u606F\uFF1A\u7528\u6237\u76EE\u6807/\u504F\u597D\u3001\u7EA6\u675F\u3001\u6280\u672F\u6808\u3001\u786E\u5B9A\u7684\u6587\u4EF6\u8DEF\u5F84\u3001\u6838\u5FC3\u51B3\u7B56\u3001\u672A\u5B8C\u6210\u5F85\u529E\u3002
+3) \u5BF9\u8BDD\u8FDB\u5C55\u4E0E\u5F85\u529E\uFF1A\u5148\u6781\u7B80\u6982\u62EC\u65E7\u4E0A\u4E0B\u6587\uFF0C\u518D\u66F4\u8BE6\u7EC6\u8BB0\u5F55\u6700\u8FD1\u8FDB\u5C55\u3001\u7ED3\u8BBA\u3001\u5206\u6B67\u4E0E\u4E0B\u4E00\u6B65\u3002
+4) \u5FFD\u7565\u5BD2\u6684\u3001\u91CD\u590D\u5C1D\u8BD5\u3001\u5DF2\u653E\u5F03\u65B9\u6848\u548C\u65E0\u4EF7\u503C\u5E9F\u8BDD\u3002
+5) \u4E0D\u8981\u7F16\u9020\u672A\u51FA\u73B0\u7684\u4FE1\u606F\uFF1B\u4E0D\u8981\u5F00\u573A\u767D\u3001\u7ED3\u675F\u8BED\u3001markdown \u4EE3\u7801\u5757\u6216\u989D\u5916\u7AE0\u8282\uFF1B\u4E0D\u8981\u8C03\u7528\u4EFB\u4F55\u5DE5\u5177\u3002`;
+function buildLocalAutoCompactionUserContent(previousSummary, messagesText) {
+  return `\u3010\u73B0\u6709\u8BB0\u5FC6\u3011\uFF1A
+${previousSummary || "(\u65E0)"}
+
+\u3010\u65B0\u589E\u5BF9\u8BDD\u3011\uFF1A
+${messagesText}`.trim();
+}
+function toPlanCompressionMessages(history) {
+  return history.map((message, index) => {
+    const usage = message.usage;
+    return {
+      id: `local-${index}`,
+      role: message.role,
+      content: message.content,
+      ...Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {},
+      ...usage?.completion_tokens != null ? { usage: { completion_tokens: usage.completion_tokens } } : {}
+    };
+  });
+}
+function formatMessagesForLocalSummary(msgs) {
+  return msgs.map((msg) => {
+    const content = serializeMessageContent(msg.content) || (Array.isArray(msg.tool_calls) ? `[tool_calls:${msg.tool_calls.map((c) => c.function?.name).filter(Boolean).join(",")}]` : "[\u975E\u6587\u672C\u5185\u5BB9]");
+    return `${msg.role}: ${content}`;
+  }).join("\n");
+}
+function buildLocalSummaryHistoryMessage(summary) {
+  const layer = buildDialogSummaryLayer({ summary });
+  return {
+    role: "user",
+    content: layer?.content ?? `--- \u5386\u53F2\u5BF9\u8BDD\u6458\u8981 ---
+${summary.trim()}`
+  };
+}
+function projectHistoryWithSummary(args) {
+  const bridged = toPlanCompressionMessages(args.history);
+  let startIndex = 0;
+  if (args.summarizedBeforeId) {
+    const found = bridged.findIndex((m) => m.id === args.summarizedBeforeId);
+    if (found !== -1) startIndex = found + 1;
+  }
+  return [
+    buildLocalSummaryHistoryMessage(args.summary),
+    ...args.history.slice(startIndex)
+  ];
+}
+var COLD_RESUME_IDLE_MS = 60 * 60 * 1e3;
+function isColdResume(history, nowMs) {
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    const at = history[i]?.createdAt;
+    if (typeof at === "number" && Number.isFinite(at)) {
+      return nowMs - at > COLD_RESUME_IDLE_MS;
+    }
+  }
+  return false;
+}
+async function maybeAutoCompactLocalHistory(args) {
+  const { adapter, dialogId, history } = args;
+  const unchanged = () => ({
+    history,
+    compressed: false,
+    summaryGenerated: false
+  });
+  if (!dialogId || history.length === 0 || typeof adapter.loadDialogSummary !== "function" || typeof adapter.saveDialogSummary !== "function") {
+    return unchanged();
+  }
+  let stored = null;
+  try {
+    stored = await adapter.loadDialogSummary(dialogId);
+  } catch (error) {
+    console.warn("[localLoop] loadDialogSummary failed:", error);
+    return unchanged();
+  }
+  const existingSummary = typeof stored?.summary === "string" ? stored.summary : "";
+  const summarizedBeforeId = typeof stored?.summarizedBeforeId === "string" ? stored.summarizedBeforeId : void 0;
+  const contextWindow = typeof args.contextWindow === "number" && Number.isFinite(args.contextWindow) && args.contextWindow > 0 ? args.contextWindow : getModelContextWindow(args.model ?? "");
+  const allMsgs = toPlanCompressionMessages(history);
+  const coldResume = isColdResume(history, args.now?.() ?? Date.now());
+  const plan = planCompression({
+    allMsgs,
+    summarizedBeforeId,
+    summary: existingSummary,
+    contextWindow,
+    ...coldResume ? { force: true, reason: "context_budget" } : {}
+  });
+  const projectExisting = () => {
+    if (!existingSummary.trim()) return unchanged();
+    return {
+      history: projectHistoryWithSummary({
+        history,
+        summary: existingSummary,
+        summarizedBeforeId
+      }),
+      compressed: true,
+      summaryGenerated: false
+    };
+  };
+  if (!plan.shouldCompress) {
+    return projectExisting();
+  }
+  try {
+    const provider = await args.resolveProvider();
+    const messagesText = formatMessagesForLocalSummary(
+      plan.msgsToCompress
+    );
+    const promptContent = buildLocalAutoCompactionUserContent(
+      existingSummary,
+      messagesText
+    );
+    const result = await provider.complete([
+      { role: "system", content: LOCAL_AUTO_COMPACTION_SYSTEM_PROMPT },
+      { role: "user", content: promptContent }
+    ]);
+    const newSummary = typeof result.content === "string" ? result.content.trim() : "";
+    if (!newSummary) {
+      console.warn(
+        "[localLoop] auto-compaction produced empty summary; keeping prior projection"
+      );
+      return projectExisting();
+    }
+    await adapter.saveDialogSummary({
+      dialogId,
+      summary: newSummary,
+      summarizedBeforeId: plan.newSummarizedBeforeId
+    });
+    return {
+      history: projectHistoryWithSummary({
+        history,
+        summary: newSummary,
+        summarizedBeforeId: plan.newSummarizedBeforeId
+      }),
+      compressed: true,
+      summaryGenerated: true,
+      ...result.usage ? { usage: result.usage } : {}
+    };
+  } catch (error) {
+    console.warn("[localLoop] auto-compaction failed:", error);
+    return projectExisting();
+  }
+}
+
 // packages/agent-runtime/localLoop.ts
 var LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 var EMPTY_ASSISTANT_REPAIR_PROMPT = "\u8BF7\u7ED9\u51FA\u660E\u786E\u7684\u6587\u5B57\u56DE\u7B54\u6216\u6267\u884C\u4E0B\u4E00\u6B65\uFF1A\u5982\u679C\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u8BF7\u76F4\u63A5\u603B\u7ED3\u7ED3\u679C\uFF1B\u5982\u679C\u9700\u8981\u8C03\u7528\u5DE5\u5177\uFF0C\u8BF7\u76F4\u63A5\u8F93\u51FA tool_calls\u3002\u8BF7\u5207\u52FF\u8FD4\u56DE\u7A7A\u5185\u5BB9\u3002";
@@ -341,14 +580,43 @@ function buildAbortedError() {
 function throwIfAborted(input) {
   if (input.abortSignal?.aborted) throw buildAbortedError();
 }
+async function raceWithAbort(input, promise, pendingToolName) {
+  const signal = input.abortSignal;
+  if (!signal) return promise;
+  let abortListener;
+  const abortPromise = new Promise((_resolve, reject) => {
+    abortListener = () => {
+      const error = buildAbortedError();
+      if (pendingToolName) error.pendingToolName = pendingToolName;
+      promise.catch(() => {
+      });
+      reject(error);
+    };
+    if (signal.aborted) {
+      abortListener();
+      return;
+    }
+    signal.addEventListener("abort", abortListener, { once: true });
+  });
+  try {
+    return await Promise.race([promise, abortPromise]);
+  } finally {
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
 function resolveLlmRequestTimeoutMs(input) {
   const raw = input.llmRequestTimeoutMs ?? input.timeoutMs;
   if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return void 0;
   return raw;
 }
 async function runCompleteWithTimeout(args) {
-  const { provider, messages, options, timeoutMs, round, input } = args;
-  emitLoopEvent(input, { kind: "llm-start", round, atMs: Date.now() });
+  const { provider, messages, options, timeoutMs, round, input, context } = args;
+  emitLoopEvent(input, {
+    kind: "llm-start",
+    round,
+    atMs: Date.now(),
+    ...context ? { context } : {}
+  });
   const complete = provider.complete(messages, options);
   let ok = false;
   const signal = input.abortSignal;
@@ -511,52 +779,218 @@ function buildActionGate(args) {
     toolCallId: args.toolCallId
   };
 }
-var MAX_HISTORICAL_TOOL_CONTENT_CHARS = 1600;
-var MAX_IN_TURN_TOOL_CONTENT_CHARS = 4e3;
-function summarizeToolContentForProvider(content, maxChars, label) {
+var TOOL_METADATA_KEYS = [
+  "path",
+  "query",
+  "effectivePattern",
+  "startLine",
+  "endLine",
+  "totalLines",
+  "totalBytes",
+  "bytes",
+  "totalChars",
+  "count",
+  "matchCount",
+  "matchedFiles",
+  "truncated",
+  "limitedByMaxResults",
+  "limitedByMaxDepth",
+  "visitedEntries",
+  "maxResults",
+  "exitCode",
+  "status",
+  "timedOut",
+  "aborted",
+  "replacements",
+  "code",
+  "error",
+  "message",
+  "pasteId",
+  "source"
+];
+function trimHistoryToContextBudget(history, model) {
+  if (history.length === 0) return { history, droppedCount: 0 };
+  const { rawMessageBudget } = planContextUsage({
+    contextWindow: getModelContextWindow(model ?? ""),
+    summaryTokens: 0,
+    // localLoop 没有 web 端的负载分档器；medium 是中性默认值，
+    // 不为了省几个 token 在这里复制一份分类逻辑。
+    recentLoad: "medium"
+  });
+  const messageTokens = (message) => {
+    const toolCalls = message.tool_calls;
+    return estimateTokenCount(contentAsText(message.content)) + (Array.isArray(toolCalls) ? estimateTokenCount(JSON.stringify(toolCalls)) : 0);
+  };
+  let used = 0;
+  let start = history.length;
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    const cost = messageTokens(history[i]);
+    if (used + cost > rawMessageBudget && start < history.length) break;
+    used += cost;
+    start = i;
+  }
+  if (start === 0) return { history, droppedCount: 0 };
+  return {
+    history: sanitizeToolCallPairing(history.slice(start)),
+    droppedCount: start
+  };
+}
+function contentAsText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (part?.type === "text") return part.text;
+    if (part?.type === "image_url") return part.image_url.url;
+    return "";
+  }).join("\n");
+}
+function contentCharCount(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  return content.reduce((total, part) => {
+    if (part?.type === "text") return total + part.text.length;
+    if (part?.type === "image_url") return total + part.image_url.url.length;
+    return total;
+  }, 0);
+}
+function compactToolMetadata(metadata) {
+  if (!metadata) return "";
+  const selected = {};
+  for (const key of TOOL_METADATA_KEYS) {
+    const value = metadata[key];
+    if (value === void 0) continue;
+    if (typeof value === "string") {
+      selected[key] = clipCompactText(value, 240);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      selected[key] = value.slice(0, 20).map(
+        (item) => typeof item === "string" ? clipCompactText(item, 180) : clipCompactText(JSON.stringify(item), 180)
+      );
+      continue;
+    }
+    selected[key] = value;
+  }
+  return Object.keys(selected).length > 0 ? clipCompactText(JSON.stringify(selected), 1200) : "";
+}
+function projectToolContentForProvider(args) {
+  const content = args.content;
   if (typeof content !== "string") return content;
-  if (content.length <= maxChars) return content;
-  const compact = compactWhitespace(content);
-  const clipped = compact.length > maxChars ? compact.slice(0, maxChars - 160) : compact;
-  return [
-    `[${label}]`,
-    `originalChars=${content.length}`,
-    clipped
-  ].join("\n");
+  const metadataText = compactToolMetadata(args.metadata);
+  const embeddedMetadataIndex = metadataText ? content.indexOf("\n\n[tool metadata]\n") : -1;
+  const contentForProjection = embeddedMetadataIndex >= 0 ? content.slice(0, embeddedMetadataIndex) : content;
+  const metadataSuffix = metadataText ? `
+
+[tool metadata]
+${metadataText}` : "";
+  if (embeddedMetadataIndex >= 0 && content.length <= args.maxChars) {
+    return content;
+  }
+  const headRatio = resolveToolOutputProfile(args.toolName).headRatio;
+  const diagnostic = (clippedLength) => `[${args.label}; originalChars=${content.length}; omittedChars=${Math.max(
+    0,
+    content.length - clippedLength
+  )}]`;
+  const suffix = (clippedLength) => [diagnostic(clippedLength), metadataSuffix.trimStart()].filter(Boolean).join("\n\n");
+  const initialBudget = Math.max(
+    1,
+    args.maxChars - suffix(contentForProjection.length).length - 2
+  );
+  let clipped = clipToolText(contentForProjection, initialBudget, headRatio);
+  const wasClipped = clipped.length < contentForProjection.trim().length;
+  const needsProjection = wasClipped || Boolean(metadataSuffix) || embeddedMetadataIndex >= 0;
+  if (!needsProjection) return args.content;
+  let projected = wasClipped || metadataSuffix ? `${clipped}
+
+${suffix(clipped.length)}` : clipped;
+  if (projected.length > args.maxChars) {
+    const boundedBudget = Math.max(
+      1,
+      args.maxChars - suffix(clipped.length).length - 2
+    );
+    clipped = clipToolText(contentForProjection, boundedBudget, headRatio);
+    projected = `${clipped}
+
+${suffix(clipped.length)}`;
+  }
+  return projected.length <= args.maxChars ? projected : projected.slice(0, args.maxChars);
 }
-function summarizeHistoricalToolContent(content) {
-  return summarizeToolContentForProvider(
+function summarizeHistoricalToolContent(content, toolName, metadata) {
+  const profile = resolveToolOutputProfile(toolName);
+  return projectToolContentForProvider({
     content,
-    MAX_HISTORICAL_TOOL_CONTENT_CHARS,
-    "historical tool result truncated for the next turn"
-  );
+    toolName,
+    metadata,
+    maxChars: Math.min(profile.maxChars, MAX_HISTORICAL_TOOL_CONTENT_CHARS),
+    label: "historical tool result truncated for the next turn"
+  });
 }
 function prepareMessagesForProviderCall(messages) {
   const paired = sanitizeToolCallPairing(messages);
-  return paired.map((message) => {
-    const sanitizedContent = message.content == null ? "" : typeof message.content === "string" ? message.content : message.content;
-    if (message.role !== "tool") {
+  let freshRunStart = paired.length;
+  while (freshRunStart > 0 && paired[freshRunStart - 1].role === "tool") {
+    freshRunStart -= 1;
+  }
+  let toolMessageCount = 0;
+  let rawToolContentChars = 0;
+  let projectedToolContentChars = 0;
+  let truncatedToolResults = 0;
+  const projected = paired.map((message, index) => {
+    const { context_reference: _contextReference, ...providerMessage } = message;
+    const sanitizedContent = providerMessage.content == null ? "" : typeof providerMessage.content === "string" ? providerMessage.content : providerMessage.content;
+    if (providerMessage.role !== "tool") {
       return {
-        ...message,
+        ...providerMessage,
         content: sanitizedContent
       };
     }
+    toolMessageCount += 1;
+    rawToolContentChars += contentCharCount(sanitizedContent);
+    const isFresh = index >= freshRunStart;
+    const maxChars = isFresh ? FRESH_TOOL_OUTPUT_MAX_CHARS : resolveToolOutputProfile(providerMessage.toolName).maxChars;
+    const projectedContent = projectToolContentForProvider({
+      content: sanitizedContent,
+      toolName: providerMessage.toolName,
+      metadata: providerMessage.tool_result_metadata,
+      maxChars,
+      label: "in-turn tool result truncated/projected before next provider call"
+    });
+    projectedToolContentChars += contentCharCount(projectedContent);
+    if (contentCharCount(projectedContent) < contentCharCount(sanitizedContent)) {
+      truncatedToolResults += 1;
+    }
     return {
-      ...message,
-      content: summarizeToolContentForProvider(
-        sanitizedContent,
-        MAX_IN_TURN_TOOL_CONTENT_CHARS,
-        "in-turn tool result truncated before next provider call"
-      )
+      ...providerMessage,
+      content: projectedContent
     };
   });
+  return {
+    messages: projected,
+    metrics: {
+      messageCount: projected.length,
+      contentChars: projected.reduce((total, message) => total + contentCharCount(message.content), 0),
+      toolMessageCount,
+      rawToolContentChars,
+      projectedToolContentChars,
+      truncatedToolResults,
+      stableContextChars: 0,
+      dynamicContextChars: 0
+    }
+  };
 }
-function prepareHistoryForNextTurn(history) {
+function prepareHistoryForNextTurn(history, contextReferenceResolver) {
   return history.map((message) => {
+    if (message.role === "user" && message.context_reference !== void 0 && contextReferenceResolver?.(message.context_reference)) {
+      return { ...message, content: message.context_reference };
+    }
     if (message.role !== "tool") return message;
     return {
       ...message,
-      content: summarizeHistoricalToolContent(message.content)
+      content: summarizeHistoricalToolContent(
+        message.content,
+        message.toolName,
+        message.tool_result_metadata
+      )
     };
   });
 }
@@ -578,25 +1012,33 @@ function buildMessages(args) {
   if (args.contextBlockScopes?.length) {
     const blocks2 = args.contextBlockScopes.filter((b) => b.content.trim());
     const stableParts = [args.prompt?.trim(), ...blocks2.filter((b) => b.cacheScope === "session").map((b) => b.content)].filter(Boolean);
-    const dynamicParts = blocks2.filter((b) => b.cacheScope === "turn").map((b) => b.content).filter(Boolean);
+    const dynamicParts = blocks2.filter((b) => b.cacheScope === "turn").map((b) => b.content).map((block) => block.trim()).filter(Boolean);
     const stableContent = stableParts.join("\n\n");
     const dynamicContent = dynamicParts.join("\n\n");
     const systemContent2 = dynamicContent ? `${stableContent}
 
 ${dynamicContent}` : stableContent;
-    return [
-      ...systemContent2 ? [{ role: "system", content: systemContent2 }] : [],
-      ...prepareHistoryForNextTurn(args.history),
-      { role: "user", content: args.input }
-    ];
+    return {
+      messages: [
+        ...systemContent2 ? [{ role: "system", content: systemContent2 }] : [],
+        ...prepareHistoryForNextTurn(args.history, args.contextReferenceResolver),
+        { role: "user", content: args.input }
+      ],
+      stableContextChars: stableContent.length,
+      dynamicContextChars: dynamicContent.length
+    };
   }
   const blocks = (args.contextBlocks ?? []).map((block) => block.trim()).filter(Boolean);
   const systemContent = [args.prompt?.trim(), ...blocks].filter(Boolean).join("\n\n");
-  return [
-    ...systemContent ? [{ role: "system", content: systemContent }] : [],
-    ...prepareHistoryForNextTurn(args.history),
-    { role: "user", content: args.input }
-  ];
+  return {
+    messages: [
+      ...systemContent ? [{ role: "system", content: systemContent }] : [],
+      ...prepareHistoryForNextTurn(args.history, args.contextReferenceResolver),
+      { role: "user", content: args.input }
+    ],
+    stableContextChars: (args.prompt?.trim() ?? "").length,
+    dynamicContextChars: blocks.join("\n\n").length
+  };
 }
 function mergeTurnUsage(current, next) {
   if (!next) return current;
@@ -619,6 +1061,24 @@ function mergeTurnUsage(current, next) {
     cache_creation_input_tokens: left.cacheMiss + right.cacheMiss
   };
 }
+function addOutOfBandUsage(turn, extra) {
+  if (!extra) return turn;
+  const num = (u, ...keys) => {
+    if (!u) return 0;
+    for (const k of keys) {
+      const v = Number(u[k]);
+      if (Number.isFinite(v) && v !== 0) return v;
+    }
+    return 0;
+  };
+  return {
+    ...turn ?? {},
+    input_tokens: num(turn, "input_tokens", "prompt_tokens") + num(extra, "input_tokens", "prompt_tokens"),
+    output_tokens: num(turn, "output_tokens", "completion_tokens") + num(extra, "output_tokens", "completion_tokens"),
+    cache_read_input_tokens: num(turn, "cache_read_input_tokens", "prompt_cache_hit_tokens") + num(extra, "cache_read_input_tokens", "prompt_cache_hit_tokens"),
+    cache_creation_input_tokens: num(turn, "cache_creation_input_tokens", "prompt_cache_miss_tokens") + num(extra, "cache_creation_input_tokens", "prompt_cache_miss_tokens")
+  };
+}
 function extractUserInputText(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -655,6 +1115,21 @@ async function persistFailedLocalTurn(args) {
     return args.input.continueDialogId;
   }
 }
+function applyPersistedTurnInput(messages, persistedInput, persistedInputReference) {
+  if (persistedInput === void 0 && persistedInputReference === void 0) {
+    return messages;
+  }
+  let replaced = false;
+  return messages.map((message) => {
+    if (replaced || message.role !== "user") return message;
+    replaced = true;
+    return {
+      ...message,
+      ...persistedInput !== void 0 ? { content: persistedInput } : {},
+      ...persistedInputReference !== void 0 ? { context_reference: persistedInputReference } : {}
+    };
+  });
+}
 async function runLocalAgentTurn(input) {
   const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
   if (!agentConfig) {
@@ -694,26 +1169,52 @@ async function runLocalAgentTurn(input) {
   const currentTimeScope = [
     { content: buildCurrentTimeBlock(/* @__PURE__ */ new Date(), void 0), cacheScope: "turn" }
   ];
+  const callerScopes = normalizeContextBlockScopes(
+    input.contextBlocks,
+    input.contextBlockScopes
+  );
   const mergedContextBlockScopes = [
     { content: identityBlock, cacheScope: "session" },
     ...guidanceScopes,
     ...currentTimeScope,
-    ...input.contextBlockScopes ?? []
+    ...callerScopes
   ];
-  const hasContextBlocks = (input.contextBlocks ?? []).some(
-    (block) => block.trim()
-  ) || mergedContextBlockScopes.some(
-    (block) => block.content.trim()
-  );
+  let resolvedProvider;
+  const resolveProviderOnce = async () => {
+    if (!resolvedProvider) {
+      resolvedProvider = await input.adapter.resolveProvider(agentConfig);
+    }
+    return resolvedProvider;
+  };
+  let compactionUsage;
+  try {
+    const compacted = await maybeAutoCompactLocalHistory({
+      adapter: input.adapter,
+      dialogId: input.continueDialogId,
+      history,
+      model: agentConfig.model,
+      resolveProvider: resolveProviderOnce
+    });
+    history = compacted.history;
+    compactionUsage = compacted.usage;
+  } catch (error) {
+    console.warn("[localLoop] auto-compaction unexpected error:", error);
+  }
+  const trimmedHistory = trimHistoryToContextBudget(history, agentConfig.model);
+  if (trimmedHistory.droppedCount > 0) {
+    history = trimmedHistory.history;
+  }
+  const hasContextBlocks = callerScopes.some((block) => block.content.trim()) || mergedContextBlockScopes.some((block) => block.content.trim());
   const promptMessageCount = agentConfig.prompt?.trim() || hasContextBlocks ? 1 : 0;
   const turnStartIndex = promptMessageCount + history.length;
-  const messages = buildMessages({
+  const builtMessages = buildMessages({
     prompt: agentConfig.prompt,
-    contextBlocks: input.contextBlocks,
     contextBlockScopes: mergedContextBlockScopes,
     history,
-    input: input.input
+    input: input.input,
+    contextReferenceResolver: input.adapter.host === "cli" ? input.contextReferenceResolver : void 0
   });
+  const messages = builtMessages.messages;
   const supportsImages = resolveAgentImageInputSupport({
     apiSource: agentConfig.apiSource,
     provider: agentConfig.provider,
@@ -732,12 +1233,13 @@ async function runLocalAgentTurn(input) {
   let skipFinalAppend = false;
   let partialContent = "";
   try {
-    const provider = await input.adapter.resolveProvider(agentConfig);
+    const provider = await resolveProviderOnce();
     while (true) {
       partialContent = "";
       throwIfAborted(input);
+      const preparedMessages = prepareMessagesForProviderCall(messages);
       const baseRequestMessages = filterImagePartsFromMessages(
-        prepareMessagesForProviderCall(messages),
+        preparedMessages.messages,
         supportsImages
       );
       if (!supportsImages && !imageDowngradeNotified && messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p?.type === "image_url"))) {
@@ -749,6 +1251,16 @@ async function runLocalAgentTurn(input) {
         });
       }
       const requestMessages = emptyAssistantRepairPending ? [...baseRequestMessages, { role: "user", content: EMPTY_ASSISTANT_REPAIR_PROMPT }] : baseRequestMessages;
+      const contextMetrics = {
+        ...preparedMessages.metrics,
+        messageCount: requestMessages.length,
+        contentChars: requestMessages.reduce(
+          (total, message) => total + contentCharCount(message.content),
+          0
+        ),
+        stableContextChars: builtMessages.stableContextChars,
+        dynamicContextChars: builtMessages.dynamicContextChars
+      };
       emptyAssistantRepairPending = false;
       result = await runCompleteWithTimeout({
         provider,
@@ -765,7 +1277,8 @@ async function runLocalAgentTurn(input) {
         },
         timeoutMs: resolveLlmRequestTimeoutMs(input),
         round,
-        input
+        input,
+        context: contextMetrics
       });
       turnUsage = mergeTurnUsage(turnUsage, result.usage);
       const toolCalls = result.tool_calls ?? [];
@@ -835,13 +1348,14 @@ async function runLocalAgentTurn(input) {
           argumentsPreview: summarizeToolArguments(toolName, toolCall.function.arguments)
         });
         try {
-          toolResult = await input.adapter.executeTool({
+          const executePromise = input.adapter.executeTool({
             id: toolCall.id,
             name: toolName,
             arguments: toolCall.function.arguments,
             ...userInputText ? { userInput: userInputText } : {},
             ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
           });
+          toolResult = await raceWithAbort(input, executePromise, toolName);
           const actionGate = buildActionGate({
             toolName,
             toolCallId: toolCall.id,
@@ -866,6 +1380,9 @@ async function runLocalAgentTurn(input) {
           });
         } catch (error) {
           emitLoopEvent(input, { kind: "tool-end", name: toolName, atMs: Date.now(), ok: false });
+          if (error && typeof error === "object" && error.code === LOCAL_TURN_ABORTED_CODE) {
+            throw error;
+          }
           if (!shouldReturnToolExecutionErrors(input.adapter)) throw error;
           emitToolEvent(input, {
             type: "tool-error",
@@ -903,7 +1420,11 @@ async function runLocalAgentTurn(input) {
     loopError = error;
   }
   if (loopError) {
-    const turnMessages2 = messages.slice(turnStartIndex);
+    const turnMessages2 = applyPersistedTurnInput(
+      messages.slice(turnStartIndex),
+      input.persistedInput,
+      input.persistedInputReference
+    );
     const dialogId = await persistFailedLocalTurn({
       adapter: input.adapter,
       agentKey: agentConfig.key,
@@ -927,7 +1448,11 @@ async function runLocalAgentTurn(input) {
       ...result.reasoning_content ? { reasoning_content: result.reasoning_content } : {}
     });
   }
-  const turnMessages = messages.slice(turnStartIndex);
+  const turnMessages = applyPersistedTurnInput(
+    messages.slice(turnStartIndex),
+    input.persistedInput,
+    input.persistedInputReference
+  );
   const saved = await input.adapter.saveTurn({
     agentKey: agentConfig.key,
     messages: turnMessages,
@@ -945,7 +1470,10 @@ async function runLocalAgentTurn(input) {
   });
   return {
     ...result,
-    ...turnUsage ? { usage: turnUsage } : {},
+    ...(() => {
+      const merged = addOutOfBandUsage(turnUsage, compactionUsage);
+      return merged ? { usage: merged } : {};
+    })(),
     ...toolCallCount > 0 ? { toolCallCount } : {},
     ...agentConfig.toolSurface ? { runtimeToolSurface: agentConfig.toolSurface } : {},
     // 透出最后一轮 provider 调用的 finish_reason；多轮工具循环里只有最后一轮收尾状态有意义。
@@ -961,6 +1489,7 @@ export {
   parseToolArgumentsJson,
   summarizeToolArguments,
   resolveAgentImageInputSupport,
+  projectToolMessageContent,
   LOCAL_AGENT_CONFIG_MISSING_CODE,
   EMPTY_ASSISTANT_REPAIR_PROMPT,
   LOCAL_TURN_ABORTED_CODE,