mixdog 1.2.3 → 1.2.5

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 };
+}

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

@@ -17,7 +17,8 @@ import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
 import { forgetSessionSaveBaseline } from '../store/save-worker.mjs';
 import { forgetSessionLoadCache } from '../store/load-cache.mjs';
 import { releaseReadSnapshotScope } from '../../tools/builtin/snapshot-store.mjs';
-import { cancelNativeTasks } from '../../tools/lib/native-spawn-client.mjs';
+import { cancelOwnedShellTrees } from '../../tools/lib/owned-shell-trees.mjs';
+import { noteShellOwnerSessionClosed } from '../../tools/builtin/lib/shell-job-records.mjs';
 import { forgetSideQuestion } from '../side-question-store.mjs';
 
 /**
@@ -47,15 +48,17 @@ export function closeSession(id, reason = 'manual', opts = {}) {
   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. Finalize that in-memory snapshot synchronously
+  // 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.
+  // 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 {
-    entry?.prepareCloseSnapshot?.(reason);
+    closeSnapshot = entry?.prepareCloseSnapshot?.tentative?.(reason) ?? null;
   } catch {
     /* best-effort */
   }
-  _stopToolActivityHeartbeat(id);
   // 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.
@@ -87,12 +90,16 @@ export function closeSession(id, reason = 'manual', opts = {}) {
   // a late save could clobber and nothing left open to resume. That close
   // succeeds and tears the runtime down normally.
   if (typeof newGen !== 'number' && outcome.absent !== true) {
+    closeSnapshot?.rollback();
     reportCloseBarrierFailure({ id, reason, tombstone, entry });
     return false;
   }
+  // The staged snapshot was folded into the synchronous generation write
+  // above; committing it stops the turn's checkpoint writer. Only now is it
+  // safe to remove the crash fallback.
+  closeSnapshot?.commit();
+  _stopToolActivityHeartbeat(id);
   cancelOwnedShellProcesses({ id, reason, tombstone });
-  // prepareCloseSnapshot was folded into the synchronous generation write
-  // above. Only now is it safe to remove the crash fallback.
   clearTurnCheckpoint(id);
   teardownSessionRuntime({ id, entry, reason, tombstone, newGen });
   return true;
@@ -138,16 +145,27 @@ function reportCloseBarrierFailure({ id, reason, tombstone, entry }) {
  * with the unconfirmed outcome. The re-stamp is idempotent: markSessionClosed
  * keeps the original close time and generation and only upgrades the cancel
  * scalars (unconfirmed never downgrades back to cancelled).
+ *
+ * Every tree records its process identities before the kill (the kill may
+ * break the parent chain). When a snapshot is still pending the cancel is
+ * sent once it lands or after PROCESS_TABLE_READ_BOUND_MS, whichever first;
+ * the close itself does not wait. Holds this session leaves behind become
+ * releasable from any session that sees their workspace.
  */
 function cancelOwnedShellProcesses({ id, reason, tombstone }) {
-  let cancelConfirmed = true;
+  const record = (result) => {
+    if (tombstone && result?.confirmed === false) markSessionClosed(id, reason, { cancelStatus: 'cancel-unconfirmed' });
+  };
+  // A cancel that threw proved nothing either.
+  const unconfirmed = () => record({ confirmed: false });
   try {
-    cancelConfirmed = cancelNativeTasks({ ownerSessionId: id })?.confirmed !== false;
+    const result = cancelOwnedShellTrees(id);
+    if (typeof result?.then === 'function') result.then(record, unconfirmed);
+    else record(result);
   } catch {
-    // A cancel that threw proved nothing either.
-    cancelConfirmed = false;
+    unconfirmed();
   }
-  if (tombstone && !cancelConfirmed) markSessionClosed(id, reason, { cancelStatus: 'cancel-unconfirmed' });
+  noteShellOwnerSessionClosed(id);
 }
 
 /**
@@ -275,8 +293,8 @@ export function abortSessionTurn(id, reason = 'turn-abort') {
  *     what a settled turn left behind;
  *   - offload sidecars, the turn checkpoint and persisted pending messages
  *     are left intact — they are the follow-up turn's context, not runtime.
- * Terminal ownership stays with the caller's own reap path (agent-tool
- * scheduleReap → closeSession('terminal-reap')).
+ * A terminal session is never closed here; it stays open until it is
+ * explicitly cancelled or deleted.
  *
  * Returns false (changing nothing) when the session is still in flight.
  */

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

@@ -29,7 +29,7 @@ import { hideCompactionArchive } from '../compaction-archive-capture.mjs';
 import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { forgetSideQuestion } from '../side-question-store.mjs';
 
-/** Force-flush session metrics to disk. Used by watchdog terminal-reap (fix B). */
+/** Force-flush session metrics to disk. */
 export async function flushSessionMetrics(sessionId) {
   if (!sessionId) return;
   const session = loadSession(sessionId);

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

@@ -7,7 +7,7 @@ import { getProvider } from '../../providers/registry.mjs';
 import { invalidateContextUsageSnapshot, invalidateProviderContextBaseline } from '../loop/compact-policy.mjs';
 import { saveSession, saveSessionAsync, saveSessionAsyncDeferred, loadSession, setLiveSession } from '../store.mjs';
 import { _liveSessions } from '../store/live-state.mjs';
-import { _isActivelyOwnedElsewhere, _recoverTurnCheckpointDurably } from './session-owner-liveness.mjs';
+import { _recoverTurnCheckpointDurably } from './turn-checkpoint-recovery.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
@@ -37,14 +37,15 @@ import { getAgentRuntimeSync, warnAgentRuntimeResolveFailureOnce } from './agent
 import { ensureCodexWireSessionId, mintSessionId } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
 import { buildSessionRecord, normalizeDesktopSessionMetadata, sessionOriginFields } from './session-record.mjs';
+import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
 import { applyPendingWorkspaceReroot, refreshSessionBp3Environment } from './prompt-utils.mjs';
 import { isWorktreeBound } from '../../../../shared/worktrees/contract.mjs';
 import { applyAgentToolExposure } from '../loop/tool-exposure-migration.mjs';
+import { prewarmSessionAutoEffort } from './ask-turn-auto-effort.mjs';
 
-// Owner liveness (attach-on-resume guard) and the durable turn-checkpoint
-// recovery it gates; re-exported so prior importers of this module stay
-// unchanged.
-export { isSessionOwnerGone, recoverSessionAfterProcessRestart } from './session-owner-liveness.mjs';
+// Durable turn-checkpoint recovery; re-exported so prior importers of this
+// module stay unchanged.
+export { recoverSessionAfterProcessRestart } from './turn-checkpoint-recovery.mjs';
 // Prepared-surface cache warmers (desktop hover prefetch, pane projection);
 // re-exported so prior importers of this module stay unchanged.
 export { prefetchSession, prepareSessionProjection } from './prepared-resume-cache.mjs';
@@ -211,6 +212,11 @@ export function createSession(opts) {
   const { profile } = resolved;
   const route = resolveSessionRoute(opts, presetObj, profile);
   const { providerName, modelName, provider, toolPreset, id } = route;
+  const routeFallbacks = normalizeWorkflowRoute({
+    provider: providerName,
+    model: modelName,
+    fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.fallbacks,
+  })?.fallbacks;
   // Provider cache strategy — agentRuntime.resolveSync() above is a
   // best-effort injection point (setAgentRuntime() has no live caller
   // today, so that branch never fires); build it directly here so every
@@ -218,11 +224,7 @@ export function createSession(opts) {
   // 'lead', or no agent at all — raw/CLI callers) get their BP4 message
   // tail TTL linked to the user's autoClear idle-sweep config; hidden and
   // public agents keep the flat 5m default (see cache-strategy.mjs docs).
-  // Scoped to explicit-breakpoint (Anthropic-family) providers only — the
-  // non-Anthropic branches of buildProviderCacheOpts (e.g. the 'openai'
-  // cacheRetention:'24h' shape) were never exercised by createSession
-  // before this change, and are left untouched to avoid altering live
-  // OpenAI/other-provider request shape as a side effect of this fix.
+  // Scoped to explicit-breakpoint (Anthropic-family) providers only.
   const providerCacheOpts = resolved.providerCacheOpts || buildSessionProviderCacheOpts(providerName, id, opts.agent);
   const surface = resolveSessionToolSurface(opts, { profile, toolPreset, modelName });
   const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface });
@@ -244,6 +246,7 @@ export function createSession(opts) {
     origin: sessionOriginFields(opts, { profile, presetObj, providerCacheOpts, surface }),
   });
   session.providerCacheOptsOverride = Boolean(resolved.providerCacheOpts);
+  if (routeFallbacks?.length) session.routeFallbacks = routeFallbacks;
   // A non-native agent sends core + bridge, built from its filtered tools.
   applyAgentToolExposure(session);
   refreshSessionBp3Environment(session, opts.cwd);
@@ -251,6 +254,7 @@ export function createSession(opts) {
   // reads live memory; disk flush is for cross-process / restart durability.
   setLiveSession(session);
   saveSession(session);
+  prewarmSessionAutoEffort(session, provider);
   return session;
 }
 
@@ -460,9 +464,8 @@ export function updateSessionRoute(id, route = {}, options = {}) {
 }
 
 // --- resume (reload tools for a stored session) ---
-// Whether another live process is driving the session (and therefore whether
-// this resume attaches as a viewer) is decided by session-owner-liveness.mjs;
-// the prepared tool surface it consumes is cached in prepared-resume-cache.mjs.
+// Interrupted-turn recovery lives in turn-checkpoint-recovery.mjs; the
+// prepared tool surface it consumes is cached in prepared-resume-cache.mjs.
 
 // Desktop callers pass their selected durable classification as a
 // capability check. Refuse a stale/tampered cross-class resume before any
@@ -496,25 +499,6 @@ function _applyDesktopResumeScope(session, options) {
   return true;
 }
 
-// ATTACH (viewer mode, zero ownership): hand back the live transcript
-// under the SAME id, flagged remoteAttached. No tool refresh, no save,
-// no generation claim — the session file remains exclusively the
-// owner's. session-turn-api routes this surface's submits into the
-// shared pending spool instead of running a local turn.
-function _attachViewerSession(session, sessionId) {
-  const attached = { ...session, remoteAttached: true };
-  delete attached.liveTurnMessages;
-  delete attached.toolApprovalHook;
-  if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
-    try {
-      process.stderr.write(`[session] attach-on-resume: ${sessionId} is live elsewhere → viewer attach\n`);
-    } catch {
-      /* best-effort */
-    }
-  }
-  return attached;
-}
-
 // Refreshes the session's tool surface from the prepared resume when it still
 // matches, warning about tools the preset no longer offers.
 function _refreshResumedTools(session, sessionId, preset) {
@@ -551,7 +535,6 @@ export async function resumeSession(sessionId, preset, options = {}) {
   if (Object.hasOwn(options, 'mcpScopeId')) {
     session.mcpScopeId = String(options.mcpScopeId || '').trim() || null;
   }
-  if (_isActivelyOwnedElsewhere(session, sessionId)) return _attachViewerSession(session, sessionId);
   _recoverTurnCheckpointDurably(session, sessionId);
   _refreshResumedTools(session, sessionId, preset);
   refreshSessionProviderCacheOpts(session);
@@ -563,5 +546,6 @@ export async function resumeSession(sessionId, preset, options = {}) {
       process.stderr.write(`[session] resume save failed: ${err?.message || err}\n`);
     } catch {}
   });
+  prewarmSessionAutoEffort(session, session.provider ? getProvider(session.provider) : null);
   return session;
 }

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

