nolo-cli 0.16.0-alpha.2 → 0.16.0-alpha.21

package/{chunk-QLFCNUVQ.js → chunk-RUTSBLDM.js}

@@ -3,12 +3,11 @@ import {
   refreshAntigravityOAuthToken,
   refreshOpenAiCodexToken,
   refreshXaiOAuthToken
-} from "./chunk-EHLHSX7R.js";
+} from "./chunk-UB4RYYNQ.js";
 import {
   buildLocalAgentLookupKeys,
-  normalizeAgentHandle,
   shouldReadAgentKeyRemotely
-} from "./chunk-QZVGMD5F.js";
+} from "./chunk-BE2GNT5E.js";
 import {
   LOCAL_CODEX_AGENT_ID,
   LOCAL_CODEX_AGENT_KEY,
@@ -17,17 +16,17 @@ import {
 } from "./chunk-VHBWHNVT.js";
 import {
   inferCaptureIntent
-} from "./chunk-WNLPAOIT.js";
+} from "./chunk-MVQ4TBSD.js";
 import {
   inlineImageUrlsForCustomProvider,
   prepareTools
-} from "./chunk-WRN5EQT7.js";
+} from "./chunk-L2RRMXNJ.js";
 import {
   getAntigravityUserAgent,
   isAntigravityOAuthAgent,
   readAntigravityProjectId,
   resolveAntigravityCloudCodeBaseUrl
-} from "./chunk-ISYE6GZB.js";
+} from "./chunk-L6NVTGI7.js";
 import {
   FORCED_TOOLS,
   addDefaultLightWebToolsForConfiguredAgents,
@@ -36,18 +35,13 @@ import {
   applyDisabledTools,
   applySystemBuiltinSkillFilter,
   expandEnabledPacks,
-  formatListRunsCard,
-  formatNotFoundRunCard,
-  formatStartRunCard,
-  formatStatusRunCard,
-  formatStopRunCard,
   readXPostFunc,
   readXPostFunctionSchema,
   readXhsProfileFunc,
   readXhsProfileFunctionSchema,
   rememberMemoryFunctionSchema,
   resolveEffectiveEnabledPacks
-} from "./chunk-VE6XMVKG.js";
+} from "./chunk-J67FKTTY.js";
 import {
   createDrainExhaustedResponse,
   isCoreDrainingBody,
@@ -57,15 +51,18 @@ import {
 import {
   normalizeDialogTitle
 } from "./chunk-OWOHNGCN.js";
+import {
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-WJRJDX2W.js";
 import {
   prepareTokenUsageData
-} from "./chunk-YNHQIXX5.js";
+} from "./chunk-UIOYWBU7.js";
 import {
   BUILTIN_TITLE_LLM_CONFIG
-} from "./chunk-V2J635L5.js";
+} from "./chunk-XOIF2TNF.js";
 import {
   fetchServerSyncedCredential
-} from "./chunk-OQMPU2ML.js";
+} from "./chunk-5PGGCJGV.js";
 import {
   buildAgentRuntimeDialogWritePlan,
   buildLocalWorkspaceOpenAiTools,
@@ -76,37 +73,39 @@ import {
   executeLocalToolWithPolicy,
   executeOpenAiCompatibleChatCompletion,
   parseSseDataLineJson,
+  parseSseDataLineObject,
   readOpenAiCompatibleSseCompletion,
   resolveOpenAiCompatibleProviderConfig
-} from "./chunk-YC3DJILJ.js";
+} from "./chunk-PUSK7HXJ.js";
 import {
   buildPlatformChatCompletionRequest,
   canUsePlatformChatProvider,
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
   readSseDataValues,
-  resolveLegacyDeepSeekProxyChatFallback,
   resolvePlatformChatProviderConfig,
   shouldUsePlatformChatProvider
-} from "./chunk-WA6KZL5V.js";
+} from "./chunk-AAODAAUQ.js";
 import {
   resolveAgentRuntimeConfigFromRecord
 } from "./chunk-OIQPORYI.js";
 import {
-  parseToolArgumentsJson,
   summarizeToolArguments
-} from "./chunk-6MHDWKOT.js";
+} from "./chunk-VVKQFITN.js";
+import {
+  convertMessagesToResponsesInput,
+  toResponsesTools
+} from "./chunk-KFEVY3ST.js";
 import {
   resolvePlatformAuthToken
-} from "./chunk-HRQCKQA5.js";
+} from "./chunk-MUCU6ATG.js";
 import {
   buildLoadSkillExecutor,
   buildNoloWorkspaceCliToolExecutors,
   buildNoloWorkspaceOpenAiTools,
-  canonicalizeToolNames,
   parseNoloWorkspaceToolArguments,
   resolveRuntimeToolSurfaceForAgent
-} from "./chunk-B4KT7RN2.js";
+} from "./chunk-DKZFOK24.js";
 import {
   clipCompactText
 } from "./chunk-5MMAK75Q.js";
@@ -122,6 +121,15 @@ import {
   readOAuthCredential,
   resolveFreshAccessToken
 } from "./chunk-JZPBVBIY.js";
+import {
+  isAdaptiveThinkingModelId
+} from "./chunk-HQPG2PIV.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-ZZ2MH7LE.js";
 import {
   compactWhitespace
 } from "./chunk-DWLEOOGR.js";
@@ -129,22 +137,29 @@ import {
   checkStaleRun,
   finalizeRunRecord,
   findRunRecord,
-  listRunRecords,
+  gcRunRecords,
+  queryRunRecords,
   spawnLocalBackgroundRun
-} from "./chunk-MYMMNKYL.js";
+} from "./chunk-VNAEBGDK.js";
+import {
+  TASK_PREVIEW_MAX,
+  formatListRunsCard,
+  formatNotFoundRunCard,
+  formatStartRunCard,
+  formatStatusRunCard,
+  formatStopRunCard,
+  isAgentNameFallback,
+  isAgentRunTerminalStatus,
+  resolveRunLabel,
+  shortRunId
+} from "./chunk-FQZZLA3C.js";
 import {
   CliProviderQuotaError,
   executeCli
-} from "./chunk-CMKUBIGW.js";
+} from "./chunk-X7W4TNB4.js";
 import {
   buildCliPrompt
 } from "./chunk-ATNTHIZI.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
-import {
-  getDefaultCliLocalRuntimeDb
-} from "./chunk-H33743XH.js";
 import {
   isCompiledBinary,
   parseUserIdFromAuthToken
@@ -152,28 +167,27 @@ import {
 import {
   DEFAULT_NOLO_SERVER_URL
 } from "./chunk-OLZBQWZU.js";
-import {
-  asRecordOrEmpty
-} from "./chunk-KX6YBIHG.js";
 import {
   createTokenKey,
   createUserKey,
   dialogMessageRange
-} from "./chunk-O4BU24WZ.js";
+} from "./chunk-6Y7A3OQQ.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
 import {
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";
 import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
 import {
   BUILTIN_NOLO_AGENT_KEY,
   PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY,
   PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
   PUBLIC_GLM_52_AGENT_KEY,
-  PUBLIC_KIMI_K26_IMAGE_AGENT_KEY,
-  PUBLIC_KIMI_K27_CODING_AGENT_KEY
-} from "./chunk-VPTJB4HM.js";
+  PUBLIC_KIMI_K26_IMAGE_AGENT_KEY
+} from "./chunk-3ND52WIL.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -263,6 +277,10 @@ var STRINGS = {
     en: "Cleared current dialog messages.",
     zh: "\u5DF2\u6E05\u9664\u5F53\u524D\u5BF9\u8BDD\u6D88\u606F\u3002"
   },
