ompchamber 1.1.0 → 1.2.1

package/src/shared/lib/chat/attachments.test.ts

@@ -0,0 +1,208 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Attachment metadata across the two representations the composer handles.
+ *
+ * A LIVE attachment carries `file: File`; a REPLAYED one — out of the queue row
+ * or back out of committed history — does not, because `JSON.stringify(new
+ * File(…))` is `{}`. Every accessor and every assembly path must therefore work
+ * from the persisted display fields, which is what used to break: a queued or
+ * retried send read `a.file.name` and threw, and the image payload filter
+ * matched on a `data:` preview the composer never produces.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import type { Attachment } from '@/shared/types';
+import {
+  applyTextAttachmentBudget,
+  attachmentImage,
+  attachmentName,
+  attachmentSize,
+  attachmentType,
+  composeMessageWithTextAttachments,
+  isImageAttachment,
+  isTextAttachment,
+  looksLikeTextFile,
+  prepareQueuedAttachments,
+  readTextAttachments,
+} from '@/shared/lib/chat/attachments';
+
+function liveFile(name: string, body: string, type = ''): File {
+  return new File([body], name, { type });
+}
+
+function liveAttachment(overrides: Partial<Attachment> & { id: string }): Attachment {
+  return { preview: '', ...overrides };
+}
+
+/** What the queue row and committed history actually hold. */
+function replayed(attachments: Attachment[]): Attachment[] {
+  return JSON.parse(JSON.stringify(attachments)) as Attachment[];
+}
+
+describe('attachment metadata accessors', () => {
+  test('read a live file, and fall back to the persisted fields', () => {
+    const live = liveAttachment({ id: 'a', name: 'notes.md', type: 'text/markdown', size: 99, file: liveFile('notes.md', '# hi', 'text/markdown') });
+    expect(attachmentName(live)).toBe('notes.md');
+    expect(attachmentType(live)).toBe('text/markdown');
+    expect(attachmentSize(live)).toBe(4); // the live handle is authoritative
+
+    const replay = replayed([live])[0];
+    // `JSON.stringify` renders a File as an empty object — not as undefined —
+    // so the replay path must treat a truthiness check as unreliable and read
+    // the display fields first.
+    expect(replay.file as unknown).toEqual({});
+    expect(attachmentName(replay)).toBe('notes.md');
+    expect(attachmentType(replay)).toBe('text/markdown');
+    expect(attachmentSize(replay)).toBe(99);
+  });
+
+  test('never throw on an attachment with neither a file nor a name', () => {
+    const bare = { id: 'x', preview: '' } as Attachment;
+    expect(attachmentName(bare)).toBe('attachment');
+    expect(attachmentType(bare)).toBe('');
+    expect(attachmentSize(bare)).toBe(0);
+    expect(isTextAttachment(bare)).toBe(false);
+    expect(attachmentImage(bare)).toBeNull();
+  });
+});
+
+describe('text vs image classification', () => {
+  test('code files with no browser MIME type still inline', () => {
+    // `File.type` is empty for most source files, so the extension decides.
+    for (const name of ['script.py', 'app.tsx', 'query.sql', 'Dockerfile.json', 'data.yaml']) {
+      expect(isTextAttachment({ name, type: '', file: liveFile(name, 'x') })).toBe(true);
+    }
+  });
+
+  test('a browser-reported text MIME type is enough on its own', () => {
+    expect(isTextAttachment({ name: 'LICENSE', type: 'text/plain', file: liveFile('LICENSE', 'x', 'text/plain') })).toBe(true);
+    expect(isTextAttachment({ name: 'blob.bin', type: 'application/json', file: liveFile('blob.bin', '{}', 'application/json') })).toBe(true);
+  });
+
+  test('binaries and images never consume the inline budget', () => {
+    expect(isTextAttachment({ name: 'app.dmg', type: 'application/octet-stream', file: liveFile('app.dmg', 'x', 'application/octet-stream') })).toBe(false);
+    // An image whose name happens to look textual is still an image.
+    expect(isTextAttachment({ name: 'trap.md', type: 'image/png', file: liveFile('trap.md', 'x', 'image/png') })).toBe(false);
+    expect(isImageAttachment({ name: 'trap.md', type: 'image/png', file: liveFile('trap.md', 'x', 'image/png') })).toBe(true);
+  });
+});
+
+describe('image payloads', () => {
+  test('carry the omp ImageContent type and the persisted MIME type', () => {
+    const payload = attachmentImage({
+      type: 'image/png',
+      dataBase64: 'iVBORw0KGgo=',
+    });
+    expect(payload).toEqual({ type: 'image', data: 'iVBORw0KGgo=', mimeType: 'image/png' });
+  });
+
+  test('a replay with a blob preview still yields its payload', () => {
+    // The old server-side filter matched `preview.startsWith('data:image/')`
+    // and so found nothing: the composer's preview is a blob URL.
+    const [replay] = replayed([
+      liveAttachment({ id: 'i', name: 's.png', type: 'image/png', preview: 'blob:http://x/1', dataBase64: 'AAAA', file: liveFile('s.png', 'x', 'image/png') }),
+    ]);
+    expect(attachmentImage(replay)?.data).toBe('AAAA');
+  });
+
+  test('an unread image yields nothing rather than a blank payload', () => {
+    expect(attachmentImage({ type: 'image/png', dataBase64: '' })).toBeNull();
+    expect(attachmentImage({ type: 'image/png' })).toBeNull();
+  });
+});
+
+describe('text contents', () => {
+  test('are read from a live file, and from `content` on a replay', async () => {
+    const live = [liveAttachment({ id: 't', name: 'notes.md', type: 'text/markdown', file: liveFile('notes.md', '# hi', 'text/markdown') })];
+    expect((await readTextAttachments(live)).map((f) => f.content)).toEqual(['# hi']);
+
+    const replay = replayed(await prepareQueuedAttachments(live));
+    expect(replay[0].file).toBeUndefined();
+    expect(replay[0].content).toBe('# hi');
+    expect((await readTextAttachments(replay)).map((f) => f.content)).toEqual(['# hi']);
+  });
+
+  test('a replay without a persisted copy is flagged, not silently dropped', async () => {
+    // It used to be filtered out, which sent a prompt naming a file whose
+    // contents never arrived — with nothing in the UI to say so.
+    const files = await readTextAttachments([
+      { id: 't', name: 'notes.md', type: 'text/markdown', preview: '' },
+    ]);
+    expect(files.map((f) => ({ name: f.name, missing: f.missing, content: f.content }))).toEqual([
+      { name: 'notes.md', missing: true, content: '' },
+    ]);
+  });
+
+  test('carry their attachment id so the caller can map them back', async () => {
+    const files = await readTextAttachments([
+      { id: 'keep', name: 'a.md', type: 'text/markdown', preview: '', content: 'a' },
+      { id: 'drop', name: 'b.bin', type: 'application/octet-stream', preview: '', content: 'b' },
+    ]);
+    expect(files.map((f) => f.id)).toEqual(['keep']);
+  });
+
+  test('are fenced with a language that matches the file', () => {
+    const py = [{ name: 'script.py', mimeType: 'text/x-python', content: 'x=1', size: 3 }];
+    expect(composeMessageWithTextAttachments('go', py)).toContain('```python');
+  });
+});
+
+describe('inline budget', () => {
+  test('counts replayed attachments, so repeated drops stop at the cap', () => {
+    const existing = Array.from({ length: 10 }, (_, i) => ({ name: `f${i}.md`, type: 'text/markdown', size: 10, content: 'x' }));
+    const { accepted, skipped } = applyTextAttachmentBudget([liveFile('extra.md', 'x', 'text/markdown')], existing);
+    expect(accepted).toEqual([]);
+    expect(skipped.map((f) => f.name)).toEqual(['extra.md']);
+  });
+
+  test('lets an image through when the text budget is spent', () => {
+    const existing = Array.from({ length: 10 }, (_, i) => ({ name: `f${i}.md`, type: 'text/markdown', size: 10, content: 'x' }));
+    const { accepted, skipped } = applyTextAttachmentBudget([liveFile('shot.png', 'x', 'image/png')], existing);
+    expect(accepted.map((f) => f.name)).toEqual(['shot.png']);
+    expect(skipped).toEqual([]);
+  });
+});
+
+describe('content sniffing for unclassified files', () => {
+  test('a file whose name and MIME say nothing is recognised as text', async () => {
+    // A promised-file drag from another app arrives like this: real bytes, a
+    // generic name, no usable type. Deciding from metadata alone left it
+    // attached but never inlined.
+    expect(await looksLikeTextFile(liveFile('document', 'IMPORTANT\ncode: ABC'))).toBe(true);
+    expect(await looksLikeTextFile(liveFile('file', '# Title\n\nBody'))).toBe(true);
+  });
+
+  test('binary content is refused', async () => {
+    const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    expect(await looksLikeTextFile(new File([png], 'download'))).toBe(false);
+    // A NUL byte is decisive: no text encoding this app handles contains one.
+    expect(await looksLikeTextFile(new File([new Uint8Array([65, 66, 0, 67])], 'blob'))).toBe(false);
+  });
+
+  test('an empty file is not treated as text', async () => {
+    expect(await looksLikeTextFile(liveFile('empty', ''))).toBe(false);
+  });
+
+  test('a sniffed attachment keeps its content through the read path', async () => {
+    // The sniffer's verdict is recorded on the attachment at attach time, so the
+    // send path must honour it even though the name still says nothing — and a
+    // bare `content` string must NOT be enough to smuggle a binary through.
+    const sniffed: Attachment = {
+      id: 'x',
+      name: 'document',
+      type: '',
+      size: 20,
+      preview: '',
+      content: 'IMPORTANT\ncode: ABC',
+      sniffedText: true,
+    };
+    const read = await readTextAttachments([sniffed]);
+    expect(read.map((f) => ({ name: f.name, content: f.content }))).toEqual([
+      { name: 'document', content: 'IMPORTANT\ncode: ABC' },
+    ]);
+  });
+});

