mixdog 1.2.2 → 1.2.3

package/src/tui/session/context-state.mjs

@@ -71,8 +71,10 @@ export function createContextState({
     // Lead workspace record (worktrees/contract.mjs SessionWorkspace): the
     // registered Project, the execution root, the worktree binding and its
     // revision. Null while the session has never left its project folder.
-    // Identity-stable until a transition commits.
-    workspace: runtime.getWorkspace?.() ?? null,
+    // Identity-stable until a transition commits. A project-folder session in a
+    // git repository publishes the folder's branch / detached commit too
+    // (getLiveWorkspace reads HEAD without spawning git).
+    workspace: runtime.getLiveWorkspace?.() ?? runtime.getWorkspace?.() ?? null,
     systemShell: runtime.systemShell || { source: 'auto', command: '', effective: '' },
     webSearchRoute: runtime.getWebSearchRoute?.() || runtime.webSearchRoute || null,
     autoClear: autoClearState(),

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

@@ -2,6 +2,7 @@
  * commands.mjs — the session object's long-running slash commands: memory
  * control, recall, doctor, and manual compaction (scheduled for turn end when
  * a turn is running). Each shows a command status while it holds the lock.
+ * /btw side questions (askSide/cancelSide) run beside them, lock-free.
  */
 import { compactEventDetail } from '../labels.mjs';
 import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction-view.mjs';
@@ -175,5 +176,14 @@ export function createSessionCommandsApi(bag) {
       });
     },
     compact: compactCommand,
+    // /btw: answered from the conversation so far while a turn keeps running.
+    // No command lock and no transcript row: the answer is only returned.
+    askSide: (question) => runtime.askSide(question),
+    // `sessionId` names the session the side question was asked in (it may
+    // no longer be the current one after a switch); omitted, the current one.
+    cancelSide: (sessionId) => {
+      if (typeof sessionId === 'string' && sessionId) runtime.cancelSide(sessionId);
+      else runtime.cancelSide();
+    },
   };
 }

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

@@ -91,8 +91,8 @@ export function createSessionControlsApi(bag) {
       );
       return result;
     },
