mixdog 1.4.2 → 1.4.3

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

@@ -6,6 +6,7 @@ import { captureTurnCheckpointContextState, createTurnCheckpointRecorder } from
 import { finalizeTurnInterruptionSnapshot } from './turn-interruption.mjs';
 import { onSensitiveValuesMarked } from '../sensitive-values.mjs';
 import { saveSessionAsync } from '../store.mjs';
+import { setTranscriptSnapshotHook } from '../store/transcript-durability.mjs';
 import { ingestSessionTurn } from '../../../../session-search/session-search-ingest.mjs';
 
 // Coalescing window for streaming-delta flushes. Each flush journals only the
@@ -22,6 +23,8 @@ export function createAskTurnState(session) {
     outgoing: null,
     /** The user turn exactly as sent, kept for interruption finalization. */
     userTurnContent: '',
+    /** Index of the user turn in `outgoing` when it was assembled. */
+    boundary: null,
     /** Queue entries this turn consumed: acked on commit, released on failure. */
     pendingEntries: [],
   };
@@ -29,34 +32,60 @@ export function createAskTurnState(session) {
 
 /** The recorder writes this turn's header synchronously on its first flush
  *  (the crash-durability anchor for the prompt, landing before the provider
- *  runs) and appends bounded deltas afterwards. */
-export function createTurnCheckpointScheduler({ sessionId, generation, turnToken, startedAt, turn, interruption }) {
+ *  runs) and appends bounded deltas afterwards. `base` is the durable
+ *  transcript the turn opens on (store/transcript-durability.mjs). Every
+ *  save of the session flushes first, so a history rewrite is in the
+ *  checkpoint before any record carries its new epoch. */
+export function createTurnCheckpointScheduler({
+  sessionId,
+  generation,
+  turnToken,
+  startedAt,
+  turn,
+  interruption,
+  base,
+}) {
   let timer = null;
   let stopped = false;
   let lastAt = 0;
   let warned = false;
-  let contextState = null;
-  const recorder = createTurnCheckpointRecorder({ sessionId, generation, turnToken, startedAt });
+  let contextDirty = false;
+  const recorder = createTurnCheckpointRecorder({
+    session: turn.session,
+    sessionId,
+    generation,
+    turnToken,
+    startedAt,
+    base,
+  });
+  const record = (messages, extra = {}) =>
+    recorder.record({
+      boundary: turn.boundary,
+      currentUserContent: turn.userTurnContent,
+      turnOutgoing: messages,
+      interruption,
+      captureContext: (boundary) => captureTurnCheckpointContextState(turn.session, messages, boundary),
+      contextDirty,
+      ...extra,
+    });
+  const warn = (error) => {
+    if (warned) return;
+    warned = true;
+    try {
+      process.stderr.write(`[turn-checkpoint] write failed session=${sessionId}: ${error?.message || error}\n`);
+    } catch {
+      // stderr may be closed; the checkpoint failure is only reported
+    }
+  };
   const flush = () => {
     if (stopped || !turn.outgoing || !turn.userTurnContent) return false;
     try {
-      const written = recorder.record({
-        currentUserContent: turn.userTurnContent,
-        turnOutgoing: turn.outgoing,
-        interruption,
-        contextState,
-      });
+      const written = record(turn.outgoing);
+      contextDirty = false;
       if (written) lastAt = Date.now();
       return written;
     } catch (error) {
-      if (!warned) {
-        warned = true;
-        try {
-          process.stderr.write(`[turn-checkpoint] write failed session=${sessionId}: ${error?.message || error}\n`);
-        } catch {
-          // stderr may be closed; the checkpoint failure is only reported
-        }
-      }
+      warn(error);
       return false;
     }
   };
@@ -83,9 +112,20 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
     });
     ingestSessionTurn(turn.session);
   });
