ompchamber 3.4.0 → 3.6.0

package/src/server/lib/omp/session/delete.server.ts

@@ -0,0 +1,136 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Deleting a session: the transcript on disk, its subagent artifacts, and every
+ * chamber-side row keyed to the session id.
+ *
+ * The transcript is authoritative — omp's own session listing is derived from
+ * the JSONL alone — so a delete that removed only the chamber's rows would see
+ * the session come straight back on the next sidebar scan. What "delete" means
+ * here, in one place:
+ *
+ *   - the session JSONL, plus any `<name>.jsonl.bak-*` copy an earlier rewind
+ *     left beside it (a full copy of the same transcript: leaving it behind
+ *     would mean the conversation was not actually deleted);
+ *   - its sibling artifacts directory, which holds the subagent transcripts;
+ *   - the `archived_sessions`, `session_ui_state`, `session_stream_state`,
+ *     `queued_messages` and `chat_sessions` rows for that id;
+ *   - in mock mode the demo `sessions` row and its `files` tree.
+ *
+ * The caller owns the process: a live omp child MUST be destroyed before this
+ * runs, because omp flushes its session state on shutdown and would otherwise
+ * recreate the file this just removed. Side-question rows and workspaces are
+ * the btw module's business (`purgeBtwForSession`).
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getDb } from '@/server/db.server';
+import type { DbClient } from '@/server/lib/db/client';
+import { findSessionFileById } from '@/server/lib/omp/session/locator';
+import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
+import { invalidateOmpSidebarData } from '@/server/lib/omp/session/reader';
+import { siblingDirForSession } from '@/server/lib/omp/subagent/history/paths';
+import { isSinglePathSegment } from '@/server/lib/fs/path-segment';
+
+export interface SessionPurgeResult {
+  /** Something keyed to this id existed — a transcript, a mock session row, or
+   *  a chamber row. False means the id resolved nowhere at all. */
+  found: boolean;
+  fileRemoved: boolean;
+  artifactsRemoved: boolean;
+}
+
+/**
+ * Chamber rows keyed by a session id. Every statement is a no-op when the id
+ * matches nothing, which is what makes one purge serve both modes: real
+ * sessions (omp UUIDs, present on disk only) and mock ones (numeric ids in
+ * `sessions`).
+ *
+ * `files` carries a FOREIGN KEY to `sessions` and `foreign_keys` is ON, so its
+ * children go before the session row or the delete is refused.
+ */
+const SESSION_ROW_DELETES: readonly (readonly [string, string])[] = [
+  ['archived_sessions', 'session_id'],
+  ['session_ui_state', 'session_id'],
+  ['session_stream_state', 'session_id'],
+  ['queued_messages', 'session_id'],
+  ['chat_sessions', 'session_id'],
+  ['files', 'session_id'],
+];
+
+async function purgeChamberRows(db: DbClient, sessionId: string): Promise<number> {
+  let changes = 0;
+  for (const [table, column] of SESSION_ROW_DELETES) {
+    const result = await db.run(`DELETE FROM ${table} WHERE ${column} = ?`, [sessionId]);
+    changes += result.changes ?? 0;
+  }
+  const mockRow = await db.run('DELETE FROM sessions WHERE id = ?', [sessionId]);
+  return changes + (mockRow.changes ?? 0);
+}
+
+/** Remove the transcript and the `.bak-*` copies beside it. */
+async function removeTranscript(filePath: string): Promise<boolean> {
+  const existed = await Bun.file(filePath).exists();
+  await fs.promises.rm(filePath, { force: true });
+  const dir = path.dirname(filePath);
+  const prefix = `${path.basename(filePath)}.bak-`;
+  try {
+    for (const entry of await fs.promises.readdir(dir)) {
+      if (entry.startsWith(prefix)) await fs.promises.rm(path.join(dir, entry), { force: true });
+    }
+  } catch {
+    // A backup that cannot be listed is not worth failing a delete the
+    // transcript half of which already succeeded.
+  }
+  return existed;
+}
+
+/**
+ * Purge everything the chamber and the agent directory hold for `sessionId`.
+ * `sessionId` must be a single safe path segment — it names the artifacts
+ * directory — which the route validates before calling.
+ */
+export async function purgeSessionData(sessionId: string): Promise<SessionPurgeResult> {
+  // Second gate, independent of the route's: an id that is not one segment
+  // would make `siblingDirForSession` and the btw purge resolve outside the
+  // session it names. Refusing here means a future caller that forgets the
+  // route's guard still cannot widen the blast radius.
+  if (!isSinglePathSegment(sessionId)) {
+    return { found: false, fileRemoved: false, artifactsRemoved: false };
+  }
+
+  const filePath = await findSessionFileById(sessionId);
+  let fileRemoved = false;
+  let artifactsRemoved = false;
+  if (filePath) {
+    fileRemoved = await removeTranscript(filePath);
+    const artifactsDir = siblingDirForSession(filePath);
+    // `stat`, not `Bun.file().exists()`: the latter answers for regular files
+    // only and reports a directory as absent, which would claim every session
+    // had no subagent transcripts.
+    artifactsRemoved = await fs.promises
+      .stat(artifactsDir)
+      .then((stats) => stats.isDirectory(), () => false);
+    await fs.promises.rm(artifactsDir, { recursive: true, force: true });
+  }
+
+  const db = await getDb();
+  const rowChanges = await purgeChamberRows(db, sessionId);
+
+  // Both caches outlive the mutation by their own keys: the file list/scan pair
+  // is mtime-keyed (a delete bumps the parent directory, but the memo can still
+  // answer first) and the sidebar dataset is TTL'd, so without this the deleted
+  // row is served back to the refresh that follows the delete.
+  clearSessionFileCaches();
+  invalidateOmpSidebarData();
+
+  return {
+    found: Boolean(filePath) || rowChanges > 0,
+    fileRemoved,
+    artifactsRemoved,
+  };
+}