@@ -18,6 +18,7 @@ import {
 } from '../../tools/builtin/runtime-capabilities.mjs';
 import { captureOriginalUserCwd } from '../../../../shared/user-cwd.mjs';
 import { delegationDisabled } from './session-tool-surface.mjs';
+import { contextAckMessage } from '../compact/user-message-kind.mjs';
 
 // Preserve the exact pre-layout environment payload: Lead carried the
 // shell preference in Profile Preferences, while any routing surface with
@@ -89,6 +90,23 @@ export function buildWorkspacePromptContext(session, cwd) {
 
 // BP1/BP2/BP3 rule blocks plus the volatile environment, composed into the
 // four system blocks; environmentTailContext is the persisted env tail.
+export function sessionRolePromptFields(identity, { ownerIsAgent, toolFreeRole, delegationFree }) {
+  const skipRules = identity.skipAgentRules || toolFreeRole;
+  let roleRules = '';
+  if (!skipRules) {
+    roleRules = ownerIsAgent
+      ? _buildAgentRules(identity.agentRulesProfile)
+      : _buildLeadRules({ includeLeadBrief: !delegationFree });
+  }
+  return {
+    roleRules,
+    userPrompt: identity.systemPrompt,
+    skipRoleCatalog: !ownerIsAgent,
+    agent: identity.agent,
+    profile: { skip: identity.profileSkip },
+  };
+}
+
 export function composeSessionSystem(opts, { profile, providerName, modelName, surface }) {
   const { ownerIsAgent, resolvedAgent, skills } = surface;
   // A tool-free hidden role (a one-shot classifier or title writer) carries
@@ -105,12 +123,14 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
         model: modelName,
       });
   const delegationFree = delegationDisabled(opts, ownerIsAgent);
