mixdog 0.9.38 → 0.9.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.38",
+  "version": "0.9.40",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -36,8 +36,8 @@
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run the Release workflow: gh workflow run release -f bump=patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
-    "smoke": "node scripts/smoke.mjs && node --test scripts/ship-mode-test.mjs",
-    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard",
+    "smoke": "node scripts/smoke.mjs && node --test scripts/ship-mode-test.mjs && npm run test:memory-routing && node --test scripts/explore-prompt-policy-test.mjs && node --test scripts/routing-corpus-test.mjs",
+    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard && npm run smoke:live-worker && npm run test:session",
     "smoke:boot": "node scripts/boot-smoke.mjs",
     "smoke:compact": "node scripts/compact-smoke.mjs",
     "smoke:loop": "node scripts/smoke-loop.mjs",
@@ -49,13 +49,18 @@
     "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-queue",
     "smoke:freevars": "node scripts/freevar-smoke.mjs",
     "smoke:logguard": "node scripts/log-writer-guard-smoke.mjs",
+    "smoke:live-worker": "node scripts/live-worker-smoke.mjs",
+    "smoke:agent-tag-reuse": "node scripts/agent-tag-reuse-smoke.mjs",
+    "test:agent-terminal-reap": "node scripts/agent-terminal-reap-test.mjs",
     "test:toolcall": "node --test scripts/toolcall-args-test.mjs",
     "test:shipmode": "node --test scripts/ship-mode-test.mjs",
     "test:shellhardening": "node --test scripts/shell-hardening-test.mjs",
     "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
     "test:providers": "node --test scripts/provider-toolcall-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
-    "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs",
+    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/memory-rule-contract-test.mjs",
+    "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
+    "test:session": "node --test scripts/session-orphan-sweep-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",

package/scripts/abort-recovery-test.mjs

