ompchamber 0.3.0 → 0.5.0

package/src/client/components/workspace/file-explorer/TreeItem.tsx

@@ -5,12 +5,16 @@ import { useFetcher } from '@/client/lib/router/fetcher';
 import { FileIcon } from '@/client/components/common/file-icon';
 import { FileContextMenu, FileDeleteModal, FileHistoryModal, FileRenameModal } from '@/client/components/workspace/file-explorer/Modals';
 import { getGitStatusInfo, type FolderGitStatusInfo } from '@/shared/lib/fs/git-status';
+import { toAbsolutePath } from '@/shared/lib/fs/paths';
+import { copyToClipboard } from '@/client/hooks/ui/clipboard';
 import type { GitChange } from '@/shared/types/git';
 import { useOnClickOutside } from '@/client/hooks/ui/on-click-outside';
 
 interface FileTreeItemProps {
   file: any;
   rootPath?: string;
+  /** Absolute base dir of the listing (server-reported `root`), anchors Copy Path. */
+  basePath?: string;
   repo?: string;
   onLoadChildren?: (path: string) => Promise<void>;
   onOpenFile?: (file: any) => void;
@@ -24,6 +28,7 @@ interface FileTreeItemProps {
 export function FileTreeItem({
   file,
   rootPath,
+  basePath,
   repo,
   onLoadChildren,
   onOpenFile,
@@ -53,6 +58,9 @@ export function FileTreeItem({
   const gitStatusInfo = gitChange ? getGitStatusInfo(gitChange.status, gitChange.staged) : null;
   const folderStatus = isFolder ? (gitFolderMap?.get(normalizedPath) || gitFolderMap?.get(file.path)) : null;
   const hasGitStatus = Boolean(gitStatusInfo);
+  // Git-ignored entries (local .gitignore or the global excludes file) are still
+  // listed but rendered faded, the way an editor dims untracked noise.
+  const isIgnored = file.ignored === true;
 
   const isExpanded = expandedPaths ? expandedPaths.has(file.path) : isOpen;
   const actualIsOpen = file.forceExpanded !== undefined ? file.forceExpanded : isExpanded;
@@ -148,9 +156,9 @@ export function FileTreeItem({
       fd.append('path', file.path);
       submitAction(fd);
     } else if (actionType === 'copy_path') {
-      navigator.clipboard.writeText('/app/applet/examples/' + file.path);
+      void copyToClipboard(toAbsolutePath(basePath, file.path));
     } else if (actionType === 'copy_relative') {
-      navigator.clipboard.writeText(file.path);
+      void copyToClipboard(file.path);
     } else if (actionType === 'history') {
       setShowHistoryModal(true);
       const fd = new FormData();
@@ -194,8 +202,11 @@ export function FileTreeItem({
           <span className="w-3 flex-shrink-0"></span>
         )}
 
-        <FileIcon name={file.name} isFolder={isFolder} isOpen={actualIsOpen} size={12} className="flex-shrink-0" />
-        <span className={`truncate min-w-0 flex-1 ${gitStatusInfo ? gitStatusInfo.colorClass : folderStatus ? folderStatus.colorClass : ''}`}>
+        <FileIcon name={file.name} isFolder={isFolder} isOpen={actualIsOpen} size={12} className={`flex-shrink-0${isIgnored ? ' opacity-40' : ''}`} />
+        <span
+          className={`truncate min-w-0 flex-1 ${gitStatusInfo ? gitStatusInfo.colorClass : folderStatus ? folderStatus.colorClass : isIgnored ? 'text-ink/40' : ''}`}
+          title={isIgnored ? `${file.path} — git-ignored` : undefined}
+        >
           {file.name}
         </span>
 
@@ -230,6 +241,7 @@ export function FileTreeItem({
               key={child.id}
               file={child}
               rootPath={rootPath}
+              basePath={basePath}
               repo={repo}
               onLoadChildren={onLoadChildren}
               onOpenFile={onOpenFile}

package/src/client/components/workspace/file-explorer/index.tsx

@@ -10,6 +10,10 @@ import { usePanelRefresh, useFileMutationRefresh } from '@/client/hooks/workspac
 
 export function FileExplorer({ className = '', enabled = true, rootPath, onOpenFile, refreshKey = 0, onRefresh }: { className?: string, enabled?: boolean, rootPath?: string, onOpenFile?: (file: any) => void, refreshKey?: number, onRefresh?: () => void }) {
   const [tree, setTree] = useState<any[]>([]);
+  // Absolute base dir reported by `/api/fs/dir` for the current listing — the
+  // workspace root, or the selected nested repo. Copy Path anchors on it
+  // because the client's `rootPath` may be rejected/unset.
+  const [listingRoot, setListingRoot] = useState('');
   const [searchQuery, setSearchQuery] = useSessionState<string>('files.searchQuery', '');
   const [isLoading, setIsLoading] = useState(false);
   const [storedExpandedPaths, setStoredExpandedPaths, expandedPathsReady] = useSessionState<string[]>('files.expandedPaths', []);
@@ -43,6 +47,7 @@ export function FileExplorer({ className = '', enabled = true, rootPath, onOpenF
     fetch(listUrl())
       .then(r => r.json())
       .then(data => {
+        if (typeof data.root === 'string') setListingRoot(data.root);
         if (Array.isArray(data.files)) {
           setTree(rehydrateTree(data.files, childrenCacheRef.current, expandedPaths));
         }
@@ -176,6 +181,7 @@ export function FileExplorer({ className = '', enabled = true, rootPath, onOpenF
               key={file.id}
               file={file}
               rootPath={rootPath}
+              basePath={listingRoot}
               repo={activeRepo}
               onLoadChildren={loadChildren}
               onOpenFile={onOpenFile}

package/src/client/data/models/catalog.ts

@@ -1,5 +1,13 @@
 import type { AIModelOption } from '@/shared/types';
 
+/**
+ * MOCK-only demo catalog: the model rows a `MOCK=true` chamber shows before the
+ * operator adds any of their own.
+ *
+ * Real mode never reads this — `/api/models` there is fed by the live omp model
+ * registry, and its mutations start from an empty list — so a demo model can
+ * never leak into a real installation (see `routes/models/root.ts`).
+ */
 export const INITIAL_MODELS_CATALOG: AIModelOption[] = [
   // FAVORITES (As seen in image.png)
   {

package/src/client/data/samples/dialogue-session.ts

@@ -277,7 +277,7 @@ export function getSampleDialogueSession(): {
         id: '65e71033',
         role: 'ai',
         content:
-          'Repo summary from `RepoSummarizer`:\n\n**OMPChamber** — developer web-view console and diagnostic chamber for AI **Oh-My-Pi** autonomous agent.\n\n**Stack:** Remix v2 + React 19 + Vite, Tailwind CSS v4, TypeScript (strict, ES2022). Runs under npm or Bun.\n\n**Structure:**\n- `app/routes/` — Remix flat-routes, large REST-style `api/` domain tree\n- `app/components/` — common, layout, workspace, mobile, settings\n- `app/hooks/` — chat, terminal, git-tree, agent streaming\n- `app/lib/omp/` — bridges to oh-my-pi runtime (RPC managers, session readers)\n- `app/types/`, `app/data/` (mock presets)\n\n**Config:** `MOCK` mode toggles seeded demo data vs real data. SQLite persistence (`app/db.server.ts`).\n\n**Deployment-relevant:** PWA support, `@google/genai` assistant, xterm/KaTeX/Shiki rendering.',
+          'Repo summary from `RepoSummarizer`:\n\n**OMPChamber** — developer web-view console and diagnostic chamber for AI **Oh-My-Pi** autonomous agent.\n\n**Stack:** Remix v2 + React 19 + Vite, Tailwind CSS v4, TypeScript (strict, ES2022). Runs under npm or Bun.\n\n**Structure:**\n- `app/routes/` — Remix flat-routes, large REST-style `api/` domain tree\n- `app/components/` — common, layout, workspace, mobile, settings\n- `app/hooks/` — chat, terminal, git-tree, agent streaming\n- `app/lib/omp/` — bridges to oh-my-pi runtime (RPC managers, session readers)\n- `app/types/`, `app/data/` (mock presets)\n\n**Config:** `MOCK` mode toggles seeded demo data vs real data. SQLite persistence (`app/db.server.ts`).\n\n**Deployment-relevant:** PWA support, xterm/KaTeX/Shiki rendering.',
         date: 'Sep 9, 04:44 AM',
       },
     ],

package/src/client/data/samples/sample-tools/other.ts

@@ -88,7 +88,7 @@ export const otherTools: ToolCallData[] = [
     target: 'app/mock.server.ts',
     output: `1: export function isMockMode(): boolean {
 2:   const envVal = (Bun.env.MOCK || "").trim().toLowerCase();
-3:   return envVal !== "false" && envVal !== "0";
+3:   return envVal === "true" || envVal === "1" || envVal === "on" || envVal === "yes";
 4: }`,
     status: 'success',
     duration: '14ms',

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

@@ -3,6 +3,7 @@ import type { ChatMessageData, OmpAgentCallbacks, OmpAgentHandle, OmpAgentState,
 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 { stopAgentSession } from '@/shared/lib/chat/omp/abort';
 
 /**
  * Live omp agent bridge for the chamber chat (real mode, MOCK=false). Mirrors
@@ -72,12 +73,14 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
       .then(res => (res.ok ? res.json() : null))
       .then((data: {
         running?: boolean;
+        /** Set when the server answered from local flags, not a get_state RPC. */
+        busy?: boolean;
         state?: { isStreaming?: boolean; isPromptRunning?: boolean };
         pendingUiRequests?: ExtensionUiDialogRequest[];
       } | null) => {
         if (cancelled || !data?.running) return;
         const probe = data.state;
-        if (probe && (probe.isStreaming || probe.isPromptRunning)) {
+        if (data.busy || probe?.isStreaming || probe?.isPromptRunning) {
           connect(sessionId);
           callbacksRef.current.onResumeStream?.();
         }
@@ -132,6 +135,8 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
       });
       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;
       }
@@ -209,15 +214,9 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
     // A user stop supersedes an in-flight interrupt-and-reply: clearing the
     // guard lets the aborted turn's agent_end reach onAgentEnd (no stuck spinner).
     interruptPendingRef.current = false;
-    try {
-      await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'abort' }),
-      });
-    } catch {
-      // Abort is best-effort; the event stream surfaces the terminal state.
-    }
+    // Self-escalating: a child that does not stop within the helper's grace
+    // period is reset instead, so a wedged session cannot hang the button.
+    await stopAgentSession(sid);
     setState((prev) => ({ ...prev, isGenerating: false }));
   }, []);
 

package/src/client/hooks/chat/omp/revalidation-throttle.ts

@@ -7,11 +7,12 @@
  * Throttled revalidation for the session sidebars.
  *
  * `omp:session-updated` arrives in bursts while a run is active (agent start,
- * JSONL write, spawn adoption, agent end) — and the chat timeline's metadata
- * retry loop can emit one every 250ms until the session file carries the user
- * turn. Each dispatch would otherwise trigger a full loader revalidation, and
- * with two sidebars mounted (desktop + mobile layouts keep theirs alive) a busy
- * run could revalidate several times per second.
+ * first completed assistant turn, JSONL write, spawn adoption, agent end) — and
+ * the chat timeline's metadata retry loop can emit one every 250ms until the
+ * session file carries the user turn. Each dispatch would otherwise trigger a
+ * full loader revalidation, and with two sidebars mounted (desktop + mobile
+ * layouts keep theirs alive) a busy run could revalidate several times per
+ * second.
  *
  * Implemented as a LEADING + TRAILING throttle, not a trailing debounce:
  *

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

@@ -16,7 +16,6 @@ import type { Dispatch, SetStateAction } from 'preact/compat';
 import type { Attachment, ChatMessageData, OmpAgentHandle, QueuedMessageModel } from '@/shared/types';
 import type { QueuedMessage } from '@/client/components/workspace/chat-timeline/QueueList';
 import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
-import { normalizeNoticePositions } from '@/shared/lib/chat/order';
 
 export interface ChatTimelineActionsDeps {
   inputValue: string;
@@ -211,7 +210,7 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
       if (!res.ok) return false;
       const next = await fetch(`/api/chat/${encodeURIComponent(sessionId)}`).then(r => r.json()).catch(() => null);
       const messages: ChatMessageData[] = next?.session?.messages ?? [];
-      if (messages.length > 0) setLocalMessages(normalizeNoticePositions(messages));
+      if (messages.length > 0) setLocalMessages(messages);
       return true;
     }
 

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

@@ -99,6 +99,10 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
   // responding (agent_start = first chunk) — the omp JSONL now carries the
   // user turn, so the sidebar item + real title appear immediately.
   const metaRefreshedRef = useRef<string | null>(null);
+  // Per-run guard for the "first assistant answer landed" sidebar signal
+  // (omp-callbacks onMessageEnd): the sidebar refreshes once per run on the
+  // completed first assistant turn, not on every assistant segment.
+  const firstAssistantRef = useRef(false);
   // Optimistic user bubble awaiting omp's echo (reconciled by the callbacks).
   const optimisticUserIdRef = useRef<string | null>(null);
   // Raw composer text for steer/follow-up echoes (those paths have no bubble).
@@ -193,6 +197,7 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     adoptedSessionIdRef,
     sessionIdRef,
     metaRefreshedRef,
+    firstAssistantRef,
     refreshSessionMeta,
     setLocalMessages,
     aiPlaceholderIdRef,

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

@@ -18,7 +18,6 @@ import { streamChatResponse } from '@/client/hooks/chat/stream';
 import { composeMessageWithTextAttachments, isTextAttachmentFile } from '@/shared/lib/chat/attachments';
 import { loadAgentNames } from '@/shared/lib/chat/composer/client';
 import { translateAgentMentions, translateFileMentions } from '@/shared/lib/chat/composer/translate';
-import { normalizeNoticePositions } from '@/shared/lib/chat/order';
 import { createMockStreamCallbacks } from '@/shared/lib/chat/timeline/stream-callbacks';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
 import { formatClock } from '@/shared/lib/format/time';
@@ -213,7 +212,7 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
     };
 
     setLocalMessages(prev => {
-      const next = normalizeNoticePositions([...prev, newUserMsg, initialAiMsg]);
+      const next = [...prev, newUserMsg, initialAiMsg];
       persistMessages(next.filter(m => m.id !== aiPlaceholderId));
       return next;
     });
@@ -312,7 +311,7 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
       }
     }
 
-    // Mock / chamber-created session: existing Gemini/simulated SSE path.
+    // Mock / chamber-created session: existing simulated SSE path.
     // Cancel any previous stream
     optimisticUserIdRef.current = null;
     if (abortControllerRef.current) {

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/index.ts

@@ -1,6 +1,26 @@
 import { Elysia } from 'elysia';
 import { apiRoutes } from '@/server/routes';
 import { ssrRoutes } from '@/server/plugins/ssr';
+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 { isMockMode } from '@/server/mock.server';
+
+// Refuse to run without a resolvable omp binary — before the listener opens and
+// before the first request can reach a route that shells out to it. The database
+// is opened lazily by getDb(), so this exits without touching it.
+const startupError = ompStartupError();
+if (startupError) {
+  console.error(startupError);
+  process.exit(1);
+}
+
+// Which omp the chamber drives, which ~/.omp tree it reads and which SQLite file
+// it writes — the paths every session/agent diagnostic traces back to. The data
+// mode comes first because it changes what every later line means.
+console.log(`[ompchamber] mock mode:      ${isMockMode() ? 'true (demo presets)' : 'false (real omp data)'}`);
+for (const line of ompStartupLogLines()) console.log(`[ompchamber] ${line}`);
+console.log(`[ompchamber] db:             ${await getDatabasePath()}`);
 
 const port = Number(Bun.env.PORT) || 3000;
 const host = Bun.env.HOST || 'localhost';
@@ -9,8 +29,41 @@ const app = new Elysia().use(apiRoutes).use(ssrRoutes);
 
 await app.listen({ port, hostname: host });
 
+// The listener is already accepting requests here, so the probe only postpones
+// this last banner line, never startup. Printing it after the probe keeps the
+// one line that matters — the URL — at the bottom of the log.
+await logDetectedRegistry();
+
 console.log(`[ompchamber] listening on http://${host}:${port}`);
 
+/**
+ * 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
+ * benefit — it warms the shared utility process the model picker drives, so the
+ * first /api/models call does not pay the spawn.
+ */
+async function logDetectedRegistry(): Promise<void> {
+  if (isMockMode()) {
+    console.log('[ompchamber] providers:      n/a (MOCK mode)');
+    console.log('[ompchamber] models:         n/a (MOCK mode)');
+    return;
+  }
+  try {
+    const { providers, models } = await fetchOmpRegistrySnapshot();
+    // Count providers that actually serve a model — the distinct `provider`
+    // values in the model list, i.e. the same set GET /api/models groups by.
+    // omp's login catalog lists every sign-in offer it supports (75 here, 73 of
+    // them without credentials); counting those would report a provider set the
+    // chamber cannot use. The catalog size is kept as context.
+    const servingProviders = new Set(models.map((model) => model.provider)).size;
+    console.log(`[ompchamber] providers:      ${servingProviders} detected (${providers.length} known to omp)`);
+    console.log(`[ompchamber] models:         ${models.length} detected`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`[ompchamber] providers/models: detection failed — ${message}`);
+  }
+}
+
 for (const signal of ['SIGTERM', 'SIGINT'] as const) {
   process.once(signal, () => {
     void app.stop();

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/models/provider-registry.server.ts

@@ -23,12 +23,54 @@ export const PROVIDERS_SETTINGS_KEY = 'omp_providers_config';
 
 const RPC_CACHE_TTL_MS = 60_000;
 
-interface LoginProvider {
+/** Minimal shape of a get_login_providers entry, as the chamber reads it. */
+export interface DetectedLoginProvider {
   id: string;
   name: string;
   authenticated: boolean;
 }
 
+function isDetectedLoginProvider(provider: unknown): provider is DetectedLoginProvider {
+  return (
+    typeof provider === 'object' && provider !== null
+    && typeof (provider as { id?: unknown }).id === 'string'
+    && typeof (provider as { name?: unknown }).name === 'string'
+    && typeof (provider as { authenticated?: unknown }).authenticated === 'boolean'
+  );
+}
+
+function isOmpModel(model: unknown): model is OmpModel {
+  return (
+    typeof model === 'object' && model !== null
+    && typeof (model as OmpModel).id === 'string'
+    && typeof (model as OmpModel).provider === 'string'
+  );
+}
+
+export interface OmpRegistrySnapshot {
+  /** Login providers omp reports (authenticated or not). */
+  providers: DetectedLoginProvider[];
+  /** Every model omp currently serves. */
+  models: OmpModel[];
+}
+
+/**
+ * Raw omp registry probe — the two commands that define "detected" for the
+ * chamber: the login providers omp knows and the models they serve. Parsed here
+ * once so the provider settings page and the startup banner count the same set.
+ * Throws when the utility RPC is unreachable; each caller degrades its own way.
+ */
+export async function fetchOmpRegistrySnapshot(): Promise<OmpRegistrySnapshot> {
+  const [loginResponse, modelsResponse] = await Promise.all([
+    runUtilityCommand<{ providers?: unknown }>({ type: 'get_login_providers' }, 30_000),
+    runUtilityCommand<{ models?: unknown }>({ type: 'get_available_models' }, 60_000),
+  ]);
+  return {
+    providers: Array.isArray(loginResponse.providers) ? loginResponse.providers.filter(isDetectedLoginProvider) : [],
+    models: Array.isArray(modelsResponse.models) ? modelsResponse.models.filter(isOmpModel) : [],
+  };
+}
+
 /**
  * Provider registry straight from the omp agent: authenticated login providers
  * (omp auth) plus their registered models (get_available_models). This is the
@@ -38,25 +80,7 @@ async function loadRpcProviderItems(): Promise<ProviderItem[]> {
   const cached = globalThis.__ompChamberProvidersRpcCache;
   if (cached && cached.expiresAt > Date.now()) return cached.data;
   try {
-    const [loginResponse, modelsResponse] = await Promise.all([
-      runUtilityCommand<{ providers?: unknown }>({ type: 'get_login_providers' }, 30_000),
-      runUtilityCommand<{ models?: unknown }>({ type: 'get_available_models' }, 60_000),
-    ]);
-    const loginProviders = Array.isArray(loginResponse.providers)
-      ? loginResponse.providers.filter((provider): provider is LoginProvider => (
-          typeof provider === 'object' && provider !== null
-          && typeof (provider as { id?: unknown }).id === 'string'
-          && typeof (provider as { name?: unknown }).name === 'string'
-          && typeof (provider as { authenticated?: unknown }).authenticated === 'boolean'
-        ))
-      : [];
-    const available = Array.isArray(modelsResponse.models)
-      ? modelsResponse.models.filter((model): model is OmpModel => (
-          typeof model === 'object' && model !== null
-          && typeof (model as OmpModel).id === 'string'
-          && typeof (model as OmpModel).provider === 'string'
-        ))
-      : [];
+    const { providers: loginProviders, models: available } = await fetchOmpRegistrySnapshot();
     const disabled = await readDisabledProviders().catch(() => new Set<string>());
 
     const items = loginProviders.map((provider) => {

package/src/server/lib/omp/core/cli.ts

@@ -20,6 +20,7 @@ let cachedBin: string | null = null;
 let binMissAt = 0;
 
 const BIN_NAME = process.platform === 'win32' ? 'omp.exe' : 'omp';
+
 // Only successes are cached for the process lifetime. omp may be installed (or
 // PATH repaired) while the server runs; a permanently cached "not found" would
 // keep the UI reporting a missing binary until restart.
@@ -32,7 +33,7 @@ export function invalidateOmpCliCache(): void {
 }
 
 function probeOmpBin(): string | null {
-  const override = Bun.env.OMP_WEB_OMP_BIN;
+  const override = Bun.env.OMPCHAMBER_OMP_BIN;
   if (override) return existsSync(override) ? override : null;
 
   const onPath = Bun.which(BIN_NAME);
@@ -49,7 +50,7 @@ function probeOmpBin(): string | null {
   return Bun.which(BIN_NAME, { PATH: fallbackPath });
 }
 
-/** Resolve the omp binary: OMP_WEB_OMP_BIN override, then PATH lookup. Returns
+/** Resolve the omp binary: OMPCHAMBER_OMP_BIN override, then PATH lookup. Returns
  * null when omp is not installed. A hit is cached for the process lifetime; a
  * miss is re-probed after MISS_TTL_MS. */
 export function resolveOmpBin(): string | null {