ompchamber 0.3.0

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

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Adapter from oh-my-pi discovery data to the chamber folder model.
+ *
+ * Folders are the SQLite-managed workspaces (id, name, isExpanded,
+ * project_path). This module produces the *session items* that fill those
+ * folders from the omp JSONL scan, and mirrors omp's project ordering so the
+ * folders list can be seeded/refreshed consistently.
+ *
+ * Session items carry the omp session UUID as their id — a session belongs to
+ * the folder whose project_path equals its resolved project root.
+ */
+
+import type { OmpProject, OmpSession, OmpSidebarData } from '@/shared/types/omp/session';
+import { formatNewSessionTitle } from '@/shared/lib/omp/session/default-title';
+
+/** Display title of a session: name, else first message, else a timestamped
+ *  `New Session - yyyy-mm-ddThh:mm:ss` default (unique per session — an
+ *  identical placeholder row made fresh sessions indistinguishable). */
+export function sessionTitleFor(session: OmpSession): string {
+  if (session.name?.trim()) {
+    const n = session.name.trim();
+    return n.charAt(0).toUpperCase() + n.slice(1);
+  }
+  const first = (session.firstMessage || '').trim();
+  if (first && first !== '(no messages)') {
+    const text = first.slice(0, 120);
+    return text.charAt(0).toUpperCase() + text.slice(1);
+  }
+  return formatNewSessionTitle(new Date(session.created));
+}
+
+/** Project display name: alias, else lowercase basename of the path. */
+export function projectDisplayName(project: OmpProject): string {
+  if (project.alias?.trim()) return project.alias.trim();
+  const trimmed = project.path.replace(/[\\/]+$/, '');
+  const base = trimmed.split(/[\\/]/).pop() || project.path;
+  return (base || project.path).toLowerCase();
+}
+
+/** Omp-side ordering of projects: sortOrder, then addedAt desc. */
+export function compareOmpProjects(a: OmpProject, b: OmpProject): number {
+  const aOrder = a.sortOrder ?? Number.POSITIVE_INFINITY;
+  const bOrder = b.sortOrder ?? Number.POSITIVE_INFINITY;
+  if (aOrder !== bOrder) return aOrder - bOrder;
+  return (b.addedAt ?? '').localeCompare(a.addedAt ?? '');
+}
+
+/** Map sessions into per-project-root buckets (newest-modified first). */
+export function groupSessionsByRoot(sessions: OmpSession[]): Map<string, OmpSession[]> {
+  const byRoot = new Map<string, OmpSession[]>();
+  for (const session of sessions) {
+    const root = session.projectRoot || session.cwd || '';
+    const bucket = byRoot.get(root);
+    if (bucket) bucket.push(session);
+    else byRoot.set(root, [session]);
+  }
+  for (const bucket of byRoot.values()) {
+    bucket.sort((a, b) => b.modified.localeCompare(a.modified));
+  }
+  return byRoot;
+}
+
+/**
+ * Build the ordered project list used to seed workspace folders:
+ * registered projects (sortOrder/addedAt) first, then discovered extras
+ * (path-sorted) — mirroring omp-web's mergeProjects ordering.
+ */
+export function orderedOmpProjects(data: OmpSidebarData): OmpProject[] {
+  const registered = data.projects.filter((p) => !p.discovered).sort(compareOmpProjects);
+  const discovered = data.projects.filter((p) => p.discovered).sort((a, b) => a.path.localeCompare(b.path));
+  return [...registered, ...discovered];
+}

