mixdog 1.2.4 → 1.2.6

package/src/runtime/agent/orchestrator/session/manager/ask-turn-steering-drain.mjs

@@ -3,7 +3,12 @@
 // prompts at every continuation boundary, plus — at the TERMINAL boundary only
 // — the manager's pending-message entries, grouped into one steering item per
 // mode and adopted by this turn (so their delivery/ack/release rides it).
-import { _groupPendingMessageEntries, drainPendingMessages, releasePendingMessages } from './pending-messages.mjs';
+import {
+  _groupPendingMessageEntries,
+  drainPendingMessages,
+  pendingQueueHoldsOnlyNotifications,
+  releasePendingMessages,
+} from './pending-messages.mjs';
 
 /**
  * @param {object} input
@@ -26,9 +31,12 @@ export function createAskSteeringDrain({ sessionId, turn, askOpts }) {
         /* best-effort steering drain */
       }
     }
-    // Manager/pending-messages entries carry no mode/priority/slash
-    // metadata, so they stay OUT of the mid-chain (post-tool-batch) drain —
-    // that would bypass the queued-command filters. At the TERMINAL boundary
+    // Manager/pending-messages prompts carry no priority/slash metadata, so
+    // they stay OUT of the mid-chain (post-tool-batch) drain — that would
+    // bypass the queued-command filters. A queue holding only task
+    // notifications (agent/shell completions, which also end a passive wait)
+    // is taken at every boundary, so a completion reaches the very next model
+    // request instead of waiting for the model to stop. At the TERMINAL boundary
     // they are exactly pending input: an `agent type=send` queued while the
     // terminal sample was in flight must be folded into THIS turn before any
     // stop hook runs, instead of losing its slot to a synthetic continuation