package/src/server/lib/omp/session/merge-stored-anchor.test.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Where an unmatched raw turn lands.
+ *
+ * omp answers a builtin on the command path and writes NO session entry for it,
+ * so `/usage` or `/compact` exists only in the chamber's own copy — no JSONL
+ * user turn relates to it, and it cannot be matched into place. It was
+ * positioned by scanning the stored array forward for the next row the JSONL
+ * carried, which only worked because the overlay also held the mirrored rows —
+ * the very rows `overlayRowsForOmpSession` drops. So this is the regression the
+ * narrowing introduced: those turns fell to the END of the timeline, after
+ * answers that came later. The clock fixes it, and the two tests below are the
+ * behaviour and the equivalence.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { mergeOmpAttachments, overlayRowsForOmpSession, type StoredMessage } from '@/server/lib/omp/session/merge-stored';
+
+/** Arbitrary epoch ms, one second per step, so the order is exact. */
+const at = (second: number) => 1_790_000_000_000 + second * 1000;
+
+/** The conversation omp recorded. `/usage` is absent: a builtin writes nothing. */
+function jsonl(): StoredMessage[] {
+  return [
+    { id: 'omp-u1', role: 'user', content: 'first question', startedAt: at(0) },
+    { id: 'omp-a1', role: 'ai', content: 'first answer', startedAt: at(1) },
+    { id: 'omp-u2', role: 'user', content: 'second question', startedAt: at(30) },
+    { id: 'omp-a2', role: 'ai', content: 'second answer', startedAt: at(31) },
+  ];
+}
+
+/** The chamber's copy of the same timeline, built in the order it was lived:
+ *  mirrors and local rows interleaved by time. */
+function storedFull(): StoredMessage[] {
+  return [
+    { id: 'msg-1-user', role: 'user', content: 'first question', startedAt: at(0) },
+    { id: 'omp-a1', role: 'ai', content: 'first answer', startedAt: at(1) },
+    { id: 'msg-2-user', role: 'user', content: '/usage', startedAt: at(2) },
+    { id: 'cmdout-1', role: 'ai', content: '', notice: '/usage output', startedAt: at(3) },
+    { id: 'msg-3-user', role: 'user', content: 'second question', startedAt: at(30) },
+    { id: 'omp-a2', role: 'ai', content: 'second answer', startedAt: at(31) },
+  ];
+}
+
+const order = (messages: StoredMessage[]) => messages.map((m) => m.notice ?? m.content);
+
+describe('unmatched raw turn placement', () => {
+  test('lands where the user sent it, not after the turns that followed', () => {
+    const merged = mergeOmpAttachments(jsonl(), JSON.stringify(overlayRowsForOmpSession(storedFull())));
+
+    expect(order(merged)).toEqual([
+      'first question',
+      'first answer',
+      '/usage',
+      '/usage output',
+      'second question',
+      'second answer',
+    ]);
+  });
+
+  test('narrowing the overlay does not move it', () => {
+    const full = mergeOmpAttachments(jsonl(), JSON.stringify(storedFull()));
+    const narrowed = mergeOmpAttachments(
+      jsonl(),
+      JSON.stringify(overlayRowsForOmpSession(storedFull())),
+    );
+
+    expect(narrowed).toEqual(full);
+  });
+
+  test('a turn with no clock to read still renders rather than being dropped', () => {
+    const clockless: StoredMessage[] = [
+      { id: 'msg-1-user', role: 'user', content: 'first question', startedAt: at(0) },
+      { id: 'msg-2-user', role: 'user', content: '/usage' },
+    ];
+
+    const merged = mergeOmpAttachments(jsonl(), JSON.stringify(clockless));
+
+    expect(order(merged)).toContain('/usage');
+    expect(merged.some((m) => m.startedAt === at(0))).toBe(true);
+  });
+});

