mixdog 0.9.46 → 0.9.49

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

@@ -1,13 +1,15 @@
 import {
   estimateRequestReserveTokens,
   estimateToolSchemaTokens,
-  estimateTranscriptContextUsage,
   contextMessagesRevision,
   resolveSessionCompactPolicy,
   summarizeContextMessages,
   toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
-import { resolveWorkerCompactPolicy } from '../runtime/agent/orchestrator/session/loop/compact-policy.mjs';
+import {
+  resolveCompactionPressureTokens,
+  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']);
@@ -84,6 +86,15 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       lastOutputTokens: Number(session?.lastOutputTokens || 0),
       lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
       lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
+      contextPressureBaselineTokens: Number(session?.contextPressureBaselineTokens || 0),
+      contextPressureBaselineOutputTokens: Number(session?.contextPressureBaselineOutputTokens || 0),
+      contextPressureBaselineMessageCount: Number(session?.contextPressureBaselineMessageCount ?? -1),
+      contextPressureBaselineUpdatedAt: Number(session?.contextPressureBaselineUpdatedAt || 0),
+      contextPressureBaselineBoundary: session?.contextPressureBaselineBoundary || null,
+      contextPressureBaselineProvider: session?.contextPressureBaselineProvider || null,
+      contextPressureBaselineModel: session?.contextPressureBaselineModel || null,
+      contextPressureBaselineToolSignature: session?.contextPressureBaselineToolSignature || null,
+      contextPressureBaselinePrefixSignature: session?.contextPressureBaselinePrefixSignature || null,
       totalInputTokens: Number(session?.totalInputTokens || 0),
       totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
       totalOutputTokens: Number(session?.totalOutputTokens || 0),
@@ -148,10 +159,6 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     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, requestTools, {
-      messageCount: messageSummary.count,
-      estimatedMessageTokens: messageSummary.estimatedTokens,
-    });
     const compactAt = Number(session?.compaction?.lastChangedAt || session?.compaction?.lastCompactAt || 0);
     const usageAt = Number(session?.lastContextTokensUpdatedAt || 0);
     const lastUsageStale = !!lastContextTokens && (
@@ -161,14 +168,6 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     );
     const compactBoundaryTokens = Number(session?.compactBoundaryTokens || session?.compaction?.boundaryTokens || 0);
     const displayWindow = compactBoundaryTokens || effectiveWindow;
-    // The transcript estimate is the single source of truth for the displayed
-    // context footprint. Provider-reported input_tokens (lastContextTokens)
-    // swing non-monotonically and are not window-bounded on some providers
-    // (e.g. OpenAI gpt-5.5 Responses API), so they are kept only as secondary
-    // metadata (lastApiRequestTokens / usage.lastContextTokens) and never feed
-    // the gauge numerator.
-    const usedTokens = estimatedContextTokens;
-    const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
     // 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.
@@ -176,6 +175,16 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const compactPolicy = workerCompactPolicy?.boundaryTokens
       ? workerCompactPolicy
       : resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);
+    // Match the pre-provider-send auto-compact check exactly: the gauge uses
+    // the same provider-baseline-or-estimate pressure, including request and
+    // configured reserves, rather than a separate transcript-only estimate.
+    const compactionPressureTokens = resolveCompactionPressureTokens(
+      messageSummary.estimatedTokens,
+      compactPolicy,
+      { messages, sessionRef: session },
+    );
+    const usedTokens = compactionPressureTokens;
+    const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
     const compactTriggerTokens = compactPolicy.triggerTokens || 0;
     const compactBufferTokens = compactPolicy.bufferTokens || 0;
     const compactBufferRatio = Number.isFinite(compactPolicy.bufferRatio)
@@ -193,7 +202,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
       usedTokens,
       usedSource: 'estimated',
-      currentEstimatedTokens: estimatedContextTokens,
+      currentEstimatedTokens: compactionPressureTokens,
       lastApiRequestTokens: lastContextTokens || 0,
       lastApiRequestStale: lastUsageStale,
       freeTokens,
@@ -203,7 +212,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
         triggerTokens: compactTriggerTokens || null,
         bufferTokens: compactBufferTokens || null,
         bufferRatio: compactBufferRatio,
