mixdog 0.9.50 → 0.9.52

package/src/standalone/channel-daemon-transport.mjs

@@ -46,6 +46,7 @@ export function createChannelDaemonTransport({
   onClientsEmpty = null,
   getStatus = () => ({}),
   dispatchBind = null,
+  registrationReplayTtlMs = 60_000,
 } = {}) {
   if (typeof handleCall !== 'function') throw new Error('handleCall is required');
 
@@ -72,6 +73,11 @@ export function createChannelDaemonTransport({
   // retry never double-runs a non-idempotent tool (e.g. reply). Short TTL.
   const callCache = new Map();
   const CALL_CACHE_TTL_MS = 60_000;
+  // Reconnect register replay: a server may commit replacement just before its
+  // HTTP response is lost. The retry supplies this stable id and receives the
+  // already-created fresh token instead of creating an orphan replacement.
+  const registrationReplays = new Map(); // registrationId -> { token, leadPid, cwd, replaceToken, responseFinished }
+  const registrationReplayTtl = Math.max(1, Number(registrationReplayTtlMs) || 60_000);
   let server = null;
   let graceTimer = null;
   let sweepTimer = null;
@@ -103,8 +109,7 @@ export function createChannelDaemonTransport({
     const c = clients.get(token);
     if (!c) return;
     const wasPointer = pointerToken === token;
-    clients.delete(token);
-    try { c.sse?.end?.(); } catch {}
+    removeClientRecord(token);
     if (pointerToken === token) pointerToken = null;
     log(`client ${token} (lead=${c.leadPid}) removed: ${reason}`);
     // Pointer client death → hand the seat to a survivor (last-wins among the
@@ -115,6 +120,62 @@ export function createChannelDaemonTransport({
     maybeArmGrace('client removed');
   }
 
+  function removeRegistrationReplay(registrationId, replay = registrationReplays.get(registrationId)) {
+    if (!replay || registrationReplays.get(registrationId) !== replay) return;
+    registrationReplays.delete(registrationId);
+    try { clearTimeout(replay.timer); } catch {}
+  }
+
+  // Every removal path uses this primitive, including replacement's deliberate
+  // no-failover retirement, so replay records/timers never target absent tokens.
+  function removeClientRecord(token) {
+    const c = clients.get(token);
+    if (!c) return null;
+    clients.delete(token);
+    for (const [registrationId, replay] of registrationReplays) {
+      if (replay.token === token) removeRegistrationReplay(registrationId, replay);
+    }
+    try { c.sse?.end?.(); } catch {}
+    return c;
+  }
+
+  function clearRegistrationReplays() {
+    for (const [registrationId, replay] of registrationReplays) removeRegistrationReplay(registrationId, replay);
+  }
+
+  function armRegistrationReplay(replayId, replay) {
+    try { clearTimeout(replay.timer); } catch {}
+    replay.timer = setTimeout(() => {
+      if (registrationReplays.get(replayId) !== replay) return;
+      // A successfully flushed register response creates a valid client even
+      // if its SSE/call is delayed. TTL only bounds cancellation metadata.
+      removeRegistrationReplay(replayId, replay);
+      if (!replay.responseFinished && clients.has(replay.token)) {
+        dropClient(replay.token, 'unflushed registration replay expired');
+      }
+    }, registrationReplayTtl);
+    replay.timer.unref?.();
+  }
+
+  function markRegistrationResponseFinished(registrationId, token) {
+    const replay = registrationId ? registrationReplays.get(registrationId) : null;
+    if (replay && replay.token === token) replay.responseFinished = true;
+  }
+
+  // A response-loss close knows only its retired token + stable registration id.
+  // Bind cancellation to every logical-client field before retiring the fresh
+  // token; malformed/mismatched cancellation can never affect another client.
+  function cancelReplacementRegistration({ token, registrationId, replaceToken, leadPid, cwd }) {
+    const replayId = registrationId ? String(registrationId).slice(0, 200) : null;
+    const replay = replayId ? registrationReplays.get(replayId) : null;
+    if (!replay) return 'missing';
+    const retiredToken = token ? String(token) : null;
+    if (retiredToken !== replay.replaceToken || String(replaceToken || '') !== replay.replaceToken ||
+        parsePid(leadPid) !== replay.leadPid || (cwd || null) !== replay.cwd) return 'forbidden';
+    dropClient(replay.token, 'replacement deregister');
+    return 'cancelled';
+  }
+
   // Pointer failover on owner death. Move the pointer to the most-recently-seen
   // LIVE client (reason 'failover'), deliver the sticky 'acquired' badge to it
   // (pending-buffered if it has no SSE yet), and re-dispatch ITS stored bind
@@ -304,8 +365,25 @@ export function createChannelDaemonTransport({
     }
   }
 
-  function registerClient({ leadPid, cwd, reattach = false }) {
+  function registerClient({ leadPid, cwd, reattach = false, replaceToken = null, registrationId = null }) {
     const pid = parsePid(leadPid) ?? 0;
+    const replacementToken = replaceToken ? String(replaceToken) : null;
+    const replayId = reattach && registrationId ? String(registrationId).slice(0, 200) : null;
+    const existingReplay = replayId ? registrationReplays.get(replayId) : null;
+    if (existingReplay) {
+      if (existingReplay.leadPid === pid && existingReplay.cwd === (cwd || null) &&
+          existingReplay.replaceToken === replacementToken && clients.has(existingReplay.token)) {
+        armRegistrationReplay(replayId, existingReplay);
+        log(`client reconnect replay token=${existingReplay.token} lead=${pid}`);
+        return existingReplay.token;
+      }
+      if (clients.has(existingReplay.token)) {
+        const err = new Error('registration replay identity mismatch');
+        err.statusCode = 409;
+        throw err;
+      }
+      removeRegistrationReplay(replayId, existingReplay);
+    }
     const token = randomUUID();
     clients.set(token, {
       token,
@@ -320,6 +398,34 @@ export function createChannelDaemonTransport({
     cancelGrace();
     startSweep();
     log(`client registered token=${token} lead=${pid} cwd=${cwd || '-'}`);
+    const rememberReplacement = (freshToken) => {
+      if (!replayId) return freshToken;
+      const replay = {
+        token: freshToken, leadPid: pid, cwd: cwd || null, replaceToken: replacementToken,
+        responseFinished: false, timer: null,
+      };
+      registrationReplays.set(replayId, replay);
+      armRegistrationReplay(replayId, replay);
+      return freshToken;
+    };
+    // A reconnect names the exact token it replaces. Retire it even when it is
+    // not the pointer: retaining a non-owner old token would let it later call,
+    // steal ownership, or accumulate a buffered frame after the fresh client
+    // has gone away. Token replacement never crosses leadPid boundaries.
+    const replaced = reattach && replacementToken ? clients.get(replacementToken) : null;
+    if (replaced && replaced.leadPid === pid) {
+      const fresh = clients.get(token);
+      const replacedWasPointer = pointerToken === replaced.token;
+      // Token-scoped state belongs to the logical client, not only the owner.
+      // A non-owner can hold a buffered superseded frame or stored bind intent.
+      if (replaced.pending?.length) fresh.pending.push(...replaced.pending.splice(0));
+      if (replaced.lastBind) fresh.lastBind = replaced.lastBind;
+      if (replacedWasPointer) pointerToken = token;
+      removeClientRecord(replaced.token);
+      log(`client reconnect replaced token=${replaced.token} -> ${token} lead=${pid}`);
+      if (replacedWasPointer) redispatchPointerBind(fresh, 'reconnect');
+      return rememberReplacement(token);
+    }
     // Pointer-follows-pid: if the current pointer client shares this leadPid AND
     // has no live SSE, it is the SAME terminal re-registering after its stream
     // dropped. That old entry is a dead-stream blackhole — pid-prune never reaps
@@ -335,15 +441,14 @@ export function createChannelDaemonTransport({
         const fresh = clients.get(token);
         if (old.pending?.length) fresh.pending.push(...old.pending.splice(0));
         if (old.lastBind) fresh.lastBind = old.lastBind;
-        clients.delete(pointerToken);
-        try { old.sse?.end?.(); } catch {}
+        removeClientRecord(pointerToken);
         pointerToken = token;
         log(`pointer follows reconnect -> token=${token} lead=${pid} (old entry dropped)`);
         // The fresh token inherited the old entry's bind intent but never went
         // through movePointer — re-dispatch it so the forwarder rebinds to this
         // reconnected terminal's transcript (guarded/no-op when no lastBind).
         redispatchPointerBind(fresh, 'reconnect');
-        return token;
+        return rememberReplacement(token);
       }
     }
     if (reattach) {
@@ -356,12 +461,17 @@ export function createChannelDaemonTransport({
       // ownership seat, and the displaced owner is told it lost (superseded).
       movePointer(token, 'register');
     }
-    return token;
+    return rememberReplacement(token);
   }
 
   function attachSse(token, res) {
     const c = clients.get(token);
     if (!c) return false;
+    // A live stream proves the client learned its fresh token, so response-loss
+    // cancellation is no longer needed for this logical registration.
+    for (const [registrationId, replay] of registrationReplays) {
+      if (replay.token === token) removeRegistrationReplay(registrationId, replay);
+    }
     res.writeHead(200, {
       'Content-Type': 'text/event-stream; charset=utf-8',
       'Cache-Control': 'no-cache, no-transform',
@@ -417,12 +527,23 @@ export function createChannelDaemonTransport({
 
       if (req.method === 'POST' && pathName === '/client/register') {
         const body = await readBody(req);
-        const clientToken = registerClient({ leadPid: body.leadPid, cwd: body.cwd, reattach: body.reattach === true });
+        const clientToken = registerClient({
+          leadPid: body.leadPid, cwd: body.cwd, reattach: body.reattach === true,
+          replaceToken: body.replaceToken, registrationId: body.registrationId,
+        });
+        const replayId = body.reattach === true && body.registrationId ? String(body.registrationId).slice(0, 200) : null;
+        res.once('finish', () => markRegistrationResponseFinished(replayId, clientToken));
         sendJson(res, { token: clientToken, pid: process.pid });
         return;
       }
       if (req.method === 'POST' && pathName === '/client/deregister') {
         const body = await readBody(req);
+        if (body.registrationId) {
+          const cancelled = cancelReplacementRegistration(body);
+          if (cancelled === 'forbidden') { sendError(res, 'forbidden replacement deregister', 403); return; }
+          sendJson(res, { ok: true, cancelled: cancelled === 'cancelled' });
+          return;
+        }
         if (body.token) dropClient(body.token, 'deregister');
         sendJson(res, { ok: true });
         return;
@@ -436,7 +557,11 @@ export function createChannelDaemonTransport({
         const body = await readBody(req);
         const clientToken = body.token || null;
         const c = clientToken ? clients.get(clientToken) : null;
-        if (c) c.lastSeen = nowMs();
+        if (!c) { sendError(res, 'unknown client token', 404); return; }
+        for (const [registrationId, replay] of registrationReplays) {
+          if (replay.token === clientToken) removeRegistrationReplay(registrationId, replay);
+        }
+        c.lastSeen = nowMs();
         const name = String(body.name || '');
         // Bind-intent calls re-point routing at the caller BEFORE dispatch, so a
         // notify emitted synchronously during the call already targets it.
@@ -526,6 +651,7 @@ export function createChannelDaemonTransport({
     cancelGrace();
     if (sweepTimer) { try { clearInterval(sweepTimer); } catch {} sweepTimer = null; }
     for (const [token] of clients) dropClient(token, 'transport stop');
+    clearRegistrationReplays();
     if (discoveryPath) { try { rmSync(discoveryPath, { force: true }); } catch {} }
     if (server) {
       await new Promise((resolve) => { try { server.close(() => resolve()); } catch { resolve(); } });
@@ -540,6 +666,7 @@ export function createChannelDaemonTransport({
     get port() { return boundPort; },
     get token() { return serverToken; },
     _clientsForTest: clients,
+    _registrationReplaysForTest: registrationReplays,
     _resolveTargetForTest: resolveTarget,
   };
 }

package/src/standalone/channel-worker.mjs

@@ -108,6 +108,7 @@ export function createStandaloneChannelWorker({
   // as an unreachable legacy path while useProcessWorker is true.
   let daemonClient = null;
   let attachPromise = null;
+  let attachGeneration = 0;
   let daemonPid = null;
   let nextCallId = 1;
   // Per-proxy unique prefix so a callId can never collide across TUIs sharing
@@ -408,6 +409,7 @@ export function createStandaloneChannelWorker({
     // CAS: only tear down when the live handle is still the one that failed, so
     // a concurrent call that already re-attached a fresh daemon isn't clobbered.
     if (expected && daemonClient !== expected) return;
+    attachGeneration++;
     const client = daemonClient;
     daemonClient = null;
     attachPromise = null;
@@ -476,31 +478,81 @@ export function createStandaloneChannelWorker({
       t.unref?.();
     });
   }
-  async function doAttach(discovery) {
-    const client = await attachToDaemon({
+  function attachCancelledError() {
+    const err = new Error('channels daemon attach superseded');
+    err.daemonAttachCancelled = true;
+    return err;
+  }
+  function discoveryMatchesHealth(discovery, health) {
+    return Number(health?.pid) === Number(discovery?.pid);
+  }
+  async function doAttach(discovery, generation) {
+    let client = null;
+    let fatalDuringAttach = false;
+    client = await attachToDaemon({
       discovery,
       leadPid: daemonLeadPid,
       cwd,
       onNotify: (msg) => { try { onNotify?.(msg); } catch {} },
-      // SSE gave up (daemon dead/restarted): drop this attach and proactively
-      // re-attach so notifies resume without waiting for the next call().
-      onFatal: () => { invalidateDaemonClient('sse fatal', client); void ensureDaemonAttached().catch(() => {}); },
+      // A stale/dead SSE endpoint drops this attach immediately. Do not revive
+      // it after this worker has explicitly stopped; otherwise proactively
+      // re-read discovery so notifies resume without waiting for the next call.
+      onFatal: () => {
+        fatalDuringAttach = true;
+        invalidateDaemonClient('sse fatal', client);
+        if (!stopRequested) void ensureDaemonAttached().catch(() => {});
+      },
       log: (line) => logLine(logPath, line),
     });
+    if (stopRequested || generation !== attachGeneration || fatalDuringAttach) {
+      await client.close('attach superseded');
+      if (fatalDuringAttach && !stopRequested && generation === attachGeneration) {
+        const err = attachCancelledError();
+        err.daemonDiscoveryStale = true;
+        throw err;
+      }
+      throw attachCancelledError();
+    }
     daemonClient = client;
     daemonPid = discovery.pid;
     return client;
   }
   async function ensureDaemonAttached() {
+    if (stopRequested) throw attachCancelledError();
     if (daemonClient) return daemonClient;
     if (attachPromise) return attachPromise;
-    attachPromise = (async () => {
+    const generation = attachGeneration;
+    const promise = (async () => {
       const deadline = Date.now() + 30_000;
+      const MAX_AUTH_REJECTIONS = 5;
+      let authRejections = 0;
+      const retryStaleDiscovery = async (err) => {
+        if (!err?.daemonAuthRejected) {
+          await daemonDelay(200);
+          return;
+        }
+        authRejections++;
+        if (authRejections >= MAX_AUTH_REJECTIONS || Date.now() >= deadline) {
+          throw new Error(`channels daemon register rejected discovery auth ${authRejections} times`);
+        }
+        await daemonDelay(Math.min(200 * (2 ** (authRejections - 1)), 2000));
+      };
       for (let attempt = 0; ; attempt++) {
+        if (stopRequested || generation !== attachGeneration) throw attachCancelledError();
         let discovery = readDaemonDiscovery(discoveryPath);
         if (discovery) {
           const health = await probeDaemonHealth({ port: discovery.port, token: discovery.token, timeoutMs: attempt === 0 ? 800 : 2000 });
-          if (health) return await doAttach(discovery);
+          if (stopRequested || generation !== attachGeneration) throw attachCancelledError();
+          if (discoveryMatchesHealth(discovery, health)) {
+            try {
+              return await doAttach(discovery, generation);
+            } catch (err) {
+              if (!err?.daemonDiscoveryStale) throw err;
+              logLine(logPath, `daemon attach discovery stale: ${err.message}; re-reading`);
+              await retryStaleDiscovery(err);
+              continue;
+            }
+          }
           discovery = null; // published but unhealthy → respawn
         }
         // No live daemon (absent / dead pid / unhealthy): spawn a candidate. A
@@ -509,16 +561,27 @@ export function createStandaloneChannelWorker({
         const after = readDaemonDiscovery(discoveryPath);
         if (after) {
           const health = await probeDaemonHealth({ port: after.port, token: after.token, timeoutMs: 3000 });
-          if (health) return await doAttach(after);
+          if (stopRequested || generation !== attachGeneration) throw attachCancelledError();
+          if (discoveryMatchesHealth(after, health)) {
+            try {
+              return await doAttach(after, generation);
+            } catch (err) {
+              if (!err?.daemonDiscoveryStale) throw err;
+              logLine(logPath, `daemon attach discovery stale: ${err.message}; re-reading`);
+              await retryStaleDiscovery(err);
+              continue;
+            }
+          }
         }
         if (Date.now() > deadline) throw new Error('channels daemon did not become ready');
         await daemonDelay(200);
       }
     })();
+    attachPromise = promise;
     try {
-      return await attachPromise;
+      return await promise;
     } finally {
-      attachPromise = null;
+      if (attachPromise === promise) attachPromise = null;
     }
   }
   async function _startInProcess() {
@@ -676,12 +739,16 @@ export function createStandaloneChannelWorker({
     // Daemon path: detach this TUI's client only. The shared daemon reaps
     // itself via client-grace once the last TUI leaves; never kill it here.
     if (useProcessWorker) {
+      const inFlightAttach = attachPromise;
+      attachGeneration++;
       const client = daemonClient;
       daemonClient = null;
       attachPromise = null;
       daemonPid = null;
-      if (!client) return Promise.resolve(false);
-      return client.close(reason).then(() => true).catch(() => true);
+      return Promise.all([
+        client ? client.close(reason).then(() => true).catch(() => true) : Promise.resolve(false),
+        Promise.resolve(inFlightAttach).catch(() => null),
+      ]).then(([detached]) => detached);
     }
     if (!child) {
       return Promise.resolve(false);

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');
+}