mixdog 0.9.174 → 1.0.0

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

@@ -33,6 +33,85 @@ function earliestSubmittedAt(batch) {
   return Number.isFinite(earliest) ? earliest : Date.now();
 }
 
+function renderBatchItems(batch, pushUserOrSyntheticItem) {
+  for (const entry of batch) {
+    // Async-completion twins (queued model-visible wrapper) used to be
+    // display-skipped here on the assumption the live notification push
+    // already rendered a card. That push is event-ephemeral and can be
+    // missed (listener race, dedupe state from another surface, daemon
+    // restart), which left completions with NO transcript card at all
+    // (2026-08-17 field report: bench shell output never appeared).
+    // Render the wrapper through the synthetic path instead — the
+    // task_id upsert in upsertSyntheticToolItem patches an
+    // already-rendered card, so the double-delivery case stays
+    // duplicate-free. Non-wrapper entries keep the old skip.
+    if (entry.mode === 'pending-resume' || entry.suppressDisplay) {
+      const twin = typeof entry.content === 'string' ? entry.content : String(entry.text || '');
+      if (parseModelVisibleCompletionWrapper(twin)) {
+        pushUserOrSyntheticItem(twin, entry.id, 'injected');
+      }
+      continue;
+    }
+    const sender = String(entry.transcriptMeta?.sender || '')
+      .trim()
+      .toLowerCase();
+    let itemExtras = sender ? { sender } : null;
+    if (Array.isArray(entry.images) && entry.images.length) {
+      itemExtras = { images: entry.images, ...(sender ? { sender } : {}) };
+    }
+    pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? 'user' : 'injected', itemExtras);
+  }
+}
+
+function turnOptionsForBatch(batch, steering) {
+  const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
+  // A completion resume is owned by the completion that woke it. Esc
+  // consumes that ownership; unlike ordinary notifications it must never
+  // be requeued from an uncommitted turn. Keep normal task notifications
+  // recoverable exactly as before.
+  const discardOnAbort = nonEditable.filter(
+    (entry) => entry?.abortDiscardOnAbort === true || entry?.mode === 'pending-resume'
+  );
+  return {
+    promptSource: isGoalQueuedEntry(batch[0]) ? batch[0].mode : undefined,
+    retryFailedTurn: batch[0]?.retryFailedTurn === true,
+    displayText: batch
+      .map((entry) => entry.text)
+      .filter((text) => String(text || '').trim())
+      .join('\n'),
+    pastedImages: mergePastedImages(batch),
+    pastedTexts: mergePastedTexts(batch),
+    submittedAt: earliestSubmittedAt(batch),
+    onCommitted: () => steering.commitSteeringQueueEntries(batch),
+    submittedIds: [...new Set(batch.map((e) => e.id))],
+    restorable: nonEditable.length === 0,
+    requeueOnAbort: nonEditable.filter((entry) => !discardOnAbort.includes(entry)),
+    discardExecutionPendingResumeKeys: discardOnAbort.flatMap((entry) =>
+      Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : []
+    ),
+    transcriptMeta: batch[0]?.transcriptMeta || null,
+    context:
+      batch
+        .map((entry) => String(entry.context || '').trim())
+        .filter(Boolean)
+        .join('\n\n') || null,
+    onToolResult: (message) => {
+      for (const entry of batch) {
+        try {
+          entry.onToolResult?.(message);
+        } catch {}
+      }
+    },
+    onSettled: (detail) => {
+      for (const entry of batch) {
+        try {
+          entry.onSettled?.(detail);
+        } catch {}
+      }
+    },
+  };
+}
+
 export function createDrainLoop(bag, { queue, steering, submissions, flushDeferredClearedSessionUi }) {
   const {
     tuiDebug,
@@ -81,85 +160,6 @@ export function createDrainLoop(bag, { queue, steering, submissions, flushDeferr
     return pending.some((entry) => !isSlashQueuedEntry(entry));
   }
 
-  function renderBatchItems(batch) {
-    for (const entry of batch) {
-      // Async-completion twins (queued model-visible wrapper) used to be
-      // display-skipped here on the assumption the live notification push
-      // already rendered a card. That push is event-ephemeral and can be
-      // missed (listener race, dedupe state from another surface, daemon
-      // restart), which left completions with NO transcript card at all
-      // (2026-08-17 field report: bench shell output never appeared).
-      // Render the wrapper through the synthetic path instead — the
-      // task_id upsert in upsertSyntheticToolItem patches an
-      // already-rendered card, so the double-delivery case stays
-      // duplicate-free. Non-wrapper entries keep the old skip.
-      if (entry.mode === 'pending-resume' || entry.suppressDisplay) {
-        const twin = typeof entry.content === 'string' ? entry.content : String(entry.text || '');
-        if (parseModelVisibleCompletionWrapper(twin)) {
-          pushUserOrSyntheticItem(twin, entry.id, 'injected');
-        }
-        continue;
-      }
-      const sender = String(entry.transcriptMeta?.sender || '')
-        .trim()
-        .toLowerCase();
-      let itemExtras = sender ? { sender } : null;
-      if (Array.isArray(entry.images) && entry.images.length) {
-        itemExtras = { images: entry.images, ...(sender ? { sender } : {}) };
-      }
-      pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? 'user' : 'injected', itemExtras);
-    }
-  }
-
-  function turnOptionsForBatch(batch) {
-    const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
-    // A completion resume is owned by the completion that woke it. Esc
-    // consumes that ownership; unlike ordinary notifications it must never
-    // be requeued from an uncommitted turn. Keep normal task notifications
-    // recoverable exactly as before.
-    const discardOnAbort = nonEditable.filter(
-      (entry) => entry?.abortDiscardOnAbort === true || entry?.mode === 'pending-resume'
-    );
-    return {
-      promptSource: isGoalQueuedEntry(batch[0]) ? batch[0].mode : undefined,
-      retryFailedTurn: batch[0]?.retryFailedTurn === true,
-      displayText: batch
-        .map((entry) => entry.text)
-        .filter((text) => String(text || '').trim())
-        .join('\n'),
-      pastedImages: mergePastedImages(batch),
-      pastedTexts: mergePastedTexts(batch),
-      submittedAt: earliestSubmittedAt(batch),
-      onCommitted: () => steering.commitSteeringQueueEntries(batch),
-      submittedIds: [...new Set(batch.map((e) => e.id))],
-      restorable: nonEditable.length === 0,
-      requeueOnAbort: nonEditable.filter((entry) => !discardOnAbort.includes(entry)),
-      discardExecutionPendingResumeKeys: discardOnAbort.flatMap((entry) =>
-        Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : []
-      ),
-      transcriptMeta: batch[0]?.transcriptMeta || null,
-      context:
-        batch
-          .map((entry) => String(entry.context || '').trim())
-          .filter(Boolean)
-          .join('\n\n') || null,
-      onToolResult: (message) => {
-        for (const entry of batch) {
-          try {
-            entry.onToolResult?.(message);
-          } catch {}
-        }
-      },
-      onSettled: (detail) => {
-        for (const entry of batch) {
-          try {
-            entry.onSettled?.(detail);
-          } catch {}
-        }
-      },
-    };
-  }
-
   async function drain() {
     if (flags.draining) return;
     // Bail while any session command holds commandBusy (auto-clear implies it,
@@ -214,8 +214,8 @@ export function createDrainLoop(bag, { queue, steering, submissions, flushDeferr
         tuiDebug(`busy-queue drain batch=${batch.length} remaining=${pending.length}`);
         const merged = mergePromptContents(batch);
         rewindFailedTurnRows(batch);
-        renderBatchItems(batch);
-        const turnStatus = await bag.runTurn(merged, turnOptionsForBatch(batch));
+        renderBatchItems(batch, pushUserOrSyntheticItem);
+        const turnStatus = await bag.runTurn(merged, turnOptionsForBatch(batch, steering));
         if (flags.drainEpoch !== drainEpoch) return;
         // A deferred cleared-session UI sync (from a late-settling abandoned
         // compacting clear) applies here now that this turn has settled.
@@ -269,7 +269,11 @@ export function createDrainLoop(bag, { queue, steering, submissions, flushDeferr
       return Promise.resolve(persistence).then((persisted) => {
         if (persisted !== false) return true;
         const index = pending.indexOf(entry);
-        if (index >= 0) pending.splice(index, 1);
+        // A turn already took the prompt while its durable mirror was being
+        // written: it was delivered, so rejecting it would hand the sender a
+        // copy of a message the model already has.
+        if (index < 0) return true;
+        pending.splice(index, 1);
         queue.removeQueuedEntries([entry]);
         if (submissionId) submissions.forget(submissionId);
         return false;

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

@@ -58,7 +58,9 @@ export function createQueueOps(bag, { kickDrain }) {
           (entry.mode === 'task-notification' ? notificationDisplayText(entry.text) : String(entry.text || '')),
       };
       if (next.mode === 'task-notification' && next.key) {
-        const duplicateQueued = pending.some((entry) => entry?.mode === 'task-notification' && entry?.key === next.key);
+        const duplicateQueued = pending.some(
+          (queued) => queued?.mode === 'task-notification' && queued?.key === next.key
+        );
         if (duplicateQueued) continue;
         pendingNotificationKeys.add(next.key);
       }

package/src/tui/session/tool-result-status.mjs

@@ -1,354 +1 @@
-/**
- * Tool-result status, display text, and aggregate-record helpers for the
- * session runtime.
- */
-import { stripShellExitHeader, toolErrorDisplay } from './tool-result-text.mjs';
-import { normalizeToolTerminalStatus, toolResultTerminalStatus } from '../../runtime/shared/tool-status.mjs';
-import { isReadOnlyNavigationMiss } from '../../runtime/agent/orchestrator/session/result-classification.mjs';
-import { formatAggregateDetail, summarizeToolResult, toolLoadingTargets } from '../../runtime/shared/tool-surface.mjs';
-import { normalizeToolName } from '../../runtime/shared/tool-primitives.mjs';
-import { gitResultError, gitResultExitCode } from '../../runtime/shared/tool-card-model/git-result.mjs';
-import { readRowsForDisplay } from '../../runtime/shared/read-row-numbers.mjs';
-
-const CANCELLED_RESULT_STATUS_LINE = '[status: cancelled]';
-
-// Detect a shell command that RAN but exited non-zero (a process exit code)
-// as opposed to a real tool-call failure (`[shell-tool-failed]`) or a
-// timeout/abort. New results use bare `[exit code: N]`; legacy transcripts may
-// use `Error: [shell-run-failed] [exit code: N]`. Persistent shell results can
-// prefix `[session: …]`. Returns the numeric exit code, or null otherwise.
-export function shellCommandExitCode(text) {
-  const body = String(text || '');
-  const lines = body.split('\n');
-  if (/^\[tool output offloaded:\s*shell\b/i.test(String(lines[0] || '').trim())) {
-    lines.shift();
-    while (lines.length > 0 && !String(lines[0] || '').trim()) lines.shift();
-  }
-  const header = lines.slice(0, 6).join('\n');
-  // Timeout / signal / abort are NOT a plain command exit — keep them "Failed".
-  if (/\[timeout:|\[signal:|timed out|aborted|interrupted/i.test(header)) return null;
-  const m = header.match(
-    /^\s*(?:\[session:[^\n]*\]\s*\n)?(?:Error:\s*)?(?:\[shell-run-failed\]\s*)?\[exit code:\s*(\d+)\]/i
-  );
-  if (!m) return null;
-  const code = Number(m[1]);
-  return Number.isFinite(code) ? code : null;
-}
-
-// Only provider envelope metadata establishes a failed invocation. Result
-// bodies can contain "Error:"/HTTP/domain/task status text without making the
-// call itself fail. A recognized plain shell exit wins over provider envelope
-// error flags: adapters commonly label non-zero process exits as tool errors
-// even though the shell tool itself ran successfully.
-export function toolCallOutcome(message, rawText) {
-  if (normalizeToolName(message?.toolName || message?.name) === 'git') {
-    const exitCode = gitResultExitCode(rawText);
-    if (exitCode !== null) return { isCallError: false, isExitError: true, exitCode };
-    if (gitResultError(rawText)) return { isCallError: true, isExitError: false, exitCode: null };
-  }
-  const exitCode = shellCommandExitCode(rawText);
-  if (exitCode != null) {
-    // Every completed shell result carries `[exit code: N]` — including 0.
-    // A non-zero code is a command failure unless execution marked a known
-    // successful no-match/no-change outcome.
-    const benignExit = exitCode !== 0 && /^\[outcome:\s*(?:no-match|no-change)\]\s*$/im.test(String(rawText || ''));
-    return { isCallError: false, isExitError: exitCode !== 0 && !benignExit, exitCode };
-  }
-  if (isReadOnlyNavigationMiss(message?.toolName || message?.name, rawText)) {
-    return { isCallError: false, isExitError: false, exitCode };
-  }
-  const isCallError = message?.isError === true || message?.toolKind === 'error';
-  return {
-    isCallError,
-    isExitError: false,
-    exitCode,
-  };
-}
-
-// Build the collapsed failure/exit detail string. Real tool-call/result
-// failures keep the red "Failed" wording; completed non-zero commands render
-// as the distinct warning "Exited" state. A mixed group surfaces both.
-export function failureDetailText({ succeeded = 0, realErrors = 0, exitErrors = 0, exitCode } = {}) {
-  const parts = [];
-  if (succeeded > 0) parts.push(`${succeeded} Ok`);
-  if (realErrors > 0) parts.push(`${realErrors} Failed`);
-  if (exitErrors > 0) {
-    const solo = exitErrors === 1 && realErrors === 0 && succeeded === 0;
-    parts.push(solo && Number.isFinite(exitCode) ? `Exited ${exitCode}` : `${exitErrors} Exited non-zero`);
-  }
-  return parts.join(' · ');
-}
-
-function itemHasKnownTerminalStatus(item, texts = []) {
-  const settled = (token) => token === 'completed' || token === 'failed' || token === 'cancelled';
-  if (settled(normalizeToolTerminalStatus(item?.args?.status))) return true;
-  for (const text of texts) {
-    if (settled(toolResultTerminalStatus(text))) return true;
-  }
-  return false;
-}
-
-export function withCancelledResultMarker(text, item) {
-  const body = String(text || '');
-  // Do NOT inspect item.rawResult here: aggregate rawResult is child tool
-  // output (`1. grep\n<result>…`) that can incidentally contain a `status:`
-  // line, which would false-positive as an already-terminal status and skip
-  // the cancelled marker. Only result/text/body are session runtime-controlled
-  // collapsed detail (empty / status word / an existing marker), so they are
-  // the trustworthy terminal-status sources.
-  const sources = [item?.result, item?.text, body];
-  if (itemHasKnownTerminalStatus(item, sources)) return body;
-  if (!body.trim()) return `${CANCELLED_RESULT_STATUS_LINE}\n`;
-  return `${CANCELLED_RESULT_STATUS_LINE}\n${body}`;
-}
-
-export function groupedToolResultText(group) {
-  const completed = Math.min(group.count, group.completed);
-  if (group.count <= 1) return group.results.at(-1)?.text ?? '';
-  const exitErrors = Number(group.exitErrors || 0);
-  if (group.errors > 0 || exitErrors > 0) {
-    const realErrors = Math.max(0, Number(group.callErrors || group.errors || 0));
-    const succeeded = Math.max(0, completed - group.errors - exitErrors);
-    const exitCode = group.results.find((result) => result?.isExitError)?.exitCode;
-    // Command-exits carry no failure reason line; only real failures do.
-    const reasons = group.results
-      .filter((result) => result?.isError && !result?.isExitError)
-      .map((result) => firstErrorLine(result?.text))
-      .filter(Boolean);
-    const uniqueReasons = [...new Set(reasons)].slice(0, 2);
-    const base = failureDetailText({ succeeded, realErrors, exitErrors, exitCode });
-    return [`${base}${uniqueReasons[0] ? ` · ${uniqueReasons[0]}` : ''}`, ...uniqueReasons.slice(1)].join('\n');
-  }
-  for (const result of group.results || []) {
-    const line = String(result?.text || '').trim();
-    if (line) return result.text;
-  }
-  return '';
-}
-
-function firstErrorLine(text) {
-  const clean = toolErrorDisplay(text, 'tool');
-  if (clean) return clean;
-  for (const line of String(text || '').split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (/^(Error|\[?error|FAIL\b)/i.test(trimmed)) return trimmed;
-  }
-  return (
-    String(text || '')
-      .split('\n')
-      .map((line) => line.trim())
-      .find(Boolean) || ''
-  );
-}
-
-/** The members' raw outputs as one numbered text (`1. grep\n…\n\n2. read\n…`).
- *
- *  Built by `+`, never `join`: V8 keeps a concatenation as a rope that points
- *  at the member strings the aggregate already holds (toolMembers[].rawResult,
- *  the calls' raw text) and copies it flat only when something reads its
- *  characters. A resumed session restores hundreds of aggregates it never
- *  displays; a joined string gave each of them a second, flat copy of every
- *  tool output (~1 MB per idle session in a 30-session measurement). */
-export function aggregateRawResult(calls) {
-  let joined = '';
-  let index = 0;
-  for (const rec of calls || []) {
-    if (rec?.resolved !== true) continue;
-    const text = String(rec?.rawResultText ?? rec?.resultText ?? '').replace(/\s+$/, '');
-    if (!text.trim()) continue;
-    const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
-    index += 1;
-    joined = joined + (index > 1 ? `\n\n${index}. ${label}\n` : `${index}. ${label}\n`) + text;
-  }
-  return joined;
-}
-
-/** Expanded aggregate text with read members' numbered rows rebuilt (the
- *  model-facing rows carry no numbers and would otherwise lose their gutter).
- *  Runs at display time so restored, never-expanded aggregates keep their rope. */
-export function aggregateRawResultForDisplay(text) {
-  if (typeof text !== 'string' || !/^\[lines \d+-\d+\]$/m.test(text)) return text;
-  const lines = text.split('\n');
-  const out = [];
-  let member = [];
-  let inRead = false;
-  const flush = () => {
-    if (member.length) out.push(inRead ? readRowsForDisplay(member.join('\n')) : member.join('\n'));
-    member = [];
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const header = (i === 0 || lines[i - 1] === '') && /^\d+\. (.+)$/.exec(lines[i]);
-    if (!header) {
-      member.push(lines[i]);
-      continue;
-    }
-    flush();
-    out.push(lines[i]);
-    inRead = normalizeToolName(header[1]) === 'read';
-  }
-  flush();
-  return out.join('\n');
-}
-
-/** Preserve the atomic calls behind a visual aggregate. Renderers can keep the
- * aggregate as one quiet summary row while revealing the original tool names,
- * arguments, and outputs in provider order. */
-export function aggregateToolMembers(calls) {
-  const source = calls?.values?.() || calls || [];
-  const members = [];
-  for (const rec of source) {
-    if (!rec || typeof rec !== 'object') continue;
-    const completed = rec.resolved === true || rec.completedEarly === true;
-    members.push({
-      kind: 'tool',
-      ...(rec.callId != null ? { id: rec.callId } : {}),
-      name: String(rec.name || 'tool'),
-      args: rec.args ?? {},
-      result: rec.resultText ?? null,
-      rawResult: rec.rawResultText ?? rec.resultText ?? null,
-      isError: rec.isError === true,
-      errorCount: rec.isError === true ? 1 : 0,
-      callErrorCount: rec.isCallError === true ? 1 : 0,
-      exitErrorCount: rec.isExitError === true ? 1 : 0,
-      count: 1,
-      completedCount: completed ? 1 : 0,
-      headerFinalized: completed,
-      ...stringUiDiffPatch(rec.uiDiff),
-      ...(Number(rec.startedAt) > 0 ? { startedAt: Number(rec.startedAt) } : {}),
-      ...(Number(rec.completedAt) > 0 ? { completedAt: Number(rec.completedAt) } : {}),
-    });
-  }
-  return members;
-}
-
-export function aggregateBucketForCategory(category, { agentBatch = '' } = {}) {
-  // Merge consecutive tool calls of the SAME category into one aggregate card;
-  // a different category opens a fresh card (no cross-category merge). The
-  // bucket key is the category itself, so a run of Search calls collapses into
-  // one Search card while an adjacent Read/Patch stays separate. Falls back to
-  // 'default' when a call has no resolved category. Hook/approval denials keep
-  // their dedicated ToolHookDenialCard path in App.jsx.
-  const key = String(category || '').trim();
-  // Exception: Read and Search share one lookup bucket so a batched turn of
-  // read+grep renders as ONE card ("Reading 3 files · Searching 2 patterns")
-  // instead of two adjacent cards. The per-category entries in
-  // aggregateCard.categories keep their own verbs/counts, so the merged
-  // header still spells out both. State-changing categories (Patch/Shell/…)
-  // stay separate.
-  if (key === 'Read' || key === 'Search') return 'category:Read+Search';
-  // Agent actions are grouped only inside the provider callback that emitted
-  // them. This keeps a later provider batch from changing an older outbound
-  // card above an intervening result/transcript boundary.
-  if (key === 'Agent') return agentBatch ? `category:Agent:${agentBatch}` : 'category:Agent';
-  return key ? `category:${key}` : 'default';
-}
-
-// Fold one call's category entries into an aggregate's header counts
-// (`categories` Map + first-seen `categoryOrder`), shared by the live card
-// and the restored transcript card.
-export function mergeAggregateCategoryEntries(aggregate, categoryEntries) {
-  for (const entry of categoryEntries) {
-    if (!aggregate.categories.has(entry.key)) aggregate.categoryOrder.push(entry.key);
-    const prev = aggregate.categories.get(entry.key);
-    aggregate.categories.set(entry.key, { ...entry, count: Number(prev?.count || 0) + Number(entry.count || 1) });
-  }
-}
-
-function aggregateSummaries(aggregate) {
-  return [...(aggregate?.calls?.values?.() || [])]
-    .filter((r) => r.summary)
-    .sort((a, b) => Number(a.summarySeq ?? 0) - Number(b.summarySeq ?? 0))
-    .map((r) => r.summary);
-}
-
-function assignAggregateSummaryOrder(aggregate, callRec) {
-  if (!aggregate || !callRec?.summary || callRec.summarySeq != null) return;
-  const next = Math.max(0, Number(aggregate.nextSummarySeq || 0));
-  callRec.summarySeq = next;
-  aggregate.nextSummarySeq = next + 1;
-}
-
-/** Live tool messages: a present uiDiff is always a string (empty if malformed). */
-export function uiDiffFromMessage(source) {
-  if (!source || typeof source !== 'object' || !Object.hasOwn(source, 'uiDiff')) return undefined;
-  return typeof source.uiDiff === 'string' ? source.uiDiff : '';
-}
-
-export function uiDiffPatchFromMessage(source) {
-  const value = uiDiffFromMessage(source);
-  return value === undefined ? {} : { uiDiff: value };
-}
-
-export function assignUiDiffFromMessage(target, source) {
-  const value = uiDiffFromMessage(source);
-  if (value === undefined || !target) return target;
-  target.uiDiff = value;
-  return target;
-}
-
-/** Stored/member records only copy a string uiDiff; other types stay omitted. */
-export function stringUiDiffPatch(value) {
-  return typeof value === 'string' ? { uiDiff: value } : {};
-}
-
-export function toolResultDisplay(message, rawText, toolName) {
-  const outcome = toolCallOutcome({ ...message, toolName }, rawText);
-  const isError = outcome.isCallError;
-  let text = rawText;
-  if (isError) text = toolErrorDisplay(rawText, toolName || 'tool');
-  else if (outcome.exitCode != null) text = stripShellExitHeader(rawText);
-  return { ...outcome, isError, text };
-}
-
-export function applyAggregateCallFields(
-  callRec,
-  aggregate,
-  { isError, isCallError, isExitError, exitCode, text, rawText, message } = {}
-) {
-  if (!callRec) return callRec;
-  callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
-  assignAggregateSummaryOrder(aggregate, callRec);
-  callRec.isError = isError;
-  callRec.isCallError = isCallError;
-  callRec.isExitError = isExitError;
-  callRec.exitCode = exitCode;
-  callRec.resultText = text;
-  callRec.rawResultText = rawText;
-  assignUiDiffFromMessage(callRec, message);
-  callRec.completedAt = callRec.completedAt || Date.now();
-  return callRec;
-}
-
-export function aggregateLoadingTargets(calls) {
-  const records = calls?.values ? [...calls.values()] : [...(calls || [])];
-  const groups = records.map((call) => toolLoadingTargets(call.name, call.args));
-  if (groups.length === 0 || !groups.every((targets) => targets.length > 0)) return [];
-  return [...new Set(groups.flat())];
-}
-
-export function aggregateResultPatch(aggregate, allCalls, completedCount) {
-  const errors = allCalls.filter((r) => r.isError).length;
-  const callErrors = allCalls.filter((r) => r.isCallError).length;
-  const exitErrors = allCalls.filter((r) => r.isExitError).length;
-  const succeeded = Math.max(0, completedCount - errors - exitErrors);
-  const displayDetail =
-    errors > 0 || exitErrors > 0
-      ? failureDetailText({
-          succeeded,
-          realErrors: callErrors,
-          exitErrors,
-          exitCode: allCalls.find((r) => r.isExitError)?.exitCode,
-        })
-      : formatAggregateDetail(aggregateSummaries(aggregate));
-  return {
-    result: displayDetail,
-    text: displayDetail,
-    isError: errors > 0,
-    errorCount: errors,
-    callErrorCount: callErrors,
-    exitErrorCount: exitErrors,
-    count: allCalls.length,
-    toolMembers: aggregateToolMembers(allCalls),
-  };
-}
+export * from '../../runtime/agent/orchestrator/session/transcript-restore/tool-result-status.mjs';