mixdog 1.3.5 → 1.4.1

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

@@ -0,0 +1,64 @@
+/**
+ * src/tui/session/tool-approval-delegation.mjs — where else a tool-approval
+ * request shows: the top-level chat above a sub-agent (`delegationSurface`) or
+ * the chats handing this session work (`handsOff`, `offerToHandoffs`;
+ * runtime/shared/delegated-approval-host.mjs).
+ */
+import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
+import { delegateToHandoffs } from '../../runtime/shared/delegated-approval-host.mjs';
+
+/** Requests a sub-agent (or a session a chat handed work to) shows in the
+ *  conversation the user watches too. A secret and a takeover go there as
+ *  well: the value goes to this PC by its request id and the sign-in window
+ *  is bound to the asking session, wherever the card is answered. A
+ *  sub-agent's question stays in its own session (its answer belongs to that
+ *  conversation); a handed-off session's question shows in the chats handing
+ *  it work too, beside their hand-off line (tool-approval.mjs
+ *  `handoffQuestions`), never in their queue. */
+const DELEGATED_KINDS = new Set(['', 'approval', 'outbound', 'permission', 'secret', 'takeover']);
+const HANDOFF_KINDS = new Set([...DELEGATED_KINDS, 'question']);
+
+export function createApprovalDelegation({ surfaceOf, ownSessionId }) {
+  /** `{ sessionId, chain }` of the top-level chat a sub-agent's request also
+   *  shows in, or null (no delegation, another kind, or this is the top). */
+  function delegationSurface(request) {
+    if (typeof surfaceOf !== 'function' || !DELEGATED_KINDS.has(request.kind)) return null;
+    const own = String(request.sessionId || ownSessionId());
+    let surface = null;
+    try {
+      surface = surfaceOf(own);
+    } catch {
+      return null;
+    }
+    const sessionId = String(surface?.sessionId || '');
+    if (!sessionId || sessionId === own || sessionId === ownSessionId()) return null;
+    return { sessionId, chain: Array.isArray(surface.chain) ? surface.chain.map(String) : [] };
+  }
+  /** Whether a request this (top-level) session itself makes also shows in
+   *  the chats handing it work (delegated-approval-host.mjs), while it waits. */
+  function handsOff(request) {
+    if (typeof surfaceOf !== 'function' || !HANDOFF_KINDS.has(request.kind)) return false;
+    const own = ownSessionId();
+    return Boolean(own) && String(request.sessionId || own) === own;
+  }
+  function offerToHandoffs(id, request, answer) {
+    const own = ownSessionId();
+    const agentId = agentIdOfHomeSession(own) || roomMemberOfSession(own)?.agentId || '';
+    // Each chat handing this session work names it its own way.
+    delegateToHandoffs({
+      id,
+      sessionId: own,
+      request,
+      answer,
+      copyFor: (chat, { title }) => ({
+        ...request,
+        sessionId: request.sessionId || own,
+        chain: [],
+        surfaceSessionId: chat,
+        handoff: { title, ...(agentId ? { agentId } : {}) },
+      }),
+    });
+  }
+  return { delegationSurface, handsOff, offerToHandoffs };
+}

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

