mixdog 1.2.2 → 1.2.4

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

@@ -20,14 +20,14 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
   // work for a conversation that is being closed. A durable close that fails
   // restores admission with every accepted input intact; one that succeeds
   // leaves the session terminal and settles queued submissions explicitly.
-  function closeCanonical(reason) {
+  function closeCanonical(reason, options) {
     const flags = bag.flags || {};
     const previous = flags.admission || 'open';
-    if (previous === 'terminal') return runtime.closeCanonicalSession?.(reason) === true;
+    if (previous === 'terminal') return runtime.closeCanonicalSession?.(reason, options) === true;
     flags.admission = 'closing';
     let closed = false;
     try {
-      closed = runtime.closeCanonicalSession?.(reason) === true;
+      closed = runtime.closeCanonicalSession?.(reason, options) === true;
     } catch (error) {
       flags.admission = previous;
       restoreAdmission();
@@ -50,13 +50,16 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
   }
 
   return {
+    isSessionTerminal: () => bag.flags?.admission === 'terminal' || runtime.isSessionTerminal?.() === true,
     resolveToolApproval: (id, decision = {}) => {
       const approved = decision === true || decision?.approved === true;
       return finishToolApproval(
         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,
+        typeof decision?.reply === 'string' ? decision.reply : undefined
       );
     },
     pushNotice,
@@ -82,8 +85,6 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
         throw new Error('latest turn did not fail on exhausted provider quota');
       }
       if (typeof runtime.continueSessionInModel !== 'function') throw new Error('runtime cannot continue in a model');
-      // Continuing elsewhere supersedes waiting for this provider's reset.
-      bag.supersedeQuotaResume?.(sessionId);
       bag.set({ commandBusy: true });
       try {
         const result = await runtime.continueSessionInModel(sessionId, route);
@@ -98,10 +99,12 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
         bag.flushEmitImmediate?.();
       }
     },
-    // Desktop sidebar watcher hook: the daemon watches this directory so
-    // heartbeat sidecar create/delete pushes instant working/dot updates.
-    // Without it the watcher silently no-ops and the sidebar falls back to
-    // the 60s safety poll (user: spinner kept spinning after the turn ended).
+    // Desktop sidebar watcher hook: the desktop host watches this directory,
+    // and a session record write (a turn starting or settling) schedules a
+    // debounced catalog refresh that re-reads `working` from the daemon's
+    // in-memory run state. Without it the watcher silently no-ops and the
+    // sidebar only refreshes on other store notifications (user: spinner kept
+    // spinning after the turn ended).
     sessionStoreDir: () => {
       try {
         return runtime.sessionStoreDir?.() || null;
@@ -115,7 +118,7 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
     deliverToolCompletion: (sessionId, text, meta = {}) =>
       runtime.deliverToolCompletion?.(sessionId, text, meta) === true,
 
-    closeCanonicalSession: (reason = 'canonical-session-close') => closeCanonical(reason),
+    closeCanonicalSession: (reason = 'canonical-session-close', options) => closeCanonical(reason, options),
 
     bindSessionAddress: (sessionId) => runtime.bindSessionAddress?.(sessionId) === true,
 

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

@@ -122,6 +122,8 @@ export function createSessionMediaApi(bag) {
     listMediaLanes: () => runtime.listMediaLanes?.(),
     getMediaDefault: (kind) => runtime.getMediaDefault?.(kind),
     setMediaDefault: (input) => runtime.setMediaDefault?.(input),
+    getMediaPins: () => runtime.getMediaPins?.(),
+    setMediaPin: (input) => runtime.setMediaPin?.(input),
     listMediaAssets: (options) => runtime.listMediaAssets?.(options),
     readMediaAsset: (id, options) => runtime.readMediaAsset?.(id, options),
     cacheMediaThumbnail: (id, input) => runtime.cacheMediaThumbnail?.(id, input),

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

@@ -4,8 +4,7 @@
  * definitions, output style and orchestration mode.
  */
 import { modelSwitchItem } from '../../../runtime/agent/orchestrator/session/transcript-restore/restore.mjs';
-import { selectedModel, switchesSessionModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
-import { latestQuotaFailure } from '../quota-resume.mjs';
+import { selectedModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
 import { createApiHelpers } from './shared.mjs';
 
 // Optimistic route preview: the requested provider/model/effort/fast are
@@ -50,6 +49,36 @@ function optimisticRoutePatch(requested = {}, current = {}) {
   return patch;
 }
 
+const SESSION_ONLY_KEYS = new Set(['provider', 'model', 'effort', 'fast', 'autoEffort']);
+
+/**
+ * A session-only request (an agent child's route) may name just the model, just
+ * the tuning, or both. Completed here, inside the serialized route write,
+ * against the latest selected route — so a Fast-only change keeps the effort a
+ * previous write selected. `unchanged` when it asks for nothing the selected
+ * route does not already have.
+ */
+function completeSessionOnlyRequest(request, selected) {
+  const named = Boolean(request.provider || request.model);
+  const target = named ? request : { ...request, provider: selected.provider, model: selected.model };
+  const sameModel = target.provider === selected.provider && target.model === selected.model;
+  if (!sameModel) return { request: target, unchanged: false };
+  const unchanged =
+    Object.keys(request).every((key) => SESSION_ONLY_KEYS.has(key)) &&
+    (request.effort === undefined || request.effort === selected.effort) &&
+    (request.fast === undefined || request.fast === (selected.fast === true)) &&
+    (request.autoEffort === undefined || request.autoEffort === (selected.autoEffort !== false));
+  return {
+    unchanged,
+    request: {
+      ...(selected.effort ? { effort: selected.effort } : {}),
+      fast: selected.fast === true,
+      autoEffort: selected.autoEffort !== false,
+      ...target,
+    },
+  };
+}
+
 /** The live divider of an in-place model switch (restored from message meta
  *  after a reload); every switch path publishes it the same way. */
 export function publishModelSwitch(bag, modelSwitch) {
@@ -76,6 +105,8 @@ export function createSessionRouteApi(bag) {
   });
   let routeWrite = null;
   let routeSequence = 0;
+  // Whether this API (not another command) is the one holding commandBusy.
+  let routeLocked = false;
 
   // A preset selector previews as the preset's model, never as its id.
   const previewedRequest = (routeOpts) => {
@@ -84,86 +115,79 @@ export function createSessionRouteApi(bag) {
     return target.provider ? { ...routeOpts, ...target } : routeOpts;
   };
 
-  // Auto-compact on model change (default on): compact on the CURRENT model,
-  // whose cache and window still hold the history, before the switch. A model
-  // stopped on its quota cannot run it; the next turn's auto-compaction on the
-  // new model fits the history instead. A failure never blocks the switch.
-  const compactBeforeModelSwitch = async () => {
-    if (runtime.getCompactionSettings?.()?.onModelChange === false) return;
-    if (latestQuotaFailure(getState().items)) return;
-    if (typeof bag.compactBeforeModelSwitch !== 'function') return;
-    set({
-      commandStatus: { active: true, verb: 'Compacting conversation', startedAt: Date.now(), mode: 'compacting' },
-    });
-    flushEmitImmediate();
-    try {
-      await bag.compactBeforeModelSwitch();
-    } catch {
-      /* the switch goes ahead; next-turn auto-compaction fits the window */
-    } finally {
-      set({ commandStatus: null });
-    }
-  };
-
   const setRoute = async (opts) => {
-    if (getState().commandBusy && !routeWrite) return false;
     const routeOpts = opts && typeof opts === 'object' ? opts : {};
-    // Every user model choice on this surface (composer picker, /model,
-    // presets, the TUI picker) switches the conversation itself in place.
-    const switchesModel = switchesSessionModel(runtime, routeOpts);
-    // A running turn keeps the route it started on.
-    if (switchesModel && getState().busy) {
-      throw new Error('The model cannot change while a response is running. Try again when it finishes.');
-    }
-    // Any route change supersedes waiting for the old route's quota reset.
-    bag.supersedeQuotaResume?.(getState().sessionId);
+    // All model pickers save a selection for the conversation's next turn; a
+    // running turn keeps the session model it started on. A selection is never
+    // refused: another command's lock neither blocks it nor is released by it.
     const token = ++routeSequence;
     const previousWrite = routeWrite;
+    // The session generation this selection was made under. The write below
+    // waits behind earlier ones, so "current" is never read later: the runtime
+    // validates this token before every route side effect, and `settle` below
+    // is the only place the display is touched once the write has started.
+    const originGeneration = runtime.sessionGeneration;
+    const owned = () => runtime.sessionGeneration === originGeneration;
     const preview = optimisticRoutePatch(previewedRequest(routeOpts), getState());
     // Preview immediately, serialize persistence without dropping a later
     // click. Earlier completions cannot replace the newest visible choice.
-    // A model switch previews once its pre-compaction (which republishes the
-    // current route) is done.
-    set({ commandBusy: true, ...(switchesModel ? {} : preview || {}) });
+    if (!getState().commandBusy) routeLocked = true;
+    set({ ...(routeLocked ? { commandBusy: true } : {}), ...(preview || {}) });
     flushEmitImmediate();
     const write = (async () => {
       if (previousWrite) await previousWrite.catch(() => {});
       const previousRoute = routeState();
+      // A stale selection only republishes the route that is actually
+      // selected; it never restores or announces its own session's state.
+      const settle = ({ failed = false, sync = false, modelSwitch = null } = {}) => {
+        const stillOwned = owned();
+        if (stillOwned) publishModelSwitch(bag, modelSwitch);
+        // A newer selection publishes the final route itself.
+        if (token !== routeSequence) return;
+        if (stillOwned && failed) {
+          if (preview) set({ ...previousRoute, stats: { ...getState().stats } });
+          return;
+        }
+        if (stillOwned && sync) syncContextStats({ allowEstimated: true });
+        publishRoute();
+      };
       try {
-        // Explicit addressing applies the route to this session: an empty
-        // one is initialized in place. Either way an established
-        // conversation follows the user's choice in place.
+        // Keep the durable session address while deferring route application.
         const applyToCurrentSession = routeOpts.applyToCurrentSession === true;
-        const keepMainModel = routeOpts.keepMainModel === true;
-        const { applyToCurrentSession: _drop, keepMainModel: _keep, ...nextRoute } = routeOpts;
-        if (switchesModel) {
-          // The destination must be accepted before the history is compacted.
-          await runtime.setRoute(nextRoute, { validateOnly: true });
-          await compactBeforeModelSwitch();
-          if (token === routeSequence && preview) {
-            set(preview);
-            flushEmitImmediate();
+        const keepMainModel = routeOpts.keepMainModel !== false;
+        const sessionOnly = routeOpts.sessionOnly === true;
+        const { applyToCurrentSession: _drop, keepMainModel: _keep, sessionOnly: _scope, ...requested } = routeOpts;
+        let nextRoute = requested;
+        if (sessionOnly) {
+          const completed = completeSessionOnlyRequest(requested, previousRoute);
+          if (completed.unchanged) {
+            // An earlier failed write skipped its rollback because this one is
+            // newer, so the shown route may still be that write's preview.
+            settle();
+            return previousRoute;
           }
+          nextRoute = completed.request;
         }
         const resolvedRoute = await runtime.setRoute(nextRoute, {
           applyToCurrentSession,
           keepMainModel,
+          ...(sessionOnly ? { sessionOnly } : {}),
+          ...(originGeneration !== undefined ? { originGeneration } : {}),
           switchEstablished: true,
+          deferUntilNextTurn: true,
+        });
+        settle({
+          sync: applyToCurrentSession || Boolean(resolvedRoute?.modelSwitch),
+          modelSwitch: resolvedRoute?.modelSwitch,
         });
-        if (token === routeSequence) {
-          if (applyToCurrentSession || resolvedRoute?.modelSwitch) syncContextStats({ allowEstimated: true });
-          publishRoute();
-        }
-        publishModelSwitch(bag, resolvedRoute?.modelSwitch);
         return resolvedRoute;
       } catch (error) {
-        if (token === routeSequence && preview) {
-          set({ ...previousRoute, stats: { ...getState().stats } });
-        }
+        settle({ failed: true });
         throw error;
       } finally {
         if (token === routeSequence) {
-          set({ commandBusy: false });
+          if (routeLocked) set({ commandBusy: false });
+          routeLocked = false;
           // Publish the resolved route (or rollback) before an RPC reply
           // reads getState(), even while the display-frame clock is busy.
           flushEmitImmediate();

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

@@ -29,9 +29,9 @@ export function createSessionSettingsApi(bag) {
 
   return {
     // A model selector (/model, a preset) is the user's model choice like any
-    // picker selection: the route surface switches an established
-    // conversation in place (pre-compaction, busy refusal, divider). False
-    // while another command holds the lock.
+    // picker selection: the route surface saves it for the conversation's
+    // next turn (a running turn keeps its model) and applies it there. Never
+    // refused: another command's lock does not block a selection.
     setModel: async (m) => (await bag.setSessionRoute({ model: m })) !== false,
     setEffort: withCommandLock(
       async (value) => {
@@ -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/worktree.mjs

@@ -23,8 +23,7 @@
  *     (expectedRevision: WORKTREE_REVISION_CONFLICT when the session moved on)
  *     (WORKTREE_REMOVAL_INCOMPLETE: partly removed; call again to finish)
  *   listWorktrees()                                → every managed worktree with its retention
- *   pruneWorktrees()                               → reconcile report (never a retained worktree)
- */
+ *   pruneWorktrees()                               → reconcile report (never a retained worktree) */
 import { worktreeError } from '../../../runtime/shared/worktrees/contract.mjs';
 
 /** Session actions of the Lead worktree feature (settings live in settings.mjs). */
@@ -34,6 +33,8 @@ export const SESSION_WORKTREE_ACTIONS = Object.freeze([
   'selectBranch',
   'selectProjectBranch',
   'mergeProjectBranch',
+  'inspectProjectBranch',
+  'manageProjectBranch',
   'requestWorktree',
   'mergeWorkspace',
   'removeWorktree',

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/session-flow/auto-clear.mjs

@@ -196,10 +196,8 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
 
   // Same eligibility as a user submit, run before a completion wake turn so a
   // cold cache after a long idle is compacted first. Never throws: a skipped or
-  // failed auto-clear must still let the wake run. A viewer mirroring another
-  // surface's owner leaves compaction to that owner.
+  // failed auto-clear must still let the wake run.
   async function autoClearBeforeWake() {
-    if (bag.liveShareMirroring?.() === true) return false;
     try {
       return await autoClearBeforeSubmit({ ignorePending: true });
     } catch {

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

@@ -89,6 +89,8 @@ export function turnOptionsForBatch(batch, steering) {
   return {
     promptSource: batchPromptSource(batch),
     retryFailedTurn: batch[0]?.retryFailedTurn === true,
+    retryTurnId: batch[0]?.retryTurnId || null,
+    retryAttemptId: batch[0]?.retryAttemptId || null,
     displayText: batch
       .map((entry) => entry.text)
       .filter((text) => String(text || '').trim())
@@ -148,7 +150,7 @@ export function createDrainLoop(
   // matching message under its own lock).
   function rewindFailedTurnRows(batch) {
     const entry = batch[0];
-    if (entry?.retryFailedTurn !== true) return;
+    if (entry?.retryFailedTurn !== true || entry.retryTurnId) return;
     const rewound = rewoundFailedTurnItems(getState().items, entry.text);
     if (!rewound) return;
     set({
@@ -217,7 +219,7 @@ export function createDrainLoop(
     // 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) {
+    if (flags.autoClearRunning || flags.quotaResumePending || getState().commandBusy) {
       scheduleBlockedDrainRetry();
       return;
     }
@@ -253,7 +255,7 @@ export function createDrainLoop(
         // its pre-compaction, a reset) runs before the next turn starts. The
         // finally below re-enters drain(), which waits on the same gate, and
         // the commandBusy release re-kicks the queue.
-        if (flags.autoClearRunning || getState().commandBusy) return;
+        if (flags.autoClearRunning || flags.quotaResumePending || getState().commandBusy) return;
         // Drain one priority/mode bucket at a time (unified command queue):
         // prompt steering stays editable and task notifications stay
         // non-editable but model-visible.
@@ -331,7 +333,7 @@ export function createDrainLoop(
     submissions.remember(submissionId);
     pending.push(entry);
     const needsDurableSteering =
-      (getState().busy || getState().commandBusy || flags.autoClearRunning) &&
+      (getState().busy || getState().commandBusy || flags.autoClearRunning || flags.quotaResumePending) &&
       steering.shouldMirrorSteeringEntry(entry);
     const persistence = needsDurableSteering ? appendTuiSteeringPersist(steering.leadSessionId(), entry) : null;
     if (isQueuedEntryVisible(entry)) {

package/src/tui/session/session-flow/queue/entry-shape.mjs

@@ -49,5 +49,7 @@ export function makeQueueEntry(text, options = {}, nextId) {
     // Retry of a failed turn: the transcript and the session rewind the
     // failed turn's unanswered prompt before this entry runs.
     retryFailedTurn: options.retryFailedTurn === true,
+    retryTurnId: options.retryTurnId || null,
+    retryAttemptId: options.retryAttemptId || null,
   };
 }

package/src/tui/session/session-flow/queue/take-entries.mjs

@@ -39,10 +39,11 @@ export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQ
         (entry.mode || 'prompt') === targetMode &&
         queuePriorityValue(entry.priority) === bestPriority
       ) {
+        if (batch.length > 0 && entry.retryTurnId) break;
         batch.push(entry);
         pending.splice(i, 1);
         if (entry.mode === 'task-notification' && entry.key) pendingNotificationKeys.delete(entry.key);
-        if (batch.length >= limit) break;
+        if (entry.retryTurnId || batch.length >= limit) break;
       } else {
         i += 1;
       }

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

@@ -14,7 +14,7 @@ import { createTakeEntriesOps } from './queue/take-entries.mjs';
 
 // Submission-id memory for idempotent re-delivery. A prompt can legitimately
 // reach this queue TWICE when its transport retries across a failed response
-// (daemon view retry, live-share spool fallback after a missing ack). The id
+// (daemon view retry after a missing ack). The id
 // the surface minted is the identity of the message, so a repeat of an id we
 // already queued is dropped instead of posting the prompt twice.
 const SUBMISSION_ID_MEMORY = 256;

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

@@ -12,24 +12,33 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
 
   function normalizeToolApprovalRequest(input = {}, id = nextId()) {
     const now = Date.now();
+    // An explicit `timeoutMs: null` means no wait limit (no timer, no expiry);
+    // any other missing/invalid value falls back to the session default.
+    const requestTimeoutMs =
+      input?.timeoutMs === null
+        ? null
+        : 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: requestTimeoutMs === null ? null : now + requestTimeoutMs,
     };
   }
   // Every request expires from ITS OWN requestedAt, queued or active. Arming
   // the timer only on presentation let a queued request sit past expiresAt
   // (retaining its promise and surfacing an obsolete approval later).
   function armToolApprovalTimeout(entry) {
-    if (!entry || entry.timer) return;
+    if (!entry || entry.timer || entry.request?.expiresAt === null) return;
     const remainingMs = Math.max(0, Number(entry.request?.expiresAt || 0) - Date.now());
     entry.timer = setTimeout(() => {
       finishToolApproval(entry.id, false, 'approval timed out');
@@ -39,10 +48,13 @@ 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, reply) {
     if (entry?.timer) clearTimeout(entry.timer);
+    const result = { approved, reason };
+    if (answers !== undefined) result.answers = answers;
+    if (reply !== undefined) result.reply = reply;
     try {
-      entry.resolve({ approved, reason });
+      entry.resolve(result);
     } catch {}
   }
   function presentNextToolApproval() {
@@ -56,7 +68,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, reply = undefined) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
@@ -67,14 +79,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, reply);
       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, reply);
       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/transcript-store/streaming-tail.mjs

@@ -4,7 +4,7 @@
  * that lets a host prove a longer text is an append of the same stream.
  */
 // Non-enumerable so the marker never enters persisted transcript items,
-// live-share JSON, or renderer snapshots. The desktop host reads the shared
+// wire JSON, or renderer snapshots. The desktop host reads the shared
 // Symbol.for key before cloning and uses it to prove that a growing text is
 // an append, avoiding an O(total text) startsWith check on every frame.
 const streamingTailTextEpochKey = Symbol.for('mixdog.streaming-tail-text-epoch');

package/src/tui/session/tui-steering-persist.mjs

@@ -99,11 +99,9 @@ function normalizePendingStore(raw) {
       // FOREIGN bucket. This file is SHARED with the runtime/manager pending
       // -message spool, and every TUI write passes the whole store through
       // here. Flattening those rows to plain strings destroyed id,
-      // enqueuedAt, options, structured content, the notification markers —
-      // and the handoffAt/handoffPid parking stamp that is the only reason an
-      // accepted-but-undelivered user message survives an owner crash. Rows
-      // this process does not own are copied through UNCHANGED (array copy
-      // only, so nothing here can alias-mutate them either).
+      // enqueuedAt, options, structured content and the notification markers.
+      // Rows this process does not own are copied through UNCHANGED (array
+      // copy only, so nothing here can alias-mutate them either).
       out.sessions[sid] = value.slice();
       const foreignTouched = Number(touchedRaw[sid]);
       // Carry an existing stamp only: inventing one would reset the runtime's

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

@@ -0,0 +1,53 @@
+// The lead turn's quiet-time cue: polls the runtime's turn liveness while the
+// turn runs and publishes `spinner.quiet` ({ since, wait, tool?, warnMs })
+// once the turn has gone QUIET_PROGRESS_CUE_MS without counted progress, and
+// clears it when progress resumes. The value is frozen for a whole silence, so
+// a silence costs two publications, never one per tick. Display only.
+import { displayProgressStage, quietProgress, lastProgressAt } from '../../runtime/shared/quiet-progress.mjs';
+import { resolveAgentStallThresholds } from '../../runtime/agent/orchestrator/stall-policy.mjs';
+
+const QUIET_POLL_MS = 1_000;
+
+/** The lead's stall-watchdog warn point, in ms. */
+export function leadStallWarnMs() {
+  return resolveAgentStallThresholds('lead').warn * 1000;
+}
+
+function sameQuiet(left, right) {
+  if (!left || !right) return !left && !right;
+  return left.since === right.since && left.wait === right.wait && left.tool === right.tool;
+}
+
+/** The quiet state a liveness snapshot implies at `now` (null: not quiet). */
+export function turnQuietState(liveness, now, warnMs) {
+  if (!liveness || typeof liveness !== 'object' || typeof liveness.then === 'function') return null;
+  const quiet = quietProgress({
+    progressAt: lastProgressAt(liveness),
+    stage: displayProgressStage(liveness),
+    tool: liveness.currentTool,
+    now,
+  });
+  return quiet ? { ...quiet, warnMs } : null;
+}
+
+export function startQuietWatch({ runtime, getState, set, isCurrentTurn, warnMs = leadStallWarnMs() }) {
+  const timer = setInterval(() => {
+    if (!isCurrentTurn()) {
+      clearInterval(timer);
+      return;
+    }
+    const spinner = getState().spinner;
+    if (!spinner) return;
+    let liveness = null;
+    try {
+      liveness = runtime?.getTurnLiveness?.() ?? null;
+    } catch {
+      return;
+    }
+    const next = turnQuietState(liveness, Date.now(), warnMs);
+    if (sameQuiet(spinner.quiet ?? null, next)) return;
+    set({ spinner: { ...spinner, quiet: next } });
+  }, QUIET_POLL_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}