mixdog 0.9.44 → 0.9.46

package/src/session-runtime/context-status.mjs

@@ -7,8 +7,30 @@ import {
   summarizeContextMessages,
   toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import { resolveWorkerCompactPolicy } from '../runtime/agent/orchestrator/session/loop/compact-policy.mjs';
 import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
 
+const DEFERRED_CATALOG_TOOL_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
+
+// Mirrors the tool-list portion of the Anthropic adapters without changing
+// their wire serialization. Other native-deferred providers expose the
+// catalog through BP1/system content, which is already metered there.
+export function requestSerializedToolsForContext(session, provider) {
+  const activeTools = Array.isArray(session?.tools) ? session.tools : [];
+  const normalizedProvider = String(provider || '').trim().toLowerCase();
+  if (!DEFERRED_CATALOG_TOOL_PROVIDERS.has(normalizedProvider)
+    || session?.deferredNativeTools !== true
+    || activeTools.length === 0) {
+    return activeTools;
+  }
+  const activeNames = new Set(activeTools.map((tool) => String(tool?.name || '').trim()).filter(Boolean));
+  const catalog = Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : [];
+  const deferredTools = catalog
+    .filter((tool) => tool?.name && !activeNames.has(String(tool.name)))
+    .map((tool) => ({ ...tool, deferLoading: true }));
+  return deferredTools.length ? [...activeTools, ...deferredTools] : activeTools;
+}
+
 // Live /context gauge computation + its self-owned memoization cache. Extracted
 // verbatim from the runtime API object; the runtime injects live getters for
 // the mutable session/route/cwd/mode locals. The cache (key + value) is owned
@@ -18,7 +40,15 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
   let contextStatusCacheKey = null;
   let contextStatusCacheValue = null;
 
-  function contextStatusCacheKeyFor({ messages, tools, messagesRevision, toolsSignature }) {
+  function contextStatusCacheKeyFor({
+    messages,
+    tools,
+    messagesRevision,
+    toolsSignature,
+    requestProvider,
+    requestToolCount,
+    requestToolsSignature,
+  }) {
     const session = getSession();
     const route = getRoute();
     const compaction = session?.compaction || {};
@@ -39,6 +69,9 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       tools,
       toolCount: tools.length,
       toolsSignature,
+      requestProvider,
+      requestToolCount,
+      requestToolsSignature,
       contextWindow: session?.contextWindow || null,
       rawContextWindow: session?.rawContextWindow || null,
       effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
@@ -89,22 +122,33 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
     const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
     const tools = Array.isArray(session?.tools) ? session.tools : [];
+    const requestProvider = session?.provider || route.provider;
+    const requestTools = requestSerializedToolsForContext(session, requestProvider);
     const messagesRevision = contextMessagesRevision(messages);
     const toolsSignature = toolSchemaSignature(tools);
-    const cacheKey = contextStatusCacheKeyFor({ messages, tools, messagesRevision, toolsSignature });
+    const requestToolsSignature = toolSchemaSignature(requestTools);
+    const cacheKey = contextStatusCacheKeyFor({
+      messages,
+      tools,
+      messagesRevision,
+      toolsSignature,
+      requestProvider,
+      requestToolCount: requestTools.length,
+      requestToolsSignature,
+    });
     if (contextStatusCacheValue && sameContextStatusCacheKey(cacheKey, contextStatusCacheKey)) {
       return contextStatusCacheValue;
     }
 
     const messageSummary = summarizeContextMessages(messages);
-    const toolSchemaTokens = estimateToolSchemaTokens(tools);
-    const toolSchemaBreakdown = estimateToolSchemaBreakdown(tools);
-    const requestReserveTokens = estimateRequestReserveTokens(tools);
+    const toolSchemaTokens = estimateToolSchemaTokens(requestTools);
+    const toolSchemaBreakdown = estimateToolSchemaBreakdown(requestTools);
+    const requestReserveTokens = estimateRequestReserveTokens(requestTools);
     const requestOverheadTokens = Math.max(0, requestReserveTokens - toolSchemaTokens);
     const rawWindow = Number(session?.rawContextWindow || session?.contextWindow || 0);
     const effectiveWindow = Number(session?.contextWindow || rawWindow || 0);
     const lastContextTokens = Number(session?.lastContextTokens || 0);
-    const estimatedContextTokens = estimateTranscriptContextUsage(messages, tools, {
+    const estimatedContextTokens = estimateTranscriptContextUsage(messages, requestTools, {
       messageCount: messageSummary.count,
       estimatedMessageTokens: messageSummary.estimatedTokens,
     });
@@ -125,15 +169,18 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     // the gauge numerator.
     const usedTokens = estimatedContextTokens;
     const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
-    // Use the same shared compact-policy math as manager/loop. Do not trust
-    // persisted trigger telemetry as an independent policy input: it is an
-    // output snapshot and was the source of repeated /context false positives.
-    // Shared session-compaction policy (same math as manager/loop): agent-owned
-    // semantic sessions report/fire at 90% of the boundary; main/user
-    // recall-fasttrack report/fire on the boundary itself (100%).
-    const compactPolicy = resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);
+    // Use the worker policy when a boundary is available so target/reserve
+    // headroom, trigger, buffer tokens, and buffer ratio stay identical to the
+    // auto-compact decision. Fall back only for incomplete session metadata.
+    const workerCompactPolicy = resolveWorkerCompactPolicy(session, tools);
+    const compactPolicy = workerCompactPolicy?.boundaryTokens
+      ? workerCompactPolicy
+      : resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);
     const compactTriggerTokens = compactPolicy.triggerTokens || 0;
     const compactBufferTokens = compactPolicy.bufferTokens || 0;
+    const compactBufferRatio = Number.isFinite(compactPolicy.bufferRatio)
+      ? compactPolicy.bufferRatio
+      : null;
     const value = {
       sessionId: session?.id || null,
       provider: route.provider,
@@ -155,6 +202,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
         boundaryTokens: compactBoundaryTokens || null,
         triggerTokens: compactTriggerTokens || null,
         bufferTokens: compactBufferTokens || null,
+        bufferRatio: compactBufferRatio,
         currentEstimatedTokens: estimatedContextTokens,
         lastApiRequestTokens: lastContextTokens || 0,
         lastApiRequestStale: lastUsageStale,

package/src/session-runtime/mcp-glue.mjs

@@ -6,13 +6,19 @@
 import { resolve } from 'node:path';
 import { statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
-import { readProjectMcpServers } from './plugin-mcp.mjs';
+import { normalizeMcpProjectPathKey, readProjectMcpServers } from './plugin-mcp.mjs';
 
 // Cache project-local `.mcp.json` reads by path + mtime so repeated mcpStatus()
 // calls skip existsSync+readFileSync+JSON.parse when the file is unchanged.
 // Invalidated automatically on any mtime change (or create/delete via mtime=0).
 const projectMcpCache = new Map();
 const PROJECT_MCP_CACHE_MAX = 32;
+export function invalidateProjectMcpCache(cwd) {
+  projectMcpCache.delete(resolve(cwd || '.', '.mcp.json'));
+}
+function mcpDisabled() {
+  return /^(?:1|true|on|yes)$/i.test(String(process.env.MIXDOG_DISABLE_MCP || ''));
+}
 function cachedProjectMcpServers(cwd) {
   const path = resolve(cwd || '.', '.mcp.json');
   let mtimeMs = 0;
@@ -48,12 +54,23 @@ export function createMcpGlue({
   // (precedence: project > user config). `sources[name]` records each server's
   // origin ('config' | 'project') for status reporting.
   function resolveEffectiveMcpServers() {
+    // Benchmark/embedding guard: do not even inspect project `.mcp.json`.
+    if (mcpDisabled()) return { servers: {}, sources: {} };
     const config = getConfig();
     const configured = config?.mcpServers && typeof config.mcpServers === 'object'
       ? config.mcpServers
       : {};
+    const projectKey = normalizeMcpProjectPathKey(getCurrentCwd());
+    const overrides = config?.mcpProjectOverrides?.[projectKey];
+    const foldedConfigured = {};
+    for (const [name, cfg] of Object.entries(configured)) {
+      const override = overrides?.[name];
+      foldedConfigured[name] = typeof override?.enabled === 'boolean'
+        ? { ...cfg, enabled: override.enabled }
+        : cfg;
+    }
     const project = cachedProjectMcpServers(getCurrentCwd());
-    const servers = { ...configured, ...project };
+    const servers = { ...foldedConfigured, ...project };
     const sources = {};
     for (const name of Object.keys(configured)) sources[name] = 'config';
     for (const name of Object.keys(project)) sources[name] = 'project';
@@ -61,6 +78,9 @@ export function createMcpGlue({
   }
 
   function mcpStatus() {
+    if (mcpDisabled()) {
+      return { servers: [], configuredCount: 0, connectedCount: 0, failedCount: 0 };
+    }
     const { servers: configured, sources } = resolveEffectiveMcpServers();
     const connected = new Map((mcpClient.getMcpServerStatus?.() || []).map((row) => [row.name, row]));
     const failures = new Map((state.mcpFailures || []).map((row) => [row.name, row]));
@@ -129,6 +149,13 @@ export function createMcpGlue({
   }
 
   async function connectConfiguredMcp({ reset = false, only = null, enabled = true } = {}) {
+    if (mcpDisabled()) {
+      ++state.mcpConnectGeneration;
+      state.mcpFailures = [];
+      if (only) await mcpClient.disconnectMcpServer?.(only);
+      else await mcpClient.disconnectAll?.();
+      return mcpStatus();
+    }
     // Scoped single-server toggle: non-superseding. It must NEVER cancel a
     // pending full {reset} (cwd-change/boot). So do not bump the generation;
     // just wait for any in-flight run, then bail if a newer full reset has

package/src/session-runtime/plugin-mcp.mjs

@@ -4,6 +4,13 @@ import { isAbsolute, join, relative, resolve } from 'node:path';
 import { clean } from './session-text.mjs';
 import { readJsonSafe } from './fs-utils.mjs';
 
+// Config keys must compare the same cwd spelling on read and write. Windows
+// paths are case-insensitive, so canonicalize their resolved form to lowercase.
+export function normalizeMcpProjectPathKey(cwd) {
+  const path = resolve(cwd || '.');
+  return process.platform === 'win32' ? path.toLowerCase() : path;
+}
+
 // Project-local MCP ingress: read `.mcp.json` from the project root and return
 // a cleaned { name: cfg } map. Best-effort — never throws. Accepts either the
 // standard `{ mcpServers: {...} }` shape or a bare name->cfg map. Self-ref

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

@@ -18,7 +18,9 @@ import {
   pluginMcpEnableScript,
   resolveContainedPluginPath,
   setProjectMcpServerEnabled,
+  normalizeMcpProjectPathKey,
 } from './plugin-mcp.mjs';
+import { invalidateProjectMcpCache } from './mcp-glue.mjs';
 
 // MCP servers, skills, plugins, hooks, and memory/recall surfaces. Extracted
 // verbatim from the runtime API object; stateless helpers are imported directly
@@ -137,7 +139,19 @@ export function createResourceApi(deps) {
         throw new Error(`MCP server not configured: ${serverName}`);
       }
       delete current[serverName];
-      saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
+      const currentOverrides = nextConfig.mcpProjectOverrides && typeof nextConfig.mcpProjectOverrides === 'object'
+        ? nextConfig.mcpProjectOverrides
+        : {};
+      const mcpProjectOverrides = {};
+      for (const [projectKey, serverOverrides] of Object.entries(currentOverrides)) {
+        if (!serverOverrides || typeof serverOverrides !== 'object' || Array.isArray(serverOverrides)) continue;
+        const nextServerOverrides = { ...serverOverrides };
+        delete nextServerOverrides[serverName];
+        if (Object.keys(nextServerOverrides).length > 0) {
+          mcpProjectOverrides[projectKey] = nextServerOverrides;
+        }
+      }
+      saveConfigAndAdopt({ ...nextConfig, mcpServers: current, mcpProjectOverrides });
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
       const session = getSession();
@@ -152,11 +166,13 @@ export function createResourceApi(deps) {
       // A project-local `.mcp.json` entry WINS over config for this name, so the
       // durable toggle must land in whichever file actually drives the server.
       // For project-sourced servers, persist the `enabled` flag into `.mcp.json`
-      // (the mtime bump invalidates the project cache), then run the same
+      // then explicitly invalidate the project cache (mtime granularity is not
+      // reliable for same-tick writes), before running the same
       // background connect/recreate chain used for config servers.
       const shadowRow = mcpStatus().servers.find((s) => s.name === serverName);
       if (shadowRow && shadowRow.source === 'project') {
         setProjectMcpServerEnabled(getCurrentCwd(), serverName, want);
+        invalidateProjectMcpCache(getCurrentCwd());
         return scheduleMcpToggle(serverName, want);
       }
       const nextConfig = { ...getConfig() };
@@ -166,12 +182,29 @@ export function createResourceApi(deps) {
       if (!Object.prototype.hasOwnProperty.call(current, serverName)) {
         throw new Error(`MCP server not configured: ${serverName}`);
       }
-      // Adopt + persist config synchronously (fast) so intent is durable, then
+      // Keep the global server definition single-source; only this project's
+      // enabled override is adopted + persisted synchronously (fast), then
       // hand the heavy connect/close/recreate to the per-server background
       // chain. Return that chain's promise so callers can settle the picker on
       // completion, but the store no longer blocks on it.
-      current[serverName] = { ...(current[serverName] || {}), enabled: want };
-      saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
+      const projectKey = normalizeMcpProjectPathKey(getCurrentCwd());
+      const currentOverrides = nextConfig.mcpProjectOverrides && typeof nextConfig.mcpProjectOverrides === 'object'
+        ? nextConfig.mcpProjectOverrides
+        : {};
+      const projectOverrides = currentOverrides[projectKey] && typeof currentOverrides[projectKey] === 'object'
+        ? currentOverrides[projectKey]
+        : {};
+      cfgMod.markMcpProjectOverrideDirty(projectKey, serverName, want);
+      saveConfigAndAdopt({
+        ...nextConfig,
+        mcpProjectOverrides: {
+          ...currentOverrides,
+          [projectKey]: {
+            ...projectOverrides,
+            [serverName]: { enabled: want },
+          },
+        },
+      });
       return scheduleMcpToggle(serverName, want);
     },
     skillsStatus() {

package/src/session-runtime/runtime-core.mjs

@@ -1051,7 +1051,7 @@ export async function createMixdogSessionRuntime({
   const toolsStartedAt = performance.now();
   const standaloneTools = [
     TOOL_SEARCH_TOOL,
-    SKILL_TOOL,
+    ...(envFlag('MIXDOG_DISABLE_SKILLS') ? [] : [SKILL_TOOL]),
     CWD_TOOL,
     SESSION_MANAGE_TOOL,
     EXPLORE_TOOL,
@@ -1141,6 +1141,10 @@ export async function createMixdogSessionRuntime({
           routingSessionId: callerSessionId,
           clientHostPid: callerCtx?.clientHostPid || session?.clientHostPid || process.pid,
           notifyFn: notifyFnForSession(callerSessionId),
+          // Cascade caller cancellation (ESC / owner abort) into the explore
+          // fan-out so every child dispatch tears down immediately — same
+          // signal the adjacent native search already forwards.
+          signal: callerCtx?.signal || session?.controller?.signal,
         });
       }
       if (name === 'cwd') {

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

@@ -11,6 +11,18 @@ import {
 } from './tool-catalog.mjs';
 import { getMcpTools } from '../runtime/agent/orchestrator/mcp/client.mjs';
 
+export function splitToolStatusCounts(rows) {
+  const list = Array.isArray(rows) ? rows : [];
+  const regular = list.filter((row) => row?.kind !== 'mcp' && row?.kind !== 'skill');
+  const mcp = list.filter((row) => row?.kind === 'mcp');
+  return {
+    count: regular.length,
+    activeCount: regular.filter((row) => row.active).length,
+    mcpToolCount: mcp.length,
+    activeMcpToolCount: mcp.filter((row) => row.active).length,
+  };
+}
+
 // Turn execution (ask) + session-manage/tool-surface/agent surfaces. Extracted
 // verbatim from the runtime API object; stateless helpers are imported directly
 // and the runtime injects live getters/setters for the mutable session/mode/
@@ -311,13 +323,13 @@ export function createSessionTurnApi(deps) {
       const activeNames = new Set((surface?.tools || []).map((tool) => tool?.name).filter(Boolean));
       const needle = clean(query).toLowerCase();
       const rows = catalog.map((tool) => toolRow(tool, activeNames)).filter((row) => row.name);
+      const counts = splitToolStatusCounts(rows);
       const tools = needle
         ? rows.filter((row) => toolSearchMatches(row, needle))
         : rows;
       return {
         mode: getMode(),
-        count: rows.length,
-        activeCount: rows.filter((row) => row.active).length,
+        ...counts,
         tools,
         activeTools: sortedNamesByMeasuredUsage(activeNames),
         discoveredTools: sortedNamesByMeasuredUsage(surface?.deferredDiscoveredTools || []),

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

@@ -189,6 +189,11 @@ export function createSettingsApi({
         next.type = compactType;
         next.compactType = compactType;
       }
+      // These controls apply only to main/user recall-fasttrack sessions;
+      // agent-owned semantic sessions retain their existing `buffer*` policy.
+      for (const key of ['mainBufferTokens', 'mainBuffer', 'mainBufferPercent', 'mainBufferPct', 'mainBufferRatio', 'mainBufferFraction']) {
+        if (hasOwn(input, key)) next[key] = input[key];
+      }
       const nextConfig = { ...config };
       nextConfig.compaction = normalizeCompactionConfig(next, { memoryEnabled: memoryEnabled() });
       saveConfigAndAdopt(nextConfig);

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

@@ -2,7 +2,7 @@
 // tool_search ranking + auto-selection, and the session tool-surface
 // application/selection logic. Pure module (session objects passed in).
 import { clean, LATE_TOOL_ANNOUNCEMENT_SENTINEL } from './session-text.mjs';
-import { estimateToolSchemaTokens } from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import { estimateToolSchemaTokens, toolSchemaSignature } from '../runtime/agent/orchestrator/session/context-utils.mjs';
 import { applyInitialDeferredToolManifestToBp1, buildDeferredToolManifest } from '../runtime/agent/orchestrator/context/collect.mjs';
 import { getMcpServerInstructionsMap } from '../runtime/agent/orchestrator/mcp/client.mjs';
 import {
@@ -40,7 +40,12 @@ function sameToolSchemaEntries(cached, tools) {
       || entry.inputSchema !== tool?.inputSchema
       || entry.input_schema !== tool?.input_schema
       || entry.parameters !== tool?.parameters
-      || entry.schema !== tool?.schema) return false;
+      || entry.schema !== tool?.schema
+      || entry.deferLoading !== tool?.deferLoading
+      || entry.defer_loading !== tool?.defer_loading
+      || entry.annotationsMixdogKind !== tool?.annotations?.mixdogKind
+      || entry.annotationsAgentHidden !== tool?.annotations?.agentHidden
+      || entry.wireSignature !== toolSchemaSignature([tool])) return false;
   }
   return true;
 }
@@ -54,6 +59,11 @@ function toolSchemaEntry(tool) {
     input_schema: tool?.input_schema,
     parameters: tool?.parameters,
     schema: tool?.schema,
+    deferLoading: tool?.deferLoading,
+    defer_loading: tool?.defer_loading,
+    annotationsMixdogKind: tool?.annotations?.mixdogKind,
+    annotationsAgentHidden: tool?.annotations?.agentHidden,
+    wireSignature: toolSchemaSignature([tool]),
   };
 }
 export const DEFERRED_DEFAULT_FULL_TOOLS = Object.freeze([
@@ -143,6 +153,7 @@ export function toolSchemaBucket(tool) {
   const kind = toolKind(tool);
   if (kind === 'mcp') return 'mcp';
   if (kind === 'skill') return 'skills';
+  if (kind === 'control') return 'control';
   if (name === 'memory' || name === 'recall' || name.includes('memory')) return 'memory';
   if (name === 'search' || name === 'web_fetch') return 'web';
   if (['read', 'grep', 'find', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';

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

@@ -13,13 +13,11 @@ export const TOOL_SEARCH_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'load_tool: pure loader for deferred tools. Pass names:["exact_tool_name", ...] (deferred tool names/aliases) to load them; returns loaded / already-active / missing plus any MCP servers still connecting (retry next turn) or failed. No keyword search, no ranking, no listing. Deferred tools can also be called directly by name (they auto-load on first call).',
+  description: 'Load deferred tools by exact name via names[]; reports loaded/already-active/missing plus MCP servers still connecting or failed. Deferred tools also auto-load when called directly.',
   inputSchema: {
     type: 'object',
     properties: {
       names: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Exact deferred tool names/aliases to load.' },
-      select: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Legacy alias for names (accepts "select:a,b").' },
-      query: { type: 'string', description: 'Legacy: only "select:a,b" is honored (mapped to names); free-text keyword queries are rejected — this tool does not search.' },
     },
     additionalProperties: false,
   },

package/src/standalone/agent-task-status.mjs

@@ -1,6 +1,7 @@
 import {
   agentWatchdogPolicyActive,
   evaluateAgentWatchdogAbort,
+  resolveEffectiveToolRunningCeilingMs,
 } from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 
 const ACTIVE_RUNTIME_STAGES = new Set([
@@ -18,10 +19,26 @@ function positiveSeconds(now, ts) {
   return Math.max(0, Math.floor((now - n) / 1000));
 }
 
-export function formatAgentWatchdogSummary(policy) {
+export function formatAgentWatchdogSummary(policy, snapshot = null) {
   if (!policy || !agentWatchdogPolicyActive(policy)) return null;
+  const transportMs = policy.firstTransportMs ?? policy.firstResponseMs ?? 0;
+  const semanticMs = policy.firstSemanticMs ?? policy.firstVisibleCeilingMs ?? 0;
+  if (snapshot) {
+    if (snapshot.waitingForTransport && transportMs > 0) {
+      return `armed transport=${Math.round(transportMs / 1000)}s`;
+    }
+    if ((snapshot.waitingForFirstSemantic ?? snapshot.waitingForFirstActivity) && semanticMs > 0) {
+      return `armed semantic=${Math.round(semanticMs / 1000)}s`;
+    }
+    if (snapshot.stage === 'tool_running' && policy.toolRunningMs > 0) {
+      const effectiveMs = resolveEffectiveToolRunningCeilingMs(snapshot, policy);
+      return `armed tool=${Math.round(effectiveMs / 1000)}s`;
+    }
+    if (policy.idleStaleMs > 0) return `armed idle=${Math.round(policy.idleStaleMs / 1000)}s`;
+  }
   const parts = [];
-  if (policy.firstResponseMs > 0) parts.push(`first=${Math.round(policy.firstResponseMs / 1000)}s`);
+  if (transportMs > 0) parts.push(`transport=${Math.round(transportMs / 1000)}s`);
+  if (semanticMs > 0) parts.push(`semantic=${Math.round(semanticMs / 1000)}s`);
   if (policy.idleStaleMs > 0) parts.push(`idle=${Math.round(policy.idleStaleMs / 1000)}s`);
   if (policy.toolRunningMs > 0) parts.push(`tool=${Math.round(policy.toolRunningMs / 1000)}s`);
   return parts.length ? `armed ${parts.join(' ')}` : null;
@@ -55,7 +72,7 @@ export function buildAgentTaskProgressFields({
   const stage = cleanStage(runtimeStage || snapshot?.stage || sessionStatus || 'unknown');
   const workerStage = stage;
   const silentFor = resolveSilentForSeconds(now, snapshot, runtime);
-  const watchdog = formatAgentWatchdogSummary(policy);
+  const watchdog = formatAgentWatchdogSummary(policy, snapshot);
   const queued = Number.isFinite(Number(queuedFollowups)) && Number(queuedFollowups) > 0
     ? Math.floor(Number(queuedFollowups))
     : null;
@@ -96,13 +113,24 @@ function cleanStage(value) {
 }
 
 function describeLastProgress({ stage, snapshot, runtime, silentFor, lastToolCall, now }) {
-  if (snapshot?.waitingForFirstActivity) return 'awaiting first model response';
+  if (snapshot?.waitingForTransport) return 'awaiting model transport';
+  if (snapshot?.waitingForFirstSemantic ?? snapshot?.waitingForFirstActivity) {
+    return 'transport active; awaiting first model event';
+  }
   if (stage === 'tool_running') {
     const tool = cleanStage(lastToolCall);
     return tool && tool !== 'unknown' ? `tool: ${tool}` : 'tool running';
   }
   if (stage === 'connecting' || stage === 'requesting') return 'connecting to model';
   if (stage === 'streaming') {
+    if (snapshot?.lastSemanticKind === 'tool') return 'tool protocol progress';
+    if (snapshot?.lastSemanticKind === 'text') return 'visible model text';
+    if (snapshot?.lastSemanticKind === 'reasoning') {
+      return snapshot?.lastVisibleTextAt
+        ? 'model reasoning (hidden; visible output previously emitted)'
+        : 'model reasoning (hidden; no visible output yet)';
+    }
+    if (snapshot?.hasFirstSemantic) return 'model active (no visible output yet)';
     const streamSilent = positiveSeconds(
       now,
       snapshot?.lastStreamDeltaAt || runtime?.lastStreamDeltaAt || 0,
@@ -149,9 +177,25 @@ function describeAgentDiagnostic({
     return `idle, ${queued} follow-up${queued === 1 ? '' : 's'} queued`;
   }
 
-  if (snapshot?.waitingForFirstActivity) return 'waiting for first response';
+  if (policy) {
+    const abortErr = evaluateAgentWatchdogAbort(snapshot, now, policy);
+    if (abortErr) return `stale: ${abortErr.message.replace(/^agent /i, '')}`;
+  }
+
+  if (snapshot?.waitingForTransport) return 'waiting for model transport';
+  if (snapshot?.waitingForFirstSemantic ?? snapshot?.waitingForFirstActivity) {
+    return 'transport healthy; waiting for first semantic model event';
+  }
 
   if (stage === 'streaming') {
+    if (snapshot?.lastSemanticKind === 'tool') return 'tool protocol active';
+    if (snapshot?.lastSemanticKind === 'text') return 'visible text streaming';
+    if (snapshot?.lastSemanticKind === 'reasoning') {
+      return snapshot?.lastVisibleTextAt
+        ? 'hidden reasoning active; visible output previously emitted'
+        : 'hidden reasoning active; no visible output yet';
+    }
+    if (snapshot?.hasFirstSemantic) return 'model active; no visible output yet';
     const streamSilent = positiveSeconds(
       now,
       snapshot?.lastStreamDeltaAt || 0,
@@ -171,12 +215,7 @@ function describeAgentDiagnostic({
       now,
       policy,
     );
-    if (abortErr) {
-      return `stale: ${abortErr.message.replace(/^agent /i, '')}`;
-    }
-    if (silentFor >= 30) {
-      return `stale: no stream/tool progress for ${silentFor}s`;
-    }
+    if (abortErr) return `stale: ${abortErr.message.replace(/^agent /i, '')}`;
   }
 
   if (normalizedTask === 'running' && (stage === 'idle' || stage === 'done')) {

package/src/standalone/agent-tool/tool-def.mjs

@@ -35,7 +35,7 @@ export const AGENT_TOOL = {
     openWorldHint: true,
     agentHidden: true,
   },
-  description: 'Delegate scoped work. Agent handoffs always start background tasks and return task IDs immediately. Spawn every independent scope in parallel in the same turn, each with a distinct tag; for the same scope, use send or spawn with the same tag to reuse the live session. Wait for the completion notification before dependent work. Do not call status/read after spawn; they are manual recovery only.',
+  description: 'Delegate scoped work; handoffs always start background tasks (task ids return immediately). Distinct tags for independent scopes; spawn/send with the same tag reuses the live session for the same scope. Wait for the completion notification; do not call status/read after spawn (manual recovery only).',
   inputSchema: {
     type: 'object',
     properties: {