ompchamber 1.2.0 → 2.0.0

package/src/server/lib/omp/config/behavior.ts

@@ -19,8 +19,8 @@
  * composer's access control), not here.
  */
 
-import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
-import { asMapping, getOmpConfigPath } from '@/server/lib/omp/config/yaml';
+import { withOmpYamlDocument } from '@/server/lib/omp/config/document';
+import { getOmpConfigPath } from '@/server/lib/omp/config/yaml';
 import { isRecord } from '@/shared/lib/util/guards';
 
 export type ApprovalValue = 'allow' | 'deny' | 'prompt';
@@ -90,24 +90,24 @@ export function parseApprovalRules(text: string): ApprovalFields | null {
 export async function writeToolsApproval(fields: ApprovalFields): Promise<void> {
   if (Object.keys(fields).length === 0) return;
   const path = getOmpConfigPath();
-  const source = (await Bun.file(path).exists()) ? await Bun.file(path).text() : '';
-  const doc = asMapping(Bun.YAML.parse(source), path);
-  const tools = doc.tools;
-  if (tools !== undefined && !isRecord(tools)) {
-    throw new Error(`${path} tools section must be a mapping`);
-  }
-  if (isRecord(tools)) {
-    const approval = tools.approval;
+  await withOmpYamlDocument(path, (doc) => {
+    const tools = doc.get('tools');
+    if (tools !== undefined && !isRecord(tools)) {
+      throw new Error(`${path} tools section must be a mapping`);
+    }
+    const approval = isRecord(tools) ? tools.approval : undefined;
     if (approval !== undefined && !isRecord(approval)) {
       throw new Error(`${path} tools.approval must be a mapping`);
     }
-    if (isRecord(approval)) {
-      Object.assign(approval, fields);
+    // Assign through the document so comments on untouched keys survive; a
+    // plain object replacement would drop the whole subtree's annotations.
+    if (isRecord(tools) && isRecord(approval)) {
+      for (const [key, value] of Object.entries(fields)) doc.setIn(['tools', 'approval', key], value);
+    } else if (isRecord(tools)) {
+      doc.setIn(['tools', 'approval'], fields);
     } else {
-      tools.approval = fields;
+      doc.set('tools', { approval: fields });
     }
-  } else {
-    doc.tools = { approval: fields };
-  }
-  await writeFileAtomic(path, Bun.YAML.stringify(doc, null, 2));
+    return { result: undefined, changed: true };
+  });
 }

package/src/server/lib/omp/config/disabled-providers.ts

@@ -7,36 +7,76 @@
  * Read/write of the native OMP `disabledProviders` list in
  * ~/.omp/agent/config.yml — the flag behind connect/disconnect in the provider
  * settings. Writes are atomic read-modify-writes that preserve every other key
- * in the file.
+ * in the file, its comments, and its path-scoped entries.
+ *
+ * `disabledProviders` is a PATH-SCOPED setting in omp: alongside bare slugs the
+ * list may carry `{ path: ~/work, providers: [deepseek] }` entries that disable
+ * a provider only under that prefix. A writer that filters the list down to
+ * strings and writes it back silently deletes the user's per-project policy, so
+ * every mutation here edits the entry in place and leaves the other entries
+ * untouched.
  */
 
-import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { homedir } from 'os';
+import { isMap, isScalar, type Document } from 'yaml';
 import { getOmpConfigPath } from '@/server/lib/omp/config/yaml';
-import { isRecord } from '@/shared/lib/util/guards';
+import { seqAt, valueAt, withOmpYamlDocument } from '@/server/lib/omp/config/document';
+import { VALUE_KEYS, isPathScopedEntry, pathScopedEntryValues, resolvePathScopedSlugs } from '@/server/lib/omp/config/path-scoped';
 
-function readDisabledProviderSlugs(data: Record<string, unknown>): string[] {
-  const current = data.disabledProviders;
-  return Array.isArray(current)
-    ? current.filter((item): item is string => typeof item === 'string')
-    : [];
+/** The string members of a value key, without assuming it is an array. */
+function stringsIn(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
+/** Every slug the raw list mentions, path-scoped entries included. */
+function listSlugs(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => (
+    typeof entry === 'string' ? [entry] : pathScopedEntryValues(entry)
+  ));
 }
 
 /**
  * Re-enable a disabled provider by removing it from config.yml
  * disabledProviders. Returns false when it was not disabled in the first place.
+ *
+ * A path-scoped entry is never deleted — the provider is only removed from its
+ * value list, because the entry's prefix policy applies to the other providers
+ * it names too.
  */
 export async function enableNativeProvider(slug: string): Promise<boolean> {
   const path = getOmpConfigPath();
-  const file = Bun.file(path);
-  if (!(await file.exists())) return false;
-  const doc = Bun.YAML.parse(await file.text());
-  if (!isRecord(doc)) return false;
-  const current = readDisabledProviderSlugs(doc);
-  const next = current.filter((item) => item !== slug);
-  if (next.length === current.length) return false;
-  doc.disabledProviders = next;
-  await writeFileAtomic(path, Bun.YAML.stringify(doc, null, 2));
-  return true;
+  return withOmpYamlDocument(path, (doc: Document) => {
+    const seq = seqAt(doc, ['disabledProviders']);
+    if (!seq) return { result: false, changed: false };
+
+    let changed = false;
+    // Walk backwards so deleting an item cannot shift the indices still to visit.
+    for (let index = seq.items.length - 1; index >= 0; index--) {
+      const item = seq.items[index];
+      if (isScalar(item) && item.value === slug) {
+        seq.delete(index);
+        changed = true;
+        continue;
+      }
+      if (!isMap(item) || !isPathScopedEntry(item.toJS(doc))) continue;
+      const record = item.toJS(doc) as Record<string, unknown>;
+      const values = pathScopedEntryValues(record);
+      if (!values.includes(slug)) continue;
+      changed = true;
+      const remaining = values.filter((value) => value !== slug);
+      if (remaining.length === 0) {
+        seq.delete(index);
+        continue;
+      }
+      // Update the key that actually held the slug, so a hand-authored
+      // `providers:` list stays `providers:` rather than turning into `values:`.
+      const holder = VALUE_KEYS.find((key) => stringsIn(record[key]).includes(slug));
+      item.set(holder ?? 'values', remaining);
+    }
+    return { result: changed, changed };
+  });
 }
 
 /**
@@ -47,22 +87,31 @@ export async function enableNativeProvider(slug: string): Promise<boolean> {
  */
 export async function disableNativeProvider(slug: string): Promise<boolean> {
   const path = getOmpConfigPath();
-  const file = Bun.file(path);
-  const source = (await file.exists()) ? await file.text() : '';
-  const doc = Bun.YAML.parse(source);
-  if (doc !== null && !isRecord(doc)) {
-    throw new Error(`${path} must contain a YAML mapping`);
-  }
-  const disabled = isRecord(doc) ? readDisabledProviderSlugs(doc) : [];
-  if (disabled.includes(slug)) return false;
+  return withOmpYamlDocument(path, (doc: Document) => {
+    const seq = seqAt(doc, ['disabledProviders']);
+    if (listSlugs(valueAt(doc, ['disabledProviders'])).includes(slug)) {
+      return { result: false, changed: false };
+    }
+    if (seq) seq.add(slug);
+    else doc.set('disabledProviders', [slug]);
+    return { result: true, changed: true };
+  });
+}
 
-  let content: string;
-  if (isRecord(doc)) {
-    doc.disabledProviders = [...disabled, slug];
-    content = Bun.YAML.stringify(doc, null, 2);
-  } else {
-    content = Bun.YAML.stringify({ disabledProviders: [slug] }, null, 2);
-  }
-  await writeFileAtomic(path, content);
-  return true;
+/** Reads the raw list including path-scoped entries (no cwd filtering). */
+export async function readDisabledProviderEntries(): Promise<unknown[]> {
+  const path = getOmpConfigPath();
+  if (!(await Bun.file(path).exists())) return [];
+  const parsed = Bun.YAML.parse(await Bun.file(path).text()) as { disabledProviders?: unknown } | null;
+  return Array.isArray(parsed?.disabledProviders) ? parsed.disabledProviders : [];
+}
+
+/**
+ * Slugs disabled for `cwd`, with path-scoped entries resolved the way omp
+ * resolves them. Defaults to the shared utility RPC process's cwd (`homedir()`),
+ * which is the cwd omp itself uses when the chamber asks it for the model list —
+ * so the chamber's own filter agrees with the list omp just served.
+ */
+export async function readDisabledProviders(cwd: string = homedir()): Promise<Set<string>> {
+  return new Set(resolvePathScopedSlugs(await readDisabledProviderEntries(), cwd));
 }

package/src/server/lib/omp/config/document.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-modify-write of an omp YAML config file: an exclusive chamber lock, a
+ * comment-preserving document model, an external-change retry, and an atomic
+ * write that keeps the file's mode and symlink.
+ *
+ * Why the `yaml` document model rather than `Bun.YAML` (plain objects):
+ *
+ * - **Comments survive.** `~/.omp/agent/models.yml` is a hand-authored file —
+ *   its providers carry notes and per-model annotations. `Bun.YAML.parse` +
+ *   `stringify` discards every comment; a single model fetch would delete them.
+ * - **Byte-stable round-trips.** Serializing the live `models.yml` through the
+ *   document model reproduces the file exactly (23210 bytes in, 23210 out).
+ *   `Bun.YAML.stringify(doc, null, 2)` rewrites it in a different style — and,
+ *   worse, emits `key: ` headers with a trailing space, which is not omp's own
+ *   canonical form (`stringifyYamlConfig` strips that space).
+ *
+ * `Bun.YAML` remains the *parser* for read-only probes, where comments and
+ * formatting are irrelevant.
+ *
+ * Concurrency: omp serializes its own config writes with an OS-level `flock(2)`
+ * on `${path}.lock`. That lock is not reachable from Bun (no `flock` binding,
+ * and the lock file omp creates must not be deleted out from under it), so the
+ * chamber takes its OWN lock file and closes the remaining window with the
+ * external-change check below: if the file moved between the read and the
+ * write, the edit is replayed against the fresh content instead of clobbering
+ * whatever omp just wrote.
+ */
+
+import { parseDocument, isMap, isScalar, isSeq, type Document, type YAMLSeq } from 'yaml';
+import { withConfigLock } from '@/server/lib/fs/config-lock';
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+
+/** A config file that is not a YAML mapping, or not valid YAML at all. */
+export class OmpConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'OmpConfigError';
+  }
+}
+
+export interface DocumentEdit<T> {
+  result: T;
+  /** `false` when the edit turned out to be a no-op — the file is left as it is. */
+  changed: boolean;
+}
+
+/** The sequence node at `path`, when it is a sequence — `null` otherwise. */
+export function seqAt(doc: Document, path: (string | number)[]): YAMLSeq | null {
+  const node = doc.getIn(path);
+  return isSeq(node) ? node : null;
+}
+
+/**
+ * The plain JavaScript value of a YAML node — never a node.
+ *
+ * `node.get(key, true)` is not enough: the `keepScalar` flag only unwraps
+ * scalars, so a map or sequence still comes back as a node, where
+ * `Array.isArray` is `false` and a naive membership check silently sees an
+ * empty collection.
+ */
+export function plainOf<T = unknown>(doc: Document, node: unknown): T | undefined {
+  if (node === undefined || node === null) return undefined;
+  if (isScalar(node)) return node.value as T;
+  if (isMap(node) || isSeq(node)) return node.toJS(doc) as T;
+  return undefined;
+}
+
+/** The plain JavaScript value at `path` — never a node. */
+export function valueAt<T = unknown>(doc: Document, path: (string | number)[]): T | undefined {
+  return plainOf<T>(doc, doc.getIn(path));
+}
+
+const EXTERNAL_CHANGE_RETRIES = 5;
+
+/** Identity of a file version: absent files hash to `missing`. */
+async function fileGeneration(path: string): Promise<string> {
+  try {
+    const stat = await Bun.file(path).stat();
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return 'missing';
+  }
+}
+
+/**
+ * Edit an omp YAML config in place. `edit` receives a live document, mutates it,
+ * and reports whether anything actually changed; the write only happens when it
+ * did. Replayed when another process writes the file mid-edit, so the edit is
+ * never applied on top of stale content.
+ *
+ * A file created here is `0600`: both omp configs carry plaintext credentials
+ * (`models.yml` holds provider `apiKey`s), and omp opens its own config temp
+ * with `wx, 0o600` for the same reason. An existing file keeps its own mode.
+ */
+export async function withOmpYamlDocument<T>(
+  path: string,
+  edit: (doc: Document) => DocumentEdit<T> | Promise<DocumentEdit<T>>,
+): Promise<T> {
+  // Not `${path}.lock`: that file belongs to omp's own flock lease.
+  return withConfigLock(`${path}.ompchamber.lock`, async () => {
+    for (let attempt = 0; ; attempt++) {
+      const before = await fileGeneration(path);
+      const source = (await Bun.file(path).exists()) ? await Bun.file(path).text() : '';
+      const doc = parseDocument(source);
+      if (doc.errors.length > 0) {
+        throw new OmpConfigError(`${path} is not valid YAML: ${doc.errors[0].message.split('\n')[0]}`);
+      }
+      if (doc.contents !== null && !isMap(doc.contents)) {
+        throw new OmpConfigError(`${path} must contain a YAML mapping`);
+      }
+
+      const { result, changed } = await edit(doc);
+      if (!changed) return result;
+      if (attempt < EXTERNAL_CHANGE_RETRIES && (await fileGeneration(path)) !== before) {
+        // Another process rewrote the file while this edit was being computed.
+        // Replay against its content rather than overwrite the newer change.
+        continue;
+      }
+      await writeFileAtomic(path, doc.toString({ indent: 2 }), { createMode: 0o600 });
+      return result;
+    }
+  });
+}

package/src/server/lib/omp/config/extensions.ts

@@ -11,8 +11,8 @@
 
 import { join } from 'path';
 import { getAgentDir, pathExists } from '@/server/lib/omp/core/paths';
-import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
-import { asMapping, getOmpConfigPath } from '@/server/lib/omp/config/yaml';
+import { getOmpConfigPath } from '@/server/lib/omp/config/yaml';
+import { withOmpYamlDocument } from '@/server/lib/omp/config/document';
 import { isRecord } from '@/shared/lib/util/guards';
 
 export interface DiscoveredExtension {
@@ -79,12 +79,13 @@ export async function readDisabledExtensions(): Promise<Set<string>> {
 export async function setExtensionDisabled(id: string, disabled: boolean): Promise<boolean> {
   if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(id)) throw new Error('Invalid extension id');
   const path = getOmpConfigPath();
-  const doc = asMapping(Bun.YAML.parse((await Bun.file(path).exists()) ? await Bun.file(path).text() : ''), path);
-  const already = (await readDisabledExtensions()).has(id);
-  if (disabled === already) return false;
-  const list = [...(await readDisabledExtensions())];
-  const next = disabled ? [...list, id] : list.filter((item) => item !== id);
-  doc.disabledExtensions = next;
-  await writeFileAtomic(path, Bun.YAML.stringify(doc, null, 2));
-  return true;
+  return withOmpYamlDocument(path, (doc) => {
+    const current = doc.get('disabledExtensions');
+    const list = Array.isArray(current)
+      ? current.filter((item): item is string => typeof item === 'string')
+      : [];
+    if (disabled === list.includes(id)) return { result: false, changed: false };
+    doc.set('disabledExtensions', disabled ? [...list, id] : list.filter((item) => item !== id));
+    return { result: true, changed: true };
+  });
 }

package/src/server/lib/omp/config/mcp.ts

@@ -16,10 +16,10 @@
  * never exposed to the browser and are preserved when an edit omits them.
  */
 
-import fs from 'fs';
-import { dirname, join, resolve } from 'path';
+import { join, resolve } from 'path';
 import { getAgentDir, pathExists } from '@/server/lib/omp/core/paths';
 import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { withConfigLock } from '@/server/lib/fs/config-lock';
 import { isRecord } from '@/shared/lib/util/guards';
 
 const MAX_MCP_CONFIG_BYTES = 512 * 1024;
@@ -86,59 +86,6 @@ export async function readProjectMcpConfig(projectRoot: string): Promise<McpUser
   return readMcpFile((await resolveProjectMcpConfig(projectRoot)).path);
 }
 
-// Two writers (e.g. the dev server and the installed app) editing the same
-// mcp.json would otherwise silently lose the earlier mutation when the later
-// rename wins. A lockfile with exclusive create (`wx`) is atomic on every
-// platform; the holder writes its PID and deletes the file on completion.
-// Stale locks (writer crashed) are broken after a grace period.
-const MCP_LOCK_TIMEOUT_MS = 3_000;
-const MCP_LOCK_STALE_MS = 10_000;
-const MCP_LOCK_RETRY_MS = 25;
-
-export async function withMcpConfigLock<T>(configPath: string, fn: () => T | Promise<T>): Promise<T> {
-  const lockPath = `${configPath}.lock`;
-  // The config file may not exist yet (first write) — the lockfile needs its
-  // parent dir to exist before exclusive-create can succeed.
-  await fs.promises.mkdir(dirname(lockPath), { recursive: true });
-  const deadline = Date.now() + MCP_LOCK_TIMEOUT_MS;
-  for (;;) {
-    let handle: fs.promises.FileHandle | null = null;
-    try {
-      handle = await fs.promises.open(lockPath, 'wx');
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-      // Held by another process — break it if stale, otherwise wait and retry.
-      try {
-        if (Date.now() - (await fs.promises.stat(lockPath)).mtimeMs > MCP_LOCK_STALE_MS) {
-          await fs.promises.unlink(lockPath);
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() >= deadline) {
-        throw new Error(`Timed out waiting for ${lockPath} (another process holds the MCP config lock)`);
-      }
-      await Bun.sleep(MCP_LOCK_RETRY_MS);
-      continue;
-    }
-    try {
-      await handle.writeFile(String(process.pid));
-    } finally {
-      await handle.close();
-    }
-    try {
-      return await fn();
-    } finally {
-      try {
-        await fs.promises.unlink(lockPath);
-      } catch {
-        // Already removed (e.g. by cleanup) — the critical section is done.
-      }
-    }
-  }
-}
-
 async function readConfigFile(path: string): Promise<McpFile> {
   if (!(await Bun.file(path).exists())) return { mcpServers: {} };
   const parsed: unknown = JSON.parse(await Bun.file(path).text());
@@ -152,7 +99,7 @@ async function writeConfigFile(path: string, config: McpFile): Promise<void> {
 }
 
 async function writeServerAt(path: string, name: string, server: McpServer, previousName?: string): Promise<{ path: string }> {
-  return withMcpConfigLock(path, async () => {
+  return withConfigLock(path, async () => {
     const config = await readConfigFile(path);
     const servers = { ...(config.mcpServers ?? {}) };
     // Capture the old entry before any rename: a rename must retain
@@ -173,7 +120,7 @@ async function writeServerAt(path: string, name: string, server: McpServer, prev
 
 async function deleteServerAt(path: string, name: string): Promise<{ path: string }> {
   if (!(await Bun.file(path).exists())) throw new Error('MCP server was not found');
-  return withMcpConfigLock(path, async () => {
+  return withConfigLock(path, async () => {
     const config = await readConfigFile(path);
     const servers = { ...(config.mcpServers ?? {}) };
     if (!(name in servers)) throw new Error('MCP server was not found');

package/src/server/lib/omp/config/model-overrides.ts

@@ -0,0 +1,123 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Per-model overrides in omp's own registry (`models.yml` →
+ * `providers.<slug>.modelOverrides.<modelId>`).
+ *
+ * omp resolves sampling per MODEL from here and globally from `config.yml`
+ * (`temperature`, `topP`, `topK`, `minP`), with no per-model temperature at
+ * all. The chamber's model dialog therefore only offers what omp honours:
+ * `maxTokens` and a reasoning `thinking` block. Writing them anywhere else
+ * (the SQLite overlay) left the controls inert — the UI showed a value the
+ * agent never applied.
+ */
+
+import { isMap, type Document } from 'yaml';
+import { getModelsConfigPath } from '@/server/lib/omp/config/models-config';
+import { plainOf, withOmpYamlDocument, OmpConfigError } from '@/server/lib/omp/config/document';
+
+/** Effort levels omp's `ThinkingConfig.efforts` accepts. */
+export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+export interface ModelOverrideInput {
+  provider: string;
+  modelId: string;
+  /** Output-token cap; `null` clears the override. */
+  maxTokens?: number | null;
+  /** Default reasoning effort; `null` clears the thinking override. */
+  reasoningEffort?: ReasoningEffort | null;
+}
+
+export interface ModelOverrideResult {
+  written: boolean;
+  /** True when the provider/model pair does not exist in models.yml. */
+  unknownTarget?: boolean;
+  reason?: string;
+}
+
+/** True when the provider entry holds the given model id. */
+function hasModel(doc: Document, provider: string, modelId: string): boolean {
+  const providers = doc.get('providers');
+  if (!isMap(providers)) return false;
+  const entry = providers.get(provider);
+  if (!isMap(entry)) return false;
+  const models = plainOf<Array<{ id?: string }>>(doc, entry.get('models'));
+  return Array.isArray(models) && models.some((model) => model?.id === modelId);
+}
+
+/**
+ * Write `maxTokens` / `reasoning` overrides for one model. An override that is
+ * cleared is deleted rather than written as `null`, so the model falls back to
+ * the catalog value; when nothing remains the whole `modelOverrides` entry goes
+ * away. The provider must already hold the model — an override for an
+ * unregistered id is silently ignored by omp.
+ */
+export async function writeModelOverride(input: ModelOverrideInput): Promise<ModelOverrideResult> {
+  const path = await getModelsConfigPath();
+  return withOmpYamlDocument<ModelOverrideResult>(path, (doc) => {
+    if (!hasModel(doc, input.provider, input.modelId)) {
+      return {
+        result: {
+          written: false,
+          unknownTarget: true,
+          reason: `${input.modelId} is not registered under provider "${input.provider}" in models.yml`,
+        },
+        changed: false,
+      };
+    }
+
+    const overrides = doc.getIn(['providers', input.provider, 'modelOverrides']);
+    if (overrides !== undefined && !isMap(overrides)) {
+      throw new OmpConfigError(`${path}: providers.${input.provider}.modelOverrides must be a mapping`);
+    }
+
+    const existing = isMap(overrides) ? overrides.get(input.modelId) : undefined;
+    if (existing !== undefined && !isMap(existing)) {
+      throw new OmpConfigError(`${path}: providers.${input.provider}.modelOverrides.${input.modelId} must be a mapping`);
+    }
+    const entry = isMap(existing) ? existing : undefined;
+
+    // Applying through `setIn` materializes the intermediate maps as YAML
+    // nodes, so a fresh override nests correctly.
+    if (input.maxTokens !== undefined) {
+      if (input.maxTokens === null) doc.deleteIn(['providers', input.provider, 'modelOverrides', input.modelId, 'maxTokens']);
+      else if (!(input.maxTokens > 0)) throw new OmpConfigError('maxTokens must be a positive number');
+      else doc.setIn(['providers', input.provider, 'modelOverrides', input.modelId, 'maxTokens'], input.maxTokens);
+    }
+
+    if (input.reasoningEffort !== undefined) {
+      if (input.reasoningEffort === null) {
+        doc.deleteIn(['providers', input.provider, 'modelOverrides', input.modelId, 'thinking']);
+      } else {
+        // `efforts` must list the level the model may use; the previous list is
+        // kept when there is one so a catalog-provided vocabulary is not
+        // narrowed to a single value by a default-level change.
+        const previous = entry ? plainOf<{ efforts?: string[] }>(doc, entry.get('thinking')) : undefined;
+        const efforts = Array.isArray(previous?.efforts) && previous.efforts.length > 0
+          ? [...new Set([...previous.efforts, input.reasoningEffort])]
+          : ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+        doc.setIn(['providers', input.provider, 'modelOverrides', input.modelId, 'thinking'], {
+          mode: 'effort',
+          efforts,
+          defaultLevel: input.reasoningEffort,
+        });
+      }
+    }
+
+    // An override left with no keys is dead weight — drop it so the model
+    // returns to the pure catalog definition.
+    const after = doc.getIn(['providers', input.provider, 'modelOverrides', input.modelId]);
+    if (isMap(after) && after.items.length === 0) {
+      doc.deleteIn(['providers', input.provider, 'modelOverrides', input.modelId]);
+    }
+    const parent = doc.getIn(['providers', input.provider, 'modelOverrides']);
+    if (isMap(parent) && parent.items.length === 0) {
+      doc.deleteIn(['providers', input.provider, 'modelOverrides']);
+    }
+
+    return { result: { written: true }, changed: true };
+  });
+}

package/src/server/lib/omp/config/models-config.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read side of the native OMP models config: the canonical path and the
+ * providers/models registered in it. Read-only — every write lives in
+ * `./providers.ts`, which owns the document-model merge.
+ */
+
+import { join } from 'path';
+import { getAgentDir } from '@/server/lib/omp/core/paths';
+import { isRecord } from '@/shared/lib/util/guards';
+
+const MODELS_FILENAMES = ['models.yml', 'models.yaml'] as const;
+
+/**
+ * Path of the native OMP models config. Prefers the canonical `models.yml`,
+ * which is what omp's own `ConfigFile` treats as the primary target and what
+ * the JSON→YAML migration writes; `models.yaml` is only the legacy fallback for
+ * a file that already exists under that name. A fresh install therefore gets
+ * `models.yml`, never the non-canonical spelling.
+ */
+export async function getModelsConfigPath(): Promise<string> {
+  const dir = getAgentDir();
+  for (const name of MODELS_FILENAMES) {
+    const candidate = join(dir, name);
+    if (await Bun.file(candidate).exists()) return candidate;
+  }
+  return join(dir, MODELS_FILENAMES[0]);
+}
+
+export interface NativeProviderInfo {
+  /** Provider slug, e.g. "deepseek" or "custom/my-gateway". */
+  slug: string;
+  /** Base URL of the provider API, when configured. */
+  baseUrl?: string;
+  /** Model ids registered under this provider in models.yml. */
+  modelIds: string[];
+  models: NativeModelInfo[];
+}
+
+export interface NativeModelInfo {
+  id: string;
+  name?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  imageInput?: boolean;
+}
+
+/**
+ * Read custom providers/models registered in models.yml. Returns [] when the
+ * file is missing or has no providers — never throws for absent files.
+ *
+ * The `models` collection is array-only here, matching omp's schema. The
+ * previous tolerant map-form reader made the chamber report providers as
+ * healthy while omp had disabled the entire file for the same content, and the
+ * next upsert then rewrote the map as an array, discarding every model in it.
+ */
+export async function readNativeProviders(): Promise<NativeProviderInfo[]> {
+  const path = await getModelsConfigPath();
+  if (!(await Bun.file(path).exists())) return [];
+  try {
+    const data = Bun.YAML.parse(await Bun.file(path).text());
+    if (!isRecord(data) || !isRecord(data.providers)) return [];
+    return Object.entries(data.providers).map(([slug, value]) => {
+      const info: NativeProviderInfo = { slug, modelIds: [], models: [] };
+      if (isRecord(value)) {
+        if (typeof value.baseUrl === 'string') info.baseUrl = value.baseUrl;
+        if (Array.isArray(value.models)) {
+          info.models = value.models.flatMap((model) => {
+            if (!isRecord(model) || typeof model.id !== 'string') return [];
+            return [{
+              id: model.id,
+              ...(typeof model.name === 'string' ? { name: model.name } : {}),
+              ...(typeof model.contextWindow === 'number' ? { contextWindow: model.contextWindow } : {}),
+              ...(typeof model.maxTokens === 'number' ? { maxTokens: model.maxTokens } : {}),
+              ...(model.reasoning === true ? { reasoning: true } : {}),
+              ...(Array.isArray(model.input) && model.input.includes('image') ? { imageInput: true } : {}),
+            }];
+          });
+        }
+        info.modelIds = info.models.map((model) => model.id);
+      }
+      return info;
+    });
+  } catch {
+    return [];
+  }
+}