ompchamber 0.6.0 → 0.8.0

package/src/client/tailwind.css

@@ -318,6 +318,11 @@
   border-radius: 0.5rem;
   background: var(--theme-paper);
   padding: 0.75rem;
+  /* `applySvg` swaps the `.code-block` shell (the positioned ancestor the copy
+     button relied on) for the SVG, so the block owns the anchor itself. */
+  position: relative;
+  /* The block is the door into the zoom/pan viewer. */
+  cursor: zoom-in;
 }
 .prose-content .mermaid-block > svg {
   display: block;
@@ -332,6 +337,27 @@
   color: var(--theme-error);
 }
 
+/* Full-screen mermaid viewer (`common/diagram-viewer/`): a chart opened from
+   the timeline. The stage is the fixed-size pan surface, the canvas child
+   carries the zoom/pan transform, so the SVG keeps its natural pixel size and
+   `100%` on it always means "the size mermaid rendered". */
+.diagram-viewer-stage {
+  touch-action: none;
+  overscroll-behavior: contain;
+}
+.diagram-viewer-canvas {
+  transform-origin: center center;
+  will-change: transform;
+  background: var(--theme-paper);
+  box-shadow: 0 25px 50px -12px color-mix(in srgb, var(--theme-ink) 45%, transparent);
+}
+.diagram-viewer-canvas > svg {
+  display: block;
+  width: 100% !important;
+  height: 100% !important;
+  max-width: none !important;
+}
+
 /* PWA Window Controls Overlay and Native Titlebar Styling */
 .titlebar-drag-region {
   -webkit-app-region: drag;
@@ -344,31 +370,31 @@
 }
 
 
