Ignore prose apostrophes and quotes when finding image paths

Contractions were pairing with later path quotes, and prose-quoted
sentences were resolving as bogus relative paths. Only treat path-
shaped wrappers as wrappers, and still find absolute paths inside
ordinary quotes.

Author: TheGreatAxios

src/tui/image-attachments.test.ts

@@ -175,6 +175,22 @@ describe("findImagePathMentions", () => {
       { raw: "/repo/second.JPG", path: "/repo/second.JPG" },
     ]);
   });
+
+  test("does not let contractions steal single-quoted path wrappers", () => {
+    const observed = "/tmp/Screenshot 2026-09-10 at 11.42.07\u202fAM.png";
+    expect(findImagePathMentions(`what's in '${observed}'?`, "/repo")).toEqual([
+      { raw: `'${observed}'`, path: observed },
+    ]);
+    expect(
+      findImagePathMentions(`don't use '/tmp/shot.png' please`, "/repo"),
+    ).toEqual([{ raw: "'/tmp/shot.png'", path: "/tmp/shot.png" }]);
+  });
+
+  test("does not let prose quotes invent a relative path over an absolute mention", () => {
+    expect(
+      findImagePathMentions(`He said "look at /tmp/shot.png" today`, "/repo"),
+    ).toEqual([{ raw: "/tmp/shot.png", path: "/tmp/shot.png" }]);
+  });
 });
 
 describe("image attachment helpers", () => {

src/tui/image-attachments.ts

@@ -104,11 +104,23 @@ function scanImagePathLine(
     const ch = text[i];
     if (ch === undefined) break;
     if (WRAPPERS.has(ch)) {
+      // Contractions/possessives (`what's`, `don't`) are not quote openers.
+      if (ch === "'" && i > start && isWordChar(text[i - 1])) {
+        i += 1;
+        continue;
+      }
       const close = text.indexOf(ch, i + 1);
       if (close !== -1 && close < end) {
-        const raw = text.slice(i, close + 1);
         const inner = text.slice(i + 1, close);
-        push(raw, normalizeImagePathCandidate(inner, cwd, true));
+        if (looksLikeQuotedImagePath(inner)) {
+          const raw = text.slice(i, close + 1);
+          push(raw, normalizeImagePathCandidate(inner, cwd, true));
+          i = close + 1;
+          continue;
+        }
+        // Balanced quotes around prose are not path wrappers. Search inside
+        // so an absolute path can still be found, then resume after the closer.
+        scanImagePathLine(text, i + 1, close, cwd, push);
         i = close + 1;
         continue;
       }
@@ -130,6 +142,40 @@ function scanImagePathLine(
   }
 }
 
+function isWordChar(ch: string | undefined): boolean {
+  if (ch === undefined || ch.length !== 1) return false;
+  return (
+    (ch >= "0" && ch <= "9") ||
+    (ch >= "A" && ch <= "Z") ||
+    (ch >= "a" && ch <= "z")
+  );
+}
+
+function looksLikeQuotedImagePath(inner: string): boolean {
+  if (inner.startsWith("file://")) return true;
+  if (inner === "~" || inner.startsWith("~/") || inner.startsWith("~\\"))
+    return true;
+  if (inner.startsWith("/") || inner.startsWith("\\")) return true;
+  if (
+    inner.startsWith("./") ||
+    inner.startsWith("../") ||
+    inner.startsWith(".\\") ||
+    inner.startsWith("..\\")
+  ) {
+    return true;
+  }
+  const drive = inner[0];
+  const sep = inner[2];
+  return (
+    inner.length >= 3 &&
+    drive !== undefined &&
+    sep !== undefined &&
+    ((drive >= "A" && drive <= "Z") || (drive >= "a" && drive <= "z")) &&
+    inner[1] === ":" &&
+    (sep === "/" || sep === "\\")
+  );
+}
+
 function canStartUnquotedPath(text: string, i: number, end: number): boolean {
   if (i >= end) return false;
   if (text.startsWith("file://", i)) return true;

src/tui/prompt-attachments.test.ts

@@ -43,6 +43,20 @@ describe("ingestPathMentions", () => {
     expect(result.attachments).toHaveLength(1);
   });
 
+  test("replaces the full wrapped token including quotes", async () => {
+    const load = async (path: string): Promise<AttachImageResult> => ({
+      ok: true,
+      attachment: { ...attachment("shot.png"), path },
+    });
+    const result = await ingestPathMentions(
+      "look at '/tmp/shot.png' please",
+      "/repo",
+      load,
+    );
+    expect(result.text).toBe("look at [Attached image: shot.png] please");
+    expect(result.attachments).toHaveLength(1);
+  });
+
   test("keeps the raw path when loading fails", async () => {
     const load = async (): Promise<AttachImageResult> => ({
       ok: false,