mixdog 1.4.0 → 1.4.1

package/src/runtime/agent/orchestrator/session/cache-warm.mjs

@@ -366,7 +366,9 @@ let deps = DEFAULT_DEPS;
 
 // The idle auto-clear measures idleness from the last cache use, a
 // successful warm included (durable in the touch store).
-setCacheWarmUseSource((sessionId) => (sessionId ? deps.touches().lastWarmUse(sessionId) : 0));
+// The record names the route and account the warm read, so only a request
+// on that same prefix counts it as fresh cache (compact-policy.mjs).
+setCacheWarmUseSource((sessionId) => (sessionId ? deps.touches().warmUse(sessionId) : null));
 
 // A session deleted for good drops everything it learned and touched.
 registerSessionPurgeHook((sessionId) => {
@@ -787,6 +789,10 @@ async function fireWarm(sessionId, chain) {
   chain.latencyMs = (reportedAt ?? deps.now()) - sentAt;
   recordTouch(sessionId, chain);
   // A read without a write is cache use: the idle auto-clear counts from it.
-  deps.touches().recordWarmUse(sessionId, sentAt);
+  deps.touches().recordWarmUse(sessionId, sentAt, {
+    provider: chain.request.provider.name,
+    model: chain.request.model,
+    accountId: target.accountId,
+  });
   scheduleWarm(sessionId, chain);
 }

package/src/runtime/agent/orchestrator/session/catalog-db/schema.mjs

@@ -11,7 +11,7 @@ import { createHash } from 'node:crypto';
 
 /** Bumped whenever the table layout or a codec changes: the DB is then
  *  dropped and backfilled again from the JSON catalog. */
-export const SCHEMA_VERSION = 10;
+export const SCHEMA_VERSION = 11;
 /** PRAGMA application_id ('MXSC'): a file without it is not this catalog. */
 export const APPLICATION_ID = 0x4d585343;
 
@@ -68,6 +68,9 @@ const FIELDS = [
   // Places of the incoming messages with text among the counted ones, for the
   // unread count of a bot home / room log; absent otherwise (schema 10).
   ['incomingTail', 'incoming_tail', 'optjson'],
+  // Compactions the session has had: the epoch of its message numbering;
+  // absent for a row written before schema 11.
+  ['compactCount', 'compact_count', 'optjson'],
 ];
 
 const COLUMN_TYPES = { text: 'TEXT', real: 'REAL', int: 'INTEGER', bool: 'INTEGER', json: 'TEXT', optjson: 'TEXT' };

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

@@ -9,6 +9,7 @@ import {
   isProtectedContextAckMessage,
   latestActualUserInstructionIndex,
   pendingTaskNotificationIndexes,
+  requestStart,
 } from './messages.mjs';
 import { staleObservations, supersedeObservation } from './observation-supersession.mjs';
 import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
@@ -101,14 +102,6 @@ export function executionTokens(messages) {
   );
 }
 
-function requestStart(messages, index) {
-  for (let i = index; i >= 0; i -= 1) {
-    if (!isActualUserInstructionMessage(messages[i])) continue;
-    if (messages[i]?.meta?.source !== 'steering') return i;
-  }
-  return latestActualUserInstructionIndex(messages.slice(0, index + 1));
-}
-
 // Each assistant tool-call turn with the tool results that directly follow it.
 function executionGroups(messages) {
   const groups = [];

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

@@ -43,6 +43,29 @@ export function latestActualUserInstructionIndex(messages) {
   return -1;
 }
 
+// The user instruction that began the request `index` belongs to; a steering
+// message continues the request instead of starting one.
+export function requestStart(messages, index) {
+  for (let i = index; i >= 0; i -= 1) {
+    if (!isActualUserInstructionMessage(messages[i])) continue;
+    if (messages[i]?.meta?.source !== 'steering') return i;
+  }
+  return latestActualUserInstructionIndex(messages.slice(0, index + 1));
+}
+
+// A tool call's arguments as an object, whether stored parsed or as JSON text.
+export function callArguments(call) {
+  let args = call?.arguments;
+  if (typeof args === 'string') {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return {};
+    }
+  }
+  return args && typeof args === 'object' ? args : {};
+}
+
 export function latestActualUserInstructionMessage(messages) {
   const index = latestActualUserInstructionIndex(messages);
   return index >= 0 ? { ...messages[index] } : null;

package/src/runtime/agent/orchestrator/session/compact/observation-supersession.mjs

@@ -1,9 +1,12 @@
-// Observations that a later one of the same browser page or desktop window
-// replaced. Such a result's refs have expired, and its element list and pixels
-// describe a state that no longer exists. Only compaction drops them: between
-// compactions the transcript stays append-only so the provider cache prefix
-// holds, and compaction rewrites that prefix anyway. The execution archive
-// keeps every original.
+// Observations that a later one of the same browser page, desktop window,
+// visualize tab (inspect / check) or image file replaced. Such a result's refs
+// have expired, and its element list and pixels describe a state that no
+// longer exists. Only compaction drops them: between compactions the
+// transcript stays append-only so the provider cache prefix holds, and
+// compaction rewrites that prefix anyway. The execution archive keeps every
+// original.
+import { callArguments, requestStart } from './messages.mjs';
+
 const BROWSER_TOOLS = new Set(['browser', 'browser_devtools']);
 const SNAPSHOT_LINE = /(?:^|\n)Snapshot:\s+((p\d+)-s\d+)\b/;
 const TERMINAL_LINE = /(?:^|\n)Terminal:\s+(session-terminal:\S+)/;
@@ -52,13 +55,40 @@ function containsRun(newer, older) {
   return false;
 }
 
-// What one tool result observed, keyed by the page or window it describes.
-function observationOf(message, toolName) {
+const VISUALIZE_READS = new Set(['inspect', 'check']);
+const IMAGE_FILE = /\.(?:png|jpe?g|gif|webp)$/i;
+// What a superseded computer frame keeps besides its reference.
+const FRAME_OUTCOME_KEYS = ['ok', 'action', 'actions', 'status', 'error', 'window_id'];
+
+// A visualize read-out is the same observation only for the same tab, kind of
+// read, viewport and scope: a mobile inspect does not replace a desktop one.
+function visualizeKey(args) {
+  const input = args.input && typeof args.input === 'object' ? args.input : {};
+  if (!VISUALIZE_READS.has(args.action) || typeof input.tab !== 'string' || !input.tab) return null;
+  const scope = args.action === 'inspect' ? `:${JSON.stringify(input.viewport ?? null)}:${input.selector ?? ''}` : '';
+  return { key: `visualize:${args.action}:${input.tab}${scope}`, action: args.action, tab: input.tab };
+}
+
+// What one tool result observed, keyed by the page, window, tab or file it
+// describes.
+function observationOf(message, call) {
   if (message?.role !== 'tool' || message.toolKind === 'error') return null;
+  const toolName = String(call?.name || '');
   const parts = contentParts(message.content);
+  if (toolName === 'read') {
+    const args = callArguments(call);
+    const path = typeof args.path === 'string' ? args.path : args.file_path;
+    if (typeof path !== 'string' || !IMAGE_FILE.test(path) || !parts.some(isImagePart)) return null;
+    return { key: `image:${path.replace(/\\/g, '/')}`, imagePath: path, requestScoped: true };
+  }
   const textIndex = parts.findIndex((part) => part?.type === 'text' && !isImagePart(part));
   if (textIndex < 0) return null;
   const text = String(parts[textIndex].text);
+  if (toolName === 'visualize') {
+    if (/^\[Visualize \w+ of tab \S+ superseded:/.test(text)) return null;
+    const read = visualizeKey(callArguments(call));
+    return read ? { key: read.key, parts, textIndex, visualize: read, requestScoped: true } : null;
+  }
   if (BROWSER_TOOLS.has(toolName)) {
     const snapshot = SNAPSHOT_LINE.exec(text);
     return snapshot ? { key: `browser:${snapshot[2]}`, parts, textIndex, text, snapshot } : null;
@@ -82,40 +112,90 @@ function observationOf(message, toolName) {
   const frame = value?.observation && typeof value.observation === 'object' ? value.observation : value;
   const windowId = frame?.window_id || value?.window_id;
   const observed = Array.isArray(frame?.elements) || frame?.ocr !== undefined || parts.some(isImagePart);
-  return windowId && observed ? { key: `computer:${windowId}`, parts, textIndex, value, frame } : null;
+  if (windowId && observed) return { key: `computer:${windowId}`, parts, textIndex, value, frame };
+  // A stub an earlier compaction wrote in the fuller format.
+  const slim =
+    typeof frame?.superseded === 'string' &&
+    Object.keys(frame).some((name) => name !== 'superseded' && !FRAME_OUTCOME_KEYS.includes(name));
+  return slim ? { stub: true, parts, textIndex, value, frame, reference: frame.superseded } : null;
 }
 
-/** Tool results that a later observation of the same page or window
- *  replaced, keyed by transcript index. */
+// Transcript indices whose results are still in use and must stay verbatim:
+// the latest tool-call group (the batch the session continues from, which
+// compaction always retains) and any group with a call that has no result yet.
+function protectedObservationIndices(messages) {
+  const protectedIndices = new Set();
+  const protect = (from, to) => {
+    for (let index = from; index < to; index += 1) protectedIndices.add(index);
+  };
+  let latest = null;
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message?.role !== 'assistant' || !message.toolCalls?.length) continue;
+    const start = index;
+    const answered = new Set();
+    while (messages[index + 1]?.role === 'tool') {
+      index += 1;
+      answered.add(messages[index].toolCallId);
+    }
+    latest = [start, index + 1];
+    if (message.toolCalls.some((call) => !answered.has(call?.id))) protect(...latest);
+  }
+  if (latest) protect(...latest);
+  return protectedIndices;
+}
+
+/** Tool results that a later observation of the same page, window, tab or
+ *  file replaced, keyed by transcript index. Protected results are never
+ *  listed, though they still count as the newer observation of what they
+ *  describe. An image file read or visualize read-out is also kept for the
+ *  whole active request (everything since the last user instruction), since
+ *  the request may compare it with a later one; once a newer user message
+ *  exists it is replaceable. */
 export function staleObservations(messages) {
-  const toolNames = new Map();
+  const protectedIndices = protectedObservationIndices(messages);
+  const activeRequest = Math.max(requestStart(messages, messages.length - 1), 0);
+  const calls = new Map();
   for (const message of messages) {
     if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
-    for (const call of message.toolCalls) if (call?.id) toolNames.set(call.id, String(call.name || ''));
+    for (const call of message.toolCalls) if (call?.id) calls.set(call.id, call);
   }
   const newest = new Set();
   const terminalReads = new Map();
   const stale = new Map();
   for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const found = observationOf(messages[index], toolNames.get(messages[index]?.toolCallId));
+    const found = observationOf(messages[index], calls.get(messages[index]?.toolCallId));
     if (!found) continue;
-    if (found.body) {
+    const replaceable = !protectedIndices.has(index) && !(found.requestScoped && index >= activeRequest);
+    if (found.stub) {
+      if (replaceable) stale.set(index, found);
+    } else if (found.body) {
       const newer = terminalReads.get(found.key) ?? [];
-      if (newer.some((body) => containsRun(body, found.body))) stale.set(index, found);
+      if (replaceable && newer.some((body) => containsRun(body, found.body))) stale.set(index, found);
       newer.push(found.body);
       terminalReads.set(found.key, newer);
-    } else if (newest.has(found.key)) stale.set(index, found);
-    else newest.add(found.key);
+    } else if (newest.has(found.key)) {
+      if (replaceable) stale.set(index, found);
+    } else newest.add(found.key);
   }
   return stale;
 }
 
 /** The result without its replaced observation. A browser result keeps what
  *  precedes its snapshot (effect notes, a script's value) and a computer
- *  result its action outcome; neither keeps elements, OCR text or pixels. */
+ *  result its action outcome plus a reference; none keeps elements, OCR text,
+ *  frame metadata or pixels. A visualize read-out or image file read becomes a
+ *  one-line placeholder naming what it was and how to get it again. */
 export function supersedeObservation(message, found, origin) {
   let text;
-  if (found.terminal) {
+  if (found.imagePath) {
+    text = `[Image read of ${found.imagePath} superseded: a newer read of this file follows. Read the file again to view it. ${origin}]`;
+    return { ...message, content: withParts(message.content, [{ type: 'text', text }]) };
+  }
+  if (found.visualize) {
+    const { action, tab } = found.visualize;
+    text = `[Visualize ${action} of tab ${tab} superseded: a newer ${action} of this tab follows. Run visualize ${action} on the tab again to get it. ${origin}]`;
+  } else if (found.terminal) {
     text = `[Terminal ${found.terminal} read superseded: a newer read of this tab follows. ${origin}]`;
   } else if (found.snapshot) {
     const { snapshot } = found;
@@ -126,9 +206,9 @@ export function supersedeObservation(message, found, origin) {
     const note = `[Snapshot ${snapshot[1]} superseded: a newer snapshot of this page follows. ${origin}]`;
     text = before ? `${before}\n\n${note}` : note;
   } else {
-    const frame = { ...found.frame, superseded: `a newer observation of this window follows. ${origin}` };
-    delete frame.elements;
-    delete frame.ocr;
+    const frame = {};
+    for (const name of FRAME_OUTCOME_KEYS) if (found.frame[name] !== undefined) frame[name] = found.frame[name];
+    frame.superseded = found.reference ?? `a newer observation of this window follows. ${origin}`;
     text = JSON.stringify(found.frame === found.value ? frame : { ...found.value, observation: frame });
   }
   const parts = found.parts.flatMap((part, index) => {

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

@@ -12,6 +12,7 @@ import {
   textByteLength,
 } from './text-utils.mjs';
 import {
+  callArguments,
   contextAckMessage,
   isCompactConversationRow,
   isProtectedContextAckMessage,
@@ -25,6 +26,7 @@ import { activeTurnContinuationMessage } from './continuation.mjs';
 import { EXECUTION_RECOVERY_SOURCE, buildExecutionTail } from './execution-tail.mjs';
 import { latestSkillBodies, skillMessageText } from '../../context/skill-state.mjs';
 import { effectiveBudget } from './budget.mjs';
+import { parseMcpToolName } from '../../../../shared/tool-primitives.mjs';
 import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user-context.mjs';
 import { carryMessageId, messageIdOf } from '../message-ids.mjs';
 import { normalizeIngestRole, shouldExcludeIngestMessage } from '../../../../memory/lib/session-ingest.mjs';
@@ -70,12 +72,23 @@ function splitFreshSource(messages) {
       break;
     }
   }
+  // Where the previous Compact's skill-use window opens: `live` index after
+  // the history it kept (see SKILL_WINDOW_SOURCE). Without a marker the whole
+  // transcript is the window.
+  const isKept = (message) => !isSummaryMessage(message) && message?.meta?.source !== SKILL_WINDOW_SOURCE;
+  const markerAt = conversation.findLastIndex((message) => message?.meta?.source === SKILL_WINDOW_SOURCE);
+  const span = conversation[markerAt]?.meta?.span;
+  const skillWindowStart =
+    markerAt >= 0 && Number.isInteger(span) && span >= 0
+      ? conversation.slice(0, markerAt).filter(isKept).length + span
+      : 0;
   const latestUserIndex = latestActualUserInstructionIndex(conversation);
   return {
     protectedPrefix,
     previousSummary: previousSummaryMessage?.content || null,
     previousSummaryMessage,
     previousAck,
+    skillWindowStart,
     // 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.
@@ -86,7 +99,7 @@ function splitFreshSource(messages) {
       .map((message, index) =>
         index === latestUserIndex ? message : referenceMessageMedia(stripRuntimeUserContext(message))
       )
-      .filter((message) => !isSummaryMessage(message)),
+      .filter(isKept),
     sanitized,
   };
 }
@@ -135,9 +148,11 @@ function toolCallSummaryLine(call, result) {
   // 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.
+  // An ask_user or handoff_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);
+    call.name === 'ask_user' || call.name === 'handoff_user'
+      ? outcome
+      : boundedSummaryText(outcome.replace(/\s+/g, ' '), SUMMARY_TOOL_OUTCOME_CHARS);
   return `[tool call] ${call.name}(${args}) → ${result ? shown || '(empty result)' : '(no result)'}`;
 }
 
@@ -564,44 +579,128 @@ function currentSkillBodyMessage(message, current) {
 
 const SKILL_RELOAD_SOURCE = 'compact-skill-reload';
 
-function skillReloadReminder(name) {
+// How many Compacts in a row a skill may go unused before even its reload
+// line is dropped: a skill untouched that long belongs to finished work, and
+// the model can still load it by name from the skill manifest.
+export const SKILL_RELOAD_MAX_IDLE = 3;
+
+const SKILL_TOOL_NAMES = new Set(['Skill', 'skill_view']);
+
+function skillReloadReminder(name, idle = 0) {
   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 },
+    content: `[mixdog-runtime] Skill "${name}" was active earlier, but Compact did not keep its instructions. Reload it with the Skill tool before relying on them.`,
+    meta: { source: SKILL_RELOAD_SOURCE, synthetic: true, skill: name, idle },
   };
 }
 
-// Restore the skills active in the transcript, each as the Skill tool would
-// deliver it now. `currentSkill(name)` (the caller's resolver) answers
-// `{ body, native, summary }` for a skill that still loads in the session, or null for
-// one switched off, outside its scope or removed: such a skill is restored
-// neither as a body nor as a reload reminder, since its instructions are no
-// longer in force. Without a resolver the transcript copies are kept.
+// Every Compact leaves this marker just ahead of the skills it restores, with
+// `span`: how many messages follow it (restored skills and retained tail).
+// All of them happened before that Compact, so the next one reads the skill
+// use window from after them, whether or not a summary exists. The marker is
+// not conversation: the next Compact removes it and writes a new one.
+const SKILL_WINDOW_SOURCE = 'compact-skill-window';
+
+function skillWindowMarker(span = 0) {
+  return {
+    role: 'user',
+    content: '[mixdog-runtime] Compact boundary.',
+    meta: { source: SKILL_WINDOW_SOURCE, synthetic: true, span },
+  };
+}
+
+// Restore the skills the session used since the previous Compact, each as the
+// Skill tool would deliver it now. A skill is used when it was loaded or one of
+// its linked tools ran in that window (`windowStart` onward); its linked
+// tools are the native tool references of its loader pair and, when the
+// resolver gives them, `tools`. `currentSkill(name)` (the caller's resolver)
+// answers `{ body, native, summary, tools? }` for a skill that still loads in
+// the session, or null for one switched off, outside its scope or removed:
+// such a skill is restored neither as a body nor as a reload line, since its
+// instructions are no longer in force. Without a resolver the transcript
+// copies are kept.
 // Never summarize/truncate operating instructions or displace the handoff
-// 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, currentSkill = null) {
+// and current task. Every other active skill, and a used one whose body does
+// not fit, is left as a one-line reload line. The line counts the Compacts
+// the skill went unused (`meta.idle`) and is dropped past SKILL_RELOAD_MAX_IDLE.
+// Reload lines are charged to the same budget: every possible line is
+// reserved before any body is restored, and restoring a body releases its own.
+function restoreSkillBodies(live, skillBudget, retainedTail, currentSkill = null, windowStart = 0) {
   const retainedCallIds = new Set(retainedTail.filter((m) => m?.role === 'tool').map((m) => m.toolCallId));
   const current = (name) => (currentSkill ? currentSkill(name) : undefined);
   const loads = (name) => current(name) !== null;
   const transcriptBodies = latestSkillBodies(live);
   const loaded = new Set(transcriptBodies.map((body) => body.name));
   const bodies = transcriptBodies.filter((body) => loads(body.name));
-  const reload = live
-    .filter((m) => m?.meta?.source === SKILL_RELOAD_SOURCE && !loaded.has(m.meta.skill) && loads(m.meta.skill))
-    .map((m) => m.meta.skill);
-  const reminderCost = (name) => estimateMessagesTokens([skillReloadReminder(name)]);
-  let reserved = [...new Set([...reload, ...bodies.map((body) => body.name)])].reduce(
-    (sum, name) => sum + reminderCost(name),
-    0
-  );
-  const dropped = [];
+  // Reload lines from earlier Compacts: skill -> Compacts it went unused.
+  const earlier = new Map();
+  for (const m of live) {
+    if (m?.meta?.source !== SKILL_RELOAD_SOURCE || loaded.has(m.meta.skill) || !loads(m.meta.skill)) continue;
+    earlier.delete(m.meta.skill);
+    earlier.set(m.meta.skill, Number.isFinite(m.meta.idle) ? m.meta.idle : 0);
+  }
+
+  // A loader pair can sit anywhere in the transcript (a restored body stays
+  // ahead of the retained tail's pair), so read them all.
+  const results = new Map(live.filter((m) => m?.role === 'tool').map((m) => [m.toolCallId, m]));
+  const loaderTools = new Map();
+  for (const message of live) {
+    for (const call of message?.role === 'assistant' ? message.toolCalls || [] : []) {
+      const references = results.get(call.id)?.nativeToolSearch?.toolReferences;
+      if (call.name !== 'Skill' || !references) continue;
+      const name = String(callArguments(call).name || '').trim();
+      loaderTools.set(name, [...(loaderTools.get(name) || []), ...references]);
+    }
+  }
+  const skillsOfTool = new Map();
+  for (const name of new Set([...earlier.keys(), ...bodies.map((body) => body.name)])) {
+    const skill = current(name);
+    const tools = [...(skill?.native?.toolReferences || []), ...(skill?.tools || []), ...(loaderTools.get(name) || [])];
+    for (const tool of tools) skillsOfTool.set(tool, (skillsOfTool.get(tool) || new Set()).add(name));
+  }
+  // Use since the previous Compact (from `windowStart`): the newest transcript
+  // position of a load or of a linked tool's call.
+  const lastUse = new Map();
+  const noteUse = (name, index) => lastUse.set(name, Math.max(lastUse.get(name) ?? -1, index));
+  live.forEach((message, index) => {
+    if (index < windowStart || message?.role !== 'assistant') return;
+    for (const call of message.toolCalls || []) {
+      const args = callArguments(call);
+      if (SKILL_TOOL_NAMES.has(call.name)) noteUse(String(args.name || '').trim(), index);
+      else {
+        const tool = call.name === 'call_tool' ? args.name : call.name;
+        const mcpServer = `mcp:${parseMcpToolName(tool)?.server}`;
+        for (const name of [...(skillsOfTool.get(tool) || []), ...(skillsOfTool.get(mcpServer) || [])]) {
+          noteUse(name, index);
+        }
+      }
+    }
+  });
+  for (const { name, message } of bodies) {
+    const index = live.lastIndexOf(message);
+    if (index >= windowStart) noteUse(name, index);
+  }
+
+  // Every active skill without a body ends as a reload line: an unused one
+  // ages by a Compact and goes once past the bound; one used (or whose body
+  // did not fit) starts over.
+  const reminders = new Map();
+  for (const [name, idle] of earlier) {
+    if (lastUse.has(name)) reminders.set(name, 0);
+    else if (idle < SKILL_RELOAD_MAX_IDLE) reminders.set(name, idle + 1);
+  }
+  const used = bodies.filter(({ name }) => lastUse.has(name)).sort((a, b) => lastUse.get(b.name) - lastUse.get(a.name));
+  const unused = bodies.filter(({ name }) => !lastUse.has(name));
+
+  const reminderCost = (name, idle = 0) => estimateMessagesTokens([skillReloadReminder(name, idle)]);
+  let reserved =
+    [...reminders].reduce((sum, [name, idle]) => sum + reminderCost(name, idle), 0) +
+    unused.reduce((sum, { name }) => sum + reminderCost(name, 1), 0) +
+    used.reduce((sum, { name }) => sum + reminderCost(name), 0);
+  const dropped = new Set();
   const restoredSkills = [];
   let skillTokens = 0;
-  for (const { name, message } of bodies.reverse()) {
+  for (const { name, message } of used) {
     const skill = current(name);
     const restored = [
       ...skillLoaderPair(live, live.lastIndexOf(message), name, retainedCallIds, skill),
@@ -610,24 +709,31 @@ function restoreSkillBodies(live, skillBudget, retainedTail, currentSkill = null
     const cost = estimateMessagesTokens(restored);
     const own = reminderCost(name);
     if (skillTokens + cost + reserved - own > skillBudget) {
-      dropped.unshift(name);
+      dropped.add(name);
       continue;
     }
     restoredSkills.unshift(...restored);
     skillTokens += cost;
     reserved -= own;
   }
-  // Newest skill first; only a budget too small for the reminders themselves
+  // In transcript order, after the lines of earlier Compacts.
+  for (const { name } of bodies) {
+    if (!lastUse.has(name)) reminders.set(name, 1);
+    else if (dropped.has(name)) reminders.set(name, 0);
+  }
+  // Newest skill first; only a budget too small for the lines themselves
   // leaves one out.
-  const pending = [...new Set([...reload, ...dropped])];
+  const pending = [...reminders];
   const reminded = new Set();
-  for (const name of pending.toReversed()) {
-    const cost = reminderCost(name);
+  for (const [name, idle] of pending.toReversed()) {
+    const cost = reminderCost(name, idle);
     if (skillTokens + cost > skillBudget) continue;
     reminded.add(name);
     skillTokens += cost;
   }
-  restoredSkills.push(...pending.filter((name) => reminded.has(name)).map(skillReloadReminder));
+  restoredSkills.push(
+    ...pending.filter(([name]) => reminded.has(name)).map(([name, idle]) => skillReloadReminder(name, idle))
+  );
   return { restoredSkills, skillTokens };
 }
 
@@ -864,15 +970,33 @@ export function freshContextCompactMessages(messages, budgetTokens, options = {}
   const summaryContent = String(summaryMessage?.content || '');
   assertHandoffFits(summaryMessage, handoff.room);
   const skillBudget = freshSkillBudget(targetBudget, budget, [...stableHead, ...tail.volatileTail]);
+  // Restored skills carry the window marker, which is charged to their budget.
+  const markerCost = estimateMessagesTokens([skillWindowMarker()]);
   const skills = {
-    ...restoreSkillBodies(source.live, skillBudget, tail.volatileTail, opts.currentSkill),
+    ...restoreSkillBodies(
+      source.live,
+      Math.max(0, skillBudget - markerCost),
+      tail.volatileTail,
+      opts.currentSkill,
+      source.skillWindowStart
+    ),
     skillBudget,
   };
-  const stablePrefixMessages = [...stableHead, ...skills.restoredSkills];
-  const result = rebaseCompactedEffortConfiguration(
+  // A session with no skill state has no use to window: no marker.
+  const marker = skills.restoredSkills.length ? [skillWindowMarker()] : [];
+  const stablePrefixMessages = [...stableHead, ...marker, ...skills.restoredSkills];
+  const compacted = rebaseCompactedEffortConfiguration(
     baseSanitized,
     reconcileDedupStubs(sanitizeToolPairs([...stablePrefixMessages, ...tail.volatileTail]))
   );
+  // The next Compact reads everything after the marker as history, not as use.
+  const markerAt = compacted.findLastIndex((message) => message?.meta?.source === SKILL_WINDOW_SOURCE);
+  const result =
+    markerAt < 0
+      ? compacted
+      : compacted.map((message, index) =>
+          index === markerAt ? skillWindowMarker(compacted.length - markerAt - 1) : message
+        );
   const finalTokens = estimateMessagesTokens(result);
   if (finalTokens > budget) {
     throw new Error(`freshContextCompactMessages: compacted result exceeds budget=${budget} (result=${finalTokens})`);

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -581,8 +581,20 @@ function reasoningBreakdown(message, fullTextTokens) {
       };
     }
   }
+  // Price each reasoning item that is actually sent (a non-empty replay
+  // replaces content) at its own cost; the whole-minus-visible difference only
+  // caps the sum so the rows never exceed the total.
+  const sent = message.providerReplay?.items?.length ? message.providerReplay.items.filter(isReasoningBlock) : blocks;
   return {
-    tokens: blocks.length ? Math.max(0, fullTextTokens() - messageTextTokens(visible)) : 0,
+    tokens: blocks.length
+      ? Math.max(
+          0,
+          Math.min(
+            sent.reduce((sum, block) => sum + estimateTokens(nativeBlocksEstimateText(block)), 0),
+            fullTextTokens() - messageTextTokens(visible)
+          )
+        )
+      : 0,
     blocks,
     message: visible,
   };