mixdog 0.9.38 → 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/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');
+});

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

@@ -0,0 +1,174 @@
+// Production-path regression: runtime completion notification -> feed enqueue
+// -> session drain -> real runTurn -> Esc. This deliberately uses the real
+// feed, queue, API, and turn implementations rather than fabricating restore
+// state, so ownership survives the same path used by the TUI.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createAgentJobFeed } from '../src/tui/engine/agent-job-feed.mjs';
+import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
+import { createRunTurn } from '../src/tui/engine/turn.mjs';
+import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
+import { _clearDeliveredCompletions } from '../src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function completion(executionId, body) {
+  return {
+    content: `Async agent task ${executionId} completed finished.\n\nResult:\n> ${body}`,
+    meta: { type: 'agent_task_result', execution_id: executionId, status: 'completed' },
+  };
+}
+
+function makeHarness() {
+  let seq = 0;
+  let notify = null;
+  let activeAsk = null;
+  let feed = null;
+  const asks = [];
+  const pending = [];
+  const itemIndexById = new Map();
+  const state = {
+    items: [],
+    queued: [],
+    busy: false,
+    commandBusy: false,
+    spinner: null,
+    thinking: null,
+    lastTurn: null,
+    stats: { turns: 0, inputTokens: 0, outputTokens: 0 },
+  };
+  const runtime = {
+    id: null,
+    toolMode: 'auto',
+    onNotification: (fn) => { notify = fn; return () => {}; },
+    consumePendingSessionReset: () => null,
+    ask: async (text, options) => new Promise((resolve, reject) => {
+      activeAsk = { text, options, reject };
+      asks.push(activeAsk);
+    }),
+    abort: () => {
+      const error = new Error('interrupted');
+      error.name = 'SessionClosedError';
+      activeAsk?.reject(error);
+      return true;
+    },
+  };
+  const bag = {
+    runtime,
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    LEAD_TURN_TIMEOUT_MS: 300_000,
+    flags: { leadTurnEpoch: 0, drainEpoch: 0, disposed: false, draining: false, activePromptRestore: null },
+    pending,
+    pendingNotificationKeys: new Set(),
+    displayedExecutionNotificationKeys: new Set(),
+    listeners: new Set(),
+    itemIndexById,
+    getState: () => state,
+    set: (patch) => Object.assign(state, patch),
+    pushItem: (item) => {
+      state.items = [...state.items, item];
+      if (item?.id != null) itemIndexById.set(item.id, state.items.length - 1);
+    },
+    patchItem: (id, patch) => {
+      const index = state.items.findIndex((item) => item.id === id);
+      if (index < 0) return false;
+      state.items = state.items.map((item, i) => i === index ? { ...item, ...patch } : item);
+      return true;
+    },
+    replaceItems: (items) => items,
+    pushNotice: () => {},
+    pushUserOrSyntheticItem: (text, id) => {
+      state.items = [...state.items, { kind: 'injected', id, text }];
+    },
+    autoClearState: () => ({ enabled: false }),
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    requestToolApproval: async () => ({ approved: false }),
+    markToolCallActive: () => {},
+    markToolCallDone: () => {},
+    clearActiveToolSummary: () => {},
+    patchToolCardResult: () => {},
+    flushToolResults: () => {},
+    // session-flow captures this dependency before the feed is constructed;
+    // keep that production ordering while forwarding to the live feed.
+    flushDeferredExecutionPendingResumeKick: () => feed?.flushDeferredExecutionPendingResumeKick(),
+  };
+
+  Object.assign(bag, createSessionFlow(bag));
+  feed = createAgentJobFeed({
+    runtime,
+    getState: bag.getState,
+    set: bag.set,
+    nextId: bag.nextId,
+    getDisposed: () => bag.flags.disposed,
+    patchItem: bag.patchItem,
+    enqueue: (...args) => bag.enqueue(...args),
+    drain: (...args) => bag.drain(...args),
+    pushUserOrSyntheticItem: bag.pushUserOrSyntheticItem,
+    makeQueueEntry: (...args) => bag.makeQueueEntry(...args),
+    getPending: () => pending,
+    agentStatusState: bag.agentStatusState,
+    displayedExecutionNotificationKeys: bag.displayedExecutionNotificationKeys,
+    pushNotice: bag.pushNotice,
+  });
+  Object.assign(bag, feed);
+  bag.runTurn = createRunTurn(bag);
+  const api = createEngineApiA(bag);
+  feed.subscribeRuntimeNotifications();
+
+  return {
+    api,
+    state,
+    asks,
+    deliver: (event) => notify(event),
+    activeAsk: () => activeAsk,
+  };
+}
+
+for (const phase of ['before first delta', 'after response progress']) {
+  test(`runtime completion Esc ${phase} does not restart it, while a new completion wakes`, async () => {
+    _clearDeliveredCompletions();
+    const harness = makeHarness();
+
+    const first = completion('execution_A', 'first result');
+    harness.deliver(first);
+    await tick();
+    assert.equal(harness.asks.length, 1, 'runtime notification drained into a real turn');
+    assert.match(harness.activeAsk().text, /first result/, 'completion body reached runtime.ask');
+    assert.equal(first.modelVisibleDelivered, true, 'notification was acknowledged on the TUI path');
+
+    if (phase === '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)),
+        true,
+        'response progress reached the live turn',
+      );
+    }
+
+    assert.equal(harness.api.abort().aborted, true, 'Esc aborts the active runTurn');
+    await tick();
+    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');
+
+    harness.deliver(completion('execution_A', 'duplicate retry'));
+    await tick();
+    assert.equal(harness.asks.length, 1, 'duplicate execution delivery cannot restart the aborted completion');
+
+    harness.deliver(completion('execution_B', 'later result'));
+    await tick();
+    assert.equal(harness.asks.length, 2, 'a genuinely new execution still wakes a turn');
+    assert.match(harness.activeAsk().text, /later result/);
+
+    // Finish the second intentionally-open mocked provider request.
+    harness.api.abort();
+    await tick();
+  });
+}