package/src/shared/lib/omp/session/stream-state.server.ts

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Server-authoritative per-session stream status, persisted in SQLite so the
+ * sidebar can render spinner/check from the SAME loader that already refresh
+ * on stream events (`omp:session-updated` → revalidator). Statuses:
+ *
+ *   stream  — a run is in flight (agent_start)
+ *   finish  — the run ended normally (agent_end), not yet seen
+ *   abort   — the user stopped it, not yet seen
+ *   error   — the run failed (prompt_error / process exit), not yet seen
+ *
+ * A terminal status is a one-shot badge: opening the session acknowledges it
+ * (`markStreamSeen` deletes the row), which is exactly the "check appears
+ * once, disappears when the session is opened" contract. Rows marked
+ * `stream` whose session is no longer running when the sidebar loads are
+ * stale (chamber restart mid-run) and self-heal to `finish`.
+ *
+ * All writes are fire-and-forget: a status write must never fail a prompt,
+ * and the sidebar re-reads on the next revalidate anyway.
+ */
+
+import { getDb } from '@/server/db.server';
+
+export type SessionStreamStatus = 'stream' | 'finish' | 'abort' | 'error';
+
+export async function markStreamStatus(sessionId: string, status: SessionStreamStatus): Promise<void> {
+  try {
+    const db = await getDb();
+    await db.run(
+      `INSERT INTO session_stream_state (session_id, status, updated_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(session_id) DO UPDATE SET status = excluded.status, updated_at = excluded.updated_at`,
+      [sessionId, status],
+    );
+  } catch {
+    // Status tracking is best-effort by design.
+  }
+}
+
+/**
+ * Opening the session clears its terminal badge (one-shot contract).
+ *
+ * Terminal-only: a `stream` row is a LIVE run and must never be deleted here.
+ * Deleting one used to be possible when a client acked from a stale status
+ * map (a `finish` row the sidebar last saw before `agent_start` overwrote it
+ * with `stream`) — the spinner vanished while the run kept going. The client
+ * `markSeen` path also guards terminal-only, but the server is the source of
+ * truth and must hold the line on its own.
+ */
+export async function markStreamSeen(sessionId: string): Promise<boolean> {
+  try {
+    const db = await getDb();
+    const result = await db.run("DELETE FROM session_stream_state WHERE session_id = ? AND status != 'stream'", [sessionId]);
+    return (result.changes ?? 0) > 0;
+  } catch {
+    // Best-effort.
+    return false;
+  }
+}
+
+/** All statuses keyed by session id — the sidebar loader's single read. */
+export async function loadStreamStatuses(): Promise<Record<string, SessionStreamStatus>> {
+  try {
+    const db = await getDb();
+    const rows = (await db.all('SELECT session_id, status FROM session_stream_state')) as {
+      session_id: string;
+      status: string;
+    }[];
+    const map: Record<string, SessionStreamStatus> = {};
+    for (const row of rows) {
+      if (row.status === 'stream' || row.status === 'finish' || row.status === 'abort' || row.status === 'error') {
+        map[row.session_id] = row.status;
+      }
+    }
+    return map;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Self-heal: `stream` rows belong to a live chamber process. After a restart
+ * mid-run nothing will ever write the terminal status, so at read time a
+ * `stream` row with no running session flips to `finish`.
+ */
+export async function healStaleStreamStatuses(runningIds: Set<string>): Promise<void> {
+  try {
+    const db = await getDb();
+    const rows = (await db.all("SELECT session_id FROM session_stream_state WHERE status = 'stream'")) as {
+      session_id: string;
+    }[];
+    for (const row of rows) {
+      if (!runningIds.has(row.session_id)) {
+        await db.run("UPDATE session_stream_state SET status = 'finish', updated_at = CURRENT_TIMESTAMP WHERE session_id = ?", [
+          row.session_id,
+        ]);
+      }
+    }
+  } catch {
+    // Best-effort.
+  }
+}

package/src/shared/lib/omp/session/telemetry-blocks.ts

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Content-block profiling for raw session telemetry: maps an omp message
+ * content value to the coarse badge categories and char counts the raw
+ * messages panel renders. Extracted from ./telemetry.ts to keep that module
+ * under the repo's per-file size ceiling.
+ */
+
+import { isRecord } from '@/shared/lib/util/guards';
+
+export const TYPE_ORDER = ['reasoning', 'text', 'bash', 'read', 'edit', 'search', 'web', 'tool'] as const;
+
+/** Coarse badge category for a tool name (mirrors the mock taxonomy). */
+function toolCategory(name: string | undefined): string {
+  const lower = (name || '').toLowerCase();
+  if (/bash|terminal|shell/.test(lower)) return 'bash';
+  if (/cmd|command|run|exec/.test(lower)) return 'bash';
+  if (/write|edit|patch|apply|create/.test(lower)) return 'edit';
+  if (/read|view|list|cat/.test(lower)) return 'read';
+  if (/search|grep|find|glob/.test(lower)) return 'search';
+  if (/web|fetch|http|browser/.test(lower)) return 'web';
+  return 'tool';
+}
+
+export function contentProfile(content: unknown): { parts: string[]; toolCalls: number; toolChars: number } {
+  if (!Array.isArray(content)) return { parts: typeof content === 'string' && content.trim() ? ['text'] : [], toolCalls: 0, toolChars: 0 };
+  const seen = new Set<string>();
+  let toolCalls = 0;
+  let toolChars = 0;
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === 'thinking') seen.add('reasoning');
+    else if (block.type === 'text') seen.add('text');
+    else if (block.type === 'toolCall') {
+      toolCalls++;
+      seen.add(toolCategory(typeof block.name === 'string' ? block.name : undefined));
+      try {
+        toolChars += JSON.stringify(block.arguments ?? {}).length;
+      } catch {
+        // ignore serialization failure
+      }
+    } else if (block.type === 'toolResult') {
+      try {
+        toolChars += JSON.stringify(block).length;
+      } catch {
+        // ignore serialization failure
+      }
+    }
+    if (typeof block.command === 'string') {
+      seen.add('bash');
+      toolChars += block.command.length;
+    }
+    if (typeof block.code === 'string') toolChars += block.code.length;
+  }
+  return { parts: TYPE_ORDER.filter((p) => seen.has(p)), toolCalls, toolChars };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Timestamp normalization for omp entries. omp writes timestamps as either an
+ * epoch-millis number or an ISO string depending on version, so both the live
+ * SSE mapper and the JSONL reload path normalize through here.
+ */
+
+/** Epoch millis from an epoch-millis number or a parseable date string. */
+export function toEpochMs(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const t = new Date(value).getTime();
+    return Number.isNaN(t) ? undefined : t;
+  }
+  return undefined;
+}