package/src/shared/lib/chat/attachments.ts

@@ -4,22 +4,32 @@
  */
 
 /**
- * Text-file attachment composition for the chat composer. Faithful port of
- * omp-web/lib/chat-attachments.ts: text files are inlined into the prompt as
- * fenced blocks so the model sees their full content.
+ * Attachment metadata and prompt composition for the chat composer.
+ *
+ * Two representations of the same attachment exist and the difference is the
+ * whole reason this module exists:
+ *
+ * - A LIVE attachment (just picked/pasted/dropped) carries `file: File`, so its
+ *   bytes are readable.
+ * - A REPLAYED attachment comes from the `queued_messages` row or from committed
+ *   history. `File` does not survive either trip (`JSON.stringify(new File(…))`
+ *   is `{}`), so only `name`/`type`/`size`/`preview`/`dataBase64`/`content`
+ *   remain.
+ *
+ * Every read of an attachment's metadata therefore goes through the accessors
+ * below, which read the display fields and fall back to the live `File` — never
+ * `a.file.name`, which throws on a replayed attachment and is what used to break
+ * queued delivery and retry.
  */
 
+import type { AgentImage, Attachment } from '@/shared/types';
+import { TEXT_FILE_EXTENSIONS, isTextMimeType } from '@/shared/lib/chat/text-file';
+
+export { looksLikeTextFile } from '@/shared/lib/chat/text-file';
+
 export const MAX_ATTACHED_TEXT_BYTES = 256 * 1024;
 export const MAX_ATTACHED_TEXT_FILES = 10;
 
