mixdog 1.3.0 → 1.3.2

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

@@ -4,10 +4,10 @@
  * consume a retry verdict, and settle a completed send into the loop state.
  */
 import { traceCacheBreak } from '../../cache-break-trace.mjs';
+import { anthropicPrefixChanges } from '../../providers/lib/anthropic-prefix-trace.mjs';
 import { resolveLiveToolCwd } from './tool-exec.mjs';
 import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { addUsage, usageDeltaEvent } from './usage.mjs';
-import { isVisibleStreamProgress } from '../../../../shared/stream-progress.mjs';
 import { prepareProviderRequest } from './request-boundary.mjs';
 import { applyStepEffort } from './step-auto-effort.mjs';
 import { projectProviderRequest } from './request-projection.mjs';
@@ -182,15 +182,10 @@ export async function sendProviderRequest(state, round) {
     tools: round.sendTools,
     opts,
   });
-  // The first visible token of this request, for its generation time (queue,
-  // preflight and time-to-first-token stay out of the speed figures).
-  let firstVisibleAt = 0;
-  const callerOnStreamDelta = opts.onStreamDelta;
-  const observeStreamDelta = (kind, ...rest) => {
-    if (!firstVisibleAt && isVisibleStreamProgress(kind)) firstVisibleAt = Date.now();
-    return callerOnStreamDelta?.(kind, ...rest);
-  };
-  opts.onStreamDelta = observeStreamDelta;
+  // The request's time for the speed figures, the wait for the first token
+  // included: the span the usage ledger recorded as `duration_ms` (stamped on
+  // the response); wall time only for a response no ledger row timed.
+  const requestStartedAt = Date.now();
   let result;
   try {
     result = await runWithProviderRequestToolsScope(round.requestToolScope, () =>
@@ -218,8 +213,6 @@ export async function sendProviderRequest(state, round) {
     sideQuestion?.discard();
     if (!(await advanceAgentRoute(state, error))) throw error;
     result = { action: 'retry_route' };
-  } finally {
-    if (opts.onStreamDelta === observeStreamDelta) opts.onStreamDelta = callerOnStreamDelta;
   }
   if (result.action === 'proceed') sideQuestion?.settle(result.response);
   else sideQuestion?.discard();
@@ -230,7 +223,9 @@ export async function sendProviderRequest(state, round) {
     prefixGuardCandidate,
     sendStartedAt,
     sendEndedAt,
-    generationMs: firstVisibleAt ? Math.max(0, sendEndedAt - firstVisibleAt) : 0,
+    requestMs: Number.isFinite(result.response?.usageDurationMs)
+      ? Math.max(0, result.response.usageDurationMs)
+      : Math.max(0, sendEndedAt - requestStartedAt),
     preSendMs,
     toolResumeMs,
   };
@@ -358,6 +353,8 @@ function traceActualCacheMiss(state, sent, response, { previousGuardState, previ
         previousCachedPrefixTokens: baseline,
         idleMs,
         missingPrefixGuardBaseline: !previousGuardState,
+        // Which wire block moved ('none': same bytes, so the cache itself dropped it).
+        ...anthropicPrefixChanges(sessionId),
       },
       state.cacheBreakTraceOptions
     );
@@ -443,7 +440,7 @@ export function settleSendResult(state, round, sent) {
             usage: reportedUsage,
             sendTools: round.sendTools,
             toolCalls: response.toolCalls?.length || 0,
-            generationMs: sent.generationMs,
+            requestMs: sent.requestMs,
           })
         )
       );

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

@@ -1,6 +1,7 @@
 // Steering-message normalization/merge helpers.
 // Merges queued steering entries into a single content payload + display text.
 import { stableMessageId } from '../../../../shared/transcript-metadata.mjs';
