mixdog 0.9.172 → 0.9.174

package/src/session-runtime/setup-tool/ui-requests.mjs

@@ -1,5 +1,15 @@
 import { randomUUID } from 'node:crypto';
 
+/** Error code of a request no Desktop window took: nothing ran, so a caller
+ *  with a runtime-only route may still take it. */
+export const SETUP_DESKTOP_UNCLAIMED = 'SETUP_DESKTOP_UNCLAIMED';
+
+function unclaimed(message) {
+  const error = new Error(message);
+  error.code = SETUP_DESKTOP_UNCLAIMED;
+  return error;
+}
+
 /** One addressed request, one desktop claimant, one receipt. Snapshot replay
  * carries only an id; it cannot replay a mutation after expiry or completion. */
 export function createSetupUiRequests({
@@ -15,7 +25,7 @@ export function createSetupUiRequests({
     pending.delete(id);
     clearTimeout(entry.timer);
     entry.signal?.removeEventListener('abort', entry.abort);
-    if (error) entry.reject(new Error(error));
+    if (error) entry.reject(error instanceof Error ? error : new Error(error));
     else entry.resolve(result);
     return true;
   }
@@ -23,7 +33,7 @@ export function createSetupUiRequests({
     if (signal?.aborted) return Promise.reject(new Error('setup: cancelled before Desktop execution'));
     const sessionId = String(getSessionId?.() || '');
     if (!sessionId)
-      return Promise.reject(new Error('setup: open this conversation in Desktop to change desktop-host settings'));
+      return Promise.reject(unclaimed('setup: open this conversation in Desktop to change desktop-host settings'));
     const id = randomUUID();
     return new Promise((resolve, reject) => {
       const entry = {
@@ -36,14 +46,14 @@ export function createSetupUiRequests({
         abort: () => finish(id, 'setup: cancelled. If Desktop already started, inspect its state before retrying.'),
         expiresAt: Date.now() + claimTimeoutMs,
         timer: setTimeout(
-          () => finish(id, 'setup: no Desktop window claimed the request; nothing was changed'),
+          () => finish(id, unclaimed('setup: no Desktop window claimed the request; nothing was changed')),
           claimTimeoutMs
         ),
       };
       pending.set(id, entry);
       signal?.addEventListener('abort', entry.abort, { once: true });
       if (notifySessionUi?.(sessionId, 'Desktop settings request', { kind: 'setup-ui', id }) !== true) {
-        finish(id, 'setup: no attached Desktop surface; nothing was changed');
+        finish(id, unclaimed('setup: no attached Desktop surface; nothing was changed'));
       }
     });
   }

package/src/session-runtime/skills-api.mjs

@@ -85,7 +85,7 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
     const missingFeature =
       typeof contextMod.skillMissingFeature === 'function' ? contextMod.skillMissingFeature(skillName) : null;
     if (missingFeature) {
-      return `Error: skill "${skillName}" needs the ${missingFeature} built-in feature, which is not installed or is switched off in Settings → Built-in`;
+      return `Error: skill "${skillName}" needs the ${missingFeature} built-in feature, which is not installed or is switched off in Extensions → Plugin → Built-in`;
     }
     if (typeof contextMod.isSkillDisabled === 'function' && contextMod.isSkillDisabled(skillName)) {
       return `Error: skill "${skillName}" is disabled`;
@@ -116,7 +116,7 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(filePath, createSkillDocument({ name, description, whenToUse, body }), 'utf8');
     if (dependencies !== undefined) saveSkillToolDependencies(filePath, dependencies);
-    contextMod.invalidateSkillsCache?.(getCwd());
+    invalidateSkills();
     return { name, filePath };
   }
 
@@ -132,7 +132,7 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
     if (input.dependenciesOnly === true) {
       if (dependencies === undefined) throw new Error('Skill tool dependencies are required.');
       saveSkillToolDependencies(resource.filePath, dependencies);
-      contextMod.invalidateSkillsCache?.(getCwd());
+      invalidateSkills();
       return { originalName, name: originalName, filePath: resource.filePath };
     }
     const name = validateSkillName(input.name);
@@ -166,7 +166,7 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
       body.trim() === parsed.body.trim()
     ) {
       if (dependencies !== undefined) saveSkillToolDependencies(resource.filePath, dependencies);
-      contextMod.invalidateSkillsCache?.(getCwd());
+      invalidateSkills();
       return { originalName, name, filePath: resource.filePath };
     }
     const updated = updateSkillDocument(source, { name, description, whenToUse, body });
@@ -187,7 +187,7 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
     else if (filePath !== resource.filePath && resource.dependencySource === 'override') {
       saveSkillToolDependencies(filePath, resource.toolDependencies || []);
     }
-    contextMod.invalidateSkillsCache?.(getCwd());
+    invalidateSkills();
     return { originalName, name, filePath };
   }
 

package/src/session-runtime/statusline-route.mjs

@@ -1,5 +1,5 @@
 // Statusline route serialization. Pure helpers.
-import { clean, hasOwn } from './session-text.mjs';
+import { clean } from './session-text.mjs';
 
 function routeForStatusline(route) {
   const out = {
@@ -21,9 +21,6 @@ function routeForStatusline(route) {
   if (route.effectiveEffort) {
     out.effort = route.effectiveEffort;
     out.displayEffort = route.effectiveEffort;
-  } else if (hasOwn(route, 'effort')) {
-    delete out.effort;
-    delete out.displayEffort;
   }
   return out;
 }

package/src/session-runtime/tool-catalog-data.mjs

@@ -65,8 +65,9 @@ export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
   'code_graph',
   'read',
   // cwd / web_fetch demoted to the deferred manifest 2026-08:
-  // 0 / 10 calls in a 3-day 7.6k-call trace window; they auto-load on
-  // first direct call.
+  // 0 / 10 calls in a 3-day 7.6k-call trace window. The model loads them
+  // with load_tool; a direct call anyway is absorbed by the runtime
+  // call-through (deferred-call-through.mjs) as a safety net.
   'edit',
   'apply_patch',
   'git',
@@ -87,7 +88,7 @@ export const READONLY_TOOL_NAMES = new Set([
   'web_search',
   'web_fetch',
   'recall',
-  'memory',
+  // memory is not listed: it adds, edits and deletes standing memories.
   'Skill',
 ]);
 

package/src/session-runtime/tool-catalog-schema.mjs

@@ -170,9 +170,3 @@ export function nativeProviderFamily(provider) {
 }
 
 export const ANTHROPIC_NATIVE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
-
-// Pure projection of the tool definitions that the next provider request will
-// serialize. Anthropic's native deferred surface sends the base active tools
-// plus only definitions that have actually been discovered through the
-// session/native tool-search history. Every other provider already receives
-// its canonical/native surface in `tools`, so preserve that array verbatim.

package/src/session-runtime/tool-catalog.mjs

@@ -49,6 +49,29 @@ export {
   MEASURED_TOOL_USAGE,
 } from './tool-catalog-data.mjs';
 
+// Provider modes whose whole catalog is the active surface (no deferred pool).
+const FIXED_SURFACE_MODES = new Set(['full', 'manifest', 'canonical']);
+
+function isMcpToolName(name) {
+  return typeof name === 'string' && name.startsWith('mcp__');
+}
+
+function toolParameters(tool) {
+  if (tool?.inputSchema && typeof tool.inputSchema === 'object') return tool.inputSchema;
+  return { type: 'object', properties: {} };
+}
+
+// The rendered BP2 manifest text, or '' when no system message carries one.
+function renderedDeferredManifest(session) {
+  const system = session.messages?.find(
+    (message) =>
+      message?.role === 'system' &&
+      typeof message.content === 'string' &&
+      message.content.includes('<available-deferred-tools>')
+  );
+  return system?.content ?? '';
+}
+
 export function filterDisallowedTools(tools, disallowed = []) {
   // Old session catalogs must not resurrect the separate staging schema.
   const deny = new Set(['git_stage', ...(Array.isArray(disallowed) ? disallowed : [])].map(clean).filter(Boolean));
@@ -118,8 +141,7 @@ function openAILoadableToolSpec(tool, provider = '') {
     name: clean(tool?.name),
     description: clean(tool?.description),
     defer_loading: true,
-    parameters:
-      tool?.inputSchema && typeof tool.inputSchema === 'object' ? tool.inputSchema : { type: 'object', properties: {} },
+    parameters: toolParameters(tool),
   };
 }
 
@@ -157,14 +179,7 @@ function activeToolSchemas(catalog, session, names) {
       const name = clean(tool?.name);
       if (!name || !wanted.has(name) || seen.has(name)) continue;
       seen.add(name);
-      specs.push({
-        name,
-        description: clean(tool?.description),
-        parameters:
-          tool?.inputSchema && typeof tool.inputSchema === 'object'
-            ? tool.inputSchema
-            : { type: 'object', properties: {} },
-      });
+      specs.push({ name, description: clean(tool?.description), parameters: toolParameters(tool) });
     }
   }
   return specs;
@@ -226,13 +241,7 @@ function setDeferredToolState(session, names) {
 }
 
 function deferredPoolToolNames(session) {
-  if (
-    !session ||
-    session.deferredProviderMode === 'full' ||
-    session.deferredProviderMode === 'manifest' ||
-    session.deferredProviderMode === 'canonical'
-  )
-    return [];
+  if (!session || FIXED_SURFACE_MODES.has(session.deferredProviderMode)) return [];
   const catalog = Array.isArray(session.deferredToolCatalog) ? session.deferredToolCatalog : [];
   const active = new Set([
     ...(session.tools || []).map((tool) => clean(tool?.name)).filter(Boolean),
@@ -303,11 +312,11 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
   const catalog = sortedCatalogByMeasuredUsage([...byName.values()]);
   const defaultNames = defaultDeferredToolNames(catalog, mode);
   const storedNames = providerMode === 'native' ? [] : storedDeferredToolNames(session);
-  let selectedNames =
-    providerMode === 'full' || providerMode === 'manifest' || providerMode === 'canonical'
-      ? sortedNamesByMeasuredUsage(catalog.map((tool) => clean(tool?.name)).filter(Boolean))
-      : [];
-  if (!['full', 'manifest', 'canonical'].includes(providerMode)) {
+  const fixedSurface = FIXED_SURFACE_MODES.has(providerMode);
+  let selectedNames = fixedSurface
+    ? sortedNamesByMeasuredUsage(catalog.map((tool) => clean(tool?.name)).filter(Boolean))
+    : [];
+  if (!fixedSurface) {
     selectedNames = storedNames.length ? canonicalDeferredToolNames(catalog, storedNames) : [];
     if (!selectedNames.length || providerMode === 'native') selectedNames = sortedNamesByMeasuredUsage(defaultNames);
   }
@@ -373,15 +382,8 @@ export function rebuildDeferredToolSurfaceForProvider(session, provider) {
     if (session.deferredProviderMode === 'native') {
       session.mcpServerInstructions = getMcpServerInstructionsMap(session.mcpScopeId);
       applyInitialDeferredToolManifestToBp2(session, deferredPoolToolNames(session), { rebuild: true });
-      const rendered = session.messages?.find(
-        (message) =>
-          message?.role === 'system' &&
-          typeof message.content === 'string' &&
-          message.content.includes('<available-deferred-tools>')
-      )?.content;
-      session.deferredAnnouncedTools = deferredPoolToolNames(session).filter(
-        (name) => typeof rendered === 'string' && rendered.includes(name)
-      );
+      const rendered = renderedDeferredManifest(session);
+      session.deferredAnnouncedTools = deferredPoolToolNames(session).filter((name) => rendered.includes(name));
     } else if (previousMode === 'native') {
       for (const system of session.messages?.filter((message) => message?.role === 'system') || []) {
         if (typeof system.content === 'string') system.content = stripDeferredToolManifestBlock(system.content);
@@ -408,7 +410,6 @@ export function rebuildDeferredToolSurfaceForProvider(session, provider) {
 export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   if (!session || !Array.isArray(session.messages)) return false;
   if (session.deferredProviderMode === 'full') return false;
-  const isMcp = (name) => typeof name === 'string' && name.startsWith('mcp__');
   const live = filterDisallowedTools(Array.isArray(liveMcpTools) ? liveMcpTools : [], session.disallowedTools);
   const byName = new Map();
   for (const tool of Array.isArray(session.deferredToolCatalog) ? session.deferredToolCatalog : []) {
@@ -418,7 +419,7 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   let added = false;
   for (const tool of live) {
     const name = clean(tool?.name);
-    if (!name || !isMcp(name) || byName.has(name)) continue;
+    if (!name || !isMcpToolName(name) || byName.has(name)) continue;
     byName.set(name, activeToolForSurface(tool));
     added = true;
   }
@@ -444,12 +445,7 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   // Pre-mark ONLY the names that ACTUALLY landed in the rebuilt BP2 manifest as
   // announced; anything the manifest could not advertise stays un-announced so
   // the turn-boundary late reminder can still surface it.
-  const rendered = (() => {
-    const sys = session.messages.find(
-      (m) => m?.role === 'system' && typeof m.content === 'string' && m.content.includes('<available-deferred-tools>')
-    );
-    return typeof sys?.content === 'string' ? sys.content : '';
-  })();
+  const rendered = renderedDeferredManifest(session);
   session.deferredAnnouncedTools = deferredPoolToolNames(session).filter((name) => rendered.includes(name));
   session.updatedAt = Date.now();
   return true;
@@ -472,7 +468,6 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
  */
 export function reconcileDeferredMcpToolCatalog(session, liveMcpTools) {
   if (!session || !Array.isArray(session.tools)) return null;
-  const isMcp = (name) => typeof name === 'string' && name.startsWith('mcp__');
   const live = filterDisallowedTools(Array.isArray(liveMcpTools) ? liveMcpTools : [], session.disallowedTools);
   const hadSnapshot = Array.isArray(session.deferredMcpToolNames);
   const previousNames = new Set(
@@ -480,18 +475,18 @@ export function reconcileDeferredMcpToolCatalog(session, liveMcpTools) {
       ? session.deferredMcpToolNames
       : [...(session.deferredToolCatalog || []), ...(session.deferredLateToolCatalog || [])]
           .map((tool) => clean(tool?.name))
-          .filter(isMcp)
+          .filter(isMcpToolName)
   );
-  session.deferredMcpToolNames = [...new Set(live.map((tool) => clean(tool?.name)).filter(isMcp))];
-  if (['full', 'manifest', 'canonical'].includes(session.deferredProviderMode)) {
+  session.deferredMcpToolNames = [...new Set(live.map((tool) => clean(tool?.name)).filter(isMcpToolName))];
+  if (FIXED_SURFACE_MODES.has(session.deferredProviderMode)) {
     const byName = new Map();
     for (const tool of Array.isArray(session.deferredToolCatalog) ? session.deferredToolCatalog : []) {
       const name = clean(tool?.name);
-      if (name && !isMcp(name)) byName.set(name, tool);
+      if (name && !isMcpToolName(name)) byName.set(name, tool);
     }
     for (const tool of live) {
       const name = clean(tool?.name);
-      if (name && isMcp(name)) byName.set(name, activeToolForSurface(tool));
+      if (name && isMcpToolName(name)) byName.set(name, activeToolForSurface(tool));
     }
     const catalog = sortedCatalogByMeasuredUsage([...byName.values()]);
     const next = catalog.filter((tool) => session.deferredSurfaceMode !== 'readonly' || isReadonlySelectable(tool));
@@ -513,7 +508,7 @@ export function reconcileDeferredMcpToolCatalog(session, liveMcpTools) {
   const liveMcpByName = new Map();
   for (const tool of live) {
     const name = clean(tool?.name);
-    if (!name || !isMcp(name) || liveMcpByName.has(name)) continue;
+    if (!name || !isMcpToolName(name) || liveMcpByName.has(name)) continue;
     liveMcpByName.set(name, activeToolForSurface(tool));
   }
 
@@ -538,13 +533,11 @@ export function reconcileDeferredMcpToolCatalog(session, liveMcpTools) {
   // schema/handler track the live connection. Swap ONLY when the serialized
   // surface actually changed, so a steady reconnect never perturbs the tools
   // request param or its cache hash.
-  if (Array.isArray(session.tools)) {
-    for (let i = 0; i < session.tools.length; i += 1) {
-      const name = clean(session.tools[i]?.name);
-      if (!name || !isMcp(name) || !liveMcpByName.has(name)) continue;
-      const freshTool = liveMcpByName.get(name);
-      if (JSON.stringify(freshTool) !== JSON.stringify(session.tools[i])) session.tools[i] = freshTool;
-    }
+  for (let i = 0; i < session.tools.length; i += 1) {
+    const name = clean(session.tools[i]?.name);
+    if (!name || !isMcpToolName(name) || !liveMcpByName.has(name)) continue;
+    const freshTool = liveMcpByName.get(name);
+    if (JSON.stringify(freshTool) !== JSON.stringify(session.tools[i])) session.tools[i] = freshTool;
   }
 
   const nextNames = new Set(session.deferredMcpToolNames);
@@ -552,7 +545,7 @@ export function reconcileDeferredMcpToolCatalog(session, liveMcpTools) {
   const added = [];
   for (const tool of liveMcpByName.values()) {
     const name = clean(tool?.name);
-    if (!name || !isMcp(name)) continue;
+    if (!name || !isMcpToolName(name)) continue;
     if (previousNames.has(name) || (!hadSnapshot && (active.has(name) || startupNames.has(name)))) continue;
     added.push({ name, description: lateAnnouncementDescription(tool?.description) });
   }
@@ -633,11 +626,6 @@ export function selectDeferredTools(session, names, mode, { exact = false } = {}
   return { added, already, blocked, missing, native };
 }
 
-// Collect the exact deferred-tool names requested by the loader.
-function parseLoadToolNames(args = {}) {
-  return parseToolSelection(args.names);
-}
-
 // Split live MCP servers into "still connecting" (pending) and "failed" so the
 // loader can tell the model to retry next turn instead of treating a missing
 // tool as a permanent zero result. `mcpStatus` is a getter plumbed from the
@@ -662,10 +650,6 @@ function pendingAndFailedMcpServers(mcpStatus) {
   return { pending: [...new Set(pending)].sort(), failed: [...new Set(failed)].sort() };
 }
 
-// Pure loader. Input is exact deferred-tool
-// names/aliases; output reports loaded / already-active / missing / blocked
-// tools PLUS pending/failed MCP servers. No listing, no ranking, no substring
-// filter. `options.mcpStatus` is the runtime getter for per-server status.
 /** The deferred catalog union, or the session's own allowed tools when nothing is deferred. */
 function resolvableCatalog(session) {
   const union = deferredCatalogUnion(session);
@@ -673,9 +657,13 @@ function resolvableCatalog(session) {
   return filterDisallowedTools(Array.isArray(session?.tools) ? session.tools : [], session?.disallowedTools);
 }
 
+// Pure loader. Input is exact deferred-tool names/aliases; output reports
+// loaded / already-active / missing / blocked tools PLUS pending/failed MCP
+// servers. No listing, no ranking, no substring filter. `options.mcpStatus` is
+// the runtime getter for per-server status.
 export function renderToolSearch(args = {}, session, mode = 'full', options = {}) {
   const catalog = resolvableCatalog(session);
-  const requestedNames = parseLoadToolNames(args);
+  const requestedNames = parseToolSelection(args.names);
   const { pending: pendingMcpServers, failed: failedMcpServers } = pendingAndFailedMcpServers(options?.mcpStatus);
   const mcpFields = {
     ...(pendingMcpServers.length ? { pendingMcpServers } : {}),

package/src/session-runtime/tool-defs.mjs

@@ -18,7 +18,7 @@ export const TOOL_SEARCH_TOOL = {
     type: 'object',
     properties: {
       names: {
-        anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+        anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }],
         description: 'Exact name(s)/aliases.',
       },
     },

package/src/session-runtime/turn/turn-run/snapshot-tracker.mjs

@@ -12,6 +12,9 @@ export function createSnapshotTrackerFactory({
 }) {
   return function createSnapshotTracker(options) {
     const tracker = { sessionId: null, promise: null };
+    // A completion wake continues the user turn whose review already exists;
+    // aborting the wake seals that review instead of discarding it.
+    const continueTurn = options.continueTurn === true;
     const cancel = () => {
       try {
         cancelTurnSnapshotForTurn(tracker.sessionId);
@@ -27,12 +30,13 @@ export function createSnapshotTrackerFactory({
             // The first submitted row is the outer prompt. Mid-loop steering
             // is drained inside this ask() and deliberately keeps this ID.
             checkpointId: String(options.id || '').trim(),
+            continueTurn,
           })
         )
         .catch(() => undefined);
     };
     tracker.finish = async (signal, awaitTurn) => {
-      if (signal.aborted) {
+      if (signal.aborted && !continueTurn) {
         cancel();
         void Promise.resolve(tracker.promise).catch(() => {});
         return;
@@ -44,7 +48,7 @@ export function createSnapshotTrackerFactory({
       } catch {
         /* optional review cleanup never overrides turn settlement */
       }
-      if (signal.aborted) cancel();
+      if (signal.aborted && !continueTurn) cancel();
     };
     return tracker;
   };

package/src/session-runtime/turn/turn-run/transcript.mjs

@@ -35,8 +35,7 @@ export function createTurnTranscript({ getTranscriptWriter, getLastAppendedAssis
   // re-write the parts into the transcript.
   function appendFinalAssistant(result) {
     if (!getTranscriptWriter()) return;
-    const finalSource = result?.historyContent ?? result?.content;
-    const finalText = finalSource != null ? String(finalSource) : '';
+    const finalText = transcriptText(result?.historyContent ?? result?.content);
     if (finalText.trim() && finalText !== getLastAppendedAssistant()) {
       append('appendAssistant', finalText, 'final append failed');
       setLastAppendedAssistant(finalText);

package/src/session-runtime/usage-stats-api.mjs

@@ -2,14 +2,42 @@
 // dependencies after the one-time import of surviving historical originals.
 import { getUsageLedger } from '../runtime/shared/llm/usage-ledger.mjs';
 import { importUsageHistory } from '../runtime/shared/llm/usage-ledger-import.mjs';
-import { refreshUnpricedUsage } from '../runtime/shared/llm/usage-pricing-refresh.mjs';
+import { refreshUnpricedUsageAsync } from '../runtime/shared/llm/usage-pricing-refresh.mjs';
 import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 import { usageStatsSnapshot } from '../standalone/usage-stats-model.mjs';
 import { resolveUsageStatsPeriod } from '../standalone/usage-stats-period.mjs';
 import { usageRollupDayKey } from '../runtime/shared/llm/usage-rollup.mjs';
+import { ACCOUNT_PROVIDERS, readProviderAccountPool } from '../runtime/shared/provider-accounts.mjs';
 
 const MAX_MODEL_LIMIT = 50;
 
+const quotaText = (value) => (typeof value === 'string' ? value.slice(0, 200) : '');
+
+// What the ledger cannot know: each subscription account's label and place in
+// its provider's account pool, the order the account picker lists them in.
+function labelQuotaHistory(history, accountPool) {
+  const rosters = new Map();
+  const rosterOf = (provider) => {
+    if (!ACCOUNT_PROVIDERS.includes(provider)) return [];
+    if (!rosters.has(provider)) {
+      try {
+        rosters.set(provider, accountPool(provider).accounts);
+      } catch {
+        rosters.set(provider, []);
+      }
+    }
+    return rosters.get(provider);
+  };
+  return {
+    ...history,
+    subscriptions: (history.subscriptions || []).map((row) => {
+      const roster = rosterOf(row.provider);
+      const rank = roster.findIndex((entry) => entry.id === row.account);
+      return { ...row, accountLabel: roster[rank]?.label || '', accountRank: rank < 0 ? null : rank };
+    }),
+  };
+}
+
 /** `null` = all time. `0` = today. Anything else is a trailing day count. */
 function normalizeDays(value) {
   if (value === null || value === undefined || value === 'all') return null;
@@ -55,7 +83,11 @@ function usageRollupQuery(period) {
   };
 }
 
-export function createUsageStatsApi({ ledger = getUsageLedger, importHistory = importUsageHistory } = {}) {
+export function createUsageStatsApi({
+  ledger = getUsageLedger,
+  importHistory = importUsageHistory,
+  accountPool = readProviderAccountPool,
+} = {}) {
   let importing = null;
   let imported = false;
   // Until the first instrumented send establishes the cutover, the legacy
@@ -76,15 +108,20 @@ export function createUsageStatsApi({ ledger = getUsageLedger, importHistory = i
     async getUsageStats(options = {}) {
       const store = ledger();
       if (!store) throw new Error('Usage ledger is unavailable');
+      // Live sends commit through the ledger worker; statistics requested
+      // after a send must include it.
+      await store.settleWrites();
       const liveSince = Number(store.get('liveSince'));
       await ensureHistoryImported(store, liveSince);
-      refreshUnpricedUsage(store);
+      await refreshUnpricedUsageAsync(store);
       // Imports may take time: their newly retained timestamps must not fall
       // beyond a clock captured before the import started.
       const now = Date.now();
       const period = usagePeriodFor(options, now);
+      // The rollup query runs off the event loop (usage-rollup-worker.mjs).
+      const rollup = await store.rollupAsync(usageRollupQuery(period));
       const snapshot = usageStatsSnapshot({
-        rollup: store.rollup(usageRollupQuery(period)),
+        rollup,
         days: normalizeDays(options?.days),
         period,
         modelLimit: normalizeModelLimit(options?.modelLimit),
@@ -99,5 +136,39 @@ export function createUsageStatsApi({ ledger = getUsageLedger, importHistory = i
       snapshot.coverage.liveSince = liveSince || null;
       return snapshot;
     },
+
+    /**
+     * How a subscription's own quota meter moved: one limit window since its
+     * last reset (`view: 'window'`, the default, paged by `anchor`), or any
+     * statistics period. `page` asks for the window history instead: one
+     * page of every window that opened, newest first. Readings are recorded
+     * whenever provider usage is measured, so history starts when recording
+     * did.
+     */
+    async getQuotaHistory(options = {}) {
+      const store = ledger();
+      if (!store) throw new Error('Usage ledger is unavailable');
+      // Prices of unpriced records are refreshed by the statistics read the
+      // same dialog makes; repeating it here only queues behind it.
+      await store.settleWrites();
+      const now = Date.now();
+      const selection = {
+        provider: quotaText(options?.provider),
+        account: quotaText(options?.account),
+        label: quotaText(options?.window),
+      };
+      if (options?.page != null) return store.quotaWindowsAsync({ ...selection, page: Number(options.page), now });
+      const view = options?.view == null || options.view === 'window' ? 'window' : options.view;
+      const period = view === 'window' ? null : usagePeriodFor({ ...options, view }, now);
+      const history = await store.quotaHistoryAsync({
+        ...selection,
+        view,
+        anchor: view === 'window' ? quotaText(options?.anchor) || null : null,
+        fromMs: period?.fromMs ?? null,
+        toMs: period?.toMs ?? null,
+        now,
+      });
+      return labelQuotaHistory(period ? { ...history, period } : history, accountPool);
+    },
   };
 }

package/src/session-runtime/workflow/agents.mjs

@@ -5,7 +5,8 @@
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { clean } from '../session-text.mjs';
-import { readDirEntriesSafe, readJsonSafe, readTextSafe } from '../fs-utils.mjs';
+import { readJsonSafe, readTextSafe } from '../fs-utils.mjs';
+import { SHARED_SCAN_REVALIDATE_MS, createSharedScanCache } from './shared-scan-cache.mjs';
 import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.mjs';
 import { isAgentDisabled } from '../../runtime/shared/agent-route-config.mjs';
 import {
@@ -20,6 +21,39 @@ import {
   setAgentDefinitionCache,
 } from '../workflow-ids.mjs';
 
+// Yields its fs requests; see shared-scan-cache.mjs.
+function* scanCustomAgentIds(userRoot, shippedRoot) {
+  const ids = new Set();
+  for (const root of [userRoot, shippedRoot]) {
+    const entries = yield { op: 'readdir', path: root };
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const id = normalizeWorkflowId(entry.name);
+      if (!id || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
+      if (root !== userRoot && (yield { op: 'exists', path: join(userRoot, id, AGENT_DELETED_MARKER) })) continue;
+      if (!(yield { op: 'exists', path: join(root, entry.name, 'AGENT.md') })) continue;
+      ids.add(id);
+    }
+  }
+  return [...ids].sort((left, right) => {
+    const leftRank = STARTER_AGENT_ORDER.get(left);
+    const rightRank = STARTER_AGENT_ORDER.get(right);
+    if (leftRank !== undefined || rightRank !== undefined) {
+      return (leftRank ?? Number.MAX_SAFE_INTEGER) - (rightRank ?? Number.MAX_SAFE_INTEGER);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+// Every session's 2 s status pulse resolves the delegatable agent list, so
+// the scan result is shared process-wide per (user, shipped) agents-root pair
+// and revalidated in the background (shared-scan-cache.mjs); an agent added,
+// removed or tombstoned on disk shows up within AGENT_LIST_REVALIDATE_MS plus
+// one background scan. listCustomAgentIds (editor/onboarding) always scans
+// fresh and republishes, so editor writes are visible immediately.
+export const AGENT_LIST_REVALIDATE_MS = SHARED_SCAN_REVALIDATE_MS;
+const agentListCache = createSharedScanCache();
+
 export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, normalizeAgentPermissionOrNone }) {
   function agentSourceDirs(dir, id) {
     const userDir = join(dir || dataDir, 'agents', id);
@@ -28,34 +62,20 @@ export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, n
   }
 
   function listCustomAgentIds(dir) {
-    const ids = new Set();
     const userRoot = join(dir || dataDir, 'agents');
-    for (const root of [userRoot, join(rootDir, 'agents')]) {
-      for (const entry of readDirEntriesSafe(root)) {
-        if (!entry.isDirectory()) continue;
-        const id = normalizeWorkflowId(entry.name);
-        if (!id || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
-        if (root !== userRoot && existsSync(join(userRoot, id, AGENT_DELETED_MARKER))) continue;
-        if (!existsSync(join(root, entry.name, 'AGENT.md'))) continue;
-        ids.add(id);
-      }
-    }
-    return [...ids].sort((left, right) => {
-      const leftRank = STARTER_AGENT_ORDER.get(left);
-      const rightRank = STARTER_AGENT_ORDER.get(right);
-      if (leftRank !== undefined || rightRank !== undefined) {
-        return (leftRank ?? Number.MAX_SAFE_INTEGER) - (rightRank ?? Number.MAX_SAFE_INTEGER);
-      }
-      return left.localeCompare(right);
-    });
+    const shippedRoot = join(rootDir, 'agents');
+    return [...agentListCache.fresh(`${userRoot}\n${shippedRoot}`, () => scanCustomAgentIds(userRoot, shippedRoot))];
   }
 
   // Agents the Lead may actually delegate to: on disk, not hidden, not a
-  // slot-backed built-in, and not switched off by the user.
+  // slot-backed built-in, and not switched off by the user. The shared scan
+  // already drops hidden agents.
   function delegatableAgentIds(config, dir) {
-    return listCustomAgentIds(dir).filter(
-      (id) => !isHiddenAgent(id) && !BUILTIN_SLOT_AGENT_IDS.has(id) && !isAgentDisabled(config, id)
-    );
+    const userRoot = join(dir || dataDir, 'agents');
+    const shippedRoot = join(rootDir, 'agents');
+    return agentListCache
+      .shared(`${userRoot}\n${shippedRoot}`, () => scanCustomAgentIds(userRoot, shippedRoot))
+      .filter((id) => !BUILTIN_SLOT_AGENT_IDS.has(id) && !isAgentDisabled(config, id));
   }
 
   function loadAgentDefinition(dir, id) {