ompchamber 1.0.0 → 1.2.0

package/src/server/lib/models/registry.server.ts

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Assembly of the chat model registry that `GET /api/models` serves: the omp
+ * registry (auth providers + models.yml) narrowed by the provider/model hides
+ * the operator set, plus the live session's default model.
+ *
+ * Extracted from `routes/models/root.ts` so the route keeps only its loader and
+ * action, and so the preference store can share the same model list.
+ */
+
+import { getDb } from '@/server/db.server';
+import { PROVIDERS_SETTINGS_KEY } from '@/server/lib/models/provider-registry.server';
+import { readSettingsJson } from '@/server/lib/db/settings-store';
+import { readDisabledProviders } from '@/server/lib/omp/config/roles';
+import { runUtilityCommand, type OmpModel } from '@/server/lib/omp/rpc/utility';
+import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+import type { ModelsData, ProviderItem } from '@/shared/types';
+
+const MODELS_CACHE_TTL_MS = 60_000;
+export const SAFE_MODEL_LOAD_FAILURE_MESSAGE = 'Model list is temporarily unavailable. Check your configuration and try again.';
+
+const modelNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+
+function compareModelEntries(a: { id: string; name: string; provider: string }, b: { id: string; name: string; provider: string }): number {
+  return modelNameCollator.compare(a.name || a.id, b.name || b.id)
+    || modelNameCollator.compare(a.provider, b.provider)
+    || modelNameCollator.compare(a.id, b.id);
+}
+
+// "off" is always a valid selector; the concrete efforts come from the model's
+// baked thinking metadata (omp: getSupportedEfforts = reasoning ? efforts : []).
+function thinkingLevelsFor(model: OmpModel): string[] {
+  if (!model.reasoning) return ['off'];
+  return ['off', ...(model.thinking?.efforts ?? [])];
+}
+
+function supportsFastMode(model: OmpModel): boolean {
+  return model.provider === 'anthropic' || model.provider === 'openai' || model.provider === 'google';
+}
+
+/**
+ * Disabled providers recorded in the chamber's own provider overlay. Used only
+ * by the MOCK path of `/api/models`, which has no config.yml `disabledProviders`
+ * to read — real mode gets the same answer natively.
+ */
+function isDisabledStoredProvider(value: unknown): value is ProviderItem {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as ProviderItem;
+  return typeof candidate.slug === 'string' && candidate.disabled === true;
+}
+
+export async function readStoredProvidersForModels(): Promise<ProviderItem[]> {
+  try {
+    const db = await getDb();
+    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_SETTINGS_KEY, null);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isDisabledStoredProvider);
+  } catch {
+    return [];
+  }
+}
+
+function hiddenModelKey(provider: string, modelId: string): string {
+  return `${provider.trim().toLowerCase()}:${modelId}`;
+}
+
+async function readHiddenModelKeys(): Promise<Set<string>> {
+  try {
+    const db = await getDb();
+    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_SETTINGS_KEY, null);
+    if (!Array.isArray(parsed)) return new Set();
+    const hidden = new Set<string>();
+    for (const provider of parsed) {
+      if (typeof provider !== 'object' || provider === null) continue;
+      const { slug, models } = provider as { slug?: unknown; models?: unknown };
+      if (typeof slug !== 'string' || !Array.isArray(models)) continue;
+      for (const model of models) {
+        if (typeof model !== 'object' || model === null) continue;
+        const { id, isVisible } = model as { id?: unknown; isVisible?: unknown };
+        if (typeof id === 'string' && isVisible === false) hidden.add(hiddenModelKey(slug, id));
+      }
+    }
+    return hidden;
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * A model is offered only when its provider is neither disabled in omp's
+ * config.yml (`disabledProviders`) nor carrying a per-model hide in the
+ * chamber overlay. Disabling the provider is the coarse switch — Settings →
+ * Providers flips it so the whole provider leaves the chat picker.
+ */
+function filterSelectableModels(
+  available: OmpModel[],
+  disabledProviders: Set<string>,
+  hiddenModelKeys: Set<string>,
+): OmpModel[] {
+  return available.filter((model) => (
+    !disabledProviders.has(model.provider)
+    && !hiddenModelKeys.has(hiddenModelKey(model.provider, model.id))
+  ));
+}
+
+function isOmpModelEntry(value: unknown): value is OmpModel {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as OmpModel;
+  return typeof candidate.id === 'string' && typeof candidate.provider === 'string';
+}
+
+function isLoginProvider(value: unknown): value is { id: string; name: string; authenticated: boolean } {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as { id?: unknown; name?: unknown; authenticated?: unknown };
+  return typeof candidate.id === 'string'
+    && typeof candidate.name === 'string'
+    && typeof candidate.authenticated === 'boolean';
+}
+
+async function loadModels(): Promise<ModelsData> {
+  const availableResponse = await runUtilityCommand<{ models?: unknown }>(
+    { type: 'get_available_models' },
+    120_000,
+  );
+  const available = Array.isArray(availableResponse.models)
+    ? availableResponse.models
+        .filter(isOmpModelEntry)
+        .map((model) => ({
+          ...model,
+          name: typeof model.name === 'string' && model.name.trim().length > 0 ? model.name : model.id,
+        }))
+    : [];
+
+  const disabledProviders = await readDisabledProviders();
+  const hiddenModelKeys = await readHiddenModelKeys();
+  const nameMap: Record<string, string> = {};
+  const thinkingLevels: Record<string, string[]> = {};
+  const modelList = filterSelectableModels(available, disabledProviders, hiddenModelKeys)
+    .map((m) => ({
+      id: m.id,
+      name: m.name,
+      provider: m.provider,
+      thinkingLevels: thinkingLevelsFor(m),
+      supportsFastMode: supportsFastMode(m),
+      contextWindow: m.contextWindow ?? undefined,
+      maxTokens: m.maxTokens ?? undefined,
+      cost: m.cost,
+    }))
+    .sort(compareModelEntries);
+
+  const loginResponse = await runUtilityCommand<{ providers?: unknown }>(
+    { type: 'get_login_providers' },
+    30_000,
+  );
+  const loginProviders = Array.isArray(loginResponse.providers)
+    ? loginResponse.providers.filter(isLoginProvider)
+    : [];
+  const connectedProviders = loginProviders
+    .filter((provider) => provider.authenticated)
+    .map((provider) => ({ id: provider.id, name: provider.name, disabled: disabledProviders.has(provider.id) }));
+  for (const m of available) {
+    const key = `${m.provider}:${m.id}`;
+    nameMap[key] = m.name;
+    thinkingLevels[key] = thinkingLevelsFor(m);
+  }
+
+  let defaultModel: { provider: string; modelId: string } | null = null;
+  try {
+    const state = await runUtilityCommand<{ model?: { provider?: string; id?: string } }>(
+      { type: 'get_state' },
+      30_000,
+    );
+    const provider = state.model?.provider;
+    const modelId = state.model?.id;
+    if (provider && modelId && available.some((m) => m.provider === provider && m.id === modelId)) {
+      defaultModel = { provider, modelId };
+    }
+  } catch {
+    // Default model is cosmetic — the models list is still useful without it.
+  }
+
+  return { models: nameMap, modelList, defaultModel, thinkingLevels, connectedProviders };
+}
+
+export const EMPTY_MODELS: ModelsData = {
+  models: {},
+  modelList: [],
+  defaultModel: null,
+  thinkingLevels: {},
+};
+
+export async function loadModelsWithCache(): Promise<ModelsData> {
+  const cached = globalThis.__ompChamberModelsCache;
+  if (cached && cached.expiresAt > Date.now()) return cached.data;
+  const data = await loadModels();
+  globalThis.__ompChamberModelsCache = { data, expiresAt: Date.now() + MODELS_CACHE_TTL_MS };
+  return data;
+}
+
+export function invalidateModelsCache(): void {
+  invalidateModelsCaches();
+}

package/src/server/lib/omp/rpc/frame-fold.ts

@@ -0,0 +1,207 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Folds one omp RPC frame into the session wrapper's runtime state, and runs
+ * the settle-time side effects a terminal run triggers.
+ *
+ * Mirrors the client's `foldAgentEvent` (shared/lib/chat/omp/agent-events.ts):
+ * the same shape of problem — one frame, many state flags — solved the same way
+ * so both ends of the transport read alike. Split out of rpc-manager.ts so the
+ * wrapper owns only process lifecycle.
+ *
+ * The state machine is the load-bearing part. `turn_end` fires for EVERY turn
+ * in a multi-turn run, `agent_end` is the only frame that knows whether the run
+ * is terminal, and a `prompt` response that failed must clear the same flags a
+ * successful settle does — a missed clear strands the session as "running" and
+ * the idle reclaim can never take it back.
+ */
+
+import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
+import {
+  consumeAutoTitleOutput,
+  triggerAutoSessionTitle,
+  type AutoTitleHost,
+} from '@/server/lib/omp/session/auto-title.server';
+import { scheduleQueueDelivery, type QueueDeliveryHost } from '@/server/lib/queue/delivery.server';
+import { loadStreamStatuses, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
+import { NON_TERMINAL_CONTINUATION_GRACE_MS, type AgentEvent } from '@/server/lib/omp/rpc/constants';
+
+/**
+ * Wrapper surface the fold reads and writes. Every field is owned by the
+ * wrapper; the fold mutates them in place exactly as the inline switch did.
+ * Composes the two host contracts the settle path hands the wrapper to
+ * (auto-title, queue delivery) so the wrapper itself satisfies this whole type.
+ */
+export interface SessionFrameHost extends AutoTitleHost, QueueDeliveryHost {
+  promptRunning: boolean;
+  streaming: boolean;
+  compacting: boolean;
+  awaitingAgentStart: boolean;
+  awaitingAgentStartDeadline: number;
+  continuationGraceUntil: number;
+  emit(event: AgentEvent): void;
+  /** Remember a blocking ask/approval dialog so a reattaching client can answer it. */
+  trackUiDialog(frame: AgentEvent): void;
+  /** Fold a subagent frame into the liveness roster. */
+  observeSubagent(frame: AgentEvent, now: number): void;
+}
+
+/** What the caller must do after the fold. */
+export interface FrameFoldResult {
+  /** The session list is stale and needs a rebuild. */
+  refreshSessionList: boolean;
+  /** The fold already handled this frame's user-visible effect and the caller
+   *  must NOT forward it: a failed `prompt` response has emitted its own
+   *  `prompt_error`, and a `command_output` belonging to the chamber's own
+   *  background rename must stay out of the timeline. */
+  suppressForward: boolean;
+}
+
+/** True when the ending turn was a user abort rather than a natural stop. */
+function endedAborted(messages: unknown): boolean {
+  return (
+    Array.isArray(messages) &&
+    messages.some((entry) => {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
+      return (entry as Record<string, unknown>).stopReason === 'aborted';
+    })
+  );
+}
+
+/**
+ * Write the terminal stream badge from the ending turn's own stopReason.
+ *
+ * The `abort` command already wrote `abort` at dispatch time, but the
+ * `agent_end` frame arrives later and previously flattened it to `finish`.
+ * Re-check the current row and only upgrade `stream` rows, so a `finish`
+ * written here can never clobber a newer run's live `stream`/`abort`.
+ */
+async function markEndStatus(sessionId: string, messages: unknown): Promise<void> {
+  if (!sessionId) return;
+  const current = await loadStreamStatuses();
+  if (current[sessionId] !== 'stream') return;
+  await markStreamStatus(sessionId, endedAborted(messages) ? 'abort' : 'finish');
+}
+
+/** Apply one frame to the wrapper's runtime state. */
+export function foldSessionFrame(host: SessionFrameHost, event: AgentEvent): FrameFoldResult {
+  const result: FrameFoldResult = { refreshSessionList: false, suppressForward: false };
+
+  switch (event.type) {
+    case 'agent_start':
+      host.promptRunning = true;
+      host.streaming = true;
+      host.awaitingAgentStart = false;
+      host.awaitingAgentStartDeadline = 0;
+      host.continuationGraceUntil = 0;
+      clearSessionFileCaches();
+      result.refreshSessionList = true;
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
+      break;
+    case 'turn_start':
+      // Redundant with agent_start in the happy path, but the run-level
+      // counterpart can be missed (e.g. the state was cleared by a command
+      // between frames). The turn is proof enough the session is live.
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
+      break;
+    case 'message_start':
+      // Same recovery as turn_start: a message frame is only emitted inside a
+      // live run, so its arrival re-arms the `stream` row no matter what stale
+      // status sits there (upsert overwrites any terminal badge).
+      if (host.sessionId) void markStreamStatus(host.sessionId, 'stream');
+      break;
+    case 'turn_end': {
+      // A multi-turn run emits turn_end for EVERY turn — intermediates end with
+      // `toolUse`/`stop` while the run keeps going (verified against omp
+      // 18.2.8: agent_start → turn_start → turn_end('toolUse') → turn_start →
+      // turn_end('stop') → agent_end, and the frame carries no isTerminal
+      // field). Only `aborted` is unambiguous here: the run is over, so the
+      // abort badge can be written before agent_end arrives. Everything else
+      // waits for agent_end, which knows isTerminal.
+      if (!host.sessionId) break;
+      const turn = event.message as Record<string, unknown> | undefined;
+      if (turn?.stopReason === 'aborted') void markStreamStatus(host.sessionId, 'abort');
+      break;
+    }
+    case 'agent_end':
+      if (event.isTerminal !== false) {
+        host.streaming = false;
+        host.promptRunning = false;
+        host.awaitingAgentStart = false;
+        host.awaitingAgentStartDeadline = 0;
+        host.continuationGraceUntil = 0;
+        clearSessionFileCaches();
+        const aborted = endedAborted(event.messages);
+        if (host.sessionId) void markEndStatus(host.sessionId, event.messages);
+        // A settled run is the moment a session becomes nameable: omp's own
+        // first-message titling is suppressed under `--mode rpc-ui`
+        // (PI_NO_TITLE), so the chamber asks for the same title itself. The
+        // trigger is a no-op once the session carries a name — see
+        // triggerAutoSessionTitle for why that check is the safety property.
+        if (!aborted) void triggerAutoSessionTitle(host);
+        // The run truly ended — the server, not the browser, decides whether a
+        // queued follow-up goes out next. A user-aborted run holds the queue
+        // (stop-all semantics): the next run end or an explicit send picks it up.
+        if (!aborted) scheduleQueueDelivery(host);
+      } else {
+        host.continuationGraceUntil = Date.now() + NON_TERMINAL_CONTINUATION_GRACE_MS;
+      }
+      break;
+    case 'prompt_result':
+      host.promptRunning = false;
+      host.awaitingAgentStart = false;
+      host.awaitingAgentStartDeadline = 0;
+      break;
+    case 'auto_compaction_start':
+      host.compacting = true;
+      break;
+    case 'auto_compaction_end':
+      host.compacting = false;
+      clearSessionFileCaches();
+      break;
+    case 'command_output':
+      // A `command_output` for a command the OPERATOR typed renders as a notice
+      // row. But the chamber fires its own `/rename` after a settled run, and
+      // omp answers it on the same frame — "Session renamed to …", or "Could not
+      // generate a session title" for a low-signal first message. Neither was
+      // asked for, and the second would be pure noise. The frame carries no
+      // correlation id, so attribution is by the request window.
+      result.suppressForward = consumeAutoTitleOutput(host);
+      break;
+    case 'session_info_update':
+      // A rename rewrote the fixed-width title slot in place; the scan cache is
+      // keyed on file mtime, which that write cannot move, so the list must be
+      // rebuilt explicitly.
+      clearSessionFileCaches();
+      result.refreshSessionList = true;
+      break;
+    case 'extension_ui_request':
+      host.trackUiDialog(event);
+      break;
+    // Subagent frames carry no turn state, but they are the only proof that
+    // work is still running once the parent turn has ended.
+    case 'subagent_lifecycle':
+    case 'subagent_progress':
+    case 'subagent_event':
+      host.observeSubagent(event, Date.now());
+      break;
+    case 'response': {
+      if (event.success === false && event.command === 'prompt') {
+        host.promptRunning = false;
+        host.awaitingAgentStart = false;
+        host.awaitingAgentStartDeadline = 0;
+        host.emit({ type: 'prompt_error', errorMessage: (event.error as string) ?? 'Prompt failed' });
+        // The caller's trailing notify covers this: promptRunning just flipped,
+        // so the running snapshot changes and the listeners fire. Suppress only
+        // the forward, or the error would land twice.
+        result.suppressForward = true;
+      }
+      break;
+    }
+  }
+
+  return result;
+}

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

@@ -17,13 +17,12 @@
 
 import { RpcProcess, type RpcFrame } from '@/server/lib/omp/rpc/process';
 import { PendingUiDialogs } from '@/server/lib/omp/rpc/pending-ui-dialogs';
-import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
+import { foldSessionFrame } from '@/server/lib/omp/rpc/frame-fold';
 import { notifyRunningChange } from '@/server/lib/omp/rpc/session-registry';
 import { dispatchSessionCommand } from '@/server/lib/omp/rpc/session-commands';
-import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
 import { SubagentLiveness } from '@/server/lib/omp/rpc/subagent-liveness';
-import { loadStreamStatuses, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
-import { GET_STATE_TIMEOUT_MS, IDLE_DESTROY_MS, NON_TERMINAL_CONTINUATION_GRACE_MS, READY_TIMEOUT_MS, SUBAGENT_STALE_MS, type AgentEvent, type EventListener, type RpcSessionState } from '@/server/lib/omp/rpc/constants';
+import { markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
+import { GET_STATE_TIMEOUT_MS, IDLE_DESTROY_MS, READY_TIMEOUT_MS, SUBAGENT_STALE_MS, type AgentEvent, type EventListener, type RpcSessionState } from '@/server/lib/omp/rpc/constants';
 
 export type {
   AgentEvent,
@@ -68,6 +67,13 @@ export class AgentSessionWrapper {
   // set in initialize(). No other flag on this wrapper can see them, and an
   // idle reclaim or a spawn-mode reconcile must never kill a running subagent.
   private readonly subagents = new SubagentLiveness();
+  // One background `/rename` at a time. A settled run may be followed by
+  // another (queue delivery, a second prompt), and two overlapping generations
+  // would race to write the same title slot.
+  autoTitleInFlight = false;
+  // Epoch ms until which `command_output` frames belong to our own background
+  // rename and must not reach the timeline. 0 when nothing is outstanding.
+  autoTitleWindowUntil = 0;
   readonly idleDestroyMs: number;
   proc: RpcProcess;
   readonly cwd: string;
@@ -173,130 +179,28 @@ export class AgentSessionWrapper {
     this.destroy();
   }
 
-  /** Write the terminal stream badge from the ending turn's own stopReason.
-   *  The `abort` command already wrote `abort` at dispatch time, but the
-   *  agent_end frame arrives later and previously flattened it to `finish`.
-   *  Re-check the current row and only upgrade `stream` rows, so a `finish`
-   *  written here can never clobber a newer run's live `stream`/`abort`. */
-  private async markEndStatus(messages: unknown): Promise<void> {
-    if (!this.sessionId) return;
-    const aborted = Array.isArray(messages) && messages.some((entry) => {
-      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
-      return (entry as Record<string, unknown>).stopReason === 'aborted';
-    });
-    const current = await loadStreamStatuses();
-    if (current[this.sessionId] !== 'stream') return;
-    await markStreamStatus(this.sessionId, aborted ? 'abort' : 'finish');
+  /** SessionFrameHost adapter: remember a blocking dialog for reattaching clients. */
+  trackUiDialog(frame: AgentEvent): void {
+    this.pendingUiDialogs.track(frame);
+  }
+
+  /** SessionFrameHost adapter: fold a subagent frame into the liveness roster. */
+  observeSubagent(frame: AgentEvent, now: number): void {
+    this.subagents.observe(frame, now);
   }
 
   private handleFrame(frame: RpcFrame): void {
     this.resetIdleTimer();
     const event = frame as AgentEvent;
-    let refreshSessionList = false;
-
-    switch (event.type) {
-      case 'agent_start':
-        this.promptRunning = true;
-        this.streaming = true;
-        this.awaitingAgentStart = false;
-        this.awaitingAgentStartDeadline = 0;
-        this.continuationGraceUntil = 0;
-        clearSessionFileCaches();
-        refreshSessionList = true;
-        if (this.sessionId) void markStreamStatus(this.sessionId, 'stream');
-        break;
-      case 'turn_start':
-        // Redundant with agent_start in the happy path, but the run-level
-        // counterpart can be missed (e.g. the state was cleared by a command
-        // between frames). The turn is proof enough the session is live.
-        if (this.sessionId) void markStreamStatus(this.sessionId, 'stream');
-        break;
-      case 'message_start':
-        // Same recovery as turn_start: a message frame is only emitted inside
-        // a live run, so its arrival re-arms the `stream` row no matter what
-        // stale status sits there (upsert overwrites any terminal badge).
-        if (this.sessionId) void markStreamStatus(this.sessionId, 'stream');
-        break;
-      case 'turn_end': {
-        // A multi-turn run emits turn_end for EVERY turn — intermediates end
-        // with `toolUse`/`stop` while the run keeps going (verified against
-        // omp 18.2.8: agent_start → turn_start → turn_end('toolUse') →
-        // turn_start → turn_end('stop') → agent_end, and the frame carries no
-        // isTerminal field). Only `aborted` is unambiguous here: the run is
-        // over, so the abort badge can be written before agent_end arrives.
-        // Everything else waits for agent_end, which knows isTerminal.
-        if (!this.sessionId) break;
-        const turn = event.message as Record<string, unknown> | undefined;
-        if (turn?.stopReason === 'aborted') void markStreamStatus(this.sessionId, 'abort');
-        break;
-      }
-      case 'agent_end':
-        if (event.isTerminal !== false) {
-          this.streaming = false;
-          this.promptRunning = false;
-          this.awaitingAgentStart = false;
-          this.awaitingAgentStartDeadline = 0;
-          this.continuationGraceUntil = 0;
-          clearSessionFileCaches();
-          // The turn's own stopReason is the ground truth for how it ended:
-          // `aborted` = user stop, anything else (`stop`, `toolUse`, and the
-          // ambiguous `error` that tool failures also produce) completes as
-          // `finish`. This must not overwrite a fresh `abort` row from a NEWER
-          // run — guard against downgrades by checking the current row first.
-          const aborted = Array.isArray(event.messages) && event.messages.some((entry) => {
-            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return false;
-            return (entry as Record<string, unknown>).stopReason === 'aborted';
-          });
-          if (this.sessionId) void this.markEndStatus(event.messages);
-          // The run truly ended — the server, not the browser, decides whether
-          // a queued follow-up goes out next. A user-aborted run holds the
-          // queue (stop-all semantics): the next run end or an explicit send
-          // picks it up.
-          if (!aborted) scheduleQueueDelivery(this);
-        } else {
-          this.continuationGraceUntil = Date.now() + NON_TERMINAL_CONTINUATION_GRACE_MS;
-        }
-        break;
-      case 'prompt_result':
-        this.promptRunning = false;
-        this.awaitingAgentStart = false;
-        this.awaitingAgentStartDeadline = 0;
-        break;
-      case 'auto_compaction_start':
-        this.compacting = true;
-        break;
-      case 'auto_compaction_end':
-        this.compacting = false;
-        clearSessionFileCaches();
-        break;
-      case 'session_info_update':
-        clearSessionFileCaches();
-        refreshSessionList = true;
-        break;
-      case 'extension_ui_request':
-        this.pendingUiDialogs.track(event);
-        break;
-      // Subagent frames carry no turn state, but they are the only proof that
-      // work is still running once the parent turn has ended.
-      case 'subagent_lifecycle':
-      case 'subagent_progress':
-      case 'subagent_event':
-        this.subagents.observe(event, Date.now());
-        break;
-      case 'response': {
-        if (event.success === false && event.command === 'prompt') {
-          this.promptRunning = false;
-          this.awaitingAgentStart = false;
-          this.awaitingAgentStartDeadline = 0;
-          this.emit({ type: 'prompt_error', errorMessage: (event.error as string) ?? 'Prompt failed' });
-          notifyRunningChange();
-          return;
-        }
-        break;
-      }
-    }
-
-    this.emit(event);
+    // The state machine and its settle-time side effects live in frame-fold.ts;
+    // this method owns only the wrapper's own bookkeeping around it.
+    const { refreshSessionList, suppressForward } = foldSessionFrame(this, event);
+    // `suppressForward` withholds only the FRAME — a failed prompt response
+    // already emitted its own `prompt_error`, and the chamber's own background
+    // rename must not surface its diagnostics. The running-state notification
+    // still fires: the fold just cleared `promptRunning`, and that flip is what
+    // releases the sidebar's spinner.
+    if (!suppressForward) this.emit(event);
     notifyRunningChange({ refreshSessionList });
   }
 

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

@@ -22,7 +22,13 @@ import { RpcProcess } from '@/server/lib/omp/rpc/process';
 
 // Extensions stay ENABLED: they can register models and login providers, and
 // omitting them made the web UI's model/provider lists disagree with the CLI's.
-const UTILITY_EXTRA_ARGS = ['--no-session', '--no-skills', '--no-lsp'];
+//
+// Skills stay ENABLED too. `--no-skills` made `get_available_commands` omit
+// every `skill:<name>` entry (measured: 45 commands without, 52 with), so the
+// composer's `/` popup could not offer the skills omp happily executes — and
+// the chamber's own disk scan missed provider roots omp reads (`~/.agents/skills`).
+// Cost is nil: the ready frame lands at the same ~420ms either way.
+const UTILITY_EXTRA_ARGS = ['--no-session', '--no-lsp'];
 const READY_TIMEOUT_MS = 60_000;
 // Longer than the 60s models-cache TTL on purpose: with idle-kill == TTL every
 // pause past a minute paid a cold multi-second respawn on top of the stale