mixdog 0.9.55 → 0.9.59

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

@@ -7,10 +7,313 @@ import { toolResultText } from './tool-result-text.mjs';
 import { parseSyntheticAgentMessage } from './agent-envelope.mjs';
 import { flushTuiSteeringPersist } from './tui-steering-persist.mjs';
 import { getVoiceStatus, toggleVoice } from '../lib/voice-setup.mjs';
+import { aggregateToolCategoryEntry, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
+import { aggregateBucketForCategory, aggregateRawResult, failureDetailText, shellCommandExitCode } from './tool-result-status.mjs';
+
+export function restoredTranscriptMetadata(message) {
+  const value = message?.meta?.transcript;
+  if (!value || typeof value !== 'object') return {};
+  const completionValue = value.completion && typeof value.completion === 'object'
+    ? value.completion
+    : null;
+  const completionStatus = typeof completionValue?.status === 'string'
+    ? completionValue.status
+    : '';
+  const completionElapsedMs = Number(completionValue?.elapsedMs);
+  const completion = completionValue && completionStatus && Number.isFinite(completionElapsedMs)
+    ? {
+        status: completionStatus,
+        elapsedMs: Math.max(0, completionElapsedMs),
+        ...(typeof completionValue.verb === 'string' && completionValue.verb
+          ? { verb: completionValue.verb }
+          : {}),
+      }
+    : null;
+  return {
+    ...(Number.isFinite(Number(value.at)) ? { at: Number(value.at) } : {}),
+    ...(typeof value.model === 'string' && value.model ? { model: value.model } : {}),
+    ...(typeof value.provider === 'string' && value.provider ? { provider: value.provider } : {}),
+    ...(typeof value.agent === 'string' && value.agent ? { agent: value.agent } : {}),
+    ...(completion ? { completion } : {}),
+  };
+}
+
+export function restoredAssistantTranscriptItems(message, nextId) {
+  const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)).trim();
+  if (!text) return [];
+  const { completion, ...metadata } = restoredTranscriptMetadata(message);
+  const items = [{ kind: 'assistant', id: nextId(), text, ...metadata }];
+  if (completion) {
+    items.push({
+      kind: 'turndone',
+      id: nextId(),
+      ...completion,
+      ...(metadata.at ? { at: metadata.at } : {}),
+    });
+  }
+  return items;
+}
+
+// Restored tool cards: stored assistant messages keep their (compacted)
+// tool_calls and the follow-up role:'tool' results, but resume used to drop
+// both — a reopened session lost every tool marker (user bug). Rebuild one
+// transcript tool item per call and attach its result by tool_call_id.
+export function restoredToolCallItems(message, nextId, pendingByCallId) {
+  const calls = Array.isArray(message?.tool_calls) ? message.tool_calls
+    : Array.isArray(message?.toolCalls) ? message.toolCalls : [];
+  const at = Number(message?.meta?.transcript?.at);
+  const items = [];
+  for (const call of calls) {
+    const name = String(call?.function?.name || call?.name || 'tool').trim() || 'tool';
+    let args = call?.function?.arguments ?? call?.arguments;
+    if (typeof args === 'string') {
+      try { args = JSON.parse(args); } catch { /* keep the raw string args */ }
+    }
+    const item = {
+      kind: 'tool',
+      id: nextId(),
+      name,
+      ...(args !== undefined && args !== '' ? { args } : {}),
+      expanded: false,
+      count: 1,
+      completedCount: 1,
+      ...(Number.isFinite(at) ? { at, startedAt: at, completedAt: at } : {}),
+    };
+    const callId = typeof call?.id === 'string' ? call.id : '';
+    if (callId) pendingByCallId.set(callId, item);
+    items.push(item);
+  }
+  return items;
+}
+
+export function attachRestoredToolResult(message, pendingByCallId) {
+  const callId = typeof message?.tool_call_id === 'string' && message.tool_call_id
+    ? message.tool_call_id
+    : typeof message?.toolCallId === 'string' ? message.toolCallId : '';
+  const target = callId ? pendingByCallId.get(callId) : null;
+  if (!target) return;
+  pendingByCallId.delete(callId);
+  const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)) || '';
+  target.result = text;
+  if (/^\s*(?:error|\[error|failed\b)/i.test(text)) target.isError = true;
+}
+
+// Collapse a consecutive run (≥2) of restored per-call tool items into ONE
+// done aggregate item shaped exactly like the live turn's '__aggregate__'
+// card (turn.mjs completeAggregateVisual): merged category header counts,
+// per-call result summaries as the collapsed detail, raw bodies preserved
+// for expansion, failures/exits surfaced as 'N Ok · N Failed'/'Exit N'.
+function buildRestoredAggregateItem(members) {
+  const categories = new Map();
+  const categoryOrder = [];
+  const calls = [];
+  for (const { item, category } of members) {
+    const entry = aggregateToolCategoryEntry(item.name, item.args, category);
+    if (!categories.has(entry.key)) categoryOrder.push(entry.key);
+    const prev = categories.get(entry.key);
+    categories.set(entry.key, { ...entry, count: Number(prev?.count || 0) + Number(entry.count || 1) });
+    const resultText = String(item.result ?? '');
+    // Mirror live outcome semantics: a plain non-zero shell exit is the
+    // neutral 'Exit N' state, not a red failure; only real call errors count.
+    const exitCode = shellCommandExitCode(resultText);
+    const isExitError = exitCode != null;
+    const isCallError = !isExitError && item.isError === true;
+    calls.push({
+      name: item.name,
+      args: item.args,
+      category,
+      isError: isCallError,
+      isCallError,
+      isExitError,
+      exitCode,
+      resultText,
+      resolved: true,
+      summary: !isCallError && resultText.trim()
+        ? summarizeToolResult(item.name, item.args, resultText, false)
+        : null,
+    });
+  }
+  const errors = calls.filter((r) => r.isError).length;
+  const callErrors = calls.filter((r) => r.isCallError).length;
+  const exitErrors = calls.filter((r) => r.isExitError).length;
+  const succeeded = Math.max(0, calls.length - errors - exitErrors);
+  const displayDetail = errors > 0 || exitErrors > 0
+    ? failureDetailText({ succeeded, realErrors: callErrors, exitErrors, exitCode: calls.find((r) => r.isExitError)?.exitCode })
+    : formatAggregateDetail(calls.filter((r) => r.summary).map((r) => r.summary));
+  const rawResult = aggregateRawResult(calls);
+  const first = members[0].item;
+  const last = members[members.length - 1].item;
+  return {
+    kind: 'tool',
+    id: first.id,
+    name: '__aggregate__',
+    args: { categoryOrder },
+    aggregate: true,
+    categories: Object.fromEntries(categories),
+    doneCategories: aggregateDoneCategories(calls),
+    count: calls.length,
+    completedCount: calls.length,
+    isError: errors > 0,
+    errorCount: errors,
+    callErrorCount: callErrors,
+    exitErrorCount: exitErrors,
+    result: displayDetail,
+    text: displayDetail,
+    rawResult: rawResult || null,
+    expanded: false,
+    headerFinalized: true,
+    ...(first.at != null ? { at: first.at } : {}),
+    ...(first.startedAt != null ? { startedAt: first.startedAt } : {}),
+    ...(last.completedAt != null ? { completedAt: last.completedAt } : {}),
+  };
+}
+
+// Restored transcripts must mirror the live turn's category merging: the live
+// engine (turn.mjs) collapses consecutive same-bucket tool calls into one
+// aggregate card, but resume rebuilt one card per call, so a reopened session
+// un-merged every run (user bug). Walk the restored items and merge adjacent
+// tool cards whose aggregateBucketForCategory matches; any non-tool item
+// (user/assistant/turndone) is a block boundary, same as the live seal rule.
+// Runs of 1 keep the plain per-call card (its argument summary stays visible).
+// Agent cards never merge on restore: the live rule scopes Agent grouping to
+// a single provider batch, a boundary the stored history no longer carries.
+export function mergeRestoredToolItems(items) {
+  const merged = [];
+  let run = null; // { bucket, members: [{ item, category }] }
+  const flushRun = () => {
+    if (!run) return;
+    if (run.members.length >= 2) merged.push(buildRestoredAggregateItem(run.members));
+    else for (const member of run.members) merged.push(member.item);
+    run = null;
+  };
+  for (const item of items || []) {
+    const mergeable = item?.kind === 'tool' && item.aggregate !== true;
+    if (!mergeable) { flushRun(); merged.push(item); continue; }
+    const category = classifyToolCategory(item.name, item.args);
+    const bucket = category === 'Agent' ? '' : aggregateBucketForCategory(category);
+    if (!bucket) { flushRun(); merged.push(item); continue; }
+    if (run && run.bucket === bucket) { run.members.push({ item, category }); continue; }
+    flushRun();
+    run = { bucket, members: [{ item, category }] };
+  }
+  flushRun();
+  return merged;
+}
+
+function restoredMessageItemUpperBound(message) {
+  if (message?.role === 'user') return 1;
+  if (message?.role !== 'assistant') return 0;
+  const calls = Array.isArray(message?.tool_calls) ? message.tool_calls
+    : Array.isArray(message?.toolCalls) ? message.toolCalls : [];
+  const content = message?.content;
+  const hasContent = typeof content === 'string'
+    ? content.length > 0
+    : Array.isArray(content) && content.length > 0;
+  const hasCompletion = Boolean(message?.meta?.transcript?.completion);
+  return Number(hasContent) + Number(hasCompletion) + calls.length;
+}
+
+function restoredUserTranscriptItems(message, nextId) {
+  // Injected model-context payloads are model-visible but never user-authored:
+  // skill bodies (meta:'skill'), hook/system reminders, and tag-wrapped context
+  // blocks must not restore as user bubbles in any client.
+  if (message?.meta === 'skill' || message?.meta === 'hook') return [];
+  const text = (typeof message?.content === 'string'
+    ? message.content
+    : toolResultText(message?.content)).trim();
+  if (/^<(?:system-reminder|skill|memory-context|mcp-instructions|available-deferred-tools|event)\b/i.test(text)) {
+    return [];
+  }
+  if (!text) return [];
+  const synthetic = parseSyntheticAgentMessage(text);
+  if (!synthetic) {
+    return [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }];
+  }
+  const label = synthetic.label || 'notification';
+  const syntheticAt = Number(message?.meta?.transcript?.at);
+  return [{
+    kind: 'tool',
+    id: nextId(),
+    name: synthetic.name || 'agent',
+    args: synthetic.args || {
+      type: label,
+      task_id: synthetic.taskId || undefined,
+      description: synthetic.summary || 'agent notification',
+    },
+    result: synthetic.result,
+    rawResult: synthetic.rawResult ?? text,
+    isError: synthetic.isError ?? /^(failed|error|killed|cancelled)$/i.test(label),
+    expanded: false,
+    count: 1,
+    completedCount: 1,
+    ...(Number.isFinite(syntheticAt)
+      ? { at: syntheticAt, startedAt: syntheticAt, completedAt: syntheticAt }
+      : {}),
+  }];
+}
+
+function restoreTranscriptRange(messages, start, sessionId) {
+  const items = [];
+  const pendingToolCalls = new Map();
+  for (let index = start; index < messages.length; index += 1) {
+    const message = messages[index];
+    let part = 0;
+    // Message-position ids remain stable when newer messages are appended and
+    // let a tail-only restore skip the prefix without first counting every old
+    // projected item.
+    const restoredId = () => `hist_${sessionId}_${index}_${++part}`;
+    if (message?.role === 'user') {
+      items.push(...restoredUserTranscriptItems(message, restoredId));
+    } else if (message?.role === 'assistant') {
+      items.push(...restoredAssistantTranscriptItems(message, restoredId));
+      items.push(...restoredToolCallItems(message, restoredId, pendingToolCalls));
+    } else if (message?.role === 'tool') {
+      attachRestoredToolResult(message, pendingToolCalls);
+    }
+  }
+  return mergeRestoredToolItems(items);
+}
+
+export function restoreTranscriptItems(messages, {
+  sessionId = 'session',
+  itemLimit = Number.POSITIVE_INFINITY,
+} = {}) {
+  const source = Array.isArray(messages) ? messages : [];
+  const numericLimit = Number(itemLimit);
+  const limited = Number.isFinite(numericLimit) && numericLimit > 0;
+  if (!limited) return restoreTranscriptRange(source, 0, sessionId);
+
+  const limit = Math.max(1, Math.floor(numericLimit));
+  // Restore beyond the visible cap so a boundary tool run can merge exactly
+  // as it did in the full transcript. Selection is incremental from the tail:
+  // large cold sessions never read or project their old message bodies.
+  const target = limit + Math.min(128, limit);
+  let start = source.length;
+  let upperBound = 0;
+  while (start > 0 && upperBound < target) {
+    start -= 1;
+    upperBound += restoredMessageItemUpperBound(source[start]);
+  }
+
+  let restored = restoreTranscriptRange(source, start, sessionId);
+  // Hidden/context messages and aggregate tool runs can make the cheap upper
+  // bound optimistic. Expand backward exponentially only when necessary.
+  let expansionTarget = Math.max(64, limit - restored.length);
+  while (start > 0 && restored.length < limit) {
+    let expansion = 0;
+    while (start > 0 && expansion < expansionTarget) {
+      start -= 1;
+      expansion += restoredMessageItemUpperBound(source[start]);
+    }
+    restored = restoreTranscriptRange(source, start, sessionId);
+    expansionTarget *= 2;
+  }
+  return restored.length > limit ? restored.slice(-limit) : restored;
+}
 
 export function createEngineApiB(bag) {
   const {
-    runtime, nextId, flags, lifecycle, listeners, getState, set, disposeEmit, replaceItems, pushNotice, removeNotice, setProgressHint, clearToastTimers, disposeTranscriptSpill, routeState, syncContextStats, finishToolApproval, denyAllToolApprovals, restoreLeadSteeringFromDisk, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, commitTuiSessionReset, resetStatsAndSyncContext,
+    runtime, nextId, flags, lifecycle, listeners, getState, set, flushEmitImmediate, disposeEmit, replaceItems, pushNotice, removeNotice, setProgressHint, clearToastTimers, disposeTranscriptSpill, routeState, syncContextStats, finishToolApproval, denyAllToolApprovals, restoreLeadSteeringFromDisk, resetStats, clearUiActivityBeforeContextSync, resetTuiForPendingSessionReset, snapshotTuiBeforeSessionReset, restoreTuiAfterFailedSessionReset, commitTuiSessionReset, resetStatsAndSyncContext,
   } = bag;
   return {
     resolveToolApproval: (id, decision = {}) => {
@@ -23,6 +326,9 @@ export function createEngineApiB(bag) {
     listProviderModels: (options = {}) => {
       return runtime.listProviderModels(options);
     },
+    prefetchSession: (id) => {
+      return runtime.prefetchSession?.(id) === true;
+    },
     getSearchRoute: () => {
       return runtime.getSearchRoute?.() || runtime.searchRoute || null;
     },
@@ -120,6 +426,60 @@ export function createEngineApiB(bag) {
     },
     isRemoteEnabled: () => runtime.isRemoteEnabled?.() === true,
     getVoiceStatus: () => getVoiceStatus(),
+    // Desktop push-to-talk dictation: accept a recorded audio payload
+    // (base64), stage it as a temp file, and run it through the SAME managed
+    // whisper.cpp pipeline the channels use (ffmpeg convert -> whisper server,
+    // model selected per voice.model/system language). Returns the transcript
+    // text or throws a user-actionable error (e.g. runtime not installed).
+    transcribeAudio: async ({ data, mimeType = 'audio/webm' } = {}) => {
+      const base64 = String(data || '');
+      if (!base64) throw new Error('transcribeAudio: audio payload is required');
+      if (base64.length > 40_000_000) throw new Error('transcribeAudio: recording too large');
+      const [{ createVoiceTranscription }, { resolvePluginData }, { readSection }, os, path, fsp, crypto] = await Promise.all([
+        import('../../runtime/channels/lib/voice-transcription.mjs'),
+        import('../../runtime/shared/plugin-paths.mjs'),
+        import('../../runtime/shared/config.mjs'),
+        import('node:os'),
+        import('node:path'),
+        import('node:fs/promises'),
+        import('node:crypto'),
+      ]);
+      const extension = /ogg/i.test(mimeType) ? 'ogg' : /wav/i.test(mimeType) ? 'wav' : /mp4|m4a/i.test(mimeType) ? 'm4a' : 'webm';
+      const audioPath = path.join(os.tmpdir(), `mixdog-dictation-${process.pid}-${Date.now()}.${extension}`);
+      await fsp.writeFile(audioPath, Buffer.from(base64, 'base64'));
+      try {
+        const { transcribeVoice } = createVoiceTranscription({
+          getConfig: () => ({ voice: readSection('voice') || {} }),
+          dataDir: resolvePluginData(),
+        });
+        const text = await transcribeVoice(audioPath, {
+          attachmentId: `dictation-${crypto.randomUUID()}`,
+        });
+        return typeof text === 'string' ? text : '';
+      } finally {
+        fsp.rm(audioPath, { force: true }).catch(() => undefined);
+      }
+    },
+    // Desktop composer image attach: run the SAME optional-sharp resize
+    // pipeline the TUI paste path uses (<=2000x2000, 5MB-base64 token budget,
+    // identical no-sharp size errors) so both clients send identical image
+    // payloads to the provider.
+    resizeImage: async ({ data, mimeType = 'image/png', filename = '' } = {}) => {
+      const base64 = String(data || '');
+      if (!base64) throw new Error('resizeImage: image payload is required');
+      if (base64.length > 40_000_000) throw new Error('resizeImage: image too large');
+      const { imageAttachmentFromBuffer } = await import('../paste-attachments.mjs');
+      const attachment = await imageAttachmentFromBuffer(
+        Buffer.from(base64, 'base64'),
+        String(mimeType || 'image/png'),
+        { filename: String(filename || 'Pasted image') },
+      );
+      return {
+        data: attachment.content,
+        mimeType: attachment.mediaType,
+        metadataText: attachment.metadataText || '',
+      };
+    },
     toggleVoice: async () => {
       const result = await toggleVoice({ pushNotice, setProgressHint });
       return {
@@ -305,6 +665,11 @@ export function createEngineApiB(bag) {
       pushNotice(`schedule ${enabled ? 'enabled' : 'disabled'}: ${name}`, 'info');
       return result;
     },
+    runScheduleNow: async (name) => {
+      const result = await runtime.runScheduleNow(name);
+      pushNotice(`schedule ran: ${name}`, 'info');
+      return result;
+    },
     saveWebhook: async (entry) => {
       const result = await runtime.saveWebhook(entry);
       pushNotice(`webhook saved: ${result.name}`, 'info');
@@ -377,6 +742,46 @@ export function createEngineApiB(bag) {
     listSessions: (options) => {
       return runtime.listSessions(options);
     },
+    deleteSession: async (id) => {
+      if (getState().commandBusy) return false;
+      const deletingCurrent = String(runtime.session?.id || getState().sessionId || '') === String(id || '');
+      set({ commandBusy: true });
+      clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
+      const rollbackSnapshot = deletingCurrent ? snapshotTuiBeforeSessionReset() : null;
+      if (deletingCurrent) resetTuiForPendingSessionReset();
+      try {
+        if (await runtime.deleteSession(id) !== true) {
+          if (rollbackSnapshot) restoreTuiAfterFailedSessionReset(rollbackSnapshot);
+          return false;
+        }
+        if (deletingCurrent) {
+          clearUiActivityBeforeContextSync();
+          flags.pendingSessionReset = false;
+          resetStatsAndSyncContext();
+          set({
+            items: replaceItems([]),
+            toasts: [],
+            queued: [],
+            thinking: null,
+            spinner: null,
+            lastTurn: null,
+            sessionId: null,
+            cwd: runtime.cwd,
+            ...routeState(),
+            stats: { ...getState().stats },
+          });
+          commitTuiSessionReset(rollbackSnapshot);
+        }
+        return true;
+      } catch (error) {
+        if (rollbackSnapshot) restoreTuiAfterFailedSessionReset(rollbackSnapshot);
+        throw error;
+      } finally {
+        flags.pendingSessionReset = false;
+        set({ commandBusy: false });
+      }
+    },
     switchContext: async (options) => {
       if (getState().commandBusy) return false;
       set({ commandBusy: true });
@@ -444,52 +849,32 @@ export function createEngineApiB(bag) {
         set({ commandBusy: false });
       }
     },
-    resume: async (id) => {
+    resume: async (id, options = {}) => {
       if (getState().commandBusy) return false;
-      set({ commandBusy: true, commandStatus: { active: true, verb: 'Resuming conversation', startedAt: Date.now(), mode: 'resuming' } });
+      // quiet: viewer-follow refreshes (engine share tick) re-resume on every
+      // owner turn — they must not flash the "Resuming conversation" status.
+      set({
+        commandBusy: true,
+        ...(options.quiet === true
+          ? {}
+          : { commandStatus: { active: true, verb: 'Resuming conversation', startedAt: Date.now(), mode: 'resuming' } }),
+      });
       clearToastTimers();
       try {
         const r = await runtime.resume(id);
         if (!r) return false;
         resetStatsAndSyncContext();
-        const items = [];
-        for (const m of r.messages || []) {
-          if (m.role === 'user') {
-            // content may be a string OR an array of parts (text/tool-call
-            // interleaving) — toolResultText coerces both to readable text so
-            // array-content messages aren't silently dropped.
-            const text = (typeof m.content === 'string' ? m.content : toolResultText(m.content)).trim();
-            if (text) {
-              const synthetic = parseSyntheticAgentMessage(text);
-              if (synthetic) {
-                const label = synthetic.label || 'notification';
-                items.push({
-                  kind: 'tool',
-                  id: nextId(),
-                  name: synthetic.name || 'agent',
-                  args: synthetic.args || {
-                    type: label,
-                    task_id: synthetic.taskId || undefined,
-                    description: synthetic.summary || 'agent notification',
-                  },
-                  result: synthetic.result,
-                  rawResult: synthetic.rawResult ?? text,
-                  isError: synthetic.isError ?? /^(failed|error|killed|cancelled)$/i.test(label),
-                  expanded: false,
-                  count: 1,
-                  completedCount: 1,
-                  startedAt: Date.now(),
-                  completedAt: Date.now(),
-                });
-              } else {
-                items.push({ kind: 'user', id: nextId(), text });
-              }
-            }
-          } else if (m.role === 'assistant') {
-            const text = (typeof m.content === 'string' ? m.content : toolResultText(m.content)).trim();
-            if (text) items.push({ kind: 'assistant', id: nextId(), text });
-          }
+        const requestedLimit = Number(options.transcriptItemLimit);
+        if (Number.isFinite(requestedLimit) && requestedLimit > 0) {
+          flags.resumeTranscriptItemLimit = Math.max(1, Math.floor(requestedLimit));
         }
+        const itemLimit = Number(flags.resumeTranscriptItemLimit);
+        const items = restoreTranscriptItems(r.messages, {
+          sessionId: String(r.id || id),
+          itemLimit: Number.isFinite(itemLimit) && itemLimit > 0
+            ? itemLimit
+            : Number.POSITIVE_INFINITY,
+        });
         set({
           items: replaceItems(items),
           toasts: [],
@@ -500,10 +885,20 @@ export function createEngineApiB(bag) {
           ...routeState(),
           stats: { ...getState().stats },
         });
+        // Reconcile the live-share legs NOW (viewer pipe attach / owner pipe
+        // start). The 3s share tick otherwise leaves a live-owned session on
+        // the stale disk snapshot and then full-swaps it seconds after entry —
+        // the visible transcript lurch. Connecting here makes the owner's
+        // full frame land at the resume boundary, so entry paints settled.
+        bag.ensureLiveShare?.();
         void restoreLeadSteeringFromDisk();
         return true;
       } finally {
         set({ commandBusy: false, commandStatus: null });
+        // Desktop resume returns a snapshot immediately after this promise.
+        // Publish the completed route/transcript boundary now so callers never
+        // observe the previous frame's session id and title.
+        flushEmitImmediate();
       }
     },
 
@@ -511,6 +906,10 @@ export function createEngineApiB(bag) {
       if (flags.disposed) return;
       disposeEmit?.();
       flags.disposed = true;
+      // Release the interactive-presence beacon so a cross-open after this
+      // surface exits takes normal ownership instead of viewer-attaching to a
+      // dead owner (crash paths fall back to the 2min staleness window).
+      try { runtime.clearSessionPresence?.(); } catch { /* best-effort */ }
       clearToastTimers();
       disposeTranscriptSpill?.();
       try { clearInterval(lifecycle.runtimePulseTimer); } catch {}

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

@@ -206,7 +206,13 @@ export function createEngineApiA(bag) {
         set({ commandBusy: false });
       }
     },
-    agentControl: async (args = {}) => {
+    agentControl: async (args = {}, options = {}) => {
+      // Silent reads (desktop dock agent viewer) go straight to the runtime:
+      // no transcript card, no commandBusy — mirrors memoryControl's silent
+      // read path.
+      if (options.silent === true) {
+        return runtime.agentControl(args);
+      }
       if (getState().commandBusy) return null;
       set({ commandBusy: true });
       try {

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

@@ -4,7 +4,7 @@
 import { presentErrorText } from '../../runtime/shared/err-text.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from '../markdown/streaming-markdown.mjs';
 import { createSessionStats } from './session-stats.mjs';
-import { queuePriorityValue, defaultQueuePriority, isQueuedEntryEditable, isQueuedEntryVisible, isSlashQueuedEntry, notificationDisplayText, sessionActivityTimestamp, promptDisplayText, mergePromptContents, mergePastedImages, mergePastedTexts, callCommitCallbacks, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
+  import { queuePriorityValue, defaultQueuePriority, isQueuedEntryEditable, isQueuedEntryVisible, isSlashQueuedEntry, notificationDisplayText, sessionActivityTimestamp, promptDisplayText, promptContentImageMeta, mergePromptContents, mergePastedImages, mergePastedTexts, callCommitCallbacks, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { appendTuiSteeringPersist, dropTuiSteeringPersist, drainTuiSteeringPersist } from './tui-steering-persist.mjs';
 
 export function createSessionFlow(bag) {
@@ -49,6 +49,7 @@ export function createSessionFlow(bag) {
       content: text,
       pastedImages: options.pastedImages && typeof options.pastedImages === 'object' ? options.pastedImages : null,
       pastedTexts: options.pastedTexts && typeof options.pastedTexts === 'object' ? options.pastedTexts : null,
+      images: promptContentImageMeta(text, options.pastedImages),
       onCommitted: typeof options.onCommitted === 'function' ? options.onCommitted : null,
       mode,
       priority,
@@ -200,7 +201,12 @@ export function createSessionFlow(bag) {
           // at delivery time; the queued twin is model-visible only and must
           // NOT render a second transcript card here (no fall-back to content).
           if (entry.suppressDisplay) continue;
-          pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? 'user' : 'injected');
+          pushUserOrSyntheticItem(
+            entry.text,
+            entry.id,
+            isQueuedEntryEditable(entry) ? 'user' : 'injected',
+            Array.isArray(entry.images) && entry.images.length ? { images: entry.images } : null,
+          );
         }
         const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
         // A completion resume is owned by the completion that woke it. Esc
@@ -357,15 +363,22 @@ export function createSessionFlow(bag) {
     const minContextPercent = Number(cfg.minContextPercent ?? 10);
     if (minContextPercent > 0) {
       const status = runtime.contextStatus?.() || null;
-      const estimatedTokens = Math.max(0, Number(status?.currentEstimatedTokens ?? status?.usedTokens ?? 0));
-      const usedTokens = Math.max(0, Number(status?.usedTokens ?? estimatedTokens ?? 0));
+      // A zero is often an unavailable/stale meter field, not an authoritative
+      // measurement. Do not let it mask the sibling live estimate.
+      const usedTokens = Math.max(
+        0,
+        Number(status?.usedTokens) || 0,
+        Number(status?.currentEstimatedTokens) || 0,
+        Number(status?.compaction?.currentEstimatedTokens) || 0,
+      );
       const triggerTokens = Number(
         status?.compaction?.triggerTokens
         || status?.compaction?.autoCompactTokenLimit
         || runtime.session?.autoCompactTokenLimit
         || 0,
       );
-      if (!(usedTokens > 0 && triggerTokens > 0)) {
+      if (!Number.isFinite(usedTokens) || !Number.isFinite(triggerTokens)
+        || !(usedTokens > 0 && triggerTokens > 0)) {
         if (!activityAt) flags.lastUserActivityAt = now;
         return false;
       }
@@ -481,11 +494,12 @@ export function createSessionFlow(bag) {
     }
   }
 
-  function restoreQueued(currentText = '') {
+  function restoreQueued(currentText = '', selectedId = '') {
+    const targetId = String(selectedId || '').trim();
     const queued = [];
     for (let i = 0; i < pending.length;) {
       const entry = pending[i];
-      if (isQueuedEntryEditable(entry)) {
+      if (isQueuedEntryEditable(entry) && (!targetId || String(entry.id) === targetId)) {
         queued.push(entry);
         pending.splice(i, 1);
       } else {

package/src/tui/engine/tool-card-results.mjs

@@ -159,6 +159,7 @@ export function createToolCardResults({
       count: group.count,
       completedCount: group.completed,
       completedAt: Date.now(),
+      liveOutput: null,
     };
     if (group.count <= 1) {
       const body = String(text || rawText || '').trim();
@@ -292,7 +293,8 @@ export function createToolCardResults({
         const currentItem = itemById(card.itemId);
         resultText = withCancelledResultMarker(resultText, currentItem);
       }
-      patchToolItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, callErrorCount: group.callErrors || 0, exitErrorCount: group.exitErrors || 0, count: group.count, completedCount: group.completed, completedAt: Date.now() });
+      // liveOutput: null — the settled result supersedes any streamed tail.
+      patchToolItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, callErrorCount: group.callErrors || 0, exitErrorCount: group.exitErrors || 0, count: group.count, completedCount: group.completed, completedAt: Date.now(), liveOutput: null });
       card.done = true;
       if (card.callId) done.add(card.callId);
     }