-/* Ask-dialog enter animation — replaces the retired `motion` dependency.
-   Exit is intentionally instant: a 160ms fade-out on a blocking modal is not
-   load-bearing, and keeping the element mounted to animate it out would add
-   state the dialog does not otherwise need. */
-@keyframes ask-dialog-backdrop-in {
+/* Blocking extension-dialog enter animation — replaces the retired `motion`
+   dependency. Exit is intentionally instant: a 160ms fade-out on a blocking
+   modal is not load-bearing, and keeping the element mounted to animate it out
+   would add state the dialog does not otherwise need. */
+@keyframes extension-dialog-backdrop-in {
   from { opacity: 0; }
   to { opacity: 1; }
 }
 
-@keyframes ask-dialog-panel-in {
+@keyframes extension-dialog-panel-in {
   from { opacity: 0; transform: translateY(10px) scale(0.95); }
   to { opacity: 1; transform: none; }
 }
 
-.ask-dialog-backdrop {
-  animation: ask-dialog-backdrop-in 150ms ease-out;
+.extension-dialog-backdrop {
+  animation: extension-dialog-backdrop-in 150ms ease-out;
 }
 
-.ask-dialog-panel {
-  animation: ask-dialog-panel-in 180ms ease-out;
+.extension-dialog-panel {
+  animation: extension-dialog-panel-in 180ms ease-out;
 }
 
 @media (prefers-reduced-motion: reduce) {
-  .ask-dialog-backdrop,
-  .ask-dialog-panel {
+  .extension-dialog-backdrop,
+  .extension-dialog-panel {
     animation: none;
   }
 }

package/src/server/index.ts

@@ -6,6 +6,7 @@ import { getDatabasePath } from '@/server/db.server';
 import { fetchOmpRegistrySnapshot } from '@/server/lib/models/provider-registry.server';
 import { ompStartupError, ompStartupLogLines } from '@/server/lib/omp/core/startup';
 import { readInstanceRecord, removeInstanceRecord, writeInstanceRecord } from '@/server/lib/lifecycle/instance';
+import { resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
 import { acquirePortLock, claimPort, PortInUseError } from '@/server/lib/lifecycle/port-guard';
 import { isMockMode } from '@/server/mock.server';
 
@@ -28,9 +29,9 @@ console.log(`[ompchamber] db:             ${await getDatabasePath()}`);
 const port = Number(Bun.env.PORT) || 3000;
 const host = Bun.env.HOST || 'localhost';
 const mode = Bun.env.NODE_ENV === 'production' ? 'prod' : 'dev';
-const launchMode = Bun.env.OMPCHAMBER_LAUNCH_MODE === 'daemon' || Bun.env.OMPCHAMBER_LAUNCH_MODE === 'foreground'
-  ? Bun.env.OMPCHAMBER_LAUNCH_MODE
-  : 'direct';
+// argv, not env: see launch-mode.ts — an inherited `OMPCHAMBER_LAUNCH_MODE`
+// would label a `bun run dev` started inside an OMPChamber shell as `daemon`.
+const launchMode = resolveLaunchMode();
 
 const lock = await acquirePortLock(port);
 if (!lock) {

package/src/server/lib/lifecycle/bun.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The Bun binary to spawn child processes with.
+ *
+ * The server is usually itself Bun, so `process.execPath` is the most
+ * trustworthy answer — it is the exact runtime this install was started with.
+ * A host that is not Bun falls back to a PATH lookup, and finally to the
+ * literal `bun`, which lets the child resolve it from its own environment.
+ */
+export function resolveBunBin(): string {
+  const execPath = process.execPath;
+  if (/(^|[\\/])bun$/.test(execPath)) return execPath;
+  return Bun.which('bun') ?? 'bun';
+}

package/src/server/lib/lifecycle/launch-mode.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'bun:test';
+
+import { launchModeArg, resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
+
+const ENTRY = '/repo/src/server/index.ts';
+
+describe('resolveLaunchMode', () => {
+  test('reads the flag the CLI appends to the servers it spawns', () => {
+    expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server', launchModeArg('daemon')])).toBe('daemon');
+    expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server', launchModeArg('foreground')])).toBe('foreground');
+  });
+
+  test('treats a server started without the flag as direct', () => {
+    // `bun run dev`, `bun run start`, a manual run, an external supervisor.
+    expect(resolveLaunchMode(['bun', 'run', '--hot', ENTRY, '--ompchamber-server'])).toBe('direct');
+    expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server', '--launch-mode=sideways'])).toBe('direct');
+  });
+
+  test('ignores an inherited environment marker', () => {
+    // The chamber's terminal panel runs commands with the server's own env, so
+    // a `bun run dev` started there inherits `daemon` — argv is the only
+    // trustworthy signal, and this test fails if env is ever read again.
+    const previous = Bun.env.OMPCHAMBER_LAUNCH_MODE;
+    Bun.env.OMPCHAMBER_LAUNCH_MODE = 'daemon';
+    try {
+      expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server'])).toBe('direct');
+    } finally {
+      if (previous === undefined) delete Bun.env.OMPCHAMBER_LAUNCH_MODE;
+      else Bun.env.OMPCHAMBER_LAUNCH_MODE = previous;
+    }
+  });
+});

package/src/server/lib/lifecycle/launch-mode.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How this server was launched — the fact that decides whether an update may
+ * replace it.
+ *
+ * The marker travels as an argv flag, never as an environment variable. Env is
+ * inherited by every descendant, so a server started from a shell *inside* an
+ * OMPChamber tree — the chamber's own terminal panel runs commands with the
+ * server's environment — would inherit `daemon` and then be swapped out by the
+ * next update, killing a `bun run dev` loop OMPChamber does not own. argv
+ * belongs to the process alone.
+ */
+
+import type { InstanceLaunchMode } from '@/server/lib/lifecycle/instance';
+
+/** The argv flag the CLI appends to every server it spawns. */
+const LAUNCH_MODE_FLAG = '--launch-mode=';
+
+/**
+ * The argv entry for `mode`. Paired with `resolveLaunchMode`, so the flag
+ * spelling exists in exactly one place for the writer and the reader.
+ */
+export function launchModeArg(mode: InstanceLaunchMode): string {
+  return `${LAUNCH_MODE_FLAG}${mode}`;
+}
+
+/**
+ * Launch mode of a server invocation. Only the CLI passes the flag, so a
+ * `bun run dev`, a `bun run start`, a manual run and an externally supervised
+ * process all resolve to `direct` — the mode that is left alone.
+ */
+export function resolveLaunchMode(argv: readonly string[] = Bun.argv): InstanceLaunchMode {
+  const flag = argv.find((arg) => arg.startsWith(LAUNCH_MODE_FLAG));
+  const value = flag?.slice(LAUNCH_MODE_FLAG.length);
+  return value === 'daemon' || value === 'foreground' ? value : 'direct';
+}

package/src/server/lib/lifecycle/restart.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'bun:test';
+
+import { isAutoRestartable } from '@/server/lib/lifecycle/restart';
+
+// The modal update and `ompchamber update` both decide with this predicate:
+// guessing wrong here kills a `bun run dev` the user owns, or leaves a daemon
+// serving the build that was just replaced.
+describe('isAutoRestartable', () => {
+  test('restarts the instances the CLI started', () => {
+    expect(isAutoRestartable('daemon')).toBe(true);
+    expect(isAutoRestartable('foreground')).toBe(true);
+  });
+
+  test('leaves every instance OMPChamber did not start alone', () => {
+    // `bun run dev`, `bun run start`, a manual run, a systemd/pm2 unit.
+    expect(isAutoRestartable('direct')).toBe(false);
+    // A probed or unreadable record never authorises a kill either.
+    expect(isAutoRestartable('unknown')).toBe(false);
+    expect(isAutoRestartable(undefined)).toBe(false);
+  });
+});

package/src/server/lib/lifecycle/restart.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Replacing the instance that is serving an update request.
+ *
+ * A server cannot restart itself: the process holding the port has to exit
+ * before a replacement can bind it, and the update response has to leave first.
+ * So once the files on disk are replaced, the work goes to a detached
+ * `ompchamber restart --port <port>` — the same stop-then-serve the CLI runs
+ * after `ompchamber update`.
+ *
+ * Instances the CLI did not start are left alone. `bun run dev` and
+ * `bun run start` execute this package's source in the user's own shell, and an
+ * external supervisor (systemd, pm2, a container) owns the process it started;
+ * all of them record `direct`, and replacing any of them would break a loop
+ * OMPChamber does not own — or fight a second daemon for the port. Their own
+ * launcher is what brings the new files up.
+ */
+
+import { existsSync } from 'node:fs';
+import { join as joinPath, resolve as resolvePath } from 'node:path';
+
+import { resolveBunBin } from '@/server/lib/lifecycle/bun';
+import { listInstanceRecords } from '@/server/lib/lifecycle/instance';
+import { resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
+
+/** Package root of the running copy: src/server/lib/lifecycle -> four levels up. */
+const PKG_ROOT = resolvePath(import.meta.dir, '..', '..', '..', '..');
+
+/**
+ * Time between answering the update request and stopping the server. The
+ * response is a small JSON body on a local listener; this is the margin that
+ * keeps the console's toast from dying with the process that sent it.
+ */
+export const RESTART_GRACE_MS = 1_200;
+
+export interface SelfRestartPlan {
+  /** A detached restart is armed; `message` says so. */
+  restarting: boolean;
+  /** What to tell the user, either way. */
+  message: string;
+}
+
+/**
+ * True when the CLI owns this instance's lifecycle and may replace it. `direct`
+ * is every server OMPChamber did not start: `bun run dev`, `bun run start`, a
+ * manual `bun src/server/index.ts`, or an external supervisor.
+ */
+export function isAutoRestartable(launchMode: string | null | undefined): boolean {
+  return launchMode === 'daemon' || launchMode === 'foreground';
+}
+
+/** One-line reason an instance is left running, shared by the CLI and console. */
+export function skipRestartNote(launchMode: string | null | undefined): string {
+  if (launchMode === 'direct') {
+    return 'this instance runs from source (`bun run dev` / `bun run start`) — start it again to apply the update';
+  }
+  return 'this instance is not managed by the ompchamber CLI — restart it yourself to apply the update';
+}
+
+/** The record this process wrote for itself; falls back to the env it was launched with. */
+function ownInstance(): { port: number; launchMode: string } | null {
+  const record = listInstanceRecords().find((entry) => entry.pid === process.pid);
+  if (record) return { port: record.port, launchMode: record.launchMode };
+
+  const port = Number(Bun.env.PORT);
+  if (!Number.isFinite(port) || port <= 0) return null;
+  return { port, launchMode: resolveLaunchMode() };
+}
+
+/** `ompchamber restart --port <port>` for the install this server runs from. */
+function restartCommand(port: number): string[] | null {
+  const cli = joinPath(PKG_ROOT, 'src', 'cli', 'ompchamber.js');
+  if (!existsSync(cli)) return null;
+  return [resolveBunBin(), cli, 'restart', '--port', String(port)];
+}
+
+/**
+ * Stop and start this port again, once the response has been delivered. The
+ * helper is detached so this process exiting does not take it down, and it
+ * removes this port's record itself (`stopInstance`) before serving.
+ */
+export function scheduleSelfRestart(): SelfRestartPlan {
+  const self = ownInstance();
+  if (!self) {
+    return { restarting: false, message: 'This instance could not be identified — restart it yourself to apply the update.' };
+  }
+
+  if (!isAutoRestartable(self.launchMode)) {
+    return { restarting: false, message: skipRestartNote(self.launchMode) };
+  }
+
+  const cmd = restartCommand(self.port);
+  if (!cmd) {
+    return { restarting: false, message: `The ompchamber CLI is missing from ${PKG_ROOT} — restart it yourself to apply the update.` };
+  }
+
+  setTimeout(() => {
+    console.log(`[ompchamber] restarting on port ${self.port}: ${cmd.join(' ')}`);
+    try {
+      Bun.spawn({ cmd, cwd: PKG_ROOT, stdin: 'ignore', stdout: 'inherit', stderr: 'inherit', detached: true }).unref();
+    } catch (err) {
+      console.error(`[ompchamber] restart helper could not be started: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }, RESTART_GRACE_MS);
+
+  return { restarting: true, message: `Restarting OMPChamber on port ${self.port} to apply it — the console reconnects on its own.` };
+}

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

@@ -102,10 +102,21 @@ export class AgentSessionWrapper {
   }
 
   /** 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. */
+   *  a compaction, a shell command, live subagents — which outlive the turn that
+   *  spawned them, so no other flag here can see them — or an ask/approval dialog
+   *  omp is BLOCKED on.
+   *
+   *  The dialogs are the load-bearing entry: an ask parks the tool call for as
+   *  long as the user takes to answer, and omp answers RPC handlers one at a
+   *  time, so every probe (`get_state`) queues behind it and times out. Without
+   *  this the timeout path read the session as "idle and unresponsive", killed
+   *  the child, and with it the question the user was still reading. */
   isBusy(): boolean {
-    return this.isRunning() || this.subagents.liveCount(Date.now(), SUBAGENT_STALE_MS) > 0;
+    return (
+      this.isRunning() ||
+      this.pendingUiDialogs.list().length > 0 ||
+      this.subagents.liveCount(Date.now(), SUBAGENT_STALE_MS) > 0
+    );
   }
 
   start(): void {

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

@@ -13,7 +13,7 @@ import { RpcCommandTimeoutError, type RpcProcess } from '@/server/lib/omp/rpc/pr
 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';
+import { clearStreamStatus, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
 import { buildWebState, type WebStateHost } from '@/server/lib/omp/rpc/web-state';
 
 /** Runtime surface AgentSessionWrapper exposes to the command dispatcher. */
@@ -66,12 +66,24 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         throw new Error('Cannot send a prompt while a shell command is running');
       }
       const streamingBehavior = command.streamingBehavior as 'steer' | 'followUp' | undefined;
+      // The live `stream` row starts with the DISPATCH, not with agent_start:
+      // the spawn/ack round trip that precedes agent_start must not read as
+      // "nothing happened" in the sidebar after the user hit send. Skipped
+      // while a turn already streams — that row belongs to the running turn,
+      // and this dispatch's failure must never roll it back.
+      const ownsStreamRow = !streamingBehavior && !host.streaming && Boolean(host.sessionId);
+      // A prompt that never started a turn leaves no run behind, so the row we
+      // wrote must go — unless a turn began meanwhile, which owns it now.
+      const releaseStreamRow = (): void => {
+        if (ownsStreamRow && !host.streaming) void clearStreamStatus(host.sessionId);
+      };
       if (!streamingBehavior) {
         host.promptRunning = true;
         host.promptDispatchPendingCount += 1;
         host.awaitingAgentStart = false;
         host.awaitingAgentStartDeadline = 0;
         host.continuationGraceUntil = 0;
+        if (ownsStreamRow) void markStreamStatus(host.sessionId, 'stream');
         notifyRunningChange();
       }
       try {
@@ -85,6 +97,7 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
           host.promptRunning = false;
           host.awaitingAgentStart = false;
           host.awaitingAgentStartDeadline = 0;
+          releaseStreamRow();
           host.emit({ type: 'prompt_result', agentInvoked: false });
           notifyRunningChange();
         } else if (!streamingBehavior && ack?.agentInvoked !== false) {
@@ -95,6 +108,7 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
         host.promptRunning = false;
         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

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

@@ -72,6 +72,24 @@ 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
+ * `isRunning()`: a blocked dialog leaves every turn flag exactly as it was, so
+ * the pending-dialog registry is the only thing that can tell a session waiting
+ * for an answer from an idle one. Feeds the sidebar's "needs input" badge, which
+ * has to reach clients that never opened the session.
+ */
+export function getAwaitingInputSessionIds(): string[] {
+  const ids = new Set<string>();
+  for (const [sessionId, session] of getRegistry()) {
+    if (session.isAlive() && session.getPendingUiDialogs().length > 0) {
+      ids.add(session.sessionId || sessionId);
+    }
+  }
+  return [...ids];
+}
+
 function getRunningListeners(): Set<(update: RunningSessionUpdate) => void> {
   if (!globalThis.__ompRunningListeners) globalThis.__ompRunningListeners = new Set();
   return globalThis.__ompRunningListeners;

package/src/server/lib/omp/session/sidebar-data.server.ts

@@ -22,7 +22,7 @@ import { isValidSessionSortOption, sortFolders } from '@/shared/lib/workspace/si
 import { loadOmpSidebarData } from '@/server/lib/omp/session/reader';
 import { sessionHasSubagents } from '@/server/lib/omp/session/subagent-presence';
 import { healStaleStreamStatuses, loadStreamStatuses } from '@/shared/lib/omp/session/stream-state.server';
-import { getRunningRpcSessionIds } from '@/server/lib/omp/rpc/session-registry';
+import { getAwaitingInputSessionIds, getRunningRpcSessionIds } from '@/server/lib/omp/rpc/session-registry';
 import type { SessionItemData, SessionSortOption, WorkspaceFolderData } from '@/shared/types';
 import type { OmpSession } from '@/shared/types/omp/session';
 
@@ -115,15 +115,21 @@ export async function loadSidebarData(): Promise<SessionListPayload> {
   // `finish` right here — the authoritative status travels with the same
   // fetch that refreshes the sidebar list.
   const streamStatuses: Record<string, 'stream' | 'finish' | 'abort' | 'error'> = {};
+  // Sessions blocked on a dialog nobody has answered yet. Read live from the
+  // process registry (never persisted): the child that owns the question is the
+  // same thing that owns the flag, so a restart cannot leave a stale badge.
+  const awaitingInput = new Set<string>();
   if (!mock) {
     await healStaleStreamStatuses(new Set(getRunningRpcSessionIds()));
     Object.assign(streamStatuses, await loadStreamStatuses());
+    for (const id of getAwaitingInputSessionIds()) awaitingInput.add(id);
   }
   const foldersWithStatus = groupedFolders.map((folder) => ({
     ...folder,
     sessions: (folder.sessions ?? []).map((s) => ({
       ...s,
       streamStatus: streamStatuses[String(s.id)],
+      ...(awaitingInput.has(String(s.id)) ? { awaitingInput: true } : {}),
     })),
   }));
 

package/src/server/lib/updates/apply.ts

@@ -1,16 +1,16 @@
 /**
  * Applies a requested update. oh-my-pi is updated through the omp binary;
  * OMPChamber through the shared self-update engine, which replaces the running
- * install in place (bun global install, or git fast-forward + rebuild).
+ * install in place (bun global install, or git fast-forward + rebuild) and then
+ * restarts this instance through a detached `ompchamber restart` — unless the
+ * instance was started from source, which its own launcher has to restart.
  */
 
+import { scheduleSelfRestart } from '@/server/lib/lifecycle/restart';
 import { updateOmpChamber } from '@/server/lib/updates/install';
 import { applyOmpUpdate } from '@/server/lib/updates/omp';
 import type { UpdateApplyResult, UpdateTarget } from '@/shared/types/updates';
 
-/** A server cannot replace its own process, so the user restarts it. */
-const RESTART_NOTE = ' Restart the server (`ompchamber restart`) to apply it.';
-
 export async function applyUpdate(target: UpdateTarget): Promise<UpdateApplyResult> {
   if (target === 'omp') {
     try {
@@ -28,11 +28,14 @@ export async function applyUpdate(target: UpdateTarget): Promise<UpdateApplyResu
 
   if (target === 'ompchamber') {
     const result = await updateOmpChamber();
+    // Only a call that actually replaced files has something to restart for:
+    // an "already up to date" answer must not bounce a healthy server.
+    const restart = result.success && result.updated ? scheduleSelfRestart() : null;
     return {
       success: result.success,
       target: 'ompchamber',
       manual: result.manual,
-      message: `${result.message}${result.updated ? RESTART_NOTE : ''}`,
+      message: restart ? `${result.message} ${restart.message}` : result.message,
       output: result.output || undefined,
     };
   }

package/src/server/lib/updates/install.ts

@@ -14,6 +14,7 @@
 
 import { join as joinPath, resolve as resolvePath } from 'node:path';
 
+import { resolveBunBin } from '@/server/lib/lifecycle/bun';
 import { fetchLatestRelease, type GitHubRelease } from '@/server/lib/updates/github';
 import {
   detectInstallMethod,
@@ -137,10 +138,12 @@ export function resolveInstallContext(pkgRoot = DEFAULT_PKG_ROOT): InstallContex
   const remote = gitWorkTree ? runSync(['git', '-C', root, 'remote', 'get-url', 'origin']) : null;
   const gitRemote = remote?.ok && remote.out.length > 0 ? remote.out : null;
 
-  const execPath = process.execPath;
-  const bunBin = /(^|[\\/])bun$/.test(execPath) ? execPath : (Bun.which('bun') ?? 'bun');
-
-  return { ...detectInstallMethod({ pkgRoot: root, gitWorkTree, gitRemote }), pkgRoot: root, gitRemote, bunBin };
+  return {
+    ...detectInstallMethod({ pkgRoot: root, gitWorkTree, gitRemote }),
+    pkgRoot: root,
+    gitRemote,
+    bunBin: resolveBunBin(),
+  };
 }
 
 /** The commands that install `version` for a given install method. */

package/src/server/routes/health/probe.ts

@@ -1,5 +1,6 @@
 import { json, NO_STORE_HEADERS } from '@/server/lib/remix-compat';
 import pkg from '@/../package.json';
+import { resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
 import { isMockMode } from '@/server/mock.server';
 
 const STARTED_AT = Date.now();
@@ -26,7 +27,7 @@ export async function loader() {
       // `launchMode` are what `status` prints, and the pair with `pid` is what
       // separates a dev server from a stale published build.
       mode: Bun.env.NODE_ENV === 'production' ? 'prod' : 'dev',
-      launchMode: Bun.env.OMPCHAMBER_LAUNCH_MODE ?? 'direct',
+      launchMode: resolveLaunchMode(),
       port: Number(Bun.env.PORT) || 3000,
       host: Bun.env.HOST || 'localhost',
     },