mixdog 1.4.1 → 1.4.3

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

@@ -10,6 +10,7 @@ import { acknowledgePendingDeferredToolDelta } from '../../runtime-core/deferred
 import { acknowledgePendingGoalReminder } from '../../runtime-core/goal-reminder.mjs';
 import { acknowledgePendingSetupNotice, acknowledgePendingWorkspaceNotice } from './prompt-utils.mjs';
 import { acknowledgePendingWorkflowNotice } from './workflow-switch-notice.mjs';
+import { acknowledgePendingPromptSettingsNotice } from './prompt-settings.mjs';
 import { acknowledgePendingOrchestrationModeNotice } from './orchestration-mode-switch-notice.mjs';
 import {
   finalizePendingMessageDelivery,
@@ -20,7 +21,7 @@ import { applyAskTerminalUsageTotals } from './usage-metrics.mjs';
 import { markSessionDone, markSessionEmptyFinal, _getRuntimeEntry } from './runtime-liveness.mjs';
 import { SessionClosedError } from './session-errors.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
-import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
+import { holdTurnUntilDurable } from './turn-durability.mjs';
 import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
 import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import { appendAssistantTurnMessage, persistProviderState, recordAskUsage } from './ask-turn-commit.mjs';
@@ -94,7 +95,7 @@ export function attachFailedTurnCompletion(messages, completion) {
 /** Commits the loop result into the session: messages, usage, provider state
  *  and queue acknowledgements. Returns the terminal result preview. */
 export async function commitAskTurn({ sessionId, opened, prepared, result, rawTranscriptMeta, askStartedAt }) {
-  const { turn, runtime, turnSignal, askGeneration, checkpoint, prepareCloseSnapshot } = opened;
+  const { turn, runtime, turnSignal, askGeneration, prepareCloseSnapshot } = opened;
   const session = turn.session;
   throwIfAborted(turnSignal);
   // Post-loop validation: if closeSession() landed while we were awaiting,
@@ -111,7 +112,8 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
   // Turn committed into session.messages; drop the live-turn alias so
   // contextStatus() reverts to the authoritative committed transcript.
   session.liveTurnMessages = null;
-  checkpoint.stop();
+  // The checkpoint keeps recording until publishAskTurn seals the finished
+  // transcript into it.
   delete session.activeTurnCheckpoint;
   appendAssistantTurnMessage({
     session,
@@ -142,6 +144,9 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
     acknowledgePendingGoalReminder(session, prepared.goalReminder.revision);
   }
   if (prepared.workflowNotice) acknowledgePendingWorkflowNotice(session, prepared.workflowNotice.revision);
+  if (prepared.promptSettingsNotice) {
+    acknowledgePendingPromptSettingsNotice(session, prepared.promptSettingsNotice.revision);
+  }
   if (prepared.orchestrationModeNotice) {
     acknowledgePendingOrchestrationModeNotice(session, prepared.orchestrationModeNotice.revision);
   }
@@ -160,7 +165,7 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
  *  starts the durable save and marks the session done. Returns the
  *  follow-up entries drained right after the provider accepted the turn. */
 export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOpts, rawTranscriptMeta, askStartedAt }) {
-  const { turn, runtime, askGeneration, turnToken } = opened;
+  const { turn, runtime, askGeneration, turnToken, checkpoint } = opened;
   const session = turn.session;
   // The provider accepted this queued turn: only now remove its
   // durable ids. A crash before here leaves them for at-least-once
@@ -197,19 +202,23 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
   // query/provider send (agentLoop pre-send), not after the previous
   // answer. This lets queued follow-up prompts resume immediately;
   // if they need compaction, their own spinner shows compacting first.
-  // Fire-and-forget terminal save. The result is already produced and
-  // (for agent surfaces) relayed via onTerminalResult above. When
-  // completion was relayed to the UI, yield before postMessage
-  // structured-clones the full session. Queued follow-up turns retain
-  // the original immediate-save ordering; they did not inject a
-  // terminal card and may mutate this same session on the next loop.
+  // The finished transcript (final assistant message, completion) is sealed
+  // into the checkpoint, and the record the terminal save writes names the
+  // turn it covers: a crash before that save lands replays the sealed turn,
+  // one after it deletes the checkpoint without a duplicate.
+  session.turnCoverage = turnToken;
+  checkpoint.seal();
+  // Terminal save. The result is already produced and (for agent surfaces)
+  // relayed via onTerminalResult above. When completion was relayed to the
+  // UI, yield before postMessage structured-clones the full session. Queued
+  // follow-up turns retain the original immediate-save ordering. Its landed
+  // acknowledgement is this session's next-turn gate (turn-durability.mjs),
+  // which alone deletes the checkpoint.
   const saveTerminalSession = terminalRelayed ? saveSessionAsyncDeferred : saveSessionAsync;
   const terminalSave = saveTerminalSession(session, { expectedGeneration: askGeneration });
+  holdTurnUntilDurable({ sessionId, session, turnToken, generation: askGeneration, save: terminalSave });
   terminalSave.then(
-    () => {
-      clearTurnCheckpoint(sessionId, turnToken);
-      ingestSessionTurn(session);
-    },
+    () => ingestSessionTurn(session),
     () => {}
   );
   finalizePendingMessageDelivery(session, turn.pendingEntries, terminalSave, () =>
@@ -227,7 +236,8 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
   const isEmptyFinal =
     !terminalResultPreview.content &&
     !terminalResultPreview.reasoningContent &&
-    !terminalResultPreview.reactionCompleted;
+    !terminalResultPreview.reactionCompleted &&
+    !terminalResultPreview.reportContent;
   if (isEmptyFinal) {
     markSessionEmptyFinal(sessionId);
   }

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