mixdog 1.2.3 → 1.2.4

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

@@ -3,6 +3,7 @@
 // throttled crash-recovery checkpoint sidecar, and the close snapshot that
 // canonicalizes the transcript when the turn is interrupted.
 import { captureTurnCheckpointContextState, createTurnCheckpointRecorder } from './turn-checkpoint.mjs';
+import { finalizeTurnInterruptionSnapshot } from './turn-interruption.mjs';
 
 // Coalescing window for streaming-delta flushes. Each flush journals only the
 // delta since the previous one, so the window just bounds syscalls.
@@ -83,28 +84,46 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
   };
 }
 
+// The live-session fields a staged close snapshot rewrites.
+const CLOSE_SNAPSHOT_SESSION_FIELDS = [
+  'liveTurnMessages',
+  '_providerPrefixGuardState',
+  'messages',
+  'activeTurnCheckpoint',
+  'providerState',
+  'updatedAt',
+  'lastUsedAt',
+];
+
 /** closeSession is synchronous and generation-first by design. This turn-local
  *  hook lets it canonicalize the in-flight transcript before
  *  bumpSessionGeneration()/markSessionClosed() writes the disk snapshot and
  *  invalidates the ordinary cancellation cleanup save. Finalizes at most once;
- *  later calls return the same snapshot. */
+ *  later calls return the same snapshot.
+ *
+ *  `prepare.tentative(reason)` stages the snapshot on the live session only:
+ *  the checkpoint scheduler and the interruption tracker keep running until
+ *  `commit()`, and `rollback()` restores the live session exactly, so a close
+ *  whose lifecycle barrier is refused leaves the turn as it was. */
 export function createCloseSnapshot({ turn, interruption, checkpoint, runtime }) {
   let snapshot = null;
-  return (abortReason) => {
-    if (snapshot) return snapshot;
+  const stage = (abortReason) => {
     const session = turn.session;
     if (!session) return null;
-    checkpoint.stop();
-    session.liveTurnMessages = null;
-    // Interruption finalize below rewrites the transcript; the
-    // mid-turn provider prefix snapshot must not survive it.
-    delete session._providerPrefixGuardState;
-    interruption.restoreTombstonedText();
-    const finalized = interruption.finalize({
+    const saved = CLOSE_SNAPSHOT_SESSION_FIELDS.map((key) => [key, Object.hasOwn(session, key), session[key]]);
+    const savedRuntimeSession = runtime.session;
+    // The tracker snapshot already counts retracted (tombstoned) text as
+    // output, so finalizing from it leaves the tracker itself untouched.
+    const finalized = finalizeTurnInterruptionSnapshot({
       turnOutgoing: turn.outgoing || session.messages,
       currentUserContent: turn.userTurnContent,
-      abortReason,
+      snapshot: interruption.snapshot(),
+      abortReason: abortReason ?? null,
     });
+    session.liveTurnMessages = null;
+    // The finalized transcript is a rewrite; the mid-turn provider prefix
+    // snapshot must not survive it.
+    delete session._providerPrefixGuardState;
     session.messages = finalized.messages;
     delete session.activeTurnCheckpoint;
     // A preserved response — or a non-user detach that keeps the provisional
@@ -113,7 +132,32 @@ export function createCloseSnapshot({ turn, interruption, checkpoint, runtime })
     session.updatedAt = Date.now();
     session.lastUsedAt = Date.now();
     runtime.session = session;
-    snapshot = finalized;
-    return finalized;
+    return {
+      snapshot: finalized,
+      commit() {
+        checkpoint.stop();
+        interruption.restoreTombstonedText();
+        snapshot = finalized;
+      },
+      rollback() {
+        for (const [key, had, value] of saved) {
+          if (had) session[key] = value;
+          else delete session[key];
+        }
+        runtime.session = savedRuntimeSession;
+      },
+    };
+  };
+  const prepare = (abortReason) => {
+    if (snapshot) return snapshot;
+    const staged = stage(abortReason);
+    if (!staged) return null;
+    staged.commit();
+    return staged.snapshot;
+  };
+  prepare.tentative = (abortReason) => {
+    if (snapshot) return { snapshot, commit() {}, rollback() {} };
+    return stage(abortReason);
   };
+  return prepare;
 }

package/src/runtime/agent/orchestrator/session/manager/failed-turn-rewind.mjs

@@ -45,3 +45,19 @@ export function rewindUnansweredPrompt(session, prompt) {
   delete session._providerPrefixGuardState;
   return true;
 }
+
+/** Resolve a retry against the durable failure, never against display text. */
+export function retainedFailedTurnInput(messages, messageId, attemptId) {
+  const list = Array.isArray(messages) ? messages : [];
+  const index = list.findLastIndex((message) => message?.role !== 'system');
+  const message = list[index];
+  const transcript = message?.meta?.transcript;
+  if (!messageId || transcript?.messageId !== messageId || transcript?.completion?.status !== 'failed') {
+    throw new Error('The failed turn is no longer the latest execution.');
+  }
+  if (transcript.completion.attemptId && transcript.completion.attemptId !== attemptId) {
+    throw new Error('The failed attempt is no longer the latest execution.');
+  }
+  if (message.role !== 'user') return null;
+  return { index, message };
+}

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

@@ -1,7 +1,6 @@
 // Steering / pending-message queue with sync buffering and atomic persistence.
-import { mkdirSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { loadSession } from '../store.mjs';
-import { ForeignPendingMessageController } from './foreign-pending-messages.mjs';
 import {
   currentPendingLifecycleToken,
   lifecycleTokenStale,
@@ -29,7 +28,7 @@ import {
   pendingIdSet,
   pruneEmptyPendingIdSet,
 } from './pending-claim-ledger.mjs';
-import { legacyPendingMessagesPath, pendingShardDir } from './pending-spool-path.mjs';
+import { legacyPendingMessagesPath } from './pending-spool-path.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.
@@ -83,16 +82,6 @@ const _sessionPendingMessages = new Map();
 const _hydratedPendingMessages = new Map();
 const _pendingHydrations = new Map();
 
-// Exposed for live-share owners: they fs.watch this session's shard file for
-// instant pickup of cross-surface submits (the 3s drain tick remains the
-// safety net). Without a valid session id there is nothing to watch.
-export function pendingMessagesSpoolPath(sessionId) {
-  if (!isValidPendingSessionId(sessionId)) return '';
-  // fs.watch needs the directory to exist before the first shard is written.
-  mkdirSync(pendingShardDir(), { recursive: true });
-  return pendingMessagesPath(sessionId);
-}
-
 function pendingIdStillQueued(sessionId, id) {
   for (const map of [_sessionPendingMessages, _pendingPersistBuffers, _hydratedPendingMessages]) {
     const q = map.get(sessionId);
@@ -196,11 +185,10 @@ function acknowledgePendingMessages(sessionId, deliveredEntries, options = {}) {
         return false;
       }
       // Keep the acked ids when the spool cleanup FAILED: the durable entry
-      // still exists, and forgetting that it was already delivered let the
-      // foreign-injection drain re-take it as a "new" cross-surface submit
-      // (user saw the same message duplicated in the transcript). Retained
-      // ids also keep suppressing the hydrate path; they are dropped only
-      // once a later ack round actually lands.
+      // still exists, and forgetting that it was already delivered would let
+      // the hydrate path re-take it as a new message (the same message
+      // duplicated in the transcript). They are dropped only once a later ack
+      // round actually lands.
       if (!ok) return false;
       forgetAckedIds();
       return true;
@@ -462,99 +450,6 @@ export function enqueuePendingMessage(sessionId, message) {
   return Math.max(q.length, bufferedDepth || 0);
 }
 
-/**
- * Remote-attach injection enqueue: persist a user message into the shared
- * cross-process spool WITHOUT touching this process's in-memory queues. Used
- * by a viewer surface attached to a session another live process owns — the
- * owner's injection poller (drainForeignUserInjections) picks it up there.
- * Skipping the local queues is deliberate: if this process later takes real
- * ownership of the session, a lingering local copy would double-inject.
- */
-export function enqueueRemotePendingMessage(sessionId, message) {
-  if (!isValidPendingSessionId(sessionId)) return 0;
-  // Same durable-lifecycle authority as the local enqueue: a cross-surface
-  // submit that lands after the session was closed is refused before any
-  // spool mutation.
-  const token = currentPendingLifecycleToken(sessionId);
-  if (pendingLifecycleInvalidated(sessionId)) return 0;
-  const normalized = pendingMessageQueueEntry(message);
-  if (!normalized) return 0;
-  // The token rides into the async spool commit, which revalidates under the
-  // spool lock (see persistPendingMessages).
-  if (pendingLifecycleInvalidated(sessionId, token)) return 0;
-  // Preserve the viewer's submission id end-to-end. Minting a fresh id here
-  // made pipe-delivered + spool-fallback twins look like two messages
-  // (owner accepted the pipe copy, then re-took the spool copy).
-  const preservedId = pendingMessageId(normalized) || pendingMessageId(message);
-  const remoteEntry = stampLifecycleToken(
-    {
-      ...normalized,
-      id: typeof preservedId === 'string' && preservedId.trim() ? preservedId.trim() : newPendingMessageId(),
-    },
-    token
-  );
-  return persistPendingMessages(sessionId, [remoteEntry]);
-}
-
-function _foreignLocalIds(sessionId) {
-  const localIds = new Set();
-  for (const map of [_sessionPendingMessages, _pendingPersistBuffers, _hydratedPendingMessages]) {
-    for (const entry of map.get(sessionId) || []) {
-      const id = pendingMessageId(entry);
-      if (id) localIds.add(id);
-    }
-  }
-  for (const set of [_inDeliveryPendingIds.get(sessionId), _ackedPendingIds.get(sessionId)]) {
-    for (const id of set || []) localIds.add(id);
-  }
-  // The durable delivered-ledger mirrors the hydrate path's suppression: an
-  // entry whose id was recorded as delivered (but whose spool cleanup has
-  // not landed yet — crash, lock contention, another process) is NOT a
-  // foreign submit and must never re-inject.
-  try {
-    for (const id of loadSession(sessionId)?.deliveredPendingMessageIds || []) {
-      if (typeof id === 'string' && id) localIds.add(id);
-    }
-  } catch {
-    /* ledger unavailable — in-memory sets still guard */
-  }
-  return localIds;
-}
-
-function addForeignInDeliveryIds(sessionId, ids) {
-  const inDelivery = pendingIdSet(_inDeliveryPendingIds, sessionId);
-  for (const id of ids) inDelivery.add(id);
-}
-
-function removeForeignInDeliveryIds(sessionId, ids) {
-  const inDelivery = _inDeliveryPendingIds.get(sessionId);
-  for (const id of ids) inDelivery?.delete(id);
-  pruneEmptyPendingIdSet(_inDeliveryPendingIds, sessionId);
-}
-
-const foreignPendingMessages = new ForeignPendingMessageController({
-  addInDeliveryIds: addForeignInDeliveryIds,
-  chainSpoolTail,
-  currentLifecycleToken: currentPendingLifecycleToken,
-  getSpoolTail: (sessionId) => _pendingPersistTails.get(sessionId),
-  isValidSessionId: isValidPendingSessionId,
-  lifecycleEpochMoved: pendingLifecycleEpochMoved,
-  lifecycleInvalidated: pendingLifecycleInvalidated,
-  localIds: _foreignLocalIds,
-  normalizeStore: normalizePendingStore,
-  removeInDeliveryIds: removeForeignInDeliveryIds,
-  setSpoolQueue,
-  spoolPath: pendingMessagesPath,
-  updateSpool,
-  warn: pendingWarn,
-});
-
-// The controller parks rows before delivery so an owner crash can redeliver
-// accepted input instead of losing it.
-export async function drainForeignUserInjections(sessionId) {
-  return foreignPendingMessages.drainUserInjections(sessionId);
-}
-
 // Drain order: enqueue time, then source (hydrated < buffered < memory), then
 // position within the source.
 function byEnqueueOrder(a, b) {
@@ -710,15 +605,6 @@ export function _dropPendingMessageState(id, { clearPersisted = true } = {}) {
   } catch {
     /* ignore */
   }
-  // A tombstoned close removes the whole durable queue anyway; a DETACH keeps
-  // its scheduled release so this process still cleans up rows it parked.
-  if (clearPersisted) {
-    try {
-      foreignPendingMessages.cancelHandoffRelease(id);
-    } catch {
-      /* ignore */
-    }
-  }
   _inDeliveryPendingIds.delete(id);
   _ackedPendingIds.delete(id);
   _pendingHydrations.delete(id);

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

@@ -93,7 +93,7 @@ export function persistPendingMessages(sessionId, messages) {
       // schedule the retry HERE. Waiting for "the next scheduled flush or
       // session takeover" meant a FINAL submit (nothing else ever
       // enqueues afterwards) stayed process-local forever, while
-      // enqueue/enqueueRemotePendingMessage had already reported success.
+      // enqueuePendingMessage had already reported success.
       try {
         // Closed/detached since this write started: its buffer and its
         // retry timer were torn down on purpose — do not rebuild them.

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -229,7 +229,7 @@ export function replaceWorkspaceCoreSlices(core, { coreMemoryContext, instructio
     if (memory) parts.push(`${CORE_MEMORY_HEADING}${memory}`);
   }
   if (instructionFilesContext !== undefined) instructionFiles = trimmedSlice(instructionFilesContext);
-  return [...parts, instructionFiles].filter((part) => part && part.trim()).join(BP3_PART_SEPARATOR);
+  return [...parts, instructionFiles].filter((part) => part?.trim()).join(BP3_PART_SEPARATOR);
 }
 
 /**
@@ -243,7 +243,7 @@ export function replaceWorkspaceEnvironment(environmentTail, environmentContext)
   const facts = trimmedSlice(environmentContext);
   if (parts[0]?.startsWith('- ')) parts[0] = facts;
   else parts.unshift(facts);
-  return parts.filter((part) => part && part.trim()).join(BP3_PART_SEPARATOR);
+  return parts.filter((part) => part?.trim()).join(BP3_PART_SEPARATOR);
 }
 
 /**
@@ -399,12 +399,13 @@ function sameWorkspacePath(left, right) {
 /** The lines a move from the project folder into a worktree adds to the notice. */
 function workspaceMoveLines(move, cwd) {
   if (!move?.from || sameWorkspacePath(move.from, cwd)) return [];
-  const changes =
-    move.changes === 'carried'
-      ? 'Uncommitted changes were moved into the worktree; ignored files (dependencies, build output, env files) were not.'
-      : move.changes === 'left'
-        ? `Uncommitted changes were left in ${move.from}; they are not present here.`
-        : '';
+  let changes = '';
+  if (move.changes === 'carried') {
+    changes =
+      'Uncommitted changes were moved into the worktree; ignored files (dependencies, build output, env files) were not.';
+  } else if (move.changes === 'left') {
+    changes = `Uncommitted changes were left in ${move.from}; they are not present here.`;
+  }
   return [
     changes,
     `For continued work, substitute ${cwd} for the project root ${move.from} in paths mentioned earlier; absolute paths are not remapped automatically. Re-read affected files before editing them.`,
@@ -418,6 +419,7 @@ function workspaceNoticeContent({ seen, target }) {
     [
       '# Working Folder Changed',
       `The working folder is now ${target.cwd}. This replaces the Cwd and environment facts given earlier in this conversation; relative paths and shell commands resolve here.`,
+      'Keep the conversation goals and decisions, but treat earlier file contents, search results and Git observations as historical, not as evidence of this checkout. Check the target project instructions and Git status, and re-read the files needed for the next edit before continuing. A folder change alone does not transfer uncommitted changes.',
       ...workspaceMoveLines(target.move, target.cwd),
       changed('environmentContext') ? target.environmentContext : '',
     ]
@@ -455,6 +457,25 @@ export function snapshotPendingWorkspaceNotice(session) {
   return content ? { revision: pending.revision, content } : null;
 }
 
+/**
+ * The report of a new worktree's preparation (session.pendingSetupNotice, set
+ * by the first turn's workspace gate) for this turn, or null. Acknowledged
+ * when the provider accepted the turn, like the workspace notice.
+ * @returns {{ revision: number, content: string } | null}
+ */
+export function snapshotPendingSetupNotice(session) {
+  const pending = session?.pendingSetupNotice;
+  return typeof pending?.content === 'string' && pending.content
+    ? { revision: pending.revision, content: pending.content }
+    : null;
+}
+
+export function acknowledgePendingSetupNotice(session, revision) {
+  if (session?.pendingSetupNotice?.revision !== revision) return false;
+  delete session.pendingSetupNotice;
+  return true;
+}
+
 /** The notice of `revision` reached the model: what it was told is now the target. */
 export function acknowledgePendingWorkspaceNotice(session, revision) {
   const pending = session?.workspaceReroot;

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

@@ -1,7 +1,10 @@
 // ── Runtime liveness map ──────────────────────────────────────────────
-// In-memory only. Tracks per-session stage + stream heartbeat so agent type=list
+// In-memory only. Tracks per-session stage + stream progress so agent type=list
 // can surface whether a session is actually alive vs stuck. Never persisted —
-// heartbeats would otherwise churn the session JSON on every SSE delta.
+// progress would otherwise churn the session JSON on every SSE delta. The Map
+// itself lives in the import-free leaf runtime-state.mjs so cold readers can
+// ask which turns are in flight (isSessionTurnInFlight /
+// inFlightSessionActivity); every mutation stays here.
 //
 // The Map and its timer companion are
 // module-level singletons — preserving the baseline's single-process shape.
@@ -20,14 +23,16 @@
 // }
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
 import { emitSessionApprovalWaitChange } from '../../../../shared/session-approval-wait.mjs';
-import { publishHeartbeat, deleteHeartbeat } from '../store.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';
 import { configureUsageMetricsRuntime, dropMetricSeenState, bumpUsageMetricsTurnId } from './usage-metrics.mjs';
+import { runtimeState as _runtimeState, isTurnInFlight } from './runtime-state.mjs';
+
+export { IN_FLIGHT_STAGES, inFlightSessionActivity } from './runtime-state.mjs';
 
 const HEARTBEAT_THROTTLE_MS = 60_000; // 60s
 
-const _runtimeState = new Map();
 const _toolActivityHeartbeats = new Map();
 const VALID_STAGES = new Set([
   'connecting',
@@ -99,7 +104,6 @@ function _touchSessionActivityProgress(id) {
   const now = Date.now();
   entry.lastProgressAt = now;
   entry.updatedAt = now;
-  publishHeartbeat(id, now);
 }
 
 function _startToolActivityHeartbeat(id) {
@@ -111,11 +115,17 @@ function _startToolActivityHeartbeat(id) {
 }
 
 export function updateSessionStage(id, stage) {
+  if (stage === MODEL_THINKING_STAGE) {
+    markSessionRequestSent(id);
+    return;
+  }
   if (!id || !VALID_STAGES.has(stage)) return;
   const entry = _touchRuntime(id);
   const now = Date.now();
   const priorStage = entry.stage;
   entry.stage = stage;
+  // A new stage (a retried attempt included) has not sent its request yet.
+  entry.requestSentAt = null;
   if (stage === 'requesting' && priorStage !== 'requesting') {
     entry.modelRequestStartedAt = now;
   }
@@ -148,6 +158,7 @@ export function markSessionAskStart(id) {
   entry.lastToolProtocolAt = null;
   entry.lastSemanticKind = null;
   entry.transportTrackingEnabled = false;
+  entry.requestSentAt = null;
   entry.lastToolCall = null;
   entry.toolStartedAt = null;
   entry.toolOutputTail = null;
@@ -166,14 +177,18 @@ export function markSessionAskStart(id) {
   entry.modelRequestStartedAt = null;
   entry.lastProgressAt = now;
   entry.updatedAt = now;
-  // Publish heartbeat immediately so the status aggregator picks the
-  // session up in the connecting / requesting window. Without this the
-  // .hb file only landed on the first stream chunk — producing a 3–10s
-  // (xhigh: 30s+) invisible gap where agent sessions ran but the
-  // statusline showed no maintenance/agent badge. STREAM_FRESH_MS (5 min)
-  // still drops a session whose provider truly never returns a chunk;
-  // markSessionStreamDelta keeps refreshing once chunks arrive.
-  return publishHeartbeat(id, now);
+}
+/** 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) {
+  if (!id) return;
+  const entry = _runtimeState.get(id);
+  if (!entry || entry.closed || entry.controller?.signal?.aborted || entry.stage !== 'requesting') return;
+  const now = Date.now();
+  entry.requestSentAt = now;
+  entry.updatedAt = now;
 }
 export function enableSessionTransportTracking(id) {
   if (!id) return;
@@ -194,7 +209,6 @@ export function markSessionTransportActivity(id) {
   const now = Date.now();
   entry.lastTransportAt = now;
   entry.updatedAt = now;
-  publishHeartbeat(id, now);
 }
 function _normalizeModelProgressKind(kind) {
   let value = 'semantic';
@@ -211,10 +225,10 @@ export async function markSessionStreamDelta(id, kind = 'semantic') {
   // creates it before streaming begins). _touchRuntime would instead resurrect a
   // blank entry — and closeSession()/idle-sweep clear _runtimeState on a deferred
   // tick while a detached provider stream may still be trickling deltas. A delta
-  // arriving after that clear must NOT re-create an entry or it would republish the
-  // .hb heartbeat that markSessionClosed deleted, orphaning a dead session's
-  // heartbeat indefinitely (the disk tombstone blocks ask resumption but not this
-  // path). Skip a missing, tombstoned, or aborted entry — never refresh liveness.
+  // arriving after that clear must NOT re-create an entry or it would revive a
+  // dead session's runtime state (the disk tombstone blocks ask resumption but
+  // not this path). Skip a missing, tombstoned, or aborted entry — never refresh
+  // liveness.
   const entry = _runtimeState.get(id);
   if (!entry || entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
   const progressKind = _normalizeModelProgressKind(kind);
@@ -240,11 +254,7 @@ export async function markSessionStreamDelta(id, kind = 'semantic') {
   if (entry.stage === 'connecting' || entry.stage === 'requesting') {
     entry.stage = 'streaming';
   }
-  // Lightweight heartbeat (≤5s self-throttled) for the status aggregator.
-  // Disk-side session.lastHeartbeatAt below is the heavy 60s zombie-reaper
-  // signal; the .hb file is the fast fresh-session signal consumed by the
-  // status line.
-  publishHeartbeat(id, now);
+  // Disk-side session.lastHeartbeatAt is the 60s zombie-reaper signal.
   const session = entry.session;
   if (session && now - (session.lastHeartbeatAt || 0) > HEARTBEAT_THROTTLE_MS) {
     session.lastHeartbeatAt = now;
@@ -271,9 +281,7 @@ export function markSessionToolCall(id, toolName) {
   entry.lastToolProtocolAt = entry.toolStartedAt;
   entry.lastProgressAt = entry.toolStartedAt;
   entry.updatedAt = entry.toolStartedAt;
-  const heartbeat = publishHeartbeat(id, entry.toolStartedAt);
   _startToolActivityHeartbeat(id);
-  return heartbeat;
 }
 // Live shell-output tail for the CURRENT running tool. Written by the shell
 // tool's onOutputTail timer (~1 s cadence), read by engine transcript
@@ -341,10 +349,6 @@ export function markSessionDone(id, { empty = false } = {}) {
     entry.emptyFinal = false;
     entry.emptyFinalAt = null;
   }
-  // Terminal stage — drop the heartbeat so the status badge releases
-  // immediately. A subsequent ask on the same session re-publishes via
-  // markSessionStreamDelta on the first chunk.
-  return deleteHeartbeat(id);
 }
 // Tag a session as having completed with empty final synthesis (no
 // content/reasoning). Distinct from `markSessionDone`: still a success
@@ -368,9 +372,7 @@ export function markSessionError(id, msg) {
   // silent empty final). Clear the flag so the next ask starts clean.
   entry.emptyFinal = false;
   entry.emptyFinalAt = null;
-  const heartbeatDeleted = deleteHeartbeat(id);
   _unlinkParentAbortListener(entry);
-  return heartbeatDeleted;
 }
 export function markSessionCancelled(id) {
   if (!id) return;
@@ -380,24 +382,19 @@ export function markSessionCancelled(id) {
   _settleTerminalEntry(entry, 'done', null);
   entry.emptyFinal = false;
   entry.emptyFinalAt = null;
-  const heartbeatDeleted = deleteHeartbeat(id);
   _unlinkParentAbortListener(entry);
-  return heartbeatDeleted;
 }
 export function getSessionRuntime(id) {
   return id ? _runtimeState.get(id) || null : null;
 }
 
-// Stages that still own live provider/tool work: compaction, idle cleanup and
-// runtime unload all stay away from an entry in one of them.
-export const IN_FLIGHT_STAGES = new Set(['connecting', 'requesting', 'streaming', 'tool_running', 'cancelling']);
+/** Whether this session's turn (provider or tool work) is running now. */
+export function isSessionTurnInFlight(sessionId) {
+  return Boolean(sessionId) && isTurnInFlight(_runtimeState.get(sessionId));
+}
 
 export function isSessionCompactionBlocked(sessionId) {
-  if (!sessionId) return false;
-  const entry = _runtimeState.get(sessionId);
-  if (!entry || entry.closed === true) return false;
-  if (entry.controller && !entry.controller.signal?.aborted) return true;
-  return IN_FLIGHT_STAGES.has(entry.stage);
+  return isSessionTurnInFlight(sessionId);
 }
 
 export function getSessionProgressSnapshot(sessionId) {
@@ -418,6 +415,9 @@ export function getSessionProgressSnapshot(sessionId) {
     firstActivityAt,
     firstSemanticAt,
     lastTransportAt: entry.lastTransportAt || 0,
+    requestSentAt: entry.requestSentAt || 0,
+    // Request on the wire, headers pending: the model is queued or thinking.
+    awaitingModelResponse: awaitingModelResponse(entry),
     lastSemanticAt: entry.lastSemanticAt || 0,
     lastSemanticKind: entry.lastSemanticKind || null,
     lastReasoningAt: entry.lastReasoningAt || 0,
@@ -482,14 +482,7 @@ export function getSessionAbortSignal(sessionId) {
  * either skip the watchdog or treat 0 as "no progress yet".
  */
 export function getSessionLastProgressAt(sessionId) {
-  const entry = _runtimeState.get(sessionId);
-  if (!entry) return 0;
-  return Math.max(
-    entry.lastProgressAt || 0,
-    entry.lastStreamDeltaAt || 0,
-    entry.toolStartedAt || 0,
-    entry.askStartedAt || 0
-  );
+  return lastProgressAt(_runtimeState.get(sessionId));
 }
 
 /**

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

@@ -0,0 +1,50 @@
+// manager/runtime-state.mjs
+// The process-global runtime liveness map and its turn-activity reads.
+// runtime-liveness.mjs owns every entry and mutation; this leaf has no
+// imports, so a cold reader (the daemon's session catalog) can ask which turns
+// are in flight without loading the session manager graph. Every session runs
+// inline in the daemon, so this map is the whole answer to "is this session's
+// turn running".
+
+export const runtimeState = new Map();
+
+// Stages that still own live provider/tool work: compaction, idle cleanup and
+// runtime unload all stay away from an entry in one of them.
+export const IN_FLIGHT_STAGES = new Set(['connecting', 'requesting', 'streaming', 'tool_running', 'cancelling']);
+
+/** Whether a runtime entry's turn (provider or tool work) is running now. */
+export function isTurnInFlight(entry) {
+  if (!entry || entry.closed === true) return false;
+  if (entry.controller && !entry.controller.signal?.aborted) return true;
+  return IN_FLIGHT_STAGES.has(entry.stage);
+}
+
+const cleanLower = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase();
+
+/**
+ * Turn activity of every session this process runs: `working` holds the ids
+ * whose turn is in flight, `agentWorking` the root owner (Lead) ids of every
+ * in-flight Agent session.
+ */
+export function inFlightSessionActivity() {
+  const working = new Set();
+  const agentWorking = new Set();
+  for (const [id, entry] of runtimeState) {
+    if (!isTurnInFlight(entry)) continue;
+    working.add(id);
+    const session = entry.session;
+    const ownerSessionId = String(session?.ownerSessionId || session?.parentSessionId || '').trim();
+    const agent = cleanLower(session?.agent);
+    if (
+      ownerSessionId &&
+      ownerSessionId !== id &&
+      (cleanLower(session?.owner) === 'agent' || (agent && agent !== 'lead'))
+    ) {
+      agentWorking.add(ownerSessionId);
+    }
+  }
+  return { working, agentWorking };
+}