ompchamber 1.1.0 → 1.2.0

package/src/shared/lib/chat/timeline/omp-callbacks.ts

@@ -16,36 +16,14 @@ import type { Dispatch, SetStateAction } from 'preact/compat';
 import type { ChatMessageData, ExtensionUiDialogRequest, IncomingExtensionUiRequest, OmpAgentCallbacks } from '@/shared/types';
 import { triggerChatCompletionSound } from '@/client/hooks/ui/notification-sound';
 import { isNoticeRow } from '@/shared/lib/chat/notice-row';
-import { createRafBatch } from '@/shared/lib/chat/timeline/stream-raf';
+import {
+  bindStreamingCoalescer,
+  disposeStreamingCoalescer,
+  flushStreamingUpdates,
+  queueStreamingUpdate,
+} from '@/shared/lib/chat/timeline/stream-coalescer';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
 
-// omp emits one message_update per model chunk, each carrying that message's
-// FULL accumulated content, so a burst only needs the newest payload per
-// message id. This batch commits at most once per animation frame; the terminal
-// frame flushes synchronously first so the last chunk is never dropped.
-// `apply`/`afterFlush` delegate through module vars because the callbacks
-// factory re-runs on every render.
-let applyMessageUpdater: Dispatch<SetStateAction<ChatMessageData[]>> = () => {};
-let scrollAfterFlush: () => void = () => {};
-
-const messageBatch = createRafBatch<ChatMessageData[]>(
-  updater => applyMessageUpdater(updater),
-  () => scrollAfterFlush(),
-);
-
-/** Apply any coalesced update, then invalidate its scheduled frame. */
-export function disposeStreamingCoalescer(): void {
-  messageBatch.flush();
-  messageBatch.cancel();
-}
-
-/** Drop coalesced updates without applying them — a session switch discards
- *  the previous session's queued `message_update` frames so they cannot leak
- *  into the freshly cleared timeline of the next session. */
-export function cancelStreamingCoalescer(): void {
-  messageBatch.cancel();
-}
-
 export interface OmpAgentCallbacksDeps {
   setGenerating: (v: boolean) => void;
   setGeneratingVerb: (v: string) => void;
@@ -91,8 +69,7 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
     withdrawExtensionDialog,
   } = deps;
 