-const TEXT_FILE_EXTENSIONS: Record<string, true> = {
-  txt: true,
-  text: true,
-  md: true,
-  markdown: true,
-  mdx: true,
-};
-
 export interface AttachedTextFileData {
   name: string;
   mimeType: string;
@@ -27,19 +37,125 @@ export interface AttachedTextFileData {
   size: number;
 }
 
+/** An inlined text file plus the id of the attachment it came from. */
+export interface ReadTextAttachment extends AttachedTextFileData {
+  id: string;
+  /** True when no bytes could be read — the file is named but not carried. */
+  missing?: boolean;
+}
+
 function getFileExtension(name: string): string {
   return name.toLowerCase().replace(/\\/g, '/').split('/').pop()?.split('.').pop() ?? '';
 }
 
-export function isTextAttachmentFile(file: Pick<File, 'name' | 'type'>): boolean {
-  return file.type === 'text/plain'
-    || file.type === 'text/markdown'
-    || TEXT_FILE_EXTENSIONS[getFileExtension(file.name)] === true;
+/** Attachment display name, live file first, persisted name second. */
+export function attachmentName(att: Pick<Attachment, 'name' | 'file'>): string {
+  return att.name ?? att.file?.name ?? 'attachment';
+}
+
+/** Attachment MIME type, live file first, persisted type second. */
+export function attachmentType(att: Pick<Attachment, 'type' | 'file'>): string {
+  return att.type ?? att.file?.type ?? '';
+}
+
+/** Attachment byte size, live file first, persisted size second. */
+export function attachmentSize(att: Pick<Attachment, 'size' | 'file'>): number {
+  return att.file?.size ?? att.size ?? 0;
+}
+
+/** Whether this attachment's contents can be inlined into the prompt. */
+export function isTextAttachment(att: Pick<Attachment, 'name' | 'type' | 'file'>): boolean {
+  const type = attachmentType(att);
+  if (isTextMimeType(type)) return true;
+  // An image is never inlined, whatever its extension claims.
+  if (type.startsWith('image/')) return false;
+  return TEXT_FILE_EXTENSIONS[getFileExtension(attachmentName(att))] === true;
+}
+
+/** Whether this attachment is an image the model can receive. */
+export function isImageAttachment(att: Pick<Attachment, 'name' | 'type' | 'file'>): boolean {
+  return attachmentType(att).startsWith('image/');
+}
+
+/** Base64 image payload for the omp RPC, or null when there is nothing to send. */
+export function attachmentImage(
+  att: Pick<Attachment, 'type' | 'file' | 'dataBase64'>,
+): AgentImage | null {
+  if (!att.dataBase64 || !isImageAttachment(att)) return null;
+  return {
+    type: 'image',
+    data: att.dataBase64,
+    // A persisted attachment carries the authoritative type; the fallback keeps
+    // a provider from rejecting a payload whose type the browser left empty.
+    mimeType: attachmentType(att) || 'image/png',
+  };
+}
+
+export interface AttachmentBudget {
+  /** Files that fit the inline budget and may be attached. */
+  accepted: File[];
+  /** Text files refused because the budget was already spent. */
+  skipped: File[];
+}
+
+/** User-facing reason for a refusal, shared by every composer attach path. */
+export function describeAttachmentBudget(skipped: File[]): string {
+  const limit = `${MAX_ATTACHED_TEXT_FILES} text files / ${Math.round(MAX_ATTACHED_TEXT_BYTES / 1024)} KB total`;
+  if (skipped.length === 1) return `"${skipped[0].name}" was not attached — inline limit is ${limit}.`;
+  return `${skipped.length} text files were not attached — inline limit is ${limit}.`;
+}
+
+/**
+ * Gate a batch of incoming files against the text-inline budget.
+ *
+ * Only text files are gated: their contents are inlined into the prompt, so a
+ * directory drop can otherwise push megabytes into a single request. Images and
+ * other binaries travel as payloads and are capped by the caller's own limit.
+ *
+ * The budget spans the whole composer, not the batch — `existing` counts too,
+ * so three successive drops of four text files stop at ten.
+ */
+export function applyTextAttachmentBudget(
+  files: File[],
+  existing: { name?: string; type?: string; size?: number; file?: File }[],
+): AttachmentBudget {
+  const accepted: File[] = [];
+  const skipped: File[] = [];
+  let textFiles = existing.filter((a) => isTextAttachment(a)).length;
+  let textBytes = existing.reduce((total, a) => (isTextAttachment(a) ? attachmentSize(a) : total), 0);
+
+  for (const file of files) {
+    if (!isTextAttachment({ name: file.name, type: file.type, file })) {
+      accepted.push(file);
+      continue;
+    }
+    if (textFiles >= MAX_ATTACHED_TEXT_FILES || textBytes + file.size > MAX_ATTACHED_TEXT_BYTES) {
+      skipped.push(file);
+      continue;
+    }
+    textFiles += 1;
+    textBytes += file.size;
+    accepted.push(file);
+  }
+
+  return { accepted, skipped };
 }
 
 function languageForFile(name: string): string {
   const extension = getFileExtension(name);
   if (extension === 'md' || extension === 'markdown' || extension === 'mdx') return 'markdown';
+  if (extension === 'json' || extension === 'jsonc') return 'json';
+  if (extension === 'yaml' || extension === 'yml') return 'yaml';
+  if (extension === 'ts' || extension === 'tsx' || extension === 'mts' || extension === 'cts') return 'typescript';
+  if (extension === 'js' || extension === 'jsx' || extension === 'mjs' || extension === 'cjs') return 'javascript';
+  if (extension === 'py') return 'python';
+  if (extension === 'sh' || extension === 'bash' || extension === 'zsh') return 'bash';
+  if (extension === 'rs') return 'rust';
+  if (extension === 'go') return 'go';
+  if (extension === 'sql') return 'sql';
+  if (extension === 'html' || extension === 'htm') return 'html';
+  if (extension === 'css') return 'css';
+  if (extension === 'xml') return 'xml';
   return 'text';
 }
 
@@ -60,3 +176,72 @@ export function composeMessageWithTextAttachments(
   });
   return [message.trim(), ...blocks].filter(Boolean).join('\n\n');
 }
