mixdog 1.2.2 → 1.2.4

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

@@ -1,16 +1,22 @@
 // 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';
 import { retryStatusLine } from '../../runtime/shared/err-text.mjs';
+import { MODEL_THINKING_STAGE } from '../../runtime/shared/quiet-progress.mjs';
 import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
 
 // Share Ink's exact 120fps cadence with the frame-batched store. A separate
 // 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 +59,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 +119,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 +209,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 +278,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 +321,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 +366,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 +375,7 @@ export function flushStreamBatch(stream) {
     stream.pendingTextFlush = false;
     stream.pendingThinkFlush = false;
     stream.pendingThinkingLastEndedAt = 0;
+    clearPartialTimer(stream);
     return;
   }
   if (stream.pendingTextFlush) {
@@ -277,9 +388,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 +425,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 +440,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 +487,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;
 }
 
@@ -466,9 +591,12 @@ export async function applyStageChange(stream, stage, detail = null) {
     await yieldToRenderer();
     return;
   }
-  if (value === 'requesting' || value === 'streaming') stream.compactingActive = false;
+  if (value === 'requesting' || value === 'streaming' || value === MODEL_THINKING_STAGE) {
+    stream.compactingActive = false;
+  }
   let mode = null;
   if (value === 'requesting') mode = 'requesting';
+  else if (value === MODEL_THINKING_STAGE) mode = 'model-thinking';
   else if (value === 'streaming') mode = getState().spinner.thinking ? 'thinking' : 'responding';
   if (!mode || getState().spinner.mode === mode) return;
   set({ spinner: { ...getState().spinner, mode } });
@@ -508,18 +636,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

@@ -7,18 +7,20 @@
  * turn record below that finalization publishes as the turndone item.
  */
 import { applyUsageDelta } from './session-stats.mjs';
+import {
+  createTranscriptRouteMetadata,
+  transcriptRouteMetadataFields,
+} from '../../runtime/shared/transcript-metadata.mjs';
+import { publishModelSwitch } from './session-api/routes.mjs';
 import { compactEventLabel } from '../../runtime/shared/compact-event-label.mjs';
 import { pickVerb, pickDoneVerb, compactEventDetail } from './labels.mjs';
-import { toolErrorDisplay } from './tool-result-text.mjs';
-import { errText, isCancelLikeError } from '../../runtime/shared/err-text.mjs';
+import { isCancelLikeError } from '../../runtime/shared/err-text.mjs';
 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 { isRejected429 } from '../../runtime/shared/error-presentation.mjs';
+import { QUOTA_KINDS, providerErrorKind } from '../../runtime/agent/orchestrator/providers/provider-error-kind.mjs';
+import { turnFailureRecord } from '../../runtime/agent/orchestrator/session/turn-failure.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';
@@ -50,6 +52,7 @@ import {
   collectClosingCards,
   startLiveTail,
 } from './turn-tool-cards.mjs';
+import { startQuietWatch } from './turn-quiet.mjs';
 
 // 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.
@@ -97,6 +100,13 @@ function streamingTailStore({ updateStreamingTail, settleStreamingTail, clearStr
 
 // The turn record: identity, transcript metadata, and the outcome fields
 // finalization publishes.
+export function applyTurnRouteMetadata(ctx, session) {
+  const metadata = transcriptRouteMetadataFields(createTranscriptRouteMetadata(session));
+  Object.assign(ctx.turn.transcriptMeta, metadata);
+  Object.assign(ctx.turn.routeMeta, metadata);
+  for (const id of ctx.turn.submittedIds) ctx.patchItem(id, metadata);
+}
+
 function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
   const index = getState().stats.turns || 0;
   const startedAt = Date.now();
@@ -105,6 +115,7 @@ function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
     ...(flags.pendingTranscriptMeta || transcriptRouteMetadata?.(startedAt) || { at: startedAt }),
     ...(options.transcriptMeta && typeof options.transcriptMeta === 'object' ? options.transcriptMeta : {}),
     completionVerb,
+    attemptId: globalThis.crypto.randomUUID(),
   };
   flags.pendingTranscriptMeta = null;
   // The prompt's own time and stable id stay on the prompt row.
@@ -394,7 +405,15 @@ 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 ?? '');
@@ -452,34 +471,13 @@ export function failTurn(ctx, error) {
   }
   turn.failed = true;
   cards.aggregates.finalizeToolHeaders();
