mixdog 0.9.47 → 0.9.49

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,

package/src/tui/components/Markdown.jsx

@@ -28,6 +28,7 @@ export {
   resetStreamingMarkdownStablePrefix,
   resetAllStreamingMarkdownStablePrefixes,
   streamingLayoutText,
+  windowPlainStreamingText,
 } from '../markdown/streaming-markdown.mjs';
 export {
   measureMarkdownRenderedRows,
@@ -82,7 +83,11 @@ export function Markdown({ children, themeEpoch = 0, trimPartialFences = false,
 export function StreamingMarkdown({ children, themeEpoch = 0, columns, streamKey }) {
   const parts = resolveStreamingMarkdownParts(children, streamKey);
   if (parts.plain) {
-    return <Markdown themeEpoch={themeEpoch} columns={columns}>{parts.unstableForRender}</Markdown>;
+    // Plain streaming text has no markdown tokens to style. Sending a growing
+    // multi-line tail through renderTokenAnsiSegments/marked on every delta
+    // reparses the whole response and dominates frame time; Ink can wrap the
+    // identical visible text directly.
+    return <Text color={theme.text} wrap="wrap">{parts.unstableForRender}</Text>;
   }
   return (
     <Box flexDirection="column" gap={1}>

package/src/tui/components/Message.jsx

@@ -15,7 +15,12 @@
 import React from 'react';
 import { Box, Text } from 'ink';
 import { theme, TURN_MARKER } from '../theme.mjs';
-import { Markdown, StreamingMarkdown, resetStreamingMarkdownStablePrefix } from './Markdown.jsx';
+import {
+  Markdown,
+  StreamingMarkdown,
+  resetStreamingMarkdownStablePrefix,
+  windowPlainStreamingText,
+} from './Markdown.jsx';
 import { assistantBodyWidth } from '../markdown/table-layout.mjs';
 
 // `themeEpoch` is a memo-busting prop (threaded from App): the active theme
@@ -28,6 +33,7 @@ export const AssistantMessage = React.memo(function AssistantMessage({
   columns = 80,
   themeEpoch = 0,
   assistantId,
+  streamingWindowRows = 0,
 }) {
   // The body column needs an EXPLICIT numeric width. Without it, ink/Yoga
   // measures the wrapped markdown body before the row's available width is
@@ -43,6 +49,9 @@ export const AssistantMessage = React.memo(function AssistantMessage({
   }, [streaming, assistantId]);
 
   const bodyWidth = assistantBodyWidth(columns);
+  const renderText = streaming && streamingWindowRows > 0
+    ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows)
+    : text;
   return (
     <Box flexDirection="row" marginTop={1}>
       <Box flexShrink={0} minWidth={2}>
@@ -50,7 +59,7 @@ export const AssistantMessage = React.memo(function AssistantMessage({
       </Box>
       <Box flexDirection="column" flexShrink={0} width={bodyWidth}>
         {streaming
-          ? <StreamingMarkdown themeEpoch={themeEpoch} columns={bodyWidth} streamKey={assistantId}>{text}</StreamingMarkdown>
+          ? <StreamingMarkdown themeEpoch={themeEpoch} columns={bodyWidth} streamKey={assistantId}>{renderText}</StreamingMarkdown>
           : <Markdown themeEpoch={themeEpoch} columns={bodyWidth}>{text}</Markdown>}
       </Box>
     </Box>

package/src/tui/components/PromptInput.jsx

@@ -49,6 +49,10 @@ import {
   isModifiedEnterSequence,
   isAnyModifiedEnterSequence,
 } from './prompt-input/edit-helpers.mjs';
+import {
+  cancelPromptImmediateFlush,
+  schedulePromptImmediateFlush,
+} from './prompt-input/immediate-render.mjs';
 
 // Windows Terminal IME composition can clip a glyph that starts exactly at the
 // left edge of the editable text node. The rounded prompt box already adds a
@@ -108,6 +112,7 @@ export function PromptInput({
   });
   const [, bumpCursorAnchorEpoch] = useState(0);
   const draftRef = useRef(draft);
+  const interruptActiveRef = useRef(interruptActive);
   const lastReportedValueRef = useRef(draft.value);
   // Bumped on every submit/draftOverride replace/unmount so an async paste
   // (clipboard read or onPasteText promise) that resolves after the draft
@@ -132,6 +137,7 @@ export function PromptInput({
   const undoRef = useRef({ past: [], future: [], lastPushAt: 0, lastValue: null });
   const { value, cursor } = draft;
   draftRef.current = draft;
+  interruptActiveRef.current = interruptActive;
   if (selectionRef) {
     const range = selectionRange(draft);
     selectionRef.current = range
@@ -158,30 +164,22 @@ export function PromptInput({
     }
   };
 
-  // commitDraft fires on every keystroke; a raw queueMicrotask(flushImmediate)
-  // per commit bypassed ink's maxFps and forced an unthrottled render for each
-  // char (a burst of paste/held-key edits = a render storm). Coalesce to a
-  // frame budget: flush the first keystroke immediately (no caret lag) and
-  // batch the rest to one flush per ~16ms, with a trailing flush so the final
-  // char of a burst always lands.
-  const FLUSH_INTERVAL_MS = 16;
+  // During an active turn, ink is already painting streaming updates at its
+  // 60fps budget. A second unthrottled input render competes with those frames
+  // and makes key echo slower, so busy input stays on ink's normal render path.
+  // Idle input keeps the leading+trailing immediate flush for crisp caret echo.
   const scheduleImmediateFlush = () => {
-    const t = flushThrottleRef.current;
-    const now = Date.now();
-    const elapsed = now - t.lastAt;
-    if (elapsed >= FLUSH_INTERVAL_MS) {
-      if (t.timer !== null) { clearTimeout(t.timer); t.timer = null; }
-      t.lastAt = now;
-      queueMicrotask(flushImmediate);
-    } else if (t.timer === null) {
-      t.timer = setTimeout(() => {
-        t.timer = null;
-        t.lastAt = Date.now();
-        flushImmediate();
-      }, FLUSH_INTERVAL_MS - elapsed);
-    }
+    schedulePromptImmediateFlush({
+      throttle: flushThrottleRef.current,
+      isSuppressed: () => interruptActiveRef.current,
+      flush: flushImmediate,
+    });
   };
 
+  useEffect(() => () => {
+    cancelPromptImmediateFlush(flushThrottleRef.current);
+  }, []);
+
   const commitDraft = (next, options = {}) => {
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;