nolo-cli 0.98.0-alpha.4 → 0.98.0

package/{chunk-KQHGZWSV.js → chunk-OXME3PEE.js}

@@ -2,7 +2,7 @@ import {
   getRecordTimestamp,
   isTombstoneRecord,
   shouldReplaceWithNextRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-D2MDMY2M.js";
 
 // packages/database/userDataMerge.ts
 var getUserDataItemTimestamp = (dataItem) => getRecordTimestamp(dataItem);

package/{chunk-ITM7D3UQ.js → chunk-P5L7VVMT.js}

@@ -3,7 +3,7 @@ import {
   createFileCredentialBroker,
   migrateAgentSecrets,
   normalizeAgentRuntimeToolPolicy
-} from "./chunk-HVURBGF3.js";
+} from "./chunk-XFUBXRVI.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -11,16 +11,18 @@ import {
   patch,
   remove,
   write
-} from "./chunk-H62HCIUP.js";
+} from "./chunk-4FFUDT6D.js";
+import {
+  getRuntimeServerContext
+} from "./chunk-UJXNKP5V.js";
 import {
   createAgentKey,
   toTrimmedString
-} from "./chunk-VMFTFOWF.js";
+} from "./chunk-3AH7LNUB.js";
 import {
   asyncThunkCreator,
-  buildCreateSlice,
-  getRuntimeServerContext
-} from "./chunk-UKWGR5SS.js";
+  buildCreateSlice
+} from "./chunk-VY6VFGKR.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -304,7 +306,7 @@ var slice = createSliceWithThunks({
       const overrides = {};
       if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
       if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
-      const { _executeModel } = await import("./_executeModel-HYZ4NXRJ.js");
+      const { _executeModel } = await import("./_executeModel-GJK4ZVU6.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -325,7 +327,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-JFFIFP7N.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-MTI5OU2W.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -341,7 +343,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-HFVTDCFD.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-IANOWAKR.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**

package/{chunk-TOP2VXOR.js → chunk-PCF3QU5Q.js}

@@ -1,12 +1,12 @@
-import {
-  selectCurrentServer
-} from "./chunk-AFUORTY4.js";
 import {
   patch
-} from "./chunk-H62HCIUP.js";
+} from "./chunk-4FFUDT6D.js";
+import {
+  selectCurrentServer
+} from "./chunk-NWENLDMM.js";
 import {
   getIsDesktopApp
-} from "./chunk-QOKAKDPE.js";
+} from "./chunk-HIM3FCLF.js";
 import {
   selectIdentityToken
 } from "./chunk-SEJ5OS6F.js";

package/{chunk-WV42OMV7.js → chunk-PTDYOADJ.js}

@@ -1,6 +1,3 @@
-import {
-  BUILTIN_PLATFORM_AGENT_KEYS
-} from "./chunk-BNGW5ASC.js";
 import {
   getRuntimeServerContext,
   partitionReadServers,
@@ -10,17 +7,20 @@ import {
   scheduleExistingRecordReplication,
   shouldReplaceLocalWithRemoteRecord,
   shouldReplicateLocalRecord
-} from "./chunk-UKWGR5SS.js";
+} from "./chunk-UJXNKP5V.js";
+import {
+  shouldReplaceWithNextRecord
+} from "./chunk-D2MDMY2M.js";
+import {
+  BUILTIN_PLATFORM_AGENT_KEYS
+} from "./chunk-BNGW5ASC.js";
 import {
   fetchFromClientDb,
   fetchFromServer,
   isAbortError,
   isReadTimeoutError,
   logger
-} from "./chunk-QOKAKDPE.js";
-import {
-  shouldReplaceWithNextRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-HIM3FCLF.js";
 import {
   NOLO_CLUSTER_SERVERS,
   normalizeKnownServerOrigin

package/{chunk-6D6VBVEW.js → chunk-SNMQMOD2.js}

@@ -1,9 +1,19 @@
+import {
+  _appendRetiredStateBatch,
+  loadMemoryVNextCatalog
+} from "./chunk-TY3TIUJK.js";
 import {
   resolveMachineId
 } from "./chunk-ESHYE7WU.js";
 import {
   getDefaultCliLocalRuntimeDb
-} from "./chunk-2F7RJC6L.js";
+} from "./chunk-FOXQ7BAB.js";
+import {
+  resolveAuthTokenFromEnv
+} from "./chunk-A7GB5UGH.js";
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
 import {
   buildCliRuntimeEnv,
   clearProfileAuthToken,
@@ -12,20 +22,14 @@ import {
   getProfileTokens,
   loadProfileConfig,
   saveDefaultProfile
-} from "./chunk-BYMV6QZG.js";
-import {
-  resolveAuthTokenFromEnv
-} from "./chunk-A7GB5UGH.js";
-import {
-  DEFAULT_NOLO_SERVER_URL
-} from "./chunk-OLZBQWZU.js";
+} from "./chunk-TNIX77YM.js";
 import {
   asTrimmedNonEmptyStringArray,
   createMemoryKey,
   createMemoryOwnerIndexKey,
   createMemorySubjectKindIndexKey,
   memoryOwnerRange
-} from "./chunk-VMFTFOWF.js";
+} from "./chunk-3AH7LNUB.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -39,6 +43,29 @@ import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 
 // packages/ai/memory/delete.ts