+
+/**
+ * Snapshot attachments for storage in the queue row, where a `File` cannot
+ * survive. Reads text contents while the live handle still exists, so delivery
+ * can inline them, and keeps every display field the chip renderer needs.
+ */
+export async function prepareQueuedAttachments(attachments: Attachment[]): Promise<Attachment[]> {
+  const textFiles = await readTextAttachments(attachments);
+  const contentById = new Map(textFiles.map((file) => [file.id, file.content]));
+  return attachments.map((att) => ({
+    id: att.id,
+    name: attachmentName(att),
+    type: attachmentType(att),
+    size: attachmentSize(att),
+    // The blob URL dies with the page; the data URL survives in the row.
+    preview: att.dataBase64 ? `data:${attachmentType(att)};base64,${att.dataBase64}` : att.preview,
+    ...(att.dataBase64 ? { dataBase64: att.dataBase64 } : {}),
+    ...(contentById.has(att.id) ? { content: contentById.get(att.id) } : {}),
+    ...(att.sniffedText ? { sniffedText: true } : {}),
+  }));
+}
+
+/**
+ * The inline-able text files of a batch, reading live `File` bytes where
+ * present and persisted `content` otherwise. Returns [] when nothing qualifies.
+ *
+ * Each entry carries the source attachment's `id`, so the caller can map a file
+ * back to the attachment it came from without re-deriving the filter.
+ *
+ * An attachment with NO readable bytes is returned with `missing: true` rather
+ * than dropped: silently omitting it sent a prompt that named a file the model
+ * never received, with nothing in the UI to say so. The caller decides whether
+ * to warn or to send anyway.
+ */
+export async function readTextAttachments(
+  attachments: Attachment[],
+): Promise<ReadTextAttachment[]> {
+  // An attachment that already carries `content` was read at attach time — for
+  // an unclassified file that read only happened because the sniffer cleared it.
+  // Anything else must still classify from metadata, so a binary that happens to
+  // have a stray `content` string cannot smuggle itself into the prompt.
+  const textAttachments = attachments.filter((a) => isTextAttachment(a) || a.sniffedText === true);
+  const contents = await Promise.all(
+    textAttachments.map(async (att): Promise<{ content: string | null; missing: boolean }> => {
+      // The persisted copy wins: it was read at attach time through
+      // `FileReader`, which is the read that waits for another app's file to
+      // materialize. Re-reading the live handle here is what returned an empty
+      // body for a file whose bytes had already been captured.
+      if (typeof att.content === 'string') return { content: att.content, missing: false };
+      if (att.file) {
+        try {
+          return { content: await att.file.text(), missing: false };
+        } catch {
+          // Fall through to the persisted copy, if any.
+        }
+      }
+      if (typeof att.content === 'string') return { content: att.content, missing: false };
+      return { content: null, missing: true };
+    }),
+  );
+  return textAttachments.map((att, index) => ({
+    id: att.id,
+    name: attachmentName(att),
+    mimeType: attachmentType(att),
+    content: contents[index].content ?? '',
+    size: attachmentSize(att),
+    missing: contents[index].missing,
+  }));
+}

