mixdog 1.3.5 → 1.4.0

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

@@ -12,10 +12,7 @@ import {
   loadSkillResource,
   buildSkillToolEnvelope,
   filterSkillsExcludingDisabled,
-  isSkillDisabled,
-  skillMissingFeature,
-  skillOutsideScope,
-  skillOutsideScopeError,
+  skillLoadRefusal,
 } from '../../context/collect.mjs';
 
 // Eager-dispatch: tools with readOnlyHint:true in their declaration are safe
@@ -95,12 +92,8 @@ export function buildSkillsListResponse(cwd) {
 export function viewSkill(cwd, name, session = null) {
   const skillName = String(name || '').trim();
   if (!skillName) return 'Error: skill name is required';
-  const missingFeature = skillMissingFeature(skillName);
-  if (missingFeature) {
-    return `Error: skill "${skillName}" needs the ${missingFeature} built-in feature, which is not installed or is switched off in Extensions → Plugin → Built-in`;
-  }
-  if (isSkillDisabled(skillName)) return `Error: skill "${skillName}" is disabled`;
-  if (skillOutsideScope(skillName, cwd)) return skillOutsideScopeError(skillName);
+  const refusal = skillLoadRefusal(skillName, cwd);
+  if (refusal) return refusal;
   const res = loadSkillResource(skillName, cwd);
   if (!res) return `Error: skill "${skillName}" not found`;
   // Return the general tool envelope: the model-visible tool_result is the

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

@@ -9,6 +9,7 @@ import { processToolBatch } from '../tool-batch.mjs';
 import { CROSS_TURN_CAP, REPEAT_FAIL_LIMIT } from './loop-state.mjs';
 import { markStepEffort } from './step-auto-effort.mjs';
 import { resolveExecutionToolCalls } from './tool-call-resolution.mjs';
+import { rememberSensitiveValues } from '../sensitive-values.mjs';
 import { callsAllowed, settleTurnLimits, turnLimitsOf } from './turn-limits.mjs';
 
 function isSleepLikeToolCall(call) {
@@ -41,13 +42,19 @@ export async function runToolPhase(state, round, sent, onToolCall) {
   // derive the multi-tool adoption ratio without scanning message bodies.
   // Audit records what runs: a bridged call_tool is recorded as its target.
   // The wire calls stay the transcript identity (assistant turn below).
-  const toolBatchId = recordToolBatch(sessionId, resolveExecutionToolCalls(calls, sessionRef), state.iterations);
+  const executionCalls = resolveExecutionToolCalls(calls, sessionRef);
+  const toolBatchId = recordToolBatch(sessionId, executionCalls, state.iterations);
+  // A sensitive fill (a verification code): every stored copy of the
+  // transcript keeps a marker instead of the value; the call runs as is.
+  rememberSensitiveValues(sessionId, executionCalls);
   await Promise.resolve(onToolCall?.(state.iterations, calls));
   const assistantTurnMsg = buildToolCallAssistantMessage(response, { calls, opts });
   commitAssistantMessage(messages, assistantTurnMsg, opts);
   try {
     opts.onToolPhaseStarted?.();
-  } catch {}
+  } catch {
+    // the tool-phase-started observer is advisory
+  }
   const toolsT0 = Date.now();
   const resultsFrom = messages.length;
   ({ dedupStubTotal: state.dedupStubTotal, editCount: state.editCount } = await processToolBatch({
@@ -90,7 +97,9 @@ export async function runToolPhase(state, round, sent, onToolCall) {
       calls: calls.length,
       elapsedMs: toolsEndedAt - toolsT0,
     });
-  } catch {}
+  } catch {
+    // the tool-phase-completed observer is advisory
+  }
   traceLoopPhaseTiming({
     iteration: round.nextIteration,
     preSendMs: sent.preSendMs,

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

@@ -9,6 +9,7 @@ import {
   drainPendingMessages,
   releasePendingMessages,
 } from './pending-messages.mjs';
+import { promptOriginOf } from '../../../../shared/prompt-origin.mjs';
 
 const SYNTHETIC_PROMPT_SOURCES = ['goal-continuation', 'goal-closeout'];
 
@@ -35,6 +36,7 @@ const tailTurnFor = (group) => ({
   content: group.content,
   entries: group.entries,
   ...(group.hop ? { hop: group.hop } : {}),
+  ...(group.origin ? { origin: group.origin } : {}),
   ...(group.mode === PENDING_MODE_TASK_NOTIFICATION
     ? promptSourceFields(PENDING_MODE_TASK_NOTIFICATION, group.execution)
     : {}),
@@ -49,13 +51,19 @@ const queuedTurnInput = (tailTurn) => ({
   pendingEntries: tailTurn.entries,
   ...(tailTurn.hop ? { hop: tailTurn.hop } : {}),
   promptSource: promptSourceFields(tailTurn.source, tailTurn.execution),
+  ...(tailTurn.origin ? { promptOrigin: tailTurn.origin } : {}),
 });
 
-export function createAskPromptQueue({ sessionId, promptSource }) {
+// The caller's provenance of its initial prompt, apart from its presentation
+// source: an inbound channel message or an agent report (shared/prompt-origin.mjs).
+const initialPromptOriginFor = (promptOrigin) => promptOriginOf(promptOrigin);
+
+export function createAskPromptQueue({ sessionId, promptSource, promptOrigin }) {
   // Local FIFO of follow-up prompts drained from the pending-message queue
   // after each turn — keeps queued `agent type=send` messages in order.
   const tail = [];
   let initialPromptSource = initialPromptSourceFor(promptSource);
+  let initialPromptOrigin = initialPromptOriginFor(promptOrigin);
   // Queue entries of the input nextTurn handed out that no turn owns yet.
   // Once a turn starts, its failure path acks or releases them instead.
   let unstartedEntries = [];
@@ -67,13 +75,15 @@ export function createAskPromptQueue({ sessionId, promptSource }) {
    *  and provenance — or null when nothing model-visible is left to run. */
   const nextTurn = (original) => {
     const source = initialPromptSource;
+    const origin = initialPromptOrigin;
     initialPromptSource = null;
+    initialPromptOrigin = null;
     let input;
     if (tail.length > 0) {
       // After the first turn, the next prompt comes from the drained queue.
       input = queuedTurnInput(tail.shift());
     } else if (hasModelVisiblePromptContent(original.prompt)) {
-      input = { ...original, pendingEntries: [], promptSource: source };
+      input = { ...original, pendingEntries: [], promptSource: source, ...(origin ? { promptOrigin: origin } : {}) };
     } else {
       // Idle resume: TUI kicks an empty ask() after execution completions
       // mirror model-visible bodies into session pending. Drain that queue

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

@@ -19,6 +19,7 @@ import { armTurnDurability, claimTurnRuntime } from './ask-turn-open.mjs';
 import { prepareAskTurn, runAskAgentLoop } from './ask-turn-execute.mjs';
 import { commitAskTurn, publishAskTurn } from './ask-turn-settle.mjs';
 import { finalizeAskTurnFailure } from './ask-turn-failure.mjs';
+import { cacheWarmTurnKind, endCacheWarmTurn, failedTurnProvenance, noteCacheWarmTurn } from '../cache-warm.mjs';
 
 export { _api_call_with_interrupt } from './ask-call-interrupt.mjs';
 export {
@@ -168,7 +169,14 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
   // return value (the queued tail turns supersede the original prompt's
   // result, mirroring how a live chat returns the latest turn).
   let result;
-  const queue = createAskPromptQueue({ sessionId, promptSource: askOpts.promptSource });
+  const queue = createAskPromptQueue({
+    sessionId,
+    promptSource: askOpts.promptSource,
+    promptOrigin: askOpts.promptOrigin,
+  });
+  // The turn the prompt-cache warmer is told about last; it forgets it when
+  // the turn ends (endCacheWarmTurn), whatever way the ask unwinds.
+  let warmTurn = null;
   // Hoisted so the outer finally (which runs once after the whole turn loop)
   // can compare against the last turn's generation.
   let askGeneration = 0;
@@ -213,6 +221,12 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         recoverCheckpoint: !crashRecoveryChecked,
         emitStart: !sessionStartEmitted,
       });
+      // The prompt-cache warmer learns idle gaps from real turns only; a
+      // retry is classified by the failed turn's stored provenance.
+      // The rebuilt retry message keeps that provenance (ask-turn-execute.mjs).
+      const retryProvenance = failedTurnProvenance(claimed.preSession?.messages, input);
+      if (retryProvenance) input.retryProvenance = retryProvenance;
+      warmTurn = noteCacheWarmTurn(sessionId, cacheWarmTurnKind(input, claimed.preSession?.messages));
       crashRecoveryChecked = true;
       sessionStartEmitted = true;
       askGeneration = claimed.askGeneration;
@@ -234,6 +248,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         askStartedAt,
       });
       result = turn.result;
+      endCacheWarmTurn(sessionId, warmTurn);
       // Turn complete. Drain the pending-message queue: any `agent type=send`
       // that arrived while this turn was in flight runs next, in order, as a
       // follow-up user turn. The mutex is still held, so a send racing this
@@ -264,6 +279,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
       return result;
     }
   } finally {
+    // A failed/cancelled turn ends here too: its warmer turn entry goes (a
+    // later ask's own turn is never removed by this one).
+    endCacheWarmTurn(sessionId, warmTurn);
     // A failed/cancelled turn ends the ask: the follow-up turns drained
     // behind it never ran, so their entries go back to the pending queue.
     queue.releaseUnstarted();

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

@@ -7,6 +7,7 @@
 import { getProvider } from '../../providers/registry.mjs';
 import { pinSessionWireRoute } from '../../providers/wire-route.mjs';
 import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
+import { appendSkillUpdateNotices } from '../skill-update-notice.mjs';
 import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import { resolveTurnAutoEffort, turnStepAutoEffort } from './ask-turn-auto-effort.mjs';
 import { saveSessionAsync } from '../store.mjs';
@@ -22,6 +23,128 @@ import { _api_call_with_interrupt } from './ask-call-interrupt.mjs';
 import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
 import { stampTurnHop } from '../../../../shared/bot-hops.mjs';
 
+function turnPromptSourceFor(input) {
+  if (!(input.promptOrigin || input.retryProvenance)) return input.promptSource;
+  return {
+    ...(input.promptSource || {}),
+    ...(input.promptOrigin ? { origin: input.promptOrigin } : {}),
+    ...(input.retryProvenance ? { provenance: input.retryProvenance } : {}),
+  };
+}
+
+// A retried failed turn resubmits its retained user message over the history
+// before it: the message keeps its input and records the failed completion.
+function retainedUserTurn(session, retained, transcriptMeta, currentAgents) {
+  const historyMessages = filterModelVisibleSessionMessages(session.messages.slice(0, retained.index));
+  const { completion, ...previousTranscript } = retained.message.meta.transcript;
+  // The retained message keeps its input; agents enabled or switched
+  // off since it was built ride its runtime context.
+  const userTurnMessage = withAgentListingNotice(
+    session,
+    retained.index,
+    {
+      ...retained.message,
+      meta: {
+        ...retained.message.meta,
+        transcript: {
+          ...previousTranscript,
+          ...transcriptMeta,
+          messageId: previousTranscript.messageId,
+          previousCompletions: [
+            ...(previousTranscript.previousCompletions || []),
+            { ...completion, at: completion.at ?? previousTranscript.at },
+          ],
+        },
+      },
+    },
+    currentAgents
+  );
+  return { historyMessages, userTurnMessage, outgoing: [...historyMessages, userTurnMessage] };
+}
+
+// The turn's user message: the retained one of a retried failed turn, or a
+// newly built one (a promise).
+function pendingUserTurn({ session, input, retained, turnSignal, transcriptMeta, currentAgents }) {
+  if (retained) return retainedUserTurn(session, retained, transcriptMeta, currentAgents);
+  return buildUserTurn({
+    session,
+    prompt: input.prompt,
+    context: input.context,
+    explicitPrefetch: input.explicitPrefetch,
+    turnSignal,
+    transcriptMeta,
+    // The stored message keeps an inbound channel's provenance and, for
+    // a rebuilt retry (the resubmitted prompt or a continuation prompt),
+    // the failed turn's, which a later retry reads back
+    // (cache-warm.mjs failedTurnProvenance).
+    turnPromptSource: turnPromptSourceFor(input),
+    effortConfiguration: null,
+    currentAgents,
+  });
+}
+
+// Stamp the turn's effort on the user message (same meta order as when it
+// was built with it: before the runtime-context provenance).
+function stampTurnEffort(userTurnMessage, effortConfiguration) {
+  const { runtimeUserContext, ...meta } = userTurnMessage.meta || {};
+  userTurnMessage.meta = {
+    ...meta,
+    effortConfiguration,
+    ...(runtimeUserContext ? { runtimeUserContext } : {}),
+  };
+}
+
+// Expose the in-flight working transcript so contextStatus() can
+// estimate the LIVE context footprint mid-turn. agentLoop mutates
+// `outgoing` in place (user turn + tool calls/results + compaction),
+// so the statusline context gauge climbs as the turn accumulates
+// tool output instead of freezing at the pre-turn snapshot. Cleared
+// on turn commit and in the ask finally.
+//
+// Also commit the user turn to the live session BEFORE the provider
+// call. Previously the prompt only reached session.messages after
+// agentLoop returned. If a worker/lead session was closed or aborted
+// before first response, closeSession() wrote a tombstone from the
+// still-system-only session and the handoff brief vanished forever
+// (agent row showed messages=2). Pre-committing makes cancellation,
+// close, and post-mortem files retain the exact user task; completion
+// overwrites this provisional transcript with the fully mutated
+// outgoing history and appends the assistant result, so no duplicate
+// user turn is introduced.
+function precommitUserTurn(session, outgoing, historyMessages, input) {
+  session.messages = filterModelVisibleSessionMessages(outgoing);
+  session.liveTurnMessages = outgoing;
+  // Name a titleless session from its first human prompt before the first
+  // save, so the title outlives any later compaction of the transcript. The
+  // earliest human turn already in the history wins; this turn's prompt is the
+  // fallback (runtime-injected turns carrying a promptSource never name it).
+  backfillFallbackSessionTitle(session, [
+    ...historyMessages,
+    ...(input.promptSource ? [] : [{ role: 'user', content: input.prompt }]),
+  ]);
+}
+
+// Mark the turn active and persist the pre-committed session before the
+// provider runs.
+function persistTurnPreflight(session, { turnToken, startedAt, checkpoint, askGeneration }) {
+  session.activeTurnCheckpoint = {
+    version: 1,
+    turnToken,
+    startedAt,
+  };
+  // The sidecar lands synchronously before provider execution. Even
+  // if the async canonical-session preflight save has not reached its
+  // worker when the process is killed, recovery still has the prompt.
+  checkpoint.schedule(true);
+  saveSessionAsync(session, { expectedGeneration: askGeneration }).catch((err) => {
+    try {
+      process.stderr.write(`[session] preflight user-turn save failed: ${err?.message || err}\n`);
+    } catch {
+      // stderr may be closed; the save failure is only reported
+    }
+  });
+}
+
 /** Resolves the provider, builds the user turn and pre-commits it; returns
  *  what the loop and the commit need from this preparation. */
 export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta, currentAgents }) {
@@ -68,45 +191,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   });
   const [autoEffort, userTurn] = await Promise.all([
     autoEffortPending,
-    retained
-      ? (() => {
-          const historyMessages = filterModelVisibleSessionMessages(session.messages.slice(0, retained.index));
-          const { completion, ...previousTranscript } = retained.message.meta.transcript;
-          // The retained message keeps its input; agents enabled or switched
-          // off since it was built ride its runtime context.
-          const userTurnMessage = withAgentListingNotice(
-            session,
-            retained.index,
-            {
-              ...retained.message,
-              meta: {
-                ...retained.message.meta,
-                transcript: {
-                  ...previousTranscript,
-                  ...transcriptMeta,
-                  messageId: previousTranscript.messageId,
-                  previousCompletions: [
-                    ...(previousTranscript.previousCompletions || []),
-                    { ...completion, at: completion.at ?? previousTranscript.at },
-                  ],
-                },
-              },
-            },
-            currentAgents
-          );
-          return { historyMessages, userTurnMessage, outgoing: [...historyMessages, userTurnMessage] };
-        })()
-      : buildUserTurn({
-          session,
-          prompt: input.prompt,
-          context: input.context,
-          explicitPrefetch: input.explicitPrefetch,
-          turnSignal,
-          transcriptMeta,
-          turnPromptSource: input.promptSource,
-          effortConfiguration: null,
-          currentAgents,
-        }),
+    pendingUserTurn({ session, input, retained, turnSignal, transcriptMeta, currentAgents }),
     wireRoutePending,
   ]);
   const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
@@ -118,60 +203,12 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // Auto effort also judges every tool-result step of the turn when the
   // installed judge was trained on steps (session/loop/step-auto-effort.mjs).
   const stepAutoEffort = turnStepAutoEffort(autoEffort, effortConfiguration);
-  if (effortConfiguration) {
-    // Stamp the turn's effort on the user message (same meta order as when it
-    // was built with it: before the runtime-context provenance).
-    const { runtimeUserContext, ...meta } = userTurn.userTurnMessage.meta || {};
-    userTurn.userTurnMessage.meta = {
-      ...meta,
-      effortConfiguration,
-      ...(runtimeUserContext ? { runtimeUserContext } : {}),
-    };
-  }
+  if (effortConfiguration) stampTurnEffort(userTurn.userTurnMessage, effortConfiguration);
   const { historyMessages, outgoing } = userTurn;
   turn.userTurnContent = userTurn.userTurnMessage.content;
   turn.outgoing = outgoing;
-  // Expose the in-flight working transcript so contextStatus() can
-  // estimate the LIVE context footprint mid-turn. agentLoop mutates
-  // `outgoing` in place (user turn + tool calls/results + compaction),
-  // so the statusline context gauge climbs as the turn accumulates
-  // tool output instead of freezing at the pre-turn snapshot. Cleared
-  // on turn commit and in the ask finally.
-  //
-  // Also commit the user turn to the live session BEFORE the provider
-  // call. Previously the prompt only reached session.messages after
-  // agentLoop returned. If a worker/lead session was closed or aborted
-  // before first response, closeSession() wrote a tombstone from the
-  // still-system-only session and the handoff brief vanished forever
-  // (agent row showed messages=2). Pre-committing makes cancellation,
-  // close, and post-mortem files retain the exact user task; completion
-  // overwrites this provisional transcript with the fully mutated
-  // outgoing history and appends the assistant result, so no duplicate
-  // user turn is introduced.
-  session.messages = filterModelVisibleSessionMessages(outgoing);
-  session.liveTurnMessages = outgoing;
-  // Name a titleless session from its first human prompt before the first
-  // save, so the title outlives any later compaction of the transcript. The
-  // earliest human turn already in the history wins; this turn's prompt is the
-  // fallback (runtime-injected turns carrying a promptSource never name it).
-  backfillFallbackSessionTitle(session, [
-    ...historyMessages,
-    ...(input.promptSource ? [] : [{ role: 'user', content: input.prompt }]),
-  ]);
-  session.activeTurnCheckpoint = {
-    version: 1,
-    turnToken,
-    startedAt,
-  };
-  // The sidecar lands synchronously before provider execution. Even
-  // if the async canonical-session preflight save has not reached its
-  // worker when the process is killed, recovery still has the prompt.
-  checkpoint.schedule(true);
-  saveSessionAsync(session, { expectedGeneration: askGeneration }).catch((err) => {
-    try {
-      process.stderr.write(`[session] preflight user-turn save failed: ${err?.message || err}\n`);
-    } catch {}
-  });
+  precommitUserTurn(session, outgoing, historyMessages, input);
+  persistTurnPreflight(session, { turnToken, startedAt, checkpoint, askGeneration });
   traceTurnContext({
     sessionId,
     session,
@@ -237,6 +274,12 @@ export async function runAskAgentLoop({
       checkpoint.schedule(true);
       notifySkillsApplied(askOpts?.onSkillsApplied, applied, userMessage);
     }
+    // Every turn (any session, any prompt source): a loaded skill that changed
+    // since it was loaded is announced once, after the history.
+    if (appendSkillUpdateNotices(outgoing, effectiveCwd).length) {
+      session.messages = filterModelVisibleSessionMessages(outgoing);
+      checkpoint.schedule(true);
+    }
     return await _api_call_with_interrupt(sessionId, (signal) =>
       agentLoop(
         provider,

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

@@ -4,6 +4,9 @@
 // canonicalizes the transcript when the turn is interrupted.
 import { captureTurnCheckpointContextState, createTurnCheckpointRecorder } from './turn-checkpoint.mjs';
 import { finalizeTurnInterruptionSnapshot } from './turn-interruption.mjs';
+import { onSensitiveValuesMarked } from '../sensitive-values.mjs';
+import { saveSessionAsync } from '../store.mjs';
+import { ingestSessionTurn } from '../../../../session-search/session-search-ingest.mjs';
 
 // Coalescing window for streaming-delta flushes. Each flush journals only the
 // delta since the previous one, so the window just bounds syscalls.
@@ -50,11 +53,36 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
         warned = true;
         try {
           process.stderr.write(`[turn-checkpoint] write failed session=${sessionId}: ${error?.message || error}\n`);
-        } catch {}
+        } catch {
+          // stderr may be closed; the checkpoint failure is only reported
+        }
       }
       return false;
     }
   };
+  const flushNow = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    flush();
+  };
+  // A value marked sensitive while the turn runs (sensitive-values.mjs) —
+  // before the call that carries it executes: every stored copy that may hold
+  // it is written again with it replaced. The checkpoint is rewritten in full
+  // now (the recorder sees the new version); the session file gets a full
+  // save (store/save-delta.mjs resyncs on the version) and the search rows a
+  // transactional replacement (session-search-ingest.mjs).
+  const stopMarks = onSensitiveValuesMarked(sessionId, () => {
+    if (stopped) return;
+    if (turn.outgoing) flushNow();
+    saveSessionAsync(turn.session, { expectedGeneration: generation }).catch((err) => {
+      try {
+        process.stderr.write(`[session] sensitive-value save failed session=${sessionId}: ${err?.message || err}\n`);
+      } catch {
+        // stderr may be closed; the save failure is only reported
+      }
+    });
+    ingestSessionTurn(turn.session);
+  });
   return {
     refreshContextState() {
       contextState = captureTurnCheckpointContextState(turn.session, turn.outgoing, turn.userTurnContent);
@@ -62,9 +90,7 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
     schedule(immediate = false) {
       if (stopped || !turn.outgoing) return;
       if (immediate || Date.now() - lastAt >= TURN_CHECKPOINT_THROTTLE_MS) {
-        if (timer) clearTimeout(timer);
-        timer = null;
-        flush();
+        flushNow();
         return;
       }
       if (timer) return;
@@ -77,6 +103,7 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
     },
     stop() {
       stopped = true;
+      stopMarks();
       if (timer) clearTimeout(timer);
       timer = null;
       recorder.stop();

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

@@ -15,6 +15,7 @@ import {
 } from '../context-utils.mjs';
 import { previewFreshContextCompaction, runFreshContextCompact } from '../loop/fresh-context.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
+import { withLiveCompactionConfig } from '../../runtime-core/compaction-config-keys.mjs';
 import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { traceAgentCompact, messagePrefixHash } from '../../agent-trace.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
@@ -36,7 +37,7 @@ import {
   shouldCompactForRequestMedia,
 } from '../loop/compact-policy.mjs';
 import { snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
-import { scheduleCompactionArchive, stampCompactionMessageIds } from '../compaction-archive-capture.mjs';
+import { prepareCompactionArchive, stampCompactionMessageIds } from '../compaction-archive-capture.mjs';
 
 // 'compacting' is a transient in-flight stage written just before Compact
 // runs. If the process crashes or only partially
@@ -263,11 +264,12 @@ function compactionResult(plan, outcome, after, tail) {
   };
 }
 
+// The commit writes only its own outcome telemetry; config-owned fields stay
+// the live ones (withLiveCompactionConfig).
 function compactionRecord(plan, { stage, after, now, reserve, outcome }) {
-  const { session, mode } = plan;
-  return {
-    ...withoutLegacyCompactFields(session.compaction),
-    auto: mode === 'auto' ? true : session.compaction?.auto !== false,
+  const { session } = plan;
+  const live = withoutLegacyCompactFields(session.compaction);
+  return withLiveCompactionConfig(live, {
     boundaryTokens: plan.boundary,
     triggerTokens: plan.triggerTokens,
     bufferTokens: plan.bufferTokens,
@@ -282,7 +284,7 @@ function compactionRecord(plan, { stage, after, now, reserve, outcome }) {
     currentEstimatedTokens: after.tokens,
     lastCheckedAt: now,
     ...outcome,
-  };
+  });
 }
 
 // compact_meta parity with the loop's pre-send pass: the out-of-loop
@@ -659,6 +661,26 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
   // Older titleless sessions: keep a name before the transcript that carries
   // the first prompt is replaced.
   if (changed) backfillFallbackSessionTitle(session, messages);
+  // Write-ahead: what this compaction drops is durable (pending sidecar)
+  // before the shortened transcript is adopted, since any later save persists
+  // it. A sidecar that cannot be written keeps the old transcript.
+  let archive = null;
+  if (changed && plan.archive) {
+    try {
+      archive = prepareCompactionArchive({
+        session,
+        sessionId: resolvedSessionId,
+        before: messages,
+        after: transcript,
+        at: now,
+      });
+    } catch (archiveError) {
+      writeStderrBestEffort(
+        `[session] compaction not applied (sess=${resolvedSessionId || 'unknown'}): ${archiveError?.message || archiveError}\n`
+      );
+      return recordFailedCompaction(plan, { compactError: archiveError, freshContextError: null }, compactStartedAt);
+    }
+  }
   session.messages = transcript;
   // The compacted transcript breaks the cache anyway: a staged working-folder
   // change re-roots the system prompt now and needs no notice any more.
@@ -677,18 +699,8 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
     outcome: compactionOutcome(session, freshContextResult, changed, now),
   });
   // Display-only: the dropped conversation stays readable above the divider.
-  // Only the selection and the segment number happen here; the projection and
-  // the write run later, off this commit.
-  const archived =
-    changed && plan.archive
-      ? scheduleCompactionArchive({
-          session,
-          sessionId: resolvedSessionId,
-          before: messages,
-          after: transcript,
-          at: now,
-        })
-      : null;
+  // The publication runs later, off this commit.
+  const archived = archive ? { ...archive, written: archive.start() } : null;
   if (changed) {
     invalidateProviderContextBaseline(session);
     if (postCompactPolicy) {

package/src/runtime/agent/orchestrator/session/manager/owner-route-fallbacks.mjs

@@ -8,7 +8,8 @@
 // The chain applies only while the session runs on the owner's configured
 // primary model. A session the user put on another model (composer picker,
 // New Task) is a deliberate choice and gets none. Route changes recompute it
-// (updateSessionRoute `routeFallbacks`); a fallback hop does not.
+// (updateSessionRoute `routeFallbacks`); a fallback hop reads it from the
+// owner's route at that moment (route-fallback-chain.mjs).
 import { loadConfig } from '../../config.mjs';
 import { findPreset } from '../../runtime-core/config-helpers.mjs';
 import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
@@ -17,26 +18,35 @@ import { storedBotRoute } from '../../../../shared/agent-store.mjs';
 import { configuredAgentRouteCandidates } from '../../../../shared/agent-route-config.mjs';
 import { CODING_MODE } from '../agent-mode.mjs';
 
-export function ownerRouteFallbacks({ sessionMode, agentId, provider, model, config = null }) {
-  if (!agentId) return [];
+/** Whether two routes name the same model (provider aliases folded). */
+export const sameRouteModel = (a, b) =>
+  Boolean(a?.provider && a?.model) &&
+  canonicalRouteProvider(a.provider) === canonicalRouteProvider(b?.provider) &&
+  String(a.model) === String(b?.model);
+
+/** The owner's stored route (primary plus `fallbacks`), normalized; null when
+ *  the owner has none or it cannot be read. */
+export function ownerConfiguredRoute({ sessionMode, agentId, config = null }) {
+  if (!agentId) return null;
   const cfg = () => config || loadConfig({ secrets: false });
   let stored;
   if (sessionMode === CODING_MODE) {
-    stored = findPreset(cfg(), cfg()?.default);
+    const loaded = cfg();
+    stored = findPreset(loaded, loaded?.default);
   } else {
     // Before the bot split a bot's route is still in the config (Mixy's never).
     stored = storedBotRoute(agentId) || (agentId === 'lead' ? null : configuredAgentRouteCandidates(cfg(), agentId)[0]);
   }
-  if (!stored?.fallbacks?.length) return [];
-  let route;
+  if (!stored) return null;
   try {
-    route = normalizeWorkflowRoute(stored);
+    return normalizeWorkflowRoute(stored) || null;
   } catch {
-    return [];
+    return null;
   }
-  const onPrimary =
-    route &&
-    canonicalRouteProvider(route.provider) === canonicalRouteProvider(provider) &&
-    String(route.model) === String(model);
-  return onPrimary ? route.fallbacks || [] : [];
+}
+
+export function ownerRouteFallbacks({ sessionMode, agentId, provider, model, config = null }) {
+  const route = ownerConfiguredRoute({ sessionMode, agentId, config });
+  if (!route?.fallbacks?.length) return [];
+  return sameRouteModel(route, { provider, model }) ? route.fallbacks : [];
 }