ompchamber 0.3.0 → 0.4.0

package/src/client/hooks/chat/timeline/session-load.ts

@@ -21,7 +21,6 @@ import type { Dispatch, RefObject, SetStateAction } from 'preact/compat';
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks';
 
 import type { ChatMessageData } from '@/shared/types';
-import { normalizeNoticePositions } from '@/shared/lib/chat/order';
 import { SESSION_META_RETRY_SCHEDULE_MS } from '@/shared/lib/workspace/refresh-cadence';
 
 export interface SessionDataShape {
@@ -210,9 +209,9 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
               if (isGeneratingRef.current) {
                 const fetchedIds = fetched.map((m: ChatMessageData) => m.id);
                 const liveTail = localMessagesRef.current.filter(m => !fetchedIds.includes(m.id));
-                setLocalMessages(normalizeNoticePositions([...fetched, ...liveTail]));
+                setLocalMessages([...fetched, ...liveTail]);
               } else {
-                setLocalMessages(normalizeNoticePositions(fetched));
+                setLocalMessages(fetched);
               }
             } else if (!sessionId.startsWith('new-') && !optimisticOwnsTail) {
               setLocalMessages([]);
@@ -284,7 +283,7 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
         setLocalMessages(prev => {
           // Drop overlap guard: the server window is index-based, so the
           // fetched slice is strictly older than everything already mounted.
-          return [...normalizeNoticePositions(older), ...prev];
+          return [...older, ...prev];
         });
         // Bump the prepend tick so the layout effect below re-runs for THIS
         // commit — it previously depended only on stable identities and ran

package/src/client/hooks/ui/syntax-ready.ts

@@ -5,13 +5,26 @@
 
 import { useEffect, useState } from 'preact/hooks';
 
-import { isSyntaxReady, onSyntaxReady } from '@/shared/lib/code/highlighter';
+import { isSyntaxReady, onLanguageReady, onSyntaxReady } from '@/shared/lib/code/highlighter';
 
-/** Re-renders once the Shiki highlighter has finished warming up. */
+/**
+ * Re-renders when the Shiki highlighter finishes booting **and** whenever a
+ * grammar lands. Grammars are fetched on demand — a language nobody renders is
+ * never downloaded — so a component may see a `true` value here while the
+ * grammar for its own code is still in flight; the second subscription is what
+ * swaps the plain-text fallback for tokenized markup once the chunk arrives.
+ */
 export function useSyntaxReady(): boolean {
   const [ready, setReady] = useState<boolean>(() => isSyntaxReady());
 
-  useEffect(() => onSyntaxReady(() => setReady(true)), []);
+  useEffect(() => {
+    const offBoot = onSyntaxReady(() => setReady(true));
+    const offLang = onLanguageReady(() => setReady(true));
+    return () => {
+      offBoot();
+      offLang();
+    };
+  }, []);
 
   return ready;
 }

package/src/client/main.tsx

@@ -4,11 +4,8 @@ import { bootSyntax } from '@/shared/lib/code/highlighter';
 import { primeChamberSettings } from '@/shared/lib/settings/client';
 
 import '@/client/tailwind.css';
-import 'katex/dist/katex.min.css';
-import '@fontsource/fira-code/400.css';
-import '@fontsource/fira-code/500.css';
-import '@fontsource/fira-code/600.css';
-import '@fontsource/fira-code/700.css';
+import '@/shared/lib/markdown/katex-fonts.css';
+import '@/shared/lib/markdown/fira-code-fonts.css';
 
 const root = document.getElementById('app');
 const bootstrap = window.__OMP_BOOTSTRAP__;

package/src/client/stubs/elkjs.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Browser replacement for `elkjs`, aliased in `rsbuild.config.ts`.
+ *
+ * Mermaid 12 changed the global `layout` default from `dagre` to `elk`, so every
+ * flowchart pulled in `elkjs/lib/elk.bundled.js` whether the diagram asked for
+ * ELK or not — the single largest artifact in the client build (~1.4 MB raw,
+ * 434 kB gzip). `src/shared/lib/markdown/mermaid.ts` pins `layout: 'dagre'`,
+ * which is what makes this stub safe: with dagre selected explicitly, mermaid
+ * never calls into `runElkLayoutCore`, the only code path that constructs an ELK
+ * instance (verified across 20 diagram types, byte-identical results to a build
+ * with the real elkjs).
+ *
+ * `layout: 'elk'` is still a valid *request* — a diagram using the
+ * `flowchart-elk` directive, or a syntax flagged `@config{layout: "elk"}`. Those
+ * now fail loudly here instead of silently rendering with a different layout
+ * than asked for. Throwing is deliberate: mermaid's `render()` propagates the
+ * error to the caller, and `mermaid.ts` already renders a fallback block on
+ * failure, so a mis-specified diagram degrades to a visible message rather than
+ * a wrong diagram.
+ */
+
+function unavailable(): never {
+  throw new Error('elkjs is not bundled in this build; use the default dagre layout');
+}
+
+export class ELK {}
+
+export default new Proxy(ELK as unknown as object, {
+  construct: unavailable,
+  apply: unavailable,
+  get: unavailable,
+}) as unknown as typeof ELK;

package/src/client/tailwind.css

@@ -285,6 +285,16 @@
 [data-theme="one-dark-pro-soft"] .shiki span { color: var(--shiki-dark); }
 .prose-content .katex-display { overflow-x: auto; overflow-y: hidden; }
 
+/* Math placeholder: `marked.ts` emits a `.math-pending` span and KaTeX is
+ * fetched on demand (~522 kB async chunk), so the span is empty for one frame.
+ * Reserve display-math height so the message does not jump when the formula
+ * lands, and keep invalid/queued source faintly visible rather than blank. */
+.prose-content .math-pending::before {
+  content: '…';
+  opacity: 0.35;
+}
+.prose-content p:has(> .math-pending[data-math-display='1']) { min-height: 2.5rem; }
+
 /* Streaming placeholder: remend turns a half-received [text](url into this
  * span; it becomes a real link once the URL arrives in a later frame. */
 .prose-content .md-incomplete-link {

package/src/server/lib/fs/git-ignore.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Git-ignore resolution for the Files panel.
+ *
+ * `git check-ignore` is the only authority that evaluates every rule source in
+ * one pass — per-directory `.gitignore`, `.git/info/exclude`, and the global
+ * `core.excludesFile` (`~/.gitignore`) — so the panel dims exactly what git
+ * would refuse to track. Paths are fed NUL-separated over stdin (`--stdin -z`)
+ * so a directory listing of any size cannot overflow argv, and the verbatim
+ * NUL-separated reply maps straight back onto those same paths.
+ *
+ * Paths must be relative to `dir` and must exist on disk: git resolves
+ * directory-only patterns (`build/`) by stat-ing the path.
+ */
+export async function collectIgnoredPaths(dir: string, relPaths: string[]): Promise<Set<string>> {
+  if (relPaths.length === 0) return new Set();
+
+  try {
+    const proc = Bun.spawn({
+      cmd: ['git', 'check-ignore', '--stdin', '-z'],
+      cwd: dir,
+      stdin: 'pipe',
+      stdout: 'pipe',
+      stderr: 'ignore',
+      timeout: 10_000,
+    });
+
+    // Drain stdout while the listing is written: a directory big enough to
+    // fill both pipe buffers would otherwise deadlock child against parent.
+    const stdout = new Response(proc.stdout).text();
+    proc.stdin.write(relPaths.map(rel => `${rel}\0`).join(''));
+    // FileSink.end() types as `number | Promise<number>` — EPIPE (child gone)
+    // must not surface as an unhandled rejection.
+    void Promise.resolve(proc.stdin.end()).catch(() => {});
+
+    const [text, exitCode] = await Promise.all([stdout, proc.exited]);
+    // 0 = at least one path matched, 1 = none, 128 = no repository. Only 0 can
+    // carry a match list.
+    if (exitCode !== 0) return new Set();
+
+    return new Set(text.split('\0').filter(Boolean));
+  } catch {
+    return new Set(); // git missing / spawn failed — nothing is dimmed
+  }
+}

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

@@ -70,12 +70,22 @@ export interface WebSessionState {
 }
 
 export const IDLE_DESTROY_MS = 10 * 60 * 1000;
+// Longest a subagent may go without a frame before the wrapper stops counting
+// it as live work. A terminal frame lost to a protocol hiccup would otherwise
+// pin the session's omp process (and its whole process group) open forever; the
+// price of the window is at most one idle omp process.
+export const SUBAGENT_STALE_MS = 30 * 60 * 1000;
 export const READY_TIMEOUT_MS = 120_000;
 export const GET_STATE_TIMEOUT_MS = 5_000;
 export const PROMPT_ACK_TIMEOUT_MS = 30_000;
 export const NON_TERMINAL_CONTINUATION_GRACE_MS = 2_000;
 export const AWAITING_AGENT_START_TIMEOUT_MS = 10_000;
 export const RESTARTING_MESSAGE = 'This session is restarting — retry in a moment.';
+// A command timeout is not proof an omp child is wedged: omp runs RPC handlers
+// one at a time, so a slow `get_state`/`prompt` ack can simply be queued behind
+// the running turn. That session keeps its process — only a session that is
+// idle AND unresponsive is reset.
+export const SESSION_BUSY_MESSAGE = 'The OMP session is busy with the running turn; retry once it settles.';
 
 export class WebRpcError extends Error {
   readonly code: string;

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

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The wrapper's lifecycle rules: which conditions may reclaim a session's omp
+ * process. A reset kills the whole process group, so a wrong answer here
+ * destroys a live turn and every subagent under it.
+ */
+
+import { afterEach, beforeEach, describe, expect, test, vi } from 'bun:test';
+
+import { AgentSessionWrapper, WebRpcError } from '@/server/lib/omp/rpc/manager';
+import { RpcCommandTimeoutError, type RpcProcess } from '@/server/lib/omp/rpc/process';
+
+/** Commands whose ack is fabricated as timed out; everything else resolves, so
+ *  only the timeout policy is under test. */
+const TIMED_OUT_COMMANDS: Record<string, true> = { get_state: true, prompt: true };
+
+interface StubProcess {
+  proc: RpcProcess;
+  emit(frame: Record<string, unknown>): void;
+  disposeCount(): number;
+}
+
+function makeProc(): StubProcess {
+  let listener: ((frame: unknown) => void) | null = null;
+  let disposals = 0;
+  const proc = {
+    isAlive: true,
+    pid: 4242,
+    onFrame(next: (frame: unknown) => void) {
+      listener = next;
+      return () => {
+        listener = null;
+      };
+    },
+    sendCommand(command: { type: string }) {
+      if (TIMED_OUT_COMMANDS[command.type] === true) {
+        return Promise.reject(new RpcCommandTimeoutError(command.type, 1));
+      }
+      return Promise.resolve(undefined);
+    },
+    sendFrame() {},
+    async dispose() {
+      disposals += 1;
+    },
+  };
+  return {
+    proc: proc as unknown as RpcProcess,
+    emit: (frame) => listener?.(frame),
+    disposeCount: () => disposals,
+  };
+}
+
+async function rejectionOf(operation: Promise<unknown>): Promise<WebRpcError> {
+  const error = await operation.then(() => null, (caught: unknown) => caught);
+  expect(error).toBeInstanceOf(WebRpcError);
+  return error as WebRpcError;
+}
+
+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.
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test('resets a session that ignores commands while idle', async () => {
+    const stub = makeProc();
+    const wrapper = new AgentSessionWrapper(stub.proc, '/tmp');
+
+    const error = await rejectionOf(wrapper.send({ type: 'get_state' }));
+
+    expect(error.code).toBe('session_unresponsive');
+    expect(stub.disposeCount()).toBe(1);
+  });
+
+  test('keeps the process when a get_state times out mid-turn', async () => {
+    const stub = makeProc();
+    const wrapper = new AgentSessionWrapper(stub.proc, '/tmp');
+    wrapper.start();
+    stub.emit({ type: 'agent_start' });
+
+    const error = await rejectionOf(wrapper.send({ type: 'get_state' }));
+
+    expect(error.code).toBe('session_busy');
+    expect(stub.disposeCount()).toBe(0);
+    expect(wrapper.isRunning()).toBe(true);
+  });
+
+  test('keeps the process when a prompt ack times out mid-turn', async () => {
+    const stub = makeProc();
+    const wrapper = new AgentSessionWrapper(stub.proc, '/tmp');
+    wrapper.start();
+    stub.emit({ type: 'agent_start' });
+
+    const error = await rejectionOf(wrapper.send({ type: 'prompt', message: 'hi' }));
+
+    expect(error.code).toBe('session_busy');
+    expect(stub.disposeCount()).toBe(0);
+  });
+
+  test('idle reclaim waits for subagents that outlive the turn', () => {
+    const stub = makeProc();
+    const wrapper = new AgentSessionWrapper(stub.proc, '/tmp', null, { idleDestroyMs: 20 });
+    wrapper.start();
+
+    stub.emit({ type: 'agent_start' });
+    stub.emit({ type: 'agent_end', isTerminal: true });
+    stub.emit({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'started', index: 0 } });
+    expect(wrapper.isRunning()).toBe(false);
+    expect(wrapper.isBusy()).toBe(true);
+
+    vi.advanceTimersByTime(200);
+    expect(stub.disposeCount()).toBe(0);
+
+    stub.emit({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'completed', index: 0 } });
+    expect(wrapper.isBusy()).toBe(false);
+
+    vi.advanceTimersByTime(200);
+    expect(stub.disposeCount()).toBe(1);
+  });
+
+  test('force_reset reclaims a process whose turn will not stop', async () => {
+    const stub = makeProc();
+    const wrapper = new AgentSessionWrapper(stub.proc, '/tmp');
+    stub.emit({ type: 'agent_start' });
+
+    await wrapper.send({ type: 'force_reset' });
+
+    expect(stub.disposeCount()).toBe(1);
+  });
+});

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