package/src/shared/lib/chat/btw/client.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Client for a session's BTW API: the frame stream, plus the commands that
+ * create, continue, cancel and promote a side question.
+ *
+ * The stream reuses the generic JSON connectors the agent stream introduced
+ * (they are transport-only: URL in, decoded frames out), so a session's side
+ * questions follow the same transport setting — WebSocket by default, SSE
+ * where the upgrade is blocked — instead of forking a third stream flavour.
+ */
+
+import type { AgentImage, BtwFrame, BtwState, StreamTransport } from '@/shared/types';
+import { connectEvents } from '@/shared/lib/chat/omp/sse';
+import { connectSocket } from '@/shared/lib/chat/omp/socket';
+import { btwEventsUrl, btwSocketUrl } from '@/shared/lib/chat/omp/transport';
+import type { StreamConnection, StreamHandlers } from '@/shared/lib/chat/omp/transport';
+
+export type BtwStreamHandlers = StreamHandlers<BtwFrame>;
+
+/** A rejected command, carrying the server's machine-readable reason. */
+export class BtwRequestError extends Error {
+  readonly code?: string;
+
+  constructor(message: string, code?: string) {
+    super(message);
+    this.name = 'BtwRequestError';
+    this.code = code;
+  }
+}
+
+export function connectBtwStream(
+  sessionId: string,
+  transport: StreamTransport,
+  handlers: BtwStreamHandlers,
+): StreamConnection {
+  return transport === 'sse' ? connectEvents(btwEventsUrl(sessionId), handlers) : connectSocket(btwSocketUrl(sessionId), handlers);
+}
+
+interface BtwResponseBody {
+  success?: boolean;
+  data?: unknown;
+  error?: string;
+  code?: string;
+}
+
+async function requestBtw<T>(sessionId: string, method: 'GET' | 'POST', body?: Record<string, unknown>): Promise<T> {
+  const response = await fetch(`/api/btw/${encodeURIComponent(sessionId)}`, {
+    method,
+    ...(body
+      ? { headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }
+      : {}),
+  });
+  const payload = (await response.json().catch(() => null)) as BtwResponseBody | null;
+  if (!response.ok || !payload?.success) {
+    throw new BtwRequestError(payload?.error ?? `Side question request failed (${response.status})`, payload?.code);
+  }
+  return payload.data as T;
+}
+
+/** The session's side questions as the server sees them. */
+export function fetchBtwState(sessionId: string): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'GET');
+}
+
+export interface AskBtwInput {
+  topicId?: string;
+  question: string;
+  images?: AgentImage[];
+}
+
+export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'POST', {
+    action: 'ask',
+    question: input.question,
+    ...(input.topicId ? { topicId: input.topicId } : {}),
+    ...(input.images?.length ? { images: input.images } : {}),
+  });
+}
+
+export function abortBtwQuestion(sessionId: string, topicId: string): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'POST', { action: 'abort', topicId });
+}
+
+export function promoteBtwTopic(sessionId: string, topicId: string): Promise<{ sessionId: string }> {
+  return requestBtw<{ sessionId: string }>(sessionId, 'POST', { action: 'promote', topicId });
+}
+
+export function deleteBtwTopic(sessionId: string, topicId: string): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'POST', { action: 'delete', topicId });
+}

