mixdog 0.9.63 → 0.9.64

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

@@ -1,141 +0,0 @@
-// 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/embedding-worker-exit-test.mjs

@@ -1,76 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { spawn } from 'node:child_process'
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-const providerUrl = new URL('../src/runtime/memory/lib/embedding-provider.mjs', import.meta.url)
-const CHILD_DEADLINE_MS = 3_000
-
-async function createExitWorkerFixture() {
-  const tempDir = await mkdtemp(join(tmpdir(), 'mixdog-embed-worker-exit-'))
-  const workerPath = join(tempDir, 'exit-before-reply.mjs')
-  await writeFile(workerPath, `
-    import { parentPort } from 'node:worker_threads'
-    parentPort.once('message', () => process.exit(0))
-  `)
-  const source = await readFile(providerUrl, 'utf8')
-  const instrumented = source
-    .replace("'./model-profile.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/model-profile.mjs', import.meta.url).href))
-    .replace("'./embedding-model-config.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/embedding-model-config.mjs', import.meta.url).href))
-    .replace(/^const WORKER_PATH = .*$/m, `const WORKER_PATH = ${JSON.stringify(workerPath)}`)
-  const providerModule = `data:text/javascript;base64,${Buffer.from(instrumented).toString('base64')}#${Date.now()}`
-  const fixturePath = join(tempDir, 'run-exit-test.mjs')
-  await writeFile(fixturePath, `
-    import { embedText } from ${JSON.stringify(providerModule)}
-    const started = Date.now()
-    const settled = await Promise.allSettled([embedText('first'), embedText('second')])
-    if (Date.now() - started >= 2_000) throw new Error('worker exit did not reject pending embeds promptly')
-    if (settled.some(({ status }) => status !== 'rejected')) throw new Error('worker exit resolved a pending embed')
-    for (const result of settled) {
-      if (result.reason?.message !== 'Worker exited with code 0') throw result.reason
-    }
-    process.stdout.write('ok')
-  `)
-  return { fixturePath, tempDir }
-}
-
-function runFixture(fixturePath) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [fixturePath], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
-    let stdout = ''
-    let stderr = ''
-    let timedOut = false
-    const deadline = setTimeout(() => {
-      timedOut = true
-      child.kill()
-    }, CHILD_DEADLINE_MS)
-    child.stdout.on('data', (chunk) => { stdout += chunk })
-    child.stderr.on('data', (chunk) => { stderr += chunk })
-    child.once('error', (error) => {
-      clearTimeout(deadline)
-      reject(error)
-    })
-    child.once('close', (code, signal) => {
-      clearTimeout(deadline)
-      if (timedOut) {
-        reject(new Error(`exit-worker fixture exceeded ${CHILD_DEADLINE_MS}ms and was killed`))
-        return
-      }
-      resolve({ code, signal, stdout, stderr })
-    })
-  })
-}
-
-test('code-zero worker exit before reply promptly rejects every pending embed', async () => {
-  const { fixturePath, tempDir } = await createExitWorkerFixture()
-  try {
-    const result = await runFixture(fixturePath)
-    assert.equal(result.code, 0, result.stderr)
-    assert.equal(result.signal, null, result.stderr)
-    assert.equal(result.stdout, 'ok')
-  } finally {
-    await rm(tempDir, { recursive: true, force: true })
-  }
-})

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

