nolo-cli 0.33.0-alpha.9 → 0.34.0-alpha.1

package/{chunk-X664KVEV.js → chunk-HHBXCRJS.js}

@@ -2,16 +2,16 @@ import {
   getAllServers,
   getIsDesktopApp,
   isAbortError
-} from "./chunk-WJSW43QZ.js";
+} from "./chunk-L3JWI7WX.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   API_ENDPOINTS,
   SERVERS,
@@ -28,104 +28,27 @@ import {
 } from "./chunk-G3SUCT4W.js";
 
 // node_modules/reselect/dist/reselect.mjs
-var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
-  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
-    let isInputSameAsOutput = false;
-    try {
-      const emptyObject = {};
-      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
-    } catch {
-    }
-    if (isInputSameAsOutput) {
-      let stack = void 0;
-      try {
-        throw new Error();
-      } catch (e) {
-        ;
-        ({ stack } = e);
-      }
-      console.warn(
-        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
-        { stack }
-      );
-    }
-  }
-};
-var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
-  const { memoize, memoizeOptions } = options;
-  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
-  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);
-  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
-  if (!areInputSelectorResultsEqual) {
-    let stack = void 0;
-    try {
-      throw new Error();
-    } catch (e) {
-      ;
-      ({ stack } = e);
-    }
-    console.warn(
-      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
-      {
-        arguments: inputSelectorArgs,
-        firstInputs: inputSelectorResults,
-        secondInputs: inputSelectorResultsCopy,
-        stack
-      }
-    );
-  }
+var CACHE_SIZE_CHECK_THRESHOLD = 1e3;
+var runCacheSizeCheck = (cacheSize, funcName) => {
+  let stack = void 0;
+  try {
+    throw new Error();
+  } catch (e) {
+    ;
+    ({ stack } = e);
+  }
+  console.warn(
+    `A function memoized with weakMapMemoize${funcName ? ` (\`${funcName}\`)` : ""} has seen over ${cacheSize} distinct values for the same primitive argument position.
+Results keyed by primitive arguments are held strongly and are only released by \`clearCache()\`, so this cache will keep growing for as long as the function keeps seeing new values.
+If it is called with ever-changing primitives (ids, offsets, timestamps), pass the \`maxSize\` option to bound the cache, switch to \`lruMemoize\`, or call \`.clearCache()\` at a suitable point.
+See https://reselect.js.org/api/development-only-checks#cachesizecheck for details.`,
+    { stack }
+  );
 };
 var globalDevModeChecks = {
   inputStabilityCheck: "once",
-  identityFunctionCheck: "once"
-};
-function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
-  if (typeof func !== "function") {
-    throw new TypeError(errorMessage);
-  }
-}
-function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
-  if (!array.every((item) => typeof item === "function")) {
-    const itemTypes = array.map(
-      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
-    ).join(", ");
-    throw new TypeError(`${errorMessage}[${itemTypes}]`);
-  }
-}
-var ensureIsArray = (item) => {
-  return Array.isArray(item) ? item : [item];
-};
-function getDependencies(createSelectorArgs) {
-  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
-  assertIsArrayOfFunctions(
-    dependencies,
-    `createSelector expects all input-selectors to be functions, but received the following types: `
-  );
-  return dependencies;
-}
-function collectInputSelectorResults(dependencies, inputSelectorArgs) {
-  const inputSelectorResults = [];
-  const { length } = dependencies;
-  for (let i = 0; i < length; i++) {
-    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
-  }
-  return inputSelectorResults;
-}
-var getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {
-  const { identityFunctionCheck, inputStabilityCheck } = {
-    ...globalDevModeChecks,
-    ...devModeChecks
-  };
-  return {
-    identityFunctionCheck: {
-      shouldRun: identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun,
-      run: runIdentityFunctionCheck
-    },
-    inputStabilityCheck: {
-      shouldRun: inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun,
-      run: runInputStabilityCheck
-    }
-  };
+  identityFunctionCheck: "once",
+  cacheSizeCheck: "once"
 };
 var StrongRef = class {
   constructor(value) {
@@ -155,9 +78,25 @@ function maybeDeref(r) {
 }
 function weakMapMemoize(func, options = {}) {
   let fnNode = createCacheNode();
-  const { resultEqualityCheck } = options;
+  const { resultEqualityCheck, maxSize } = options;
+  const useGenerations = maxSize !== void 0;
+  if (useGenerations && (!Number.isInteger(maxSize) || maxSize < 1)) {
+    throw new TypeError(
+      `maxSize must be a positive integer, received: ${maxSize}`
+    );
+  }
+  let prevNode = null;
+  let insertionCount = 0;
   let lastResult;
   let resultsCount = 0;
+  let hasWarnedAboutCacheSize = false;
+  function maybeFlipGenerations() {
+    if (insertionCount >= maxSize) {
+      prevNode = fnNode;
+      fnNode = createCacheNode();
+      insertionCount = 0;
+    }
+  }
   function memoized() {
     let cacheNode = fnNode;
     const { length } = arguments;
@@ -184,35 +123,77 @@ function weakMapMemoize(func, options = {}) {
         if (primitiveNode === void 0) {
           cacheNode = createCacheNode();
           primitiveCache.set(arg, cacheNode);
+          insertionCount++;
+          if (process.env.NODE_ENV !== "production") {
+            if (primitiveCache.size > CACHE_SIZE_CHECK_THRESHOLD) {
+              const { cacheSizeCheck } = globalDevModeChecks;
+              if (cacheSizeCheck === "always" || cacheSizeCheck === "once" && !hasWarnedAboutCacheSize) {
+                hasWarnedAboutCacheSize = true;
+                runCacheSizeCheck(primitiveCache.size, func.name);
+              }
+            }
+          }
         } else {
           cacheNode = primitiveNode;
         }
       }
     }
-    const terminatedNode = cacheNode;
-    let result;
     if (cacheNode.s === TERMINATED) {
-      result = cacheNode.v;
-    } else {
-      result = func.apply(null, arguments);
-      resultsCount++;
-      if (resultEqualityCheck) {
-        const lastResultValue = maybeDeref(lastResult);
-        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
-          result = lastResultValue;
-          resultsCount !== 0 && resultsCount--;
+      return cacheNode.v;
+    }
+    if (prevNode !== null) {
+      let prevCacheNode = prevNode;
+      for (let i = 0, l = length; i < l; i++) {
+        const arg = arguments[i];
+        let next;
+        if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+          const prevObjectCache = prevCacheNode.o;
+          next = prevObjectCache !== null ? prevObjectCache.get(arg) : void 0;
+        } else {
+          const prevPrimitiveCache = prevCacheNode.p;
+          next = prevPrimitiveCache !== null ? prevPrimitiveCache.get(arg) : void 0;
+        }
+        if (next === void 0) {
+          prevCacheNode = null;
+          break;
         }
-        const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
-        lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+        prevCacheNode = next;
+      }
+      if (prevCacheNode !== null && prevCacheNode.s === TERMINATED) {
+        const promotedNode = cacheNode;
+        promotedNode.s = TERMINATED;
+        promotedNode.v = prevCacheNode.v;
+        maybeFlipGenerations();
+        return prevCacheNode.v;
       }
     }
+    const terminatedNode = cacheNode;
+    let result = func.apply(null, arguments);
+    resultsCount++;
+    if (resultEqualityCheck) {
+      const lastResultValue = maybeDeref(lastResult);
+      if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+        result = lastResultValue;
+        resultsCount !== 0 && resultsCount--;
+      }
+      const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
+      lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+    }
     terminatedNode.s = TERMINATED;
     terminatedNode.v = result;
+    if (useGenerations) {
+      maybeFlipGenerations();
+    }
     return result;
   }
   memoized.clearCache = () => {
     fnNode = createCacheNode();
+    prevNode = null;
+    insertionCount = 0;
     memoized.resetResultsCount();
+    if (process.env.NODE_ENV !== "production") {
+      hasWarnedAboutCacheSize = false;
+    }
   };
   memoized.resultsCount = () => resultsCount;
   memoized.resetResultsCount = () => {
@@ -220,6 +201,98 @@ function weakMapMemoize(func, options = {}) {
   };
   return memoized;
 }
+var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
+  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
+    let isInputSameAsOutput = false;
+    try {
+      const emptyObject = {};
+      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
+    } catch {
+    }
+    if (isInputSameAsOutput) {
+      let stack = void 0;
+      try {
+        throw new Error();
+      } catch (e) {
+        ;
+        ({ stack } = e);
+      }
+      console.warn(
+        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
+        { stack }
+      );
+    }
+  }
+};
+var withoutResultEqualityCheck = (option) => {
+  if (option === null || typeof option !== "object" || !("resultEqualityCheck" in option)) {
+    return option;
+  }
+  const optionCopy = { ...option };
+  delete optionCopy.resultEqualityCheck;
+  return optionCopy;
+};
+var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
+  const { memoize, memoizeOptions } = options;
+  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
+  const probeMemoizeOptions = [];
+  const { length } = memoizeOptions;
+  for (let i = 0; i < length; i++) {
+    probeMemoizeOptions.push(withoutResultEqualityCheck(memoizeOptions[i]));
+  }
+  const createAnEmptyObject = memoize(() => ({}), ...probeMemoizeOptions);
+  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
+  if (!areInputSelectorResultsEqual) {
+    let stack = void 0;
+    try {
+      throw new Error();
+    } catch (e) {
+      ;
+      ({ stack } = e);
+    }
+    console.warn(
+      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
+      {
+        arguments: inputSelectorArgs,
+        firstInputs: inputSelectorResults,
+        secondInputs: inputSelectorResultsCopy,
+        stack
+      }
+    );
+  }
+};
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+  if (typeof func !== "function") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+  if (!array.every((item) => typeof item === "function")) {
+    const itemTypes = array.map(
+      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
+    ).join(", ");
+    throw new TypeError(`${errorMessage}[${itemTypes}]`);
+  }
+}
+var ensureIsArray = (item) => {
+  return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+  assertIsArrayOfFunctions(
+    dependencies,
+    `createSelector expects all input-selectors to be functions, but received the following types: `
+  );
+  return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+  const inputSelectorResults = [];
+  const { length } = dependencies;
+  for (let i = 0; i < length; i++) {
+    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+  }
+  return inputSelectorResults;
+}
 function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
   const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
     memoize: memoizeOrOptions,