@@ -18,6 +18,8 @@ const wait = (ms) => new Promise((r) => setTimeout(r, ms));
 function makeEngine({ abortSettles = false, recoveryMs = 30 } = {}) {
   let seq = 0;
   const notices = [];
+  const requeued = [];
+  const discardedCompletionKeys = [];
   let drainCount = 0;
   let state = { items: [], queued: [], busy: false, commandBusy: false, spinner: null, thinking: null, lastTurn: null };
   const bag = {
@@ -51,16 +53,24 @@ function makeEngine({ abortSettles = false, recoveryMs = 30 } = {}) {
     syncContextStats: () => {},
     denyAllToolApprovals: () => {},
     updateAgentJobCard: () => {},
-    requeueEntriesFront: () => {},
+    requeueEntriesFront: (entries) => { requeued.push(...entries); },
     resetStatsAndSyncContext: () => {},
     flushDeferredExecutionPendingResumeKick: () => {},
+    discardExecutionPendingResume: (keys) => { discardedCompletionKeys.push(...keys); },
     drain: async () => { drainCount += 1; },
     runTurn: async () => 'ok',
   };
   Object.assign(bag, createSessionFlow(bag));
   bag.drain = async () => { drainCount += 1; };
   const api = createEngineApiA(bag);
-  return { api, bag, getNotices: () => notices, getDrainCount: () => drainCount };
+  return {
+    api,
+    bag,
+    getNotices: () => notices,
+    getDrainCount: () => drainCount,
+    getRequeued: () => requeued,
+    getDiscardedCompletionKeys: () => discardedCompletionKeys,
+  };
 }
 
 test('starved abort → bounded recovery hard-releases busy and re-kicks drain', async () => {
@@ -116,3 +126,34 @@ test('recovery no-ops if a newer turn already owns the store', async () => {
   assert.equal(bag.flags.leadTurnEpoch, 5, 'recovery must not touch a newer turn epoch');
   assert.equal(bag.getState().busy, true, 'newer turn stays busy — not force-released');
 });
+
+for (const phase of ['before first delta', 'after response progress']) {
+  test(`Esc ${phase} abandons the active completion resume`, () => {
+    const {
+      api, bag, getRequeued, getDiscardedCompletionKeys,
+    } = makeEngine({ abortSettles: true });
+    bag.flags.activePromptRestore = {
+      text: 'completion response',
+      restorable: false,
+      committed: false,
+      requeueEntries: [{
+        mode: 'pending-resume',
+        text: 'completion response',
+        abortDiscardOnAbort: true,
+      }],
+      discardExecutionPendingResumeKeys: ['execution_A'],
+    };
+    bag.set({
+      busy: true,
+      spinner: { active: true, responseLength: phase === 'after response progress' ? 24 : 0 },
+      thinking: phase === 'after response progress' ? { text: 'working' } : null,
+    });
+
+    assert.equal(api.abort().aborted, true);
+    assert.equal(bag.getState().busy, false, 'Esc releases the active completion turn');
+    assert.equal(bag.getState().spinner, null, 'spinner is cleared');
+    assert.equal(bag.getState().thinking, null, 'thinking is cleared');
+    assert.deepEqual(getRequeued(), [], 'the completion resume is not requeued');
+    assert.deepEqual(getDiscardedCompletionKeys(), ['execution_A'], 'its completion ownership is retired');
+  });
+}

package/scripts/agent-tag-reuse-smoke.mjs

@@ -12,10 +12,9 @@
 // session manager so resolveTag / worker-index behavior is exercised end to end.
 //
 // Run: node scripts/agent-tag-reuse-smoke.mjs
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { createStandaloneAgent } from '../src/standalone/agent-tool.mjs';
 import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
 import {
   closeSession,
@@ -27,6 +26,15 @@ import {
 } from '../src/runtime/agent/orchestrator/session/manager.mjs';
 
 process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+process.env.MIXDOG_AGENT_SPAWN_PREP_TIMEOUT_MS = '50';
+// Terminal reap is intentionally no longer environment-configurable. Keep a
+// conflicting value here so this smoke proves the Advanced provider override
+// is the authority; shorten only the test clock, not the configured duration.
+process.env.MIXDOG_AGENT_TERMINAL_REAP_MS = '1000';
+const nativeSetTimeout = globalThis.setTimeout;
+globalThis.setTimeout = (callback, ms, ...args) => nativeSetTimeout(callback, ms === 60_000 ? 500 : ms, ...args);
+
+const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
 
 const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-reuse-'));
 const dataDir = join(root, '.mixdog-data');
@@ -40,6 +48,7 @@ function taskId(text) { return String(text).match(/agent task: (\S+)/)?.[1] || n
 
 const askLog = [];
 let holdBusy = false;
+let delayGeminiInit = false;
 async function fakeAskSession(sessionId, prompt) {
   const session = getSession(sessionId);
   if (session) { session.status = 'running'; session.lastStreamDeltaAt = Date.now(); }
@@ -57,7 +66,11 @@ async function fakeAskSession(sessionId, prompt) {
 const cfgMod = {
   loadConfig() {
     return {
-      providers: { 'openai-oauth': { enabled: true } },
+      providers: delayGeminiInit ? {
+        'openai-oauth': { enabled: true },
+        gemini: { enabled: true, apiKey: 'smoke-key' },
+      } : { 'openai-oauth': { enabled: true } },
+      autoClear: { providerIdleMs: { 'openai-oauth': 60_000 } },
       agents: {
         reviewer: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' },
         worker: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low', fast: true },
@@ -72,7 +85,12 @@ const cfgMod = {
     return { lane: 'agent', scopeKey: `reuse:${ctx.agentId}`, provider: preset.provider, model: preset.model };
   },
 };
-const reg = { initProviders };
+const reg = {
+  async initProviders(providers) {
+    if (delayGeminiInit && providers?.gemini) await sleep(100);
+    return await initProviders(providers);
+  },
+};
 const mgr = {
   getSession,
   listSessions,
@@ -84,14 +102,16 @@ const mgr = {
 };
 
 const ctx = { invocationSource: 'model-tool', cwd: root, clientHostPid: 0xBEEF };
+const peerCtx = { invocationSource: 'model-tool', cwd: root, clientHostPid: 0xCAFE };
 const agent = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+const peerAgent = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
 
-async function waitJob(out, pattern, label, tries = 60) {
+async function waitJob(out, pattern, label, tries = 60, context = ctx) {
   const id = taskId(out);
   assert(id, `missing task id for ${label}: ${out}`);
   let last = '';
   for (let i = 0; i < tries; i += 1) {
-    last = await agent.execute({ type: 'read', task_id: id }, ctx);
+    last = await agent.execute({ type: 'read', task_id: id }, context);
     if (pattern.test(last)) return last;
     if (/status: error/.test(last)) break;
     await sleep(40);
@@ -101,6 +121,32 @@ async function waitJob(out, pattern, label, tries = 60) {
 function sessionForTag(tag) {
   return listSessions().find((s) => s?.agentTag === tag && !s.closed) || null;
 }
+function addPeerTerminalRow(tag, sessionId) {
+  const file = join(dataDir, 'agent-workers.json');
+  const index = JSON.parse(readFileSync(file, 'utf8'));
+  index.workers[sessionId] = {
+    tag,
+    sessionId,
+    agent: 'worker',
+    provider: 'openai-oauth',
+    status: 'idle',
+    stage: 'idle',
+    updatedAt: new Date().toISOString(),
+    clientHostPid: peerCtx.clientHostPid,
+    cwd: root,
+  };
+  writeFileSync(file, JSON.stringify(index));
+}
+function hasWorkerRow(sessionId) {
+  const index = JSON.parse(readFileSync(join(dataDir, 'agent-workers.json'), 'utf8'));
+  return Boolean(index.workers?.[sessionId]);
+}
+function removeWorkerRow(sessionId) {
+  const file = join(dataDir, 'agent-workers.json');
+  const index = JSON.parse(readFileSync(file, 'utf8'));
+  delete index.workers?.[sessionId];
+  writeFileSync(file, JSON.stringify(index));
+}
 async function waitSessionForTag(tag, label, tries = 60) {
   for (let i = 0; i < tries; i += 1) {
     const s = sessionForTag(tag);
@@ -153,11 +199,14 @@ async function main() {
 
   // --- tier 3: terminal trace -> reap and reuse tag (spawn) or auto-respawn (send) ---
   closeSession(sid, 'smoke-session-closed-trace');
+  addPeerTerminalRow('reviewerA', 'sess_peer_trace');
   const traceSpawnOut = await agent.execute({
     type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'trace reap respawn', cwd: root,
   }, ctx);
   assert(!/^Error:/.test(traceSpawnOut), `terminal-trace spawn must reap and reuse tag: ${traceSpawnOut}`);
   await waitJob(traceSpawnOut, /ack: trace reap respawn/, 'trace reap spawn');
+  assert(hasWorkerRow('sess_peer_trace'), 'terminal-trace reap must preserve a peer terminal row with the same tag');
+  removeWorkerRow('sess_peer_trace');
   const traceLive = await waitSessionForTag('reviewerA', 'trace reap spawn live');
   closeSession(traceLive.id, 'smoke-kill-for-send-respawn');
   const traceSendOut = await agent.execute({
@@ -168,14 +217,104 @@ async function main() {
   assert(!/reused: true/.test(traceSendOut), `dead-tag send must not be a live reuse: ${traceSendOut}`);
   await waitJob(traceSendOut, /ack: auto-respawn follow-up/, 'trace send respawn');
 
+  // A local terminal timer must remove only its own same-tag trace; a peer
+  // terminal may legitimately retain the identical tag at the same time.
+  const timerPeerStart = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'timer-peer', prompt: 'timer peer seed', cwd: root,
+  }, ctx);
+  await waitJob(timerPeerStart, /ack: timer peer seed/, 'timer peer seed');
+  const timerPeerSession = (await waitSessionForTag('timer-peer', 'timer peer seed')).id;
+  addPeerTerminalRow('timer-peer', 'sess_peer_timer');
+  await sleep(700);
+  assert(getSession(timerPeerSession)?.closed, 'terminal timer must reap its local session');
+  assert(hasWorkerRow('sess_peer_timer'), 'terminal timer must preserve a peer row with the same tag');
+
+  // Fully reaped tags have no in-memory map or persisted row. Explicit
+  // cold-spawn identity is enough to create a replacement.
+  const coldStart = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'cold-reaped', prompt: 'cold reap seed', cwd: root,
+  }, ctx);
+  await waitJob(coldStart, /ack: cold reap seed/, 'cold reap seed');
+  const coldSessionId = (await waitSessionForTag('cold-reaped', 'cold reap seed')).id;
+  await sleep(1200);
+  assert(!sessionForTag('cold-reaped') && getSession(coldSessionId)?.closed, 'terminal reaper must remove the cold-reaped session');
+  const coldSendOut = await agent.execute({
+    type: 'send', agent: 'worker', tag: 'cold-reaped', message: 'cold reap replacement', cwd: root,
+  }, ctx);
+  assert(!/^Error:/.test(coldSendOut), `fully reaped tag must cold-respawn: ${coldSendOut}`);
+  assert(/respawned: true/.test(coldSendOut), `fully reaped send must flag respawned: ${coldSendOut}`);
+  await waitJob(coldSendOut, /ack: cold reap replacement/, 'cold reap replacement');
+
+  // A raw session id, typo without retained evidence/identity, and a peer tag
+  // must never turn into a local cold spawn.
+  const rawSessionOut = await agent.execute({
+    type: 'send', sessionId: 'sess_missing', agent: 'worker', message: 'must not spawn', cwd: root,
+  }, ctx);
+  assert(/^Error:/.test(rawSessionOut), `raw session id must remain an error: ${rawSessionOut}`);
+  const typoOut = await agent.execute({
+    type: 'send', tag: 'typo-no-evidence', message: 'must not spawn', cwd: root,
+  }, ctx);
+  assert(/^Error:/.test(typoOut), `unproven typo tag must remain an error: ${typoOut}`);
+  const peerStart = await peerAgent.execute({
+    type: 'spawn', agent: 'worker', tag: 'peer-owned', prompt: 'peer seed', cwd: root,
+  }, peerCtx);
+  await waitJob(peerStart, /ack: peer seed/, 'peer seed', 60, peerCtx);
+  const peerOut = await agent.execute({
+    type: 'send', agent: 'worker', tag: 'peer-owned', message: 'must not take peer tag', cwd: root,
+  }, ctx);
+  assert(/^Error:/.test(peerOut), `peer-terminal tag must remain an error: ${peerOut}`);
+
   // agent close clears the trace; same tag can spawn fresh again
+  addPeerTerminalRow('reviewerA', 'sess_peer_close');
   await agent.execute({ type: 'close', tag: 'reviewerA' }, ctx);
+  assert(hasWorkerRow('sess_peer_close'), 'explicit close must preserve a peer terminal row with the same tag');
+  removeWorkerRow('sess_peer_close');
   const freshAfterClose = await agent.execute({
     type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'post-forget fresh', cwd: root,
   }, ctx);
   assert(!/^Error/.test(freshAfterClose), `post-forget spawn must work: ${freshAfterClose}`);
   await waitJob(freshAfterClose, /ack: post-forget fresh/, 'post-forget spawn');
 
+  // A timed-out spawn prep can bind after its task is already terminal. Its
+  // cleanup must remove only that late local session, preserving a peer row
+  // and leaving the local tag free for a fresh spawn.
+  delayGeminiInit = true;
+  const prepOut = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'prep-peer', provider: 'gemini', model: 'gemini-smoke', prompt: 'late prep cleanup', cwd: root,
+  }, ctx);
+  assert(/agent task:/.test(prepOut), `prep-timeout spawn must return a task: ${prepOut}`);
+  addPeerTerminalRow('prep-peer', 'sess_peer_prep');
+  await sleep(200);
+  delayGeminiInit = false;
+  const prepStatus = await agent.execute({ type: 'read', task_id: taskId(prepOut) }, ctx);
+  assert(/status: error|spawn prep timed out/i.test(prepStatus), `prep cleanup path must time out: ${prepStatus}`);
+  assert(hasWorkerRow('sess_peer_prep'), 'spawn-prep cleanup must preserve a peer terminal row with the same tag');
+  const freshPrep = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'prep-peer', prompt: 'fresh after prep cleanup', cwd: root,
+  }, ctx);
+  assert(!/^Error/.test(freshPrep), `fresh same-tag spawn must follow prep cleanup: ${freshPrep}`);
+  await waitJob(freshPrep, /ack: fresh after prep cleanup/, 'fresh after prep cleanup');
+
+  // A stale local tagAgents entry may make explicit close return forgotten:true,
+  // but it must not erase a peer terminal's same-tag worker row.
+  const staleStart = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'fallback-peer', prompt: 'stale fallback seed', cwd: root,
+  }, ctx);
+  await waitJob(staleStart, /ack: stale fallback seed/, 'stale fallback seed');
+  const staleSessionId = (await waitSessionForTag('fallback-peer', 'stale fallback seed')).id;
+  closeSession(staleSessionId, 'smoke-stale-close-fallback');
+  removeWorkerRow(staleSessionId);
+  addPeerTerminalRow('fallback-peer', 'sess_peer_fallback');
+  const fallbackClose = await agent.execute({ type: 'close', tag: 'fallback-peer' }, ctx);
+  assert(/forgotten: true/.test(fallbackClose), `stale close fallback must stay forgotten:true: ${fallbackClose}`);
+  assert(hasWorkerRow('sess_peer_fallback'), 'stale close fallback must preserve a peer terminal row with the same tag');
+  removeWorkerRow('sess_peer_fallback');
+  const fallbackFresh = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'fallback-peer', prompt: 'fresh after stale fallback', cwd: root,
+  }, ctx);
+  assert(!/^Error/.test(fallbackFresh), `fresh same-tag spawn must follow stale close fallback: ${fallbackFresh}`);
+  await waitJob(fallbackFresh, /ack: fresh after stale fallback/, 'fresh after stale fallback');
+
   process.stdout.write(`agent tag-reuse smoke passed (asks=${askLog.length})\n`);
 }
 
@@ -183,5 +322,6 @@ try {
   await main();
 } finally {
   try { agent.closeAll('agent-tag-reuse-smoke-end'); } catch {}
+  globalThis.setTimeout = nativeSetTimeout;
   rmSync(root, { recursive: true, force: true });
 }

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

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  AUTO_CLEAR_PROVIDER_IDLE_MS,
+  resolveAgentTerminalReapMs,
+} from '../src/session-runtime/config-helpers.mjs';
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-terminal-reap-'));
+process.env.MIXDOG_DATA_DIR = root;
+process.env.MIXDOG_AGENT_TERMINAL_REAP_MS = '1';
+
+function assertEqual(actual, expected, label) {
+  assert.equal(actual, expected, `${label}: expected ${expected}, got ${actual}`);
+}
+
+try {
+  const builtIns = Object.entries(AUTO_CLEAR_PROVIDER_IDLE_MS).filter(([provider]) => provider !== 'default');
+  for (const [provider, idleMs] of builtIns) {
+    assertEqual(resolveAgentTerminalReapMs({ autoClear: {} }, provider), idleMs, `${provider} built-in`);
+  }
+
+  const overrideConfig = {
+    autoClear: {
+      idleMs: 12 * 60 * 60 * 1000,
+      providerIdleMs: { 'openai-oauth': 60_000, default: 90_000, unlisted: 60_000 },
+    },
+  };
+  assertEqual(resolveAgentTerminalReapMs(overrideConfig, 'openai-oauth'), 60_000, 'provider override');
+  assertEqual(
+    resolveAgentTerminalReapMs(overrideConfig, 'anthropic'),
+    AUTO_CLEAR_PROVIDER_IDLE_MS.anthropic,
+    'global idleMs and default row are ignored for listed providers',
+  );
+  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() - 181_000;
+  const known = {
+    id: 'sess_known_reap',
+    owner: 'agent',
+    status: 'idle',
+    provider: 'openai-oauth',
+    createdAt: old,
+    updatedAt: old,
+    messages: [],
+  };
+  const shortOverride = {
+    id: 'sess_short_override',
+    owner: 'agent',
+    status: 'idle',
+    provider: 'openai-oauth',
+    createdAt: Date.now() - 120_000,
+    updatedAt: Date.now() - 120_000,
+    messages: [],
+  };
+  const unknown = {
+    id: 'sess_unknown_keep',
+    owner: 'agent',
+    status: 'idle',
+    provider: 'unlisted',
+    createdAt: old,
+    updatedAt: old,
+    messages: [],
+  };
+  writeFileSync(join(root, 'sessions', `${known.id}.json`), JSON.stringify(known));
+  writeFileSync(join(root, 'sessions', `${shortOverride.id}.json`), JSON.stringify(shortOverride));
+  writeFileSync(join(root, 'sessions', `${unknown.id}.json`), JSON.stringify(unknown));
+  for (const id of [known.id, unknown.id]) utimesSync(join(root, 'sessions', `${id}.json`), old / 1000, old / 1000);
+  utimesSync(join(root, 'sessions', `${shortOverride.id}.json`), shortOverride.updatedAt / 1000, shortOverride.updatedAt / 1000);
+  const defaultSweep = sweepStaleSessions({ retainOpenSessions: false });
+  assert.ok(
+    defaultSweep.details.some((detail) => detail.id === shortOverride.id),
+    '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 reaps an unlisted provider at the default duration');
+
+  const dataDir = join(root, 'worker-index');
+  mkdirSync(dataDir, { recursive: true });
+  writeFileSync(join(dataDir, 'agent-workers.json'), JSON.stringify({
+    workers: {
+      known: {
+        tag: 'known',
+        sessionId: 'sess_known_row',
+        provider: 'openai-oauth',
+        status: 'idle',
+        updatedAt: new Date(old).toISOString(),
+      },
+      unknown: {
+        tag: 'unknown',
+        sessionId: 'sess_unknown_row',
+        provider: 'unlisted',
+        status: 'idle',
+        updatedAt: new Date(old).toISOString(),
+      },
+    },
+  }));
+  const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
+  const agent = createStandaloneAgent({
+    cfgMod: {
+      loadConfig: () => overrideConfig,
+      resolveRuntimeSpec: () => ({ lane: 'agent', scopeKey: 'terminal-reap', provider: 'openai-oauth', model: 'test' }),
+    },
+    reg: {},
+    mgr: { listSessions: () => [], getSession: () => null },
+    dataDir,
+    cwd: root,
+  });
+  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 expires at the default duration');
+  agent.closeAll('agent-terminal-reap-test');
+
+  process.stdout.write(`agent terminal reap test passed (${builtIns.length} providers)\n`);
+} finally {
+  delete process.env.MIXDOG_AGENT_TERMINAL_REAP_MS;
+  delete process.env.MIXDOG_DATA_DIR;
+  rmSync(root, { recursive: true, force: true });
+}

package/scripts/agent-trace-io-test.mjs

@@ -0,0 +1,69 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import test from 'node:test';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const traceModuleUrl = pathToFileURL(join(root, 'src/runtime/agent/orchestrator/agent-trace-io.mjs')).href;
+
+test('drainAgentTrace awaits delayed local JSONL append without a memory service', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-agent-trace-io-test-'));
+  const tracePath = join(dir, 'agent-trace.jsonl');
+  const loaderPath = join(dir, 'loader.mjs');
+  const delayedFsPath = join(dir, 'delayed-fs-promises.mjs');
+  try {
+    writeFileSync(delayedFsPath, `
+      import { appendFile as realAppendFile } from 'node:fs/promises';
+      export async function appendFile(...args) {
+        await new Promise((resolve) => setTimeout(resolve, Number(process.env.TRACE_APPEND_DELAY_MS)));
+        return realAppendFile(...args);
+      }
+    `);
+    writeFileSync(loaderPath, `
+      export async function resolve(specifier, context, nextResolve) {
+        if (specifier === 'fs/promises' && context.parentURL === ${JSON.stringify(traceModuleUrl)}) {
+          return { url: new URL('./delayed-fs-promises.mjs', import.meta.url).href, shortCircuit: true };
+        }
+        return nextResolve(specifier, context);
+      }
+    `);
+    const child = spawnSync(process.execPath, [
+      '--experimental-loader',
+      pathToFileURL(loaderPath).href,
+      '--input-type=module',
+      '-e',
+      `
+        import { readFileSync } from 'node:fs';
+        import { appendAgentTrace, drainAgentTrace } from ${JSON.stringify(traceModuleUrl)};
+        appendAgentTrace({ kind: 'delayed-local-test', session_id: 'sess_delayed' });
+        const started = Date.now();
+        await drainAgentTrace();
+        const rows = readFileSync(process.env.MIXDOG_AGENT_TRACE_PATH, 'utf8').trim().split(/\\r?\\n/).map(JSON.parse);
+        process.stdout.write(JSON.stringify({ elapsed: Date.now() - started, rows }));
+      `,
+    ], {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        MIXDOG_AGENT_TRACE_PATH: tracePath,
+        MIXDOG_AGENT_TRACE_DISABLE: '',
+        MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
+        MIXDOG_RUNTIME_ROOT: join(dir, 'no-service'),
+        TRACE_APPEND_DELAY_MS: '75',
+      },
+      timeout: 5000,
+    });
+    assert.equal(child.status, 0, child.stderr || child.stdout);
+    const result = JSON.parse(child.stdout);
+    assert.ok(result.elapsed >= 60, `drain returned before delayed append (${result.elapsed}ms)`);
+    assert.equal(result.rows.length, 1);
+    assert.equal(result.rows[0].kind, 'delayed-local-test');
+    assert.equal(result.rows[0].session_id, 'sess_delayed');
+    assert.match(readFileSync(tracePath, 'utf8'), /"kind":"delayed-local-test"/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});