@@ -1,205 +0,0 @@
-// 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');
-});
-
-test('parallel agent status bursts coalesce to one status snapshot per frame', async () => {
-  let handler = null;
-  let setCalls = 0;
-  const statusArgs = [];
-  const feed = createAgentJobFeed({
-    runtime: { onNotification: (fn) => { handler = fn; return () => {}; } },
-    getState: () => ({ busy: false }),
-    set: () => { setCalls += 1; },
-    nextId: () => 'id',
-    getDisposed: () => false,
-    patchItem: () => {},
-    enqueue: () => true,
-    drain: () => Promise.resolve(),
-    pushUserOrSyntheticItem: () => {},
-    makeQueueEntry: (text, opts = {}) => ({ text, ...opts }),
-    getPending: () => [],
-    agentStatusState: (args) => {
-      statusArgs.push(args);
-      return {};
-    },
-    displayedExecutionNotificationKeys: new Set(),
-    pushNotice: () => {},
-  });
-  const unsubscribe = feed.subscribeRuntimeNotifications();
-
-  for (let i = 0; i < 24; i += 1) {
-    handler({
-      content: `agent task: burst_${i}\nstatus: running`,
-      meta: { type: 'agent_task_status', execution_id: `burst_${i}`, status: 'running' },
-    });
-  }
-  assert.equal(setCalls, 0, 'burst stays deferred until the coalesce boundary');
-  await new Promise((resolve) => setTimeout(resolve, 30));
-  assert.equal(setCalls, 1);
-  assert.equal(statusArgs.length, 1);
-
-  for (let i = 0; i < 24; i += 1) {
-    handler({
-      content: `agent task: burst_${i}\nstatus: completed`,
-      meta: { type: 'agent_task_result', execution_id: `burst_${i}`, status: 'completed' },
-    });
-  }
-  await new Promise((resolve) => setTimeout(resolve, 30));
-  assert.equal(setCalls, 2);
-  assert.deepEqual(statusArgs.at(-1), { force: true }, 'terminal burst forces one fresh snapshot');
-  unsubscribe();
-});

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

@@ -1,151 +0,0 @@
-// Regression for the execution-pending-resume kick (engine/agent-job-feed.mjs).
-// Guards two coupled defects:
-//   A (body loss): parallel completions deferred while busy must each surface
-//     their model-visible body on resume — the old single string slot dropped
-//     all but the last.
-//   B (missed resume): a deferred kick left after a busy->false transition that
-//     did NOT go through drain-finally / normal-turn-end (watchdog force-release
-//     or stale-unwind) must still fire when flushDeferred is called.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-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({ now, executionResumeTombstoneTtlMs, executionResumeTombstoneLimit } = {}) {
-  const pending = [];
-  const surfaced = [];
-  const state = { busy: false };
-  let draining = false;
-
-  function drain() {
-    if (draining) return Promise.resolve();
-    draining = true;
-    try {
-      for (let i = 0; i < pending.length;) {
-        const entry = pending[i];
-        if (entry.mode === 'pending-resume') {
-          surfaced.push(entry.text);
-          pending.splice(i, 1);
-        } else {
-          i += 1;
-        }
-      }
-    } finally {
-      draining = false;
-    }
-    return Promise.resolve();
-  }
-
-  const feed = createAgentJobFeed({
-    runtime: {},
-    getState: () => state,
-    set: () => {},
-    nextId: () => 'id',
-    getDisposed: () => false,
-    patchItem: () => {},
-    enqueue: () => {},
-    drain,
-    pushUserOrSyntheticItem: () => {},
-    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 };
-}
-
-const microtasks = () => new Promise((r) => setImmediate(r));
-
-test('A: two completions deferred while busy both surface their bodies on resume', async () => {
-  const { feed, surfaced, state } = makeHarness();
-  state.busy = true;
-  feed.scheduleExecutionPendingResumeKick('body A');
-  feed.scheduleExecutionPendingResumeKick('body B');
-  await microtasks();
-  // Both kicks deferred while busy; nothing surfaced yet.
-  assert.deepEqual(surfaced, []);
-
-  // Turn settles normally -> busy false -> flush re-arms the kick.
-  state.busy = false;
-  feed.flushDeferredExecutionPendingResumeKick();
-  assert.equal(surfaced.length, 1, 'a single merged resume entry surfaced');
-  assert.match(surfaced[0], /body A/, 'first body preserved');
-  assert.match(surfaced[0], /body B/, 'second body preserved (not dropped)');
-});
-
-test('B: deferred kick after a non-drain busy->false transition still fires', async () => {
-  const { feed, surfaced, state } = makeHarness();
-  state.busy = true;
-  feed.scheduleExecutionPendingResumeKick('only body');
-  await microtasks();
-  assert.deepEqual(surfaced, [], 'deferred while busy');
-
-  // Simulate watchdog force-release / stale-unwind: busy flips to false WITHOUT
-  // drain-finally, then flushDeferred runs on that transition.
-  state.busy = false;
-  feed.flushDeferredExecutionPendingResumeKick();
-  assert.deepEqual(surfaced, ['only body'], 'resume fired on the non-drain transition');
-
-  // Idempotent: a second flush with nothing deferred is a no-op.
-  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');
-});