mixdog 1.3.5 → 1.4.1

package/src/runtime/agent/orchestrator/session/conversation-import/convert.mjs

@@ -6,7 +6,13 @@
  */
 import { createClaudeReducer } from './claude.mjs';
 import { createCodexReducer } from './codex.mjs';
-import { IMPORT_WARNING_MALFORMED, conversationTitle, normalizeTurns } from './turns.mjs';
+import {
+  IMPORT_ERROR_INTERNAL,
+  IMPORT_WARNING_HISTORY_PARTIAL,
+  IMPORT_WARNING_MALFORMED,
+  conversationTitle,
+  normalizeTurns,
+} from './turns.mjs';
 
 export const IMPORT_SOURCES = Object.freeze(['codex', 'claude']);
 /** A line or converted transcript beyond the import limits fails the file. */
@@ -35,7 +41,9 @@ const transcriptChars = (turns) => turns.reduce((total, turn) => total + turn.te
  * (an over-long line or file). `result()` may be called repeatedly and also
  * holds the normalized turns to `maxTranscriptChars`.
  * `errorCode` is null for an importable result, else one of `empty` |
- * `malformed` | `unsupported` | `tooLarge` (whose turns are not returned).
+ * `malformed` | `unsupported` | `internalRecord` (the source app's own
+ * subagent/review record; `internalKind` names it) | `tooLarge` (whose turns
+ * are not returned).
  */
 export function createConversationConverter(
   source,
@@ -47,18 +55,37 @@ export function createConversationConverter(
 ) {
   if (!isImportSource(source)) throw new TypeError('source must be codex or claude.');
   const reducer = source === 'codex' ? createCodexReducer() : createClaudeReducer();
-  let lines = 0;
   let records = 0;
   let malformed = 0;
   let tooLarge = false;
+  let historyPartial = false;
   return {
+    /** True while every message seen so far is a Claude sidechain message. */
+    get sidechainOnly() {
+      return reducer.sidechainOnly === true;
+    },
     markTooLarge() {
       tooLarge = true;
     },
-    pushLine(raw) {
+    /** A history base could not be followed in full. */
+    markHistoryPartial() {
+      historyPartial = true;
+    },
+    /** Feed a line for the stored title only (Claude Code's tail window); other sources ignore it. */
+    pushTitleLine(raw) {
+      let value;
+      try {
+        value = JSON.parse(String(raw).trim());
+      } catch {
+        return;
+      }
+      if (value && typeof value === 'object') reducer.pushTitle?.(value);
+    },
+    /** `inherited` lines belong to a history base followed ahead of this file's own lines. */
+    pushLine(raw, { inherited = false } = {}) {
       if (tooLarge) return false;
       let line = String(raw);
-      if (lines++ === 0 && line.charCodeAt(0) === 0xfeff) line = line.slice(1);
+      if (line.charCodeAt(0) === 0xfeff) line = line.slice(1);
       if (line.endsWith('\r')) line = line.slice(0, -1);
       if (!line.trim()) return true;
       let value;
@@ -73,7 +100,7 @@ export function createConversationConverter(
         return true;
       }
       records += 1;
-      reducer.push(value);
+      reducer.push(value, inherited);
       if (
         reducer.chars > maxTranscriptChars ||
         reducer.entries > maxRetainedEntries ||
@@ -90,8 +117,10 @@ export function createConversationConverter(
       if (transcriptChars(turns) > maxTranscriptChars) tooLarge = true;
       const warnings = new Set(parsed.warnings);
       if (malformed) warnings.add(IMPORT_WARNING_MALFORMED);
+      if (historyPartial) warnings.add(IMPORT_WARNING_HISTORY_PARTIAL);
       let errorCode = null;
       if (tooLarge) errorCode = IMPORT_ERROR_TOO_LARGE;
+      else if (parsed.internalKind) errorCode = IMPORT_ERROR_INTERNAL;
       else if (!records) errorCode = malformed ? 'malformed' : 'empty';
       else if (!parsed.recognized) errorCode = 'unsupported';
       else if (!turns.length) errorCode = 'empty';
@@ -100,8 +129,10 @@ export function createConversationConverter(
         errorCode,
         foreignSessionId: parsed.foreignSessionId,
         cwd: parsed.cwd,
+        internalKind: parsed.internalKind,
+        historyBase: parsed.historyBase ?? null,
         turns: tooLarge ? [] : turns,
-        title: conversationTitle(turns),
+        title: parsed.storedTitle || conversationTitle(turns),
         messageCount: tooLarge ? 0 : turns.length,
         warnings: [...warnings],
       };

package/src/runtime/agent/orchestrator/session/conversation-import/imported-session.mjs

@@ -70,6 +70,9 @@ export function importedTranscriptMessages(turns, importedAt) {
     content: turn.text,
     meta: {
       source: IMPORTED_MESSAGE_SOURCE,
+      // Where the text holds a run of tool use, and which tools: the desktop
+      // draws each run as a native activity row.
+      ...(turn.toolRuns?.length ? { importedToolRuns: turn.toolRuns } : {}),
       transcript: { messageId: newTranscriptMessageId(), at: turn.at || importedAt },
     },
   }));

package/src/runtime/agent/orchestrator/session/conversation-import/turns.mjs

@@ -9,6 +9,11 @@
 export const IMPORT_WARNING_IMAGE_OMITTED = 'imageOmitted';
 export const IMPORT_WARNING_MALFORMED = 'malformed';
 export const IMPORT_WARNING_CWD_MISSING = 'cwdMissing';
+/** The conversation continues a history stored in another file that was not followed. */
+export const IMPORT_WARNING_HISTORY_PARTIAL = 'historyPartial';
+
+/** Failure code of a record the source app writes for its own use (not a conversation). */
+export const IMPORT_ERROR_INTERNAL = 'internalRecord';
 
 /** Stands in for an image the importer does not carry over. */
 export const IMAGE_OMITTED_TEXT = '[image omitted]';
@@ -17,12 +22,49 @@ export const IMPORTED_USER_STUB_TEXT = '[Imported conversation continues from an
 
 const TITLE_MAX_CHARS = 100;
 
-/** Plain-text note for a tool call: its name only, never its arguments. */
+/** Note for a tool call: its name only, never its arguments. A run of notes
+ *  becomes one compact line in the text and one structured entry in `toolRuns`. */
 export function toolNote(name) {
-  const clean = String(name || '')
-    .replace(/\s+/g, ' ')
-    .trim();
-  return { text: `[ran tool: ${clean || 'unknown'}]`, note: true };
+  const clean =
+    String(name || '')
+      .replace(/\s+/g, ' ')
+      .trim() || 'unknown';
+  return { text: `[ran tool: ${clean}]`, note: true, tool: clean };
+}
+
+/** Longest model-facing run line, and the longest tool name shown in it. */
+export const TOOL_RUN_LINE_MAX_CHARS = 400;
+const TOOL_RUN_NAME_MAX_CHARS = 40;
+
+/**
+ * Model-facing line for one run of tool notes: `[ran tools: shell ×6, Read ×2]`.
+ * Bounded: names are clipped, and tools that do not fit are counted as
+ * `, +N more`. Deterministic in `tools`, so a stored line can be re-derived.
+ */
+export function toolRunLine(tools) {
+  const entries = tools.map(({ name, count }) => {
+    const chars = Array.from(String(name));
+    const shown =
+      chars.length > TOOL_RUN_NAME_MAX_CHARS ? `${chars.slice(0, TOOL_RUN_NAME_MAX_CHARS - 1).join('')}…` : name;
+    return `${shown} ×${count}`;
+  });
+  const omittedSuffix = (omitted) => (omitted > 0 ? `, +${omitted} more` : '');
+  let body = '';
+  let shownCount = 0;
+  for (const entry of entries) {
+    const next = shownCount ? `${body}, ${entry}` : entry;
+    const length = `[ran tools: ${next}${omittedSuffix(entries.length - shownCount - 1)}]`.length;
+    if (shownCount && length > TOOL_RUN_LINE_MAX_CHARS) break;
+    body = next;
+    shownCount += 1;
+  }
+  return `[ran tools: ${body}${omittedSuffix(entries.length - shownCount)}]`;
+}
+
+function toolRunCounts(notes) {
+  const counts = new Map();
+  for (const note of notes) counts.set(note.tool, (counts.get(note.tool) || 0) + 1);
+  return [...counts].map(([name, count]) => ({ name, count }));
 }
 
 export function textPart(text) {
@@ -42,18 +84,31 @@ export function timestampMs(value) {
   return Number.isFinite(ms) && ms > 0 ? ms : null;
 }
 
-// Consecutive tool notes stay one per line; every other boundary is a blank line.
+// Each run of consecutive tool notes collapses into one compact line; every
+// boundary is a blank line. `toolRuns` locates those lines in `text`.
 function joinParts(parts) {
-  let text = '';
-  let previous = null;
+  const blocks = [];
   for (const part of parts) {
     const piece = String(part.text || '').trim();
     if (!piece) continue;
-    if (previous) text += previous.note && part.note ? '\n' : '\n\n';
-    text += piece;
-    previous = part;
+    const last = blocks[blocks.length - 1];
+    if (part.note && last?.notes) last.notes.push(part);
+    else blocks.push(part.note ? { notes: [part] } : { text: piece });
+  }
+  let text = '';
+  const toolRuns = [];
+  for (const block of blocks) {
+    if (text) text += '\n\n';
+    if (block.notes) {
+      const tools = toolRunCounts(block.notes);
+      const line = toolRunLine(tools);
+      toolRuns.push({ start: text.length, end: text.length + line.length, tools });
+      text += line;
+    } else {
+      text += block.text;
+    }
   }
-  return { text, last: previous };
+  return { text, toolRuns };
 }
 
 /**
@@ -72,9 +127,15 @@ export function normalizeTurns(rawTurns) {
     else merged.push({ role: raw.role, parts: [...parts], at: timestampMs(raw.at) });
   }
   const turns = merged.map(({ role, parts, at }) => {
-    const turn = { role, text: joinParts(parts).text, at };
-    // A carried-over compaction summary never names the conversation.
-    if (parts.some((part) => part.summary)) turn.titleText = joinParts(parts.filter((part) => !part.summary)).text;
+    const joined = joinParts(parts);
+    const turn = { role, text: joined.text, at };
+    if (joined.toolRuns.length) turn.toolRuns = joined.toolRuns;
+    // A carried-over compaction summary never names the conversation; a slash
+    // command only when no typed prompt does.
+    if (parts.some((part) => part.summary || part.command)) {
+      turn.titleText = joinParts(parts.filter((part) => !part.summary && !part.command)).text;
+    }
+    if (parts.some((part) => part.command)) turn.commandText = joinParts(parts.filter((part) => part.command)).text;
     return turn;
   });
   if (turns[0]?.role === 'assistant') {
@@ -83,19 +144,26 @@ export function normalizeTurns(rawTurns) {
   return turns;
 }
 
-const titleLines = (turn) =>
-  (turn.titleText ?? turn.text)
+const textLines = (text) =>
+  String(text ?? '')
     .split('\n')
     .map((value) => value.replace(/\s+/g, ' ').trim())
     .filter(Boolean);
 
+const titleLines = (turn) => textLines(turn.titleText ?? turn.text);
+
+/** First non-empty line of a title text, whitespace-normalized, ≤100 chars. */
+export function titleFromText(text) {
+  const line = textLines(text)[0];
+  if (!line) return null;
+  return Array.from(line).slice(0, TITLE_MAX_CHARS).join('').trim() || null;
+}
+
 /** First line of the first genuine user turn, whitespace-normalized, ≤100 chars
- *  (an image marker only when the turn has no text line). */
+ *  (an image marker only when the turn has no text line), else the first slash command. */
 export function conversationTitle(turns) {
   const first = turns.find((turn) => turn.role === 'user' && !turn.stub && titleLines(turn).length);
-  if (!first) return null;
+  if (!first) return titleFromText(turns.find((turn) => turn.role === 'user' && turn.commandText)?.commandText);
   const lines = titleLines(first);
-  const line = lines.find((value) => value !== IMAGE_OMITTED_TEXT) || lines[0];
-  if (!line) return null;
-  return Array.from(line).slice(0, TITLE_MAX_CHARS).join('').trim() || null;
+  return titleFromText(lines.find((value) => value !== IMAGE_OMITTED_TEXT) || lines[0]);
 }

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -24,6 +24,7 @@ export function createEagerDispatcher({
   getIterations,
   getNextIteration,
   repeatFailLimit,
+  isTurnLimitNoticed = () => false,
   executeToolFn = executeTool,
 }) {
   const pending = new Map();
@@ -56,7 +57,9 @@ export function createEagerDispatcher({
   const startEagerTool = (wireCall) => {
     // Streamed call_tool requests are admitted, ordered and executed as their
     // targets; a projection error is answered by the serial batch instead.
-    if (capped) return null;
+    // Once the turn was told to reply (any limit), no call runs: the batch
+    // refuses them, so none may start while the wrap-up response streams.
+    if (capped || isTurnLimitNoticed()) return null;
     const call = resolveExecutionToolCall(wireCall, sessionRef);
     if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
     const admitted = admission.admit(call);

package/src/runtime/agent/orchestrator/session/human-gate/gate.mjs

@@ -98,7 +98,8 @@ const LEAD_NAME = 'Lead';
  *  bot-created task session, a bot's home chat or room member session) and
  *  the names from there down to the asker ("Lead › Reviewer", "사무관 ›
  *  Worker"). Only where the card shows: no bot identity, grant or remember
- *  scope follows from it. Null for a top-level session. */
+ *  scope follows from it. Null for a top-level session (whose requests show
+ *  in the chats handing it work instead: tui/session/tool-approval.mjs). */
 export function approvalSurface(sessionId) {
   const delegation = delegationOf(sessionId);
   if (delegation.state !== 'resolved') return null;
@@ -156,7 +157,13 @@ async function describeEmails(call, outbound, ctx) {
     const { executeMcpTool } = await import('../../mcp/client.mjs');
     const ids = outbound.category === 'trash' && Array.isArray(call.args?.ids) ? call.args.ids.map(String) : [];
     const shown = ids.slice(0, PREVIEW_MESSAGES);
-    const raw = await executeMcpTool(name, { ids: shown }, { scopeId: ctx.mcpScopeId });
+    // The account the call acts as (one server holds every Gmail account).
+    const chosen = typeof call.args?.account === 'string' ? call.args.account.trim() : '';
+    const raw = await executeMcpTool(
+      name,
+      { ids: shown, ...(chosen ? { account: chosen } : {}) },
+      { scopeId: ctx.mcpScopeId }
+    );
     const { account, emails } = JSON.parse(raw);
     const messages = (Array.isArray(emails) ? emails : []).map((mail) =>
       [mail.from, mail.subject, String(mail.date || '').slice(0, 10)].filter(Boolean).join(' · ')
@@ -231,10 +238,9 @@ export async function humanGateDecision(call, decision, ctx = {}) {
       editable: outbound.editable,
       details: outbound.details,
     },
-    remember: ['once'],
+    // "Don't ask again" is the bot's permission.
+    remember: outboundRemember(outbound.category),
   };
-  // "Don't ask again" is the bot's permission.
-  request.remember = outboundRemember(outbound.category);
   const store = ctx.store || (await humanGateStore());
   const mode = await store.modeFor({ agentId, action: outbound.category });
   const base = decision && typeof decision === 'object' ? decision : {};

package/src/runtime/agent/orchestrator/session/human-gate/outbound-policy.mjs

@@ -74,8 +74,6 @@ const MCP_OUTBOUND = new Map([
     'slack_post_message',
     'slack_reply_to_thread',
     'chat_post_message',
-    'discord_send_message',
-    'telegram_send_message',
   ].map((name) => [name, 'message']),
   ...['create_post', 'publish_post', 'create_tweet', 'post_tweet', 'send_tweet'].map((name) => [name, 'publish']),
   ['submit_form', 'form'],

package/src/runtime/agent/orchestrator/session/human-gate/requests.mjs

@@ -12,10 +12,23 @@
 // the scopes it allows and can leave out `always`. Nothing here ever carries a
 // secret value: a decision that names one is stripped to its verdict.
 
-export const HUMAN_REQUEST_KINDS = Object.freeze(['approval', 'outbound', 'secret', 'takeover', 'permission']);
-export const HUMAN_RESPONSES = Object.freeze(['approve', 'deny', 'edit-and-approve', 'provide-secret', 'skip', 'done']);
-export const REMEMBER_SCOPES = Object.freeze(['once', 'agent', 'always']);
+const HUMAN_REQUEST_KINDS = Object.freeze(['approval', 'outbound', 'secret', 'takeover', 'permission']);
+const HUMAN_RESPONSES = Object.freeze(['approve', 'deny', 'edit-and-approve', 'provide-secret', 'skip', 'done']);
+const REMEMBER_SCOPES = Object.freeze(['once', 'agent', 'always']);
 export const SECRET_REQUEST_TIMEOUT_MS = 120_000;
+/** What a secret's bound field is: a sign-in form (아이디 + 비밀번호), a lone
+ *  password, a new password, or a one-time code; '' when unknown (computer). */
+export const SECRET_FORMS = Object.freeze(['login', 'password', 'new-password', 'otp']);
+/** Every result a secret handoff (and a declined or expired takeover) gives
+ *  the agent: facts, never a verdict about the site. */
+export const HANDOFF_OUTCOMES = Object.freeze([
+  'entered',
+  'user_skipped',
+  'no_field',
+  'page_changed',
+  'blocked',
+  'expired',
+]);
 
 const RESPONSES_BY_KIND = Object.freeze({
   approval: ['approve', 'deny'],
@@ -49,7 +62,7 @@ const text = (value, limit = TEXT_LIMIT) => (typeof value === 'string' ? value.t
 
 /** The human kind of a request; anything else (ask_user's 'question', a
  *  hook's bare ask) is an ordinary approval for responses. */
-export function humanRequestKind(request) {
+function humanRequestKind(request) {
   return HUMAN_REQUEST_KINDS.includes(request?.kind) ? request.kind : 'approval';
 }
 
@@ -103,11 +116,21 @@ export function humanRequestFields(input = {}) {
   }
   if (kind === 'secret') {
     const secret = isRecord(input.secret) ? input.secret : {};
+    // The bound page's origin and what its field is (the desktop read it at
+    // request time, ask-user-tool.mjs): the card's title and inputs; no value.
+    const origin = loginPageUrl(secret.origin)?.origin || '';
+    const form = SECRET_FORMS.includes(secret.form) ? secret.form : '';
+    // A code's length is the bound field's own (credential-autofill.ts
+    // codeLength); absent, it stays unspecified.
+    const length = Number.isInteger(secret.length) && secret.length > 0 ? secret.length : 0;
     fields.secret = {
       requestId: text(secret.requestId),
       surface: secret.surface === 'computer' ? 'computer' : 'browser',
       target: text(secret.target),
       field: text(secret.field),
+      ...(origin ? { origin } : {}),
+      ...(form ? { form } : {}),
+      ...(form === 'otp' && length ? { length } : {}),
     };
     fields.args = { surface: fields.secret.surface, target: fields.secret.target, field: fields.secret.field };
     fields.remember = ['once'];
@@ -132,12 +155,21 @@ export function humanRequestFields(input = {}) {
     // A login takeover (purpose 'login') opens the desktop's sign-in window on
     // its validated page instead of handing over the side panel.
     const login = surface === 'browser' && takeover.purpose === 'login' ? loginPageUrl(takeover.url) : null;
+    // The saved logins of the sign-in page's origin: opaque ids and masked
+    // labels only (profile-import.ts credentialSuggestions), never a password.
+    const accounts = (login && Array.isArray(takeover.accounts) ? takeover.accounts : [])
+      .filter((account) => isRecord(account) && token(account.id, 128) && text(account.label, 120))
+      .map((account) => ({ id: token(account.id, 128), label: text(account.label, 120) }));
+    // The page those logins may be filled into, bound by the desktop at
+    // request time (ask-user-tool.mjs fillId): without it none is offered.
+    const fillId = /^secret_[A-Za-z0-9-]{8,80}$/.test(text(takeover.fillId, 100)) ? text(takeover.fillId, 100) : '';
     fields.takeover = {
       surface,
       instructions: text(takeover.instructions, 2_000),
       ...(text(takeover.target) ? { target: text(takeover.target) } : {}),
       ...identity,
       ...(login ? { purpose: 'login', url: login.url, origin: login.origin } : {}),
+      ...(accounts.length && fillId ? { accounts, fillId } : {}),
     };
     fields.remember = ['once'];
   }

package/src/runtime/agent/orchestrator/session/human-gate/store.mjs

@@ -17,7 +17,7 @@ import { ACTION_KINDS, isRememberableAction } from './outbound-policy.mjs';
 const ANY_AGENT = '*';
 const FIELD_LIMIT = 200;
 const AUDIT_KEYS = ['agentId', 'kind', 'action', 'tool', 'target', 'decision', 'device'];
-const PERMISSION_MODES = Object.freeze(['ask', 'allow', 'block']);
+export const PERMISSION_MODES = Object.freeze(['ask', 'allow', 'block']);
 
 const field = (value) => String(value ?? '').slice(0, FIELD_LIMIT);
 const grantId = (agentId, action) =>

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -16,11 +16,15 @@ import { CONTEXT_SHARE_RATIO, COMPACT_TARGET_MIN_TOKENS, COMPACT_SAFETY_PERCENT
 import { HANDOFF_TIMEOUT_MAX_MS } from '../compact/constants.mjs';
 import { envFlag, envPositiveInt } from '../../../../shared/env.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
+import { cacheWarmUseFor, lastCacheWarmUseAt } from '../../../../shared/idle-auto-clear-gate.mjs';
+import { ACCOUNT_PROVIDERS } from '../../../../shared/provider-accounts.mjs';
+import { plannedAccountId } from '../../providers/account-pool.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { isAgentModeSession } from '../agent-mode.mjs';
 import { providerInputExcludesCache, providerNativePdf } from '../../providers/registry.mjs';
 import { contentMediaBytes, contentMediaCount } from '../../providers/media-normalization.mjs';
 import { splitProtectedContext } from '../compact/messages.mjs';
+import { withLiveCompactionConfig } from '../../runtime-core/compaction-config-keys.mjs';
 
 // Unified context-share rule (compact/constants.mjs CONTEXT_SHARE_RATIO): the
 // post-compaction target is 25% of the boundary/context window. One
@@ -394,13 +398,6 @@ export function invalidateProviderContextBaseline(sessionRef) {
   delete sessionRef.contextPressureUnanchoredReason;
 }
 
-// A baseline is refreshed on every provider_send/turn-end. When the transcript
-// has grown but no fresh recording landed for this long, recording is failing
-// (zero/absent usage keeps the OLD baseline because record() only returns
-// false) — distrust it and fall back to the estimate. An idle session whose
-// transcript did NOT grow keeps its baseline regardless of age.
-const BASELINE_MAX_STALE_GROWTH_MS = 30 * 60 * 1000;
-
 /**
  * Does this anchor still describe this message prefix?
  *
@@ -480,17 +477,19 @@ function providerBaselinePressureTokens(messages, sessionRef, policy, { includeC
         ? Math.max(0, tokens - Math.round(storedRequestReserve) + currentRequestReserve)
         : tokens + currentRequestReserve;
   }
-  // Staleness means a baseline that stopped being refreshed WHILE the session
-  // kept working — never age on the wall clock. Measured against `now`, this
-  // discarded the reading of every session that simply sat unopened for a
-  // while (88 of 983 stored sessions), and the whole-transcript estimate that
-  // replaced it was the less accurate number in both directions: 1.12x over
-  // on the median, 0.82x under on a session already past its window.
-  // Comparing against the session's own last activity keeps the rule aimed at
-  // its actual target — a live session whose usage recording is failing while
-  // its transcript grows — and leaves a session at rest on its measurement.
-  const activityAt = Math.max(Number(sessionRef.updatedAt) || 0, Number(sessionRef.lastContextTokensUpdatedAt) || 0);
-  if (messages.length > count && baselineAt > 0 && activityAt - baselineAt > BASELINE_MAX_STALE_GROWTH_MS) return null;
+  // Staleness means usage recording is failing: a provider request completed
+  // AFTER this reading without replacing it (every send records its usage
+  // after it starts, so a working recorder always leaves the reading newer
+  // than the last send) — zero/absent usage keeps the OLD baseline because
+  // record() only returns false. Never age on a clock: measured against `now`
+  // it discarded the reading of every session that sat unopened for a while
+  // (88 of 983 stored sessions), and measured against the session's last
+  // activity it discarded it whenever anything was appended more than half an
+  // hour after the last request — a user back from a break, an agent's result
+  // posted to a waiting Lead — so the next send compacted on the
+  // whole-transcript estimate, far above the provider's own count.
+  const lastSendAt = Number(sessionRef.lastProviderSendAt) || 0;
+  if (messages.length > count && baselineAt > 0 && lastSendAt > baselineAt) return null;
   try {
     // Baseline tokens are authoritative provider billing; only the growth
     // after the baseline is a local estimate and needs billing calibration.
@@ -707,13 +706,40 @@ export function shouldCompactForRequestMedia(messages, provider = '') {
 // Anthropic's 5m message-tail TTL (agent-runtime/cache-strategy.mjs gives it
 // to agent sessions). A send this long after the previous one finds the tail
 // cache expired and would rewrite the whole accumulated transcript; compacting
-// first makes that cold write the compacted transcript instead.
+// first makes that cold write the compacted transcript instead. The tail was
+// last used by the session's own send or by a successful cache warm
+// (cache-warm.mjs), which reads and refreshes it without moving
+// lastProviderSendAt: a warmed tail has not expired — for a request on the
+// warm's provider, model and account only, since the entry lives there.
 const AGENT_MESSAGE_CACHE_TTL_MS = 5 * 60_000;
 
-export function shouldCompactForExpiredAgentCache(sessionRef, opts) {
+// The account the request would be served by: the roster's first pick for a
+// provider with accounts (account-pool.mjs), '' for one without a roster.
+function requestAccountId(provider, model, sessionRef, opts, messages) {
+  if (!ACCOUNT_PROVIDERS.includes(provider)) return '';
+  return plannedAccountId(provider, {
+    sessionId: opts?.sessionId || sessionRef?.id || null,
+    messages,
+    providerState: opts?.providerState,
+    model,
+  });
+}
+
+/** Whether the agent session's 5m message tail expired before this request
+ *  on `provider` / `model` (default: the session's route). */
+export function shouldCompactForExpiredAgentCache(sessionRef, opts, { provider, model, messages = [] } = {}) {
   if (!isAgentOwner(sessionRef) || opts?.cacheStrategy?.messages !== '5m') return false;
   const lastSendAt = Number(sessionRef.lastProviderSendAt);
-  return lastSendAt > 0 && Date.now() - lastSendAt > AGENT_MESSAGE_CACHE_TTL_MS;
+  if (!(lastSendAt > 0)) return false;
+  const now = Date.now();
+  if (now - lastSendAt <= AGENT_MESSAGE_CACHE_TTL_MS) return false;
+  // No warm since the last send: the tail expired.
+  if (!(lastCacheWarmUseAt(sessionRef.id) > lastSendAt)) return true;
+  const route = { provider: provider || sessionRef.provider || '', model: model || sessionRef.model || '' };
+  const accountId = requestAccountId(route.provider, route.model, sessionRef, opts, messages);
+  if (accountId === null) return true;
+  const warmAt = cacheWarmUseFor(sessionRef.id, { ...route, accountId });
+  return now - Math.max(lastSendAt, warmAt) > AGENT_MESSAGE_CACHE_TTL_MS;
 }
 
 export function shouldCompactForSession(
@@ -795,9 +821,9 @@ function compactionTelemetryRecord(sessionRef, policy, meta, prev) {
     if (terminalSuccess) return null;
     return present ? (next ?? null) : (previous ?? null);
   };
-  return {
-    ...prev,
-    auto: policy.auto !== false,
+  // Config-owned fields stay the live ones (withLiveCompactionConfig): `policy`
+  // was resolved before a compaction that a reload may have outlived.
+  return withLiveCompactionConfig(prev, {
     requestReserveTokens: policy.requestReserveTokens || 0,
     reserveTokens: policy.reserveTokens || 0,
     boundaryTokens: policy.boundaryTokens || null,
@@ -848,7 +874,7 @@ function compactionTelemetryRecord(sessionRef, policy, meta, prev) {
     compactCount: (prev.compactCount || 0) + (changed ? 1 : 0),
     singleShotConsumed:
       policy.singleShot === true && meta.stage === 'compacting' ? true : prev.singleShotConsumed === true,
-  };
+  });
 }
 
 // Postmortem ring buffer: the per-check telemetry record is overwritten on

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

@@ -18,6 +18,9 @@ import { summarizeOnSharedPrefix } from '../compact/forked-summary.mjs';
 import { normalizeCompactionSummaryMode } from '../compact/summary-mode.mjs';
 import { compactionCacheWarm, lighterSubscriptionModel } from '../compact/summary-route.mjs';
 import { retireCompactionFork } from '../side-question-store.mjs';
+import { buildSkillToolEnvelope, collectSkillsCached, currentSkillDelivery } from '../../context/collect.mjs';
+import { loadSkillToolDependencies } from '../../runtime-core/skill-tool-loading.mjs';
+import { parseNativeToolSearchPayload } from './tool-helpers.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
@@ -262,11 +265,42 @@ function freshContextBudget({ compactPolicy, sessionRef, provider, compactBudget
   return { contextWindow, hardBudget, conversationInput, conversationTokens, conversationThresholdTokens };
 }
 
+// Compact restores each active skill from its current source, as the Skill
+// tool would deliver it in this session now (null: it no longer loads). The
+// real pass also re-arms the skill's current tool dependencies on the session
+// surface and answers the native tool-search payload they produce (or, with
+// none, the Skill result summary); a preview never touches the surface and
+// keeps the transcript's loader pairs.
+function currentSkillResolver(sessionRef, { preview = false } = {}) {
+  const cwd = sessionRef?.cwd || null;
+  const config = loadConfig({ secrets: false });
+  const skills = collectSkillsCached(cwd);
+  return (name) => {
+    const delivery = currentSkillDelivery(name, cwd, config, skills);
+    if (!delivery) return null;
+    const { resource } = delivery;
+    // The tools whose use counts as use of the skill: its tool dependencies,
+    // an MCP server as `mcp:<server>`.
+    const tools = (resource.toolDependencies || []).flatMap(({ type, value }) =>
+      type === 'tool' ? [value] : type === 'mcp' ? [`mcp:${value}`] : []
+    );
+    if (preview) return { body: delivery.body, native: undefined, tools };
+    const envelope = loadSkillToolDependencies(
+      buildSkillToolEnvelope(name, resource.content, resource.dir, resource),
+      sessionRef
+    );
+    const native = parseNativeToolSearchPayload('Skill', envelope.result);
+    return { body: delivery.body, native, summary: native?.summary ?? envelope.result, tools };
+  };
+}
+
 function freshContextBuildOptions(
-  { compactPolicy = {}, sessionId, goalReminderText, activeTurn, referenceLatestAttachments },
+  { sessionRef, compactPolicy = {}, sessionId, goalReminderText, activeTurn, referenceLatestAttachments, preview },
   budget
 ) {
   return {
+    // A sessionless call (no session gates to apply) keeps the transcript copies.
+    currentSkill: sessionRef ? currentSkillResolver(sessionRef, { preview }) : null,
     reserveTokens: compactPolicy.reserveTokens,
     maxBudgetTokens: budget.hardBudget,
     force: true,
@@ -287,7 +321,7 @@ export function previewFreshContextCompaction(input) {
   const budget = freshContextBudget(input);
   const summaryTriggered = budget.conversationTokens >= budget.conversationThresholdTokens;
   const result = freshContextCompactMessages(input.messages, input.compactBudgetTokens, {
-    ...freshContextBuildOptions(input, budget),
+    ...freshContextBuildOptions({ ...input, preview: true }, budget),
     preview: true,
     previewSummary: summaryTriggered,
   });
@@ -346,7 +380,7 @@ export async function runFreshContextCompact({
   });
   const summaryTriggered = conversationTokens >= conversationThresholdTokens;
   const buildOptions = freshContextBuildOptions(
-    { compactPolicy, sessionId, goalReminderText, activeTurn, referenceLatestAttachments },
+    { sessionRef, compactPolicy, sessionId, goalReminderText, activeTurn, referenceLatestAttachments },
     { contextWindow, hardBudget }
   );
   const build = (handoffText) =>

package/src/runtime/agent/orchestrator/session/loop/loop-state.mjs

@@ -120,7 +120,9 @@ export function createLoopState({ provider, messages, model, tools, cwd, sendOpt
     messages.push(message);
     try {
       opts.onToolResult?.(message);
-    } catch {}
+    } catch {
+      // the tool-result observer is advisory
+    }
   };
   state.drainSteering = createSteeringDrain({
     messages,

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

@@ -44,7 +44,7 @@ export function createNoToolTurnResolver({
     // whether it answered that input.
     reactions: [],
     // Structured provider continuation signals honored this turn. Diagnostic
-    // only: the loop has no iteration cap, so this count bounds nothing. A
+    // only: this count bounds nothing. A
     // text-only continuation runaway is bounded by continuationsSinceToolBatch
     // below; continuations interleaved with tool batches are not limited.
     providerContinuationCount: 0,