mixdog 1.2.2 → 1.2.3

package/src/session-runtime/settings-builtin-tools-api.mjs

@@ -79,6 +79,15 @@ export function createBuiltinToolSettings(
       invalidateContextStatusCache();
       return this.getRecapSettings();
     },
+    // Whether the model may title the session (session tool, action=rename).
+    // Absent config means on; only the opt-out is stored.
+    getSessionTitleSettings() {
+      return { aiSessionTitles: getConfig()?.aiSessionTitles !== false };
+    },
+    setAiSessionTitles(enabled) {
+      saveConfigAndAdopt({ ...getConfig(), aiSessionTitles: enabled !== false });
+      return this.getSessionTitleSettings();
+    },
     getToolModuleSettings() {
       const config = getConfig();
       const localProvider = getLocalProviderStatus?.() || {};

package/src/session-runtime/setup-tool/executor.mjs

@@ -92,6 +92,7 @@ function routeInput(source) {
   if (clean(source.model)) next.model = clean(source.model);
   if (clean(source.effort)) next.effort = clean(source.effort);
   if (typeof source.fast === 'boolean') next.fast = source.fast;
+  if (typeof source.autoEffort === 'boolean') next.autoEffort = source.autoEffort;
   if (Object.hasOwn(source, 'modelParameters')) next.modelParameters = { ...source.modelParameters };
   if (Object.hasOwn(source, 'contextPercent')) next.contextPercent = source.contextPercent;
   if (Object.hasOwn(source, 'contextTokens')) next.contextTokens = source.contextTokens;
@@ -141,6 +142,34 @@ function publicProviderRows(setup) {
   };
 }
 
+/** Minimal provider rows for the model: only providers with a credential (or
+ *  one needing re-authentication), counts instead of account rosters. */
+function configuredProviderRows(rows, accountCount) {
+  const providers = [];
+  let notConfigured = 0;
+  for (const [kind, list] of [
+    ['api', rows.api],
+    ['oauth', rows.oauth],
+    ['local', rows.local],
+  ]) {
+    for (const row of list) {
+      if (!row.authenticated && !row.reauthRequired) {
+        notConfigured += 1;
+        continue;
+      }
+      providers.push({
+        id: row.id,
+        kind,
+        authenticated: row.authenticated,
+        status: row.status,
+        ...(row.reauthRequired ? { reauthRequired: true } : {}),
+        ...(kind === 'oauth' ? { accounts: row.authenticated ? accountCount(row.id) : 0 } : {}),
+      });
+    }
+  }
+  return { ...(rows.pendingSecrets ? { pendingSecrets: true } : {}), providers, notConfigured };
+}
+
 /** OAuth account roster without usage meters or provider-side identities. */
 function publicAccounts(pool) {
   return {
@@ -300,8 +329,9 @@ const SETUP_STATUS_READERS = {
   'local-provider': (rt) => rt.getToolModuleSettings().localProvider,
   features: (rt, { getConfig }) => featureStatus(rt, getConfig),
   shell: (rt) => rt.getSystemShell?.() || {},
-  providers: async (rt) => {
+  providers: async (rt, { detail }) => {
     const rows = publicProviderRows(await rt.getProviderSetup?.({}));
+    if (!detail) return configuredProviderRows(rows, (id) => rt.getProviderAccounts(id).accounts.length);
     rows.oauth = rows.oauth.map((row) =>
       row.authenticated ? { ...row, accounts: publicAccounts(rt.getProviderAccounts(row.id)) } : row
     );
@@ -339,7 +369,7 @@ function validateSetupInput(args) {
     if (action !== 'set_agent_route' && Object.hasOwn(args.route, 'disabled')) {
       throw new Error('route.disabled is only accepted by set_agent_route');
     }
-    for (const field of ['contextPercent', 'contextTokens']) {
+    for (const field of ['contextPercent', 'contextTokens', 'autoEffort']) {
       if (action !== 'set_route' && action !== 'set_agent_route' && Object.hasOwn(args.route, field)) {
         throw new Error(`route.${field} is only accepted by set_route and set_agent_route`);
       }
@@ -401,7 +431,7 @@ const SETUP_ACTION_HANDLERS = {
   status: async (_rt, args, { readStatus, requestDesktop }) => {
     const domain = clean(args.domain) || 'summary';
     requireEnum(domain, SETUP_STATUS_DOMAINS, 'domain');
-    return { domain, ...(await readStatus(domain, requestDesktop)) };
+    return { domain, ...(await readStatus(domain, requestDesktop, args.detail === true)) };
   },
   open: (_rt, args, { openSurface }) => openSurface(args.target),
   set_route: async (rt, args) => {
@@ -631,11 +661,11 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
     return facade;
   };
 
-  async function readStatus(domain, requestDesktop) {
+  async function readStatus(domain, requestDesktop, detail) {
     const rt = api();
     if (SETUP_DESKTOP_DOMAINS.includes(domain)) return requestDesktop({ action: 'status', domain });
     if (!Object.hasOwn(SETUP_STATUS_READERS, domain)) throw new Error(`setup: unknown status domain "${domain}"`);
-    return SETUP_STATUS_READERS[domain](rt, { domain, getConfig: () => getConfig?.() || {} });
+    return SETUP_STATUS_READERS[domain](rt, { domain, detail, getConfig: () => getConfig?.() || {} });
   }
 
   function openSurface(target) {
@@ -669,7 +699,7 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
     dispose: desktop.dispose,
     async execute(args = {}, options = {}) {
       const result = await execute(args, options);
-      if (READ_ONLY_SETUP_ACTIONS.has(args.action)) return JSON.stringify(result ?? {}, null, 2);
+      if (READ_ONLY_SETUP_ACTIONS.has(args.action)) return JSON.stringify(result ?? {});
       await flushSettings?.();
       // Attached surfaces re-read what changed instead of waiting for their
       // next open or cache expiry.

package/src/session-runtime/setup-tool/extended-actions.mjs

@@ -1,11 +1,81 @@
 import { SETUP_EXTENDED_PROPERTIES, SETUP_DESKTOP_ACTIONS } from './settings-contract.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
+import { OPENAI_COMPAT_PRESETS } from '../../runtime/agent/orchestrator/providers/openai-compat-presets.mjs';
 
 const own = (value, key) => Object.hasOwn(value || {}, key);
 const pick = (value, keys) => Object.fromEntries(keys.filter((key) => own(value, key)).map((key) => [key, value[key]]));
 const entryKeys = Object.keys(SETUP_EXTENDED_PROPERTIES.entry.properties);
 const definitionKeys = Object.keys(SETUP_EXTENDED_PROPERTIES.definition.properties);
 
+const MODEL_PAGE_DEFAULT = 25;
+
+function providerIndex(rows) {
+  const counts = new Map();
+  for (const row of rows) counts.set(row.provider, (counts.get(row.provider) || 0) + 1);
+  return [...counts].map(([provider, count]) => {
+    const defaultModel = OPENAI_COMPAT_PRESETS[provider]?.defaultModel;
+    return { provider, count, ...(defaultModel ? { defaultModel } : {}) };
+  });
+}
+
+function compactModelRow(row) {
+  const context = row.contextWindow || null;
+  const maxContext = Number(row.maxContextWindow) || 0;
+  return {
+    id: row.id,
+    display: row.display || row.id,
+    context,
+    ...(maxContext > (context || 0) ? { maxContext } : {}),
+    efforts: (row.effortOptions || []).map((option) => option.value),
+    ...(row.fastCapable === true ? { fast: true } : {}),
+    ...(row.supportsVision === true ? { vision: true } : {}),
+  };
+}
+
+const isPresent = (value) =>
+  value != null &&
+  value !== '' &&
+  value !== false &&
+  !(typeof value === 'object' && !Object.keys(value).length);
+
+/** Everything set_route can use for one model; empty and false fields omitted. */
+function modelDetail(row) {
+  const detail = {
+    provider: row.provider,
+    id: row.id,
+    display: row.display || row.id,
+    context: row.contextWindow,
+    maxContext: Number(row.maxContextWindow) > row.contextWindow ? row.maxContextWindow : null,
+    outputTokens: row.outputTokens,
+    vision: row.supportsVision,
+    webSearch: row.supportsWebSearch,
+    reasoning: row.supportsReasoning,
+    effortOptions: (row.effortOptions || []).map(({ value, label }) => ({ value, label })),
+    defaultEffort: row.defaultEffort,
+    fastCapable: row.fastCapable,
+    fastEfforts: row.fastEfforts,
+    defaultFast: row.defaultFast,
+    serviceTiers: row.serviceTiers,
+    defaultServiceTier: row.defaultServiceTier,
+    additionalSpeedTiers: row.additionalSpeedTiers,
+    modelParameterOptions: row.modelParameterOptions,
+    parameterVariants: row.parameterVariants,
+    defaultModelParameters: row.defaultModelParameters,
+    supportsMaxMode: row.supportsMaxMode,
+  };
+  return Object.fromEntries(Object.entries(detail).filter(([, value]) => isPresent(value)));
+}
+
+function findModel(rows, id, provider) {
+  const matches = rows.filter((row) => row.id === id && (!provider || row.provider === provider));
+  if (!matches.length) {
+    throw new Error(`model "${id}" not found${provider ? ` for provider "${provider}"` : ''}; list_models with catalog.provider returns its model ids`);
+  }
+  const providers = [...new Set(matches.map((row) => row.provider))];
+  if (providers.length > 1) throw new Error(`model "${id}" is offered by ${providers.join(', ')}; pass catalog.provider`);
+  return matches[0];
+}
+
 export function publicAutomation(row) {
   const result = {
     ...pick(row, entryKeys),
@@ -136,12 +206,22 @@ async function saveDefinition(rt, args) {
 export const EXTENDED_SETUP_HANDLERS = Object.freeze({
   set_local_context: (rt, args) => rt.setLocalProviderContext(args.modelId, args.localContextWindow),
   async list_models(rt, args) {
-    const options = args.catalog || {};
-    const refresh = options.refresh === true;
-    const models = options.webSearch
-      ? await rt.listWebSearchModels({ refresh })
-      : await rt.listProviderModels({ refresh });
-    return { models: options.provider ? models.filter((model) => model.provider === options.provider) : models };
+    const { provider, model, page = 1, limit = MODEL_PAGE_DEFAULT, webSearch, refresh } = args.catalog || {};
+    const rows = webSearch
+      ? await rt.listWebSearchModels({ refresh: refresh === true })
+      : await rt.listProviderModels({ refresh: refresh === true });
+    if (model) return { model: modelDetail(findModel(rows, model, provider)) };
+    if (!provider) return { providers: providerIndex(rows) };
+    const own = rows.filter((row) => row.provider === provider);
+    const pages = Math.max(1, Math.ceil(own.length / limit));
+    return {
+      provider,
+      total: own.length,
+      page,
+      pages,
+      ...(page < pages ? { nextPage: page + 1 } : {}),
+      models: own.slice((page - 1) * limit, page * limit).map(compactModelRow),
+    };
   },
   set_orchestration_mode: (rt, args) => rt.setOrchestrationMode(args.mode),
   get_mcp_server: async (rt, args) => publicMcpConfig(await rt.getMcpServerConfig(args.name)),

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -114,9 +114,19 @@ export const SETUP_MCP_SCHEMA = object({
 
 export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
   catalog: object({
-    provider: text,
-    webSearch: boolean,
-    refresh: boolean,
+    provider: {
+      ...text,
+      description: 'list_models: omit for the provider index; set for that provider\'s compact model rows.',
+    },
+    model: {
+      ...text,
+      description:
+        'list_models: one model id; returns its full options (efforts, fast, service tiers, modelParameterOptions, parameterVariants) for set_route. Add provider when several offer the id.',
+    },
+    page: { type: 'integer', minimum: 1, description: 'list_models with provider: 1-based page; default 1.' },
+    limit: { type: 'integer', minimum: 1, maximum: 100, description: 'list_models with provider: rows per page; default 25.' },
+    webSearch: { ...boolean, description: 'list_models: native-search capable models only.' },
+    refresh: { ...boolean, description: 'list_models: refresh the catalog first.' },
   }),
   localContextWindow: {
     type: ['integer', 'null'],

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

@@ -68,7 +68,7 @@ export const SETUP_OPEN_TARGETS = Object.freeze([
 // Runtime dispatch contract. A trailing ? denotes an optional field. Keep
 // this out of the wire schema: field descriptions already name their actions.
 export const SETUP_ACTION_FIELDS = Object.freeze({
-  status: 'domain?',
+  status: 'domain? detail?',
   open: 'target',
   set_route: 'route',
   set_agent_route: 'agent route',
@@ -136,6 +136,10 @@ const ROUTE_SCHEMA = {
     model: { type: 'string' },
     effort: { type: 'string' },
     fast: { type: 'boolean' },
+    autoEffort: {
+      type: 'boolean',
+      description: 'Main and agent routes only: Auto reasoning for this route; omitted = preserved.',
+    },
     modelParameters: { type: 'object', additionalProperties: { type: 'string' } },
     // A typed enum is unrepresentable on Gemini; the bounds project everywhere
     // and the executor rejects values that are not a multiple of 10.
@@ -157,7 +161,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
     name: 'setup',
     title: 'Setup',
     description:
-      "Read or change this Mixdog installation's settings through the runtime. Load the setup skill first (local-provider for managed local-model installation). status reads one domain; open navigates the attached app to a settings surface. Secrets (API keys, OAuth) are never accepted. Changes apply to new sessions unless the result says otherwise.",
+      "Read or change this Mixdog installation's settings through the runtime. Load the setup skill first (local-provider for managed local-model installation). status reads one domain; open navigates the attached app to a settings surface; list_models returns a provider index, then one provider's paged compact rows, then one model's full options (catalog.model). Results are compact JSON. Secrets (API keys, OAuth) are never accepted. Changes apply to new sessions unless the result says otherwise.",
     annotations: {
       title: 'Setup',
       readOnlyHint: false,
@@ -177,6 +181,11 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           enum: [...SETUP_STATUS_DOMAINS],
           description: 'status: which domain to read; default summary.',
         },
+        detail: {
+          type: 'boolean',
+          description:
+            'status providers: full rows for every provider (key URLs, expiry, account ids) instead of configured providers only.',
+        },
         target: {
           type: 'string',
           enum: [...SETUP_OPEN_TARGETS],
@@ -236,7 +245,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         accountId: {
           type: 'string',
           description:
-            'forget_provider_auth: OAuth account id from status providers; required when the provider has several accounts.',
+            'forget_provider_auth: OAuth account id from status providers with detail:true; required when the provider has several accounts.',
         },
         providerAccount: {
           type: 'object',
@@ -263,7 +272,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
               properties: { id: { type: 'string' }, label: { type: 'string', maxLength: 80 } },
             },
           },
-          description: 'set_provider_account: OAuth account change; account ids from status providers.',
+          description: 'set_provider_account: OAuth account change; account ids from status providers with detail:true.',
         },
         modelId: {
           type: 'string',

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

@@ -46,18 +46,16 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
       }
       return { kind: 'user' };
     };
+    const enabledFlags = contextMod.skillEnabledFlags(skills);
     return {
       cwd,
       count: skills.length,
       tools: getTools().map(({ name }) => ({ name })),
-      skills: skills.map((skill) => {
+      skills: skills.map((skill, index) => {
         const source = sourceForSkill(skill);
         return {
           name: skill.name,
-          enabled: !(
-            contextMod.isSkillDisabled?.(skill.name, null, skills) ||
-            contextMod.skillMissingFeature?.(skill.name, null, skills)
-          ),
+          enabled: enabledFlags[index],
           description: skill.description || '',
           whenToUse: skill.whenToUse || '',
           filePath: skill.filePath || null,

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

@@ -6,6 +6,7 @@ import {
   filterDisallowedTools,
   selectDeferredTools,
 } from '../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
+import { AGENT_WORKER_DENIED_TOOLS } from '../runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
 import { LEAD_DISALLOWED_TOOLS } from '../runtime/agent/orchestrator/runtime-core/tool-defs.mjs';
 import { deferredSurfaceModeForLead, toolSpecForMode } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { loadSkillToolDependencies } from '../runtime/agent/orchestrator/runtime-core/skill-tool-loading.mjs';
@@ -52,8 +53,11 @@ export function createToolSurface({
     const workflowTools = hideAgentTool
       ? profileTools.filter((tool) => !agentToolNames.has(String(tool?.name || '')))
       : profileTools;
+    const visibleTools = agentOwned
+      ? workflowTools.filter((tool) => !AGENT_WORKER_DENIED_TOOLS.has(String(tool?.name || '').toLowerCase()))
+      : workflowTools;
     const denied = new Set(getFeatureDisallowedTools().map((name) => String(name || '')));
-    return denied.size ? workflowTools.filter((tool) => !denied.has(String(tool?.name || ''))) : workflowTools;
+    return denied.size ? visibleTools.filter((tool) => !denied.has(String(tool?.name || ''))) : visibleTools;
   }
 
   function disallowedTools() {

package/src/session-runtime/turn/compaction-gate.mjs

@@ -0,0 +1,25 @@
+/**
+ * src/session-runtime/turn/compaction-gate.mjs - serializes a model-scheduled
+ * compaction (session tool) with everything that follows its turn. The
+ * compaction is chained, never left dangling: `after(fn)` wraps a command so it
+ * waits for the compaction in flight, and the compaction itself only runs if
+ * the session it was scheduled for is still the live one.
+ */
+export function createCompactionGate({ getSessionId, compact }) {
+  let tail = Promise.resolve();
+  const run = (sessionId) => {
+    tail = tail
+      .then(() => (getSessionId() === sessionId ? compact() : null))
+      .catch(() => {
+        /* best-effort: a scheduled compaction must never break teardown */
+      });
+    return tail;
+  };
+  const after =
+    (fn) =>
+    async (...args) => {
+      await tail;
+      return fn(...args);
+    };
+  return { run, after };
+}

package/src/session-runtime/turn/session-ops.mjs

@@ -10,7 +10,6 @@ export function createSessionOps(deps) {
   const {
     getSession,
     setSession,
-    getCurrentCwd,
     setMode,
     getActiveTurnCount,
     mgr,
@@ -18,7 +17,7 @@ export function createSessionOps(deps) {
     agentTool,
     invalidatePreSessionToolSurface,
     refreshEmptySessionToolPolicy,
-    applyResolvedCwd,
+    switchProject,
     resolveCwdPath,
     agentStatusState,
     getReservedSessionId,
@@ -122,9 +121,12 @@ export function createSessionOps(deps) {
     return { messageCount: list.length, messages: list.slice(start) };
   }
 
-  function setCwd(path) {
-    applyResolvedCwd(resolveCwdPath(path), { persistProjectSelection: true });
-    return getCurrentCwd();
+  // The desktop/remote Project switch: refused while a turn runs or the
+  // session works in a managed worktree (switchProject); resolves once the
+  // prompt refresh landed. Its target is a registered Project or the task
+  // workspace, classified by desktop membership.
+  async function setCwd(path) {
+    return switchProject(resolveCwdPath(path), { classifyByMembership: true });
   }
 
   return {

package/src/session-runtime/turn/side-question-ops.mjs

@@ -0,0 +1,22 @@
+/**
+ * src/session-runtime/turn/side-question-ops.mjs - /btw side questions on the
+ * runtime's current session. They run beside an in-progress turn and touch no
+ * session state (see orchestrator/session/side-question.mjs).
+ */
+import {
+  askSideQuestion,
+  cancelSideQuestion,
+} from '../../runtime/agent/orchestrator/session/side-question.mjs';
+
+export function createSideQuestionOps({ getSession, getReservedSessionId }) {
+  const sessionId = () => getSession()?.id || getReservedSessionId?.() || '';
+  return {
+    /** @returns {Promise<{ text: string }>} */
+    askSide: (question) => askSideQuestion(sessionId(), question),
+    /** Abort the side question of `targetSessionId` (the session it was
+     *  asked in), or of the current session when omitted. */
+    cancelSide: (targetSessionId) => {
+      cancelSideQuestion(typeof targetSessionId === 'string' && targetSessionId ? targetSessionId : sessionId());
+    },
+  };
+}

package/src/session-runtime/turn/turn-run/ask-callbacks.mjs

@@ -1,4 +1,5 @@
 import { isVisibleStreamProgress } from '../../../runtime/shared/stream-progress.mjs';
+import { toolCallDisplayIdentity } from '../../../runtime/shared/tool-primitives.mjs';
 
 // The askSession callback bridge: caller callbacks pass through, with the
 // transcript, first-visible timing, title release and warmup arming folded in.
@@ -6,10 +7,13 @@ export function createAskCallbacks({ transcript, notifyFnForSession, scheduleSea
   function plannedToolCalls(session0, options) {
     return async (iter, calls) => {
       for (const call of calls || []) {
+        // A bridged call reports the tool it runs; the transcript keeps the wire call.
+        const identity = toolCallDisplayIdentity(call?.name, call?.arguments);
         hooks.emit('tool:planned', {
           sessionId: session0.id,
-          name: call?.name || 'tool',
+          name: identity.name || 'tool',
           callId: call?.id || null,
+          ...(identity.via ? { via: identity.via } : {}),
         });
       }
       if (typeof options.onToolCall === 'function') {

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

@@ -49,9 +49,9 @@ export function createTurnPreparation({
     // Slower servers remain available through the late-tool path; a reconnect
     // in flight gets the same short TTFT grace BEFORE folding the catalog so it
     // cannot hold the provider request. No reconnect in flight → no-op.
-    const awaitGrace = async () => {
+    const awaitGrace = async (options) => {
       try {
-        await turn.awaitTurn(() => turn.timing.awaitMcpGrace());
+        await turn.awaitTurn(() => turn.timing.awaitMcpGrace(options));
       } catch {
         /* gate must never break the turn */
       }
@@ -64,7 +64,12 @@ export function createTurnPreparation({
       // One-shot: cleared before the fold so a throw still never re-runs it,
       // and a resumed session (flag unset) skips straight to the late path.
       session0.deferredInitialRefreshPending = false;
-      await awaitGrace();
+      // A spawned agent runtime owns a fresh MCP scope whose connect starts at
+      // its boot, so the 0 ms default grace would hide every MCP tool from the
+      // agent's first (often only) turn. Agents are not on the user's TTFT
+      // path: wait for the initial connect within the server startup budget.
+      const agentOwned = session0.owner === 'agent' || session0.visibility === 'agent-only';
+      await awaitGrace({ untilConnected: agentOwned });
       try {
         refreshInitialDeferredMcpSurface(session0, scopedMcpTools(session0));
       } catch {

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

@@ -28,6 +28,8 @@ export function createTurnSettlement({
   setFirstTurnCompleted,
   scheduleProviderWarmup,
   scheduleProviderModelWarmup,
+  takePendingCompact,
+  runPendingCompact,
 }) {
   async function completeTurn(turn, session0, result) {
     throwIfAborted(turn.signal);
@@ -99,6 +101,14 @@ export function createTurnSettlement({
       /* lead pool must never break turn teardown */
     }
     setActiveTurnCount(Math.max(0, getActiveTurnCount() - 1));
+    // A compaction the model scheduled (session tool) runs once the turn is over.
+    // Only while the settled session is still the live one; otherwise it stays
+    // pending for that session and never compacts another. The runner chains
+    // the compaction so the next turn waits on it.
+    const settledId = turn.session0?.id;
+    if (getActiveTurnCount() === 0 && settledId && getSession()?.id === settledId && takePendingCompact?.(settledId)) {
+      runPendingCompact?.(settledId);
+    }
     if (!isFirstTurnCompleted()) {
       setFirstTurnCompleted(true);
       scheduleProviderWarmup();

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

@@ -38,11 +38,12 @@ export function createTurnTimingFactory({ getSession, awaitInitialMcpConnect, mc
         /* timing telemetry must never affect a turn */
       }
     };
-    // Give an in-flight MCP connect only a short TTFT grace.
-    timing.awaitMcpGrace = async () => {
+    // Give an in-flight MCP connect only a short TTFT grace. untilConnected
+    // waits for the initial connect bounded only by the server startup budget.
+    timing.awaitMcpGrace = async ({ untilConnected = false } = {}) => {
       const graceStartedAt = performance.now();
       try {
-        await awaitInitialMcpConnect?.(mcpTurnGraceMs);
+        await awaitInitialMcpConnect?.(untilConnected ? undefined : mcpTurnGraceMs);
       } finally {
         timing.mcpWaitMs += performance.now() - graceStartedAt;
       }

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

@@ -13,6 +13,7 @@ import { createSnapshotTrackerFactory } from './turn-run/snapshot-tracker.mjs';
 import { createTurnOpener } from './turn-run/turn-open.mjs';
 import { createTurnPreparation } from './turn-run/turn-prepare.mjs';
 import { createAskCallbacks } from './turn-run/ask-callbacks.mjs';
+import { registerNativeWebSearchUsageSink } from '../native-web-search-usage.mjs';
 import { createTurnSettlement } from './turn-run/turn-settle.mjs';
 
 export function createTurnRunner(deps) {
@@ -94,15 +95,30 @@ export function createTurnRunner(deps) {
     try {
       const session0 = await prepareSession(turn, prompt, options);
       const turnContext = await dispatchPromptSubmit(turn, session0, prompt, options);
-      const result = await mgr.askSession(
-        session0.id,
-        prompt,
-        turnContext || null,
-        plannedToolCalls(session0, options),
-        getCurrentCwd(),
-        options.prefetch || null,
-        askCallbacks(turn, session0, options)
-      );
+      const callbacks = askCallbacks(turn, session0, options);
+      // Register only once askSession's session lock is held: the first
+      // provider send of this turn. A turn queued behind another on the same
+      // session id therefore never receives the running turn's search usage.
+      let releaseWebSearchUsage = null;
+      const providerSendStarted = callbacks.onProviderSendStarted;
+      callbacks.onProviderSendStarted = (...args) => {
+        releaseWebSearchUsage ??= registerNativeWebSearchUsageSink(session0.id, options.onNativeWebSearchUsage);
+        return providerSendStarted(...args);
+      };
+      let result;
+      try {
+        result = await mgr.askSession(
+          session0.id,
+          prompt,
+          turnContext || null,
+          plannedToolCalls(session0, options),
+          getCurrentCwd(),
+          options.prefetch || null,
+          callbacks
+        );
+      } finally {
+        releaseWebSearchUsage?.();
+      }
       return await completeTurn(turn, session0, result);
     } catch (error) {
       reportTurnError(turn, error);

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

@@ -82,22 +82,43 @@ function accountsInUse(accountPool) {
   return inUse;
 }
 
-// Every id a session's spend was recorded under: its own, and the per-account
-// provider session each subscription account sent it under before account
-// sends recorded the visible session.
-function sessionUsageIds(sessionId, accountPool) {
-  const ids = [sessionId];
+// Each subscription provider's account ids, read once per request.
+function accountScopes(accountPool) {
+  const scopes = [];
   for (const provider of ACCOUNT_PROVIDERS) {
     try {
-      for (const account of accountPool(provider).accounts)
-        ids.push(accountScopedSessionId(provider, account.id, sessionId));
+      scopes.push([provider, accountPool(provider).accounts.map((account) => account.id)]);
     } catch {
       /* an unreadable pool leaves that provider's older records out */
     }
   }
+  return scopes;
+}
+
+// Every id a session's spend was recorded under: its own, and the per-account
+// provider session each subscription account sent it under before account
+// sends recorded the visible session.
+function sessionUsageIdsFor(scopes, sessionId) {
+  const ids = [sessionId];
+  for (const [provider, accounts] of scopes) {
+    for (const account of accounts) ids.push(accountScopedSessionId(provider, account, sessionId));
+  }
   return ids;
 }
 
+// Other sessions a caller asks about beside its own (the composer island's
+// agent sessions): bounded, distinct, never the caller's own id.
+const MAX_SESSION_USAGE_IDS = 64;
+function otherSessionIds(options, sessionId) {
+  const ids = Array.isArray(options?.sessionIds) ? options.sessionIds : [];
+  const unique = new Set();
+  for (const id of ids) {
+    if (typeof id === 'string' && id && id !== sessionId) unique.add(id);
+    if (unique.size >= MAX_SESSION_USAGE_IDS) break;
+  }
+  return [...unique];
+}
+
 /** `null` = all time. `0` = today. Anything else is a trailing day count. */
 function normalizeDays(value) {
   if (value === null || value === undefined || value === 'all') return null;
@@ -213,15 +234,26 @@ export function createUsageStatsApi({
       return snapshot;
     },
 
-    /** This runtime's session from its first request, compactions included; null before it has one. */
-    async getSessionUsage() {
+    /**
+     * This runtime's session from its first request, compactions included; null before it has one.
+     * `sessionIds` adds the same totals for each named session (the agents it spawned) under
+     * `sessions`, each read by its own id only.
+     */
+    async getSessionUsage(options = {}) {
       const sessionId = getSessionId();
       if (!sessionId) return null;
       const store = ledger();
       if (!store) throw new Error('Usage ledger is unavailable');
       await store.settleWrites();
-      const usage = await store.sessionUsageAsync(sessionUsageIds(sessionId, accountPool));
-      return { sessionId, ...sessionUsageSnapshot(usage) };
+      const scopes = accountScopes(accountPool);
+      const usage = await store.sessionUsageAsync(sessionUsageIdsFor(scopes, sessionId));
+      const result = { sessionId, ...sessionUsageSnapshot(usage) };
+      const others = otherSessionIds(options, sessionId);
+      if (!others.length) return result;
+      const totals = await Promise.all(
+        others.map(async (id) => [id, sessionUsageSnapshot(await store.sessionUsageAsync(sessionUsageIdsFor(scopes, id)))])
+      );
+      return { ...result, sessions: Object.fromEntries(totals) };
     },
 
     /**