package/src/server/lib/omp/session/merge-stored-overlay-rows.test.ts

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The overlay narrowing. For a session omp owns on disk the transcript lives in
+ * the JSONL, so the chamber's copy only has to carry what omp cannot record
+ * there — the user turns (raw composer text, attachment metadata) and the notice
+ * rows. Everything else was a mirror written on every `message_end`.
+ *
+ * The load-bearing property is the EQUIVALENCE below: narrowing the stored copy
+ * must not change a single rendered row. `mergeOmpAttachments` is the only
+ * reader, and it reads user rows and notices only — if that ever stops being
+ * true, this test fails rather than the timeline silently losing turns.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { mergeOmpAttachments, overlayRowsForOmpSession, type StoredMessage } from '@/server/lib/omp/session/merge-stored';
+
+const NOTICE = 'Context window: 1000000 tokens (1% used)';
+
+/** The conversation as omp wrote it: the `@agent` turn was delivered as a task
+ *  delegation prompt, and the builtin command wrote no entry at all. */
+function jsonl(): StoredMessage[] {
+  return [
+    { id: 'omp-u1', role: 'user', content: 'hello' },
+    { id: 'omp-a1', role: 'ai', content: 'hi there' },
+    { id: 'omp-u2', role: 'user', content: 'Use the task tool to delegate this request: @agent' },
+    { id: 'omp-a2', role: 'ai', content: 'delegated' },
+  ];
+}
+
+/** The same conversation as the chamber mirrored it: its own id on the turns the
+ *  user typed, the attachment metadata the JSONL cannot carry, and the command's
+ *  notice row — which is the only place its output exists at all. */
+function storedFull(): StoredMessage[] {
+  return [
+    { id: 'msg-1-user', role: 'user', content: 'hello' },
+    { id: 'omp-a1', role: 'ai', content: 'hi there' },
+    {
+      id: 'msg-2-user',
+      role: 'user',
+      content: '@agent',
+      attachments: [{ name: 'notes.md', content: '# notes' }],
+    },
+    { id: 'omp-a2', role: 'ai', content: 'delegated' },
+    { id: 'cmdout-1', role: 'ai', content: '', notice: NOTICE },
+  ];
+}
+
+describe('overlayRowsForOmpSession', () => {
+  test('keeps the user turns and the notice rows, in their original order', () => {
+    const kept = overlayRowsForOmpSession(storedFull());
+
+    expect(kept.map((m) => m.id)).toEqual(['msg-1-user', 'msg-2-user', 'cmdout-1']);
+  });
+
+  test('keeps the attachment metadata the JSONL cannot carry', () => {
+    const kept = overlayRowsForOmpSession(storedFull());
+
+    expect(kept[1].attachments).toEqual([{ name: 'notes.md', content: '# notes' }]);
+  });
+
+  test('drops every role the merge never reads, including assistant rows', () => {
+    const rows: StoredMessage[] = [
+      { id: 'u', role: 'user', content: 'ask' },
+      { id: 'a', role: 'ai', content: 'answer' },
+      { id: 'as', role: 'assistant', content: 'answer' },
+      { id: 's', role: 'system', content: 'You are helpful.' },
+    ];
+
+    expect(overlayRowsForOmpSession(rows).map((m) => m.id)).toEqual(['u']);
+  });
+
+  test('drops a notice with no text and entries that are not objects', () => {
+    const rows = [
+      null,
+      'a bare string',
+      42,
+      { id: 'blank', role: 'ai', content: '', notice: '   \n  ' },
+      { id: 'kept', role: 'ai', content: '', notice: NOTICE },
+    ];
+
+    expect(overlayRowsForOmpSession(rows as StoredMessage[]).map((m) => m.id)).toEqual(['kept']);
+  });
+
+  test('narrows the stored copy without changing a single rendered row', () => {
+    const full = mergeOmpAttachments(jsonl(), JSON.stringify(storedFull()));
+    const narrowed = mergeOmpAttachments(
+      jsonl(),
+      JSON.stringify(overlayRowsForOmpSession(storedFull())),
+    );
+
+    expect(narrowed).toEqual(full);
+    // The rows only the overlay could supply are still there: the turn as the
+    // user typed it (`@agent`, not the delegation prompt omp delivered) and the
+    // command notice, which the session file never recorded.
+    expect(narrowed.map((m) => m.notice ?? m.content)).toEqual([
+      'hello',
+      'hi there',
+      '@agent',
+      NOTICE,
+      'delegated',
+    ]);
+  });
+});

