ompchamber 1.2.1 → 2.0.0

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

@@ -51,8 +51,6 @@ export interface SessionFrameHost extends AutoTitleHost, QueueDeliveryHost {
 
 /** 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
@@ -88,7 +86,7 @@ async function markEndStatus(sessionId: string, messages: unknown): Promise<void
 
 /** Apply one frame to the wrapper's runtime state. */
 export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): FrameFoldResult {
-  const result: FrameFoldResult = { refreshSessionList: false, suppressForward: false };
+  const result: FrameFoldResult = { suppressForward: false };
 
   switch (event.type) {
     case 'agent_start':
@@ -97,8 +95,12 @@ export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): Fra
       host.awaitingAgentStart = false;
       host.awaitingAgentStartDeadline = 0;
       host.continuationGraceUntil = 0;
+      // One early auto-title attempt per run, not per conversation: the flag is
+      // reset here so a run that opens after an aborted one (which skipped the
+      // settle attempt) still gets its own early try. The eligibility latch is
+      // what bounds this to the conversation's first run.
+      host.autoTitleRequested = false;
       clearSessionFileCaches();
-      result.refreshSessionList = true;
       if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
       break;
     case 'turn_start':
@@ -113,19 +115,34 @@ export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): Fra
       // 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');
+    case 'message_end': {
+      // A settled USER message is the earliest point at which the transcript
+      // carries the conversation's opening intent, so it is the earliest a
+      // title can be derived from it.
+      //
+      // `agent_start` is too early, and that is not an implementation detail
+      // but a property of omp's event order: the agent loop pushes
+      // `agent_start` BEFORE the turn opens, and the user's message rides
+      // `emitInputMessages` inside that turn. Measured on omp 18.3.0: the
+      // user message lands ~120ms after `agent_start`, so a `/rename` fired
+      // there reads `messageCount: 0`, builds an empty title context, and omp
+      // answers "Could not generate a session title". `message_start` is
+      // equally too early — the message is appended to the agent's state on
+      // `message_end`, so only here does `get_state` report it.
+      //
+      // The latch makes a later user message (a queued steer) a no-op, and a
+      // session that resumed an existing conversation is ineligible from the
+      // start. `agent_end` below retries if this attempt produced nothing.
+      const message = event.message as Record<string, unknown> | undefined;
+      if (message?.role === 'user') void triggerAutoSessionTitle(host, 'opening');
       break;
     }
+    // `turn_end` is deliberately NOT handled here: a multi-turn run emits it for
+    // EVERY turn (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, so no turn-level stopReason can be read
+    // as "the run is over". The terminal badge is written from `agent_end`
+    // alone (markEndStatus), which is the only frame that knows.
     case 'agent_end':
       if (event.isTerminal !== false) {
         host.streaming = false;
@@ -136,12 +153,15 @@ export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): Fra
         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);
+        // Fallback for the early attempt: the first user message fires `/rename`
+        // before the turn runs, and that attempt can come back empty (a provider
+        // error, a timeout, a child that went away, or the tiny model
+        // declining). The run end is the last moment a title can still be
+        // derived from this conversation's OPENING turn, so retry here.
+        //
+        // An aborted run still skips: the operator stopped the turn, and the
+        // next completed run is a better moment than a half-run transcript.
+        if (!aborted) void triggerAutoSessionTitle(host, 'settle');
         // 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.
@@ -164,8 +184,8 @@ export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): Fra
       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
+      // row. But the chamber fires its own `/rename` in the background, 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.
@@ -176,7 +196,6 @@ export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): Fra
       // 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);

package/src/server/lib/omp/rpc/lifecycle.test.ts

@@ -60,6 +60,33 @@ async function rejectionOf(operation: Promise<unknown>): Promise<WebRpcError> {
   return error as WebRpcError;
 }
 
