mixdog 1.2.5 → 1.3.0

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

@@ -6,6 +6,11 @@
  * state, so the closure identifiers (state/set/nextId/disposed/timeout) are
  * threaded through the factory argument via getters — never stale snapshots.
  */
+import {
+  humanRequestFields,
+  normalizeHumanResponse,
+} from '../../runtime/agent/orchestrator/session/human-gate/requests.mjs';
+
 export function createToolApproval({ getState, set, nextId, getDisposed, timeoutMs }) {
   const toolApprovalQueue = [];
   let activeToolApproval = null;
@@ -32,6 +37,8 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
       requestedAt: now,
       timeoutMs: requestTimeoutMs,
       expiresAt: requestTimeoutMs === null ? null : now + requestTimeoutMs,
+      // outbound / secret / takeover / permission fields (human-gate/requests.mjs).
+      ...humanRequestFields(input),
     };
   }
   // Every request expires from ITS OWN requestedAt, queued or active. Arming
@@ -41,18 +48,24 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     if (!entry || entry.timer || entry.request?.expiresAt === null) return;
     const remainingMs = Math.max(0, Number(entry.request?.expiresAt || 0) - Date.now());
     entry.timer = setTimeout(() => {
-      finishToolApproval(entry.id, false, 'approval timed out');
+      finishToolApproval(entry.id, false, 'approval timed out', '', undefined, undefined, { timedOut: true });
     }, 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) {
+  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;
     try {
       entry.resolve(result);
     } catch {}
@@ -68,7 +81,15 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     armToolApprovalTimeout(entry);
     set({ toolApproval: entry.request });
   }
-  function finishToolApproval(id, approved, reason = '', device = '', answers = undefined, reply = undefined) {
+  function finishToolApproval(
+    id,
+    approved,
+    reason = '',
+    device = '',
+    answers = undefined,
+    reply = undefined,
+    extra = undefined
+  ) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
@@ -79,14 +100,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
         ? { id: targetId, approved: approved === true, device: String(device), at: Date.now() }
         : null;
       set({ toolApproval: null, toolApprovalResult });
-      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply);
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       presentNextToolApproval();
       return true;
     }
     const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
-      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply);
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       return true;
     }
     return false;

package/src/tui/session/transcript-intake.mjs