-  // Presentation only: legacy untyped failure text may still name a usage limit.
-  const errorKind = providerErrorKind(error, { legacyQuotaWording: true });
+  const record = turnFailureRecord(error, { provider: turn.routeMeta?.provider, model: turn.routeMeta?.model });
   // 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;
-  // 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(source.provider || turn.routeMeta?.provider || ''),
-      model: String(source.model || turn.routeMeta?.model || ''),
-      resetAt,
-    };
-  }
-  turn.failureDetail = toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, '');
-  turn.failureDiagnostic = safeErrorDetails(errText(error));
+  turn.errorKind = record.errorKind;
+  turn.usageLimited = isUsageLimitError(error, record.providerKind);
+  if (record.quota) turn.quota = record.quota;
+  turn.failureDetail = record.detail;
+  turn.failureDiagnostic = record.errorDetails;
   pushNotice(turn.failureDetail, 'error', { owner: 'transcript' });
 }
 
@@ -649,6 +647,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),
@@ -676,7 +676,12 @@ export function createRunTurn(bag) {
       routeMeta: turn.routeMeta,
       sealToolBlock: cards.aggregates.clearAggregateContinuation,
     });
-    const stopLiveTail = startLiveTail(cards);
+    const stopToolTail = startLiveTail(cards);
+    const stopQuietWatch = startQuietWatch({ runtime, getState, set, isCurrentTurn });
+    const stopLiveTail = () => {
+      stopToolTail();
+      stopQuietWatch();
+    };
     const ctx = {
       ...bag,
       bag,
@@ -696,11 +701,20 @@ export function createRunTurn(bag) {
         submittedAt: options.submittedAt,
         promptSource: options.promptSource,
         retryFailedTurn: options.retryFailedTurn === true,
+        retryTurnId: options.retryTurnId,
+        retryAttemptId: options.retryAttemptId,
         transcriptMeta: turn.transcriptMeta,
         context: options.context || null,
         ...turnHandlers(ctx),
         ...toolHandlers(ctx),
         ...streamHandlers(ctx),
+        onRouteApplied: (session) => {
+          if (isCurrentTurn()) applyTurnRouteMetadata(ctx, session);
+        },
+        onModelSwitch: (boundary) => {
+          if (!isCurrentTurn()) return;
+          publishModelSwitch(bag, boundary);
+        },
       });
       if (!isCurrentTurn()) turn.cancelled = true;
       else completeTurn(ctx, result, session);

package/src/tui/session/worktree-setup-notice.mjs

@@ -0,0 +1,38 @@
+/**
+ * src/tui/session/worktree-setup-notice.mjs - the one-line transcript notice
+ * shown while a new worktree's dependencies install (runtime.onWorktreeSetup).
+ * Only runs that install anything reach it; one notice per run, patched in
+ * place, so every surface showing the transcript (TUI, desktop, remote) sees
+ * the same line. The details (output, failures, skips) go to the agent only.
+ */
+const ENDINGS = {
+  completed: 'Worktree dependencies installed.',
+  cancelled: 'Installing worktree dependencies was cancelled.',
+};
+const INCOMPLETE = 'Some worktree dependencies were not installed; the agent has the details.';
+
+/** Notice text and tone for one install progress event. */
+export function worktreeSetupNotice(event) {
+  if (event.final) {
+    const text = ENDINGS[event.status] ?? INCOMPLETE;
+    return { text, tone: event.status === 'completed' ? 'info' : 'warn' };
+  }
+  const what = event.label || event.command;
+  return { text: `Installing worktree dependencies [${event.index + 1}/${event.total}]: ${what}`, tone: 'info' };
+}
+
+export function createWorktreeSetupNotices({ pushItem, patchItem, nextId }) {
+  const items = new Map();
+  return (event) => {
+    const notice = worktreeSetupNotice(event);
+    const itemId = items.get(event.id);
+    if (itemId === undefined) {
+      const id = nextId();
+      items.set(event.id, id);
+      pushItem({ kind: 'notice', id, ...notice });
+    } else {
+      patchItem(itemId, notice);
+    }
+    if (event.final) items.delete(event.id);
+  };
+}

package/src/tui/spinner-meta.mjs

@@ -9,6 +9,8 @@
  * for 30s. One builder, one answer.
  */
 
