Drop leftover drain send after a generation bump

Leftover hops went through sendUserPrompt with no deliveryGeneration
check, so a /clear mid-ingest still landed in the new session.
Capture generation at leftover hop time and skip send and recall
after ingest when the generation has bumped. Operator Enter stays
ungated.

Author: TheGreatAxios

src/tui/queued-delivery.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import type { PendingImageAttachment } from "./image-attachments.js";
 import {
   createDeliveryGeneration,
+  createLeftoverSend,
   createLiveSteerDeliver,
   routeQueuedDelivery,
 } from "./queued-delivery.js";
@@ -177,3 +178,101 @@ describe("createLiveSteerDeliver", () => {
     expect(delivered).toEqual([]);
   });
 });
+
+describe("createLeftoverSend", () => {
+  test("generation bump during ingest drops leftover send and sent-message record", async () => {
+    const sent: string[] = [];
+    const recorded: string[] = [];
+    const { enqueue, awaitTail } = createSessionOperationQueue();
+    const generation = createDeliveryGeneration();
+    let resolveSlow!: () => void;
+    const slow = new Promise<void>((resolve) => {
+      resolveSlow = resolve;
+    });
+    const leftoverSend = createLeftoverSend({
+      enqueue,
+      ingest: async (text) => {
+        if (text === "leftover") await slow;
+        return { text, attachments: [] };
+      },
+      send: (text) => {
+        sent.push(text);
+      },
+      recordSent: (text) => {
+        recorded.push(text);
+      },
+      captureGeneration: generation.capture,
+      onFailure: (err) => {
+        throw err;
+      },
+    });
+
+    leftoverSend("leftover");
+    generation.bump();
+    resolveSlow();
+    await awaitTail();
+    expect(sent).toEqual([]);
+    expect(recorded).toEqual([]);
+  });
+
+  test("leftover send without a bump still sends and records", async () => {
+    const sent: string[] = [];
+    const recorded: string[] = [];
+    const { enqueue, awaitTail } = createSessionOperationQueue();
+    const leftoverSend = createLeftoverSend({
+      enqueue,
+      ingest: async (text) => ({ text, attachments: [] }),
+      send: (text) => {
+        sent.push(text);
+      },
+      recordSent: (text) => {
+        recorded.push(text);
+      },
+      captureGeneration: () => () => true,
+      onFailure: (err) => {
+        throw err;
+      },
+    });
+
+    leftoverSend("follow-up");
+    await awaitTail();
+    expect(sent).toEqual(["follow-up"]);
+    expect(recorded).toEqual(["follow-up"]);
+  });
+
+  test("generation bump drops leftover send but not a sibling Enter send", async () => {
+    const leftoverSent: string[] = [];
+    const enterSent: string[] = [];
+    const { enqueue, awaitTail } = createSessionOperationQueue();
+    const generation = createDeliveryGeneration();
+    let resolveSlow!: () => void;
+    const slow = new Promise<void>((resolve) => {
+      resolveSlow = resolve;
+    });
+    const leftoverSend = createLeftoverSend({
+      enqueue,
+      ingest: async (text) => {
+        await slow;
+        return { text, attachments: [] };
+      },
+      send: (text) => {
+        leftoverSent.push(text);
+      },
+      captureGeneration: generation.capture,
+      onFailure: (err) => {
+        throw err;
+      },
+    });
+    const enterSend = (text: string) => {
+      enterSent.push(text);
+    };
+
+    leftoverSend("queued");
+    generation.bump();
+    enterSend("hello");
+    resolveSlow();
+    await awaitTail();
+    expect(leftoverSent).toEqual([]);
+    expect(enterSent).toEqual(["hello"]);
+  });
+});

src/tui/queued-delivery.ts

@@ -64,12 +64,34 @@ export interface CreateLiveSteerDeliverArgs {
   onFailure: (err: unknown) => void;
 }
 