@@ -0,0 +1,39 @@
+/**
+ * src/tui/session/tool-approval-request.mjs — the request record a tool-approval
+ * queue (tool-approval.mjs) holds and presents: name, args, reason, and its
+ * own wait limit.
+ */
+import { humanRequestFields } from '../../runtime/agent/orchestrator/session/human-gate/requests.mjs';
+
+/** The queue's default wait limit from its `timeoutMs` option: a positive
+ *  number, else null (no limit). */
+export function defaultApprovalTimeoutMs(timeoutMs) {
+  return Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Number(timeoutMs) : null;
+}
+
+export function normalizeToolApprovalRequest(input, id, defaultTimeoutMs) {
+  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,
+  // which is itself no limit unless the runtime configures one.
+  let requestTimeoutMs = defaultTimeoutMs;
+  if (input?.timeoutMs === null) requestTimeoutMs = null;
+  else if (Number.isFinite(Number(input?.timeoutMs)) && Number(input.timeoutMs) > 0) {
+    requestTimeoutMs = Number(input.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: requestTimeoutMs,
+    expiresAt: requestTimeoutMs === null ? null : now + requestTimeoutMs,
+    // outbound / secret / takeover / permission fields (human-gate/requests.mjs).
+    ...humanRequestFields(input),
+  };
+}

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

@@ -0,0 +1,62 @@
+/**
+ * src/tui/session/tool-approval-settle.mjs — how one tool-approval entry ends:
+ * the answer its waiter gets, the forwarded answer of a copy, and the outcome
+ * record published on the state (`toolApprovalResult`).
+ */
+import { normalizeHumanResponse } from '../../runtime/agent/orchestrator/session/human-gate/requests.mjs';
+import { withdrawDelegatedApproval } from '../../runtime/shared/delegated-approval-host.mjs';
+
+// 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.
+export function settleToolApproval(entry, approved, reason, answers, reply, extra, device = '') {
+  if (entry?.timer) clearTimeout(entry.timer);
+  const result = { approved, reason };
+  if (answers !== undefined) result.answers = answers;
+  if (reply !== undefined) result.reply = reply;
+  // A human-kind request answers with its canonical response (never a value).
+  if (entry?.request?.remember) {
+    Object.assign(result, normalizeHumanResponse(entry.request, approved, extra));
+    if (device) result.device = device;
+  }
+  if (extra?.timedOut === true) result.timedOut = true;
+  // Settled here: its copy in the top-level chat goes away.
+  if (entry?.delegated) {
+    withdrawDelegatedApproval(entry.id, { approved, device, ...(extra?.timedOut === true ? { expired: true } : {}) });
+  }
+  try {
+    entry.resolve(result);
+  } catch {
+    // The requester's resolver must not break settling the queue.
+  }
+}
+
+/** Hand a copy's answer to the queue that owns the request; false when the
+ *  owner had already settled it. */
+export function forwardToOwner(entry, approved, reason, device, answers, reply, extra) {
+  try {
+    return entry.mirror.answer(approved, reason, device, answers, reply, extra) === true;
+  } catch {
+    return false;
+  }
+}
+
+/** How the shown entry ended, from its own finish: only an answer from a known
+ *  device is attributed; a real timeout says `expired`; any other unattributed
+ *  end names nobody (null). */
+export function finishedOutcome(id, approved, device, extra) {
+  if (device) return { id, approved: approved === true, device: String(device), at: Date.now() };
+  if (extra?.timedOut === true) return { id, approved: false, device: '', expired: true, at: Date.now() };
+  return null;
+}
+
+/** How a copy ended, from the owner's settle: answered from a known device
+ *  (who), a real timeout (`expired`), or taken away with no answer
+ *  (`withdrawn`: the owner's turn ended, the hand-off copy was removed). */
+export function copyOutcome(id, result) {
+  const device = String(result?.device || '');
+  const at = Date.now();
+  if (device) return { id, approved: result.approved === true, device, at };
+  if (result?.expired === true) return { id, approved: false, device: '', expired: true, at };
+  return { id, approved: false, device: '', withdrawn: true, at };
+}

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

@@ -13,20 +13,14 @@
  * that session's own turn ending, and its answer is forwarded to the owning
  * queue, so either place settles the one request once.
  */
-import {
-  humanRequestFields,
-  normalizeHumanResponse,
-} from '../../runtime/agent/orchestrator/session/human-gate/requests.mjs';
 import {
   delegateApproval,
   delegatedApprovalsFor,
   registerApprovalQueue,
-  withdrawDelegatedApproval,
 } from '../../runtime/shared/delegated-approval-host.mjs';
-
-/** Approvals a sub-agent shows in the top-level chat too; a question, a secret
- *  or a takeover stays in its own session (its answer or window is there). */
-const DELEGATED_KINDS = new Set(['', 'approval', 'outbound', 'permission']);
+import { defaultApprovalTimeoutMs, normalizeToolApprovalRequest } from './tool-approval-request.mjs';
+import { copyOutcome, finishedOutcome, forwardToOwner, settleToolApproval } from './tool-approval-settle.mjs';
+import { createApprovalDelegation } from './tool-approval-delegation.mjs';
 
 /** The wait limit an approval has when its request names none, from
  *  MIXDOG_TOOL_APPROVAL_TIMEOUT_MS (milliseconds, one second at least): null —
@@ -39,10 +33,18 @@ export function resolveToolApprovalTimeoutMs(env = process.env) {
 }
 
 export function createToolApproval({ getState, set, nextId, getDisposed, timeoutMs = null, surfaceOf = null }) {
-  const defaultTimeoutMs = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Number(timeoutMs) : null;
+  const defaultTimeoutMs = defaultApprovalTimeoutMs(timeoutMs);
   const toolApprovalQueue = [];
   let activeToolApproval = null;
+  // Copies of the ask_user questions of sessions this chat handed work to
+  // (`{ id, request, mirror }`): published as `handoffQuestions`, each shown
+  // at its hand-off line for the user alone (no transcript row), outside the
+  // queue so they never hold this chat's own requests back and several show
+  // at once. Answered here, the answer goes to the asking session's queue.
+  const handoffQuestions = [];
+  const publishHandoffQuestions = () => set({ handoffQuestions: handoffQuestions.map((entry) => entry.request) });
   const ownSessionId = () => String(getState()?.sessionId || '');
+  const { delegationSurface, handsOff, offerToHandoffs } = createApprovalDelegation({ surfaceOf, ownSessionId });
   const unregister =
     typeof surfaceOf === 'function'
       ? registerApprovalQueue({
@@ -53,33 +55,6 @@ 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,
-    // which is itself no limit unless the runtime configures one.
-    const requestTimeoutMs =
-      input?.timeoutMs === null
-        ? null
-        : Number.isFinite(Number(input?.timeoutMs)) && Number(input.timeoutMs) > 0
-          ? Number(input.timeoutMs)
-          : defaultTimeoutMs;
-    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: requestTimeoutMs,
-      expiresAt: requestTimeoutMs === null ? null : now + requestTimeoutMs,
-      // outbound / secret / takeover / permission fields (human-gate/requests.mjs).
-      ...humanRequestFields(input),
-    };
-  }
   // A request that has a limit 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).
@@ -93,54 +68,35 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     }, remainingMs);
     entry.timer.unref?.();
   }
-  // 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, answers, reply, extra, device = '') {
-    if (entry?.timer) clearTimeout(entry.timer);
-    const result = { approved, reason };
-    if (answers !== undefined) result.answers = answers;
-    if (reply !== undefined) result.reply = reply;
-    // A human-kind request answers with its canonical response (never a value).
-    if (entry?.request?.remember) {
-      Object.assign(result, normalizeHumanResponse(entry.request, approved, extra));
-      if (device) result.device = device;
-    }
-    if (extra?.timedOut === true) result.timedOut = true;
-    // Settled here: its copy in the top-level chat goes away.
-    if (entry?.delegated) withdrawDelegatedApproval(entry.id, { approved, device });
-    try {
-      entry.resolve(result);
-    } catch {}
-  }
-  /** Hand a copy's answer to the queue that owns the request; false when the
-   *  owner had already settled it. */
-  function forwardToOwner(entry, approved, reason, device, answers, reply, extra) {
-    try {
-      return entry.mirror.answer(approved, reason, device, answers, reply, extra) === true;
-    } catch {
-      return false;
-    }
-  }
   function offerDelegatedApproval(delegated) {
     if (getDisposed() || delegated.sessionId !== ownSessionId()) return;
+    if (delegated.request?.kind === 'question') {
+      if (handoffQuestions.some((entry) => entry.id === delegated.id)) return;
+      handoffQuestions.push({ id: delegated.id, request: delegated.request, mirror: delegated });
+      publishHandoffQuestions();
+      return;
+    }
     if (activeToolApproval?.id === delegated.id || toolApprovalQueue.some((entry) => entry.id === delegated.id)) return;
     toolApprovalQueue.push({ id: delegated.id, request: delegated.request, mirror: delegated, timer: null });
     presentNextToolApproval();
   }
   function withdrawDelegatedCopy(id, result) {
+    const question = handoffQuestions.findIndex((entry) => entry.id === id);
+    if (question >= 0) {
+      handoffQuestions.splice(question, 1);
+      if (!getDisposed()) publishHandoffQuestions();
+      return;
+    }
     if (activeToolApproval?.mirror && activeToolApproval.id === id) {
       activeToolApproval = null;
-      const device = String(result?.device || '');
-      set({
-        toolApproval: null,
-        toolApprovalResult: device ? { id, approved: result.approved === true, device, at: Date.now() } : null,
-      });
+      set({ toolApproval: null, toolApprovalResult: copyOutcome(id, result) });
       presentNextToolApproval();
       return;
     }
     const index = toolApprovalQueue.findIndex((entry) => entry.mirror && entry.id === id);
-    if (index >= 0) toolApprovalQueue.splice(index, 1);
+    if (index < 0) return;
+    toolApprovalQueue.splice(index, 1);
+    presentNextToolApproval();
   }
   /** Show the delegated approvals waiting for this session (it loaded, or its
    *  session id became the top-level one after the request was made). */
@@ -149,16 +105,23 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     if (!sessionId || typeof surfaceOf !== 'function') return;
     for (const delegated of delegatedApprovalsFor(sessionId)) offerDelegatedApproval(delegated);
   }