+import { quietProgressLabel, quietProgressParts } from '../runtime/shared/quiet-progress.mjs';
+
 const compactNumberFormatter = new Intl.NumberFormat('en-US', {
   notation: 'compact',
   maximumFractionDigits: 1,
@@ -67,9 +69,13 @@ export function buildSpinnerMeta({
   thinkingSince = 0,
   thinkingMs = 0,
   effort = '',
+  // The turn's published quiet state (`spinner.quiet`) and the clock it is read at.
+  quiet = null,
+  now = Date.now(),
   verbose: _verbose = false,
 } = {}) {
   const tokens = Math.max(0, Number(outputTokens) || 0);
+  const quietParts = quietProgressParts(quiet, now, quiet?.warnMs);
   const thinkingParts = spinnerThinkingParts({ thinking, thinkingSince, thinkingMs, effort });
   const thinkingText = spinnerThinkingLabel({ thinking, thinkingSince, thinkingMs, effort });
   return {
@@ -83,6 +89,10 @@ export function buildSpinnerMeta({
     showTokens: tokens > 0,
     thinkingText,
     thinkingActive: Boolean(thinking || Number(thinkingSince) > 0),
+    // Quiet-time cue: structured for the desktop's i18n, English for the TUI;
+    // `escalated` once the silence reaches the stall watchdog's warn point.
+    quietParts,
+    quietText: quietProgressLabel(quietParts),
   };
 }
 

package/src/tui/spinner-verbs.mjs

@@ -247,6 +247,9 @@ export const SPINNER_MODE_OVERRIDE_VERBS = {
   'auto-clear': 'Auto-clearing conversation',
   resuming: 'Resuming conversation',
   'task-wait': '작업 대기 중',
+  // The request is sent and its response headers are pending: the model is
+  // queued or thinking server-side.
+  'model-thinking': 'Model thinking',
 };
 
 /**

package/src/ui/statusline.mjs

@@ -31,7 +31,11 @@ import {
   num,
   formatElapsed,
 } from '../runtime/shared/statusline/statusline-format.mjs';
-import { shellJobsStatus, memoryCycleStatus } from '../runtime/shared/statusline/statusline-segments.mjs';
+import {
+  shellJobsStatus,
+  memoryCycleStatus,
+  unconfirmedShellCount,
+} from '../runtime/shared/statusline/statusline-segments.mjs';
 import {
   agentStatuslinePayload,
   classifyAgentWorkers,
@@ -397,10 +401,16 @@ function activitySegments({ sessionId, clientHostPid, agentWorkers, agentJobs, a
     const n = runningWorkers.length;
     segment(`Running ${n} Agent${n === 1 ? '' : 's'}`, agentsElapsed(runningWorkers));
   }
-  if (shellStatus.count > 0) {
-    const n = shellStatus.count;
+  const unconfirmed = unconfirmedShellCount(shellStatus);
+  if (shellStatus.count - unconfirmed > 0) {
+    const n = shellStatus.count - unconfirmed;
     segment(`Running ${n} Shell${n === 1 ? '' : 's'}`, shellStatus.elapsedLabel);
   }
+  if (unconfirmed > 0) {
+    parts.push(
+      `${YLW}⚠ ${unconfirmed} Shell${unconfirmed === 1 ? '' : 's'} termination unconfirmed${R} ${D}·${R} /shells`
+    );
+  }
   const webSearch = webSearchActivity(activeTools, { sessionId, clientHostPid });
   if (webSearch.count > 0) segment('Web Searching', webSearch.elapsed);
   // Memory cycle segment — single unified "Memory" wording for all states:

package/src/workflows/default/WORKFLOW.md

@@ -6,7 +6,9 @@ description: "Handle tasks as requested."
 
 Consult the user and build the work plan together. Explicit read-only requests
 proceed immediately. When file edits, state mutation, or delegation are
-required, investigate and plan only until the user approves the latest plan.
+required, investigate and plan only until the user approves the latest plan. If the
+plan leaves the user a choice among clear options, ask it with `ask_user`
+before asking for approval.
 
 When user input is required, park only the affected work and continue
 unaffected approved work. Ask pending questions together once no such work

package/src/runtime/agent/orchestrator/providers/model-pricing-rates.mjs

@@ -1 +0,0 @@
-export * from '../../../shared/llm/model-pricing-rates.mjs';