+var VNEXT_STATE_ID_PREFIX = "vnext-state-";
+var toVNextMemoryItem = (state, owner) => ({
+  id: `${VNEXT_STATE_ID_PREFIX}${state.id}`,
+  ownerType: owner.ownerType,
+  ownerId: owner.ownerId,
+  visibility: "private",
+  subjectType: "user",
+  subjectId: owner.ownerId,
+  kind: "semantic",
+  content: state.text.trim(),
+  createdAt: state.createdAt,
+  lastActivatedAt: state.createdAt,
+  activationCount: 1,
+  importance: 0.9,
+  confidence: 0.9,
+  resident: state.facet === "preference" || state.facet === "style"
+});
+var matchesVNextFilters = (state, idSet, contentSub) => {
+  if (!idSet && !contentSub) return false;
+  if (idSet && !idSet.has(`${VNEXT_STATE_ID_PREFIX}${state.id}`)) return false;
+  if (contentSub && !state.text.toLowerCase().includes(contentSub)) return false;
+  return true;
+};
 function hasExplicitDeleteFilters(filters) {
   return Boolean(
     filters.ids && filters.ids.length > 0 || typeof filters.contentSubstring === "string" && filters.contentSubstring.trim().length > 0 || filters.tags && filters.tags.length > 0 || typeof filters.sourceDialogId === "string" && filters.sourceDialogId.trim().length > 0 || typeof filters.patternKeyPrefix === "string" && filters.patternKeyPrefix.trim().length > 0 || filters.facets && filters.facets.length > 0 || typeof filters.subjectId === "string" && filters.subjectId.trim().length > 0
@@ -127,8 +154,32 @@ var deleteMemoriesForOwnerFromDb = async (db, owner, filters = {}) => {
     matchedItems.push(item);
     if (matchedItems.length >= limit) break;
   }
+  const idSet = normalizeSet(filters.ids);
+  const contentSub = asTrimmedString(filters.contentSubstring).toLowerCase();
+  const vnextStateIdsToRetire = [];
+  const vnextStatesToRetire = [];
+  const vnextMatchedItems = [];
+  let vnextPrincipalId = null;
+  const hasScopingFilters = Boolean(
+    normalizeSet(filters.kinds) || normalizeSet(filters.facets) || normalizeSet(filters.tags) || asTrimmedString(filters.subjectType) || asTrimmedString(filters.subjectId) || asTrimmedString(filters.patternKeyPrefix) || asTrimmedString(filters.sourceDialogId)
+  );
+  const canMatchVNext = !hasScopingFilters && (contentSub.length > 0 || idSet !== null && [...idSet].some((id) => id.startsWith(VNEXT_STATE_ID_PREFIX)));
+  if (canMatchVNext) {
+    vnextPrincipalId = `${owner.ownerType}:${encodeURIComponent(owner.ownerId)}`;
+    const catalog = await loadMemoryVNextCatalog(db, vnextPrincipalId);
+    for (const state of catalog.states) {
+      if (matchedItems.length >= limit) break;
+      if (state.retiredAt) continue;
+      if (!matchesVNextFilters(state, idSet, contentSub)) continue;
+      vnextStateIdsToRetire.push(state.id);
+      vnextStatesToRetire.push(state);
+      const projected = toVNextMemoryItem(state, owner);
+      vnextMatchedItems.push(projected);
+      matchedItems.push(projected);
+    }
+  }
   if (matchedItems.length === 0) {
-    return { deletedCount: 0, deletedIds: [], matchedItems: [] };
+    return { deletedCount: 0, deletedIds: [], retiredIds: [], matchedItems: [] };
   }
   const token = generateMemoryDeletionToken(
     owner.ownerId,
@@ -138,6 +189,7 @@ var deleteMemoriesForOwnerFromDb = async (db, owner, filters = {}) => {
     return {
       deletedCount: 0,
       deletedIds: [],
+      retiredIds: [],
       matchedItems,
       deletionToken: token
     };
@@ -147,14 +199,28 @@ var deleteMemoriesForOwnerFromDb = async (db, owner, filters = {}) => {
       "deletionToken mismatch: memory dataset changed since preview; please rerun dry-run preview before confirming."
     );
   }
-  const batch = db.batch();
-  for (const item of matchedItems) {
-    deleteMemoryItemWithIndexesInBatch(batch, item);
+  const vnextMatchedIdSet = new Set(
+    vnextStateIdsToRetire.map((stateId) => `${VNEXT_STATE_ID_PREFIX}${stateId}`)
+  );
+  const legacyItems = matchedItems.filter((item) => !vnextMatchedIdSet.has(item.id));
+  const shouldRetireVNext = vnextStatesToRetire.length > 0;
+  if (legacyItems.length > 0 || shouldRetireVNext) {
+    const batch = db.batch();
+    for (const item of legacyItems) {
+      deleteMemoryItemWithIndexesInBatch(batch, item);
+    }
+    if (shouldRetireVNext) {
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      for (const state of vnextStatesToRetire) {
+        _appendRetiredStateBatch(batch, { ...state, retiredAt: nowIso });
+      }
+    }
+    await batch.write();
   }
-  await batch.write();
   return {
     deletedCount: matchedItems.length,
     deletedIds: matchedItems.map((item) => item.id),
+    retiredIds: vnextMatchedItems.map((item) => item.id),
     matchedItems,
     deletionToken: token
   };

package/{chunk-BYMV6QZG.js → chunk-TNIX77YM.js}

@@ -308,6 +308,8 @@ function saveProfileOAuthSync(provider, sync, path = getDefaultProfileConfigPath
 }
 
 export {
+  normalizeProfileServerUrl,
+  isProtectedHomeProfileWrite,
   getDefaultProfileConfigPath,
   loadProfileConfig,
   clearProfileAuthToken,
@@ -319,6 +321,8 @@ export {
   getCurrentProfile,
   saveProfileLocale,
   getAgentSelectionAuditPath,
+  redactArgvSecrets,
+  appendAgentSelectionAudit,
   readLastAgentSelectionAudit,
   saveProfileAgentSelection,
   getProfileOAuthSync,

package/{chunk-Z77CRGTW.js → chunk-TVCAR26G.js}

@@ -1,7 +1,7 @@
 import {
   buildAgentRuntimeAgentLookupKeys,
   shouldFetchAgentRuntimeRecordRemotely
-} from "./chunk-IIVGDG4I.js";
+} from "./chunk-4YSOUKUR.js";
 
 // packages/cli/client/localAgentRecords.ts
 var buildLocalAgentLookupKeys = buildAgentRuntimeAgentLookupKeys;

package/chunk-TY3TIUJK.js

@@ -0,0 +1,89 @@
+import {
+  isLevelNotFoundError
+} from "./chunk-OW765XBU.js";
+
+// packages/ai/memory/vnext/store.ts
+var enc = (value) => encodeURIComponent(value).replace(/-/g, "%2D");
+var rangeOf = (prefix) => ({ gte: prefix, lte: `${prefix}\uFFFF` });
+var entityKey = (ownerId, id) => `mem2-e-${enc(ownerId)}-${enc(id)}`;
+var entityOwnerPrefix = (ownerId) => `mem2-e-${enc(ownerId)}-`;
+var stateKey = (ownerId, id) => `mem2-s-${enc(ownerId)}-${enc(id)}`;
+var stateEntityIndexKey = (ownerId, entityId, stateId) => `mem2-si-${enc(ownerId)}-${enc(entityId)}-${enc(stateId)}`;
+var stateEntityIndexPrefix = (ownerId, entityId) => `mem2-si-${enc(ownerId)}-${enc(entityId)}-`;
+var evidenceKey = (ownerId, id) => `mem2-v-${enc(ownerId)}-${enc(id)}`;
+var relationKey = (ownerId, id) => `mem2-r-${enc(ownerId)}-${enc(id)}`;
+var relationFromIndexKey = (ownerId, from, relationId) => `mem2-rf-${enc(ownerId)}-${enc(from)}-${enc(relationId)}`;
+var relationToIndexKey = (ownerId, to, relationId) => `mem2-rt-${enc(ownerId)}-${enc(to)}-${enc(relationId)}`;
+var readIndexed = async (db, prefix) => {
+  const refs = [];
+  for await (const [, value] of db.iterator({ ...rangeOf(prefix), reverse: false })) {
+    if (typeof value?.key === "string") refs.push(value.key);
+  }
+  const rows = await Promise.all(refs.map((key) => db.get(key).catch(() => null)));
+  return rows.filter((row) => !!row);
+};
+var getMemoryEntityVNext = async (db, ownerId, entityId) => db.get(entityKey(ownerId, entityId)).catch(() => null);
+var listMemoryEntitiesVNext = async (db, ownerId) => {
+  const rows = [];
+  for await (const [, value] of db.iterator({
+    ...rangeOf(entityOwnerPrefix(ownerId)),
+    reverse: false
+  })) {
+    if (value) rows.push(value);
+  }
+  return rows;
+};
+var loadMemoryVNextCatalog = async (db, ownerId) => {
+  const entities = await listMemoryEntitiesVNext(db, ownerId);
+  const states = (await Promise.all(entities.map((entity) => listMemoryStatesForEntityVNext(db, ownerId, entity.id)))).flat();
+  return { entities, states };
+};
+var getMemoryStateVNext = async (db, ownerId, stateId) => db.get(stateKey(ownerId, stateId)).catch(() => null);
+var listMemoryStatesForEntityVNext = (db, ownerId, entityId) => readIndexed(db, stateEntityIndexPrefix(ownerId, entityId));
+var putMemoryEvidenceVNext = async (db, evidence) => {
+  await db.put(evidenceKey(evidence.ownerId, evidence.id), evidence);
+};
+var getMemoryEvidenceVNext = async (db, ownerId, evidenceId) => db.get(evidenceKey(ownerId, evidenceId)).catch(() => null);
+var getMemoryEvidenceVNextStrict = async (db, ownerId, evidenceId) => {
+  try {
+    return await db.get(evidenceKey(ownerId, evidenceId));
+  } catch (error) {
+    if (isLevelNotFoundError(error)) return null;
+    throw error;
+  }
+};
+var _appendEntityBatch = (batch, entity) => {
+  batch.put(entityKey(entity.ownerId, entity.id), entity);
+};
+var _appendEvidenceBatch = (batch, evidence) => {
+  batch.put(evidenceKey(evidence.ownerId, evidence.id), evidence);
+};
+var _appendStateBatch = (batch, state) => {
+  const key = stateKey(state.ownerId, state.id);
+  batch.put(key, state);
+  batch.put(stateEntityIndexKey(state.ownerId, state.entityId, state.id), { key });
+};
+var _appendRetiredStateBatch = (batch, state) => {
+  batch.put(stateKey(state.ownerId, state.id), state);
+};
+var _appendRelationBatch = (batch, relation) => {
+  const key = relationKey(relation.ownerId, relation.id);
+  batch.put(key, relation);
+  batch.put(relationFromIndexKey(relation.ownerId, relation.from, relation.id), { key });
+  batch.put(relationToIndexKey(relation.ownerId, relation.to, relation.id), { key });
+};
+
+export {
+  getMemoryEntityVNext,
+  loadMemoryVNextCatalog,
+  getMemoryStateVNext,
+  listMemoryStatesForEntityVNext,
+  putMemoryEvidenceVNext,
+  getMemoryEvidenceVNext,
+  getMemoryEvidenceVNextStrict,
+  _appendEntityBatch,
+  _appendEvidenceBatch,
+  _appendStateBatch,
+  _appendRetiredStateBatch,
+  _appendRelationBatch
+};

package/{chunk-I3TQJXQ7.js → chunk-U3C3IA32.js}

@@ -1,6 +1,6 @@
 import {
   isAgentRunTerminalStatus
-} from "./chunk-3VNWWVKB.js";
+} from "./chunk-E3YWHWCR.js";
 import {
   isCompiledBinary,
   resolveCliEntrypointPath
@@ -1056,7 +1056,14 @@ function defaultGetProcessStartTime(pid) {
     const output = nodeExecFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
-      timeout: 1e3
+      timeout: 1e3,
+      // `ps -o lstart` 的日期串随系统 locale 变化：
+      //   LANG=en_US.UTF-8 → "Thu Oct  8 08:54:18 2026"（new Date 可解析）
+      //   LANG=zh_CN.UTF-8 → "四 10月  8 08:54:18 2026"（new Date → NaN → null）
+      // 这会让 isPidReused 的结论依赖调用者环境：同一条 run 记录在英文
+      // locale 下被判 pid reused → orphaned，中文 locale 下不判。强制 C
+      // locale 让输出恒为可解析的英文格式，结果与 locale 无关。
+      env: { ...process.env, LC_ALL: "C", LANG: "C" }
     }).trim();
     if (!output) return null;
     const d = new Date(output);

package/{chunk-RG6JBBX5.js → chunk-U7XXEI5R.js}

@@ -3,21 +3,28 @@ import {
 } from "./chunk-YYLHWIW6.js";
 import {
   compareAgentSelection
-} from "./chunk-IIVGDG4I.js";
+} from "./chunk-4YSOUKUR.js";
+import {
+  isAgentUnavailableNow
+} from "./chunk-H6A6X4EK.js";
+import {
+  isSubscriptionEndpoint,
+  isSubscriptionOAuthCredential
+} from "./chunk-EKPKW6RM.js";
 import {
   isAntigravityOAuthAgent
-} from "./chunk-UZGQNTVW.js";
+} from "./chunk-UA324D4O.js";
 import {
   getModelAbility
-} from "./chunk-ACTMNVHM.js";
+} from "./chunk-CYSYR67N.js";
+import {
+  fnv1a32Hex
+} from "./chunk-UJXNKP5V.js";
 import {
   isOwnedAgentKey,
   ownedAgentKey,
   publicAgentKey
 } from "./chunk-M2EJHDJP.js";
-import {
-  fnv1a32Hex
-} from "./chunk-UKWGR5SS.js";
 
 // packages/ai/agent/agentBilling.ts
 function resolveBillingSource(candidate) {
@@ -36,6 +43,9 @@ function resolveBillingSource(candidate) {
   }
   if (candidate?.isOAuth === true || candidate?.billingSource === "user_subscription" || candidate?.apiSource === "oauth" || isOAuthApiKeyRef(candidate?.apiKeyRef)) return "user_subscription";
   if (candidate?.apiSource === "custom" || candidate?.billingSource === "user_api") {
+    if (isSubscriptionEndpoint(candidate?.customProviderUrl) || isSubscriptionOAuthCredential(candidate?.apiKeyRef)) {
+      return "user_subscription";
+    }
     return "user_api";
   }
   return "platform_credits";
@@ -227,6 +237,16 @@ function deriveCredentialGroup(ref) {
     credentialKind: "api-key"
   };
 }
+function deriveCustomProviderCredentialGroup(userId, customProviderUrl) {
+  if (typeof customProviderUrl !== "string" || !customProviderUrl.trim()) {
+    return void 0;
+  }
+  const basis = `${userId ?? ""}|${customProviderUrl.trim().toLowerCase()}`;
+  return {
+    credentialGroup: `custom-${fnv1a32Hex(basis)}`,
+    credentialKind: "api-key"
+  };
+}
 function summarizeCredentialGroups(agents, now = Date.now()) {
   const groups = /* @__PURE__ */ new Map();
   for (const agent of agents) {
@@ -327,6 +347,15 @@ function resolveFavoriteStatus(record, options) {
   }
   return { isFavorite: false, favoritedAt: null };
 }
+function isOwnedAgentRecord(record, userId) {
+  if (!userId) return false;
+  if (typeof record?.userId === "string" && record.userId === userId || typeof record?.ownerId === "string" && record.ownerId === userId) {
+    return true;
+  }
+  return [record?.dbKey, record?.privateKey].some(
+    (key) => isOwnedAgentKey(key, userId)
+  );
+}
 function toSafeAgentSummary(record, options) {
   const rawId = parseAgentRecordId(
     typeof record?.privateKey === "string" ? record.privateKey : record?.dbKey,
@@ -356,12 +385,13 @@ function toSafeAgentSummary(record, options) {
   const isPublic = record?.isPublic === true || record?.isPublicFlag === true || record?.publicRecordExists === true;
   const updatedAt = safeTimestamp(record?.updatedAt ?? record?.createdAt ?? record?.created);
   const nextAvailableAt = typeof record?.nextAvailableAt === "number" && Number.isFinite(record.nextAvailableAt) ? record.nextAvailableAt : void 0;
+  const rawQuota = record?.quota;
+  const quota = rawQuota && typeof rawQuota === "object" && Array.isArray(rawQuota.windows) && typeof rawQuota.observedAt === "number" && Number.isFinite(rawQuota.observedAt) ? rawQuota : void 0;
   const currentUserId = options?.userId;
-  const isOwnedByRecord = Boolean(currentUserId) && (typeof record?.userId === "string" && record.userId === currentUserId || typeof record?.ownerId === "string" && record.ownerId === currentUserId);
   const ownedKey = currentUserId ? [record?.dbKey, record?.privateKey].find(
     (key) => isOwnedAgentKey(key, currentUserId)
   ) : void 0;
-  const isOwned = isOwnedByRecord || Boolean(ownedKey);
+  const isOwned = isOwnedAgentRecord(record, currentUserId);
   const isOAuth = isOAuthApiKeyRef(record?.apiKeyRef);
   const billingSource = resolveBillingSource({
     ...record,
@@ -418,6 +448,7 @@ function toSafeAgentSummary(record, options) {
     isOwned,
     isOAuth,
     ...nextAvailableAt !== void 0 ? { nextAvailableAt } : {},
+    ...quota !== void 0 ? { quota } : {},
     ...credentialGroup !== void 0 ? { credentialGroup } : {},
     ...credentialKind !== void 0 ? { credentialKind } : {},
     // 「未知 ≠ 独立」：无 credentialGroup 时显式 credentialed:false，调用方
@@ -448,6 +479,8 @@ var COMPACT_AGENT_SUMMARY_FIELDS = [
   // 决策信息（CLI --show-unavailable 场景）；默认列表已把这类 agent 过滤掉，
   // 所以通常根本不占字节。
   "nextAvailableAt",
+  // 额度快照：只有上游真上报过窗口的 agent 才带（通常是小对象）。
+  "quota",
   "credentialGroup",
   "credentialKind",
   "credentialed"
@@ -481,6 +514,7 @@ var UNAVAILABLE_AGENT_SUMMARY_FIELDS = [
   "isOAuth",
   "isOwned",
   "nextAvailableAt",
+  "quota",
   "favoritedAt",
   "updatedAt"
 ];
@@ -500,12 +534,131 @@ function toUnavailableAgentSummary(summary) {
   return item;
 }
 
+// packages/ai/agent/agentDiscovery.ts
+function isPreferredAgent(agent) {
+  return agent.isFavorite === true || agent.isOwned === true || agent.isOAuth === true || agent.billingSource === "user_subscription" || agent.billingSource === "user_api" || agent.billingSource === "local";
+}
+function isPublicDiscoveryAgent(agent) {
+  return agent.isPublic === true && !isPreferredAgent(agent);
+}
+function resolveDiscoveryScope(args) {
+  const rawScope = typeof args?.scope === "string" ? args.scope.trim().toLowerCase() : void 0;
+  const hasScope = rawScope !== void 0 && rawScope !== "";
+  const hasPublicOnly = typeof args?.publicOnly === "boolean";
+  const publicOnly = args?.publicOnly === true;
+  if (hasScope) {
+    if (rawScope !== "preferred" && rawScope !== "public" && rawScope !== "all") {
+      throw new Error(`Invalid scope '${args?.scope}': must be 'preferred', 'public', or 'all'.`);
+    }
+    const scope = rawScope;
+    if (hasPublicOnly) {
+      if (publicOnly && scope !== "public") {
+        throw new Error(
+          `Conflicting arguments: scope='${args?.scope}' conflicts with publicOnly=true.`
+        );
+      }
+      if (!publicOnly && scope === "public") {
+        throw new Error(
+          `Conflicting arguments: scope='${args?.scope}' conflicts with publicOnly=false.`
+        );
+      }
+    }
+    return scope;
+  }
+  if (hasPublicOnly && publicOnly) {
+    return "public";
+  }
+  return "preferred";
+}
+function agentIdentityKeys(agent) {
+  return [agent.agentKey, agent.publicKey, agent.id].filter(
+    (key) => typeof key === "string" && key.length > 0
+  );
+}
+function deduplicateAgentSummaries(agents) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    const keys = agentIdentityKeys(agent);
+    const existing = keys.map((key) => byIdentity.get(key)).find(Boolean);
+    if (!existing) {
+      for (const key of keys) byIdentity.set(key, agent);
+      continue;
+    }
+    const winner = isPreferredAgent(agent) && !isPreferredAgent(existing) ? agent : existing;
+    for (const key of /* @__PURE__ */ new Set([...agentIdentityKeys(existing), ...keys])) byIdentity.set(key, winner);
+  }
+  return [...new Set(byIdentity.values())];
+}
+function filterAgentsByScope(agents, scope) {
+  const unique = deduplicateAgentSummaries(agents);
+  if (scope === "preferred") return unique.filter((agent) => isPreferredAgent(agent));
+  if (scope === "public") return unique.filter((agent) => isPublicDiscoveryAgent(agent));
+  return unique.filter((agent) => isPreferredAgent(agent) || agent.isPublic === true);
+}
+function matchesAgentQuery(agent, query) {
+  if (!query || typeof query !== "string") return true;
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const candidates = [
+    agent.name,
+    agent.model,
+    agent.provider,
+    agent.handle,
+    agent.agentKey,
+    agent.publicKey,
+    agent.id
+  ];
+  return candidates.some((text) => typeof text === "string" && text.toLowerCase().includes(q));
+}
+function buildAgentDiscoveryResult(options) {
+  const scope = resolveDiscoveryScope({
+    scope: options.scope,
+    publicOnly: options.publicOnly
+  });
+  const now = options.now ?? Date.now();
+  let scopedAgents = filterAgentsByScope(options.agents, scope);
+  if (options.query && typeof options.query === "string" && options.query.trim()) {
+    scopedAgents = scopedAgents.filter((a) => matchesAgentQuery(a, options.query));
+  }
+  const unavailableList = scopedAgents.filter((a) => isAgentUnavailableNow(a, now));
+  const unavailableCount = unavailableList.length;
+  const unavailableAgents = sortSafeAgentSummaries(unavailableList).map(toUnavailableAgentSummary);
+  const credentialGroups = summarizeCredentialGroups(scopedAgents, now);
+  if (options.showUnavailable !== true) {
+    scopedAgents = scopedAgents.filter((a) => !isAgentUnavailableNow(a, now));
+  }
+  const sortedAgents = sortSafeAgentSummaries(scopedAgents);
+  const projectedAgents = options.verbose === true ? sortedAgents.map(omitNullishAgentSummaryFields) : sortedAgents.map(toCompactAgentSummary);
+  return {
+    total: projectedAgents.length,
+    unavailableCount,
+    unavailableAgents,
+    credentialGroups,
+    agents: projectedAgents
+  };
+}
+function toDiscoverySafeAgentSummary(record, options) {
+  const mergedOptions = record?.publicRecordExists === true ? { ...options, publicRecordExists: true } : options;
+  return toSafeAgentSummary(record, mergedOptions);
+}
+function assembleAgentDiscoveryResult(options) {
+  const { records, summaryOptions, ...discoveryOptions } = options;
+  const agents = records.map(
+    (record) => toDiscoverySafeAgentSummary(
+      record,
+      typeof summaryOptions === "function" ? summaryOptions(record) : summaryOptions
+    )
+  );
+  return buildAgentDiscoveryResult({ ...discoveryOptions, agents });
+}
+
 export {
   deriveCredentialGroup,
+  deriveCustomProviderCredentialGroup,
   summarizeCredentialGroups,
-  toSafeAgentSummary,
-  sortSafeAgentSummaries,
-  omitNullishAgentSummaryFields,
-  toCompactAgentSummary,
-  toUnavailableAgentSummary
+  resolveDiscoveryScope,
+  matchesAgentQuery,
+  buildAgentDiscoveryResult,
+  toDiscoverySafeAgentSummary,
+  assembleAgentDiscoveryResult
 };