ompchamber 0.3.0

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

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * LIVE-path adapter: omp agent event/message stream → chamber ChatMessageData.
+ * All content-block parsing is delegated to the shared core parser
+ * (parse-message-blocks.ts); this module only handles what is genuinely
+ * SSE-specific: streaming tool status, incremental output pairing, notice
+ * frames, and chamber display timestamps. The JSONL reload path uses the same
+ * core via messages-parse.ts — behavior parity is enforced by construction.
+ */
+
+import type { ChatMessageData, ToolCallData } from '@/shared/types';
+import { extractText, extractUserImageAttachments, parseMessageBlocks, stripInlinedTextAttachments, toToolCallData } from '@/shared/lib/omp/session/parse-message-blocks';
+import { deriveTurnError } from '@/shared/lib/omp/session/turn-error';
+import { formatClock } from '@/shared/lib/format/time';
+import { toEpochMs } from '@/shared/lib/omp/session/timestamps';
+
+/** Extract plain text from omp content (string or [{type:'text',text},...]). */
+export function extractTextFromContent(content: unknown): string {
+  return extractText(content);
+}
+
+/** Tool events carry result/partialResult as a string or as an omp content
+ *  block ({content:[{type:'text',text}]}) — normalize both to plain text. */
+export function toolResultText(value: unknown): string {
+  if (typeof value === 'string') return value;
+  if (value && typeof value === 'object') {
+    const content = (value as { content?: unknown }).content;
+    return extractText(content);
+  }
+  return '';
+}
+
+/** Convert an omp AgentMessage (content blocks) into the chamber ChatMessageData shape.
+ *  Custom-role frames (ultrathink-notice, xdev-mount-notice, ...) become a
+ *  `notice` row — omp marks them display:false, so they render as an alert,
+ *  never as assistant content. */
+export function toChatMessage(raw: Record<string, unknown>, streaming = true): ChatMessageData | null {
+  if (raw.role === 'custom') {
+    if (raw.customType === 'session_exit') return null; // runtime plumbing, not user-visible
+    const content = raw.content;
+    const text = typeof content === 'string'
+      ? content
+      : Array.isArray(content)
+        ? content
+            .map((b) => (b && typeof b === 'object' && (b as { type?: unknown }).type === 'text' ? (b as { text?: unknown }).text ?? '' : ''))
+            .join('')
+        : '';
+    const notice = text.replace(/<\/?system-notice[^>]*>/g, '').trim();
+    if (!notice) return null;
+    return {
+      id: typeof raw.id === 'string' ? raw.id : `notice-${Date.now()}`,
+      role: 'ai',
+      content: '',
+      notice,
+    };
+  }
+
+  const parsed = parseMessageBlocks(raw.content);
+  const id = typeof raw.id === 'string' ? raw.id : `msg-${raw.timestamp ?? Date.now()}-ai`;
+  const role = raw.role === 'user' ? 'user' : 'ai';
+  const timestamp = typeof raw.timestamp === 'number'
+    ? formatClock(raw.timestamp)
+    : undefined;
+  const attribution = typeof raw.attribution === 'string' ? raw.attribution : undefined;
+  const startedAt = toEpochMs(raw.timestamp) ?? toEpochMs(raw.startedAt);
+  const durationMs = typeof raw.duration === 'number' ? raw.duration : typeof raw.durationMs === 'number' ? raw.durationMs : undefined;
+  const completedAt = toEpochMs(raw.completedAt)
+    ?? (startedAt !== undefined && durationMs !== undefined ? startedAt + durationMs : undefined);
+  const provider = typeof raw.provider === 'string' ? raw.provider : undefined;
+
+  if (raw.role === 'developer' || raw.role === 'system' || parsed.textParts.some((t) => /<\/?system-reminder[^>]*>/i.test(t))) {
+    const rawText = parsed.textParts.join('\n').trim();
+    const notice = rawText.replace(/<\/?system-reminder[^>]*>/g, '').trim();
+    if (!notice) return null;
+    return {
+      id,
+      role: 'ai',
+      date: timestamp ? `Today, ${timestamp}` : undefined,
+      timestamp,
+      content: '',
+      notice,
+    };
+  }
+
+  if (role === 'user') {
+    const text = stripInlinedTextAttachments(parsed.textParts.join('\n'));
+    const attachments = extractUserImageAttachments(raw.content);
+    return {
+      id,
+      role,
+      date: timestamp ? `Today, ${timestamp}` : undefined,
+      timestamp,
+      startedAt,
+      content: text,
+      attribution,
+      attachments: attachments.map((a) => ({ id: a.id, name: a.name, preview: a.preview, type: a.type })),
+    };
+  }
+
+  const toolCalls: ToolCallData[] = parsed.toolCalls.map((tc) =>
+    toToolCallData(tc, { streaming }),
+  );
+  const message: ChatMessageData = {
+    id,
+    role,
+    date: timestamp ? `Today, ${timestamp}` : undefined,
+    timestamp,
+    attribution,
+    model: typeof raw.model === 'string' ? raw.model : undefined,
+    provider,
+    startedAt,
+    completedAt,
+    durationMs,
+    usage: (raw.usage && typeof raw.usage === 'object') ? (raw.usage as ChatMessageData['usage']) : undefined,
+    content: parsed.textParts.join('\n'),
+    intent: parsed.intent,
+    thinking: parsed.thinking
+      ? { thought: parsed.thinking, isGenerating: streaming }
+      : (raw.thinking as ChatMessageData['thinking']),
+    toolCalls: toolCalls.length > 0 ? toolCalls : (raw.toolCalls as ChatMessageData['toolCalls']),
+    summary: typeof raw.summary === 'string' ? raw.summary : undefined,
+    // Aborted/errored turns carry no nested `error` — omp writes flat
+    // stopReason/errorMessage fields. Derive them so the turn survives the
+    // empty-content guard below and renders live instead of only after reload.
+    error: (raw.error as ChatMessageData['error']) ?? deriveTurnError(raw),
+  };
+
+  if (
+    !message.content &&
+    !message.thinking &&
+    (!message.toolCalls || message.toolCalls.length === 0) &&
+    !message.intent &&
+    !message.error &&
+    !message.summary &&
+    !message.notice
+  ) {
+    return null;
+  }
+
+  return message;
+}

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

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { ChatMessageData } from '@/shared/types/chat';
+import { extractText, extractUserImageAttachments, parseAssistantContent, resultOutput, roleFor, stripInlinedTextAttachments, type OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
+import { isRecord } from '@/shared/lib/util/guards';
+import { deriveTurnError } from '@/shared/lib/omp/session/turn-error';
+import { toEpochMs } from '@/shared/lib/omp/session/timestamps';
+
+/** Map a raw omp JSONL entry of type "message" to the chamber shape. */
+export function toChatMessage(entry: OmpMessageEntry): ChatMessageData | null {
+  const msg = entry.message;
+  if (!msg) return null;
+  const role = msg.role ?? '';
+  const content = msg.content;
+  const attribution = typeof msg.attribution === 'string'
+    ? msg.attribution
+    : typeof entry.attribution === 'string'
+      ? entry.attribution
+      : undefined;
+
+  const base: ChatMessageData = {
+    id: entry.id ?? `msg-${entry.timestamp ?? Date.now()}`,
+    role: roleFor(role),
+    content: '',
+    date: entry.timestamp ? new Date(entry.timestamp).toISOString() : undefined,
+    startedAt: toEpochMs(msg.timestamp) ?? toEpochMs(entry.timestamp),
+    attribution,
+  };
+
+  if (role === 'user') {
+    const text = stripInlinedTextAttachments(extractText(content));
+    const attachments = extractUserImageAttachments(content);
+    if (!text.trim() && attachments.length === 0) return null;
+    return { ...base, content: text, attachments };
+  }
+
+  if (role === 'toolResult') {
+    const text = resultOutput(msg);
+    const toolName = typeof msg.toolName === 'string' ? msg.toolName : undefined;
+    const toolCallId = typeof msg.toolCallId === 'string' ? msg.toolCallId : undefined;
+    if (toolCallId) return null; // consumed by the paired tool call in pass 2
+    if (!text.trim() && !toolName) return null;
+    return { ...base, role: 'assistant', systemNote: toolName ? `[${toolName}] ${text}` : text };
+  }
+
+  // Assistant / developer / custom: parse the rich block structure.
+  const parsed = parseAssistantContent(content);
+  const turnError = deriveTurnError(msg);
+  const durationMs = typeof msg.duration === 'number'
+    ? msg.duration
+    : typeof entry.durationMs === 'number'
+      ? entry.durationMs
+      : undefined;
+  const model = typeof msg.model === 'string'
+    ? msg.model
+    : typeof entry.model === 'string'
+      ? entry.model
+      : undefined;
+  const provider = typeof msg.provider === 'string' ? msg.provider : undefined;
+  const startedAt = typeof base.startedAt === 'number' ? base.startedAt : undefined;
+  const completedAt = toEpochMs(msg.completedAt)
+    ?? (startedAt !== undefined && durationMs !== undefined ? startedAt + durationMs : undefined);
+  const usage = isRecord(msg.usage) ? (msg.usage as ChatMessageData['usage']) : undefined;
+
+  const message: ChatMessageData = {
+    ...base,
+    content: parsed.textParts.join('\n').trim(),
+    model,
+    provider,
+    completedAt,
+    durationMs,
+    usage,
+  };
+  // Live-path parity (mapper.toChatMessage): an assistant turn whose text is a
+  // <system-reminder> block renders as a SystemNotice alert, never as raw
+  // content — otherwise the reminder leaks into the timeline as markdown.
+  if (parsed.textParts.some((t) => /<\/?system-reminder[^>]*>/i.test(t))) {
+    const notice = parsed.textParts.join('\n').replace(/<\/?system-reminder[^>]*>/gi, '').trim();
+    if (notice) {
+      message.notice = notice;
+      message.content = '';
+    } else if (!parsed.thinking && parsed.toolCalls.length === 0 && !turnError) {
+      return null;
+    } else {
+      message.content = '';
+    }
+  }
+  if (turnError) message.error = turnError;
+  if (parsed.thinking) message.thinking = { thought: parsed.thinking, isGenerating: false };
+  if (parsed.intent) message.intent = parsed.intent;
+  if (parsed.toolCalls.length > 0) {
+    // Inline toolResult blocks (same-entry) are already paired by the shared
+    // core parser; pass 2 (collectToolOutputs) overrides with later entries.
+    message.toolCalls = msg.isError
+      ? parsed.toolCalls.map((call) => ({ ...call, status: 'error' as const }))
+      : parsed.toolCalls;
+  }
+  // Error turns are kept even when they carry no text/tools so the failure is
+  // visible in the timeline instead of silently vanishing.
+  if (!message.content && !message.thinking && !message.toolCalls?.length && !message.systemNote && !message.error && !message.notice) {
+    return null;
+  }
+  return message;
+}
+
+export interface CollectedToolResult {
+  output: string;
+  details?: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export interface SequenceState {
+  messages: ChatMessageData[];
+  /** toolCallId → output and details accumulated from later toolResult entries. */
+  outputsByCall: Map<string, CollectedToolResult>;
+}
+
+/**
+ * First pass: collect every toolResult output (entry-level) into a map keyed
+ * by toolCallId so assistant tool calls rendered later can show their result.
+ */
+export function collectToolOutputs(records: Record<string, unknown>[]): Map<string, CollectedToolResult> {
+  const outputs = new Map<string, CollectedToolResult>();
+  for (const record of records) {
+    if (record?.type !== 'message') continue;
+    const msg = (record as unknown as OmpMessageEntry).message;
+    if (!msg || msg.role !== 'toolResult') continue;
+    const callId = typeof msg.toolCallId === 'string' ? msg.toolCallId : undefined;
+    if (!callId) continue;
+    const text = resultOutput(msg);
+    const existing = outputs.get(callId);
+    let output = text;
+    if (existing) {
+      if (existing.output.trim() === text.trim() || existing.output.includes(text)) {
+        output = existing.output;
+      } else if (text.includes(existing.output)) {
+        output = text;
+      } else {
+        output = `${existing.output}\n${text}`;
+      }
+    }
+    const details = (isRecord(msg.details) ? (msg.details as Record<string, unknown>) : undefined) || existing?.details;
+    const isError = msg.isError === true || existing?.isError;
+    outputs.set(callId, { output, details, isError });
+  }
+  return outputs;
+}
+
+/** Map an omp `custom_message` or `custom` entry (launch-completion,
+ *  ultrathink-notice, xdev-mount-notice, ...) to a notice row. `session_exit`
+ *  entries are runtime plumbing and are intentionally dropped. */
+export function noticeFromCustomMessage(record: Record<string, unknown>): ChatMessageData | null {
+  const customType = typeof record.customType === 'string' ? record.customType : '';
+  const date = typeof record.timestamp === 'string' ? new Date(record.timestamp).toISOString() : undefined;
+  const id = typeof record.id === 'string' ? record.id : `notice-${Date.now()}`;
+
+  if (customType === 'session_exit') return null;
+
+  const content = record.content;
+  const text = typeof content === 'string'
+    ? content
+    : Array.isArray(content)
+      ? content
+          .map((b) => (isRecord(b) && b.type === 'text' && typeof b.text === 'string' ? b.text : ''))
+          .join('')
+      : '';
+  const notice = text.replace(/<\/?system-notice[^>]*>/g, '').trim();
+  if (!notice) return null;
+  return {
+    id,
+    role: 'ai',
+    content: '',
+    notice,
+    date,
+  };
+}

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

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * RELOAD-path adapter: raw omp JSONL entries → chamber ChatMessageData parts.
+ * Content-block parsing is delegated to the shared core parser
+ * (parse-message-blocks.ts) — the same one the live SSE path uses — so the
+ * two render paths cannot drift. This module keeps only JSONL-specific
+ * concerns: the entry wrapper shape, role folding, and image attachments.
+ */
+
+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 { isRecord } from '@/shared/lib/util/guards';
+
+export { stripInlinedTextAttachments };
+export type { OmpMessageEntry };
+
+/** Extract plain text from omp content (string or [{type:'text',text},...]). */
+export function extractText(content: unknown): string {
+  return coreExtractText(content);
+}
+
+type ChatRole = 'user' | 'ai' | 'assistant';
+
+export function roleFor(role: string | undefined): ChatRole {
+  if (role === 'user') return 'user';
+  if (role === 'assistant') return 'ai';
+  return 'assistant';
+}
+
+/** Strip a toolResult's text into a plain output string (skip binary/refusal). */
+export function resultOutput(message: OmpMessageEntry['message']): string {
+  if (!message) return '';
+  const blocks = Array.isArray(message.content) ? (message.content as Record<string, unknown>[]) : [];
+  const parts: string[] = [];
+  for (const block of blocks) {
+    if (!isRecord(block) || block.type !== 'text') continue;
+    if (typeof block.text === 'string') parts.push(block.text);
+  }
+  // Deliberately untrimmed: whitespace is real output; call sites check emptiness.
+  return parts.join('\n');
+}
+
+export interface ParsedAssistantTurn {
+  thinking?: string;
+  toolCalls: ToolCallData[];
+  textParts: string[];
+  /** Short human intent (omp arguments.i) for the tool calls in this turn. */
+  intent?: string;
+}
+
+export function parseAssistantContent(content: unknown): ParsedAssistantTurn {
+  const parsed = parseMessageBlocks(content);
+  const toolCalls = parsed.toolCalls.map((tc) =>
+    toToolCallData(tc, { streaming: false, output: parsed.inlineOutputs.get(tc.id) ?? undefined }),
+  );
+  return {
+    thinking: parsed.thinking,
+    toolCalls,
+    textParts: parsed.textParts,
+    intent: parsed.intent,
+  };
+}
+
+export { extractUserImageAttachments };

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

@@ -0,0 +1,223 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Single source of truth for parsing omp message content blocks (text /
+ * thinking / toolCall / toolResult) into the chamber's parsed-message shape.
+ *
+ * Both render paths share this core so their behavior can never drift:
+ * - live SSE events:  hooks/chat/omp/stream.ts → mapper.ts (streaming=true)
+ * - JSONL reload:     lib/omp/session/messages-parse.ts → messages-map.ts
+ *
+ * The two adapters only handle what is genuinely path-specific: the entry
+ * wrapper shape, the streaming status of tool calls, and output pairing
+ * (incremental in live, 2-pass on reload).
+ */
+
+import type { ToolCallData, ToolType } from '@/shared/types/chat';
+import { hashlineTargetPath } from '@/shared/lib/omp/session/hashline-patch';
+import { isRecord } from '@/shared/lib/util/guards';
+
+/** Extract plain text from omp content (string or [{type:'text',text},...]). */
+export function extractText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === 'text' && typeof block.text === 'string') parts.push(block.text);
+  }
+  return parts.join('\n');
+}
+
+export interface ParsedToolCall {
+  id: string;
+  name: string;
+  title: string;
+  intent?: string;
+  target?: string;
+  command?: string;
+  input?: string | Record<string, unknown>;
+}
+
+export interface ParsedMessageBlocks {
+  thinking?: string;
+  toolCalls: ParsedToolCall[];
+  /** toolCallId → text output carried by inline toolResult blocks. */
+  inlineOutputs: Map<string, string>;
+  textParts: string[];
+  /** Short human intent (omp arguments.i) for the tool calls in this turn. */
+  intent?: string;
+}
+
+function inferToolType(name?: string): ToolType {
+  const lower = (name || '').toLowerCase();
+  if (lower.includes('bash') || lower.includes('terminal') || lower.includes('shell') || lower.includes('run')) {
+    return 'bash';
+  }
+  if (lower.includes('write') || lower.includes('edit') || lower.includes('patch') || lower.includes('apply')) {
+    return 'edit_file';
+  }
+  if (lower.includes('create')) return 'create_file';
+  if (lower.includes('read') || lower.includes('view') || lower.includes('list')) return 'read_file';
+  if (lower.includes('grep') || lower.includes('glob')) return 'grep';
+  if (lower.includes('search') || lower.includes('find')) return 'search_fs';
+  if (lower.includes('web') || lower.includes('fetch') || lower.includes('http')) return 'web_search';
+  if (lower.includes('todo')) return 'todo';
+  if (lower.includes('task')) return 'task';
+  if (lower.includes('lsp')) return 'lsp';
+  if (lower.includes('eval')) return 'eval';
+  if (lower.includes('github')) return 'github';
+  if (lower.includes('security')) return 'security_scan';
+  return 'custom';
+}
+
+export { inferToolType };
+
+function stringArg(rawInput: Record<string, unknown> | undefined, keys: string[]): string {
+  if (!rawInput) return '';
+  for (const key of keys) {
+    const value = rawInput[key];
+    if (typeof value === 'string') return value;
+  }
+  return '';
+}
+
+const COMMAND_KEYS = ['command', 'cmd', 'CommandLine', 'commandLine'];
+const TARGET_KEYS = ['path', 'TargetFile', 'targetFile', 'FilePath', 'filePath', 'AbsolutePath', 'file'];
+
+/** Parse omp message content (string or block array) into the canonical
+ *  parsed-message shape shared by the live and reload render paths. */
+export function parseMessageBlocks(content: unknown): ParsedMessageBlocks {
+  const result: ParsedMessageBlocks = { toolCalls: [], inlineOutputs: new Map(), textParts: [] };
+  if (typeof content === 'string') {
+    result.textParts.push(content);
+    return result;
+  }
+  if (!Array.isArray(content)) return result;
+
+  for (const raw of content) {
+    if (!isRecord(raw)) continue;
+    const block = raw as {
+      type?: unknown;
+      text?: unknown;
+      thinking?: unknown;
+      id?: unknown;
+      name?: unknown;
+      toolCallId?: unknown;
+      arguments?: unknown;
+      input?: unknown;
+    };
+    if (block.type === 'thinking') {
+      if (typeof block.thinking === 'string') result.thinking = block.thinking;
+      else if (typeof block.text === 'string') result.thinking = block.text;
+    } else if (block.type === 'toolCall') {
+      const id = typeof block.id === 'string' ? block.id : `tool-${Math.random().toString(36).slice(2, 10)}`;
+      const name = typeof block.name === 'string' ? block.name : 'tool';
+      const rawInput = (block.arguments ?? block.input) as Record<string, unknown> | undefined;
+      const args = isRecord(rawInput) ? rawInput : undefined;
+      const command = stringArg(args, COMMAND_KEYS);
+      // An omp `edit` carries its target inside the patch header (`input:
+      // "[PATH#TAG]\nCUT …"`) — no `path` key — so the card would otherwise
+      // render without a file name until the result's `details.path` arrives.
+      const target = stringArg(args, TARGET_KEYS) || (args ? hashlineTargetPath(args) : undefined);
+      const intent = typeof args?.i === 'string' ? args.i : undefined;
+      const detail = command || target;
+      result.toolCalls.push({
+        id,
+        name,
+        title: detail ? `${name} — ${detail}` : name,
+        intent,
+        target: target || undefined,
+        command: command || undefined,
+        input: args && Object.keys(args).length > 0 ? args : undefined,
+      });
+      if (intent && !result.intent) result.intent = intent;
+      result.inlineOutputs.set(id, '');
+    } else if (block.type === 'toolResult') {
+      const targetId = typeof block.toolCallId === 'string' ? block.toolCallId : undefined;
+      const text = typeof block.text === 'string' ? block.text : '';
+      if (targetId && result.inlineOutputs.has(targetId)) {
+        result.inlineOutputs.set(targetId, text);
+      } else if (text && result.toolCalls.length > 0) {
+        const last = result.toolCalls[result.toolCalls.length - 1];
+        result.inlineOutputs.set(last.id, text);
+      }
+    } else if (block.type === 'text') {
+      if (typeof block.text === 'string') result.textParts.push(block.text);
+    }
+  }
+  return result;
+}
+
+/** Build a chamber ToolCallData from the parsed core shape. `streaming`
+ *  controls the initial status (live calls start 'running'); pairing an
+ *  output after the fact overrides it back to success/error. */
+export function toToolCallData(
+  parsed: ParsedToolCall,
+  options: { streaming: boolean; output?: string; isError?: boolean },
+): ToolCallData {
+  const input = parsed.input;
+  const stripped = isRecord(input)
+    ? Object.fromEntries(Object.entries(input).filter(([key]) => key !== 'i'))
+    : input;
+  const status: ToolCallData['status'] = options.isError
+    ? 'error'
+    : options.output !== undefined
+      ? 'success'
+      : options.streaming ? 'running' : 'success';
+  return {
+    id: parsed.id,
+    type: inferToolType(parsed.name),
+    name: parsed.name,
+    title: parsed.title,
+    intent: parsed.intent,
+    target: parsed.target,
+    command: parsed.command,
+    input: stripped && Object.keys(stripped).length > 0 ? stripped : undefined,
+    output: options.output,
+    status,
+  };
+}
+
+/** 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. */
+export function extractUserImageAttachments(
+  content: unknown,
+): { id: string; name: string; preview: string; type: string }[] {
+  if (!Array.isArray(content)) return [];
+  const attachments: { id: string; name: string; preview: string; type: string }[] = [];
+  let index = 0;
+  for (const block of content) {
+    if (!isRecord(block) || block.type !== 'image') continue;
+    const data = typeof block.data === 'string' ? block.data : undefined;
+    const mimeType = typeof block.mimeType === 'string' ? block.mimeType : 'image/png';
+    if (!data) continue;
+    index += 1;
+    const ext = (mimeType.split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '') || 'png';
+    attachments.push({
+      id: `att-${index}`,
+      name: `attachment-${index}.${ext}`,
+      preview: `data:${mimeType};base64,${data}`,
+      type: mimeType,
+    });
+  }
+  return attachments;
+}
+
+/** Strip the inlined "Attached file: ..." fenced blocks that the composer
+ *  appends to the prompt before sending (mirror omp-web). The JSONL stores
+ *  the composed prompt; the timeline should show the original text only —
+ *  the file itself renders as an attachment chip. Handles both a leading
+ *  block (attach-only prompt) and one appended after the user text. */
+export function stripInlinedTextAttachments(text: string): string {
+  const match = text.match(/(?:^|\n{2})\s*Attached file: /);
+  if (!match || match.index === undefined) return text;
+  const before = text.slice(0, match.index);
+  const rest = text.slice(match.index + match[0].length);
+  if (!/^[^\n]+\n```[a-z]*\n/.test(rest)) return text;
+  return before.trim();
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Client-side trigger for the server's prewarm pool: asking the chamber server
+ * to start an idle `omp --mode rpc-ui` process for a project cwd before the
+ * first prompt is sent. Fired when the user opens a new (pending) session —
+ * the seconds between the click and the first send then hide the omp boot.
+ *
+ * Fire-and-forget by contract: a failed or slow prewarm must never block or
+ * error the UI. The next send spawns cold in that case, exactly as before.
+ */
+
+export function triggerSessionPrewarm(cwd: string, accessMode?: string): void {
+  if (!cwd) return;
+  fetch('/api/agent/prewarm', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ cwd, ...(accessMode ? { accessMode } : {}) }),
+  }).catch(() => {});
+}
+
+export interface PrewarmFolderShape {
+  id: number | string;
+  name: string;
+  project_path?: string | null;
+  sessions?: { id: number | string }[];
+}
+
+/** Resolve the folder whose context a new session will inherit — the folder
+ *  owning the active session, falling back to the first bound folder. Matches
+ *  the cwd resolution of the send path, so the prewarmed process is spawned in
+ *  the directory the eventual spawn will actually use. */
+export function spawnCwdForNewSession(
+  folders: PrewarmFolderShape[],
+  activeSessionId: string | number | null,
+  folderId?: number | string,
+): string | null {
+  const target = folderId !== undefined
+    ? folders.find((f) => String(f.id) === String(folderId))
+    : folders.find((f) => f.sessions?.some((s) => String(s.id) === String(activeSessionId)))
+      ?? folders.find((f) => Boolean(f.project_path));
+  return target?.project_path || target?.name || null;
+}