+  const unhookSaves = setTranscriptSnapshotHook(turn.session, () => {
+    if (!stopped && turn.outgoing) flushNow();
+  });
+  const halt = (options) => {
+    stopped = true;
+    stopMarks();
+    unhookSaves();
+    if (timer) clearTimeout(timer);
+    timer = null;
+    recorder.stop(options);
+  };
   return {
     refreshContextState() {
-      contextState = captureTurnCheckpointContextState(turn.session, turn.outgoing, turn.userTurnContent);
+      contextDirty = true;
     },
     schedule(immediate = false) {
       if (stopped || !turn.outgoing) return;
@@ -101,12 +141,27 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
       }, waitMs);
       timer.unref?.();
     },
+    /** Record the finished transcript (`turn.session.messages`, with the
+     *  final assistant message and its completion) as sealed, then stop: a
+     *  crash before a save covers the turn replays it as finished, not as
+     *  interrupted. */
+    seal() {
+      if (stopped) return false;
+      let written = false;
+      if (turn.outgoing && turn.userTurnContent) {
+        try {
+          contextDirty = true;
+          written = record(turn.session.messages, { sealed: true });
+        } catch (error) {
+          warn(error);
+        }
+      }
+      halt({ keepQueued: true });
+      return written;
+    },
     stop() {
-      stopped = true;
-      stopMarks();
-      if (timer) clearTimeout(timer);
-      timer = null;
-      recorder.stop();
+      if (stopped) return;
+      halt();
     },
   };
 }

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