package/src/server/lib/omp/session/merge-stored.ts

@@ -41,6 +41,14 @@ export interface StoredMessage {
   content: string;
   date?: string;
   timestamp?: string;
+  /**
+   * When omp recorded the entry, in epoch ms — `toChatMessage` stamps every
+   * JSONL-derived row with it, and the chamber's own rows carry the clock they
+   * were created at. It is what positions a raw turn that no JSONL turn relates
+   * to (see `anchorIndexFor`); `date` cannot serve, because a chamber row's is a
+   * display string ("Today, 03:57 PM") rather than an ISO instant.
+   */
+  startedAt?: number;
   attachments?: StoredAttachment[];
   /**
    * A notice row — omp's own reminder/task-result entries, or the chamber's
@@ -52,6 +60,39 @@ export interface StoredMessage {
   notice?: string;
 }
 
+/**
+ * The only rows a chamber overlay needs for a session whose transcript omp owns
+ * on disk: the user turns (the raw composer text and the attachment metadata the
+ * JSONL cannot record) and the notice rows (builtin command output, which omp
+ * writes nowhere).
+ *
+ * Every other row is a mirror of a JSONL entry: this module never reads one, and
+ * rewriting the transcript on every `message_end` is what grew the overlay to
+ * the size of the conversation it copies — measured at 165.6 MB of 167.9 MB of
+ * `ai` rows that nothing consumes. A session with NO session file is a different
+ * case and must stay whole — there the DB is the only copy — so callers gate on
+ * the file, never on the id's shape.
+ *
+ * The merge depends on no mirror to place a turn either: a stored raw turn that
+ * no JSONL user turn relates to is positioned by its own clock
+ * (`anchorIndexFor`), not by scanning the stored array for a row the JSONL still
+ * carries — which is what makes this narrowing self-sufficient rather than a
+ * change that quietly moves a `/usage` or `/compact` bubble to the end of the
+ * timeline. Verified against this install's own files: of 260 stored sessions
+ * compared against their JSONLs, only the turns whose anchor the scan had been
+ * supplying change position, and they change to the time they were sent.
+ */
+export function overlayRowsForOmpSession<T>(messages: T[]): T[] {
+  return messages.filter((message) => {
+    if (typeof message !== 'object' || message === null) return false;
+    const record = message as { role?: unknown; notice?: unknown };
+    if (record.role === 'user') return true;
+    // Whitespace-only notices are dropped by the merge anyway; keeping one would
+    // only carry bytes no renderer ever shows.
+    return typeof record.notice === 'string' && record.notice.trim().length > 0;
+  });
+}
+
 function isRawComposerInput(content: string): boolean {
   return /^\s*\//.test(content) || /(^|\s)@[A-Za-z0-9_-]+/.test(content);
 }
@@ -100,6 +141,40 @@ function mergeAttachmentLists(
   return [...merged, ...remaining];
 }
 
+/**
+ * Where an unmatched raw turn belongs in the merged timeline.
+ *
+ * Its own clock decides: the turn was typed before the next row omp recorded
+ * after it, so it is inserted ahead of the first merged row that carries a later
+ * `startedAt`. This replaced a scan for "the next stored row the JSONL still
+ * carries" — that scan worked only while the overlay also held the mirrored
+ * rows, which are exactly the rows `overlayRowsForOmpSession` drops, so it sent
+ * every such turn to the tail of the timeline of a narrowed session (measured:
+ * a `/usage` or `/compact` turn, 7 of them in one install).
+ *
+ * The scan is kept for a row with no clock to read — a legacy stored turn —
+ * where it still resolves against an un-narrowed overlay, and `merged.length`
+ * (append at the end) is the last resort rather than a silent drop.
+ */
+function anchorIndexFor(
+  raw: StoredMessage,
+  merged: StoredMessage[],
+  jsonlIndex: Map<string, number>,
+  stored: StoredMessage[],
+): number {
+  const at = raw.startedAt;
+  if (typeof at === 'number' && Number.isFinite(at)) {
+    const after = merged.findIndex((m) => typeof m.startedAt === 'number' && m.startedAt > at);
+    if (after !== -1) return after;
+  }
+  for (let i = stored.indexOf(raw) + 1; i < stored.length; i += 1) {
+    const id = stored[i]?.id;
+    const found = typeof id === 'string' ? jsonlIndex.get(id) : undefined;
+    if (found !== undefined) return found;
+  }
+  return merged.length;
+}
+
 /** Merge user turns and attachments from the chamber DB copy onto the
  *  JSONL-loaded messages. */
 export function mergeOmpAttachments(
@@ -136,21 +211,13 @@ export function mergeOmpAttachments(
     return attachments.length ? { ...next, attachments } : next;
   });
 
-  // Unmatched raw turns are anchored before the next stored message the JSONL
-  // still carries; splice highest-anchor-first so earlier indices stay valid.
+  // Unmatched raw turns are positioned by their own clock, and spliced
+  // highest-anchor-first so earlier indices stay valid.
   const insertions = new Map<number, StoredMessage[]>();
   storedUsers.forEach((storedMsg, userIndex) => {
     if (used.has(userIndex) || !isRawComposerInput(storedMsg.content)) return;
     if (storedMsg.id && jsonlIndex.has(storedMsg.id)) return;
-    let anchor = merged.length;
-    for (let i = stored.indexOf(storedMsg) + 1; i < stored.length; i += 1) {
-      const id = stored[i]?.id;
-      const found = typeof id === 'string' ? jsonlIndex.get(id) : undefined;
-      if (found !== undefined) {
-        anchor = found;
-        break;
-      }
-    }
+    const anchor = anchorIndexFor(storedMsg, merged, jsonlIndex, stored);
     const group = insertions.get(anchor);
     if (group) group.push(storedMsg);
     else insertions.set(anchor, [storedMsg]);

package/src/server/lib/omp/session/reader.ts

@@ -60,6 +60,19 @@ export async function loadOmpSidebarData(): Promise<OmpSidebarData> {
   return slot.inFlight;
 }
 
+/**
+ * Drop the cached dataset so the next load re-scans disk. For a mutation the
+ * TTL cannot see: deleting a session removes a row rather than changing one, so
+ * nothing in the cached snapshot is stale — it is simply wrong, and the refresh
+ * that follows the delete would otherwise serve it back for up to the TTL.
+ */
+export function invalidateOmpSidebarData(): void {
+  const slot = globalThis.__ompChamberSidebarDataCache;
+  if (!slot) return;
+  slot.data = undefined as unknown as OmpSidebarData;
+  slot.expiresAt = 0;
+}
+
 /** Resolve each unique cwd to its project root; bounded concurrency so 100+
  *  unique cwds don't spawn 100 parallel git processes. */
 async function resolveRootsByCwd(cwds: string[]): Promise<Map<string, string>> {

package/src/server/lib/omp/session/reload.server.test.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * omp discovers plugins once per process, so a skill written while a session
+ * runs is invisible to it until a reload. `/reload-plugins` is the refresh, and
+ * it is only safe to send to an IDLE session: it answers `agentInvoked: false`
+ * (no model turn, nothing written to the transcript), but a prompt dispatched
+ * into a RUNNING turn is a queue insert with user-visible consequences. The
+ * busy guard is therefore an invariant, not an optimization — a broadcast that
+ * ignored it would inject a command into every in-flight turn.
+ */
+
+import { afterAll, describe, expect, mock, test } from 'bun:test';
+
+interface FakeSession {
+  sessionId: string;
+  isBusy: () => boolean;
+  send: (command: unknown) => Promise<unknown>;
+}
+
+const sent: Array<{ sessionId: string; command: unknown }> = [];
+let sessions: FakeSession[] = [];
+let failFor: string | null = null;
+
+mock.module('@/server/lib/omp/rpc/session-registry', () => ({
+  listRpcSessions: () => sessions,
+}));
+
+// Static import cannot work here: `mock.module` only intercepts modules
+// registered BEFORE the importer is evaluated, so the module under test has to
+// load after the mock is in place.
+const { reloadLiveSessions } = await import('@/server/lib/omp/session/reload.server');
+
+function session(sessionId: string, busy: boolean): FakeSession {
+  return {
+    sessionId,
+    isBusy: () => busy,
+    async send(command: unknown) {
+      if (failFor === sessionId) throw new Error('session gone');
+      sent.push({ sessionId, command });
+      return { agentInvoked: false };
+    },
+  };
+}
+
+describe('reloadLiveSessions', () => {
+  test('sends /reload-plugins to idle sessions only', async () => {
+    sent.length = 0;
+    failFor = null;
+    sessions = [session('idle-1', false), session('busy-1', true), session('idle-2', false)];
+
+    const reloaded = await reloadLiveSessions();
+
+    expect(reloaded.sort()).toEqual(['idle-1', 'idle-2']);
+    expect(sent.map((entry) => entry.sessionId).sort()).toEqual(['idle-1', 'idle-2']);
+    // The prompt form is the point: no RPC command exists for a reload.
+    expect(sent.every((entry) => JSON.stringify(entry.command) === JSON.stringify({ type: 'prompt', message: '/reload-plugins' }))).toBe(true);
+  });
+
+  test('a failing session does not stop the others', async () => {
+    sent.length = 0;
+    failFor = 'idle-1';
+    sessions = [session('idle-1', false), session('idle-2', false)];
+
+    const reloaded = await reloadLiveSessions();
+
+    expect(reloaded).toEqual(['idle-2']);
+    expect(sent.map((entry) => entry.sessionId)).toEqual(['idle-2']);
+  });
+
+  test('no live sessions is a no-op', async () => {
+    sent.length = 0;
+    failFor = null;
+    sessions = [];
+
+    expect(await reloadLiveSessions()).toEqual([]);
+    expect(sent.length).toBe(0);
+  });
+});
+
+afterAll(() => {
+  mock.restore();
+});

package/src/server/lib/omp/session/reload.server.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Refresh the plugin/skill inventory of the LIVE omp children.
+ *
+ * omp discovers skills, commands and plugins once per process and does not
+ * watch the filesystem: a SKILL.md written while a session runs is invisible to
+ * that session until it restarts (measured: `get_available_commands` kept
+ * reporting 8 skill entries after a ninth landed on disk, and `/skill:<new>`
+ * resolved to nothing). The only refresh omp exposes is the `/reload-plugins`
+ * builtin, which has a text-mode `handle` — so it is reachable as a prompt.
+ *
+ * Verified against omp 18.3.5: sending `/reload-plugins` as a prompt answers
+ * `agentInvoked: false` (no model turn), writes nothing to the transcript, and
+ * emits `available_commands_update`, after which the new skill is listed and
+ * runnable. That is what makes broadcasting it safe.
+ *
+ * Only IDLE sessions are reloaded. A busy session is mid-turn, and a prompt
+ * dispatched into a running turn is a queue insert with user-visible
+ * consequences; its next turn picks the new skills up from the restart path
+ * instead. Best-effort: one session failing never blocks the others.
+ */
+
+import { listRpcSessions } from '@/server/lib/omp/rpc/session-registry';
+
+/** Ask every idle live session to re-discover plugins. Returns the ids that
+ *  accepted the reload. */
+export async function reloadLiveSessions(): Promise<string[]> {
+  const reloaded: string[] = [];
+  await Promise.all(
+    listRpcSessions().map(async (session) => {
+      if (session.isBusy()) return;
+      try {
+        await session.send({ type: 'prompt', message: '/reload-plugins' });
+        reloaded.push(session.sessionId);
+      } catch (error) {
+        console.error(
+          `Failed to reload plugins for session ${session.sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }),
+  );
+  return reloaded;
+}

package/src/server/lib/omp/session/subagent-presence.ts

@@ -21,7 +21,7 @@
  * parse it exists to avoid.
  */
 
-import { promises as fs } from 'fs';
+import { promises as fs, statSync } from 'fs';
 import { extractSubagentHistory } from '@/server/lib/omp/subagent/history';
 import { siblingDirForSession } from '@/server/lib/omp/subagent/history/paths';
 
@@ -35,9 +35,33 @@ const MAX_ENTRIES = 2_000;
 
 const cache = new Map<string, PresenceEntry>();
 
-async function siblingDirMtimeMs(dir: string): Promise<number> {
+/**
+ * Version of the sibling artifacts directory, or `0` when it does not exist —
+ * which is the COMMON case, since most sessions never spawn a subagent.
+ *
+ * The stat is SYNC (`statSync` + `throwIfNoEntry: false`) rather than an
+ * awaited `fs.stat`, because an awaited one rejects on that common path and a
+ * caught rejection from `fs` is still reported by Bun's rejection tracker when
+ * this module is re-evaluated by `bun run --hot` — the dev server, and any
+ * `ompchamber serve` whose NODE_ENV is unset. The result was a full ENOENT
+ * report with a `Bun v1.4.2` footer printed over a healthy server's own sidebar
+ * polls. Measured on Bun 1.4.2 against this exact function — 40 concurrent
+ * probes per request, 40 module rewrites, 6 runs: `try { await fs.stat(dir) }
+ * catch {}` reported ENOENT 8-12 times, `.catch()` 4-8 times, while both
+ * `throwIfNoEntry: false` and `statSync` reported zero, all yielding the same
+ * `0` and the same `hasSubagents: false`. The distinguishing property is not
+ * the error handling but whether a rejected promise is created at all; a sync
+ * throw is caught on the spot and never reaches the tracker.
+ *
+ * Cost is not a concern: 343 sessions (this machine's sidebar) cost 0.37 ms per
+ * poll versus 0.32 ms for the async form — 0.055 ms, on a poll that runs at
+ * most every few seconds.
+ */
+function siblingDirVersion(dir: string): number {
   try {
-    return (await fs.stat(dir)).mtimeMs;
+    // Only ENOENT is suppressed; EACCES and the like still throw and are
+    // swallowed here, leaving the `0` contract intact.
+    return statSync(dir, { throwIfNoEntry: false })?.mtimeMs ?? 0;
   } catch {
     return 0;
   }
@@ -48,17 +72,24 @@ export async function sessionHasSubagents(
   sessionLastEntryAt: string,
 ): Promise<boolean> {
   const siblingDir = siblingDirForSession(sessionPath);
-  const version = `${sessionLastEntryAt}:${await siblingDirMtimeMs(siblingDir)}`;
+  const siblingMtime = siblingDirVersion(siblingDir);
+  const version = `${sessionLastEntryAt}:${siblingMtime}`;
 
   const cached = cache.get(sessionPath);
   if (cached && cached.version === version) return cached.hasSubagents;
 
   let hasSubagents = false;
-  try {
-    const files = await fs.readdir(siblingDir);
-    hasSubagents = files.some((file) => file.endsWith('.jsonl'));
-  } catch {
-    hasSubagents = false;
+  // Guarded on the version: an unguarded readdir on the absent dir is the same
+  // spurious-rejection leak, and it rejects on the same sessions. The try/catch
+  // is what remains for a genuine read failure (the dir removed between the
+  // stat and here), which is rare enough not to be the reported noise.
+  if (siblingMtime !== 0) {
+    try {
+      const files = await fs.readdir(siblingDir);
+      hasSubagents = files.some((file) => file.endsWith('.jsonl'));
+    } catch {
+      hasSubagents = false;
+    }
   }
   if (!hasSubagents) {
     try {