ompchamber 1.1.0 → 1.2.0

package/src/server/lib/db/schema.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Schema bootstrap for the chamber database: the `CREATE TABLE IF NOT EXISTS`
+ * block plus the in-place migrations that repair schemas written by older
+ * installs. Split out of `@/server/db.server` so the connection lifecycle
+ * there stays readable; the order below is load-bearing — the migrations run
+ * between the two DDL blocks, after the tables they touch exist.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+import { migrateQueueTableFk } from '@/server/lib/queue/schema-migration.server';
+import { ensureBtwSchema } from '@/server/lib/btw/schema.server';
+import { migrateWorkspaceFolderColumns } from '@/shared/lib/workspace/schema-migrations';
+
+export async function initSchema(db: DbClient): Promise<void> {
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS workspace_folders (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      is_expanded BOOLEAN DEFAULT 0,
+      project_path TEXT,
+      model TEXT DEFAULT 'Not selected',
+      accent_color TEXT DEFAULT '',
+      icon TEXT DEFAULT 'default',
+      custom_icon_url TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    
+    CREATE TABLE IF NOT EXISTS sessions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      folder_id INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      is_active BOOLEAN DEFAULT 0,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (folder_id) REFERENCES workspace_folders (id)
+    );
+
+    CREATE TABLE IF NOT EXISTS app_settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS chat_sessions (
+      session_id TEXT PRIMARY KEY,
+      title TEXT,
+      messages TEXT NOT NULL,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS deleted_workspaces (
+      project_path TEXT PRIMARY KEY,
+      deleted_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS archived_sessions (
+      session_id TEXT PRIMARY KEY,
+      archived_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS session_ui_state (
+      session_id TEXT PRIMARY KEY,
+      state TEXT NOT NULL DEFAULT '{}',
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS queued_messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      position INTEGER NOT NULL,
+      message TEXT NOT NULL DEFAULT '',
+      attachments TEXT NOT NULL DEFAULT '[]',
+      provider TEXT,
+      model_id TEXT,
+      thinking_level TEXT,
+      access_mode TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE INDEX IF NOT EXISTS idx_queued_messages_session ON queued_messages (session_id, position);
+
+    CREATE TABLE IF NOT EXISTS session_stream_state (
+      session_id TEXT PRIMARY KEY,
+      status TEXT NOT NULL,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+
+  await migrateWorkspaceFolderColumns(db);
+  // Installs older `queued_messages` schemas carry an invalid FK (see the
+  // migration module); rebuild once so real-session queue inserts work.
+  await migrateQueueTableFk(db);
+  // Side-question tables live in their own module (see schema.server.ts).
+  await ensureBtwSchema(db);
+
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id INTEGER NOT NULL,
+      parent_id INTEGER,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      is_expanded BOOLEAN DEFAULT 0,
+      FOREIGN KEY (session_id) REFERENCES sessions (id),
+      FOREIGN KEY (parent_id) REFERENCES files (id)
+    );
+  `);
+}

package/src/server/lib/db/seed.ts

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `MOCK=true` database seeding: demo workspace folders, screenshot-matching
+ * chat sessions, the bundled sample transcripts and a synthetic file tree.
+ * Split out of `@/server/db.server` so the connection lifecycle there stays
+ * readable. Runs only in mock mode and only on a database that has not been
+ * seeded before — every branch is idempotent, so a restart re-asserts the
+ * demo rows instead of duplicating them.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+import { SAMPLE_TOOLS_SESSION_ID, getSampleToolsSession } from '@/client/data/samples/tools-session';
+import { SAMPLE_DIALOGUE_SESSION_ID, getSampleDialogueSession } from '@/client/data/samples/dialogue-session';
+import { SAMPLE_DEVICES_SESSION_ID, getSampleDevicesSession } from '@/client/data/samples/virtual-devices-session';
+
+const INSERT_CHAT_SESSION =
+  'INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)';
+
+export async function seedMockData(db: DbClient): Promise<void> {
+  const folderCount = await db.get('SELECT COUNT(*) as count FROM workspace_folders');
+
+  if (folderCount.count === 0) {
+    await db.exec(`
+      INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES 
+        (1, 'Chats', 1), 
+        (2, 'Workspace', 1), 
+        (3, 'drrealhandler', 1);
+    `);
+  }
+
+  await seedChatSessions(db);
+  await seedWorkspaceSessions(db, 2, [
+    'History Commit 2026-09-05 23:00',
+    'History Commit 2026-09-04 23:00',
+    'History Commit 2026-09-03 23:00',
+    'Error SMSC latency pada jns6.5 smppv2',
+    'Penyebab provider_submit_status=-1 di jns6.5 Smartfren SMPP',
+    'jns6.5 filevalidator error Mask Code di Release',
+    'Union query transaksi 202607 dan 202606',
+  ]);
+  await seedWorkspaceSessions(db, 3, [
+    'Buat branch feat/add-provider-err-telco-to-dr-smpp',
+    'Update wiki v1.5.0 & testing dari add-configurabel',
+    'Konfigurasi rute DR SMPP via config lookup',
+    'drrealhandler update v1.5.0',
+    'Gitlab wiki clone isi kosong',
+  ]);
+
+  await seedFillerSessions(db);
+  await seedSessionFiles(db);
+}
+
+/** Demo folders 1-3 and the five sessions the sidebar screenshots show. */
+async function seedChatSessions(db: DbClient): Promise<void> {
+  // Ensure ompchamber, Workspace, drrealhandler folders exist
+  await db.run("INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES (1, 'ompchamber', 1)");
+  await db.run("INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES (2, 'Workspace', 1)");
+  await db.run("INSERT OR IGNORE INTO workspace_folders (id, name, is_expanded) VALUES (3, 'drrealhandler', 1)");
+  await db.run("UPDATE workspace_folders SET name = 'ompchamber' WHERE id = 1");
+
+  const existingChats = await db.all("SELECT * FROM sessions WHERE folder_id = 1");
+  const titles = [
+    'Cek stream subagent di ompweb',
+    'Fitur Diff Panel dan Git Status Files',
+    'Implementasi Saved State UI per Session ID',
+    'Review loading indicator, model & intent title',
+    'Status fitur streer dan queue',
+  ];
+
+  if (existingChats.length === 0) {
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[0]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[1]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 1)", [titles[2]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[3]]);
+    await db.run("INSERT INTO sessions (folder_id, title, is_active) VALUES (1, ?, 0)", [titles[4]]);
+  } else {
+    await db.run("UPDATE sessions SET title = ? WHERE id = 1", [titles[0]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 2", [titles[1]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 3", [titles[2]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 4", [titles[3]]);
+    await db.run("UPDATE sessions SET title = ? WHERE id = 5", [titles[4]]);
+    await db.run("UPDATE sessions SET is_active = 0 WHERE folder_id = 1");
+    await db.run("UPDATE sessions SET is_active = 1 WHERE id = 3");
+  }
+
+  // Pre-seed sample sessions data
+  try {
+    const s1 = getSampleToolsSession();
+    await db.run(INSERT_CHAT_SESSION, ['1', s1.title, JSON.stringify(s1.messages)]);
+    await db.run(INSERT_CHAT_SESSION, [SAMPLE_TOOLS_SESSION_ID, s1.title, JSON.stringify(s1.messages)]);
+
+    const s2 = getSampleDialogueSession();
+    await db.run(INSERT_CHAT_SESSION, ['2', s2.title, JSON.stringify(s2.messages)]);
+    await db.run(INSERT_CHAT_SESSION, [SAMPLE_DIALOGUE_SESSION_ID, s2.title, JSON.stringify(s2.messages)]);
+
+    const s3 = getSampleDevicesSession();
+    await db.run(INSERT_CHAT_SESSION, ['3', s3.title, JSON.stringify(s3.messages)]);
+    await db.run(INSERT_CHAT_SESSION, [SAMPLE_DEVICES_SESSION_ID, s3.title, JSON.stringify(s3.messages)]);
+    const s3Row = await db.get("SELECT id FROM sessions WHERE folder_id = 1 AND title = ?", [titles[2]]);
+    if (s3Row) {
+      await db.run(INSERT_CHAT_SESSION, [String(s3Row.id), s3.title, JSON.stringify(s3.messages)]);
+    }
+  } catch (e) {
+    console.error('Failed to pre-seed sample sessions:', e);
+  }
+}
+
+/** Add the given session titles to a folder when it has none yet. */
+async function seedWorkspaceSessions(db: DbClient, folderId: number, titles: string[]): Promise<void> {
+  const existing = await db.all('SELECT * FROM sessions WHERE folder_id = ?', [folderId]);
+  if (existing.length > 0) return;
+  for (const title of titles) {
+    await db.run('INSERT INTO sessions (folder_id, title, is_active) VALUES (?, ?, 0)', [folderId, title]);
+  }
+}
+
+/** Add random sessions if we don't have enough to demonstrate the UI. */
+async function seedFillerSessions(db: DbClient): Promise<void> {
+  const sessionCount = await db.get('SELECT COUNT(*) as count FROM sessions');
+  if (sessionCount.count >= 15) return;
+
+  const titles = [
+    'Fix header styling issue', 'Implement authentication flow', 'Setup CI/CD pipeline',
+    'Debug database connection', 'Update README.md docs', 'Refactor UI components',
+  ];
+  for (let i = 1; i <= 3; i++) {
+    for (let j = 0; j < 3; j++) {
+      const title = titles[Math.floor(Math.random() * titles.length)] + ' #' + Math.floor(Math.random() * 1000);
+      await db.run('INSERT INTO sessions (folder_id, title, is_active) VALUES (?, ?, 0)', [i, title]);
+    }
+  }
+}
+
+/** Seed a demo file tree for every session when the files table is empty. */
+async function seedSessionFiles(db: DbClient): Promise<void> {
+  const fileCount = await db.get('SELECT COUNT(*) as count FROM files');
+  if (fileCount.count !== 0) return;
+
+  const insertFile =
+    'INSERT INTO files (session_id, parent_id, name, type, is_expanded) VALUES (?, ?, ?, ?, ?)';
+  const allSessions = await db.all('SELECT id FROM sessions');
+  for (const session of allSessions) {
+    const src = await db.run(insertFile, [session.id, null, 'src', 'folder', 1]);
+    const components = await db.run(insertFile, [session.id, null, 'components', 'folder', 0]);
+
+    await db.run(insertFile, [session.id, src.lastID, 'index.tsx', 'file', 0]);
+    await db.run(insertFile, [session.id, src.lastID, 'App.tsx', 'file', 0]);
+    await db.run(insertFile, [session.id, src.lastID, 'styles.css', 'file', 0]);
+
+    await db.run(insertFile, [session.id, components.lastID, 'Button.tsx', 'file', 0]);
+    await db.run(insertFile, [session.id, components.lastID, 'Header.tsx', 'file', 0]);
+
+    await db.run(insertFile, [session.id, null, 'package.json', 'file', 0]);
+    await db.run(insertFile, [session.id, null, 'README.md', 'file', 0]);
+  }
+}

package/src/server/lib/db/workspace-sync.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Additive-only folder ↔ omp project sync: creates a workspace folder for
+ * every project discovered from ~/.omp/agent (folder name = lowercase
+ * basename, bound via project_path). It never modifies or deletes existing
+ * user data — no renames, no re-binding of unbound folders — and it skips
+ * projects the user has explicitly deleted (tombstoned in
+ * `deleted_workspaces`), so a deleted workspace stays deleted.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+import { projectPathKey } from '@/server/lib/omp/core/paths';
+import { loadOmpSidebarData } from '@/server/lib/omp/session/reader';
+import { orderedOmpProjects, projectDisplayName } from '@/shared/lib/omp/session/sidebar';
+
+/** SYNC_WORKSPACE env flag (default true when unset). When enabled in real
+ *  mode, workspace folders are auto-created from discovered omp projects. */
+function isWorkspaceSyncEnabled(): boolean {
+  const raw = (Bun.env.SYNC_WORKSPACE || '').trim().toLowerCase();
+  if (raw === '') return true;
+  return raw !== 'false' && raw !== '0' && raw !== 'off' && raw !== 'no';
+}
+
+/**
+ * Real-data workspace bootstrap: sync discovered omp projects into
+ * `workspace_folders` when SYNC_WORKSPACE allows it. Discovery must never
+ * block app startup, so a failure is logged rather than thrown.
+ */
+export async function syncWorkspaceFoldersFromDiscovery(db: DbClient): Promise<void> {
+  if (!isWorkspaceSyncEnabled()) return;
+  try {
+    await syncWorkspaceFoldersWithOmp(db);
+  } catch (err) {
+    // Discovery must never block app startup.
+    console.error('OMP workspace sync failed:', err);
+  }
+}
+
+async function syncWorkspaceFoldersWithOmp(db: DbClient): Promise<void> {
+  const data = await loadOmpSidebarData();
+  const existing = await db.all('SELECT id, name, project_path FROM workspace_folders');
+  const tombstoned = await db.all('SELECT project_path FROM deleted_workspaces');
+
+  // Compare by canonical key, not raw string: tombstones may predate the
+  // directory (unresolved symlink spelling) while project.path is realpath'd.
+  const byPath = new Set(existing.map((r) => r.project_path).filter(Boolean).map(projectPathKey));
+  const usedNames = new Set(existing.map((r) => (r.name as string).toLowerCase()));
+  const deletedPaths = new Set(tombstoned.map((r) => projectPathKey(r.project_path as string)));
+
+  for (const project of orderedOmpProjects(data)) {
+    if (deletedPaths.has(projectPathKey(project.path))) continue;
+    if (byPath.has(projectPathKey(project.path))) continue;
+
+    const name = projectDisplayName(project);
+    let candidate = name;
+    let suffix = 2;
+    while (usedNames.has(candidate)) {
+      candidate = `${name}-${suffix++}`;
+    }
+    usedNames.add(candidate);
+    await db.run(
+      'INSERT INTO workspace_folders (name, is_expanded, project_path) VALUES (?, 1, ?)',
+      [candidate, project.path],
+    );
+  }
+}

package/src/server/lib/fs/root.ts

@@ -28,6 +28,43 @@ export function resolveWithinRoot(root: string, rel: string): string | null {
   return isWithinRoot(root, target) ? target : null;
 }
 
+/**
+ * Resolve a file a drop or a link pointed at, which may live outside the active
+ * root.
+ *
+ * A dropped file is always named by an absolute path or URL — a file manager
+ * cannot know which workspace the page considers active — so
+ * {@link resolveWithinRoot} rejects exactly the references the composer needs.
+ * The allow-list that governs a client-supplied `root` governs these too: the
+ * app root, a path beneath it, or an exact registered workspace project path.
+ * Anything else resolves to null, so an arbitrary path from a page still cannot
+ * read the filesystem.
+ */
+export async function resolveReferencedPath(rawPath: string): Promise<string | null> {
+  const candidate = rawPath.trim();
+  if (!candidate) return null;
+
+  const resolved = path.resolve(candidate);
+  if (resolved === APP_ROOT || resolved.startsWith(APP_ROOT + path.sep)) {
+    return (await pathExists(resolved)) ? resolved : null;
+  }
+
+  try {
+    const db = await getDb();
+    const rows = (await db.all(
+      'SELECT project_path FROM workspace_folders WHERE project_path IS NOT NULL'
+    )) as { project_path: string }[];
+    for (const row of rows) {
+      const workspaceRoot = path.resolve(row.project_path);
+      if (isWithinRoot(workspaceRoot, resolved) && (await pathExists(resolved))) return resolved;
+    }
+  } catch {
+    // Database unavailable — nothing outside the app root can be verified.
+  }
+
+  return null;
+}
+
 /**
  * Default browsing root when no session-bound project is active. Mock/demo
  * mode browses the bundled `examples` tree; real mode browses the app root.

package/src/server/lib/omp/rpc/frame-fold.ts

@@ -0,0 +1,207 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Folds one omp RPC frame into the session wrapper's runtime state, and runs
+ * the settle-time side effects a terminal run triggers.
+ *
+ * Mirrors the client's `foldAgentEvent` (shared/lib/chat/omp/agent-events.ts):
+ * the same shape of problem — one frame, many state flags — solved the same way
+ * so both ends of the transport read alike. Split out of rpc-manager.ts so the
+ * wrapper owns only process lifecycle.
+ *
+ * The state machine is the load-bearing part. `turn_end` fires for EVERY turn
+ * in a multi-turn run, `agent_end` is the only frame that knows whether the run
+ * is terminal, and a `prompt` response that failed must clear the same flags a
+ * successful settle does — a missed clear strands the session as "running" and
+ * the idle reclaim can never take it back.
+ */
+
+import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
+import {
+  consumeAutoTitleOutput,
+  triggerAutoSessionTitle,
+  type AutoTitleHost,
+} from '@/server/lib/omp/session/auto-title.server';
+import { scheduleQueueDelivery, type QueueDeliveryHost } from '@/server/lib/queue/delivery.server';
+import { loadStreamStatuses, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
+import { NON_TERMINAL_CONTINUATION_GRACE_MS, type AgentEvent } from '@/server/lib/omp/rpc/constants';
+
+/**
+ * Wrapper surface the fold reads and writes. Every field is owned by the
+ * wrapper; the fold mutates them in place exactly as the inline switch did.
+ * Composes the two host contracts the settle path hands the wrapper to
+ * (auto-title, queue delivery) so the wrapper itself satisfies this whole type.
+ */
+export interface SessionFrameHost extends AutoTitleHost, QueueDeliveryHost {
+  promptRunning: boolean;
+  streaming: boolean;
+  compacting: boolean;
+  awaitingAgentStart: boolean;
+  awaitingAgentStartDeadline: number;
+  continuationGraceUntil: number;
+  emit(event: AgentEvent): void;
+  /** Remember a blocking ask/approval dialog so a reattaching client can answer it. */
+  trackUiDialog(frame: AgentEvent): void;
+  /** Fold a subagent frame into the liveness roster. */
+  observeSubagent(frame: AgentEvent, now: number): void;
+}
+
+/** What the caller must do after the fold. */
+export interface FrameFoldResult {
+  /** The session list is stale and needs a rebuild. */
+  refreshSessionList: boolean;
+  /** The fold already handled this frame's user-visible effect and the caller
+   *  must NOT forward it: a failed `prompt` response has emitted its own
+   *  `prompt_error`, and a `command_output` belonging to the chamber's own
+   *  background rename must stay out of the timeline. */
+  suppressForward: boolean;
+}
+
+/** True when the ending turn was a user abort rather than a natural stop. */
+function endedAborted(messages: unknown): boolean {
+  return (
+    Array.isArray(messages) &&
+    messages.some((entry) => {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
+      return (entry as Record<string, unknown>).stopReason === 'aborted';
+    })
+  );
+}
+
+/**
+ * Write the terminal stream badge from the ending turn's own stopReason.
+ *
+ * The `abort` command already wrote `abort` at dispatch time, but the
+ * `agent_end` frame arrives later and previously flattened it to `finish`.
+ * Re-check the current row and only upgrade `stream` rows, so a `finish`
+ * written here can never clobber a newer run's live `stream`/`abort`.
+ */
+async function markEndStatus(sessionId: string, messages: unknown): Promise<void> {
+  if (!sessionId) return;
+  const current = await loadStreamStatuses();
+  if (current[sessionId] !== 'stream') return;
+  await markStreamStatus(sessionId, endedAborted(messages) ? 'abort' : 'finish');
+}
+
+/** Apply one frame to the wrapper's runtime state. */
+export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): FrameFoldResult {
+  const result: FrameFoldResult = { refreshSessionList: false, suppressForward: false };
+
+  switch (event.type) {
+    case 'agent_start':
+      host.promptRunning = true;
+      host.streaming = true;
+      host.awaitingAgentStart = false;
+      host.awaitingAgentStartDeadline = 0;
+      host.continuationGraceUntil = 0;
+      clearSessionFileCaches();
+      result.refreshSessionList = true;
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
+      break;
+    case 'turn_start':
+      // Redundant with agent_start in the happy path, but the run-level
+      // counterpart can be missed (e.g. the state was cleared by a command
+      // between frames). The turn is proof enough the session is live.
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
+      break;
+    case 'message_start':
+      // Same recovery as turn_start: a message frame is only emitted inside a
+      // live run, so its arrival re-arms the `stream` row no matter what stale
+      // status sits there (upsert overwrites any terminal badge).
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
+      break;
+    case 'turn_end': {
+      // A multi-turn run emits turn_end for EVERY turn — intermediates end with
+      // `toolUse`/`stop` while the run keeps going (verified against omp
+      // 18.2.8: agent_start → turn_start → turn_end('toolUse') → turn_start →
+      // turn_end('stop') → agent_end, and the frame carries no isTerminal
+      // field). Only `aborted` is unambiguous here: the run is over, so the
+      // abort badge can be written before agent_end arrives. Everything else
+      // waits for agent_end, which knows isTerminal.
+      if (!host.sessionId) break;
+      const turn = event.message as Record<string, unknown> | undefined;
+      if (turn?.stopReason === 'aborted') void markStreamStatus(host.sessionId, 'abort');
+      break;
+    }
+    case 'agent_end':
+      if (event.isTerminal !== false) {
+        host.streaming = false;
+        host.promptRunning = false;
+        host.awaitingAgentStart = false;
+        host.awaitingAgentStartDeadline = 0;
+        host.continuationGraceUntil = 0;
+        clearSessionFileCaches();
+        const aborted = endedAborted(event.messages);
+        if (host.sessionId) void markEndStatus(host.sessionId, event.messages);
+        // A settled run is the moment a session becomes nameable: omp's own
+        // first-message titling is suppressed under `--mode rpc-ui`
+        // (PI_NO_TITLE), so the chamber asks for the same title itself. The
+        // trigger is a no-op once the session carries a name — see
+        // triggerAutoSessionTitle for why that check is the safety property.
+        if (!aborted) void triggerAutoSessionTitle(host);
+        // The run truly ended — the server, not the browser, decides whether a
+        // queued follow-up goes out next. A user-aborted run holds the queue
+        // (stop-all semantics): the next run end or an explicit send picks it up.
+        if (!aborted) scheduleQueueDelivery(host);
+      } else {
+        host.continuationGraceUntil = Date.now() + NON_TERMINAL_CONTINUATION_GRACE_MS;
+      }
+      break;
+    case 'prompt_result':
+      host.promptRunning = false;
+      host.awaitingAgentStart = false;
+      host.awaitingAgentStartDeadline = 0;
+      break;
+    case 'auto_compaction_start':
+      host.compacting = true;
+      break;
+    case 'auto_compaction_end':
+      host.compacting = false;
+      clearSessionFileCaches();
+      break;
+    case 'command_output':
+      // A `command_output` for a command the OPERATOR typed renders as a notice
+      // row. But the chamber fires its own `/rename` after a settled run, and
+      // omp answers it on the same frame — "Session renamed to …", or "Could not
+      // generate a session title" for a low-signal first message. Neither was
+      // asked for, and the second would be pure noise. The frame carries no
+      // correlation id, so attribution is by the request window.
+      result.suppressForward = consumeAutoTitleOutput(host);
+      break;
+    case 'session_info_update':
+      // A rename rewrote the fixed-width title slot in place; the scan cache is
+      // keyed on file mtime, which that write cannot move, so the list must be
+      // rebuilt explicitly.
+      clearSessionFileCaches();
+      result.refreshSessionList = true;
+      break;
+    case 'extension_ui_request':
+      host.trackUiDialog(event);
+      break;
+    // Subagent frames carry no turn state, but they are the only proof that
+    // work is still running once the parent turn has ended.
+    case 'subagent_lifecycle':
+    case 'subagent_progress':
+    case 'subagent_event':
+      host.observeSubagent(event, Date.now());
+      break;
+    case 'response': {
+      if (event.success === false && event.command === 'prompt') {
+        host.promptRunning = false;
+        host.awaitingAgentStart = false;
+        host.awaitingAgentStartDeadline = 0;
+        host.emit({ type: 'prompt_error', errorMessage: (event.error as string) ?? 'Prompt failed' });
+        // The caller's trailing notify covers this: promptRunning just flipped,
+        // so the running snapshot changes and the listeners fire. Suppress only
+        // the forward, or the error would land twice.
+        result.suppressForward = true;
+      }
+      break;
+    }
+  }
+
+  return result;
+}