package/src/shared/lib/chat/composer/client.test.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The popup's command pool has two sources with different owners: omp's
+ * `get_available_commands` and the chamber's own commands. `/btw` exists only
+ * in the second — omp's registry entry for it is TUI-only, so RPC never
+ * advertises it — and the composer intercepts the token on send. If the entry
+ * ever disappears, the popup offers every command except the one being typed,
+ * and the user is left guessing why `/btw` matches nothing but `browser` by
+ * description.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { CommandItem } from '@/shared/types';
+import { mergeCommandAndSkillItems } from '@/shared/lib/chat/composer/client';
+
+function command(over: Partial<CommandItem> & { name: string }): CommandItem {
+  return {
+    id: `cmd-${over.name}`,
+    description: '',
+    scope: 'system',
+    template: '',
+    ...over,
+  };
+}
+
+describe('mergeCommandAndSkillItems', () => {
+  test('offers the chamber-owned /btw with omp metadata', () => {
+    const items = mergeCommandAndSkillItems([command({ name: 'model', description: 'Show current model selection' })], []);
+
+    const btw = items.find((item) => item.name === 'btw');
+    expect(btw).toBeDefined();
+    expect(btw?.token).toBe('/btw');
+    expect(btw?.kind).toBe('command');
+    // The hint is folded into the description exactly as the popup renders it.
+    expect(btw?.description).toBe("[question] - Ask a side question, or browse this session's BTW history");
+  });
+
+  test('keeps the chamber entry when omp advertises the same name', () => {
+    const items = mergeCommandAndSkillItems([command({ name: 'btw', description: 'something else entirely' })], []);
+
+    const matching = items.filter((item) => item.name === 'btw');
+    expect(matching.length).toBe(1);
+    expect(matching[0].description).toContain('Ask a side question');
+  });
+});