+import { raiseTurnHop } from '../../../../shared/bot-hops.mjs';
 
 function steeringContentText(content) {
   if (typeof content === 'string') return content;
@@ -140,6 +141,8 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
   // gets it back (onSteerMessage) for the row it draws. A steered prompt
   // keeps the id the surface gave it, else gets one.
   const messageId = stableMessageId(merged.transcriptMeta?.messageId);
+  // A bot's message at a higher hop makes the running turn bot-descended at that hop.
+  raiseTurnHop(opts.session, merged.transcriptMeta);
   const steeringTranscriptMeta =
     merged.transcriptMeta && typeof merged.transcriptMeta === 'object'
       ? { at: submittedAt ?? injectedAt, ...merged.transcriptMeta, messageId }

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

@@ -6,15 +6,20 @@ import { resolvePreToolAskApproval } from '../tool-helpers.mjs';
 import { runAbortable, throwIfAborted } from '../../../../../shared/abort-race.mjs';
 import { evaluateExecPolicy } from '../../../tools/bash-policy-scan.mjs';
 import { beginSessionApprovalWait } from '../../manager/runtime-liveness.mjs';
-import { agentMcpToolPermission } from '../../../mcp/agent-connectors.mjs';
-import { humanGateDecision, recordHumanDecision } from '../../human-gate/gate.mjs';
+import { agentMcpToolPermission, writeAgentMcpToolPermission } from '../../../mcp/agent-connectors.mjs';
+import {
+  actingContactBotId,
+  humanGateDecision,
+  recordHumanDecision,
+  rememberSurfaceOf,
+} from '../../human-gate/gate.mjs';
 import { applyEditedArgs } from '../../human-gate/requests.mjs';
 
 const isArgsObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
 
 async function askApproval(
   call,
-  { callerSessionId, executeOpts, toolApprovalHook, decision, request = null, gate = null }
+  { callerSessionId, executeOpts, toolApprovalHook, decision, request = null, gate = null, onApproved = null }
 ) {
   const askReason = String(decision?.reason || 'approval requested by hook').trim();
   // While the user decides, the session is waiting on them, not working.
@@ -46,26 +51,52 @@ async function askApproval(
   }
   // The user approved this very call on the richer outbound card.
   if (request?.kind === 'outbound') call.outboundApproved = true;
+  await onApproved?.(approval);
   return null;
 }
 
+/** The renderer translates this exact text (desktop-toasts.tsx ALLOW_NOT_SAVED_TEXT). */
+export const ALLOW_NOT_SAVED_NOTICE = 'Allowed this once. The setting could not be saved.';
 export const CONNECTOR_APPROVAL_REASON = 'This connector tool is set to ask before it runs for this agent.';
 
 /**
  * A connector tool the running agent set to `needs_approval` asks through the
  * ordinary approval hook, whatever the PreToolUse hooks decided. Run after
  * them, on the final call: a renamed call is judged under its final name.
- * A call the outbound card already got approved is not asked a second time.
+ * A call the outbound gate owns (its card approved it, or a remembered
+ * outbound grant answered it) is not asked a second time.
  * @returns {Promise<{ denial: string } | null>} the denial, or null to run
  */
 export function applyConnectorApproval(call, { agentId, callerSessionId, executeOpts, toolApprovalHook }) {
   if (call.outboundApproved) return null;
   if (agentMcpToolPermission(agentId, call.name) !== 'needs_approval') return null;
+  // "Always allow" is offered only to the contact bot that is acting, for its
+  // own policy entry for this one tool: never another bot, Mixy or the Lead.
+  const botId = actingContactBotId(callerSessionId);
+  const rememberable = Boolean(botId) && botId === agentId;
   return askApproval(call, {
     callerSessionId,
     executeOpts,
     toolApprovalHook,
     decision: { reason: CONNECTOR_APPROVAL_REASON },
+    request: rememberable
+      ? {
+          kind: 'approval',
+          agentId: botId,
+          remember: ['once', 'agent'],
+          rememberAt: rememberSurfaceOf(callerSessionId),
+        }
+      : null,
+    onApproved: async (approval) => {
+      if (!rememberable || approval?.remember !== 'agent') return;
+      try {
+        if (await writeAgentMcpToolPermission(botId, call.name, 'auto')) return;
+      } catch {
+        // fall through to the notice below
+      }
+      // Not saved: this call still runs once, and the next one asks again.
+      toolApprovalHook?.notice?.(ALLOW_NOT_SAVED_NOTICE, 'warn');
+    },
   });
 }
 
@@ -120,7 +151,7 @@ export async function applyBeforeToolHook({
     // Judged as the call will run: only a rewriting decision changes name/args.
     const hookAction = String(hookDecision?.action || hookDecision?.decision || '').toLowerCase();
     const rewritten = hookAction === 'ask' || hookAction === 'modify' || hookAction === 'rewrite';
-    const { decision, request, gate } = await humanGateDecision(
+    const { decision, request, gate, remembered } = await humanGateDecision(
       {
         name:
           rewritten && typeof hookDecision?.name === 'string' && hookDecision.name.trim()
@@ -132,6 +163,8 @@ export async function applyBeforeToolHook({
       { sessionId: callerSessionId, mcpScopeId }
     );
     const action = String(decision?.action || decision?.decision || '').toLowerCase();
+    // A remembered outbound grant answered this call: the connector ask is not repeated.
+    if (remembered) call.outboundApproved = true;
     if (action === 'deny' || action === 'block') {
       const reason = decision?.reason ? `: ${decision.reason}` : '';
       return { denial: `Error: tool "${name}" denied by hook${reason}` };

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

@@ -17,6 +17,26 @@ import { isOnDeferredToolSurface } from '../deferred-call-through.mjs';
 import { _executeCodeGraphToolLazy } from '../../manager/runtime-loaders.mjs';
 import { requiresReadBody } from '../tool-classify.mjs';
 import { executeCursorNativeBuiltin } from '../../../tools/builtin/external-tool-adapters.mjs';
+import { providerNativePdf, providerReadsImages } from '../../../providers/registry.mjs';
+import { getModelMetadataSync } from '../../../../../shared/llm/model-catalog.mjs';
+
+/**
+ * How read returns a PDF to this session's model. Native PDF support decides
+ * only whether a short PDF may arrive whole as a document block. A scanned
+ * page arrives as a page image whenever the model sees images — the provider
+ * sends image input (only the text-only local runtime does not) and the
+ * catalog does not say the model lacks it — and as OCR text otherwise.
+ */
+export function pdfReadModes(
+  sessionRef,
+  { nativePdf = providerNativePdf, readsImages = providerReadsImages, catalogRow = getModelMetadataSync } = {}
+) {
+  const provider = sessionRef?.provider;
+  const model = sessionRef?.model;
+  const seesImages =
+    readsImages(provider) && (model ? catalogRow(model, provider)?.supportsVision : undefined) !== false;
+  return { pdfPageMode: seesImages ? 'image' : 'ocr', pdfNativeDocument: nativePdf(provider) };
+}
 
 function dispatchMcp(name, args, { cwd, callerSessionId, sessionRef, executeOpts }) {
   const mcpScopeId = sessionRef?.mcpScopeId || null;
@@ -107,6 +127,7 @@ export function dispatchToolCall({ name, args }, ctx) {
         : {}),
       // Runtime-granted only; any value inherited from executeOpts is overridden.
       elevationApproved: ctx.elevationApproved === true,
+      ...pdfReadModes(sessionRef),
     };
     return executeCursorNativeBuiltin(
       name,

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

@@ -6,6 +6,7 @@
 //   tool-exec/after-hook.mjs         — PostToolUse result override
 //   tool-exec/read-only-deadline.mjs — bounded read-only I/O with partial-output grace
 import { isMcpTool } from '../../mcp/client.mjs';
+import { connectorPolicyAgentOf } from '../../mcp/agent-connectors.mjs';
 import { prepareDeferredToolCallThrough } from './deferred-call-through.mjs';
 import { refreshDeferredMcpToolCatalog } from '../../runtime-core/tool-catalog.mjs';
 import { bridgeTargetUnavailable } from '../../runtime-core/tool-bridge.mjs';
@@ -54,7 +55,7 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
   });
   if (hooked.denial) return hooked.denial;
   const connectorDenied = await applyConnectorApproval(hooked, {
-    agentId: sessionRef?.agent,
+    agentId: connectorPolicyAgentOf(sessionRef),
     callerSessionId,
     executeOpts,
     toolApprovalHook,

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

@@ -8,6 +8,7 @@ import {
   bridgeSurfaceOutdated,
   sessionToolExposure,
   TOOL_EXPOSURE_BRIDGE,
+  TOOL_EXPOSURE_NATIVE,
   TOOL_SURFACE_MIGRATION_INTENT,
   toolExposureMigrationNeeded,
   toolExposureModeForProvider,
@@ -122,6 +123,17 @@ export function applyAgentToolExposure(session, { existing = false } = {}) {
   const bridge =
     !allowlisted && toolExposureModeForProvider(session.provider, session.wireRoute) === TOOL_EXPOSURE_BRIDGE;
   if (!bridge && before === null) return false;
+  // A native deferred surface (the session runtime builds one) stays one:
+  // re-selected over the tools just resolved, never stripped to the full
+  // array. Native → native is no exposure change, so nothing is tagged.
+  if (!bridge && before === TOOL_EXPOSURE_NATIVE) {
+    session.tools = session.tools.slice();
+    applyDeferredToolSurface(session, session.deferredSurfaceMode || 'full', [], {
+      provider: session.provider,
+      model: session.model,
+    });
+    return false;
+  }
   // A surface an earlier bridge revision built is rebuilt now.
   const outdated = bridgeSurfaceOutdated(session);
   // The tools just resolved are the whole authority: no earlier catalog, MCP

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

@@ -3,6 +3,7 @@
 // native tool-search payload parsing, bash-session routing, and approval.
 import { isMcpTool } from '../../mcp/client.mjs';
 import { unattendedApprovalPort } from '../human-gate/gate.mjs';
+import { isGrantedRun, runAskOutcome } from '../human-gate/run-policy.mjs';
 import { isBuiltinTool } from '../../tools/builtin.mjs';
 import { isInternalTool } from '../../internal-tools.mjs';
 import { loadSkillToolDependencies } from '../../runtime-core/skill-tool-loading.mjs';
@@ -212,12 +213,13 @@ export async function resolvePreToolAskApproval({
 }) {
   const name = String(toolName || 'tool');
   const reason = String(askReason || 'approval requested by hook').trim();
-  // Unattended runs never auto-approve and have no card: a schedule or webhook
-  // run always holds the request for its owner; a room member does when no
+  // A schedule or webhook run never asks: saving it was the user's grant
+  // (human-gate/run-policy.mjs). A room member is held for its owner when no
   // approval UI is attached (session-runtime/held-requests.mjs).
   const unattended = unattendedApprovalPort();
   const run = unattended?.runOf?.(sessionId) || null;
-  const held = run && (run.kind !== 'room' || typeof toolApprovalHook !== 'function');
+  if (isGrantedRun(run)) return runAskOutcome({ name, request });
+  const held = run && typeof toolApprovalHook !== 'function';
   const ask = held ? unattended.hold : toolApprovalHook;
   if (typeof ask !== 'function') {
     return { denial: formatMissingToolApprovalUiDenial(name, reason) };
@@ -238,8 +240,12 @@ export async function resolvePreToolAskApproval({
     return { denial: `Error: tool "${name}" denied by hook: ${detail}` };
   }
   if (!approvalGranted(approval)) {
-    const detail = approvalReason(approval, reason || 'not approved');
-    return { denial: `Error: tool "${name}" denied by hook: ${detail}`, approval };
+    // A person (or the hold for one) said no: never a policy hook to work around.
+    const detail = String(approvalReason(approval, reason || 'not approved')).replace(/[.\s]+$/, '');
+    return {
+      denial: `Error: tool "${name}" was not approved: ${detail}. Do not retry it or reach the same result another way; report it.`,
+      approval,
+    };
   }
   return { approval };
 }

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

@@ -41,7 +41,7 @@ export function usageDeltaEvent({
   usage,
   sendTools,
   toolCalls = 0,
-  generationMs = 0,
+  requestMs = 0,
 }) {
   return {
     sessionId,
@@ -57,9 +57,10 @@ export function usageDeltaEvent({
     deltaToolCalls: toolCalls,
     ...reasoningUsage(usage),
     deltaPrompt: usage.promptTokens || 0,
-    // First visible token → end of this response; 0 when the call was not
-    // timed (nothing visible streamed). Only timed output enters speed figures.
-    generationMs,
+    // Request start → end of this response (first-token wait included, as the
+    // ledger's duration_ms); 0 when the call was not timed. Only timed output
+    // enters speed figures.
+    requestMs,
     // A provider that cannot measure the prompt or its cache split says so;
     // its zeros are unknowns, not readings (no cache hit can be derived).
     promptKnown: usage.inputTokensKnown !== false && usage.cacheTokensKnown !== false,
@@ -79,6 +80,47 @@ export function usageDeltaEvent({
   };
 }
 
+const SUMMED_USAGE_FIELDS = [
+  'inputTokens',
+  'outputTokens',
+  'cachedTokens',
+  'cacheWriteTokens',
+  'cacheWrite1hTokens',
+  'promptTokens',
+];
+
+/** What `total` added after the running total `earlier` (both from addUsage); null when nothing. */
+export function usageSince(total, earlier) {
+  if (!total) return null;
+  if (!earlier) return { ...total };
+  const delta = {};
+  for (const field of SUMMED_USAGE_FIELDS) delta[field] = Math.max(0, (total[field] || 0) - (earlier[field] || 0));
+  if (total.reasoningTokens != null) {
+    delta.reasoningTokens = Math.max(0, total.reasoningTokens - (earlier.reasoningTokens ?? 0));
+    delta.reasoningTokensComplete = total.reasoningTokensComplete === true;
+  }
+  if (total.costUsd != null) delta.costUsd = Math.max(0, total.costUsd - (earlier.costUsd || 0));
+  if (total.contextTokens) delta.contextTokens = total.contextTokens;
+  return Object.values(delta).some((value) => typeof value === 'number' && value > 0) ? delta : null;
+}
+
+/**
+ * The turn's usage split per model when the route switched mid-turn:
+ * `hops` holds, per left model, the running total when it was left. Each
+ * segment carries only its own tokens so it is priced at its own rates.
+ */
+export function routeUsageSegments(hops, total, current) {
+  if (!Array.isArray(hops) || !hops.length) return null;
+  const boundaries = [...hops, { ...current, usage: total }];
+  return boundaries
+    .map((segment, index) => ({
+      provider: segment.provider,
+      model: segment.model,
+      usage: usageSince(segment.usage, index ? boundaries[index - 1].usage : null),
+    }))
+    .filter((segment) => segment.usage);
+}
+
 export function addUsage(total, usage) {
   const delta = normalizeUsage(usage);
   if (!delta) return total;

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

@@ -11,6 +11,7 @@ import { autoEffortModel, turnEffortConfigurationMode } from '../../providers/ef
 import {
   autoEffortApplicable,
   autoEffortBase,
+  clampAutoEffortBase,
   normalizeAutoEffortMode,
   resolveAutoEffort,
 } from '../../providers/auto-effort.mjs';
@@ -58,6 +59,15 @@ export function autoEffortMode() {
   }
 }
 
+/** The global "Auto reasoning base" setting; absent or unreadable is medium. */
+export function autoEffortBaseSetting() {
+  try {
+    return autoEffortBase(readSection('agent')?.autoEffortBase);
+  } catch {
+    return autoEffortBase(undefined);
+  }
+}
+
 /**
  * Starts the judge worker when a session is created or opened on a route that
  * Auto effort can judge, so the first judged turn does not wait for the cold
@@ -102,7 +112,9 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
   if (!request || request.startsWith('<')) return null;
   if (!turnEffortConfigurationMode(session, provider)) return null;
   const chosen = String(session.effort || '').toLowerCase();
-  const base = autoEffortBase(chosen);
+  const options = effortOptionsFor(session.provider, autoEffortModel(session.provider, provider, session.model));
+  const setting = autoEffortBaseSetting();
+  const base = clampAutoEffortBase({ base: setting, options }) ?? autoEffortBase(setting);
   const record = {
     at: new Date().toISOString(),
     sessionId,
@@ -113,7 +125,6 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
     base,
     requestChars: request.length,
   };
-  const options = effortOptionsFor(session.provider, autoEffortModel(session.provider, provider, session.model));
   // No judged outcome can apply when the base is off the model's ladder, so
   // the judge is not asked (in observe mode too: nothing would be logged).
   if (!autoEffortApplicable({ base, options })) {

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

@@ -120,14 +120,24 @@ function recordAgentRuntimeCall(session, result) {
 export async function recordAskUsage({ session, result, askStartedAt, turnSignal }) {
   const prefixHashForLog = recordAgentRuntimeCall(session, result);
   if (!result.usage) return;
-  await logSessionLlmUsage({
-    session,
-    usage: result.usage,
-    startedAt: askStartedAt,
-    signal: turnSignal,
-    prefixHash: prefixHashForLog,
-    transportTiming: result.transportTiming || null,
-  });
+  // A turn that switched models mid-way books one row per model, each priced
+  // at that model's rates; otherwise one row for the whole turn.
+  const segments = result.usageSegments?.length
+    ? result.usageSegments
+    : [{ provider: session.provider, model: session.model, usage: result.usage }];
+  for (const segment of segments) {
+    await logSessionLlmUsage({
+      session:
+        segment.provider === session.provider && segment.model === session.model
+          ? session
+          : { ...session, provider: segment.provider, model: segment.model },
+      usage: segment.usage,
+      startedAt: askStartedAt,
+      signal: turnSignal,
+      prefixHash: prefixHashForLog,
+      transportTiming: result.transportTiming || null,
+    });
+  }
   recordStandaloneStatusTelemetry(session, result, Date.now() - askStartedAt);
 }
 

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

@@ -19,12 +19,15 @@ import { retainedFailedTurnInput, rewindUnansweredPrompt } from './failed-turn-r
 import { buildAgentLoopOptions, trackedToolCallHook } from './ask-turn-loop-options.mjs';
 import { _api_call_with_interrupt } from './ask-call-interrupt.mjs';
 import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
+import { stampTurnHop } from '../../../../shared/bot-hops.mjs';
 
 /** 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 }) {
   const { turn, runtime, turnSignal, askGeneration, checkpoint, turnToken, startedAt, codexTurnId } = opened;
   const session = turn.session;
+  // Where the turn sits in a bot-to-bot chain (session-runtime/bot-hops.mjs).
+  stampTurnHop(session, transcriptMeta, input.promptSource);
   const retained = input.retryTurnId
     ? retainedFailedTurnInput(session.messages, input.retryTurnId, input.retryAttemptId)
     : null;
@@ -187,6 +190,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
     deferredToolDelta: userTurn.deferredToolDelta,
     goalReminder: userTurn.goalReminder,
     workflowNotice: userTurn.workflowNotice,
+    orchestrationModeNotice: userTurn.orchestrationModeNotice,
     workspaceNotice: userTurn.workspaceNotice,
     setupNotice: userTurn.setupNotice,
   };

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

@@ -20,6 +20,7 @@ import {
   snapshotPendingSetupNotice,
 } from './prompt-utils.mjs';
 import { snapshotPendingWorkflowNotice } from './workflow-switch-notice.mjs';
+import { snapshotPendingOrchestrationModeNotice } from './orchestration-mode-switch-notice.mjs';
 import { codexWireSendOpts } from './session-id.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
@@ -184,8 +185,12 @@ export async function buildUserTurn({
   // A mid-conversation workflow switch: the prompt and tools were rebuilt
   // for the new workflow; this turn tells the model once.
   const workflowNotice = snapshotPendingWorkflowNotice(session);
+  // A mid-conversation orchestration mode switch, after the workflow notice
+  // so the mode it names wins over the one a workflow reminder carries.
+  const orchestrationModeNotice = snapshotPendingOrchestrationModeNotice(session);
   const reminderBlock = [
     workflowNotice?.content || '',
+    orchestrationModeNotice?.content || '',
     workspaceNotice?.content || '',
     setupNotice?.content || '',
     currentTimeBlock ? `<system-reminder>\n# Current Time\n${currentTimeBlock}\n</system-reminder>` : '',
@@ -215,6 +220,7 @@ export async function buildUserTurn({
     deferredToolDelta,
     goalReminder,
     workflowNotice,
+    orchestrationModeNotice,
     workspaceNotice,
     setupNotice,
     userTurnMessage,

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 { acknowledgePendingOrchestrationModeNotice } from './orchestration-mode-switch-notice.mjs';
 import {
   finalizePendingMessageDelivery,
   drainPendingMessages,
@@ -141,6 +142,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.orchestrationModeNotice) {
+    acknowledgePendingOrchestrationModeNotice(session, prepared.orchestrationModeNotice.revision);
+  }
   if (prepared.workspaceNotice) {
     acknowledgePendingWorkspaceNotice(session, prepared.workspaceNotice.revision);
   }

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

@@ -110,17 +110,12 @@ function withoutLegacyCompactFields(value) {
     delete next[key];
   return next;
 }
-// Handoff-summary timeout scales with transcript size (clear/manual path):
-// default max(60s, ~10s per 25k estimated message tokens) capped at 300s.
-// The summary may run on a slow reasoning model — the session's own model is
-// used whenever the maintenance route is unavailable — where even a small
-// transcript outlives the old 30s floor and a large one the old 120s cap.
-// session.compaction.timeoutMs still overrides.
-function handoffSummaryTimeoutMs(session, messageTokens) {
-  const override = positiveInt(session?.compaction?.timeoutMs);
-  if (override) return override;
-  const scaled = Math.ceil((messageTokens || 0) / 25_000) * 10_000;
-  return Math.min(HANDOFF_TIMEOUT_MAX_MS, Math.max(60_000, scaled));
+// Handoff-summary timeout (clear/manual path): the same 300s as automatic
+// compaction, whatever the transcript size — the summary may run on a slow
+// reasoning model or a stalled provider connection, and a timeout fails the
+// compaction. session.compaction.timeoutMs still overrides.
+function handoffSummaryTimeoutMs(session) {
+  return positiveInt(session?.compaction?.timeoutMs) || HANDOFF_TIMEOUT_MAX_MS;
 }
 /**
  * ONE wiring for the fresh-context handoff pass: provider, summary model,
@@ -144,13 +139,8 @@ export async function runHandoffCompaction({
   provider = null,
   model = null,
   config,
-  messageTokensEst = null,
   requireReduction = false,
 } = {}) {
-  const messageList = Array.isArray(messages) ? messages : [];
-  const transcriptTokens = Number.isFinite(Number(messageTokensEst))
-    ? Number(messageTokensEst)
-    : estimateMessagesTokens(messageList);
   return runFreshContextCompact({
     sessionRef: session,
     messages,
@@ -159,7 +149,7 @@ export async function runHandoffCompaction({
       reserveTokens,
       contextWindow: positiveInt(contextWindow) || positiveInt(session?.contextWindow) || boundaryTokens,
       boundaryTokens,
-      handoffTimeoutMs: handoffSummaryTimeoutMs(session, transcriptTokens),
+      handoffTimeoutMs: handoffSummaryTimeoutMs(session),
     },
     sessionId,
     signal,
@@ -336,7 +326,6 @@ async function runSessionHandoff(plan, opts) {
       provider: opts.provider || getProvider(session.provider) || null,
       model: opts.model,
       config: opts.config,
-      messageTokensEst: plan.beforeMessageTokens,
       requireReduction: plan.requireReduction,
     });
     if (Array.isArray(run.freshContextResult?.messages)) {
@@ -609,7 +598,43 @@ function withAppendedMessages(plan, numbers, appended) {
 const TRANSCRIPT_MOVED_ERROR =
   'compact: the conversation changed while compacting; compaction not applied, run it again';
 
+// Why a compaction took as long as it did: persisted next to lastSummaryModel
+// and echoed as one daemon.log line. Wall time runs start → end of commit; the
+// summary call's own time comes from the handoff pipeline, so the remainder is
+// planning, transcript comparison and the commit below. The archive write is
+// scheduled by the commit and runs later, off it.
+function recordCompactionTiming(plan, freshContextResult, { startedAt, commitStartedAt, afterTokens }) {
+  const { session, resolvedSessionId } = plan;
+  const committedAt = Date.now();
+  const pipeline = freshContextResult?.diagnostics?.pipeline;
+  const summaryMs = pipeline?.generated?.durationMs ?? null;
+  // How the summary ran: a fork of the cached request or the isolated
+  // request, and on which route (session / maintenance / lighter).
+  let summaryRun = null;
+  if (pipeline?.summaryRoute) {
+    const kind = pipeline.generated?.mode === 'shared-prefix' ? 'fork' : 'isolated';
+    summaryRun = `${kind}:${pipeline.summaryRoute}`;
+  }
+  const timing = {
+    lastStartedAt: startedAt,
+    lastCommittedAt: committedAt,
+    lastDurationMs: committedAt - startedAt,
+    lastPipelineMs: pipeline?.totalMs ?? null,
+    lastSummaryMs: summaryMs,
+    lastCommitMs: committedAt - commitStartedAt,
+    lastCompactMode: summaryRun ? `${pipeline.mode}:${summaryRun}` : pipeline?.mode || null,
+  };
+  Object.assign(session.compaction, timing);
+  writeStderrBestEffort(
+    `compaction session=${resolvedSessionId || 'unknown'} source=${freshContextResult?.handoffSource || 'session-local'} ` +
+      `model=${freshContextResult?.summaryModel || '-'} mode=${summaryRun || '-'} total=${timing.lastDurationMs}ms ` +
+      `summary=${summaryMs ?? 0}ms commit=${timing.lastCommitMs}ms ` +
+      `in=${plan.beforeTokens} out=${afterTokens}\n`
+  );
+}
+
 async function commitSessionCompaction(plan, run, compactStartedAt) {
+  const commitStartedAt = Date.now();
   const { session, messages, mode, force, resolvedSessionId, reserveTokens } = plan;
   const { freshContextResult } = run;
   const numbers = await afterCompactionNumbers(plan, run.compacted);
@@ -688,6 +713,7 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
   if (changed) {
     session.pendingCacheBreakIntent = mode === 'auto' ? 'post_turn_compaction' : 'manual_compaction';
   }
+  recordCompactionTiming(plan, freshContextResult, { startedAt: compactStartedAt, commitStartedAt, afterTokens });
   return compactionResult(
     plan,
     { changed, reason: unchangedReason },