+  /** Show the next request when none is shown, and publish how many wait
+   *  behind the shown one (`toolApprovalsWaiting`: the dock's "1/N"). */
   function presentNextToolApproval() {
-    if (activeToolApproval || getDisposed()) return;
-    const entry = toolApprovalQueue.shift();
-    if (!entry) {
-      if (getState().toolApproval) set({ toolApproval: null });
-      return;
+    if (getDisposed()) return;
+    const patch = {};
+    if (!activeToolApproval) {
+      const entry = toolApprovalQueue.shift();
+      if (entry) {
+        activeToolApproval = entry;
+        armToolApprovalTimeout(entry);
+        patch.toolApproval = entry.request;
+      } else if (getState().toolApproval) patch.toolApproval = null;
+    }
+    if ((getState().toolApprovalsWaiting ?? 0) !== toolApprovalQueue.length) {
+      patch.toolApprovalsWaiting = toolApprovalQueue.length;
     }
-    activeToolApproval = entry;
-    armToolApprovalTimeout(entry);
-    set({ toolApproval: entry.request });
+    if (Object.keys(patch).length > 0) set(patch);
   }
   function finishToolApproval(
     id,
@@ -173,12 +136,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
       activeToolApproval = null;
-      // Only an answer from a known device is attributed; a timeout or an
-      // interrupt names nobody.
-      const toolApprovalResult = device
-        ? { id: targetId, approved: approved === true, device: String(device), at: Date.now() }
-        : null;
-      set({ toolApproval: null, toolApprovalResult });
+      set({ toolApproval: null, toolApprovalResult: finishedOutcome(targetId, approved, device, extra) });
       let accepted = true;
       if (entry.mirror) {
         accepted = forwardToOwner(entry, approved, reason, device, answers, reply, extra);
@@ -191,10 +149,17 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
+      presentNextToolApproval();
       if (entry.mirror) return forwardToOwner(entry, approved, reason, device, answers, reply, extra);
       settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       return true;
     }
+    const question = handoffQuestions.findIndex((entry) => entry.id === targetId);
+    if (question >= 0) {
+      const [entry] = handoffQuestions.splice(question, 1);
+      publishHandoffQuestions();
+      return forwardToOwner(entry, approved, reason, device, answers, reply, extra);
+    }
     return false;
   }
   /** Deny this session's own requests. A copy of a sub-agent's request stays
@@ -202,11 +167,19 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
    *  unanswered: the next runtime of this session adopts it again. */
   function denyAllToolApprovals(reason = 'approval cancelled') {
     const closing = getDisposed();
-    if (closing) unregister();
+    if (closing) {
+      unregister();
+      // Dropped unanswered with this runtime: the next one adopts them again.
+      handoffQuestions.length = 0;
+    }
     if (activeToolApproval && !(activeToolApproval.mirror && !closing)) {
       const entry = activeToolApproval;
       activeToolApproval = null;
-      if (!entry.mirror) settleToolApproval(entry, false, reason);
+      if (!entry.mirror) {
+        settleToolApproval(entry, false, reason);
+        // Stop/turn abort ended it: not a timeout, nobody answered.
+        set({ toolApprovalResult: { id: entry.id, approved: false, device: '', interrupted: true, at: Date.now() } });
+      }
     }
     const kept = [];
     while (toolApprovalQueue.length > 0) {
@@ -215,7 +188,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
       else if (!closing) kept.push(entry);
     }
     toolApprovalQueue.push(...kept);
-    if (activeToolApproval) return;
+    if (activeToolApproval) return presentNextToolApproval();
     if (getState().toolApproval) set({ toolApproval: null });
     presentNextToolApproval();
   }
@@ -223,43 +196,24 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     if (getDisposed()) return Promise.resolve({ approved: false, reason: 'runtime disposed' });
     return new Promise((resolve) => {
       const id = nextId();
-      const full = normalizeToolApprovalRequest(input, id);
+      const full = normalizeToolApprovalRequest(input, id, defaultTimeoutMs);
       const surface = delegationSurface(full);
       if (surface) {
         // Who asks, from the top-level chat down ("사무관 › Worker"), and where the copy is.
         full.chain = surface.chain;
         full.surfaceSessionId = surface.sessionId;
       }
-      const entry = { id, request: full, resolve, timer: null, delegated: Boolean(surface) };
+      const handoffs = !surface && handsOff(full);
+      const entry = { id, request: full, resolve, timer: null, delegated: Boolean(surface || handoffs) };
       toolApprovalQueue.push(entry);
       armToolApprovalTimeout(entry);
       presentNextToolApproval();
-      if (surface) {
-        delegateApproval({
-          id,
-          sessionId: surface.sessionId,
-          request: full,
-          answer: (approved, reason, device, answers, reply, extra) =>
-            finishToolApproval(id, approved, reason, device, answers, reply, extra),
-        });
-      }
+      const answer = (approved, reason, device, answers, reply, extra) =>
+        finishToolApproval(id, approved, reason, device, answers, reply, extra);
+      if (surface) delegateApproval({ id, sessionId: surface.sessionId, request: full, answer });
+      if (handoffs) offerToHandoffs(id, full, answer);
     });
   }
