ompchamber 3.5.0 → 3.6.0

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/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 {

package/src/server/lib/terminal/liveness.server.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Which shells are live, and which of them are doing work.
+ *
+ * Split from the registry that mutates them (`runtime.server.ts`) because the
+ * question is asked from outside the socket: the terminal inventory endpoint
+ * ("which shells can this client adopt?"), and the capacity check that runs
+ * before a new shell is created. Both ask it about every session at once, so
+ * both pay for one `ps` rather than one per shell.
+ *
+ * Two kinds of session are deliberately excluded from `countLiveTerminals`: an
+ * exited shell (a corpse with a scrollback nobody is reading) and a shell
+ * sitting at its prompt — the PTY's foreground process group tells them apart
+ * exactly (see `foreground.ts`). Counting idle shells is how a panel that was
+ * restarted or switched a few times pins the budget with nothing running, and
+ * the next attach is refused.
+ */
+
+import path from 'path';
+import { detectBusyShells, type ShellProcess } from '@/server/lib/terminal/foreground';
+import { snapshotOf } from '@/server/lib/terminal/session.server';
+import { terminalStore } from '@/server/lib/terminal/store';
+import type { TerminalSnapshot } from '@/shared/lib/workspace/terminal/protocol';
+
+/** Shells that are actually doing work, which is what the cap budgets. */
+export async function countLiveTerminals(): Promise<number> {
+  const running: ShellProcess[] = [];
+  for (const session of terminalStore().sessions.values()) {
+    if (session.status !== 'running' || !session.proc) continue;
+    running.push({ id: session.id, pid: session.proc.pid });
+  }
+  const busy = await detectBusyShells(running);
+  return busy.size;
+}
+
+/**
+ * Live terminal summaries, optionally narrowed to one scope, so a client can
+ * adopt a shell it does not have an id for (a reloaded page, a second tab).
+ *
+ * `busy` marks a shell with a foreground command — the panel shows it as
+ * running, and the cap budgets it.
+ */
+export async function listTerminals(root?: string | null, repo?: string | null): Promise<TerminalSnapshot[]> {
+  const scope = root ? (repo && repo !== '.' ? path.join(root, repo) : root) : null;
+  // Resolved once: a scope boundary either ends in a separator already or gets
+  // one, so a sibling directory that merely shares the prefix (`/a/bc`) is not
+  // read as being inside `/a/b`.
+  const scopePrefix = scope && !scope.endsWith(path.sep) ? scope + path.sep : scope;
+
+  const running: ShellProcess[] = [];
+  const out: TerminalSnapshot[] = [];
+  for (const session of terminalStore().sessions.values()) {
+    if (scopePrefix && session.cwd !== scope && !session.cwd.startsWith(scopePrefix)) continue;
+    if (session.status === 'running' && session.proc) {
+      running.push({ id: session.id, pid: session.proc.pid });
+    }
+    out.push(snapshotOf(session));
+  }
+  const busy = await detectBusyShells(running);
+  return out.map((snapshot) => ({ ...snapshot, busy: busy.has(snapshot.id) }));
+}