mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -602,6 +602,18 @@ export function shouldCompactForRequestMedia(messages) {
   return false;
 }
 
+// Anthropic's 5m message-tail TTL (agent-runtime/cache-strategy.mjs gives it
+// to agent sessions). A send this long after the previous one finds the tail
+// cache expired and would rewrite the whole accumulated transcript; compacting
+// first makes that cold write the compacted transcript instead.
+const AGENT_MESSAGE_CACHE_TTL_MS = 5 * 60_000;
+
+export function shouldCompactForExpiredAgentCache(sessionRef, opts) {
+  if (!isAgentOwner(sessionRef) || opts?.cacheStrategy?.messages !== '5m') return false;
+  const lastSendAt = Number(sessionRef.lastProviderSendAt);
+  return lastSendAt > 0 && Date.now() - lastSendAt > AGENT_MESSAGE_CACHE_TTL_MS;
+}
+
 export function shouldCompactForSession(
   messageTokensEst,
   policy,
@@ -803,7 +815,7 @@ export function emitCompactEvent(opts, event = {}) {
 // or relay may not expose Haiku at all), so guessing a cheaper model risks a
 // hard compact failure. The summary runs on the session's own model unless an
 // operator explicitly configures compaction.summaryModel.
-export function resolveHandoffSummaryModel(sessionRef, _opts = {}) {
+export function resolveHandoffSummaryModel(sessionRef) {
   const cfg = sessionRef?.compaction && typeof sessionRef.compaction === 'object' ? sessionRef.compaction : {};
   const explicit =
     String(cfg.summaryModel || '').trim() || String(process.env.MIXDOG_AGENT_COMPACT_SUMMARY_MODEL || '').trim();

package/src/runtime/agent/orchestrator/session/loop/completion-guards.mjs

@@ -3,9 +3,9 @@
 // Pure string/signature helpers; the loop body only wires state + messages.
 // No provider/manager coupling.
 
-// Deterministic, key-sorted stringify for cross-turn call signatures. Mirrors
-// _canonicalArgs but exposed by name for the dedup signature contract.
-export function stableStringify(value) {
+// Deterministic, key-sorted stringify for cross-turn call signatures (recursive,
+// unlike tool-classify's top-level-only _canonicalArgs).
+function stableStringify(value) {
   if (value == null || typeof value !== 'object') {
     try {
       return JSON.stringify(value);

package/src/runtime/agent/orchestrator/session/loop/deferred-call-through.mjs

@@ -1,12 +1,12 @@
 // Deferred catalog call-through: inactive catalog tool_use → discovery bookkeeping
 // then normal executeTool routing (runtime errors only; no pre-dispatch schema).
-import { clean } from '../../../../../session-runtime/session-text.mjs';
+import { clean } from '../../runtime-core/session-text.mjs';
 import {
   deferredCatalogUnion,
   isReadonlySelectable,
   selectDeferredTools,
-} from '../../../../../session-runtime/tool-catalog.mjs';
-import { isDeferredToolAvailable } from '../../../../../session-runtime/deferred-tool-availability.mjs';
+} from '../../runtime-core/tool-catalog.mjs';
+import { isDeferredToolAvailable } from '../../runtime-core/deferred-tool-availability.mjs';
 
 /** Skill-list plumbing only; mutation/MCP/builtins must use the catalog+mode gate. */
 const INACTIVE_INFRA_BYPASS = new Set(['skills_list', 'skill_view']);
@@ -80,7 +80,7 @@ function denyDeferredCallThrough(message) {
  * or deny. Native provider schema arrays are never mutated here.
  * Returns null when not applicable (not in catalog, already active, infra allowlist).
  */
-export function prepareDeferredToolCallThrough(sessionRef, name, _args) {
+export function prepareDeferredToolCallThrough(sessionRef, name) {
   if (!sessionRef) return null;
   if (!isDeferredToolAvailable(sessionRef, name)) {
     return denyDeferredCallThrough(

package/src/runtime/agent/orchestrator/session/loop/fresh-context.mjs

@@ -5,7 +5,7 @@ import { getProvider, initProviders } from '../../providers/registry.mjs';
 import { resolveMaintenanceRoute } from '../../agent-runtime/maintenance-route.mjs';
 import { resolveSessionContextMeta } from '../manager/context-meta.mjs';
 import { isAccountQuotaError } from '../../providers/account-pool.mjs';
-import { builtinFeatureActive } from '../../../../../session-runtime/builtin-features.mjs';
+import { builtinFeatureActive } from '../../runtime-core/builtin-features.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
 import { estimateMessagesTokens, providerTokenCalibration } from '../context-utils.mjs';
 import {

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

@@ -1,10 +1,10 @@
 /**
  * loop-state.mjs — the agent loop's explicit per-ask state record: the
- * request-loop bookkeeping that used to live in agentLoop's closure, plus the
+ * request-loop bookkeeping, plus the
  * helpers every phase shares (abort check, steering drain, no-tool resolver).
  */
 import { isAgentOwner } from '../../agent-owner.mjs';
-import { SessionClosedError } from '../manager.mjs';
+import { SessionClosedError } from '../manager/session-errors.mjs';
 import { resolveLiveToolCwd } from './tool-exec.mjs';
 import { createSteeringDrain } from './steering.mjs';
 import { createNoToolTurnResolver } from './no-tool-turn.mjs';

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/continuation.mjs

@@ -7,7 +7,7 @@
 // as the final answer.
 import { writeLoopDiagnostic } from './diagnostic.mjs';
 
-export const PROVIDER_CONTINUATION_NO_TOOL_LIMIT = Math.max(
+const PROVIDER_CONTINUATION_NO_TOOL_LIMIT = Math.max(
   1,
   Number(process.env.MIXDOG_PROVIDER_CONTINUATION_NO_TOOL_LIMIT) || 8
 );

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -90,10 +90,9 @@ export function routeWebFetchCall(call) {
 }
 
 /**
- * Exported for smoke tests — same runtime deny as the agent loop. `_toolKind`
- * is accepted for caller compatibility; the rules do not depend on it.
+ * Exported for smoke tests — same runtime deny as the agent loop.
  */
-export function preDispatchDenyForSession(sessionRef, call, _toolKind) {
+export function preDispatchDenyForSession(sessionRef, call) {
   const name = call?.name;
   if (typeof name !== 'string' || !name) return null;
   const schemaName = String(call?.schemaName || name);

package/src/runtime/agent/orchestrator/session/loop/request-boundary.mjs

@@ -8,12 +8,12 @@ import { runPreSendCompactPass } from '../pre-send-compact.mjs';
 import {
   refreshDeferredMcpToolCatalog,
   snapshotProviderRequestTools,
-} from '../../../../../session-runtime/tool-catalog.mjs';
+} from '../../runtime-core/tool-catalog.mjs';
 import {
   finalizeProviderRequestTools,
   providerNativeToolPrefixCount,
   runWithProviderRequestToolsScope,
-} from '../../../../../session-runtime/provider-request-tools.mjs';
+} from '../../runtime-core/provider-request-tools.mjs';
 
 const isDynamicTool = (tool) =>
   tool.deferLoading === true || tool.defer_loading === true || String(tool.name || '').startsWith('mcp__');

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -13,7 +13,7 @@ import { traceProviderSend, traceOutputTruncation } from './diagnostics.mjs';
 import { createEagerDispatcher } from '../eager-dispatch.mjs';
 import { sendWithRecovery } from '../send-with-recovery.mjs';
 import { stripInlineImages } from '../image-strip-recovery.mjs';
-import { runWithProviderRequestToolsScope } from '../../../../../session-runtime/provider-request-tools.mjs';
+import { runWithProviderRequestToolsScope } from '../../runtime-core/provider-request-tools.mjs';
 import { REPEAT_FAIL_LIMIT } from './loop-state.mjs';
 
 /**
@@ -209,8 +209,6 @@ export function applyRetryAction(state, result) {
   }
 }
 
-/** Fold a completed send into the state: prefix guard, image-strip
- *  rebaseline, per-request budgets, provider state, usage and diagnostics. */
 // An image-strip retry succeeded: heal the stripped images out of the live
 // transcript when the recovery asked for it, otherwise drop the prefix guard
 // so the next send rebaselines against the unstripped history.
@@ -236,12 +234,17 @@ function settleImageStrip(state, round, sent) {
   state.imageStrip = null;
 }
 
+/** Fold a completed send into the state: prefix guard, image-strip
+ *  rebaseline, per-request budgets, provider state, usage and diagnostics. */
 export function settleSendResult(state, round, sent) {
   const { opts, sessionRef, sessionId, model, messages } = state;
   const response = sent.result.response;
   state.response = response;
   state.prefixGuardState = sent.prefixGuardCandidate;
   if (sessionRef) sessionRef._providerPrefixGuardState = state.prefixGuardState;
+  // The provider read and refreshed its prompt cache when this request was
+  // sent; agent cache-expiry compaction measures idle time from here.
+  if (sessionRef) sessionRef.lastProviderSendAt = sent.sendStartedAt;
   if (state.imageStrip) settleImageStrip(state, round, sent);
   opts.onToolCall = undefined;
   delete opts.cacheBreakIntent;

package/src/runtime/agent/orchestrator/session/loop/tool-classify.mjs

@@ -39,7 +39,7 @@ export function _isShellTool(name) {
 // produces a stable hash regardless of arg-object key order. Anything
 // non-serializable falls back to String(args) — still deterministic for
 // the model's typical structured-arg shape.
-export function _canonicalArgs(args) {
+function _canonicalArgs(args) {
   if (args == null || typeof args !== 'object') {
     try {
       return JSON.stringify(args);

package/src/runtime/agent/orchestrator/session/loop/tool-exec/call-prep.mjs

@@ -3,11 +3,12 @@
  * live cwd, coerced args, the scoped-cache outcome, the completion notifier
  * and the option bags handed to the tool.
  */
-import { enqueuePendingMessage, markCompletionEntry, markSessionToolOutputTail } from '../../manager.mjs';
+import { enqueuePendingMessage, markCompletionEntry } from '../../manager/pending-messages.mjs';
+import { markSessionToolOutputTail } from '../../manager/runtime-liveness.mjs';
 import { createScopedCacheOutcome } from '../../cache/scoped-cache-outcome.mjs';
 import { modelVisibleToolCompletionMessage } from '../../../../../shared/tool-execution-contract.mjs';
 import { _isScopedCacheableTool } from '../tool-classify.mjs';
-import { refreshDeferredMcpToolCatalog } from '../../../../../../session-runtime/tool-catalog.mjs';
+import { refreshDeferredMcpToolCatalog } from '../../../runtime-core/tool-catalog.mjs';
 import { coerceToolArgsForSession } from '../arg-schema-coerce.mjs';
 
 export function resolveToolCompletionSessionId({ callerSessionId } = {}) {

package/src/runtime/agent/orchestrator/session/loop/tool-exec/dispatch.mjs

@@ -14,14 +14,7 @@ import { executePatchTool } from '../../../tools/patch.mjs';
 import { executeInternalTool, isInternalTool } from '../../../internal-tools.mjs';
 import { buildSkillsListResponse, viewSkill } from '../tool-helpers.mjs';
 import { isOnDeferredToolSurface } from '../deferred-call-through.mjs';
-
-let codeGraphRuntimePromise = null;
-async function executeCodeGraphToolLazy(name, args, cwd, signal = null, options = {}) {
-  codeGraphRuntimePromise ??= import('../../../tools/code-graph.mjs');
-  const mod = await codeGraphRuntimePromise;
-  if (typeof mod.executeCodeGraphTool !== 'function') throw new Error('code_graph runtime is not available');
-  return mod.executeCodeGraphTool(name, args, cwd, signal, options);
-}
+import { _executeCodeGraphToolLazy } from '../../manager/runtime-loaders.mjs';
 
 function dispatchMcp(name, args, { cwd, callerSessionId, sessionRef, executeOpts }) {
   const mcpScopeId = sessionRef?.mcpScopeId || null;
@@ -81,7 +74,7 @@ export function dispatchToolCall({ name, args }, ctx) {
   if (name === 'code_graph') {
     // cwd chain: args.cwd (caller-explicit) → session cwd → undefined (handler throws)
     const graphCwd = typeof args?.cwd === 'string' && args.cwd.trim() ? args.cwd.trim() : cwd;
-    return executeCodeGraphToolLazy(name, args, graphCwd, executeOpts.signal || null, toolOpts);
+    return _executeCodeGraphToolLazy(name, args, graphCwd, executeOpts.signal || null, toolOpts);
   }
   if (isInternalTool(name, sessionRef?.mcpScopeId)) return dispatchInternal(name, args, ctx);
   if (name === 'apply_patch') {
@@ -97,7 +90,10 @@ export function dispatchToolCall({ name, args }, ctx) {
   // variants) adapt to a native execution inside executeBuiltinTool's default
   // case; on a shape mismatch it falls back to the redirect guidance message.
   if (name === 'shell' || isBuiltinTool(name) || isExternalAdapterTool(name)) {
-    return executeBuiltinTool(name, args, cwd, completionToolOpts);
+    const builtinOpts = executeOpts.suppressReadUnchangedStub
+      ? { ...completionToolOpts, suppressReadUnchangedStub: true }
+      : completionToolOpts;
+    return executeBuiltinTool(name, args, cwd, builtinOpts);
   }
   return formatUnknownBuiltinToolMessage(name, args, 'tool');
 }

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -7,7 +7,7 @@
 //   tool-exec/read-only-deadline.mjs — bounded read-only I/O with partial-output grace
 import { isMcpTool } from '../../mcp/client.mjs';
 import { prepareDeferredToolCallThrough } from './deferred-call-through.mjs';
-import { refreshDeferredMcpToolCatalog } from '../../../../../session-runtime/tool-catalog.mjs';
+import { refreshDeferredMcpToolCatalog } from '../../runtime-core/tool-catalog.mjs';
 import { preDispatchDenyForSession, routeWebFetchCall } from './pre-dispatch-deny.mjs';
 import { runWithToolExecutionOwner } from '../../../../shared/tool-execution-owner.mjs';
 import { runWithLocalSearchTelemetry } from '../../tools/builtin/local-search-telemetry.mjs';
@@ -63,7 +63,7 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
   if (denial !== null) return denial;
   const call = { name: finalCall.name, args: finalCall.arguments, cwd: prepared.cwd };
   if (isMcpTool(call.name)) refreshDeferredMcpToolCatalog(sessionRef);
-  const deferredPrep = prepareDeferredToolCallThrough(sessionRef, call.name, call.args);
+  const deferredPrep = prepareDeferredToolCallThrough(sessionRef, call.name);
   if (deferredPrep?.deny) return deferredPrep.deny;
   const result = await runReadOnlyIoWithDeadline(call.name, executeOpts.signal || null, async (deadlineSignal) => {
     let callOpts = executeOpts;

package/src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs

@@ -4,7 +4,7 @@
 import { isMcpTool } from '../../mcp/client.mjs';
 import { isBuiltinTool } from '../../tools/builtin.mjs';
 import { isInternalTool } from '../../internal-tools.mjs';
-import { loadSkillToolDependencies } from '../../../../../session-runtime/skill-tool-loading.mjs';
+import { loadSkillToolDependencies } from '../../runtime-core/skill-tool-loading.mjs';
 import {
   collectSkillsCached,
   loadSkillResource,

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

@@ -1,9 +1,8 @@
-// Thin facade. The agent loop implementation moved to ./agent-loop.mjs and the
-// pre-send auto-compact pass to ./pre-send-compact.mjs. This module re-exports
-// the exact public surface (agentLoop plus the tool/approval/transcript
-// helpers) so every existing import path -- scripts/tests, the manager.mjs
-// dynamic import('./loop.mjs'), and other runtime modules -- keeps resolving
-// unchanged.
+// Thin facade over ./agent-loop.mjs (the loop; the pre-send auto-compact pass
+// is ./pre-send-compact.mjs). Re-exports the public surface (agentLoop plus the
+// tool/approval/transcript helpers) for scripts/tests, the lazy
+// import('../loop.mjs') in manager/runtime-loaders.mjs, and other runtime
+// modules.
 export {
   agentLoop,
   preDispatchDenyForSession,

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

@@ -3,7 +3,7 @@
 // its empty-final forensic record), the usage/cost ledger row, and the
 // opaque provider continuation state.
 import { cloneProviderReplay } from '../../providers/lib/provider-replay.mjs';
-import { logLlmCall } from '../../../../shared/llm/usage-log.mjs';
+import { logLlmCall } from '../../usage-log.mjs';
 import { runAbortable } from '../../../../shared/abort-race.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
 import { recordStandaloneStatusTelemetry } from './status-telemetry.mjs';

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

@@ -7,8 +7,8 @@ import { withRuntimeUserContext } from '../runtime-user-context.mjs';
 import { estimateJsonBytes } from '../../../../shared/json-metrics.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
 import { appendAgentTrace } from '../../agent-trace.mjs';
-import { snapshotPendingDeferredToolDelta } from '../../../../../session-runtime/deferred-tool-delta.mjs';
-import { snapshotPendingGoalReminder } from '../../../../../session-runtime/goal-reminder.mjs';
+import { snapshotPendingDeferredToolDelta } from '../../runtime-core/deferred-tool-delta.mjs';
+import { snapshotPendingGoalReminder } from '../../runtime-core/goal-reminder.mjs';
 import { resolveSessionContextMeta } from './context-meta.mjs';
 import {
   promptContentText,

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

@@ -5,8 +5,8 @@
 // (publishAskTurn).
 import { saveSessionAsync, saveSessionAsyncDeferred } from '../store.mjs';
 import { persistedAssistantTranscriptMetadata } from '../../../../shared/transcript-metadata.mjs';
-import { acknowledgePendingDeferredToolDelta } from '../../../../../session-runtime/deferred-tool-delta.mjs';
-import { acknowledgePendingGoalReminder } from '../../../../../session-runtime/goal-reminder.mjs';
+import { acknowledgePendingDeferredToolDelta } from '../../runtime-core/deferred-tool-delta.mjs';
+import { acknowledgePendingGoalReminder } from '../../runtime-core/goal-reminder.mjs';
 import {
   finalizePendingMessageDelivery,
   drainPendingMessages,

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -1,7 +1,7 @@
 // Session compaction runner — one fresh-context Compact contract.
-// Self-contained: operates on a live `session` object + opts, using pure
-// compact/context helpers. No runtime-liveness (_runtimeState) coupling —
-// manager.mjs still owns scheduling / stage gating and simply calls
+// Operates on a live `session` object + opts, using pure compact/context
+// helpers. Its only runtime-liveness read is isSessionCompactionBlocked;
+// manager.mjs owns scheduling / stage gating and simply calls
 // runSessionCompaction().
 import { getProvider } from '../../providers/registry.mjs';
 import { HANDOFF_TIMEOUT_MAX_MS } from '../compact/constants.mjs';
@@ -30,7 +30,7 @@ import {
   resolveHandoffSummaryModel,
   resolveWorkerCompactPolicy,
 } from '../loop/compact-policy.mjs';
-import { snapshotProviderRequestTools } from '../../../../../session-runtime/tool-catalog.mjs';
+import { snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
 
 // 'compacting' is a transient in-flight stage written just before Compact
 // runs. If the process crashes or only partially
@@ -158,7 +158,7 @@ export async function runHandoffCompaction({
     signal,
     config,
     provider: provider || getProvider(session?.provider) || null,
-    model: model || resolveHandoffSummaryModel(session, { budgetTokens }) || session?.model,
+    model: model || resolveHandoffSummaryModel(session) || session?.model,
     sendOpts: { session },
   });
 }

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

@@ -1,4 +1,5 @@
 import { stat } from 'node:fs/promises';
+import { isProcessAlive } from '../store/paths-heartbeat.mjs';
 import {
   isCompletionNotificationEntry,
   isStaleUserInjection,
@@ -13,18 +14,6 @@ import { lifecycleTokenClosed } from './pending-lifecycle-epoch.mjs';
 const HANDOFF_RETRY_MS = 1000;
 const HANDOFF_RELEASE_SLACK_MS = 50;
 
-function handoffOwnerIsLive(pid) {
-  const value = Number(pid) || 0;
-  if (value <= 0) return false;
-  if (value === process.pid) return true;
-  try {
-    process.kill(value, 0);
-    return true;
-  } catch (err) {
-    return err?.code !== 'ESRCH';
-  }
-}
-
 /**
  * One session's spool queue, split into what this process takes and what stays
  * on disk. A foreign user message is taken (and parked with a handoff stamp
@@ -56,7 +45,7 @@ function takeForeignMessagesFromQueue(queue, request, handoffReleaseMs) {
         kept.push(entry);
         continue;
       }
-      if (!expired || handoffOwnerIsLive(handoffPid)) {
+      if (!expired || isProcessAlive(handoffPid)) {
         kept.push(entry);
         continue;
       }
@@ -198,7 +187,7 @@ export class ForeignPendingMessageController {
     const operation = preceding
       .catch(() => {})
       .then(() =>
-        updateSpool((raw) => {
+        updateSpool(sessionId, (raw) => {
           released.length = 0;
           nextDueIn = 0;
           // A generation move transfers ownership; never clean the new queue.
@@ -284,6 +273,17 @@ export class ForeignPendingMessageController {
     this._drainRunning = true;
     const batch = [...this._drainRequests.values()];
     this._drainRequests.clear();
+    try {
+      // Each session drains against its own shard and lock, so one busy
+      // session never delays (or fails) another's intake.
+      await Promise.all(batch.map((request) => this._drainOne(request)));
+    } finally {
+      this._drainRunning = false;
+      this._scheduleDrainBatch();
+    }
+  }
+
+  async _drainOne(request) {
     const {
       addInDeliveryIds,
       lifecycleInvalidated,
@@ -295,76 +295,52 @@ export class ForeignPendingMessageController {
       updateSpool,
       warn,
     } = this._dependencies;
+    const { sessionId, epochToken } = request;
     try {
       let mtime = 0;
       try {
-        mtime = (await stat(spoolPath())).mtimeMs || 0;
+        mtime = (await stat(spoolPath(sessionId))).mtimeMs || 0;
       } catch {
-        for (const request of batch) this._settleDrain(request, []);
+        this._settleDrain(request, []);
         return;
       }
-      const scanAt = Date.now();
-      const candidates = batch.filter(
-        (request) =>
-          this._scanNeeded(request.sessionId, mtime, scanAt) &&
-          !lifecycleInvalidated(request.sessionId, request.epochToken)
-      );
-      const candidateSet = new Set(candidates);
-      for (const request of batch) {
-        if (!candidateSet.has(request)) this._settleDrain(request, []);
-      }
-      if (candidates.length === 0) return;
-      for (const request of candidates) {
-        request.localIds = localIds(request.sessionId);
-        request.taken = [];
-        request.released = [];
-        request.rescanDueAt = 0;
-        request.lifecycleDecided = false;
+      if (!this._scanNeeded(sessionId, mtime, Date.now()) || lifecycleInvalidated(sessionId, epochToken)) {
+        this._settleDrain(request, []);
+        return;
       }
+      request.localIds = localIds(sessionId);
+      request.taken = [];
+      request.released = [];
+      request.rescanDueAt = 0;
+      request.lifecycleDecided = false;
       await updateSpool(
+        sessionId,
         (raw) => {
           const next = normalizeStore(raw);
-          let changed = false;
-          for (const request of candidates) {
-            const { sessionId, epochToken } = request;
-            if (lifecycleInvalidated(sessionId, epochToken)) continue;
-            request.lifecycleDecided = true;
-            const queue = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
-            if (queue.length === 0) continue;
-            const kept = takeForeignMessagesFromQueue(queue, request, this._handoffReleaseMs);
-            if (request.taken.length === 0 && request.released.length === 0) continue;
-            changed = true;
-            setSpoolQueue(next, sessionId, kept);
-          }
-          if (!changed) return undefined;
+          if (lifecycleInvalidated(sessionId, epochToken)) return undefined;
+          request.lifecycleDecided = true;
+          const queue = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
+          if (queue.length === 0) return undefined;
+          const kept = takeForeignMessagesFromQueue(queue, request, this._handoffReleaseMs);
+          if (request.taken.length === 0 && request.released.length === 0) return undefined;
+          setSpoolQueue(next, sessionId, kept);
           next.updatedAt = Date.now();
           return next;
         },
         { timeoutMs: 0 }
       );
-      for (const request of candidates) {
-        if (request.lifecycleDecided) {
-          this._rememberScan(request.sessionId, mtime, request.rescanDueAt);
-        }
-        if (request.taken.length > 0) {
-          addInDeliveryIds(request.sessionId, request.taken.map((item) => item?.id).filter(Boolean));
-          this._scheduleHandoffRelease(request.sessionId, this._handoffReleaseMs + HANDOFF_RELEASE_SLACK_MS);
-        }
-        if (request.released.length > 0) {
-          removeInDeliveryIds(request.sessionId, request.released);
-        }
-        this._settleDrain(request, request.taken);
+      if (request.lifecycleDecided) this._rememberScan(sessionId, mtime, request.rescanDueAt);
+      if (request.taken.length > 0) {
+        addInDeliveryIds(sessionId, request.taken.map((item) => item?.id).filter(Boolean));
+        this._scheduleHandoffRelease(sessionId, this._handoffReleaseMs + HANDOFF_RELEASE_SLACK_MS);
       }
+      if (request.released.length > 0) removeInDeliveryIds(sessionId, request.released);
+      this._settleDrain(request, request.taken);
     } catch (err) {
       if (err?.code !== 'ELOCKCONTENDED') {
         warn(`[session] foreign-injection drain failed: ${err?.message || err}\n`);
       }
-      for (const request of batch) {
-        if (request.waiters.length > 0) this._settleDrain(request, []);
-      }
-    } finally {
-      this._drainRunning = false;
-      this._scheduleDrainBatch();
+      this._settleDrain(request, []);
     }
   }
 }

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

@@ -48,8 +48,6 @@ export function lifecycleTokenClosed(token) {
   return source === 'closed' || source === 'unreadable';
 }
 
-// Pure epoch comparison against an already-read lifecycle (no IO), so a caller
-// that judges many entries reads the durable record once.
 // Parses a `source:generation` epoch token.
 function parseLifecycleToken(token) {
   const text = String(token);
@@ -57,6 +55,8 @@ function parseLifecycleToken(token) {
   return { source: text.slice(0, separator), generation: Number(text.slice(separator + 1)) || 0 };
 }
 
+// Pure epoch comparison against an already-read lifecycle (no IO), so a caller
+// that judges many entries reads the durable record once.
 export function lifecycleTokenStale(now, sinceToken) {
   if (sinceToken === null || sinceToken === undefined) return false;
   const { source: sinceSource, generation: sinceGeneration } = parseLifecycleToken(sinceToken);

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

@@ -1,5 +1,5 @@
 // Steering / pending-message queue with sync buffering and atomic persistence.
-import { readFileSync } from 'node:fs';
+import { mkdirSync, readFileSync } from 'node:fs';
 import { loadSession } from '../store.mjs';
 import { ForeignPendingMessageController } from './foreign-pending-messages.mjs';
 import {
@@ -29,6 +29,7 @@ import {
   pendingIdSet,
   pruneEmptyPendingIdSet,
 } from './pending-claim-ledger.mjs';
+import { legacyPendingMessagesPath, pendingShardDir } 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.
@@ -82,10 +83,14 @@ const _sessionPendingMessages = new Map();
 const _hydratedPendingMessages = new Map();
 const _pendingHydrations = new Map();
 
-// Exposed for live-share owners: they fs.watch this file for instant pickup
-// of cross-surface submits (the 3s drain tick remains the safety net).
-export function pendingMessagesSpoolPath() {
-  return pendingMessagesPath();
+// 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) {
@@ -157,7 +162,7 @@ function acknowledgePendingMessages(sessionId, deliveredEntries, options = {}) {
       // Skipped once the epoch moved: those queue entries are the new
       // owner's (a hydrate can republish the very same durable ids).
       if (!pendingLifecycleEpochMoved(sessionId, expectedToken)) purgeMemory();
-      return updateSpool((raw) => {
+      return updateSpool(sessionId, (raw) => {
         // Atomic re-validation: we now hold the spool lock. A generation
         // movement while we waited means the rows are the reopened owner's —
         // delete nothing and report failure so no ledger prune follows.
@@ -315,7 +320,7 @@ export function hydratePendingMessages(sessionId) {
       // is an id to actually suppress.
       const inDelivery = _inDeliveryPendingIds.get(sessionId) || null;
       const acked = _ackedPendingIds.get(sessionId) || null;
-      await updateSpool((raw) => {
+      await updateSpool(sessionId, (raw) => {
         const next = normalizePendingStore(raw);
         const q = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
         const rows = partitionHydratableSpoolRows(q, { deliveredLedger, inDelivery, acked });
@@ -406,7 +411,7 @@ function clearPersistedPendingMessages(sessionId) {
   const operation = preceding
     .catch(() => {})
     .then(() =>
-      updateSpool((raw) => {
+      updateSpool(sessionId, (raw) => {
         if (pendingLifecycleEpochMoved(sessionId, epochToken)) return undefined;
         const next = normalizePendingStore(raw);
         if (!Object.hasOwn(next.sessions, sessionId)) return undefined;
@@ -660,15 +665,18 @@ export function drainPendingMessages(sessionId) {
 export function _getPendingMessagesForSession(sessionId) {
   if (!isValidPendingSessionId(sessionId)) return [];
   const queued = [...(_sessionPendingMessages.get(sessionId) || []), ...(_pendingPersistBuffers.get(sessionId) || [])];
-  let raw;
-  try {
-    raw = readFileSync(pendingMessagesPath(), 'utf8');
-  } catch (err) {
-    if (err?.code === 'ENOENT') return queued;
-    throw err;
+  // The not-yet-migrated global spool can still hold this session's rows.
+  for (const path of [pendingMessagesPath(sessionId), legacyPendingMessagesPath()]) {
+    let raw;
+    try {
+      raw = readFileSync(path, 'utf8');
+    } catch (err) {
+      if (err?.code === 'ENOENT') continue;
+      throw err;
+    }
+    const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
+    if (Array.isArray(persisted)) queued.push(...persisted);
   }
-  const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
-  if (Array.isArray(persisted)) queued.push(...persisted);
   return queued;
 }
 

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

@@ -48,7 +48,7 @@ export function persistPendingMessages(sessionId, messages) {
   // process contention on the shared spool never freezes the renderer.
   // Best-effort: the returned promise is fire-and-forget; depth is reported
   // optimistically from the buffered batch length.
-  const operation = updateSpool((raw) => {
+  const operation = updateSpool(sessionId, (raw) => {
     // Close fence, INSIDE the spool lock: a close/detach that tore this
     // session's pending state down while the write waited for the lock owns
     // the spool from here on — the superseded write may not land after it.