mixdog 0.9.36 → 0.9.37

package/src/tui/engine/agent-job-feed.mjs

@@ -94,18 +94,27 @@ export function createAgentJobFeed({
     queueMicrotask(() => kickExecutionPendingResume(body));
   }
 
-  function updateAgentJobCard(itemId, text, isError = false) {
+  // Pure builder for the agent-job card patch. Split out so callers that are
+  // already patching the same card in the same tick (see tool-card-results
+  // non-aggregate path) can MERGE these fields into their single patchItem
+  // instead of issuing a second set() — collapsing the L1/L2 double-update
+  // jitter into one visible item update.
+  function buildAgentJobCardPatch(itemId, text, isError = false) {
     const parsed = parseAgentJob(text);
     const current = getState().items.find((it) => it.id === itemId);
     const rawDisplayText = agentJobResultText(text, parsed) || String(text ?? '').trim();
     const displayText = isError ? toolErrorDisplay(rawDisplayText, 'agent') : rawDisplayText;
-    patchItem(itemId, {
+    return {
       result: displayText,
       text: displayText,
       isError,
       errorCount: isError ? 1 : 0,
       ...(parsed ? { args: agentArgsWithResultMetadata(current?.args, parsed) } : {}),
-    });
+    };
+  }
+
+  function updateAgentJobCard(itemId, text, isError = false) {
+    patchItem(itemId, buildAgentJobCardPatch(itemId, text, isError));
   }
 
   function subscribeRuntimeNotifications() {
@@ -119,7 +128,7 @@ export function createAgentJobFeed({
       const delivery = resolveTuiRuntimeNotificationDelivery(event, text);
       if (delivery.action === 'ignore') return;
       if (delivery.action === 'notice') {
-        pushNotice?.(delivery.displayText, delivery.tone || 'info', { transcript: true });
+        pushNotice?.(delivery.displayText, delivery.tone || 'info', { transcript: delivery.transcript === true });
         return true;
       }
       if (delivery.action === 'status-only') {
@@ -135,7 +144,15 @@ export function createAgentJobFeed({
         if (parsed?.taskId) set(agentStatusState({ force: true }));
         const resumeBody = String(delivery.modelContent || '').trim();
         if (resumeBody) {
-          scheduleExecutionPendingResumeKick(resumeBody);
+          enqueue(resumeBody, {
+            mode: 'task-notification',
+            // Claude Code parity: live execution completions are queued as
+            // task notifications so the active loop can attach them after the
+            // next tool batch; no special pending-resume bypass.
+            priority: 'next',
+            key: notificationKey || undefined,
+            displayText: delivery.displayText || text,
+          });
         }
         return true;
       }
@@ -147,7 +164,9 @@ export function createAgentJobFeed({
       if (!modelContent && imagePaths.length === 0) return true;
       const enqueueOpts = {
         mode: 'task-notification',
-        priority: 'next',
+        // Claude Code parity: task/schedule notifications are lower-priority
+        // queue items and drain between turns, behind direct user input.
+        priority: 'later',
         key: notificationKey || undefined,
         displayText: delivery.displayText || text,
       };
@@ -184,6 +203,7 @@ export function createAgentJobFeed({
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
     updateAgentJobCard,
+    buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
   };
 }

package/src/tui/engine/notification-plan.mjs

@@ -61,14 +61,14 @@ export function resolveTuiRuntimeNotificationDelivery(event, text) {
   if (!trimmed) return { action: 'ignore' };
   const parsed = parseAgentJob(trimmed);
   const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  // UI-only notices (e.g. boot auto-update outcome): render as a transcript
-  // notice, never enqueue anything model-visible.
+  // UI-only notices (e.g. boot auto-update outcome): render as a transient
+  // notice, never enqueue anything model-visible or transcript-persistent.
   if (meta.kind === 'update-notice') {
     // Wording lives here (the notice surface), not in the emitting runtime:
     // the emitter only supplies meta.version; the sentence is composed here.
     const ver = String(meta.version || '').trim();
     const displayText = ver ? `mixdog v${ver} ready — restart to apply.` : trimmed;
-    return { action: 'notice', displayText, tone: meta.tone === 'warn' ? 'warn' : 'info' };
+    return { action: 'notice', displayText, tone: meta.tone === 'warn' ? 'warn' : 'info', transcript: false };
   }
   if (!isExecutionNotification(event, trimmed, parsed)) {
     return { action: 'enqueue', displayText: trimmed, modelContent: trimmed };

package/src/tui/engine/render-timing.mjs

@@ -1,17 +1,113 @@
 /**
  * src/tui/engine/render-timing.mjs - render-throttle timing helper.
  *
- * Extracted from engine.mjs (no behavior change).
+ * Extracted from engine.mjs (no behavior change originally).
  *
- * Ink renders through a maxFps throttle (120fps in index.jsx, ≈8.3ms). A plain
+ * Ink renders through a maxFps throttle (60fps in index.jsx, ≈16.7ms). A plain
  * setImmediate only yields to the event loop; if Ink already painted within the
  * current throttle window, the next paint may still be queued and our following
- * transcript mutation can coalesce into the same visible frame. Wait just past
- * one render window when we intentionally split transcript commits for visual
- * stability (preamble frame → tool-card frame).
+ * transcript mutation can coalesce into the same visible frame. When we
+ * intentionally split transcript commits for visual stability (preamble frame →
+ * tool-card frame), we must wait for the split-off commit to actually paint.
+ *
+ * A fixed 12ms wait was below the 60fps frame budget, so the tool card could
+ * land in the same frame as the preamble and the bottom-pinned viewport jumped.
+ * Instead we wait for the next real Ink render frame: index.jsx routes its
+ * onRender hook through notifyRenderFrame(), which resolves any pending yields.
+ * The fixed timeout below is only a fallback ceiling for when no renderer ack is
+ * wired (or the renderer is idle) so a yield can never hang the turn.
  */
-export const RENDER_THROTTLE_FLUSH_MS = 12;
+export const RENDER_ACK_FALLBACK_MS = 32;
+export const RENDER_ACK_HANG_GUARD_MS = 250;
+export const RENDER_SETTLE_IDLE_MS = 64;
+
+// Back-compat alias: previously the fixed wait duration, now the fallback only.
+export const RENDER_THROTTLE_FLUSH_MS = RENDER_ACK_FALLBACK_MS;
+
+let pendingRenderAcks = [];
+let renderAckSeq = 0;
+
+/**
+ * Called by the Ink onRender hook once per painted frame. The sequence is
+ * allocated synchronously at onRender time, BEFORE the deferred post-write ack,
+ * so a yield that starts after onRender but before setImmediate delivery can
+ * identify and ignore that stale/previous-frame ack.
+ */
+export const scheduleRenderFrameAck = () => {
+  const seq = ++renderAckSeq;
+  setImmediate(() => notifyRenderFrame(seq));
+};
+
+export const notifyRenderFrame = (seq = ++renderAckSeq) => {
+  if (pendingRenderAcks.length === 0) return;
+  const acks = pendingRenderAcks;
+  pendingRenderAcks = [];
+  for (const ack of acks) ack(seq);
+};
 
-export const yieldToRenderer = () => new Promise((resolve) => {
-  setTimeout(resolve, RENDER_THROTTLE_FLUSH_MS);
+export const yieldToRenderer = ({ frames = 1 } = {}) => new Promise((resolve) => {
+  const minSeq = renderAckSeq;
+  let remainingFrames = Math.max(1, Math.floor(Number(frames) || 1));
+  let settled = false;
+  let sawRealFrame = false;
+  let timer = null;
+  const finish = () => {
+    if (settled) return;
+    settled = true;
+    if (timer) clearTimeout(timer);
+    const idx = pendingRenderAcks.indexOf(onFrame);
+    if (idx !== -1) pendingRenderAcks.splice(idx, 1);
+    resolve();
+  };
+  const onTimeout = () => {
+    if (settled) return;
+    // A render has already reached onRender and scheduled its deferred
+    // post-write ack, but the event loop may run expired timers before the
+    // check-phase setImmediate. Do NOT let the first-frame hang guard beat that
+    // queued real-frame ack; keep waiting for it so frames:2 cannot collapse to
+    // zero/one actual paints under a slow preamble render.
+    if (!sawRealFrame && renderAckSeq > minSeq) {
+      // Yield exactly one check phase: a legitimate queued notifyRenderFrame(seq)
+      // was scheduled before this timeout callback and should run first. If it is
+      // lost/skipped, this follow-up finishes the hang guard instead of
+      // re-arming forever.
+      setImmediate(() => {
+        if (!settled && !sawRealFrame) finish();
+      });
+      return;
+    }
+    finish();
+  };
+  const armWait = () => {
+    if (settled) return;
+    if (!pendingRenderAcks.includes(onFrame)) pendingRenderAcks.push(onFrame);
+    if (timer) clearTimeout(timer);
+    // Before the FIRST real frame, the timer is only a long hang guard for
+    // no-ack/no-render paths. After at least one frame painted, the timer becomes
+    // a short "settle idle" fallback: if no follow-up measurement/correction
+    // render arrives within roughly four 60fps frames, treat the preamble as
+    // stable instead of forcing a visible 250ms pause before the tool card.
+    timer = setTimeout(onTimeout, sawRealFrame ? RENDER_SETTLE_IDLE_MS : RENDER_ACK_HANG_GUARD_MS);
+  };
+  const onFrame = (seq = 0) => {
+    if (settled) return;
+    if (seq <= minSeq) {
+      if (!pendingRenderAcks.includes(onFrame)) pendingRenderAcks.push(onFrame);
+      return;
+    }
+    sawRealFrame = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    const idx = pendingRenderAcks.indexOf(onFrame);
+    if (idx !== -1) pendingRenderAcks.splice(idx, 1);
+    remainingFrames -= 1;
+    if (remainingFrames <= 0) finish();
+    else armWait();
+  };
+  // Count real render acks as frames. The pre-first-frame timeout is a hang
+  // guard, while the post-first-frame timeout is an idle-settle fallback so a
+  // missing second frame does not add a quarter-second tool-card delay.
+  armWait();
 });

package/src/tui/engine/session-api.mjs

@@ -9,13 +9,22 @@ import { buildDoctorReport } from '../app/doctor.mjs';
 import { recomputePromptHistory } from './prompt-history.mjs';
 import { buildMergedPromptHistory, loadPromptHistory } from '../prompt-history-store.mjs';
 
+// Upper bound on how long a manual Esc abort may leave the store busy while the
+// in-flight runtime.ask() unwinds. runtime.abort() normally rejects the pending
+// ask within a tick; this is the belt-and-suspenders window before the bounded
+// recovery timer hard-releases busy so Esc can never wedge input forever.
+const MANUAL_ABORT_RECOVERY_MS = (() => {
+  const v = Number(process.env.MIXDOG_MANUAL_ABORT_RECOVERY_MS);
+  return Number.isFinite(v) && v > 0 ? v : 4000;
+})();
+
 export function createEngineApi(bag) {
   return { ...createEngineApiA(bag), ...createEngineApiB(bag) };
 }
 
 export function createEngineApiA(bag) {
   const {
-    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext,
+    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick,
   } = bag;
   return {
     getState: () => getState(),
@@ -44,12 +53,23 @@ export function createEngineApiA(bag) {
         enqueue(text, queueOptions);
         return true;
       }
-      if (getState().commandBusy) return false;
+      // Any in-flight session command (clear/setModel/newSession/resume/...)
+      // holds commandBusy. Previously the prompt was dropped here and only the
+      // prompt-history side effect survived. Queue it instead: drain bails while
+      // commandBusy, and the central release hook re-kicks drain once the
+      // command settles, so the prompt runs afterwards rather than vanishing.
+      if (getState().commandBusy) {
+        enqueue(text, queueOptions);
+        return true;
+      }
       if (getState().busy) {
         enqueue(text, queueOptions);
         return true;
       }
-      void autoClearBeforeSubmit().then(() => enqueue(text, queueOptions));
+      // If autoClearBeforeSubmit rejects (e.g. compaction timeout throws), the
+      // prompt must still be queued — swallow the rejection so enqueue always
+      // runs and the submit is never silently lost.
+      void autoClearBeforeSubmit().catch(() => {}).then(() => enqueue(text, queueOptions));
       return true;
     },
     restoreQueued,
@@ -573,6 +593,41 @@ export function createEngineApiA(bag) {
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
       }
+      // ── Bounded manual-abort recovery ───────────────────────────────────
+      // runtime.abort() above normally rejects the in-flight runtime.ask() so
+      // the turn's own finally clears busy within a tick. If that unwind is
+      // starved — e.g. a provider abort that never settles after a post-tool
+      // fetch stall — busy would stay true until the far-larger turn watchdog
+      // trips, wedging the TUI with dead input. Arm a short grace timer that
+      // hard-releases busy exactly like the watchdog force-release, but ONLY
+      // when this same turn is still the active owner (epoch unchanged) AND
+      // still busy — so a normal cancellation that settles in time is never
+      // masked and a newer turn's store is never corrupted.
+      const abortEpoch = flags.leadTurnEpoch;
+      const recoveryMs = Number(flags.manualAbortRecoveryMs) > 0
+        ? Number(flags.manualAbortRecoveryMs)
+        : MANUAL_ABORT_RECOVERY_MS;
+      const recoveryTimer = setTimeout(() => {
+        if (flags.disposed) return;
+        if (!getState().busy) return;                    // normal abort settled
+        if (flags.leadTurnEpoch !== abortEpoch) return;  // a newer turn owns the store
+        // Bump the epoch FIRST so the still-stuck turn's eventual finally becomes
+        // a no-op for shared getState() writes and cannot corrupt the handoff.
+        flags.leadTurnEpoch = (Number(flags.leadTurnEpoch) || 0) + 1;
+        set({ busy: false, spinner: null, thinking: null, lastTurn: null });
+        flags.activePromptRestore = null;
+        // Abandon the drain loop that is still awaiting the stuck turn before
+        // releasing the drain lock. Its eventual finally observes the stale
+        // epoch and cannot clear a newer drain's ownership or continue work.
+        flags.drainEpoch = (Number(flags.drainEpoch) || 0) + 1;
+        if (flags.draining) flags.draining = false;
+        pushNotice('Interrupt did not settle — input restored.', 'warn', { transcript: true });
+        if (pending.length > 0 && typeof drain === 'function') void drain();
+        // busy→false here bypasses the normal turn-end + drain-finally flushes,
+        // so re-arm any deferred completion kick explicitly (idempotent).
+        if (typeof flushDeferredExecutionPendingResumeKick === 'function') flushDeferredExecutionPendingResumeKick();
+      }, recoveryMs);
+      recoveryTimer.unref?.();
       return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages, pastedTexts: restorePastedTexts, discardPastedTexts };
     },
   };

package/src/tui/engine/session-flow.mjs

@@ -60,9 +60,6 @@ export function createSessionFlow(bag) {
 
   function removeQueuedEntries(entries) {
     const ids = new Set(entries.map((entry) => entry.id));
-    const keys = entries.map((entry) => entry.key).filter(Boolean);
-    for (const key of keys) pendingNotificationKeys.delete(key);
-    for (const key of keys) displayedExecutionNotificationKeys.delete(key);
     const queued = getState().queued.filter((q) => !ids.has(q.id));
     if (queued.length !== getState().queued.length) set({ queued });
   }
@@ -76,8 +73,9 @@ export function createSessionFlow(bag) {
         displayText: entry.displayText || (entry.mode === 'task-notification' ? notificationDisplayText(entry.text) : String(entry.text || '')),
       };
       if (next.mode === 'task-notification' && next.key) {
-        if (pendingNotificationKeys.has(next.key)) continue;
-        pendingNotificationKeys.add(next.key);
+        const duplicateQueued = pending.some((entry) => entry?.mode === 'task-notification' && entry?.key === next.key);
+        if (duplicateQueued) continue;
+        if (!pendingNotificationKeys.has(next.key)) pendingNotificationKeys.add(next.key);
       }
       restored.push(next);
     }
@@ -120,17 +118,67 @@ export function createSessionFlow(bag) {
     return batch;
   }
 
+  function scheduleBlockedDrainRetry() {
+    if (pending.length === 0) return;
+    if (flags.blockedDrainRetryTimer) return;
+    const timer = setTimeout(() => {
+      flags.blockedDrainRetryTimer = null;
+      if (pending.length > 0) void drain();
+    }, 50);
+    if (typeof timer.unref === 'function') timer.unref();
+    flags.blockedDrainRetryTimer = timer;
+  }
+
+  function clearBlockedDrainRetry() {
+    if (!flags.blockedDrainRetryTimer) return;
+    clearTimeout(flags.blockedDrainRetryTimer);
+    flags.blockedDrainRetryTimer = null;
+  }
+
+  function hasModelDrainablePending() {
+    return pending.some((entry) => !isSlashQueuedEntry(entry));
+  }
+
   async function drain() {
     if (flags.draining) return;
-    if (flags.autoClearRunning) return;
+    // Bail while any session command holds commandBusy (auto-clear implies it,
+    // but so do setModel/newSession/resume/etc). Running a turn concurrently
+    // with a command that swaps or reroutes the live session is a race; the
+    // commandBusy-release hook re-kicks drain once the command finishes.
+    if (flags.autoClearRunning || getState().commandBusy) {
+      scheduleBlockedDrainRetry();
+      return;
+    }
+    // Claude Code parity: a queued prompt/notification can arrive while a
+    // provider turn is already in flight (scheduled message, webhook, agent
+    // completion, or user input), but the unified queue only runs BETWEEN
+    // turns. Do NOT start a second Lead runTurn from the post-turn drain in
+    // that window: the active runtime.ask owns the session mutex/transcript.
+    // Anything pending is kicked again by runTurn.finally once busy flips
+    // false. Starting a parallel run here is what tangles turn order and can
+    // abort/interleave the active turn.
+    if (getState().busy) {
+      tuiDebug(`busy-queue drain deferred while active pending=${pending.length}`);
+      return;
+    }
+    clearBlockedDrainRetry();
+    const drainEpoch = (Number(flags.drainEpoch) || 0) + 1;
+    flags.drainEpoch = drainEpoch;
     flags.draining = true;
     let firstBatch = true;
     try {
       while (pending.length > 0) {
+        if (flags.drainEpoch !== drainEpoch) return;
         // Drain one priority/mode bucket at a time (unified command queue):
         // unified command queue semantics: prompt steering stays editable and
         // task notifications stay non-editable but model-visible.
-        const batch = dequeueQueueBatch('later', { limit: firstBatch ? 1 : Infinity });
+        const batch = dequeueQueueBatch('later', {
+          limit: firstBatch ? 1 : Infinity,
+          // Slash commands must run through the TUI command dispatcher, not be
+          // delivered to the model as plain text. Claude Code's queueProcessor
+          // similarly handles slash entries outside the queued_command drain.
+          predicate: (entry) => !isSlashQueuedEntry(entry),
+        });
         firstBatch = false;
         if (batch.length === 0) break;
         tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
@@ -152,6 +200,7 @@ export function createSessionFlow(bag) {
           restorable: nonEditable.length === 0,
           requeueOnAbort: nonEditable,
         });
+        if (flags.drainEpoch !== drainEpoch) return;
         // A deferred cleared-session UI sync (from a late-settling abandoned
         // compacting clear) applies here now that this turn has settled.
         flushDeferredClearedSessionUi();
@@ -180,10 +229,12 @@ export function createSessionFlow(bag) {
         if (turnStatus === 'cancelled' && pending.length === 0) break;
       }
     } finally {
-      flags.draining = false;
-      flushDeferredClearedSessionUi();
-      if (pending.length > 0) void drain();
-      else flushDeferredExecutionPendingResumeKick();
+      if (flags.drainEpoch === drainEpoch) {
+        flags.draining = false;
+        flushDeferredClearedSessionUi();
+        if (hasModelDrainablePending()) void drain();
+        else flushDeferredExecutionPendingResumeKick();
+      }
     }
   }
   function enqueue(text, options = {}) {
@@ -202,25 +253,24 @@ export function createSessionFlow(bag) {
     return true;
   }
 
-  function drainPendingSteering() {
-    // Mid-turn steering drain:
-    // Injects queued user prompts (steering) plus non-editable internal entries
-    // into the CURRENT provider pre-send window so the user can redirect a turn
-    // that is already running. Slash commands are still excluded: they must run
-    // through the normal command processor after the turn, not be sent as plain
-    // text. Consumed entries are spliced out of `pending` here, so the post-turn
-    // drain() loop will not re-execute them.
-    //
-    // dequeueQueueBatch drains ONE priority/mode bucket per call, capped at a
-    // max priority. A concurrent user steering prompt (`next`) and a task
-    // notification (`later`) sit in different buckets, so a single `next`-capped
-    // dequeue would leave the notification pending and the post-turn drain()
-    // loop would spawn an unintended follow-up turn/reply. Loop up to `later`
-    // so EVERY non-slash bucket is consumed by the current turn.
-    const predicate = (entry) => !isSlashQueuedEntry(entry);
+  function drainPendingSteering(_sessionIdOrOptions = null, maybeOptions = null) {
+    const options = maybeOptions && typeof maybeOptions === 'object'
+      ? maybeOptions
+      : (_sessionIdOrOptions && typeof _sessionIdOrOptions === 'object' ? _sessionIdOrOptions : {});
+    const maxPriority = options.maxPriority || 'next';
+    // Claude Code parity: mid-chain drain converts queued prompt/task
+    // notification entries into model-visible "queued_command" style steering
+    // only at provider continuation boundaries. Slash commands stay queued for
+    // the post-turn command processor. `later` notifications (scheduled tasks)
+    // are skipped unless the runtime explicitly asks for a later flush.
+    const predicate = (entry) => {
+      if (isSlashQueuedEntry(entry)) return false;
+      const mode = entry?.mode || 'prompt';
+      return mode === 'prompt' || mode === 'task-notification';
+    };
     const out = [];
     for (;;) {
-      const batch = dequeueQueueBatch('later', { predicate });
+      const batch = dequeueQueueBatch(maxPriority, { predicate });
       if (batch.length === 0) break;
       for (const entry of batch) {
         const content = entry.content;

package/src/tui/engine/tool-card-results.mjs

@@ -14,7 +14,7 @@ import { summarizeToolResult, aggregateDoneCategories, classifyToolCategory } fr
 import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback } from './tool-result-text.mjs';
 import { toolResultCallId } from './tool-call-fields.mjs';
 import { memoryCoreResultErrorText } from '../app/input-parsers.mjs';
-import { parseAgentJob, agentArgsWithResultMetadata, toolResultStatus, isErrorToolStatus } from './agent-envelope.mjs';
+import { parseAgentJob, toolResultStatus, isErrorToolStatus } from './agent-envelope.mjs';
 import {
   withCancelledResultMarker,
   groupedToolResultText,
@@ -31,6 +31,7 @@ export function createToolCardResults({
   patchItem,
   markToolCallDone,
   updateAgentJobCard,
+  buildAgentJobCardPatch,
   agentStatusState,
 }) {
   function patchToolItem(id, patch) {
@@ -65,7 +66,16 @@ export function createToolCardResults({
     // calls: the text-matcher's ^(error|failed) catch-all would otherwise
     // misflag legitimate non-memory success output.
     const isMemoryCall = classifyToolCategory(callRec?.name || card?.name || '', callRec?.args || {}) === 'Memory';
-    const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText)) || (isMemoryCall && memoryCoreResultErrorText(rawText) != null);
+    // Split the failure signal into two:
+    //   isCallError  — a REAL tool-call failure (backend isError / error
+    //                  toolKind). ONLY this paints the ● dot red.
+    //   isResultError — a command/result failure (shell exit code, [error…]
+    //                  text, failed status text, flattened core memory-op
+    //                  failure). These still mark the card Failed in the L2
+    //                  detail but must NOT turn the dot red.
+    const isCallError = message?.isError === true || message?.toolKind === 'error';
+    const isResultError = /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText)) || (isMemoryCall && memoryCoreResultErrorText(rawText) != null);
+    const isError = isCallError || isResultError;
     const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
 
     if (aggregate && card.itemId === aggregate.itemId) {
@@ -78,11 +88,13 @@ export function createToolCardResults({
       callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
       assignAggregateSummaryOrder(aggregate, callRec);
       callRec.isError = isError;
+      callRec.isCallError = isCallError;
       callRec.resultText = text;
       callRec.resolved = true;
       const allCalls = [...aggregate.calls.values()];
       const completed = allCalls.filter((r) => r.resolved).length;
       const errors = allCalls.filter((r) => r.isError).length;
+      const callErrors = allCalls.filter((r) => r.isCallError).length;
       // Collapsed detail carries the merged per-call count summary
       // ("512 lines, 6 matches, 3 files") so the finished card answers "how
       // much" without ctrl+o. Failures keep a bare 'N Ok · N Failed' status so
@@ -103,6 +115,7 @@ export function createToolCardResults({
         rawResult: rawResult || null,
         isError: errors > 0,
         errorCount: errors,
+        callErrorCount: callErrors,
         count: allCalls.length,
         completedCount: visualCompleted,
         doneCategories: aggregateDoneCategories(allCalls),
@@ -114,9 +127,10 @@ export function createToolCardResults({
     }
 
     // Non-aggregate (legacy agent-job cards, etc.)
-    const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, results: [] };
+    const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, callErrors: 0, results: [] };
     group.completed = Math.min(group.count, group.completed + 1);
     group.errors += isError ? 1 : 0;
+    group.callErrors = (group.callErrors || 0) + (isCallError ? 1 : 0);
     group.results.push({ text, isError });
     toolGroups.set(card.itemId, group);
     const resultText = groupedToolResultText(group);
@@ -126,6 +140,7 @@ export function createToolCardResults({
       text: displayResult,
       isError: group.errors > 0,
       errorCount: group.errors,
+      callErrorCount: group.callErrors || 0,
       count: group.count,
       completedCount: group.completed,
       completedAt: Date.now(),
@@ -135,19 +150,17 @@ export function createToolCardResults({
       if (body) patch.rawResult = text || rawText;
       const parsedAgent = parseAgentJob(rawText);
       if (parsedAgent) {
-        patch.args = agentArgsWithResultMetadata(getState().items.find((it) => it.id === card.itemId)?.args, parsedAgent);
         set(agentStatusState({ force: true }));
       }
+      // Coalesce the agent-job card refresh (result/text/isError/errorCount/
+      // args) into THIS patch instead of a second updateAgentJobCard() call.
+      // The two calls previously wrote the same card back-to-back with
+      // different result/text strings, producing the visible L1/L2 flash.
+      // The agent fields win (final display) while patch keeps the completion
+      // metadata (count/completedCount/completedAt/rawResult) for expand.
+      Object.assign(patch, buildAgentJobCardPatch(card.itemId, rawText, isError));
     }
     patchToolItem(card.itemId, patch);
-    if (group.count <= 1) {
-      const beforeAgent = getState().items.find((it) => it.id === card.itemId);
-      updateAgentJobCard(card.itemId, rawText, isError);
-      const afterAgent = getState().items.find((it) => it.id === card.itemId);
-      if (afterAgent && beforeAgent && afterAgent !== beforeAgent) {
-        carryTranscriptMeasuredRowsCache(beforeAgent, afterAgent);
-      }
-    }
     card.done = true;
     if (callId) done.add(callId);
     return true;
@@ -209,6 +222,7 @@ export function createToolCardResults({
         const completed = allCalls.filter((r) => r.resolved).length;
         const totalCompleted = completed;
         const errors = allCalls.filter((r) => r.isError).length;
+        const callErrors = allCalls.filter((r) => r.isCallError).length;
         const succeeded = completed - errors;
         const rawResult = aggregateRawResult(allCalls);
         // Collapsed detail carries the merged per-call count summary; failures
@@ -229,6 +243,7 @@ export function createToolCardResults({
           rawResult: rawResult || null,
           isError: errors > 0,
           errorCount: errors,
+          callErrorCount: callErrors,
           count: allCalls.length,
           completedCount: totalCompleted,
           doneCategories: aggregateDoneCategories(allCalls),
@@ -250,7 +265,7 @@ export function createToolCardResults({
         const currentItem = getState().items.find((it) => it.id === card.itemId);
         resultText = withCancelledResultMarker(resultText, currentItem);
       }
-      patchToolItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, count: group.count, completedCount: group.completed, completedAt: Date.now() });
+      patchToolItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, callErrorCount: group.callErrors || 0, count: group.count, completedCount: group.completed, completedAt: Date.now() });
       card.done = true;
       if (card.callId) done.add(card.callId);
     }