feat(vision): resolve persisted image URLs against the API base

Images are now stored on disk under tmp (not SQLite) and served via
GET /images/:conversationId/:imageId. Persisted ImageChunk.url is a compact
relative HTTP path (/images/<conv>/<uuid>.png) instead of a base64 data URL.
No wire/transport-contract type change (behavior only) — re-mirrored the
delta notes.

- New pure resolveImageUrl(url, apiBase) helper (core/chunks/image-url.ts,
  +8 tests): data/absolute URLs pass through; relative paths are prepended
  with the API base (no double slash; empty base -> root-relative). Exported
  from core/chunks + re-exported from features/chat.
- ChatView: new apiBaseUrl prop; <img src> uses resolveImageUrl. The
  optimistic echo's data URL passes through; persisted relative paths
  resolve against the base. +3 tests.
- AppStore exposes httpBase (getter); App.svelte passes apiBaseUrl into
  ChatView and the heartbeat RunModal (also renders image chunks).

Verification: svelte-check 0/0; vitest 959/959 (run twice, +11); biome
clean; vite build OK. See backend-handoff.md §2j-update-2.

Not merged or pushed.

3 files changed, 82 insertions, 0 deletions

diff --git a/src/core/chunks/image-url.test.ts b/src/core/chunks/image-url.test.ts
new file mode 100644
index 0000000..8a79c09
--- /dev/null
+++ b/src/core/chunks/image-url.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { resolveImageUrl } from "./image-url";
+
+const BASE = "http://localhost:24203";
+
+describe("resolveImageUrl", () => {
+  it("returns a data URL as-is (the optimistic echo / a pasted image)", () => {
+    const dataUrl = "data:image/png;base64,iVBORw0KGgo=";
+    expect(resolveImageUrl(dataUrl, BASE)).toBe(dataUrl);
+  });
+
+  it("returns an absolute http URL as-is", () => {
+    const abs = "https://example.com/img.png";
+    expect(resolveImageUrl(abs, BASE)).toBe(abs);
+  });
+
+  it("prepends the api base to a relative /images/ path", () => {
+    expect(resolveImageUrl("/images/conv-123/abc-456.png", BASE)).toBe(
+      "http://localhost:24203/images/conv-123/abc-456.png",
+    );
+  });
+
+  it("does not double the slash when the base has a trailing slash", () => {
+    expect(resolveImageUrl("/images/c/x.png", "http://localhost:24203/")).toBe(
+      "http://localhost:24203/images/c/x.png",
+    );
+  });
+
+  it("adds a leading slash to a path-relative url without one", () => {
+    expect(resolveImageUrl("images/c/x.png", BASE)).toBe("http://localhost:24203/images/c/x.png");
+  });
+
+  it("returns the relative path as-is when apiBase is empty (root-relative)", () => {
+    // A browser resolves a root-relative `/images/…` against the document origin.
+    expect(resolveImageUrl("/images/c/x.png", "")).toBe("/images/c/x.png");
+  });
+
+  it("handles a relative path with an empty apiBase (path-relative without slash)", () => {
+    expect(resolveImageUrl("images/c/x.png", "")).toBe("/images/c/x.png");
+  });
+
+  it("returns a data URL as-is even with an empty apiBase", () => {
+    const dataUrl = "data:image/jpeg;base64,AAAA";
+    expect(resolveImageUrl(dataUrl, "")).toBe(dataUrl);
+  });
+});
diff --git a/src/core/chunks/image-url.ts b/src/core/chunks/image-url.ts
new file mode 100644
index 0000000..e5ec756
--- /dev/null
+++ b/src/core/chunks/image-url.ts
@@ -0,0 +1,35 @@
+/**
+ * Resolve an `ImageChunk.url` into a renderable `<img src>` value.
+ *
+ * Persisted image chunks now carry a COMPACT HTTP path
+ * (`/images/<conversationId>/<uuid>.png`) served by the backend — NOT a base64
+ * data URL (images are stored on disk under tmp, not in the conversation store,
+ * to keep SQLite payloads small). The optimistic echo (what the FE just sent in
+ * `ChatRequest.images`) still carries a data URL, and a chunk could also carry
+ * an absolute `http(s)://` URL, so the resolution is format-aware:
+ *
+ * - `data:` URL  → returned as-is (the optimistic echo / a pasted data URL).
+ * - `http(s)://` → returned as-is (an absolute URL already).
+ * - anything else (a relative path like `/images/…`) → `apiBase` is prepended
+ *   (with no double slash). An empty `apiBase` leaves a root-relative path,
+ *   which a browser resolves against the document origin.
+ *
+ * Pure: input → output, zero DOM, zero Svelte.
+ *
+ * @param url      The chunk's `url` (data URL, absolute, or relative path).
+ * @param apiBase  The HTTP API base URL (e.g. `http://localhost:24203`).
+ */
+export function resolveImageUrl(url: string, apiBase: string): string {
+  if (url.startsWith("data:") || url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  // A relative path (e.g. `/images/…`) — normalize to a leading slash and
+  // prepend the api base. With an empty base this yields a root-relative path
+  // (a browser resolves `/images/…` against the document origin).
+  const path = url.startsWith("/") ? url : `/${url}`;
+  if (apiBase.length === 0) return path;
+  // Join without a double slash: strip a trailing slash from the base, then
+  // append the (leading-slash) path verbatim.
+  const base = apiBase.endsWith("/") ? apiBase.slice(0, -1) : apiBase;
+  return `${base}${path}`;
+}
diff --git a/src/core/chunks/index.ts b/src/core/chunks/index.ts
index eea2303..bdd6ce4 100644
--- a/src/core/chunks/index.ts
+++ b/src/core/chunks/index.ts
@@ -1,5 +1,6 @@
 export type { RenderGroup, ToolBatchEntry } from "./groups";
 export { groupRenderedChunks } from "./groups";
+export { resolveImageUrl } from "./image-url";
 export {
   appendUserMessage,
   applyHistory,