mixdog 0.9.37 → 0.9.39

package/scripts/code-graph-disk-hit-test.mjs

@@ -0,0 +1,224 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  _isCompatibleDiskCodeGraphEntry,
+  _postCodeGraphWorkerSuccess,
+  _prepareDiskCodeGraphFastPath,
+  _runDiskCodeGraphFastPath,
+  _validateDiskCodeGraphHit,
+} from '../src/runtime/agent/orchestrator/tools/code-graph/build.mjs';
+import { CODE_GRAPH_MAX_FILES } from '../src/runtime/agent/orchestrator/tools/code-graph/constants.mjs';
+import { _serializeGraph } from '../src/runtime/agent/orchestrator/tools/code-graph/graph-model.mjs';
+import { _persistDiskCodeGraphCacheNow } from '../src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs';
+
+test('signature-validated disk hit restores memory without a Worker build', async () => {
+  const graph = { nodes: new Map() };
+  let restored = null;
+  const result = await _validateDiskCodeGraphHit({
+    graphCwd: '/project',
+    diskEntry: { signature: 'sig', maxFiles: CODE_GRAPH_MAX_FILES },
+    genAtStart: 4,
+    now: 123,
+    runManifest: async () => [{ rel: 'a.mjs', fp: '1' }],
+    computeSignature: () => 'sig',
+    deserializeGraph: () => graph,
+    getGeneration: () => 4,
+    setMemoryCache: (cwd, entry) => { restored = { cwd, entry }; },
+  });
+  assert.equal(result.graph, graph);
+  assert.deepEqual(restored, {
+    cwd: '/project',
+    entry: { ts: 123, signature: 'sig', graph },
+  });
+});
+
+test('disk mismatch hands one manifest to the isolated rebuild without restoring stale data', async () => {
+  let deserialized = false;
+  const manifest = [{ rel: 'changed.mjs', fp: '2' }];
+  const result = await _validateDiskCodeGraphHit({
+    graphCwd: '/project',
+    diskEntry: { signature: 'old', maxFiles: CODE_GRAPH_MAX_FILES },
+    genAtStart: 1,
+    runManifest: async () => manifest,
+    computeSignature: () => 'new',
+    deserializeGraph: () => { deserialized = true; },
+  });
+  assert.equal(result.graph, null);
+  assert.equal(result.manifest, manifest);
+  assert.equal(result.signature, 'new');
+  assert.equal(deserialized, false);
+});
+
+test('generation change rejects a validated stale disk graph', async () => {
+  const result = await _validateDiskCodeGraphHit({
+    graphCwd: '/project',
+    diskEntry: { signature: 'sig', maxFiles: CODE_GRAPH_MAX_FILES },
+    genAtStart: 1,
+    runManifest: async () => [],
+    computeSignature: () => 'sig',
+    deserializeGraph: () => ({ nodes: new Map() }),
+    getGeneration: () => 2,
+  });
+  assert.deepEqual(result, { invalidated: true });
+});
+
+function fastProbe(overrides = {}) {
+  return { isFastPathEligible: true, maxFiles: CODE_GRAPH_MAX_FILES, bytes: 1, ...overrides };
+}
+
+test('validated hit releases its pre-acquired slot exactly once', async () => {
+  let releases = 0;
+  let workers = 0;
+  const result = await _runDiskCodeGraphFastPath({
+    graphCwd: '/project',
+    diskProbe: fastProbe(),
+    genAtStart: 1,
+    loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
+    acquireSlot: async () => () => { releases++; },
+    validateDiskHit: async () => ({ graph: 'hit' }),
+    spawnWorker: () => { workers++; },
+  });
+  assert.equal(result, 'hit');
+  assert.equal(releases, 1);
+  assert.equal(workers, 0);
+});
+
+test('validation errors release the pre-acquired slot', async () => {
+  let releases = 0;
+  await assert.rejects(_runDiskCodeGraphFastPath({
+    graphCwd: '/project',
+    diskProbe: fastProbe(),
+    genAtStart: 1,
+    loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
+    acquireSlot: async () => () => { releases++; },
+    validateDiskHit: async () => { throw new Error('manifest failed'); },
+    spawnWorker: () => assert.fail('Worker must not start'),
+  }), /manifest failed/);
+  assert.equal(releases, 1);
+});
+
+test('validated miss hands its slot to Worker exactly once', async () => {
+  let releases = 0;
+  let receivedRelease = null;
+  const result = await _runDiskCodeGraphFastPath({
+    graphCwd: '/project',
+    diskProbe: fastProbe(),
+    genAtStart: 1,
+    loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
+    acquireSlot: async () => () => { releases++; },
+    validateDiskHit: async () => ({ graph: null, manifest: ['one'], signature: 'new' }),
+    spawnWorker: (release, manifest, signature) => {
+      receivedRelease = release;
+      assert.deepEqual(manifest, ['one']);
+      assert.equal(signature, 'new');
+      return 'worker-result';
+    },
+  });
+  assert.equal(result, 'worker-result');
+  assert.equal(releases, 0);
+  receivedRelease();
+  assert.equal(releases, 1);
+});
+
+test('abort after slot acquisition or validation releases the slot and never starts a Worker', async () => {
+  for (const abortAt of ['acquire', 'validate']) {
+    const controller = new AbortController();
+    let releases = 0;
+    let workers = 0;
+    await assert.rejects(_runDiskCodeGraphFastPath({
+      graphCwd: '/project',
+      diskProbe: fastProbe(),
+      genAtStart: 1,
+      signal: controller.signal,
+      loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
+      acquireSlot: async () => {
+        if (abortAt === 'acquire') controller.abort();
+        return () => { releases++; };
+      },
+      validateDiskHit: async () => {
+        if (abortAt === 'validate') controller.abort();
+        return { graph: 'hit' };
+      },
+      spawnWorker: () => { workers++; },
+    }), /aborted/);
+    assert.equal(releases, 1, abortAt);
+    assert.equal(workers, 0, abortAt);
+  }
+});
+
+test('oversized or maxFiles-incompatible entries bypass main-thread load and use Worker', async () => {
+  for (const probe of [fastProbe({ isFastPathEligible: false }), fastProbe({ maxFiles: null })]) {
+    let loaded = 0;
+    let acquired = 0;
+    const result = await _runDiskCodeGraphFastPath({
+      graphCwd: '/project',
+      diskProbe: probe,
+      genAtStart: 1,
+      loadDiskEntry: () => { loaded++; return { maxFiles: CODE_GRAPH_MAX_FILES }; },
+      acquireSlot: async () => { acquired++; return () => {}; },
+      spawnWorker: (release) => ({ release }),
+    });
+    assert.deepEqual(result, { release: null });
+    assert.equal(loaded, 0);
+    assert.equal(acquired, 0);
+  }
+});
+
+test('persisted entries require matching maxFiles in both cache paths', () => {
+  assert.equal(_isCompatibleDiskCodeGraphEntry({ maxFiles: CODE_GRAPH_MAX_FILES }), true);
+  assert.equal(_isCompatibleDiskCodeGraphEntry({}), false);
+  assert.equal(_isCompatibleDiskCodeGraphEntry({ maxFiles: CODE_GRAPH_MAX_FILES - 1 }), false);
+  assert.equal(_serializeGraph({ nodes: new Map() }).maxFiles, CODE_GRAPH_MAX_FILES);
+});
+
+test('large legacy cache bypasses parent migration/parser and routes directly to Worker', () => {
+  let migrationOrParserCalls = 0;
+  let probeCalls = 0;
+  const result = _prepareDiskCodeGraphFastPath({
+    graphCwd: '/project',
+    hasLegacyCache: () => true,
+    ensureDiskLoaded: () => { migrationOrParserCalls++; },
+    probeDiskEntry: () => { probeCalls++; return assert.fail('legacy probe must not run'); },
+    runFastPath: (probe) => ({ probe, route: 'worker' }),
+  });
+  assert.deepEqual(result, { probe: null, route: 'worker' });
+  assert.equal(migrationOrParserCalls, 0);
+  assert.equal(probeCalls, 0);
+});
+
+test('Worker drains all migrated cache entries before posting success', () => {
+  const migratedEntries = new Map([
+    ['/requested', { signature: 'requested' }],
+    ['/legacy-project', { signature: 'legacy' }],
+  ]);
+  const events = [];
+  _postCodeGraphWorkerSuccess(
+    { signature: 'requested', nodes: new Map() },
+    (message) => {
+      events.push('post');
+      assert.equal(migratedEntries.size, 2);
+      assert.equal(message.ok, true);
+    },
+    () => {
+      events.push('drain');
+      assert.deepEqual([...migratedEntries.keys()], ['/requested', '/legacy-project']);
+    },
+  );
+  assert.deepEqual(events, ['drain', 'post']);
+});
+
+test('strict persistence failure prevents Worker success post', () => {
+  let posted = false;
+  assert.throws(
+    () => _postCodeGraphWorkerSuccess(
+      { signature: 'requested' },
+      () => { posted = true; },
+      () => _persistDiskCodeGraphCacheNow({
+        strict: true,
+        writeJson: () => { throw new Error('persist failed'); },
+      }),
+    ),
+    /persist failed/,
+  );
+  assert.equal(posted, false);
+});

