ompchamber 1.1.0 → 1.2.1

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 {

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

@@ -15,8 +15,8 @@
  *   - cwd → repository root      → lib/omp/worktree.ts
  *   - managed projects registry  → lib/omp/project-registry.ts
  *
- * All reads are bounded (4 KiB prefix per session file), cached by mtime, and
- * never mutate the agent's files.
+ * All reads are bounded (a 4 KiB prefix plus a 16 KiB tail window per session
+ * file), cached by file mtime, and never mutate the agent's files.
  */
 
 import { listAllSessionInfos, type OmpSessionInfo } from '@/server/lib/omp/session/files';

package/src/server/lib/omp/session/subagent-presence.ts

@@ -12,10 +12,13 @@
  * megabytes, and doing that per session per poll dominated the endpoint's cost
  * (the dataset scan itself is cached; this probe was not).
  *
- * The roster can only change when the session file or its sibling artifacts
- * directory changes, so that (session mtime, sibling-dir mtime) pair is a
- * sufficient cache version. Both cost one stat — orders of magnitude cheaper
- * than the parse they gate.
+ * The roster can only change when the session file gains entries or its
+ * sibling artifacts directory changes, so that (last-entry timestamp,
+ * sibling-dir mtime) pair is a sufficient cache version. Both cost one stat —
+ * orders of magnitude cheaper than the parse they gate. The timestamp is the
+ * file's last ENTRY time, not its mtime: a title-slot rewrite bumps mtime
+ * without appending anything, and a spurious version bump would re-run the
+ * parse it exists to avoid.
  */
 
 import { promises as fs } from 'fs';
@@ -42,10 +45,10 @@ async function siblingDirMtimeMs(dir: string): Promise<number> {
 
 export async function sessionHasSubagents(
   sessionPath: string,
-  sessionModified: string,
+  sessionLastEntryAt: string,
 ): Promise<boolean> {
   const siblingDir = siblingDirForSession(sessionPath);
-  const version = `${sessionModified}:${await siblingDirMtimeMs(siblingDir)}`;
+  const version = `${sessionLastEntryAt}:${await siblingDirMtimeMs(siblingDir)}`;
 
   const cached = cache.get(sessionPath);
   if (cached && cached.version === version) return cached.hasSubagents;

package/src/server/lib/queue/delivery.server.test.ts

@@ -169,6 +169,63 @@ describe('queue delivery', () => {
     expect(queue.get(sessionId)).toEqual([]);
   });
 
+  // Attachments reach the server as the persisted display fields only: the
+  // composer's `File` never survives the queue row's JSON round trip, and its
+  // image preview is a `blob:` object URL the server cannot read. These pin the
+  // fields the delivery must use instead — `dataBase64` for the bytes, `type`
+  // for the media type, `content` for an inline-able text file.
+  test('a queued image rides its persisted base64 payload', async () => {
+    const item = queueItem('with image', null);
+    item.attachments = [
+      { id: 'i', name: 'shot.png', type: 'image/png', size: 4, preview: 'blob:http://x/1', dataBase64: 'iVBORw0KGgo=' },
+    ] as QueuedMessage['attachments'];
+    queue.set(sessionId, [item]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent).toEqual([
+      {
+        type: 'prompt',
+        message: 'with image',
+        images: [{ type: 'image', data: 'iVBORw0KGgo=', mimeType: 'image/png' }],
+      },
+    ]);
+  });
+
+  test('a queued text file is inlined into the delivered prompt', async () => {
+    const item = queueItem('review this', null);
+    item.attachments = [
+      { id: 't', name: 'notes.md', type: 'text/markdown', size: 5, preview: '', content: '# hi' },
+    ] as QueuedMessage['attachments'];
+    queue.set(sessionId, [item]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    const prompt = sent.find((c) => c.type === 'prompt');
+    expect(prompt?.message).toBe('review this\n\nAttached file: notes.md\n```markdown\n# hi\n```');
+  });
+
+  test('an attachment without a payload is not sent as a blank image', async () => {
+    const item = queueItem('no payload', null);
+    item.attachments = [
+      { id: 'i', name: 'broken.png', type: 'image/png', size: 4, preview: 'blob:http://x/1', dataBase64: '' },
+    ] as QueuedMessage['attachments'];
+    queue.set(sessionId, [item]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent).toEqual([{ type: 'prompt', message: 'no payload' }]);
+  });
+
   test('a lost timer delays the queue instead of wedging it', async () => {
     queue.set(sessionId, [queueItem('recovered')]);
     const { host, sent } = makeHost(sessionId);

package/src/server/lib/queue/delivery.server.ts

@@ -21,6 +21,7 @@
  */
 
 import { claimHeadQueueItem, requeueHeadQueueItem } from '@/server/lib/queue/store.server';
+import { composeMessageWithTextAttachments } from '@/shared/lib/chat/attachments';
 import type { QueuedMessage } from '@/shared/types/chat';
 
 /** Settling time between agent_end and the next prompt dispatch. Small on
@@ -71,12 +72,33 @@ async function dispatchQueuedItem(session: QueueDeliveryHost, item: QueuedMessag
         await session.send({ type: 'set_thinking_level', level: item.model.thinkingLevel });
       }
     }
+    // Attachments reach this point as the persisted display fields — the live
+    // `File` never survived the queue's JSON round trip. The base64 payload and
+    // the MIME type are therefore read from the fields that DID persist:
+    // `dataBase64` for the bytes, `type` for the media type. (Matching on a
+    // `data:` preview used to yield zero images, because the composer's preview
+    // is a `blob:` object URL that the server cannot read.)
     const images = item.attachments
-      .filter((a) => typeof a?.preview === 'string' && a.preview.startsWith('data:image/') && typeof a?.dataBase64 === 'string')
-      .map((a) => ({ type: 'image' as const, data: a.dataBase64 as string, mimeType: a.preview.slice(5).split(';')[0] || 'image/png' }));
+      .filter((a) => typeof a?.dataBase64 === 'string' && a.dataBase64.length > 0)
+      .map((a) => ({
+        type: 'image' as const,
+        data: a.dataBase64 as string,
+        mimeType: typeof a.type === 'string' && a.type.startsWith('image/') ? a.type : 'image/png',
+      }));
+    // Text attachments are inlined into the prompt, exactly as the composer
+    // does at send time — the item's own `text` is the raw composer input, so
+    // without this a queued file would deliver as a bare filename mention.
+    const textFiles = item.attachments
+      .filter((a) => typeof a?.content === 'string' && a.content.length > 0)
+      .map((a) => ({
+        name: typeof a.name === 'string' && a.name ? a.name : 'attachment',
+        mimeType: typeof a.type === 'string' ? a.type : 'text/plain',
+        content: a.content as string,
+        size: typeof a.size === 'number' ? a.size : (a.content as string).length,
+      }));
     await session.send({
       type: 'prompt',
-      message: item.text,
+      message: composeMessageWithTextAttachments(item.text, textFiles),
       ...(images.length ? { images } : {}),
       ...(item.model ? { accessMode: item.model.accessMode } : {}),
     });

package/src/server/plugins/ssr.ts

@@ -36,7 +36,7 @@ function missingBuildResponse(): Response {
 <p>For a rebuild-on-change loop while developing:</p>
 <pre style="background:#f4f1ea;padding:1rem;border-radius:6px">bunx rsbuild build --watch</pre>
 </body>`,
-    { status: 503, headers: { 'content-type': 'text/html; charset=utf-8' } },
+    { status: 503, headers: HTML_HEADERS },
   );
 }
 
@@ -64,6 +64,33 @@ function themeColor(theme: string): string {
 
 const MOBILE_UA = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile|mobile|CriOS/i;
 
+/**
+ * The HTML shell is generated per request, so its cacheability is declared
+ * rather than left to the browser's heuristics.
+ *
+ * It is not a static file: the theme and the bootstrap settings are injected on
+ * every request, and its only link to the bundle is a content hash inside the
+ * markup. A copy that outlives its build does not merely go stale — it points at
+ * an asset hash the build no longer emits, leaving the page running previous
+ * code with nothing in the response to signal it.
+ *
+ * Chrome does not currently cache it: the response carries no `Cache-Control`,
+ * `Last-Modified` or `ETag`, so there is no freshness to heuristically derive
+ * and every navigation re-fetches (measured: a second load of the shell reported
+ * the full 41 KB `transferSize`). That is the behaviour this header makes
+ * explicit — the day a validator is added for the template, heuristic caching
+ * would start and nothing else here would prevent it.
+ *
+ * `no-store` rather than `no-cache`: with no validator there is nothing to
+ * revalidate against, so a stored copy is never usable.
+ */
+const SHELL_CACHE = 'no-store';
+
+const HTML_HEADERS = {
+  'content-type': 'text/html; charset=utf-8',
+  'cache-control': SHELL_CACHE,
+} as const;
+
 export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }) => {
   const pathname = new URL(request.url).pathname;
 
@@ -95,6 +122,6 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
       .replace('data-theme="paper"', `data-theme="${theme}"`)
       .replace('<!--app-head-->', `<meta name="theme-color" content="${themeColor(theme)}">`)
       .replace('<!--app-bootstrap-->', `<script>window.__OMP_BOOTSTRAP__=${bootstrap}</script>`),
-    { headers: { 'content-type': 'text/html; charset=utf-8' } },
+    { headers: HTML_HEADERS },
   );
 });

package/src/server/routes/btw/events.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `GET /api/btw/:sessionId/events` — SSE stream of a session's BTW frames.
+ *
+ * Unlike the agent stream this one is not observer-only: a side question's
+ * history must be readable for a session whose omp child is not running (that
+ * is the normal state of a session opened from the sidebar), so the route
+ * subscribes to the registry and never spawns anything.
+ */
+
+import { createEventCoalescer, createSseStream, type EventCoalescer } from '@/server/lib/sse';
+import { btwStateFor, subscribeBtw } from '@/server/lib/btw/registry.server';
+import type { BtwFrame } from '@/shared/types';
+
+/** Longest a coalesced frame may wait before it is flushed anyway. */
+const FLUSH_DELAY_MS = 50;
+
+export async function loader({ params, request }: { params: Record<string, string>; request: Request }) {
+  const { sessionId } = params;
+  if (!sessionId) return new Response('session id is required', { status: 400 });
+
+  let coalescer: EventCoalescer | null = null;
+
+  const stream = createSseStream({
+    heartbeatMs: 30_000,
+    signal: request.signal,
+    beforeHeartbeat: () => coalescer?.flush() ?? true,
+    onStart(handlers) {
+      let unsubscribe: (() => void) | null = null;
+      coalescer = createEventCoalescer({
+        send: (event, data) => handlers.send(event, data),
+        isBackpressured: handlers.isBackpressured,
+        flushDelayMs: FLUSH_DELAY_MS,
+      });
+      const push = (frame: BtwFrame) => coalescer?.push('', frame);
+
+      handlers.send('', { type: 'connected', sessionId });
+      if (handlers.isClosed()) return;
+      unsubscribe = subscribeBtw(sessionId, push);
+      void btwStateFor(sessionId)
+        .then((state) => push({ type: 'btw_state', state }))
+        .catch((error: unknown) => {
+          push({
+            type: 'btw_error',
+            topicId: null,
+            message: error instanceof Error ? error.message : String(error),
+          });
+        });
+
+      return () => {
+        coalescer?.dispose();
+        coalescer = null;
+        if (unsubscribe) {
+          try {
+            unsubscribe();
+          } catch {
+            // Subscriber cleanup is best-effort.
+          }
+          unsubscribe = null;
+        }
+      };
+    },
+  });
+
+  return stream.response;
+}

package/src/server/routes/btw/index.ts

@@ -0,0 +1,8 @@
+import { actionBindings, bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
+import { action, loader } from '@/server/routes/btw/topics';
+import * as btwEvents from '@/server/routes/btw/events';
+
+export const btwBindings: HandlerBinding[] = [
+  ...actionBindings(action, '/api/btw/:sessionId', loader),
+  ...bindingsFor(btwEvents, '/api/btw/:sessionId/events'),
+];

package/src/server/routes/btw/topics.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * BTW commands: `GET /api/btw/:sessionId` returns a session's side questions,
+ * `POST` runs one action against them.
+ *
+ * Mutating verbs stay in one handler with its own dispatch (the ported Remix
+ * shape the rest of the API uses), so an unsupported action gets a named error
+ * instead of a silent success.
+ */
+
+import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { toImageContents, validateAgentImages } from '@/server/lib/omp/rpc/constants';
+import { BtwError, type BtwImages } from '@/server/lib/btw/runtime.server';
+import { abortBtw, askBtw, getBtwState, promoteBtw, removeBtw } from '@/server/lib/btw/service.server';
+
+/** Actions that can reject for a reason the client should show as-is. */
+const STATUS_BY_CODE: Record<string, number> = {
+  btw_busy: 409,
+  btw_stale: 409,
+  session_not_found: 404,
+  btw_topic_not_found: 404,
+};
+
+function btwErrorResponse(error: unknown): Response {
+  if (error instanceof BtwError) {
+    return json({ error: error.message, code: error.code }, { status: STATUS_BY_CODE[error.code] ?? 400 });
+  }
+  return json({ error: error instanceof Error ? error.message : String(error) }, { status: 500 });
+}
+
+function readImages(raw: unknown): { images?: BtwImages } | { error: string } {
+  const problem = validateAgentImages(raw);
+  if (problem) return { error: problem };
+  const images = toImageContents(raw);
+  return images ? { images } : {};
+}
+
+export async function action({ params, request }: ActionFunctionArgs) {
+  const { sessionId } = params;
+  if (!sessionId) return json({ error: 'session id is required' }, { status: 400 });
+
+  const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+  const action = typeof body?.action === 'string' ? body.action : '';
+  const topicId = typeof body?.topicId === 'string' ? body.topicId : undefined;
+  if (!action) return json({ error: 'action is required', code: 'action_required' }, { status: 400 });
+
+  try {
+    switch (action) {
+      case 'ask': {
+        const question = typeof body?.question === 'string' ? body.question : '';
+        const parsed = readImages(body?.images);
+        if ('error' in parsed) return json({ error: parsed.error, code: 'invalid_images' }, { status: 400 });
+        return json({ success: true, data: await askBtw(sessionId, { topicId, question, images: parsed.images }) });
+      }
+      case 'abort': {
+        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
+        return json({ success: true, data: await abortBtw(sessionId, topicId) });
+      }
+      case 'promote': {
+        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
+        return json({ success: true, data: await promoteBtw(sessionId, topicId) });
+      }
+      case 'delete': {
+        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
+        return json({ success: true, data: await removeBtw(sessionId, topicId) });
+      }
+      default:
+        return json({ error: `Unknown btw action: ${action}`, code: 'unknown_action' }, { status: 400 });
+    }
+  } catch (error) {
+    return btwErrorResponse(error);
+  }
+}
+
+export async function loader({ params }: LoaderFunctionArgs) {
+  const { sessionId } = params;
+  if (!sessionId) return json({ error: 'session id is required' }, { status: 400 });
+  try {
+    return json({ success: true, data: await getBtwState(sessionId) });
+  } catch (error) {
+    return btwErrorResponse(error);
+  }
+}