+/** A process that completes the readiness handshake, so `waitUntilReady`
+ *  reaches the `get_state` probe whose message count seeds the title latch. */
+function makeReadyProc(messageCount: number): RpcProcess {
+  const proc = {
+    isAlive: true,
+    pid: 4243,
+    onFrame() {
+      return () => {};
+    },
+    waitReady() {
+      return Promise.resolve({ type: 'ready' });
+    },
+    negotiateProtocol() {
+      return Promise.resolve(1);
+    },
+    sendCommand(command: { type: string }) {
+      if (command.type === 'get_state') {
+        return Promise.resolve({ sessionId: 'sess-1', sessionFile: '/tmp/s.jsonl', messageCount, isStreaming: false, isCompacting: false });
+      }
+      return Promise.resolve(undefined);
+    },
+    sendFrame() {},
+    async dispose() {},
+  };
+  return proc as unknown as RpcProcess;
+}
+
 describe('AgentSessionWrapper lifecycle', () => {
   // Every command arms the wrapper's idle timer; keep the clock fake so a test
   // never schedules a real ten-minute window.
@@ -135,4 +162,18 @@ describe('AgentSessionWrapper lifecycle', () => {
 
     expect(stub.disposeCount()).toBe(1);
   });
+
+  test('a fresh conversation is title-eligible, a resumed one is not', async () => {
+    // omp reports the messages it restored, so `messageCount` is the only
+    // signal that separates "this session has no first turn yet" from "this
+    // child resumed a conversation that already has one". Getting it wrong
+    // re-titles an existing session from its newest turn.
+    const fresh = new AgentSessionWrapper(makeReadyProc(0), '/tmp');
+    await fresh.waitUntilReady();
+    expect(fresh.autoTitlePending).toBe(true);
+
+    const resumed = new AgentSessionWrapper(makeReadyProc(2), '/tmp');
+    await resumed.waitUntilReady();
+    expect(resumed.autoTitlePending).toBe(false);
+  });
 });

package/src/server/lib/omp/rpc/manager.ts

@@ -18,7 +18,6 @@
 import { RpcProcess, type RpcFrame } from '@/server/lib/omp/rpc/process';
 import { PendingUiDialogs } from '@/server/lib/omp/rpc/pending-ui-dialogs';
 import { foldSessionFrame } from '@/server/lib/omp/rpc/frame-fold';