+  persistentProcessesLeft: {
+    en: "{0} persistent process(es) left running in the background.",
+    zh: "\u4ECD\u6709 {0} \u4E2A\u5E38\u9A7B\u540E\u53F0\u8FDB\u7A0B\u5728\u540E\u53F0\u7EE7\u7EED\u8FD0\u884C\u3002"
+  },
   clearNoDialog: {
     en: "No current dialog messages to clear.",
     zh: "\u5F53\u524D\u6CA1\u6709\u53EF\u6E05\u9664\u7684\u5BF9\u8BDD\u6D88\u606F\u3002"
@@ -463,6 +481,10 @@ var STRINGS = {
     en: "Run stopped",
     zh: "\u8FD0\u884C\u5DF2\u505C\u6B62"
   },
+  runFinishedLabel: {
+    en: "Run finished",
+    zh: "\u8FD0\u884C\u5DF2\u7ED3\u675F"
+  },
   runLogTailLabel: {
     en: "Log tail:",
     zh: "\u65E5\u5FD7\u5C3E\u90E8\uFF1A"
@@ -497,6 +519,10 @@ var STRINGS = {
     en: "selected",
     zh: "\u5DF2\u9009"
   },
+  dialogMultiSelectRequired: {
+    en: "Pick at least one option to submit",
+    zh: "\u81F3\u5C11\u9009\u62E9\u4E00\u9879\u624D\u80FD\u63D0\u4EA4"
+  },
   dialogConfirmHint: {
     en: "(\u2191\u2193 move \xB7 Enter choose \xB7 Esc cancel)",
     zh: "\uFF08\u2191\u2193 \u79FB\u52A8 \xB7 Enter \u9009\u62E9 \xB7 Esc \u53D6\u6D88\uFF09"
@@ -537,7 +563,7 @@ var STRINGS = {
     en: "abort the operation",
     zh: "\u4E2D\u6B62\u64CD\u4F5C"
   },
-  // --- Ask choice (ui_ask_choice) ------------------------------------------
+  // --- Ask choice (ask_user) ------------------------------------------
   askChoiceTitle: {
     en: "question",
     zh: "\u95EE\u9898"
@@ -928,11 +954,191 @@ function agentRunCardLabels() {
     runStatus: t("runStatusLabel"),
     runStarted: t("runStartedLabel"),
     runStopped: t("runStoppedLabel"),
+    runFinished: t("runFinishedLabel"),
     logTail: t("runLogTailLabel"),
     runs: (count) => t("runsListLabel", String(count))
   };
 }
 
+// packages/ai/tools/agent/quotaCircuitBreaker.ts
+var QUOTA_ERROR_PATTERNS = [
+  /429/,
+  /quota/i,
+  /rate\s*limit/i,
+  /too\s*many\s*requests/i,
+  /额度/,
+  /上限/,
+  /用尽/,
+  /CliProviderQuotaError/i
+];
+var AGENT_NOT_FOUND_PATTERNS = [
+  /agent[^\n]{0,80}not\s+found/i,
+  /agent[^\n]{0,80}not\s+exist/i,
+  /agent[^\n]{0,80}不存在/i,
+  /agent[^\n]{0,80}未找到/i,
+  /AGENT_NOT_FOUND/
+];
+var AUTH_ERROR_PATTERNS = [
+  /401/,
+  /403/,
+  /unauthori[sz]ed/i,
+  /authentication\s+failed/i,
+  /invalid\s+(api[-\s]?key|token|credential)/i,
+  /api[-\s]?key\s+(invalid|missing|not\s+found)/i,
+  /token\s*(invalid|expired|失效|过期)/i,
+  /未授权/,
+  /认证失败/,
+  /凭证/
+];
+var NETWORK_ERROR_PATTERNS = [
+  /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|EHOSTUNREACH|EPIPE/i,
+  /getaddrinfo|DNS\s+(error|fail)/i,
+  /fetch\s+failed/i,
+  /network\s+(error|unreachable|down|disconnected)/i,
+  /socket\s+(hang|closed|error)/i,
+  /连接失败/,
+  /网络错误|网络异常|无法连接/
+];
+function findActiveBreaker(now, table, target) {
+  if (!Number.isFinite(now)) return void 0;
+  for (const entry of table) {
+    if (entry.target !== target) continue;
+    if (typeof entry.until === "number" && entry.until > now) return entry;
+  }
+  return void 0;
+}
+function isCliProviderQuotaErrorShape(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  return e.name === "CliProviderQuotaError" || typeof e.message === "string" && e.message.startsWith("[QUOTA_LIMITED:");
+}
+function isQuotaExhaustedError(error) {
+  if (!error) return false;
+  if (isCliProviderQuotaErrorShape(error)) return true;
+  if (error instanceof Error) {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error.message));
+  }
+  if (typeof error === "string") {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error));
+  }
+  const maybeStatus = error.status;
+  if (typeof maybeStatus === "number" && maybeStatus === 429) return true;
+  const maybeStatusCode = error.statusCode;
+  if (typeof maybeStatusCode === "number" && maybeStatusCode === 429) return true;
+  return false;
+}
+function isAgentNotFoundError(error) {
+  if (!error) return false;
+  const e = error;
+  if (e.code === "AGENT_NOT_FOUND") return true;
+  const message = typeof e.message === "string" ? e.message : typeof error === "string" ? error : "";
+  if (AGENT_NOT_FOUND_PATTERNS.some((pattern) => pattern.test(message))) return true;
+  if ((e.status === 404 || e.statusCode === 404) && /agent|不存在|未找到/i.test(message)) {
+    return true;
+  }
+  return false;
+}
+function extractMessage(error) {
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object") {
+    const m = error.message;
+    return typeof m === "string" ? m : "";
+  }
+  return "";
+}
+function extractStatus(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const e = error;
+  const s = typeof e.status === "number" ? e.status : void 0;
+  const sc = typeof e.statusCode === "number" ? e.statusCode : void 0;
+  return s ?? sc;
+}
+function parseResetsInMs(text) {
+  if (!text) return void 0;
+  const unitMs = (n, unit) => {
+    if (/^d/.test(unit)) return n * 24 * 3600 * 1e3;
+    if (/^h/.test(unit)) return n * 3600 * 1e3;
+    if (/^m/.test(unit)) return n * 60 * 1e3;
+    if (/^s/.test(unit)) return n * 1e3;
+    return NaN;
+  };
+  const re = /(\d+)\s*(d(?:ay|ays)?|h(?:r|rs|our|ours)?|m(?:in|ins|inute|inutes)?|s(?:ec|ecs|econd|econds)?)/gi;
+  let totalMs = 0;
+  let matched = false;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const ms = unitMs(Number(m[1]), m[2]);
+    if (!Number.isFinite(ms)) continue;
+    totalMs += ms;
+    matched = true;
+  }
+  return matched ? totalMs : void 0;
+}
+function extractProvider(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const p = error.provider;
+  if (typeof p === "string" && p.length > 0) return p;
+  const message = extractMessage(error);
+  const tag = /\[QUOTA_LIMITED:([^\]]+)\]/i.exec(message);
+  if (tag?.[1]) return tag[1];
+  return void 0;
+}
+function extractRetryAfterHeader(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const headers = error.headers;
+  if (!headers || typeof headers !== "object") return void 0;
+  const raw = headers["retry-after"];
+  if (typeof raw !== "string" && typeof raw !== "number") return void 0;
+  const secs = Number(raw);
+  return Number.isFinite(secs) && secs > 0 ? secs * 1e3 : void 0;
+}
+function classifyRunFailure(error) {
+  const message = extractMessage(error);
+  const status = extractStatus(error);
+  const retryAfterMs = extractRetryAfterHeader(error) ?? parseResetsInMs(message);
+  if (isQuotaExhaustedError(error)) {
+    return {
+      reason: "quota",
+      provider: extractProvider(error),
+      // 纯函数不取时钟：resetsAt 由调用方用 now + retryAfterMs 计算后补齐
+      retryAfterMs,
+      message
+    };
+  }
+  if (isAgentNotFoundError(error)) {
+    return { reason: "agent-not-found", message };
+  }
+  if (isAuthError(error)) {
+    return { reason: "auth", message };
+  }
+  if (isNetworkError(error)) {
+    return { reason: "network", message };
+  }
+  return { reason: "other", message };
+}
+function isAuthError(error) {
+  const message = extractMessage(error);
+  const status = extractStatus(error);
+  if (status === 401 || status === 403) return true;
+  return AUTH_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+function isNetworkError(error) {
+  const message = extractMessage(error);
+  return NETWORK_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+var DEFAULT_QUOTA_BREAKER_MS = 6 * 3600 * 1e3;
+var DEFAULT_AGENT_NOT_FOUND_BREAKER_MS = 15 * 60 * 1e3;
+function buildBreakerEntry(now, target, kind, retryAfterMs) {
+  const ttl = kind === "quota" ? typeof retryAfterMs === "number" && retryAfterMs > 0 ? retryAfterMs : DEFAULT_QUOTA_BREAKER_MS : DEFAULT_AGENT_NOT_FOUND_BREAKER_MS;
+  return {
+    target,
+    kind,
+    until: now + ttl,
+    ...kind === "quota" && typeof retryAfterMs === "number" ? { resetsAt: now + retryAfterMs } : {}
+  };
+}
+
 // packages/cli/client/localRuntimeDiagnostics.ts
 import { ulid } from "ulid";
 var preparedAgentRuntimeCache = /* @__PURE__ */ new Map();
@@ -972,7 +1178,7 @@ function summarizeOpenAiToolNames(tools) {
 }
 
 // packages/cli/client/localRuntimeAdapter.ts
-import { dirname, extname, join } from "node:path";
+import { dirname as dirname2, extname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/core/summarizeEndpoint.ts
@@ -1123,6 +1329,11 @@ async function fetchWithTransientRetry(fetchImpl, input, init, options = {}) {
         const attemptBudget = coreDraining ? coreDrainingMaxAttempts : maxAttempts;
         if (attempt < attemptBudget) {
           const delayMs = await resolveRetryAfterMs(response, attempt);
+          options.onRetry?.({
+            attempt: attempt + 1,
+            maxAttempts: attemptBudget,
+            delayMs
+          });
           await (options.sleep ?? defaultSleep)(delayMs);
           continue;
         }
@@ -1136,7 +1347,13 @@ async function fetchWithTransientRetry(fetchImpl, input, init, options = {}) {
       if (!isTransientFetchError(error)) throw error;
       lastError = error;
       if (attempt < maxAttempts) {
-        await (options.sleep ?? defaultSleep)(transientFetchRetryDelayMs(attempt));
+        const delayMs = transientFetchRetryDelayMs(attempt);
+        options.onRetry?.({
+          attempt: attempt + 1,
+          maxAttempts,
+          delayMs
+        });
+        await (options.sleep ?? defaultSleep)(delayMs);
       }
     }
   }
@@ -1466,14 +1683,14 @@ var BUILTIN_PLATFORM_AGENT_CONFIGS = {
   [PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY]: {
     key: PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
     name: "DeepSeek V4 Pro",
-    provider: "deepseek",
+    provider: "nolo",
     model: "deepseek-v4-pro",
     apiSource: "platform",
     useServerProxy: true,
     rawRecord: {
       dbKey: PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
       isPublic: true,
-      provider: "deepseek",
+      provider: "nolo",
       model: "deepseek-v4-pro",
       apiSource: "platform",
       useServerProxy: true
@@ -1511,22 +1728,6 @@ var BUILTIN_PLATFORM_AGENT_CONFIGS = {
       useServerProxy: true
     }
   },
-  [PUBLIC_KIMI_K27_CODING_AGENT_KEY]: {
-    key: PUBLIC_KIMI_K27_CODING_AGENT_KEY,
-    name: "Kimi K2.7 Coding",
-    provider: "nolo",
-    model: "kimi-k2.7-code",
-    apiSource: "platform",
-    useServerProxy: true,
-    rawRecord: {
-      dbKey: PUBLIC_KIMI_K27_CODING_AGENT_KEY,
-      isPublic: true,
-      provider: "nolo",
-      model: "kimi-k2.7-code",
-      apiSource: "platform",
-      useServerProxy: true
-    }
-  },
   [BUILTIN_NOLO_AGENT_KEY]: {
     key: BUILTIN_NOLO_AGENT_KEY,
     name: "Nolo",
@@ -1599,23 +1800,6 @@ async function readAgentFromStore(args) {
     if (!record || typeof record !== "object") continue;
     return resolveAgentRuntimeConfigFromRecord(key, record);
   }
-  const normalizedRef = normalizeAgentHandle(args.agentRef);
-  if (!normalizedRef) {
-    return resolveBuiltinPlatformAgentConfig(args.agentRef);
-  }
-  try {
-    const iterator = args.store.iterator({
-      gte: "agent-",
-      lte: "agent-\uFFFF"
-    });
-    for await (const [key, record] of iterator) {
-      if (!record || typeof record !== "object") continue;
-      const handle = normalizeAgentHandle(record.handle);
-      if (handle !== normalizedRef) continue;
-      return resolveAgentRuntimeConfigFromRecord(key, record);
-    }
-  } catch {
-  }
   return resolveBuiltinPlatformAgentConfig(args.agentRef);
 }
 async function readDialogMessages(args) {
@@ -1774,7 +1958,10 @@ var LOCAL_SERVER_WEB_TOOL_NAMES = ["fetchWebpage", "exa_search"];
 var LOCAL_SERVER_WEB_TOOL_NAME_SET = new Set(
   LOCAL_SERVER_WEB_TOOL_NAMES
 );
-var LOCAL_SERVER_MEMORY_TOOL_NAMES = ["rememberMemory"];
+var LOCAL_SERVER_MEMORY_TOOL_NAMES = [
+  "queryMemory",
+  "rememberMemory"
+];
 var LOCAL_SERVER_MEMORY_TOOL_NAME_SET = new Set(
   LOCAL_SERVER_MEMORY_TOOL_NAMES
 );
@@ -2006,6 +2193,25 @@ function buildServerPlatformToolExecutors(args) {
       }
     ])
   );
+  const queryMemory = async (call) => {
+    const parsed = parseNoloWorkspaceToolArguments(call.arguments);
+    const query = typeof parsed.query === "string" ? parsed.query.trim() : "";
+    if (!query) {
+      return {
+        content: JSON.stringify({ error: "queryMemory \u9700\u8981\u975E\u7A7A query\u3002" }),
+        metadata: { serverPlatformTool: true, memoryRead: false }
+      };
+    }
+    const body = { userInput: query };
+    if (args.agentKey) body.agentKey = args.agentKey;
+    const raw = await postServer("/api/memory/query", body, {
+      retryTransient: true
+    });
+    return {
+      content: raw,
+      metadata: { serverPlatformTool: true, memoryRead: true }
+    };
+  };
   const rememberMemory = async (call) => {
     const parsed = parseNoloWorkspaceToolArguments(call.arguments);
     const content = typeof parsed.content === "string" ? parsed.content.trim() : "";
@@ -2032,11 +2238,368 @@ function buildServerPlatformToolExecutors(args) {
       metadata: { serverPlatformTool: true, memoryWrite: true }
     };
   };
-  return { ...tableExecutors, ...webExecutors, rememberMemory };
+  return { ...tableExecutors, ...webExecutors, queryMemory, rememberMemory };
+}
+
+// packages/cli/client/cliAgentRunToolExecutors.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// packages/cli/client/agentRunSnapshot.ts
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readLogLines(parsed) {
+  if (Array.isArray(parsed.logLines)) return parsed.logLines;
+  const tail = readString(parsed.logTail);
+  return tail ? tail.split("\n") : void 0;
+}
+function readTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  return void 0;
+}
+function readToolNames(value) {
+  if (!Array.isArray(value)) return void 0;
+  const names = value.filter((n) => typeof n === "string" && Boolean(n.trim()));
+  return names.length > 0 ? names : void 0;
+}
+function buildSnapshot(parsed, event) {
+  const runId = readString(parsed.runId) ?? readString(event.metadata?.runId) ?? "";
+  const label = resolveRunLabel({
+    agentName: parsed.agentName,
+    name: parsed.name,
+    agentKey: parsed.agentKey
+  });
+  const logLines = readLogLines(parsed);
+  const taskPreview = readString(parsed.taskPreview);
+  const lastToolNames = readToolNames(parsed.lastToolNames);
+  const lastAssistantText = readString(parsed.lastAssistantText);
+  const errorMessage = readString(parsed.errorMessage);
+  const startedAt = readTimestamp(parsed.startedAt);
+  const finishedAt = readTimestamp(parsed.finishedAt) ?? readTimestamp(parsed.endedAt);
+  return {
+    runId,
+    status: readString(parsed.status) ?? "running",
+    // The literal `agent` fallback is dropped here rather than at each render
+    // site: an unnamed run should render no name row, not the word "agent".
+    ...isAgentNameFallback(label) ? {} : { agentName: label },
+    ...taskPreview ? { taskPreview } : {},
+    ...typeof parsed.toolCallCount === "number" && Number.isFinite(parsed.toolCallCount) ? { toolCallCount: parsed.toolCallCount } : {},
+    ...lastToolNames ? { lastToolNames } : {},
+    ...lastAssistantText ? { lastAssistantText } : {},
+    ...errorMessage ? { errorMessage } : {},
+    ...startedAt !== void 0 ? { startedAt } : {},
+    ...finishedAt !== void 0 ? { finishedAt } : {},
+    ...logLines ? { logLines } : {},
+    logKey: logLines && logLines.length > 0 ? logLines.join("\n") : ""
+  };
+}
+var STOP_STATUSES = /* @__PURE__ */ new Set(["killed", "cancelled", "cancelling"]);
+function parseAgentRunEvent(event) {
+  if (event.type !== "tool-result") return null;
+  if (event.toolName !== "startAgentRun" && event.toolName !== "controlAgentRun") {
+    return null;
+  }
+  const raw = typeof event.content === "string" ? event.content.trim() : "";
+  if (!raw.startsWith("{")) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (Array.isArray(parsed.runs)) return null;
+  const snapshot = buildSnapshot(parsed, event);
+  const status = readString(parsed.status);
+  if (event.toolName === "startAgentRun") {
+    if (!snapshot.runId) return null;
+    return { kind: "start", snapshot };
+  }
+  if (parsed.found === false || status === "not_found") {
+    return { kind: "gone", snapshot: { ...snapshot, status: "not_found" } };
+  }
+  if (status && STOP_STATUSES.has(status)) {
+    return { kind: "stop", snapshot };
+  }
+  if (!status) return null;
+  if (!snapshot.runId) return null;
+  return { kind: "status", snapshot };
+}
+
+// packages/ai/tools/agent/batchAggregation.ts
+var DEFAULT_BATCH_TIMEOUT_MS = 30 * 60 * 1e3;
+var MAX_ERROR_SUMMARY_CHARS = 120;
+var MAX_FAILURE_LINES = 10;
+function isFailureStatus(status) {
+  return isAgentRunTerminalStatus(status) && status !== "done";
+}
+function isOrphanedStatus(status) {
+  return status === "orphaned";
+}
+function toEpochMs(iso) {
+  if (!iso) return void 0;
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? ms : void 0;
+}
+function isOverTimeout(run, nowMs, timeoutMs) {
+  const startedMs = toEpochMs(run.startedAt);
+  if (startedMs === void 0) return false;
+  return nowMs - startedMs >= timeoutMs;
+}
+function truncateErrorSummary(text, max = MAX_ERROR_SUMMARY_CHARS) {
+  if (!text) return "";
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= max) return collapsed;
+  return `${collapsed.slice(0, max - 1)}\u2026`;
+}
+function formatFailureLine(run) {
+  const label = shortRunId(run.runId);
+  const agent = run.agentName ? ` (${run.agentName})` : "";
+  const error = truncateErrorSummary(run.errorSummary);
+  return error ? `\u5931\u8D25: ${label}${agent} \u2014 ${error}` : `\u5931\u8D25: ${label}${agent}`;
+}
+function formatBatchSummary(batchId, counts, runs, reason) {
+  const failures = runs.filter((r) => isFailureStatus(r.status));
+  const unfinished = runs.filter((r) => !isAgentRunTerminalStatus(r.status));
+  if (reason === "timeout") {
+    const lines2 = [
+      `\u6279\u6B21 ${batchId}: \u8D85\u65F6\u672A\u6536\u655B \u2014 ${counts.running} \u4E2A\u672A\u5B8C\u6210`
+    ];
+    for (const run of unfinished.slice(0, MAX_FAILURE_LINES)) {
+      const agent = run.agentName ? ` (${run.agentName})` : "";
+      lines2.push(`\u672A\u5B8C\u6210: ${shortRunId(run.runId)}${agent}`);
+    }
+    const rest2 = unfinished.length - MAX_FAILURE_LINES;
+    if (rest2 > 0) lines2.push(`\u2026 \u53CA\u53E6\u5916 ${rest2} \u4E2A\u672A\u5B8C\u6210`);
+    return lines2.join("\n");
+  }
+  const tail = counts.running > 0 ? `, ${counts.running} \u4ECD\u5728\u8DD1` : "";
+  const lines = [
+    `\u6279\u6B21 ${batchId}: ${counts.success + counts.failed}/${counts.total} \u5B8C\u6210 \u2014 ${counts.success} \u6210\u529F, ${counts.failed} \u5931\u8D25${tail}`
+  ];
+  for (const run of failures.slice(0, MAX_FAILURE_LINES)) {
+    lines.push(formatFailureLine(run));
+  }
+  const rest = failures.length - MAX_FAILURE_LINES;
+  if (rest > 0) lines.push(`\u2026 \u53CA\u53E6\u5916 ${rest} \u4E2A\u5931\u8D25`);
+  return lines.join("\n");
+}
+function aggregateBatch(input) {
+  const { batchId, runs, now } = input;
+  const timeoutMs = input.timeoutMs ?? DEFAULT_BATCH_TIMEOUT_MS;
+  const notified = new Set(input.notifiedReasons ?? []);
+  const nowMs = toEpochMs(now) ?? 0;
+  let success = 0;
+  let failed = 0;
+  let orphaned = 0;
+  let running = 0;
+  const unfinished = [];
+  let timedOut = false;
+  for (const run of runs) {
+    if (isAgentRunTerminalStatus(run.status)) {
+      if (run.status === "done") success += 1;
+      else {
+        failed += 1;
+        if (isOrphanedStatus(run.status)) orphaned += 1;
+      }
+    } else {
+      running += 1;
+      unfinished.push(run.runId);
+      if (isOverTimeout(run, nowMs, timeoutMs)) timedOut = true;
+    }
+  }
+  const converged = running === 0;
+  let newWakeReasons = [];
+  if (failed > 0 && !notified.has("failure")) {
+    newWakeReasons = ["failure"];
+  } else if (converged && !notified.has("converged")) {
+    newWakeReasons = ["converged"];
+  } else if (timedOut && !notified.has("timeout")) {
+    newWakeReasons = ["timeout"];
+  }
+  const counts = {
+    total: runs.length,
+    success,
+    failed,
+    orphaned,
+    running
+  };
+  const summary = newWakeReasons.length > 0 ? formatBatchSummary(batchId, counts, runs, newWakeReasons[0]) : "";
+  return {
+    batchId,
+    converged,
+    timedOut,
+    counts,
+    newWakeReasons,
+    unfinished,
+    summary
+  };
+}
+
+// packages/ai/tools/agent/runtimeTodo.ts
+var TODO_REVIEW_BLOCK = "BLOCK";
+function deriveTodoStatus(input) {
+  const { todo, runs } = input;
+  if (todo.status === "abandoned") {
+    return { status: "abandoned" };
+  }
+  if (runs.length === 0) {
+    return { status: todo.status };
+  }
+  if (runs.some((r) => !isAgentRunTerminalStatus(r.status))) {
+    return { status: "running", latestRun: latestRun(runs) };
+  }
+  const latest = latestRun(runs);
+  if (latest?.reviewVerdict === TODO_REVIEW_BLOCK) {
+    return {
+      status: "blocked",
+      latestRun: latest,
+      blockedReason: clipSummary(latest.reviewReason, MAX_ERROR_SUMMARY_CHARS)
+    };
+  }
+  if (latest?.status === "done") {
+    return { status: "done", latestRun: latest };
+  }
+  return { status: "pending", latestRun: latest };
+}
+function toEpochMs2(iso) {
+  if (!iso) return void 0;
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? ms : void 0;
+}
+function latestRun(runs) {
+  let latest;
+  let latestScore = -1;
+  for (const run of runs) {
+    const score = toEpochMs2(run.finishedAt) ?? toEpochMs2(run.startedAt) ?? -1;
+    if (latest === void 0 || score >= latestScore) {
+      latest = run;
+      latestScore = score;
+    }
+  }
+  return latest;
+}
+function clipSummary(text, max) {
+  if (!text) return void 0;
+  const folded = text.replace(/\s+/g, " ").trim();
+  if (folded.length === 0) return void 0;
+  return folded.length > max ? `${folded.slice(0, max - 1)}\u2026` : folded;
+}
+
+// packages/cli/client/fileSystemStores.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir as nodeHomedir } from "node:os";
+import { dirname, join } from "node:path";
+var nodeFs = {
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync
+};
+function resolveNoloHome(env, homedir) {
+  const custom = env?.NOLO_HOME;
+  if (custom && custom.trim()) return custom.trim();
+  return join(homedir(), ".nolo");
+}
+function ensureDir(dir, fs) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function readJson(path, fs) {
+  if (!fs.existsSync(path)) return void 0;
+  try {
+    const raw = fs.readFileSync(path, "utf8");
+    return JSON.parse(String(raw));
+  } catch {
+    return void 0;
+  }
+}
+function writeJson(path, data, fs) {
+  fs.writeFileSync(path, JSON.stringify(data, null, 2));
+}
+function createFileSystemCircuitBreakerStore(opts = {}) {
+  const env = opts.env ?? process.env;
+  const homedir = opts.homedir ?? nodeHomedir;
+  const fs = opts.fs ?? nodeFs;
+  const filePath = opts.filePath ?? join(resolveNoloHome(env, homedir), "breakers.json");
+  const loadMap = () => {
+    const data = readJson(filePath, fs);
+    const map = /* @__PURE__ */ new Map();
+    if (data?.entries) {
+      for (const entry of data.entries) {
+        if (entry && typeof entry.target === "string") map.set(entry.target, entry);
+      }
+    }
+    return map;
+  };
+  const persist = (map) => {
+    ensureDir(dirname(filePath), fs);
+    writeJson(filePath, { entries: [...map.values()] }, fs);
+  };
+  return {
+    get(target) {
+      return loadMap().get(target);
+    },
+    set(entry) {
+      const map = loadMap();
+      map.set(entry.target, entry);
+      persist(map);
+    },
+    clear(target) {
+      const map = loadMap();
+      map.delete(target);
+      persist(map);
+    },
+    clearAll() {
+      persist(/* @__PURE__ */ new Map());
+    }
+  };
+}
+function createFileSystemTodoStore(opts = {}) {
+  const env = opts.env ?? process.env;
+  const homedir = opts.homedir ?? nodeHomedir;
+  const fs = opts.fs ?? nodeFs;
+  const filePath = opts.filePath ?? join(resolveNoloHome(env, homedir), "todos.json");
+  const loadMap = () => {
+    const data = readJson(filePath, fs);
+    const map = /* @__PURE__ */ new Map();
+    if (data?.todos) {
+      for (const todo of data.todos) {
+        if (todo && typeof todo.id === "string") map.set(todo.id, todo);
+      }
+    }
+    return map;
+  };
+  const persist = (map) => {
+    ensureDir(dirname(filePath), fs);
+    writeJson(filePath, { todos: [...map.values()] }, fs);
+  };
+  return {
+    async getTodo(id) {
+      return loadMap().get(id);
+    },
+    async listTodos(filter) {
+      const all = [...loadMap().values()];
+      if (!filter?.statuses || filter.statuses.length === 0) return all;
+      const wanted = new Set(filter.statuses);
+      return all.filter((t2) => wanted.has(t2.status));
+    },
+    async putTodo(todo) {
+      const map = loadMap();
+      map.set(todo.id, todo);
+      persist(map);
+    },
+    async deleteTodo(id) {
+      const map = loadMap();
+      map.delete(id);
+      persist(map);
+    }
+  };
 }
 
 // packages/cli/client/cliAgentRunToolExecutors.ts
