mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/session/manager/pending-spool-file.mjs

@@ -1,10 +1,9 @@
-// The shared cross-process pending-message spool file: where it lives, which
+// The shared cross-process pending-message spool (one shard file per session): where it lives, which
 // session ids and rows may enter it, the single locked transaction shape every
 // mutation uses, and the per-session serialization of those transactions.
 // Nothing here decides WHAT to queue — only how the file is read, written and
 // kept well-formed.
-import { updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
-import { PENDING_MESSAGES_MODE, pendingMessagesPath } from './pending-spool-path.mjs';
+import { updatePendingShard } from './pending-spool-shard.mjs';
 import {
   COMPLETION_NOTIFICATION_KIND,
   completionExecutionId,
@@ -17,16 +16,11 @@ export const _pendingPersistTails = new Map();
 // The spool location is shared with the TUI steering mirror.
 export { pendingMessagesPath, touchPendingSessionEntry } from './pending-spool-path.mjs';
 
-// Single spool transaction shape: every mutation of the shared file is locked,
-// compact and non-fsync; `extra` only ever relaxes the lock timeout.
-export function updateSpool(mutate, extra = null) {
-  return updateJsonAtomic(pendingMessagesPath(), mutate, {
-    compact: true,
-    lock: true,
-    mode: PENDING_MESSAGES_MODE,
-    fsync: false,
-    ...extra,
-  });
+// Single spool transaction shape: every mutation touches only `sessionId`'s
+// own shard file, locked, compact and non-fsync; `extra` only ever relaxes the
+// lock timeout.
+export function updateSpool(sessionId, mutate, extra = null) {
+  return updatePendingShard(sessionId, mutate, extra);
 }
 
 // Publish a session's queue inside a spool transaction. An emptied queue drops

package/src/runtime/agent/orchestrator/session/manager/pending-spool-path.mjs

@@ -6,8 +6,23 @@ import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 
 export const PENDING_MESSAGES_MODE = 0o600;
 
-export function pendingMessagesPath() {
-  return join(resolvePluginData(), 'session-pending-messages.json');
+// Layout: one file (and one lock) per pending key under `session-pending/`.
+// A key is an orchestrator session id or a `tui_<lead session id>` steering
+// bucket, so operations on different sessions never share a lock.
+export const PENDING_SHARD_DIR_NAME = 'session-pending';
+export const LEGACY_PENDING_FILE_NAME = 'session-pending-messages.json';
+
+export function pendingShardDir() {
+  return join(resolvePluginData(), PENDING_SHARD_DIR_NAME);
+}
+
+export function pendingMessagesPath(sessionId) {
+  return join(pendingShardDir(), `${sessionId}.json`);
+}
+
+// The pre-sharding global spool; only the one-time migration reads it.
+export function legacyPendingMessagesPath() {
+  return join(resolvePluginData(), LEGACY_PENDING_FILE_NAME);
 }
 
 export function touchPendingSessionEntry(next, sessionId, now = Date.now()) {

package/src/runtime/agent/orchestrator/session/manager/pending-spool-shard.mjs

@@ -0,0 +1,139 @@
+// Per-session pending spool shards: the locked read-modify-write every
+// mutation goes through, plus the one-time migration of the pre-sharding
+// global spool file. Kept free of the queue machinery so the TUI steering
+// mirror shares it without loading the runtime queue.
+import { readFile, rename, stat, unlink } from 'node:fs/promises';
+import { updateJsonAtomic, withFileLock } from '../../../../shared/atomic-file.mjs';
+import { legacyPendingMessagesPath, pendingMessagesPath, PENDING_MESSAGES_MODE } from './pending-spool-path.mjs';
+
+const SHARD_KEY_RE = /^[A-Za-z0-9_-]+$/;
+const MIGRATION_LOCK_TIMEOUT_MS = 15_000;
+
+export function isShardKey(key) {
+  return typeof key === 'string' && SHARD_KEY_RE.test(key);
+}
+
+function storeIsEmpty(store) {
+  return (
+    Boolean(store) &&
+    typeof store === 'object' &&
+    (!store.sessions || typeof store.sessions !== 'object' || Object.keys(store.sessions).length === 0)
+  );
+}
+
+// One shard transaction: locked, compact, non-fsync. A shard emptied by the
+// mutation (or found empty) is deleted under the same lock, so the directory
+// holds only sessions that actually have queued rows.
+async function updateShardFile(key, mutate, extra = null) {
+  const path = pendingMessagesPath(key);
+  return withFileLock(
+    `${path}.lock`,
+    async () => {
+      const result = await updateJsonAtomic(path, mutate, {
+        compact: true,
+        lock: true,
+        mode: PENDING_MESSAGES_MODE,
+        fsync: false,
+        ...extra,
+      });
+      if (storeIsEmpty(result)) {
+        try {
+          await unlink(path);
+        } catch (error) {
+          if (error?.code !== 'ENOENT') throw error;
+        }
+      }
+      return result;
+    },
+    { ...extra }
+  );
+}
+
+function rowKey(row) {
+  return row && typeof row === 'object' && typeof row.id === 'string' && row.id ? `id:${row.id}` : `json:${JSON.stringify(row)}`;
+}
+
+// Idempotent merge of one legacy bucket into its shard: legacy rows (older)
+// first, then whatever the shard already holds; rows already present by id are
+// not duplicated, so a re-run after a crash changes nothing.
+function mergeLegacyBucket(key, legacyRows, legacyTouchedAt) {
+  return (raw) => {
+    const current = Array.isArray(raw?.sessions?.[key]) ? raw.sessions[key] : [];
+    const present = new Set(current.map(rowKey));
+    const additions = legacyRows.filter((row) => !present.has(rowKey(row)));
+    if (additions.length === 0) return undefined;
+    const now = Date.now();
+    const currentTouched = Number(raw?.sessionTouchedAt?.[key]) || 0;
+    return {
+      version: 1,
+      updatedAt: now,
+      sessions: { [key]: [...additions, ...current] },
+      sessionTouchedAt: { [key]: currentTouched || legacyTouchedAt || now },
+    };
+  };
+}
+
+async function migrateLegacySpool() {
+  const legacyPath = legacyPendingMessagesPath();
+  try {
+    await stat(legacyPath);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return;
+    throw error;
+  }
+  // Every process migrates under the legacy file's own lock, so exactly one
+  // performs the merge and the rest find the file already renamed away. The
+  // shard locks are only taken inside it (shard operations never take the
+  // legacy lock), so there is no lock-order cycle. The backup rename is the
+  // commit point: a crash before it re-runs the (idempotent) merge.
+  await withFileLock(
+    `${legacyPath}.lock`,
+    async () => {
+      let text;
+      try {
+        text = await readFile(legacyPath, 'utf8');
+      } catch (error) {
+        if (error?.code === 'ENOENT') return;
+        throw error;
+      }
+      let parsed = null;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        // Unreadable content cannot be migrated; keep it as the backup.
+      }
+      const sessions = parsed && typeof parsed.sessions === 'object' && parsed.sessions ? parsed.sessions : {};
+      for (const [key, rows] of Object.entries(sessions)) {
+        if (!isShardKey(key) || !Array.isArray(rows) || rows.length === 0) continue;
+        const touched = Number(parsed.sessionTouchedAt?.[key]) || Number(parsed.updatedAt) || 0;
+        await updateShardFile(key, mergeLegacyBucket(key, rows, touched), { timeoutMs: MIGRATION_LOCK_TIMEOUT_MS });
+      }
+      await rename(legacyPath, `${legacyPath}.migrated-${Date.now()}-${process.pid}.bak`);
+    },
+    { timeoutMs: MIGRATION_LOCK_TIMEOUT_MS }
+  );
+}
+
+let migration = null;
+
+// Resolves once this process has seen the legacy spool migrated (or absent).
+// A failure is not memoized: the next shard operation retries it.
+export function ensurePendingSpoolMigrated() {
+  if (!migration) {
+    migration = migrateLegacySpool().catch((error) => {
+      migration = null;
+      throw error;
+    });
+  }
+  return migration;
+}
+
+// TEST-ONLY: forget that this process already migrated (temp data dirs change).
+export function _resetPendingSpoolMigrationForTest() {
+  migration = null;
+}
+
+export async function updatePendingShard(key, mutate, extra = null) {
+  await ensurePendingSpoolMigrated();
+  return updateShardFile(key, mutate, extra);
+}

package/src/runtime/agent/orchestrator/session/manager/pending-spool-sweep.mjs

@@ -1,9 +1,13 @@
 // Spool hygiene: eviction of stale/orphaned session queues from the shared
 // pending-message file, plus the boot-time sweep the lead process schedules.
 // Retention policy only — it never delivers, claims or acknowledges anything.
+import { readdir } from 'node:fs/promises';
 import { loadSession } from '../store.mjs';
+import { pendingShardDir } from './pending-spool-path.mjs';
+import { ensurePendingSpoolMigrated } from './pending-spool-shard.mjs';
 import {
   isTuiSteeringPendingKey,
+  isValidPendingSessionId,
   normalizePendingStore,
   pendingWarn,
   setSpoolQueue,
@@ -36,21 +40,37 @@ export async function sweepOrphanedPendingMessages({ ttlMs = PENDING_ORPHAN_TTL_
   const now = Date.now();
   const removed = [];
   try {
-    await updateSpool((raw) => {
-      const next = normalizePendingStore(raw);
-      const ids = Object.keys(next.sessions);
-      if (ids.length === 0) return undefined;
-      for (const sid of ids) {
-        const entryTouchedAt = next.sessionTouchedAt?.[sid];
-        if (shouldEvictPendingSession(sid, ttlMs, entryTouchedAt, now)) {
-          setSpoolQueue(next, sid, []);
-          removed.push(sid);
+    await ensurePendingSpoolMigrated();
+    let names = [];
+    try {
+      names = await readdir(pendingShardDir());
+    } catch (err) {
+      if (err?.code !== 'ENOENT') throw err;
+    }
+    // Shards are independent files: walk them one at a time so the sweep never
+    // holds more than one session's lock.
+    for (const name of names) {
+      if (!name.endsWith('.json')) continue;
+      const key = name.slice(0, -'.json'.length);
+      if (!isValidPendingSessionId(key)) continue;
+      await updateSpool(key, (raw) => {
+        const next = normalizePendingStore(raw);
+        const ids = Object.keys(next.sessions);
+        if (ids.length === 0) return next;
+        let changed = false;
+        for (const sid of ids) {
+          const entryTouchedAt = next.sessionTouchedAt?.[sid];
+          if (shouldEvictPendingSession(sid, ttlMs, entryTouchedAt, now)) {
+            setSpoolQueue(next, sid, []);
+            removed.push(sid);
+            changed = true;
+          }
         }
-      }
-      if (removed.length === 0) return undefined;
-      next.updatedAt = now;
-      return next;
-    });
+        if (!changed) return undefined;
+        next.updatedAt = now;
+        return next;
+      });
+    }
   } catch (err) {
     pendingWarn(`[session] pending-message sweep failed: ${err?.message || err}\n`);
     return 0;

package/src/runtime/agent/orchestrator/session/manager/prefetch-bridge/file-prefetch.mjs

@@ -61,7 +61,7 @@ export async function prefetchFiles(session, { files, readOpts }, signal) {
         // Only cache default-window reads; custom-window results would poison
         // the shared cross-dispatch cache.
         if (!readOpts.has(file)) setPrefetchCached(abs, content, readStates.get(file));
-      } else if (content === undefined || classifyResultKind(content) === 'error') {
+      } else {
         failed.push(file);
       }
     }

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -3,6 +3,7 @@
 import { isInternalRuntimeNotificationText as contractIsInternalRuntimeNotificationText } from '../../../../shared/tool-execution-contract.mjs';
 import { formatLocalAndUtcTimestamp } from '../../../../shared/time-format.mjs';
 import { SUMMARY_PREFIX } from '../compact.mjs';
+import { isProtectedContextUserMessage } from '../compact/messages.mjs';
 import { attachmentTextForPart, isAttachmentReference } from '../../../../attachments/store.mjs';
 
 export function promptContentText(content) {
@@ -42,14 +43,6 @@ export function prefixUserTurnContent(content, contextBlock) {
   return `${contextBlock}# Task\n${content}`;
 }
 
-export function prefixSessionStartContent(content, sessionBlock) {
-  if (!sessionBlock) return content;
-  if (Array.isArray(content)) {
-    return [{ type: 'text', text: `${sessionBlock}\n\n` }, ...content];
-  }
-  return `${sessionBlock}\n\n${content}`;
-}
-
 // Per-turn <system-reminder> blocks (current time, deferred-tool delta, Goal
 // state) trail the human's words instead of leading them: the user's own
 // language is then the last thing the model reads before answering, and the
@@ -99,7 +92,7 @@ function sessionModelDisplay(model) {
     .replace(/(?:^|-)([a-z])/g, (m) => m.toUpperCase());
 }
 
-export function buildSessionStartBlock(session, cwd) {
+function buildSessionStartBlock(session, cwd) {
   if (!session || session.owner === 'agent') return '';
   const lines = ['# Session'];
   const effectiveCwd = String(cwd || session.cwd || '').trim();
@@ -207,7 +200,7 @@ export function resetSessionBp3Environment(session) {
   return true;
 }
 
-export function isReferenceFilesMessage(message) {
+function isReferenceFilesMessage(message) {
   return (
     message?.role === 'user' &&
     typeof message.content === 'string' &&
@@ -215,14 +208,7 @@ export function isReferenceFilesMessage(message) {
   );
 }
 
-export function isProtectedContextUserMessage(message) {
-  if (message?.role !== 'user' || typeof message.content !== 'string') return false;
-  const content = message.content.trim();
-  if (!content.toLowerCase().startsWith('<system-reminder>')) return false;
-  const closingTag = '</system-reminder>';
-  const closingIndex = content.toLowerCase().indexOf(closingTag);
-  return closingIndex < 0 || content.slice(closingIndex + closingTag.length).trim() === '';
-}
+export { isProtectedContextUserMessage };
 
 // Compact summary messages (role:'user', content startsWith SUMMARY_PREFIX)
 // are synthetic anchors, not a real human turn — they must not count as

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -425,7 +425,7 @@ export function forEachSessionRuntime() {
 
 // Wire the usage-metrics runtime accessor to this module's _runtimeState so
 // persistIterationMetrics can read the live in-memory session and flag
-// usageMetricsTurnIncremental. (Moved with the map from manager.mjs.)
+// usageMetricsTurnIncremental.
 configureUsageMetricsRuntime({ getRuntimeEntry: (id) => _runtimeState.get(id) });
 
 /** Mark session hidden so listSessions() filters it out (runtime-only). */

package/src/runtime/agent/orchestrator/session/manager/session-close.mjs

@@ -30,7 +30,7 @@ import { cancelNativeTasks } from '../../tools/lib/native-spawn-client.mjs';
  * If we delete the file, a late save sees no file, decides nothing to drop,
  * and recreates the session in its pre-close state.
  *
- * Long-term cleanup: `sweepTombstones()` below unlinks tombstones older than
+ * Long-term cleanup: `sweepTombstones()` (idle-cleanup.mjs) unlinks tombstones older than
  * TOMBSTONE_MAX_AGE_MS (1h — vastly longer than the microsecond in-flight race).
  */
 export function closeSession(id, reason = 'manual', opts = {}) {
@@ -67,23 +67,15 @@ export function closeSession(id, reason = 'manual', opts = {}) {
   //    write could silently overwrite the session after the user resumes
   //    it back (BL: burned-session late-save clobber).
   const newGen = tombstone ? markSessionClosed(id, reason) : bumpSessionGeneration(id, reason);
-  // Durable lifecycle barrier check. `null` is ambiguous — it covers both a
-  // legitimate veto (session gone, live owner, contended commit) and a
-  // FAILED durable write. Only the latter publishes a lifecycle commit
-  // error. When the barrier never landed there is no tombstone and no
-  // generation bump on disk, so nothing fences a late save: tearing down
-  // here would abort the provider and clear the crash checkpoint while the
-  // session remains open and resumable on disk — the exact way a failed
-  // close silently destroys a turn. Leave every runtime structure intact,
-  // surface the cause, and report failure to the caller.
-  // ANY nonnumeric result means the barrier is not on disk — a write
-  // failure, a liveness/ownership veto, a contended commit lock, or a
-  // missing record. The detail map only explains WHY when the cause was a
-  // failed write; its absence is not evidence of success. Treating a
-  // detail-less null as a close is what let a vetoed/failed close abort the
-  // provider and drop the crash checkpoint while the session stayed open and
-  // resumable on disk. Leave every runtime structure intact and report
-  // failure in all of them.
+  // Durable lifecycle barrier check. ANY nonnumeric result means the barrier
+  // is not on disk — a write failure, a liveness/ownership veto, a contended
+  // commit lock, or a missing record. Only a failed write publishes a
+  // lifecycle commit error, so a detail-less null is not evidence of success.
+  // Without the barrier there is no tombstone and no generation bump fencing
+  // a late save: tearing down here would abort the provider and clear the
+  // crash checkpoint while the session stays open and resumable on disk — the
+  // way a failed close silently destroys a turn. Leave every runtime
+  // structure intact, surface the cause, and report failure to the caller.
   if (typeof newGen !== 'number') {
     reportCloseBarrierFailure({ id, reason, tombstone, entry });
     return false;

package/src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs

@@ -10,7 +10,7 @@ import { isAgentOwner } from '../../agent-owner.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
 import { buildProviderCacheOpts, cacheCapabilityForProvider } from '../../agent-runtime/cache-strategy.mjs';
-import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../../../../session-runtime/config-helpers.mjs';
+import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
 import { _buildBaseRules } from './rules-cache.mjs';
 import { composeSessionSystem, seedSessionMessages } from './session-prompt-composition.mjs';
 import { _prepareResumeTools, delegationDisabled, resolveSessionToolSurface } from './session-tool-surface.mjs';

package/src/runtime/agent/orchestrator/session/manager/session-record.mjs

@@ -3,7 +3,7 @@
 // compaction budget, the origin/permission/cache metadata analytics slice on,
 // the desktop classification, and the record assembled from them. Everything
 // here is field derivation — no I/O, no ownership, no prompt text.
-import { toSessionWorkflowMeta } from '../../../../../session-runtime/workflow.mjs';
+import { toSessionWorkflowMeta } from '../../runtime-core/workflow.mjs';
 import { sessionOrchestrationMode } from '../../../../shared/orchestration.mjs';
 import { preserveBufferConfigFields } from './context-meta.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
@@ -34,7 +34,7 @@ export function normalizeDesktopSessionMetadata(value, cwd = null) {
   return null;
 }
 
-export function initialCompactionConfig(compaction = {}, contextMeta = {}) {
+function initialCompactionConfig(compaction = {}, contextMeta = {}) {
   return {
     auto: compaction?.auto !== false,
     model: compaction?.model || null,

package/src/runtime/agent/orchestrator/session/manager/session-tool-surface.mjs

@@ -8,7 +8,7 @@
 import { collectPromptSkillsCached } from '../../context/collect.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
-import { workflowDisallowsAgentTool } from '../../../../../session-runtime/workflow.mjs';
+import { workflowDisallowsAgentTool } from '../../runtime-core/workflow.mjs';
 import { sessionOrchestrationMode } from '../../../../shared/orchestration.mjs';
 import { finalizeSessionToolList, resolveSessionTools, permissionFromToolSpec } from './tool-resolution.mjs';
 import { unusedModelEditToolName } from '../../../../shared/edit-tool-dialect.mjs';

package/src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs

@@ -8,8 +8,8 @@ import { PATCH_TOOL_DEFS } from '../../tools/patch-tool-defs.mjs';
 import { CODE_GRAPH_TOOL_DEFS } from '../../tools/code-graph-tool-defs.mjs';
 import { buildSkillToolDefs } from '../../context/collect.mjs';
 import { filterModelEditTools } from '../../../../shared/edit-tool-dialect.mjs';
-import { filterMcpToolsForSession } from '../../../../../session-runtime/extension-scopes.mjs';
-import { ROUTE_TOOL_ORDER } from '../../../../../session-runtime/tool-catalog-data.mjs';
+import { filterMcpToolsForSession } from '../../runtime-core/extension-scopes.mjs';
+import { ROUTE_TOOL_ORDER } from '../../runtime-core/tool-catalog-data.mjs';
 
 // Merge externally-connected MCP tools with the plugin's in-process tools
 // (registered by agent's toolExecutor adapter). Internal tools are exposed

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint.mjs

@@ -113,18 +113,14 @@ export function createTurnCheckpointRecorder({ sessionId, generation, turnToken,
     stop() {
       if (stopped) return;
       stopped = true;
-      cancelPendingTurnCheckpoint(sessionId);
+      // Retire queued (not yet written) appends. The durable prefix stays on
+      // disk on purpose: between turn commit and clearTurnCheckpoint a crash
+      // must still recover the turn's work, not just its opening header.
+      cancelJournalWrites(sessionId);
     },
   };
 }
 
-/** Retire queued (not yet written) journal appends for a session. The durable
- * prefix stays on disk on purpose: between turn commit and clearTurnCheckpoint
- * a crash must still recover the turn's work, not just its opening header. */
-function cancelPendingTurnCheckpoint(sessionId) {
-  cancelJournalWrites(sessionId);
-}
-
 export function readTurnCheckpoint(sessionId) {
   const header = readTurnCheckpointHeader(sessionId);
   if (!header) return null;
@@ -141,7 +137,7 @@ export function clearTurnCheckpoint(sessionId, turnToken = null) {
   // turn's checkpoint; retire them BEFORE the token guard reads disk so a
   // lagging write can never resurrect state after the unlink.
   if (!turnToken) {
-    cancelPendingTurnCheckpoint(sessionId);
+    cancelJournalWrites(sessionId);
     let removed = true;
     try {
       unlinkSync(target);
@@ -158,7 +154,7 @@ export function clearTurnCheckpoint(sessionId, turnToken = null) {
   // A token guard prevents an older turn's late terminal save from
   // deleting the checkpoint already created by its queued follow-up.
   if (current.header?.turnToken && current.header.turnToken !== turnToken) return false;
-  cancelPendingTurnCheckpoint(sessionId);
+  cancelJournalWrites(sessionId);
   let removed = true;
   try {
     unlinkSync(target);

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -66,8 +66,7 @@ export {
   enqueueRemotePendingMessage,
   drainForeignUserInjections,
   drainPendingMessages,
-  // Shutdown drain for runtime hosts (session-runtime-worker calls this
-  // before exit so buffered/in-flight spool writes are never abandoned).
+  // Shutdown drain so buffered/in-flight spool writes are never abandoned.
   settlePendingMessageWrites,
   markCompletionEntry,
   COMPLETION_NOTIFICATION_KIND,

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -8,6 +8,7 @@ import {
   currentContextEstimateTokens,
   compactTargetBudget,
   shouldCompactForRequestMedia,
+  shouldCompactForExpiredAgentCache,
   shouldCompactForSession,
   rememberCompactTelemetry,
   recordContextUsageSnapshot,
@@ -22,14 +23,14 @@ import { reasoningUsage } from '../../../shared/llm/reasoning-usage.mjs';
 import { agentCompactFailedError, agentContextOverflowError } from './loop/context-overflow.mjs';
 import { isContextOverflowError } from '../providers/retry-classifier.mjs';
 import { traceAgentCompact, messagePrefixHash } from '../agent-trace.mjs';
-import { invalidateProviderRequestToolsScope } from '../../../../session-runtime/provider-request-tools.mjs';
-import { bumpUsageMetricsEpoch } from './manager.mjs';
+import { invalidateProviderRequestToolsScope } from '../runtime-core/provider-request-tools.mjs';
+import { bumpUsageMetricsEpoch } from './manager/usage-metrics.mjs';
 import { resetReadStateAfterCompaction } from './read-dedup.mjs';
 import {
   acknowledgePendingGoalReminder,
   markPendingGoalReminder,
   snapshotPendingGoalReminder,
-} from '../../../../session-runtime/goal-reminder.mjs';
+} from '../runtime-core/goal-reminder.mjs';
 
 function writeStderr(line) {
   try {
@@ -71,6 +72,8 @@ function transcriptPrefixHash(messages) {
 // same event. A pending reactive-overflow retry makes THIS compact pass the
 // recovery from a provider overflow refusal, not the proactive pressure
 // trigger — the emitted events are tagged so telemetry can tell them apart.
+// An agent whose 5m message cache expired compacts before the cold send
+// whatever its size (trigger 'cache_expired').
 function preSendCompactDecision(state, compactPolicy) {
   const { messages, sessionRef } = state;
   const messageTokensEst = estimateMessagesTokensSafe(messages);
@@ -80,9 +83,11 @@ function preSendCompactDecision(state, compactPolicy) {
     messages,
     sessionRef,
   });
+  const cacheExpired = shouldCompactForExpiredAgentCache(sessionRef, state.opts);
   const shouldCompact =
     state.skipProactiveCompact !== true &&
-    (shouldCompactForRequestMedia(messages) ||
+    (cacheExpired ||
+      shouldCompactForRequestMedia(messages) ||
       shouldCompactForSession(messageTokensEst, compactPolicy, {
         forceReactive: reactivePending,
         messages,
@@ -93,7 +98,7 @@ function preSendCompactDecision(state, compactPolicy) {
     messageTokensEst,
     pressureTokens,
     shouldCompact,
-    compactTrigger: reactivePending ? 'reactive' : 'auto',
+    compactTrigger: reactivePending ? 'reactive' : cacheExpired ? 'cache_expired' : 'auto',
     compactBudgetTokens: shouldCompact
       ? compactTargetBudget({ ...compactPolicy, pressureTokens }) || compactPolicy.boundaryTokens
       : compactPolicy.boundaryTokens,
@@ -234,7 +239,7 @@ async function compactTranscript(ctx, run) {
     sessionId,
     signal,
     provider,
-    model: resolveHandoffSummaryModel(sessionRef, { budgetTokens: compactBudgetTokens }) || model,
+    model: resolveHandoffSummaryModel(sessionRef) || model,
     sendOpts: opts,
     goalReminderText: run.inlineGoalReminder?.content || '',
     activeTurn: true,

package/src/runtime/agent/orchestrator/session/result-classification.mjs

@@ -61,7 +61,7 @@ const ZERO_MATCH_PREFIXES = [
 const READ_ONLY_NAVIGATION_TOOLS = new Set(['find', 'glob', 'grep', 'list', 'read', 'code_graph']);
 
 const NAVIGATION_MISS_RE =
-  /\b(?:enoent|enotdir)\b|path does not exist|directory does not exist|no such (?:file|path)|not found at this path|file not found in graph/i;
+  /\b(?:enoent|enotdir)\b|path does not exist|directory does not exist|no such (?:file|path)|not found at this path|file not found\b|symbol "[^"\n]*" not found in /i;
 
 export function isReadOnlyNavigationMiss(toolName, result) {
   if (!READ_ONLY_NAVIGATION_TOOLS.has(String(toolName || '').toLowerCase())) return false;