mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/session/store.mjs

@@ -3,10 +3,10 @@
  * Sessions are saved to disk so CLI and MCP server can share state,
  * and sessions survive server restarts (resume).
  */
-import { writeFileSync } from 'node:fs';
+import { closeSync, fsyncSync, openSync, writeFileSync } from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import { randomBytes } from 'node:crypto';
-import { sessionPath } from './store/paths-heartbeat.mjs';
+import { sessionPath } from './store/session-paths.mjs';
 import {
   guardedSaveOptions as _guardedSaveOptions,
   cancelSessionWrites as _cancelSessionWrites,
@@ -30,17 +30,6 @@ export {
   _upsertSessionSummary,
   _removeSessionSummary,
 } from './store-summary-index.mjs';
-export {
-  publishHeartbeat,
-  deleteHeartbeat,
-  publishSessionPresence,
-  deleteSessionPresence,
-  readSessionPresenceMtime,
-  isSessionPresenceOwnerDead,
-  readSessionHeartbeatOwnerPid,
-  isSessionHeartbeatOwnerDead,
-  isProcessAlive,
-} from './store/paths-heartbeat.mjs';
 import { _sessionForDisk, _ensureLifecycleFields } from './store/serialize.mjs';
 import {
   _cacheSessionSummary,
@@ -55,11 +44,9 @@ import {
   withdrawPendingOwnCommit as _withdrawPendingOwnCommit,
   recordOwnSessionCommit as _recordOwnSessionCommit,
 } from './store/canonical-reader.mjs';
-// Durable lifecycle reads, heartbeat freshness and live-cache reclamation are
-// owned by dedicated modules; re-exported so prior importers of store.mjs
-// stay unchanged.
+// Durable lifecycle reads and live-cache reclamation are owned by dedicated
+// modules; re-exported so prior importers of store.mjs stay unchanged.
 export { readSessionLifecycleFromDisk, readSessionLifecycleStateFromDisk } from './store/lifecycle-read.mjs';
-export { readSessionHeartbeatMtime } from './store/liveness-veto.mjs';
 export { evictLiveSession, evictIdleLiveSessions } from './store/live-cache-eviction.mjs';
 import {
   setLiveSession,
@@ -354,7 +341,15 @@ function _doSaveSync(payload) {
       attempted = JSON.stringify(disk);
       // The lifecycle these exact bytes carry, recorded with the commit stamp.
       const lifecycle = _lifecycleOfSessionDocument(disk);
-      writeFileSync(tmp, attempted, 'utf-8');
+      // fsync before the rename: without it an OS crash can publish the
+      // renamed file with its data blocks never written (all-NUL record).
+      const fd = openSync(tmp, 'w');
+      try {
+        writeFileSync(fd, attempted, 'utf-8');
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
       if (_shouldDrop(id, opts, attempt)) {
         _discardSaveTmp(tmp);
         if (mayMutate()) _recordSaveDrop(id, epoch);
@@ -636,7 +631,14 @@ async function _doSave(payload) {
     attempted = JSON.stringify(disk);
     // Captured before the await: the lifecycle of exactly these bytes.
     const lifecycle = _lifecycleOfSessionDocument(disk);
-    await fsp.writeFile(tmp, attempted, 'utf-8');
+    // fsync before the rename (see _doSaveSync).
+    const handle = await fsp.open(tmp, 'w');
+    try {
+      await handle.writeFile(attempted, 'utf-8');
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
     // Second check: between the temp write and the rename, closeSession()
     // may have planted a tombstone. Re-check on disk; if a newer tombstone
     // now exists, discard our temp file rather than let rename clobber it.
@@ -706,6 +708,7 @@ export { loadSession } from './store/load-session.mjs';
 // Hard delete + owned-agent enumeration live in store/session-delete.mjs;
 // re-exported here so prior importers of store.mjs stay unchanged.
 export { deleteSession, listOwnedAgentSessionIds } from './store/session-delete.mjs';
+export { fenceSessionWrites } from './store/live-state.mjs';
 
 // Listing / summaries live in store/listing.mjs and the stale sweep in
 // store/sweep/stale-sweep.mjs; re-exported here so importers keep one

package/src/runtime/agent/orchestrator/session/tool-batch/execute-call.mjs

@@ -78,7 +78,12 @@ export async function executeBatchCall(batch, call, callIndex) {
 // Read entries are stat-validated; scoped entries retain dependency
 // invalidation and their bounded TTL. A miss proceeds to execution.
 function lookupCaches(batch, call, exec) {
-  const cached = lookupToolResultReuse({ sessionId: batch.sessionId, call, cwd: batch.cwd });
+  const cached = lookupToolResultReuse({
+    sessionId: batch.sessionId,
+    call,
+    cwd: batch.cwd,
+    sessionRef: batch.sessionRef,
+  });
   if (cached?.kind === 'read') exec.readCacheHit = cached.entry;
   else if (cached?.kind === 'scoped') exec.scopedCacheHit = cached.entry;
 }
@@ -115,9 +120,7 @@ async function executeLive(batch, call, callIndex, exec) {
   // this session never received the discarded body.
   let discardedRead = false;
   if (eager !== undefined && eager.mutationEpoch < epoch.mutation && isEagerDispatchable(call.name, tools)) {
-    const stale = _isReadTool(call.name)
-      ? mutationAffectsRead(epoch, eager.mutationEpoch, call, batch.cwd)
-      : true;
+    const stale = _isReadTool(call.name) ? mutationAffectsRead(epoch, eager.mutationEpoch, call, batch.cwd) : true;
     if (stale) {
       discardedRead = _isReadTool(call.name);
       pending.delete(call.id);
@@ -176,14 +179,10 @@ async function executeSerially(batch, call, exec, suppressReadUnchangedStub = fa
   exec.executionStartedAt = Date.now();
   exec.serialExecutionStartedAt = exec.executionStartedAt;
   exec.localSearchTelemetry = {};
-  exec.result = await executeToolFn(
-    call.name,
-    call.arguments,
-    cwd,
-    sessionId,
-    sessionRef,
-    { ...invocationOptions(batch, call, exec), ...(suppressReadUnchangedStub ? { suppressReadUnchangedStub: true } : {}) }
-  );
+  exec.result = await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, {
+    ...invocationOptions(batch, call, exec),
+    ...(suppressReadUnchangedStub ? { suppressReadUnchangedStub: true } : {}),
+  });
   exec.toolEndedAt = Date.now();
   classifyExecuted(call, exec);
 }
@@ -208,6 +207,7 @@ function invocationOptions(batch, call, exec) {
     iteration: batch.iterations,
     localSearchTelemetry: exec.localSearchTelemetry || {},
     resultTelemetry: exec.resultTelemetry,
+    ...(call.wireCall ? { bridgeWireCall: call.wireCall } : {}),
   };
 }
 

package/src/runtime/agent/orchestrator/session/tool-batch/finalize.mjs

@@ -15,6 +15,8 @@ import { crossTurnSignature, isEditProgressTool } from '../loop/completion-guard
 import { isEagerDispatchable, isToolCallDedupEligible, parseNativeToolSearchPayload } from '../loop/tool-helpers.mjs';
 import { restoreToolCallBodyForId } from '../loop/stored-tool-args.mjs';
 import { stageToolResult } from './state.mjs';
+import { providerConsumesReadWindows } from '../../providers/registry.mjs';
+import { remoteReadWindowReport } from '../../tools/builtin/external-tool-adapters.mjs';
 import { toolMetaPatchFromMessage } from '../transcript-restore/tool-result-status.mjs';
 import {
   compactToolResultImage,
@@ -42,12 +44,30 @@ export async function finalizeBatchResults(batch) {
   for (const state of offloadStates) {
     if (state?.result && typeof state.result === 'object') state.result = await compactResultImages(state.result);
   }
+  await reportReadWindows(batch);
   for (let index = 0; index < batch.completed.length; index += 1) {
     postProcessCompleted(batch, batch.completed[index], offloadStates[index]);
     batch.throwIfAborted();
   }
 }
 
+// A provider that declares `consumesReadWindows` (also through a remote/proxy
+// stand-in) only receives the read text. Its read results carry the
+// structured clip report next to the text, for every serving path (live,
+// eager or cached). Failure fails closed.
+async function reportReadWindows(batch) {
+  if (!providerConsumesReadWindows(batch.sessionRef?.provider)) return;
+  for (const completed of batch.completed) {
+    if (!completed.executeOk || !_isReadTool(completed.call.name)) continue;
+    try {
+      const report = await remoteReadWindowReport(completed.call.arguments, batch.cwd, completed.result);
+      if (report) completed.readWindow = report;
+    } catch {
+      completed.readWindow = { lineClipped: true };
+    }
+  }
+}
+
 // An image no provider can take is replaced by fixed text here, before it can
 // reach the transcript and fail every later send.
 const unsupportedImageText = (mimeType) => `[image omitted: ${mimeType} is not a supported image type]`;
@@ -57,7 +77,10 @@ const UNDECODABLE_IMAGE_TEXT = '[image omitted: could not be decoded]';
 // inline image is fully decoded (not only large ones); with no decoder
 // installed the image is kept as is.
 async function rejectedImageText(base64, rawMime) {
-  const mimeType = String(rawMime || 'image/png').split(';')[0].trim().toLowerCase();
+  const mimeType = String(rawMime || 'image/png')
+    .split(';')[0]
+    .trim()
+    .toLowerCase();
   if (!SUPPORTED_IMAGE_MIME_TYPES.has(mimeType)) return unsupportedImageText(mimeType);
   try {
     await resizeImageBuffer(Buffer.from(base64, 'base64'), mimeType.split('/')[1]);
@@ -73,8 +96,8 @@ async function rejectedImageText(base64, rawMime) {
 // the result reaches the read cache or the transcript; stored history is never
 // revisited.
 export async function compactResultImages(result) {
-  const parts = Array.isArray(result) ? result : Array.isArray(result?.content) ? result.content : null;
-  if (!parts) return result;
+  const parts = Array.isArray(result) ? result : result?.content;
+  if (!Array.isArray(parts)) return result;
   let changed = false;
   const next = [];
   for (const part of parts) {
@@ -101,16 +124,16 @@ export async function compactResultImages(result) {
     if (dims.originalWidth !== dims.displayWidth || dims.originalHeight !== dims.displayHeight) {
       next.push({ type: 'text', text: supersedingImageMetadataText(dims) });
     }
-    next.push(
-      source
-        ? { ...part, source: { ...source, data: compacted.data, media_type: compacted.mimeType } }
-        : {
-            ...part,
-            data: compacted.data,
-            mimeType: compacted.mimeType,
-            ...(part.mediaType ? { mediaType: compacted.mimeType } : {}),
-          }
-    );
+    if (source) {
+      next.push({ ...part, source: { ...source, data: compacted.data, media_type: compacted.mimeType } });
+    } else {
+      next.push({
+        ...part,
+        data: compacted.data,
+        mimeType: compacted.mimeType,
+        ...(part.mediaType ? { mediaType: compacted.mimeType } : {}),
+      });
+    }
   }
   if (!changed) return result;
   return Array.isArray(result) ? next : { ...result, content: next };
@@ -281,6 +304,7 @@ function completedToolResult(completed, result, postprocessStartedAt) {
     toolKind: completed.resultKind,
     toolTiming: toolTiming(completed, postprocessStartedAt),
     ...(completed.nativeToolSearch ? { nativeToolSearch: completed.nativeToolSearch } : {}),
+    ...(completed.readWindow ? { readWindow: completed.readWindow } : {}),
     ...(uiDiff !== null ? { uiDiff } : {}),
     ...toolMetaPatchFromMessage(completed.result),
   };
@@ -319,7 +343,7 @@ function stagePostProcessingFailure(batch, completed, postErr, postprocessStarte
   if (sessionRef?._scopedCacheOutcomeByCallId instanceof Map && call?.id) {
     sessionRef._scopedCacheOutcomeByCallId.delete(call.id);
   }
-  if (call?.id) restoreToolCallBodyForId(batch.assistantTurnMsg, batch.calls, call.id);
+  if (call?.id) restoreToolCallBodyForId(batch.assistantTurnMsg, batch.wireCalls, call.id);
   const message = `Error: tool result post-processing failed for "${call.name}": ${postErr instanceof Error ? postErr.message : String(postErr)}`;
   traceAgentToolFailure({
     sessionId: batch.sessionId,

package/src/runtime/agent/orchestrator/session/tool-batch/pre-dispatch.mjs

@@ -3,7 +3,12 @@
 // and the repeat-failure / argument-shape guards. `skip` is the staged tool
 // message for a resolved call, or null when the call may execute.
 import { appendAgentTrace } from '../../agent-trace.mjs';
-import { _argShapeSig, _repeatFailureSig, _repeatFailurePatternWouldContinue } from '../loop/tool-classify.mjs';
+import {
+  _argShapeSig,
+  _repeatFailureSig,
+  _repeatFailurePatternWouldContinue,
+  requiresReadBody,
+} from '../loop/tool-classify.mjs';
 import { preDispatchDenyForSession } from '../loop/pre-dispatch-deny.mjs';
 import { crossTurnSignature, crossTurnDedupStub } from '../loop/completion-guards.mjs';
 import { isToolCallDedupEligible } from '../loop/tool-helpers.mjs';
@@ -27,7 +32,7 @@ export function preDispatchSkip(batch, call) {
       'error'
     );
   }
-  if (plan.duplicateCallIds.has(call.id)) {
+  if (plan.duplicateCallIds.has(call.id) && !requiresReadBody(call.name, sessionRef)) {
     const firstId = plan.dupFirstId.get(call.id);
     // Explicitly NOT a success: no tool executed for this call. 'skipped'
     // keeps the transcript/UI non-error while the unresolved-tool-failure
@@ -43,7 +48,7 @@ export function preDispatchSkip(batch, call) {
   let ctSig = null;
   if (isToolCallDedupEligible(call.name, tools)) {
     ctSig = crossTurnSignature(call.name, call.arguments);
-    const stub = crossTurnStub(batch, call, ctSig);
+    const stub = requiresReadBody(call.name, sessionRef) ? null : crossTurnStub(batch, call, ctSig);
     if (stub !== null) return skipped(stub, 'skipped', ctSig);
   }
   const sigs = {
@@ -60,7 +65,13 @@ export function preDispatchSkip(batch, call) {
 function crossTurnStub(batch, call, ctSig) {
   const prior = batch.crossTurnCalls.get(ctSig);
   if (!prior || prior.firstIteration >= batch.iterations) return null;
-  const cached = lookupToolResultReuse({ sessionId: batch.sessionId, call, cwd: batch.cwd, touch: false });
+  const cached = lookupToolResultReuse({
+    sessionId: batch.sessionId,
+    call,
+    cwd: batch.cwd,
+    touch: false,
+    sessionRef: batch.sessionRef,
+  });
   if (!cached || !prior.toolUseId || cached.entry.firstToolUseId !== prior.toolUseId) {
     batch.crossTurnCalls.delete(ctSig);
     return null;

package/src/runtime/agent/orchestrator/session/tool-batch/record-outcome.mjs

@@ -46,7 +46,7 @@ export async function recordCallOutcome(batch, call, exec, sigs, ctSig) {
   // otherwise hide behind a `[mixdog compacted …]` placeholder). Restored
   // immediately so an abort or post-processing throw cannot leave it
   // compacted; early-skipped calls stay compacted.
-  if (executed && failed && call?.id) restoreToolCallBodyForId(batch.assistantTurnMsg, batch.calls, call.id);
+  if (executed && failed && call?.id) restoreToolCallBodyForId(batch.assistantTurnMsg, batch.wireCalls, call.id);
   if (sessionId && _stripMcpPrefix(call.name) === 'apply_patch') {
     if (exec.executeOk && exec.resultKind === 'normal') invalidateAfterPatch(sessionId, call, cwd);
     // Mutation tools invalidate even on returned-error/partial-fail — the

package/src/runtime/agent/orchestrator/session/tool-batch/state.mjs

@@ -4,11 +4,17 @@
 // live here so processToolBatch can hand them back.
 import { executeTool } from '../loop/tool-exec.mjs';
 import { planToolBatch } from './plan.mjs';
+import { bridgeClassificationTools, resolveExecutionToolCalls } from '../loop/tool-call-resolution.mjs';
 
 export function createBatchState(ctx) {
-  const { calls, tools, assistantTurnMsg, sessionRef } = ctx;
+  const { assistantTurnMsg, sessionRef } = ctx;
+  // Bridged call_tool requests run as their targets from here on; the wire
+  // calls stay authoritative for the transcript and failed-argument restore.
+  const calls = resolveExecutionToolCalls(ctx.calls, sessionRef);
+  const tools = bridgeClassificationTools(ctx.tools, calls);
   return {
     calls,
+    wireCalls: ctx.calls,
     messages: ctx.messages,
     tools,
     cwd: ctx.cwd,

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -19,8 +19,10 @@ import { getPluginData } from '../config.mjs';
 import { countSplitLines, normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
 import { classifyResultKind } from './result-classification.mjs';
 import { registerSessionPurgeHook } from './store.mjs';
+import { SETUP_OUTPUT_MAX_BYTES } from '../../../shared/tool-output-limit.mjs';
 
 const TOOL_RESULT_OFFLOAD_THRESHOLD_CHARS = 50_000;
+const TOOL_RESULT_SETUP_THRESHOLD_CHARS = SETUP_OUTPUT_MAX_BYTES;
 const TOOL_RESULT_PREVIEW_CHARS = 512;
 const TOOL_RESULT_SHELL_THRESHOLD_CHARS = 30_000;
 const TOOL_RESULT_SEARCH_THRESHOLD_CHARS = 50_000;
@@ -61,6 +63,7 @@ const INLINE_THRESHOLD_BY_TOOL = new Map([
   ['bash_session', TOOL_RESULT_SHELL_THRESHOLD_CHARS],
   ['terminal', TOOL_RESULT_SHELL_THRESHOLD_CHARS],
   ['task', TOOL_RESULT_SHELL_THRESHOLD_CHARS],
+  ['setup', TOOL_RESULT_SETUP_THRESHOLD_CHARS],
 ]);
 
 function getOffloadThreshold(toolName) {
@@ -554,6 +557,7 @@ export const _internals = {
   TOOL_RESULT_SHELL_THRESHOLD_CHARS,
   TOOL_RESULT_SEARCH_THRESHOLD_CHARS,
   TOOL_RESULT_GREP_THRESHOLD_CHARS,
+  TOOL_RESULT_SETUP_THRESHOLD_CHARS,
   getOffloadThreshold,
   TOOL_RESULT_PREVIEW_CHARS,
   TOOL_RESULT_MESSAGE_MAX_CHARS,

package/src/runtime/agent/orchestrator/session/tool-schema-rejection.mjs

@@ -0,0 +1,79 @@
+// A provider 400 that names one tool's input schema (Anthropic
+// `tools.3.custom.input_schema`, OpenAI `Invalid schema for function 'x'` /
+// `tools[3].parameters`, Gemini `function_declarations[3]`): which tool of the
+// request it is, so the session can drop it instead of failing every turn.
+import { providerToolExclusionReason } from './loop/provider-tool-exclusions.mjs';
+import { providerNativeToolPrefixCount } from '../runtime-core/provider-request-tools.mjs';
+
+const MAX_REASON_CHARS = 240;
+
+const text = (value) => (typeof value === 'string' ? value : '');
+
+// Provider-structured places a rejection names its field, best evidence first:
+// OpenAI `param` (also nested under `error`), Anthropic / OpenAI `error.message`,
+// Google `details[].fieldViolations[].field`, then a JSON body, then the
+// error's own message.
+function evidence(error) {
+  const nested = [error?.error, error?.providerError, error?.response?.data?.error, error?.response?.data];
+  const violations = [error?.details, error?.error?.details, error?.errorDetails]
+    .flatMap((details) => (Array.isArray(details) ? details : []))
+    .flatMap((detail) => (Array.isArray(detail?.fieldViolations) ? detail.fieldViolations : []))
+    .flatMap((violation) => [text(violation?.field), text(violation?.description)]);
+  const bodies = [error?.body, error?.responseBody].map((body) => {
+    if (typeof body !== 'string') return [];
+    try {
+      const parsed = JSON.parse(body);
+      return [text(parsed?.error?.param), text(parsed?.error?.message), text(parsed?.message)];
+    } catch {
+      return [body];
+    }
+  });
+  return [
+    error?.param,
+    ...nested.map((entry) => entry?.param),
+    ...nested.map((entry) => entry?.message),
+    ...violations,
+    ...bodies.flat(),
+    error?.message,
+    error?.cause?.message,
+  ].filter((entry) => typeof entry === 'string' && entry);
+}
+
+// One piece of evidence -> which tool: a wire index (`byIndex`, with the
+// OpenAI Responses hosted-tool offset when `shifted`) or a function name.
+function target(entry) {
+  let match = /\btools\.(\d+)\.(?:custom\.)?input_schema/.exec(entry);
+  if (match) return { index: Number(match[1]) };
+  match = /\btools(?:\[(\d+)\]|\.(\d+))\.(?:function\.)?parameters/.exec(entry);
+  if (match) return { index: Number(match[1] ?? match[2]), shifted: true };
+  match = /\b(?:function_declarations|functionDeclarations)(?:\[(\d+)\]|\.(\d+))/.exec(entry);
+  if (match) return { index: Number(match[1] ?? match[2]) };
+  match = /Invalid schema for function ['"`]([^'"`]+)['"`]/.exec(entry);
+  if (match) return { name: match[1] };
+  return null;
+}
+
+/** `{ name, pointer, reason }` of the tool a schema 400 points at, or null (any
+ *  other error, or a tool that is not part of the request's own tools). */
+export function rejectedToolSchema(error, { sendTools, sessionRef, opts }) {
+  if ((error?.httpStatus ?? error?.status ?? error?.statusCode) !== 400) return null;
+  const tools = Array.isArray(sendTools) ? sendTools : [];
+  const nativeCount = providerNativeToolPrefixCount(tools);
+  // The wire list: the request's tools minus those the wire left out.
+  const wire = tools.filter((tool) => !providerToolExclusionReason(sessionRef, tool?.name));
+  const hosted =
+    sessionRef?.wireRoute?.wire !== 'chat' && Array.isArray(opts?.nativeTools) ? opts.nativeTools.length : 0;
+  const entries = evidence(error);
+  let name = '';
+  for (const entry of entries) {
+    const found = target(entry);
+    if (!found) continue;
+    const shift = found.shifted ? hosted : 0;
+    const tool = found.name ? wire.find((t) => t?.name === found.name) : wire[found.index - shift];
+    name = typeof tool?.name === 'string' ? tool.name : '';
+    if (name) break;
+  }
+  if (!name || tools.findIndex((t) => t?.name === name) < nativeCount) return null;
+  const detail = entries.join(' ').replace(/\s+/g, ' ').trim().slice(0, MAX_REASON_CHARS);
+  return { name, pointer: '/', reason: `the provider rejected it with HTTP 400: ${detail}` };
+}

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -37,8 +37,24 @@ import {
   isTranscriptCancelledStatusText,
 } from '../../../../shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../../../shared/tool-status.mjs';
-import { transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+import { transcriptAttachmentFields, transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
 import { isImportedMessage } from '../imported-message.mjs';
+import { isContextAckMessage } from '../compact/user-message-kind.mjs';
+
+/** A failed turn's recorded end: its route, reason and quota stop, the same
+ *  fields the live turndone carries. */
+function restoredFailureFields(value) {
+  if (value.status !== 'failed') return {};
+  const errorKind = value.errorKind && typeof value.errorKind === 'object' ? value.errorKind : null;
+  const quota = value.quota && typeof value.quota === 'object' ? value.quota : null;
+  return {
+    ...transcriptRouteMetadataFields(value),
+    ...(typeof value.detail === 'string' && value.detail ? { detail: value.detail } : {}),
+    ...(typeof value.errorDetails === 'string' && value.errorDetails ? { errorDetails: value.errorDetails } : {}),
+    ...(errorKind && typeof errorKind.kind === 'string' ? { errorKind: { ...errorKind } } : {}),
+    ...(quota && typeof quota.provider === 'string' ? { quota: { ...quota } } : {}),
+  };
+}
 
 function restoredTranscriptMetadata(message) {
   const value = message?.meta?.transcript;
@@ -53,6 +69,10 @@ function restoredTranscriptMetadata(message) {
     if (typeof completionValue.checkpointId === 'string' && completionValue.checkpointId) {
       completion.checkpointId = completionValue.checkpointId;
     }
+    Object.assign(completion, restoredFailureFields(completionValue));
+    const attemptId = completionValue.attemptId || value.attemptId;
+    if (typeof attemptId === 'string' && attemptId) completion.attemptId = attemptId;
+    if (Number.isFinite(Number(completionValue.at))) completion.at = Number(completionValue.at);
   }
   return {
     // The stable message id lets a live view map a compaction's dropped
@@ -63,6 +83,9 @@ function restoredTranscriptMetadata(message) {
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
     ...(typeof value.device === 'string' && value.device ? { device: value.device } : {}),
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    // The attachments this prompt carried, by content hash: a restored row
+    // opens/downloads them by id from the attachment store.
+    ...transcriptAttachmentFields(value),
     // Skills this user turn explicitly loaded (header selection or `$name`).
     ...(Array.isArray(value.appliedSkills) && value.appliedSkills.length
       ? { appliedSkills: value.appliedSkills.filter((name) => typeof name === 'string' && name) }
@@ -71,24 +94,45 @@ function restoredTranscriptMetadata(message) {
   };
 }
 
+function restoredTurnDoneItem(completion, metadata, nextId, finalAssistantId = '') {
+  const at = Number.isFinite(completion.at) ? completion.at : metadata.at;
+  return {
+    kind: 'turndone',
+    id: nextId(),
+    ...completion,
+    ...(completion.status === 'done' && finalAssistantId ? { finalAssistantId } : {}),
+    ...(Number.isFinite(at) ? { at } : {}),
+    ...(metadata.messageId ? { messageId: metadata.messageId } : {}),
+  };
+}
+
 function restoredAssistantTranscriptItems(message, nextId) {
   const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)).trim();
   if (!text) return [];
   const { completion, ...metadata } = restoredTranscriptMetadata(message);
   const items = [{ kind: 'assistant', id: nextId(), text, ...metadata }];
-  if (completion) {
-    items.push({
-      kind: 'turndone',
-      id: nextId(),
-      ...completion,
-      ...(completion.status === 'done' ? { finalAssistantId: items[0].id } : {}),
-      ...(metadata.at ? { at: metadata.at } : {}),
-      ...(metadata.messageId ? { messageId: metadata.messageId } : {}),
-    });
+  // A failed end follows the message's tool calls (restoreTranscriptRange).
+  if (completion && completion.status !== 'failed') {
+    items.push(restoredTurnDoneItem(completion, metadata, nextId, items[0].id));
   }
   return items;
 }
 
+/** The failed end recorded on a message that holds no reply text before it:
+ *  the prompt itself, a tool call or a tool result. */
+function restoredFailedTurnItems(message, nextId) {
+  const { completion, ...metadata } = restoredTranscriptMetadata(message);
+  const previous = Array.isArray(message?.meta?.transcript?.previousCompletions)
+    ? message.meta.transcript.previousCompletions
+    : [];
+  const items = previous.flatMap((value) => {
+    const historical = restoredTranscriptMetadata({ meta: { transcript: { completion: value, at: value?.at } } });
+    return historical.completion ? [restoredTurnDoneItem(historical.completion, historical, nextId)] : [];
+  });
+  if (completion?.status === 'failed') items.push(restoredTurnDoneItem(completion, metadata, nextId));
+  return items;
+}
+
 // Restored tool cards: stored assistant messages keep their (compacted)
 // tool_calls and the follow-up role:'tool' results. Rebuild one transcript
 // tool item per call and attach its result by tool_call_id, so a reopened
@@ -289,13 +333,17 @@ function restoredMessageItemUpperBound(message) {
   const boundaries =
     (Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0) +
     (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0);
-  if (message?.role === 'user') return 1 + boundaries;
-  if (message?.role !== 'assistant') return boundaries;
+  const completionCount =
+    Number(Boolean(message?.meta?.transcript?.completion)) +
+    (Array.isArray(message?.meta?.transcript?.previousCompletions)
+      ? message.meta.transcript.previousCompletions.length
+      : 0);
+  if (message?.role === 'user') return 1 + completionCount + boundaries;
+  if (message?.role !== 'assistant') return completionCount + boundaries;
   const calls = restoredMessageToolCalls(message);
   const content = message?.content;
   const hasContent = typeof content === 'string' ? content.length > 0 : Array.isArray(content) && content.length > 0;
-  const hasCompletion = Boolean(message?.meta?.transcript?.completion);
-  return Number(hasContent) + Number(hasCompletion) + calls.length + boundaries;
+  return Number(hasContent) + completionCount + calls.length + boundaries;
 }
 
 // One restored tool card for a parsed notification/completion envelope.
@@ -404,12 +452,14 @@ function restoreTranscriptRange(messages, start, sessionId) {
     const restoredId = () => `hist_${sessionId}_${index}_${++part}`;
     if (message?.role === 'user') {
       items.push(...restoredUserTranscriptItems(message, restoredId));
-    } else if (message?.role === 'assistant') {
+    } else if (message?.role === 'assistant' && !isContextAckMessage(message, messages[index - 1])) {
       items.push(...restoredAssistantTranscriptItems(message, restoredId));
       items.push(...restoredToolCallItems(message, restoredId, pendingToolCalls));
     } else if (message?.role === 'tool') {
       attachRestoredToolResult(message, pendingToolCalls);
     }
+    const eventStart = items.length;
+    items.push(...restoredFailedTurnItems(message, restoredId));
     for (const boundary of Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances : []) {
       if (!boundary?.sessionId || !boundary?.provider || !boundary?.modelId) continue;
       items.push({
@@ -427,6 +477,13 @@ function restoreTranscriptRange(messages, start, sessionId) {
       if (!boundary?.provider || !boundary?.modelId) continue;
       items.push(modelSwitchItem(restoredId(), boundary));
     }
+    if (message?.meta?.transcript?.previousCompletions?.length) {
+      const events = items.slice(eventStart);
+      if (events.every((item) => Number.isFinite(item.at))) {
+        events.sort((left, right) => left.at - right.at);
+        items.splice(eventStart, events.length, ...events);
+      }
+    }
   }
   return mergeRestoredToolItems(items);
 }

package/src/runtime/agent/orchestrator/session/turn-failure.mjs

@@ -0,0 +1,45 @@
+// The failed-turn record shared by the live turn close (tui/session/turn.mjs)
+// and the durable turn end (manager/ask-turn-failure.mjs), so a reopened
+// session shows the same failure, reason and quota stop as the live one.
+import { errText } from '../../../shared/err-text.mjs';
+import { safeErrorDetails } from '../../../shared/error-presentation.mjs';
+import { providerErrorKind } from '../providers/provider-error-kind.mjs';
+import { toolErrorDisplay } from './transcript-restore/tool-result-text.mjs';
+
+/**
+ * `{ providerKind, errorKind, quota, detail, errorDetails }` for one turn
+ * error. `quota` is null unless the pool validated an exhaustion or the
+ * provider named the real reset time; `route` fills its provider/model.
+ */
+export function turnFailureRecord(error, route = {}) {
+  // Presentation only: legacy untyped failure text may still name a usage limit.
+  const providerKind = providerErrorKind(error, { legacyQuotaWording: true });
+  const errorKind = {
+    kind: providerKind.kind,
+    code: providerKind.code,
+    status: providerKind.status,
+    retryAfterMs: providerKind.retryAfterMs,
+    resetAt: providerKind.resetAt,
+  };
+  const exhausted = error?.quotaExhausted;
+  const resetKnown = providerKind.kind === 'quota_exhausted' && Number.isFinite(providerKind.resetAt);
+  let quota = null;
+  if ((exhausted && typeof exhausted === 'object') || resetKnown) {
+    const source = exhausted && typeof exhausted === 'object' ? exhausted : {};
+    let resetAt = null;
+    if (Number.isFinite(source.resetAt)) resetAt = source.resetAt;
+    else if (Number.isFinite(providerKind.resetAt)) resetAt = providerKind.resetAt;
+    quota = {
+      provider: String(source.provider || route.provider || ''),
+      model: String(source.model || route.model || ''),
+      resetAt,
+    };
+  }
+  return {
+    providerKind,
+    errorKind,
+    quota,
+    detail: toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, ''),
+    errorDetails: safeErrorDetails(errText(error)),
+  };
+}