mixdog 0.9.37 → 0.9.39

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,26 @@ export function createAgentJobFeed({
   enqueue,
   drain,
   pushUserOrSyntheticItem,
+  pushAsyncAgentResponse,
   makeQueueEntry,
   getPending,
   agentStatusState,
   displayedExecutionNotificationKeys,
   pushNotice,
+  now = () => Date.now(),
+  executionResumeTombstoneTtlMs = 30_000,
+  executionResumeTombstoneLimit = 128,
 }) {
   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();
 
   // 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 +81,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 +137,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 +154,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
@@ -117,6 +198,13 @@ 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) => {
@@ -132,33 +220,81 @@ export function createAgentJobFeed({
         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 executionId = String(event?.meta?.execution_id || parsed?.taskId || '').trim();
+        const status = String(event?.meta?.status || parsed?.status || '').toLowerCase();
+        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 responseState = executionId ? displayedExecutionResponseStates.get(executionId) : '';
+        const bodyAlreadyDisplayed = responseState === 'body';
+        if (firstDelivery && !successfulPreview && !bodyAlreadyDisplayed) {
+          if (cardKey) displayedExecutionNotificationKeys.add(cardKey);
+          if (executionId) displayedExecutionResponseStates.set(executionId, hasBody ? 'body' : 'preview');
+          // 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. 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;
@@ -202,6 +338,7 @@ export function createAgentJobFeed({
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,
+    discardExecutionPendingResume,
     updateAgentJobCard,
     buildAgentJobCardPatch,
     subscribeRuntimeNotifications,

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/queue-helpers.mjs

@@ -12,6 +12,14 @@ import {
 
 const QUEUE_PRIORITY = { now: 0, next: 1, later: 2 };
 
+// Sentinel display text for a steering entry that is model-visible only: its
+// immediate transcript ("Response …") card was already pushed at delivery time
+// (live execution completion), so the mid-turn steering drain must NOT render a
+// second card for it. drainPendingSteering emits this as the entry's display
+// text; turn.mjs's onSteerMessage recognizes it and skips the push while the
+// model still receives the entry's content.
+export const STEERING_SUPPRESSED_DISPLAY = '\u0000mixdog:suppress-steer-display\u0000';
+
 export function queuePriorityValue(value) {
   return QUEUE_PRIORITY[String(value || 'next')] ?? QUEUE_PRIORITY.next;
 }

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, 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

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

@@ -3,7 +3,7 @@
  */
 import { presentErrorText } from '../../runtime/shared/err-text.mjs';
 import { createSessionStats } from './session-stats.mjs';
-import { queuePriorityValue, defaultQueuePriority, isQueuedEntryEditable, isQueuedEntryVisible, isSlashQueuedEntry, notificationDisplayText, sessionActivityTimestamp, promptDisplayText, mergePromptContents, mergePastedImages, mergePastedTexts, callCommitCallbacks } from './queue-helpers.mjs';
+import { queuePriorityValue, defaultQueuePriority, isQueuedEntryEditable, isQueuedEntryVisible, isSlashQueuedEntry, notificationDisplayText, sessionActivityTimestamp, promptDisplayText, mergePromptContents, mergePastedImages, mergePastedTexts, callCommitCallbacks, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { appendTuiSteeringPersist, dropTuiSteeringPersist, drainTuiSteeringPersist } from './tui-steering-persist.mjs';
 
 export function createSessionFlow(bag) {
@@ -53,6 +53,13 @@ export function createSessionFlow(bag) {
       key: options.key || null,
       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,
     };
@@ -186,9 +193,24 @@ export function createSessionFlow(bag) {
         const merged = mergePromptContents(batch);
         for (const entry of batch) {
           if (entry.mode === 'pending-resume') continue;
+          // Live execution completions push their own immediate Response card
+          // at delivery time; the queued twin is model-visible only and must
+          // NOT render a second transcript card here (no fall-back to content).
+          if (entry.suppressDisplay) continue;
           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, {
@@ -198,7 +220,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
@@ -274,6 +297,15 @@ export function createSessionFlow(bag) {
       if (batch.length === 0) break;
       for (const entry of batch) {
         const content = entry.content;
+        if (entry.suppressDisplay) {
+          // Model-visible twin of an already-rendered live completion: deliver
+          // content to the model but flag onSteerMessage to skip the duplicate
+          // transcript card (no fall-back to content-derived display text).
+          if (Array.isArray(content) ? content.length > 0 : String(content ?? '').trim().length > 0) {
+            out.push({ text: STEERING_SUPPRESSED_DISPLAY, content });
+          }
+          continue;
+        }
         const value = typeof content === 'string'
           ? content.trim()
           : { text: String(entry.text || '').trim(), content };