-  /** `{ sessionId, chain }` of the top-level chat a sub-agent's request also
-   *  shows in, or null (no delegation, another kind, or this is the top). */
-  function delegationSurface(request) {
-    if (typeof surfaceOf !== 'function' || !DELEGATED_KINDS.has(request.kind)) return null;
-    const own = String(request.sessionId || ownSessionId());
-    let surface = null;
-    try {
-      surface = surfaceOf(own);
-    } catch {
-      return null;
-    }
-    const sessionId = String(surface?.sessionId || '');
-    if (!sessionId || sessionId === own || sessionId === ownSessionId()) return null;
-    return { sessionId, chain: Array.isArray(surface.chain) ? surface.chain.map(String) : [] };
-  }
 
   return {
     presentNextToolApproval,

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

@@ -70,10 +70,17 @@ function persistedQueuePayload(entry) {
     const value = entry[field];
     if (value && typeof value === 'object' && !Array.isArray(value)) out[field] = value;
   }
-  for (const field of ['mode', 'priority', 'context']) {
+  for (const field of ['mode', 'priority', 'context', 'origin']) {
     if (typeof entry[field] === 'string' && entry[field]) out[field] = entry[field];
   }
   if (entry.skipSlashCommands === true) out.skipSlashCommands = true;
+  // Retry of a failed turn: the drain rewinds the failed prompt by these.
+  if (typeof entry.skillSelection === 'string') out.skillSelection = entry.skillSelection;
+  if (entry.suppressDisplay === true) out.suppressDisplay = true;
+  if (entry.retryFailedTurn === true) out.retryFailedTurn = true;
+  for (const field of ['retryTurnId', 'retryAttemptId']) {
+    if (typeof entry[field] === 'string' && entry[field]) out[field] = entry[field];
+  }
   return out;
 }
 

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

@@ -588,6 +588,12 @@ function stopReconnectCountdown(stream) {
   stream.reconnectTimer = null;
 }
 
+// The spinner's wait fields for a reconnect stage (see applyStageChange).
+function reconnectWait(detail, now = Date.now()) {
+  const retryAt = Number(detail?.retryAt) || 0;
+  return { retryAt, retryInMs: retryAt > 0 ? Math.max(0, retryAt - now) : 0 };
+}
+
 // Re-renders the reconnect verb once a second until the wait ends, the stage
 // moves on, or the turn is gone. The desktop reads the same spinner state.
 function startReconnectCountdown(stream, detail) {
@@ -599,7 +605,7 @@ function startReconnectCountdown(stream, detail) {
       stopReconnectCountdown(stream);
       return;
     }
-    stream.set({ spinner: { ...spinner, verb: reconnectVerb(detail) } });
+    stream.set({ spinner: { ...spinner, verb: reconnectVerb(detail), ...reconnectWait(detail) } });
   }, 1_000);
   stream.reconnectTimer.unref?.();
 }
