mixdog 1.4.0 → 1.4.2

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

@@ -1,11 +1,18 @@
 /**
  * Codex CLI rollout (`rollout-*.jsonl`) → raw import turns. Kept: the first
  * `session_meta` (foreign id, cwd), user/assistant `message` items as text and
- * tool calls as `[ran tool: <name>]` notes. Dropped: developer/system
+ * tool calls as tool notes. Dropped: developer/system
  * messages, Codex's own wrapper user messages, tool outputs, reasoning,
  * event_msg, token counts and turn_context.
  */
-import { IMAGE_OMITTED_TEXT, IMPORT_WARNING_IMAGE_OMITTED, isWholeElement, textPart, toolNote } from './turns.mjs';
+import {
+  IMAGE_OMITTED_TEXT,
+  IMPORT_WARNING_IMAGE_OMITTED,
+  isWholeElement,
+  stringOrNull,
+  textPart,
+  toolNote,
+} from './turns.mjs';
 
 // User-role envelopes Codex injects itself (environment, instructions, abort
 // notices, plugin hints, shell-command echoes, image wrappers).
@@ -17,6 +24,7 @@ const CODEX_ENVELOPE_TAGS = [
   'user_shell_command',
   'subagent_notification',
   'skills_instructions',
+  'external_codex_apps_open_page',
 ];
 const TOOL_CALL_TYPES = new Set(['function_call', 'custom_tool_call', 'local_shell_call']);
 
@@ -29,6 +37,17 @@ export function isCodexEnvelopeText(text) {
   return /^<image\b[^>]*>$/.test(trimmed) || trimmed === '</image>';
 }
 
+// Codex shows a user message after the last of these headings: what precedes it
+// is context the app adds for the model (IDE state, mentioned files, response
+// annotations, an earlier request it already carries).
+const USER_REQUEST_HEADING = '## My request for Codex:';
+
+/** A user text part as Codex displays it. */
+function codexUserDisplayText(text) {
+  const at = text.lastIndexOf(USER_REQUEST_HEADING);
+  return at < 0 ? text : text.slice(at + USER_REQUEST_HEADING.length).trim();
+}
+
 function messageParts(payload, warnings) {
   const content = typeof payload.content === 'string' ? [{ type: 'text', text: payload.content }] : payload.content;
   if (!Array.isArray(content)) return [];
@@ -41,8 +60,8 @@ function messageParts(payload, warnings) {
       continue;
     }
     if (typeof item.text !== 'string') continue;
-    if (payload.role === 'user' && isCodexEnvelopeText(item.text)) continue;
-    parts.push(textPart(item.text));
+    if (payload.role !== 'user') parts.push(textPart(item.text));
+    else if (!isCodexEnvelopeText(item.text)) parts.push(textPart(codexUserDisplayText(item.text)));
   }
   return parts;
 }
@@ -52,7 +71,30 @@ function toolName(payload) {
   return payload.type === 'local_shell_call' ? 'local_shell' : '';
 }
 
-const stringOrNull = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+// `session_meta.thread_source` values Codex gives threads it runs for itself.
+const INTERNAL_THREAD_SOURCES = {
+  subagent: 'subagent',
+  guardian_review: 'guardianReview',
+  memory_consolidation: 'internal',
+};
+
+/**
+ * What kind of Codex-internal record a `session_meta` payload marks, else null
+ * for a conversation the user had. Markers are Codex's own: `thread_source`
+ * (`subagent`, `guardian_review`, `memory_consolidation`) and a `source` of the
+ * form `{ subagent: … }` (spawned agent, review, compact; `{ other: "guardian" }`
+ * is the approval reviewer) or `{ internal: … }`. Other sources (cli, vscode,
+ * exec, mcp, custom) and features (automation, voice chat) are the user's.
+ */
+function codexInternalKind(payload) {
+  const byThread = INTERNAL_THREAD_SOURCES[payload?.thread_source];
+  if (byThread) return byThread;
+  const source = payload?.source;
+  if (!source || typeof source !== 'object') return null;
+  if ('subagent' in source) return source.subagent?.other === 'guardian' ? 'guardianReview' : 'subagent';
+  if ('internal' in source) return source.internal === 'guardian' ? 'guardianReview' : 'internal';
+  return null;
+}
 // Rough fixed cost of one retained turn object, so tiny turns still count.
 const ENTRY_OVERHEAD_BYTES = 64;
 
