ompchamber 0.6.0 → 0.7.0

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "ompchamber",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Developer web console and diagnostic chamber for AI Oh-My-Pi — Elysia + Preact on Bun.",
+  "license": "UNLICENSED",
+  "author": "Wijanarko Putra Rajeb <wijanarko.rajeb@gmail.com>",
   "type": "module",
   "engines": {
     "bun": ">=1.4.0"

package/src/cli/lib/args.js

@@ -189,7 +189,7 @@ COMMANDS:
   serve          Start the OMPChamber web server (default when no command is given)
   update         Update OMPChamber to the latest GitHub release
   stop           Stop running OMPChamber instances (every one, or --port <port>)
-  restart        Stop and then start again (every instance, or --port <port>)
+  restart        Stop and start again (every CLI-started instance, or --port <port>)
   status         Show running instances (every one, or --port <port>)
   logs           Print or follow server logs (every instance, or --port <port>)
 

package/src/cli/lib/commands/restart.js

@@ -3,11 +3,17 @@
 // Scoping matches `status` and `stop`: without `--port` every live instance is
 // restarted on its own recorded port/host/mode, and `--port <port>` restricts
 // the restart to that one. With nothing running, the command is simply `serve`.
+//
+// Instances the CLI did not start are left alone, exactly as `ompchamber update`
+// leaves them: `bun run dev` and `bun run start` own their own process, so
+// replacing it would break a loop OMPChamber does not manage. `ompchamber stop`
+// is still the deliberate way to end one.
 
 import { findLiveInstance, listLiveInstances, stopInstance } from '@/cli/lib/runtime.js';
 import { STOP_TIMEOUT_MS } from '@/cli/lib/process-lifecycle.js';
 import { log, isJson, isQuiet } from '@/cli/lib/output.js';
 import { run as runServe } from '@/cli/lib/commands/serve.js';
+import { isAutoRestartable, skipRestartNote } from '@/server/lib/lifecycle/restart';
 
 function explicitPort(options) {
   const raw = options?.port;
@@ -28,6 +34,11 @@ export async function run(options, ctx) {
   if (targets.length === 0) return runServe(options, ctx);
 
   for (const live of targets) {
+    if (!isAutoRestartable(live.launchMode)) {
+      if (!json && !quiet) log(`Skipping OMPChamber on port ${live.port}: ${skipRestartNote(live.launchMode)}.`);
+      continue;
+    }
+
     if (!json && !quiet) log(`Stopping OMPChamber on port ${live.port} (pid ${live.pid})...`);
     await stopInstance(live, { timeoutMs: STOP_TIMEOUT_MS });
 

package/src/cli/lib/commands/update.js

@@ -2,19 +2,23 @@
 //
 // The installation mechanics live in the shared update engine so the CLI and
 // the console's "Update" button do the same thing; this command owns the
-// terminal presentation and restarts any instance still serving the previous
-// build.
+// terminal presentation and restarts the instances still serving the previous
+// build (the ones the CLI started — a server running from source is left to its
+// own launcher).
 
 import { color, configure, error, log, ok, warn, printJson, isJson, isQuiet } from '@/cli/lib/output.js';
 import { listLiveInstances, findLiveInstance, stopInstance } from '@/cli/lib/runtime.js';
 import { STOP_TIMEOUT_MS } from '@/cli/lib/process-lifecycle.js';
 import { run as runServe } from '@/cli/lib/commands/serve.js';
+import { isAutoRestartable, skipRestartNote } from '@/server/lib/lifecycle/restart';
 import { resolveInstallContext, resolveOmpChamberVersion, updateOmpChamber } from '@/server/lib/updates/install';
 
 /**
  * Live instances to restart after an update: every one with `--all`, otherwise
  * the first. Their recorded port/host/mode is reused, so a server started on a
- * non-default port comes back on that same port.
+ * non-default port comes back on that same port. Instances started outside the
+ * CLI (`bun run dev`, `bun run start`, a supervisor) are reported and left
+ * running — their own launcher is what applies the new files.
  */
 async function liveInstances(options) {
   if (options?.all) return await listLiveInstances();
@@ -24,7 +28,14 @@ async function liveInstances(options) {
 
 async function restartInstances(options, ctx) {
   const restarted = [];
+  const skipped = [];
   for (const entry of await liveInstances(options)) {
+    if (!isAutoRestartable(entry.launchMode)) {
+      skipped.push({ port: entry.port, pid: entry.pid, launchMode: entry.launchMode });
+      log(`Skipping OMPChamber on port ${entry.port}: ${skipRestartNote(entry.launchMode)}.`);
+      continue;
+    }
+
     log(`Restarting OMPChamber on port ${entry.port} (pid ${entry.pid})...`);
     await stopInstance(entry, { timeoutMs: STOP_TIMEOUT_MS });
     await runServe(
@@ -41,7 +52,7 @@ async function restartInstances(options, ctx) {
     );
     restarted.push(entry.port);
   }
-  return restarted;
+  return { restarted, skipped };
 }
 
 async function runCheck(pkgRoot, json) {
@@ -91,8 +102,10 @@ export async function run(options, ctx) {
     // Restarting prints through the serve command; silence it so stdout stays
     // one JSON document.
     if (result.success && result.updated && shouldRestart) configure({ json: false, quiet: true });
-    const restarted = result.success && result.updated && shouldRestart ? await restartInstances(options, ctx) : [];
-    printJson({ ...result, restarted });
+    const { restarted, skipped } = result.success && result.updated && shouldRestart
+      ? await restartInstances(options, ctx)
+      : { restarted: [], skipped: [] };
+    printJson({ ...result, restarted, skipped });
     if (!result.success) process.exitCode = 1;
     return;
   }
@@ -111,7 +124,8 @@ export async function run(options, ctx) {
     return;
   }
 
-  if ((await restartInstances(options, ctx)).length === 0) {
+  const { restarted, skipped } = await restartInstances(options, ctx);
+  if (restarted.length === 0 && skipped.length === 0) {
     log('No running instance to restart.');
   }
 }

package/src/cli/lib/runtime.js

@@ -13,6 +13,7 @@ import fs from 'node:fs';
 import { ensureDataDirs, getLogFilePath } from '@/cli/lib/paths.js';
 import { killChildTree, STOP_TIMEOUT_MS } from '@/cli/lib/process-lifecycle.js';
 import { getProcessState, isProcessAlive } from '@/server/lib/lifecycle/identity';
+import { launchModeArg } from '@/server/lib/lifecycle/launch-mode';
 import { listInstanceRecords, readInstanceRecord, removeInstanceRecord } from '@/server/lib/lifecycle/instance';
 import { fetchHealth, probeHost } from '@/server/lib/lifecycle/probe';
 import { joinPath, homeDir } from '@/cli/lib/path-utils.js';
@@ -134,7 +135,10 @@ export function resolveBunBin() {
  * the SSR shell either way. `--ompchamber-server` is an identity marker: it
  * makes this process recognizable in `ps` output, which is how a starting
  * server decides whether a busy port belongs to OMPChamber before signalling
- * anything.
+ * anything. The launch mode rides along as argv (`--launch-mode=`), never as an
+ * environment variable: env is inherited by descendants, so a `bun run dev`
+ * started from an OMPChamber shell would otherwise be labelled `daemon` and
+ * replaced by the next update.
  */
 export function buildServeInvocation({ pkgRoot, mode, port, host, launchMode = 'daemon' }) {
   const entry = joinPath(pkgRoot, 'src', 'server', 'index.ts');
@@ -146,13 +150,12 @@ export function buildServeInvocation({ pkgRoot, mode, port, host, launchMode = '
   }
   return {
     file: resolveBunBin(),
-    args: [entry, '--ompchamber-server'],
+    args: [entry, '--ompchamber-server', launchModeArg(launchMode)],
     env: {
       ...Bun.env,
       NODE_ENV: mode === 'prod' ? 'production' : 'development',
       PORT: String(port),
       HOST: host,
-      OMPCHAMBER_LAUNCH_MODE: launchMode,
     },
   };
 }

package/src/client/hooks/chat/omp/index.ts

@@ -1,8 +1,8 @@
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import type { ChatMessageData, OmpAgentCallbacks, OmpAgentHandle, OmpAgentState, StreamTransport } from '@/shared/types';
 import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { type ToolResultRecord, useOmpAgentStream } from '@/client/hooks/chat/omp/stream';
+import { useOmpPromptSender } from '@/client/hooks/chat/omp/prompt-send';
 import { stopAgentSession } from '@/shared/lib/chat/omp/abort';
 
 /**
@@ -98,114 +98,9 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
     };
   }, [sessionId, disconnect, connect]);
 
-  /** Send a prompt to the omp session via the RPC bridge. */
-  const sendPrompt = useCallback(async (
-    message: string,
-    images?: { data: string; mimeType: string }[],
-    options?: { accessMode?: ApprovalMode },
-  ) => {
-    const sid = sessionIdRef.current;
-    if (!sid) return false;
-    setState((prev) => ({ ...prev, isGenerating: true, error: null }));
-    try {
-      // Mirror omp-web handleSend: warm the session process up with get_state
-      // (spawns it on first use), then attach the event stream before sending
-      // the prompt so no agent events are missed.
-      const warmup = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        // The mode rides the warmup too: this is the request that lazily spawns
-        // an idle session, and omp only accepts --approval-mode at spawn time.
-        body: JSON.stringify({
-          type: 'get_state',
-          ...(options?.accessMode ? { accessMode: options.accessMode } : {}),
-        }),
-      });
-      if (warmup.ok) connect(sid);
-
-      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          type: 'prompt',
-          message,
-          ...(images?.length ? { images } : {}),
-          ...(options?.accessMode ? { accessMode: options.accessMode } : {}),
-        }),
-      });
-      const body = (await res.json().catch(() => ({}))) as { success?: boolean; error?: string };
-      if (!res.ok || body.error) {
-        // `session_busy`: the ack timed out behind a still-running turn, so the
-        // prompt may already be accepted — never resend it automatically.
-        setState((prev) => ({ ...prev, isGenerating: false, error: body.error ?? `HTTP ${res.status}` }));
-        return false;
-      }
-      return true;
-    } catch (e) {
-      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
-      return false;
-    }
-  }, [connect]);
-
-  /** Spawn a brand-new omp session and send the first prompt: ensure_session
-   *  first (returns omp's real session id), attach the event stream, then send
-   *  the prompt through the existing session route so no agent events are
-   *  missed. Model/thinking picks ride the ensure_session body so omp applies
-   *  them BEFORE the first prompt (and their JSONL change entries are written
-   *  up front, not after the run starts). Returns the new session id on
-   *  success, or null on failure — the caller adopts the id as the active
-   *  session. */
-  const sendNewPrompt = useCallback(async (
-    message: string,
-    cwd: string,
-    images?: { data: string; mimeType: string }[],
-    composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
-  ): Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null> => {
-    setState((prev) => ({ ...prev, isGenerating: true, error: null }));
-    try {
-      const created = await fetch('/api/agent/new', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          type: 'ensure_session',
-          cwd,
-          ...(composerOptions?.model ? composerOptions.model : {}),
-          ...(composerOptions?.thinkingLevel ? { thinkingLevel: composerOptions.thinkingLevel } : {}),
-          ...(composerOptions?.accessMode ? { accessMode: composerOptions.accessMode } : {}),
-        }),
-      });
-      const createdBody = (await created.json().catch(() => ({}))) as {
-        success?: boolean;
-        sessionId?: string;
-        model?: { provider: string; modelId: string } | null;
-        error?: string;
-      };
-      if (!created.ok || !createdBody.sessionId) {
-        setState((prev) => ({ ...prev, isGenerating: false, error: createdBody.error ?? `HTTP ${created.status}` }));
-        return null;
-      }
-      const sid = createdBody.sessionId;
-      connect(sid);
-      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          type: 'prompt',
-          message,
-          ...(images?.length ? { images } : {}),
-        }),
-      });
-      const body = (await res.json().catch(() => ({}))) as { success?: boolean; error?: string };
-      if (!res.ok || body.error) {
-        setState((prev) => ({ ...prev, isGenerating: false, error: body.error ?? `HTTP ${res.status}` }));
-        return null;
-      }
-      return { sessionId: sid, model: createdBody.model ?? null };
-    } catch (e) {
-      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
-      return null;
-    }
-  }, [connect]);
+  // Prompt delivery (warm-up + stream attach + the dispatch-time sidebar
+  // signal) lives in its own module so this hook stays under the size ceiling.
+  const { sendPrompt, sendNewPrompt } = useOmpPromptSender({ sessionIdRef, connect, setState });
 
   /** Abort the running agent turn. */
   const abort = useCallback(async () => {

package/src/client/hooks/chat/omp/prompt-send.ts

@@ -0,0 +1,161 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Prompt delivery for the live omp bridge: warm the session up, attach the
+ * event stream, POST the prompt, then signal the sidebars the moment it is
+ * dispatched.
+ *
+ * The signal is the point: the server writes the live `stream` row when it
+ * dispatches the prompt, so waiting for `agent_start` (spawn + ack round trip)
+ * would leave the sidebar spinner dark for seconds after the user hit send.
+ * Extracted from useOmpAgent so that hook stays under the repo's per-file size
+ * ceiling.
+ */
+
+import { useCallback } from 'preact/hooks';
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { OmpAgentState } from '@/shared/types';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+
+export interface OmpPromptSenderDeps {
+  /** Live session id the prompt targets; the caller mirrors its prop into it. */
+  sessionIdRef: { current: string | null };
+  /** Attach the event stream to a spawned session. */
+  connect: (sessionId: string) => void;
+  setState: Dispatch<SetStateAction<OmpAgentState>>;
+}
+
+export interface OmpPromptSender {
+  sendPrompt: (message: string, images?: { data: string; mimeType: string }[], options?: { accessMode?: ApprovalMode }) => Promise<boolean>;
+  sendNewPrompt: (
+    message: string,
+    cwd: string,
+    images?: { data: string; mimeType: string }[],
+    composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
+  ) => Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null>;
+}
+
+export function useOmpPromptSender(deps: OmpPromptSenderDeps): OmpPromptSender {
+  const { sessionIdRef, connect, setState } = deps;
+
+  /** Send a prompt to the omp session via the RPC bridge. */
+  const sendPrompt = useCallback(async (
+    message: string,
+    images?: { data: string; mimeType: string }[],
+    options?: { accessMode?: ApprovalMode },
+  ) => {
+    const sid = sessionIdRef.current;
+    if (!sid) return false;
+    setState((prev) => ({ ...prev, isGenerating: true, error: null }));
+    try {
+      // Mirror omp-web handleSend: warm the session process up with get_state
+      // (spawns it on first use), then attach the event stream before sending
+      // the prompt so no agent events are missed.
+      const warmup = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        // The mode rides the warmup too: this is the request that lazily spawns
+        // an idle session, and omp only accepts --approval-mode at spawn time.
+        body: JSON.stringify({
+          type: 'get_state',
+          ...(options?.accessMode ? { accessMode: options.accessMode } : {}),
+        }),
+      });
+      if (warmup.ok) connect(sid);
+
+      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'prompt',
+          message,
+          ...(images?.length ? { images } : {}),
+          ...(options?.accessMode ? { accessMode: options.accessMode } : {}),
+        }),
+      });
+      const body = (await res.json().catch(() => ({}))) as { success?: boolean; error?: string };
+      if (!res.ok || body.error) {
+        // `session_busy`: the ack timed out behind a still-running turn, so the
+        // prompt may already be accepted — never resend it automatically.
+        setState((prev) => ({ ...prev, isGenerating: false, error: body.error ?? `HTTP ${res.status}` }));
+        return false;
+      }
+      // Tell the sidebars to re-read the session list now — the server wrote
+      // this session's live `stream` row at dispatch. Revalidation is
+      // leading-edge throttled, so this lands immediately.
+      window.dispatchEvent(new CustomEvent('omp:session-updated', { detail: { sessionId: sid } }));
+      return true;
+    } catch (e) {
+      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
+      return false;
+    }
+  }, [connect, sessionIdRef, setState]);
+
+  /** Spawn a brand-new omp session and send the first prompt: ensure_session
+   *  first (returns omp's real session id), attach the event stream, then send
+   *  the prompt through the existing session route so no agent events are
+   *  missed. Model/thinking picks ride the ensure_session body so omp applies
+   *  them BEFORE the first prompt (and their JSONL change entries are written
+   *  up front, not after the run starts). Returns the new session id on
+   *  success, or null on failure — the caller adopts the id as the active
+   *  session. */
+  const sendNewPrompt = useCallback(async (
+    message: string,
+    cwd: string,
+    images?: { data: string; mimeType: string }[],
+    composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
+  ): Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null> => {
+    setState((prev) => ({ ...prev, isGenerating: true, error: null }));
+    try {
+      const created = await fetch('/api/agent/new', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'ensure_session',
+          cwd,
+          ...(composerOptions?.model ? composerOptions.model : {}),
+          ...(composerOptions?.thinkingLevel ? { thinkingLevel: composerOptions.thinkingLevel } : {}),
+          ...(composerOptions?.accessMode ? { accessMode: composerOptions.accessMode } : {}),
+        }),
+      });
+      const createdBody = (await created.json().catch(() => ({}))) as {
+        success?: boolean;
+        sessionId?: string;
+        model?: { provider: string; modelId: string } | null;
+        error?: string;
+      };
+      if (!created.ok || !createdBody.sessionId) {
+        setState((prev) => ({ ...prev, isGenerating: false, error: createdBody.error ?? `HTTP ${created.status}` }));
+        return null;
+      }
+      const sid = createdBody.sessionId;
+      connect(sid);
+      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'prompt',
+          message,
+          ...(images?.length ? { images } : {}),
+        }),
+      });
+      const body = (await res.json().catch(() => ({}))) as { success?: boolean; error?: string };
+      if (!res.ok || body.error) {
+        setState((prev) => ({ ...prev, isGenerating: false, error: body.error ?? `HTTP ${res.status}` }));
+        return null;
+      }
+      // Same dispatch-time signal as sendPrompt: the new session's live badge
+      // must not wait for agent_start + the first JSONL write.
+      window.dispatchEvent(new CustomEvent('omp:session-updated', { detail: { sessionId: sid } }));
+      return { sessionId: sid, model: createdBody.model ?? null };
+    } catch (e) {
+      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
+      return null;
+    }
+  }, [connect, setState]);
+
+  return { sendPrompt, sendNewPrompt };
+}

package/src/client/hooks/chat/timeline/send.ts

@@ -304,8 +304,9 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
             next.set('sessionId', spawned.sessionId);
             return next;
           }, { replace: true });
-          // The agent_start event refreshes the session metadata/sidebar once
-          // the JSONL has the user turn; no immediate refresh is needed here.
+          // The sidebar already re-read at prompt dispatch (sendNewPrompt
+          // signals it), so the new session shows its live badge without
+          // waiting for the JSONL to carry the user turn.
           return;
         }
       }

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);
+  });
+});