@@ -20,8 +20,9 @@ import { PendingUiDialogs } from '@/server/lib/omp/rpc/pending-ui-dialogs';
 import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 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';
-import { GET_STATE_TIMEOUT_MS, IDLE_DESTROY_MS, NON_TERMINAL_CONTINUATION_GRACE_MS, READY_TIMEOUT_MS, type AgentEvent, type EventListener, type RpcSessionState } from '@/server/lib/omp/rpc/constants';
+import { GET_STATE_TIMEOUT_MS, IDLE_DESTROY_MS, NON_TERMINAL_CONTINUATION_GRACE_MS, READY_TIMEOUT_MS, SUBAGENT_STALE_MS, type AgentEvent, type EventListener, type RpcSessionState } from '@/server/lib/omp/rpc/constants';
 
 export type {
   AgentEvent,
@@ -31,6 +32,13 @@ export type {
 } from '@/server/lib/omp/rpc/constants';
 export { WebRpcError, resolveSpawnCwd } from '@/server/lib/omp/rpc/constants';
 
+/** Overrides for the wrapper's own timers. Production always uses the
+ *  constant; tests shrink the window so the lifecycle rules stay fast. */
+export interface AgentSessionWrapperOptions {
+  /** Idle window before an unused process is reclaimed. */
+  idleDestroyMs?: number;
+}
+
 export class AgentSessionWrapper {
   private listeners: EventListener[] = [];
   promptRunning = false;
@@ -55,14 +63,20 @@ export class AgentSessionWrapper {
   // `extension_ui_request`, so a client that reloads mid-dialog can only learn
   // the id it must answer from here.
   private readonly pendingUiDialogs = new PendingUiDialogs();
+  // Live subagents, folded from the frames omp streams after the subscription
+  // 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();
+  readonly idleDestroyMs: number;
   proc: RpcProcess;
   readonly cwd: string;
   private readonly recordedCwd: string | null;
 
-  constructor(proc: RpcProcess, cwd: string, recordedCwd?: string | null) {
+  constructor(proc: RpcProcess, cwd: string, recordedCwd?: string | null, options: AgentSessionWrapperOptions = {}) {
     this.proc = proc;
     this.cwd = cwd;
     this.recordedCwd = recordedCwd ?? null;
+    this.idleDestroyMs = options.idleDestroyMs ?? IDLE_DESTROY_MS;
   }
 
   get sessionId(): string {
@@ -87,6 +101,13 @@ export class AgentSessionWrapper {
     return this.isAlive() && (this.promptRunning || this.streaming || this.compacting || this.bashRunning);
   }
 
+  /** Anything in flight that a process reset would destroy: the current turn,
+   *  a compaction, a shell command, or live subagents — which outlive the turn
+   *  that spawned them, so no other flag here can see them. */
+  isBusy(): boolean {
+    return this.isRunning() || this.subagents.liveCount(Date.now(), SUBAGENT_STALE_MS) > 0;
+  }
+
   start(): void {
     this.unsubscribeFrames = this.proc.onFrame((frame) => this.handleFrame(frame));
     this.resetIdleTimer();
@@ -188,6 +209,13 @@ export class AgentSessionWrapper {
       case 'extension_ui_request':
         this.pendingUiDialogs.track(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':
+        this.subagents.observe(event, Date.now());
+        break;
       case 'response': {
         if (event.success === false && event.command === 'prompt') {
           this.promptRunning = false;
@@ -226,12 +254,12 @@ export class AgentSessionWrapper {
     this.lastIdleReset = now;
     if (this.idleTimer) clearTimeout(this.idleTimer);
     this.idleTimer = setTimeout(() => {
-      if (this.isRunning()) {
+      if (this.isBusy()) {
         this.resetIdleTimer(true);
         return;
       }
       this.destroy();
-    }, IDLE_DESTROY_MS);
+    }, this.idleDestroyMs);
   }
 
   onEvent(listener: EventListener): () => void {

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

@@ -10,7 +10,7 @@
  */
 
 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, WebRpcError, toImageContents, type AgentEvent, type RpcSessionState, validateAgentImages } from '@/server/lib/omp/rpc/constants';
+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 { markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
@@ -21,6 +21,10 @@ export interface SessionCommandHost extends WebStateHost {
   restarting: boolean;
   proc: RpcProcess;
   isAlive(): boolean;
+  /** Anything a reset would destroy: the running turn, a compaction, a shell
+   *  command, or live subagents. A timed-out command against a busy session is
+   *  queued behind that work, not evidence the child is wedged. */
+  isBusy(): boolean;
   /** Real omp session id (empty before the first get_state). */
   sessionId: string;
   emit(event: AgentEvent): void;
@@ -31,6 +35,20 @@ export interface SessionCommandHost extends WebStateHost {
   destroyAndWait(): Promise<void>;
 }
 
+/** Decide a command timeout's consequence. omp runs RPC handlers one at a
+ *  time, so a late `get_state`/`prompt` ack is usually queued behind the
+ *  running turn (or behind a subagent's spawn): resetting that child would
+ *  throw away a live turn and every subagent it owns. Only a session that is
+ *  demonstrably idle AND unresponsive is reclaimed.
+ *
+ *  Never throws `session_unresponsive` for a busy session, and never suggests a
+ *  retry of a command whose acceptance is unknown. */
+async function settleCommandTimeout(host: SessionCommandHost): Promise<never> {
+  if (host.isBusy()) throw new WebRpcError(SESSION_BUSY_MESSAGE, 'session_busy');
+  await host.destroyAndWait();
+  throw new WebRpcError('The OMP session stopped responding and was reset.', 'session_unresponsive');
+}
+
 export async function dispatchSessionCommand(host: SessionCommandHost, command: Record<string, unknown>): Promise<unknown> {
   if (host.restarting) throw new WebRpcError(RESTARTING_MESSAGE, 'session_restarting');
   if (!host.isAlive()) throw new Error('Session is no longer running');
@@ -78,10 +96,10 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         host.awaitingAgentStart = false;
         host.awaitingAgentStartDeadline = 0;
         notifyRunningChange();
-        if (error instanceof RpcCommandTimeoutError) {
-          await host.destroyAndWait();
-          throw new WebRpcError('The OMP session stopped responding and was reset.', 'session_unresponsive');
-        }
+        // 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.
+        if (error instanceof RpcCommandTimeoutError) await settleCommandTimeout(host);
         throw error;
       } finally {
         if (!streamingBehavior) {
@@ -102,15 +120,20 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
       });
       return null;
 
+    // Escape hatch behind the Stop button: `abort` resolves only once the turn
+    // actually stops, so a session wedged on a subagent never answers it. The
+    // caller (shared/lib/chat/omp/abort.ts) escalates to this after a grace
+    // period and accepts losing the in-flight work.
+    case 'force_reset':
+      await host.destroyAndWait();
+      return null;
+
     case 'get_state': {
       try {
         const state = await host.proc.sendCommand<RpcSessionState>({ type: 'get_state' }, GET_STATE_TIMEOUT_MS);
         return buildWebState(host, state);
       } catch (error) {
-        if (error instanceof RpcCommandTimeoutError) {
-          await host.destroyAndWait();
-          throw new WebRpcError('The OMP session stopped responding and was reset.', 'session_unresponsive');
-        }
+        if (error instanceof RpcCommandTimeoutError) await settleCommandTimeout(host);
         throw error;
       }
     }

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

@@ -131,8 +131,9 @@ export function getSpawnApprovalMode(session: AgentSessionWrapper): ApprovalMode
  *  Returns true when the session was destroyed (caller MUST respawn). */
 export async function reconcileSpawnApprovalMode(session: AgentSessionWrapper, desired: ApprovalMode): Promise<boolean> {
   if (getSpawnApprovalMode(session) === desired) return false;
-  // Never kill an in-flight run — the caller would lose the active turn.
-  if (session.isRunning()) return false;
+  // Never kill in-flight work — the caller would lose the active turn, and a
+  // live subagent outlives that turn.
+  if (session.isBusy()) return false;
   // A brand-new session has no JSONL on disk yet; destroying it would 404 the
   // next request that tries to resolve its file.
   if (!session.sessionFile) return false;

package/src/server/lib/omp/rpc/subagent-liveness.test.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { SubagentLiveness } from '@/server/lib/omp/rpc/subagent-liveness';
+
+const NOW = 1_000_000;
+const STALE_MS = 60_000;
+
+describe('SubagentLiveness', () => {
+  test('counts a started subagent until its terminal lifecycle arrives', () => {
+    const live = new SubagentLiveness();
+    live.observe({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'started', index: 0 } }, NOW);
+    expect(live.liveCount(NOW, STALE_MS)).toBe(1);
+
+    live.observe({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'completed', index: 0 } }, NOW + 1);
+    expect(live.liveCount(NOW + 1, STALE_MS)).toBe(0);
+  });
+
+  test('an id-less progress frame lands on the lifecycle entry it names', () => {
+    const live = new SubagentLiveness();
+    live.observe({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'started', index: 3 } }, NOW);
+    live.observe({ type: 'subagent_progress', payload: { index: 3, status: 'running' } }, NOW + 1);
+    expect(live.liveCount(NOW + 1, STALE_MS)).toBe(1);
+
+    // A terminal progress frame for the same index must clear that one entry —
+    // not leave a second key behind holding the session open.
+    live.observe({ type: 'subagent_progress', payload: { index: 3, status: 'completed' } }, NOW + 2);
+    expect(live.liveCount(NOW + 2, STALE_MS)).toBe(0);
+  });
+
+  test('reads a progress snapshot nested under `progress`', () => {
+    const live = new SubagentLiveness();
+    live.observe({ type: 'subagent_progress', payload: { progress: { id: 's9', status: 'running' } } }, NOW);
+    expect(live.liveCount(NOW, STALE_MS)).toBe(1);
+  });
+
+  test('malformed frames never fabricate liveness', () => {
+    const live = new SubagentLiveness();
+    live.observe({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'paused' } }, NOW);
+    live.observe({ type: 'subagent_lifecycle', payload: { status: 'started' } }, NOW);
+    live.observe({ type: 'subagent_progress', payload: 'nonsense' }, NOW);
+    live.observe({ type: 'subagent_event', payload: { event: { type: 'message_end' } } }, NOW);
+    expect(live.liveCount(NOW, STALE_MS)).toBe(0);
+  });
+
+  test('a subagent silent past the stale window stops counting, so one lost terminal frame cannot pin a session', () => {
+    const live = new SubagentLiveness();
+    live.observe({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'started', index: 0 } }, NOW);
+    expect(live.liveCount(NOW + STALE_MS + 1, STALE_MS)).toBe(0);
+  });
+
+  test('an unattributed event refreshes tracked work without inventing an entry', () => {
+    const live = new SubagentLiveness();
+    live.observe({ type: 'subagent_lifecycle', payload: { id: 's1', status: 'started', index: 0 } }, NOW);
+    live.observe({ type: 'subagent_event', payload: { event: { type: 'tool_execution_start', toolName: 'bash' } } }, NOW + STALE_MS - 1);
+    expect(live.liveCount(NOW + STALE_MS + 1, STALE_MS)).toBe(1);
+  });
+});