ompchamber 0.8.0 → 1.1.0

package/src/server/lib/fs/git-sync.ts

@@ -0,0 +1,191 @@
+import { runShell, shellOk } from '@/server/lib/fs/shell';
+
+/**
+ * Ahead/behind counts behind the git panel's Sync button.
+ *
+ * `git rev-list --left-right --count HEAD...@{upstream}` counts against the
+ * LOCAL remote-tracking ref, and that ref only moves on fetch/pull/push.
+ * Nothing in the chamber ever fetched, so `behind` reported the state of the
+ * last fetch rather than the remote: the badge sat at ↑0 ↓0 while origin had
+ * commits to pull, and the button — disabled by that very zero — could never
+ * correct itself.
+ *
+ * A read that asks for counts therefore refreshes the tracking ref first. The
+ * refresh is TTL'd so the git panel's 5s poll is not a 5s fetch loop, it is
+ * shared across the panels polling the same repo, and the loader starts it
+ * before its local git probes so the round trip overlaps instead of adding up.
+ */
+
+/** How long a fetch attempt — success or failure — is trusted. */
+const FETCH_TTL_MS = 60_000;
+/**
+ * How long a read waits for the fetch before answering from the tracking ref
+ * as it stands. A slow or offline remote must not stall the panel; the fetch
+ * keeps running under its own budget and a later read picks up the new ref.
+ */
+const FETCH_WAIT_MS = 3_000;
+/** Hard budget for one fetch; it is killed at the end of it. */
+const FETCH_TIMEOUT_MS = 15_000;
+
+export interface GitSyncCount {
+  ahead: number;
+  behind: number;
+}
+
+interface RemoteState {
+  /** When the last attempt settled; `0` means never attempted. */
+  at: number;
+  /** The running attempt, so concurrent polls share one fetch. */
+  inFlight: Promise<void> | null;
+}
+
+const remoteStates = new Map<string, RemoteState>();
+
+function stateFor(cwd: string): RemoteState {
+  let state = remoteStates.get(cwd);
+  if (!state) {
+    state = { at: 0, inFlight: null };
+    remoteStates.set(cwd, state);
+  }
+  return state;
+}
+
+/**
+ * Runs one `git fetch` with a hard deadline, returning whether it succeeded.
+ *
+ * Deliberately not `runShell`: that helper reads stdout and stderr to EOF, and
+ * a stalled fetch defeats it — git's own `git-remote-https` child survives the
+ * kill and keeps the inherited stderr pipe open, so the read never ends and the
+ * promise hangs forever. Verified on Bun 1.4.2: Bun's `timeout` closes stdout
+ * but not that inherited stderr, and the orphan lingers. Nothing here reads the
+ * fetch's output, so both streams are ignored (no pipe, nothing to hang on) and
+ * the process is killed by process group at the deadline — `detached` is what
+ * makes the group killable, and the group kill is what stops the helper from
+ * accumulating on every stalled attempt.
+ */
+async function runFetch(cwd: string, remote: string): Promise<boolean> {
+  const proc = Bun.spawn({
+    cmd: ['sh', '-c', `git fetch --quiet --no-tags '${remote.replace(/'/g, `'\\''`)}'`],
+    cwd,
+    stdin: 'ignore',
+    stdout: 'ignore',
+    stderr: 'ignore',
+    detached: true,
+    // Without this a remote that wants credentials blocks on stdin; the fetch
+    // then fails instead, and the counts fall back to the tracking ref.
+    env: { ...Bun.env, GIT_TERMINAL_PROMPT: '0' },
+  });
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, FETCH_TIMEOUT_MS);
+  });
+  const exitCode = await Promise.race([
+    proc.exited,
+    deadline.then(() => {
+      try {
+        process.kill(-proc.pid, 'SIGKILL');
+      } catch {
+        // Already gone, or the group could not be signalled: `exited` below
+        // still settles, and the ref simply stays as it was.
+      }
+      return proc.exited;
+    }),
+  ]);
+  clearTimeout(timer);
+  return exitCode === 0;
+}
+
+/**
+ * The branch's upstream remote, or null when it has none. Cheap and local, so
+ * the no-upstream case is never cached: configuring an upstream in the terminal
+ * shows up on the next poll instead of up to a TTL later.
+ */
+async function readUpstreamRemote(cwd: string): Promise<string | null> {
+  try {
+    const result = await runShell('git rev-parse --abbrev-ref --symbolic-full-name @{upstream}', {
+      cwd,
+      timeout: 5_000,
+    });
+    if (!shellOk(result)) return null;
+    const upstream = result.stdout.trim();
+    const slash = upstream.indexOf('/');
+    return slash > 0 ? upstream.slice(0, slash) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Refresh `cwd`'s remote-tracking refs, awaiting at most `FETCH_WAIT_MS`.
+ * Resolves immediately when the last attempt is still inside its TTL, and
+ * shares the running attempt when one is already in flight.
+ */
+export async function refreshRemoteRefs(cwd: string): Promise<void> {
+  const state = stateFor(cwd);
+  if (state.inFlight) return state.inFlight;
+  if (state.at !== 0 && Date.now() - state.at < FETCH_TTL_MS) return;
+
+  const remote = await readUpstreamRemote(cwd);
+  if (!remote) return;
+  // Reading the upstream is itself an await: another poll may have started the
+  // fetch, or completed one, in the meantime.
+  if (state.inFlight) return state.inFlight;
+  if (state.at !== 0 && Date.now() - state.at < FETCH_TTL_MS) return;
+
+  // The attempt never rejects — a failed fetch is not a broken panel — and
+  // always clears `inFlight` so a later read can retry.
+  state.inFlight = (async () => {
+    try {
+      await runFetch(cwd, remote);
+    } finally {
+      state.at = Date.now();
+      state.inFlight = null;
+    }
+  })();
+
+  // Bounded wait. `AbortSignal.timeout` rather than `Bun.sleep`: it is unref'd,
+  // so an abandoned wait cannot hold a live timer open on every poll that
+  // refreshes.
+  const deadline = new Promise<void>((resolve) => {
+    AbortSignal.timeout(FETCH_WAIT_MS).addEventListener('abort', () => resolve(), { once: true });
+  });
+  await Promise.race([state.inFlight, deadline]);
+}
+
+/**
+ * Marks `cwd` as freshly fetched — a pull/push has already moved the tracking
+ * ref, so the next read must not fetch a state it just produced.
+ */
+export function markRemoteRefsFresh(cwd: string): void {
+  stateFor(cwd).at = Date.now();
+}
+
+/**
+ * Forces the next read to fetch. The counts are per-branch, so a checkout makes
+ * whatever the previous branch refreshed irrelevant.
+ */
+export function invalidateRemoteRefs(cwd: string): void {
+  stateFor(cwd).at = 0;
+}
+
+/**
+ * Ahead/behind against the branch's upstream, read from the local tracking ref
+ * (`refreshRemoteRefs` is what makes that ref current). Both zero when the
+ * branch has no upstream or git cannot answer.
+ */
+export async function gitSyncCount(cwd: string): Promise<GitSyncCount> {
+  try {
+    // `git rev-list --left-right --count HEAD...@{upstream}` prints "<ahead>\t<behind>".
+    const result = await runShell('git rev-list --left-right --count HEAD...@{upstream}', {
+      cwd,
+      timeout: 8_000,
+    });
+    if (!shellOk(result)) return { ahead: 0, behind: 0 };
+
+    const [ahead, behind] = result.stdout.trim().split(/\s+/).map(Number);
+    return { ahead: ahead || 0, behind: behind || 0 };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+}

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

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Persistence for the user's favorite + last-used models.
+ *
+ * Lives apart from the model registry because a favorite is NOT a property of
+ * omp's registry: the catalog the route used to mutate (`omp_models_catalog`)
+ * is a MOCK-only demo list that real mode never reads back, so a star clicked
+ * on a real install was written into a dead row and lost on the next render.
+ * This store is the single source for both modes.
+ *
+ * Keys are composite (`provider:id`) — see `modelKey` — and stale ones are
+ * dropped on read, so a model removed from models.yml cannot hold a slot in the
+ * five-entry recent rail forever.
+ */
+
+import { getDb } from '@/server/db.server';
+import { readSettingsJson, writeSettingsJson } from '@/server/lib/db/settings-store';
+import { isMockMode } from '@/server/mock.server';
+import { INITIAL_MODELS_CATALOG } from '@/client/data/models/catalog';
+import {
+  EMPTY_MODEL_PREFERENCES,
+  RECENT_MODELS_LIMIT,
+  filterKnownKeys,
+  readModelPreferences,
+  recordRecentKey,
+  toggleFavoriteKey,
+} from '@/shared/lib/models/preferences';
+import { modelKey } from '@/shared/lib/models/identity';
+import type { ModelPreferences } from '@/shared/types';
+
+const MODEL_PREFERENCES_KEY = 'omp_model_preferences';
+
+/**
+ * Demo favorites/recents so a `MOCK=true` chamber still opens with the rails
+ * the shipped catalog advertises. Seeded on first read only — from then on the
+ * row is the user's, and the catalog's own flags are ignored.
+ */
+function mockSeedPreferences(): ModelPreferences {
+  return {
+    favorites: INITIAL_MODELS_CATALOG.filter((model) => model.isFavorite).map(modelKey),
+    recentKeys: INITIAL_MODELS_CATALOG.filter((model) => model.isRecent).map(modelKey).slice(0, RECENT_MODELS_LIMIT),
+  };
+}
+
+async function readStoredPreferences(): Promise<ModelPreferences> {
+  const db = await getDb();
+  const raw = await readSettingsJson<unknown>(db, MODEL_PREFERENCES_KEY, null);
+  if (raw === null) return isMockMode() ? mockSeedPreferences() : EMPTY_MODEL_PREFERENCES;
+  return readModelPreferences(raw);
+}
+
+/**
+ * Preferences narrowed to the models the registry actually serves right now —
+ * the shape every loader response carries.
+ */
+export async function readModelPreferencesFor(
+  models: readonly { provider: string; id: string }[],
+): Promise<ModelPreferences> {
+  try {
+    const known = new Set(models.map(modelKey));
+    const stored = await readStoredPreferences();
+    return {
+      favorites: filterKnownKeys(stored.favorites, known),
+      recentKeys: filterKnownKeys(stored.recentKeys, known),
+    };
+  } catch {
+    return EMPTY_MODEL_PREFERENCES;
+  }
+}
+
+/**
+ * Persist a mutation with the stale keys already removed, so a key the registry
+ * dropped cannot sit in the row holding one of the five recent slots. Reading
+ * prunes for display only — without this the slot stayed occupied across
+ * reloads and the RECENT rail silently showed four models instead of five.
+ */
+async function writePreferences(known: ReadonlySet<string>, mutate: (current: ModelPreferences) => ModelPreferences): Promise<ModelPreferences> {
+  const current = await readStoredPreferences();
+  const next = mutate({
+    favorites: filterKnownKeys(current.favorites, known),
+    recentKeys: filterKnownKeys(current.recentKeys, known),
+  });
+  const db = await getDb();
+  await writeSettingsJson(db, MODEL_PREFERENCES_KEY, next);
+  return next;
+}
+
+/** Flip one model's favorite flag, returning the full persisted pair. */
+export async function toggleFavoritePreference(key: string, known: ReadonlySet<string>): Promise<ModelPreferences> {
+  return writePreferences(known, (current) => ({
+    ...current,
+    favorites: toggleFavoriteKey(current.favorites, key),
+  }));
+}
+
+/**
+ * Record a model as last used. Called from the selection action rather than
+ * from a separate endpoint: "the user picked this model" is one event, and a
+ * second request would only add a way for the two to disagree.
+ */
+export async function recordRecentPreference(key: string, known: ReadonlySet<string>): Promise<ModelPreferences> {
+  return writePreferences(known, (current) => ({
+    ...current,
+    recentKeys: recordRecentKey(current.recentKeys, key),
+  }));
+}

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

@@ -20,8 +20,9 @@ import { PendingUiDialogs } from '@/server/lib/omp/rpc/pending-ui-dialogs';
 import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 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 { markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
+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';
 
 export type {
@@ -172,6 +173,22 @@ 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');
+  }
+
   private handleFrame(frame: RpcFrame): void {
     this.resetIdleTimer();
     const event = frame as AgentEvent;
@@ -188,6 +205,31 @@ export class AgentSessionWrapper {
         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;
@@ -196,7 +238,21 @@ export class AgentSessionWrapper {
           this.awaitingAgentStartDeadline = 0;
           this.continuationGraceUntil = 0;
           clearSessionFileCaches();
-          if (this.sessionId) void markStreamStatus(this.sessionId, 'finish');
+          // 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;
         }
@@ -232,7 +288,6 @@ export class AgentSessionWrapper {
           this.promptRunning = false;
           this.awaitingAgentStart = false;
           this.awaitingAgentStartDeadline = 0;
-          if (this.sessionId) void markStreamStatus(this.sessionId, 'error');
           this.emit({ type: 'prompt_error', errorMessage: (event.error as string) ?? 'Prompt failed' });
           notifyRunningChange();
           return;

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

@@ -13,6 +13,7 @@ import { RpcCommandTimeoutError, type RpcProcess } from '@/server/lib/omp/rpc/pr
 import { AWAITING_AGENT_START_TIMEOUT_MS, GET_STATE_TIMEOUT_MS, IMAGE_BEARING_COMMANDS, PASSTHROUGH_COMMANDS, PROMPT_ACK_TIMEOUT_MS, RESTARTING_MESSAGE, SESSION_BUSY_MESSAGE, WebRpcError, toImageContents, type AgentEvent, type RpcSessionState, validateAgentImages } from '@/server/lib/omp/rpc/constants';
 import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 import { notifyRunningChange } from '@/server/lib/omp/rpc/session-registry';
+import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
 import { clearStreamStatus, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
 import { buildWebState, type WebStateHost } from '@/server/lib/omp/rpc/web-state';
 
@@ -28,6 +29,8 @@ export interface SessionCommandHost extends WebStateHost {
   /** Real omp session id (empty before the first get_state). */
   sessionId: string;
   emit(event: AgentEvent): void;
+  /** One dispatch throat (same surface the wrapper's own send uses). */
+  send(command: Record<string, unknown>): Promise<unknown>;
   resetIdleTimer(force?: boolean): void;
   /** Forget a pending ask/approval dialog once its response is sent. */
   resolvePendingUiDialog(id: string): void;
@@ -100,6 +103,9 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
           releaseStreamRow();
           host.emit({ type: 'prompt_result', agentInvoked: false });
           notifyRunningChange();
+          // Nothing ran (agent was idle and declined) — the queue may hold the
+          // next item; give it the same delivery window a run end would.
+          scheduleQueueDelivery(host);
         } else if (!streamingBehavior && ack?.agentInvoked !== false) {
           host.awaitingAgentStart = true;
           host.awaitingAgentStartDeadline = Date.now() + AWAITING_AGENT_START_TIMEOUT_MS;

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

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

@@ -110,11 +110,11 @@ export async function loadSidebarData(): Promise<SessionListPayload> {
   const sidebarSort = await serverSidebarSort();
 
   // Live stream status per session (spinner / one-shot done badge), written by
-  // the RPC manager on agent_start/agent_end/abort/error. `stream` rows whose
-  // session is no longer running are stale (restart mid-run) and heal to
+  // the RPC manager on agent_start/agent_end and by the abort command. `stream`
+  // rows whose session is no longer running are stale (restart mid-run) and heal to
   // `finish` right here — the authoritative status travels with the same
   // fetch that refreshes the sidebar list.
-  const streamStatuses: Record<string, 'stream' | 'finish' | 'abort' | 'error'> = {};
+  const streamStatuses: Record<string, 'stream' | 'finish' | 'abort'> = {};
   // Sessions blocked on a dialog nobody has answered yet. Read live from the
   // process registry (never persisted): the child that owns the question is the
   // same thing that owns the flag, so a restart cannot leave a stale badge.