mixdog 0.9.39 → 0.9.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.39",
+  "version": "0.9.40",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/agent-terminal-reap-test.mjs

@@ -33,16 +33,16 @@ try {
     AUTO_CLEAR_PROVIDER_IDLE_MS.anthropic,
     'global idleMs and default row are ignored for listed providers',
   );
-  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'default'), null, 'default row is ignored');
-  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'unlisted'), null, 'unlisted override is ignored');
-  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'unknown'), null, 'unknown provider is ignored');
+  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'default'), 90_000, 'default row applies to default provider');
+  assert.equal(resolveAgentTerminalReapMs(overrideConfig, 'unlisted'), 90_000, 'default row applies to unlisted provider');
+  assert.equal(resolveAgentTerminalReapMs({ autoClear: {} }, 'unknown'), AUTO_CLEAR_PROVIDER_IDLE_MS.default, 'unknown provider uses built-in default');
 
   mkdirSync(join(root, 'sessions'), { recursive: true });
   writeFileSync(join(root, 'mixdog-config.json'), JSON.stringify({
     agent: { autoClear: overrideConfig.autoClear },
   }));
   const { sweepStaleSessions } = await import('../src/runtime/agent/orchestrator/session/store.mjs');
-  const old = Date.now() - 61_000;
+  const old = Date.now() - 181_000;
   const known = {
     id: 'sess_known_reap',
     owner: 'agent',
@@ -81,7 +81,7 @@ try {
     'short provider override bypasses the default sweep freshness gate',
   );
   assert.ok(defaultSweep.details.some((detail) => detail.id === known.id), 'store reaps a listed provider at its Advanced duration');
-  assert.ok(!defaultSweep.details.some((detail) => detail.id === unknown.id), 'store never sweeps an unlisted provider');
+  assert.ok(defaultSweep.details.some((detail) => detail.id === unknown.id), 'store reaps an unlisted provider at the default duration');
 
   const dataDir = join(root, 'worker-index');
   mkdirSync(dataDir, { recursive: true });
@@ -116,7 +116,7 @@ try {
   });
   const workers = agent.getStatus().workers;
   assert.ok(!workers.some((worker) => worker.tag === 'known'), 'worker row expires at the provider duration');
-  assert.ok(workers.some((worker) => worker.tag === 'unknown'), 'unlisted worker row does not expire');
+  assert.ok(!workers.some((worker) => worker.tag === 'unknown'), 'unlisted worker row expires at the default duration');
   agent.closeAll('agent-terminal-reap-test');
 
   process.stdout.write(`agent terminal reap test passed (${builtIns.length} providers)\n`);

package/scripts/execution-resume-esc-integration-test.mjs

@@ -146,9 +146,10 @@ for (const phase of ['before first delta', 'after response progress']) {
       harness.activeAsk().options.onTextDelta('partial response\n');
       await wait(40);
       assert.equal(
-        harness.state.items.some((item) => item.kind === 'assistant' && /partial response/.test(item.text)),
+        harness.state.streamingTail?.kind === 'assistant'
+          && /partial response/.test(harness.state.streamingTail.text),
         true,
-        'response progress reached the live turn',
+        'response progress reached the dedicated live tail',
       );
     }
 
@@ -157,6 +158,7 @@ for (const phase of ['before first delta', 'after response progress']) {
     assert.equal(harness.state.busy, false, 'busy clears after the real abort unwind');
     assert.equal(harness.state.spinner, null, 'spinner clears after Esc');
     assert.equal(harness.state.thinking, null, 'thinking clears after Esc');
+    assert.equal(harness.state.streamingTail == null, true, 'Esc leaves no orphaned streaming tail');
 
     harness.deliver(completion('execution_A', 'duplicate retry'));
     await tick();

package/scripts/steering-drain-buckets-test.mjs

@@ -3,6 +3,8 @@ import assert from 'node:assert/strict';
 import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
 import { createRunTurn } from '../src/tui/engine/turn.mjs';
 
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
 // Minimal bag: drainPendingSteering only touches pending, the queue helpers,
 // and commitSteeringQueueEntries (which no-ops on disk when runtime.id is not
 // a valid session key). No provider/runTurn wiring needed.
@@ -71,7 +73,7 @@ test('drainPendingSteering accepts runtime callback signature', () => {
   assert.equal(bag.pending.length, 0);
 });
 
-test('drained notification key remains deduped and displayed key is not cleared', () => {
+test('drained notification key is released while displayed key is not cleared', () => {
   const { flow, bag } = makeFlow();
   bag.getState().busy = true;
   assert.equal(flow.enqueue('task finished', { mode: 'task-notification', key: 'task-1' }), true);
@@ -80,7 +82,7 @@ test('drained notification key remains deduped and displayed key is not cleared'
   const out = flow.drainPendingSteering({ maxPriority: 'later' });
 
   assert.deepEqual(out, ['task finished']);
-  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), false);
+  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), true);
   assert.equal(bag.displayedExecutionNotificationKeys.has('task-1'), true);
 });
 