-import { notifyRunningChange } from '@/server/lib/omp/rpc/session-registry';
 import { dispatchSessionCommand } from '@/server/lib/omp/rpc/session-commands';
 import { SubagentLiveness } from '@/server/lib/omp/rpc/subagent-liveness';
 import { markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
@@ -67,10 +66,19 @@ export class AgentSessionWrapper {
   // set in initialize(). No other flag on this wrapper can see them, and an
   // idle reclaim or a spawn-mode reconcile must never kill a running subagent.
   private readonly subagents = new SubagentLiveness();
-  // One background `/rename` at a time. A settled run may be followed by
-  // another (queue delivery, a second prompt), and two overlapping generations
-  // would race to write the same title slot.
+  // One background `/rename` at a time. The first run makes up to two attempts
+  // (the early one at the first user message, the fallback at run end), and two
+  // overlapping generations would race to write the same title slot.
   autoTitleInFlight = false;
+  // One-shot: the FIRST run of this conversation is the only one the chamber
+  // may ask omp to name it from. Seeded in applyIdentity from omp's own message
+  // count, so a session reclaimed and respawned with `--resume` (which reports
+  // the messages it restored) never re-titles from its newest turn.
+  autoTitlePending = true;
+  // True once this run's early attempt (the first settled user message) has
+  // been made. Reset at each `agent_start`, so a queued steer message inside the
+  // same run cannot re-ask and cancel the generation already in flight.
+  autoTitleRequested = false;
   // Epoch ms until which `command_output` frames belong to our own background
   // rename and must not reach the timeline. 0 when nothing is outstanding.
   autoTitleWindowUntil = 0;
@@ -129,7 +137,6 @@ export class AgentSessionWrapper {
   start(): void {
     this.unsubscribeFrames = this.proc.onFrame((frame) => this.handleFrame(frame));
     this.resetIdleTimer();
-    notifyRunningChange();
   }
 
   /** Resolves once the child announced readiness and identity is known. */
@@ -162,6 +169,12 @@ export class AgentSessionWrapper {
     this.streaming = state.isStreaming;
     this.compacting = state.isCompacting;
     this.fastModeEnabled = state.fastModeEnabled ?? state.fastMode ?? this.fastModeEnabled;
+    // omp reports the messages it restored, so a child spawned for an EXISTING
+    // conversation (a `--resume` after the idle reclaim, or a session opened
+    // from the sidebar) already has a first turn behind it — it must never be
+    // titled from whatever the operator asks next. Only a conversation with no
+    // messages at all is eligible, which is exactly the fresh-spawn case.
+    this.autoTitlePending = state.messageCount === 0;
   }
 
   handleProcessExit(stderrTail: string): void {
@@ -194,14 +207,11 @@ export class AgentSessionWrapper {
     const event = frame as AgentEvent;
     // The state machine and its settle-time side effects live in frame-fold.ts;
     // this method owns only the wrapper's own bookkeeping around it.
-    const { refreshSessionList, suppressForward } = foldSessionFrame(this, event);
+    const { suppressForward } = foldSessionFrame(this, event);
     // `suppressForward` withholds only the FRAME — a failed prompt response
     // already emitted its own `prompt_error`, and the chamber's own background
-    // rename must not surface its diagnostics. The running-state notification
-    // still fires: the fold just cleared `promptRunning`, and that flip is what
-    // releases the sidebar's spinner.
+    // rename must not surface its diagnostics.
     if (!suppressForward) this.emit(event);
-    notifyRunningChange({ refreshSessionList });
   }
 
   emit(event: AgentEvent): void {
@@ -255,14 +265,6 @@ export class AgentSessionWrapper {
     this.onDestroyCallback = cb;
   }
 
-  async withFinalRunningNotification<T>(operation: () => Promise<T>): Promise<T> {
-    try {
-      return await operation();
-    } finally {
-      notifyRunningChange();
-    }
-  }
-
   /** Persist the session identity omp reports in a get_state payload. */
   adoptSessionIdentity(state: RpcSessionState): void {
     if (!state.sessionId) return;
@@ -298,11 +300,9 @@ export class AgentSessionWrapper {
     this.continuationGraceUntil = 0;
     const disposed = this.proc.dispose().catch(() => {});
     this.destroyPromise = disposed;
-    notifyRunningChange();
     await disposed;
     this.onDestroyCallback?.();
   }
 }
 
-export type { RunningRpcSession, RunningSessionUpdate } from '@/server/lib/omp/rpc/session-registry';
-export { getRpcSession, getRunningRpcSessions, getRunningRpcSessionIds, subscribeRunningSessions, notifyRunningChange, startRpcSession, prewarmRpcSession, startNewRpcSession } from '@/server/lib/omp/rpc/session-registry';
+export { getRpcSession, startRpcSession, prewarmRpcSession, startNewRpcSession } from '@/server/lib/omp/rpc/session-registry';

package/src/server/lib/omp/rpc/pending-ui-dialogs.ts

@@ -26,22 +26,26 @@ export class PendingUiDialogs {
   // answer them in — a Map preserves it.
   private readonly requests = new Map<string, RpcFrame>();
 
-  /** Record an answerable request, or forget one omp withdrew (`cancel`). */
-  track(frame: RpcFrame): void {
+  /** Record an answerable request, or forget one omp withdrew (`cancel`).
+   *  Returns whether the pending set changed — a caller that republishes state
+   *  on every frame would otherwise republish for `notify`/`open_url` too. */
+  track(frame: RpcFrame): boolean {
     if (frame.method === 'cancel') {
       const targetId = typeof frame.targetId === 'string' ? frame.targetId : '';
-      if (targetId) this.requests.delete(targetId);
-      return;
+      return targetId ? this.requests.delete(targetId) : false;
     }
     const id = typeof frame.id === 'string' ? frame.id : '';
-    if (!id || typeof frame.method !== 'string' || !ANSWERABLE_UI_METHODS.has(frame.method)) return;
+    if (!id || typeof frame.method !== 'string' || !ANSWERABLE_UI_METHODS.has(frame.method)) return false;
+    // A repeat of the same id is not a change.
+    if (this.requests.has(id)) return false;
     this.requests.set(id, frame);
+    return true;
   }
 
   /** Forget a request once its response is on the wire — omp will not raise it
    *  again, so replaying it to a later client would only show a dead modal. */
-  resolve(id: string): void {
-    this.requests.delete(id);
+  resolve(id: string): boolean {
+    return this.requests.delete(id);
   }
 
   /** Still-blocking requests, oldest first. */

package/src/server/lib/omp/rpc/session-commands.ts

@@ -12,7 +12,6 @@
 import { RpcCommandTimeoutError, type RpcProcess } from '@/server/lib/omp/rpc/process';
 import { AWAITING_AGENT_START_TIMEOUT_MS, GET_STATE_TIMEOUT_MS, IMAGE_BEARING_COMMANDS, PASSTHROUGH_COMMANDS, PROMPT_ACK_TIMEOUT_MS, RESTARTING_MESSAGE, SESSION_BUSY_MESSAGE, WebRpcError, toImageContents, type AgentEvent, type RpcSessionState, validateAgentImages } from '@/server/lib/omp/rpc/constants';
 import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
-import { notifyRunningChange } from '@/server/lib/omp/rpc/session-registry';
 import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
 import { clearStreamStatus, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
 import { buildWebState, type WebStateHost } from '@/server/lib/omp/rpc/web-state';
@@ -34,7 +33,6 @@ export interface SessionCommandHost extends WebStateHost {
   resetIdleTimer(force?: boolean): void;
   /** Forget a pending ask/approval dialog once its response is sent. */
   resolvePendingUiDialog(id: string): void;
-  withFinalRunningNotification<T>(operation: () => Promise<T>): Promise<T>;
   destroyAndWait(): Promise<void>;
 }
 
@@ -87,7 +85,6 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         host.awaitingAgentStartDeadline = 0;
         host.continuationGraceUntil = 0;
         if (ownsStreamRow) void markStreamStatus(host.sessionId, 'stream');
-        notifyRunningChange();
       }
       try {
         const ack = await host.proc.sendCommand<{ agentInvoked?: boolean } | undefined>({
@@ -102,7 +99,6 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
           host.awaitingAgentStartDeadline = 0;
           releaseStreamRow();
           host.emit({ type: 'prompt_result', agentInvoked: false });
-          notifyRunningChange();
           // Nothing ran (agent was idle and declined) — the queue may hold the
           // next item; give it the same delivery window a run end would.
           scheduleQueueDelivery(host);
@@ -115,7 +111,6 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         host.awaitingAgentStart = false;
         host.awaitingAgentStartDeadline = 0;
         releaseStreamRow();
-        notifyRunningChange();
         // The ack may simply be queued behind a running turn: omp accepts the
         // prompt before the turn it starts. No reset, and the client must not
         // resend — a duplicate prompt would run twice.
@@ -130,14 +125,12 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
     }
 
     case 'abort':
-      await host.withFinalRunningNotification(async () => {
-        await host.proc.sendCommand({ type: 'abort' });
-        host.promptRunning = false;
-        host.awaitingAgentStart = false;
-        host.awaitingAgentStartDeadline = 0;
-        host.continuationGraceUntil = 0;
-        if (host.sessionId) void markStreamStatus(host.sessionId, 'abort');
-      });
+      await host.proc.sendCommand({ type: 'abort' });
+      host.promptRunning = false;
+      host.awaitingAgentStart = false;
+      host.awaitingAgentStartDeadline = 0;
+      host.continuationGraceUntil = 0;
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'abort');
       return null;
 
     // Escape hatch behind the Stop button: `abort` resolves only once the turn
@@ -173,26 +166,23 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
 
     case 'compact': {
       try {
-        return await host.withFinalRunningNotification(async () => {
-          host.compacting = true;
-          notifyRunningChange();
-          try {
-            const result = await host.proc.sendCommand<{ summary?: string; tokensBefore?: number; estimatedTokensAfter?: number }>({
-              type: 'compact',
-              ...(command.customInstructions ? { customInstructions: command.customInstructions } : {}),
-            });
-            return result;
-          } finally {
-            host.compacting = false;
-          }
-        });
+        host.compacting = true;
+        try {
+          const result = await host.proc.sendCommand<{ summary?: string; tokensBefore?: number; estimatedTokensAfter?: number }>({
+            type: 'compact',
+            ...(command.customInstructions ? { customInstructions: command.customInstructions } : {}),
+          });
+          return result;
+        } finally {
+          host.compacting = false;
+        }
       } finally {
         clearSessionFileCaches();
       }
     }
 
     case 'abort_compaction':
-      await host.withFinalRunningNotification(() => host.proc.sendCommand({ type: 'abort' }));
+      await host.proc.sendCommand({ type: 'abort' });
       return null;
 
     case 'set_session_name': {
@@ -215,13 +205,11 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         throw new Error('Cannot run a shell command while the session is busy');
       }
       host.bashRunning = true;
-      notifyRunningChange();
       try {
         return await host.proc.sendCommand<{ output?: string; exitCode?: number }>({ type: 'bash', command: command.command as string });
       } finally {
         host.bashRunning = false;
         clearSessionFileCaches();
-        notifyRunningChange();
       }
     }
 

package/src/server/lib/omp/rpc/session-registry.ts

@@ -4,12 +4,11 @@
  */
 
 /**
- * Global omp session registry: keeps one AgentSessionWrapper per session id,
- * exposes lookups, and broadcasts running-session changes to subscribers.
- * Split out of rpc-manager.ts so each file stays under the repo's per-file
- * size ceiling. Importing AgentSessionWrapper here is a runtime-only circular
- * reference with rpc-manager (the wrapper calls notifyRunningChange) — both
- * usages happen inside functions, never at module init.
+ * Global omp session registry: keeps one AgentSessionWrapper per session id and
+ * exposes lookups. Split out of rpc-manager.ts so each file stays under the
+ * repo's per-file size ceiling. Importing AgentSessionWrapper here is a
+ * runtime-only circular reference with rpc-manager — every usage happens inside
+ * a function, never at module init.
  */
 
 import { RpcProcess } from '@/server/lib/omp/rpc/process';
@@ -17,24 +16,11 @@ import { buildSessionSpawnArgs } from '@/server/lib/omp/rpc/constants';
 import { AgentSessionWrapper } from '@/server/lib/omp/rpc/manager';
 import { DEFAULT_APPROVAL_MODE, type ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 
-export interface RunningRpcSession {
-  id: string;
-  cwd: string;
-}
-
-export interface RunningSessionUpdate {
-  ids: string[];
-  runningSessions: RunningRpcSession[];
-  refreshSessionList: boolean;
-}
-
 declare global {
   // eslint-disable-next-line no-var
   var __ompSessions: Map<string, AgentSessionWrapper> | undefined;
   // eslint-disable-next-line no-var
   var __ompStartLocks: Map<string, Promise<{ session: AgentSessionWrapper; realSessionId: string }>> | undefined;
-  // eslint-disable-next-line no-var
-  var __ompRunningListeners: Set<(update: RunningSessionUpdate) => void> | undefined;
 }
 
 function getRegistry(): Map<string, AgentSessionWrapper> {
@@ -57,21 +43,6 @@ export function getRpcSession(sessionId: string): AgentSessionWrapper | undefine
   return getRegistry().get(sessionId);
 }
 
-export function getRunningRpcSessions(): RunningRpcSession[] {
-  const map = new Map<string, string>();
-  for (const [sessionId, session] of getRegistry()) {
-    if (session.isRunning()) {
-      const realId = session.sessionId || sessionId;
-      map.set(realId, session.cwd);
-    }
-  }
-  return [...map.entries()].map(([id, cwd]) => ({ id, cwd }));
-}
-
-export function getRunningRpcSessionIds(): string[] {
-  return getRunningRpcSessions().map((s) => s.id);
-}
-
 /**
  * Sessions whose omp process is parked on a dialog only the user can release —
  * an `ask` question or an approval gate. Deliberately independent of
@@ -90,38 +61,6 @@ export function getAwaitingInputSessionIds(): string[] {
   return [...ids];
 }
 
-function getRunningListeners(): Set<(update: RunningSessionUpdate) => void> {
-  if (!globalThis.__ompRunningListeners) globalThis.__ompRunningListeners = new Set();
-  return globalThis.__ompRunningListeners;
-}
-
-/** Subscribe to running-session-id changes and session-list refreshes. */
-export function subscribeRunningSessions(listener: (update: RunningSessionUpdate) => void): () => void {
-  const listeners = getRunningListeners();
-  listeners.add(listener);
-  return () => { listeners.delete(listener); };
-}
-
-let lastRunningSnapshot = '';
-
-/**
- * Recompute the running-session-id set and, when it changes, broadcast it.
- * A session file may first appear after its id starts running, so callers can
- * force one otherwise-identical update to refresh sidebar session metadata.
- */
-export function notifyRunningChange({ refreshSessionList = false }: { refreshSessionList?: boolean } = {}): void {
-  const runningSessions = getRunningRpcSessions();
-  const ids = runningSessions.map((s) => s.id);
-  if (runningSessions.length === 0 && lastRunningSnapshot === '[]' && !refreshSessionList) return;
-  const snapshot = JSON.stringify(runningSessions.slice().sort((a, b) => a.id.localeCompare(b.id)));
-  if (snapshot === lastRunningSnapshot && !refreshSessionList) return;
-  lastRunningSnapshot = snapshot;
-  const update: RunningSessionUpdate = { ids, runningSessions, refreshSessionList };
-  for (const listener of getRunningListeners()) {
-    try { listener(update); } catch { /* ignore listener errors */ }
-  }
-}
-
 // The approval mode each wrapper's omp child was actually spawned with. omp has
 // no RPC setter for it, so a live wrapper is stale once the desired mode
 // differs and must be respawned with the new --approval-mode flag.

package/src/server/lib/omp/rpc/web-state.ts

@@ -14,7 +14,6 @@
  * rpc-manager.ts stays under the repo's per-file size ceiling.
  */
 
-import { notifyRunningChange } from '@/server/lib/omp/rpc/session-registry';
 import type { RpcSessionState, WebSessionState } from '@/server/lib/omp/rpc/constants';
 
 /** Wrapper state the reconciliation reads and writes. */
@@ -34,8 +33,6 @@ export interface WebStateHost {
 }
 
 export function buildWebState(host: WebStateHost, state: RpcSessionState): WebSessionState {
-  const wasRunning = host.isRunning();
-
   host.streaming = state.isStreaming;
   host.compacting = state.isCompacting;
   host.adoptSessionIdentity(state);
@@ -56,9 +53,6 @@ export function buildWebState(host: WebStateHost, state: RpcSessionState): WebSe
     host.awaitingAgentStartDeadline = 0;
   }
 
-  if (wasRunning && !host.isRunning()) {
-    notifyRunningChange();
-  }
   return {
     sessionId: state.sessionId,
     sessionFile: state.sessionFile ?? '',