nolo-cli 0.16.0-alpha.11 → 0.16.0-alpha.13

package/{chunk-ZH62XNZE.js → chunk-6IZTYSJK.js}

@@ -21,7 +21,7 @@ import {
 import {
   inlineImageUrlsForCustomProvider,
   prepareTools
-} from "./chunk-47QUPRHO.js";
+} from "./chunk-EPCM5E6C.js";
 import {
   getAntigravityUserAgent,
   isAntigravityOAuthAgent,
@@ -30,27 +30,19 @@ import {
 } from "./chunk-L6NVTGI7.js";
 import {
   FORCED_TOOLS,
-  TASK_PREVIEW_MAX,
   addDefaultLightWebToolsForConfiguredAgents,
   addDefaultSystemCapabilityTools,
   appendEnabledPackPromptPatches,
   applyDisabledTools,
   applySystemBuiltinSkillFilter,
   expandEnabledPacks,
-  formatListRunsCard,
-  formatNotFoundRunCard,
-  formatStartRunCard,
-  formatStatusRunCard,
-  formatStopRunCard,
-  isAgentNameFallback,
   readXPostFunc,
   readXPostFunctionSchema,
   readXhsProfileFunc,
   readXhsProfileFunctionSchema,
   rememberMemoryFunctionSchema,
-  resolveEffectiveEnabledPacks,
-  resolveRunLabel
-} from "./chunk-D4NCEGGR.js";
+  resolveEffectiveEnabledPacks
+} from "./chunk-TSGUTKW2.js";
 import {
   createDrainExhaustedResponse,
   isCoreDrainingBody,
@@ -62,13 +54,13 @@ import {
 } from "./chunk-OWOHNGCN.js";
 import {
   prepareTokenUsageData
-} from "./chunk-4LXOVZ4W.js";
+} from "./chunk-KEPSRWXW.js";
 import {
   BUILTIN_TITLE_LLM_CONFIG
 } from "./chunk-XOIF2TNF.js";
 import {
   fetchServerSyncedCredential
-} from "./chunk-ZXQ52OY2.js";
+} from "./chunk-COIZN2AL.js";
 import {
   buildAgentRuntimeDialogWritePlan,
   buildLocalWorkspaceOpenAiTools,
@@ -138,9 +130,22 @@ import {
   checkStaleRun,
   finalizeRunRecord,
   findRunRecord,
-  listRunRecords,
+  gcRunRecords,
+  queryRunRecords,
   spawnLocalBackgroundRun
-} from "./chunk-MYMMNKYL.js";
+} from "./chunk-E5CLOOG5.js";
+import {
+  TASK_PREVIEW_MAX,
+  formatListRunsCard,
+  formatNotFoundRunCard,
+  formatStartRunCard,
+  formatStatusRunCard,
+  formatStopRunCard,
+  isAgentNameFallback,
+  isAgentRunTerminalStatus,
+  resolveRunLabel,
+  shortRunId
+} from "./chunk-FKXFCYVO.js";
 import {
   CliProviderQuotaError,
   executeCli
@@ -950,6 +955,185 @@ function agentRunCardLabels() {
   };
 }
 
+// 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();
@@ -989,7 +1173,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
@@ -2048,7 +2232,7 @@ function buildServerPlatformToolExecutors(args) {
 }
 
 // packages/cli/client/cliAgentRunToolExecutors.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 
 // packages/cli/client/agentRunSnapshot.ts
 function readString(value) {
@@ -2135,6 +2319,276 @@ function parseAgentRunEvent(event) {
   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
 var noopOutput = { write: () => {
 } };
@@ -2145,7 +2599,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 {
@@ -2157,6 +2611,10 @@ 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 createCliStartAgentRunExecutor(deps = {}) {
   return async (call) => {
     const args = parseCallArgs(call);
@@ -2164,6 +2622,29 @@ 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 ---
@@ -2179,13 +2660,15 @@ ${JSON.stringify(args.input)}`;
       ...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 } : {},
         cwd: deps.cwd ?? process.cwd(),
         message,
         output: noopOutput
@@ -2195,10 +2678,39 @@ ${JSON.stringify(args.input)}`;
     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",
+        // 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 } : {}
       }),
@@ -2218,26 +2730,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`);
     }
@@ -2256,6 +2845,25 @@ function createCliControlAgentRunExecutor(deps = {}) {
       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,
@@ -10420,9 +11028,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;
@@ -11262,6 +11870,8 @@ export {
   t,
   toolLabel,
   agentRunCardLabels,
+  QUOTA_ERROR_PATTERNS,
+  isQuotaExhaustedError,
   clearCliLocalRuntimePreparedAgentCache,
   createCliCallAgentToolExecutor,
   createCliLocalRuntimeAdapter