@@ -36,7 +44,7 @@ export function createAskSteeringDrain({ sessionId, turn, askOpts }) {
     // nothing. Entries consumed here join the turn's pending entries: their
     // delivery/ack (and release on failure) rides this turn, and the
     // post-loop drain can no longer see them.
-    if (drainOptions?.stage === 'terminal') {
+    if (drainOptions?.stage === 'terminal' || pendingQueueHoldsOnlyNotifications(sessionId)) {
       const pendingNow = drainPendingMessages(sessionId);
       if (pendingNow.length > 0) {
         // One steering entry per mode group: the merged prompt (if any) and

package/src/runtime/agent/orchestrator/session/manager/pending-message-entry.mjs

@@ -103,12 +103,15 @@ function completionEntryFields(entry) {
   };
 }
 
-export function completionWasDelivered(entry, site) {
+/** True when this completion entry already reached the model (no log). */
+export function completionIsDelivered(entry) {
   if (!isCompletionNotificationEntry(entry)) return false;
-  const executionId = completionExecutionId(entry);
-  const text = pendingMessageText(entry);
-  if (!isDeliveredCompletion({ executionId, text })) return false;
-  logDuplicateSkip(site, { executionId, text });
+  return isDeliveredCompletion({ executionId: completionExecutionId(entry), text: pendingMessageText(entry) });
+}
+
+export function completionWasDelivered(entry, site) {
+  if (!completionIsDelivered(entry)) return false;
+  logDuplicateSkip(site, { executionId: completionExecutionId(entry), text: pendingMessageText(entry) });
   return true;
 }
 
@@ -166,7 +169,7 @@ function explicitModeField(entry) {
   return entry?.mode === PENDING_MODE_TASK_NOTIFICATION ? { mode: PENDING_MODE_TASK_NOTIFICATION } : {};
 }
 
-export function normalizePendingMessageEntry(entry) {
+function normalizePendingMessageEntry(entry) {
   if (typeof entry === 'string') {
     const text = entry.trim();
     return text ? { content: text, text } : null;
@@ -211,7 +214,7 @@ export function normalizePendingMessageEntry(entry) {
   return carryLifecycleToken(marker ? { ...out, ...identity, ...marker } : { ...out, ...identity }, entry);
 }
 
-export function pendingMessageText(entry) {
+function pendingMessageText(entry) {
   const normalized = normalizePendingMessageEntry(entry);
   return normalized ? String(normalized.text || promptContentText(normalized.content) || '').trim() : '';
 }

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -29,6 +29,12 @@ import {
   pruneEmptyPendingIdSet,
 } from './pending-claim-ledger.mjs';
 import { legacyPendingMessagesPath } from './pending-spool-path.mjs';
+import {
+  TASK_WAIT_WAKE_NOTIFICATION,
+  TASK_WAIT_WAKE_USER,
+  interruptTaskWaitForSession,
+  registerTaskWaitSteeringCheck,
+} from '../task-wait-control.mjs';
 import { pruneCleanupConfirmedLedger } from './pending-delivered-ledger.mjs';
 // The durable delivered-id ledger on the session record lives in
 // pending-delivered-ledger.mjs; re-exported so prior importers stay unchanged.
@@ -51,6 +57,8 @@ import {
   PENDING_MODE_TASK_NOTIFICATION,
   _groupPendingMessageEntries,
   _mergePendingMessageEntries,
+  completionExecutionId,
+  completionIsDelivered,
   completionWasDelivered,
   entryLifecycleToken,
   isCompletionNotificationEntry,
@@ -447,9 +455,52 @@ export function enqueuePendingMessage(sessionId, message) {
   }
   q.push(entry);
   const bufferedDepth = schedulePendingMessagePersist(sessionId, entry);
+  const wake = pendingEntryWake(entry);
+  if (wake) {
+    interruptTaskWaitForSession(
+      sessionId,
+      wake,
+      wake === TASK_WAIT_WAKE_NOTIFICATION ? completionExecutionId(entry) : null
+    );
+  }
   return Math.max(q.length, bufferedDepth || 0);
 }
 
+// What one queued entry wakes a passive task wait or shell hold for, so it
+// reaches the loop now: steering (a Lead message to its agent) as user input,
+// and an undelivered task completion (agent/shell, any status). A plain
+// channel notice (scheduled or event-rule inject) waits for the turn, as it
+// does in the Lead's queue.
+function pendingEntryWake(entry) {
+  if (pendingEntryMode(entry) === PENDING_MODE_PROMPT) return TASK_WAIT_WAKE_USER;
+  if (isCompletionNotificationEntry(entry) && !completionIsDelivered(entry)) return TASK_WAIT_WAKE_NOTIFICATION;
+  return false;
+}
+
+// Anything already queued when a wait or hold begins ends it at once, exactly
+// like what arrives during it. A completion the agent already received is no
+// longer deliverable and never wakes.
+registerTaskWaitSteeringCheck((sessionId) => {
+  let wake = false;
+  for (const entry of _sessionPendingMessages.get(sessionId) || []) {
+    const found = pendingEntryWake(entry);
+    if (found === TASK_WAIT_WAKE_USER) return found;
+    wake = wake || found;
+  }
+  return wake;
+});
+
+// True when this session's queue holds task notifications and nothing else:
+// the mid-chain boundary may then take the whole queue without bypassing the
+// prompt filters that keep queued prompts for the terminal boundary.
+export function pendingQueueHoldsOnlyNotifications(sessionId) {
+  const queued = [
+    ...(_sessionPendingMessages.get(sessionId) || []),
+    ...(_hydratedPendingMessages.get(sessionId) || []),
+  ];
+  return queued.length > 0 && queued.every((entry) => pendingEntryMode(entry) === PENDING_MODE_TASK_NOTIFICATION);
+}
+
 // Drain order: enqueue time, then source (hydrated < buffered < memory), then
 // position within the source.
 function byEnqueueOrder(a, b) {
@@ -468,19 +519,13 @@ export function drainPendingMessages(sessionId) {
   // This path is deliberately memory-only: no file lock, stat, parse, or
   // atomic rename can run in the agent-completion tick.
   const buffered = takeBufferedPendingMessages(sessionId);
-  // Deferred completion/task notifications are dropped ONLY from the persisted
-  // (disk/buffer) path. Those are the entries a later session resume/restart
-  // would replay out-of-order into a future turn, once the in-memory queue is
-  // gone — discarding them there is the deliberate owner decision.
-  // Live in-memory completions (fallback/headless enqueues delivered within
-  // THIS process, e.g. the idle-resume kick that surfaces the model-visible
-  // body) are the intended payload and MUST survive the drain — filtering
-  // them here dropped the notification entirely. On a genuine resume the
-  // in-memory queue is empty, so keeping it only ever delivers live entries.
-  // Genuine user/steering messages carry no marker and are kept in order in
-  // both paths.
-  // Drain-time belt: drop MARKED in-memory completion entries whose text hash
-  // was already delivered+ACKed (TUI execution-ui) this process — those would
+  // A completion that reached the spool and was never acknowledged was never
+  // delivered to the model (delivery acknowledges and removes it), so it
+  // survives a restart: the hydrated disk entries drain like live in-memory
+  // ones. Dropping them on resume lost a finished (or failed) task's only
+  // notification.
+  // Drain-time belt: drop MARKED completion entries whose text hash was
+  // already delivered+ACKed (TUI execution-ui) this process — those would
   // double-inject next turn. Only marked completion entries are eligible;
   // genuine user/steering entries carry no marker and are always kept.
   const deliveredIds = new Set();
@@ -494,10 +539,11 @@ export function drainPendingMessages(sessionId) {
     deliveredEntries.push(entry);
     return false;
   };
+  const hydratedKept = hydrated.filter(keepUndelivered);
   const memoryKept = memory.filter(keepUndelivered);
   const bufferedKept = buffered.filter(keepUndelivered);
   const tagged = [
-    ...hydrated.map((entry, index) => ({ entry, source: 0, index })),
+    ...hydratedKept.map((entry, index) => ({ entry, source: 0, index })),
     ...bufferedKept.map((entry, index) => ({ entry, source: 1, index })),
     ...memoryKept.map((entry, index) => ({ entry, source: 2, index })),
   ];
@@ -512,14 +558,8 @@ export function drainPendingMessages(sessionId) {
     if (!prior || item.source > prior.source) byId.set(normalized.id, { ...item, entry: normalized });
   }
   const ordered = [...byId.values()].sort(byEnqueueOrder);
-  const dropped = ordered
-    .filter(({ entry, source }) => source === 0 && isCompletionNotificationEntry(entry))
-    .map(({ entry }) => entry);
-  const acknowledged = [...deliveredEntries, ...dropped];
-  if (acknowledged.length > 0) acknowledgePendingMessages(sessionId, acknowledged);
-  const visible = modelVisiblePendingMessages(
-    ordered.filter(({ entry }) => !dropped.includes(entry)).map(({ entry }) => entry)
-  );
+  if (deliveredEntries.length > 0) acknowledgePendingMessages(sessionId, deliveredEntries);
+  const visible = modelVisiblePendingMessages(ordered.map(({ entry }) => entry));
   // Epoch gate. Normalization above rebuilds every entry, but each copy
   // inherits the IMMUTABLE token the entry was accepted under. An entry from
   // an older epoch (a cross-process close/detach moved the generation while

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -23,6 +23,7 @@
 // }
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
 import { emitSessionApprovalWaitChange } from '../../../../shared/session-approval-wait.mjs';
+import { emitSessionActivityChange } from '../../../../shared/session-activity-signal.mjs';
 import { DEFAULT_ACTIVITY_HEARTBEAT_MS } from '../../stall-policy.mjs';
 import { MODEL_THINKING_STAGE, awaitingModelResponse, lastProgressAt } from '../../../../shared/quiet-progress.mjs';
 import { finishBrowserTurn } from '../../../../browser-bridge/client.mjs';
@@ -177,12 +178,14 @@ export function markSessionAskStart(id) {
   entry.modelRequestStartedAt = null;
   entry.lastProgressAt = now;
   entry.updatedAt = now;
+  entry.taskWaits = 0;
+  emitSessionActivityChange(id);
 }
 /** The provider put the request on the wire; its response headers are
  *  pending. The turn stays `requesting` (every stage set and the watchdog
  *  clock are unchanged); the send time lets surfaces show "model thinking"
  *  until transport arrives. Not progress: lastProgressAt is untouched. */
-export function markSessionRequestSent(id) {
+function markSessionRequestSent(id) {
   if (!id) return;
   const entry = _runtimeState.get(id);
   if (!entry || entry.closed || entry.controller?.signal?.aborted || entry.stage !== 'requesting') return;
@@ -321,6 +324,23 @@ export function beginSessionApprovalWait(id) {
     emitSessionApprovalWaitChange(id, null, meta);
   };
 }
+// A turn parked on a background task (`task wait`): published as
+// `awaitingTask` so status surfaces show the session waiting, not working.
+// Counted like approval waits; never creates an entry. Returns the idempotent
+// release.
+export function beginSessionTaskWait(id) {
+  const entry = id ? _runtimeState.get(id) : null;
+  if (!entry) return () => {};
+  entry.taskWaits = (entry.taskWaits || 0) + 1;
+  if (entry.taskWaits === 1) emitSessionActivityChange(id);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    entry.taskWaits = Math.max(0, (entry.taskWaits || 0) - 1);
+    if (entry.taskWaits === 0) emitSessionActivityChange(id);
+  };
+}
 // Parent AbortSignal listeners are dropped on askSession unwind (finally /
 // terminal return) and on error/cancel/close — not in markSessionDone, which
 // also runs between queued follow-up turns within one ask.
@@ -335,6 +355,8 @@ function _settleTerminalEntry(entry, stage, lastError) {
   entry.doneAt = settledAt;
   entry.lastProgressAt = settledAt;
   entry.updatedAt = settledAt;
+  entry.taskWaits = 0;
+  emitSessionActivityChange(entry.session?.id || '');
 }
 export function markSessionDone(id, { empty = false } = {}) {
   if (!id) return;

package/src/runtime/agent/orchestrator/session/manager/session-close.mjs

@@ -3,7 +3,16 @@
 // when tombstone=false), aborts the in-flight controller, tears down
 // runtime/bash/dedup/offload/pending state, and defers the runtime-map clear.
 // abortSessionTurn cancels the current turn without tombstoning.
-import { markSessionClosed, bumpSessionGeneration, getSessionLifecycleCommitError } from '../store.mjs';
+import {
+  markSessionClosed,
+  markSessionClosedAsync,
+  markSessionClosedAttempt,
+  bumpSessionGeneration,
+  bumpSessionGenerationAttempt,
+  isLifecycleRetry,
+  getSessionLifecycleCommitError,
+} from '../store.mjs';
+import { sleep } from '../../../../shared/sleep.mjs';
 import { clearReadDedupSession } from '../read-dedup.mjs';
 import { SessionClosedError } from './session-errors.mjs';
 import { _dropPendingMessageState } from './pending-messages.mjs';
@@ -36,44 +45,79 @@ import { forgetSideQuestion } from '../side-question-store.mjs';
  * TOMBSTONE_MAX_AGE_MS (1h — vastly longer than the microsecond in-flight race).
  */
 export function closeSession(id, reason = 'manual', opts = {}) {
-  // tombstone=false: detach runtime resources (heartbeat, bash shells,
-  // controller abort, runtime-map clear) WITHOUT planting the disk
-  // tombstone. Used for non-empty sessions on /resume-away, /new, and
-  // TUI exit: a tombstone would drop the session from the Resume list
-  // immediately and let sweepTombstones() hard-delete it even though it
-  // has real conversation content worth resuming. Only truly-empty
-  // scratch sessions should still tombstone.
-  const tombstone = opts.tombstone !== false;
   if (!id) return false;
+  const tombstone = opts.tombstone !== false;
   const entry = _getRuntimeEntry(id);
-  // askSession owns the interruption tracker that can merge committed
-  // iterations, the current partial response, and observed tool results into
-  // one canonical transcript. Stage that in-memory snapshot synchronously
-  // BEFORE the lifecycle generation changes; once generation is bumped, the
-  // normal cancellation cleanup save is intentionally rejected as stale. It
-  // is only staged: a refused barrier rolls it back so the turn keeps running
-  // and checkpointing as if no close had been attempted.
-  let closeSnapshot = null;
-  try {
-    closeSnapshot = entry?.prepareCloseSnapshot?.tentative?.(reason) ?? null;
-  } catch {
-    /* best-effort */
-  }
-  // 1. Tombstone first — this wins the race against saveSession().
-  //    Skipped when tombstone=false: no closed:true marker is planted, so
-  //    the session file stays intact and resumeSession() will accept it.
-  //    We still bump the on-disk generation via bumpSessionGeneration() —
-  //    that alone is what protects the session from a late save race: any
-  //    saveSession() still in flight from this detached turn (e.g. the
-  //    cancel-cleanup save below) carries the OLD generation as its
-  //    expectedGeneration, so _shouldDrop()'s ownership-counter rule drops
-  //    it once disk generation moves past that. Without this bump the late
-  //    write could silently overwrite the session after the user resumes
-  //    it back (BL: burned-session late-save clobber).
+  const closeSnapshot = stageCloseSnapshot(entry, reason);
   const outcome = { absent: false };
   const newGen = tombstone
     ? markSessionClosed(id, reason, { outcome })
     : bumpSessionGeneration(id, reason, { outcome });
+  return finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outcome });
+}
+
+/**
+ * closeSession that never blocks the event loop. Each barrier attempt runs
+ * synchronously exactly as closeSession's barrier does (the first one before
+ * this function first yields), but a rename the OS refuses with retries left
+ * is waited out with a timer instead of sleepSync. Between attempts the staged
+ * close snapshot is rolled back, so the turn keeps running untouched, and it
+ * is re-staged from the then-current turn right before the next attempt: the
+ * barrier that lands always carries the latest transcript. The session is
+ * torn down — and reported closed — only after its barrier is on disk.
+ */
+export async function closeSessionAsync(id, reason = 'manual', opts = {}) {
+  if (!id) return false;
+  const tombstone = opts.tombstone !== false;
+  const entry = _getRuntimeEntry(id);
+  for (let attempt = 0; ; attempt++) {
+    const closeSnapshot = stageCloseSnapshot(entry, reason);
+    const outcome = { absent: false };
+    const newGen = tombstone
+      ? markSessionClosedAttempt(id, reason, { outcome }, attempt)
+      : bumpSessionGenerationAttempt(id, reason, { outcome }, attempt);
+    if (!isLifecycleRetry(newGen)) {
+      return finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outcome });
+    }
+    closeSnapshot?.rollback();
+    await sleep(newGen.retryInMs);
+  }
+}
+
+// askSession owns the interruption tracker that can merge committed
+// iterations, the current partial response, and observed tool results into
+// one canonical transcript. Stage that in-memory snapshot synchronously
+// BEFORE the lifecycle generation changes; once generation is bumped, the
+// normal cancellation cleanup save is intentionally rejected as stale. It
+// is only staged: a refused barrier rolls it back so the turn keeps running
+// and checkpointing as if no close had been attempted.
+function stageCloseSnapshot(entry, reason) {
+  try {
+    return entry?.prepareCloseSnapshot?.tentative?.(reason) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// tombstone=false: detach runtime resources (heartbeat, bash shells,
+// controller abort, runtime-map clear) WITHOUT planting the disk
+// tombstone. Used for non-empty sessions on /resume-away, /new, and
+// TUI exit: a tombstone would drop the session from the Resume list
+// immediately and let sweepTombstones() hard-delete it even though it
+// has real conversation content worth resuming. Only truly-empty
+// scratch sessions should still tombstone.
+//
+// The barrier (`newGen`) came first — it wins the race against saveSession().
+// tombstone=false plants no closed:true marker, so the session file stays
+// intact and resumeSession() will accept it, but the on-disk generation is
+// still bumped (bumpSessionGeneration): that alone protects the session from
+// a late save race. Any saveSession() still in flight from this detached turn
+// (e.g. the cancel-cleanup save below) carries the OLD generation as its
+// expectedGeneration, so _shouldDrop()'s ownership-counter rule drops it once
+// disk generation moves past that. Without this bump the late write could
+// silently overwrite the session after the user resumes it back (BL:
+// burned-session late-save clobber).
+function finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outcome }) {
   // Durable lifecycle barrier check. ANY nonnumeric result means the barrier
   // is not on disk — a write failure, a liveness/ownership veto, a contended
   // commit lock, or a missing record. Only a failed write publishes a
@@ -154,7 +198,10 @@ function reportCloseBarrierFailure({ id, reason, tombstone, entry }) {
  */
 function cancelOwnedShellProcesses({ id, reason, tombstone }) {
   const record = (result) => {
-    if (tombstone && result?.confirmed === false) markSessionClosed(id, reason, { cancelStatus: 'cancel-unconfirmed' });
+    // Off the event loop's critical path: a refused rename retries on timers.
+    if (tombstone && result?.confirmed === false) {
+      markSessionClosedAsync(id, reason, { cancelStatus: 'cancel-unconfirmed' }).catch(() => {});
+    }
   };
   // A cancel that threw proved nothing either.
   const unconfirmed = () => record({ confirmed: false });

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

@@ -122,6 +122,6 @@ export {
 export { deleteSession, listOwnedAgentSessionIds, fenceSessionWrites } from './store.mjs';
 // Read-only parsed-session access (desktop pane peek): no resume, no
 // ownership, no liveness side effects.
-export { loadSession } from './store.mjs';
-export { closeSession, abortSessionTurn, unloadSessionRuntime } from './manager/session-close.mjs';
+export { loadSession, loadSessionStatus } from './store.mjs';
+export { closeSession, closeSessionAsync, abortSessionTurn, unloadSessionRuntime } from './manager/session-close.mjs';
 export { sweepTombstones, startIdleCleanup, stopIdleCleanup } from './manager/idle-cleanup.mjs';

package/src/runtime/agent/orchestrator/session/request-fork.mjs

@@ -0,0 +1,47 @@
+// request-fork.mjs — a cache-sharing fork of a provider request the main loop
+// already sent (side-question-store.mjs): its messages unchanged, then the
+// reply that request produced and one appended user turn. Reusing the saved
+// send options keeps the model, system prompt, tools and cache-relevant
+// options identical, so the provider's prompt cache serves the prefix.
+import { collectAssistantToolCallIds } from './context-tool-pairs.mjs';
+import { buildIntermediateAssistantMessage, buildToolCallAssistantMessage } from './loop/assistant-commit.mjs';
+
+// The assistant turn the saved request produced, built the way the loop
+// commits it (without the turn's one-shot transcript metadata), plus a stub
+// result per tool call: the fork only needs each call answered so the
+// request stays well-formed.
+function replyMessages(response, toolStub) {
+  if (!response) return [];
+  const reply = response.toolCalls?.length
+    ? buildToolCallAssistantMessage(response, { calls: response.toolCalls, opts: {} })
+    : buildIntermediateAssistantMessage(response, {});
+  if (!reply) return [];
+  const stubs = collectAssistantToolCallIds(reply).map((id) => ({ role: 'tool', toolCallId: id, content: toolStub }));
+  return [reply, ...stubs];
+}
+
+/**
+ * The fork of a saved request with `prompt` as its final user turn. The
+ * provider continuation state follows the reply when it is appended, exactly
+ * as the main loop's next request would carry it. `sharedCachePrefixCount`
+ * (the shared prefix's message count, which survives model-proxy
+ * serialization) keeps an Anthropic message breakpoint on the shared prefix,
+ * so the fork reads the saved request's cache entry and writes none for its
+ * suffix.
+ */
+export function buildForkedRequest(request, prompt, toolStub) {
+  const reply = replyMessages(request.response, toolStub);
+  const opts = { ...request.opts };
+  if (reply.length && Object.hasOwn(request.response, 'providerState')) {
+    opts.providerState = request.response.providerState;
+  }
+  if (request.messages.length) opts.sharedCachePrefixCount = request.messages.length;
+  const messages = [
+    ...request.messages,
+    ...reply,
+    // A user interjection keeps its own turn (never folded into a preceding
+    // tool result), so the prefix's last block reaches the provider unchanged.
+    { role: 'user', content: prompt, meta: { source: 'steering' } },
+  ];
+  return { messages, opts };
+}

package/src/runtime/agent/orchestrator/session/side-question-store.mjs

@@ -1,6 +1,6 @@
 // side-question-store.mjs — the in-memory state behind /btw side questions:
 // per session, the latest provider request the main loop sent (the request a
-// side question forks) and the side question in flight. It holds live
+// side question or a compaction summary forks) and the side question in flight. It holds live
 // provider/tool objects, so it never reaches the session record or disk.
 import { isAgentOwner } from '../agent-owner.mjs';
 
@@ -65,6 +65,21 @@ export function sideQuestionRequest(sessionId) {
   return (sessionId && requests.get(sessionId)) || null;
 }
 
+/** The saved request a compaction summary may fork: one whose reply settled
+ *  and whose transcript no compaction has rewritten since it was sent. */
+export function compactionForkRequest(sessionId) {
+  const request = sideQuestionRequest(sessionId);
+  return request?.response && !request.compacted ? request : null;
+}
+
+/** A compaction rewrote the transcript: the saved request no longer holds the
+ *  history a later compaction must summarize. A side question still forks it
+ *  until the next request replaces it. */
+export function retireCompactionFork(sessionId) {
+  const request = sideQuestionRequest(sessionId);
+  if (request) request.compacted = true;
+}
+
 /** Start the session's side question, aborting the one still in flight. */
 export function beginSideQuestion(sessionId) {
   cancelSideQuestion(sessionId);

package/src/runtime/agent/orchestrator/session/side-question.mjs

@@ -5,8 +5,7 @@
 // the provider's prompt cache serves the prefix. Only the reply that request
 // produced and one question are appended. One provider call, no tool loop;
 // the answer is returned to the caller and never enters the transcript.
-import { collectAssistantToolCallIds } from './context-tool-pairs.mjs';
-import { buildIntermediateAssistantMessage, buildToolCallAssistantMessage } from './loop/assistant-commit.mjs';
+import { buildForkedRequest } from './request-fork.mjs';
 import { logSessionLlmUsage } from './manager/ask-turn-commit.mjs';
 import { disposeTransportScope, forkTransportScope } from '../providers/transport-scope.mjs';
 import { isAgentOwner } from '../agent-owner.mjs';
@@ -48,47 +47,10 @@ function sideQuestionPrompt(question) {
   ].join('\n');
 }
 
-// The assistant turn the saved request produced, built the way the loop
-// commits it (without the turn's one-shot transcript metadata), plus a stub
-// result per tool call.
-function replyMessages(response) {
-  if (!response) return [];
-  const reply = response.toolCalls?.length
-    ? buildToolCallAssistantMessage(response, { calls: response.toolCalls, opts: {} })
-    : buildIntermediateAssistantMessage(response, {});
-  if (!reply) return [];
-  const stubs = collectAssistantToolCallIds(reply).map((id) => ({
-    role: 'tool',
-    toolCallId: id,
-    content: SIDE_QUESTION_TOOL_STUB,
-  }));
-  return [reply, ...stubs];
-}
-
-/**
- * The fork of a saved request: its messages unchanged, then the reply and
- * the question. The send options are the saved ones; the provider
- * continuation state follows the reply when it is appended, exactly as the
- * main loop's next request would carry it. `sharedCachePrefixCount` (the
- * shared prefix's message count, which survives model-proxy serialization)
- * keeps an Anthropic message breakpoint on the shared prefix, so the fork reads the
- * saved request's cache entry and writes none for its suffix.
- */
-export function buildSideQuestionRequest(request, question) {
-  const reply = replyMessages(request.response);
-  const opts = { ...request.opts };
-  if (reply.length && Object.hasOwn(request.response, 'providerState')) {
-    opts.providerState = request.response.providerState;
-  }
-  if (request.messages.length) opts.sharedCachePrefixCount = request.messages.length;
-  const messages = [
-    ...request.messages,
-    ...reply,
-    // A user interjection keeps its own turn (never folded into a preceding
-    // tool result), so the prefix's last block reaches the provider unchanged.
-    { role: 'user', content: sideQuestionPrompt(question), meta: { source: 'steering' } },
-  ];
-  return { messages, opts };
+/** The fork of a saved request: its messages unchanged, then the reply and
+ *  the question (request-fork.mjs). */
+function buildSideQuestionRequest(request, question) {
+  return buildForkedRequest(request, sideQuestionPrompt(question), SIDE_QUESTION_TOOL_STUB);
 }
 
 /**

package/src/runtime/agent/orchestrator/session/store/fs-probe.mjs

@@ -63,3 +63,13 @@ export function readTextFile(path) {
     return { state, text: '', code };
   }
 }
+
+/** `readTextFile` with the raw bytes (`bytes`, a Buffer) instead of text. */
+export function readBytesFile(path) {
+  try {
+    return { state: PROBE_PRESENT, bytes: readFileSync(path), code: null };
+  } catch (err) {
+    const { state, code } = _failureVerdict(err);
+    return { state, bytes: Buffer.alloc(0), code };
+  }
+}