package/src/shared/lib/omp/session/turn-error.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Single source of truth for deriving a turn's abort/error payload from a raw
+ * omp message.
+ *
+ * omp records an abnormal stop as FLAT fields on the message itself
+ * (`stopReason` / `errorStatus` / `errorId` / `errorMessage`) — there is no
+ * nested `error` object. Both render paths must read those same fields, or an
+ * aborted turn renders one way live and another way after a JSONL reload:
+ * - live SSE events:  agent-events.ts → mapper.ts
+ * - JSONL reload:     messages-parse.ts → messages-map.ts
+ */
+
+import type { ChatMessageData } from '@/shared/types/chat';
+
+/** omp `stopReason` values that mean the turn did not finish normally. */
+const ABNORMAL_STOP_REASONS = new Set(['aborted', 'error']);
+
+/** True when the raw omp message ended abnormally (user abort or provider error). */
+export function turnStoppedAbnormally(raw: Record<string, unknown>): boolean {
+  const stopReason = raw.stopReason;
+  if (typeof stopReason === 'string' && ABNORMAL_STOP_REASONS.has(stopReason)) return true;
+  return typeof raw.errorStatus === 'number' || typeof raw.errorMessage === 'string';
+}
+
+/** Chamber error payload for an abnormally stopped turn — undefined when the
+ *  turn finished normally, so callers keep their empty-content guard intact. */
+export function deriveTurnError(raw: Record<string, unknown>): ChatMessageData['error'] {
+  if (!turnStoppedAbnormally(raw)) return undefined;
+  return {
+    status: typeof raw.errorStatus === 'number' ? raw.errorStatus : undefined,
+    id: typeof raw.errorId === 'number' ? raw.errorId : undefined,
+    message: typeof raw.errorMessage === 'string' ? raw.errorMessage : undefined,
+    stopReason: typeof raw.stopReason === 'string' ? raw.stopReason : undefined,
+  };
+}