-  applyMessageUpdater = setLocalMessages;
-  scrollAfterFlush = () => scrollToBottom('smooth');
+  bindStreamingCoalescer(setLocalMessages, () => scrollToBottom('smooth'));
 
   return {
     onAgentStart: () => {
@@ -152,7 +129,7 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
       if (msg.role !== 'user' && !isNoticeRow(msg)) optimisticUserIdRef.current = null;
       // Queue for the next frame, collapsing same-message bursts to the newest
       // full-content frame; scroll runs once per rendered frame.
-      messageBatch.queue(prev => {
+      queueStreamingUpdate(prev => {
         const placeholderId = aiPlaceholderIdRef.current;
         // Notice rows (e.g. background job done, system alerts) are appended in
         // arrival order — the timeline renders state as-is, so omp's own write
@@ -237,7 +214,7 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
       }
       // Apply any coalesced update before the terminal frame so the last chunk
       // is never dropped and the end always runs after it.
-      messageBatch.flush();
+      flushStreamingUpdates();
       if (msg.role !== 'user') optimisticUserIdRef.current = null;
       setLocalMessages(prev => {
         const placeholderId = aiPlaceholderIdRef.current;
@@ -345,6 +322,15 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
         return [...prev, row];
       });
     },
+    // omp renamed the session — the auto-title generation the chamber asks for
+    // after a settled run, a `/rename`, or an RPC set_session_name. The slot
+    // write is in place, so the title is already on disk: refresh the metadata
+    // the navbar/context panel read, and signal the sidebar (whose scan cache
+    // is keyed on file mtime, which a fixed-width in-place write cannot move).
+    onSessionTitleChanged: () => {
+      const sid = adoptedSessionIdRef.current ?? sessionIdRef.current;
+      if (sid) refreshSessionMeta(sid);
+    },
     onNotice: (_level, message) => {
       console.info('OMP notice:', message);
     },

package/src/shared/lib/chat/timeline/stream-coalescer.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Frame coalescer for the live agent stream.
+ *
+ * omp emits one `message_update` per model chunk, each carrying that message's
+ * FULL accumulated content, so a burst only needs the newest payload per
+ * message id. This batches at most one commit per animation frame; the terminal
+ * frame flushes synchronously first so the last chunk is never dropped.
+ *
+ * The sink is a module-level singleton bound once per callbacks factory run
+ * (`bindStreamingCoalescer`), because that factory re-runs on every render
+ * while the batch's scheduled frame must survive across renders. Split out of
+ * omp-callbacks.ts so that file stays under the repo's per-file size ceiling.
+ */
+
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { ChatMessageData } from '@/shared/types';
+import { createRafBatch } from '@/shared/lib/chat/timeline/stream-raf';
+
+let applyMessageUpdater: Dispatch<SetStateAction<ChatMessageData[]>> = () => {};
+let scrollAfterFlush: () => void = () => {};
+
+const messageBatch = createRafBatch<ChatMessageData[]>(
+  updater => applyMessageUpdater(updater),
+  () => scrollAfterFlush(),
+);
+
+/** Point the batch at the current render's state setter and scroll hook. */
+export function bindStreamingCoalescer(
+  apply: Dispatch<SetStateAction<ChatMessageData[]>>,
+  afterFlush: () => void,
+): void {
+  applyMessageUpdater = apply;
+  scrollAfterFlush = afterFlush;
+}
+
+/** Queue a coalesced update for the next animation frame, keyed per message. */
+export function queueStreamingUpdate(
+  updater: (prev: ChatMessageData[]) => ChatMessageData[],
+  key: string,
+): void {
+  messageBatch.queue(updater, key);
+}
+
+/** Apply any queued update synchronously (terminal frames call this first so
+ *  the last chunk is never dropped). */
+export function flushStreamingUpdates(): void {
+  messageBatch.flush();
+}
+
+/** Apply any coalesced update, then invalidate its scheduled frame. */
+export function disposeStreamingCoalescer(): void {
+  messageBatch.flush();
+  messageBatch.cancel();
+}
+
+/** Drop coalesced updates without applying them — a session switch discards
+ *  the previous session's queued `message_update` frames so they cannot leak
+ *  into the freshly cleared timeline of the next session. */
+export function cancelStreamingCoalescer(): void {
+  messageBatch.cancel();
+}

package/src/shared/lib/chat/timeline/turns.ts

@@ -8,8 +8,15 @@
  * rewind endpoint: identifying raw composer input and deciding whether a
  * JSONL-derived user turn and a stored DB-copy turn are the same request
  * (omp rewrites delivered prompts, so equality is not enough).
+ *
+ * The jump rail also reads from here: it lists user turns of the FULL session
+ * (`/api/chat/:id/turns`) and from the mounted window, and both build the same
+ * tooltip preview, so the truncation length is shared rather than duplicated.
  */
 
+/** Longest prompt excerpt a rail tooltip renders. */
+export const TURN_PREVIEW_CHARS = 220;
+
 /** Whether a stored content string is raw composer input (slash command or
  *  @mention) rather than the prompt omp actually delivered. */
 export function isRawComposerInput(content: string): boolean {

package/src/shared/lib/fs/file-kind.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * File-kind classification shared by the server read routes and every client
+ * viewer (desktop editor, mobile editor, chat tool panels).
+ *
+ * A raster image is not text: decoding its bytes as UTF-8 yields replacement
+ * characters, so the editor used to paint a PNG as mojibake. The extension is
+ * the only signal available before reading the file, and it is the same signal
+ * the Files panel already uses to pick an icon — keeping it in one module means
+ * the reader, the icon, and the viewer can never disagree about which files are
+ * pictures.
+ *
+ * SVG is deliberately absent: it is editable XML text and stays on the
+ * syntax-highlighted code path.
+ */
+export const IMAGE_MIME_BY_EXT: Record<string, string> = {
+  png: 'image/png',
+  apng: 'image/apng',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  jfif: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  avif: 'image/avif',
+  bmp: 'image/bmp',
+  ico: 'image/x-icon',
+  tif: 'image/tiff',
+  tiff: 'image/tiff',
+};
+
+/** Lower-cased extension of a path or name, query/fragment/line suffix removed. */
+export function getFileExtension(filePath: string | undefined | null): string {
+  if (!filePath) return '';
+  const clean = filePath.split('?')[0].split('#')[0].split(/[/\\]/).pop() ?? '';
+  const dot = clean.lastIndexOf('.');
+  return dot > 0 ? clean.slice(dot + 1).toLowerCase() : '';
+}
+
+/**
+ * MIME type for a raster image path, or null when the extension is not one.
+ * Null is the "treat as text" answer, so every caller branches on this single
+ * check instead of re-deriving the extension list.
+ */
+export function getImageMimeType(filePath: string | undefined | null): string | null {
+  return IMAGE_MIME_BY_EXT[getFileExtension(filePath)] ?? null;
+}

package/src/shared/lib/fs/paths.ts

@@ -1,5 +1,5 @@
 /**
- * Path formatting for the Files panel's copy actions.
+ * Path helpers shared by the Files panel and every surface that opens a file.
  *
  * `/api/fs/dir` emits every entry as a path relative to the listing's base
  * directory — the workspace root, or the selected nested repo — and reports
@@ -7,7 +7,25 @@
  * two halves; a relative path on its own is not resolvable outside the panel
  * (the client-side `rootPath` may be `~`-relative, rejected by the server, or
  * absent entirely in mock mode).
+ *
+ * `buildFsRawUrl` is the byte-stream counterpart of that same scoping: it is
+ * what an image tab points its `<img>` at, so the file it names is the file
+ * the tab names, nested repo included.
+ */
+
+/**
+ * URL of one file's raw bytes through `/api/fs/raw`, carrying the same scope
+ * (`root`, nested `repo`) as `/api/fs/read` so an image opened from a nested
+ * repo resolves to the file the tab names. `repo: '.'` is omitted: the server
+ * treats an absent repo as the scoped root.
  */
+export function buildFsRawUrl(file: { path: string; root?: string; repo?: string }): string {
+  const params = new URLSearchParams({ path: file.path });
+  if (file.root) params.set('root', file.root);
+  if (file.repo && file.repo !== '.') params.set('repo', file.repo);
+  return `/api/fs/raw?${params.toString()}`;
+}
+
 export function toAbsolutePath(baseDir: string | null | undefined, relPath: string): string {
   // `/`- and `./`-prefixed raws are stripped; a dot-file name (`.env`) is not a prefix.
   const rel = relPath.replace(/^(?:\.?[/\\])+/, '').replace(/[/\\]+$/, '');

package/src/shared/lib/markdown/math.test.ts

@@ -20,16 +20,19 @@
  * they are no-ops everywhere else.
  */
 
-import { beforeAll, describe, expect, test } from 'bun:test';
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
 import { Window } from 'happy-dom';
 
 let hydrateMathBlocks: typeof import('@/shared/lib/markdown/katex').hydrateMathBlocks;
 let renderMarkdown: typeof import('@/shared/lib/markdown/marked').renderMarkdown;
 let sanitizeHtml: typeof import('@/shared/lib/markdown/sanitize').sanitizeHtml;
 
+const displaced: Record<string, unknown> = {};
+const installed: Record<string, unknown> = {};
+
 beforeAll(async () => {
   const win = new Window({ url: 'http://localhost' });
-  Object.assign(globalThis, {
+  for (const [key, value] of Object.entries({
     window: win,
     document: win.document,
     MutationObserver: win.MutationObserver,
@@ -37,7 +40,11 @@ beforeAll(async () => {
     Element: win.Element,
     HTMLElement: win.HTMLElement,
     NodeFilter: win.NodeFilter,
-  });
+  })) {
+    displaced[key] = (globalThis as Record<string, unknown>)[key];
+    installed[key] = value;
+    (globalThis as Record<string, unknown>)[key] = value;
+  }
   // Dynamic import is required here, not stylistic: `sanitize.ts` binds
   // DOMPurify at module scope, which captures the DOM globals present at
   // evaluation time. A static import would run before the happy-dom globals
@@ -47,6 +54,16 @@ beforeAll(async () => {
   ({ sanitizeHtml } = await import('@/shared/lib/markdown/sanitize'));
 });
 
+// Every test file shares one process, so the globals go back the way they were:
+// the fold in `agent-events.ts` branches on `typeof window`, and a leaked DOM
+// window would take its browser path with a `CustomEvent` from another realm.
+afterAll(() => {
+  for (const key of Object.keys(installed)) {
+    if (displaced[key] === undefined) delete (globalThis as Record<string, unknown>)[key];
+    else (globalThis as Record<string, unknown>)[key] = displaced[key];
+  }
+});
+
 /** Render markdown and mount it exactly as `MarkdownRenderer` does. */
 function mount(content: string): HTMLElement {
   const host = document.createElement('div');

package/src/shared/lib/omp/session/inlined-attachments.test.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Recovery of inlined text attachments from a delivered prompt.
+ *
+ * The composer does not send a text file as data — it appends the file to the
+ * prompt as `Attached file: <name>` plus a fenced block, and that composed
+ * prompt is the only record omp keeps. `stripInlinedTextAttachments` removes
+ * those blocks so the timeline shows the user's own words, which also discards
+ * the names: a reloaded session then showed an image chip and nothing for the
+ * `.md`/`.py`/`.json` that rode beside it.
+ *
+ * These tests pin the round trip, including the adversarial cases the format
+ * allows: content that itself contains a run of backticks (the fence grows to
+ * outrun it) and content that literally reads `Attached file:`.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  extractInlinedTextAttachments,
+  stripInlinedTextAttachments,
+} from '@/shared/lib/omp/session/parse-message-blocks';
+
+describe('extractInlinedTextAttachments', () => {
+  test('recovers a file the composer appended to a prompt', () => {
+    const prompt = 'explain this\n\nAttached file: script.py\n```python\nx=1\n```';
+    expect(extractInlinedTextAttachments(prompt)).toEqual([{ name: 'script.py', content: 'x=1' }]);
+    // The visible text is the user's own words; the block is not shown twice.
+    expect(stripInlinedTextAttachments(prompt)).toBe('explain this');
+  });
+
+  test('recovers an attach-only prompt, whose visible text is empty', () => {
+    const prompt = 'Attached file: attachment-test.md\n```markdown\n# Title\n\nbody\n\n```';
+    // Trailing newline before the closing fence belongs to the content: the
+    // composer writes `<content>\n<fence>`.
+    expect(extractInlinedTextAttachments(prompt)).toEqual([
+      { name: 'attachment-test.md', content: '# Title\n\nbody\n' },
+    ]);
+    expect(stripInlinedTextAttachments(prompt)).toBe('');
+  });
+
+  test('recovers every file when several were attached', () => {
+    const prompt = 'q\n\nAttached file: a.md\n```markdown\nA\n```\n\nAttached file: b.py\n```python\nB\n```';
+    expect(extractInlinedTextAttachments(prompt)).toEqual([
+      { name: 'a.md', content: 'A' },
+      { name: 'b.py', content: 'B' },
+    ]);
+  });
+
+  test('leaves a prompt with no attachments alone', () => {
+    expect(extractInlinedTextAttachments('just a normal message')).toEqual([]);
+    expect(stripInlinedTextAttachments('just a normal message')).toBe('just a normal message');
+  });
+
+  test('does not mistake prose that merely mentions the header', () => {
+    // No fence follows, so this is not a block — it is the user talking.
+    expect(extractInlinedTextAttachments('I saw an Attached file: note in the docs')).toEqual([]);
+  });
+
+  test('keeps content that contains a backtick run', () => {
+    // `fenceForContent` grows the fence past the longest run in the content, so
+    // the inner ``` must survive as content and the outer ```` is the close.
+    const prompt = 'q\n\nAttached file: nested.md\n````markdown\nbefore\n```\ncode\n```\nafter\n````';
+    expect(extractInlinedTextAttachments(prompt)).toEqual([
+      { name: 'nested.md', content: 'before\n```\ncode\n```\nafter' },
+    ]);
+  });
+
+  test('keeps content that literally contains the header', () => {
+    const prompt = 'q\n\nAttached file: tricky.md\n````markdown\nAttached file: fake.txt\n```\ninner\n```\n````';
+    expect(extractInlinedTextAttachments(prompt)).toEqual([
+      { name: 'tricky.md', content: 'Attached file: fake.txt\n```\ninner\n```' },
+    ]);
+  });
+
+  test('an unterminated block yields nothing rather than a partial read', () => {
+    expect(extractInlinedTextAttachments('q\n\nAttached file: open.md\n```markdown\nno close')).toEqual([]);
+  });
+});

package/src/shared/lib/omp/session/mapper.ts

@@ -13,7 +13,7 @@
  */
 
 import type { ChatMessageData, ToolCallData } from '@/shared/types';
-import { extractText, extractUserImageAttachments, parseMessageBlocks, stripInlinedTextAttachments, toToolCallData } from '@/shared/lib/omp/session/parse-message-blocks';
+import { extractInlinedTextAttachments, extractText, extractUserImageAttachments, parseMessageBlocks, stripInlinedTextAttachments, toToolCallData } from '@/shared/lib/omp/session/parse-message-blocks';
 import { reminderPartIndex } from '@/shared/lib/chat/notice-row';
 import { deriveTurnError } from '@/shared/lib/omp/session/turn-error';
 import { formatClock } from '@/shared/lib/format/time';
@@ -95,8 +95,22 @@ export function toChatMessage(raw: Record<string, unknown>, streaming = true): C
   }
 
   if (role === 'user') {
-    const text = stripInlinedTextAttachments(parsed.textParts.join('\n'));
-    const attachments = extractUserImageAttachments(raw.content);
+    const rawText = parsed.textParts.join('\n');
+    const text = stripInlinedTextAttachments(rawText);
+    // Parity with the JSONL path: the composer's inlined `Attached file:` blocks
+    // are the only record of a text attachment, so they are read back into
+    // chips here too. Without this a text file vanished from the timeline as
+    // soon as the turn was re-rendered from the wire.
+    const attachments = [
+      ...extractUserImageAttachments(raw.content),
+      ...extractInlinedTextAttachments(rawText).map((file, index) => ({
+        id: `text-${index + 1}`,
+        name: file.name,
+        type: 'text/plain',
+        preview: '',
+        content: file.content,
+      })),
+    ];
     return {
       id,
       role,
@@ -105,7 +119,13 @@ export function toChatMessage(raw: Record<string, unknown>, streaming = true): C
       startedAt,
       content: text,
       attribution,
-      attachments: attachments.map((a) => ({ id: a.id, name: a.name, preview: a.preview, type: a.type })),
+      attachments: attachments.map((a) => ({
+        id: a.id,
+        name: a.name,
+        preview: a.preview,
+        type: a.type,
+        ...('content' in a ? { content: a.content } : {}),
+      })),
     };
   }
 

package/src/shared/lib/omp/session/messages-map.ts

@@ -4,7 +4,7 @@
  */
 
 import type { ChatMessageData } from '@/shared/types/chat';
-import { extractText, extractUserImageAttachments, parseAssistantContent, resultOutput, roleFor, stripInlinedTextAttachments, type OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
+import { extractInlinedTextAttachments, extractText, extractUserImageAttachments, parseAssistantContent, resultOutput, roleFor, stripInlinedTextAttachments, type OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
 import { isRecord } from '@/shared/lib/util/guards';
 import { reminderPartIndex } from '@/shared/lib/chat/notice-row';
 import { deriveTurnError } from '@/shared/lib/omp/session/turn-error';
@@ -32,8 +32,21 @@ export function toChatMessage(entry: OmpMessageEntry): ChatMessageData | null {
   };
 
   if (role === 'user') {
-    const text = stripInlinedTextAttachments(extractText(content));
-    const attachments = extractUserImageAttachments(content);
+    const rawText = extractText(content);
+    const text = stripInlinedTextAttachments(rawText);
+    // omp keeps no attachment metadata for a text file: the composer inlined it
+    // into the prompt and that composed prompt is the only record. Recover the
+    // names from those blocks so a reloaded session still shows their chips —
+    // images survive on their own (they ride as a content block), text files
+    // did not, and disappeared from the timeline entirely.
+    const textAttachments = extractInlinedTextAttachments(rawText);
+    const attachments = [...extractUserImageAttachments(content), ...textAttachments.map((file, index) => ({
+      id: `text-${index + 1}`,
+      name: file.name,
+      type: 'text/plain',
+      preview: '',
+      content: file.content,
+    }))];
     if (!text.trim() && attachments.length === 0) return null;
     return { ...base, content: text, attachments };
   }

package/src/shared/lib/omp/session/messages-parse.ts

@@ -13,7 +13,7 @@
 
 import type { ToolCallData } from '@/shared/types/chat';
 import type { OmpMessageEntry } from '@/shared/types/omp/session';
-import { extractText as coreExtractText, extractUserImageAttachments, parseMessageBlocks, stripInlinedTextAttachments, toToolCallData } from '@/shared/lib/omp/session/parse-message-blocks';
+import { extractInlinedTextAttachments, extractText as coreExtractText, extractUserImageAttachments, parseMessageBlocks, stripInlinedTextAttachments, toToolCallData } from '@/shared/lib/omp/session/parse-message-blocks';
 import { isRecord } from '@/shared/lib/util/guards';
 
 export { stripInlinedTextAttachments };
@@ -66,4 +66,4 @@ export function parseAssistantContent(content: unknown): ParsedAssistantTurn {
   };
 }
 
-export { extractUserImageAttachments };
+export { extractUserImageAttachments, extractInlinedTextAttachments };

package/src/shared/lib/omp/session/parse-message-blocks.ts

@@ -182,14 +182,37 @@ export function toToolCallData(
   };
 }
 
+/**
+ * A user-attachment entry extracted from an omp content block. `blobRef` is set
+ * when omp externalized the bytes instead of inlining them (see
+ * `@/server/lib/omp/session/blobs.server`); the server resolves it before the
+ * timeline sees the attachment, so `preview` here is only a placeholder.
+ */
+export interface ExtractedImageAttachment {
+  id: string;
+  name: string;
+  preview: string;
+  type: string;
+  /** `blob:sha256:<hash>` when the bytes were externalized, else undefined. */
+  blobRef?: string;
+}
+
+/** True for the `blob:sha256:<hash>` references omp writes in place of image data. */
+export function isBlobImageRef(data: string): boolean {
+  return data.startsWith('blob:sha256:');
+}
+
 /** Extract image blocks from an omp user content array ({type:'image',
- *  data: base64, mimeType}) into ChatMessageData attachment entries so the
- *  timeline keeps showing them after a reload from the session JSONL. */
+ *  data: base64 | blob:sha256:<hash>, mimeType}) into ChatMessageData attachment
+ *  entries so the timeline keeps showing them after a reload from the session
+ *  JSONL. A blob ref carries no preview: building one from the ref string
+ *  produced an undecodable `data:` URL, which is what the server-side resolver
+ *  now replaces with the real bytes. */
 export function extractUserImageAttachments(
   content: unknown,
-): { id: string; name: string; preview: string; type: string }[] {
+): ExtractedImageAttachment[] {
   if (!Array.isArray(content)) return [];
-  const attachments: { id: string; name: string; preview: string; type: string }[] = [];
+  const attachments: ExtractedImageAttachment[] = [];
   let index = 0;
   for (const block of content) {
     if (!isRecord(block) || block.type !== 'image') continue;
@@ -198,11 +221,13 @@ export function extractUserImageAttachments(
     if (!data) continue;
     index += 1;
     const ext = (mimeType.split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '') || 'png';
+    const externalized = isBlobImageRef(data);
     attachments.push({
       id: `att-${index}`,
       name: `attachment-${index}.${ext}`,
-      preview: `data:${mimeType};base64,${data}`,
+      preview: externalized ? '' : `data:${mimeType};base64,${data}`,
       type: mimeType,
+      ...(externalized ? { blobRef: data } : {}),
     });
   }
   return attachments;
@@ -221,3 +246,58 @@ export function stripInlinedTextAttachments(text: string): string {
   if (!/^[^\n]+\n```[a-z]*\n/.test(rest)) return text;
   return before.trim();
 }
+
+/** One text file recovered from an inlined `Attached file:` block. */
+export interface InlinedTextAttachment {
+  name: string;
+  content: string;
+}
+
+/**
+ * Recover the text files the composer inlined into a delivered prompt.
+ *
+ * omp stores no attachment metadata for a text file: the composer appends each
+ * one to the prompt as `Attached file: <name>` plus a fenced block, and that
+ * composed prompt IS the session record. `stripInlinedTextAttachments` removes
+ * those blocks for display, which also throws the names away — so a reloaded
+ * session showed no chip for a dropped `.md`/`.py`/`.json` while its image
+ * siblings survived (images ride as their own content block).
+ *
+ * This walks the same format back out, so the timeline can render the chips and
+ * re-open the files. The fence length is whatever `fenceForContent` chose (at
+ * least 3 backticks, longer when the content itself contains a run), and a
+ * block's content may contain anything — including the literal string
+ * "Attached file:" — so the closing fence is matched by exact length rather
+ * than by looking for the next header.
+ */
+export function extractInlinedTextAttachments(text: string): InlinedTextAttachment[] {
+  const attachments: InlinedTextAttachment[] = [];
+  const header = /(?:^|\n{2})Attached file: ([^\n]+)\n(`{3,})[a-zA-Z0-9_-]*\n/g;
+  let match: RegExpExecArray | null;
+  while ((match = header.exec(text)) !== null) {
+    const name = match[1].trim();
+    const fence = match[2];
+    const contentStart = match.index + match[0].length;
+    // The closing fence sits on its own line and repeats the opening run
+    // exactly; a longer run is content, not the close.
+    const closer = `\n${fence}`;
+    let cursor = contentStart;
+    let end = -1;
+    while (cursor <= text.length) {
+      const at = text.indexOf(closer, cursor);
+      if (at === -1) break;
+      const after = text.slice(at + closer.length);
+      // Accept the close only at a block boundary: end of string, or a blank
+      // line followed by the next header / nothing.
+      if (after === '' || after.startsWith('\n') || /^\n{2}Attached file: /.test(after)) {
+        end = at;
+        break;
+      }
+      cursor = at + closer.length;
+    }
+    if (end === -1) continue;
+    attachments.push({ name, content: text.slice(contentStart, end) });
+    header.lastIndex = end + closer.length;
+  }
+  return attachments;
+}

package/src/shared/types/btw.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * BTW (side question) domain types.
+ *
+ * A BTW topic is an independent question plus its explicit follow-ups, run
+ * against the parent session's context but never appended to its transcript —
+ * the same contract omp's own `/btw` implements in the TUI. The server is the
+ * source of truth for a session's topics; the panel renders the state it is
+ * sent and streams answer text through `btw_delta` frames.
+ */
+
+/** Lifecycle of one question/answer pair inside a topic. */
+export type BtwTurnStatus = 'running' | 'complete' | 'cancelled' | 'failed' | 'interrupted';
+
+/** Model a topic's side conversation runs on — the parent session's model,
+ *  captured when the topic was created (omp's `/btw` uses the active model). */
+export interface BtwModel {
+  provider: string;
+  id: string;
+  /** Display name reported by the running side session (`DeepSeek-V4.1-Flash`). */
+  name?: string;
+}
+
+/** One question and its answer inside a topic. */
+export interface BtwTurn {
+  index: number;
+  question: string;
+  answer: string;
+  status: BtwTurnStatus;
+  createdAt: number;
+  updatedAt: number;
+}
+
+/** A side conversation scoped to one chamber session. */
+export interface BtwTopic {
+  id: string;
+  sessionId: string;
+  /** The first question, used as the topic's label in history. */
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  model?: BtwModel;
+  /** Set once the topic was promoted into the chat as a session of its own. */
+  promotedSessionId?: string;
+  turns: BtwTurn[];
+}
+
+/** A session's whole BTW view. */
+export interface BtwState {
+  topics: BtwTopic[];
+  /** Topic with a question in flight; at most one per session, because a
+   *  session runs one side conversation at a time. */
+  runningTopicId: string | null;
+}
+
+/** Server → client frames on `/api/btw/:sessionId/*` (WS and SSE alike). */
+export type BtwFrame =
+  | { type: 'connected'; sessionId: string }
+  | { type: 'btw_state'; state: BtwState }
+  | { type: 'btw_delta'; topicId: string; turnIndex: number; text: string }
+  | { type: 'btw_error'; topicId: string | null; message: string };