ompchamber 3.5.0 → 3.6.0

package/src/client/components/settings/categories/skill-settings/SidebarList.tsx

@@ -1,7 +1,7 @@
 import { useState } from 'preact/hooks';
 import { ChevronDown, ChevronRight, Plus } from 'lucide-preact';
 import type { SkillItem } from '@/shared/types';
-import { ProjectSelectorDropdown } from '@/client/components/settings/ProjectSelectorDropdown';
+import { ProjectSelectorDropdown, type ProjectOption } from '@/client/components/settings/ProjectSelectorDropdown';
 
 interface SkillSidebarListProps {
   skills: SkillItem[];
@@ -11,6 +11,8 @@ interface SkillSidebarListProps {
   onAddNewSkill: () => void;
   selectedProject: string;
   onSelectProject: (project: string) => void;
+  /** Real workspace folders; defaults to the shared placeholder list. */
+  projectOptions?: ProjectOption[];
 }
 
 export function SkillSidebarList({
@@ -21,6 +23,7 @@ export function SkillSidebarList({
   onAddNewSkill,
   selectedProject,
   onSelectProject,
+  projectOptions,
 }: SkillSidebarListProps) {
   const [collapsedGroups, setCollapsedGroups] = useState<Record<string, boolean>>({});
 
@@ -55,8 +58,9 @@ export function SkillSidebarList({
         variant="compact"
         selectedProject={selectedProject}
         onChangeProject={onSelectProject}
+        {...(projectOptions ? { options: projectOptions } : {})}
         getTriggerLabel={(options, value) =>
-          options.find((option) => option.id === value)?.label || value
+          options.find((option) => option.id === value || option.value === value)?.label || value
         }
       />
 
@@ -77,8 +81,10 @@ export function SkillSidebarList({
 
       {/* Skills List */}
       <div className="flex-1 scrollbar-overlay-container scrollbar-overlay-static p-1.5 space-y-2">
+        {/* The picker above names the scope; the list is exactly that scope's
+            skills, so a second scope claim here would only be able to lie. */}
         <div className="px-2 pt-1 pb-0.5 text-[10px] font-bold text-ink/50 uppercase tracking-wider">
-          USER SKILLS
+          SKILLS
         </div>
 
         {/* Temporary "New Skill" indicator item */}

package/src/client/data/settings/command.ts

@@ -7,8 +7,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'init',
     description: 'guided AGENTS.md setup',
     scope: 'system',
-    overrideAgent: 'Not selected',
-    overrideModel: 'Not selected',
     template: `Initialize AGENTS.md instructions for this repository following guided prompts. Context: $ARGUMENTS`,
     isBuiltIn: true,
   },
@@ -17,8 +15,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'review',
     description: 'review changes [commit|branch|working]',
     scope: 'system',
-    overrideAgent: 'code-reviewer',
-    overrideModel: 'Not selected',
     template: `Review the current changes in $ARGUMENTS and summarize bugs, formatting issues, and test considerations.\n!\`git diff --stat\``,
     isBuiltIn: true,
   },
@@ -28,8 +24,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'debugging',
     description: 'MUST USE for any real runtime debugging session',
     scope: 'user',
-    overrideAgent: 'coder',
-    overrideModel: 'Not selected',
     template: `Analyze the runtime error log and isolate the root failure:\n!\`bun run test\`\nFix the issue and verify: $ARGUMENTS`,
   },
   {
@@ -37,8 +31,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'frontend',
     description: 'MUST USE for frontend/web UI/UX development',
     scope: 'user',
-    overrideAgent: 'frontend-specialist',
-    overrideModel: 'Not selected',
     template: `Implement clean responsive UI component following Tailwind and theme variable specifications.\nTarget file: @$ARGUMENTS`,
   },
   {
@@ -46,8 +38,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'git-master',
     description: 'MUST USE for ANY git operations and commit conventions',
     scope: 'user',
-    overrideAgent: 'git-sync',
-    overrideModel: 'Not selected',
     template: `Inspect git status and generate clean conventional commit message:\n!\`git status -s\`\nDetails: $ARGUMENTS`,
   },
   {
@@ -55,8 +45,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'goal',
     description: '(builtin) Set, show, pause, resume session goal',
     scope: 'user',
-    overrideAgent: 'Sisyphus - ultraworker',
-    overrideModel: 'Not selected',
     template: `Manage current goal state: $ARGUMENTS`,
   },
   {
@@ -64,8 +52,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'handoff',
     description: '(builtin) Create a detailed context handoff report',
     scope: 'user',
-    overrideAgent: 'general',
-    overrideModel: 'Not selected',
     template: `Summarize work in progress, architectural decisions, and open items for handoff to next agent session.\n$ARGUMENTS`,
   },
   {
@@ -73,8 +59,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'hyperplan',
     description: '(builtin) Adversarial multi-agent plan builder',
     scope: 'user',
-    overrideAgent: 'Prometheus - Plan Builder',
-    overrideModel: 'Not selected',
     template: `Construct a detailed plan with review gates and adversarial critiques for $ARGUMENTS.`,
   },
   {
@@ -82,8 +66,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'init-deep',
     description: '(builtin) Initialize hierarchical AGENTS.md setup',
     scope: 'user',
-    overrideAgent: 'architect',
-    overrideModel: 'Not selected',
     template: `Analyze directory structure and construct domain-specific AGENTS.md files for subpackages: $ARGUMENTS`,
   },
   {
@@ -91,8 +73,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'playwright',
     description: 'MUST USE for any browser-related testing',
     scope: 'user',
-    overrideAgent: 'e2e-runner',
-    overrideModel: 'Not selected',
     template: `Run playwright tests for scenario: $ARGUMENTS\n!\`bunx playwright test\``,
   },
   {
@@ -100,8 +80,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'pty-open-background-spy',
     description: 'Open PTY Sessions Web Interface',
     scope: 'user',
-    overrideAgent: 'devops-runner',
-    overrideModel: 'Not selected',
     template: `Launch PTY background session monitor with target: $ARGUMENTS`,
   },
   {
@@ -109,8 +87,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'pty-show-server-url',
     description: 'Show PTY Sessions Web Interface URL',
     scope: 'user',
-    overrideAgent: 'devops-runner',
-    overrideModel: 'Not selected',
     template: `Output the active PTY session web socket endpoint and UI URL.`,
   },
   {
@@ -118,8 +94,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'refactor',
     description: '(builtin) Intelligent refactoring coordinator',
     scope: 'user',
-    overrideAgent: 'refactor-pro',
-    overrideModel: 'Not selected',
     template: `Refactor module @$ARGUMENTS into decoupled single-responsibility files without changing public behavior. Keep files under 350 lines.`,
   },
   {
@@ -127,8 +101,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'benchmark',
     description: 'Run performance benchmark suites and record timings',
     scope: 'user',
-    overrideAgent: 'performance-tuner',
-    overrideModel: 'Not selected',
     template: `Execute benchmark suite on target: $ARGUMENTS`,
   },
   {
@@ -136,8 +108,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'bundle-analyze',
     description: 'Inspect vendor bundle size and dynamic chunk splitting',
     scope: 'user',
-    overrideAgent: 'bundle-optimizer',
-    overrideModel: 'Not selected',
     template: `Run build analyzer and report chunk weight statistics: !\`bun run build\``,
   },
   {
@@ -145,8 +115,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'db-migrate',
     description: 'Review and execute database migrations safely',
     scope: 'user',
-    overrideAgent: 'database-analyzer',
-    overrideModel: 'Not selected',
     template: `Review pending schema migrations and verify backward compatibility: $ARGUMENTS`,
   },
   {
@@ -154,8 +122,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'doc-generate',
     description: 'Generate API documentation and usage guides',
     scope: 'user',
-    overrideAgent: 'doc-writer',
-    overrideModel: 'Not selected',
     template: `Draft comprehensive technical documentation for module @$ARGUMENTS`,
   },
   {
@@ -163,8 +129,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'security-scan',
     description: 'Run static security analysis and check dependency vulnerabilities',
     scope: 'user',
-    overrideAgent: 'security-auditor',
-    overrideModel: 'Not selected',
     template: `Scan repository for leaked secrets and outdated dependencies: !\`npm audit\``,
   },
   {
@@ -172,8 +136,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'test-unit',
     description: 'Run unit test suite with coverage report',
     scope: 'user',
-    overrideAgent: 'test-engineer',
-    overrideModel: 'Not selected',
     template: `Run test suite with coverage: !\`bun test\` - Focus: $ARGUMENTS`,
   },
   {
@@ -181,8 +143,6 @@ export const DEFAULT_COMMANDS_LIST: CommandItem[] = [
     name: 'typecheck',
     description: 'Run strict TypeScript compiler verification',
     scope: 'user',
-    overrideAgent: 'lint-fixer',
-    overrideModel: 'Not selected',
     template: `Run strict typecheck without emitting files: !\`bunx tsc --noEmit\``,
   },
 ];

package/src/client/hooks/settings/workspace-roots.ts

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useEffect, useState } from 'preact/hooks';
+import type { ProjectOption } from '@/client/components/settings/ProjectSelectorDropdown';
+
+interface ProjectConfigItem {
+  id: string;
+  name: string;
+  path?: string;
+}
+
+export interface WorkspaceRoots {
+  options: ProjectOption[];
+  /** Workspace root for a selected option id, or null for the user scope. */
+  rootFor: (optionId: string) => string | null;
+  /** Query string (with leading `?`) for a read scoped to this option. */
+  queryFor: (optionId: string) => string;
+  /** Extra body fields scoping a write to this option. */
+  scopeBodyFor: (optionId: string) => { root?: string; scope?: string };
+  /** True when this option is a real workspace (the project scope exists). */
+  isWorkspace: (optionId: string) => boolean;
+}
+
+/** Option id for the user-level (no workspace) scope. */
+export const GLOBAL_SCOPE_ID = 'global';
+
+const USER_OPTION: ProjectOption = {
+  id: GLOBAL_SCOPE_ID,
+  name: 'global',
+  label: 'User (all projects)',
+  value: '',
+};
+
+/**
+ * The workspace folders the skills/commands panels can be scoped to.
+ *
+ * These are the real registered folders (`/api/settings/projects`), not the
+ * hardcoded placeholder list the panels used to offer: a panel scoped to a
+ * made-up project name sent a root the server could not resolve, so the picker
+ * silently did nothing. The `value` of each option is the folder's project
+ * path, which is what the API takes as `?root=`.
+ *
+ * The USER scope is `?scope=user` rather than "no root": omp resolves
+ * project-scope skills and commands from its process cwd, so an unscoped read
+ * answered for whatever directory the server happened to run in. `scope=user`
+ * pins that read to the agent dir, which is the only cwd whose inventory is
+ * the user's own.
+ */
+export function useWorkspaceRoots(): WorkspaceRoots {
+  const [options, setOptions] = useState<ProjectOption[]>([USER_OPTION]);
+
+  useEffect(() => {
+    let active = true;
+    fetch('/api/settings/projects')
+      .then((res) => res.json())
+      .then((data: { projects?: ProjectConfigItem[] }) => {
+        if (!active) return;
+        const folders = (data.projects ?? [])
+          .filter((project) => typeof project.path === 'string' && project.path)
+          .map((project) => ({
+            id: project.id,
+            name: project.name,
+            label: project.name,
+            value: project.path as string,
+          }));
+        setOptions([...folders, USER_OPTION]);
+      })
+      .catch((error) => console.error('Failed to load workspace folders:', error));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  // The dropdown reports the option's VALUE (a project path) while a panel may
+  // hold either that or the option id, so both resolve to the same root. An
+  // id-only lookup silently answered the user scope for every workspace.
+  const rootFor = (optionId: string): string | null => {
+    const option = options.find((candidate) => candidate.id === optionId || candidate.value === optionId);
+    const value = option?.value ?? '';
+    return value || null;
+  };
+
+  const queryFor = (optionId: string): string => {
+    const root = rootFor(optionId);
+    return root ? `?root=${encodeURIComponent(root)}` : '?scope=user';
+  };
+
+  const scopeBodyFor = (optionId: string): { root?: string; scope?: string } => {
+    const root = rootFor(optionId);
+    return root ? { root } : { scope: 'user' };
+  };
+
+  const isWorkspace = (optionId: string): boolean => rootFor(optionId) !== null;
+
+  return { options, rootFor, queryFor, scopeBodyFor, isWorkspace };
+}

package/src/client/hooks/ui/updates/index.ts

@@ -0,0 +1,178 @@
+/**
+ * Live update state: the check that reports what is available, and the apply
+ * that runs it.
+ *
+ * The apply is a POST whose response is an SSE stream, not a JSON body. An
+ * `omp update` or an OMPChamber install runs for minutes; a buffered response
+ * left the console with a spinner and nothing else until it finished, and
+ * discarded the command output the server had already collected. Every frame
+ * the stream carries is folded into `progress`, which survives the modal being
+ * closed — the hook lives on the sidebar, so leaving the dialog no longer hides
+ * the run.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import { readSseStream } from '@/shared/lib/chat/read-sse';
+import { appendUpdateLog, type UpdateLogState } from '@/shared/lib/updates/progress';
+import type { UpdateApplyResult, UpdateCheckResult, UpdateTarget } from '@/shared/types/updates';
+
+export interface UseUpdatesResult {
+  info: UpdateCheckResult | null;
+  checking: boolean;
+  applying: UpdateTarget | null;
+  /** Log of the run in flight (or the last one), null before any apply. */
+  progress: UpdateLogState | null;
+  error: string | null;
+  hasUpdate: boolean;
+  check: () => Promise<void>;
+  apply: (target: UpdateTarget) => Promise<UpdateApplyResult | null>;
+}
+
+function responseMessage(payload: unknown, fallback: string): string {
+  if (typeof payload !== 'object' || payload === null) return fallback;
+
+  if ('error' in payload && typeof payload.error === 'string') return payload.error;
+  if ('message' in payload && typeof payload.message === 'string') return payload.message;
+  return fallback;
+}
+
+export function isUpdateApplyResult(payload: unknown): payload is UpdateApplyResult {
+  if (typeof payload !== 'object' || payload === null) return false;
+
+  return (
+    'success' in payload && typeof payload.success === 'boolean' &&
+    'target' in payload && (payload.target === 'ompchamber' || payload.target === 'omp') &&
+    'manual' in payload && typeof payload.manual === 'boolean' &&
+    'message' in payload && typeof payload.message === 'string'
+  );
+}
+
+export function useUpdates(): UseUpdatesResult {
+  const [info, setInfo] = useState<UpdateCheckResult | null>(null);
+  const [checking, setChecking] = useState(false);
+  const [applying, setApplying] = useState<UpdateTarget | null>(null);
+  const [progress, setProgress] = useState<UpdateLogState | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const inFlightCheckRef = useRef<Promise<void> | null>(null);
+  const didAutoCheckRef = useRef(false);
+  const applyAbortRef = useRef<AbortController | null>(null);
+
+  const check = useCallback(() => {
+    if (inFlightCheckRef.current) return inFlightCheckRef.current;
+
+    const request = (async () => {
+      setChecking(true);
+      setError(null);
+
+      try {
+        const response = await fetch('/api/updates/check');
+        const payload: unknown = await response.json();
+        if (!response.ok) {
+          throw new Error(responseMessage(payload, `Update check failed (HTTP ${response.status})`));
+        }
+        setInfo(payload as UpdateCheckResult);
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : 'Unable to check for updates.');
+      } finally {
+        setChecking(false);
+        inFlightCheckRef.current = null;
+      }
+    })();
+
+    inFlightCheckRef.current = request;
+    return request;
+  }, []);
+
+  const apply = useCallback(async (target: UpdateTarget): Promise<UpdateApplyResult | null> => {
+    setApplying(target);
+    setProgress({ lines: [], pending: '', truncated: false });
+    setError(null);
+
+    const controller = new AbortController();
+    applyAbortRef.current = controller;
+    // The fold is mirrored in a local so each frame is one setState, rather
+    // than a read-modify-write against the previous render's state.
+    let log: UpdateLogState = { lines: [], pending: '', truncated: false };
+    let result: UpdateApplyResult | null = null;
+
+    try {
+      const response = await fetch('/api/updates/apply', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'text/event-stream' },
+        body: JSON.stringify({ target }),
+        signal: controller.signal,
+      });
+
+      if (!response.ok && !(response.headers.get('content-type') ?? '').includes('text/event-stream')) {
+        const payload: unknown = await response.json().catch(() => null);
+        const message = responseMessage(payload, `Update failed (HTTP ${response.status})`);
+        // 409 is the server saying another run holds the slot. That is a state,
+        // not a failure of this request, so it is reported by toast alone: an
+        // error state would replace the update rows with a block the user
+        // cannot act on, and its Retry only re-checks.
+        if (response.status === 409) return { success: false, target, manual: false, message };
+        throw new Error(message);
+      }
+
+      await readSseStream(
+        response,
+        (event, data) => {
+          if (event === 'line') {
+            log = appendUpdateLog(log, JSON.parse(data) as string);
+            setProgress(log);
+            return;
+          }
+          if (event === 'stage') {
+            // A stage is its own line: the updater's heading and the output
+            // under it must not be glued into one line.
+            log = appendUpdateLog(log, `${JSON.parse(data) as string}\n`);
+            setProgress(log);
+            return;
+          }
+          if (event === 'result') {
+            const payload: unknown = JSON.parse(data);
+            if (isUpdateApplyResult(payload)) result = payload;
+          }
+        },
+        controller.signal,
+      );
+
+      if (!controller.signal.aborted) await check();
+      return result;
+    } catch (cause) {
+      if (controller.signal.aborted) return null;
+      const message = cause instanceof Error ? cause.message : 'Unable to apply the update.';
+      setError(message);
+      // Returned rather than swallowed: the caller's toast is the only surface
+      // the user sees, and a generic "could not be completed" would hide a
+      // refusal the server explained — an update already running, in the case
+      // that matters most, because a reload has just erased this panel's own
+      // record that one was.
+      return { success: false, target, manual: false, message };
+    } finally {
+      if (applyAbortRef.current === controller) {
+        applyAbortRef.current = null;
+        setApplying(null);
+      }
+    }
+  }, [check]);
+
+  useEffect(() => {
+    if (didAutoCheckRef.current) return;
+    didAutoCheckRef.current = true;
+    void check();
+  }, [check]);
+
+  useEffect(() => () => applyAbortRef.current?.abort(), []);
+
+  return {
+    info,
+    checking,
+    applying,
+    progress,
+    error,
+    hasUpdate: Boolean(info?.ompchamber.updateAvailable || info?.omp.updateAvailable),
+    check,
+    apply,
+  };
+}

package/src/server/db.server.ts

@@ -7,7 +7,9 @@
  * Database lifecycle for OMPChamber: resolve the SQLite path, open the
  * `bun:sqlite` client once, bootstrap the schema, and seed demo data in mock
  * mode. The DDL lives in `./db/schema`, the mock presets in `./db/seed` and
- * the workspace discovery sync in `./db/workspace-sync`.
+ * the workspace discovery sync in `./db/workspace-sync`. The one-time overlay
+ * rewrite is NOT here: it is a server-lifecycle concern (`compact-chat-overlay`)
+ * and runs from the server bootstrap, so opening a handle can never trigger it.
  */
 
 import path from 'path';
@@ -21,10 +23,33 @@ import { isMockMode } from '@/server/mock.server';
 import { pathExists } from '@/server/lib/omp/core/paths';
 import { migrateLegacyProjectSettings } from '@/shared/lib/workspace/project-settings-migration';
 
-let dbPromise: Promise<DbClient> | null = null;
-/** Resolved handle cached by getDb(); promise callbacks never run sync, so
- *  hot paths unwrap through `getDbSync` instead of awaiting. */
-let dbResolved: DbClient | null = null;
+/**
+ * The handle and its promise live on `globalThis`, not in module bindings.
+ *
+ * `bun run --hot` re-evaluates this module on every server-file edit while the
+ * process lives on, so a module-level cache is reset each time and the previous
+ * `Database` is dropped without ever being closed: measured on Bun 1.4.2 /
+ * macOS, each reload of this file left two more descriptors behind (`db.sqlite`
+ * and `db.sqlite-wal`), which is 2 per edit toward the 10,240-descriptor point
+ * where every `Bun.spawn` in the process starts failing with `EBADF`. The slot
+ * keeps ONE handle per process — the same reason the terminal registry, the
+ * flock host and the provider cache are anchored here.
+ */
+interface DbSlot {
+  /** In-flight open, so concurrent `getDb()` callers share one handle. */
+  promise: Promise<DbClient> | null;
+  /** Resolved handle for `getDbSync`; hot paths must not await. */
+  resolved: DbClient | null;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberDb: DbSlot | undefined;
+}
+
+function slot(): DbSlot {
+  return (globalThis.__ompChamberDb ??= { promise: null, resolved: null });
+}
 
 export async function getDatabasePath(): Promise<string> {
   if (isMockMode()) {
@@ -51,9 +76,13 @@ export async function getDatabasePath(): Promise<string> {
 }
 
 export async function getDb(): Promise<DbClient> {
-  if (dbPromise) return dbPromise;
+  const state = slot();
+  if (state.promise) return state.promise;
+  // A reload keeps the previous generation's handle: the schema was already
+  // initialized in this process, and re-opening would leak the old one.
+  if (state.resolved) return state.resolved;
 
-  dbPromise = (async () => {
+  state.promise = (async () => {
     const dbPath = await getDatabasePath();
     const db = createDb(dbPath);
 
@@ -72,11 +101,11 @@ export async function getDb(): Promise<DbClient> {
 
     await migrateLegacyProjectSettings(db);
 
-    dbResolved = db;
+    state.resolved = db;
     return db;
   })();
 
-  return dbPromise;
+  return state.promise;
 }
 
 /**
@@ -86,6 +115,7 @@ export async function getDb(): Promise<DbClient> {
  * use `getDb()`.
  */
 export function getDbSync(): DbClient {
-  if (!dbResolved) throw new Error('Database not initialized — call getDb() first');
-  return dbResolved;
+  const resolved = slot().resolved;
+  if (!resolved) throw new Error('Database not initialized — call getDb() first');
+  return resolved;
 }

package/src/server/index.ts

@@ -4,7 +4,8 @@ import shell from '@/../index.html';
 import { apiRoutes } from '@/server/routes';
 import { ssrRoutes } from '@/server/plugins/ssr';
 import { setListener } from '@/server/lib/lifecycle/listener';
-import { getDatabasePath } from '@/server/db.server';
+import { getDatabasePath, getDb } from '@/server/db.server';
+import { compactChatOverlayRows } from '@/server/lib/db/compact-chat-overlay';
 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';
@@ -106,6 +107,21 @@ await logDetectedRegistry();
 
 console.log(`[ompchamber] listening on http://${host}:${port}`);
 
+/**
+ * One-time rewrite of the overlay rows written before `overlayRowsForOmpSession`
+ * existed — see the module. Deliberately HERE, after the banner, and NOT inside
+ * `getDb()`: the test suite and the CLI reach `getDb()` in real mode too, and
+ * merely opening the database must not be able to launch a rewrite of every
+ * mirrored conversation. (It could: a `bun test` run compacted a live database.)
+ * The pass is marker-keyed, so from the second start it is one indexed SELECT,
+ * and it reports its own per-row failures rather than throwing.
+ */
+try {
+  await compactChatOverlayRows(await getDb());
+} catch (error) {
+  console.error('[chat-overlay] compaction skipped:', error);
+}
+
 /**
  * What omp reports it can actually run. A live RPC round-trip: a cold utility
  * process takes seconds, which is why it runs after the listener is up. Side

package/src/server/lib/db/client.ts

@@ -21,10 +21,27 @@ export interface DbClient {
  * reusable, and the app issues thousands of small queries per request cycle
  * (sidebar scans, telemetry probes, file listings).
  */
+/**
+ * How long a blocked write waits for another connection to release the lock.
+ *
+ * The chamber database is shared: a second chamber on another port writes the
+ * same file, the CLI writes it, and a maintenance `VACUUM` takes the exclusive
+ * lock outright. Without this, a write that meets any of them fails on the spot
+ * with `SQLITE_BUSY: database is locked` — which is exactly what a server log
+ * from 2026-09-25 is full of, with no writer at fault.
+ *
+ * Deliberately modest: `bun:sqlite` is synchronous, so this wait blocks the
+ * whole event loop — every request, stream and terminal frame with it. Two
+ * seconds clears every realistic holder (a full `VACUUM` of this database
+ * measured 134 ms) without freezing the app for long when a lock is stuck.
+ */
+const BUSY_TIMEOUT_MS = 2000;
+
 export function createDb(path: string): DbClient {
   const raw = new Database(path, { create: true });
   raw.exec('PRAGMA journal_mode = WAL');
   raw.exec('PRAGMA foreign_keys = ON');
+  raw.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
 
   const stmts = new Map<string, ReturnType<Database['query']>>();
   const prep = (sql: string) => {