package/scripts/dispatch-persist-recovery-test.mjs

@@ -0,0 +1,141 @@
+// Regression tests for recoverPending recovery bugs:
+//  (a) an entry must survive when notifyFn resolves false (not delivered) and
+//      only be removed after a confirmed (truthy) ack.
+//  (b) a scoped recovery that matches purely on clientHostPid must NOT stamp
+//      the reconnecting filter session's id onto another session's abort — it
+//      delivers to the true owner session, and leaves the entry persisted when
+//      there is no owner session to target.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  addPending,
+  recoverPending,
+} from '../src/runtime/agent/orchestrator/dispatch-persist.mjs';
+
+const FILE = 'pending-dispatches.json';
+
+function readMap(dir) {
+  try {
+    const raw = readFileSync(join(dir, FILE), 'utf8');
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch { return {}; }
+}
+
+async function waitFor(fn, { timeout = 3000, step = 20 } = {}) {
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    if (fn()) return true;
+    if (Date.now() > deadline) return false;
+    await new Promise((r) => setTimeout(r, step));
+  }
+}
+
+function tmp() {
+  const dir = mkdtempSync(join(tmpdir(), 'dpersist-'));
+  return dir;
+}
+
+test('(a) only explicit false/0 keeps entry; undefined/void resolve deletes', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-a', 'recall', ['q'], 'sid-owner', 1111);
+    await waitFor(() => 'h-a' in readMap(dir));
+
+    // Explicit false → undelivered, entry MUST survive for retry.
+    recoverPending(dir, () => Promise.resolve(false), {});
+    await new Promise((r) => setTimeout(r, 200));
+    assert.ok('h-a' in readMap(dir), 'entry removed despite notifyFn=false');
+
+    // Explicit 0 → also undelivered, entry survives.
+    recoverPending(dir, () => Promise.resolve(0), {});
+    await new Promise((r) => setTimeout(r, 200));
+    assert.ok('h-a' in readMap(dir), 'entry removed despite notifyFn=0');
+
+    // undefined/void resolve from a delivered notifyFn → entry removed.
+    recoverPending(dir, () => Promise.resolve(undefined), {});
+    const gone = await waitFor(() => !('h-a' in readMap(dir)));
+    assert.ok(gone, 'entry not removed after undefined (delivered) resolve');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('(b) hostPid-only match delivers to true owner session, never the filter session', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-b', 'recall', ['q'], 'owner-A', 4242);
+    await waitFor(() => 'h-b' in readMap(dir));
+
+    let seen = null;
+    // Reconnect as a DIFFERENT session that only shares the host pid.
+    recoverPending(dir, (content, meta) => { seen = meta; return Promise.resolve(true); }, {
+      sessionId: 'session-B',
+      clientHostPid: 4242,
+    });
+    await waitFor(() => seen != null);
+    assert.equal(seen.caller_session_id, 'owner-A', 'stamped filter session instead of true owner');
+    assert.notEqual(seen.caller_session_id, 'session-B');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('(b) hostPid-only match with no owner session is left persisted, not injected', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-c', 'recall', ['q'], null, 5353);
+    await waitFor(() => 'h-c' in readMap(dir));
+
+    let called = false;
+    recoverPending(dir, () => { called = true; return Promise.resolve(true); }, {
+      sessionId: 'session-C',
+      clientHostPid: 5353,
+    });
+    await new Promise((r) => setTimeout(r, 250));
+    assert.equal(called, false, 'notifyFn fired for an entry with no owner session');
+    assert.ok('h-c' in readMap(dir), 'entry with no owner session was not left persisted');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('owner-session match still stamps the reconnecting session id', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-d', 'recall', ['q'], 'prior-sid', 6464);
+    await waitFor(() => 'h-d' in readMap(dir));
+
+    let seen = null;
+    recoverPending(dir, (content, meta) => { seen = meta; return Promise.resolve(true); }, {
+      sessionId: 'new-sid',
+      priorSessionId: 'prior-sid',
+      clientHostPid: 6464,
+    });
+    await waitFor(() => seen != null);
+    assert.equal(seen.caller_session_id, 'new-sid', 'owner match should stamp reconnecting session id');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('priorSessionId match with no current sessionId keeps the entry owner cid', async () => {
+  const dir = tmp();
+  try {
+    addPending(dir, 'h-e', 'recall', ['q'], 'prior-sid', 7575);
+    await waitFor(() => 'h-e' in readMap(dir));
+
+    let seen = null;
+    // priorSessionId matches the owner but no current sessionId is supplied →
+    // filterSid is null; must fall back to the entry's known owner cid.
+    recoverPending(dir, (content, meta) => { seen = meta; return Promise.resolve(true); }, {
+      priorSessionId: 'prior-sid',
+    });
+    await waitFor(() => seen != null);
+    assert.equal(seen.caller_session_id, 'prior-sid', 'dropped known owner cid when sessionId absent');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/execution-completion-dedup-test.mjs

@@ -0,0 +1,157 @@
+// Regression: consolidated completion dedup on the delivered-completions
+// registry (src/tui/engine/agent-job-feed.mjs execution-ui branch).
+//
+// Symptom guarded: after a turn completes and the lead goes IDLE, a duplicate
+// execution completion (SAME execution_id, slightly different composite
+// status/body key) must NOT re-enqueue a model-visible twin — otherwise
+// post-turn drain() spawns a fresh turn. A genuinely-new completion (different
+// execution_id) must still enqueue so the lead wakes.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createAgentJobFeed } from '../src/tui/engine/agent-job-feed.mjs';
+import {
+  _clearDeliveredCompletions,
+} from '../src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+
+const completionText = 'Async agent task task_1 completed finished.\n\nResult:\n> ok';
+const completionMeta = { type: 'agent_task_result', execution_id: 'task_1', status: 'completed' };
+
+function makeHarness() {
+  const enqueued = [];       // captured enqueue entries (spy)
+  const pending = [];        // real queue depth proxy
+  let enqueueCalls = 0;      // spy call-count
+  let handler = null;
+  const state = { busy: false };
+  const feed = createAgentJobFeed({
+    runtime: { onNotification: (fn) => { handler = fn; return () => {}; } },
+    getState: () => state,
+    set: () => {},
+    nextId: () => 'id',
+    getDisposed: () => false,
+    patchItem: () => {},
+    enqueue: (body, opts) => {
+      enqueueCalls += 1;
+      enqueued.push({ body, opts });
+      pending.push({ body, opts });
+      return true;
+    },
+    drain: () => Promise.resolve(),
+    pushUserOrSyntheticItem: () => {},
+    makeQueueEntry: (text, opts = {}) => ({ text, ...opts }),
+    getPending: () => pending,
+    agentStatusState: () => ({}),
+    displayedExecutionNotificationKeys: new Set(),
+    pushNotice: () => {},
+  });
+  feed.subscribeRuntimeNotifications();
+  return { enqueued, pending, enqueueCalls: () => enqueueCalls, deliver: (event) => handler(event) };
+}
+
+test('re-arriving delivered completion (same execution_id) does NOT enqueue a new turn', () => {
+  _clearDeliveredCompletions();
+  const { enqueueCalls, pending, deliver } = makeHarness();
+
+  // First arrival: brand-new completion → enqueued + ACKed.
+  const first = { content: completionText, meta: completionMeta };
+  deliver(first);
+  assert.equal(enqueueCalls(), 1, 'new completion enqueues the model-visible twin');
+  assert.equal(pending.length, 1, 'one pending entry queued');
+  assert.equal(first.modelVisibleDelivered, true, 'first delivery ACKs runtime-core mirror suppression');
+
+  // Duplicate: SAME execution_id, different composite key (meta.type differs →
+  // different notificationQueueKey AND a different model-visible text hash), but
+  // still a persistable terminal completion. Dedup must recognize it purely via
+  // the execution_id registry key, not the status/body-derived composite.
+  const dup = { content: completionText, meta: { ...completionMeta, type: 'background_task_result' } };
+  deliver(dup);
+  // END-TO-END proxy for "no idle refire": the handler returned with NO new
+  // enqueue call and NO new pending entry, so post-turn drain has nothing new to
+  // fire — yet the ack is still set so runtime-core never mirrors it either.
+  assert.equal(enqueueCalls(), 1, 'already-delivered completion triggers NO new enqueue (no idle refire)');
+  assert.equal(pending.length, 1, 'queue depth stable — dup pushed no new pending entry');
+  assert.equal(dup.modelVisibleDelivered, true, 'duplicate still ACKs so mirror/fallback stays suppressed');
+});
+
+test('genuinely-new completion (different execution_id) still enqueues + wakes the lead', () => {
+  _clearDeliveredCompletions();
+  const { enqueueCalls, deliver } = makeHarness();
+
+  deliver({ content: completionText, meta: completionMeta });
+  const secondText = 'Async agent task task_2 completed finished.\n\nResult:\n> done';
+  deliver({ content: secondText, meta: { type: 'agent_task_result', execution_id: 'task_2', status: 'completed' } });
+  assert.equal(enqueueCalls(), 2, 'a new execution_id triggers exactly one new enqueue (lead wakeup preserved)');
+});
+
+// CARD dedup regression: the transcript-card first-delivery guard keys on a
+// stable execution_id-based key (executionCardKey → card:<id>:<hasBody>), NOT
+// the full composite notificationKey. A duplicate completion re-arriving with a
+// different type/status (same execution_id, same hasBody) must push ONE card;
+// a bodyless successful preview (b0) is status-only; the real body (b1) is the
+// single visible logical response.
+function makeCardHarness() {
+  let handler = null;
+  let cardPushes = 0;
+  const responseCalls = [];
+  const feed = createAgentJobFeed({
+    runtime: { onNotification: (fn) => { handler = fn; return () => {}; } },
+    getState: () => ({ busy: false }),
+    set: () => {},
+    nextId: () => 'id',
+    getDisposed: () => false,
+    patchItem: () => {},
+    enqueue: () => true,
+    drain: () => Promise.resolve(),
+    pushUserOrSyntheticItem: () => { cardPushes += 1; },
+    pushAsyncAgentResponse: (...args) => { cardPushes += 1; responseCalls.push(args); },
+    makeQueueEntry: (text, opts = {}) => ({ text, ...opts }),
+    getPending: () => [],
+    agentStatusState: () => ({}),
+    displayedExecutionNotificationKeys: new Set(),
+    pushNotice: () => {},
+  });
+  feed.subscribeRuntimeNotifications();
+  return { cardPushes: () => cardPushes, responseCalls, deliver: (event) => handler(event) };
+}
+
+test('duplicate completion (same execution_id, differing type/status) pushes ONE card', () => {
+  _clearDeliveredCompletions();
+  const { cardPushes, deliver } = makeCardHarness();
+
+  deliver({ content: completionText, meta: completionMeta });
+  assert.equal(cardPushes(), 1, 'first completion pushes a card');
+
+  deliver({ content: completionText, meta: { ...completionMeta, type: 'background_task_result', status: 'finished' } });
+  assert.equal(cardPushes(), 1, 'dup with differing type/status pushes NO second card (execution_id card key)');
+});
+
+test('bodyless successful preview (b0) then result (b1), same execution_id, pushes ONE card', () => {
+  _clearDeliveredCompletions();
+  const { cardPushes, deliver } = makeCardHarness();
+
+  // Bodyless preview: header-only, no blank-line-separated result body → b0.
+  deliver({ content: 'Async agent task task_9 completed finished.', meta: { type: 'agent_task_result', execution_id: 'task_9', status: 'completed' } });
+  assert.equal(cardPushes(), 0, 'successful preview is status-only');
+
+  // Real result: carries a body after a blank line → b1 (upgrade preserved).
+  deliver({ content: 'Async agent task task_9 completed finished.\n\nResult:\n> ok', meta: { type: 'agent_task_result', execution_id: 'task_9', status: 'completed' } });
+  assert.equal(cardPushes(), 1, 'result body (b1) is the one logical response');
+
+  deliver({ content: 'Async agent task task_9 completed finished.\n\nResult:\n> retry', meta: { type: 'background_task_result', execution_id: 'task_9', status: 'finished' } });
+  assert.equal(cardPushes(), 1, 'same execution retry pushes no additional response');
+});
+
+test('bodyless failure preview does not suppress its later body', () => {
+  _clearDeliveredCompletions();
+  const { cardPushes, responseCalls, deliver } = makeCardHarness();
+  deliver({ content: 'Async agent task task_fail failed.', meta: { type: 'agent_task_result', execution_id: 'task_fail', status: 'failed' } });
+  assert.equal(cardPushes(), 1, 'failure preview remains visible');
+
+  deliver({ content: 'Async agent task task_fail completed.\n\nResult:\n> recovered', meta: { type: 'agent_task_result', execution_id: 'task_fail', status: 'completed' } });
+  assert.equal(cardPushes(), 2, 'body is delivered for tail update or boundary-safe standalone card');
+  assert.equal(responseCalls[0][3].responseKey, 'task_fail');
+  assert.equal(responseCalls[1][3].responseKey, 'task_fail');
+
+  deliver({ content: 'Async agent task task_fail completed.\n\nResult:\n> retry', meta: { type: 'background_task_result', execution_id: 'task_fail', status: 'finished' } });
+  assert.equal(cardPushes(), 2, 'same-body retry remains idempotent');
+});

package/scripts/execution-pending-resume-kick-test.mjs

@@ -13,7 +13,7 @@ import { createAgentJobFeed } from '../src/tui/engine/agent-job-feed.mjs';
 
 // Minimal harness: a mutable busy flag, a pending queue, and a synchronous
 // drain stub that "resumes" by surfacing every pending-resume entry's body.
-function makeHarness() {
+function makeHarness({ now, executionResumeTombstoneTtlMs, executionResumeTombstoneLimit } = {}) {
   const pending = [];
   const surfaced = [];
   const state = { busy: false };
@@ -48,11 +48,20 @@ function makeHarness() {
     enqueue: () => {},
     drain,
     pushUserOrSyntheticItem: () => {},
-    makeQueueEntry: (text, opts = {}) => ({ text, mode: opts.mode, priority: opts.priority }),
+    makeQueueEntry: (text, opts = {}) => ({
+      text,
+      mode: opts.mode,
+      priority: opts.priority,
+      abortDiscardOnAbort: opts.abortDiscardOnAbort,
+      resumeCompletionKeys: opts.resumeCompletionKeys,
+    }),
     getPending: () => pending,
     agentStatusState: () => ({}),
     displayedExecutionNotificationKeys: new Set(),
     pushNotice: () => {},
+    now,
+    executionResumeTombstoneTtlMs,
+    executionResumeTombstoneLimit,
   });
 
   return { feed, pending, surfaced, state };
@@ -94,3 +103,49 @@ test('B: deferred kick after a non-drain busy->false transition still fires', as
   feed.flushDeferredExecutionPendingResumeKick();
   assert.deepEqual(surfaced, ['only body']);
 });
+
+test('Esc discards one completion resume, drops its duplicate retry, and still wakes for a new completion', async () => {
+  const { feed, surfaced, state } = makeHarness();
+  state.busy = true;
+  feed.scheduleExecutionPendingResumeKick('body A', 'execution_A');
+  await microtasks();
+
+  // Esc owns and retires A while its resume is active. A delayed duplicate
+  // cannot re-create that resume, but a genuinely different completion can.
+  feed.discardExecutionPendingResume(['execution_A']);
+  state.busy = false;
+  feed.flushDeferredExecutionPendingResumeKick();
+  assert.deepEqual(surfaced, [], 'the aborted completion is not deferred-kicked');
+
+  feed.scheduleExecutionPendingResumeKick('body A retry', 'execution_A');
+  await microtasks();
+  assert.deepEqual(surfaced, [], 'duplicate retry after Esc cannot restart A');
+
+  feed.scheduleExecutionPendingResumeKick('body B', 'execution_B');
+  await microtasks();
+  assert.deepEqual(surfaced, ['body B'], 'a later new completion still wakes the lead');
+});
+
+test('Esc tombstone expires so a later legitimate execution/body reuse can resume', async () => {
+  let clock = 1_000;
+  const { feed, surfaced, state } = makeHarness({
+    now: () => clock,
+    executionResumeTombstoneTtlMs: 20,
+    executionResumeTombstoneLimit: 2,
+  });
+  state.busy = true;
+  feed.scheduleExecutionPendingResumeKick('same body', 'execution_reused');
+  await microtasks();
+  feed.discardExecutionPendingResume(['execution_reused']);
+  state.busy = false;
+  feed.flushDeferredExecutionPendingResumeKick();
+
+  feed.scheduleExecutionPendingResumeKick('duplicate retry', 'execution_reused');
+  await microtasks();
+  assert.deepEqual(surfaced, [], 'the short-lived tombstone blocks a delayed duplicate');
+
+  clock += 21;
+  feed.scheduleExecutionPendingResumeKick('legitimate reuse', 'execution_reused');
+  await microtasks();
+  assert.deepEqual(surfaced, ['legitimate reuse'], 'expired tombstone no longer reserves the execution ID');
+});