@@ -635,7 +641,18 @@ export async function applyStageChange(stream, stage, detail = null) {
   }
   if (value === 'reconnecting') {
     stream.compactingActive = false;
-    set({ spinner: { ...getState().spinner, mode: 'reconnecting', verb: reconnectVerb(detail) } });
+    // The wait rides on the spinner so a surface that repaints on its own
+    // clock (the desktop status line) counts it down itself: `retryInMs` is
+    // the remaining wait at publish (relative, so a remote client's clock skew
+    // cannot distort it) and `retryAt` only identifies this retry.
+    set({
+      spinner: {
+        ...getState().spinner,
+        mode: 'reconnecting',
+        verb: reconnectVerb(detail),
+        ...reconnectWait(detail),
+      },
+    });
     startReconnectCountdown(stream, detail);
     await yieldToRenderer();
     return;

package/src/tui/session/turn.mjs

@@ -777,6 +777,7 @@ export function createRunTurn(bag) {
         submissionIds: turn.submittedIds,
         submittedAt: options.submittedAt,
         promptSource: options.promptSource,
+        ...(options.promptOrigin ? { promptOrigin: options.promptOrigin } : {}),
         retryFailedTurn: options.retryFailedTurn === true,
         retryTurnId: options.retryTurnId,
         retryAttemptId: options.retryAttemptId,

package/src/ui/statusline-agents.mjs

@@ -13,9 +13,7 @@ import { positiveInt } from '../runtime/shared/numbers.mjs';
 
 // One table owns both halves of a maintenance agent: which agents are hidden
 // from the worker list by default, and the short label they render as.
-const MAINTENANCE_AGENT_LABELS = new Map([
-  ['cycle1-agent', 'cycle1'],
-]);
+const MAINTENANCE_AGENT_LABELS = new Map([['cycle1-agent', 'cycle1']]);
 const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze([...MAINTENANCE_AGENT_LABELS.keys()]);
 const TERMINAL_AGENT_STATUS = /idle|done|complete|success|closed|error|fail|cancel|killed|timeout/i;
 const ACTIVE_AGENT_STATUS = /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting)$/i;