@@ -67,6 +109,8 @@ export function createCodexReducer() {
   let recognized = false;
   let foreignSessionId = null;
   let cwd = null;
+  let internalKind = null;
+  let historyBase = null;
   let metaSeen = false;
   let chars = 0;
   let metadataBytes = 0;
@@ -86,15 +130,19 @@ export function createCodexReducer() {
     get metadataBytes() {
       return metadataBytes;
     },
-    push(record) {
+    /** `inherited` records come from a history base: its session metadata is not this thread's. */
+    push(record, inherited = false) {
       const payload = record?.payload && typeof record.payload === 'object' ? record.payload : null;
       if (!payload) return;
       if (record.type === 'session_meta') {
+        if (inherited) return;
         recognized = true;
         if (!metaSeen) {
           metaSeen = true;
           foreignSessionId = stringOrNull(payload.id) || stringOrNull(payload.session_id);
           cwd = stringOrNull(payload.cwd);
+          internalKind = codexInternalKind(payload);
+          if (payload.history_base && typeof payload.history_base === 'object') historyBase = payload.history_base;
         }
         return;
       }
@@ -108,23 +156,95 @@ export function createCodexReducer() {
       }
     },
     result() {
-      return { recognized, foreignSessionId, cwd, rawTurns, warnings };
+      return { recognized, foreignSessionId, cwd, internalKind, historyBase, rawTurns, warnings };
     },
   };
 }
 
-/** id/cwd of a `session_meta` first line cut off by a bounded prefix read. */
-export function codexMetaFromTruncatedLine(line) {
-  const text = String(line || '');
-  if (!/"type"\s*:\s*"session_meta"/.test(text)) return null;
-  const field = (name) => {
-    const match = new RegExp(`"${name}"\\s*:\\s*("(?:[^"\\\\]|\\\\.)*")`).exec(text);
-    if (!match) return null;
-    try {
-      return stringOrNull(JSON.parse(match[1]));
-    } catch {
-      return null;
+// ── bounded-prefix `session_meta` scan ───────────────────────────────────────
+// Index after the string starting at `i`, or -1 when the text ends inside it.
+function scanString(text, i) {
+  for (let j = i + 1; j < text.length; j++) {
+    if (text[j] === '\\') j++;
+    else if (text[j] === '"') return j + 1;
+  }
+  return -1;
+}
+
+// Index after the JSON value starting at `i`, or -1 when the text ends inside it.
+function scanValue(text, i) {
+  if (text[i] === '"') return scanString(text, i);
+  if (text[i] === '{' || text[i] === '[') {
+    let depth = 0;
+    for (let j = i; j < text.length; j++) {
+      if (text[j] === '"') {
+        j = scanString(text, j) - 1;
+        if (j < 0) return -1;
+      } else if (text[j] === '{' || text[j] === '[') depth++;
+      else if ((text[j] === '}' || text[j] === ']') && --depth === 0) return j + 1;
+    }
+    return -1;
+  }
+  const literal = /[^,}\]\s]+/y;
+  literal.lastIndex = i;
+  literal.exec(text);
+  return literal.lastIndex < text.length ? literal.lastIndex : -1;
+}
+
+/**
+ * Complete top-level values (raw JSON text) of the record object and of its
+ * `payload` object in a possibly cut-off line. Nested values are never
+ * inspected, so a key inside custom metadata is not mistaken for a payload field.
+ */
+function recordFields(text) {
+  const top = {};
+  const payload = {};
+  const walk = (start, target, descend) => {
+    let j = start + 1;
+    for (;;) {
+      while (/[\s,]/.test(text[j] ?? '')) j++;
+      if (text[j] !== '"') return;
+      const keyEnd = scanString(text, j);
+      if (keyEnd < 0) return;
+      const key = JSON.parse(text.slice(j, keyEnd));
+      j = keyEnd;
+      while (/\s/.test(text[j] ?? '')) j++;
+      if (text[j] !== ':') return;
+      j++;
+      while (/\s/.test(text[j] ?? '')) j++;
+      if (descend && key === 'payload' && text[j] === '{') return walk(j, payload, false);
+      const end = scanValue(text, j);
+      if (end < 0) return;
+      target[key] = text.slice(j, end);
+      j = end;
     }
   };
-  return { foreignSessionId: field('id') || field('session_id'), cwd: field('cwd') };
+  const open = text.indexOf('{');
+  if (open >= 0) walk(open, top, true);
+  return { top, payload };
+}
+
+const jsonOrNull = (raw) => {
+  try {
+    return raw === undefined ? null : JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * id/cwd/internal kind of a `session_meta` first line cut off by a bounded
+ * prefix read, from the payload fields that arrived whole. A marker that did
+ * not arrive whole leaves the record unclassified (`internalKind: null`).
+ */
+export function codexMetaFromTruncatedLine(line) {
+  const { top, payload } = recordFields(String(line || ''));
+  if (jsonOrNull(top.type) !== 'session_meta') return null;
+  const field = (name) => stringOrNull(jsonOrNull(payload[name]));
+  const meta = { thread_source: field('thread_source'), source: jsonOrNull(payload.source) };
+  return {
+    foreignSessionId: field('id') || field('session_id'),
+    cwd: field('cwd'),
+    internalKind: codexInternalKind(meta),
+  };
 }

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 = null;
   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; `warning` names why. */
+    markHistoryPartial(warning = IMPORT_WARNING_HISTORY_PARTIAL) {
+      historyPartial = warning;
+    },
+    /** 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(historyPartial);
       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,18 @@
 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';
+/** Earlier history was left out because following it would pass the import size limit. */
+export const IMPORT_WARNING_HISTORY_SIZE_LIMIT = 'historySizeLimit';
+/** Earlier history was left out because its file is missing or could not be read. */
+export const IMPORT_WARNING_HISTORY_UNAVAILABLE = 'historyUnavailable';
+
+/** A compressed rollout needs a Node.js runtime with zstd; used as the failure code and as the warning of an unreadable base. */
+export const IMPORT_ERROR_NEEDS_NEWER_NODE = 'needsNewerNode';
+
+/** 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,14 +29,54 @@ 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. */
+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 }));
 }
 