-    setCwd: (path, options = {}) => {
-      const next = runtime.setCwd(path);
+    setCwd: async (path, options = {}) => {
+      const next = await runtime.setCwd(path);
       // Republish up-arrow history for the NEW project: current session prompts
       // merged with the cwd-scoped persisted store for the new cwd.
       const sessionList = recomputePromptHistory(getState().items);

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

@@ -38,8 +38,8 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getQuotaHistory: async (options = {}) => {
       return await runtime.getQuotaHistory?.(options);
     },
-    getSessionUsage: async () => {
-      return await runtime.getSessionUsage?.();
+    getSessionUsage: async (options = {}) => {
+      return await runtime.getSessionUsage?.(options);
     },
     consumeCodexRateLimitResetCredit: async (options = {}) => {
       // Desktop capability parity: without this delegation the session runtime
@@ -52,6 +52,12 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getSessionReviewDiff: async () => {
       return (await runtime.getSessionReviewDiff?.()) ?? { supported: false, files: [], patch: '' };
     },
+    getSessionReviewFilePatch: async (file, oldPath) => {
+      return (await runtime.getSessionReviewFilePatch?.(file, oldPath)) ?? { supported: false, patch: '' };
+    },
+    getTurnReviewFilePatch: async (file) => {
+      return (await runtime.getTurnReviewFilePatch?.(file)) ?? { supported: false, patch: '' };
+    },
     revertTurnReview: async (checkpointId) => {
       return await requireRuntimeMethod('revertTurnReview', 'Turn review revert is unavailable')(checkpointId);
     },
@@ -140,6 +146,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       return result;
     },
     testCustomProvider: (input) => runtime.testCustomProvider(input),
+    checkCustomProviderKeyEnv: (name) => runtime.checkCustomProviderKeyEnv(name),
     discoverCustomProviderModels: (input) => runtime.discoverCustomProviderModels(input),
     saveOpenCodeGoUsageAuth: async (opts) => {
       await runtime.saveOpenCodeGoUsageAuth(opts);

package/src/tui/session/session-api/lifecycle/dispose.mjs

@@ -40,6 +40,7 @@ export function createDisposeAction(bag, { oauthFlows }) {
         'unsubscribeAgentStatus',
         'unsubscribeRemoteState',
         'unsubscribeCompletionWakeGate',
+        'unsubscribeGitHeadWatch',
       ]) {
         try {
           lifecycle[key]?.();

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

@@ -56,7 +56,8 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
         id,
         approved,
         decision?.reason || (approved ? 'approved by user' : 'denied by user'),
-        typeof decision?.device === 'string' ? decision.device : ''
+        typeof decision?.device === 'string' ? decision.device : '',
+        decision?.answers
       );
     },
     pushNotice,

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

@@ -106,6 +106,12 @@ export function createSessionSettingsApi(bag) {
       deferStatsRefresh();
       return next;
     }),
+    getSessionTitleSettings: () => {
+      return runtime.getSessionTitleSettings?.() || { aiSessionTitles: true };
+    },
+    setAiSessionTitles: withCommandLock(async (enabled) => {
+      return await runtime.setAiSessionTitles?.(enabled);
+    }),
     getToolModuleSettings: () => {
       return (
         runtime.getToolModuleSettings?.() || {

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

@@ -33,6 +33,7 @@ export function createSessionApi(bag) {
       autoClear: await read(api.getAutoClear),
       compaction: await read(api.getCompactionSettings),
       recap: await read(api.getRecapSettings),
+      sessionTitles: await read(api.getSessionTitleSettings),
       toolModules: await read(api.getToolModuleSettings),
       channels: await read(api.getChannelSettings, { includeStatus: false }),
       systemShell: await read(api.getSystemShell),

package/src/tui/session/tool-approval.mjs

@@ -12,17 +12,20 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
 
   function normalizeToolApprovalRequest(input = {}, id = nextId()) {
     const now = Date.now();
+    const requestTimeoutMs =
+      Number.isFinite(Number(input?.timeoutMs)) && Number(input.timeoutMs) > 0 ? Number(input.timeoutMs) : timeoutMs;
     return {
       id,
       name: String(input?.name || input?.tool_name || 'tool'),
+      kind: typeof input?.kind === 'string' ? input.kind : '',
       args: input?.args ?? input?.tool_input ?? null,
       cwd: input?.cwd || null,
       sessionId: input?.sessionId || input?.session_id || null,
       toolCallId: input?.toolCallId || input?.tool_use_id || null,
       reason: String(input?.reason || input?.message || 'approval requested by hook').trim(),
       requestedAt: now,
-      timeoutMs,
-      expiresAt: now + timeoutMs,
+      timeoutMs: requestTimeoutMs,
+      expiresAt: now + requestTimeoutMs,
     };
   }
   // Every request expires from ITS OWN requestedAt, queued or active. Arming
@@ -39,10 +42,10 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
   // Settle one entry: drop its timeout, then hand the waiter its answer. The
   // resolve stays guarded — a waiter whose caller already went away must never
   // take the rest of the queue down with it.
-  function settleToolApproval(entry, approved, reason) {
+  function settleToolApproval(entry, approved, reason, answers) {
     if (entry?.timer) clearTimeout(entry.timer);
     try {
-      entry.resolve({ approved, reason });
+      entry.resolve(answers === undefined ? { approved, reason } : { approved, reason, answers });
     } catch {}
   }
   function presentNextToolApproval() {
@@ -56,7 +59,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     armToolApprovalTimeout(entry);
     set({ toolApproval: entry.request });
   }
-  function finishToolApproval(id, approved, reason = '', device = '') {
+  function finishToolApproval(id, approved, reason = '', device = '', answers = undefined) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
@@ -67,14 +70,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
         ? { id: targetId, approved: approved === true, device: String(device), at: Date.now() }
         : null;
       set({ toolApproval: null, toolApprovalResult });
-      settleToolApproval(entry, approved === true, String(reason || ''));
+      settleToolApproval(entry, approved === true, String(reason || ''), answers);
       presentNextToolApproval();
       return true;
     }
     const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
-      settleToolApproval(entry, approved === true, String(reason || ''));
+      settleToolApproval(entry, approved === true, String(reason || ''), answers);
       return true;
     }
     return false;

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,10 +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 { 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';
@@ -394,7 +391,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 ?? '');
@@ -649,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/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