mixdog 0.9.38 → 0.9.40

package/src/tui/engine/agent-job-feed.mjs

@@ -21,9 +21,15 @@ import {
 import { toolErrorDisplay } from './tool-result-text.mjs';
 import {
   notificationQueueKey,
+  executionCardKey,
   resolveTuiRuntimeNotificationDelivery,
 } from './notification-plan.mjs';
+import { shortTextFingerprint } from './queue-helpers.mjs';
 import { readImageAttachmentFromPath } from '../paste-attachments.mjs';
+import {
+  isDeliveredCompletion,
+  recordDeliveredCompletion,
+} from '../../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
 
 // Channel inbound images arrive as a JSON-array-of-paths meta value (stringified
 // across the notify IPC boundary). Parse defensively; a malformed value simply
@@ -48,13 +54,82 @@ export function createAgentJobFeed({
   enqueue,
   drain,
   pushUserOrSyntheticItem,
+  pushAsyncAgentResponse,
   makeQueueEntry,
   getPending,
   agentStatusState,
   displayedExecutionNotificationKeys,
+  itemIndexById,
   pushNotice,
+  now = () => Date.now(),
+  executionResumeTombstoneTtlMs = 30_000,
+  executionResumeTombstoneLimit = 128,
 }) {
+  const executionDedupLimit = 256;
   let executionResumeKickDeferred = false;
+  // Completion keys explicitly abandoned by Esc. Tombstones are per-feed
+  // (therefore per TUI session), short-lived, and bounded: they catch a late
+  // duplicate racing the abort without permanently reserving execution IDs or
+  // retaining completion bodies.
+  const discardedExecutionResumeKeys = new Map();
+  // Tracks whether an execution's visible response is only a bodyless preview
+  // or has reached its final body. A preview must not permanently suppress the
+  // later body, while repeated body retries remain idempotent.
+  const displayedExecutionResponseStates = new Map();
+  const terminalExecutionNotificationKeys = new Set();
+  const terminalExecutionResponseKeys = new Set();
+  const executionNotificationKeys = new Map();
+
+  const clearExecutionDedupState = () => {
+    displayedExecutionNotificationKeys.clear();
+    displayedExecutionResponseStates.clear();
+    terminalExecutionNotificationKeys.clear();
+    terminalExecutionResponseKeys.clear();
+    executionNotificationKeys.clear();
+  };
+  const rememberDisplayedExecutionNotificationKey = (key, terminal = false, executionId = '') => {
+    if (!key) return;
+    displayedExecutionNotificationKeys.delete(key);
+    if (executionId) executionNotificationKeys.set(key, executionId);
+    if (terminal) terminalExecutionNotificationKeys.add(key);
+    else terminalExecutionNotificationKeys.delete(key);
+    while (displayedExecutionNotificationKeys.size >= executionDedupLimit) {
+      const oldestTerminal = [...displayedExecutionNotificationKeys]
+        .find((candidate) => terminalExecutionNotificationKeys.has(candidate));
+      if (oldestTerminal == null) break;
+      displayedExecutionNotificationKeys.delete(oldestTerminal);
+      terminalExecutionNotificationKeys.delete(oldestTerminal);
+      executionNotificationKeys.delete(oldestTerminal);
+    }
+    displayedExecutionNotificationKeys.add(key);
+  };
+  const promoteExecutionNotificationKeys = (executionId) => {
+    if (!executionId) return;
+    for (const [key, keyExecutionId] of executionNotificationKeys) {
+      if (keyExecutionId !== executionId || !displayedExecutionNotificationKeys.has(key)) continue;
+      terminalExecutionNotificationKeys.add(key);
+    }
+  };
+  const promoteExecutionDedupState = (executionId) => {
+    if (!executionId) return;
+    promoteExecutionNotificationKeys(executionId);
+    const responseState = displayedExecutionResponseStates.get(executionId);
+    if (responseState) rememberDisplayedExecutionResponseState(executionId, responseState, true);
+  };
+  const rememberDisplayedExecutionResponseState = (key, value, terminal = false) => {
+    if (!key) return;
+    displayedExecutionResponseStates.delete(key);
+    if (terminal) terminalExecutionResponseKeys.add(key);
+    else terminalExecutionResponseKeys.delete(key);
+    while (displayedExecutionResponseStates.size >= executionDedupLimit) {
+      const oldestTerminal = [...displayedExecutionResponseStates.keys()]
+        .find((candidate) => terminalExecutionResponseKeys.has(candidate));
+      if (oldestTerminal == null) break;
+      displayedExecutionResponseStates.delete(oldestTerminal);
+      terminalExecutionResponseKeys.delete(oldestTerminal);
+    }
+    displayedExecutionResponseStates.set(key, value);
+  };
 
   // FIFO accumulation of model-visible bodies from completions that arrived
   // while busy (or while a pending-resume entry was already queued). A single
@@ -62,8 +137,49 @@ export function createAgentJobFeed({
   // the queue preserves every body and merges them into the resume turn.
   const executionResumeKickBodies = [];
 
-  function kickExecutionPendingResume(body = '') {
-    if (body) executionResumeKickBodies.push(body);
+  function executionResumeKey(body, completionKey = '') {
+    if (completionKey && typeof completionKey === 'object') {
+      completionKey = completionKey.executionId || completionKey.key || '';
+    }
+    const explicitKey = String(completionKey || '').trim();
+    if (explicitKey.startsWith('execution:') || explicitKey.startsWith('body:')) return explicitKey;
+    if (explicitKey) return `execution:${explicitKey}`;
+    const value = String(body || '').trim();
+    return value ? `body:${shortTextFingerprint(value)}` : '';
+  }
+
+  function pruneDiscardedExecutionResumeKeys() {
+    const nowMs = Number(now()) || Date.now();
+    for (const [key, expiresAt] of discardedExecutionResumeKeys) {
+      if (expiresAt <= nowMs) discardedExecutionResumeKeys.delete(key);
+    }
+  }
+
+  function isDiscardedExecutionResumeKey(key) {
+    if (!key) return false;
+    pruneDiscardedExecutionResumeKeys();
+    return discardedExecutionResumeKeys.has(key);
+  }
+
+  function rememberDiscardedExecutionResumeKey(key) {
+    if (!key) return;
+    pruneDiscardedExecutionResumeKeys();
+    const limit = Math.max(1, Number(executionResumeTombstoneLimit) || 128);
+    while (!discardedExecutionResumeKeys.has(key) && discardedExecutionResumeKeys.size >= limit) {
+      const oldest = discardedExecutionResumeKeys.keys().next().value;
+      if (oldest == null) break;
+      discardedExecutionResumeKeys.delete(oldest);
+    }
+    const ttlMs = Math.max(1, Number(executionResumeTombstoneTtlMs) || 30_000);
+    // Refresh insertion order so the bounded map evicts the oldest tombstone.
+    discardedExecutionResumeKeys.delete(key);
+    discardedExecutionResumeKeys.set(key, (Number(now()) || Date.now()) + ttlMs);
+  }
+
+  function kickExecutionPendingResume(body = '', completionKey = '') {
+    const key = executionResumeKey(body, completionKey);
+    if (body && isDiscardedExecutionResumeKey(key)) return;
+    if (body) executionResumeKickBodies.push({ body, key });
     if (getDisposed()) return;
     if (getState().busy) {
       executionResumeKickDeferred = true;
@@ -77,8 +193,15 @@ export function createAgentJobFeed({
     executionResumeKickDeferred = false;
     // Drain every accumulated body into ONE resume turn so no completion body
     // is lost when several deferred while busy.
-    const resumeBody = executionResumeKickBodies.splice(0).filter(Boolean).join('\n\n');
-    pending.push(makeQueueEntry(resumeBody, { mode: 'pending-resume', priority: 'next' }));
+    const resumeBodies = executionResumeKickBodies.splice(0);
+    const resumeBody = resumeBodies.map(({ body: value }) => value).filter(Boolean).join('\n\n');
+    const resumeCompletionKeys = resumeBodies.map(({ key }) => key).filter(Boolean);
+    pending.push(makeQueueEntry(resumeBody, {
+      mode: 'pending-resume',
+      priority: 'next',
+      abortDiscardOnAbort: true,
+      resumeCompletionKeys,
+    }));
     void drain();
   }
 
@@ -87,11 +210,25 @@ export function createAgentJobFeed({
     kickExecutionPendingResume();
   }
 
-  function scheduleExecutionPendingResumeKick(body = '') {
+  function scheduleExecutionPendingResumeKick(body = '', completionKey = '') {
     // Carry the model-visible body directly into the pending-resume entry so
     // the resumed turn sends it, instead of relying on the session-pending
     // completion marker (dropped by askSession pre-drain).
-    queueMicrotask(() => kickExecutionPendingResume(body));
+    queueMicrotask(() => kickExecutionPendingResume(body, completionKey));
+  }
+
+  function discardExecutionPendingResume(completionKeys = []) {
+    const keys = (Array.isArray(completionKeys) ? completionKeys : [completionKeys])
+      .map((key) => executionResumeKey('', key))
+      .filter(Boolean);
+    if (keys.length === 0) return;
+    for (const key of keys) rememberDiscardedExecutionResumeKey(key);
+    for (let i = executionResumeKickBodies.length - 1; i >= 0; i -= 1) {
+      if (isDiscardedExecutionResumeKey(executionResumeKickBodies[i].key)) {
+        executionResumeKickBodies.splice(i, 1);
+      }
+    }
+    executionResumeKickDeferred = executionResumeKickBodies.length > 0;
   }
 
   // Pure builder for the agent-job card patch. Split out so callers that are
@@ -101,7 +238,10 @@ export function createAgentJobFeed({
   // jitter into one visible item update.
   function buildAgentJobCardPatch(itemId, text, isError = false) {
     const parsed = parseAgentJob(text);
-    const current = getState().items.find((it) => it.id === itemId);
+    const index = itemIndexById?.get(itemId);
+    const current = Number.isInteger(index) && getState().items[index]?.id === itemId
+      ? getState().items[index]
+      : null;
     const rawDisplayText = agentJobResultText(text, parsed) || String(text ?? '').trim();
     const displayText = isError ? toolErrorDisplay(rawDisplayText, 'agent') : rawDisplayText;
     return {
@@ -117,58 +257,110 @@ export function createAgentJobFeed({
     patchItem(itemId, buildAgentJobCardPatch(itemId, text, isError));
   }
 
+  function refreshAgentStatus(parsed) {
+    if (!parsed?.taskId) return;
+    const status = String(parsed.status || '').toLowerCase();
+    const terminal = /^(completed|complete|done|success|succeeded|ok|failed|error|timeout|killed|cancelled|canceled|denied)$/.test(status);
+    set(agentStatusState(terminal ? { force: true } : undefined));
+  }
+
   function subscribeRuntimeNotifications() {
     if (typeof runtime.onNotification !== 'function') return null;
-    return runtime.onNotification((event) => {
+    const unsubscribe = runtime.onNotification((event) => {
       if (getDisposed()) return;
       const text = String(event?.content ?? event?.text ?? event ?? '').trim();
       if (!text) return;
       const parsed = parseAgentJob(text);
       const notificationKey = notificationQueueKey(event, text, parsed);
       const delivery = resolveTuiRuntimeNotificationDelivery(event, text);
+      const executionId = String(event?.meta?.execution_id || parsed?.taskId || '').trim();
+      const status = String(event?.meta?.status || parsed?.status || '').toLowerCase();
+      const terminalStatus = /^(completed|complete|done|success|succeeded|ok|failed|error|timeout|killed|cancelled|canceled|denied)$/.test(status);
+      if (terminalStatus) promoteExecutionDedupState(executionId);
       if (delivery.action === 'ignore') return;
       if (delivery.action === 'notice') {
         pushNotice?.(delivery.displayText, delivery.tone || 'info', { transcript: delivery.transcript === true });
         return true;
       }
       if (delivery.action === 'status-only') {
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
+        refreshAgentStatus(parsed);
         return true;
       }
       if (delivery.action === 'execution-ui') {
-        const firstDelivery = !notificationKey || !displayedExecutionNotificationKeys.has(notificationKey);
-        if (firstDelivery) {
-          if (notificationKey) displayedExecutionNotificationKeys.add(notificationKey);
-          pushUserOrSyntheticItem(delivery.displayText, nextId());
+        const cardKey = executionCardKey(event, text, parsed);
+        const firstDelivery = !cardKey || !displayedExecutionNotificationKeys.has(cardKey);
+        const hasBody = /\n\s*\n[\s\S]*\S/.test(text);
+        const isFailure = /^(failed|error|timeout|killed|cancelled|canceled|denied)$/.test(status);
+        const successfulPreview = !hasBody && !isFailure && /^(completed|complete|done|success|succeeded|ok)$/.test(status);
+        const terminal = terminalStatus;
+        const responseState = executionId ? displayedExecutionResponseStates.get(executionId) : '';
+        const bodyAlreadyDisplayed = responseState === 'body';
+        if (cardKey && terminal && displayedExecutionNotificationKeys.has(cardKey)) {
+          rememberDisplayedExecutionNotificationKey(cardKey, true, executionId);
+        }
+        if (terminal) promoteExecutionDedupState(executionId);
+        if (firstDelivery && !successfulPreview && !bodyAlreadyDisplayed) {
+          if (cardKey) rememberDisplayedExecutionNotificationKey(cardKey, terminal, executionId);
+          if (executionId) rememberDisplayedExecutionResponseState(executionId, hasBody ? 'body' : 'preview', terminal);
+          // Execution completions are inbound agent responses. The engine keeps
+          // their aggregation tail-safe (only an immediately-adjacent inbound
+          // response of the same preview/body phase can merge); the fallback
+          // preserves the standalone path for minimal/test harnesses.
+          (pushAsyncAgentResponse || pushUserOrSyntheticItem)(delivery.displayText, nextId(), 'injected', { responseKey: executionId });
         }
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
+        refreshAgentStatus(parsed);
         const resumeBody = String(delivery.modelContent || '').trim();
         if (resumeBody) {
-          enqueue(resumeBody, {
+          const completionKey = executionResumeKey(resumeBody, executionId);
+          // Consolidated completion dedup keyed off execution_id (+ text hash):
+          // if this exact execution completion was already delivered — either by
+          // an earlier TUI enqueue here or by runtime-core's ack — do NOT enqueue
+          // a duplicate model-visible twin. A re-arriving completion while IDLE
+          // would otherwise re-enqueue and let post-turn drain() spawn a fresh
+          // turn. Still ack (modelVisibleDelivered) so runtime-core's
+          // mirror/fallback stays suppressed; the card first-delivery push and
+          // status refresh above already ran.
+          if (isDiscardedExecutionResumeKey(completionKey) || isDeliveredCompletion({ executionId, text: resumeBody })) {
+            if (event && typeof event === 'object') event.modelVisibleDelivered = true;
+            return true;
+          }
+          const enqueued = enqueue(resumeBody, {
             mode: 'task-notification',
             // Claude Code parity: live execution completions are queued as
             // task notifications so the active loop can attach them after the
             // next tool batch; no special pending-resume bypass.
             priority: 'next',
             key: notificationKey || undefined,
+            abortDiscardOnAbort: true,
+            resumeCompletionKeys: completionKey ? [completionKey] : [],
             displayText: delivery.displayText || text,
             // The immediate Response card was already pushed above
             // (pushUserOrSyntheticItem). Keep this queued twin model-visible
             // but suppress its drain-time transcript card to avoid a duplicate.
             suppressDisplay: true,
           });
+          // Self-sufficient TUI dedup: mark delivered right here (mark-once at
+          // delivery, keyed by execution_id) so a re-arriving completion is
+          // skipped above without depending solely on the runtime-core ack
+          // roundtrip — removes the split-brain asymmetry. Gated on a CONFIRMED
+          // enqueue: enqueue() returns false only when an identical-key
+          // task-notification twin is already queued (session-flow.mjs
+          // pendingNotificationKeys.has(key)), in which case the completion is
+          // already pending delivery and must not be double-recorded.
+          if (enqueued) recordDeliveredCompletion({ executionId, text: resumeBody });
           // EXPLICIT ack to the emitting runtime: the model-visible completion
           // body was injected into the active loop here, so notifyFnForSession
           // must NOT also mirror it into the pending queue (double injection).
           // A bare truthy return below is display/status handling only — this
-          // flag is the sole model-visible-delivery signal.
+          // flag is the sole model-visible-delivery signal. Set for BOTH the
+          // real-enqueue and the enqueue===false (already-queued twin) cases:
+          // either way the completion is pending delivery on the TUI path, so
+          // runtime-core must still not mirror it.
           if (event && typeof event === 'object') event.modelVisibleDelivered = true;
         }
         return true;
       }
-      if (parsed?.taskId) {
-        set(agentStatusState({ force: true }));
-      }
+      refreshAgentStatus(parsed);
       const modelContent = String(delivery.modelContent ?? delivery.displayText ?? text).trim();
       const imagePaths = parseInboundImagePaths(event?.meta?.image_paths);
       if (!modelContent && imagePaths.length === 0) return true;
@@ -206,14 +398,19 @@ export function createAgentJobFeed({
       enqueue(modelContent, enqueueOpts);
       return true;
     });
+    return () => {
+      try { unsubscribe?.(); } finally { clearExecutionDedupState(); }
+    };
   }
 
   return {
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,
+    clearExecutionDedupState,
   };
 }

package/src/tui/engine/agent-response-tail.mjs

@@ -0,0 +1,68 @@
+// Pure, tail-only inbound-agent response aggregation. The caller decides
+// whether the transcript tail is eligible; this helper never searches older
+// rows, so a retry cannot mutate across a real transcript boundary.
+function responseEntry(response = {}) {
+  return {
+    key: String(response.key || ''),
+    raw: String(response.rawResult ?? response.raw ?? '').trim(),
+    result: response.result,
+    hasBody: response.hasBody === true,
+    isError: response.isError === true,
+  };
+}
+
+export function formatAgentResponseRaw(entries = []) {
+  return entries
+    .map((entry, index) => {
+      const raw = String(entry?.raw || '').trim();
+      return raw ? `${index + 1}. agent\n${raw}` : '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function priorEntries(previous) {
+  if (Array.isArray(previous?.agentResponseEntries) && previous.agentResponseEntries.length) {
+    return previous.agentResponseEntries.map(responseEntry);
+  }
+  return [responseEntry({
+    key: previous?.agentResponseKey,
+    rawResult: previous?.rawResult ?? previous?.result,
+    result: previous?.result,
+    hasBody: previous?.agentResponseHasBody,
+    isError: previous?.isError,
+  })];
+}
+
+export function appendAgentResponseTail(previous, response, now = Date.now()) {
+  if (previous?.kind !== 'tool' || previous.agentDirection !== 'inbound') return null;
+  const next = responseEntry(response);
+  const entries = priorEntries(previous);
+  const existingIndex = next.key ? entries.findIndex((entry) => entry.key === next.key) : -1;
+
+  if (existingIndex >= 0) {
+    // A preview/final/retry for the same execution is one response. Replace
+    // that entry in-place only because this aggregate is still the transcript
+    // tail; never turn it into another count or a nested raw block.
+    entries[existingIndex] = next;
+  } else {
+    // Distinct responses can merge only when their presentation phase matches.
+    // A visible bodyless failure stays a separate row from a later full body.
+    if (previous.agentResponseHasBody !== next.hasBody) return null;
+    entries.push(next);
+  }
+
+  return {
+    args: response.args,
+    result: response.result,
+    rawResult: formatAgentResponseRaw(entries) || null,
+    isError: entries.some((entry) => entry.isError),
+    count: entries.length,
+    completedCount: entries.length,
+    completedAt: now,
+    agentResponseEntries: entries,
+    agentResponseKeys: entries.map((entry) => entry.key).filter(Boolean),
+    agentResponseHasBody: entries.every((entry) => entry.hasBody),
+    agentResponseAggregate: entries.length > 1,
+  };
+}

package/src/tui/engine/notification-plan.mjs

@@ -47,6 +47,22 @@ export function notificationQueueKey(event, text, parsed) {
   return [id, type || fallbackKind, status, hasBody].filter(Boolean).join(':');
 }
 
+/**
+ * Stable dedup key for the execution transcript CARD. Unlike notificationQueueKey
+ * it drops the volatile type/status dimensions so a duplicate completion re-arriving
+ * with a different type/status (same execution_id) cannot push a second card. The
+ * hasBody dimension is preserved so a bodyless preview (b0) and the real result (b1)
+ * remain distinct cards (intentional preview→result upgrade). Falls back to
+ * notificationQueueKey when no execution_id is present.
+ */
+export function executionCardKey(event, text, parsed) {
+  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
+  const executionId = String(meta.execution_id || '').trim();
+  if (!executionId) return notificationQueueKey(event, text, parsed);
+  const hasBody = /\n\s*\n[\s\S]*\S/.test(String(text || '')) ? 'b1' : 'b0';
+  return `card:${executionId}:${hasBody}`;
+}
+
 export function isExecutionNotification(event, text, parsed) {
   const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
   if (meta.execution_id || meta.execution_surface) return true;

package/src/tui/engine/session-api.mjs

@@ -24,7 +24,7 @@ export function createEngineApi(bag) {
 
 export function createEngineApiA(bag) {
   const {
-    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick,
+    runtime, nextId, flags, pending, listeners, getState, set, pushItem, patchItem, replaceItems, settleStreamingTail, clearStreamingTail, pushNotice, autoClearState, agentStatusState, routeState, syncContextStats, denyAllToolApprovals, updateAgentJobCard, requeueEntriesFront, enqueue, autoClearBeforeSubmit, restoreQueued, resetStatsAndSyncContext, drain, flushDeferredExecutionPendingResumeKick, discardExecutionPendingResume,
   } = bag;
   return {
     getState: () => getState(),
@@ -573,10 +573,15 @@ export function createEngineApiA(bag) {
         ? restoreState.pastedTexts
         : null;
       const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries)
-        ? restoreState.requeueEntries.slice()
+        ? restoreState.requeueEntries.filter(
+          (entry) => entry?.abortDiscardOnAbort !== true && entry?.mode !== 'pending-resume',
+        )
         : [];
       const aborted = runtime.abort('cli-react-abort');
       if (restoreState) {
+        if (aborted !== false && Array.isArray(restoreState.discardExecutionPendingResumeKeys)) {
+          discardExecutionPendingResume?.(restoreState.discardExecutionPendingResumeKeys);
+        }
         if ((restoreText || requeueEntries.length > 0) && aborted !== false) {
           restoreState.reclaimed = true;
           const idSet = new Set((restoreState.submittedIds || []).filter((id) => id != null));
@@ -592,6 +597,7 @@ export function createEngineApiA(bag) {
         }
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
+        restoreState.discardExecutionPendingResumeKeys = [];
       }
       // ── Bounded manual-abort recovery ───────────────────────────────────
       // runtime.abort() above normally rejects the in-flight runtime.ask() so
@@ -611,6 +617,12 @@ export function createEngineApiA(bag) {
         if (flags.disposed) return;
         if (!getState().busy) return;                    // normal abort settled
         if (flags.leadTurnEpoch !== abortEpoch) return;  // a newer turn owns the store
+        const streamingTail = getState().streamingTail;
+        if (streamingTail?.text?.trim()) {
+          settleStreamingTail?.(streamingTail.id, {});
+        } else {
+          clearStreamingTail?.();
+        }
         // Bump the epoch FIRST so the still-stuck turn's eventual finally becomes
         // a no-op for shared getState() writes and cannot corrupt the handoff.
         flags.leadTurnEpoch = (Number(flags.leadTurnEpoch) || 0) + 1;

package/src/tui/engine/session-flow.mjs

@@ -8,7 +8,7 @@ import { appendTuiSteeringPersist, dropTuiSteeringPersist, drainTuiSteeringPersi
 
 export function createSessionFlow(bag) {
   const {
-    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
+    runtime, nextId, tuiDebug, flags, pending, pendingNotificationKeys, displayedExecutionNotificationKeys, clearExecutionDedupState, getState, set, pushItem, replaceItems, pushNotice, pushUserOrSyntheticItem, autoClearState, agentStatusState, routeState, syncContextStats, flushDeferredExecutionPendingResumeKick,
   } = bag;
 
   // Upper bound on the awaited compacting clear. requireCompactSuccess makes
@@ -54,6 +54,12 @@ export function createSessionFlow(bag) {
       skipSlashCommands: options.skipSlashCommands === true,
       displayText: mode === 'task-notification' ? notificationDisplayText(displayText) : String(displayText || ''),
       suppressDisplay: options.suppressDisplay === true,
+      // Completion resumes are consumed exactly once: Esc abandons their
+      // uncommitted body instead of putting it back at the queue front.
+      abortDiscardOnAbort: options.abortDiscardOnAbort === true,
+      resumeCompletionKeys: Array.isArray(options.resumeCompletionKeys)
+        ? options.resumeCompletionKeys.filter((key) => key != null && String(key).trim())
+        : [],
       steeringPersistId: options.steeringPersistId || null,
       steeringPersistRestored: options.steeringPersistRestored === true,
     };
@@ -110,6 +116,7 @@ export function createSessionFlow(bag) {
       if (predicate(entry) && (entry.mode || 'prompt') === targetMode && queuePriorityValue(entry.priority) === bestPriority) {
         batch.push(entry);
         pending.splice(i, 1);
+        if (entry.mode === 'task-notification' && entry.key) pendingNotificationKeys.delete(entry.key);
         if (batch.length >= limit) break;
       } else {
         i += 1;
@@ -194,6 +201,17 @@ export function createSessionFlow(bag) {
           pushUserOrSyntheticItem(entry.text, entry.id, isQueuedEntryEditable(entry) ? 'user' : 'injected');
         }
         const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
+        // A completion resume is owned by the completion that woke it. Esc
+        // consumes that ownership; unlike ordinary notifications it must never
+        // be requeued from an uncommitted turn. Keep normal task notifications
+        // recoverable exactly as before.
+        const discardOnAbort = nonEditable.filter(
+          (entry) => entry?.abortDiscardOnAbort === true || entry?.mode === 'pending-resume',
+        );
+        const requeueOnAbort = nonEditable.filter((entry) => !discardOnAbort.includes(entry));
+        const discardExecutionPendingResumeKeys = discardOnAbort.flatMap(
+          (entry) => Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : [],
+        );
         const batchPastedImages = mergePastedImages(batch);
         const batchPastedTexts = mergePastedTexts(batch);
         const turnStatus = await bag.runTurn(merged, {
@@ -203,7 +221,8 @@ export function createSessionFlow(bag) {
           onCommitted: () => commitSteeringQueueEntries(batch),
           submittedIds: [...ids],
           restorable: nonEditable.length === 0,
-          requeueOnAbort: nonEditable,
+          requeueOnAbort,
+          discardExecutionPendingResumeKeys,
         });
         if (flags.drainEpoch !== drainEpoch) return;
         // A deferred cleared-session UI sync (from a late-settling abandoned
@@ -480,6 +499,7 @@ export function createSessionFlow(bag) {
     getState().busy = false;
     pendingNotificationKeys.clear();
     displayedExecutionNotificationKeys.clear();
+    clearExecutionDedupState?.();
   };
   // Post-success UI sync shared by the normal clear path and a late-fulfilling
   // abandoned compacting clear, so the UI always matches the cleared runtime