mixdog 0.9.49 → 0.9.51

package/src/runtime/search/lib/http-fetch.mjs

@@ -1,4 +1,6 @@
 import { readFileSync } from 'fs'
+import dns from 'node:dns'
+import { Agent, fetch as undiciFetch } from 'undici'
 
 import {
   assertPublicUrl,
@@ -128,6 +130,158 @@ export async function readBodyBytesWithCap(response, maxBytes) {
   return Buffer.concat(chunks.map((c) => Buffer.from(c)))
 }
 
+const SAFE_IMAGE_MIMES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp'])
+
+function loopbackHost(hostname) {
+  const host = hostname.toLowerCase().replace(/^\[|\]$/g, '')
+  if (host === 'localhost' || host === '::1') return true
+  const match = host.match(/^(\d{1,3})(?:\.(\d{1,3})){3}$/)
+  return Boolean(match && Number(match[1]) === 127)
+}
+
+function abortRace(promise, signal) {
+  if (!signal) return promise
+  if (signal.aborted) return Promise.reject(signal.reason || new Error('local_fetch aborted'))
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason || new Error('local_fetch aborted'))
+    signal.addEventListener('abort', onAbort, { once: true })
+    promise.then(
+      (value) => { signal.removeEventListener('abort', onAbort); resolve(value) },
+      (error) => { signal.removeEventListener('abort', onAbort); reject(error) },
+    )
+  })
+}
+
+async function pinnedLoopbackFetch(url, options = {}) {
+  const parsed = assertLoopbackUrl(url)
+  const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '')
+  const addresses = host === 'localhost'
+    ? await abortRace(dns.promises.lookup(host, { all: true }), options.signal)
+    : [{ address: host, family: host.includes(':') ? 6 : 4 }]
+  if (!addresses.length || addresses.some((entry) => !loopbackHost(entry.address))) {
+    throw new Error(`Blocked non-loopback local_fetch resolution: ${host}`)
+  }
+  const pinned = addresses[0]
+  const dispatcher = new Agent({
+    connect: {
+      lookup: (_hostname, opts, cb) => opts?.all
+        ? cb(null, [{ address: pinned.address, family: pinned.family }])
+        : cb(null, pinned.address, pinned.family),
+    },
+  })
+  let response
+  try {
+    response = await undiciFetch(url, { ...options, dispatcher })
+  } catch (error) {
+    dispatcher.destroy().catch(() => {})
+    throw error
+  }
+  if (!response.body) {
+    dispatcher.destroy().catch(() => {})
+    return response
+  }
+  const reader = response.body.getReader()
+  let cleaned = false
+  const cleanup = () => {
+    if (cleaned) return
+    cleaned = true
+    dispatcher.destroy().catch(() => {})
+  }
+  const monitored = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read()
+        if (done) {
+          controller.close()
+          cleanup()
+        } else {
+          controller.enqueue(value)
+        }
+      } catch (error) {
+        controller.error(error)
+        cleanup()
+      }
+    },
+    cancel(reason) {
+      reader.cancel(reason).catch(() => {})
+      cleanup()
+    },
+  })
+  return new Response(monitored, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  })
+}
+
+export function assertLoopbackUrl(url) {
+  const parsed = new URL(url)
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error(`Blocked non-HTTP protocol: ${parsed.protocol}`)
+  }
+  if (parsed.username || parsed.password) throw new Error('Blocked loopback URL with userinfo credentials')
+  if (!loopbackHost(parsed.hostname)) throw new Error(`Blocked non-loopback local_fetch target: ${parsed.hostname}`)
+  return parsed
+}
+
+async function boundedManualFetch(url, { signal, fetchImpl, validateUrl, sameHost = false } = {}) {
+  const original = validateUrl(url)
+  let currentUrl = original.toString()
+  for (let hops = 0; ; hops++) {
+    const current = validateUrl(currentUrl)
+    if (sameHost && current.hostname.toLowerCase() !== original.hostname.toLowerCase()) {
+      throw new Error(`cross-host redirect blocked (redirected_to: ${currentUrl})`)
+    }
+    const response = await fetchImpl(currentUrl, {
+      signal,
+      headers: buildHeaders(),
+      redirect: 'manual',
+    })
+    if (!REDIRECT_STATUSES.has(response.status)) return response
+    try { await response.body?.cancel() } catch {}
+    if (hops >= MAX_REDIRECTS) throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`)
+    const location = response.headers.get('location')
+    if (!location) throw new Error(`Redirect ${response.status} without Location header`)
+    currentUrl = new URL(location, currentUrl).toString()
+  }
+}
+
+export async function fetchLoopbackText(url, { signal, fetchImpl = pinnedLoopbackFetch } = {}) {
+  const response = await boundedManualFetch(url, {
+    signal,
+    fetchImpl,
+    validateUrl: assertLoopbackUrl,
+  })
+  if (!response.ok) {
+    try { await response.body?.cancel() } catch {}
+    throw new Error(`HTTP ${response.status}`)
+  }
+  return readBodyWithCap(response, MAX_BODY_BYTES)
+}
+
+export async function fetchPublicImage(url, { signal, fetchImpl = pinnedFetch } = {}) {
+  const response = await boundedManualFetch(url, {
+    signal,
+    fetchImpl,
+    validateUrl: (value) => {
+      assertPublicUrl(value)
+      return new URL(value)
+    },
+    sameHost: true,
+  })
+  if (!response.ok) {
+    try { await response.body?.cancel() } catch {}
+    throw new Error(`HTTP ${response.status}`)
+  }
+  const mimeType = (response.headers.get('content-type') || '').split(';')[0].trim().toLowerCase()
+  if (!SAFE_IMAGE_MIMES.has(mimeType)) {
+    try { await response.body?.cancel() } catch {}
+    throw new Error(`Blocked unsupported image content-type: ${mimeType || '(missing)'}`)
+  }
+  const bytes = await readBodyBytesWithCap(response, MAX_BODY_BYTES)
+  return { mimeType, data: bytes.toString('base64'), bytes: bytes.byteLength }
+}
+
 const CDP_FORBIDDEN_RESPONSE_HEADERS = new Set([
   'content-length',
   'transfer-encoding',

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

@@ -2,6 +2,8 @@ import {
   TOOL_SYNC_EXECUTION_CONTRACT,
 } from '../shared/tool-execution-contract.mjs';
 
+const TOOL_DEFS_PLACEHOLDER = Symbol('web-fetch-schema')
+
 export const TOOL_DEFS = [
   {
     name: 'search',
@@ -54,4 +56,25 @@ export const TOOL_DEFS = [
     },
     annotations: { title: 'Mixdog Web Fetch', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
   },
+  {
+    name: 'local_fetch',
+    title: 'Mixdog Loopback Fetch',
+    public: false,
+    description: 'Runtime-only loopback HTTP(S) fetch target.',
+    inputSchema: TOOL_DEFS_PLACEHOLDER,
+    annotations: { title: 'Mixdog Loopback Fetch', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  },
+  {
+    name: 'image_fetch',
+    title: 'Mixdog Image Fetch',
+    public: false,
+    description: 'Runtime-only bounded public image fetch target.',
+    inputSchema: TOOL_DEFS_PLACEHOLDER,
+    annotations: { title: 'Mixdog Image Fetch', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  },
 ]
+
+const webFetchSchema = TOOL_DEFS.find((tool) => tool.name === 'web_fetch').inputSchema
+for (const tool of TOOL_DEFS) {
+  if (tool.inputSchema === TOOL_DEFS_PLACEHOLDER) tool.inputSchema = webFetchSchema
+}

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

@@ -331,6 +331,32 @@ export function shouldMirrorCompletionToPendingQueue({
   return shouldPersistModelVisibleToolCompletion(text, meta);
 }
 
+export async function dispatchSearchRuntimeTool(name, args, callerCtx = {}, {
+  getSearchModule,
+  getCurrentCwd,
+  getSession,
+  notifyFnForSession,
+  runNativeWebSearch,
+} = {}) {
+  const currentSession = typeof getSession === 'function' ? getSession() : null;
+  const callerCwd = callerCtx?.callerCwd || (typeof getCurrentCwd === 'function' ? getCurrentCwd() : process.cwd());
+  const callerSessionId = callerCtx?.callerSessionId || currentSession?.id || null;
+  const callerSignal = callerCtx?.signal || currentSession?.controller?.signal;
+  const searchMod = await getSearchModule();
+  if (!searchMod?.handleToolCall) throw new Error('search runtime is not available');
+  return await searchMod.handleToolCall(name, args || {}, {
+    callerCwd,
+    callerSessionId,
+    routingSessionId: callerSessionId,
+    clientHostPid: callerCtx?.clientHostPid || currentSession?.clientHostPid || process.pid,
+    notifyFn: notifyFnForSession(callerSessionId),
+    signal: callerSignal,
+    nativeSearch: name === 'search'
+      ? async (searchArgs) => runNativeWebSearch(searchArgs, { signal: callerSignal })
+      : undefined,
+  });
+}
+
 export async function createMixdogSessionRuntime({
   provider,
   model,
@@ -1049,13 +1075,15 @@ export async function createMixdogSessionRuntime({
   });
   bootProfile('channels:worker-ready', { ms: (performance.now() - channelsStartedAt).toFixed(1) });
   const toolsStartedAt = performance.now();
+  const searchRuntimeTools = (searchToolDefs?.TOOL_DEFS || [])
+    .filter((tool) => ['search', 'web_fetch', 'local_fetch', 'image_fetch'].includes(tool?.name));
   const standaloneTools = [
     TOOL_SEARCH_TOOL,
     ...(envFlag('MIXDOG_DISABLE_SKILLS') ? [] : [SKILL_TOOL]),
     CWD_TOOL,
     SESSION_MANAGE_TOOL,
     EXPLORE_TOOL,
-    ...(searchToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'search' || tool?.name === 'web_fetch'),
+    ...searchRuntimeTools.filter((tool) => tool?.public !== false),
     ...(memoryToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'recall' || tool?.name === 'memory'),
     ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => channels.isChannelTool(tool?.name)),
     ...(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS || []).filter((tool) => tool?.name === 'code_graph'),
@@ -1102,22 +1130,16 @@ export async function createMixdogSessionRuntime({
     if (replay.length) selectDeferredTools(session, replay, deferredSurfaceModeForLead(mode));
   }
   internalTools.setInternalToolsProvider({
-    tools: standaloneTools,
+    tools: [...standaloneTools, ...searchRuntimeTools.filter((tool) => tool?.public === false)],
     executor: async (name, args, callerCtx = {}) => {
       const callerCwd = callerCtx?.callerCwd || currentCwd;
-      if (name === 'search' || name === 'web_fetch') {
-        const callerSessionId = callerCtx?.callerSessionId || session?.id || null;
-        const searchMod = await getSearchModule();
-        if (!searchMod?.handleToolCall) throw new Error('search runtime is not available');
-        return await searchMod.handleToolCall(name, args || {}, {
-          callerCwd,
-          callerSessionId,
-          routingSessionId: callerSessionId,
-          clientHostPid: callerCtx?.clientHostPid || session?.clientHostPid || process.pid,
-          notifyFn: notifyFnForSession(callerSessionId),
-          nativeSearch: name === 'search'
-            ? async (searchArgs) => runNativeWebSearch(searchArgs, { signal: callerCtx?.signal || session?.controller?.signal })
-            : undefined,
+      if (name === 'search' || name === 'web_fetch' || name === 'local_fetch' || name === 'image_fetch') {
+        return dispatchSearchRuntimeTool(name, args, callerCtx, {
+          getSearchModule,
+          getCurrentCwd: () => currentCwd,
+          getSession: () => session,
+          notifyFnForSession,
+          runNativeWebSearch,
         });
       }
       if (name === 'recall' || name === 'memory' || name === 'search_memories') {

package/src/standalone/hook-bus/handlers.mjs

@@ -498,6 +498,7 @@ export function parseHandlerOutput(run, eventName) {
     reason: null,
     permissionDecision: null,
     updatedInput: null,
+    updatedToolName: null,
     updatedToolOutput: null,
     additionalContext: null,
     systemMessage: null,
@@ -545,6 +546,9 @@ export function parseHandlerOutput(run, eventName) {
         out.updatedInput = hso.updatedInput;
       }
       if (hso.updatedToolOutput != null) out.updatedToolOutput = hso.updatedToolOutput;
+      if (typeof hso.updatedToolName === 'string' && hso.updatedToolName.trim()) {
+        out.updatedToolName = hso.updatedToolName.trim();
+      }
       if (hso.permissionDecision) out.permissionDecision = String(hso.permissionDecision).toLowerCase();
       if (hso.permissionDecisionReason) out.reason = out.reason || limitText(hso.permissionDecisionReason);
       if (eventName === 'PermissionRequest' && hso.decision && typeof hso.decision === 'object') {

package/src/standalone/hook-bus/rules.mjs

@@ -35,7 +35,13 @@ export function decisionFromRule(rule, input) {
     const nextArgs = rule.args && typeof rule.args === 'object'
       ? rule.args
       : { ...(input.args || {}), ...(rule.patch || {}) };
-    return { action: 'modify', args: nextArgs, reason: rule.reason || rule.message || `modified by hook rule for ${input.name}` };
+    const nextName = rule.updatedToolName ?? rule.replaceTool ?? rule.targetTool;
+    return {
+      action: 'modify',
+      args: nextArgs,
+      ...(typeof nextName === 'string' && nextName.trim() ? { name: nextName.trim() } : {}),
+      reason: rule.reason || rule.message || `modified by hook rule for ${input.name}`,
+    };
   }
   if (action === 'ask') {
     return { action: 'ask', reason: rule.reason || rule.message || `approval requested by hook rule for ${input.name}` };

package/src/standalone/hook-bus.mjs

@@ -268,6 +268,7 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
       blocked: false,
       reason: null,
       updatedInput: null,
+      updatedToolName: null,
       updatedToolOutput: null,
       additionalContext: [],
       systemMessage: null,
@@ -304,6 +305,7 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
       if (parsed.additionalContext) agg.additionalContext.push(parsed.additionalContext);
       if (parsed.systemMessage && !agg.systemMessage) agg.systemMessage = parsed.systemMessage;
       if (parsed.updatedInput && !agg.updatedInput) agg.updatedInput = parsed.updatedInput;
+      if (parsed.updatedToolName && !agg.updatedToolName) agg.updatedToolName = parsed.updatedToolName;
       if (parsed.updatedToolOutput != null && agg.updatedToolOutput == null) agg.updatedToolOutput = parsed.updatedToolOutput;
       if (parsed.askReason && !agg.ask && !agg.blocked) {
         agg.ask = true;
@@ -452,9 +454,14 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
           emit('tool:deny', { sessionId: input.sessionId || input.session_id || null, name: input.name || input.tool_name || 'tool', reason: agg.reason });
           return { action: 'deny', reason: agg.reason };
         }
-        if (agg.updatedInput) {
+        if (agg.updatedInput || agg.updatedToolName) {
           emit('tool:modify', { sessionId: input.sessionId || input.session_id || null, name: input.name || input.tool_name || 'tool', reason: agg.reason });
-          return { action: 'modify', args: agg.updatedInput, reason: agg.reason };
+          return {
+            action: 'modify',
+            ...(agg.updatedInput ? { args: agg.updatedInput } : {}),
+            ...(agg.updatedToolName ? { name: agg.updatedToolName } : {}),
+            reason: agg.reason,
+          };
         }
         if (agg.ask) {
           emit('tool:ask', { sessionId: input.sessionId || input.session_id || null, name: input.name || input.tool_name || 'tool', reason: agg.askReason });
@@ -504,6 +511,7 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
         additionalContext: agg.additionalContext.length ? agg.additionalContext : undefined,
         systemMessage: agg.systemMessage || undefined,
         updatedInput: agg.updatedInput || undefined,
+        updatedToolName: agg.updatedToolName || undefined,
         handlersRun: agg.handlersRun || undefined,
       };
       if (agg.updatedToolOutput != null) out.updatedToolOutput = agg.updatedToolOutput;

package/src/tui/App.jsx

@@ -77,6 +77,7 @@ import {
   slashCommandForName,
   slashArgumentHint,
 } from './app/slash-commands.mjs';
+import { isCompletedTranscriptTailAppendedThisCommit, isLiveSpinnerMetaVisible } from './app/live-spinner-visibility.mjs';
 import {
   parseHookRuleInput,
   parseMcpServerInput,
@@ -2564,7 +2565,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     ? promptHintTone
     : (latestToast?.tone || progressHint?.tone || 'info');
   const latestTranscriptItem = state.items[state.items.length - 1] || null;
-  const latestDoneAtTail = latestTranscriptItem?.kind === 'turndone' || latestTranscriptItem?.kind === 'statusdone';
   // Bottom meta band ownership is LIVE-SPINNER ONLY. A finished turn's done row
   // (turndone/statusdone) is a normal transcript item and flows into scrollback
   // like anything else, so the area directly above the prompt is CLEAR when the
@@ -2621,13 +2621,17 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   // While the slash palette is open it owns the area above the prompt, so the
   // live spinner/meta row is suppressed entirely — no reservation and no render.
   // Normalize the spinner → TurnDone handoff by making them occupy the SAME
-  // two-row slot. Engine appends turndone/statusdone before clearing spinner, so
-  // a transient frame can otherwise contain BOTH: transcript grows by two rows
-  // while the bottom spinner still reserves two rows, making the viewport visibly
-  // jump. As soon as the done row is the transcript tail, drop the spinner slot;
-  // the new done row replaces that height in the same frame, with no ms timer.
-  const promptMetaVisible = !inputBoxHidden && !slashPaletteOpen && !!liveSpinner
-    && (liveSpinnerIsCommand || !latestDoneAtTail);
+  // two-row slot. Completion appends turndone and clears spinner in one commit,
+  // so a completed row replaces the spinner slot with no transient jump. A
+  // statusdone can be emitted mid-turn (for example after compaction), so it
+  // must not suppress the still-active spinner.
+  const promptMetaVisible = isLiveSpinnerMetaVisible({
+    inputBoxHidden,
+    slashPaletteOpen,
+    liveSpinner,
+    liveSpinnerIsCommand,
+    latestTranscriptItem,
+  });
   const promptMetaRows = promptMetaVisible ? 2 : 0;
   // Toast/error text without a live spinner uses the existing transcript guard
   // row directly above the prompt. Do NOT reserve another row here: that made a
@@ -2718,7 +2722,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     // transcript bounce. Exempt exactly the meta-collapse rows from the ink mask
     // when the done row is the transcript tail. Every other prompt-row-only
     // shrink (typing newline removal, queued-row churn) AND the reclaimed/no-op
-    // path (engine.mjs skips turndone, so latestDoneAtTail stays false and no
+    // path (engine.mjs skips turndone, so the completed-tail check stays false and no
     // row replaces the height) keep the mask so they still reclaim smoothly.
     const prevMetaRows = Number(String(panelTransition.signature).split('|')[PANEL_LAYOUT_SIG.PROMPT_META]) || 0;
     const nextMetaRows = Number(String(panelLayoutSignature).split('|')[PANEL_LAYOUT_SIG.PROMPT_META]) || 0;
@@ -2727,8 +2731,10 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     // tail and then clear without appending statusdone (e.g. /recall — see
     // engine.mjs), collapsing the meta band with NO same-commit backfill; masking
     // must stay on for that path or the vacated rows overpaint the stale row.
-    const doneTailAppendedThisCommit = latestDoneAtTail
-      && (latestTranscriptItem?.id ?? null) !== panelTransition.tailId;
+    const doneTailAppendedThisCommit = isCompletedTranscriptTailAppendedThisCommit(
+      latestTranscriptItem,
+      panelTransition.tailId,
+    );
     const spinnerMetaCollapseRows = doneTailAppendedThisCommit
       ? Math.max(0, prevMetaRows - nextMetaRows)
       : 0;

package/src/tui/app/live-spinner-visibility.mjs

@@ -0,0 +1,20 @@
+export function isCompletedTranscriptTail(latestTranscriptItem) {
+  return latestTranscriptItem?.kind === 'turndone'
+    || latestTranscriptItem?.kind === 'statusdone';
+}
+
+export function isCompletedTranscriptTailAppendedThisCommit(latestTranscriptItem, previousTailId) {
+  return isCompletedTranscriptTail(latestTranscriptItem)
+    && (latestTranscriptItem?.id ?? null) !== previousTailId;
+}
+
+export function isLiveSpinnerMetaVisible({
+  inputBoxHidden,
+  slashPaletteOpen,
+  liveSpinner,
+  liveSpinnerIsCommand,
+  latestTranscriptItem,
+}) {
+  return !inputBoxHidden && !slashPaletteOpen && !!liveSpinner
+    && (liveSpinnerIsCommand || latestTranscriptItem?.kind !== 'turndone');
+}

package/src/tui/dist/index.mjs

@@ -8083,6 +8083,23 @@ function slashArgumentHint(value) {
   return command?.params ? `${command.usage} ${command.params}` : "";
 }
 
+// src/tui/app/live-spinner-visibility.mjs
+function isCompletedTranscriptTail(latestTranscriptItem) {
+  return latestTranscriptItem?.kind === "turndone" || latestTranscriptItem?.kind === "statusdone";
+}
+function isCompletedTranscriptTailAppendedThisCommit(latestTranscriptItem, previousTailId) {
+  return isCompletedTranscriptTail(latestTranscriptItem) && (latestTranscriptItem?.id ?? null) !== previousTailId;
+}
+function isLiveSpinnerMetaVisible({
+  inputBoxHidden,
+  slashPaletteOpen,
+  liveSpinner,
+  liveSpinnerIsCommand,
+  latestTranscriptItem
+}) {
+  return !inputBoxHidden && !slashPaletteOpen && !!liveSpinner && (liveSpinnerIsCommand || latestTranscriptItem?.kind !== "turndone");
+}
+
 // src/tui/app/input-parsers.mjs
 function parseHookRuleInput(text) {
   const parts = String(text || "").split("|").map((part) => part.trim());
@@ -21453,7 +21470,6 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
   const inputHint = promptHint || toastHint || (progressHint?.text || "");
   const inputHintTone = promptHint ? promptHintTone : latestToast?.tone || progressHint?.tone || "info";
   const latestTranscriptItem = state.items[state.items.length - 1] || null;
-  const latestDoneAtTail = latestTranscriptItem?.kind === "turndone" || latestTranscriptItem?.kind === "statusdone";
   const latestDoneItem = null;
   const SCROLL_HINT_ROWS = 0;
   const LIVE_STATUS_ROWS = 0;
@@ -21473,7 +21489,13 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
   const TEXT_ENTRY_ROWS = PANEL_CHROME_ROWS + textEntryContentRows + textEntryDetailRows;
   const OPTION_PANEL_EXTRA_ROWS = expandedOptionPanel ? 3 : 0;
   const queuedVisible = !hasFloatingPanel && !inputBoxHidden && state.queued?.length > 0;
-  const promptMetaVisible = !inputBoxHidden && !slashPaletteOpen && !!liveSpinner && (liveSpinnerIsCommand || !latestDoneAtTail);
+  const promptMetaVisible = isLiveSpinnerMetaVisible({
+    inputBoxHidden,
+    slashPaletteOpen,
+    liveSpinner,
+    liveSpinnerIsCommand,
+    latestTranscriptItem
+  });
   const promptMetaRows = promptMetaVisible ? 2 : 0;
   const overlayHintRequested = !inputBoxHidden && !hasFloatingPanel && !liveSpinner && !!inputHint && !queuedVisible;
   const overlayHintRows = 0;
@@ -21516,7 +21538,10 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
     const promptRowsOnlyChange = panelShrinkRows > 0 && panelKindSignature(panelTransition.signature) === panelKindSignature(panelLayoutSignature);
     const prevMetaRows = Number(String(panelTransition.signature).split("|")[PANEL_LAYOUT_SIG.PROMPT_META]) || 0;
     const nextMetaRows = Number(String(panelLayoutSignature).split("|")[PANEL_LAYOUT_SIG.PROMPT_META]) || 0;
-    const doneTailAppendedThisCommit = latestDoneAtTail && (latestTranscriptItem?.id ?? null) !== panelTransition.tailId;
+    const doneTailAppendedThisCommit = isCompletedTranscriptTailAppendedThisCommit(
+      latestTranscriptItem,
+      panelTransition.tailId
+    );
     const spinnerMetaCollapseRows = doneTailAppendedThisCommit ? Math.max(0, prevMetaRows - nextMetaRows) : 0;
     const prevQueuedSigRows = Number(String(panelTransition.signature).split("|")[PANEL_LAYOUT_SIG.QUEUED]) || 0;
     const nextQueuedSigRows = Number(String(panelLayoutSignature).split("|")[PANEL_LAYOUT_SIG.QUEUED]) || 0;