mixdog 1.2.1 → 1.2.3

package/src/tui/session/transcript-spill.mjs

@@ -30,6 +30,13 @@ export { cleanupStaleTranscriptSpillDirs };
 
 let staleSpillSweepDone = false;
 
+/** One sweep per process: it lists the whole temp directory synchronously. */
+export function sweepStaleTranscriptSpillDirsOnce() {
+  if (staleSpillSweepDone) return;
+  staleSpillSweepDone = true;
+  cleanupStaleTranscriptSpillDirs();
+}
+
 // Serialized pages deliberately release the old item object graph while
 // keeping every byte restorable. Only `items` is render-live and walkable.
 // This buffer owns the page list, the reading cursor and snapshots; the spill
@@ -47,12 +54,9 @@ export function createTranscriptSpillBuffer({
   try {
     writeOwnerRegistry();
   } catch {}
-  // One sweep per process: it lists the whole temp directory synchronously,
-  // and a buffer is created per session.
-  if (!staleSpillSweepDone) {
-    staleSpillSweepDone = true;
-    cleanupStaleTranscriptSpillDirs();
-  }
+  // A buffer is created per session; the sweep runs once per process (the
+  // daemon runs it in its post-ready warm-up).
+  sweepStaleTranscriptSpillDirsOnce();
   const pages = [];
   let cursor = null;
   let spillDir = null;
@@ -228,13 +232,16 @@ export function reindexItems(itemIndexById, items) {
 export function replaceSessionItemsState({ state, items, itemIndexById, preserveStreamingTail = false, extra = {} }) {
   const nextItems = Array.isArray(items) ? items : [];
   reindexItems(itemIndexById, nextItems);
-  return {
+  const next = {
     ...state,
     ...extra,
     items: nextItems,
     structureRevision: (Number(state.structureRevision) || 0) + 1,
     streamingTail: preserveStreamingTail ? state.streamingTail : null,
   };
+  // The desktop's partial line belongs to the live row it continues.
+  if (!preserveStreamingTail && next.streamingPartial) next.streamingPartial = null;
+  return next;
 }
 
 // Shared by the live session runtime and focused transcript tests so revision/tail

package/src/tui/session/turn-stream.mjs

@@ -1,6 +1,7 @@
 // Per-turn streaming state for the lead TUI turn: the assistant text
 // segments, the thinking (reasoning) timer, and the frame-batched flush that
-// publishes completed visible lines and thinking transitions to the store.
+// publishes completed visible lines and thinking transitions to the store,
+// plus the desktop-only unfinished line (`streamingPartial`, see partialNow).
 // `createTurnStream` returns one explicit state object (deps + mutable
 // scalars); every function here takes it as its first argument.
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
@@ -11,6 +12,10 @@ import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata
 // 16ms timer left every other terminal frame idle, so completed script lines
 // accumulated and then climbed into view in coarse two-step chunks.
 const STREAM_BATCH_INTERVAL_MS = TUI_FRAME_MS;
+// The desktop's unfinished-line channel (see partialNow): at most one
+// publication per interval, the first chunk after an idle gap on the next
+// frame. Forced flushes (tool calls, notices, finalization) publish at once.
+const PARTIAL_INTERVAL_MS = 40;
 
 // deps: getState, set, nextId, updateStreamingTail, settleStreamingTail,
 // clearStreamingTail, isCurrentTurn, transcriptMeta, routeMeta, sealToolBlock.
@@ -53,42 +58,59 @@ export function createTurnStream(deps) {
     publishedThinkingActive: false,
     // Live countdown of a reconnect wait (see startReconnectCountdown).
     reconnectTimer: null,
+    // The row identity (id, time, message id) claimed before the row exists,
+    // while only the desktop's partial line shows it; the row takes it over.
+    assistantIdentity: null,
+    // Desktop partial-line publication timer and last publish time.
+    partialTimer: null,
+    partialPublishedAt: 0,
+    // This segment's partial is on screen / was cleared by a transcript
+    // replacement (and must not come back).
+    partialShown: false,
+    partialDropped: false,
   };
 }
 
+function claimAssistantIdentity(stream) {
+  if (stream.assistantIdentity) return stream.assistantIdentity;
+  const id = stream.nextId();
+  const meta = stream.transcriptMeta;
+  // A non-streaming continuation was persisted before its text reached this
+  // row: the runtime left that message's id and time (ask-session
+  // takeAssistant), and the row carries them instead of minting new ones.
+  const persisted = stream.claimPersistedAssistant ? meta.persistedAssistant : null;
+  if (persisted) meta.persistedAssistant = null;
+  let assistantAt = persisted?.at;
+  let messageId = persisted?.messageId;
+  if (!persisted) {
+    assistantAt =
+      Number.isFinite(Number(meta.assistantAt)) && Number(meta.assistantAt) > 0 ? Number(meta.assistantAt) : Date.now();
+    meta.assistantAt = assistantAt;
+    // The reply this segment becomes is persisted with this stable id (the
+    // runtime takes it with assistantAt), so a compaction that drops the
+    // reply greys this row.
+    if (!(typeof meta.assistantMessageId === 'string' && meta.assistantMessageId)) {
+      meta.assistantMessageId = newTranscriptMessageId();
+    }
+    messageId = meta.assistantMessageId;
+  }
+  stream.assistantIdentity = { id, at: assistantAt, messageId };
+  return stream.assistantIdentity;
+}
+
 function ensureAssistant(stream, initialText = '') {
   if (!stream.currentAssistantId) {
-    stream.currentAssistantId = stream.nextId();
-    const meta = stream.transcriptMeta;
-    // A non-streaming continuation was persisted before its text reached this
-    // row: the runtime left that message's id and time (ask-session
-    // takeAssistant), and the row carries them instead of minting new ones.
-    const persisted = stream.claimPersistedAssistant ? meta.persistedAssistant : null;
-    if (persisted) meta.persistedAssistant = null;
-    let assistantAt = persisted?.at;
-    let messageId = persisted?.messageId;
-    if (!persisted) {
-      assistantAt =
-        Number.isFinite(Number(meta.assistantAt)) && Number(meta.assistantAt) > 0
-          ? Number(meta.assistantAt)
-          : Date.now();
-      meta.assistantAt = assistantAt;
-      // The reply this segment becomes is persisted with this stable id (the
-      // runtime takes it with assistantAt), so a compaction that drops the
-      // reply greys this row.
-      if (!(typeof meta.assistantMessageId === 'string' && meta.assistantMessageId)) {
-        meta.assistantMessageId = newTranscriptMessageId();
-      }
-      messageId = meta.assistantMessageId;
-    }
+    const { id, at, messageId } = claimAssistantIdentity(stream);
+    stream.assistantIdentity = null;
+    stream.currentAssistantId = id;
     // Do NOT reset currentAssistantText here: the first onTextDelta has
     // already accumulated the opening chunk before this batched flush runs.
     // Segment resets are owned by closeAssistantSegment(). Seed the new row
     // with the already-visible text so the ● gutter and the first body line
     // appear in the SAME set()/emit() — no empty "●-only" row.
-    stream.updateStreamingTail(stream.currentAssistantId, {
+    stream.updateStreamingTail(id, {
       text: String(initialText || ''),
-      at: assistantAt,
+      at,
       messageId,
       ...stream.routeMeta,
     });
@@ -96,6 +118,85 @@ function ensureAssistant(stream, initialText = '') {
   return stream.currentAssistantId;
 }
 
+// The desktop paints streamed text before its line completes; the terminal
+// keeps the line-gated tail below. `streamingPartial` is the unfinished line
+// beyond the published tail text (`from` is that text's length), cut from the
+// same leak-guarded text the tail is, never raw provider output. Before the
+// row's first completed line there is no tail: the partial then carries all
+// visible text so far plus the row identity (`tail`) the row will take over.
+// Terminal projections drop the field (session-proxy/projection.mjs).
+function partialNow(stream) {
+  const text = stream.currentAssistantText;
+  const id = stream.currentAssistantId;
+  if (id != null) {
+    const tail = stream.getState().streamingTail;
+    if (!tail || tail.id !== id) return null;
+    const shown = typeof tail.text === 'string' ? tail.text : '';
+    if (text.length <= shown.length || !text.startsWith(shown)) return null;
+    return { id, from: shown.length, text: text.slice(shown.length) };
+  }
+  // Same rule as the row itself: nothing appears before visible content.
+  if (!text.trim()) return null;
+  const identity = claimAssistantIdentity(stream);
+  return {
+    id: identity.id,
+    from: 0,
+    text,
+    tail: {
+      kind: 'assistant',
+      id: identity.id,
+      streaming: true,
+      at: identity.at,
+      messageId: identity.messageId,
+      ...stream.routeMeta,
+    },
+  };
+}
+
+function samePartial(left, right) {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  return left.id === right.id && left.from === right.from && left.text === right.text && !left.tail === !right.tail;
+}
+
+function clearPartialTimer(stream) {
+  if (stream.partialTimer === null) return;
+  clearTimeout(stream.partialTimer);
+  stream.partialTimer = null;
+}
+
+function publishPartial(stream) {
+  clearPartialTimer(stream);
+  if (!stream.isCurrentTurn()) return;
+  const current = stream.getState().streamingPartial ?? null;
+  // A transcript replacement cleared the partial this segment showed: the
+  // segment stays gone, like a tail the replacement dropped.
+  if (stream.partialShown && current === null) stream.partialDropped = true;
+  if (stream.partialDropped) return;
+  const next = partialNow(stream);
+  stream.partialShown = next !== null;
+  if (samePartial(current, next)) return;
+  stream.partialPublishedAt = Date.now();
+  stream.set({ streamingPartial: next });
+}
+
+function schedulePartial(stream) {
+  if (stream.partialTimer !== null) return;
+  const wait = Math.max(STREAM_BATCH_INTERVAL_MS, PARTIAL_INTERVAL_MS - (Date.now() - stream.partialPublishedAt));
+  stream.partialTimer = setTimeout(() => {
+    stream.partialTimer = null;
+    flushStreamBatch(stream);
+  }, wait);
+  stream.partialTimer?.unref?.();
+}
+
+// The segment's text settled (or was dropped): no partial line outlives it.
+function clearPartial(stream) {
+  clearPartialTimer(stream);
+  stream.partialShown = false;
+  if (stream.getState().streamingPartial != null && stream.isCurrentTurn()) stream.set({ streamingPartial: null });
+}
+
 function resetLineScan(stream) {
   stream.scanLen = 0;
   stream.lastNewlineIdx = -1;
@@ -107,7 +208,10 @@ function closeAssistantSegment(stream) {
   stream.currentAssistantId = null;
   stream.currentAssistantText = '';
   stream.claimPersistedAssistant = false;
+  stream.assistantIdentity = null;
   resetLineScan(stream);
+  clearPartial(stream);
+  stream.partialDropped = false;
 }
 
 export function commitAssistantSegment(stream, { sealToolBlock = false } = {}) {
@@ -173,12 +277,14 @@ function flushTextBatch(stream) {
   const { getState, set } = stream;
   const visibleText = streamingVisibleTextNow(stream);
   const patch = {};
+  let rowCreated = false;
   // Do NOT create the assistant row (and scroll the transcript) before there
   // is a completed line with VISIBLE content: the row appears together with
   // its first visible line. `.trim()` also guards a response that opens with
   // leading newlines, whose blank first line would reserve rows and scroll
   // onto an empty band until a non-blank line lands.
   if (stream.currentAssistantId || visibleText.trim()) {
+    rowCreated = !stream.currentAssistantId;
     const id = ensureAssistant(stream, visibleText);
     const current = getState().streamingTail;
     if (!current || current.id !== id || !Object.is(current.text, visibleText)) {
@@ -214,6 +320,9 @@ function flushTextBatch(stream) {
     set(patch);
   }
   stream.pendingThinkingLastEndedAt = 0;
+  // A completed line created or moved the tail: the partial line restarts
+  // after it in the same frame, so the two never disagree on screen.
+  if (rowCreated || patch.streamingTail) publishPartial(stream);
 }
 
 function thinkingSpinnerPatch(stream, thinkingElapsedMs) {
@@ -256,7 +365,7 @@ function flushThinkBatch(stream) {
   stream.publishedThinkingActive = nextThinkingActive;
 }
 
-export function flushStreamBatch(stream) {
+function flushPendingBatches(stream) {
   if (stream.batchTimer !== null) {
     clearTimeout(stream.batchTimer);
     stream.batchTimer = null;
@@ -265,6 +374,7 @@ export function flushStreamBatch(stream) {
     stream.pendingTextFlush = false;
     stream.pendingThinkFlush = false;
     stream.pendingThinkingLastEndedAt = 0;
+    clearPartialTimer(stream);
     return;
   }
   if (stream.pendingTextFlush) {
@@ -277,9 +387,17 @@ export function flushStreamBatch(stream) {
   }
 }
 
+// A forced flush is a boundary (tool call, notice, finalization, error, or
+// the partial-line tick): the line-gated batch lands, and so does the
+// desktop's unfinished line.
+export function flushStreamBatch(stream) {
+  flushPendingBatches(stream);
+  publishPartial(stream);
+}
+
 function scheduleStreamFlush(stream) {
   if (stream.batchTimer !== null) return; // already scheduled; do not re-arm
-  stream.batchTimer = setTimeout(() => flushStreamBatch(stream), STREAM_BATCH_INTERVAL_MS);
+  stream.batchTimer = setTimeout(() => flushPendingBatches(stream), STREAM_BATCH_INTERVAL_MS);
   stream.batchTimer?.unref?.(); // don't prevent process exit
 }
 
@@ -306,6 +424,7 @@ export function appendTextDelta(stream, textChunk) {
   stream.pendingTextFlush = true;
   if (thinkingLastEndedAt) stream.pendingThinkingLastEndedAt = thinkingLastEndedAt;
   scheduleStreamFlush(stream);
+  schedulePartial(stream);
 }
 
 // Mid-turn assistant text that precedes a tool call from a provider that only
@@ -320,6 +439,9 @@ export function appendAssistantText(stream, full, { committed = false } = {}) {
   // id. Any other text (a tool preamble published before its message commits)
   // leaves an earlier recorded id unclaimed, so drop it.
   stream.claimPersistedAssistant = committed;
+  // A committed message's row takes its persisted identity, never one claimed
+  // earlier for partial text that has since been retracted.
+  if (committed && !stream.currentAssistantId) stream.assistantIdentity = null;
   if (!committed && stream.transcriptMeta && typeof stream.transcriptMeta === 'object') {
     stream.transcriptMeta.persistedAssistant = null;
   }
@@ -364,6 +486,8 @@ export function resetStreamedText(stream, { chars, reasoning } = {}) {
       stream.currentAssistantId = null;
     }
   }
+  // The retraction applies to the desktop's partial line in the same frame.
+  publishPartial(stream);
   return true;
 }
 
@@ -508,18 +632,37 @@ export function settleFinalText(stream, finalText) {
       text: stream.currentAssistantText || stream.assistantText,
     });
   }
+  clearPartial(stream);
 }
 
 // On abort, preserve only the still-open segment: tool boundaries already
 // sealed prior progress segments into their own rows, and replaying the
 // turn-global text would create one giant duplicate after the cancelled card.
 export function settleOpenSegmentOnCancel(stream) {
-  if (!stream.currentAssistantText.trim()) return;
-  const id = stream.currentAssistantId || ensureAssistant(stream, stream.currentAssistantText);
-  stream.settleStreamingTail(id, { text: stream.currentAssistantText });
+  if (stream.currentAssistantText.trim()) {
+    const id = stream.currentAssistantId || ensureAssistant(stream, stream.currentAssistantText);
+    stream.settleStreamingTail(id, { text: stream.currentAssistantText });
+  }
+  clearPartial(stream);
+}
+
+// A segment that never completed a line has no tail, only the partial row the
+// desktop shows. A turn that ends without finalizing it (provider error,
+// aborted tool loop) keeps that text as its row, like cancellation does. A
+// transcript replacement cleared the partial, and then the text stays gone.
+function settlePartialOnlySegment(stream) {
+  const identity = stream.assistantIdentity;
+  const open = stream.getState().streamingPartial;
+  if (stream.currentAssistantId || stream.partialDropped || !identity || open?.id !== identity.id) return;
+  if (!stream.isCurrentTurn()) return;
+  const text = stream.currentAssistantText;
+  if (!text.trim()) return;
+  stream.settleStreamingTail(ensureAssistant(stream, text), { text });
 }
 
 export function settleStreamingTailAtClose(stream) {
+  settlePartialOnlySegment(stream);
+  clearPartial(stream);
   const id = stream.currentAssistantId;
   if (!id || stream.getState().streamingTail?.id !== id) return;
   if (stream.currentAssistantText.trim()) stream.settleStreamingTail(id, { text: stream.currentAssistantText });

package/src/tui/session/turn.mjs

@@ -15,6 +15,7 @@ import { preserveGoalStateAfterTurn } from './goal-turn-state.mjs';
 export { preserveGoalStateAfterTurn } from './goal-turn-state.mjs';
 export { transcriptToolCallDisplayMode } from './turn-tool-cards.mjs';
 import { isRejected429, safeErrorDetails } from '../../runtime/shared/error-presentation.mjs';
+import { QUOTA_KINDS, providerErrorKind } from '../../runtime/agent/orchestrator/providers/provider-error-kind.mjs';
 import { registerTaskWaitSteeringCheck } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
@@ -47,14 +48,11 @@ import {
   startLiveTail,
 } from './turn-tool-cards.mjs';
 
-function isUsageLimitError(error) {
+// A usage limit is exactly a spent quota, a plan-gated feature or a billing
+// refusal; overloads, rate limits and server faults recover by waiting.
+function isUsageLimitError(error, kind = providerErrorKind(error)) {
   if (!error || isRejected429(error)) return false;
-  const status = Number(error?.httpStatus || error?.status || error?.response?.status || 0);
-  if (error?.providerQuota === true || error?.quotaExceeded === true || status === 429) return true;
-  const text = String(error?.message || error);
-  return /\brate[_ -]?limit\b|\bquota\b|too many requests|resource exhausted|insufficient_quota|quota_exceeded/i.test(
-    text
-  );
+  return QUOTA_KINDS.has(kind.kind);
 }
 
 function turnOutcome(cancelled, failed) {
@@ -165,7 +163,7 @@ function promptRestoreFor(displayText, options, submittedIds, content = null) {
   };
 }
 
-function commitPromptRestore(flags, turn) {
+export function commitPromptRestore(flags, turn) {
   const restore = flags.activePromptRestore;
   if (!restore) return;
   if (!turn.promptCommitted && typeof restore.onCommitted === 'function') {
@@ -389,16 +387,27 @@ function toolHandlers(ctx) {
   };
 }
 
-function streamHandlers(ctx) {
+export function streamHandlers(ctx) {
   const { isCurrentTurn, stream } = ctx;
   return {
     onStageChange: async (stage, detail = null) => {
-      if (isCurrentTurn()) await applyStageChange(stream, stage, detail);
+      if (!isCurrentTurn()) return;
+      // A runtime notice (e.g. a tool the provider left out of the request)
+      // becomes a transcript notice the TUI and desktop render.
+      if (stage === 'notice') {
+        flushStreamBatch(stream);
+        ctx.pushNotice(detail?.message, detail?.tone === 'warn' ? 'warn' : 'info', { transcript: true });
+        return;
+      }
+      await applyStageChange(stream, stage, detail);
     },
     onTextDelta: (chunk) => {
       const textChunk = String(chunk ?? '');
       if (!textChunk || !isCurrentTurn()) return;
-      ctx.markPromptCommitted();
+      // Same verdict as the runtime's interruption check (finalizeInterruptedTurn
+      // trims): whitespace-only text is not output, so it must not commit the
+      // prompt — the runtime would rewind it while the host skipped the requeue.
+      if (textChunk.trim()) ctx.markPromptCommitted();
       appendTextDelta(stream, textChunk);
     },
     onTextReset: (reset = {}) => (isCurrentTurn() ? resetStreamedText(stream, reset) : false),
@@ -448,13 +457,30 @@ export function failTurn(ctx, error) {
   }
   turn.failed = true;
   cards.aggregates.finalizeToolHeaders();
-  turn.usageLimited = isUsageLimitError(error);
+  // Presentation only: legacy untyped failure text may still name a usage limit.
+  const errorKind = providerErrorKind(error, { legacyQuotaWording: true });
+  // The UI reads this descriptor instead of re-parsing the error text.
+  turn.errorKind = {
+    kind: errorKind.kind,
+    code: errorKind.code,
+    status: errorKind.status,
+    retryAfterMs: errorKind.retryAfterMs,
+    resetAt: errorKind.resetAt,
+  };
+  turn.usageLimited = isUsageLimitError(error, errorKind);
   const exhausted = error?.quotaExhausted;
-  if (exhausted && typeof exhausted === 'object') {
+  // Quota metadata: the pool's validated exhaustion, or a spent quota whose
+  // provider named the real reset time.
+  const resetKnown = errorKind.kind === 'quota_exhausted' && Number.isFinite(errorKind.resetAt);
+  if ((exhausted && typeof exhausted === 'object') || resetKnown) {
+    const source = exhausted && typeof exhausted === 'object' ? exhausted : {};
+    let resetAt = null;
+    if (Number.isFinite(source.resetAt)) resetAt = source.resetAt;
+    else if (Number.isFinite(errorKind.resetAt)) resetAt = errorKind.resetAt;
     turn.quota = {
-      provider: String(exhausted.provider || turn.routeMeta?.provider || ''),
-      model: String(exhausted.model || turn.routeMeta?.model || ''),
-      resetAt: Number.isFinite(exhausted.resetAt) ? exhausted.resetAt : null,
+      provider: String(source.provider || turn.routeMeta?.provider || ''),
+      model: String(source.model || turn.routeMeta?.model || ''),
+      resetAt,
     };
   }
   turn.failureDetail = toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, '');
@@ -485,6 +511,7 @@ export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
     ...(turn.failureDiagnostic ? { errorDetails: turn.failureDiagnostic } : {}),
     ...turn.routeMeta,
     ...(turn.failed && turn.quota ? { quota: turn.quota } : {}),
+    ...(turn.failed && turn.errorKind ? { errorKind: turn.errorKind } : {}),
   };
 }
 
@@ -564,6 +591,7 @@ async function settleTurn(ctx) {
     result: turn.askResult,
     session: runtime.session || null,
     error: turn.failureDetail || null,
+    errorKind: turn.failed ? turn.errorKind || null : null,
   };
   // Publish termination before optional Goal work can delay the caller.
   bag.settleSteeredSubmissions?.(turn.epoch, detail);
@@ -626,6 +654,8 @@ export function createRunTurn(bag) {
     set({
       busy: true,
       lastTurn: null,
+      // A turn that unwound stale never cleared its desktop partial line.
+      ...(getState().streamingPartial ? { streamingPartial: null } : {}),
       spinner: {
         active: true,
         verb: pickVerb(turn.index),

package/src/tui/statusline-ansi-bridge.mjs

@@ -65,7 +65,7 @@ export function statuslineFooterIdentityChanged(args, lastArgs) {
   if (!lastArgs) return true;
   if (args.sessionId !== lastArgs.sessionId) return true;
   if (args.provider !== lastArgs.provider || args.model !== lastArgs.model) return true;
-  if (args.effort !== lastArgs.effort || args.fast !== lastArgs.fast) return true;
+  if (args.effort !== lastArgs.effort || args.fast !== lastArgs.fast || args.ultra !== lastArgs.ultra) return true;
   if (args.contextWindow !== lastArgs.contextWindow || args.rawContextWindow !== lastArgs.rawContextWindow) return true;
   if (args.displayContextWindow !== lastArgs.displayContextWindow) return true;
   if (args.compactBoundaryTokens !== lastArgs.compactBoundaryTokens) return true;

package/src/ui/statusline-agents.mjs

@@ -25,8 +25,7 @@ let _hiddenStatuslineAgents = null;
 function normalizeAgentWorkerForStatusline(worker = {}) {
   const tag = String(worker.tag || worker.agent || worker.name || '').trim();
   if (!tag) return null;
-  const statuses = agentStatusValues(worker);
-  const status = isActiveAgentEntry(statuses) ? 'running' : 'idle';
+  const status = isActiveAgentEntry(lifecycleStatuses(worker)) ? 'running' : 'idle';
   return {
     tag,
     status,
@@ -63,11 +62,12 @@ function normalizeAgentJobForStatusline(job = {}) {
       model: job.model || null,
     };
   }
-  if (!isActiveAgentEntry(statuses)) return null;
+  const lifecycle = lifecycleStatuses(job);
+  if (!isActiveAgentEntry(lifecycle)) return null;
   return {
     tag,
     taskId,
-    status: isQueuedAgentEntry(statuses) ? 'queued' : 'running',
+    status: isQueuedAgentEntry(lifecycle) ? 'queued' : 'running',
     startedAtMs,
     agent: job.agent || null,
     stage: job.stage || job.workerStatus || job.status || null,
@@ -214,6 +214,17 @@ function agentStatusValues(value = {}) {
     .filter((status, index, values) => Boolean(status) && values.indexOf(status) === index);
 }
 
+/** The statuses that decide whether an entry is working. `status` is the
+ *  lifecycle; `stage` is the runtime phase copied in beside it, which can read
+ *  idle/done/error mid-work, so it decides only for an entry with no status. A
+ *  cancel in either field still counts (it keeps both in play). */
+function lifecycleStatuses(value = {}) {
+  const statuses = agentStatusValues(value);
+  if (statuses.some((status) => /cancel|killed/i.test(status))) return statuses;
+  const status = String(value.status || '').trim();
+  return status ? [status] : statuses;
+}
+
 function isTerminalAgentEntry(statuses = []) {
   return statuses.some((status) => TERMINAL_AGENT_STATUS.test(String(status || '')));
 }

package/src/ui/statusline.mjs

@@ -197,6 +197,7 @@ export async function renderStatusline({
   model = '',
   effort = '',
   fast = false,
+  ultra = false,
   cwd = '',
   stats,
   sessionId,
@@ -223,6 +224,7 @@ export async function renderStatusline({
       model,
       effort,
       fast,
+      ultra,
       cwd,
       stats,
       sessionId,
@@ -233,7 +235,7 @@ export async function renderStatusline({
       ...displayArgs,
     });
   } catch {
-    return fallbackLine({ provider, model, effort, fast, cwd, stats, ...displayArgs });
+    return fallbackLine({ provider, model, effort, fast, ultra, cwd, stats, ...displayArgs });
   }
 }
 
@@ -244,6 +246,7 @@ function renderNativeStatusline({
   model = '',
   effort = '',
   fast = false,
+  ultra = false,
   stats,
   sessionId,
   contextWindow = 0,
@@ -275,7 +278,7 @@ function renderNativeStatusline({
 
   const sep = ` ${D}│${R} `;
   const l1Parts = [
-    formatModelSegment({ provider, model, effort, fast, cols }),
+    formatModelSegment({ provider, model, effort, fast, ultra, cols }),
     formatContextSegment(ctxPct, cols, s.currentContextSource),
     ...quotaSegmentsFor({ provider, model, effort, fast, sessionId, clientHostPid, gatewayStatus, cols }),
   ].filter(Boolean);
@@ -664,6 +667,7 @@ function fallbackLine({
   model = '',
   effort = '',
   fast = false,
+  ultra = false,
   cwd: _cwd = '',
   stats,
   contextWindow = 0,
@@ -687,7 +691,7 @@ function fallbackLine({
   });
   const sep = ` ${D}│${R} `;
   const parts = [
-    formatModelSegment({ provider, model, effort, fast, cols }),
+    formatModelSegment({ provider, model, effort, fast, ultra, cols }),
     formatContextSegment(ctxPct, cols, s.currentContextSource),
   ].filter(Boolean);
   if (!parts.length) return statusSubtle('> mixdog');

package/src/ui/streaming-markdown-heal.mjs

@@ -213,12 +213,43 @@ function healIncompleteLink(text, isPendingLocalPath) {
   return `${prefix}[${closeEmphasis(caption)}${']'.repeat(Math.max(0, depth - 1))}]()`;
 }
 
+const PIPE_ROW = /^ {0,3}\|/;
+const DELIMITER_ROW = /^ {0,3}\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+const PARTIAL_DELIMITER_ROW = /^ {0,3}\|?[\s:|-]*$/;
+
+function tableCells(line) {
+  const cells = line.trim().split(/(?<!\\)\|/);
+  if (cells[0].trim() === '') cells.shift();
+  if (cells.length && cells[cells.length - 1].trim() === '') cells.pop();
+  return cells.length;
+}
+
+// A table streams in as its header row, then its delimiter row a token at a
+// time. Until the delimiter is complete (and has the header's cell count) the
+// rows are a paragraph of raw pipes, which then re-laid out as a table of a
+// different height — the reply grew and shrank under a followed transcript.
+// Hold both rows back until the table can form in one step.
+function trimPendingTableHead(text) {
+  let offset = 0;
+  for (const blank of text.matchAll(/\n[ \t]*\r?\n/g)) offset = blank.index + blank[0].length;
+  const block = text.slice(offset);
+  const lines = block.split('\n').map((line) => line.replace(/\r$/, ''));
+  if (lines.length === 0 || lines.length > 2 || !PIPE_ROW.test(lines[0])) return text;
+  if (lines.length === 2) {
+    const delimiter = lines[1];
+    if (!PARTIAL_DELIMITER_ROW.test(delimiter)) return text;
+    if (DELIMITER_ROW.test(delimiter) && tableCells(delimiter) === tableCells(lines[0])) return text;
+  }
+  return text.slice(0, offset);
+}
+
 export function healStreamingMarkdownTail(text, isPendingLocalPath) {
-  const value = String(text ?? '');
+  const source = String(text ?? '');
+  const fence = source.includes('`') || source.includes('~') ? openFence(source) : null;
+  if (fence) return trimPartialClosingFence(source, fence);
+  const value = source.includes('|') ? trimPendingTableHead(source) : source;
   const hasSyntax = HEALABLE_MARKDOWN_SYNTAX.test(value);
   if (!value || (!hasSyntax && !isPendingLocalPath)) return value;
-  const fence = openFence(value);
-  if (fence) return trimPartialClosingFence(value, fence);
   const healed = hasSyntax
     ? closeEmphasis(healIncompleteLink(closeInlineCode(value, isPendingLocalPath), isPendingLocalPath))
     : value;