@@ -262,27 +335,35 @@ function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
     let firstRun = true;
     const selector = argsMemoize(function dependenciesChecker() {
       dependencyRecomputations++;
-      const inputSelectorResults = collectInputSelectorResults(
-        dependencies,
-        arguments
-      );
+      const { length } = dependencies;
+      const inputSelectorResults = new Array(length);
+      for (let i = 0; i < length; i++) {
+        inputSelectorResults[i] = dependencies[i].apply(null, arguments);
+      }
       lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
       if (process.env.NODE_ENV !== "production") {
-        const { devModeChecks = {} } = combinedOptions;
-        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);
-        if (identityFunctionCheck.shouldRun) {
-          identityFunctionCheck.run(
+        const { devModeChecks } = combinedOptions;
+        const identityFunctionCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "identityFunctionCheck"
+        ) ? devModeChecks.identityFunctionCheck : globalDevModeChecks.identityFunctionCheck;
+        const inputStabilityCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "inputStabilityCheck"
+        ) ? devModeChecks.inputStabilityCheck : globalDevModeChecks.inputStabilityCheck;
+        if (identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun) {
+          runIdentityFunctionCheck(
             resultFunc,
             inputSelectorResults,
             lastResult
           );
         }
-        if (inputStabilityCheck.shouldRun) {
+        if (inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun) {
           const inputSelectorResultsCopy = collectInputSelectorResults(
             dependencies,
             arguments
           );
-          inputStabilityCheck.run(
+          runInputStabilityCheck(
             { inputSelectorResults, inputSelectorResultsCopy },
             { memoize, memoizeOptions: finalMemoizeOptions },
             arguments

package/{chunk-75U775RZ.js → chunk-IFS5CUEH.js}

@@ -199,7 +199,7 @@ async function readDocFunc(args, thunkApi) {
     throw new Error(`\u65E0\u6548\u7684\u9875\u9762 ID: ${id}\u3002\u9875\u9762 ID \u901A\u5E38\u4EE5 "page-" \u5F00\u5934\u3002`);
   }
   try {
-    const { readAction } = await import("./read-2VHEHCAN.js");
+    const { readAction } = await import("./read-6C2XD3YZ.js");
     const pageData = await readAction({ dbKey: id }, thunkApi);
     if (!pageData) {
       throw new Error(`\u672A\u627E\u5230 ID \u4E3A ${id} \u7684\u9875\u9762\u3002`);

package/{chunk-WLH5BAKX.js → chunk-IIOHYLIG.js}

@@ -43,14 +43,19 @@ var TOOL_PACKS = {
   // search_all_spaces 已改为内置 skill（search-all-spaces），按需 loadSkill
   // 加载，不再随 CORE 常驻；全部视图（All View）运行时只给 recommended hint，
   // 不自动注入工具。search_workspace 保持常驻（分类视图的「当前空间」检索）。
+  // ask_user：Web/TUI 默认启用（CORE 常驻，用户可显式 disabledTools 关闭）；
+  // desktop 无交互通道，由 desktopAgentRuntimeTurnService.ts 经
+  // INTERACTION_REQUIRED_TOOL_NAMES 剥离。
+  // queryModelUsage / queryUserGrowthReport：server-only 工具（web/CLI executor
+  // 直接返回 serverOnlyResult），不随 CORE 常驻——server 端由 agent 显式
+  // tools 配置按需挂载（utilityServerTools 执行器），web 端不再挂死 schema。
   CORE: [
     "read",
     "createDoc",
     "updateDoc",
     "search_workspace",
     "updateSelf",
-    "queryModelUsage",
-    "queryUserGrowthReport",
+    "ask_user",
     "createAgentAutomation",
     "notifyUser",
     "setTodoList"
@@ -100,8 +105,8 @@ var CAPABILITY_PACKS = [
   {
     id: "long-term-memory",
     label: "\u957F\u671F\u8BB0\u5FC6",
-    description: "\u5BF9\u8BDD\u524D\u81EA\u52A8\u8F7D\u5165\u9AD8\u76F8\u5173\u8BB0\u5FC6\uFF0C\u5E76\u5141\u8BB8 agent \u6309\u9700\u67E5\u8BE2\u6216\u5199\u5165\u957F\u671F\u8BB0\u5FC6\u3002",
-    tools: ["queryMemory", "rememberMemory"],
+    description: "\u5BF9\u8BDD\u524D\u81EA\u52A8\u8F7D\u5165\u9AD8\u76F8\u5173\u8BB0\u5FC6\uFF0C\u5E76\u5141\u8BB8 agent \u6309\u9700\u67E5\u8BE2\u3001\u5199\u5165\u6216\u5728\u7528\u6237\u5F3A\u5236\u8981\u6C42\u4E0B\u5220\u9664\u957F\u671F\u8BB0\u5FC6\u3002",
+    tools: ["queryMemory", "rememberMemory", "deleteMemory"],
     defaultEnabled: true,
     icon: "\u{1F9E0}"
   },

package/{chunk-ADLYMQB6.js → chunk-IZCHPD7T.js}

@@ -1,13 +1,13 @@
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
-import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
 import {
   asNonEmptyStringArray,
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
 import {
   isOwnedAgentKey,
   ownedAgentKey,
@@ -146,6 +146,53 @@ function redactAgentRecordForWorkspaceTool(record) {
   return redacted;
 }
 
+// packages/ai/agent/agentSelectionPriority.ts
+function parseAgentTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+function isUserConfiguredAgent(agent) {
+  return agent.isOAuth === true || agent.isOwned === true && agent.apiSource === "custom";
+}
+function resolveAgentSelectionPriority(agent) {
+  const favorite = agent.isFavorite === true;
+  const configured = isUserConfiguredAgent(agent);
+  if (favorite && configured) return 0;
+  if (favorite) return 1;
+  if (configured) return 2;
+  if (agent.isOwned === true) return 3;
+  return 4;
+}
+function compareAgentSelection(left, right) {
+  const priorityDiff = resolveAgentSelectionPriority(left) - resolveAgentSelectionPriority(right);
+  if (priorityDiff !== 0) return priorityDiff;
+  const leftFav = left.isFavorite === true;
+  const rightFav = right.isFavorite === true;
+  if (leftFav && rightFav) {
+    const leftFavAt = parseAgentTimestamp(left.favoritedAt);
+    const rightFavAt = parseAgentTimestamp(right.favoritedAt);
+    if (leftFavAt !== rightFavAt) return rightFavAt - leftFavAt;
+  }
+  const leftUpdated = parseAgentTimestamp(left.updatedAt ?? left.createdAt);
+  const rightUpdated = parseAgentTimestamp(right.updatedAt ?? right.createdAt);
+  return rightUpdated - leftUpdated;
+}
+var AGENT_SELECTION_PRIORITY_INSTRUCTIONS = `   - \u4F18\u5148\u7EA7\u5951\u7EA6\uFF08\u4E0E\u5217\u8868\u6392\u5E8F\u771F\u503C\u4E25\u683C\u4E00\u81F4\uFF09\uFF1A
+     1. \u6536\u85CF\u7684 OAuth / \u81EA\u5B9A\u4E49 Agent\uFF08isFavorite=true \u4E14 isOAuth=true \u6216 apiSource="custom"\uFF0C\u7528\u6237\u79C1\u6709\u8BA2\u9605/\u51ED\u636E\u4F18\u5148\uFF0C\u4E0D\u70E7\u5E73\u53F0 credits\uFF09
+     2. \u5176\u4ED6\u6536\u85CF Agent\uFF08isFavorite=true\uFF09
+     3. \u672A\u6536\u85CF\u7684 OAuth / \u81EA\u5B9A\u4E49 Agent\uFF08isOAuth=true \u6216 apiSource="custom"\uFF09
+     4. \u5176\u4ED6\u81EA\u5EFA Agent\uFF08isOwned=true\uFF09
+     5. \u516C\u5F00 / \u5E73\u53F0 Agent\uFF08apiSource="platform" \u6216\u793E\u533A\u516C\u5F00\uFF09
+     \u540C\u6863\u4F4D\u4E0B\u6536\u85CF\u9879\u6309\u6700\u8FD1\u6536\u85CF\uFF08favoritedAt\uFF09\u4F18\u5148\uFF0C\u5176\u4F59\u6309\u6700\u8FD1\u66F4\u65B0\uFF08updatedAt\uFF09\u4F18\u5148\u3002
+   - \u9009\u4EBA\u4E0E\u4EFB\u52A1\u5339\u914D\u53C2\u8003\uFF1A
+     * **\u80FD\u529B\u5339\u914D**\uFF1A\u82E5\u4EFB\u52A1\u660E\u786E\u9700\u8981\u7279\u5B9A\u989D\u5916\u80FD\u529B\uFF08\u6D4F\u89C8\u5668/\u56FE\u7247/\u8868\u683C/\u90AE\u4EF6/\u6570\u636E\u5E93\uFF09\uFF0C\u4F18\u5148\u7B5B\u9009 tools \u5B57\u6BB5\u8986\u76D6\u5BF9\u5E94\u80FD\u529B\u7684\u5019\u9009\uFF1B
+     * **\u6210\u672C\u4E0E\u914D\u989D**\uFF1A\u5728\u6EE1\u8DB3\u80FD\u529B\u7684\u540C\u6863\u5019\u9009\u4E2D\uFF0C\u4F18\u5148\u9009\u62E9\u6210\u672C\u4F4E\uFF08\u4F4E inputPrice\uFF09\u6216\u8D70\u7528\u6237\u81EA\u5EFA/\u79C1\u6709\u51ED\u636E\u7684\u901A\u9053\uFF1B
+     * **tools \u5B57\u6BB5\u53EA\u53CD\u6620\u989D\u5916\u80FD\u529B\uFF0C\u4E0D\u53CD\u6620 coding \u80FD\u529B**\uFF1AwriteFile/editFile/execBash/applyEdit/gitCommit \u7B49\u4EE3\u7801\u5DE5\u5177\u7531 host \u81EA\u52A8\u6CE8\u5165\uFF0Ctools=[] \u4E0D\u4EE3\u8868\u4E0D\u80FD\u5199\u4EE3\u7801\uFF0C\u4E0D\u8981\u636E\u6B64\u6392\u9664\u5019\u9009\u3002`;
+
 // packages/agent-runtime/noloWorkspaceTools.ts
 var NOLO_WORKSPACE_TOOL_NAMES = [
   "listDialogs",
@@ -619,6 +666,8 @@ function buildNoloWorkspaceCommandArgs(call) {
 }
 
 export {
+  compareAgentSelection,
+  AGENT_SELECTION_PRIORITY_INSTRUCTIONS,
   buildAgentRuntimeAgentLookupKeys,
   shouldFetchAgentRuntimeRecordRemotely,
   resolveRuntimeToolSurfaceForAgent,

package/{chunk-ITIA6OAQ.js → chunk-IZNJDUJ4.js}

@@ -11,22 +11,22 @@ import {
   getAntigravityUserAgent,
   normalizeAntigravityTokenPayload,
   refreshAntigravityToken
-} from "./chunk-SCUETSRP.js";
+} from "./chunk-PV734VZX.js";
 import {
   writeOAuthCredential
-} from "./chunk-JZPBVBIY.js";
+} from "./chunk-FD36SCCD.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
 
 // packages/cli/oauth/callback-server.ts
 import { createServer } from "node:http";

package/{chunk-X2DAEZ3X.js → chunk-J5NMOM35.js}

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

package/{chunk-RPRRIFXV.js → chunk-JI2TIPLP.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_AGENT_BASE_POLICY,
   DEFAULT_USER_PREFERENCE_PROFILE
-} from "./chunk-UNOTBWZZ.js";
+} from "./chunk-B6H5XCT2.js";
 
 // packages/ai/policy/runtimePolicy.ts
 var clampLevel = (value, fallback) => {

package/{chunk-EGRJC4ZN.js → chunk-JIADXJYU.js}

@@ -1,6 +1,6 @@
 import {
   dialogMessageKey
-} from "./chunk-KMSZPTM6.js";
+} from "./chunk-2WKUUY2E.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";

package/{chunk-IHEC7VBF.js → chunk-K4KIFRIN.js}

@@ -2,7 +2,7 @@ import {
   deleteDbRecord,
   queryUserRecords,
   readDbRecord
-} from "./chunk-YDTYDA5W.js";
+} from "./chunk-GZRMWK5R.js";
 import {
   mergeAndDedupUserData
 } from "./chunk-KQHGZWSV.js";