mixdog 1.2.5 → 1.2.6

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -8,6 +8,7 @@ import { noEnabledProvidersError } from './registry-errors.mjs';
 import { providerTakesNativePdf } from '../../../attachments/store.mjs';
 import { modelProxyClientMode } from '../../../shared/model-proxy-mode.mjs';
 import { getModelProxyChannel } from './model-proxy-channel.mjs';
+import { boundedProviderCatalogOp } from './catalog-deadline.mjs';
 // OpenAI-compat provider names are self-declared by openai-compat-presets.mjs via
 // OPENAI_COMPAT_PRESETS. No parallel list maintained here.
 const providers = new Map();
@@ -33,6 +34,7 @@ export const OAUTH_PROVIDER_NAMES = new Set([
   'mimo-oauth',
   'cursor-oauth',
   'antigravity-oauth',
+  'opencode-go-oauth',
 ]);
 // Providers the most recently applied config declared with enabled:false for a
 // USER reason. A deliberate opt-out (logout / disable in settings) must survive
@@ -178,7 +180,7 @@ const PROVIDER_MODULES = {
   'cursor-api': ['./cursor.mjs', 'CursorApiProvider'],
   openai: ['./openai-ws.mjs', 'OpenAIDirectProvider'],
   'mixdog-local': ['./mixdog-local.mjs', 'MixdogLocalProvider'],
-  'opencode-go': ['./opencode-go.mjs', 'OpenCodeGoProvider'],
+  'opencode-go-oauth': ['./opencode-go-oauth.mjs', 'OpenCodeGoOAuthProvider'],
   // Multi-wire preset gateways (wire-route.mjs picks the wire per model).
   openrouter: ['./openrouter.mjs', 'OpenRouterProvider'],
   deepseek: ['./deepseek.mjs', 'DeepSeekProvider'],
@@ -288,6 +290,8 @@ async function _initProvidersUnsynchronized(config, signal = null, proxyChannel
   const enabledResults = await Promise.all(
     entries.map(async ([name, cfg]) => {
       if (!cfg.enabled) return null;
+      // A retired provider's saved config is inert: its replacement is its own entry.
+      if (Object.hasOwn(RETIRED_PROVIDER_ALIASES, name)) return null;
       // Idempotent reuse: an enabled provider whose config signature is
       // unchanged from the live registry is carried forward as-is. Only
       // added or changed providers are (re)constructed below.
@@ -438,7 +442,14 @@ function _scheduleOAuthSelfHeal(name) {
       _oauthSelfHealLoads.delete(name);
     });
 }
-export function getProvider(name) {
+// Provider ids that were retired: a saved route or session naming one is served
+// by its replacement account. When that account is not connected the lookup
+// misses like any other unconnected provider.
+const RETIRED_PROVIDER_ALIASES = Object.freeze({ 'opencode-go': 'opencode-go-oauth' });
+export function getProvider(requestedName) {
+  const name = Object.hasOwn(RETIRED_PROVIDER_ALIASES, requestedName)
+    ? RETIRED_PROVIDER_ALIASES[requestedName]
+    : requestedName;
   const cached = providers.get(name);
   if (cached) return cached;
   // OAuth lazy fallback. Covers the boot-time race where the credential probe
@@ -560,10 +571,23 @@ export async function _withRegisteredProviderForTestAsync(name, instance, fn) {
 // Shared by the startup refresh and the 24h/forced refresh below.
 function providerCatalogRefreshFn(provider) {
   if (typeof provider?._refreshModelCache === 'function') return () => provider._refreshModelCache();
-  if (typeof provider?.listModels === 'function') return () => provider.listModels();
+  if (typeof provider?.listModels === 'function') return (signal) => provider.listModels({ signal });
   return null;
 }
 
+// One provider's refresh, bounded per provider (catalog-deadline.mjs): a hung
+// or offline provider is reported and left out after the deadline, so the
+// refresh epoch still completes for everyone else. Its late answer lands in
+// its own model cache; the session catalog retries its listing after the
+// partial-catalog backoff.
+function boundedCatalogRefresh(name, provider, refreshFn, label) {
+  return boundedProviderCatalogOp({ name, provider, kind: 'refresh', run: refreshFn }).then(({ error }) => {
+    if (!error) return;
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[provider:${name}] ${label} failed: ${msg}\n`);
+  });
+}
+
 function armNextCatalogRefresh(startedAt = Date.now()) {
   _catalogRefreshNotBefore = startedAt + CATALOG_REFRESH_INTERVAL_MS;
   if (_catalogRefreshTimer) clearTimeout(_catalogRefreshTimer);
@@ -589,14 +613,7 @@ export function refreshProviderCatalogsOnStartup() {
   for (const [name, provider] of providers) {
     const refreshFn = providerCatalogRefreshFn(provider);
     if (!refreshFn) continue;
-    pending.push(
-      Promise.resolve()
-        .then(() => refreshFn())
-        .catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[provider:${name}] startup catalog refresh failed: ${msg}\n`);
-        })
-    );
+    pending.push(boundedCatalogRefresh(name, provider, refreshFn, 'startup catalog refresh'));
   }
   // Returns a completion promise so callers can invalidate stale model
   // caches once the fresh catalogs land. Still fire-and-forget: unawaited
@@ -621,25 +638,22 @@ export function refreshCatalogs(options = {}) {
   }
   armNextCatalogRefresh();
   const pending = [];
-  const metadataReady = Promise.resolve()
-    .then(() => refreshMetadataCatalog())
-    .catch((err) => {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[model-catalog] metadata refresh failed: ${msg}\n`);
-      return null;
-    });
+  // The shared metadata fetch is bounded the same way: providers wait for it
+  // at most one deadline before refreshing without fresh metadata.
+  const metadataReady = boundedProviderCatalogOp({
+    name: '(model-metadata)',
+    provider: null,
+    kind: 'refresh',
+    run: () => refreshMetadataCatalog(),
+  }).then(({ error }) => {
+    if (!error) return;
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[model-catalog] metadata refresh failed: ${msg}\n`);
+  });
   for (const [name, provider] of providers) {
     const refreshFn = providerCatalogRefreshFn(provider);
     if (!refreshFn) continue;
-    pending.push(
-      Promise.resolve()
-        .then(() => metadataReady)
-        .then(() => refreshFn())
-        .catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[provider:${name}] catalog refresh failed: ${msg}\n`);
-        })
-    );
+    pending.push(metadataReady.then(() => boundedCatalogRefresh(name, provider, refreshFn, 'catalog refresh')));
   }
   // Completion promise: lets callers drop stale model caches after refresh.
   _catalogRefreshPromise = Promise.allSettled([metadataReady, ...pending])

package/src/runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs

@@ -1,6 +1,5 @@
-export const ASK_USER_MAX_QUESTIONS = 4;
+const ASK_USER_MAX_QUESTIONS = 4;
 export const ASK_USER_MAX_TEXT = 4000;
-export const ASK_USER_MAX_LABEL = 80;
 
 export const ASK_USER_TOOL_DEFS = Object.freeze([
   {
@@ -9,7 +8,7 @@ export const ASK_USER_TOOL_DEFS = Object.freeze([
     trigger:
       'Ask the user 1–4 multiple-choice questions and wait; when a plan needs the user to pick between clear options, instead of listing them in chat.',
     description:
-      'Ask the user multiple-choice questions and wait. Only while planning, for a decision only the user can make with clear options; open questions, minor choices and plan approval go in chat. Do not repeat the options in your message.',
+      'Ask the user multiple-choice questions and wait. Only for a decision only the user can make, with clear options; never for minor choices or approval of requested work, and open questions go in chat. Do not repeat the options in your message.',
     annotations: {
       title: 'Ask User',
       readOnlyHint: true,

package/src/runtime/agent/orchestrator/runtime-core/orchestration.mjs

@@ -29,8 +29,7 @@ ${BATCHING[mode]}
 The mode sets how work splits; an agent's description sets its role and when
 it runs. Splitting applies to every role alike — implementation, review,
 investigation, writing — by file, module, commit range or risk area.
-If the plan has only one implementation scope, Lead executes it directly; a
-role tied to a point in the work, such as the final check, still runs then.
+If the plan has only one implementation scope, Lead executes it directly.
 
 Delegation is for work whose size justifies a brief. When the brief would have
 to spell out the edits themselves — a few localized changes whose sites Lead
@@ -41,11 +40,7 @@ Dispatch all ready independent scopes in one turn. Only a scope that requires
 another's output waits. Brief each agent as the Lead rules describe.
 A running agent receives only changes within its own scope; a new independent
 need goes to a new agent. When scopes touch the same file, name one owner for
-that file in each brief. Agents run only the checks covering their own change;
-Lead runs the full suite once after integration.
+that file in each brief.
 Use only available agents; when none fits a role, Lead does that work itself
-and never changes settings to enable one. If the reviewer is disabled or
-unavailable, Lead alone reviews the result against the approved scope and
-performs the required verification, without a substitute agent; never skip
-review or describe Lead's own review as independent.`;
+and never changes settings to enable one.`;
 }

package/src/runtime/agent/orchestrator/session/agent-pool-progress.mjs

@@ -6,14 +6,26 @@ import { displayProgressStage, lastProgressAt } from '../../../shared/quiet-prog
 import { resolveAgentStallThresholds } from '../stall-policy.mjs';
 
 /** `rows` with progress fields on every row `runtimeEntry(sessionId)` reports
- *  in flight; other rows pass through untouched. */
-export function withTurnProgress(rows, runtimeEntry, isTurnInFlight) {
+ *  in flight. `awaitingTask` marks a row whose agent waits on its background
+ *  work: 'wait' while its turn sits in `task wait`, 'background' while it is
+ *  idle with a background task it handed off still running. Other rows pass
+ *  through untouched. */
+export function withTurnProgress(rows, runtimeEntry, isTurnInFlight, hasRunningTasks = () => false) {
   return rows.map((row) => {
     const entry = runtimeEntry(row?.sessionId);
-    if (!isTurnInFlight(entry)) return row;
+    if (!isTurnInFlight(entry)) {
+      return row?.sessionId && hasRunningTasks(row.sessionId) ? { ...row, awaitingTask: 'background' } : row;
+    }
     const stage = typeof entry.stage === 'string' ? entry.stage : null;
+    // The in-flight turn's own start is the elapsed origin. The index row's
+    // stamp is written deferred (and a Lead row may never get one), so right
+    // after a wake it still holds the PREVIOUS turn's start or none.
+    const askStartedAt = Number(entry.askStartedAt) || 0;
+    const rowStart = Number(row.turnStartedAt) || Date.parse(row.turnStartedAt) || 0;
     return {
       ...row,
+      ...(askStartedAt > rowStart ? { turnStartedAt: new Date(askStartedAt).toISOString() } : {}),
+      ...(entry.taskWaits > 0 ? { awaitingTask: 'wait' } : {}),
       progressAt: lastProgressAt(entry) || null,
       // `model_thinking` while the sent request waits for its headers.
       progressStage: displayProgressStage(entry),

package/src/runtime/agent/orchestrator/session/compact/execution-tail.mjs

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs';
 import { estimateMessagesTokens } from '../context-utils.mjs';
 import { estimateTokens } from '../token-estimate.mjs';
 import { persistToolResultArtifactSync, previewToolResultArtifact } from '../tool-result-offload.mjs';
@@ -12,9 +13,64 @@ import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
 export const EXECUTION_RECOVERY_SOURCE = 'compact-execution-recovery';
 const TOOL_HISTORY_CONTEXT_RATIO = 0.05;
 // The working set of recent execution evidence does not grow with the window:
-// above 400k, 5% kept a large block of old tool output after every Compact.
-const TOOL_HISTORY_MAX_TOKENS = 20_000;
+// above 800k, 5% kept a large block of old tool output after every Compact.
+export const TOOL_HISTORY_MAX_TOKENS = 40_000;
 const ARCHIVE_THRESHOLD_TOKENS = 512;
+// Only the newest reminder survives a Compact; it names the dumps it replaced
+// (each dump holds the reminder that preceded it, so older ones stay reachable).
+const MAX_EARLIER_DUMPS = 4;
+const RECOVERY_PATH_RE = /available at (.+?) \(sha256:/;
+const EARLIER_DUMPS_RE = /^Earlier dumps \(older first\): (.+)$/m;
+const EARLIER_DUMPS_SEPARATOR = ' | ';
+// Below this a reference line saves little and every blob is one more file
+// for the offload prune walk to stat and read.
+const ARCHIVE_BLOB_MIN_BYTES = 16_384;
+const ARCHIVED_MESSAGE_KEY = 'archivedMessage';
+
+// One message per line (JSONL): grep returns whole messages, and line N + 1
+// holds message index N. JSON.stringify never emits a raw newline.
+// A message whose line reaches ARCHIVE_BLOB_MIN_BYTES is stored once per
+// session as its own content-addressed one-line file (`storeLine`); its dump
+// line is a reference to that file. Every later dump that still carries the
+// message (a retained tool result, an unchanged summary) repeats only the
+// reference, so a session's dumps no longer re-save their large bodies.
+function serializeExecutionArchive(messages, storeLine = null) {
+  return messages
+    .map((message) => {
+      const line = `${JSON.stringify(message, withoutMessageIdsReplacer)}\n`;
+      if (!storeLine || Buffer.byteLength(line, 'utf8') < ARCHIVE_BLOB_MIN_BYTES) return line;
+      const blob = storeLine(line);
+      if (!blob) throw new Error('compact: execution history could not be archived; original context preserved');
+      // The file name is the line's sha256; the call id keeps the line greppable.
+      const reference = { path: blob.path, toolCallId: message?.toolCallId };
+      return `${JSON.stringify({ [ARCHIVED_MESSAGE_KEY]: reference })}\n`;
+    })
+    .join('');
+}
+
+function archivedReference(value) {
+  return value && !Object.hasOwn(value, 'role') ? value[ARCHIVED_MESSAGE_KEY] : null;
+}
+
+// The archived transcript, with every referenced message read back.
+export function parseExecutionArchive(text) {
+  return text
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const value = JSON.parse(line);
+      const reference = archivedReference(value);
+      return reference ? JSON.parse(readFileSync(reference.path, 'utf8')) : value;
+    });
+}
+
+// Dump paths a recovery reminder names, oldest first.
+function recoveryArchivePaths(message) {
+  const content = String(message?.content ?? '');
+  const own = RECOVERY_PATH_RE.exec(content)?.[1];
+  const earlier = EARLIER_DUMPS_RE.exec(content)?.[1].split(EARLIER_DUMPS_SEPARATOR) ?? [];
+  return own ? [...earlier, own] : earlier;
+}
 
 export function toolHistoryBudget(contextWindow) {
   const window = Number(contextWindow);
@@ -89,7 +145,7 @@ function withoutStaleReplay(messages) {
 // call keeps its paired result.
 function shrinkGroup(group, archive, level) {
   const reference = (offset, what, id) =>
-    `[${what} archived without interpretation: ${archive.path}; message index ${group.start + offset}; toolCallId=${id}.`;
+    `[${what} archived without interpretation: ${archive.path}; message index ${group.start + offset} (line ${group.start + offset + 1}); toolCallId=${id}.`;
   return group.messages.map((message, offset) => {
     if (message.role === 'tool') {
       if (executionTokens([message]) < ARCHIVE_THRESHOLD_TOKENS) return message;
@@ -157,22 +213,27 @@ export function buildExecutionTail(
   const kept = new Map();
   let tokens = 0;
   let archive = null;
-  let recovery = previousRecovery;
+  // One reminder at most: the newest, which replaces any earlier ones.
+  let recovery = previousRecovery.slice(-1);
   const ensureArchive = () => {
     if (archive) return;
-    archive = (preview ? previewToolResultArtifact : persistToolResultArtifactSync)({
-      sessionId,
-      toolCallId: 'compact-execution',
-      channel: 'compact-execution',
-      // Model-readable evidence: display ids stay out of it.
-      content: JSON.stringify({ version: 1, messages: transcript }, withoutMessageIdsReplacer, 2),
-    });
-    if (!archive) throw new Error('compact: execution history could not be archived; original context preserved');
+    const persist = preview ? previewToolResultArtifact : persistToolResultArtifactSync;
+    // Model-readable evidence: display ids stay out of it.
+    const text = serializeExecutionArchive(transcript, (line) =>
+      persist({ sessionId, toolCallId: 'compact-execution', channel: 'compact-execution-message', content: line })
+    );
+    const dump = persist({ sessionId, toolCallId: 'compact-execution', channel: 'compact-execution', content: text });
+    if (!dump) throw new Error('compact: execution history could not be archived; original context preserved');
+    archive = dump;
+    const earlier = [...new Set(previousRecovery.flatMap(recoveryArchivePaths))]
+      .filter((path) => path !== archive.path)
+      .slice(-MAX_EARLIER_DUMPS);
+    const earlierLine = earlier.length ? `\nEarlier dumps (older first): ${earlier.join(EARLIER_DUMPS_SEPARATOR)}` : '';
     recovery = [
       {
         role: 'user',
         meta: { source: EXECUTION_RECOVERY_SOURCE, synthetic: true },
-        content: `<system-reminder>\nSome execution history was omitted or shortened to fit the tool-history budget. This is not an instruction to repeat those calls. The original calls, outcomes, and earlier recovery references are available at ${archive.path} (sha256:${archive.sha256}). Read only missing evidence when needed.\n</system-reminder>`,
+        content: `<system-reminder>\nSome execution history was omitted or shortened to fit the tool-history budget. This is not an instruction to repeat those calls. The original calls, outcomes, and earlier recovery references are available at ${archive.path} (sha256:${archive.sha256}). The dump is JSONL: line N+1 is message index N; an "archivedMessage" line names the file holding that message, so search its directory too. Read only missing evidence when needed.${earlierLine}\n</system-reminder>`,
       },
     ];
   };

package/src/runtime/agent/orchestrator/session/compact/forked-summary.mjs

@@ -0,0 +1,102 @@
+// The conversation summary as a cache-sharing fork of the session's latest
+// provider request: the same provider, model, system prompt, tools, send
+// options and message prefix, with the summary instruction appended as the
+// final user turn. The provider's prompt cache serves the whole prefix, so
+// the request pays cache-read prices for the context instead of sending a
+// separate text-only transcript uncached.
+//
+// The fork is skipped (and the isolated summary request runs instead) when
+// there is no settled request to fork, the summary route is a different
+// provider or model (a cache is never shared across them), or the fork would
+// not fit the window. A fork that fails, answers with a tool call or returns
+// no text falls back the same way; cancellation and timeout propagate.
+import { estimateMessagesTokens, estimateRequestReserveTokens, providerTokenCalibration } from '../context-utils.mjs';
+import { disposeTransportScope, forkTransportScope } from '../../providers/transport-scope.mjs';
+import { buildForkedRequest } from '../request-fork.mjs';
+import { compactionForkRequest } from '../side-question-store.mjs';
+import { HANDOFF_TIMEOUT_MAX_MS, SUMMARY_OUTPUT_TOKENS } from './constants.mjs';
+import { enforceCompactSummarySchema, extractResponseText, forkedCompactionPrompt } from './summary.mjs';
+
+const FORK_TOOL_STUB = 'Result omitted from this summary request; the call and its result are kept after the summary.';
+
+function forkSignal(parent, timeoutMs) {
+  const timeout = AbortSignal.timeout(Number(timeoutMs) > 0 ? Math.floor(timeoutMs) : HANDOFF_TIMEOUT_MAX_MS);
+  return parent ? AbortSignal.any([parent, timeout]) : timeout;
+}
+
+function forkUsage(usage) {
+  if (!usage) return null;
+  return {
+    inputTokens: Number(usage.inputTokens) || 0,
+    outputTokens: Number(usage.outputTokens) || 0,
+    cachedTokens: Number(usage.cachedTokens) || 0,
+    cacheWriteTokens: Number(usage.cacheWriteTokens) || 0,
+  };
+}
+
+// Why the fork cannot run on this route, or null when it can.
+function forkSkipReason(request, route) {
+  if (!request) return 'no_settled_request';
+  const sameProvider = request.provider === route.provider || request.provider?.name === route.providerName;
+  if (!sameProvider || request.model !== route.model) return 'different_route';
+  return null;
+}
+
+/**
+ * Summarize `conversationInput`'s history through a fork of the session's
+ * latest request on `route`. Returns `{ generated }` in the shape of
+ * generateFreshHandoffSummary's result, or `{ fallback }` naming why the
+ * isolated request must run instead.
+ */
+export async function summarizeOnSharedPrefix({ sessionId, route, conversationInput, signal, timeoutMs }) {
+  const request = compactionForkRequest(sessionId);
+  const skip = forkSkipReason(request, route);
+  if (skip) return { fallback: skip };
+  const startedAt = Date.now();
+  const { messages, opts } = buildForkedRequest(request, forkedCompactionPrompt(), FORK_TOOL_STUB);
+  const promptTokens = estimateMessagesTokens(messages) + estimateRequestReserveTokens(request.tools);
+  const window = Math.floor(Number(route.contextWindow) / providerTokenCalibration(route.providerName));
+  if (!(promptTokens + SUMMARY_OUTPUT_TOKENS <= window)) return { fallback: 'window' };
+  const requestSignal = forkSignal(signal, timeoutMs);
+  // The fork keeps the session id (prompt-cache routing) on its own transport
+  // scope: no pooled socket or response chain of the main session is touched.
+  const transportScope = forkTransportScope(sessionId, 'compact');
+  let response;
+  try {
+    response = await route.provider.send(messages, request.model, request.tools.length ? request.tools : undefined, {
+      ...opts,
+      transportScope,
+      admissionOwner: sessionId,
+      signal: requestSignal,
+    });
+  } catch (error) {
+    if (requestSignal.aborted) throw requestSignal.reason ?? error;
+    return { fallback: 'error', error };
+  } finally {
+    disposeTransportScope(transportScope, route.provider);
+  }
+  requestSignal.throwIfAborted();
+  const usage = forkUsage(response?.usage);
+  if (response?.toolCalls?.length) return { fallback: 'tool_call', usage };
+  const raw = extractResponseText(response);
+  if (!raw) return { fallback: 'empty', usage };
+  const enforced = enforceCompactSummarySchema(raw, { head: conversationInput, tail: [] });
+  return {
+    generated: {
+      summary: enforced.summary,
+      summaryRepaired: enforced.repaired === true,
+      usage,
+      handoffGenerated: true,
+      diagnostics: {
+        mode: 'shared-prefix',
+        calls: 1,
+        sharedPrefixMessages: request.messages.length,
+        promptTokens,
+        summaryChars: enforced.summary.length,
+        rawSummaryChars: raw.length,
+        summaryRepaired: enforced.repaired === true,
+        durationMs: Date.now() - startedAt,
+      },
+    },
+  };
+}

package/src/runtime/agent/orchestrator/session/compact/runner.mjs

@@ -18,7 +18,7 @@ import {
   splitProtectedContext,
 } from './messages.mjs';
 import { activeTurnContinuationMessage } from './continuation.mjs';
-import { buildExecutionTail } from './execution-tail.mjs';
+import { EXECUTION_RECOVERY_SOURCE, buildExecutionTail } from './execution-tail.mjs';
 import { latestSkillBodies } from '../../context/skill-state.mjs';
 import { effectiveBudget } from './budget.mjs';
 import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user-context.mjs';
@@ -48,7 +48,13 @@ function combinedSignal(parent, timeoutMs) {
 
 function splitFreshSource(messages) {
   const sanitized = redactToolCallSecretsInMessages(reconcileDedupStubs(sanitizeToolPairs(messages)));
-  const { protectedPrefix, conversation } = splitProtectedContext(sanitized);
+  const split = splitProtectedContext(sanitized);
+  // A recovery reminder right after the system prompt reads as protected
+  // prefix and would outlive every pass. It belongs to the conversation, where
+  // buildExecutionTail replaces it with the newest compaction's reminder.
+  const isRecovery = (message) => message?.meta?.source === EXECUTION_RECOVERY_SOURCE;
+  const protectedPrefix = split.protectedPrefix.filter((message) => !isRecovery(message));
+  const conversation = [...split.protectedPrefix.filter(isRecovery), ...split.conversation];
   let previousSummaryMessage = null;
   let previousAck = null;
   for (let index = conversation.length - 1; index >= 0; index -= 1) {

package/src/runtime/agent/orchestrator/session/compact/summary.mjs

@@ -61,6 +61,22 @@ Rules:
 - Use the same language as the active user thread when it is clear.
 - Do not mention the summary process or that context was compacted.`;
 
+// The final user turn of a summary forked from the session's own cached
+// request: the conversation itself is the history, so the instruction carries
+// what COMPACTION_SYSTEM_PROMPT says for the isolated request.
+export function forkedCompactionPrompt() {
+  return [
+    '<compaction-request>',
+    'Pause the task for this one response. No tools are available here: do not call any.',
+    'Write the anchored handoff summary this work continues from. The latest user request and the recent tool calls and results are kept verbatim after it, so focus on the older context that still matters.',
+    'If the conversation holds an earlier summary, update it: preserve still-true details, remove stale details, and merge in the new facts.',
+    'Do not answer the conversation itself. Do not mention that you are summarizing, compacting, or merging context. Respond in the same language as the conversation.',
+    '',
+    SUMMARY_TEMPLATE,
+    '</compaction-request>',
+  ].join('\n');
+}
+
 // The index-independent part of one transcript line. A batch fit rebuilds the
 // prompt for many overlapping slices of the same head; `lineCache` (scoped to
 // one fit sequence at a fixed perMessageChars) keeps each message's rendering

package/src/runtime/agent/orchestrator/session/lifecycle-scan.mjs

@@ -189,6 +189,15 @@ export function readTopLevelLifecycleRecord(raw) {
   // — for EVERY top-level key, since consumers reserialize and act on the
   // whole record, not only on the lifecycle three.
   if (!hasUniqueTopLevelKeys(raw)) return LIFECYCLE_SCAN_CONFLICT;
+  return lifecycleRecordOf(doc);
+}
+
+/**
+ * Step 3 alone, for a reader that has already proven `doc` is the complete,
+ * well-formed, duplicate-free top-level object of its document (see
+ * store-record-strict-scan.mjs): the record, or LIFECYCLE_SCAN_CONFLICT.
+ */
+export function lifecycleRecordOf(doc) {
   const has = (key) => Object.hasOwn(doc, key);
   const record = { doc, id: undefined, closed: undefined, generation: undefined };
   if (has('id')) {

package/src/runtime/agent/orchestrator/session/loop/fresh-context.mjs

@@ -15,6 +15,8 @@ import {
   SUMMARY_OUTPUT_TOKENS,
   COMPACT_TARGET_MIN_TOKENS,
 } from '../compact.mjs';
+import { summarizeOnSharedPrefix } from '../compact/forked-summary.mjs';
+import { retireCompactionFork } from '../side-question-store.mjs';
 
 // Conversation summarization triggers independently of the post-compact target:
 // at 5% of the window, capped so a large window does not carry tens of
@@ -110,6 +112,39 @@ function summarizeConversation(target, ctx) {
   );
 }
 
+function sumUsage(a, b) {
+  if (!a || !b) return a || b || null;
+  return Object.fromEntries(Object.keys(a).map((key) => [key, (a[key] || 0) + (Number(b[key]) || 0)]));
+}
+
+// Summary policy. On the session's own provider and model the summary forks
+// the latest cached request (compact/forked-summary.mjs): the context is
+// already in the prompt cache, so reading it costs a tenth to a twentieth of
+// sending the text-only transcript uncached, and the summary sees the full
+// execution context. A different summary route (the maintenance model)
+// cannot share that cache; there the isolated text-only request runs: on
+// the usage ledger it cost a median $0.16 and 24.5 s against a projected
+// $0.19 and 27 s for a cache-read fork of the main model's median 500k-token
+// context (the fork is cheaper than a same-model isolated request, $0.20).
+// A fork that cannot run or fails falls back to the isolated request.
+async function summarizeOnRoute(route, ctx) {
+  const shared = await summarizeOnSharedPrefix({
+    sessionId: ctx.sessionId,
+    route,
+    conversationInput: ctx.conversationInput,
+    signal: ctx.signal,
+    timeoutMs: ctx.compactPolicy.handoffTimeoutMs,
+  });
+  if (shared.generated) return shared.generated;
+  ctx.signal?.throwIfAborted();
+  const generated = await summarizeConversation(route, ctx);
+  return {
+    ...generated,
+    usage: sumUsage(generated.usage, shared.usage),
+    diagnostics: { ...generated.diagnostics, mode: 'isolated', sharedPrefixFallback: shared.fallback },
+  };
+}
+
 // A maintenance summary model that is out of quota must not take the whole
 // turn down: the conversation's own model still has budget and can
 // summarize. Only exhaustion reroutes — every other compaction failure
@@ -118,7 +153,7 @@ function summarizeConversation(target, ctx) {
 async function summarizeWithQuotaFallback(ctx, routeInput) {
   const route = await resolveCompactionRoute(routeInput);
   try {
-    return { route, generated: await summarizeConversation(route, ctx) };
+    return { route, generated: await summarizeOnRoute(route, ctx) };
   } catch (error) {
     ctx.signal?.throwIfAborted();
     const status = Number(error?.status || error?.httpStatus || error?.response?.status || 0);
@@ -132,7 +167,7 @@ async function summarizeWithQuotaFallback(ctx, routeInput) {
       throw error;
     }
     try {
-      return { route: fallback, generated: await summarizeConversation(fallback, ctx) };
+      return { route: fallback, generated: await summarizeOnRoute(fallback, ctx) };
     } catch (fallbackError) {
       fallbackError.compactRoute = { provider: fallback.providerName, model: fallback.model };
       throw fallbackError;
@@ -236,6 +271,8 @@ export async function runFreshContextCompact({
         diagnostics: { ...result.diagnostics, noOp: true, reason: 'no_token_reduction' },
       };
     }
+    // The rewritten transcript is no longer what the saved request carried.
+    if (result.freshContext) retireCompactionFork(sessionId);
     return result;
   };
   const pipeline = {

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

@@ -9,7 +9,7 @@ import { beginSessionApprovalWait } from '../../manager/runtime-liveness.mjs';
 
 const isArgsObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
 
-async function askApproval(call, { callerSessionId, executeOpts, toolApprovalHook, decision, keepArgs = false }) {
+async function askApproval(call, { callerSessionId, executeOpts, toolApprovalHook, decision }) {
   const askReason = String(decision?.reason || 'approval requested by hook').trim();
   // While the user decides, the session is waiting on them, not working.
   const releaseApprovalWait = beginSessionApprovalWait(callerSessionId);
@@ -31,33 +31,23 @@ async function askApproval(call, { callerSessionId, executeOpts, toolApprovalHoo
   }
   if (askOutcome.denial) return { denial: askOutcome.denial };
   const approval = askOutcome.approval;
-  if (!keepArgs && approval && typeof approval === 'object' && isArgsObject(approval.args)) call.args = approval.args;
+  if (approval && typeof approval === 'object' && isArgsObject(approval.args)) call.args = approval.args;
   return null;
 }
 
 /**
- * Approval gate for a shell call (or a terminal `run`) whose exec policy
- * decision is 'ask' (elevated launch). Runs after the final call is known. The
- * approval is granted for the exact command being asked about: an approval
- * reply cannot rewrite the args.
- * @returns {Promise<{ denial: string } | { elevationApproved: boolean }>}
+ * Elevation pass for a shell call (or a terminal `run`) whose exec policy
+ * decision is 'ask' (elevated launch). Runs after the final call is known.
+ * Mixdog does not prompt first: the OS elevation prompt (Windows UAC) is the
+ * user's confirmation. A deny is never lifted.
+ * @returns {{ elevationApproved: boolean }}
  */
-export async function applyShellElevationGate(call, { callerSessionId, executeOpts, toolApprovalHook }) {
+export function applyShellElevationGate(call) {
   const gated = call.name === 'shell' || (call.name === 'terminal' && call.args?.action === 'run');
   if (!gated || !isArgsObject(call.args) || call.args.command == null) {
     return { elevationApproved: false };
   }
-  const decision = evaluateExecPolicy(String(call.args.command));
-  if (decision.decision !== 'ask') return { elevationApproved: false };
-  const denied = await askApproval(call, {
-    callerSessionId,
-    executeOpts,
-    toolApprovalHook,
-    decision,
-    keepArgs: true,
-  });
-  if (denied) return denied;
-  return { elevationApproved: true };
+  return { elevationApproved: evaluateExecPolicy(String(call.args.command)).decision === 'ask' };
 }
 
 /**

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

@@ -74,9 +74,8 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
     const unavailable = bridgeTargetUnavailable(sessionRef, finalCall.schemaName || finalCall.name);
     if (unavailable) return unavailable;
   }
-  // Elevated launches ask the user first; denied / no approval UI refuses the call.
-  const elevation = await applyShellElevationGate(call, { callerSessionId, executeOpts, toolApprovalHook });
-  if (elevation.denial) return elevation.denial;
+  // Elevated launches skip Mixdog's own prompt; the OS elevation prompt confirms them.
+  const elevation = applyShellElevationGate(call);
   throwIfAborted(executeOpts.signal);
   const result = await runReadOnlyIoWithDeadline(call.name, executeOpts.signal || null, async (deadlineSignal) => {
     let callOpts = executeOpts;

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

@@ -130,6 +130,9 @@ export function buildAgentLoopOptions({
       checkpoint.schedule(true);
       relay(askOpts?.onAssistantToolCallObserved, call, detail);
     },
+    // A provider output item started (a tool call, a phased message): display
+    // only, so it bypasses the interruption journal.
+    onStreamItemStart: optionalFn(askOpts?.onStreamItemStart),
     onProviderSendStarted: () => {
       interruption.markProviderSendStarted();
       checkpoint.schedule(true);