ompchamber 1.0.0 → 1.2.0

package/src/shared/lib/models/provider-models.ts

@@ -63,6 +63,14 @@ export function mergeProviderModels(
   return { merged: [...existing, ...added], added, addedCount: added.length };
 }
 
+/**
+ * Register newly added provider models on the chamber's catalog.
+ *
+ * `isFavorite` is deliberately NOT sent: the picker derives favorites from the
+ * stored preference keys, so a catalog flag would be a second, silently
+ * ignored source of truth for the FAVORITES rail. A new provider's models are
+ * starred by the user, not by this sync.
+ */
 export async function syncProviderModelsToCatalog(
   providerName: string,
   models: ProviderModel[],
@@ -81,7 +89,6 @@ export async function syncProviderModelsToCatalog(
               provider: providerName,
               contextWindow: model.contextWindow?.split(' ')[0] || '128K',
               thinkingLevel: 'Default',
-              isFavorite: true,
               capabilities: ['Tool calling', 'Reasoning'],
               inputFormats: ['text'],
               outputFormats: ['text'],

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/lib/omp/subagent/label.test.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers the boundaries of the subagent label derivation: the Target-section
+ * scan (heading level, colon variant, section end) and the two identity shapes.
+ *
+ * These are the cases where the label is derived from prompt text the caller
+ * controls, so a wrong boundary silently renders template boilerplate or a
+ * section name where the assignment's headline belongs.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { assignmentTarget, subagentHeaderTitle, subagentRowLabel } from '@/shared/lib/omp/subagent/label';
+import type { SubagentInfo } from '@/shared/types/omp/subagent';
+
+/** Minimal roster entry — only the fields the label helpers read. */
+function makeSubagent(overrides: Partial<SubagentInfo> = {}): SubagentInfo {
+  return { id: 'Scout', agent: 'task', status: 'completed', index: 0, ...overrides };
+}
+
+describe('assignmentTarget', () => {
+  test('reads the headline under the task template Target section', () => {
+    const task = 'Complete assignment thoroughly:\n\n# Target\nCount .tsx files under src/.\n\n# Change\nNone.\n\n# Acceptance\nReport the integer.';
+    expect(assignmentTarget(task)).toBe('Count .tsx files under src/.');
+  });
+
+  test('stops at the next heading so Change prose never becomes the headline', () => {
+    const task = '# Target\nMap the panel data model.\n\n# Change\nDo the thing';
+    expect(assignmentTarget(task)).toBe('Map the panel data model.');
+  });
+
+  test('accepts any heading level and a trailing colon', () => {
+    expect(assignmentTarget('## Target:\nHeadline here')).toBe('Headline here');
+    expect(assignmentTarget('### Target\nHeadline here')).toBe('Headline here');
+  });
+
+  test('skips an empty Target section instead of promoting the next section', () => {
+    expect(assignmentTarget('# Target\n\n# Change\nDo the thing')).toBe('Do the thing');
+  });
+
+  test('falls back to the first prose line when no Target section exists', () => {
+    expect(assignmentTarget('Fix the sidebar expand bug')).toBe('Fix the sidebar expand bug');
+    expect(assignmentTarget('# Scope\nNot a target section')).toBe('Not a target section');
+  });
+
+  test('never returns the template lead-in or a bare heading', () => {
+    expect(assignmentTarget('Complete assignment thoroughly:')).toBeUndefined();
+    expect(assignmentTarget('# Target')).toBeUndefined();
+  });
+
+  test('returns undefined for absent or empty text', () => {
+    expect(assignmentTarget(undefined)).toBeUndefined();
+    expect(assignmentTarget('   \n\n  ')).toBeUndefined();
+  });
+});
+
+describe('subagentHeaderTitle', () => {
+  test('appends the model role recorded on a history entry', () => {
+    expect(subagentHeaderTitle(makeSubagent({ modelRole: 'smol' }))).toBe('Scout (task:smol)');
+  });
+
+  test('falls back to the role carried by a live progress frame', () => {
+    expect(subagentHeaderTitle(makeSubagent({ progress: { modelRole: 'task' } }))).toBe('Scout (task:task)');
+  });
+
+  test('omits the role when the run recorded none', () => {
+    expect(subagentHeaderTitle(makeSubagent())).toBe('Scout (task)');
+  });
+});
+
+describe('subagentRowLabel', () => {
+  test('appends the assignment headline to the identity', () => {
+    const subagent = makeSubagent({ task: 'Complete assignment thoroughly:\n\n# Target\nHeadline here.\n\n# Change\nx' });
+    expect(subagentRowLabel(subagent)).toBe('Scout (task): Headline here.');
+  });
+
+  test('reads the assignment field when the task template is absent', () => {
+    expect(subagentRowLabel(makeSubagent({ assignment: '# Target\nFrom the assignment field.' })))
+      .toBe('Scout (task): From the assignment field.');
+  });
+
+  test('falls back to the description, then to the bare identity', () => {
+    expect(subagentRowLabel(makeSubagent({ description: 'fallback description' }))).toBe('Scout (task): fallback description');
+    expect(subagentRowLabel(makeSubagent())).toBe('Scout (task)');
+  });
+
+  test('keeps the identity when the assignment has no usable headline', () => {
+    expect(subagentRowLabel(makeSubagent({ task: '# Target' }))).toBe('Scout (task)');
+  });
+});

package/src/shared/lib/omp/subagent/label.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * One-line labels for a subagent roster entry.
+ *
+ * A delegated assignment is a task prompt, not a sentence. The wire carries it
+ * twice: `assignment` is the document the caller wrote, and `task` is that same
+ * document wrapped by the task tool's template ("Complete assignment
+ * thoroughly:" followed by `# Target` / `# Change` / `# Acceptance` sections).
+ * Rendering either verbatim in a 268px sidebar row would spend the whole row on
+ * the template's lead-in, so a row shows the Target section's headline — the
+ * one line that says what the agent is for.
+ *
+ * The two surfaces differ only in what they append to the identity:
+ *   roster row  →  `id (agent): target`
+ *   banner      →  `id (agent:modelRole)`
+ */
+
+import type { SubagentInfo } from '@/shared/types/omp/subagent';
+
+/** Any markdown heading — the boundary between prompt sections. */
+const HEADING_RE = /^#{1,6}\s+\S/;
+/** The section the task prompt template mandates as the assignment's summary. */
+const TARGET_HEADING_RE = /^#{1,6}\s+target\s*:?\s*$/i;
+/** The task template's own lead-in; it says nothing about the assignment. */
+const LEAD_IN_RE = /^complete (the )?assignment\b/i;
+
+/** First line of `lines` that has content, trimmed. */
+function firstLine(lines: string[]): string | undefined {
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+/**
+ * The headline of a delegated assignment: the first line of its `# Target`
+ * section, falling back to the prompt's own first prose line when there is no
+ * such section (or it is empty).
+ */
+export function assignmentTarget(text: string | undefined): string | undefined {
+  if (!text) return undefined;
+  const lines = text.split('\n');
+  const headingAt = lines.findIndex((line) => TARGET_HEADING_RE.test(line.trim()));
+  if (headingAt !== -1) {
+    // Bounded by the next heading: an empty Target section must not promote the
+    // Change/Acceptance prose that follows it into the headline.
+    const body = lines.slice(headingAt + 1);
+    const nextHeading = body.findIndex((line) => HEADING_RE.test(line.trim()));
+    const headline = firstLine(nextHeading === -1 ? body : body.slice(0, nextHeading));
+    if (headline) return headline;
+  }
+  // No Target section, or an empty one: the prompt's first prose line. Headings
+  // are skipped because a section name is not a summary of the assignment.
+  return firstLine(lines.filter((line) => {
+    const trimmed = line.trim();
+    return !HEADING_RE.test(trimmed) && !LEAD_IN_RE.test(trimmed);
+  }));
+}
+
+/** `id (agent:modelRole)`, or `id (agent)` when no role was recorded. Live
+ *  snapshots carry the role on `progress`; history entries carry it top-level,
+ *  because the on-disk fold records it from the parent's task toolResult rather
+ *  than from a progress frame. */
+export function subagentHeaderTitle(subagent: SubagentInfo): string {
+  const role = subagent.modelRole ?? subagent.progress?.modelRole;
+  return role
+    ? `${subagent.id} (${subagent.agent}:${role})`
+    : `${subagent.id} (${subagent.agent})`;
+}
+
+/** `id (agent): target` — the roster row's one-line label. The description is
+ *  the fallback for entries whose assignment text never reached the roster. */
+export function subagentRowLabel(subagent: SubagentInfo): string {
+  const target = assignmentTarget(subagent.task)
+    ?? assignmentTarget(subagent.assignment)
+    ?? subagent.description;
+  const identity = `${subagent.id} (${subagent.agent})`;
+  return target ? `${identity}: ${target}` : identity;
+}