mixdog 1.2.3 → 1.2.5

package/src/standalone/session-service/entries/session-loads.mjs

@@ -6,6 +6,7 @@
 // converge on one runtime.
 
 export function createSessionLoads({
+  pendingViewers,
   sessionExists,
   log,
   assertAvailable,
@@ -20,12 +21,21 @@ export function createSessionLoads({
   const sessionLoads = new Map(); // sessionId -> Promise<entry>
 
   function getOrCreateSessionEntry(sessionId, create) {
-    const owner = sessionOwner(sessionId);
-    if (owner) return Promise.resolve(owner);
     const inFlight = sessionLoads.get(sessionId);
     if (inFlight) return inFlight;
     const loading = Promise.resolve()
-      .then(create)
+      .then(async () => {
+        const owner = sessionOwner(sessionId);
+        if (owner) {
+          if ((await owner.runtime.isSessionTerminal?.()) !== true) return owner;
+          if (owner.subscribers?.size) {
+            if (!pendingViewers.has(sessionId)) pendingViewers.set(sessionId, new Set());
+            for (const subscriber of owner.subscribers) pendingViewers.get(sessionId).add(subscriber);
+          }
+          await destroy(owner, 'replace terminal runtime', { keepBackgroundWork: true, announce: false });
+        }
+        return create();
+      })
       .finally(() => {
         if (sessionLoads.get(sessionId) === loading) sessionLoads.delete(sessionId);
       });
@@ -84,11 +94,12 @@ export function createSessionLoads({
    *  flight), or null where answering would take a fresh load. */
   async function hostedEntryForSession(sessionId) {
     assertAvailable();
+    if (sessionLoads.has(sessionId)) return sessionLoads.get(sessionId);
     const owner = sessionOwner(sessionId);
-    if (owner) return owner;
+    if (owner) return (await owner.runtime.isSessionTerminal?.()) === true ? null : owner;
     const external = await bindExternalSessionView(sessionId);
     const acquiredOwner = sessionOwner(sessionId);
-    if (acquiredOwner) return acquiredOwner;
+    if (acquiredOwner) return (await acquiredOwner.runtime.isSessionTerminal?.()) === true ? null : acquiredOwner;
     if (external?.runtime?.externalAction === true) return external;
     return sessionLoads.get(sessionId) || null;
   }

package/src/standalone/session-service/entries.mjs

@@ -70,6 +70,7 @@ export function createSessionEntries({
     publishExternalSessionState,
   });
   const loads = createSessionLoads({
+    pendingViewers,
     sessionExists,
     log,
     assertAvailable: lifecycle.assertAvailable,

package/src/standalone/session-service/projection/transcript-window.mjs

@@ -386,3 +386,42 @@ export async function loadLiveTranscriptHead(entry, sessionId, readStoredSession
   view.headOlder = from > 0 || stored.transcriptHasOlder === true;
   return true;
 }
+
+/** A one-shot range must not grow or rebudget an attached desktop's window. */
+export async function readTranscriptRange(entry, sessionId, readStoredSession, { offset, limit }) {
+  if (
+    !Number.isSafeInteger(offset) ||
+    offset < 0 ||
+    !Number.isInteger(limit) ||
+    limit < 1 ||
+    limit > 100 ||
+    !Number.isSafeInteger(offset + limit)
+  )
+    throw new TypeError('invalid transcript range');
+  const requested = offset + limit;
+  let snapshot;
+  if (entry) {
+    const state = entry.runtime.getState();
+    const isolated = { runtime: { getState: () => state } };
+    requestLiveTranscriptWindow(isolated, { limit: requested, byteBudget: null, pageBase: 0 });
+    windowTranscriptSnapshot(isolated, state);
+    isolated.transcriptView.paged = true;
+    await loadLiveTranscriptHead(isolated, sessionId, readStoredSession);
+    snapshot = windowTranscriptSnapshot(isolated, state);
+  } else {
+    snapshot = await readStoredSession(sessionId, { transcriptItemLimit: requested });
+  }
+  if (!snapshot) throw new Error(`session ${sessionId} is not available`);
+  const source = snapshot.items || [];
+  if (offset >= source.length && snapshot.transcriptHasOlder) {
+    throw new Error('session: requested history is not available in the retained projection');
+  }
+  const end = Math.max(0, source.length - offset);
+  const start = Math.max(0, end - limit);
+  return {
+    sessionId,
+    offset,
+    items: sanitizeForWire(source.slice(start, end)),
+    hasOlder: start > 0 || snapshot.transcriptHasOlder === true,
+  };
+}

package/src/standalone/session-service/quota-resume.mjs

@@ -8,8 +8,6 @@
 // again, and the session's own lane runs the retry under the entry's
 // generation. Overdue entries run as soon as the scheduler starts.
 
-import { isAgentOnlySession } from '../../runtime/shared/quota-resume-store.mjs';
-
 /** A still-exhausted reading is re-taken once, this much later. */
 export const QUOTA_RESUME_RETRY_MS = 5 * 60_000;
 /** A busy session is re-checked this much later, without spending an attempt. */
@@ -32,19 +30,33 @@ async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsabl
     return 'unavailable';
   }
   if (!isCurrent(store, entry)) return 'cancelled';
-  // A delegated agent child never owns a resume (the Lead decides retries), so
-  // an entry persisted for one never fires, whatever wrote it.
-  if (isAgentOnlySession({ id: sessionId, ...runtime?.session })) {
-    store.cancelQuotaResumeEntry(sessionId, { generation });
-    return 'agent-session';
-  }
   let usable = false;
+  const currentRoute = () => {
+    const snapshot = runtime.getState?.() ?? {};
+    return {
+      // The selected route is what the next turn runs on; sessionProvider /
+      // sessionModel still hold the previous turn's after a deferred selection.
+      provider: snapshot.provider || snapshot.sessionProvider || runtime.session?.provider || entry.provider,
+      model: snapshot.model || snapshot.sessionModel || runtime.session?.model || entry.model,
+    };
+  };
+  const { provider, model } = currentRoute();
   try {
-    usable = await readQuotaUsable(entry.provider, entry.model);
+    usable = await readQuotaUsable(provider, model);
   } catch (error) {
-    log(`quota resume usage reading failed provider=${entry.provider}: ${error?.message || error}`);
+    log(`quota resume usage reading failed provider=${provider}: ${error?.message || error}`);
   }
   if (!isCurrent(store, entry)) return 'cancelled';
+  const selected = currentRoute();
+  if (selected.provider !== provider || selected.model !== model) {
+    // The reading belongs to the old route. Preserve the reservation and
+    // check the selected route on the normal busy-recheck cadence.
+    store.deferQuotaResumeEntry(sessionId, generation, {
+      resetAt: now() + QUOTA_RESUME_BUSY_RECHECK_MS,
+      attempts: entry.attempts,
+    });
+    return 'route-changed';
+  }
   if (!usable) {
     // One more reading five minutes on; after that the session falls back
     // to the user's own choice.
@@ -59,8 +71,8 @@ async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsabl
     return 'exhausted';
   }
   const outcome =
-    typeof runtime?.fireQuotaResume === 'function' ? runtime.fireQuotaResume({ generation }) : 'unsupported';
-  if (outcome === 'busy') {
+    typeof runtime?.fireQuotaResume === 'function' ? await runtime.fireQuotaResume({ generation }) : 'unsupported';
+  if (outcome === 'busy' || outcome === 'rejected') {
     store.deferQuotaResumeEntry(sessionId, generation, {
       resetAt: now() + QUOTA_RESUME_BUSY_RECHECK_MS,
       attempts: entry.attempts,
@@ -117,7 +129,10 @@ export function createQuotaResumeScheduler({
           log(`quota resume session=${entry.sessionId} outcome=${outcome}`);
         } catch (error) {
           log(`quota resume failed session=${entry.sessionId}: ${error?.message || error}`);
-          store.cancelQuotaResumeEntry(entry.sessionId, { generation: entry.generation });
+          store.deferQuotaResumeEntry(entry.sessionId, entry.generation, {
+            resetAt: now() + QUOTA_RESUME_RETRY_MS,
+            attempts: entry.attempts,
+          });
         }
       }
     })().finally(() => {

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -5,6 +5,7 @@
 // ./goal-recovery.mjs.
 import { createGoalRecovery } from './goal-recovery.mjs';
 import {
+  attachmentsForIntake,
   materializePromptSubmission,
   preparePromptSubmissionForProvider,
 } from '../../../runtime/attachments/store.mjs';
@@ -52,18 +53,28 @@ export function createSessionTurnCalls(ctx) {
     const entry = await entryForSession(id, openHints || {});
     const target = entry.runtime.submitAsync;
     if (typeof target !== 'function') throw new TypeError('session runtime must implement submitAsync');
-    const intake = await preparePromptSubmissionForProvider(
-      materializePromptSubmission(prompt, options || {}),
-      { nativePdf: providerNativePdf(entry.runtime.provider || entry.runtime.session?.provider || '') }
-    );
+    const intake = await preparePromptSubmissionForProvider(materializePromptSubmission(prompt, options || {}), {
+      nativePdf: providerNativePdf(entry.runtime.provider || entry.runtime.session?.provider || ''),
+    });
     // Await intake only: submitAsync resolves once the prompt is represented by
     // the queue/user row, while provider execution remains daemon-owned and
     // detached.
     let submissionOptions = intake.options;
-    if (entry.runtime.externalAction === true) {
+    // Every send (desktop or paired device) reaches the engine here: the
+    // message records its attachments by content hash, so any device can open
+    // or download them by id later (and the store's census keeps the blobs).
+    const attachments = attachmentsForIntake(intake.prompt, intake.options);
+    if (attachments.length || entry.runtime.externalAction === true) {
       const transcriptMeta = intake.options?.transcriptMeta;
       const baseMeta = transcriptMeta && typeof transcriptMeta === 'object' ? transcriptMeta : {};
-      submissionOptions = { ...intake.options, transcriptMeta: { ...baseMeta, sender: 'user' } };
+      submissionOptions = {
+        ...intake.options,
+        transcriptMeta: {
+          ...baseMeta,
+          ...(attachments.length ? { attachments } : {}),
+          ...(entry.runtime.externalAction === true ? { sender: 'user' } : {}),
+        },
+      };
     }
     const accepted = await Promise.resolve(target.call(entry.runtime, intake.prompt, submissionOptions));
     if (accepted === true) {

package/src/standalone/session-service/session-calls/session-views.mjs

@@ -6,6 +6,7 @@ import { SESSION_READ_ACTION_SET } from '../../session-protocol.mjs';
 import { SESSION_ID_PATTERN } from '../agent-tree.mjs';
 import {
   loadLiveTranscriptHead,
+  readTranscriptRange,
   rebudgetTranscriptWindow,
   requestedHeldTranscript,
   requestedTranscriptWindow,
@@ -132,6 +133,11 @@ export function createSessionViewCalls(ctx) {
     if (!id) throw new TypeError('sessionId is required');
     const live = await liveEntryFor(id);
     assertAvailable(live);
+    if (params.transcriptRange) {
+      const range = await readTranscriptRange(live, id, readStoredSession, params.transcriptRange);
+      assertAvailable(live);
+      return { range };
+    }
     if (live) {
       return liveSessionReadResult(live, params, id, baseRevision);
     }

package/src/standalone/session-tool-output.mjs

@@ -0,0 +1,82 @@
+import { encodeCatalogCursor } from '../runtime/agent/orchestrator/session/catalog-db/schema.mjs';
+import { truncateToolText } from '../runtime/shared/tool-primitives.mjs';
+import { summarizeToolResult } from '../runtime/shared/tool-result-summary.mjs';
+
+import { TOOL_OUTPUT_PAGE_BYTES, TOOL_OUTPUT_TAIL_BYTES } from '../runtime/shared/tool-output-budget.mjs';
+
+export const SESSION_TOOL_OUTPUT_BYTES = TOOL_OUTPUT_TAIL_BYTES;
+const MESSAGE_TEXT_LIMIT = 2000;
+const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
+
+/** Keep catalog paging authoritative even when the output budget shortens a page. */
+export function sessionListOutput(page, limit) {
+  const raw = page.sessions;
+  const sessions = raw.slice(0, limit).map((row) => ({
+    id: row.id,
+    ...(row.title || row.preview ? { title: truncateToolText(row.title || row.preview, 160) } : {}),
+    ...(row.status ? { status: row.status } : {}),
+    ...(row.cwd ? { cwd: row.cwd } : {}),
+  }));
+  const result = { sessions, nextCursor: page.nextCursor ?? null };
+  for (;;) {
+    if (sessions.length < raw.length && sessions.length) {
+      result.nextCursor = encodeCatalogCursor(raw[sessions.length - 1]);
+    }
+    if (outputBytes(result) <= TOOL_OUTPUT_PAGE_BYTES) return result;
+    if (sessions.length <= 1) throw new Error('session: one catalog row exceeds the output budget');
+    sessions.pop();
+  }
+}
+
+function conversationItem(item, offset, textOffset) {
+  const row = { kind: item.kind, offset, ...(item.id != null ? { id: item.id } : {}) };
+  if (item.name) row.name = item.name;
+  if (item.status) row.status = item.status;
+  if (item.isError === true) row.isError = true;
+  let text = item.text || item.detail || item.label || '';
+  if (item.kind === 'tool') {
+    const value = item.rawResult ?? item.result ?? '';
+    const raw = typeof value === 'string' ? value : JSON.stringify(value);
+    text = raw || summarizeToolResult(item.name, item.args, raw, item.isError === true) || text;
+  }
+  if (text) {
+    // Conversation indentation is significant; do not trim code/prose like a title.
+    if (
+      textOffset > 0 &&
+      /[\uDC00-\uDFFF]/.test(text[textOffset] || '') &&
+      /[\uD800-\uDBFF]/.test(text[textOffset - 1])
+    )
+      throw new Error('session: text_offset splits a surrogate pair');
+    let end = Math.min(text.length, textOffset + MESSAGE_TEXT_LIMIT);
+    if (end < text.length && /[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+    row.text = text.slice(textOffset, end);
+    if (end < text.length) row.nextTextOffset = end;
+  }
+  const attachments = item.attachments ?? item.imageRefs ?? item.images;
+  if (attachments?.length) row.attachments = attachments.length;
+  return row;
+}
+
+/** Service windows can be sticky/shared; enforce this tool call's limits locally. */
+export function sessionReadOutput(sessionId, range, { textOffset = 0, itemId } = {}) {
+  const byteLimit = range.offset === 0 && textOffset === 0 ? TOOL_OUTPUT_TAIL_BYTES : TOOL_OUTPUT_PAGE_BYTES;
+  const source = range.items;
+  if (itemId !== undefined && (source.length !== 1 || source[0].id !== itemId)) {
+    throw new Error('session: stale item position; read the tail again');
+  }
+  const items = source.map((item, index) =>
+    conversationItem(item, range.offset + source.length - index - 1, textOffset)
+  );
+  const result = {
+    sessionId,
+    offset: range.offset,
+    items,
+    nextOffset: null,
+  };
+  for (;;) {
+    result.nextOffset = range.hasOlder || items.length < source.length ? range.offset + items.length : null;
+    if (outputBytes(result) <= byteLimit) return result;
+    if (items.length <= 1) throw new Error('session: one transcript item exceeds the output budget');
+    items.shift();
+  }
+}

package/src/tui/app/app-view.jsx

@@ -138,6 +138,7 @@ export function renderAppView(ctx) {
       thinkingActiveSince={liveSpinner?.thinkingSegmentStartedAt ?? 0}
       thinkingMs={liveSpinner?.thinkingAccumulatedMs ?? 0}
       effort={state.effort || ''}
+      quiet={liveSpinner?.quiet ?? null}
       hasActiveTools={!!activeTools?.web_search?.count}
       paused={!!toolApproval}
       interruptible={!!(state.busy && state.spinner?.active)}
@@ -230,7 +231,7 @@ export function renderAppView(ctx) {
         ) : null}
         <StatusLine
           sessionId={state.sessionId}
-          clientHostPid={state.ownerClientHostPid || state.clientHostPid}
+          clientHostPid={state.clientHostPid}
           provider={state.provider}
           model={state.model}
           effort={state.effort}

package/src/tui/app/provider-setup/provider-items.mjs

@@ -77,6 +77,14 @@ export function buildProviderItems(setup) {
       _authenticated: p.authenticated,
     });
   }
+  if (setup.managedByClient === true) {
+    for (const p of setup.local || []) {
+      providerItems.push({
+        value: `local:${p.id}`, label: p.name, meta: providerStatusLabel(p), description: '',
+        _type: 'local', _providerId: p.id, _providerName: p.name, _provider: p,
+      });
+    }
+  }
   providerItems.sort((a, b) => {
     const rank = providerItemRank(a) - providerItemRank(b);
     if (rank !== 0) return rank;

package/src/tui/app/provider-setup-picker.mjs

@@ -54,7 +54,7 @@ export function createProviderSetupPicker({
     });
     try {
       await new Promise((resolve) => setTimeout(resolve, 0));
-      return await store.getProviderSetup();
+      return await store.getProviderSetup(options.forceRefresh ? { force: true } : undefined);
     } catch (e) {
       store.pushNotice(`providers failed: ${e?.message || e}`, 'error');
       return null;
@@ -98,6 +98,9 @@ export function createProviderSetupPicker({
       });
     }
     items.push(...buildProviderItems(setup));
+    if (setup.managedByClient === true) {
+      items.push({ value: 'refresh-client-providers', label: 'Refresh', _type: 'refresh-client-providers' });
+    }
 
     const flow = {
       store,
@@ -127,10 +130,13 @@ export function createProviderSetupPicker({
 
     flow.paint({
       title: options.title || 'Providers',
-      description: options.description || 'Choose a provider. Enter opens provider actions.',
+      description: setup.managedByClient === true
+        ? 'Manage provider sign-ins and accounts in the local desktop window. Refresh to update availability.'
+        : options.description || 'Choose a provider. Enter opens provider actions.',
       footer: providerFooter,
       footerGapRows: 1,
-      help: options.confirmBar ? undefined : '↑/↓ Select · Enter Open · Esc Back',
+      help: options.confirmBar ? undefined : setup.managedByClient === true
+        ? '↑/↓ Select · Enter Refresh · Esc Back' : '↑/↓ Select · Enter Open · Esc Back',
       indexMode: 'always',
       labelWidth: 18,
       metaWidth: 12,
@@ -142,6 +148,12 @@ export function createProviderSetupPicker({
         if (item?._providerId) flow.rememberProviderSelection(item);
       },
       onSelect: (_value, item) => {
+        if (setup.managedByClient === true && item._type !== 'continue') {
+          if (item._type === 'refresh-client-providers') {
+            void openProviderSetupPicker({ ...options, preloadedSetup: null, forceRefresh: true });
+          }
+          return;
+        }
         // In-flow navigation (Enter on a provider row): the flow keeps the
         // surface, so clear-and-continue — own.close() would supersede this
         // very flow and paintProviders would then reject the action panel the

package/src/tui/app/slash-commands.mjs

@@ -35,6 +35,12 @@ export const SLASH_COMMANDS = [
   },
   { name: 'resume', usage: '/resume', params: '[id]', description: 'Resume a saved chat' },
   { name: 'context', usage: '/context', description: 'Show current context surface' },
+  {
+    name: 'shells',
+    usage: '/shells',
+    params: '[release <task_id> [--confirm]]',
+    description: 'List shells; release one whose termination is unconfirmed',
+  },
   {
     name: 'fork',
     usage: '/fork',

package/src/tui/app/slash-dispatch/session-commands.mjs

@@ -119,6 +119,55 @@ export const sessionCommands = {
     return true;
   },
 
+  // /shells — this session's shells, each marked running or "termination
+  // unconfirmed". `/shells release <id>` explains what releasing means and
+  // asks for `--confirm`; only then is the workspace hold dropped.
+  shells(ctx, arg) {
+    const { store } = ctx;
+    const [action, taskId, flag] = String(arg || '')
+      .trim()
+      .split(/\s+/)
+      .filter(Boolean);
+    if (!action) {
+      void Promise.resolve(store.listShellJobs?.())
+        .then((result) => {
+          const jobs = Array.isArray(result?.jobs) ? result.jobs : [];
+          if (!jobs.length) {
+            store.pushNotice('No shells are running.', 'info');
+            return;
+          }
+          const lines = jobs.map(
+            (job) =>
+              `${job.taskId}  ${job.terminationUnconfirmed ? 'termination unconfirmed' : 'running'}  ${job.command}`
+          );
+          const held = jobs.some((job) => job.terminationUnconfirmed);
+          if (held) lines.push('Release a held shell with /shells release <task_id>.');
+          store.pushNotice(lines.join('\n'), held ? 'warn' : 'info');
+        })
+        .catch((error) => store.pushNotice(`Couldn’t list shells: ${error?.message || error}`, 'error'));
+      return true;
+    }
+    if (action !== 'release' || !taskId) {
+      store.pushNotice('usage: /shells [release <task_id> [--confirm]]', 'warn');
+      return true;
+    }
+    if (flag !== '--confirm') {
+      store.pushNotice(
+        `Releasing ${taskId} unlocks its folder although its processes may still be running. To proceed, run /shells release ${taskId} --confirm`,
+        'warn'
+      );
+      return true;
+    }
+    void Promise.resolve(store.releaseShellJob?.(taskId))
+      .then((result) =>
+        result?.released
+          ? store.pushNotice(`Released ${taskId}.`, 'info')
+          : store.pushNotice(`Couldn’t release ${taskId}: ${result?.error || 'unavailable'}`, 'warn')
+      )
+      .catch((error) => store.pushNotice(`Couldn’t release ${taskId}: ${error?.message || error}`, 'error'));
+    return true;
+  },
+
   doctor(ctx) {
     const { state, store, deps } = ctx;
     if (state.commandBusy) {

package/src/tui/components/Spinner.jsx

@@ -66,6 +66,8 @@ export function Spinner({
   thinkingActiveSince = 0,
   thinkingMs = 0,
   effort = '',
+  // The turn's quiet state (`spinner.quiet`), shown as the quiet-time cue.
+  quiet = null,
   hasActiveTools = false,
   paused = false,
   interruptible = false,
@@ -126,6 +128,8 @@ export function Spinner({
         thinkingActiveSince={thinkingActiveSince}
         thinkingMs={thinkingMs}
         effort={effort}
+        quiet={quiet}
+        now={now}
         interruptible={interruptible}
         columns={columns}
         reducedMotion={reducedMotion}

package/src/tui/components/SpinnerByline.jsx

@@ -20,6 +20,7 @@ const THINKING_DELAY_MS = 3000;
 // One-way shimmer. The tail runs past the final character before restarting.
 const GLIMMER_SPEED_MS = {
   requesting: 70,
+  'model-thinking': 70,
   reconnecting: 70,
   compacting: 120,
   'auto-clear': 120,
@@ -91,7 +92,9 @@ function tokenModeGlyph(mode) {
     case 'responding':
     case 'thinking':
       return DOWN_ARROW;
+    // The request is sent and nothing has come back yet.
     case 'requesting':
+    case 'model-thinking':
       return UP_ARROW;
     default:
       return '';
@@ -108,6 +111,8 @@ export function SpinnerByline({
   thinkingActiveSince,
   thinkingMs,
   effort,
+  quiet = null,
+  now = Date.now(),
   interruptible,
   columns,
   reducedMotion,
@@ -151,6 +156,8 @@ export function SpinnerByline({
     thinkingSince: thinkingActiveSince,
     thinkingMs,
     effort,
+    quiet,
+    now,
   });
   const tokenGlyph = tokenModeGlyph(mode);
   let tokenText = '';
@@ -176,8 +183,13 @@ export function SpinnerByline({
   const interruptW = interruptText.length;
   const showInterrupt = Boolean(interruptText) && avail > interruptW;
   const usedAfterInterrupt = showInterrupt ? interruptW + SEP_WIDTH : 0;
-  const showThinkingStatus = Boolean(thinkingStatusText) && avail > usedAfterInterrupt + thinkingStatusW;
-  const usedAfterThinking = usedAfterInterrupt + (showThinkingStatus ? thinkingStatusW + SEP_WIDTH : 0);
+  // A quiet turn says so before any other stat: it is the one that explains a
+  // long silence (the interrupt hint beside it is how to stop it).
+  const quietText = meta.quietText;
+  const showQuiet = Boolean(quietText) && avail > usedAfterInterrupt + quietText.length;
+  const usedAfterQuiet = usedAfterInterrupt + (showQuiet ? quietText.length + SEP_WIDTH : 0);
+  const showThinkingStatus = Boolean(thinkingStatusText) && avail > usedAfterQuiet + thinkingStatusW;
+  const usedAfterThinking = usedAfterQuiet + (showThinkingStatus ? thinkingStatusW + SEP_WIDTH : 0);
   const showTimer = Boolean(timerLabel) && avail > usedAfterThinking + timerW;
   const usedAfterTimer = usedAfterThinking + (showTimer ? timerW + SEP_WIDTH : 0);
   const showTokens = wantsTokens && tokenText && avail > usedAfterTimer + tokenW;
@@ -223,6 +235,13 @@ export function SpinnerByline({
       )
     );
   }
+  if (showQuiet) {
+    segments.push(
+      <Text key="quiet" color={meta.quietParts?.escalated ? theme.warning : theme.statusSubtle}>
+        {quietText}
+      </Text>
+    );
+  }
   if (showInterrupt) {
     segments.push(
       <Text key="interrupt" color={theme.statusSubtle}>

package/src/tui/components/status-line/local-line.mjs

@@ -10,7 +10,7 @@ import { normalizeStatuslineAnsi } from '../../statusline-ansi-bridge.mjs';
 // Cache-only synchronous read (never touches fs on the render path), so the
 // instant-local L2 can render the Shell segment itself instead of grafting it
 // out of the previous full line.
-import { shellJobsStatus } from '../../../runtime/shared/statusline/statusline-segments.mjs';
+import { shellJobsStatus, unconfirmedShellCount } from '../../../runtime/shared/statusline/statusline-segments.mjs';
 import { formatElapsed, num, terminalColumns, timeMs } from '../../../runtime/shared/statusline/statusline-format.mjs';
 import { isTerminalStatus } from './boot-schedule.mjs';
 
@@ -137,11 +137,19 @@ export function localStatusLineL2(
   const shellStatus = shellScope
     ? shellJobsStatus({ clientHostPid, sessionId: shellScope })
     : shellJobsStatus({ clientHostPid });
-  const shellCount = Number(shellStatus?.count) || 0;
+  // A shell whose termination is unconfirmed is not "running": it is held,
+  // with /shells as the way to inspect or release it.
+  const unconfirmed = unconfirmedShellCount(shellStatus);
+  const shellCount = (Number(shellStatus?.count) || 0) - unconfirmed;
   if (shellCount > 0) {
     const label = `Running ${shellCount} Shell${shellCount === 1 ? '' : 's'}`;
     l2Parts.push(`${spin} ${STATUS}${label}${RESET}${elapsedSuffix(shellStatus.elapsedLabel || '')}`);
   }
+  if (unconfirmed > 0) {
+    const { WARNING } = statusColors();
+    const label = `⚠ ${unconfirmed} Shell${unconfirmed === 1 ? '' : 's'} termination unconfirmed`;
+    l2Parts.push(`${WARNING}${label}${RESET} ${SUBTLE}·${RESET} /shells`);
+  }
   // `web_search` is the key the producers publish (session/active-tool-summary
   // and app/use-transcript-activity); the async full render reads the same key,
   // so both paths light the segment on the same snapshot.