mixdog 1.4.0 → 1.4.1

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

@@ -17,6 +17,10 @@
 //   stage, lastStreamDeltaAt, lastTransportAt, firstSemanticAt,
 //   lastSemanticAt, lastReasoningAt, lastVisibleTextAt, lastToolProtocolAt,
 //   lastToolCall, lastError, updatedAt,
+//   modelRequestStartedAt, requestTransportAt, requestFirstSemanticAt,
+//   modelResponseAccepted,  // the current logical model request (see
+//                           // _setLogicalModelRequest); the fields above
+//                           // stay turn-level history
 //   controller?: AbortController,  // set while an ask is in flight
 //   generation?: number,            // snapshot taken at ask start
 //   closed?: boolean,               // flipped by closeSession()
@@ -131,6 +135,23 @@ function _startToolActivityHeartbeat(id) {
   _toolActivityHeartbeats.set(id, timer);
 }
 
+// One logical model request owns one first-output allowance: its request
+// clock and its own first transport / first semantic marks. It begins with the
+// ask's first request, with the first request after the model's previous
+// response was accepted (its tool calls ran — the request that carries the
+// tool results), and with a request after a settled turn. Every other entry
+// into `requesting` — a provider or loop retry, a route fallback, a no-tool
+// recovery continuation — re-sends the same logical request and keeps all of
+// it, so a retry never earns a fresh allowance. The turn-level marks
+// (firstSemanticAt, lastTransportAt, …) are history and are not touched.
+// `startedAt` null: no request yet (an ask starting).
+function _setLogicalModelRequest(entry, startedAt) {
+  entry.modelRequestStartedAt = startedAt;
+  entry.requestTransportAt = null;
+  entry.requestFirstSemanticAt = null;
+  entry.modelResponseAccepted = false;
+}
+
 export function updateSessionStage(id, stage) {
   if (stage === MODEL_THINKING_STAGE) {
     markSessionRequestSent(id);
@@ -143,8 +164,11 @@ export function updateSessionStage(id, 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;
+  if (
+    stage === 'requesting' &&
+    (!entry.modelRequestStartedAt || entry.modelResponseAccepted || TERMINAL_STAGES.has(priorStage))
+  ) {
+    _setLogicalModelRequest(entry, now);
   }
   entry.lastProgressAt = now;
   entry.updatedAt = now;
@@ -192,7 +216,7 @@ export function markSessionAskStart(id) {
   // after provider admission (the scheduler emits stage=requesting).
   const now = Date.now();
   entry.askStartedAt = now;
-  entry.modelRequestStartedAt = null;
+  _setLogicalModelRequest(entry, null);
   entry.lastProgressAt = now;
   entry.updatedAt = now;
   entry.taskWaits = 0;
@@ -229,13 +253,14 @@ export function markSessionTransportActivity(id) {
   if (!entry || entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
   const now = Date.now();
   entry.lastTransportAt = now;
+  entry.requestTransportAt = now;
   entry.updatedAt = now;
 }
 function _normalizeModelProgressKind(kind) {
   let value = 'semantic';
   if (typeof kind === 'string') value = kind;
   else if (kind && typeof kind.kind === 'string') value = kind.kind;
-  if (value === 'transport' || value === 'reasoning' || value === 'text' || value === 'tool') {
+  if (value === 'transport' || value === 'keepalive' || value === 'reasoning' || value === 'text' || value === 'tool') {
     return value;
   }
   return 'semantic';
@@ -257,12 +282,22 @@ export async function markSessionStreamDelta(id, kind = 'semantic') {
     markSessionTransportActivity(id);
     return;
   }
+  if (progressKind === 'keepalive') {
+    markSessionTransportActivity(id);
+    // A keepalive before the request's first semantic event is covered by the
+    // first-output window and never counts as progress. lastProgressAt stays
+    // untouched: the watchdog caps how long keepalives may extend it.
+    if (entry.requestFirstSemanticAt) entry.lastKeepaliveAt = Date.now();
+    return;
+  }
   _stopToolActivityHeartbeat(id);
   const now = Date.now();
   // Every semantic model event also proves transport health. The inverse is
   // intentionally false: raw chunks/keepalives update only lastTransportAt.
   entry.lastTransportAt = now;
+  entry.requestTransportAt = now;
   if (!entry.firstSemanticAt) entry.firstSemanticAt = now;
+  if (!entry.requestFirstSemanticAt) entry.requestFirstSemanticAt = now;
   entry.lastSemanticAt = now;
   entry.lastSemanticKind = progressKind;
   if (progressKind === 'reasoning') entry.lastReasoningAt = now;
@@ -296,7 +331,12 @@ export function markSessionToolCall(id, toolName) {
   entry.toolOutputTailAt = null;
   entry.toolStartedAt = Date.now();
   entry.lastTransportAt = entry.toolStartedAt;
+  entry.requestTransportAt = entry.toolStartedAt;
   if (!entry.firstSemanticAt) entry.firstSemanticAt = entry.toolStartedAt;
+  if (!entry.requestFirstSemanticAt) entry.requestFirstSemanticAt = entry.toolStartedAt;
+  // The response whose tool call runs now was accepted: the next model
+  // request carries its tool results and is a new logical request.
+  entry.modelResponseAccepted = true;
   entry.lastSemanticAt = entry.toolStartedAt;
   entry.lastSemanticKind = 'tool';
   entry.lastToolProtocolAt = entry.toolStartedAt;
@@ -436,6 +476,18 @@ export function markSessionCancelled(id) {
   entry.emptyFinalAt = null;
   _unlinkParentAbortListener(entry);
 }
+/**
+ * The session's current logical model request: when it started and whether
+ * it has produced semantic output yet. A provider stream opened for it — a
+ * retry or a route fallback included — bounds its first-output phase by this
+ * request instead of starting a fresh one. Null without a request.
+ */
+export function getLogicalModelRequest(sessionId) {
+  const entry = sessionId ? _runtimeState.get(sessionId) : null;
+  if (!entry?.modelRequestStartedAt) return null;
+  return { startedAt: entry.modelRequestStartedAt, outputSeen: Boolean(entry.requestFirstSemanticAt) };
+}
+
 export function getSessionRuntime(id) {
   return id ? _runtimeState.get(id) || null : null;
 }
@@ -458,8 +510,10 @@ export function getSessionProgressSnapshot(sessionId) {
   const firstActivityAt = firstSemanticAt;
   const stage = entry.stage || 'idle';
   const activeModelStage = stage === 'connecting' || stage === 'requesting' || stage === 'streaming';
-  const waitingForTransport = Boolean(modelRequestStartedAt && activeModelStage && !entry.lastTransportAt);
-  const waitingForFirstSemantic = Boolean(modelRequestStartedAt && activeModelStage && !firstSemanticAt);
+  // Judged per logical model request: output an earlier request of this turn
+  // produced never ends a later request's first-output phase.
+  const waitingForTransport = Boolean(modelRequestStartedAt && activeModelStage && !entry.requestTransportAt);
+  const waitingForFirstSemantic = Boolean(modelRequestStartedAt && activeModelStage && !entry.requestFirstSemanticAt);
   return {
     stage,
     askStartedAt,
@@ -481,6 +535,7 @@ export function getSessionProgressSnapshot(sessionId) {
     toolOutputTail: entry.toolOutputTail || null,
     toolOutputTailAt: entry.toolOutputTailAt || 0,
     lastProgressAt: entry.lastProgressAt || 0,
+    lastKeepaliveAt: entry.lastKeepaliveAt || 0,
     updatedAt: entry.updatedAt || 0,
     hasFirstActivity: Boolean(firstSemanticAt && (!askStartedAt || firstSemanticAt >= askStartedAt)),
     hasFirstSemantic: Boolean(firstSemanticAt && (!askStartedAt || firstSemanticAt >= askStartedAt)),

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

@@ -42,11 +42,13 @@ 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 { executionFallbacks } from '../../../../shared/model-route-chain.mjs';
 import { ownerRouteFallbacks } from './owner-route-fallbacks.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';
+import { cancelCacheWarm } from '../cache-warm.mjs';
 
 // Durable turn-checkpoint recovery; re-exported so prior importers of this
 // module stay unchanged.
@@ -239,11 +241,13 @@ export function createSession(createOpts) {
     ? Object.hasOwn(opts, 'routeFallbacks')
       ? opts.routeFallbacks
       : ownerRouteFallbacks({ sessionMode, agentId: actingAgent, provider: providerName, model: modelName })
-    : normalizeWorkflowRoute({
-        provider: providerName,
-        model: modelName,
-        fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.fallbacks,
-      })?.fallbacks;
+    : executionFallbacks(
+        normalizeWorkflowRoute({
+          provider: providerName,
+          model: modelName,
+          fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.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
@@ -262,7 +266,7 @@ export function createSession(createOpts) {
     : agentProfileRevision(surface.resolvedAgent, { mixy: sessionMode === AGENT_MODE });
   // A bot thread lives on across releases: the rules it was built from.
   const rulesRevision = agentProfile && sessionMode === AGENT_MODE ? promptRulesRevision() : '';
-  const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode });
+  const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode, sessionId: id });
   const messages = seedSessionMessages(prompt, opts.files);
   logSessionSurface(surface);
   const contextMeta = resolveSessionContextMeta(provider, modelName, {
@@ -322,24 +326,27 @@ export function contextSeedForRouteUpdate(session, routeChanged, selectedContext
 // ever replaced; custom-prompt or agent layouts without that block are left
 // untouched, and a same-variant switch is a no-op.
 export function _refreshSessionRuleVariantsForModel(session, previousModel, previousProvider = session?.provider) {
+  const ownerIsAgent = isAgentOwner(session);
   const deny = [
     ...(Array.isArray(session?.disallowedTools) ? session.disallowedTools : []),
     ...(getHiddenAgent(session?.agent || null) ? ['Skill'] : []),
-    ...(delegationDisabled(session, isAgentOwner(session)) ? ['agent'] : []),
+    ...(delegationDisabled(session, ownerIsAgent) ? ['agent'] : []),
   ];
   const allowTools = honoredSchemaAllowlist(session?.schemaAllowedTools, {
-    ownerIsAgent: isAgentOwner(session),
+    ownerIsAgent,
     agent: session?.agent || null,
   });
   const previousRules = _buildBaseRules({
     omitTools: [...deny, unusedModelEditToolName(previousModel)],
     allowTools,
+    ownerIsAgent,
     provider: previousProvider,
     model: previousModel,
   });
   const nextRules = _buildBaseRules({
     omitTools: [...deny, unusedModelEditToolName(session?.model)],
     allowTools,
+    ownerIsAgent,
     provider: session?.provider,
     model: session?.model,
   });
@@ -436,6 +443,10 @@ function resetSessionForRouteChange(id, session, previousModel, previousProvider
   delete session._providerPrefixGuardState;
   // The new route resolves its own wire before its first request.
   session.wireRoute = null;
+  // A warm chain replays the previous route's request: stop it. Its recorded
+  // warm use names that route, so it never counts as fresh cache for the new
+  // one (compact-policy.mjs shouldCompactForExpiredAgentCache).
+  cancelCacheWarm(id);
   const prepared = _prepareResumeTools(session, session.preset || 'full');
   session.tools = prepared.tools;
   session.toolSpec = prepared.toolSpec;

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

@@ -21,6 +21,7 @@ import {
   describeShellToolsStartupState,
 } from '../../tools/builtin/runtime-capabilities.mjs';
 import { captureOriginalUserCwd } from '../../../../shared/user-cwd.mjs';
+import { sessionScratchDir } from '../../../../shared/session-scratch.mjs';
 import { delegationDisabled } from './session-tool-surface.mjs';
 import { contextAckMessage } from '../compact/user-message-kind.mjs';
 
@@ -31,7 +32,9 @@ import { contextAckMessage } from '../compact/user-message-kind.mjs';
 // it still get a location line via captureOriginalUserCwd(), which
 // resolves explicit session signals first and never leaks the daemon's
 // install root (user-cwd.mjs safe fallback chain).
-function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting) {
+function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting, sessionId = null) {
+  // Fixed per session id and data dir, so the line never changes across turns.
+  const scratchDir = sessionScratchDir(sessionId);
   const sessionCwdLine = opts.cwd || captureOriginalUserCwd();
   const wantsGitStartupLine = toolsForRouting.some((tool) => tool?.name === 'git');
   let cwdContextLine = '';
@@ -45,6 +48,9 @@ function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting) {
   return [
     cwdContextLine,
     `- Shell: ${shellName}. Use ${shellName} syntax unless the user specifies otherwise.`,
+    scratchDir
+      ? `- Scratch: ${scratchDir} — this session's scratch directory; TEMP, TMP and TMPDIR in shell commands point here.`
+      : '',
     // Which common tools the shell can run, measured where commands run
     // (login shell on POSIX, this process's PATH on Windows); see
     // runtime-capabilities.mjs. Recorded runs spent a round per session
@@ -84,7 +90,7 @@ export function buildWorkspacePromptContext(session, cwd) {
     ...(Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []),
   ];
   return {
-    environmentContext: buildShellEnvironmentContext({ cwd }, ownerIsAgent, tools),
+    environmentContext: buildShellEnvironmentContext({ cwd }, ownerIsAgent, tools, session?.id),
     // Agent mode never carries project instruction files.
     instructionFilesContext:
       session?.skipInstructionFiles === true || sessionModeOf(session) === AGENT_MODE
@@ -143,7 +149,7 @@ export function sessionRolePromptFields(identity, { ownerIsAgent, toolFreeRole,
   };
 }
 
-export function composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode }) {
+export function composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode, sessionId }) {
   const agentMode = sessionMode === AGENT_MODE;
   const { ownerIsAgent, resolvedAgent, skills } = surface;
   // A tool-free hidden role (a one-shot classifier or title writer) carries
@@ -156,6 +162,7 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     : _buildBaseRules({
         omitTools: surface.ruleOmitTools,
         allowTools: surface.schemaAllowedTools,
+        ownerIsAgent,
         provider: providerName,
         model: modelName,
       });
@@ -177,12 +184,12 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
   const metaContext = leadOnly ? _buildLeadMetaContext({ includeOutputStyle: !agentMode }) : '';
   // Lead-only response language; closes the environment block so no English
   // system text (session/shell/git lines) follows it.
-  const languageContext = leadOnly ? _buildLeadLanguageContext() : '';
+  const languageContext = leadOnly ? _buildLeadLanguageContext({ includeOutputStyle: !agentMode }) : '';
   // Cwd, shell and repository facts only serve tool calls; a tool-free role
   // gets none, which also keeps its prompt identical across projects.
   const shellEnvironmentContext = toolFreeRole
     ? ''
-    : buildShellEnvironmentContext(opts, ownerIsAgent, surface.toolsForRouting);
+    : buildShellEnvironmentContext(opts, ownerIsAgent, surface.toolsForRouting, sessionId);
   // Persisted env tail: refreshSessionBp3Environment rebuilds the env block
   // as [session, bp3EnvironmentContext], so the language block must
   // already sit at the end of this string to stay last after a refresh.

package/src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs

@@ -3,7 +3,7 @@
 import { compareCodePoints } from '../../../../shared/code-point-order.mjs';
 import { getMcpTools } from '../../mcp/client.mjs';
 import { getInternalTools } from '../../internal-tools.mjs';
-import { BUILTIN_TOOLS, bindShellKind } from '../../tools/builtin/builtin-tools.mjs';
+import { BUILTIN_TOOLS, bindAgentOwner, bindShellKind } from '../../tools/builtin/builtin-tools.mjs';
 import { resolveShellFor } from '../../tools/builtin/shell-runtime.mjs';
 import { PATCH_TOOL_DEFS } from '../../tools/patch-tool-defs.mjs';
 import { CODE_GRAPH_TOOL_DEFS } from '../../tools/code-graph-tool-defs.mjs';
@@ -51,7 +51,7 @@ const FILESYSTEM_TOOL_NAMES = new Set(['code_graph', 'find', 'glob', 'list', 'gr
 const READONLY_FS_TOOL_NAMES = new Set(['code_graph', 'find', 'glob', 'list', 'grep', 'read']);
 
 // Lead-only control tools: never part of a worker/sub-agent session surface.
-export const AGENT_WORKER_DENIED_TOOLS = Object.freeze(new Set(['agent', 'ask_user', 'session']));
+export const AGENT_WORKER_DENIED_TOOLS = Object.freeze(new Set(['agent', 'ask_user', 'handoff_user', 'session']));
 
 export function finalizeSessionToolList(
   tools,
@@ -70,7 +70,7 @@ export function finalizeSessionToolList(
   }
   if (ownerIsAgent) {
     out = out.filter((t) => !AGENT_WORKER_DENIED_TOOLS.has(String(t?.name || '').toLowerCase()));
-    out = orderSessionTools(out);
+    out = orderSessionTools(out.map(bindAgentOwner));
   }
   return out;
 }

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

@@ -93,6 +93,10 @@ export function captureTurnCheckpointContextState(session, messages, currentUser
     ),
     ...(kind === 'post_compact' ? { usageSnapshot: { ...usageSnapshot } } : {}),
     compaction: compactCheckpointState(session.compaction),
+    // Diagnostic only: the prefix fingerprint of the turn's last settled
+    // request (anthropic-prefix-trace.mjs), so the first request after a
+    // crash is still traced against it.
+    ...(session.providerPrefixBaseline ? { prefixBaseline: session.providerPrefixBaseline } : {}),
   };
 }
 

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

@@ -224,6 +224,9 @@ export function recoverTurnCheckpoint(session) {
   // mark it unanchored so the first resumed send cannot compact from a gross
   // whole-transcript estimate.
   const contextStateRestored = restoreTurnCheckpointContextState(session, checkpoint);
+  // Diagnostic only (anthropic-prefix-trace.mjs): the turn's last settled
+  // request, whatever the context reading's alignment.
+  if (checkpoint.contextState?.prefixBaseline) session.providerPrefixBaseline = checkpoint.contextState.prefixBaseline;
   delete session.activeTurnCheckpoint;
   delete session.providerState;
   delete session._providerPrefixGuardState;

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

@@ -110,6 +110,15 @@ function finalizeInterruptedTurn({
     };
   }
 
+  // Killed with a request on the wire (phase 'streaming' after a tool run):
+  // the provider received the transcript up to its last message, and may
+  // have cached it. Stamping that message keeps what this interruption
+  // appends (the marker, the next prompt) out of the tool_result it ends —
+  // see toAnthropicMessages. The stamp is meta only; no wire bytes change.
+  const sentTail = messages.length - 1;
+  if (phase === 'streaming' && (messages[sentTail]?.role === 'tool' || messages[sentTail]?.role === 'user')) {
+    messages[sentTail] = { ...messages[sentTail], meta: { ...messages[sentTail].meta, sentRequestTail: true } };
+  }
   appendObservedTurnOutput(messages, {
     partialAssistantContent,
     partialReasoningContent,

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -92,7 +92,11 @@ function preSendCompactDecision(state, compactPolicy) {
     messages,
     sessionRef,
   });
-  const cacheExpired = shouldCompactForExpiredAgentCache(sessionRef, state.opts);
+  const cacheExpired = shouldCompactForExpiredAgentCache(sessionRef, state.opts, {
+    provider: sessionRef?.provider || state.provider?.name,
+    model: state.model,
+    messages,
+  });
   const mediaPressure = shouldCompactForRequestMedia(messages, sessionRef?.provider);
   const requireReduction = !reactivePending && !mediaPressure;
   let shouldCompact =

package/src/runtime/agent/orchestrator/session/prompt-cache-touch-store.mjs

@@ -26,6 +26,20 @@ function validTouch(value) {
   );
 }
 
+// A warm use as stored: `{ at, provider, model, accountId }` — the route and
+// account whose cached prefix the warm read. A bare time (written before the
+// identity was recorded) keeps its time and matches no route.
+function warmUseRecord(value) {
+  const record = value && typeof value === 'object' ? value : { at: value };
+  if (!(Number(record.at) > 0)) return null;
+  return {
+    at: Number(record.at),
+    provider: String(record.provider || ''),
+    model: String(record.model || ''),
+    accountId: String(record.accountId || ''),
+  };
+}
+
 /** A touch store backed by `path` (default: the data dir's file). */
 export function createPromptCacheTouchStore(
   path = () => join(resolvePluginData(), PROMPT_CACHE_TOUCH_FILE),
@@ -43,8 +57,9 @@ export function createPromptCacheTouchStore(
     for (const [sessionId, touch] of Object.entries(stored?.touches || {})) {
       if (validTouch(touch)) touches.set(sessionId, { ...touch });
     }
-    for (const [sessionId, at] of Object.entries(stored?.warmUses || {})) {
-      if (Number(at) > 0) warmUses.set(sessionId, Number(at));
+    for (const [sessionId, use] of Object.entries(stored?.warmUses || {})) {
+      const record = warmUseRecord(use);
+      if (record) warmUses.set(sessionId, record);
     }
     return touches;
   };
@@ -102,12 +117,20 @@ export function createPromptCacheTouchStore(
     },
     /** When a warm last used the session's cache successfully, or 0. */
     lastWarmUse(sessionId) {
-      return uses().get(String(sessionId || '')) || 0;
+      return uses().get(String(sessionId || ''))?.at || 0;
+    },
+    /** The session's last successful warm use `{ at, provider, model,
+     *  accountId }`, or null. */
+    warmUse(sessionId) {
+      const use = uses().get(String(sessionId || ''));
+      return use ? { ...use } : null;
     },
-    /** A warm read the session's cache without writing at `at`. */
-    recordWarmUse(sessionId, at) {
-      if (!sessionId || !(Number(at) > 0)) return;
-      uses().set(String(sessionId), Number(at));
+    /** A warm read the session's cache without writing at `at`, on the
+     *  route and account `{ provider, model, accountId }`. */
+    recordWarmUse(sessionId, at, identity = {}) {
+      const record = warmUseRecord({ ...identity, at });
+      if (!sessionId || !record) return;
+      uses().set(String(sessionId), record);
       scheduleFlush();
     },
     /** The session's own activity supersedes its warm use (a real request

package/src/runtime/agent/orchestrator/session/restart-prefix-parity.fixture.mjs

@@ -0,0 +1,154 @@
+// Child process of restart-prefix-parity.test.mjs: one phase of a scripted
+// anthropic-oauth session in its own process, so a "restart" is a real new
+// process reading the data dir the previous one left. The fake provider
+// records the request body the real OAuth builder makes for every main-loop
+// send (providers/anthropic-oauth.mjs buildRequestBody, after the same
+// tool-pair sanitize its send path runs) and answers from a script.
+//
+//   node restart-prefix-parity.fixture.mjs <phase> <dataDir> <outFile> [sessionId]
+//   phase idle    two complete turns, then exit
+//   phase killtool    one complete turn; the second turn's second request is
+//                     answered with a tool call whose run settles the journal,
+//                     prints READY and hangs until the parent kills the process
+//   phase killrequest the same, but it hangs in the second request itself
+//                     (sent, never answered)
+//   phase resume  one turn on the stored session (crash recovery included)
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const [phase, dataDir, outFile, resumeId] = process.argv.slice(2);
+process.env.MIXDOG_DATA_DIR = dataDir;
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+const workDir = join(dataDir, '..', 'work');
+mkdirSync(workDir, { recursive: true });
+// The response language defaults to the system locale, and only a Korean one
+// gets Opus 5.5's turn-scoped tail reminder (tail-reminder-rules.mjs), so the
+// language is pinned: every host sends the same requests. The resume phase
+// reads what the first phase wrote.
+if (phase !== 'resume') {
+  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({ agent: { profile: { language: 'ko' } } }));
+}
+// One file per call: a repeated read is answered from the read cache, which
+// never reaches the tool run the midturn phase hangs in.
+for (const name of ['call_1', 'call_2', 'call_3']) writeFileSync(join(workDir, `${name}.txt`), `${name}\n`);
+
+const { createSession } = await import('./manager/session-lifecycle.mjs');
+const { askSession } = await import('./manager/ask-session.mjs');
+const { settleTurnCheckpointWrites } = await import('./manager/turn-checkpoint.mjs');
+const { sanitizeToolPairs } = await import('./context-utils.mjs');
+const { _withRegisteredProviderForTestAsync } = await import('../providers/registry.mjs');
+const { _buildRequestBodyForCacheSmoke } = await import('../providers/anthropic-oauth.mjs');
+const { modelToolSchemaAllowlist } = await import('../runtime-core/tool-profile.mjs');
+const { anthropicPrefixChanges, anthropicPrefixFingerprint, anthropicPrefixSessionId, recordAnthropicPrefix } =
+  await import('../providers/lib/anthropic-prefix-trace.mjs');
+
+const MODEL = 'claude-opus-5-5';
+const USAGE = { inputTokens: 10, outputTokens: 5, cachedTokens: 0, cacheWriteTokens: 0 };
+const thinking = (id) => [{ type: 'thinking', thinking: `plan ${id}`, signature: `sig-${id}` }];
+const toolStep = (id) => async () => ({
+  content: 'Reading.',
+  thinkingBlocks: thinking(id),
+  hasThinkingContent: true,
+  toolCalls: [{ id, name: 'read', arguments: { path: `${id}.txt` } }],
+  stopReason: 'tool_use',
+  usage: USAGE,
+});
+const textStep = (text) => async () => ({
+  content: text,
+  thinkingBlocks: thinking(text),
+  hasThinkingContent: true,
+  stopReason: 'end_turn',
+  usage: USAGE,
+});
+
+const bodies = [];
+const changes = [];
+let warmBody = null;
+let script = [];
+let sessionId = resumeId || null;
+const provider = {
+  name: 'anthropic-oauth',
+  contextWindow: 200_000,
+  async send(messages, model, tools, opts) {
+    if (opts?.requestKind && opts.requestKind !== 'turn') return { content: 'Title', usage: USAGE };
+    const body = await _buildRequestBodyForCacheSmoke(sanitizeToolPairs(messages), model, tools || [], opts);
+    bodies.push(JSON.parse(JSON.stringify(body)));
+    // The diagnostic fingerprint the real send records, and what it reports
+    // against the previous request (the record's, after a restart).
+    recordAnthropicPrefix(anthropicPrefixSessionId(opts), anthropicPrefixFingerprint(body));
+    changes.push(anthropicPrefixChanges(anthropicPrefixSessionId(opts)));
+    const step = script.shift();
+    if (!step) throw new Error(`unscripted send #${bodies.length}`);
+    return step();
+  },
+};
+
+// Where the interrupted turn stops: the checkpoint made durable, the recorded
+// bodies handed over, and nothing ever finishes (the parent kills the process).
+const hang = async () => {
+  await settleTurnCheckpointWrites(sessionId);
+  await new Promise((resolve) => setTimeout(resolve, 300));
+  await settleTurnCheckpointWrites(sessionId);
+  writeFileSync(outFile, JSON.stringify({ sessionId, bodies, changes }));
+  process.stdout.write('READY\n');
+  return new Promise(() => {});
+};
+// killtool: in the second tool run of the turn (after its second request settled).
+let toolRuns = 0;
+const hangInSecondTool = async () => {
+  toolRuns += 1;
+  if (toolRuns >= 2) await hang();
+};
+
+await _withRegisteredProviderForTestAsync('anthropic-oauth', provider, async () => {
+  if (phase === 'resume') {
+    // The cache warm a restart re-arms (cache-warm.mjs rearmCacheWarmsAfterRestart)
+    // replays this request, built before the next turn touches the session.
+    const { lastSentMainRequest } = await import('./side-question.mjs');
+    const { cacheWarmSend } = await import('./cache-warm.mjs');
+    const request = lastSentMainRequest(sessionId);
+    if (request) {
+      const send = cacheWarmSend(request);
+      warmBody = await _buildRequestBodyForCacheSmoke(
+        sanitizeToolPairs(send.messages),
+        send.model,
+        send.tools || [],
+        send.opts
+      );
+    }
+    script = [textStep('resumed')];
+    await askSession(sessionId, 'third task', null, null, null, null, {});
+    return;
+  }
+  const session = createSession({
+    provider: 'anthropic-oauth',
+    model: MODEL,
+    cwd: workDir,
+    skipSkills: true,
+    schemaAllowedTools: modelToolSchemaAllowlist('headless'),
+    workflow: { id: 'headless', delegatesAgents: false },
+  });
+  sessionId = session.id;
+  if (phase === 'idle') {
+    script = [toolStep('call_1'), textStep('done one'), toolStep('call_2'), textStep('done two')];
+    await askSession(sessionId, 'first task', null, null, null, null, {});
+    await askSession(sessionId, 'second task', null, null, null, null, {});
+    return;
+  }
+  // killrequest: while the turn's second request is on the wire.
+  const killTool = phase === 'killtool';
+  script = [toolStep('call_1'), textStep('done one'), toolStep('call_2'), killTool ? toolStep('call_3') : hang];
+  await askSession(sessionId, 'first task', null, null, null, null, {});
+  await askSession(
+    sessionId,
+    'second task',
+    null,
+    null,
+    null,
+    null,
+    killTool ? { beforeToolExecution: hangInSecondTool } : {}
+  );
+});
+
+writeFileSync(outFile, JSON.stringify({ sessionId, bodies, changes, warmBody }));
+process.exit(0);

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

@@ -36,6 +36,7 @@ import { _savePending, _clearDebounce, _releasePendingSlot } from './pending-sav
 import { _runtimeLivenessVeto } from './liveness-veto.mjs';
 import { _runSessionPurgeHooks } from './session-observers.mjs';
 import { deleteCompactionArchive } from '../compaction-archive.mjs';
+import { removeSessionScratchDir } from '../../../../shared/session-scratch.mjs';
 
 /** Child-agent session ids linked to one visible parent. Candidates come from
  * metadata only (the summary rows and the agent-worker links — no folder
@@ -154,6 +155,12 @@ export function deleteSession(id, options = {}) {
     _runSessionPurgeHooks(id, { cwds: knownSessionCwds(id) });
     // The display-only compaction archive has no meaning without its session.
     deleteCompactionArchive(getStoreDir(), id);
+    // The session's scratch directory (shell TEMP/TMP/TMPDIR) goes with it.
+    try {
+      removeSessionScratchDir(id);
+    } catch {
+      /* a locked scratch file never fails the delete */
+    }
     _clearLiveSession(id);
     // The file is gone: every marker of the retired incarnation goes with it
     // (save error + failed-snapshot evidence, split-brain drop flag, lifecycle

package/src/runtime/agent/orchestrator/session/store-summary-catalog.mjs

@@ -30,6 +30,7 @@ import {
   inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber,
+  compactCountField,
   realTurnCount,
   workspaceSummary,
 } from './store-summary-fields.mjs';
@@ -216,6 +217,9 @@ export function normalizedRow(row) {
     // Absent from a row read off a session file: its assistant text is not
     // decoded there, so the unread count falls back until the next save.
     ...(Array.isArray(row.incomingTail) ? { incomingTail: normalizedIncomingTail(row.incomingTail) } : {}),
+    // Absent from a row read off a session file (its compaction record is not
+    // decoded there) until the next save.
+    ...compactCountField(row),
     realTurnCount: realTurnCount(row),
     title: cleanText(row.title, 100),
     preview: cleanText(row.preview),

package/src/runtime/agent/orchestrator/session/store-summary-fields.mjs

@@ -63,6 +63,21 @@ export function realTurnCount(value) {
   return typeof count === 'number' && Number.isFinite(count) && count >= 0 ? Math.floor(count) : null;
 }
 
+/** How many compactions a session has had (`compaction.compactCount`): each
+ *  one trims the live messages and so restarts their numbering (the unread
+ *  cursors count them). Null for a value without it, e.g. a row written
+ *  before the field existed. */
+export function compactCount(value) {
+  const count = value?.compactCount;
+  return typeof count === 'number' && Number.isSafeInteger(count) && count >= 0 ? count : null;
+}
+
+/** `{ compactCount }` for a row that carries one, else nothing. */
+export function compactCountField(value) {
+  const count = compactCount(value);
+  return count === null ? {} : { compactCount: count };
+}
+
 export function importKey(value) {
   const key = typeof value?.importKey === 'string' ? value.importKey : value?.importOrigin?.key;
   return typeof key === 'string' && key.trim() ? key : null;