-        currentEstimatedTokens: estimatedContextTokens,
+        currentEstimatedTokens: compactionPressureTokens,
         lastApiRequestTokens: lastContextTokens || 0,
         lastApiRequestStale: lastUsageStale,
       },

package/src/session-runtime/model-route-api.mjs

@@ -21,6 +21,7 @@ import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mj
 import {
   hasUserConversationMessage,
 } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { rebuildDeferredToolSurfaceForProvider } from './tool-catalog.mjs';
 
 function isSummaryAnchorMessage(message) {
   return message?.role === 'user'
@@ -179,6 +180,7 @@ export function createModelRouteApi(deps) {
       }
       if (session) {
         const route = getRoute();
+        rebuildDeferredToolSurfaceForProvider(session, route.provider);
         const updated = mgr.updateSessionRoute?.(session.id, {
           provider: route.provider,
           model: route.model,

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

@@ -303,8 +303,8 @@ const {
   agentRouteFromConfig,
 } = createWorkflowRouteHelpers({ resolveDefaultProvider, findPreset });
 
-export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full') {
-  return renderToolSearch(args, session, mode);
+export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full', options = {}) {
+  return renderToolSearch(args, session, mode, options);
 }
 
 export function __saveModelSettingsForTest(cfgMod, route, options = {}) {

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

@@ -320,7 +320,10 @@ export function createSessionTurnApi(deps) {
       const catalog = Array.isArray(surface?.deferredToolCatalog)
         ? surface.deferredToolCatalog
         : (Array.isArray(surface?.tools) ? surface.tools : []);
-      const activeNames = new Set((surface?.tools || []).map((tool) => tool?.name).filter(Boolean));
+      const activeNames = new Set([
+        ...(surface?.tools || []).map((tool) => tool?.name).filter(Boolean),
+        ...(surface?.deferredCallableTools || []),
+      ]);
       const needle = clean(query).toLowerCase();
       const rows = catalog.map((tool) => toolRow(tool, activeNames)).filter((row) => row.name);
       const counts = splitToolStatusCounts(rows);

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

@@ -228,13 +228,22 @@ function activeToolForSurface(tool) {
 
 function deferredProviderMode(provider) {
   const p = clean(provider).toLowerCase();
-  if (p === 'gemini') return 'full';
+  if (p === 'gemini') return 'manifest';
   if (p === 'anthropic' || p === 'anthropic-oauth'
-    || p === 'openai' || p === 'openai-oauth'
-    || p === 'xai' || p === 'grok-oauth') {
+    || p === 'openai' || p === 'openai-oauth') {
     return 'native';
   }
-  return 'legacy';
+  // xAI/Grok and every other OpenAI-compatible backend have no native
+  // tool_search/tool_search_output contract. Give them one complete canonical
+  // function array instead of a load-driven array whose bytes churn.
+  return 'canonical';
+}
+
+function nativeProviderFamily(provider) {
+  const p = clean(provider).toLowerCase();
+  if (p === 'openai' || p === 'openai-oauth') return 'openai';
+  if (p === 'anthropic' || p === 'anthropic-oauth') return 'anthropic';
+  return '';
 }
 
 export function filterDisallowedTools(tools, disallowed = []) {
@@ -324,6 +333,7 @@ function toolSearchNativePayload(catalog, names, provider = '') {
   }
   if (!refs.length) return null;
   return {
+    provider: clean(provider).toLowerCase(),
     toolReferences: refs,
     openaiTools: tools,
     summary: `Loaded deferred tools: ${refs.join(', ')}`,
@@ -386,11 +396,16 @@ function setDeferredToolState(session, names) {
 }
 
 export function deferredPoolToolNames(session) {
-  if (!session || session.deferredProviderMode === 'full') return [];
+  if (!session || session.deferredProviderMode === 'full'
+    || session.deferredProviderMode === 'manifest'
+    || session.deferredProviderMode === 'canonical') return [];
   const catalog = Array.isArray(session.deferredToolCatalog)
     ? session.deferredToolCatalog
     : [];
-  const active = new Set((session.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
+  const active = new Set([
+    ...(session.tools || []).map((tool) => clean(tool?.name)).filter(Boolean),
+    ...parseToolSelection(session.deferredCallableTools),
+  ]);
   const out = [];
   for (const tool of catalog) {
     const name = clean(tool?.name);
@@ -447,10 +462,10 @@ 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'
+  let selectedNames = providerMode === 'full' || providerMode === 'manifest' || providerMode === 'canonical'
     ? sortedNamesByMeasuredUsage(catalog.map((tool) => clean(tool?.name)).filter(Boolean))
     : [];
-  if (providerMode !== 'full') {
+  if (!['full', 'manifest', 'canonical'].includes(providerMode)) {
     selectedNames = storedNames.length ? canonicalDeferredToolNames(catalog, storedNames) : [];
     if (!selectedNames.length || providerMode === 'native') selectedNames = sortedNamesByMeasuredUsage(defaultNames);
   }
@@ -460,6 +475,7 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
   session.deferredDefaultTools = sortedNamesByMeasuredUsage(defaultNames);
   session.deferredProviderMode = providerMode;
   session.deferredNativeTools = providerMode === 'native';
+  session.deferredSurfaceMode = mode;
   session.tools.length = 0;
   const active = [];
   for (const tool of catalog) {
@@ -468,6 +484,7 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
     session.tools.push(tool);
     active.push(clean(tool?.name));
   }
+  session.deferredCallableTools = sortedNamesByMeasuredUsage(active);
   if (providerMode === 'native') {
     const discovered = canonicalDeferredToolNames(catalog, session.deferredDiscoveredTools || []);
     session.deferredSelectedTools = active;
@@ -491,6 +508,33 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
   return session;
 }
 
+export function rebuildDeferredToolSurfaceForProvider(session, provider) {
+  if (!session || !Array.isArray(session.tools)) return session;
+  const previousFamily = nativeProviderFamily(session.provider);
+  const nextFamily = nativeProviderFamily(provider);
+  const preserveNativeState = previousFamily && previousFamily === nextFamily;
+  const discovered = preserveNativeState
+    ? canonicalDeferredToolNames(deferredCatalogUnion(session), session.deferredDiscoveredTools || [])
+    : [];
+  const catalog = deferredCatalogUnion(session).slice();
+  session.deferredDiscoveredTools = discovered;
+  applyDeferredToolSurface(
+    session,
+    session.deferredSurfaceMode || 'lead',
+    catalog,
+    { provider },
+  );
+  if (session.deferredProviderMode === 'native' && discovered.length) {
+    session.deferredDiscoveredTools = discovered;
+    session.deferredCallableTools = sortedNamesByMeasuredUsage(new Set([
+      ...(session.deferredCallableTools || []),
+      ...discovered,
+    ]));
+    session.deferredSelectedTools = session.deferredCallableTools.slice();
+  }
+  return session;
+}
+
 // FIRST-TURN deferred-surface refresh (claude-code turn-time deferred manifest).
 // An MCP server may finish its handshake BETWEEN session-create and the first
 // user send. Fold those LIVE MCP tools into the boot deferred catalog + the
@@ -502,7 +546,7 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
 // active — there is no deferred manifest to refresh).
 export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   if (!session || !Array.isArray(session.messages)) return false;
-  if (session.deferredProviderMode === 'full') return false;
+  if (session.deferredProviderMode === 'full' || session.deferredProviderMode === 'canonical') return false;
   const isMcp = (name) => typeof name === 'string' && name.startsWith('mcp__');
   const byName = new Map();
   for (const tool of Array.isArray(session.deferredToolCatalog) ? session.deferredToolCatalog : []) {
@@ -518,6 +562,15 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   }
   if (!added) return false;
   session.deferredToolCatalog = sortedCatalogByMeasuredUsage([...byName.values()]);
+  if (session.deferredProviderMode === 'manifest') {
+    const next = session.deferredToolCatalog.filter((tool) => (
+      session.deferredSurfaceMode !== 'readonly' || isReadonlySelectable(tool)
+    ));
+    session.tools.splice(0, session.tools.length, ...next);
+    session.deferredCallableTools = next.map((tool) => clean(tool?.name)).filter(Boolean);
+    session.updatedAt = Date.now();
+    return true;
+  }
   // Refresh MCP server instructions so a newly-connected server's block is
   // included when BP1 is re-rendered below.
   session.mcpServerInstructions = getMcpServerInstructionsMap();
@@ -558,9 +611,31 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
  */
 export function reconcileDeferredMcpToolCatalog(session, liveMcpTools, options = {}) {
   if (!session || !Array.isArray(session.messages)) return null;
-  if (session.deferredProviderMode === 'full') return null;
+  if (session.deferredProviderMode === 'full' || session.deferredProviderMode === 'canonical') return null;
   const isMcp = (name) => typeof name === 'string' && name.startsWith('mcp__');
   const live = Array.isArray(liveMcpTools) ? liveMcpTools : [];
+  if (session.deferredProviderMode === 'manifest') {
+    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);
+    }
+    for (const tool of live) {
+      const name = clean(tool?.name);
+      if (name && isMcp(name)) byName.set(name, activeToolForSurface(tool));
+    }
+    const catalog = sortedCatalogByMeasuredUsage([...byName.values()]);
+    const next = catalog.filter((tool) => (
+      session.deferredSurfaceMode !== 'readonly' || isReadonlySelectable(tool)
+    ));
+    const before = JSON.stringify((session.tools || []).map((tool) => activeToolForSurface(tool)));
+    const after = JSON.stringify(next);
+    session.deferredToolCatalog = catalog;
+    session.tools.splice(0, session.tools.length, ...next);
+    session.deferredCallableTools = next.map((tool) => clean(tool?.name)).filter(Boolean);
+    if (before !== after) session.updatedAt = Date.now();
+    return before === after ? null : session.deferredCallableTools;
+  }
   const lateCatalog = Array.isArray(session.deferredLateToolCatalog) ? session.deferredLateToolCatalog : [];
   const active = new Set((session.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
 
@@ -700,18 +775,18 @@ function deliverDeferredAnnouncement(session, reminder, options) {
 }
 
 export function selectDeferredTools(session, names, mode, options = {}) {
-  const promoteToActive = options?.promoteToActive === true;
   // Resolve against the union of the boot-frozen catalog and the late-connected
-  // MCP catalog so load_tool can load a late tool; loading promotes it onto
-  // session.tools where the providers serialize it as a real (non-deferred) tool.
+  // MCP catalog so load_tool can load a late tool. Native providers register it
+  // independently; canonical fallback providers already expose the full array.
   const union = deferredCatalogUnion(session);
   const catalog = union.length
     ? union
     : (Array.isArray(session?.tools) ? session.tools : []);
-  const active = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
+  const surfaceActive = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
+  const active = new Set([...surfaceActive, ...parseToolSelection(session?.deferredCallableTools)]);
   const native = session?.deferredProviderMode === 'native' || session?.deferredNativeTools === true;
   const discovered = new Set(Array.isArray(session?.deferredDiscoveredTools) ? session.deferredDiscoveredTools : []);
-  const activateOnSurface = !native || promoteToActive;
+  const activateOnSurface = !native;
   const byName = new Map();
   for (const tool of catalog) {
     const name = clean(tool?.name);
@@ -745,12 +820,14 @@ export function selectDeferredTools(session, names, mode, options = {}) {
       discovered.delete(name);
     } else {
       discovered.add(name);
+      active.add(name);
     }
     added.push(name);
   }
   if (native) {
+    session.deferredCallableTools = sortedNamesByMeasuredUsage(active);
     session.deferredDiscoveredTools = sortedNamesByMeasuredUsage(
-      [...discovered].filter((toolName) => !active.has(toolName)),
+      [...discovered],
     );
     session.deferredSelectedTools = sortedNamesByMeasuredUsage(active);
   } else {
@@ -828,14 +905,31 @@ export function renderToolSearch(args = {}, session, mode = 'full', options = {}
     }, null, 2);
   }
 
+  // Native loads update only the callable registry and provider-native history
+  // payload. Canonical fallback providers already carry the complete array.
   const toolSelection = selectDeferredTools(session, requestedNames, mode);
-  const nextActiveNames = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
+  const nextActiveNames = new Set([
+    ...(session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean),
+    ...parseToolSelection(session?.deferredCallableTools),
+  ]);
   const loaded = toolSelection.added || [];
   const alreadyActive = toolSelection.already || [];
   const missing = toolSelection.missing || [];
   const blocked = toolSelection.blocked || [];
-  const nativeToolSearch = toolSelection.native
-    ? toolSearchNativePayload(catalog, [...new Set([...loaded, ...alreadyActive])], session?.provider)
+  const nativeToolSearchBase = toolSelection.native
+    ? (toolSearchNativePayload(catalog, loaded, session?.provider) || {
+        provider: clean(session?.provider).toLowerCase(),
+        toolReferences: [],
+        openaiTools: [],
+        summary: '',
+      })
+    : null;
+  const nativeSummary = [
+    ...(loaded.length ? [`Loaded deferred tools: ${loaded.join(', ')}`] : []),
+    ...(alreadyActive.length ? [`Already active: ${alreadyActive.join(', ')}`] : []),
+  ].join('\n');
+  const nativeToolSearch = nativeToolSearchBase
+    ? { ...nativeToolSearchBase, summary: nativeSummary || nativeToolSearchBase.summary }
     : null;
   const notes = [];
   if (missing.length && pendingMcpServers.length) {

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

@@ -18,6 +18,7 @@ export const TOOL_SEARCH_TOOL = {
     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 exact names/aliases and select:name syntax.' },
     },
     additionalProperties: false,
   },

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

@@ -1,14 +1,14 @@
-// Pure, dependency-light helpers extracted from the agent-tool facade. No
-// module-level mutable state lives here (the frontmatter perm cache and all
-// timers stay in the facade / their owner modules). Behavior-preserving:
-// function bodies are identical to the originals.
+// Dependency-light helpers extracted from the agent-tool facade.
 import { existsSync, readFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import {
   normalizeAgentPermissionOrNone,
   parseMarkdownFrontmatter,
 } from '../../runtime/shared/markdown-frontmatter.mjs';
-import { clearGatewaySessionRoute, writeGatewaySessionRoute } from '../../vendor/statusline/src/gateway/session-routes.mjs';
+import {
+  clearGatewaySessionRoute,
+  writeGatewaySessionRoutes,
+} from '../../vendor/statusline/src/gateway/session-routes.mjs';
 import { PRESET_ALIASES } from './tool-def.mjs';
 
 export function envTimeoutMs(name, fallback) {
@@ -99,14 +99,33 @@ export function bridgeRouteForStatusline(preset = {}) {
   return out;
 }
 
+const pendingAgentStatuslineRoutes = new Map();
+let pendingAgentStatuslineRouteFlush = null;
+
+export function flushAgentStatuslineRoutes() {
+  if (pendingAgentStatuslineRouteFlush) {
+    clearImmediate(pendingAgentStatuslineRouteFlush);
+    pendingAgentStatuslineRouteFlush = null;
+  }
+  if (pendingAgentStatuslineRoutes.size === 0) return false;
+  const entries = [...pendingAgentStatuslineRoutes.values()];
+  pendingAgentStatuslineRoutes.clear();
+  try { return writeGatewaySessionRoutes(entries); } catch { return false; }
+}
+
 export function writeAgentStatuslineRoute(sessionId, preset) {
   const route = bridgeRouteForStatusline(preset);
   if (!sessionId || !route) return false;
-  try { return writeGatewaySessionRoute(sessionId, route); } catch { return false; }
+  pendingAgentStatuslineRoutes.set(sessionId, { sessionId, route });
+  if (!pendingAgentStatuslineRouteFlush) {
+    pendingAgentStatuslineRouteFlush = setImmediate(flushAgentStatuslineRoutes);
+  }
+  return true;
 }
 
 export function clearAgentStatuslineRoute(sessionId) {
   if (!sessionId) return false;
+  pendingAgentStatuslineRoutes.delete(sessionId);
   try { return clearGatewaySessionRoute(sessionId); } catch { return false; }
 }
 

package/src/standalone/agent-tool.mjs

@@ -993,7 +993,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     // to whatever raw args carry.
     let resolved = null;
     if (!clean(args.model) || !clean(args.provider)) {
-      try { resolved = resolvePreset(cfgMod.loadConfig(), args)?.preset || null; }
+      try { resolved = resolveAgentSpawnPreset(cfgMod.loadConfig(), args)?.preset || null; }
       catch { resolved = null; }
     }
     return sanitizeTaskMeta({
@@ -1127,58 +1127,92 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     }, notifyContext);
   }
 
-  function startProgressIdleWatchdog(sessionId, watchdogPolicy, agent = null) {
-    if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
-    if (typeof mgr.getSessionProgressSnapshot !== 'function' && typeof mgr.getSessionLastProgressAt !== 'function') return null;
-    if (typeof mgr.linkParentSignalToSession !== 'function') return null;
-    const controller = new AbortController();
-    const anchorTs = Date.now();
-    try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
-    const timer = setInterval(() => {
-      if (controller.signal?.aborted) return;
-      const now = Date.now();
-      const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
-        ? mgr.getSessionProgressSnapshot(sessionId)
-        : null;
-      const abortErr = snapshot
-        ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy)
-        : null;
-      const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
-      const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
-      if (!abortErr && !snapshot) {
-        const reported = mgr.getSessionLastProgressAt(sessionId);
-        const last = reported || anchorTs;
-        if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
-          abortAgentProgressWatchdog(controller, {
-            sessionId,
-            agent,
-            error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
-            policy: watchdogPolicy,
-            now,
-            anchorTs,
-            lastProgressAt: reported,
-            iteration,
-          });
-        }
-        return;
-      }
-      if (abortErr) {
+  const progressWatchdogs = new Map();
+  let progressWatchdogTimer = null;
+
+  function stopProgressWatchdogTimerIfIdle() {
+    if (progressWatchdogs.size > 0 || !progressWatchdogTimer) return;
+    try { clearInterval(progressWatchdogTimer); } catch {}
+    progressWatchdogTimer = null;
+  }
+
+  function checkProgressIdleWatchdog(state) {
+    const {
+      sessionId,
+      watchdogPolicy,
+      agent,
+      controller,
+      anchorTs,
+    } = state;
+    if (controller.signal?.aborted) {
+      progressWatchdogs.delete(sessionId);
+      stopProgressWatchdogTimerIfIdle();
+      return;
+    }
+    const now = Date.now();
+    const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
+      ? mgr.getSessionProgressSnapshot(sessionId)
+      : null;
+    const abortErr = snapshot
+      ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy)
+      : null;
+    const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
+    const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
+    if (!abortErr && !snapshot) {
+      const reported = mgr.getSessionLastProgressAt(sessionId);
+      const last = reported || anchorTs;
+      if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
         abortAgentProgressWatchdog(controller, {
           sessionId,
           agent,
-          error: abortErr,
-          snapshot,
+          error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
           policy: watchdogPolicy,
           now,
           anchorTs,
+          lastProgressAt: reported,
           iteration,
         });
       }
+      return;
+    }
+    if (abortErr) {
+      abortAgentProgressWatchdog(controller, {
+        sessionId,
+        agent,
+        error: abortErr,
+        snapshot,
+        policy: watchdogPolicy,
+        now,
+        anchorTs,
+        iteration,
+      });
+    }
+  }
+
+  function ensureProgressWatchdogTimer() {
+    if (progressWatchdogTimer || progressWatchdogs.size === 0) return;
+    progressWatchdogTimer = setInterval(() => {
+      for (const state of [...progressWatchdogs.values()]) {
+        checkProgressIdleWatchdog(state);
+      }
     }, 1000);
-    timer.unref?.();
+    progressWatchdogTimer.unref?.();
+  }
+
+  function startProgressIdleWatchdog(sessionId, watchdogPolicy, agent = null) {
+    if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
+    if (typeof mgr.getSessionProgressSnapshot !== 'function' && typeof mgr.getSessionLastProgressAt !== 'function') return null;
+    if (typeof mgr.linkParentSignalToSession !== 'function') return null;
+    const controller = new AbortController();
+    const anchorTs = Date.now();
+    try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
+    const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
+    progressWatchdogs.set(sessionId, state);
+    ensureProgressWatchdogTimer();
     return {
       stop: () => {
-        try { clearInterval(timer); } catch {}
+        if (progressWatchdogs.get(sessionId) === state) progressWatchdogs.delete(sessionId);
+        stopProgressWatchdogTimerIfIdle();
       },
     };
   }

package/src/tui/App.jsx

@@ -95,6 +95,7 @@ import {
   TRANSCRIPT_WINDOW_MIN_ITEMS,
   TRANSCRIPT_WINDOW_OVERSCAN_ROWS,
   TRANSCRIPT_WINDOW_MAX_ITEMS,
+  TRANSCRIPT_WINDOW_TAIL_OVERSCAN_ROWS,
   SELECTION_PAINT_INTERVAL_MS,
   SCROLL_COALESCE_MS,
   PROMPT_HISTORY_LIMIT,
@@ -3161,6 +3162,9 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
                  rightTone={attachOverlayHint ? inputHintTone : 'info'}
                  rightMessageWidth={attachOverlayHint ? (guardHintWidth || transientStatusWidth || 24) : 24}
                  themeEpoch={state.themeEpoch || 0}
+                 streamingWindowRows={transcriptTailPinned && item.id === state.streamingTail?.id
+                   ? transcriptContentHeight + TRANSCRIPT_WINDOW_TAIL_OVERSCAN_ROWS
+                   : 0}
                />
              );
              // When measured-rows is on, wrap each row in a zero-cost flex column

package/src/tui/app/input-parsers.mjs

@@ -98,14 +98,14 @@ export function parseMemoryCoreRows(text) {
         // meta column instead (blank for common).
         return null;
       }
-      const match = raw.match(/^id=(\d+)\s+\[([^\]]*)\]\s+(.+?)(?:\s+—\s+(.+))?$/);
+      const match = raw.match(/^id=(\d+)\s+(.+?)(?:\s+—\s+(.+))?$/);
       if (match) {
-        const [, id, category, element, summary = ''] = match;
+        const [, id, element, summary = ''] = match;
         return {
           value: `core-${id}`,
           // Display is summary-first: session injection only ever uses the
-          // summary sentence (buildSessionCoreMemoryPayload), so id/category/
-          // element are UI noise. They stay in the hidden _fields for
+          // summary sentence (buildSessionCoreMemoryPayload), so id/element
+          // are UI noise. The element stays in the hidden fields for
           // edit/delete plumbing.
           label: `#${id}`,
           meta: currentProjectId || '',
@@ -113,7 +113,6 @@ export function parseMemoryCoreRows(text) {
           _line: raw,
           _action: 'core-entry',
           _id: Number(id),
-          _category: category,
           _element: element,
           _summary: summary || element,
           _projectId: currentProjectId,
@@ -142,8 +141,8 @@ export function parseMemoryCandidateRows(text) {
   if (!trimmed || /^core candidates:\s*none$/i.test(trimmed)) return [];
   // Backend row shape (index.mjs ~3164), one candidate per line, no group
   // headers:
-  //   id=<n> project=<COMMON|slug> [<category>] score=<x.xx|-> <element> — <summary> (<reason>)
-  const rowPattern = /^id=(\d+)\s+project=(\S+)\s+\[([^\]]*)\]\s+score=(\S+)\s+(.+?)\s+—\s+(.+?)\s+\(([^)]*)\)$/;
+  //   id=<n> project=<COMMON|slug> score=<x.xx|-> <element> — <summary> (<reason>)
+  const rowPattern = /^id=(\d+)\s+project=(\S+)\s+score=(\S+)\s+(.+?)\s+—\s+(.+?)\s+\(([^)]*)\)$/;
   return trimmed
     .split('\n')
     .filter((line) => line.trim())
@@ -151,10 +150,10 @@ export function parseMemoryCandidateRows(text) {
       const raw = line.trim();
       const match = raw.match(rowPattern);
       if (match) {
-        const [, id, project, category, score, element, summary, reason] = match;
+        const [, id, project, score, element, summary, reason] = match;
         return {
           value: `candidate-${id}`,
-          label: `#${id} [${category}] ${element}`,
+          label: `#${id} ${element}`,
           meta: project === 'COMMON' ? 'common' : project,
           description: `${summary}${score !== '-' ? ` (score ${score})` : ''} — ${reason}`,
           _line: raw,