-import { existsSync, readFileSync } from "node:fs";
 var noopOutput = { write: () => {
 } };
 var parseCallArgs = (call) => {
@@ -2046,7 +2609,7 @@ var parseCallArgs = (call) => {
     return {};
   }
 };
-var resolveFs = (deps) => deps.fs ?? { existsSync, readFileSync };
+var resolveFs = (deps) => deps.fs ?? { existsSync: existsSync2, readFileSync: readFileSync2 };
 var tailFile = (logPath, tailLines, fs) => {
   if (!fs.existsSync(logPath)) return void 0;
   try {
@@ -2058,6 +2621,27 @@ var tailFile = (logPath, tailLines, fs) => {
     return void 0;
   }
 };
+var resolveBreakerStore = (deps) => deps.breakerStore ?? createFileSystemCircuitBreakerStore({ env: deps.env, homedir: deps.homedir, fs: deps.fs });
+var resolveTodoStore = (deps) => deps.todoStore ?? createFileSystemTodoStore({ env: deps.env, homedir: deps.homedir, fs: deps.fs });
+var resolveNowMs = (deps) => typeof deps.nowMs === "function" ? deps.nowMs() : Date.now();
+var resolveTarget = (deps, agentKey) => typeof deps.resolveProviderTarget === "function" ? deps.resolveProviderTarget(agentKey) : agentKey;
+function buildProgressField(record, nowMs) {
+  const activity = record.activity;
+  if (!activity || isAgentRunTerminalStatus(record.status)) return {};
+  const lastEventAt = Date.parse(activity.lastEventAt ?? "");
+  const inFlight = activity.inFlight;
+  const progress = {
+    toolCalls: activity.counters?.toolCalls ?? 0,
+    llmCalls: activity.counters?.llmCalls ?? 0,
+    fileEdits: activity.counters?.fileEdits ?? 0,
+    ...Number.isFinite(lastEventAt) ? { idleMs: Math.max(0, nowMs - lastEventAt) } : {}
+  };
+  if (inFlight) {
+    progress.inFlight = inFlight.name ? `${inFlight.kind}:${inFlight.name}` : inFlight.kind;
+    if (Number.isFinite(inFlight.sinceMs)) progress.inFlightMs = Math.max(0, inFlight.sinceMs);
+  }
+  return { progress };
+}
 function createCliStartAgentRunExecutor(deps = {}) {
   return async (call) => {
     const args = parseCallArgs(call);
@@ -2065,35 +2649,105 @@ function createCliStartAgentRunExecutor(deps = {}) {
     const task = typeof args.task === "string" ? args.task.trim() : "";
     if (!agentKey) throw new Error("startAgentRun: \u7F3A\u5C11 agentKey \u53C2\u6570\u3002");
     if (!task) throw new Error("startAgentRun: \u7F3A\u5C11\u6709\u6548\u7684 task \u6587\u672C\u63CF\u8FF0\u3002");
+    const breakerStore = resolveBreakerStore(deps);
+    const target = resolveTarget(deps, agentKey);
+    const nowMs = resolveNowMs(deps);
+    const activeBreaker = findActiveBreaker(
+      nowMs,
+      [breakerStore.get(target)].filter(Boolean),
+      target
+    );
+    if (activeBreaker) {
+      const resetsAt = activeBreaker.resetsAt;
+      return {
+        content: JSON.stringify({
+          rejected: true,
+          reason: "quota",
+          provider: target,
+          ...resetsAt !== void 0 ? { resetsAt } : {},
+          message: `provider ${target} \u5904\u4E8E\u7194\u65AD\u671F\uFF08\u914D\u989D\u8017\u5C3D\uFF09\uFF0C\u5EFA\u8BAE\u6539\u6D3E\u5176\u5B83 provider\u3002`
+        }),
+        metadata: {
+          displayData: `Run rejected \xB7 quota breaker active on ${target}`
+        }
+      };
+    }
     const message = typeof args.input === "undefined" ? task : `${task}
 
 --- \u9644\u52A0\u8F93\u5165 ---
 ${JSON.stringify(args.input)}`;
-    const rawArgs = ["--agent", agentKey, "--msg-file", "PLACEHOLDER", "--bg"];
+    const rawArgs = [
+      "--agent",
+      agentKey,
+      "--msg-file",
+      "PLACEHOLDER",
+      "--bg",
+      // 非持久化派发（review 等一次性任务）：透传 --ephemeral，run 完成后不留
+      // dialog 记录。与 web 端 runAgentBackground 的 ephemeral: true 对齐。
+      ...args.ephemeral === true ? ["--ephemeral"] : []
+    ];
     const agentName = typeof args.agentName === "string" && args.agentName.trim() ? args.agentName.trim() : typeof args.name === "string" && args.name.trim() ? args.name.trim() : void 0;
-    const { runId } = await spawnLocalBackgroundRun(
+    const batchId = typeof args.batchId === "string" && args.batchId.trim() ? args.batchId.trim() : void 0;
+    const { runId, batchId: resolvedBatchId } = await spawnLocalBackgroundRun(
       {
         rawArgs,
         commandPath: ["agent", "run"],
         cliEntrypointPath: deps.cliEntrypoint,
         agentKey,
         ...agentName ? { agentName } : {},
+        ...batchId ? { batchId } : {},
+        ...typeof args.parentDialogId === "string" && args.parentDialogId.trim() ? { parentDialogId: args.parentDialogId.trim() } : {},
         cwd: deps.cwd ?? process.cwd(),
         message,
         output: noopOutput
       },
       deps
     );
-    const displayName = agentName ?? "agent";
+    const displayName = resolveRunLabel({ agentName, agentKey, runId });
     const labels = agentRunCardLabels();
+    const taskPreview = typeof args.task === "string" ? args.task.replace(/\s+/g, " ").trim().slice(0, TASK_PREVIEW_MAX) : "";
+    const trackTodo = typeof args.trackTodo === "boolean" ? args.trackTodo : Boolean(resolvedBatchId);
+    if (trackTodo) {
+      try {
+        const todoStore = resolveTodoStore(deps);
+        const todoId = `todo-${resolvedBatchId}`;
+        const existing = await todoStore.getTodo(todoId);
+        const nowIso = new Date(nowMs).toISOString();
+        const runIds = existing?.runIds ?? [];
+        if (!runIds.includes(runId)) runIds.push(runId);
+        const todo = {
+          id: todoId,
+          title: taskPreview || task.slice(0, 100),
+          status: existing?.status ?? "pending",
+          ...existing?.specPath ? { specPath: existing.specPath } : {},
+          ...existing?.worktree ? { worktree: existing.worktree } : {},
+          ...existing?.branch ? { branch: existing.branch } : {},
+          ...deps.cwd ? { worktree: deps.cwd } : {},
+          runIds,
+          deps: existing?.deps ?? [],
+          createdAt: existing?.createdAt ?? nowIso,
+          updatedAt: nowIso
+        };
+        await todoStore.putTodo(todo);
+      } catch {
+      }
+    }
     return {
       content: JSON.stringify({
         runId,
         status: "running",
-        ...agentName ? { agentName } : {}
+        // batchId is always returned so the caller can later filter by it —
+        // even when the caller didn't supply one, a fresh id was generated.
+        batchId: resolvedBatchId,
+        ...agentName ? { agentName } : {},
+        ...taskPreview ? { taskPreview } : {}
       }),
       metadata: {
-        displayData: formatStartRunCard(displayName, "running", labels)
+        displayData: formatStartRunCard(displayName, "running", {
+          task: taskPreview,
+          runId,
+          labels
+        })
       }
     };
   };
@@ -2104,26 +2758,103 @@ function createCliControlAgentRunExecutor(deps = {}) {
     const action = typeof args.action === "string" ? args.action : "";
     const tailLines = typeof args.tailLines === "number" ? args.tailLines : 0;
     if (action === "list") {
-      const records = listRunRecords(deps);
+      gcRunRecords(deps);
+      const { runs: records, total, hasMore } = queryRunRecords(
+        {
+          ...typeof args.batchId === "string" && args.batchId.trim() ? { batchId: args.batchId.trim() } : {},
+          ...typeof args.status === "string" && args.status.trim() ? { status: args.status.trim() } : typeof args.statusFilter === "string" && args.statusFilter.trim() ? { status: args.statusFilter.trim() } : {},
+          ...typeof args.limit === "number" ? { limit: args.limit } : {},
+          ...typeof args.offset === "number" ? { offset: args.offset } : {}
+        },
+        deps
+      );
       const runs = records.map((record2) => {
-        const reconciled = checkStaleRun(record2.runId, deps) ?? record2;
         return {
-          runId: reconciled.runId,
-          status: reconciled.status,
-          agentKey: reconciled.agentKey,
-          ...reconciled.agentName ? { agentName: reconciled.agentName } : {},
-          pid: reconciled.pid ?? null,
-          startedAt: reconciled.startedAt
+          runId: record2.runId,
+          status: record2.status,
+          agentKey: record2.agentKey,
+          ...record2.agentName ? { agentName: record2.agentName } : {},
+          ...record2.batchId ? { batchId: record2.batchId } : {},
+          pid: record2.pid ?? null,
+          startedAt: record2.startedAt
         };
       });
       const labels2 = agentRunCardLabels();
+      const batchIdArg = typeof args.batchId === "string" && args.batchId.trim() ? args.batchId.trim() : void 0;
+      let batchSummary;
+      if (batchIdArg && records.length > 0) {
+        const batchRuns = records.map((r) => ({
+          runId: r.runId,
+          status: r.status,
+          startedAt: r.startedAt,
+          ...r.agentName ? { agentName: r.agentName } : {}
+        }));
+        batchSummary = aggregateBatch({
+          batchId: batchIdArg,
+          runs: batchRuns,
+          now: new Date(resolveNowMs(deps)).toISOString()
+        });
+      }
       return {
-        content: JSON.stringify({ runs, count: runs.length }),
+        content: JSON.stringify({
+          runs,
+          count: runs.length,
+          total,
+          hasMore,
+          ...batchSummary?.summary ? { batchSummary: batchSummary.summary } : {}
+        }),
         metadata: {
           displayData: formatListRunsCard(runs, labels2)
         }
       };
     }
+    if (action === "todo") {
+      const todoStore = resolveTodoStore(deps);
+      const statusesRaw = typeof args.status === "string" ? args.status.trim() : void 0;
+      const filter = statusesRaw && statusesRaw !== "all" ? { statuses: statusesRaw.split(",").map((s) => s.trim()).filter(Boolean) } : void 0;
+      const todos = await todoStore.listTodos(filter);
+      const enriched = await Promise.all(
+        todos.map(async (todo) => {
+          const runSummaries = [];
+          for (const rid of todo.runIds) {
+            const rec = findRunRecord(rid, deps);
+            if (!rec) continue;
+            runSummaries.push({
+              runId: rec.runId,
+              status: rec.status,
+              startedAt: rec.startedAt,
+              ...rec.agentName ? { agentName: rec.agentName } : {}
+            });
+          }
+          const derived = deriveTodoStatus({
+            todo: { id: todo.id, status: todo.status },
+            runs: runSummaries,
+            now: new Date(resolveNowMs(deps)).toISOString()
+          });
+          return {
+            id: todo.id,
+            title: todo.title,
+            status: derived.status,
+            runIds: todo.runIds,
+            ...derived.blockedReason ? { blockedReason: derived.blockedReason } : {},
+            ...derived.latestRun ? { latestRunId: derived.latestRun.runId, latestRunStatus: derived.latestRun.status } : {},
+            updatedAt: todo.updatedAt
+          };
+        })
+      );
+      return {
+        content: JSON.stringify({ todos: enriched, count: enriched.length }),
+        metadata: {
+          displayData: formatListRunsCard(
+            enriched.map((t2) => ({
+              agentName: t2.title,
+              status: t2.status
+            })),
+            agentRunCardLabels()
+          )
+        }
+      };
+    }
     if (action !== "status" && action !== "stop") {
       throw new Error(`controlAgentRun: \u672A\u77E5 action "${action}"\u3002`);
     }
@@ -2139,9 +2870,28 @@ function createCliControlAgentRunExecutor(deps = {}) {
     if (action === "status") {
       const reconciled = checkStaleRun(record.runId, deps) ?? record;
       const logTail = tailLines > 0 ? tailFile(record.logPath, tailLines, resolveFs(deps)) : void 0;
-      const name = reconciled.agentName || "agent";
+      const name = resolveRunLabel(reconciled);
       const logLines = logTail ? logTail.split("\n") : void 0;
       const labels2 = agentRunCardLabels();
+      if (reconciled.status === "failed" || reconciled.status === "orphaned") {
+        try {
+          const failureSource = logTail ?? reconciled.note ?? "";
+          const failureInfo = classifyRunFailure(
+            failureSource || reconciled.status
+          );
+          if (failureInfo.reason === "quota") {
+            const t2 = resolveTarget(deps, reconciled.agentKey);
+            const entry = buildBreakerEntry(
+              resolveNowMs(deps),
+              t2,
+              "quota",
+              failureInfo.retryAfterMs
+            );
+            resolveBreakerStore(deps).set(entry);
+          }
+        } catch {
+        }
+      }
       return {
         content: JSON.stringify({
           runId: reconciled.runId,
@@ -2162,11 +2912,26 @@ function createCliControlAgentRunExecutor(deps = {}) {
           // indistinguishable from a hung run without this field. Surfacing
           // dialogId gives the caller a reliable way to fetch the result.
           ...reconciled.dialogId ? { dialogId: reconciled.dialogId } : {},
+          // Progress is what makes tailLines:0 an actual answer to "is it
+          // stuck?". Without it a poll returns `running` and a pid, so the only
+          // way to tell a working run from a wedged one was to pull 30 lines of
+          // log — the exact thing the orchestration prompt tells the model not
+          // to do. The registry has been recording this all along and `nolo
+          // agent status` has been printing it; only the tool was blind.
+          ...buildProgressField(reconciled, resolveNowMs(deps)),
           ...logTail !== void 0 ? { logTail } : {},
           ...logLines ? { logLines } : {}
         }),
         metadata: {
-          displayData: formatStatusRunCard(name, reconciled.status, { logLines, labels: labels2 })
+          displayData: formatStatusRunCard(name, reconciled.status, {
+            runId: reconciled.runId,
+            timing: {
+              startedAt: readTimestamp(reconciled.startedAt),
+              finishedAt: readTimestamp(reconciled.endedAt)
+            },
+            logLines,
+            labels: labels2
+          })
         }
       };
     }
@@ -2304,7 +3069,7 @@ function buildLocalToolExecutors(args) {
         }
       };
     },
-    ui_ask_choice: async (call) => {
+    ask_user: async (call) => {
       const parsedArgs = (() => {
         try {
           return JSON.parse(call.arguments || "{}");
@@ -2320,8 +3085,8 @@ function buildLocalToolExecutors(args) {
       if (!hasQuestions && (!question || choices.length === 0)) {
         return {
           content: JSON.stringify({
-            error: "ui_ask_choice",
-            detail: "ui_ask_choice \u9700\u8981 question+choices \u6216 questions\u3002"
+            error: "ask_user",
+            detail: "ask_user \u9700\u8981 question+choices \u6216 questions\u3002"
           }),
           metadata: { uiAskChoice: true, error: true }
         };
@@ -2337,7 +3102,7 @@ function buildLocalToolExecutors(args) {
           if (result.kind === "multi-submitted") {
             return {
               content: JSON.stringify({
-                type: "ui_ask_choice",
+                type: "ask_user",
                 question,
                 choices,
                 blocking,
@@ -2354,7 +3119,7 @@ function buildLocalToolExecutors(args) {
           if (result.kind === "selected") {
             return {
               content: JSON.stringify({
-                type: "ui_ask_choice",
+                type: "ask_user",
                 question,
                 choices,
                 blocking,
@@ -2369,7 +3134,7 @@ function buildLocalToolExecutors(args) {
           }
           return {
             content: JSON.stringify({
-              type: "ui_ask_choice",
+              type: "ask_user",
               question,
               choices,
               blocking,
@@ -2384,7 +3149,7 @@ function buildLocalToolExecutors(args) {
       }
       return {
         content: JSON.stringify({
-          type: "ui_ask_choice",
+          type: "ask_user",
           question,
           choices,
           blocking,
@@ -2448,19 +3213,22 @@ function resolveAntigravityWireModel(logicalModelId) {
   return { wireModelId: id };
 }
 
-// packages/agent-runtime/antigravityCloudCodeProvider.ts
-var STREAM_PATH = "/v1internal:streamGenerateContent?alt=sse";
+// packages/agent-runtime/geminiNativeShared.ts
 var SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
-function isGemini3WireModel(modelId) {
+function isGemini3Model(modelId) {
   return modelId.includes("gemini-3");
 }
 function messageText(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
-  return content.filter((part) => part?.type === "text").map((part) => part.text).join("\n").trim();
+  return content.filter(
+    (part) => part?.type === "text"
+  ).map((part) => part.text).join("\n").trim();
 }
 function parseDataUrlToInlineData(url) {
-  const match = /^data:([A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+);base64,([A-Za-z0-9+/=]*)$/.exec(url);
+  const match = /^data:([A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+);base64,([A-Za-z0-9+/=]*)$/.exec(
+    url
+  );
   if (!match) return null;
   return { mimeType: match[1], data: match[2] };
 }
@@ -2477,7 +3245,7 @@ function extractInlineDataParts(content) {
   }
   return parts;
 }
-function convertOpenAiMessagesToCca(messages, options) {
+function convertOpenAiMessagesToGemini(messages, options) {
   const contents = [];
   const systemTexts = [];
   const toolNamesById = /* @__PURE__ */ new Map();
@@ -2493,9 +3261,11 @@ function convertOpenAiMessagesToCca(messages, options) {
   };
   const flushPendingFunctionCalls = () => {
     if (pendingFunctionCalls.length === 0) return;
-    const dummyResponses = pendingFunctionCalls.map(({ name }) => ({
-      functionResponse: { name, response: { output: "{}" } }
-    }));
+    const dummyResponses = pendingFunctionCalls.map(
+      ({ name }) => ({
+        functionResponse: { name, response: { output: "{}" } }
+      })
+    );
     pendingFunctionCalls = [];
     pushOrMergeContent("user", dummyResponses);
   };
@@ -2504,13 +3274,17 @@ function convertOpenAiMessagesToCca(messages, options) {
     const role = String(raw.role);
     const content = "content" in raw ? raw.content : null;
     if (role === "system") {
-      const text = messageText(content);
+      const text = messageText(
+        content
+      );
       if (text) systemTexts.push(text);
       continue;
     }
     if (role === "user") {
       flushPendingFunctionCalls();
-      const text = messageText(content);
+      const text = messageText(
+        content
+      );
       const imageParts = extractInlineDataParts(
         content
       );
@@ -2524,7 +3298,9 @@ function convertOpenAiMessagesToCca(messages, options) {
     if (role === "assistant") {
       flushPendingFunctionCalls();
       const parts = [];
-      const text = messageText(content);
+      const text = messageText(
+        content
+      );
       if (text) parts.push({ text });
       const toolCalls = "tool_calls" in raw && Array.isArray(raw.tool_calls) ? raw.tool_calls ?? [] : [];
       for (const call of toolCalls) {
@@ -2534,17 +3310,20 @@ function convertOpenAiMessagesToCca(messages, options) {
         toolNamesById.set(id, name);
         pendingFunctionCalls.push({ name, id });
         const realSignature = typeof call.thought_signature === "string" && call.thought_signature ? call.thought_signature : void 0;
-        const isFirstFunctionCallPart = !parts.some((p) => "functionCall" in p);
-        parts.push({
+        const isFirstFunctionCallPart = !parts.some(
+          (p) => "functionCall" in p
+        );
+        const signature = realSignature ?? (options.attachSkipThoughtSignature && isFirstFunctionCallPart ? SKIP_THOUGHT_SIGNATURE : void 0);
+        const part = {
           functionCall: {
             name,
-            args: parseToolArgumentsJson(call.function?.arguments),
-            id
+            args: parseToolArgs(call.function?.arguments),
+            ...id ? { id } : {}
           },
-          ...realSignature ? { thoughtSignature: realSignature } : options.attachSkipThoughtSignature && isFirstFunctionCallPart ? { thoughtSignature: SKIP_THOUGHT_SIGNATURE } : {}
-        });
+          ...signature ? { thoughtSignature: signature } : {}
+        };
+        parts.push(part);
       }
-      if (parts.length === 0) continue;
       pushOrMergeContent("model", parts);
       continue;
     }
@@ -2562,14 +3341,39 @@ function convertOpenAiMessagesToCca(messages, options) {
       }
       const output = messageText(content) || "{}";
       pushOrMergeContent("user", [
-        { functionResponse: { name, response: { output } } }
+        {
+          functionResponse: {
+            name,
+            response: { output },
+            // 保留 OpenAI tool_call_id：antigravity Cloud Code Assist 网关把
+            // Gemini contents 转成 Claude messages 时需要 functionResponse →
+            // tool_result 的 tool_use_id；缺 id 时网关报
+            // "tool_result.tool_use_id: Field required"（HTTP 400）。
+            ...toolCallId ? { id: toolCallId } : {}
+          }
+        }
       ]);
     }
   }
   flushPendingFunctionCalls();
   return { contents, systemTexts };
 }
-function convertOpenAiTools(tools) {
+function parseToolArgs(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
+  }
+  return {};
+}
+function convertOpenAiToolsToGemini(tools) {
   if (!Array.isArray(tools) || tools.length === 0) return void 0;
   const declarations = [];
   for (const tool of tools) {
@@ -2586,6 +3390,97 @@ function convertOpenAiTools(tools) {
   if (declarations.length === 0) return void 0;
   return [{ functionDeclarations: declarations }];
 }
+function accumulateGeminiChunks(chunks) {
+  let text = "";
+  const toolCalls = [];
+  let usage;
+  let pendingThoughtSignature;
+  for (const chunk of chunks) {
+    if (!chunk || typeof chunk !== "object") continue;
+    const response = "response" in chunk && chunk.response && typeof chunk.response === "object" ? chunk.response : chunk;
+    if ("usageMetadata" in response && response.usageMetadata && typeof response.usageMetadata === "object") {
+      const meta = response.usageMetadata;
+      const prompt = typeof meta.promptTokenCount === "number" ? meta.promptTokenCount : 0;
+      const candidates2 = typeof meta.candidatesTokenCount === "number" ? meta.candidatesTokenCount : 0;
+      const total = typeof meta.totalTokenCount === "number" ? meta.totalTokenCount : prompt + candidates2;
+      usage = {
+        prompt_tokens: prompt,
+        completion_tokens: candidates2,
+        total_tokens: total
+      };
+    }
+    const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+    for (const candidate of candidates) {
+      if (!candidate || typeof candidate !== "object") continue;
+      const parts = Array.isArray(
+        candidate.content?.parts
+      ) ? candidate.content.parts : [];
+      for (const part of parts) {
+        if (!part || typeof part !== "object") continue;
+        const partSignature = part.thoughtSignature;
+        if ("text" in part && typeof part.text === "string") {
+          const piece = part.text;
+          if (!part.thought) {
+            text += piece;
+          }
+        }
+        if (part.thought && typeof partSignature === "string" && partSignature) {
+          pendingThoughtSignature = partSignature;
+        }
+        if ("functionCall" in part && part.functionCall) {
+          const call = part.functionCall;
+          const name = typeof call.name === "string" ? call.name : "tool";
+          const id = typeof call.id === "string" ? call.id : `${name}_${toolCalls.length}`;
+          const argsObj = call.args && typeof call.args === "object" ? call.args : {};
+          const resolvedSignature = typeof partSignature === "string" && partSignature ? partSignature : pendingThoughtSignature;
+          pendingThoughtSignature = void 0;
+          toolCalls.push({
+            id,
+            type: "function",
+            function: { name, arguments: JSON.stringify(argsObj) },
+            ...typeof resolvedSignature === "string" && resolvedSignature ? { thought_signature: resolvedSignature } : {}
+          });
+        }
+      }
+    }
+  }
+  return { text, toolCalls, usage };
+}
+function shouldUseGeminiNativeToolRoute(provider, model, tools, isImageModel) {
+  return provider === "google" && !isImageModel(model) && isGemini3Model(model) && Array.isArray(tools) && tools.length > 0;
+}
+function buildGeminiGenerateContentRequest(args) {
+  const { contents, systemTexts } = convertOpenAiMessagesToGemini(
+    args.messages,
+    { attachSkipThoughtSignature: args.attachSkipThoughtSignature }
+  );
+  const request = { contents };
+  if (systemTexts.length > 0) {
+    request.systemInstruction = {
+      role: "user",
+      parts: systemTexts.map((text) => ({ text }))
+    };
+  }
+  const toolsResult = convertOpenAiToolsToGemini(args.tools);
+  if (toolsResult) {
+    request.tools = toolsResult;
+    request.toolConfig = { functionCallingConfig: { mode: "VALIDATED" } };
+  }
+  const generationConfig = {};
+  if (typeof args.maxTokens === "number" && args.maxTokens > 0) {
+    generationConfig.maxOutputTokens = args.maxTokens;
+  }
+  if (typeof args.temperature === "number") {
+    generationConfig.temperature = args.temperature;
+  }
+  if (Object.keys(generationConfig).length > 0) {
+    request.generationConfig = generationConfig;
+  }
+  return request;
+}
+
+// packages/agent-runtime/antigravityCloudCodeProvider.ts
+var STREAM_PATH = "/v1internal:streamGenerateContent?alt=sse";
 function buildCloudCodeAssistPayload(args) {
   const projectId = readAntigravityProjectId(args.metadata);
   if (!projectId) {
@@ -2596,8 +3491,9 @@ function buildCloudCodeAssistPayload(args) {
   const logicalModel = asOptionalTrimmedString(args.openAiBody.model) ?? asOptionalTrimmedString(args.agentConfig.model) ?? "gemini-3.1-pro";
   const { wireModelId: model, profile } = resolveAntigravityWireModel(logicalModel);
   const rawMessages = Array.isArray(args.openAiBody.messages) ? args.openAiBody.messages : [];
-  const { contents, systemTexts } = convertOpenAiMessagesToCca(rawMessages, {
-    attachSkipThoughtSignature: isGemini3WireModel(model)
+  const isClaude = model.toLowerCase().includes("claude");
+  const { contents, systemTexts } = convertOpenAiMessagesToGemini(rawMessages, {
+    attachSkipThoughtSignature: isGemini3Model(model)
   });
   if (contents.length === 0) {
     throw new Error("Antigravity Cloud Code Assist request has no user/model contents.");
@@ -2611,7 +3507,7 @@ function buildCloudCodeAssistPayload(args) {
       parts: systemTexts.map((text) => ({ text }))
     };
   }
-  const tools = convertOpenAiTools(
+  const tools = convertOpenAiToolsToGemini(
     Array.isArray(args.openAiBody.tools) ? args.openAiBody.tools : void 0
   );
   if (tools) {
@@ -2631,83 +3527,31 @@ function buildCloudCodeAssistPayload(args) {
     request.generationConfig = generationConfig;
   }
   const agentId = randomUUID();
-  const trajectoryId = randomUUID();
-  const step = 2;
-  const requestId = `agent/${agentId}/${Date.now()}/${trajectoryId}/${step}`;
-  const isClaude = model.toLowerCase().includes("claude");
-  const labels = {
-    trajectory_id: trajectoryId,
-    last_step_index: String(step - 1),
-    used_claude: String(isClaude),
-    used_claude_conservative: String(isClaude)
-  };
-  if (profile?.modelEnum) {
-    labels.model_enum = profile.modelEnum;
-  }
-  request.labels = labels;
-  request.sessionId = `-${Math.floor(Math.random() * 9e15)}`;
-  return {
-    url: `${resolveAntigravityCloudCodeBaseUrl(args.agentConfig.customProviderUrl)}${STREAM_PATH}`,
-    envelope: {
-      project: projectId,
-      model,
-      request,
-      requestId,
-      requestType: "agent",
-      userAgent: "antigravity"
-    }
-  };
-}
-function accumulateCcaChunks(chunks) {
-  let text = "";
-  const toolCalls = [];
-  let usage;
-  for (const chunk of chunks) {
-    if (!chunk || typeof chunk !== "object") continue;
-    const response = "response" in chunk && chunk.response && typeof chunk.response === "object" ? chunk.response : chunk;
-    if ("usageMetadata" in response && response.usageMetadata && typeof response.usageMetadata === "object") {
-      const meta = response.usageMetadata;
-      const prompt = typeof meta.promptTokenCount === "number" ? meta.promptTokenCount : 0;
-      const candidates2 = typeof meta.candidatesTokenCount === "number" ? meta.candidatesTokenCount : 0;
-      const total = typeof meta.totalTokenCount === "number" ? meta.totalTokenCount : prompt + candidates2;
-      usage = {
-        prompt_tokens: prompt,
-        completion_tokens: candidates2,
-        total_tokens: total
-      };
-    }
-    const candidates = Array.isArray(response.candidates) ? response.candidates : [];
-    for (const candidate of candidates) {
-      if (!candidate || typeof candidate !== "object" || !("content" in candidate)) continue;
-      const content = candidate.content;
-      if (!content || typeof content !== "object" || !("parts" in content)) continue;
-      const parts = content.parts;
-      if (!Array.isArray(parts)) continue;
-      for (const part of parts) {
-        if (!part || typeof part !== "object") continue;
-        const partSignature = part.thoughtSignature;
-        if ("text" in part && typeof part.text === "string") {
-          const piece = part.text;
-          if (!part.thought) {
-            text += piece;
-          }
-        }
-        if ("functionCall" in part && part.functionCall) {
-          const call = part.functionCall;
-          const name = typeof call.name === "string" ? call.name : "tool";
-          const id = typeof call.id === "string" ? call.id : `${name}_${toolCalls.length}`;
-          const argsObj = asRecordOrEmpty(call.args);
-          toolCalls.push({
-            id,
-            type: "function",
-            function: { name, arguments: JSON.stringify(argsObj) },
-            ...typeof partSignature === "string" && partSignature ? { thought_signature: partSignature } : {}
-          });
-        }
-      }
-    }
+  const trajectoryId = randomUUID();
+  const step = 2;
+  const requestId = `agent/${agentId}/${Date.now()}/${trajectoryId}/${step}`;
+  const labels = {
+    trajectory_id: trajectoryId,
+    last_step_index: String(step - 1),
+    used_claude: String(isClaude),
+    used_claude_conservative: String(isClaude)
+  };
+  if (profile?.modelEnum) {
+    labels.model_enum = profile.modelEnum;
   }
-  return { text, toolCalls, usage };
+  request.labels = labels;
+  request.sessionId = `-${Math.floor(Math.random() * 9e15)}`;
+  return {
+    url: `${resolveAntigravityCloudCodeBaseUrl(args.agentConfig.customProviderUrl)}${STREAM_PATH}`,
+    envelope: {
+      project: projectId,
+      model,
+      request,
+      requestId,
+      requestType: "agent",
+      userAgent: "antigravity"
+    }
+  };
 }
 async function readSseJsonChunks(response) {
   return readSseDataValues(response, parseSseDataLineJson);
@@ -2733,7 +3577,7 @@ async function fetchAntigravityCloudCodeCompletion(args) {
     };
   }
   const chunks = await readSseJsonChunks(response);
-  const { text, toolCalls, usage } = accumulateCcaChunks(chunks);
+  const { text, toolCalls, usage } = accumulateGeminiChunks(chunks);
   const message = {
     role: "assistant",
     content: text || null
@@ -2769,28 +3613,94 @@ var CLAUDE_CODE_IDENTITY_PATTERNS = [
   CLAUDE_CODE_SYSTEM_INSTRUCTION,
   "You are Claude Code"
 ];
+var REASONING_EFFORT_TO_BUDGET = {
+  minimal: 2048,
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  xhigh: 32e3,
+  max: 32e3
+};
+function resolveThinkingBudget(effort) {
+  if (!effort) return void 0;
+  const normalized = effort.toLowerCase();
+  if (normalized === "none" || normalized === "off") return void 0;
+  return REASONING_EFFORT_TO_BUDGET[normalized];
+}
+var DEFAULT_THINKING_EFFORT = "medium";
+var DEFAULT_ENABLED_BUDGET = 8192;
+var DEFAULT_ENABLE_THINKING_BUDGET = 8e3;
+var ANTHROPIC_EFFORT_ALIASES = { minimal: "low" };
+function resolveThinkingSpec(input) {
+  const { model, maxTokens } = input;
+  const normalizedEffort = input.reasoningEffort?.toLowerCase();
+  const effortDisabled = normalizedEffort === "none" || normalizedEffort === "off";
+  const effectiveEffort = normalizedEffort !== void 0 && !effortDisabled ? ANTHROPIC_EFFORT_ALIASES[normalizedEffort] ?? normalizedEffort : DEFAULT_THINKING_EFFORT;
+  let thinkingBlock;
+  let outputConfig;
+  let finalMaxTokens = maxTokens;
+  let finalTemperature = input.temperature;
+  if (isAdaptiveThinkingModelId(model)) {
+    if (effortDisabled) {
+      thinkingBlock = { type: "disabled" };
+    } else {
+      thinkingBlock = { type: "adaptive", display: "summarized" };
+      outputConfig = { effort: effectiveEffort };
+    }
+  } else {
+    const injected = input.injectedThinking;
+    const injectedBudget = injected?.type === "enabled" && typeof injected.budget_tokens === "number" ? injected.budget_tokens : void 0;
+    const effortBudget = resolveThinkingBudget(input.reasoningEffort);
+    const fallbackBudget = input.reasoningEffort === void 0 ? injectedBudget ?? (input.enableThinking === true ? typeof input.thinkingBudget === "number" ? input.thinkingBudget : DEFAULT_ENABLE_THINKING_BUDGET : DEFAULT_ENABLED_BUDGET) : void 0;
+    const thinkingBudget = effortBudget ?? fallbackBudget;
+    if (thinkingBudget !== void 0) {
+      thinkingBlock = { type: "enabled", budget_tokens: thinkingBudget };
+      finalMaxTokens = Math.max(maxTokens, thinkingBudget + 1);
+      finalTemperature = 1;
+    }
+  }
+  return {
+    thinkingBlock,
+    outputConfig,
+    maxTokens: finalMaxTokens,
+    temperature: finalTemperature
+  };
+}
 function stringValue(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function isCacheControl(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && typeof value.type === "string"
+  );
+}
 function toAnthropicContent(content) {
-  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "text", text: content }] : [];
+  }
   if (!Array.isArray(content)) return [];
   const blocks = [];
   for (const raw of content) {
     if (!raw || typeof raw !== "object") continue;
     const part = raw;
     if ((part.type === "text" || part.type === "input_text") && typeof part.text === "string") {
-      blocks.push({ type: "text", text: part.text });
+      if (part.text.length > 0) {
+        const block2 = { type: "text", text: part.text };
+        if (isCacheControl(part.cache_control)) block2.cache_control = part.cache_control;
+        blocks.push(block2);
+      }
       continue;
     }
     if (part.type !== "image_url") continue;
     const imageUrl = typeof part.image_url === "string" ? part.image_url : stringValue(part.image_url?.url);
     if (!imageUrl) continue;
     const dataMatch = imageUrl.match(/^data:([^;,]+);base64,(.+)$/s);
-    blocks.push({
+    const block = {
       type: "image",
       source: dataMatch ? { type: "base64", media_type: dataMatch[1], data: dataMatch[2] } : { type: "url", url: imageUrl }
-    });
+    };
+    if (isCacheControl(part.cache_control)) block.cache_control = part.cache_control;
+    blocks.push(block);
   }
   return blocks;
 }
@@ -2824,7 +3734,15 @@ function buildAnthropicMessagesBody(args) {
     const message = raw;
     const role = String(message.role ?? "");
     if (role === "system" || role === "developer") {
-      system.push(...toAnthropicContent(message.content));
+      const stablePrefixChars = Number(message.stable_prefix_chars);
+      if (typeof message.content === "string" && Number.isFinite(stablePrefixChars) && stablePrefixChars > 0 && stablePrefixChars <= message.content.length) {
+        const stable = message.content.slice(0, stablePrefixChars);
+        const dynamic = message.content.slice(stablePrefixChars);
+        system.push({ type: "text", text: stable, cache_control: { type: "ephemeral" } });
+        if (dynamic) system.push({ type: "text", text: dynamic });
+      } else {
+        system.push(...toAnthropicContent(message.content));
+      }
       continue;
     }
     if (role === "tool") {
@@ -2866,6 +3784,9 @@ function buildAnthropicMessagesBody(args) {
   if (!hasClaudeCodeIdentity(system)) {
     system.unshift({ type: "text", text: CLAUDE_CODE_SYSTEM_INSTRUCTION });
   }
+  if (system.length > 0 && !system.some((block) => isCacheControl(block.cache_control))) {
+    system[system.length - 1].cache_control = { type: "ephemeral" };
+  }
   const tools = Array.isArray(args.openAiBody.tools) ? args.openAiBody.tools.flatMap((raw) => {
     if (!raw || typeof raw !== "object") return [];
     const fn = raw.function;
@@ -2880,14 +3801,39 @@ function buildAnthropicMessagesBody(args) {
   const model = stringValue(args.openAiBody.model) ?? args.agentConfig.model ?? "claude-sonnet-5";
   const maxTokensRaw = args.openAiBody.max_completion_tokens ?? args.openAiBody.max_tokens ?? args.agentConfig.max_tokens;
   const maxTokens = typeof maxTokensRaw === "number" && Number.isFinite(maxTokensRaw) ? Math.max(1, Math.floor(maxTokensRaw)) : 8192;
+  const reasoningEffort = stringValue(args.openAiBody.reasoning_effort) ?? stringValue(args.agentConfig.reasoning_effort);
+  const spec = resolveThinkingSpec({
+    model,
+    reasoningEffort,
+    maxTokens,
+    temperature: typeof args.openAiBody.temperature === "number" ? args.openAiBody.temperature : args.agentConfig.temperature,
+    injectedThinking: args.openAiBody.thinking,
+    enableThinking: args.agentConfig.enableThinking,
+    thinkingBudget: args.agentConfig.thinkingBudget
+  });
+  const { thinkingBlock, outputConfig } = spec;
+  const finalMaxTokens = spec.maxTokens;
+  const finalTemperature = spec.temperature;
+  if (messages.length > 0) {
+    const lastMessage = messages[messages.length - 1];
+    const content = Array.isArray(lastMessage.content) ? lastMessage.content : [];
+    if (content.length > 0) {
+      const lastBlock = content[content.length - 1];
+      if (!isCacheControl(lastBlock.cache_control)) {
+        lastBlock.cache_control = { type: "ephemeral" };
+      }
+    }
+  }
   return {
     model,
     messages,
-    max_tokens: maxTokens,
+    max_tokens: finalMaxTokens,
     stream: false,
+    ...thinkingBlock ? { thinking: thinkingBlock } : {},
+    ...outputConfig ? { output_config: outputConfig } : {},
     ...system.length > 0 ? { system } : {},
     ...tools.length > 0 ? { tools } : {},
-    ...typeof args.openAiBody.temperature === "number" ? { temperature: args.openAiBody.temperature } : typeof args.agentConfig.temperature === "number" ? { temperature: args.agentConfig.temperature } : {},
+    ...typeof finalTemperature === "number" ? { temperature: finalTemperature } : {},
     ...typeof args.openAiBody.top_p === "number" ? { top_p: args.openAiBody.top_p } : {}
   };
 }
@@ -2911,6 +3857,8 @@ function mapAnthropicMessageToOpenAi(payload) {
   }
   const usage = payload.usage ?? {};
   const inputTokens = (typeof usage.input_tokens === "number" ? usage.input_tokens : 0) + (typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0) + (typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0);
+  const cacheCreationInputTokens = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : 0;
+  const cacheReadInputTokens = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
   const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
   const stopReason = String(payload.stop_reason ?? "");
   const message = { role: "assistant", content: text || null };
@@ -2926,9 +3874,16 @@ function mapAnthropicMessageToOpenAi(payload) {
       finish_reason: toolCalls.length > 0 || stopReason === "tool_use" ? "tool_calls" : stopReason === "max_tokens" ? "length" : "stop"
     }],
     usage: {
+      // prompt_tokens/input_tokens are total input, including cache read/write.
+      // Preserve Anthropic's components so normalization and billing can apply
+      // the correct cache prices without double-counting them.
       prompt_tokens: inputTokens,
+      input_tokens: inputTokens,
       completion_tokens: outputTokens,
-      total_tokens: inputTokens + outputTokens
+      output_tokens: outputTokens,
+      total_tokens: inputTokens + outputTokens,
+      cache_creation_input_tokens: cacheCreationInputTokens,
+      cache_read_input_tokens: cacheReadInputTokens
     }
   };
 }
@@ -9003,6 +9958,262 @@ function isCursorOAuthAgent(agent) {
   return agent.apiKeyRef?.trim().toLowerCase() === "cursor";
 }
 
+// packages/agent-runtime/codexResponsesProvider.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+var CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+var CODEX_CLIENT_VERSION = "0.144.1";
+var CODEX_ORIGINATOR = "codex_cli_rs";
+var CODEX_OPENAI_BETA = "responses=experimental";
+var OPENAI_AUTH_CLAIM = "https://api.openai.com/auth";
+var CODEX_INSTALLATION_ID = randomUUID4();
+function decodeCodexAccountId(accessToken) {
+  const parts = accessToken.split(".");
+  if (parts.length < 2) return void 0;
+  try {
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64").toString("utf8")
+    );
+    const claim = payload[OPENAI_AUTH_CLAIM];
+    const value = claim && typeof claim === "object" ? claim.chatgpt_account_id : void 0;
+    return typeof value === "string" && value ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createCodexRequestIdentity(installationId = CODEX_INSTALLATION_ID) {
+  const sessionId = randomUUID4();
+  const threadId = randomUUID4();
+  const windowId = randomUUID4();
+  const turnId = randomUUID4();
+  const turnMetadata = {
+    installation_id: installationId,
+    session_id: sessionId,
+    thread_id: threadId,
+    turn_id: turnId,
+    window_id: windowId,
+    request_kind: "turn",
+    turn_started_at_unix_ms: Date.now()
+  };
+  const turnMetadataJson = JSON.stringify(turnMetadata);
+  return {
+    sessionId,
+    threadId,
+    windowId,
+    turnId,
+    turnMetadataJson,
+    clientMetadata: {
+      "x-codex-installation-id": installationId,
+      session_id: sessionId,
+      thread_id: threadId,
+      "x-codex-window-id": windowId,
+      turn_id: turnId,
+      "x-codex-turn-metadata": turnMetadataJson
+    }
+  };
+}
+function buildCodexCompatibilityHeaders(identity, accountId) {
+  return {
+    Authorization: "",
+    // filled by caller with bearer token
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    "chatgpt-account-id": accountId,
+    "OpenAI-Beta": CODEX_OPENAI_BETA,
+    originator: CODEX_ORIGINATOR,
+    version: CODEX_CLIENT_VERSION,
+    session_id: identity.sessionId,
+    conversation_id: identity.sessionId,
+    "x-client-request-id": identity.sessionId,
+    "session-id": identity.sessionId,
+    "thread-id": identity.threadId,
+    "x-codex-window-id": identity.windowId,
+    "x-codex-turn-metadata": identity.turnMetadataJson
+  };
+}
+function collectInstructions(messages, agentPrompt) {
+  const systemTexts = [];
+  const prompt = agentPrompt?.trim();
+  if (prompt) systemTexts.push(prompt);
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object") continue;
+    const role = String(raw.role ?? "");
+    if (role !== "system" && role !== "developer") continue;
+    const content = raw.content;
+    const stringContent = asOptionalTrimmedString(content);
+    if (stringContent) {
+      systemTexts.push(stringContent);
+    } else if (Array.isArray(content)) {
+      const text = content.filter(
+        (p) => !!p && p.type === "text"
+      ).map((p) => p.text).join("\n").trim();
+      if (text) systemTexts.push(text);
+    }
+  }
+  return systemTexts.join("\n\n");
+}
+function collectStableInstructions(messages, fallbackPrompt) {
+  const systemTexts = [];
+  if (fallbackPrompt?.trim()) systemTexts.push(fallbackPrompt.trim());
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object") continue;
+    const message = raw;
+    const role = String(message.role ?? "");
+    if (role !== "system" && role !== "developer") continue;
+    if (typeof message.content === "string") {
+      const boundary = Number(message.stable_prefix_chars);
+      const text = Number.isFinite(boundary) && boundary > 0 ? message.content.slice(0, boundary) : message.content;
+      if (text.trim()) systemTexts.push(text.trim());
+    }
+  }
+  return systemTexts.join("\n\n");
+}
+function stablePromptCacheKey(parts) {
+  const value = JSON.stringify(parts);
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `nolo-codex-${hash.toString(16).padStart(8, "0")}`;
+}
+function buildCodexRequestBody(args, identity = createCodexRequestIdentity()) {
+  const rawMessages = Array.isArray(args.openAiBody.messages) ? args.openAiBody.messages : [];
+  const nonSystem = rawMessages.filter((m) => {
+    const role = m && typeof m === "object" ? String(m.role) : "";
+    return role !== "system" && role !== "developer";
+  });
+  const input = convertMessagesToResponsesInput(nonSystem);
+  const instructions = collectInstructions(rawMessages, args.agentConfig.prompt);
+  const stableInstructions = collectStableInstructions(rawMessages, args.agentConfig.prompt);
+  const model = asOptionalTrimmedString(args.openAiBody.model) ?? asOptionalTrimmedString(args.agentConfig.model) ?? "gpt-5.5";
+  const tools = toResponsesTools(
+    Array.isArray(args.openAiBody.tools) ? args.openAiBody.tools : void 0
+  );
+  const body = {
+    model,
+    input,
+    stream: true,
+    store: false,
+    // Keep routing stable across turns and request UUIDs. Growing input/history
+    // is intentionally excluded; only stable request-prefix material belongs.
+    prompt_cache_key: stablePromptCacheKey([model, stableInstructions, tools ?? []]),
+    client_metadata: identity.clientMetadata
+  };
+  if (instructions) body.instructions = instructions;
+  if (tools && tools.length > 0) {
+    body.tools = tools;
+    body.tool_choice = "auto";
+    body.parallel_tool_calls = true;
+  }
+  return body;
+}
+function aggregateResponsesStream(events) {
+  let text = "";
+  const toolCalls = [];
+  let usage;
+  for (const ev of events) {
+    const type = String(ev.type ?? "");
+    if (type === "response.output_text.delta" && typeof ev.delta === "string") {
+      text += ev.delta;
+      continue;
+    }
+    if (type === "response.output_item.done") {
+      const item = ev.item;
+      if (item && item.type === "function_call") {
+        const name = typeof item.name === "string" ? item.name : "";
+        if (name) {
+          toolCalls.push({
+            id: typeof item.call_id === "string" && item.call_id ? item.call_id : `${name}_${toolCalls.length}`,
+            type: "function",
+            function: {
+              name,
+              arguments: typeof item.arguments === "string" ? item.arguments : "{}"
+            }
+          });
+        }
+      }
+      continue;
+    }
+    if (type === "response.completed") {
+      const response = ev.response;
+      const u = response?.usage;
+      if (u) {
+        const prompt = typeof u.input_tokens === "number" ? u.input_tokens : 0;
+        const completion = typeof u.output_tokens === "number" ? u.output_tokens : 0;
+        const total = typeof u.total_tokens === "number" ? u.total_tokens : prompt + completion;
+        usage = {
+          prompt_tokens: prompt,
+          completion_tokens: completion,
+          total_tokens: total
+        };
+      }
+    }
+  }
+  return { text, toolCalls, usage };
+}
+async function readSseEvents(response) {
+  return readSseDataValues(response, (line) => {
+    const ev = parseSseDataLineObject(line);
+    return ev && !Array.isArray(ev) ? ev : null;
+  });
+}
+async function fetchCodexResponsesCompletion(args) {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const accountId = args.accountId?.trim() || decodeCodexAccountId(args.accessToken);
+  if (!accountId) {
+    return {
+      status: 401,
+      body: {
+        error: {
+          message: "ChatGPT Codex credential is missing chatgpt_account_id. Re-run `nolo auth chatgpt`."
+        }
+      }
+    };
+  }
+  const identity = createCodexRequestIdentity();
+  const body = buildCodexRequestBody(args, identity);
+  const headers = buildCodexCompatibilityHeaders(identity, accountId);
+  headers.Authorization = `Bearer ${args.accessToken}`;
+  const response = await fetchImpl(CODEX_RESPONSES_URL, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: args.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      status: response.status,
+      body: { error: { message: errorText || response.statusText } }
+    };
+  }
+  const events = await readSseEvents(response);
+  const { text, toolCalls, usage } = aggregateResponsesStream(events);
+  const message = {
+    role: "assistant",
+    content: text || null
+  };
+  if (toolCalls.length > 0) message.tool_calls = toolCalls;
+  return {
+    status: 200,
+    body: {
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop"
+        }
+      ],
+      ...usage ? { usage } : {}
+    }
+  };
+}
+function isCodexOAuthAgent(agentConfig) {
+  if (!agentConfig) return false;
+  const apiKeyRef = asTrimmedLowercaseString(agentConfig.apiKeyRef);
+  return apiKeyRef === "chatgpt";
+}
+
 // packages/agent-runtime/oauthProviders.ts
 var XAI_ACCESS_TOKEN_CLIENT_SKEW_MS = 5 * 60 * 1e3;
 var decodeBase64 = (s) => Buffer.from(s, "base64").toString("utf8");
@@ -9496,7 +10707,7 @@ function buildOpenAiTools(args) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   const toolNameSet = new Set(args.toolNames ?? []);
   const callAgentTools = toolNameSet.has("callAgent") ? prepareTools(["callAgent"]) : [];
-  const uiAskChoiceTools = toolNameSet.has("ui_ask_choice") ? prepareTools(["ui_ask_choice"]) : [];
+  const uiAskChoiceTools = toolNameSet.has("ask_user") ? prepareTools(["ask_user"]) : [];
   const readPastedTextTools = toolNameSet.has("readPastedText") ? [
     {
       type: "function",
@@ -9556,10 +10767,10 @@ function buildOpenAiTools(args) {
 var CLI_DEFAULT_TOOLS = ["exa_search", "fetchWebpage"];
 function addDefaultCliCoreTools(toolNames, env, options) {
   const declaredOnly = env && shouldUseDeclaredOnlyLocalWorkspaceTools(env);
-  const forcedTools = options?.hasUserChoice === true ? FORCED_TOOLS : FORCED_TOOLS.filter((name) => name !== "ui_ask_choice");
+  const forcedTools = options?.hasUserChoice === true ? FORCED_TOOLS : FORCED_TOOLS.filter((name) => name !== "ask_user");
   const injected = declaredOnly ? [...forcedTools] : [...forcedTools, ...CLI_DEFAULT_TOOLS];
   const combined = [...toolNames, ...injected];
-  const filtered = options?.hasUserChoice === true ? combined : combined.filter((name) => name !== "ui_ask_choice");
+  const filtered = options?.hasUserChoice === true ? combined : combined.filter((name) => name !== "ask_user");
   return [...new Set(filtered)];
 }
 function resolveCliEffectiveEnabledPacks(args) {
@@ -9852,9 +11063,9 @@ function createCliCallAgentToolExecutor(deps, ctx) {
 // packages/cli/client/localRuntimeAdapter.ts
 var currentMetaFile = fileURLToPath(import.meta.url);
 var isJsBundle = extname(currentMetaFile) === ".js";
-var SOURCE_CLI_DIR = isJsBundle ? dirname(currentMetaFile) : dirname(dirname(currentMetaFile));
-var CLI_DIR = isCompiledBinary() ? dirname(process.execPath) : SOURCE_CLI_DIR;
-var CLI_ENTRYPOINT = isCompiledBinary() ? process.execPath : isJsBundle ? currentMetaFile : join(SOURCE_CLI_DIR, "index.ts");
+var SOURCE_CLI_DIR = isJsBundle ? dirname2(currentMetaFile) : dirname2(dirname2(currentMetaFile));
+var CLI_DIR = isCompiledBinary() ? dirname2(process.execPath) : SOURCE_CLI_DIR;
+var CLI_ENTRYPOINT = isCompiledBinary() ? process.execPath : isJsBundle ? currentMetaFile : join2(SOURCE_CLI_DIR, "index.ts");
 function createCliLocalRuntimeAdapter(deps) {
   const now = deps.now ?? Date.now;
   const createId = deps.createId ?? createFallbackId;
@@ -10200,6 +11411,74 @@ function createCliLocalRuntimeAdapter(deps) {
           }
         };
       }
+      if (isCodexOAuthAgent(agentConfig)) {
+        const accessToken = await apiKeyRefResolver("chatgpt");
+        if (!accessToken) {
+          throw new Error(
+            'OAuth credential for "chatgpt" not found locally. Run `nolo auth chatgpt`.'
+          );
+        }
+        const credential = readOAuthCredential("chatgpt");
+        const accountId = credential?.accountId;
+        const { requestedToolNames: requestedToolNames2, tools: tools2 } = resolveProviderOpenAiToolBundle(
+          agentConfig,
+          deps.env,
+          buildProviderOpenAiTools,
+          additionalToolNames,
+          { hasUserChoice: Boolean(deps.requestUserChoice) }
+        );
+        logLocalRuntimeDiagnostic("provider.selected", {
+          agentKey: agentConfig.key,
+          transport: "codex-responses",
+          provider: "openai",
+          model: agentConfig.model ?? "gpt-5.6-sol",
+          hasApiKey: true
+        });
+        return {
+          model: agentConfig.model || "gpt-5.6-sol",
+          complete: async (messages, options) => {
+            const result = await fetchCodexResponsesCompletion({
+              agentConfig,
+              accessToken,
+              ...accountId ? { accountId } : {},
+              openAiBody: {
+                model: agentConfig.model || "gpt-5.6-sol",
+                messages,
+                stream: false,
+                ...tools2.length > 0 ? { tools: tools2 } : {}
+              },
+              fetchImpl: (url, init) => fetchWithTransientRetry(fetchImpl, url, init, {
+                sleep: deps.sleep,
+                loopbackRequest
+              })
+            });
+            if (result.status < 200 || result.status >= 300) {
+              const errMsg = result.body?.error && typeof result.body.error === "object" && typeof result.body.error.message === "string" ? result.body.error.message : JSON.stringify(result.body);
+              throw new Error(
+                `local Codex OAuth provider failed: HTTP ${result.status} ${errMsg}`
+              );
+            }
+            const choice = Array.isArray(result.body.choices) ? result.body.choices[0] : void 0;
+            const message = choice?.message ?? {};
+            const content = typeof message.content === "string" ? message.content : "";
+            const tool_calls = Array.isArray(message.tool_calls) ? message.tool_calls : void 0;
+            if (content && options?.onTextDelta) options.onTextDelta(content);
+            logLocalRuntimeDiagnostic("provider.request.result", {
+              agentKey: agentConfig.key,
+              transport: "codex-responses",
+              ok: true,
+              contentChars: content.length,
+              toolCallCount: tool_calls?.length ?? 0,
+              requestedToolNames: requestedToolNames2
+            });
+            return {
+              content,
+              ...tool_calls ? { tool_calls } : {},
+              trace: messages
+            };
+          }
+        };
+      }
       if (isCursorOAuthAgent(agentConfig)) {
         const accessToken = await apiKeyRefResolver("cursor");
         if (!accessToken) {
@@ -10269,6 +11548,101 @@ function createCliLocalRuntimeAdapter(deps) {
           }
         };
       }
+      if (shouldUsePlatformChatProvider(deps.env, agentConfig) && isGemini3Model(agentConfig.model ?? "") && agentConfig.provider === "google") {
+        const providerConfig2 = await resolvePlatformChatProviderConfig({
+          agentConfig,
+          env: deps.env,
+          apiKeyRefResolver,
+          credentialBroker,
+          syncFetcher
+        });
+        const { requestedToolNames: requestedToolNames2, tools: tools2 } = resolveProviderOpenAiToolBundle(
+          agentConfig,
+          deps.env,
+          buildProviderOpenAiTools,
+          additionalToolNames,
+          { hasUserChoice: Boolean(deps.requestUserChoice) }
+        );
+        if (tools2.length > 0 && providerConfig2.apiKey && shouldUseGeminiNativeToolRoute(
+          agentConfig.provider ?? "",
+          agentConfig.model ?? "",
+          tools2,
+          () => false
+          // CLI 端不区分 image 模型
+        )) {
+          logLocalRuntimeDiagnostic("provider.selected", {
+            agentKey: agentConfig.key,
+            transport: "gemini-native-tool",
+            apiSource: agentConfig.apiSource ?? null,
+            provider: providerConfig2.provider,
+            model: providerConfig2.model,
+            hasApiKey: Boolean(providerConfig2.apiKey)
+          });
+          return {
+            model: providerConfig2.model,
+            complete: async (messages, options) => {
+              const requestBody = buildGeminiGenerateContentRequest({
+                messages,
+                tools: tools2,
+                maxTokens: typeof agentConfig.max_tokens === "number" ? agentConfig.max_tokens : void 0,
+                temperature: typeof agentConfig.temperature === "number" ? agentConfig.temperature : void 0,
+                attachSkipThoughtSignature: true
+              });
+              const model = providerConfig2.model;
+              const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse`;
+              logLocalRuntimeDiagnostic("provider.request.start", {
+                agentKey: agentConfig.key,
+                transport: "gemini-native-tool",
+                model,
+                messageCount: messages.length,
+                toolCount: tools2.length,
+                requestedToolNames: requestedToolNames2
+              });
+              const res = await fetchImpl(url, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "x-goog-api-key": providerConfig2.apiKey ?? ""
+                },
+                body: JSON.stringify(requestBody),
+                signal: AbortSignal.timeout(12e4)
+              });
+              if (!res.ok) {
+                const errText = await res.text();
+                logLocalRuntimeDiagnostic("provider.request.failed", {
+                  agentKey: agentConfig.key,
+                  transport: "gemini-native-tool",
+                  status: res.status,
+                  error: errText.slice(0, 200)
+                });
+                throw new Error(
+                  `gemini native tool provider failed: HTTP ${res.status} ${errText.slice(0, 500)}`
+                );
+              }
+              const chunks = await readSseDataValues(res, parseSseDataLineJson);
+              const { text, toolCalls, usage } = accumulateGeminiChunks(chunks);
+              if (text && options?.onTextDelta) {
+                options.onTextDelta(text);
+              }
+              const result = {
+                content: text,
+                model,
+                tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+                ...usage ? { usage } : {},
+                trace: messages
+              };
+              logLocalRuntimeDiagnostic("provider.request.result", {
+                agentKey: agentConfig.key,
+                transport: "gemini-native-tool",
+                ok: true,
+                contentChars: text.length,
+                toolCallCount: toolCalls.length
+              });
+              return result;
+            }
+          };
+        }
+      }
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
         const providerConfig2 = await resolvePlatformChatProviderConfig({
           agentConfig,
@@ -10329,47 +11703,20 @@ function createCliLocalRuntimeAdapter(deps) {
               },
               {
                 sleep: deps.sleep,
-                loopbackRequest
+                loopbackRequest,
+                // auto 档位转发 nolo.chat 时，网关层 502（server: Caddy、空 body）
+                // 意味着请求根本没到 Bun 上游，provider 未受理，重试安全。
+                // 与 429/503 同口径：不会重复计费/重复生成。
+                retryableStatuses: /* @__PURE__ */ new Set([429, 502, 503]),
+                onRetry: deps.activityReporter ? ({ attempt, maxAttempts, delayMs }) => {
+                  deps.activityReporter(
+                    `\u81EA\u52A8\u91CD\u8BD5 ${attempt}/${maxAttempts} \xB7 ${Math.ceil(delayMs / 1e3)}s`
+                  );
+                } : void 0
               }
             );
-            let responseProviderConfig = providerConfig2;
-            let firstErrorRaw;
             if (!res.ok) {
-              firstErrorRaw = await res.text().catch(() => "");
-              const fallbackProviderConfig = resolveLegacyDeepSeekProxyChatFallback({
-                providerConfig: providerConfig2,
-                status: res.status,
-                raw: firstErrorRaw
-              });
-              if (fallbackProviderConfig) {
-                responseProviderConfig = fallbackProviderConfig;
-                const fallbackRequest = buildPlatformChatCompletionRequest({
-                  providerConfig: fallbackProviderConfig,
-                  messages,
-                  tools: tools2,
-                  stream: false
-                });
-                logLocalRuntimeDiagnostic("provider.request.compatibility-fallback", {
-                  agentKey: agentConfig.key,
-                  provider: providerConfig2.provider,
-                  fromEndpoint: summarizeEndpoint(providerConfig2.endpoint) ?? null,
-                  toEndpoint: summarizeEndpoint(fallbackProviderConfig.endpoint) ?? null,
-                  reason: "legacy-proxy-responses-schema"
-                });
-                res = await fetchWithTransientRetry(
-                  fetchImpl,
-                  fallbackRequest.url,
-                  { ...fallbackRequest.init },
-                  {
-                    sleep: deps.sleep,
-                    loopbackRequest
-                  }
-                );
-                firstErrorRaw = void 0;
-              }
-            }
-            if (!res.ok) {
-              const raw2 = firstErrorRaw ?? await res.text().catch(() => "");
+              const raw2 = await res.text().catch(() => "");
               const data2 = parsePlatformChatCompletionData(raw2);
               const rawPreview = raw2.length > 200 ? `${raw2.slice(0, 200)}\u2026(${raw2.length}b)` : raw2;
               const gatewayHeaders = [
@@ -10420,7 +11767,7 @@ function createCliLocalRuntimeAdapter(deps) {
             });
             const data = parsePlatformChatCompletionData(raw);
             return parsePlatformChatCompletionResponse({
-              providerConfig: responseProviderConfig,
+              providerConfig: providerConfig2,
               data,
               trace: messages
             });
@@ -10521,6 +11868,23 @@ function createCliLocalRuntimeAdapter(deps) {
       };
     },
     executeTool: async (call, opts) => {
+      const contextualCall = opts?.runtimeContext ? { ...call, runtimeContext: opts.runtimeContext } : call;
+      let injectedCall = contextualCall;
+      if (contextualCall.name === "startAgentRun" && deps.parentDialogId && typeof contextualCall.arguments === "string") {
+        try {
+          const args = JSON.parse(contextualCall.arguments);
+          if (!args.parentDialogId) {
+            injectedCall = {
+              ...contextualCall,
+              arguments: JSON.stringify({
+                ...args,
+                parentDialogId: deps.parentDialogId
+              })
+            };
+          }
+        } catch {
+        }
+      }
       assertWithinLocalToolBudget({
         toolName: call.name,
         budgets: localToolBudgets,
@@ -10529,7 +11893,7 @@ function createCliLocalRuntimeAdapter(deps) {
       const result = await executeLocalToolWithPolicy({
         env: deps.env,
         agentToolNames: activeAgentToolNames,
-        call,
+        call: injectedCall,
         executors: localToolExecutors,
         abortSignal: opts?.abortSignal,
         detachMs: resolveExecShellDetachMs(deps.env),
@@ -10550,6 +11914,8 @@ function createCliLocalRuntimeAdapter(deps) {
 export {
   summarizeEndpoint,
   isBuiltinNoloAgentRef,
+  readTimestamp,
+  parseAgentRunEvent,
   parseCliLocale,
   getCliLocale,
   setCliLocale,
@@ -10557,6 +11923,8 @@ export {
   t,
   toolLabel,
   agentRunCardLabels,
+  QUOTA_ERROR_PATTERNS,
+  isQuotaExhaustedError,
   clearCliLocalRuntimePreparedAgentCache,
   createCliCallAgentToolExecutor,
   createCliLocalRuntimeAdapter