mixdog 1.3.5 → 1.4.1

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-loop-options.mjs

@@ -231,9 +231,9 @@ export function buildAgentLoopOptions({
     },
     onStreamDelta: (kind = 'semantic') => {
       markSessionStreamDelta(sessionId, kind).catch(() => {});
-      // Raw transport is an internal health signal, not model progress.
-      // Preserve the public callback's historical semantic-only contract.
-      if (kind !== 'transport') relay(askOpts?.onStreamDelta, kind);
+      // Raw transport and keepalives are internal health signals, not model
+      // progress. Preserve the public callback's historical semantic-only contract.
+      if (kind !== 'transport' && kind !== 'keepalive') relay(askOpts?.onStreamDelta, kind);
     },
   };
 }

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

@@ -225,7 +225,9 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
   // (which inspects entry.emptyFinal first) classifies the
   // terminal state correctly even if it ticks during unwind.
   const isEmptyFinal =
-    !terminalResultPreview.content && !terminalResultPreview.reasoningContent && !terminalResultPreview.reactionCompleted;
+    !terminalResultPreview.content &&
+    !terminalResultPreview.reasoningContent &&
+    !terminalResultPreview.reactionCompleted;
   if (isEmptyFinal) {
     markSessionEmptyFinal(sessionId);
   }

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,35 +8,45 @@
 // 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';
-import { canonicalRouteProvider } from '../../../../shared/model-route-chain.mjs';
+import { canonicalRouteProvider, executionFallbacks } from '../../../../shared/model-route-chain.mjs';
 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 }) ? executionFallbacks(route) : [];
 }

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

@@ -4,6 +4,7 @@ import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions
 import { promptContentText } from './prompt-utils.mjs';
 import { parseTaskNotification, taskNotificationId } from '../../../../shared/task-notification-envelope.mjs';
 import { hopOf } from '../../../../shared/bot-hops.mjs';
+import { PROMPT_ORIGIN_CHANNEL } from '../../../../shared/prompt-origin.mjs';
 
 const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
 const PENDING_PROCESS_START_MS = Date.now();
@@ -12,6 +13,8 @@ const LIFECYCLE_TOKEN = Symbol('pendingLifecycleToken');
 export const COMPLETION_NOTIFICATION_KIND = 'completion_notification';
 export const PENDING_MODE_PROMPT = 'prompt';
 export const PENDING_MODE_TASK_NOTIFICATION = 'task-notification';
+// Prompt provenance apart from the presentation mode (shared/prompt-origin.mjs).
+export { PROMPT_ORIGIN_AGENT_REPORT, PROMPT_ORIGIN_CHANNEL } from '../../../../shared/prompt-origin.mjs';
 
 export function stampLifecycleToken(entry, token) {
   if (!entry || typeof entry !== 'object' || !token) return entry;
@@ -169,9 +172,14 @@ export function lateDeliveryText(text, entry, now = Date.now()) {
 // A non-completion entry may be queued explicitly as a task notification (a
 // runtime/channel notice, never the user typing): the mode survives
 // normalization and the durable spool so the drain stores it as one and it
-// never drives explicit skill selection.
+// never drives explicit skill selection. A channel's inbound message keeps
+// its provenance beside the mode (PROMPT_ORIGIN_CHANNEL).
 function explicitModeField(entry) {
-  return entry?.mode === PENDING_MODE_TASK_NOTIFICATION ? { mode: PENDING_MODE_TASK_NOTIFICATION } : {};
+  if (entry?.mode !== PENDING_MODE_TASK_NOTIFICATION) return {};
+  return {
+    mode: PENDING_MODE_TASK_NOTIFICATION,
+    ...(entry.origin === PROMPT_ORIGIN_CHANNEL ? { origin: PROMPT_ORIGIN_CHANNEL } : {}),
+  };
 }
 
 function normalizePendingMessageEntry(entry) {
@@ -343,6 +351,7 @@ export function _groupPendingMessageEntries(entries) {
       mode: PENDING_MODE_TASK_NOTIFICATION,
       ...(normalized.execution ? { execution: normalized.execution } : {}),
       ...(normalized.hop ? { hop: normalized.hop } : {}),
+      ...(normalized.origin ? { origin: normalized.origin } : {}),
       ids: idsOf([entry]),
       entries: [entry],
     });

package/src/runtime/agent/orchestrator/session/manager/provider-replay.mjs

@@ -33,6 +33,19 @@ function plainToolCalls(toolCalls) {
   });
 }
 
+/** The provider-native replay state `message` carries — its replay fields'
+ *  values and its tool calls' signatures — or null when it carries none. */
+export function providerReplayState(message) {
+  if (!message || typeof message !== 'object') return null;
+  const state = PROVIDER_REPLAY_FIELDS.filter((field) => field in message).map((field) => message[field]);
+  for (const call of Array.isArray(message.toolCalls) ? message.toolCalls : []) {
+    if (call && typeof call === 'object') {
+      for (const field of TOOL_CALL_SIGNATURE_FIELDS) if (field in call) state.push(call[field]);
+    }
+  }
+  return state.length ? state : null;
+}
+
 /** `message` without provider-native replay state; the same object when it carries none. */
 export function stripProviderReplayMessage(message) {
   if (!message || typeof message !== 'object') return message;