ompchamber 1.0.0 → 1.2.0

package/src/server/lib/omp/session/files.test.ts

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterAll, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import { join } from 'path';
+
+import { scanSessionInfo } from '@/server/lib/omp/session/files';
+
+/**
+ * `modified` is the session's last real activity, and two signals that look
+ * like it are not:
+ *
+ *   - the file mtime, which a title-slot rename bumps without a turn having
+ *     happened (measured: 5 days of skew on a real session);
+ *   - a `session_exit` lifecycle marker, written per process dispose, which
+ *     floats a session quiet for days to the top of the sidebar (measured: 255
+ *     of 319 sessions ranked by one).
+ *
+ * The cost of regressing either is a silently wrong sidebar order, which no
+ * other test observes.
+ */
+
+const tempDirs: string[] = [];
+
+/** Write a session file whose lines are exactly the given records, in order. */
+async function writeSession(lines: unknown[]): Promise<string> {
+  const dir = await fs.promises.mkdtemp('omp-session-files-');
+  tempDirs.push(dir);
+  const file = join(dir, 'session.jsonl');
+  await Bun.write(file, `${lines.map((line) => JSON.stringify(line)).join('\n')}\n`);
+  return file;
+}
+
+afterAll(() => {
+  for (const dir of tempDirs) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+const at = (day: number, second = 0) =>
+  `2026-09-${String(day).padStart(2, '0')}T03:00:${String(second).padStart(2, '0')}.000Z`;
+
+const slot = (title: string) => ({ type: 'title', v: 1, title, updatedAt: at(1), pad: '' });
+const header = { type: 'session', version: 3, id: 'session-id', cwd: '/tmp/proj', timestamp: at(1) };
+const message = (day: number, text = 'hello') => ({
+  type: 'message',
+  id: `m-${day}`,
+  parentId: null,
+  timestamp: at(day),
+  message: { role: 'user', content: [{ type: 'text', text }] },
+});
+/** The marker omp appends every time it disposes the session process. */
+const sessionExit = (day: number) => ({
+  type: 'custom',
+  customType: 'session_exit',
+  data: { reason: 'dispose', kind: 'normal', recordedAt: at(day) },
+  id: `x-${day}`,
+  parentId: null,
+  timestamp: at(day),
+});
+const toolStart = (day: number) => ({
+  type: 'custom',
+  customType: 'tool_execution_start',
+  data: { toolCallId: 'call', toolName: 'bash' },
+  id: `t-${day}`,
+  parentId: null,
+  timestamp: at(day),
+});
+
+describe('scanSessionInfo last activity', () => {
+  test('dates the session by its newest entry, not the file mtime', async () => {
+    // The mtime is "now" (just written); only the entry timestamp is the answer.
+    const file = await writeSession([slot('t'), header, message(10)]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(10));
+    expect(info?.modified.getTime()).not.toBe(info?.fileMtime.getTime());
+  });
+
+  test('ignores a trailing session_exit marker', async () => {
+    const file = await writeSession([slot('t'), header, message(10), sessionExit(20)]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(10));
+  });
+
+  test('ignores a stack of session_exit markers, however many accumulated', async () => {
+    const file = await writeSession([
+      slot('t'),
+      header,
+      message(11),
+      sessionExit(20),
+      sessionExit(21),
+      sessionExit(22),
+    ]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(11));
+  });
+
+  test('still counts an in-flight tool call as activity', async () => {
+    // A run killed mid-tool-call has no later message, but it IS the newest
+    // session. Excluding every custom entry would misrank it.
+    const file = await writeSession([slot('t'), header, message(12), toolStart(13)]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(13));
+  });
+
+  test('counts an unrecognised custom entry rather than assuming it is bookkeeping', async () => {
+    const file = await writeSession([
+      slot('t'),
+      header,
+      message(12),
+      { type: 'custom', customType: 'brand_new_marker', id: 'z', timestamp: at(19) },
+    ]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(19));
+  });
+
+  test('uses a later message when the exit marker came first', async () => {
+    const file = await writeSession([slot('t'), header, sessionExit(5), message(6)]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(6));
+  });
+
+  test('falls back to the creation time for a session with no activity at all', async () => {
+    const file = await writeSession([slot('t'), header, sessionExit(30)]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(1));
+  });
+
+  test('reads the timestamp past an entry larger than the tail window', async () => {
+    // A tool result carrying a big file read is the newest entry and is
+    // usually the largest one; the window must widen to reach its line.
+    const file = await writeSession([
+      slot('t'),
+      header,
+      message(2, 'head'),
+      message(4, 'x'.repeat(200_000)),
+    ]);
+    const info = await scanSessionInfo(file);
+    expect(info?.modified.toISOString()).toBe(at(4));
+  });
+
+  test('returns undefined for a file with no session header', async () => {
+    const file = await writeSession([slot('t'), message(3)]);
+    expect(await scanSessionInfo(file)).toBeUndefined();
+  });
+});

package/src/server/lib/omp/session/files.ts

@@ -15,12 +15,15 @@
  * File layout: optional fixed-width 256-byte title-slot line, then the
  * {"type":"session"} header line, then message entries. Legacy pi v1/v2
  * shapes parse leniently (raw-text scans); nothing here mutates on-disk data.
- * The lenient JSONL + header parsing lives in ./session-jsonl.ts.
+ * The lenient JSONL + header parsing lives in
+ * `@/shared/lib/omp/session/jsonl`; the bounded window readers (head prefix
+ * plus escalating tail) live in ./file-scan.ts.
  */
 
 import fs from 'fs';
 import * as path from 'path';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
+import { readLastEntryTimestamp, readTextPrefix, SESSION_LIST_PREFIX_BYTES } from '@/server/lib/omp/session/file-scan';
 import { countMessageMarkers, extractFirstDisplayMessageFromPrefix, extractTextFromContent, parseJsonlLenient, parseSessionListHeader } from '@/shared/lib/omp/session/jsonl';
 import { isRecord } from '@/shared/lib/util/guards';
 
@@ -37,37 +40,30 @@ export interface OmpSessionInfo {
   title?: string;
   parentSessionPath?: string;
   created: Date;
+  /** Last activity: the newest JSONL entry's own `timestamp`, falling back to
+   *  the file mtime for a file the tail window cannot date. */
   modified: Date;
+  /** Filesystem mtime. Scan-cache version only — never user-visible, and never
+   *  an ordering key (see readLastEntryTimestamp for why). */
+  fileMtime: Date;
   messageCount: number;
   size: number;
   firstMessage: string;
 }
 
-// ============================================================================
-// Per-file scan (4 KiB prefix window)
-// ============================================================================
-
-const SESSION_LIST_PREFIX_BYTES = 4096;
-
-async function readTextPrefix(filePath: string, prefixBytes: number): Promise<[string, number, Date]> {
-  const file = Bun.file(filePath);
-  const stat = await file.stat();
-  const prefixLength = Math.min(prefixBytes, stat.size);
-  const prefix = prefixLength > 0 ? await file.slice(0, prefixLength).text() : '';
-  return [prefix, stat.size, new Date(stat.mtimeMs)];
-}
-
 /**
- * Scan a single session file into an OmpSessionInfo using only a 4 KiB prefix
- * window. Faithful port of omp's scanSessionFile — messageCount is a
- * prefix-derived lower bound. Missing/unreadable/header-less files yield
- * undefined instead of throwing.
+ * Scan a single session file into an OmpSessionInfo from a 4 KiB prefix window
+ * (header, title, first message) plus a bounded tail window (last activity).
+ * Faithful port of omp's scanSessionFile except for `modified`, which is the
+ * last entry's timestamp rather than the file mtime. Missing/unreadable/
+ * header-less files yield undefined instead of throwing.
  */
 export async function scanSessionInfo(filePath: string): Promise<OmpSessionInfo | undefined> {
   try {
-    const [content, size, mtime] = await readTextPrefix(filePath, SESSION_LIST_PREFIX_BYTES);
-    const entries = parseJsonlLenient<Record<string, unknown>>(content);
-    const header = parseSessionListHeader(content, entries);
+    const { text: prefix, size, mtime } = await readTextPrefix(filePath, SESSION_LIST_PREFIX_BYTES);
+    const lastEntryAt = await readLastEntryTimestamp(filePath, size, prefix);
+    const entries = parseJsonlLenient<Record<string, unknown>>(prefix);
+    const header = parseSessionListHeader(prefix, entries);
     if (!header) return undefined;
 
     let parsedMessageCount = 0;
@@ -90,7 +86,7 @@ export async function scanSessionInfo(filePath: string): Promise<OmpSessionInfo
       }
     }
 
-    firstMessage ||= extractFirstDisplayMessageFromPrefix(content) ?? '';
+    firstMessage ||= extractFirstDisplayMessageFromPrefix(prefix) ?? '';
     return {
       path: filePath,
       id: header.id,
@@ -98,8 +94,9 @@ export async function scanSessionInfo(filePath: string): Promise<OmpSessionInfo
       title: header.title ?? shortSummary,
       parentSessionPath: header.parentSession,
       created: new Date(header.timestamp ?? ''),
-      modified: mtime,
-      messageCount: Math.max(parsedMessageCount, countMessageMarkers(content)),
+      modified: lastEntryAt ?? mtime,
+      fileMtime: mtime,
+      messageCount: Math.max(parsedMessageCount, countMessageMarkers(prefix)),
       size,
       firstMessage: firstMessage || '(no messages)',
     };
@@ -120,9 +117,24 @@ interface SessionFileListCacheEntry {
   files: string[];
 }
 
+/**
+ * Shape version of a cached OmpSessionInfo. The caches hang off `globalThis`
+ * so they survive a module reload, which means an entry written by an older
+ * build of this file is still readable after an edit — and a field added or
+ * renamed since then reads as undefined at the point of use rather than
+ * missing a scan. Bump this whenever OmpSessionInfo changes; the cache is
+ * discarded instead of misread.
+ */
+const SESSION_SCAN_CACHE_VERSION = 2;
+
+interface SessionScanCache {
+  version: number;
+  entries: Map<string, OmpSessionInfo>;
+}
+
 declare global {
   var __ompChamberSessionFileListCache: Map<string, SessionFileListCacheEntry> | undefined;
-  var __ompChamberSessionScanCache: Map<string, OmpSessionInfo> | undefined;
+  var __ompChamberSessionScanCache: SessionScanCache | undefined;
 }
 
 const MAX_SESSION_SCAN_CACHE_ENTRIES = 2048;
@@ -197,16 +209,18 @@ export async function listSessionFiles(sessionsRoot: string = getSessionsDir()):
 }
 
 function getSessionScanCache(): Map<string, OmpSessionInfo> {
-  if (!globalThis.__ompChamberSessionScanCache) {
-    globalThis.__ompChamberSessionScanCache = new Map();
-  }
-  return globalThis.__ompChamberSessionScanCache;
+  const slot = globalThis.__ompChamberSessionScanCache;
+  if (slot && slot.version === SESSION_SCAN_CACHE_VERSION) return slot.entries;
+  const fresh: SessionScanCache = { version: SESSION_SCAN_CACHE_VERSION, entries: new Map() };
+  globalThis.__ompChamberSessionScanCache = fresh;
+  return fresh.entries;
 }
 
 /** scanSessionInfo memoized on (path, size, mtimeMs) — an unchanged file costs
  *  a single stat. Cache hits share one object; callers must treat results as
- *  immutable. */
-async function scanSessionInfoCached(filePath: string): Promise<OmpSessionInfo | undefined> {
+ *  immutable. Exported so the id locator shares this cache with the sidebar
+ *  list instead of re-reading every prefix and tail on each resolve. */
+export async function scanSessionInfoCached(filePath: string): Promise<OmpSessionInfo | undefined> {
   let stat: { size: number; mtimeMs: number };
   try {
     stat = await Bun.file(filePath).stat();
@@ -217,8 +231,11 @@ async function scanSessionInfoCached(filePath: string): Promise<OmpSessionInfo |
   const cached = cache.get(filePath);
   if (cached) {
     const info = cached;
-    // Re-scan when size or mtime changed.
-    if (info.size === stat.size && info.modified.getTime() === stat.mtimeMs) {
+    // Re-scan when size or mtime changed. The version is the FILE mtime, not
+    // `modified` — the latter is now an entry timestamp, and a title-slot
+    // rewrite that bumps the file without appending an entry must still be
+    // picked up (it can change the title the row displays).
+    if (info.size === stat.size && info.fileMtime.getTime() === stat.mtimeMs) {
       cache.delete(filePath);
       cache.set(filePath, info);
       return info;
@@ -259,7 +276,7 @@ export async function listAllSessionInfos(sessionsRoot: string = getSessionsDir(
  *  that mtime keys cannot detect). */
 export function clearSessionFileCaches(): void {
   globalThis.__ompChamberSessionFileListCache?.clear();
-  globalThis.__ompChamberSessionScanCache?.clear();
+  globalThis.__ompChamberSessionScanCache?.entries.clear();
 }
 
 /** Exported for tests/spot-checks: read a raw JSONL session header directly. */

package/src/server/lib/omp/session/locator.ts

@@ -11,7 +11,7 @@
 
 import { json } from '@/server/lib/remix-compat';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
-import { listSessionFiles, readRawHeaderLine, scanSessionInfo } from '@/server/lib/omp/session/files';
+import { listSessionFiles, readRawHeaderLine, scanSessionInfoCached } from '@/server/lib/omp/session/files';
 
 /** Find the absolute path of the .jsonl whose header id matches. */
 export async function findSessionFileById(
@@ -20,7 +20,7 @@ export async function findSessionFileById(
 ): Promise<string | undefined> {
   const files = await listSessionFiles(sessionsRoot);
   for (const file of files) {
-    const info = await scanSessionInfo(file);
+    const info = await scanSessionInfoCached(file);
     if (info?.id === sessionId) return file;
   }
   return undefined;

package/src/server/lib/omp/session/merge-stored.test.ts

@@ -0,0 +1,118 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Merging the chamber's stored turns onto JSONL-loaded ones.
+ *
+ * The two sources see different halves of an attachment: the JSONL recovers a
+ * text file's name from the delivered prompt but has no preview or content,
+ * while the chamber row has those display fields but nothing about what omp
+ * received. Taking one list over the other dropped whichever entries only
+ * existed on the losing side — a dropped `.md` disappeared from a reloaded
+ * session as soon as the same turn carried an image.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { mergeOmpAttachments, type StoredMessage } from '@/server/lib/omp/session/merge-stored';
+
+function userTurn(overrides: Partial<StoredMessage> = {}): StoredMessage {
+  return { id: 'u1', role: 'user', content: 'hello', ...overrides };
+}
+
+function storedJson(messages: StoredMessage[]): string {
+  return JSON.stringify(messages);
+}
+
+describe('mergeOmpAttachments attachments', () => {
+  test('keeps both an image from the JSONL and a text file from the store', () => {
+    const jsonl = [userTurn({
+      attachments: [{ name: 'shot.png', type: 'image/png', preview: 'data:image/png;base64,AAAA' }],
+    })];
+    const stored = [userTurn({
+      attachments: [
+        { name: 'notes.md', type: 'text/plain', content: '# hi' },
+        { name: 'shot.png', type: 'image/png', preview: 'blob:http://x/1' },
+      ],
+    })];
+
+    const [merged] = mergeOmpAttachments(jsonl, storedJson(stored));
+    expect(merged.attachments?.map((a) => a.name)).toEqual(['shot.png', 'notes.md']);
+  });
+
+  test('a text file recovered from the JSONL keeps its name when the store has none', () => {
+    const jsonl = [userTurn({
+      attachments: [{ name: 'script.py', type: 'text/plain', content: 'x=1' }],
+    })];
+    const [merged] = mergeOmpAttachments(jsonl, storedJson([userTurn()]));
+    expect(merged.attachments).toEqual([{ name: 'script.py', type: 'text/plain', content: 'x=1' }]);
+  });
+
+  test('a matching name fills in the fields the JSONL could not carry', () => {
+    const jsonl = [userTurn({
+      attachments: [{ name: 'shot.png', type: 'image/png', preview: 'data:image/png;base64,AAAA' }],
+    })];
+    const stored = [userTurn({
+      attachments: [{ name: 'shot.png', type: 'image/png', size: 42, content: 'stored' }],
+    })];
+
+    const [merged] = mergeOmpAttachments(jsonl, storedJson(stored));
+    expect(merged.attachments).toEqual([
+      { name: 'shot.png', type: 'image/png', size: 42, content: 'stored', preview: 'data:image/png;base64,AAAA' },
+    ]);
+  });
+
+  test('an attachment only the store knows about is still shown', () => {
+    const jsonl = [userTurn({
+      attachments: [{ name: 'shot.png', type: 'image/png', preview: 'data:image/png;base64,AAAA' }],
+    })];
+    const stored = [userTurn({
+      attachments: [
+        { name: 'shot.png', type: 'image/png' },
+        { name: 'dropped.txt', type: 'text/plain', content: 'kept' },
+      ],
+    })];
+
+    const [merged] = mergeOmpAttachments(jsonl, storedJson(stored));
+    expect(merged.attachments?.map((a) => a.name)).toEqual(['shot.png', 'dropped.txt']);
+  });
+
+  test('a turn with no attachments on either side stays attachment-free', () => {
+    const [merged] = mergeOmpAttachments([userTurn()], storedJson([userTurn()]));
+    expect(merged.attachments).toBeUndefined();
+  });
+
+  test('a stored turn that never reached the JSONL is still merged in', () => {
+    const [merged] = mergeOmpAttachments([userTurn()], storedJson([userTurn({
+      attachments: [{ name: 'notes.md', type: 'text/plain', content: '# hi' }],
+    })]));
+    expect(merged.attachments).toEqual([{ name: 'notes.md', type: 'text/plain', content: '# hi' }]);
+  });
+});
+
+describe('mergeOmpAttachments text restoration', () => {
+  test('a raw composer turn keeps the text the user typed', () => {
+    // The JSONL records only a synthesized `/skill:<name>`; the DB copy has the
+    // invocation with its arguments, which is what the user actually typed.
+    const jsonl = [userTurn({ content: '/skill:capacity' })];
+    const stored = [userTurn({ content: '/skill:capacity summarize this repo' })];
+    const [merged] = mergeOmpAttachments(jsonl, storedJson(stored));
+    expect(merged.content).toBe('/skill:capacity summarize this repo');
+  });
+
+  test('an unrelated stored turn does not overwrite the JSONL text', () => {
+    // Turns that cannot be recognized as the same request are left alone; the
+    // JSONL keeps what the model was actually sent.
+    const jsonl = [userTurn({ content: 'rewritten prompt' })];
+    const stored = [userTurn({ content: 'a completely different request' })];
+    const [merged] = mergeOmpAttachments(jsonl, storedJson(stored));
+    expect(merged.content).toBe('rewritten prompt');
+  });
+
+  test('malformed stored JSON leaves the JSONL messages untouched', () => {
+    const jsonl = [userTurn()];
+    expect(mergeOmpAttachments(jsonl, 'not json')).toBe(jsonl);
+    expect(mergeOmpAttachments(jsonl, undefined)).toBe(jsonl);
+  });
+});

package/src/server/lib/omp/session/merge-stored.ts

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Merge the chamber's own copy of a conversation onto the messages loaded from
+ * an omp JSONL file.
+ *
+ * The JSONL is authoritative for what the model received, but it is not a
+ * complete record of the chamber's UI: omp rewrites raw composer input
+ * (`@agent` → a task-tool delegation prompt, `/skill:a b` → `/skill:a`) and
+ * writes no user entry at all for `/command` turns. The chamber DB keeps the
+ * turn as the user typed it, which is what this restores.
+ *
+ * Attachments are UNIONED rather than picked from one side. The two sources see
+ * different halves of the same attachment:
+ *
+ * - The JSONL recovers a text file's NAME from the delivered prompt (the
+ *   composer inlines the file as `Attached file: <name>` plus a fenced block)
+ *   and carries an image's bytes, but has no preview and no stored content.
+ * - The chamber row has the display fields — a text file's name and content, an
+ *   image's name and preview — but nothing about what omp actually received.
+ *
+ * Choosing one list over the other is what made a dropped `.md`/`.py`/`.json`
+ * vanish from a reloaded session: the JSONL had an image, so its list won, and
+ * the text file only ever existed in the chamber row.
+ */
+
+export interface StoredAttachment {
+  name?: string;
+  preview?: string;
+  type?: string;
+  size?: number;
+  content?: string;
+}
+
+export interface StoredMessage {
+  id?: string;
+  role: string;
+  content: string;
+  date?: string;
+  timestamp?: string;
+  attachments?: StoredAttachment[];
+}
+
+function isRawComposerInput(content: string): boolean {
+  return /^\s*\//.test(content) || /(^|\s)@[A-Za-z0-9_-]+/.test(content);
+}
+
+/** Whether a JSONL-derived user turn (a) and a stored one (b) are the same
+ *  request despite omp rewriting the delivered prompt. */
+function userTurnsRelate(a: string, b: string): boolean {
+  if (a === b || a.startsWith(b) || b.startsWith(a)) return true;
+  // `@agent` is delivered to omp as a task-tool delegation prompt.
+  if (a.startsWith('Use the task tool to delegate this request') && /(^|\s)@[A-Za-z0-9_-]+/.test(b)) {
+    return true;
+  }
+  // `/skill:<name> <args>`: the JSONL only records a synthesized `/skill:<name>`.
+  const token = a.split(' ')[0];
+  return a.startsWith('/skill:') && Boolean(token) && b.startsWith(token);
+}
+
+/**
+ * Union two attachment lists by name.
+ *
+ * The JSONL entry comes first, so the order the model received wins; a stored
+ * entry with the same name fills in the fields the JSONL could not carry.
+ */
+function mergeAttachmentLists(
+  fromJsonl: StoredAttachment[] | undefined,
+  fromStore: StoredAttachment[] | undefined,
+): StoredAttachment[] {
+  const jsonl = Array.isArray(fromJsonl) ? fromJsonl : [];
+  const stored = Array.isArray(fromStore) ? fromStore : [];
+  if (jsonl.length === 0) return stored;
+  if (stored.length === 0) return jsonl;
+  const remaining = [...stored];
+  const merged = jsonl.map((attachment) => {
+    const index = remaining.findIndex((candidate) => candidate.name === attachment.name);
+    if (index === -1) return attachment;
+    const [match] = remaining.splice(index, 1);
+    return {
+      ...match,
+      ...attachment,
+      content: attachment.content ?? match.content,
+      preview: attachment.preview || match.preview,
+    };
+  });
+  // Anything the JSONL could not see (an attachment omp dropped before the
+  // prompt was persisted) is still shown rather than silently discarded.
+  return [...merged, ...remaining];
+}
+
+/** Merge user turns and attachments from the chamber DB copy onto the
+ *  JSONL-loaded messages. */
+export function mergeOmpAttachments(
+  messages: StoredMessage[],
+  storedMessagesJson: string | undefined,
+): StoredMessage[] {
+  if (!storedMessagesJson) return messages;
+  let stored: StoredMessage[] = [];
+  try {
+    stored = JSON.parse(storedMessagesJson);
+  } catch {
+    return messages;
+  }
+  if (!Array.isArray(stored)) return messages;
+  const storedUsers = stored.filter((m) => m?.role === 'user' && typeof m.content === 'string');
+
+  const jsonlIndex = new Map<string, number>();
+  messages.forEach((m, index) => {
+    if (m.id) jsonlIndex.set(m.id, index);
+  });
+
+  const used = new Set<number>();
+  const merged = messages.map((m) => {
+    if (m.role !== 'user') return m;
+    const storedIndex = storedUsers.findIndex((s, i) => !used.has(i) && userTurnsRelate(m.content, s.content));
+    if (storedIndex === -1) return m;
+    used.add(storedIndex);
+    const storedMsg = storedUsers[storedIndex];
+    const content = storedMsg.content !== m.content && isRawComposerInput(storedMsg.content)
+      ? storedMsg.content
+      : m.content;
+    const attachments = mergeAttachmentLists(m.attachments, storedMsg.attachments);
+    const next = { ...m, content };
+    return attachments.length ? { ...next, attachments } : next;
+  });
+
+  // Unmatched raw turns are anchored before the next stored message the JSONL
+  // still carries; splice highest-anchor-first so earlier indices stay valid.
+  const insertions = new Map<number, StoredMessage[]>();
+  storedUsers.forEach((storedMsg, userIndex) => {
+    if (used.has(userIndex) || !isRawComposerInput(storedMsg.content)) return;
+    if (storedMsg.id && jsonlIndex.has(storedMsg.id)) return;
+    let anchor = merged.length;
+    for (let i = stored.indexOf(storedMsg) + 1; i < stored.length; i += 1) {
+      const id = stored[i]?.id;
+      const found = typeof id === 'string' ? jsonlIndex.get(id) : undefined;
+      if (found !== undefined) {
+        anchor = found;
+        break;
+      }
+    }
+    const group = insertions.get(anchor);
+    if (group) group.push(storedMsg);
+    else insertions.set(anchor, [storedMsg]);
+  });
+  for (const anchor of [...insertions.keys()].sort((a, b) => b - a)) {
+    const group = insertions.get(anchor);
+    if (group) merged.splice(anchor, 0, ...group);
+  }
+
+  const byContent = new Map<string, StoredAttachment[]>();
+  for (const m of stored) {
+    if (m?.role === 'user' && Array.isArray(m.attachments) && m.attachments.length > 0) {
+      byContent.set(m.content, m.attachments);
+    }
+  }
+  return merged.map((m) => {
+    if (m.role !== 'user' || m.attachments?.length) return m;
+    // The JSONL content may carry inlined text-file blocks appended to the
+    // original prompt, so match by prefix instead of exact equality.
+    const atts = byContent.get(m.content)
+      ?? [...byContent.entries()].find(([storedContent]) =>
+          m.content.startsWith(storedContent) || storedContent.startsWith(m.content)
+        )?.[1];
+    return atts ? { ...m, attachments: atts } : m;
+  });
+}

package/src/server/lib/omp/session/messages.ts

@@ -25,6 +25,7 @@ import { normalizeThinkingLevel } from '@/shared/lib/models/thinking-levels';
 import type { ChatMessageData } from '@/shared/types/chat';
 import { collectToolOutputs, noticeFromCustomMessage, toChatMessage, type SequenceState } from '@/shared/lib/omp/session/messages-map';
 import type { OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
+import { readBlobRef } from '@/server/lib/omp/session/blobs.server';
 
 const MAX_SESSION_LOAD_BYTES = 512 * 1024 * 1024;
 
@@ -121,9 +122,42 @@ export async function loadSessionMessages(filePath: string): Promise<ChatMessage
     }
     state.messages.push(mapped);
   }
+  await resolveImageBlobs(state.messages);
   return state.messages;
 }
 
+/**
+ * Replace `blob:sha256:` image references with the bytes they point at.
+ *
+ * omp externalizes a large attached image out of the session JSONL: the entry
+ * keeps the ref, the bytes go to the blob store. Only omp's own loader resolves
+ * them, so a reloaded chamber session used to render
+ * `data:image/png;base64,blob:sha256:…` — a data URL whose payload is the ref
+ * string, which the browser cannot decode. The ref itself is dropped once
+ * resolved; an unresolvable one leaves the attachment with no preview rather
+ * than a broken image.
+ */
+async function resolveImageBlobs(messages: ChatMessageData[]): Promise<void> {
+  const pending: Promise<void>[] = [];
+  for (const message of messages) {
+    for (const attachment of message.attachments ?? []) {
+      // `blobRef` rides the attachment only until the bytes are read back; it is
+      // not part of the public attachment shape, so narrow before touching it.
+      if (!('blobRef' in attachment) || typeof attachment.blobRef !== 'string') continue;
+      const ref = attachment.blobRef;
+      delete attachment.blobRef;
+      pending.push(
+        readBlobRef(ref).then((bytes) => {
+          if (bytes) {
+            attachment.preview = `data:${attachment.type ?? 'image/png'};base64,${bytes.toString('base64')}`;
+          }
+        }),
+      );
+    }
+  }
+  await Promise.all(pending);
+}
+
 /** Derive the display title from the JSONL header/title slot (cheap read). */
 export async function loadSessionTitle(filePath: string): Promise<string | undefined> {
   try {