mixdog 1.3.4 → 1.4.0

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

@@ -40,6 +40,9 @@ export function createTurnStream(deps) {
     // (`commentary` / `final_answer`), or null; the desktop row carries it.
     phase: null,
     thinkingText: '',
+    // Length of thinkingText when the current provider send began: a
+    // `reasoning` retraction drops only what that send added.
+    thinkingSendMark: 0,
     thinkingStartedAt: 0,
     thinkingSegmentStartedAt: 0,
     accumulatedThinkingMs: 0,
@@ -492,9 +495,20 @@ export function appendReasoningDelta(stream, chunk) {
   scheduleStreamFlush(stream);
 }
 
+// A provider send (one model request of the turn) begins: the thinking so far
+// belongs to earlier sends and survives a retraction of this one.
+export function markThinkingSendStart(stream) {
+  stream.thinkingSendMark = stream.thinkingText.length;
+}
+
 export function resetStreamedText(stream, { chars, reasoning } = {}) {
   const count = Math.max(0, Number(chars) || 0);
-  if (reasoning) endThinkingForText(stream);
+  if (reasoning) {
+    endThinkingForText(stream);
+    // The discarded attempt's thinking must not prefix the next attempt's;
+    // earlier sends' thinking stays.
+    stream.thinkingText = stream.thinkingText.slice(0, stream.thinkingSendMark);
+  }
   if (!count) return reasoning === true;
   flushStreamBatch(stream);
   stream.assistantText = stream.assistantText.slice(0, Math.max(0, stream.assistantText.length - count));
@@ -529,6 +543,8 @@ export function resetStreamedText(stream, { chars, reasoning } = {}) {
 // tool phase (`spinnerMode`: 'task-wait' or 'tool-use').
 export function closeThinkingForToolBatch(stream, spinnerMode) {
   const { getState, set } = stream;
+  // The send that produced this batch is complete; its thinking is kept.
+  markThinkingSendStart(stream);
   if (stream.thinkingText && getState().thinking) {
     const thinkingLastEndedAt = closeThinkingSegment(stream);
     set({
@@ -572,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) {
@@ -583,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?.();
 }
@@ -619,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

@@ -23,6 +23,10 @@ import { isRejected429 } from '../../runtime/shared/error-presentation.mjs';
 import { QUOTA_KINDS, providerErrorKind } from '../../runtime/agent/orchestrator/providers/provider-error-kind.mjs';
 import { turnFailureRecord } from '../../runtime/agent/orchestrator/session/turn-failure.mjs';
 import { registerTaskWaitSteeringCheck } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
+import {
+  isReactionSuccess,
+  reactionCallIds,
+} from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
 import { archiveItemsForCompaction, compactionArchivedRows } from './compaction-view.mjs';
@@ -35,6 +39,7 @@ import {
   appendTextDelta,
   appendAssistantText,
   appendReasoningDelta,
+  markThinkingSendStart,
   noteAssistantPhase,
   resetStreamedText,
   applyStageChange,
@@ -152,6 +157,9 @@ function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
     askResult: null,
     finishedNormally: false,
     transcriptCompacted: false,
+    // Ids of this turn's react calls; `reacted` is set once one succeeds.
+    reactionCallIds: new Set(),
+    reacted: false,
   };
 }
 
@@ -403,10 +411,15 @@ export function toolHandlers(ctx) {
       if (isCurrentTurn()) settleSegmentBeforeToolCall(ctx);
     },
     onToolCall: async (_iter, calls) => {
-      if (isCurrentTurn()) await openToolCalls(ctx, calls);
+      if (!isCurrentTurn()) return;
+      for (const id of reactionCallIds(calls)) ctx.turn.reactionCallIds.add(id);
+      await openToolCalls(ctx, calls);
     },
     onToolResult: (message) => {
       if (!isCurrentTurn()) return;
+      // A reaction that landed on the user's message is this turn's output
+      // even with no reply text; a rejected or failed react call is not.
+      if (isReactionSuccess(message, ctx.turn.reactionCallIds)) ctx.turn.reacted = true;
       try {
         options.onToolResult?.(message);
       } catch {}
@@ -440,7 +453,9 @@ export function streamHandlers(ctx) {
   const { isCurrentTurn, stream } = ctx;
   return {
     onProviderSendStarted: () => {
-      if (isCurrentTurn()) markLiveCallRequestStart(stream);
+      if (!isCurrentTurn()) return;
+      markThinkingSendStart(stream);
+      markLiveCallRequestStart(stream);
     },
     onStageChange: async (stage, detail = null) => {
       if (!isCurrentTurn()) return;
@@ -554,6 +569,9 @@ export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
     outputTokens: finalOutputTokens(stream, getState().spinner?.outputTokens),
     thinkingElapsedMs: stream.thinkingStartedAt ? stream.accumulatedThinkingMs : 0,
     toolCount: cards.toolCards.length,
+    // Its answer may be a reaction alone: readers of the turn's final answer
+    // take it as done with nothing to say (session-final-answer.ts).
+    ...(turn.reacted ? { reacted: true } : {}),
     verb: turn.completionVerb,
     at: Date.now(),
     ...(turn.failureDetail ? { detail: turn.failureDetail } : {}),
@@ -577,9 +595,11 @@ function publishTurnClose(ctx, closingItems) {
   const assistantOutput = (stream.currentAssistantText || stream.assistantText || '').trim();
   // Suppress only true pending-resume no-ops: no transcript items added and
   // no model output; cancelled/error turns and any visible turn stay marked.
+  // A turn whose only output was a reaction ends with its turndone row too.
   const isNoOpTurn =
     turn.finishedNormally &&
     !turn.cancelled &&
+    !turn.reacted &&
     cards.toolCards.length === 0 &&
     !resultContent &&
     !assistantOutput &&
@@ -757,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,