@@ -123,7 +125,11 @@ test('post-turn drain does not send queued slash command to model', async () =>
 // Minimal store bag for createRunTurn: only the surface the streaming/steering
 // finalize path touches. runtime.ask is a caller-supplied mock that drives the
 // text-delta / steer-message callbacks.
-function makeTurnBag(ask) {
+function makeTurnBag(ask, {
+  timeoutMs = 300000,
+  getTurnLiveness,
+  abort,
+} = {}) {
   let seq = 0;
   const state = {
     items: [],
@@ -134,11 +140,13 @@ function makeTurnBag(ask) {
   };
   const itemIndexById = new Map();
   const findIndexById = (id) => state.items.findIndex((it) => it.id === id);
+  const runtime = { id: null, toolMode: 'auto', ask, abort: abort || (() => {}) };
+  if (typeof getTurnLiveness === 'function') runtime.getTurnLiveness = getTurnLiveness;
   const bag = {
-    runtime: { id: null, toolMode: 'auto', ask, abort: () => {} },
+    runtime,
     nextId: () => `id_${++seq}`,
     tuiDebug: () => {},
-    LEAD_TURN_TIMEOUT_MS: 300000,
+    LEAD_TURN_TIMEOUT_MS: timeoutMs,
     flags: { leadTurnEpoch: 0 },
     pending: [],
     itemIndexById,
@@ -176,6 +184,133 @@ function makeTurnBag(ask) {
   return { bag, getState: () => state };
 }
 
+test('watchdog accepts fresh runtime liveness without tripping', async () => {
+  let aborts = 0;
+  const ask = async () => {
+    await wait(45);
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs: 15,
+    abort: () => { aborts += 1; },
+    getTurnLiveness: () => ({
+      stage: 'tool_running',
+      lastProgressAt: Date.now(),
+      toolStartedAt: Date.now(),
+      toolSelfDeadlineMs: 0,
+    }),
+  });
+
+  assert.equal(await createRunTurn(bag)('do a thing'), 'done');
+  assert.equal(aborts, 0, 'fresh orchestrator heartbeats defer the watchdog');
+});
+
+test('watchdog trips at the tool ceiling despite fresh liveness', async () => {
+  const previousMax = process.env.MIXDOG_LEAD_TOOL_MAX_MS;
+  const timeoutMs = 30;
+  const ceilingMs = 95;
+  process.env.MIXDOG_LEAD_TOOL_MAX_MS = String(ceilingMs);
+  let rejectAsk;
+  let heartbeatTimer = null;
+  let heartbeatStartTimer = null;
+  let aborts = 0;
+  let abortAt = 0;
+  let livenessCalls = 0;
+  const toolStartedAt = Date.now();
+  const ask = (_userText, options) => new Promise((_resolve, reject) => {
+    rejectAsk = reject;
+    // Let the first watchdog probe defer from orchestrator liveness, then keep
+    // the TUI's local progress fresh so the ceiling-bounded re-arm is exercised.
+    heartbeatStartTimer = setTimeout(() => {
+      heartbeatTimer = setInterval(() => options.onStreamDelta(), 5);
+    }, 40);
+  });
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs,
+    abort: () => {
+      aborts += 1;
+      abortAt = Date.now();
+      clearTimeout(heartbeatStartTimer);
+      clearInterval(heartbeatTimer);
+      const error = new Error('interrupted');
+      error.name = 'SessionClosedError';
+      rejectAsk(error);
+    },
+    getTurnLiveness: () => {
+      livenessCalls += 1;
+      return {
+        stage: 'tool_running',
+        lastProgressAt: Date.now(),
+        toolStartedAt,
+        toolSelfDeadlineMs: 0,
+      };
+    },
+  });
+
+  try {
+    const result = await Promise.race([
+      createRunTurn(bag)('do a thing'),
+      wait(180).then(() => 'watchdog did not trip at the ceiling'),
+    ]);
+    assert.equal(result, 'cancelled');
+    assert.equal(aborts, 1);
+    assert.ok(livenessCalls >= 2, 'first probe deferred, then the ceiling probe rechecked liveness');
+    assert.ok(abortAt - toolStartedAt < ceilingMs + timeoutMs, 'ceiling trips before an unbounded watchdog interval');
+  } finally {
+    clearTimeout(heartbeatStartTimer);
+    clearInterval(heartbeatTimer);
+    if (previousMax === undefined) delete process.env.MIXDOG_LEAD_TOOL_MAX_MS;
+    else process.env.MIXDOG_LEAD_TOOL_MAX_MS = previousMax;
+  }
+});
+
+for (const [name, getTurnLiveness] of [
+  ['throws', () => { throw new Error('liveness unavailable'); }],
+  ['returns null', () => null],
+]) {
+  test(`watchdog ${name} probe falls back to abort`, async () => {
+    let rejectAsk;
+    let aborts = 0;
+    const ask = () => new Promise((_resolve, reject) => { rejectAsk = reject; });
+    const { bag } = makeTurnBag(ask, {
+      timeoutMs: 15,
+      getTurnLiveness,
+      abort: () => {
+        aborts += 1;
+        const error = new Error('interrupted');
+        error.name = 'SessionClosedError';
+        rejectAsk(error);
+      },
+    });
+
+    const [result] = await Promise.all([createRunTurn(bag)('do a thing'), wait(40)]);
+    assert.equal(result, 'cancelled');
+    assert.equal(aborts, 1);
+  });
+}
+
+test('stream-delta progress keeps the watchdog alive', async () => {
+  let aborts = 0;
+  let streamDeltas = 0;
+  const ask = async (_userText, options) => {
+    options.onStreamDelta();
+    streamDeltas += 1;
+    await wait(12);
+    options.onStreamDelta();
+    streamDeltas += 1;
+    await wait(12);
+    return { result: { content: '' }, session: { messages: [] } };
+  };
+  const { bag } = makeTurnBag(ask, {
+    timeoutMs: 20,
+    abort: () => { aborts += 1; },
+  });
+
+  assert.equal(await createRunTurn(bag)('do a thing'), 'done');
+  assert.equal(streamDeltas, 2);
+  assert.equal(aborts, 0);
+});
+
 test('onSteerMessage commits a streamed no-newline assistant tail into items', async () => {
   // A terminal no-tool response streams a single line WITHOUT a trailing '\n',
   // so no assistant row/currentAssistantId exists yet. A steering injection

package/scripts/tui-transcript-perf-test.mjs

@@ -0,0 +1,279 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createEngineItemMutators, replaceEngineItemsState } from '../src/tui/engine.mjs';
+import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
+import { createRunTurn } from '../src/tui/engine/turn.mjs';
+import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-window.mjs';
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function makeTurnHarness(ask) {
+  let seq = 0;
+  let state = {
+    items: [],
+    structureRevision: 0,
+    streamingTail: null,
+    stats: { turns: 0, inputTokens: 0, outputTokens: 0 },
+    busy: false,
+    spinner: null,
+    thinking: null,
+  };
+  const itemIndexById = new Map();
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const pushItem = (item) => {
+    const items = [...state.items, item];
+    if (item?.id != null) itemIndexById.set(item.id, items.length - 1);
+    set({ items, structureRevision: state.structureRevision + 1 });
+  };
+  const updateStreamingTail = (id, patch) => set({
+    streamingTail: {
+      ...(state.streamingTail?.id === id ? state.streamingTail : {}),
+      ...patch,
+      kind: 'assistant',
+      id,
+      streaming: true,
+    },
+  });
+  const { patchItem, settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  const clearStreamingTail = (id = null) => {
+    if (id == null || state.streamingTail?.id === id) set({ streamingTail: null });
+  };
+  const bag = {
+    runtime: { id: null, toolMode: 'auto', ask, abort: () => true },
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    LEAD_TURN_TIMEOUT_MS: 300_000,
+    flags: { leadTurnEpoch: 0, disposed: false },
+    pending: [],
+    itemIndexById,
+    getState: () => state,
+    set,
+    pushItem,
+    patchItem,
+    updateStreamingTail,
+    settleStreamingTail,
+    clearStreamingTail,
+    pushNotice: () => {},
+    pushUserOrSyntheticItem: () => {},
+    markToolCallActive: () => {},
+    markToolCallDone: () => {},
+    clearActiveToolSummary: () => {},
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    requestToolApproval: async () => ({ approved: false }),
+    patchToolCardResult: () => {},
+    flushToolResults: () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    drain: async () => {},
+    drainPendingSteering: () => [],
+  };
+  return { runTurn: createRunTurn(bag), getState: () => state };
+}
+
+test('stream flush keeps settled items identity and finalize appends one assistant', async () => {
+  let identityStable = false;
+  const harness = makeTurnHarness(async (_text, options) => {
+    const before = harness.getState().items;
+    options.onTextDelta('settled line\n');
+    await wait(30);
+    identityStable = harness.getState().items === before;
+    assert.match(harness.getState().streamingTail?.text || '', /settled line/);
+    return { result: { content: 'settled line\n' }, session: { messages: [] } };
+  });
+
+  assert.equal(await harness.runTurn('go'), 'done');
+  assert.equal(identityStable, true, 'tail flush must not swap settled items');
+  assert.equal(harness.getState().streamingTail, null);
+  const assistants = harness.getState().items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].streaming, false);
+  assert.equal(assistants[0].text, 'settled line\n');
+});
+
+test('abort after stream progress settles the tail and leaves no orphan', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('partial line\n');
+    await wait(30);
+    const error = new Error('interrupted');
+    error.name = 'SessionClosedError';
+    throw error;
+  });
+
+  assert.equal(await harness.runTurn('go'), 'cancelled');
+  assert.equal(harness.getState().streamingTail, null);
+  const assistants = harness.getState().items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].streaming, false);
+  assert.match(assistants[0].text, /partial line/);
+});
+
+// Codifies pre-existing parity: text had no item/currentAssistantId before its first completed line.
+test('abort before a newline has no tail id and preserves prior text-drop parity', async () => {
+  const harness = makeTurnHarness(async (_text, options) => {
+    options.onTextDelta('partial without newline');
+    await wait(30);
+    const error = new Error('interrupted');
+    error.name = 'SessionClosedError';
+    throw error;
+  });
+
+  assert.equal(await harness.runTurn('go'), 'cancelled');
+  assert.equal(harness.getState().streamingTail, null);
+  assert.equal(
+    harness.getState().items.filter((item) => item.kind === 'assistant').length,
+    0,
+    'without a visible tail id, pre-newline text keeps the existing drop-on-abort behavior',
+  );
+});
+
+// Codifies pre-existing parity: the old in-items completed-line snapshot survived starved recovery.
+test('starved Esc recovery settles a non-empty tail exactly once', async () => {
+  let state = {
+    items: [],
+    structureRevision: 0,
+    streamingTail: { id: 'tail_abort', kind: 'assistant', text: 'visible partial\n', streaming: true },
+    queued: [],
+    busy: true,
+    commandBusy: false,
+    spinner: { active: true },
+    thinking: null,
+    lastTurn: null,
+  };
+  const itemIndexById = new Map();
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { patchItem, settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  const bag = {
+    runtime: { abort: () => true },
+    nextId: () => 'notice',
+    flags: { leadTurnEpoch: 1, disposed: false, draining: false, manualAbortRecoveryMs: 10 },
+    pending: [],
+    listeners: new Set(),
+    getState: () => state,
+    set,
+    pushItem: () => {},
+    patchItem,
+    replaceItems: (items) => items,
+    settleStreamingTail,
+    clearStreamingTail: () => set({ streamingTail: null }),
+    pushNotice: () => {},
+    autoClearState: () => ({}),
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    updateAgentJobCard: () => {},
+    requeueEntriesFront: () => {},
+    enqueue: () => {},
+    autoClearBeforeSubmit: async () => {},
+    restoreQueued: () => {},
+    resetStatsAndSyncContext: () => {},
+    drain: async () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    discardExecutionPendingResume: () => {},
+  };
+
+  createEngineApiA(bag).abort();
+  await wait(30);
+  assert.equal(state.streamingTail, null);
+  const assistants = state.items.filter((item) => item.kind === 'assistant');
+  assert.equal(assistants.length, 1);
+  assert.equal(assistants[0].id, 'tail_abort');
+  assert.equal(assistants[0].streaming, false);
+});
+
+test('removeNotice-style replacement preserves the live tail and later settles once', () => {
+  let state = {
+    items: [{ id: 'notice', kind: 'notice', text: 'temporary' }],
+    structureRevision: 4,
+    streamingTail: { id: 'tail_notice', kind: 'assistant', text: 'visible\n', streaming: true },
+  };
+  const itemIndexById = new Map([['notice', 0]]);
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  state = replaceEngineItemsState({
+    state,
+    items: state.items.filter((item) => item.id !== 'notice'),
+    itemIndexById,
+    preserveStreamingTail: true,
+  });
+
+  assert.equal(state.streamingTail?.id, 'tail_notice');
+  assert.equal(settleStreamingTail('tail_notice', { text: 'complete final text' }), true);
+  assert.equal(state.items.length, 1);
+  assert.equal(state.items[0].text, 'complete final text');
+  assert.equal(state.items[0].streaming, false);
+  assert.equal(settleStreamingTail('tail_notice', { text: 'duplicate' }), false);
+  assert.equal(state.items.length, 1);
+});
+
+test('bulk replacement clears the tail and stale settle cannot append into reset transcript', () => {
+  let state = {
+    items: [{ id: 'old', kind: 'user', text: 'old prompt' }],
+    structureRevision: 8,
+    streamingTail: { id: 'stale_tail', kind: 'assistant', text: 'old response\n', streaming: true },
+  };
+  const itemIndexById = new Map([['old', 0]]);
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { settleStreamingTail } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  state = replaceEngineItemsState({ state, items: [], itemIndexById });
+
+  assert.equal(state.streamingTail, null);
+  assert.equal(settleStreamingTail('stale_tail', { text: 'must not reappear' }), false);
+  assert.deepEqual(state.items, []);
+});
+
+test('tool-card revision invalidates the incremental prefix cache', () => {
+  const cacheRef = { current: null };
+  const tail = { id: 'tail', kind: 'assistant', text: 'live\n', streaming: true };
+  let state = {
+    items: [{ id: 'tool', kind: 'tool', name: 'shell', text: 'ok', result: 'ok' }],
+    structureRevision: 1,
+    streamingTail: tail,
+  };
+  const itemIndexById = new Map([['tool', 0]]);
+  const set = (patch) => { state = { ...state, ...patch }; return true; };
+  const { patchItem } = createEngineItemMutators({
+    getState: () => state,
+    set,
+    itemIndexById,
+  });
+  const before = buildTranscriptRowIndexIncremental([...state.items, state.streamingTail], {
+    columns: 24,
+    cacheRef,
+    prefixRevision: state.structureRevision,
+  });
+  const cachedBeforePatch = cacheRef.current;
+  assert.equal(patchItem('tool', {
+    text: 'a much longer tool result '.repeat(20),
+    result: 'a much longer tool result '.repeat(20),
+  }), true);
+  assert.equal(state.structureRevision, 2, 'real engine patchItem bumps revision');
+  const after = buildTranscriptRowIndexIncremental([...state.items, state.streamingTail], {
+    columns: 24,
+    cacheRef,
+    prefixRevision: state.structureRevision,
+  });
+
+  assert.notEqual(cacheRef.current, cachedBeforePatch, 'revision bump rebuilds the prefix cache');
+  assert.equal(after.rows.length, before.rows.length);
+  assert.equal(cacheRef.current.prefixRevision, 2);
+});

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -309,6 +309,12 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
     const errorFirstLine = resultKind === 'error'
         ? _firstNonEmptyLine(_redactLogText(String(resultText ?? ''))).slice(0, 200) || null
         : null;
+    // Failure taxonomy on the tool row itself (mirrors the failure log's
+    // `category`) so trace-level aggregation can exclude expected command
+    // exits (`command-exit`) without joining tool-failures.jsonl.
+    const errorCategory = resultKind === 'error'
+        ? classifyToolFailure(String(resultText ?? ''), toolName)
+        : null;
     // Flat shape — fields named exactly as the agent_calls PG columns so
     // insertAgentCalls can pick them up by direct property access without
     // a payload-unwrap step. result_kind has no column and rides as plain
@@ -327,6 +333,7 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
         tool_args_summary: summarizedArgs,
         result_kind: resultKind || null,
         result_error_first_line: errorFirstLine,
+        result_error_category: errorCategory,
         result_has_next_call: nextCallCount > 0,
         result_next_call_count: nextCallCount,
         result_bytes_est: resultBytesEst,

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -26,6 +26,9 @@ import {
     compactTypeForSession,
 } from './context-meta.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
+import { pruneOffloadSession } from '../tool-result-offload.mjs';
+import { _getPendingMessagesForSession } from './pending-messages.mjs';
+import { isSessionCompactionBlocked } from './runtime-liveness.mjs';
 
 // 'compacting' is a transient in-flight stage written just before semantic /
 // recall-fasttrack compaction runs. If the process crashes or only partially
@@ -489,6 +492,18 @@ export async function runSessionCompaction(session, opts = {}) {
     const unchangedReason = changed ? null : (force ? 'nothing to compact' : 'below threshold');
     const now = Date.now();
     session.messages = compacted;
+    // Best-effort GC only: the 10-minute mtime gate plus this idle-only guard
+    // lets an in-flight turn's sidecars survive until a later compaction/close.
+    const pruneSessionId = opts.sessionId || session.id;
+    if (!isSessionCompactionBlocked(pruneSessionId)) {
+        try {
+            await pruneOffloadSession(pruneSessionId, () => [
+                session.messages,
+                session.liveTurnMessages,
+                _getPendingMessagesForSession(pruneSessionId),
+            ]);
+        } catch { /* best-effort */ }
+    }
     session.providerState = undefined;
     session.compaction = {
         ...(session.compaction || {}),

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

@@ -1,6 +1,7 @@
 // Steering / pending-message queue with sync buffered + atomic-file persistence.
 // Extracted verbatim from manager.mjs (behavior-preserving).
 import { join } from 'path';
+import { readFileSync } from 'fs';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomicSync, updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
 import { promptContentText, isInternalRuntimeNotificationText } from './prompt-utils.mjs';
@@ -458,6 +459,31 @@ export function drainPendingMessages(sessionId) {
     return out;
 }
 
+// Snapshot queued entries without draining them. Compaction uses this to keep
+// sidecars referenced by a message that is waiting for the next turn, whether
+// it is still in memory, buffered for persistence, or already on disk.
+export function _getPendingMessagesForSession(sessionId) {
+    if (!isValidPendingSessionId(sessionId)) return [];
+    const queued = [
+        ...(_sessionPendingMessages.get(sessionId) || []),
+        ...(_pendingPersistBuffers.get(sessionId) || []),
+    ];
+    let raw;
+    try {
+        raw = readFileSync(pendingMessagesPath(), 'utf8');
+    } catch (err) {
+        if (err?.code === 'ENOENT') return queued;
+        throw err;
+    }
+    try {
+        const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
+        if (Array.isArray(persisted)) queued.push(...persisted);
+    } catch (err) {
+        throw err;
+    }
+    return queued;
+}
+
 // Cleanup hook for closeSession — drop the in-memory queue and buffered-persist
 // entry so both Maps do not accumulate one entry per closed session.
 export function _dropPendingMessageState(id, { clearPersisted = true } = {}) {

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -163,6 +163,8 @@ export function bumpUsageMetricsTurnId(session) {
     if (!session || typeof session !== 'object') return 0;
     const next = (Number(session.usageMetricsTurnId) || 0) + 1;
     session.usageMetricsTurnId = next;
+    const seen = _metricSeenIter.get(session.id);
+    if (seen) seen.clear();
     return next;
 }