+/** A trimmed non-blank string, else null. */
+export const stringOrNull = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+
 export function textPart(text) {
   return { text: String(text), note: false };
 }
@@ -42,18 +94,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 +137,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 +154,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

@@ -39,9 +39,10 @@ export function createEagerDispatcher({
     repeatFailLimit,
   });
   const barriers = createEagerBarriers({ cwd });
-  // A capped turn runs its calls in order, so none past its cap starts early
-  // (loop/turn-limits.mjs).
-  const capped = turnLimitsOf(opts) !== null;
+  // A turn capped by calls or time runs its calls in order, so none past its
+  // cap starts early (loop/turn-limits.mjs).
+  const limits = turnLimitsOf(opts);
+  const capped = limits !== null && (limits.maxToolCalls !== Infinity || limits.wrapUpAt !== Infinity);
   const execute = (call, entry) =>
     executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, {
       toolCallId: call.id,

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

@@ -7,12 +7,19 @@
 //   secret     — the user types a value into a target field; the request names
 //                the target and the field label, never a value;
 //   takeover   — the user does a step themselves and says "done";
-//   permission — the user picks one of the offered scopes.
+//   permission — the user picks one of the offered scopes;
+//   connector  — a bot asks for more authority on one connector tool of its
+//                own: the card names the tool, its current level and the one
+//                asked for, and the person picks the level (`scope`: one of
+//                `choices`) or denies. Answered once, never remembered.
 // A response is one of HUMAN_RESPONSES plus a `remember` scope; a policy lists
 // 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.
 
-const HUMAN_REQUEST_KINDS = Object.freeze(['approval', 'outbound', 'secret', 'takeover', 'permission']);
+const HUMAN_REQUEST_KINDS = Object.freeze(['approval', 'outbound', 'secret', 'takeover', 'permission', 'connector']);
+/** The levels a connector card may raise a tool to. */
+export const CONNECTOR_WIDEN_LEVELS = Object.freeze(['needs_approval', 'auto']);
+const CONNECTOR_LEVELS = ['disabled', ...CONNECTOR_WIDEN_LEVELS];
 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;
@@ -36,6 +43,7 @@ const RESPONSES_BY_KIND = Object.freeze({
   secret: ['provide-secret', 'skip'],
   takeover: ['done', 'deny'],
   permission: ['approve', 'deny'],
+  connector: ['approve', 'deny'],
 });
 const GRANTING_RESPONSES = new Set(['approve', 'edit-and-approve', 'provide-secret', 'done']);
 const TEXT_LIMIT = 200;
@@ -89,12 +97,15 @@ function rememberScopes(value) {
   return ['once', ...new Set(listed.filter((scope) => scope !== 'once'))];
 }
 
-/** The kind-specific fields of a request, whitelisted. Spread onto the
- *  presented request; `args` is replaced for a secret so no value rides it. */
+/** The kind-specific fields of a request, whitelisted, plus the connector
+ *  `account` a tool call is bound to (any kind; the card names it). Spread
+ *  onto the presented request; `args` is replaced for a secret so no value
+ *  rides it. */
 export function humanRequestFields(input = {}) {
+  const bound = text(input?.account) ? { account: text(input.account) } : {};
   const kind = input?.kind;
-  if (!HUMAN_REQUEST_KINDS.includes(kind)) return {};
-  const fields = { remember: rememberScopes(input.remember) };
+  if (!HUMAN_REQUEST_KINDS.includes(kind)) return bound;
+  const fields = { ...bound, remember: rememberScopes(input.remember) };
   // The agent the request acts for (its name on the card and the remembered grant).
   if (text(input.agentId)) fields.agentId = text(input.agentId);
   if (kind === 'outbound' && isRecord(input.outbound)) {
@@ -187,6 +198,20 @@ export function humanRequestFields(input = {}) {
         })),
     };
   }
+  if (kind === 'connector') {
+    const connector = isRecord(input.connector) ? input.connector : {};
+    const level = (value) => (CONNECTOR_LEVELS.includes(value) ? value : '');
+    fields.connector = {
+      server: text(connector.server),
+      tool: text(connector.tool),
+      from: level(connector.from),
+      requested: level(connector.requested),
+      choices: (Array.isArray(connector.choices) ? connector.choices : []).filter((choice) =>
+        CONNECTOR_WIDEN_LEVELS.includes(choice)
+      ),
+    };
+    fields.remember = ['once'];
+  }
   return fields;
 }
 
@@ -226,6 +251,11 @@ export function normalizeHumanResponse(request, approved, extra = {}) {
     const ids = (request?.permission?.scopes || []).map((scope) => scope.id);
     if (ids.includes(extra?.scope)) result.scope = extra.scope;
   }
+  // The level the person picked; none of the offered ones picks nothing.
+  if (kind === 'connector' && polarity) {
+    const choices = Array.isArray(request?.connector?.choices) ? request.connector.choices : [];
+    if (choices.includes(extra?.scope)) result.scope = extra.scope;
+  }
   return result;
 }
 

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

@@ -16,6 +16,9 @@ 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';
@@ -703,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(