package/src/shared/lib/chat/composer/client.ts

@@ -1,4 +1,5 @@
 import type { AgentItem, CommandItem, ComposerPickItem, ComposerPickKind, FsFileEntry, SkillItem } from '@/shared/types';
+import { CHAMBER_COMMANDS } from '@/shared/lib/chat/composer/trigger';
 
 const CACHE_TTL_MS = 300_000;
 
@@ -61,6 +62,10 @@ export function toFilePickItems(files: FsFileEntry[]): ComposerPickItem[] {
  * `skill:`-namespaced name a command already covers is skipped, so the two
  * sources never double-list the same skill.
  *
+ * The chamber's own commands (`CHAMBER_COMMANDS`) lead, so a same-named entry
+ * from omp can never advertise behavior the composer overrides on send — `/btw`
+ * is reserved by omp in the TUI for the same reason.
+ *
  * The description carries the argument hint exactly as oh-my-pi renders it
  * (`[on|off|status] - Toggle fast mode`) so the popup matches the CLI.
  */
@@ -68,7 +73,7 @@ export function mergeCommandAndSkillItems(commands: CommandItem[], skills: Skill
   const result: ComposerPickItem[] = [];
   const seen = new Set<string>();
 
-  for (const command of commands) {
+  for (const command of [...CHAMBER_COMMANDS, ...commands]) {
     const key = command.name.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);

package/src/shared/lib/chat/composer/composer.test.ts

@@ -14,8 +14,9 @@
 import { describe, expect, test } from 'bun:test';
 
 import type { ComposerPickItem } from '@/shared/types';
-import { detectComposerTrigger, insertToken, tokenForItem } from '@/shared/lib/chat/composer/trigger';
+import { detectComposerTrigger, insertToken, sendInsteadOfAccept, tokenForItem } from '@/shared/lib/chat/composer/trigger';
 import { filterComposerItems } from '@/shared/lib/chat/composer/filter';
+import { mergeCommandAndSkillItems } from '@/shared/lib/chat/composer/client';
 
 function item(over: Partial<ComposerPickItem> & { name: string }): ComposerPickItem {
   const isSkill = over.name.startsWith('skill:');
@@ -155,3 +156,40 @@ describe('composer slash trigger', () => {
     expect(detectComposerTrigger('foo@bar', 7)).toBeNull();
   });
 });
+
+describe('composer Enter on a complete command', () => {
+  /** The real popup pool: omp's commands plus the chamber's own. */
+  const CHAMBER_POOL: ComposerPickItem[] = mergeCommandAndSkillItems(
+    [{ id: 'c-model', name: 'model', description: 'Show current model selection', scope: 'system', template: '' }],
+    [],
+  );
+
+  /** Does Enter send here, or does the popup accept the highlighted item? */
+  const enterSends = (text: string): boolean => {
+    const trigger = detectComposerTrigger(text, text.length);
+    if (!trigger) throw new Error(`no trigger for ${text}`);
+    const [highlighted] = filterComposerItems(CHAMBER_POOL, trigger);
+    return sendInsteadOfAccept(trigger, highlighted);
+  };
+
+  test('the chamber-owned /btw sends, so Enter reaches the side-question form', () => {
+    expect(enterSends('/btw')).toBe(true);
+    expect(enterSends('/BTW')).toBe(true);
+  });
+
+  test('a command omp owns still accepts, however complete it looks', () => {
+    // `/model` takes no subcommands, but the chamber does not intercept it:
+    // accepting is what the CLI does, and it must stay that way.
+    expect(enterSends('/model')).toBe(false);
+    expect(enterSends('/mo')).toBe(false);
+  });
+
+  test('a command with subcommands still opens its arguments', () => {
+    expect(enterSends('/fast')).toBe(false);
+  });
+
+  test('arguments and mentions never yield Enter', () => {
+    expect(enterSends('/fast o')).toBe(false);
+    expect(enterSends('@sonic')).toBe(false);
+  });
+});