mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/runtime-core/tool-exposure.mjs

@@ -0,0 +1,96 @@
+// Versioned tool exposure. deferredProviderMode classifies the provider
+// (native tool search or not); toolExposureMode records how the session's
+// tools reach the model. Non-native providers use the fixed bridge: a small
+// eager core plus the shared load_tool and call_tool, with every other tool
+// only in the session's scoped catalog. Native sessions carry no field.
+import { deferredProviderMode } from './tool-catalog-schema.mjs';
+import { TOOL_SEARCH_TOOL } from './tool-defs.mjs';
+
+export const TOOL_EXPOSURE_BRIDGE = 'bridge-v1';
+export const TOOL_EXPOSURE_NATIVE = 'native';
+export const TOOL_SURFACE_MIGRATION_INTENT = 'tool_surface_bridge_migration';
+
+const BRIDGE_PROVIDER_MODES = new Set(['canonical', 'manifest']);
+// call_tool, and the retired search_tools an older bridge surface carried.
+const BRIDGE_ONLY_TOOL_NAMES = new Set(['search_tools', 'call_tool']);
+// load_tool definitions earlier bridge surfaces carried: the describe-only
+// bridge loader, and the shared loader with query/cursor inputs.
+const LEGACY_BRIDGE_LOAD_TOOL_DESCRIPTIONS = new Set([
+  'Describe tools by exact name: description, input schema and annotations, or the part one JSON Pointer selects. Large definitions arrive in chunks; pass nextCursor back for the rest. Describing never enables a tool.',
+  'Load full schemas for missing deferred tool names/aliases; batch needed names in one call. Or find tools by keyword with query. Pass nextCursor back for the next page.',
+]);
+const SHARED_LOAD_TOOL_SCHEMA = JSON.stringify(TOOL_SEARCH_TOOL.inputSchema);
+
+/** `route`: the session's pinned wire route (session.wireRoute), when one exists. */
+export function toolExposureModeForProvider(provider, route = null) {
+  return BRIDGE_PROVIDER_MODES.has(deferredProviderMode(provider, route)) ? TOOL_EXPOSURE_BRIDGE : TOOL_EXPOSURE_NATIVE;
+}
+
+export function isToolBridgeEnabled(session) {
+  return session?.toolExposureMode === TOOL_EXPOSURE_BRIDGE;
+}
+
+/**
+ * The exposure a session's persisted surface was built with, or null before
+ * it has one. Surfaces persisted before exposure versions: native providers
+ * were already native; fixed-surface providers carried the whole catalog.
+ */
+export function sessionToolExposure(session) {
+  if (session?.toolExposureMode) return session.toolExposureMode;
+  if (!session?.deferredProviderMode) return null;
+  return session.deferredProviderMode === 'native' ? TOOL_EXPOSURE_NATIVE : 'legacy-fixed';
+}
+
+/**
+ * True when an existing surface was built for another exposure than
+ * `provider` needs, or is a bridge surface an earlier bridge revision built
+ * (bridgeSurfaceOutdated).
+ */
+export function toolExposureMigrationNeeded(session, provider = session?.provider) {
+  const current = sessionToolExposure(session);
+  if (current === null) return false;
+  const target = toolExposureModeForProvider(provider, session?.wireRoute);
+  return current !== target || (target === TOOL_EXPOSURE_BRIDGE && bridgeSurfaceOutdated(session));
+}
+
+/**
+ * A bridge session an earlier bridge revision built: its fixed prompt holds
+ * other bridge guidance than the current one (the guidance-only block, or
+ * guidance naming search_tools or query), or its eager surface still carries
+ * search_tools or a load_tool other than the shared one.
+ */
+export function bridgeSurfaceOutdated(session) {
+  if (!isToolBridgeEnabled(session)) return false;
+  const tools = Array.isArray(session.tools) ? session.tools : [];
+  const staleTool = tools.some(
+    (tool) =>
+      tool?.name === 'search_tools' ||
+      (tool?.name === TOOL_SEARCH_TOOL.name &&
+        (tool.description !== TOOL_SEARCH_TOOL.description ||
+          JSON.stringify(tool.inputSchema) !== SHARED_LOAD_TOOL_SCHEMA))
+  );
+  if (staleTool) return true;
+  return (Array.isArray(session.messages) ? session.messages : []).some(
+    (message) =>
+      message?.role === 'system' &&
+      typeof message.content === 'string' &&
+      message.content.includes('<tool-bridge>') &&
+      !message.content.includes(TOOL_BRIDGE_GUIDANCE)
+  );
+}
+
+/** A bridge-only definition (never part of the scoped catalog). */
+export function isBridgeToolDefinition(tool) {
+  const name = String(tool?.name || '');
+  if (BRIDGE_ONLY_TOOL_NAMES.has(name)) return true;
+  return name === TOOL_SEARCH_TOOL.name && LEGACY_BRIDGE_LOAD_TOOL_DESCRIPTIONS.has(tool?.description);
+}
+
+// Static and byte-stable; it follows the deferred roster (the same
+// <available-deferred-tools> block native sessions get), never replaces it.
+// A prompt holding any other bridge guidance is migrated once.
+export const TOOL_BRIDGE_GUIDANCE = [
+  '<tool-bridge>',
+  'Deferred tools (listed above, or announced later as added) are not defined here: run one with call_tool {name, arguments}, and use load_tool first to see its parameters (a keyword instead of a name searches the deferred tools). Call directly defined tools directly.',
+  '</tool-bridge>',
+].join('\n');

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