-  let roleRules = '';
-  if (!skipAgentRules) {
-    roleRules = ownerIsAgent
-      ? _buildAgentRules(surface.agentRulesProfile)
-      : _buildLeadRules({ includeLeadBrief: !delegationFree });
-  }
+  const promptIdentity = {
+    systemPrompt: opts.systemPrompt || '',
+    skipAgentRules: opts.skipAgentRules === true,
+    profileSkip: { ...profile?.skip },
+    agent: resolvedAgent,
+    agentRulesProfile: surface.agentRulesProfile,
+  };
+  const roleFields = sessionRolePromptFields(promptIdentity, { ownerIsAgent, toolFreeRole, delegationFree });
   const leadOnly = !skipAgentRules && !ownerIsAgent;
   const metaContext = leadOnly ? _buildLeadMetaContext() : '';
   // Lead-only response language; closes the environment block so no English
@@ -132,14 +152,10 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
       ? ''
       : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd: opts.cwd });
   const composed = composeSystemPrompt({
-    userPrompt: opts.systemPrompt,
+    ...roleFields,
     agentRules: injectedRules || undefined,
-    roleRules: roleRules || undefined,
     metaContext: metaContext || undefined,
     languageContext: languageContext || undefined,
-    skipRoleCatalog: !ownerIsAgent,
-    profile: profile || undefined,
-    agent: resolvedAgent,
     workflowContext: opts.workflowContext || null,
     coreMemoryContext: opts.coreMemoryContext || null,
     instructionFilesContext: instructionFilesContext || null,
@@ -147,7 +163,7 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     environmentContext: shellEnvironmentContext,
     provider: providerName || null,
   });
