Skip leftover ingest for director wake text

Leftover hops used operator ingest, so a parked @path was rewritten
before echo matching could consume the raw wake.

Author: TheGreatAxios

src/tui/agent-ask-wake.test.ts

@@ -5,7 +5,13 @@ import { createAppShell } from "./shell/index";
 import { withTestRenderer } from "./harness";
 import type { PendingAskWake } from "../subagent/fleet-report.js";
 import { classifySubmission, createSubmitHandler } from "./runner/submit.js";
-import { routeQueuedDelivery } from "./queued-delivery.js";
+import {
+  createDeliveryGeneration,
+  createLeftoverSend,
+  routeQueuedDelivery,
+} from "./queued-delivery.js";
+import { createSessionOperationQueue } from "./session-operation-queue.js";
+import { ingestOperatorPrompt } from "./prompt-attachments.js";
 import {
   armFeedbackCapture,
   cancelFeedbackCapture,
@@ -482,4 +488,84 @@ describe("agent ask wake delivery", () => {
       { width: 80, height: 24 },
     );
   });
+
+  test("idle leftover wake keeps an @path in the question raw and consumes the echo", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const sent: string[] = [];
+        const attachments: number[] = [];
+        const ingested: string[] = [];
+        const queue = createSessionOperationQueue();
+        const leftoverSend = createLeftoverSend({
+          enqueue: queue.enqueue,
+          ingest: async (text, pending) => {
+            ingested.push(text);
+            return ingestOperatorPrompt(
+              text,
+              "/repo",
+              async () => {
+                throw new Error("wake leftover must not load image paths");
+              },
+              pending,
+            );
+          },
+          send: (text, pending) => {
+            sent.push(text);
+            attachments.push(pending.length);
+          },
+          captureGeneration: createDeliveryGeneration().capture,
+          onFailure: (error) => {
+            throw error;
+          },
+        });
+        const send = (text: string) => {
+          leftoverSend(text);
+        };
+        const bridge = attachSessionBridge(
+          shell,
+          createLiveSessionPort({
+            send,
+            deliver: routeQueuedDelivery({
+              send,
+              deliverSteer: () => {
+                throw new Error("wake must not live-inject");
+              },
+              parentCycleLive: () => bridge.parentCycleLive,
+            }),
+            interrupt: () => {},
+          }),
+        );
+        try {
+          const ask = {
+            ...wake("a1", "q1"),
+            question: "Should I edit @src/foo.ts?",
+          };
+          bridge.handle({ type: "agent-ask", asks: [ask] });
+          await queue.awaitTail();
+          expect(sent).toHaveLength(1);
+          const wakeText = sent[0];
+          if (wakeText === undefined) throw new Error("expected wake text");
+          expect(wakeText).toContain("@src/foo.ts");
+          expect(wakeText).not.toContain("(not found)");
+          expect(attachments).toEqual([0]);
+          expect(ingested).toEqual([]);
+          expect(shell.streamLog.filter((row) => row.role === "user")).toHaveLength(1);
+          bridge.handle({
+            type: "message.received",
+            data: { message: { content: wakeText } },
+          });
+          expect(shell.streamLog.filter((row) => row.role === "user")).toHaveLength(1);
+        } finally {
+          bridge.dispose();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 });

src/tui/queued-delivery.test.ts

@@ -240,6 +240,35 @@ describe("createLeftoverSend", () => {
     expect(recorded).toEqual(["follow-up"]);
   });
 
+  test("leftover send skips ingest for ask_director wake and still ingests operator prompts", async () => {
+    const sent: string[] = [];
+    const ingested: string[] = [];
+    const { enqueue, awaitTail } = createSessionOperationQueue();
+    const leftoverSend = createLeftoverSend({
+      enqueue,
+      ingest: async (text, pending) => {
+        ingested.push(text);
+        return { text: `${text} ingested`, attachments: pending };
+      },
+      send: (text) => {
+        sent.push(text);
+      },
+      captureGeneration: () => () => true,
+      onFailure: (err) => {
+        throw err;
+      },
+    });
+
+    leftoverSend("ask_director wake — see @src/foo.ts");
+    leftoverSend("please read @src/foo.ts");
+    await awaitTail();
+    expect(ingested).toEqual(["please read @src/foo.ts"]);
+    expect(sent).toEqual([
+      "ask_director wake — see @src/foo.ts",
+      "please read @src/foo.ts ingested",
+    ]);
+  });
+
   test("generation bump drops leftover send but not a sibling Enter send", async () => {
     const leftoverSent: string[] = [];
     const enterSent: string[] = [];

src/tui/queued-delivery.ts

@@ -121,9 +121,18 @@ export function createLiveSteerDeliver(
 /**
  * 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.
+ * `ask_director wake` leftover is passed through raw so worker @paths and
+ * image mentions are not rewritten as operator attachments.
  */
 export function createLeftoverSend(
   args: CreateLeftoverSendArgs,
 ): (text: string, attachments?: readonly PendingImageAttachment[]) => void {
-  return createGenerationGatedHop({ ...args, hop: args.send });
+  return createGenerationGatedHop({
+    ...args,
+    hop: args.send,
+    ingest: async (text, pending) =>
+      text.startsWith("ask_director wake")
+        ? { text, attachments: pending }
+        : args.ingest(text, pending),
+  });
 }