mixdog 1.3.1 → 1.3.3

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

@@ -3,9 +3,12 @@ import { estimateMessagesTokens } from '../context-utils.mjs';
 import { estimateTokens } from '../token-estimate.mjs';
 import { persistToolResultArtifactSync, previewToolResultArtifact } from '../tool-result-offload.mjs';
 import {
+  EXECUTION_TEXT_SOURCE,
   isActualUserInstructionMessage,
+  isCompactConversationRow,
   isProtectedContextAckMessage,
   latestActualUserInstructionIndex,
+  pendingTaskNotificationIndexes,
 } from './messages.mjs';
 import { staleObservations, supersedeObservation } from './observation-supersession.mjs';
 import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
@@ -168,9 +171,10 @@ function shrinkGroup(group, archive, level) {
   });
 }
 
-// Walk from the anchor: kept groups verbatim, user instructions, and the
-// conversational assistant text the mode allows.
-function assembleTail(messages, kept, { anchor, firstKept, preserveConversation }) {
+// Walk from the anchor: kept groups verbatim, user instructions, unanswered
+// task notifications, and the conversation the mode allows (rule-only:
+// assistant text and runtime conversation rows).
+function assembleTail(messages, kept, { anchor, firstKept, preserveConversation, pending }) {
   const tail = [];
   for (let i = Math.max(0, anchor); i < messages.length; i += 1) {
     const group = kept.get(i);
@@ -184,8 +188,16 @@ function assembleTail(messages, kept, { anchor, firstKept, preserveConversation
       // Omitted execution stays in the archive; its conversational text
       // remains verbatim without replaying an orphaned call or reasoning.
       if (message.toolCalls?.length) {
-        // The text-only copy is this message's rewrite: it keeps its id.
-        if (message.content) tail.push(carryMessageId({ role: 'assistant', content: message.content }, message));
+        // The text-only copy is this message's rewrite: it keeps its id, and
+        // its marker keeps it from reading as a final reply.
+        if (message.content) {
+          tail.push(
+            carryMessageId(
+              { role: 'assistant', content: message.content, meta: { source: EXECUTION_TEXT_SOURCE } },
+              message
+            )
+          );
+        }
       } else {
         tail.push(message);
       }
@@ -193,6 +205,8 @@ function assembleTail(messages, kept, { anchor, firstKept, preserveConversation
     }
     if (
       isActualUserInstructionMessage(message) ||
+      pending.has(i) ||
+      (preserveConversation && isCompactConversationRow(message)) ||
       (i >= firstKept && message?.role === 'assistant' && !message.toolCalls?.length)
     ) {
       tail.push(message);
@@ -201,6 +215,19 @@ function assembleTail(messages, kept, { anchor, firstKept, preserveConversation
   return tail;
 }
 
+// The reminder naming the new dump and the earlier ones it supersedes.
+function recoveryReminder(archive, previousRecovery) {
+  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)}` : '';
+  return {
+    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}). 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>`,
+  };
+}
+
 export function buildExecutionTail(
   transcript,
   { contextWindow, sessionId, preserveConversation = false, preview = false } = {}
@@ -225,17 +252,7 @@ export function buildExecutionTail(
     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}). 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>`,
-      },
-    ];
+    recovery = [recoveryReminder(archive, previousRecovery)];
   };
   // An observation a later one of the same page or window replaced keeps only
   // its outcome and a reference to the archived original.
@@ -294,13 +311,22 @@ export function buildExecutionTail(
     throw new Error('compact: latest execution group cannot fit the tool-history budget; original context preserved');
   }
   const latest = latestActualUserInstructionIndex(messages);
+  const pendingIndexes = pendingTaskNotificationIndexes(messages);
+  const pending = new Set(pendingIndexes);
   const firstKept = kept.size ? Math.min(...kept.keys()) : messages.length;
   const latestKept = latest < 0 ? firstKept : latest;
-  const anchor = preserveConversation ? 0 : requestStart(messages, Math.min(firstKept, latestKept));
-  const tail = assembleTail(messages, kept, { anchor, firstKept, preserveConversation });
+  const anchor = preserveConversation
+    ? 0
+    : Math.min(requestStart(messages, Math.min(firstKept, latestKept)), ...pendingIndexes);
+  const tail = assembleTail(messages, kept, { anchor, firstKept, preserveConversation, pending });
   // With no execution to retain, keep the existing latest-request contract.
   if (!preserveConversation && !groups.length && !previousRecovery.length) {
-    return { messages: latest < 0 ? [] : [messages[latest]], toolTokens: 0, toolBudget: budget, retainedGroups: 0 };
+    return {
+      messages: messages.filter((_message, index) => index === latest || pending.has(index)),
+      toolTokens: 0,
+      toolBudget: budget,
+      retainedGroups: 0,
+    };
   }
   return {
     messages: [...recovery, ...tail],

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

@@ -65,6 +65,9 @@ export async function summarizeOnSharedPrefix({ sessionId, route, conversationIn
   try {
     response = await route.provider.send(messages, request.model, request.tools.length ? request.tools : undefined, {
       ...opts,
+      // Usage-ledger source, as on the isolated request (a background
+      // session's own sourceType in `opts.session` still wins there).
+      requestKind: 'compaction',
       transportScope,
       admissionOwner: sessionId,
       signal: requestSignal,

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

@@ -10,6 +10,7 @@ import {
   isProtectedContextUserMessage,
   isSummaryMessage,
 } from './user-message-kind.mjs';
+import { CONTROL_MARKER_RE } from '../../../../shared/tool-execution-contract.mjs';
 
 export function compactHeader(oldHistory) {
   // Stable display ids are bookkeeping, not conversation: the header names
@@ -53,6 +54,49 @@ export function isProtectedContextAckMessage(m) {
   );
 }
 
+// The text-only copy rule-only Compact keeps of an omitted tool-call turn.
+// It is execution, not a final reply, though it no longer carries its calls.
+export const EXECUTION_TEXT_SOURCE = 'compact-execution-text';
+
+// Delivered task notifications (a background agent's or task's completion,
+// stored as a role:'user' turn with source 'task-notification') the model has
+// not answered yet: every one after the latest final assistant reply. They
+// are turn input but neither a user instruction nor summarized conversation,
+// so a Compact must carry them verbatim or the report is lost.
+export function pendingTaskNotificationIndexes(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  const pending = [];
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    const message = list[index];
+    if (
+      message?.role === 'assistant' &&
+      !message.toolCalls?.length &&
+      !isProtectedContextAckMessage(message) &&
+      message.meta?.source !== EXECUTION_TEXT_SOURCE
+    ) {
+      break;
+    }
+    if (message?.role === 'user' && message.meta?.source === 'task-notification') pending.unshift(index);
+  }
+  return pending;
+}
+
+// Runtime rows that are conversation, not instructions: task and channel
+// notifications (answered or not), routine and task results posted into a
+// home thread, and turn interruption markers. Rule-only Compact keeps them
+// with the dialogue; the summary reads them as data.
+const CONVERSATION_RUNTIME_SOURCES = new Set(['task-notification', 'schedule-result']);
+
+export function isCompactConversationRow(message) {
+  if (message?.role !== 'user') return false;
+  if (CONVERSATION_RUNTIME_SOURCES.has(String(message.meta?.source || ''))) return true;
+  return (
+    typeof message.content === 'string' &&
+    CONTROL_MARKER_RE.test(message.content.trim()) &&
+    !isActualUserInstructionMessage(message)
+  );
+}
+
 function referenceFilesManifestMessage(message) {
   if (message?.role !== 'user' || typeof message.content !== 'string') return null;
   const text = message.content.trimStart();

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

@@ -5,16 +5,19 @@ import { estimateMessagesTokens, reconcileDedupStubs, sanitizeToolPairs } from '
 import { HANDOFF_TIMEOUT_MAX_MS, SUMMARY_OUTPUT_TOKENS, compactDebugLog } from './constants.mjs';
 import {
   contentText,
+  redactRawSecretString,
   redactToolCallSecretsInMessages,
   safeEstimateMessagesTokens,
   textByteLength,
 } from './text-utils.mjs';
 import {
   contextAckMessage,
+  isCompactConversationRow,
   isProtectedContextAckMessage,
   isSummaryMessage,
   latestActualUserInstructionIndex,
   latestActualUserInstructionMessage,
+  pendingTaskNotificationIndexes,
   splitProtectedContext,
 } from './messages.mjs';
 import { activeTurnContinuationMessage } from './continuation.mjs';
@@ -25,6 +28,8 @@ import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user
 import { carryMessageId, messageIdOf } from '../message-ids.mjs';
 import { normalizeIngestRole, shouldExcludeIngestMessage } from '../../../../memory/lib/session-ingest.mjs';
 import { codexWireSendOpts } from '../manager/session-id.mjs';
+import { messageHasReferencableMedia, referenceMessageMedia } from '../../../../attachments/attachment-reference.mjs';
+import { messageAttachmentTokens } from '../attachment-preflight.mjs';
 import { rebaseCompactedEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import {
   COMPACTION_SYSTEM_PROMPT,
@@ -73,8 +78,13 @@ function splitFreshSource(messages) {
     // Budgeting, AI input and rule-only retention use this same projection.
     // Keep current-turn reminders; remove only proven runtime additions from
     // older requests. Unmarked legacy text remains part of the summary budget.
+    // Older requests also carry their attachments by reference from here on:
+    // the file stays on disk under the path the reference names, so the
+    // compacted context keeps the pointer instead of the whole document.
     live: conversation
-      .map((message, index) => (index === latestUserIndex ? message : stripRuntimeUserContext(message)))
+      .map((message, index) =>
+        index === latestUserIndex ? message : referenceMessageMedia(stripRuntimeUserContext(message))
+      )
       .filter((message) => !isSummaryMessage(message)),
     sanitized,
   };
@@ -95,28 +105,76 @@ function chunkConversationMessage(role, content, source = {}) {
   return out;
 }
 
-function pureConversationForHandoff(messages) {
+// What the summary reads of runtime conversation rows and tool calls. The
+// rows stay whole in rule-only Compact; the calls stay in the execution tail
+// and archive.
+const SUMMARY_RUNTIME_ROW_CHARS = 4_000;
+const SUMMARY_TOOL_ARGS_CHARS = 200;
+const SUMMARY_TOOL_OUTCOME_CHARS = 300;
+
+function boundedSummaryText(text, limit) {
+  return text.length > limit ? `${text.slice(0, limit)}… [${text.length - limit} more chars]` : text;
+}
+
+function toolCallSummaryLine(call, result) {
+  const rawArgs = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+  const args = boundedSummaryText(rawArgs.replace(/\s+/g, ' '), SUMMARY_TOOL_ARGS_CHARS);
+  // Arguments arrive redacted (splitFreshSource); the outcome is redacted
+  // here, before any cut can split a secret from its key.
+  const outcome = redactRawSecretString(contentText(result?.content)).trim();
+  // An ask_user result is the user's own answer: never cut.
+  const shown =
+    call.name === 'ask_user' ? outcome : boundedSummaryText(outcome.replace(/\s+/g, ' '), SUMMARY_TOOL_OUTCOME_CHARS);
+  return `[tool call] ${call.name}(${args}) → ${result ? shown || '(empty result)' : '(no result)'}`;
+}
+
+// The conversation Compact measures and summarizes: user and assistant text
+// (the memory-ingest projection) plus runtime conversation rows. `summary`
+// bounds those rows and adds one line per tool call with its outcome.
+function compactionConversationRows(messages, { summary = false } = {}) {
+  const list = messages || [];
+  const results = new Map(list.filter((m) => m?.role === 'tool').map((m) => [m.toolCallId, m]));
   const out = [];
-  for (const message of messages || []) {
+  for (const message of list) {
     if (!message || typeof message !== 'object') continue;
-    const role = normalizeIngestRole(message.role);
-    if (!role || shouldExcludeIngestMessage(message)) continue;
     const content = contentText(message.content).trim();
-    if (!content) continue;
-    out.push(...chunkConversationMessage(role, content, message));
+    if (isCompactConversationRow(message)) {
+      // A notification can carry a background command's output: the summary
+      // reads it redacted like a tool outcome.
+      const text = summary ? boundedSummaryText(redactRawSecretString(content), SUMMARY_RUNTIME_ROW_CHARS) : content;
+      if (text) out.push(...chunkConversationMessage('user', text, message));
+      continue;
+    }
+    const role = normalizeIngestRole(message.role);
+    if (role && content && !shouldExcludeIngestMessage(message)) {
+      out.push(...chunkConversationMessage(role, content, message));
+    }
+    if (summary && message.role === 'assistant' && message.toolCalls?.length) {
+      const lines = message.toolCalls.map((call) => toolCallSummaryLine(call, results.get(call.id)));
+      out.push(...chunkConversationMessage('assistant', lines.join('\n'), message));
+    }
   }
   return out;
 }
 
-export function conversationCompactionInput(messages) {
+/** The conversation Compact measures against its summary threshold, or with
+ *  `summary`, the input the summary is written from. */
+export function conversationCompactionInput(messages, { summary = false } = {}) {
   const source = splitFreshSource(messages);
-  const latest = latestActualUserInstructionIndex(source.live);
+  // The turn input (the latest actual request and unanswered notifications)
+  // is mandatory and must never be replaced by a summary. Skills and runtime
+  // injections are excluded by the same conversation projection used by
+  // summary generation.
+  const turnInput = new Set([
+    latestActualUserInstructionIndex(source.live),
+    ...pendingTaskNotificationIndexes(source.live),
+  ]);
   return [
     ...(source.previousSummaryMessage ? [source.previousSummaryMessage] : []),
-    // The latest actual request is mandatory and must never be replaced by
-    // a summary. Tool outputs, skills and runtime injections are excluded
-    // by the same conversation projection used by summary generation.
-    ...pureConversationForHandoff(source.live.filter((_, index) => index !== latest)),
+    ...compactionConversationRows(
+      source.live.filter((_, index) => !turnInput.has(index)),
+      { summary }
+    ),
   ];
 }
 
@@ -135,6 +193,9 @@ function summarySendOpts(opts) {
     // Fast mode is opt-in (it needs separate account credits); the summary
     // follows the route/session choice and never enables it on its own.
     fast: opts.fast ?? opts.sendOpts?.fast ?? false,
+    // Usage-ledger source for a foreground session's summary call (a
+    // background session's own sourceType still wins there).
+    requestKind: 'compaction',
     maxOutputTokens: opts.maxOutputTokens || SUMMARY_OUTPUT_TOKENS,
     providerState: undefined,
     onToolCall: undefined,
@@ -219,7 +280,8 @@ export async function generateFreshHandoffSummary(provider, messages, model, bud
   const startedAt = Date.now();
   const budget = effectiveBudget(budgetTokens, opts);
   const source = splitFreshSource(messages);
-  let head = opts.filterOldHistoryForIngest === true ? pureConversationForHandoff(source.live) : source.live;
+  let head =
+    opts.filterOldHistoryForIngest === true ? compactionConversationRows(source.live, { summary: true }) : source.live;
   if (head.length === 0 && !source.previousSummary) {
     throw new Error('generateFreshHandoffSummary: no compactable session history');
   }
@@ -331,7 +393,12 @@ function prependLatestUserContext(message, prefix) {
   if (replacesGoalState) {
     suffix = suffix.replace(/<system-reminder>\s*<goal_state>[\s\S]*?<\/goal_state>\s*<\/system-reminder>\s*/gi, '');
   }
-  return withRuntimeUserContext(bare, { prefix: `${text}\n\n`, suffix });
+  // The kept suffix still carries the turn's agent list reminder: it stays told.
+  const told = bare !== message && message.meta.agentListing ? { agentListing: message.meta.agentListing } : null;
+  return withRuntimeUserContext(told ? { ...bare, meta: { ...bare.meta, ...told } } : bare, {
+    prefix: `${text}\n\n`,
+    suffix,
+  });
 }
 
 // The retained execution tail plus the current-turn messages that must
@@ -350,8 +417,11 @@ function freshContextTail(source, budgetTokens, preserveConversation, opts) {
   const retainedTail = execution.messages.map((message, index) =>
     index === latestIndex ? prependLatestUserContext(message, opts.latestUserPrefix) : message
   );
+  // The turn's input: the latest real request or an unanswered notification
+  // (a bot home thread may hold no human request at all).
+  const turnInput = !!latestUser || pendingTaskNotificationIndexes(source.live).length > 0;
   const activeTurnContinuation =
-    latestUser && opts.activeTurn === true ? activeTurnContinuationMessage(source.live) : null;
+    turnInput && opts.activeTurn === true ? activeTurnContinuationMessage(source.live) : null;
   // Older compacted sessions may have only synthetic Goal turns left.
   // Preserve the current snapshot without inventing a human instruction
   // to attach it to or resurrecting every historical Goal reminder.
@@ -366,6 +436,7 @@ function freshContextTail(source, budgetTokens, preserveConversation, opts) {
   return {
     execution,
     latestUser,
+    turnInput,
     retainedTail,
     activeTurnContinuation,
     volatileTail: [
@@ -398,20 +469,57 @@ function skillLoaderPair(live, bodyIndex, name, retainedCallIds) {
   return [];
 }
 
+const SKILL_RELOAD_SOURCE = 'compact-skill-reload';
+
+function skillReloadReminder(name) {
+  return {
+    role: 'user',
+    content: `[mixdog-runtime] Skill "${name}" was active, but its instructions did not fit after Compact. Reload it with the Skill tool before relying on them.`,
+    meta: { source: SKILL_RELOAD_SOURCE, synthetic: true, skill: name },
+  };
+}
+
 // Preserve complete, most-recent skill bodies from the durable transcript.
 // Never summarize/truncate operating instructions or displace the handoff
-// and current task. An omitted body remains eligible for a normal reload.
+// and current task. An omitted body leaves a one-line reload reminder, which
+// stands through later Compacts until the skill is loaded again. Reminders
+// are charged to the same budget: every skill's reminder is reserved before
+// any body is restored, and restoring a body releases its own reminder.
 function restoreSkillBodies(live, skillBudget, retainedTail) {
   const retainedCallIds = new Set(retainedTail.filter((m) => m?.role === 'tool').map((m) => m.toolCallId));
+  const bodies = latestSkillBodies(live);
+  const loaded = new Set(bodies.map((body) => body.name));
+  const reload = live
+    .filter((m) => m?.meta?.source === SKILL_RELOAD_SOURCE && !loaded.has(m.meta.skill))
+    .map((m) => m.meta.skill);
+  const reminderCost = (name) => estimateMessagesTokens([skillReloadReminder(name)]);
+  let reserved = [...new Set([...reload, ...loaded])].reduce((sum, name) => sum + reminderCost(name), 0);
+  const dropped = [];
   const restoredSkills = [];
   let skillTokens = 0;
-  for (const { name, message } of latestSkillBodies(live).reverse()) {
+  for (const { name, message } of bodies.reverse()) {
     const restored = [...skillLoaderPair(live, live.lastIndexOf(message), name, retainedCallIds), message];
     const cost = estimateMessagesTokens(restored);
-    if (skillTokens + cost > skillBudget) continue;
+    const own = reminderCost(name);
+    if (skillTokens + cost + reserved - own > skillBudget) {
+      dropped.unshift(name);
+      continue;
+    }
     restoredSkills.unshift(...restored);
     skillTokens += cost;
+    reserved -= own;
   }
+  // Newest skill first; only a budget too small for the reminders themselves
+  // leaves one out.
+  const pending = [...new Set([...reload, ...dropped])];
+  const reminded = new Set();
+  for (const name of pending.toReversed()) {
+    const cost = reminderCost(name);
+    if (skillTokens + cost > skillBudget) continue;
+    reminded.add(name);
+    skillTokens += cost;
+  }
+  restoredSkills.push(...pending.filter((name) => reminded.has(name)).map(skillReloadReminder));
   return { restoredSkills, skillTokens };
 }
 
@@ -538,7 +646,7 @@ function freshContextLayout(source, budgetTokens, opts) {
     ? fitFreshContextSummaryMessage(source.live, handoffText, Number.MAX_SAFE_INTEGER)
     : source.previousSummaryMessage;
   const tail = freshContextTail(source, budgetTokens, !replaceConversation, opts);
-  const stableAck = tail.latestUser && summaryMessage ? stableAckMessage(source.previousAck, tail.volatileTail) : null;
+  const stableAck = tail.turnInput && summaryMessage ? stableAckMessage(source.previousAck, tail.volatileTail) : null;
   const stableHead = [
     ...source.protectedPrefix,
     ...(summaryMessage ? [summaryMessage] : []),
@@ -548,15 +656,43 @@ function freshContextLayout(source, budgetTokens, opts) {
   return { handoffText, summaryMessage, tail, stableHead, mandatory, mandatoryCost: estimateMessagesTokens(mandatory) };
 }
 
-function assertMandatoryFits(budget, mandatoryCost, summaryMessage, contextWindow) {
-  if (mandatoryCost > budget || (summaryMessage && mandatoryCost === budget)) {
-    const window = Number(contextWindow) > 0 ? ` (currently ${contextWindow} tokens)` : '';
-    throw new Error(
-      `freshContextCompactMessages: mandatory session context/latest instruction exceeds compact budget=${budget} ` +
-        `(mandatory=${mandatoryCost}); the model context window${window} is too small for the tool definitions ` +
-        'and session context. Increase the model context size.'
-    );
-  }
+function mandatoryOverflows(budget, mandatoryCost, summaryMessage) {
+  return mandatoryCost > budget || (summaryMessage && mandatoryCost === budget);
+}
+
+export const LATEST_TURN_EXCEEDS_CONTEXT = 'LATEST_TURN_EXCEEDS_CONTEXT';
+
+// Says what does not fit and what would make it fit. A larger window is only
+// offered when one would actually hold the required size.
+function assertMandatoryFits(budget, mandatoryCost, summaryMessage, contextWindow, latestUser) {
+  if (!mandatoryOverflows(budget, mandatoryCost, summaryMessage)) return;
+  // Fixed sentences with the sizes inline: the desktop re-speaks each one
+  // through its catalog (error-notice-copy / transcript-failure-text).
+  const count = (value) => Number(value).toLocaleString('en-US');
+  const window = Number(contextWindow) > 0 ? `${count(contextWindow)}-token` : 'current';
+  const attachments = messageAttachmentTokens(latestUser);
+  const cause =
+    attachments > 0
+      ? `Its attachments alone are about ${count(attachments)} tokens.`
+      : 'The latest message and protected session context (system rules, tool definitions) are that large.';
+  const error = new Error(
+    `The latest message cannot fit this model (${LATEST_TURN_EXCEEDS_CONTEXT}): it needs about ` +
+      `${count(mandatoryCost)} tokens, but the ${window} window leaves ${count(budget)} for it. ${cause} ` +
+      'Shorten the message or move large pasted text into a file the model can read. ' +
+      `A larger context window helps only if it holds ${count(mandatoryCost)} tokens plus room for the answer.`
+  );
+  error.code = LATEST_TURN_EXCEEDS_CONTEXT;
+  throw error;
+}
+
+// The source with the latest request's attachments sent by reference. Same
+// source when it carries none.
+function withLatestAttachmentsReferenced(source) {
+  const latest = latestActualUserInstructionIndex(source.live);
+  if (latest < 0 || !messageHasReferencableMedia(source.live[latest])) return source;
+  const live = source.live.slice();
+  live[latest] = referenceMessageMedia(live[latest]);
+  return { ...source, live };
 }
 
 function assertHandoffFits(summaryMessage, room) {
@@ -584,14 +720,26 @@ export function freshContextCompactMessages(messages, budgetTokens, opts = {}) {
     });
   }
 
-  const source = splitFreshSource(baseSanitized);
-  const { handoffText, summaryMessage, tail, stableHead, mandatory, mandatoryCost } = freshContextLayout(
-    source,
-    budgetTokens,
-    opts
-  );
-  const budget = freshContextBudget({ targetBudget, budgetTokens, mandatoryCost, summaryMessage, opts });
-  assertMandatoryFits(budget, mandatoryCost, summaryMessage, opts.contextWindow);
+  let source = splitFreshSource(baseSanitized);
+  let layout = freshContextLayout(source, budgetTokens, opts);
+  let budget = freshContextBudget({ targetBudget, budgetTokens, ...layout, opts });
+  // The latest request is mandatory and kept verbatim — except its
+  // attachments: when they are what does not fit (or the provider already
+  // refused this request as too long), they travel by reference instead of
+  // failing the turn, and every later turn, forever.
+  if (
+    opts.referenceLatestAttachments === true ||
+    mandatoryOverflows(budget, layout.mandatoryCost, layout.summaryMessage)
+  ) {
+    const referenced = withLatestAttachmentsReferenced(source);
+    if (referenced !== source) {
+      source = referenced;
+      layout = freshContextLayout(source, budgetTokens, opts);
+      budget = freshContextBudget({ targetBudget, budgetTokens, ...layout, opts });
+    }
+  }
+  const { handoffText, summaryMessage, tail, stableHead, mandatory, mandatoryCost } = layout;
+  assertMandatoryFits(budget, mandatoryCost, summaryMessage, opts.contextWindow, tail.latestUser);
   const handoff = handoffRoomFor(budget, mandatoryCost, opts);
   const summaryContent = String(summaryMessage?.content || '');
   assertHandoffFits(summaryMessage, handoff.room);

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

@@ -0,0 +1,16 @@
+// compaction.summaryMode — which model writes a compaction summary
+// (loop/fresh-context.mjs compactionSummaryPlan):
+//   smart       warm prompt cache: fork the conversation's own cached request;
+//               cold: the Maintainer, else the subscription provider's lighter
+//               model, else the conversation's own model (isolated)
+//   maintainer  the Maintainer (isolated), else the conversation's own model
+//   self        the conversation's own model: fork when warm, isolated when cold
+export const COMPACTION_SUMMARY_MODES = Object.freeze(['smart', 'maintainer', 'self']);
+
+/** The saved mode; the previous release's boolean `useMaintainer:false`
+ *  reads as 'self', true or absent as the 'smart' default. */
+export function normalizeCompactionSummaryMode(compaction) {
+  const mode = compaction?.summaryMode;
+  if (COMPACTION_SUMMARY_MODES.includes(mode)) return mode;
+  return compaction?.useMaintainer === false ? 'self' : 'smart';
+}

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

@@ -0,0 +1,87 @@
+// What the compaction summary route choice reads: whether the session's
+// prompt cache is still warm (a fork of its last request would read it), and
+// the lighter model of a subscription provider.
+import { cacheCapabilityForProvider, providerTailCacheLifetimeMs } from '../../agent-runtime/cache-strategy.mjs';
+import { getModelMetadataSync } from '../../../../shared/llm/model-catalog.mjs';
+import {
+  _compareVersion as compareAnthropicVersion,
+  _loadModelCache as loadAnthropicCatalogCache,
+} from '../../providers/anthropic-model-resolve.mjs';
+import { gptVersion } from '../../providers/openai-model-capabilities.mjs';
+import { loadSavedCodexCatalog } from '../../providers/openai-oauth-catalog-store.mjs';
+import { compactionForkRequest } from '../side-question-store.mjs';
+
+// A provider outside the Anthropic/OpenAI lifetimes whose catalog marks prompt
+// caching: the shortest common cache lifetime (Gemini's default TTL).
+const CATALOG_PROMPT_CACHE_LIFETIME_MS = 5 * 60_000;
+// The cache is read when the fork is sent, after the route choice: a request
+// this close to its lifetime counts as cold.
+const WARM_MARGIN_MIN_MS = 30_000;
+const WARM_MARGIN_RATIO = 0.1;
+
+/** How long the cache a saved request wrote or read stays readable, in ms:
+ *  Infinity when it does not expire (openai-oauth), 0 when it is not cached.
+ *  Anthropic: the request's message-tail tier (5m / 1h); OpenAI: the 30m tail
+ *  that holds the conversation (the Lead's 12h breakpoint covers only the
+ *  stable tools/instructions prefix). */
+function requestCacheLifetimeMs(request) {
+  const name = request?.provider?.name;
+  if (name === 'openai-oauth') return Infinity;
+  if (name === 'openai' || cacheCapabilityForProvider(name) === 'explicit-breakpoint') {
+    return providerTailCacheLifetimeMs(name, request.opts?.cacheStrategy) ?? 0;
+  }
+  const info = request.provider.getCachedModelInfo?.(request.model) || getModelMetadataSync(request.model, name);
+  return info?.supportsPromptCaching ? CATALOG_PROMPT_CACHE_LIFETIME_MS : 0;
+}
+
+/** Whether the session's last settled request is still inside the cache
+ *  lifetime it used, with a safety margin. No forkable request = cold. */
+export function compactionCacheWarm(sessionId, now = Date.now()) {
+  const request = compactionForkRequest(sessionId);
+  if (!request) return false;
+  const lifetime = requestCacheLifetimeMs(request);
+  if (lifetime === Infinity) return true;
+  const margin = Math.max(WARM_MARGIN_MIN_MS, lifetime * WARM_MARGIN_RATIO);
+  return now - Number(request.sentAt) < lifetime - margin;
+}
+
+function compareGptVersion(a, b) {
+  const [aMajor, aMinor] = gptVersion(a);
+  const [bMajor, bMinor] = gptVersion(b);
+  // Same version: the undated alias over a dated snapshot.
+  return aMajor - bMajor || aMinor - bMinor || b.length - a.length;
+}
+
+// The lighter family per subscription provider: its newest catalog model.
+// API-key providers bill per token and get no lighter step. `catalog` reads
+// the provider's saved catalog only (disk cache, no auth or network on the
+// compaction path): Anthropic's within its 24h TTL, Codex's stale or not.
+const LIGHTER_FAMILY = Object.freeze({
+  'anthropic-oauth': {
+    catalog: loadAnthropicCatalogCache,
+    matches: (row) => row.family === 'haiku',
+    compare: compareAnthropicVersion,
+  },
+  'openai-oauth': {
+    catalog: loadSavedCodexCatalog,
+    matches: (row, id) => id.includes('-luna') && gptVersion(id) !== null,
+    compare: compareGptVersion,
+  },
+});
+
+/** The newest lighter-family model the saved catalog of `providerName` lists
+ *  for this account, or null (not a subscription provider, no saved catalog,
+ *  none listed). */
+export async function lighterSubscriptionModel(providerName) {
+  const family = LIGHTER_FAMILY[providerName];
+  if (!family) return null;
+  const catalog = await family.catalog();
+  if (!Array.isArray(catalog)) return null;
+  let best = null;
+  for (const row of catalog) {
+    const id = String(row?.id || '');
+    if (!id || !family.matches(row, id)) continue;
+    if (!best || family.compare(id, best) > 0) best = id;
+  }
+  return best;
+}

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

@@ -59,6 +59,8 @@ Rules:
 - Use terse bullets, not prose paragraphs.
 - Preserve exact file paths, commands, error strings, and identifiers when known.
 - Use the same language as the active user thread when it is clear.
+- Record work as Done or In Progress only when a tool call and its result in the history show it (an agent spawn/send result, an edit, a command outcome). An assistant's stated intent with no matching tool call is not started: list it under Next Steps as "announced, not started".
+- Attribute every decision, answer, and version/choice to its source: the user (message or ask_user answer), a named agent's report, or the assistant. Never credit an agent or the assistant with a user's answer.
 - 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