-  return { ...composed, environmentTailContext };
+  return { ...composed, environmentTailContext, promptIdentity };
 }
 
 // 4-BP layout (see composeSystemPrompt docs):
@@ -188,7 +204,7 @@ export function seedSessionMessages({ baseRules, stableSystemContext, sessionMar
   if (files?.length) {
     const fileContext = files.map((f) => `### ${f.path}\n\`\`\`\n${f.content}\n\`\`\``).join('\n\n');
     messages.push({ role: 'user', content: `Reference files:\n\n${fileContext}` });
-    messages.push({ role: 'assistant', content: '.' });
+    messages.push(contextAckMessage());
   }
   return messages;
 }

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

@@ -138,6 +138,8 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     agent: opts.agent,
     owner: opts.owner || 'user',
     bp3CoreContext: prompt.sessionMarkerCore,
+    promptIdentity: prompt.promptIdentity,
+    callerDisallowedTools: [...(opts.callerDisallowedTools ?? opts.disallowedTools ?? [])],
     bp3EnvironmentContext: prompt.environmentTailContext,
     // BP3 core and the volatile environment live in SEPARATE system
     // blocks (cacheTier 'tier3' vs 'env'). Legacy persisted sessions
@@ -162,9 +164,7 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     totalInputTokens: 0,
     totalOutputTokens: 0,
     totalToolCalls: 0,
-    // Refreshed on each completed ask() — surfaced by agent type=list for
-    // debugging + consumed by store.mjs's idle-sweep to reclaim stalled
-    // agent sessions past RUNNING_STALL_MS.
+    // Refreshed on each completed ask() — surfaced by agent type=list.
     lastUsedAt: Date.now(),
     tokensCumulative: 0,
     ...origin,

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint-recovery.mjs

@@ -0,0 +1,45 @@
+// manager/turn-checkpoint-recovery.mjs
+// Durable recovery of a turn interrupted by a process restart: an interrupted
+// turn checkpoint is committed as interrupted on resume. Every session runs in
+// the daemon, so a turn is live while this process runs it or while another
+// live process owns the daemon; reads never recover a live turn.
+import { join } from 'node:path';
+import { readSingletonOwner } from '../../../../shared/singleton-owner.mjs';
+import { loadSession, saveSession } from '../store.mjs';
+import { dataDir } from '../store-summary-locations.mjs';
+import { runtimeState, isTurnInFlight } from './runtime-state.mjs';
+import { clearTurnCheckpoint, recoverTurnCheckpoint } from './turn-checkpoint.mjs';
+
+/** Whether this session's turn may still be running: in flight in this
+ *  process, or owned by another live process holding the daemon record. */
+export function isSessionTurnLive(sessionId) {
+  if (isTurnInFlight(runtimeState.get(sessionId))) return true;
+  const { owner, alive } = readSingletonOwner(join(dataDir(), 'daemon-owner.json'));
+  return alive && Number(owner.pid) !== process.pid;
+}
+
+export function _recoverTurnCheckpointDurably(session, sessionId) {
+  const recovery = recoverTurnCheckpoint(session);
+  if (!recovery.changed) return recovery;
+  // Recovery is a durable reconnect boundary, not a renderer-only view.
+  // Persist before removing the checkpoint so a second crash leaves at
+  // least one complete copy of the interrupted turn.
+  saveSession(session, {
+    sync: true,
+    expectedGeneration: session.generation,
+  });
+  if (recovery.turnToken) {
+    clearTurnCheckpoint(sessionId, recovery.turnToken);
+  }
+  return recovery;
+}
+
+// Reconnect-safe historical read used by desktop pane peeks. Unlike a normal
+// read-only load, it resolves a dead owner's durable turn checkpoint before
+// returning the transcript; a live turn is returned untouched.
+export function recoverSessionAfterProcessRestart(sessionId) {
+  const session = loadSession(sessionId);
+  if (!session || session.closed === true || isSessionTurnLive(sessionId)) return session || null;
+  _recoverTurnCheckpointDurably(session, sessionId);
+  return session;
+}

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

@@ -2,7 +2,7 @@
 // Thin facade over the split session-manager modules in ./manager/.
 //
 // Module map:
-//   manager/runtime-liveness.mjs       — in-memory stage/heartbeat + accessors
+//   manager/runtime-liveness.mjs       — in-memory stage/progress + accessors
 //   manager/tool-resolution.mjs        — tool policy resolution/narrowing
 //   manager/context-meta.mjs           — context-window / compact-trigger meta
 //   manager/prompt-utils.mjs           — prompt content shaping helpers
@@ -45,6 +45,7 @@ export {
   markSessionError,
   markSessionCancelled,
   getSessionRuntime,
+  isSessionTurnInFlight,
   isSessionCompactionBlocked,
   getSessionProgressSnapshot,
   forEachSessionRuntime,
@@ -59,19 +60,12 @@ export { previewSessionTools } from './manager/tool-resolution.mjs';
 export {
   _mergePendingMessageEntries,
   enqueuePendingMessage,
-  enqueueRemotePendingMessage,
-  drainForeignUserInjections,
   drainPendingMessages,
   // Shutdown drain so buffered/in-flight spool writes are never abandoned.
   settlePendingMessageWrites,
   markCompletionEntry,
   COMPLETION_NOTIFICATION_KIND,
-  pendingMessagesSpoolPath,
 } from './manager/pending-messages.mjs';
-// Interactive-presence sidecar (idle-open ownership signal for the
-// attach-on-resume guard) — resolved through the manager facade so the
-// session-runtime turn API reaches it as mgr.publishSessionPresence.
-export { publishSessionPresence, deleteSessionPresence } from './store.mjs';
 
 // ── Usage-metrics surface — re-exported unchanged so loop.mjs / smoke scripts
 //    keep resolving these through the facade. ────────────────────────────────
@@ -105,7 +99,6 @@ export {
   prefetchSession,
   prepareSessionProjection,
   resumeSession,
-  isSessionOwnerGone,
   recoverSessionAfterProcessRestart,
 } from './manager/session-lifecycle.mjs';
 export { askSession, _api_call_with_interrupt } from './manager/ask-session.mjs';

package/src/runtime/agent/orchestrator/session/send-instrumentation.mjs

@@ -3,6 +3,7 @@
 // wrappers are installed on the caller's opts in place for ONE send, and the
 // returned restore unwinds only our own wrappers.
 import { isVisibleStreamProgress } from '../../../shared/stream-progress.mjs';
+import { MODEL_THINKING_STAGE } from '../../../shared/quiet-progress.mjs';
 
 // Bench-only turn timing (MIXDOG_TURN_TIMING=1): one stderr line per
 // provider request — TTFT (first visible model progress) and total stream
@@ -61,7 +62,7 @@ function retryVisibilityWrappers(opts, timedOpts, retryAttemptNumber, retryMaxFo
   if (!(retryAttemptNumber > 0 && prevOnStageChange)) return wrappers;
   let progressObserved = false;
   wrappers.onStageChange = (stage, detail) => {
-    if (!progressObserved && (stage === 'requesting' || stage === 'streaming')) {
+    if (!progressObserved && (stage === 'requesting' || stage === 'streaming' || stage === MODEL_THINKING_STAGE)) {
       return prevOnStageChange('reconnecting', {
         ...(detail && typeof detail === 'object' ? detail : {}),
         attempt: retryAttemptNumber,

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -37,7 +37,7 @@ import {
   isThinkingReplayRejection,
   repairThinkingReplayInPlace,
 } from './thinking-replay-recovery.mjs';
-import { readStreamOutcome } from '../providers/lib/stream-outcome.mjs';
+import { readStreamOutcome, stampStreamOutcome } from '../providers/lib/stream-outcome.mjs';
 import { cloneProviderReplay } from '../providers/lib/provider-replay.mjs';
 import { resolveWorkerCompactPolicy } from './loop/compact-policy.mjs';
 import { agentContextOverflowError } from './loop/context-overflow.mjs';
@@ -260,6 +260,7 @@ export async function sendWithRecovery(ctx) {
       hooks.logTurnTiming('ok');
     } catch (sendErr) {
       hooks.logTurnTiming(`err:${sendErr?.code || sendErr?.name || 'unknown'}`);
+      stampStreamOutcome(sendErr, hooks.relayWitness);
       return await recoverFromSendError(sendErr, { ...ctx, relayWitness: hooks.relayWitness });
     }
     return { action: 'proceed', response };
@@ -454,7 +455,9 @@ async function recoverFromSendError(sendErr, state) {
   if (toolSchemaDropUsed !== true) {
     const exclusion = rejectedToolSchema(sendErr, state);
     if (exclusion) {
-      logLoop(`[loop] provider rejected tool schema "${exclusion.name}" (${loopTag(state)}); dropping it and replaying once`);
+      logLoop(
+        `[loop] provider rejected tool schema "${exclusion.name}" (${loopTag(state)}); dropping it and replaying once`
+      );
       traceLoop(state, 'tool_schema_drop', { tool: exclusion.name });
       return { action: 'retry_tool_schema_drop', exclusion };
     }

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

@@ -54,7 +54,7 @@ function sideQuestionPrompt(question) {
 function replyMessages(response) {
   if (!response) return [];
   const reply = response.toolCalls?.length
-    ? buildToolCallAssistantMessage(response, { calls: response.toolCalls, suppressMidTurnText: false, opts: {} })
+    ? buildToolCallAssistantMessage(response, { calls: response.toolCalls, opts: {} })
     : buildIntermediateAssistantMessage(response, {});
   if (!reply) return [];
   const stubs = collectAssistantToolCallIds(reply).map((id) => ({
@@ -165,12 +165,17 @@ export async function askSideQuestion(sessionId, question) {
     const { messages, opts } = buildSideQuestionRequest(request, text);
     let response;
     try {
-      response = await request.provider.send(messages, request.model, request.tools.length ? request.tools : undefined, {
-        ...opts,
-        transportScope,
-        admissionOwner: sessionId,
-        signal: run.signal,
-      });
+      response = await request.provider.send(
+        messages,
+        request.model,
+        request.tools.length ? request.tools : undefined,
+        {
+          ...opts,
+          transportScope,
+          admissionOwner: sessionId,
+          signal: run.signal,
+        }
+      );
     } catch (error) {
       throw run.signal.aborted ? run.signal.reason : error;
     }

package/src/runtime/agent/orchestrator/session/store/lifecycle-barriers.mjs

@@ -11,7 +11,7 @@ import { join } from 'node:path';
 import { getPluginData } from '../../config.mjs';
 import { PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../../../../../lib/mixdog-debug.cjs';
 import { createAsyncLogAppender } from '../../../../shared/async-log-appender.mjs';
-import { sessionPath, deleteHeartbeat } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 import {
   readCanonicalSessionRecord as _readCanonicalRecord,
   CANONICAL_RECORD_UNREADABLE as LIFECYCLE_AMBIGUOUS,
@@ -36,7 +36,7 @@ import {
 } from './live-state.mjs';
 import { _uncacheSessionSummary, _queueSessionSummaryUpsert } from './summary-cache.mjs';
 import { _savePending, _clearDebounce } from './pending-saves.mjs';
-import { _runtimeLivenessVeto, _heartbeatLivenessVeto, _deleteHeartbeatUnlessNewer } from './liveness-veto.mjs';
+import { _runtimeLivenessVeto } from './liveness-veto.mjs';
 import { loadSession } from './load-session.mjs';
 
 // Cancellation truth, single rule: an UNCONFIRMED stop outranks a confirmed
@@ -185,15 +185,11 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
   // Caller-provided probes may re-enter the store, so evaluate them before
   // taking the non-reentrant Atomics commit lock. A veto must also precede
   // pending-save cancellation so debounce durability remains intact.
-  if (_runtimeLivenessVeto(id, options) || _heartbeatLivenessVeto(id, options)) return null;
+  if (_runtimeLivenessVeto(id, options)) return null;
   const closeGuard = _guardedSaveOptions(id);
   const commitControl = _acquireWriteCommit(closeGuard);
   if (commitControl === false) return null;
   try {
-    // Cross-process heartbeat revival after full-TTL silence is accepted as a
-    // best-effort race: the tombstone resurrection guard is the authoritative
-    // post-race arbiter. Re-stat here, but never invoke caller code under lock.
-    if (_heartbeatLivenessVeto(id, options)) return null;
     const authority = _readLifecycleAuthority(id, reason, 'close');
     if (authority === LIFECYCLE_AMBIGUOUS) return null;
     // Only a committed close may disrupt pending persistence.
@@ -230,7 +226,7 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
     const tombstone = {
       ...base,
       closed: true,
-      closedReason: alreadyClosed ? base.closedReason || reason : reason,
+      closedReason: alreadyClosed && reason !== 'desktop-session-delete' ? base.closedReason || reason : reason,
       status: 'closed',
       generation: newGen,
       updatedAt: closeTime,
@@ -240,8 +236,6 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
     _savePending.delete(id);
     clearSessionSaveError(id);
     _clearLiveSession(id);
-    // Preserve a sidecar published strictly after the sweep's scan snapshot.
-    _deleteHeartbeatUnlessNewer(id, options);
     _queueSessionSummaryUpsert(tombstone);
     _droppedSaveIds.delete(id);
     // Emit the close metric only on the FIRST close — a re-close of an
@@ -257,7 +251,7 @@ export function markSessionClosed(id, reason = 'manual', options = {}) {
 /**
  * Bump a session's generation WITHOUT planting a closed:true tombstone.
  * Used by closeSession(id, reason, { tombstone: false }) — the runtime side
- * (heartbeat, bash shells, controller, in-memory entry) is detached, but the
+ * (bash shells, controller, in-memory entry) is detached, but the
  * session file itself stays valid/resumable. The generation bump alone is
  * what protects it from a late save race: any saveSession() still in flight
  * from the detached turn was issued with the OLD generation as its
@@ -299,7 +293,6 @@ export function bumpSessionGeneration(id, reason = 'detach', options = {}) {
     _savePending.delete(id);
     clearSessionSaveError(id);
     _clearLiveSession(id);
-    deleteHeartbeat(id);
     _queueSessionSummaryUpsert(detached);
     _droppedSaveIds.delete(id);
     return newGen;

package/src/runtime/agent/orchestrator/session/store/lifecycle-read.mjs

@@ -6,7 +6,7 @@
  * path and of the in-memory snapshot caches.
  */
 import { readCanonicalSessionRecord, CANONICAL_RECORD_UNREADABLE } from './canonical-reader.mjs';
-import { sessionPath } from './paths-heartbeat.mjs';
+import { sessionPath } from './session-paths.mjs';
 
 /**
  * Cheap authoritative lifecycle read straight from disk (no live/pending