package/src/shared/lib/omp/subagent/history/client.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Client helpers for the on-disk subagent history route
+ * (`GET /api/sessions/:id/subagents`): wire normalization, history → roster
+ * mapping, and the compact row formatters.
+ */
+
+import { isRecord } from '@/shared/lib/util/guards';
+import type { SubagentHistoryEntry, SubagentInfo, SubagentProgress } from '@/shared/types/omp/subagent';
+
+/** Minimal wire guard — a malformed element must not become a roster row. */
+function isHistoryEntry(value: unknown): value is SubagentHistoryEntry {
+  return isRecord(value)
+    && typeof value.id === 'string' && value.id.length > 0
+    && typeof value.agent === 'string' && value.agent.length > 0
+    && typeof value.status === 'string'
+    && typeof value.index === 'number';
+}
+
+/** Fetch the recovered roster for a session. `null` = unavailable/failed. */
+export async function fetchSubagentHistory(sessionId: string): Promise<SubagentHistoryEntry[] | null> {
+  try {
+    const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/subagents`);
+    if (!res.ok) return null;
+    const body: unknown = await res.json().catch(() => null);
+    if (!isRecord(body)) return null;
+    const payload = isRecord(body.data) ? body.data : body;
+    if (!Array.isArray(payload.subagents)) return null;
+    return payload.subagents.filter(isHistoryEntry);
+  } catch {
+    return null;
+  }
+}
+
+/** Convert a recovered on-disk history entry into roster form. `lastUpdate: 0`
+ *  marks it infinitely old, so any live frame wins in `mergeSubagentRoster`. */
+export function historyEntryToSubagentInfo(entry: SubagentHistoryEntry): SubagentInfo {
+  const info: SubagentInfo = { ...entry, source: 'history', lastUpdate: 0 };
+  const progress: SubagentProgress = {};
+  if (entry.lastIntent !== undefined) progress.lastIntent = entry.lastIntent;
+  if (entry.toolCount !== undefined) progress.toolCount = entry.toolCount;
+  if (entry.requests !== undefined) progress.requests = entry.requests;
+  if (entry.tokens !== undefined) progress.tokens = entry.tokens;
+  if (entry.contextTokens !== undefined) progress.contextTokens = entry.contextTokens;
+  if (entry.contextWindow !== undefined) progress.contextWindow = entry.contextWindow;
+  if (entry.cost !== undefined) progress.cost = entry.cost;
+  if (entry.durationMs !== undefined) progress.durationMs = entry.durationMs;
+  if (entry.resolvedModel !== undefined) progress.resolvedModel = entry.resolvedModel;
+  if (Object.keys(progress).length > 0) info.progress = progress;
+  return info;
+}
+
+/** ms → `17.8s` / `1m 4s`; empty for absent/negative values. */
+export function formatSubagentDuration(ms: number | undefined): string {
+  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) return '';
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const totalSeconds = Math.round(ms / 1000);
+  return `${Math.floor(totalSeconds / 60)}m ${totalSeconds % 60}s`;
+}
+
+/** `$0.003` compact cost; empty for absent/zero values. */
+export function formatSubagentCost(cost: number | undefined): string {
+  if (typeof cost !== 'number' || !Number.isFinite(cost) || cost <= 0) return '';
+  return `$${cost.toFixed(3)}`;
+}
+
+/** Combined `duration · cost` row suffix, sourced from the roster progress. */
+export function formatSubagentMeta(subagent: SubagentInfo): string {
+  const duration = formatSubagentDuration(subagent.progress?.durationMs);
+  const cost = formatSubagentCost(subagent.progress?.cost);
+  return [duration, cost].filter(Boolean).join(' · ');
+}

package/src/shared/lib/omp/subagent/history/settlement.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Settlement folding for detached async subagent spawns.
+ *
+ * A parent `task` toolResult persists only the launch snapshot
+ * (`async.state = "running"`); terminal state arrives later as an
+ * `async-result` custom message or a `hub` `jobs` snapshot, so without folding
+ * those onto the roster seeded by `@/lib/omp/subagent/history/fold` the agent
+ * stays "started" forever.
+ */
+
+import { extractText } from '@/shared/lib/omp/session/parse-message-blocks';
+import { isRecord } from '@/shared/lib/util/guards';
+import { resultStatus } from '@/shared/lib/omp/subagent/history/status';
+import { asNumber, asString } from '@/shared/lib/omp/subagent/result-details';
+import type { OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
+import type { SubagentHistoryEntry } from '@/shared/types/omp/subagent';
+
+/** Settled state reported by a detached async spawn. The parent's task
+ *  toolResult persists only the launch snapshot (`async.state = "running"`);
+ *  settlement arrives later as an `async-result` custom message or a `hub`
+ *  `jobs` snapshot, so without folding those the roster stays "started". */
+export function applySettlement(
+  byId: Map<string, SubagentHistoryEntry>,
+  patch: Pick<SubagentHistoryEntry, 'id' | 'status'> & Partial<SubagentHistoryEntry>,
+): void {
+  const existing = byId.get(patch.id);
+  if (!existing) return;
+  byId.set(patch.id, {
+    ...existing,
+    ...patch,
+    task: patch.task ?? existing.task,
+    assignment: patch.assignment ?? existing.assignment,
+    description: patch.description ?? existing.description,
+    index: existing.index,
+    parentToolCallId: existing.parentToolCallId ?? patch.parentToolCallId,
+    batchSeq: existing.batchSeq,
+    result: { ...existing.result, ...patch.result },
+  });
+}
+
+/**
+ * Fold `async-result` custom messages and `hub` op="jobs" toolResults onto the
+ * roster entries seeded by the history fold.
+ */
+export function foldSettlements(entries: OmpMessageEntry[], byId: Map<string, SubagentHistoryEntry>): void {
+  // Settlement for detached async spawns arrives as `async-result` custom
+  // messages (`details.jobs[]` snapshots) and `hub` op="jobs" toolResults —
+  // fold their terminal status onto the roster entries seeded above.
+  for (const entry of entries) {
+    const details = isRecord(entry.details) ? entry.details : undefined;
+    if (entry.type === 'custom_message' && entry.customType === 'async-result') {
+      const contentText = extractText(entry.content);
+      const inlineStatus = /<task-result\b[^>]*\bstatus="(completed|failed|aborted)"/.exec(contentText)?.[1];
+      if (details && Array.isArray(details.jobs)) {
+        for (const raw of details.jobs) {
+          if (!isRecord(raw)) continue;
+          const jobId = asString(raw.jobId) ?? asString(raw.id);
+          if (!jobId) continue;
+          const settled = resultStatus(raw) !== 'started' ? resultStatus(raw)
+            : inlineStatus === 'completed' ? 'completed' : 'started';
+          if (settled === 'started') continue;
+          applySettlement(byId, {
+            id: jobId,
+            agent: asString(raw.agent) ?? 'task',
+            status: settled,
+            durationMs: asNumber(raw.durationMs),
+            resolvedModel: asString(raw.resolvedModel),
+            transcriptAvailable: false,
+            result: { exitCode: 0 },
+          });
+        }
+        continue;
+      }
+      const inlineId = /<task-result\b[^>]*\bid="([A-Za-z0-9_.-]+)"/.exec(contentText)?.[1];
+      if (inlineId && inlineStatus) {
+        applySettlement(byId, {
+          id: inlineId,
+          agent: 'task',
+          status: inlineStatus as SubagentHistoryEntry['status'],
+          transcriptAvailable: false,
+          result: { exitCode: 0 },
+        });
+      }
+      continue;
+    }
+    const message = entry.message;
+    if (entry.type !== 'message' || !message || message.role !== 'toolResult') continue;
+    if (message.toolName !== 'hub') continue;
+    const hubDetails = isRecord(message.details) ? message.details : {};
+    if (!Array.isArray(hubDetails.jobs)) continue;
+    for (const raw of hubDetails.jobs) {
+      if (!isRecord(raw)) continue;
+      const jobId = asString(raw.id) ?? asString(raw.jobId);
+      if (!jobId) continue;
+      const settled = resultStatus(raw);
+      if (settled === 'started') continue;
+      applySettlement(byId, {
+        id: jobId,
+        agent: 'task',
+        status: settled,
+        durationMs: asNumber(raw.durationMs),
+        resolvedModel: asString(raw.resolvedModel),
+        transcriptAvailable: false,
+        result: { exitCode: 0 },
+      });
+    }
+  }
+}

package/src/shared/lib/omp/subagent/history/status.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Status projection shared by the subagent history fold and settlement pass.
+ *
+ * omp reports lifecycle state in several shapes — live progress snapshots,
+ * settled task SingleResults, async-result job snapshots — and all of them map
+ * onto the roster's terminal status vocabulary here, together with the guard
+ * that stops a stale progress snapshot from regressing a settled agent.
+ */
+
+import type { SubagentHistoryEntry } from '@/shared/types/omp/subagent';
+
+export function progressStatusToHistory(status: string | undefined): SubagentHistoryEntry['status'] {
+  if (status === 'completed') return 'completed';
+  if (status === 'failed') return 'failed';
+  if (status === 'aborted') return 'aborted';
+  return 'started';
+}
+
+export function resultStatus(value: Record<string, unknown>): SubagentHistoryEntry['status'] {
+  const explicit = value.status;
+  if (explicit === 'completed' || explicit === 'failed' || explicit === 'aborted') return explicit;
+  if (value.aborted === true) return 'aborted';
+  if (typeof value.error === 'string' && value.error) return 'failed';
+  if (typeof value.exitCode === 'number') return value.exitCode === 0 ? 'completed' : 'failed';
+  return 'started';
+}
+
+/** True when an entry already carries a settled state that a stale/duplicate
+ *  progress snapshot must not regress (unknown/running → "started"). */
+export function progressUpsertBlocked(existing: SubagentHistoryEntry): boolean {
+  return existing.result !== undefined
+    || existing.status === 'completed'
+    || existing.status === 'failed'
+    || existing.status === 'aborted';
+}