Clear pending images with the first idle Ctrl+C

Idle Ctrl+C used to wipe prompt text but leave pending attachments on
the notice row. Clear both, and unlink only files Corbits created
(ephemeralPath) so operator path-mention files stay on disk.

Author: TheGreatAxios

docs/TUI.md

@@ -619,8 +619,10 @@ The prompt repaints on every keystroke (`onFrame` in `shell.ts` calls
 not on a debounce) — anything added to the prompt's paint path must stay
 cheap, because it runs at typing speed.
 
-Ctrl+C interrupts a busy run (or clears a non-empty idle prompt); a second
-Ctrl+C within a 2-second window (`CTRL_C_EXIT_WINDOW_MS`) quits — this
+Ctrl+C interrupts a busy run, or clears idle prompt text and pending
+attachments. Clearing prompt text arms a 2-second quit window
+(`CTRL_C_EXIT_WINDOW_MS`); clearing attachments alone does not. A second
+Ctrl+C while the window is open quits — this
 replaced an Ink-era yes/no exit-confirm modal with the same intent (an
 explicit second confirmation) without adding a modal (`handleCtrlC`,
 `shell.ts`). See "Soft steer vs. follow-up" above for the two

src/tui/image-attachments.ts

@@ -27,6 +27,8 @@ const IMAGE_MIME_BY_EXT: Readonly<Record<string, string>> = {
 export type PendingImageAttachment = MessageAttachment & {
   id: string;
   path?: string;
+  /** Set only for files Corbits created; never the operator's `path`. */
+  ephemeralPath?: string;
   /** SHA-256 of the source image file's bytes, used to identify identical images. */
   contentHash: string;
 };

src/tui/keybindings.ts

@@ -32,7 +32,8 @@ export const SHELL_SHORTCUTS: readonly ShellShortcut[] = [
   },
   {
     keys: "Ctrl+C",
-    description: "interrupt the run, or clear the prompt when idle; press twice to exit",
+    description:
+      "interrupt the run, or clear the prompt and attachments when idle; press twice to exit",
   },
   {
     keys: "Ctrl+G",

src/tui/prompt-slash-exit.test.ts

@@ -3,11 +3,17 @@
  * through the wired key path on a headless shell.
  */
 import { describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import { withTestRenderer } from "./harness";
 import type { PaletteCommand } from "./command-catalog";
+import type { PendingImageAttachment } from "./image-attachments.js";
 import {
   CTRL_C_EXIT_WINDOW_MS,
+  addPendingAttachment,
+  clearPendingAttachments,
   createAppShell,
   handleCtrlC,
   isSlashPopupOpen,
@@ -269,4 +275,85 @@ describe("Ctrl+C exit", () => {
       expect(exits).toBe(1);
     });
   });
+
+  test("idle Ctrl+C with prompt text also drops pending attachments", async () => {
+    await withShell(async ({ shell }) => {
+      addPendingAttachment(shell, pendingImage("clip"));
+      shell.prompt.value = "look at this";
+      expect(noticeText(shell)).toContain("1 image");
+
+      handleCtrlC(shell, 0);
+
+      expect(shell.prompt.value).toBe("");
+      expect(shell.pendingAttachments).toHaveLength(0);
+      expect(noticeText(shell)).not.toContain("1 image");
+    });
+  });
+
+  test("idle Ctrl+C with only attachments clears them and does not arm exit", async () => {
+    await withShell(async ({ shell }) => {
+      let exits = 0;
+      setShellExitHandler(shell, () => {
+        exits += 1;
+      });
+      addPendingAttachment(shell, pendingImage("clip"));
+      expect(shell.prompt.value).toBe("");
+      expect(noticeText(shell)).toContain("1 image");
+
+      handleCtrlC(shell, 0);
+      expect(shell.pendingAttachments).toHaveLength(0);
+      expect(noticeText(shell)).not.toContain("1 image");
+      expect(shell.statusFlash).not.toBe("press ctrl+c again to exit");
+      expect(noticeText(shell)).not.toContain("press ctrl+c again to exit");
+      expect(exits).toBe(0);
+
+      handleCtrlC(shell, 1);
+      expect(exits).toBe(0);
+    });
+  });
+
+  test("busy Ctrl+C interrupts without dropping pending attachments", async () => {
+    await withShell(async ({ shell }) => {
+      setShellRunState(shell, "busy");
+      addPendingAttachment(shell, pendingImage("clip"));
+
+      handleCtrlC(shell, 0);
+
+      expect(shell.pendingAttachments).toHaveLength(1);
+      expect(shell.session.run).not.toBe("busy");
+    });
+  });
+
+  test("clearPendingAttachments unlinks ephemeralPath and leaves the operator path", async () => {
+    await withShell(async ({ shell }) => {
+      const dir = mkdtempSync(join(tmpdir(), "ctrlc-attach-"));
+      const ephemeral = join(dir, "ours.png");
+      const operator = join(dir, "theirs.png");
+      writeFileSync(ephemeral, "ephemeral-bytes");
+      writeFileSync(operator, "operator-bytes");
+      try {
+        addPendingAttachment(shell, pendingImage("ours", { ephemeralPath: ephemeral }));
+        addPendingAttachment(shell, pendingImage("theirs", { path: operator }));
+
+        clearPendingAttachments(shell);
+
+        expect(shell.pendingAttachments).toHaveLength(0);
+        expect(existsSync(ephemeral)).toBe(false);
+        expect(existsSync(operator)).toBe(true);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
 });
+
+function pendingImage(id: string, extra?: Partial<PendingImageAttachment>): PendingImageAttachment {
+  return {
+    id,
+    name: `${id}.png`,
+    contentType: "image/png",
+    data: new Uint8Array([137, 80, 78, 71]),
+    contentHash: `hash-${id}`,
+    ...extra,
+  };
+}

src/tui/shell.ts

@@ -5,6 +5,7 @@
  * production interactive CLI surface (Ink is no longer the live path).
  */
 
+import { unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import {
   clampBoardRows,
@@ -976,8 +977,22 @@ export function addPendingAttachment(shell: AppShell, attachment: PendingImageAt
 }
 
 export function clearPendingAttachments(shell: AppShell): void {
+  const pending = shell.pendingAttachments;
   shell.pendingAttachments = [];
   paintChrome(shell);
+  for (const attachment of pending) {
+    const ephemeral = attachment.ephemeralPath;
+    if (ephemeral === undefined) continue;
+    try {
+      unlinkSync(ephemeral);
+    } catch (err) {
+      if (!isENOENT(err)) throw err;
+    }
+  }
+}
+
+function isENOENT(err: unknown): boolean {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
 /**
@@ -5411,12 +5426,20 @@ export function handleCtrlC(shell: AppShell, now = Date.now(), options?: FlashOp
       return;
     }
   }
+
+  const idle = shell.session.run !== "busy" && badgeCount(shell.session) === 0;
+  const hasPromptText = shell.prompt.value.length > 0;
+  const hasAttachments = shell.pendingAttachments.length > 0;
+  if (idle && (hasPromptText || hasAttachments)) {
+    shell.prompt.value = "";
+    clearPendingAttachments(shell);
+    if (!hasPromptText) return;
+  }
+
   ctrlCArmedAt.set(shell, now);
 
   if (shell.session.run === "busy" || badgeCount(shell.session) > 0) {
     interruptShell(shell);
-  } else if (shell.prompt.value.length > 0) {
-    shell.prompt.value = "";
   }
   // The notice is exactly as true as the arming window is open, so it expires
   // with it rather than waiting for some later flash to overwrite it.