-/**
- * Live inject: enqueue ingest, then deliver, in drain order. Previously
- * each item started ingest immediately, so Agent.deliver could reverse.
- */
-export function createLiveSteerDeliver(
-  args: CreateLiveSteerDeliverArgs,
+export interface CreateLeftoverSendArgs {
+  enqueue: (op: () => Promise<void>) => Promise<void>;
+  ingest: (text: string, attachments: readonly PendingImageAttachment[]) => Promise<IngestedSteer>;
+  /**
+   * Post-ingest hop (agentProxy.send). Must not ingest again — leftover
+   * ingest already ran in this wrapper.
+   */
+  send: (text: string, attachments: readonly PendingImageAttachment[]) => void;
+  /**
+   * Up/Down recall. Called with the original text only when the hop is
+   * still current after ingest, so a /clear|/new drop is not recorded.
+   */
+  recordSent?: (text: string) => void;
+  captureGeneration: () => () => boolean;
+  onFailure: (err: unknown) => void;
+}
+
+interface GenerationGatedHopArgs {
+  enqueue: (op: () => Promise<void>) => Promise<void>;
+  ingest: (text: string, attachments: readonly PendingImageAttachment[]) => Promise<IngestedSteer>;
+  hop: (text: string, attachments: readonly PendingImageAttachment[]) => void;
+  recordSent?: (text: string) => void;
+  captureGeneration: () => () => boolean;
+  onFailure: (err: unknown) => void;
+}
+
+function createGenerationGatedHop(
+  args: GenerationGatedHopArgs,
 ): (text: string, attachments?: readonly PendingImageAttachment[]) => void {
   return (text, attachments) => {
     const stillCurrent = args.captureGeneration();
@@ -79,8 +101,29 @@ export function createLiveSteerDeliver(
         if (!stillCurrent()) return;
         const ingested = await args.ingest(text, pending);
         if (!stillCurrent()) return;
-        args.deliver(ingested.text, ingested.attachments);
+        args.recordSent?.(text);
+        args.hop(ingested.text, ingested.attachments);
       })
       .catch(args.onFailure);
   };
 }
+
+/**
+ * Live inject: enqueue ingest, then deliver, in drain order. Previously
+ * each item started ingest immediately, so Agent.deliver could reverse.
+ */
+export function createLiveSteerDeliver(
+  args: CreateLiveSteerDeliverArgs,
+): (text: string, attachments?: readonly PendingImageAttachment[]) => void {
+  return createGenerationGatedHop({ ...args, hop: args.deliver });
+}
+
+/**
+ * Leftover / queue drain hop: capture generation at hop time, ingest, then
+ * send only if /clear|/new has not bumped. Operator Enter must not use this.
+ */
+export function createLeftoverSend(
+  args: CreateLeftoverSendArgs,
+): (text: string, attachments?: readonly PendingImageAttachment[]) => void {
+  return createGenerationGatedHop({ ...args, hop: args.send });
+}

src/tui/runner.ts

@@ -187,6 +187,7 @@ import { createCycleTextRecorder } from "../session/stream-journal.js";
 import { mountRunnerHost } from "./runner-host.js";
 import {
   createDeliveryGeneration,
+  createLeftoverSend,
   createLiveSteerDeliver,
   routeQueuedDelivery,
 } from "./queued-delivery.js";
@@ -2296,7 +2297,25 @@ export async function runTUI(initialConfig: Config): Promise<number> {
         }),
       interrupt,
       deliver: routeQueuedDelivery({
-        send,
+        send: createLeftoverSend({
+          enqueue: sessionOps.enqueue,
+          ingest: (text, pending) =>
+            ingestOperatorPrompt(text, config.cwd, imageAttachmentFromPath, pending),
+          send: (text, pending) => {
+            sendAborted = false;
+            void agentProxy.send(userInboundMessage(text, pending)).catch(handleSendFailure);
+          },
+          recordSent: (text) => {
+            if (text.trim().length === 0) return;
+            void appendSentMessage(config.cwd, sessionId, text).catch((err: unknown) => {
+              tuiLogger.debug("sent-message append failed: {error}", {
+                error: err instanceof Error ? err.message : String(err),
+              });
+            });
+          },
+          captureGeneration: deliveryGeneration.capture,
+          onFailure: handleSendFailure,
+        }),
         parentCycleLive: () => host.bridge.parentCycleLive,
         deliverSteer: createLiveSteerDeliver({
           enqueue: sessionOps.enqueue,