@@ -12,6 +12,7 @@ import {
 import { isLateToolAnnouncement } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { appendPromptHistory } from '../prompt-history-store.mjs';
 import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
+import { routineTriggerField } from '../../runtime/shared/routine-trigger.mjs';
 import {
   buildExecutionResponseToolItem,
   completionCardFromExecution,
@@ -107,16 +108,19 @@ export function createTranscriptIntake({ getState, flags, pushItem, patchItem, t
     // message reports it) or, for a typed prompt, a new one that goes with
     // the prompt into the model transcript. An injected row with no message
     // id of its own carries none.
+    // A routine fire's row is the prompt the turn persists, like a typed one.
+    const ownsPrompt = origin === 'user' || origin === 'routine';
     let messageId = '';
     if (typeof extra?.messageId === 'string' && extra.messageId) messageId = extra.messageId;
-    else if (origin === 'user') messageId = newTranscriptMessageId();
+    else if (ownsPrompt) messageId = newTranscriptMessageId();
     const transcriptMeta = { ...transcriptRouteMetadata(), ...(messageId ? { messageId } : {}) };
-    if (origin === 'user') flags.pendingTranscriptMeta = transcriptMeta;
+    if (ownsPrompt) flags.pendingTranscriptMeta = transcriptMeta;
     pushItem({
       kind: 'user',
       id,
       text,
       ...transcriptMeta,
+      ...routineTriggerField(extra),
       ...(extra && typeof extra.sender === 'string' && extra.sender ? { sender: extra.sender } : {}),
       ...(extra && typeof extra.device === 'string' && extra.device ? { device: extra.device } : {}),
       // Byte-free attachment metadata (name/mime/size) from the queue entry —

package/src/tui/session/transcript-spill.mjs

@@ -1,6 +1,7 @@
 /**
  * Transcript spill storage, history paging, and session item-state mutations.
  */
+import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { Worker } from 'node:worker_threads';
@@ -19,8 +20,11 @@ export const tuiDebug = (msg) => {
   } catch {}
 };
 
+// Item ids outlive the process (queued-input mirror, turn change records), so
+// a restarted process never issues an id again.
+const ID_PREFIX = `it_${randomBytes(4).toString('hex')}_`;
 let _idSeq = 0;
-export const nextId = () => `it_${++_idSeq}`;
+export const nextId = () => `${ID_PREFIX}${++_idSeq}`;
 
 export const TRANSCRIPT_LIVE_ITEM_CAP = 512;
 export const TRANSCRIPT_SPILL_CHUNK_ITEMS = 128;

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

@@ -7,10 +7,10 @@ import { promptContentText } from './queue-helpers.mjs';
 // Restore window for persisted busy-input steering rows. Rows older than this
 // are leftovers of a session that ended long ago — restoring them into a fresh
 // TUI boot reads as a surprise self-injection (user report), so they are
-// discarded at drain time instead.
+// discarded when the mirror is read instead.
 const STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1000;
 
-// Serialize this UI process's own steering writes so append→drop→drain keep
+// Serialize this UI process's own steering writes so append→drop→read keep
 // their issue order even though each now waits on the lock asynchronously.
 // Cross-process mutual exclusion still comes from the shared lock protocol;
 // this chain only orders same-process operations that were previously
@@ -59,23 +59,40 @@ function newSteeringPersistId() {
   return `ts_${Date.now().toString(36)}_${randomBytes(4).toString('hex')}`;
 }
 
-function normalizeTuiSteeringQueueEntry(entry) {
-  if (typeof entry === 'string') {
-    const text = entry.trim();
-    return text || null;
+// What the accepted input runs: its executable content (attachment
+// references), the pasted-attachment links and transcript metadata it was
+// submitted with, and its run options. Callbacks and live queue state never
+// reach the spool.
+function persistedQueuePayload(entry) {
+  const out = {};
+  if (typeof entry.content === 'string' || Array.isArray(entry.content)) out.content = entry.content;
+  for (const field of ['pastedImages', 'pastedTexts', 'transcriptMeta']) {
+    const value = entry[field];
+    if (value && typeof value === 'object' && !Array.isArray(value)) out[field] = value;
+  }
+  for (const field of ['mode', 'priority', 'context']) {
+    if (typeof entry[field] === 'string' && entry[field]) out[field] = entry[field];
   }
+  if (entry.skipSlashCommands === true) out.skipSlashCommands = true;
+  return out;
+}
+
+function normalizeTuiSteeringQueueEntry(entry) {
+  if (typeof entry === 'string') entry = { text: entry };
   if (!entry || typeof entry !== 'object') return null;
   if (typeof entry.text === 'string' && entry.text.trim()) {
     const text = entry.text.trim();
-    const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
+    // A row of an older build may have no id; it gets one here, under the
+    // shard lock, so every later read and drop names the same row.
+    const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : newSteeringPersistId();
     const submissionId =
       typeof entry.submissionId === 'string' && entry.submissionId.trim() ? entry.submissionId.trim() : null;
     const submittedAt = Number(entry.submittedAt);
-    if (!id) return text;
     const at = Number(entry.at);
     return {
       id,
       text,
+      ...persistedQueuePayload(entry),
       ...(Number.isFinite(at) && at > 0 ? { at } : {}),
       ...(submissionId ? { submissionId } : {}),
       ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
@@ -131,24 +148,15 @@ function entryPersistText(entry) {
   return text;
 }
 
-function rowMatchesEntry(row, entry) {
-  const persistId = entry?.steeringPersistId;
-  if (persistId) {
-    return Boolean(row && typeof row === 'object' && row.id === persistId);
-  }
-  const text = entryPersistText(entry);
-  if (!text) return false;
-  return row === text;
-}
-
+// Every stored row has an id (normalize assigns one), so a row is named by it.
 function removePersistRow(q, entry) {
-  const idx = q.findIndex((row) => rowMatchesEntry(row, entry));
+  const idx = q.findIndex((row) => row.id === entry?.steeringPersistId);
   if (idx >= 0) q.splice(idx, 1);
 }
 
 // Consistency-required: a dropped append loses a user's queued steering
 // message, so we async-wait for the lock (never try-once). Returns a promise;
-// fire-and-forget at call sites is fine — _serialize keeps append/drop/drain
+// fire-and-forget at call sites is fine — _serialize keeps append/drop/read
 // in issue order and the write never blocks the render loop.
 export function appendTuiSteeringPersist(leadSessionId, entry) {
   const text = entryPersistText(entry);
@@ -158,13 +166,22 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
   const submissionId = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
   const submittedAt = Number(entry.submittedAt);
-  const record = {
+  const identity = {
     id: entry.steeringPersistId,
     text,
     at: Date.now(),
     ...(submissionId ? { submissionId } : {}),
     ...(Number.isFinite(submittedAt) && submittedAt > 0 ? { submittedAt } : {}),
   };
+  // A JSON snapshot taken now: the lock wait below must not let a later
+  // edit of the live entry change what was accepted. A payload JSON cannot
+  // carry still leaves the input itself durable.
+  let record;
+  try {
+    record = JSON.parse(JSON.stringify({ ...identity, ...persistedQueuePayload(entry) }));
+  } catch {
+    record = identity;
+  }
   return _serialize(key, async () => {
     try {
       await updatePendingShard(key, (raw) => {
@@ -225,30 +242,27 @@ export function _steeringPersistChainCount() {
   return _persistChains.size;
 }
 
-function drainedRowToRestore(row) {
-  if (typeof row === 'string') {
-    return { text: row, steeringPersistId: null };
-  }
-  if (row && typeof row === 'object' && typeof row.text === 'string') {
-    return {
-      text: row.text,
-      steeringPersistId: typeof row.id === 'string' ? row.id : null,
-      submissionId: typeof row.submissionId === 'string' ? row.submissionId : null,
-      submittedAt: Number.isFinite(Number(row.submittedAt)) ? Number(row.submittedAt) : null,
-    };
-  }
-  return null;
+function persistedRowToRestore(row) {
+  return {
+    ...persistedQueuePayload(row),
+    text: row.text,
+    steeringPersistId: row.id,
+    submissionId: typeof row.submissionId === 'string' ? row.submissionId : null,
+    submittedAt: Number.isFinite(Number(row.submittedAt)) ? Number(row.submittedAt) : null,
+  };
 }
 
 // Consistency-required (restores queued messages after boot/command). Async
 // lock wait, serialized on _persistChain so it never reorders against a
 // pending append/drop and never blocks the render loop. Returns a promise of
-// the drained rows; call sites await it.
-export function drainTuiSteeringPersist(leadSessionId) {
+// the stored rows; call sites await it. A read never consumes: a row stays
+// durable until the queue commits, reclaims or closes it (drop), so a
+// restart before then restores it again.
+export function readTuiSteeringPersist(leadSessionId) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve([]);
   return _serialize(key, async () => {
-    let drained = [];
+    let restored = [];
     let droppedStale = 0;
     try {
       await updatePendingShard(key, (raw) => {
@@ -262,18 +276,27 @@ export function drainTuiSteeringPersist(leadSessionId) {
           if (stale) droppedStale += 1;
           return !stale;
         });
-        drained = fresh.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0 && droppedStale === 0) return undefined;
-        deleteSessionBucket(next, key);
+        restored = fresh.map(persistedRowToRestore);
+        // Write only to drop stale rows or to keep the ids normalize gave
+        // rows of an older build.
+        const stored = Array.isArray(raw?.sessions?.[key]) ? raw.sessions[key] : [];
+        if (droppedStale === 0 && stored.every((row) => typeof row?.id === 'string' && row.id.trim())) {
+          return undefined;
+        }
+        if (fresh.length > 0) next.sessions[key] = fresh;
+        else deleteSessionBucket(next, key);
         next.updatedAt = Date.now();
         return next;
       });
     } catch (err) {
-      writeSteeringDiagnostic(`steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}`);
+      // An id assigned to an older row that never reached disk names nothing.
+      restored = [];
+      droppedStale = 0;
+      writeSteeringDiagnostic(`steering-queue read failed sessionId=${leadSessionId}: ${err?.message || err}`);
     }
     if (droppedStale > 0) {
       writeSteeringDiagnostic(`dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}`);
     }
-    return drained;
+    return restored;
   });
 }

package/src/tui/session/turn-live-call.mjs

@@ -0,0 +1,56 @@
+/**
+ * src/tui/session/turn-live-call.mjs — the live decode speed of the model call
+ * that is streaming right now (`spinner.liveCall`), for the desktop composer's
+ * usage readout.
+ *
+ * Providers report a call's exact output tokens only when it ends (the usage
+ * delta), so mid-stream the count is the runtime's own token estimate of the
+ * text and reasoning streamed so far (token-estimate.mjs, measured against a
+ * real tokenizer at +6.5% aggregate bias). The clock starts at the call's first
+ * visible text/reasoning token, so queueing and time-to-first-token stay out.
+ *
+ * Published at most every LIVE_CALL_PUBLISH_MS with its own sample time, so the
+ * reader divides tokens by (sample time - start) and a pause between samples
+ * never skews the figure. A tool call's arguments stream without text the
+ * runtime can count: once the call turns to one, the live figure is withdrawn
+ * until the next call rather than decaying against tokens nobody counted. The
+ * call's usage delta ends it.
+ */
+import { estimateTokens } from '../../runtime/agent/orchestrator/session/token-estimate.mjs';
+
+export const LIVE_CALL_PUBLISH_MS = 250;
+
+function publish({ getState, set }, liveCall) {
+  const spinner = getState().spinner;
+  if (spinner) set({ spinner: { ...spinner, liveCall } });
+}
+
+/** A text or reasoning chunk of the streaming call arrived. */
+export function noteLiveCallText(stream, chunk, now = Date.now()) {
+  const text = String(chunk ?? '');
+  if (!text || stream.liveCallWithdrawn) return;
+  const call = stream.liveCall || { startedAt: now, text: '', publishedAt: 0 };
+  stream.liveCall = call;
+  call.text += text;
+  if (call.publishedAt && now - call.publishedAt < LIVE_CALL_PUBLISH_MS) return;
+  call.publishedAt = now;
+  publish(stream, { startedAt: call.startedAt, outputTokens: estimateTokens(call.text), at: now });
+}
+
+/** The call turned to a tool call (withdraw until the next call) or was reset. */
+export function withdrawLiveCall(stream) {
+  stream.liveCallWithdrawn = true;
+  endLiveCall(stream);
+}
+
+/** The call ended (its usage delta landed): the next call starts fresh. */
+export function endLiveCall(stream) {
+  const had = Boolean(stream.liveCall) || Boolean(stream.getState().spinner?.liveCall);
+  stream.liveCall = null;
+  if (had) publish(stream, null);
+}
+
+export function startNextLiveCall(stream) {
+  stream.liveCallWithdrawn = false;
+  endLiveCall(stream);
+}

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

@@ -33,6 +33,12 @@ export function createTurnStream(deps) {
     // segment out of the provider's final content individually: the combined
     // prefix no longer matches when the provider omits an earlier segment.
     committedSegments: [],
+    // The open segment was settled when the provider streamed a tool call
+    // (turn.mjs); cleared when that response's tool calls open.
+    settledBeforeToolCall: false,
+    // The phase the provider named for the message this segment streams
+    // (`commentary` / `final_answer`), or null; the desktop row carries it.
+    phase: null,
     thinkingText: '',
     thinkingStartedAt: 0,
     thinkingSegmentStartedAt: 0,
@@ -113,6 +119,7 @@ function ensureAssistant(stream, initialText = '') {
       text: String(initialText || ''),
       at,
       messageId,
+      ...phaseField(stream),
       ...stream.routeMeta,
     });
   }
@@ -149,11 +156,17 @@ function partialNow(stream) {
       streaming: true,
       at: identity.at,
       messageId: identity.messageId,
+      ...phaseField(stream),
       ...stream.routeMeta,
     },
   };
 }
 
+// The row's `phase` field; absent when the provider named none.
+function phaseField(stream) {
+  return stream.phase ? { phase: stream.phase } : {};
+}
+
 function samePartial(left, right) {
   if (left === right) return true;
   if (!left || !right) return false;
@@ -208,6 +221,7 @@ function resetLineScan(stream) {
 function closeAssistantSegment(stream) {
   stream.currentAssistantId = null;
   stream.currentAssistantText = '';
+  stream.phase = null;
   stream.claimPersistedAssistant = false;
   stream.assistantIdentity = null;
   resetLineScan(stream);
@@ -296,6 +310,7 @@ function flushTextBatch(stream) {
         text: visibleText,
         streaming: true,
         at: current?.at || Date.now(),
+        phase: stream.phase || undefined,
         ...stream.routeMeta,
       };
     }
@@ -449,6 +464,24 @@ export function appendAssistantText(stream, full, { committed = false } = {}) {
   flushStreamBatch(stream);
 }
 
+// The provider named the phase of the message it is streaming. A message of
+// another phase than the open segment's text is its own row: that segment
+// settles first. A segment whose phase was not known yet (the provider named
+// it only on the finished message) takes it.
+export function noteAssistantPhase(stream, phase) {
+  if (phase !== 'commentary' && phase !== 'final_answer') return;
+  if (stream.phase === phase) return;
+  if (stream.phase && stream.currentAssistantText.trim()) {
+    flushStreamBatch(stream);
+    commitAssistantSegment(stream);
+  }
+  stream.phase = phase;
+  const tail = stream.getState().streamingTail;
+  if (stream.currentAssistantId != null && tail?.id === stream.currentAssistantId) {
+    stream.updateStreamingTail(tail.id, { phase });
+  }
+}
+
 // Reasoning is not a commit boundary: a turn interrupted while it is still
 // thinking produced no model-visible message, so Esc must hand the prompt
 // back to the input box. Text, tool calls and turn end still commit it.

package/src/tui/session/turn.mjs

@@ -34,6 +34,7 @@ import {
   appendTextDelta,
   appendAssistantText,
   appendReasoningDelta,
+  noteAssistantPhase,
   resetStreamedText,
   applyStageChange,
   settleFinalText,
@@ -53,6 +54,7 @@ import {
   startLiveTail,
 } from './turn-tool-cards.mjs';
 import { startQuietWatch } from './turn-quiet.mjs';
+import { endLiveCall, noteLiveCallText, startNextLiveCall, withdrawLiveCall } from './turn-live-call.mjs';
 
 // A usage limit is exactly a spent quota, a plan-gated feature or a billing
 // refusal; overloads, rate limits and server faults recover by waiting.
@@ -241,9 +243,21 @@ function injectSteerMessage({ stream, cards, pushUserOrSyntheticItem }, text, st
   pushUserOrSyntheticItem(value, steeringIds[0], 'injected', steeringItemExtras(steeringMeta));
 }
 
+function settleSegmentBeforeToolCall(ctx) {
+  const { stream } = ctx;
+  if (!stream.currentAssistantText.trim()) return;
+  ctx.markPromptCommitted();
+  flushStreamBatch(stream);
+  commitAssistantSegment(stream, { sealToolBlock: true });
+  // The response's own content (onAssistantText, before its tool calls open)
+  // is this streamed text again: it must not reopen as a second row.
+  stream.settledBeforeToolCall = true;
+}
+
 async function openToolCalls(ctx, calls) {
   const { stream, cards, runtime } = ctx;
   ctx.markPromptCommitted();
+  stream.settledBeforeToolCall = false;
   // Flush buffered mid-turn assistant text before the tool card appears;
   // otherwise, with neither a thinking panel nor a spinner active, the
   // message above the tool card vanished.
@@ -323,10 +337,15 @@ export function applyCompactEvent(ctx, event) {
   set({ ...routeState(), stats: { ...getState().stats } });
 }
 
-function applyTurnUsageDelta({ turn, getState, set, syncContextStats }, delta) {
+function applyTurnUsageDelta(ctx, delta) {
+  const { turn, getState, set, syncContextStats } = ctx;
   const stats = { ...getState().stats };
   applyUsageDelta(stats, delta);
   set({ stats });
+  // The call is over: the composer's live speed gives way to the session's
+  // figure, which this delta's exact usage has just joined.
+  startNextLiveCall(ctx.stream);
+  // Publishes the session's persisted usage totals (stats.usageReadout) too.
   syncContextStats({ allowEstimated: true });
   const inputTokens = Math.max(0, getState().stats.inputTokens - turn.inputBaseline);
   const outputTokens = Math.max(0, getState().stats.outputTokens - turn.outputBaseline);
@@ -356,7 +375,6 @@ function turnHandlers(ctx) {
     },
     drainSteering: (_sessionId, drainOptions) =>
       isCurrentTurn() ? drainPendingSteering({ ...drainOptions, turnEpoch: ctx.turn.epoch }) : [],
-    onStreamDelta: () => {},
     onSteerMessage: (text, steeringMeta = {}) => {
       if (isCurrentTurn()) injectSteerMessage(ctx, text, steeringMeta);
     },
@@ -372,9 +390,14 @@ function turnHandlers(ctx) {
   };
 }
 
-function toolHandlers(ctx) {
+export function toolHandlers(ctx) {
   const { isCurrentTurn, cards, getState, set, options } = ctx;
   return {
+    // The provider streamed a tool call: the text before it is complete (a
+    // preamble), so it settles now instead of after the whole response.
+    onAssistantToolCallObserved: () => {
+      if (isCurrentTurn()) settleSegmentBeforeToolCall(ctx);
+    },
     onToolCall: async (_iter, calls) => {
       if (isCurrentTurn()) await openToolCalls(ctx, calls);
     },
@@ -423,20 +446,38 @@ export function streamHandlers(ctx) {
       // prompt — the runtime would rewind it while the host skipped the requeue.
       if (textChunk.trim()) ctx.markPromptCommitted();
       appendTextDelta(stream, textChunk);
+      noteLiveCallText(stream, textChunk);
+    },
+    onTextReset: (reset = {}) => {
+      if (!isCurrentTurn()) return false;
+      endLiveCall(stream);
+      return resetStreamedText(stream, reset);
     },
-    onTextReset: (reset = {}) => (isCurrentTurn() ? resetStreamedText(stream, reset) : false),
     onAssistantText: (text, detail) => {
       const full = String(text ?? '');
       if (!full.trim() || !isCurrentTurn()) return;
       // The streaming path owns this segment when it already produced text.
       // Do not check turn-global assistantText: earlier closed preambles stay
       // there across tool calls.
-      if (stream.currentAssistantText.trim()) return;
+      if (stream.currentAssistantText.trim() || stream.settledBeforeToolCall) return;
       ctx.markPromptCommitted();
       appendAssistantText(stream, full, { committed: detail?.committed === true });
     },
     onReasoningDelta: (chunk) => {
-      if (isCurrentTurn()) appendReasoningDelta(stream, String(chunk ?? ''));
+      if (!isCurrentTurn()) return;
+      appendReasoningDelta(stream, String(chunk ?? ''));
+      noteLiveCallText(stream, chunk);
+    },
+    // A provider output item started. A tool call ends the text before it
+    // (a preamble settles at the call's start, not after its arguments or
+    // the whole response); a message naming its phase marks its row as
+    // commentary or final answer.
+    onStreamItemStart: (detail) => {
+      if (!isCurrentTurn()) return;
+      if (detail?.kind === 'tool') {
+        withdrawLiveCall(stream);
+        settleSegmentBeforeToolCall(ctx);
+      } else if (detail?.kind === 'text') noteAssistantPhase(stream, detail.phase);
     },
   };
 }
@@ -693,11 +734,12 @@ export function createRunTurn(bag) {
       markPromptCommitted: () => commitPromptRestore(flags, turn),
     };
     const stopTaskWaitSteeringCheck = registerTaskWaitSteeringCheck(
-      (sessionId) => isCurrentTurn() && runtime.id === sessionId && bag.hasPendingSteering()
+      (sessionId) => isCurrentTurn() && runtime.id === sessionId && bag.pendingTaskWaitWake()
     );
     try {
       const { result, session } = await runtime.ask(userText, {
         id: turn.submittedIds[0],
+        submissionIds: turn.submittedIds,
         submittedAt: options.submittedAt,
         promptSource: options.promptSource,
         retryFailedTurn: options.retryFailedTurn === true,
@@ -705,6 +747,7 @@ export function createRunTurn(bag) {
         retryAttemptId: options.retryAttemptId,
         transcriptMeta: turn.transcriptMeta,
         context: options.context || null,
+        ...(typeof options.skillSelection === 'string' ? { skillSelection: options.skillSelection } : {}),
         ...turnHandlers(ctx),
         ...toolHandlers(ctx),
         ...streamHandlers(ctx),

package/src/ui/statusline.mjs

@@ -10,7 +10,6 @@
  * CLI route passed here.
  */
 import { readCachedOAuthUsageSnapshot } from '../runtime/agent/orchestrator/providers/oauth-usage.mjs';
-import { readCachedOpenCodeGoUsageSnapshot } from '../runtime/agent/orchestrator/providers/opencode-go-usage.mjs';
 import { buildGatewayLimits } from '../runtime/agent/orchestrator/providers/statusline-route-meta.mjs';
 import { formatGatewayLimitSegments, loadGatewayStatus } from '../vendor/statusline/bin/statusline-route.mjs';
 import { createSessionStats } from './session-stats.mjs';
@@ -614,14 +613,11 @@ function refreshFallbackQuotaStatus(cacheKey, normalizedProvider, model) {
 // the route reports nothing worth a segment.
 function fallbackQuotaValue(routeInfo, normalizedProvider) {
   let usageSnapshot = null;
-  if (normalizedProvider === 'opencode-go') {
-    usageSnapshot = readCachedOpenCodeGoUsageSnapshot();
-  } else if (normalizedProvider.includes('oauth')) {
+  if (normalizedProvider.includes('oauth')) {
     try {
       usageSnapshot = readCachedOAuthUsageSnapshot(routeInfo, { allowStale: true });
     } catch {}
   }
-  if (normalizedProvider === 'opencode-go' && !usageSnapshot) return null;
   // Boot guard: do not render previous-launch usage before the current
   // runtime has captured at least one snapshot. Once captured in this
   // process, keep it visible while idle even if refreshes are delayed.
@@ -647,7 +643,6 @@ function fallbackQuotaValue(routeInfo, normalizedProvider) {
 
 function providerKindForQuota(provider) {
   const p = String(provider || '').toLowerCase();
-  if (p === 'opencode-go') return 'quota-api';
   if (p.includes('oauth')) return 'oauth';
   if (p === 'mixdog-local') return 'local';
   return 'api';