@@ -7,6 +7,7 @@ import { normalizeEffortInput } from './effort.mjs';
 import { isLikelyRawModelId } from './config-helpers.mjs';
 import { configuredAgentRouteCandidates } from '../../../shared/agent-route-config.mjs';
 import { normalizeContextTokens } from '../../../shared/llm/default-context-window.mjs';
+import { canonicalRouteProvider, normalizeRouteChain } from '../../../shared/model-route-chain.mjs';
 import { normalizeAgentId, normalizeWorkflowId } from './workflow-ids.mjs';
 import { createWorkflowPacks } from './workflow/packs.mjs';
 import { createWorkflowAgents } from './workflow/agents.mjs';
@@ -38,12 +39,6 @@ const WEB_SEARCH_PROVIDER_FAMILIES = new Map([
 ]);
 export const WEB_SEARCH_DEFAULT_PROVIDER = 'default';
 export const WEB_SEARCH_DEFAULT_MODEL = 'default';
-const WEB_SEARCH_PROVIDER_ALIASES = Object.freeze({
-  'openai-api': 'openai',
-  'xai-api': 'xai',
-  'gemini-api': 'gemini',
-  'anthropic-api': 'anthropic',
-});
 
 export function workflowPresetId(slot) {
   return `workflow-${slot}`;
@@ -121,8 +116,7 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
 }
 
 export function normalizeWebSearchProviderId(provider) {
-  const id = clean(provider);
-  return WEB_SEARCH_PROVIDER_ALIASES[id] || id;
+  return canonicalRouteProvider(provider);
 }
 
 export function isDefaultWebSearchRouteConfig(routeLike = {}) {
@@ -141,6 +135,10 @@ export function isWebSearchCapableProvider(provider) {
 }
 
 export function normalizeWebSearchRouteConfig(routeLike, fallback = {}) {
+  return normalizeRouteChain(routeLike, normalizeWebSearchRouteLeaf, fallback);
+}
+
+function normalizeWebSearchRouteLeaf(routeLike, fallback = {}) {
   const provider = normalizeWebSearchProviderId(routeLike?.provider || fallback.provider);
   const model = clean(routeLike?.model || fallback.model);
   if (!provider || !model) return null;
@@ -178,6 +176,10 @@ export function webSearchRouteOrDefault(...routeLikes) {
 }
 
 export function normalizeWorkflowRoute(routeLike, fallback = {}) {
+  return normalizeRouteChain(routeLike, normalizeWorkflowRouteLeaf, fallback);
+}
+
+function normalizeWorkflowRouteLeaf(routeLike, fallback = {}) {
   const provider = clean(routeLike?.provider) || clean(fallback.provider);
   const model = clean(routeLike?.model) || clean(fallback.model);
   if (!provider || !model) return null;

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

@@ -9,7 +9,7 @@ import {
 } from './loop/tool-helpers.mjs';
 import { repairTranscriptBeforeProviderSend } from './loop/transcript-repair.mjs';
 import { resetAccountProbePacing } from '../providers/account-pool.mjs';
-import { createLoopState, finishLoop, shouldSuppressAgentMidTurnText } from './loop/loop-state.mjs';
+import { createLoopState, finishLoop } from './loop/loop-state.mjs';
 import { applyRetryAction, beginIteration, sendProviderRequest, settleSendResult } from './loop/send-phase.mjs';
 import { runToolPhase } from './loop/tool-phase.mjs';
 
@@ -25,7 +25,6 @@ export {
   resolvePreToolAskApproval,
   approvalGranted,
   approvalReason,
-  shouldSuppressAgentMidTurnText,
 };
 
 /**

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

@@ -0,0 +1,24 @@
+// The Agents pool's quiet-time inputs: each row whose turn is in flight in
+// this process carries its last counted progress stamp, its runtime stage
+// (and running tool), and its agent's stall-watchdog warn point. Display
+// only — nothing here reads or changes the watchdog's abort policy.
+import { displayProgressStage, lastProgressAt } from '../../../shared/quiet-progress.mjs';
+import { resolveAgentStallThresholds } from '../stall-policy.mjs';
+
+/** `rows` with progress fields on every row `runtimeEntry(sessionId)` reports
+ *  in flight; other rows pass through untouched. */
+export function withTurnProgress(rows, runtimeEntry, isTurnInFlight) {
+  return rows.map((row) => {
+    const entry = runtimeEntry(row?.sessionId);
+    if (!isTurnInFlight(entry)) return row;
+    const stage = typeof entry.stage === 'string' ? entry.stage : null;
+    return {
+      ...row,
+      progressAt: lastProgressAt(entry) || null,
+      // `model_thinking` while the sent request waits for its headers.
+      progressStage: displayProgressStage(entry),
+      progressTool: stage === 'tool_running' ? entry.lastToolCall || null : null,
+      stallWarnMs: resolveAgentStallThresholds(row.agent).warn * 1000,
+    };
+  });
+}

package/src/runtime/agent/orchestrator/session/cache/tool-result-reuse.mjs

@@ -1,13 +1,21 @@
 // One freshness authority for eager admission, cross-turn references and
 // serial cache hits. A readOnlyHint alone never proves a result reusable.
 import { tryReadCached } from './read-cache.mjs';
+import { isCursorNativeCallId } from '../../providers/cursor-native-context.mjs';
 import { tryScopedToolCached } from './scoped-cache.mjs';
-import { _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from '../loop/tool-classify.mjs';
+import { _isReadTool, _isScopedCacheableTool, _stripMcpPrefix, requiresReadBody } from '../loop/tool-classify.mjs';
 
-export function lookupToolResultReuse({ sessionId, call, cwd, touch = true }) {
+export function lookupToolResultReuse({ sessionId, call, cwd, touch = true, sessionRef = null }) {
+  if (isCursorNativeCallId(call.id)) return null;
   if (!sessionId) return null;
   if (_isReadTool(call.name)) {
     const entry = tryReadCached({ sessionId, args: call.arguments, cwd });
+    if (
+      requiresReadBody(call.name, sessionRef) &&
+      typeof entry?.content === 'string' &&
+      /^(?:\[file unchanged:|\[cross-turn-dedup\]|\[intra-turn-dedup\])/.test(entry.content)
+    )
+      return null;
     return entry === null ? null : { kind: 'read', entry };
   }
   if (_isScopedCacheableTool(call.name)) {

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

@@ -3,8 +3,8 @@
  * the ordinary session catalog.
  *
  * Everything runs on one worker thread (./worker.mjs): the catalog engine's
- * change detection (summary index, sessions directory, per-file stamps, `.hb`
- * liveness, background verification) feeds `<dataDir>/session-catalog.sqlite`
+ * change detection (summary index, sessions directory, per-file stamps,
+ * background verification) feeds `<dataDir>/session-catalog.sqlite`
  * and an ordinary listing is one request that answers from it. This thread
  * does no filesystem work for it and never loads node:sqlite.
  *
@@ -24,7 +24,6 @@ import { dataDir as currentDataDir } from '../store-summary-locations.mjs';
 export const SESSION_CATALOG_DB_FILE = 'session-catalog.sqlite';
 /** Config: `{ "sessionStore": { "sqliteCatalog": false } }` forces the JSON
  *  path (an off-switch); absent or true uses the DB whenever it can. */
-export const SESSION_STORE_CONFIG_SECTION = 'sessionStore';
 export const SESSION_STORE_CONFIG_DEFAULTS = Object.freeze({ sqliteCatalog: true });
 /** Stable prefix of every daemon.log line of the catalog DB. */
 export const SESSION_CATALOG_LOG_PREFIX = '[session-catalog-db]';

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 = 4;
+export const SCHEMA_VERSION = 6;
 /** PRAGMA application_id ('MXSC'): a file without it is not this catalog. */
 export const APPLICATION_ID = 0x4d585343;
 
@@ -27,8 +27,6 @@ const FIELDS = [
   ['lastUsedAt', 'last_used_at', 'real'],
   ['createdAt', 'created_at', 'real'],
   ['lastHeartbeatAt', 'last_heartbeat_at', 'real'],
-  // Always 0 in a stored row: liveness is overlaid from `.hb` sidecars at read.
-  ['heartbeatAt', 'heartbeat_at', 'real'],
   ['closed', 'closed', 'bool'],
   ['status', 'status', 'text'],
   ['owner', 'owner', 'loose'],
@@ -59,6 +57,8 @@ const FIELDS = [
   ['importKey', 'import_key', 'loose'],
   // Source session of an inherited (forked) session (schema 4).
   ['inheritedFromSessionId', 'inherited_from_session_id', 'loose'],
+  // Real human turns (null for a row written before schema 5).
+  ['realTurnCount', 'real_turn_count', 'loose'],
 ];
 
 const COLUMN_TYPES = { text: 'TEXT', real: 'REAL', int: 'INTEGER', bool: 'INTEGER', json: 'TEXT', optjson: 'TEXT' };
@@ -193,16 +193,10 @@ export function rowFromDb(record) {
   return row;
 }
 
-// Overlays a listing adds at read time; never part of the comparison.
-const OVERLAY_KEYS = new Set(['heartbeatAt', 'agentHeartbeatAt']);
-
-/** Comparable JSON of a row's stored fields (overlays excluded). */
+/** Comparable JSON of a row's stored fields. */
 function comparable(row) {
   const out = [];
-  for (const [key] of FIELDS) {
-    if (OVERLAY_KEYS.has(key)) continue;
-    out.push(row[key] === undefined ? null : row[key]);
-  }
+  for (const [key] of FIELDS) out.push(row[key] === undefined ? null : row[key]);
   return JSON.stringify(out);
 }
 

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

@@ -2,8 +2,8 @@
 //
 // It owns `<dataDir>/session-catalog.sqlite` and runs the ordinary catalog
 // engine (store-summary-catalog.mjs): the summary index stamps and delta-log
-// apply, the sessions-directory name diff, per-file stamps, `.hb` liveness and
-// the background verification. An ordinary listing is one `list` request: the
+// apply, the sessions-directory name diff, per-file stamps and the background
+// verification. An ordinary listing is one `list` request: the
 // engine's cheap stamp check runs first (so changes by any writer appear as
 // soon as they do on the JSON path), its changes are written to the DB, and
 // the answer comes from the DB. When one of the daemon's own writes changed a
@@ -20,8 +20,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from 'node:
 import { dirname, join } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { postWorkerEvent, serveWorkerRequests } from '../../../../shared/worker-requests.mjs';
-import { agentHeartbeatsByOwner, createOrdinaryCatalog, isLeadVisibleRow } from '../store-summary-catalog.mjs';
-import { positiveNumber } from '../store-summary-fields.mjs';
+import { createOrdinaryCatalog, isLeadVisibleRow } from '../store-summary-catalog.mjs';
 import { SQLITE_REQUIREMENT, sqliteVersionSupported } from './sqlite-gate.mjs';
 import {
   APPLICATION_ID,
@@ -514,30 +513,15 @@ function switchedOff(s) {
   return s.switchOff.value;
 }
 
-/** Rows from the DB with the liveness of the current scan overlaid. */
+/** Rows from the DB. */
 function answer(s, page) {
-  const heartbeatMtimes = s.engine.current()?.heartbeatMtimes ?? new Map();
-  const live = [];
-  for (const [id, heartbeatAt] of heartbeatMtimes) {
-    const entry = resolve(s, id);
-    if (entry) live.push({ ...entry.row, heartbeatAt });
-  }
-  const agentHeartbeatByOwner = agentHeartbeatsByOwner(live);
-  const overlay = (row) => {
-    const agentHeartbeatAt = agentHeartbeatByOwner.get(row.id) || 0;
-    return {
-      ...row,
-      heartbeatAt: positiveNumber(heartbeatMtimes.get(row.id), 0),
-      ...(agentHeartbeatAt > 0 ? { agentHeartbeatAt } : {}),
-    };
-  };
   const { statements } = s;
-  if (!page) return { rows: statements.listAll.all().map((record) => overlay(rowFromDb(record))), more: false };
+  if (!page) return { rows: statements.listAll.all().map(rowFromDb), more: false };
   const { limit, after } = page;
   const records = after
     ? statements.listAfter.all(after.activity, after.activity, after.id, limit + 1)
     : statements.listFirst.all(limit + 1);
-  return { rows: records.slice(0, limit).map((record) => overlay(rowFromDb(record))), more: records.length > limit };
+  return { rows: records.slice(0, limit).map(rowFromDb), more: records.length > limit };
 }
 
 const unavailable = (reason, final = false) => ({ status: 'unavailable', reason, final });

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

@@ -15,8 +15,9 @@ export {
   compactionBufferTokensForBoundary,
 };
 
-export const SUMMARY_PREFIX_ANCHOR =
-  'A previous model worked on this task and produced the compacted handoff summary below.';
+import { SUMMARY_PREFIX_ANCHOR } from './summary-anchor.mjs';
+
+export { SUMMARY_PREFIX_ANCHOR };
 export const SUMMARY_PREFIX = `${SUMMARY_PREFIX_ANCHOR} Build on the work already done and avoid duplicating it. The summary covers the session; retained requests and execution records follow it. Actual tool outcomes take precedence over plans or older claims in the summary.`;
 export const SUMMARY_OUTPUT_TOKENS = 4_096;
 // Longest a handoff summary call may run: the default, the config fallback,

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

@@ -1,13 +1,15 @@
 // Message classification, protected-context splitting, and summary-message
 // construction helpers.
-import { SUMMARY_PREFIX, SUMMARY_PREFIX_ANCHOR } from './constants.mjs';
+import { SUMMARY_PREFIX } from './constants.mjs';
 import { sha16, roleCounts } from './text-utils.mjs';
 import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
-import { isImportedMessage } from '../imported-message.mjs';
 import {
-  isInternalRuntimeNotificationText,
-  isModelVisibleToolCompletionWrapper,
-} from '../../../../shared/tool-execution-contract.mjs';
+  contextAckMessage,
+  isActualUserInstructionMessage,
+  isInjectedSkillBodyMessage,
+  isProtectedContextUserMessage,
+  isSummaryMessage,
+} from './user-message-kind.mjs';
 
 export function compactHeader(oldHistory) {
   // Stable display ids are bookkeeping, not conversation: the header names
@@ -23,94 +25,15 @@ export function makeSummaryMessage(content) {
   return { role: 'user', content, meta: { source: 'compact-summary' } };
 }
 
-// A compact summary message is a synthetic role:'user' message carrying the
-// SUMMARY_PREFIX anchor. It is NOT a real user turn: it must be excluded from
-// real user-turn boundary calculations and treated as merge input, otherwise
-// an old summary can sit in the preserved tail as a live user message,
-// duplicate, or fail to merge across repeated compaction.
-export function isSummaryMessage(m) {
-  return (
-    m?.role === 'user' &&
-    !isImportedMessage(m) &&
-    (String(m?.meta?.source || '') === 'compact-summary' ||
-      (typeof m.content === 'string' &&
-        m.content.startsWith(SUMMARY_PREFIX_ANCHOR) &&
-        /\nmessages=\d+\s+(?:sha256=|compact_type=)/.test(m.content)))
-  );
-}
-
-export function isProtectedContextUserMessage(m) {
-  if (m?.role !== 'user' || typeof m.content !== 'string' || isImportedMessage(m)) return false;
-  let content = m.content.trim();
-  if (!content.toLowerCase().startsWith('<system-reminder>')) return false;
-  const closingTag = '</system-reminder>';
-  // A runtime turn may carry several reminders (Goal, clock, tool delta).
-  // Only text outside those envelopes is a human instruction. Keep this
-  // compatible with stored turns that predate explicit source metadata.
-  while (content.toLowerCase().startsWith('<system-reminder>')) {
-    const closingIndex = content.toLowerCase().indexOf(closingTag);
-    if (closingIndex < 0) return true;
-    content = content.slice(closingIndex + closingTag.length).trim();
-  }
-  return content === '';
-}
-
-// An injected Skill-body user message (the general newMessages channel carries
-// the full SKILL.md body as a role:'user' message after the Skill tool_result).
-// Like isSummaryMessage / isProtectedContextUserMessage, it is detected by
-// content prefix (the `<skill>` envelope from buildSkillResultEnvelope) so the
-// check survives even if the synthetic `meta` field is dropped during a tail
-// rebuild. It is NOT the human's latest prompt and must be excluded from
-// "latest human request" selection (deriveCurrentRequest). The `meta:'skill'`
-// marker is also honoured.
-export function isInjectedSkillBodyMessage(m) {
-  if (m?.role !== 'user' || isImportedMessage(m)) return false;
-  if (m.meta === 'skill') return true;
-  return typeof m.content === 'string' && m.content.trimStart().startsWith('<skill>');
-}
-
-const SYNTHETIC_USER_SOURCES = new Set([
-  'goal-continuation',
-  'goal-closeout',
-  'compact-context',
-  'compact-active-turn-continuation',
-  'compact-execution-recovery',
-  'max-output-recovery',
-  'refusal-recovery',
-  'stream-cut-recovery',
-]);
-const SYNTHETIC_USER_CONTROL_RE =
-  /^(?:\[mixdog-runtime\]|\[request interrupted(?: by user(?: for tool use)?| by process restart)?\])(?:\s|$)/i;
-
-function userMessageText(message) {
-  if (typeof message?.content === 'string') return message.content;
-  if (!Array.isArray(message?.content)) return '';
-  return message.content.map((block) => (typeof block === 'string' ? block : block?.text || '')).join('');
-}
-
-export function isActualUserInstructionMessage(message) {
-  if (
-    message?.role !== 'user' ||
-    isSummaryMessage(message) ||
-    isProtectedContextUserMessage(message) ||
-    isInjectedSkillBodyMessage(message)
-  ) {
-    return false;
-  }
-  const text = userMessageText(message);
-  // Imported prose is the user's own words whatever it looks like.
-  if (isImportedMessage(message)) return text.trim().length > 0;
-  if (/^Reference files:\s*/i.test(text.trimStart())) return false;
-  if (
-    SYNTHETIC_USER_CONTROL_RE.test(text.trimStart()) ||
-    isInternalRuntimeNotificationText(text) ||
-    isModelVisibleToolCompletionWrapper(text) ||
-    SYNTHETIC_USER_SOURCES.has(String(message?.meta?.source || ''))
-  ) {
-    return false;
-  }
-  return text.trim().length > 0 || (Array.isArray(message.content) && message.content.length > 0);
-}
+// User-message classification lives in the import-light user-message-kind.mjs
+// (the session store counts real turns with it); re-exported for callers.
+export {
+  contextAckMessage,
+  isActualUserInstructionMessage,
+  isInjectedSkillBodyMessage,
+  isProtectedContextUserMessage,
+  isSummaryMessage,
+};
 
 export function latestActualUserInstructionIndex(messages) {
   for (let index = (Array.isArray(messages) ? messages.length : 0) - 1; index >= 0; index -= 1) {

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

@@ -10,6 +10,8 @@ import {
   textByteLength,
 } from './text-utils.mjs';
 import {
+  contextAckMessage,
+  isProtectedContextAckMessage,
   isSummaryMessage,
   latestActualUserInstructionIndex,
   latestActualUserInstructionMessage,
@@ -20,7 +22,7 @@ import { buildExecutionTail } from './execution-tail.mjs';
 import { latestSkillBodies } from '../../context/skill-state.mjs';
 import { effectiveBudget } from './budget.mjs';
 import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user-context.mjs';
-import { carryMessageId } from '../message-ids.mjs';
+import { carryMessageId, messageIdOf } from '../message-ids.mjs';
 import { normalizeIngestRole, shouldExcludeIngestMessage } from '../../../../memory/lib/session-ingest.mjs';
 import { codexWireSendOpts } from '../manager/session-id.mjs';
 import { rebaseCompactedEffortConfiguration } from '../../providers/effort-configuration.mjs';
@@ -48,9 +50,11 @@ function splitFreshSource(messages) {
   const sanitized = redactToolCallSecretsInMessages(reconcileDedupStubs(sanitizeToolPairs(messages)));
   const { protectedPrefix, conversation } = splitProtectedContext(sanitized);
   let previousSummaryMessage = null;
+  let previousAck = null;
   for (let index = conversation.length - 1; index >= 0; index -= 1) {
     if (isSummaryMessage(conversation[index])) {
       previousSummaryMessage = conversation[index];
+      if (isProtectedContextAckMessage(conversation[index + 1])) previousAck = conversation[index + 1];
       break;
     }
   }
@@ -59,6 +63,7 @@ function splitFreshSource(messages) {
     protectedPrefix,
     previousSummary: previousSummaryMessage?.content || null,
     previousSummaryMessage,
+    previousAck,
     // 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.
@@ -505,6 +510,15 @@ function freshSkillBudget(targetBudget, budget, committed) {
   return Math.max(0, Math.min(25_000, Math.floor(targetBudget * 0.2), budget - estimateMessagesTokens(committed)));
 }
 
+// Every pass rebuilds the ack; it keeps the previous ack's id so the archive
+// does not count an unchanged ack as dropped, unless the tail still holds it.
+function stableAckMessage(previousAck, volatileTail) {
+  const ack = contextAckMessage();
+  const id = messageIdOf(previousAck);
+  if (!id || volatileTail.some((message) => messageIdOf(message) === id)) return ack;
+  return carryMessageId(ack, previousAck);
+}
+
 // The pieces every fresh context carries: the protected prefix, the handoff
 // summary (or the previous one when no handoff was produced), the stable
 // acknowledgement between them and the volatile tail. `mandatory` is what
@@ -518,7 +532,7 @@ function freshContextLayout(source, budgetTokens, opts) {
     ? fitFreshContextSummaryMessage(source.live, handoffText, Number.MAX_SAFE_INTEGER)
     : source.previousSummaryMessage;
   const tail = freshContextTail(source, budgetTokens, !replaceConversation, opts);
-  const stableAck = tail.latestUser && summaryMessage ? { role: 'assistant', content: '.' } : null;
+  const stableAck = tail.latestUser && summaryMessage ? stableAckMessage(source.previousAck, tail.volatileTail) : null;
   const stableHead = [
     ...source.protectedPrefix,
     ...(summaryMessage ? [summaryMessage] : []),

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

@@ -0,0 +1,5 @@
+// Leaf constant: the anchor sentence every compact summary message opens with.
+// Kept import-free so store-layer code can classify messages without pulling
+// the context-utils graph (which cycles back into the session store).
+export const SUMMARY_PREFIX_ANCHOR =
+  'A previous model worked on this task and produced the compacted handoff summary below.';