Unlink Corbits-created files when idle Ctrl+C clears attachments

Clipboard ingest now assigns ephemeralPath instead of deleting the
temp file immediately, so clear unlinks only Corbits-created files
and leaves operator-owned path mentions untouched.

Author: TheGreatAxios

src/tui/image-attachments.ts

@@ -90,7 +90,10 @@ export function findImagePathMentions(text: string, cwd: string): ImagePathMenti
   return mentions;
 }
 
-export async function imageAttachmentFromPath(path: string): Promise<AttachImageResult> {
+export async function imageAttachmentFromPath(
+  path: string,
+  opts?: { ephemeral?: boolean },
+): Promise<AttachImageResult> {
   const mimeType = imageMimeTypeForPath(path);
   if (mimeType === undefined) return { ok: false, reason: "unsupported image type" };
   let info;
@@ -112,6 +115,7 @@ export async function imageAttachmentFromPath(path: string): Promise<AttachImage
   // downscaling recompresses them differently.
   const contentHash = await hashImageBytes(raw);
   const capped = await capImageForIngestion(raw, mimeType);
+  const ephemeral = opts?.ephemeral === true;
   return {
     ok: true,
     attachment: {
@@ -122,7 +126,7 @@ export async function imageAttachmentFromPath(path: string): Promise<AttachImage
           : replaceExtension(basename(path), capped.contentType),
       contentType: capped.contentType,
       data: capped.data,
-      path,
+      ...(ephemeral ? { ephemeralPath: path } : { path }),
       contentHash,
     },
   };
@@ -228,14 +232,15 @@ end try
     return { ok: false, reason: "no PNG image found on the clipboard" };
   }
 
-  const attachment = await imageAttachmentFromPath(tmpPath);
-  await unlink(tmpPath).catch(() => undefined);
-  if (!attachment.ok) return attachment;
-  const { path: _path, ...clipboardAttachment } = attachment.attachment;
+  const attachment = await imageAttachmentFromPath(tmpPath, { ephemeral: true });
+  if (!attachment.ok) {
+    await unlink(tmpPath).catch(() => undefined);
+    return attachment;
+  }
   return {
     ok: true,
     attachment: {
-      ...clipboardAttachment,
+      ...attachment.attachment,
       name: `clipboard-${new Date().toISOString().replace(/[:.]/g, "-")}.png`,
     },
   };

src/tui/prompt-features.test.ts

@@ -4,6 +4,9 @@
  * suggestions.
  */
 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 type { PendingImageAttachment } from "./image-attachments.js";
 import { withTestRenderer, type Harness } from "./harness";
@@ -222,6 +225,35 @@ describe("image attachments", () => {
     });
   });
 
+  test("a duplicate clipboard paste unlinks only the rejected ephemeral file", async () => {
+    await withShell(async (shell) => {
+      const dir = mkdtempSync(join(tmpdir(), "clip-dup-"));
+      const kept = join(dir, "kept.png");
+      const rejected = join(dir, "rejected.png");
+      writeFileSync(kept, "kept-bytes");
+      writeFileSync(rejected, "rejected-bytes");
+      try {
+        let calls = 0;
+        setPromptImageSource(shell, async () => {
+          calls += 1;
+          return {
+            ok: true,
+            attachment: {
+              ...(calls === 1 ? CLIP : CLIP_SAME_CONTENT),
+              ephemeralPath: calls === 1 ? kept : rejected,
+            },
+          };
+        });
+        expect(await attachClipboardImage(shell)).toBe(true);
+        expect(await attachClipboardImage(shell)).toBe(false);
+        expect(existsSync(kept)).toBe(true);
+        expect(existsSync(rejected)).toBe(false);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
+
   test("a genuinely different image still attaches alongside the first", async () => {
     await withShell(async (shell) => {
       let calls = 0;

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

@@ -9,7 +9,7 @@ import { join } from "node:path";
 
 import { withTestRenderer } from "./harness";
 import type { PaletteCommand } from "./command-catalog";
-import type { PendingImageAttachment } from "./image-attachments.js";
+import { imageAttachmentFromPath, type PendingImageAttachment } from "./image-attachments.js";
 import {
   CTRL_C_EXIT_WINDOW_MS,
   addPendingAttachment,
@@ -386,6 +386,38 @@ describe("Ctrl+C exit", () => {
       }
     });
   });
+
+  test("ingesting a Corbits-written file assigns ephemeralPath so idle Ctrl+C unlinks only that file", async () => {
+    await withShell(async ({ shell }) => {
+      const dir = mkdtempSync(join(tmpdir(), "ctrlc-attach-ingest-"));
+      const ephemeral = join(dir, "clip.png");
+      const operator = join(dir, "shot.png");
+      writeFileSync(ephemeral, "ephemeral-bytes");
+      writeFileSync(operator, "operator-bytes");
+      try {
+        const clip = await imageAttachmentFromPath(ephemeral, { ephemeral: true });
+        const mention = await imageAttachmentFromPath(operator);
+        expect(clip.ok).toBe(true);
+        expect(mention.ok).toBe(true);
+        if (!clip.ok || !mention.ok) return;
+
+        expect(clip.attachment.ephemeralPath).toBe(ephemeral);
+        expect(clip.attachment.path).toBeUndefined();
+        expect(mention.attachment.path).toBe(operator);
+        expect(mention.attachment.ephemeralPath).toBeUndefined();
+
+        addPendingAttachment(shell, clip.attachment);
+        addPendingAttachment(shell, mention.attachment);
+        handleCtrlC(shell, 0);
+
+        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 {

src/tui/shell.ts

@@ -973,14 +973,16 @@ 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;
-    }
+  for (const attachment of pending) unlinkEphemeral(attachment);
+}
+
+function unlinkEphemeral(attachment: PendingImageAttachment): void {
+  const ephemeral = attachment.ephemeralPath;
+  if (ephemeral === undefined) return;
+  try {
+    unlinkSync(ephemeral);
+  } catch (err) {
+    if (!isENOENT(err)) throw err;
   }
 }
 
@@ -999,7 +1001,10 @@ export async function attachClipboardImage(shell: AppShell): Promise<boolean> {
   const result = await source();
   // Quitting while the clipboard read is pending tears down the shell's
   // renderables; a stale continuation must not mutate them on resume.
-  if (shell.disposed) return false;
+  if (shell.disposed) {
+    if (result.ok) unlinkEphemeral(result.attachment);
+    return false;
+  }
   if (!result.ok) {
     setStatusFlash(shell, `image attach failed: ${result.reason}`, {
       ttlMs: RUNTIME_FLASH_MS,
@@ -1008,6 +1013,7 @@ export async function attachClipboardImage(shell: AppShell): Promise<boolean> {
   }
   const duplicate = findDuplicateAttachment(shell.pendingAttachments, result.attachment);
   if (duplicate !== undefined) {
+    unlinkEphemeral(result.attachment);
     setStatusFlash(shell, `${duplicate.name} is already attached`, {
       ttlMs: RUNTIME_FLASH_MS,
     });