@@ -44,6 +44,9 @@ export function createAskSteeringDrain({ sessionId, turn, askOpts }) {
     // nothing. Entries consumed here join the turn's pending entries: their
     // delivery/ack (and release on failure) rides this turn, and the
     // post-loop drain can no longer see them.
+    // A route saved while this turn runs (session.heldRoute) leaves the
+    // queued entries to the next turn, which opens on that route.
+    if (turn.session?.heldRoute) return out;
     if (drainOptions?.stage === 'terminal' || pendingQueueHoldsOnlyNotifications(sessionId)) {
       const pendingNow = drainPendingMessages(sessionId);
       if (pendingNow.length > 0) {

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

@@ -36,7 +36,8 @@ import {
   resolveWorkerCompactPolicy,
   shouldCompactForRequestMedia,
 } from '../loop/compact-policy.mjs';
-import { snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
+import { rearmLateDeferredTools, snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
+import { rearmPromptSettingsNotice } from './prompt-settings.mjs';
 import { prepareCompactionArchive, stampCompactionMessageIds } from '../compaction-archive-capture.mjs';
 
 // 'compacting' is a transient in-flight stage written just before Compact
@@ -724,6 +725,16 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
   // break instead of logging an unexplained input_prefix_mismatch.
   if (changed) {
     session.pendingCacheBreakIntent = mode === 'auto' ? 'post_turn_compaction' : 'manual_compaction';
+    // The compacted history no longer holds the late-tool announcements
+    // (connected MCP tools, built-ins a setting opened); a worker gets no
+    // prompt fold to list them, so they ride the next prompt again, as the
+    // pre-send compaction does.
+    try {
+      rearmLateDeferredTools(session);
+      rearmPromptSettingsNotice(session);
+    } catch {
+      /* a tool reminder never fails the compaction */
+    }
   }
   recordCompactionTiming(plan, freshContextResult, { startedAt: compactStartedAt, commitStartedAt, afterTokens });
   return compactionResult(

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

@@ -154,7 +154,7 @@ export function resolveSessionContextMeta(provider, model, seed = {}, { wholeWin
   // Legacy-data migration: old implementations derived autoCompactTokenLimit
   // from the full effective/raw window and persisted it onto the session.
   // A resumed session therefore re-seeds autoCompactTokenLimit == boundary
-  // (or the raw window), which compactTriggerForSession / loop policy used to
+  // (or the raw window), which compactTriggerForSession / loop policy would
   // honor as an explicit trigger, collapsing the compaction buffer to 0. Only
   // accept an explicit limit that is STRICTLY BELOW the boundary; a value at
   // or above the boundary is a derived full-window artifact and is dropped to

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -9,6 +9,7 @@ import {
   evictIdleLiveSessions,
 } from '../store.mjs';
 import { sweepOrphanedPendingMessages } from './pending-messages.mjs';
+import { sweepOrphanTurnJournals } from './turn-checkpoint-recovery.mjs';
 import { applySessionSidebarChange, readSessionSidebarState } from '../../../../shared/session-sidebar-host.mjs';
 import {
   IN_FLIGHT_STAGES,
@@ -184,7 +185,7 @@ function _runCleanupCycle() {
     await sweepOrphanedPendingMessages();
     await sweepIdleSessions({ includeTombstones: true });
     // Reclaim same-process session snapshots whose state is durable on disk
-    // (memory-leak guard: _liveSessions used to grow for process lifetime).
+    // (memory-leak guard: _liveSessions would otherwise grow for process lifetime).
     try {
       evictIdleLiveSessions({ isSessionLive: _isSessionLive });
     } catch {
@@ -213,6 +214,10 @@ function _startCleanupInterval() {
 
 export function startIdleCleanup() {
   if (_cleanupTimer || _cleanupInitialTimer) return;
+  // Once per start, ahead of the first delayed cycle: checkpoint journals a
+  // previous run could not delete (their sessions may never be reopened).
+  // Only the daemon owner sweeps (it checks); the daemon runs in worker mode.
+  void sweepOrphanTurnJournals().catch(() => {});
   if (CLEANUP_INITIAL_DELAY_MS <= 0) {
     void _runCleanupCycle();
     _startCleanupInterval();

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

@@ -490,6 +490,14 @@ registerTaskWaitSteeringCheck((sessionId) => {
   return wake;
 });
 
+/** Whether anything waits in this session's queue (memory or takeover-hydrated). */
+export function hasPendingMessages(sessionId) {
+  return (
+    (_sessionPendingMessages.get(sessionId)?.length ?? 0) > 0 ||
+    (_hydratedPendingMessages.get(sessionId)?.length ?? 0) > 0
+  );
+}
+
 // True when this session's queue holds task notifications and nothing else:
 // the mid-chain boundary may then take the whole queue without bypassing the
 // prompt filters that keep queued prompts for the terminal boundary.
@@ -583,7 +591,7 @@ export function drainPendingMessages(sessionId) {
     );
   }
   // Only materialize the ledger when there is an id to suppress: an empty
-  // drain used to leave a dead Set behind on every call.
+  // drain would leave a dead Set behind on every call.
   const claimedIds = accepted.filter((entry) => entry.id);
   if (claimedIds.length > 0) {
     const inDelivery = pendingIdSet(_inDeliveryPendingIds, sessionId);

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

@@ -9,8 +9,8 @@ export const PENDING_MESSAGES_MODE = 0o600;
 // Layout: one file (and one lock) per pending key under `session-pending/`.
 // A key is an orchestrator session id or a `tui_<lead session id>` steering
 // bucket, so operations on different sessions never share a lock.
-export const PENDING_SHARD_DIR_NAME = 'session-pending';
-export const LEGACY_PENDING_FILE_NAME = 'session-pending-messages.json';
+const PENDING_SHARD_DIR_NAME = 'session-pending';
+const LEGACY_PENDING_FILE_NAME = 'session-pending-messages.json';
 
 export function pendingShardDir() {
   return join(resolvePluginData(), PENDING_SHARD_DIR_NAME);

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

@@ -9,7 +9,7 @@ import { legacyPendingMessagesPath, pendingMessagesPath, PENDING_MESSAGES_MODE }
 const SHARD_KEY_RE = /^[A-Za-z0-9_-]+$/;
 const MIGRATION_LOCK_TIMEOUT_MS = 15_000;
 
-export function isShardKey(key) {
+function isShardKey(key) {
   return typeof key === 'string' && SHARD_KEY_RE.test(key);
 }