@kabmo-labs/kabmo 0.5.3 → 0.6.0

package/src/server/lib/bundler/titlebar-css.test.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The window-drag contract, at the two places it can silently break.
+ *
+ * The macOS shell does not read CSS to decide a drag: a WKWebView swallows mouse
+ * events, so `ShellWindow.mouseDown` asks the page whether the press landed on
+ * `[data-drag-region]`, walking up and stopping at any interactive element. That
+ * makes two things load-bearing, and neither fails loudly:
+ *
+ * 1. **the header must carry the attribute** — without it the window cannot be
+ *    moved by its own title bar, which is what the previous shell shipped;
+ * 2. **the PWA's `-webkit-app-region` must survive the bundle** — it is what the
+ *    browser-installed app reads for its Window Controls Overlay, and Tailwind's
+ *    minifier is the last step that could drop it.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+
+import cssPlugin from '@/server/lib/bundler/css';
+
+async function build(css: string): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), 'kabmo-titlebar-'));
+  try {
+    await Bun.write(join(dir, 'probe.css'), css);
+    const result = await Bun.build({
+      entrypoints: [join(dir, 'probe.css')],
+      outdir: join(dir, 'out'),
+      target: 'bun',
+      minify: true,
+      plugins: [cssPlugin],
+    });
+    if (!result.success) throw new Error(result.logs.map((log) => log.message).join('\n'));
+    return await Bun.file(join(dir, 'out', 'probe.css')).text();
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+const source = (path: string) => readFileSync(join(process.cwd(), path), 'utf8');
+
+describe('window-drag contract', () => {
+  /**
+   * The shell's hit test starts at the element under the pointer and walks up.
+   * A header without the attribute is a header that cannot move the window.
+   */
+  test('both title-bar headers carry data-drag-region', () => {
+    for (const path of [
+      'src/client/components/layout/desktop-layout/TopNavbar.tsx',
+      'src/client/components/layout/session-sidebar/Header.tsx',
+    ]) {
+      const file = source(path);
+      expect(file).toContain('dragRegionProps()');
+    }
+    // The attribute name is stated once, in the module the headers import.
+    expect(source('src/client/lib/desktop/titlebar.ts')).toContain("'data-drag-region'");
+  });
+
+  /** The PWA keeps its drag region: the property has to reach the browser. */
+  test('the webkit property survives the bundle', async () => {
+    const out = await build(`
+.titlebar-drag-region { -webkit-app-region: drag; app-region: drag; }
+.titlebar-no-drag { -webkit-app-region: no-drag; app-region: no-drag; }
+`);
+    expect(out).toContain('-webkit-app-region:drag');
+    expect(out).toContain('-webkit-app-region:no-drag');
+  });
+});

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

@@ -17,6 +17,7 @@ import { ensureBtwSchema } from '@/server/lib/btw/schema.server';
 import { ensureScheduleSchema } from '@/server/lib/schedule/schema.server';
 import { ensureWaitingSchema } from '@/server/lib/waiting/schema.server';
 import { ensurePluginSchema } from '@/server/lib/plugins/schema.server';
+import { ensureModelRolePresetSchema } from '@/server/lib/model-roles/schema.server';
 import { migrateWorkspaceFolderColumns } from '@/shared/lib/workspace/schema-migrations';
 import { migrateSessionStreamStateColumns } from '@/shared/lib/omp/session/schema-migrations';
 
@@ -109,6 +110,8 @@ export async function initSchema(db: DbClient): Promise<void> {
   await ensureWaitingSchema(db);
   // The plugin platform's own tables (kv, records, settings).
   await ensurePluginSchema(db);
+  // Named model-role presets (the role editor's preset picker).
+  await ensureModelRolePresetSchema(db);
 
   await db.exec(`
     CREATE TABLE IF NOT EXISTS files (

package/src/server/lib/model-roles/catalog.server.test.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The role dropdowns' candidate catalog.
+ *
+ * Two properties matter and both are about failure, not the happy path:
+ *
+ *   - **A catalog failure is REPORTED, never thrown.** The roles live in
+ *     config.yml and stay editable without a catalog; an empty dropdown with no
+ *     explanation reads as "no models exist", which is a different and false
+ *     claim. The message is omp's own sentence where there is one.
+ *   - **The listing is cached, and dropped by the same signal that drops the
+ *     chat model cache.** A model removed from models.yml must leave the role
+ *     pickers too, or they keep offering a selector omp cannot resolve.
+ *
+ * `omp` is never spawned: the failure case points the binary override at a path
+ * that does not exist (which `resolveOmpBin` answers with `null`, by design —
+ * it does not fall through to a PATH lookup), and the mock case never reaches a
+ * spawn at all.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { readModelRoleCandidates } from '@/server/lib/model-roles/catalog.server';
+import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+
+const originalMock = Bun.env.MOCK;
+const originalBin = Bun.env.KABMO_OMP_BIN;
+
+beforeEach(() => {
+  globalThis.__kabmoRoleCandidatesCache = undefined;
+});
+
+afterEach(() => {
+  if (originalMock === undefined) delete Bun.env.MOCK;
+  else Bun.env.MOCK = originalMock;
+  if (originalBin === undefined) delete Bun.env.KABMO_OMP_BIN;
+  else Bun.env.KABMO_OMP_BIN = originalBin;
+  globalThis.__kabmoRoleCandidatesCache = undefined;
+});
+
+describe('role candidate catalog', () => {
+  test('mock mode answers a demo catalog covering every role kind', async () => {
+    Bun.env.MOCK = 'true';
+    const { candidates, error } = await readModelRoleCandidates();
+    expect(error).toBeNull();
+    const kinds = new Set(candidates.map((candidate) => candidate.kind));
+    // The five kind roles need a model of their own kind, or their dropdown is empty.
+    for (const kind of ['chat', 'search', 'stt', 'tts', 'tiny', 'image']) {
+      expect(kinds.has(kind), `${kind} candidates`).toBe(true);
+    }
+  });
+
+  test('a missing omp binary is reported, not thrown', async () => {
+    delete Bun.env.MOCK;
+    Bun.env.KABMO_OMP_BIN = '/nonexistent/omp-binary';
+    const { candidates, error } = await readModelRoleCandidates();
+    expect(candidates).toEqual([]);
+    expect(error).toContain('omp binary not found');
+  });
+
+  test('a successful listing is cached until the models cache is invalidated', async () => {
+    Bun.env.MOCK = 'true';
+    await readModelRoleCandidates();
+    expect(globalThis.__kabmoRoleCandidatesCache).toBeUndefined();
+
+    // Seed a cache the way a real read would, then prove the shared invalidation
+    // clears it — the same call every provider/model mutation already makes.
+    globalThis.__kabmoRoleCandidatesCache = { data: [], expiresAt: Date.now() + 60_000 };
+    invalidateModelsCaches();
+    expect(globalThis.__kabmoRoleCandidatesCache).toBeUndefined();
+  });
+});

package/src/server/lib/model-roles/catalog.server.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The model catalog behind the role dropdowns.
+ *
+ * Read from `omp models --json --kind all` — the CLI's own listing, so the
+ * candidates are exactly what omp can resolve (a model removed from
+ * `models.yml`, or one whose provider lost its credential, does not appear).
+ * `get_available_models` over RPC was the alternative and was rejected: it
+ * answers CHAT models only (`modelRegistry.getAvailable()` defaults to kind
+ * `chat`), so the five kind roles would have had nothing to offer.
+ *
+ * One limit is worth naming: the CLI's JSON does not carry `webSearch`, so a
+ * CHAT model that omp's `web` role would also accept cannot be identified
+ * here. `web` therefore offers search-kind rows; a chat model already assigned
+ * to it stays selectable through the dropdown's current-value option.
+ *
+ * Cached for a minute on `globalThis` — a listing spawn costs ~1.3 s and the
+ * settings panel reads it on open and on Refresh.
+ */
+
+import { childEnv } from '@/server/lib/fs/child-env';
+import { resolveOmpBin } from '@/server/lib/omp/core/cli';
+import { isMockMode } from '@/server/mock.server';
+import { mockRoleCandidates } from '@/server/lib/model-roles/mock.server';
+import type { ModelRoleCandidate } from '@/shared/types/model-roles';
+
+const CANDIDATES_TTL_MS = 60_000;
+const LIST_TIMEOUT_MS = 30_000;
+
+/**
+ * One `omp models --json` row → a candidate; null when the row is unusable.
+ *
+ * The row is read as an untyped record and every field is narrowed: the JSON is
+ * produced by a binary this module does not compile against, so a missing or
+ * retyped field must degrade the row, not the listing.
+ */
+function toCandidate(raw: unknown): ModelRoleCandidate | null {
+  if (typeof raw !== 'object' || raw === null) return null;
+  const row: Record<string, unknown> = { ...raw };
+  const provider = row.provider;
+  const id = row.id;
+  if (typeof provider !== 'string' || typeof id !== 'string') return null;
+  const name = row.name;
+  const kind = row.kind;
+  const selector = row.selector;
+  return {
+    selector: typeof selector === 'string' ? selector : `${provider}/${id}`,
+    id,
+    name: typeof name === 'string' && name.trim() ? name : id,
+    provider,
+    kind: typeof kind === 'string' ? kind : 'chat',
+  };
+}
+
+/** `omp models --json --kind all` → candidates; throws with omp's own sentence. */
+async function readCandidatesFromCli(): Promise<ModelRoleCandidate[]> {
+  const bin = resolveOmpBin();
+  if (!bin) throw new Error('omp binary not found — install omp to pick role models');
+  const proc = Bun.spawn({
+    env: childEnv(),
+    cmd: [bin, 'models', '--json', '--kind', 'all'],
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: LIST_TIMEOUT_MS,
+    maxBuffer: 32 * 1024 * 1024,
+    windowsHide: true,
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const line = (stderr.trim() || stdout.trim()).split('\n').map((row) => row.trim()).find(Boolean);
+    throw new Error(line ? line.replace(/^[^\w@/]*/, '') : `omp models exited with code ${exitCode}`);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new Error('omp models returned unexpected JSON');
+  }
+  const rows = typeof parsed === 'object' && parsed !== null && 'models' in parsed ? parsed.models : undefined;
+  if (!Array.isArray(rows)) throw new Error('omp models returned no model list');
+  return rows.flatMap((raw) => {
+    const candidate = toCandidate(raw);
+    return candidate ? [candidate] : [];
+  });
+}
+
+/**
+ * Candidates for the role dropdowns. A catalog failure is REPORTED rather than
+ * thrown: the roles themselves live in config.yml and stay editable without it,
+ * and an empty dropdown with no explanation reads as "no models exist".
+ */
+export async function readModelRoleCandidates(): Promise<{ candidates: ModelRoleCandidate[]; error: string | null }> {
+  if (isMockMode()) return { candidates: mockRoleCandidates(), error: null };
+  const cached = globalThis.__kabmoRoleCandidatesCache;
+  if (cached && cached.expiresAt > Date.now()) return { candidates: cached.data, error: null };
+  try {
+    const candidates = await readCandidatesFromCli();
+    globalThis.__kabmoRoleCandidatesCache = { data: candidates, expiresAt: Date.now() + CANDIDATES_TTL_MS };
+    return { candidates, error: null };
+  } catch (error) {
+    return { candidates: [], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+

package/src/server/lib/model-roles/mock.server.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Demo catalog for the role dropdowns under `MOCK=true`.
+ *
+ * A demo install spawns no omp child, so `omp models` answers nothing and every
+ * role dropdown would be empty. The chat rows come from the SAME demo catalog
+ * `/api/models` serves in mock mode, so the role picker and the composer picker
+ * name the same models; the non-chat rows exist because the five kind roles
+ * accept a model of that kind only and would otherwise have no option at all.
+ */
+
+import { INITIAL_MODELS_CATALOG } from '@/client/data/models/catalog';
+import type { ModelRoleCandidate } from '@/shared/types/model-roles';
+
+const DEMO_KIND_MODELS: Array<Pick<ModelRoleCandidate, 'id' | 'name' | 'provider' | 'kind'>> = [
+  { id: 'brave', name: 'Brave', provider: 'web', kind: 'search' },
+  { id: 'deepseek', name: 'DeepSeek Search', provider: 'web', kind: 'search' },
+  { id: 'gemma-3-1b', name: 'Gemma 3 1B', provider: 'local', kind: 'tiny' },
+  { id: 'whisper-base', name: 'Whisper Base', provider: 'local', kind: 'stt' },
+  { id: 'kokoro', name: 'Kokoro-82M', provider: 'local', kind: 'tts' },
+  { id: 'flux-schnell', name: 'FLUX.1 Schnell', provider: 'local', kind: 'image' },
+];
+
+export function mockRoleCandidates(): ModelRoleCandidate[] {
+  const chat: ModelRoleCandidate[] = INITIAL_MODELS_CATALOG.map((model) => ({
+    selector: `${model.provider}/${model.id}`,
+    id: model.id,
+    name: model.name,
+    provider: model.provider,
+    kind: 'chat',
+  }));
+  return [
+    ...chat,
+    ...DEMO_KIND_MODELS.map((model) => ({ ...model, selector: `${model.provider}/${model.id}` })),
+  ];
+}

package/src/server/lib/model-roles/schema.server.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Model-role preset schema, in its own module for the reason
+ * `schedule/schema.server.ts` and `btw/schema.server.ts` are: it is created on
+ * every database open, and the feature that reads it owns the DDL.
+ *
+ * The preset's whole `modelRoles` map is ONE JSON column rather than a row per
+ * role. A preset is a SNAPSHOT applied as a unit — the same semantics as omp's
+ * own `/modelpreset switch`, which re-applies the saved roles "as a whole" — so
+ * a per-role table would have to express an operation that does not exist.
+ *
+ * `name` is UNIQUE with `COLLATE NOCASE`: a user who saves "Fast" twice means
+ * the same preset, and two rows differing only in case would be two entries the
+ * picker cannot tell apart.
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+
+const MODEL_ROLE_PRESET_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS model_role_presets (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL COLLATE NOCASE UNIQUE,
+    roles TEXT NOT NULL DEFAULT '{}',
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+`;
+
+/** Idempotent: the role-preset table, created on every database open. */
+export async function ensureModelRolePresetSchema(db: DbClient): Promise<void> {
+  await db.exec(MODEL_ROLE_PRESET_SCHEMA_SQL);
+}

package/src/server/lib/model-roles/store.server.test.ts

@@ -0,0 +1,218 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Model-role presets, end to end over the real route and a temp database.
+ *
+ * The properties pinned here are the ones a preset picker depends on:
+ *
+ *   - A preset is stored in Kabmo's OWN table (`model_role_presets`), so it
+ *     survives a restart and does not depend on omp's config.yml.
+ *   - A name is unique case-insensitively — saving "Cheap" twice is one preset,
+ *     and the second answer names the collision instead of the SQLite sentence.
+ *   - `PUT` writes the WHOLE map, which is what applying a preset is; an empty
+ *     selector removes a role rather than storing `''`.
+ *   - A custom role id survives, because `modelRoles` accepts them and the map
+ *     is written back whole — filtering would silently delete one.
+ *
+ * `omp` is never spawned: the loader's catalog read is pointed at MOCK mode by
+ * the candidate test's own fixture (see `mock.server.ts`), and the rest of the
+ * route does not touch it.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { isolateDb, releaseDb } from '@/test-support/isolated-db';
+import { removeDir } from '@/test-support/remove-dir';
+import { getDb } from '@/server/db.server';
+import { initSchema } from '@/server/lib/db/schema';
+import { action, loader } from '@/server/routes/models/roles';
+import {
+  SEEDED_PRESET_NAME,
+  deleteModelRolePreset,
+  listModelRolePresets,
+  saveModelRolePreset,
+  seedPresetFromCurrentRoles,
+} from '@/server/lib/model-roles/store.server';
+
+type Handler = (args: never) => unknown;
+
+const originalAgentDir = Bun.env.PI_CODING_AGENT_DIR;
+const originalMock = Bun.env.MOCK;
+let agentDir = '';
+
+beforeEach(async () => {
+  // A temp agent dir, not the developer's: `PUT` writes `config.yml`, and a
+  // suite that pointed at `~/.omp/agent` would rewrite a live install's roles.
+  agentDir = mkdtempSync(join(tmpdir(), 'omc-role-presets-'));
+  Bun.env.PI_CODING_AGENT_DIR = agentDir;
+  await isolateDb();
+  await initSchema(await getDb());
+  Bun.env.MOCK = 'true';
+});
+
+afterEach(async () => {
+  await releaseDb();
+  removeDir(agentDir);
+  if (originalAgentDir === undefined) delete Bun.env.PI_CODING_AGENT_DIR;
+  else Bun.env.PI_CODING_AGENT_DIR = originalAgentDir;
+  if (originalMock === undefined) delete Bun.env.MOCK;
+  else Bun.env.MOCK = originalMock;
+});
+
+function call(handler: Handler, request: Request): Promise<Response> {
+  return handler({ request, params: {} } as never) as Promise<Response>;
+}
+
+function send(verb: string, body?: unknown, query = ''): Request {
+  return new Request(`http://localhost/api/model-roles${query}`, {
+    method: verb,
+    ...(body === undefined ? {} : { body: JSON.stringify(body), headers: { 'content-type': 'application/json' } }),
+  });
+}
+
+describe('preset store', () => {
+  test('a preset round-trips its whole role map', async () => {
+    const saved = await saveModelRolePreset({
+      id: null,
+      name: 'cheap',
+      roles: { default: 'kenari/deepseek-v4-flash', tiny: 'local/gemma-3-1b' },
+    });
+    expect(saved.name).toBe('cheap');
+    expect(saved.roles).toEqual({ default: 'kenari/deepseek-v4-flash', tiny: 'local/gemma-3-1b' });
+    expect(await listModelRolePresets()).toEqual([saved]);
+  });
+
+  test('a duplicate name is refused with a sentence, case-insensitively', async () => {
+    await saveModelRolePreset({ id: null, name: 'Cheap', roles: { default: 'a/b' } });
+    await expect(saveModelRolePreset({ id: null, name: 'cheap', roles: { default: 'c/d' } }))
+      .rejects.toThrow('A preset named “cheap” already exists');
+  });
+
+  test('an update keeps created_at and moves updated_at', async () => {
+    const first = await saveModelRolePreset({ id: null, name: 'p', roles: { default: 'a/b' } });
+    const second = await saveModelRolePreset({ id: first.id, name: 'p2', roles: { default: 'c/d' } });
+    expect(second.id).toBe(first.id);
+    expect(second.name).toBe('p2');
+    expect(second.createdAt).toBe(first.createdAt);
+    expect(second.updatedAt).toBeGreaterThanOrEqual(first.updatedAt);
+  });
+
+  test('an empty selector is dropped and a custom role id survives', async () => {
+    const saved = await saveModelRolePreset({
+      id: null,
+      name: 'mixed',
+      roles: { default: 'a/b', tiny: '   ', 'my-role': 'x/y', 'bad role': 'z/z' },
+    });
+    expect(saved.roles).toEqual({ default: 'a/b', 'my-role': 'x/y' });
+  });
+
+  test('a preset with no usable role is refused', async () => {
+    await expect(saveModelRolePreset({ id: null, name: 'empty', roles: { default: '' } }))
+      .rejects.toThrow('A preset needs at least one role assigned');
+  });
+
+  test('a blank name is refused', async () => {
+    await expect(saveModelRolePreset({ id: null, name: '   ', roles: { default: 'a/b' } }))
+      .rejects.toThrow('Preset name is required');
+  });
+});
+
+describe('one-shot seed from the install’s current roles', () => {
+  test('an install with roles and no presets gets one preset named Default', async () => {
+    Bun.env.MOCK = 'false';
+    await seedPresetFromCurrentRoles({ default: 'kenari/deepseek-v4-flash', plan: 'kenari/deepseek-v4-pro' });
+    const presets = await listModelRolePresets();
+    expect(presets.length).toBe(1);
+    expect(presets[0].name).toBe(SEEDED_PRESET_NAME);
+    expect(presets[0].roles).toEqual({ default: 'kenari/deepseek-v4-flash', plan: 'kenari/deepseek-v4-pro' });
+  });
+
+  test('a deleted seed is NOT resurrected on the next read', async () => {
+    Bun.env.MOCK = 'false';
+    await seedPresetFromCurrentRoles({ default: 'a/b' });
+    const [seeded] = await listModelRolePresets();
+    await deleteModelRolePreset(seeded.id);
+
+    await seedPresetFromCurrentRoles({ default: 'a/b' });
+    expect(await listModelRolePresets()).toEqual([]);
+  });
+
+  test('a table that already holds a preset is left alone', async () => {
+    Bun.env.MOCK = 'false';
+    await saveModelRolePreset({ id: null, name: 'mine', roles: { default: 'x/y' } });
+    await seedPresetFromCurrentRoles({ default: 'a/b' });
+    expect((await listModelRolePresets()).map((preset) => preset.name)).toEqual(['mine']);
+  });
+
+  test('a map with no roles seeds nothing but still spends the run', async () => {
+    Bun.env.MOCK = 'false';
+    await seedPresetFromCurrentRoles({});
+    expect(await listModelRolePresets()).toEqual([]);
+    // The run is spent: a later non-empty map does not seed retroactively.
+    await seedPresetFromCurrentRoles({ default: 'a/b' });
+    expect(await listModelRolePresets()).toEqual([]);
+  });
+
+  test('mock mode writes no demo preset into the database', async () => {
+    Bun.env.MOCK = 'true';
+    await seedPresetFromCurrentRoles({ default: 'a/b' });
+    expect(await listModelRolePresets()).toEqual([]);
+  });
+});
+
+describe('model-roles route', () => {
+  test('GET answers roles, presets and candidates together', async () => {
+    const res = await call(loader, send('GET'));
+    const body = await res.json() as Record<string, unknown>;
+    expect(res.status).toBe(200);
+    expect(body.roles).toEqual({});
+    expect(body.presets).toEqual([]);
+    // Mock mode answers the demo catalog — never a spawn, never a network read.
+    expect(Array.isArray(body.candidates)).toBe(true);
+    expect((body.candidates as unknown[]).length).toBeGreaterThan(0);
+  });
+
+  test('POST saves a preset and answers the whole list', async () => {
+    const res = await call(action, send('POST', { preset: { name: 'fast', roles: { default: 'a/b' } } }));
+    const body = await res.json() as { success: boolean; preset: { id: string }; presets: unknown[] };
+    expect(res.status).toBe(200);
+    expect(body.success).toBe(true);
+    expect(body.presets.length).toBe(1);
+  });
+
+  test('a duplicate name answers 400 with the refusal sentence', async () => {
+    await call(action, send('POST', { preset: { name: 'dup', roles: { default: 'a/b' } } }));
+    const res = await call(action, send('POST', { preset: { name: 'dup', roles: { default: 'c/d' } } }));
+    const body = await res.json() as { error: string };
+    expect(res.status).toBe(400);
+    expect(body.error).toContain('already exists');
+  });
+
+  test('DELETE removes by id and 404s an unknown one', async () => {
+    const created = await call(action, send('POST', { preset: { name: 'gone', roles: { default: 'a/b' } } }));
+    const { preset } = await created.json() as { preset: { id: string } };
+    const removed = await call(action, send('DELETE', undefined, `?id=${preset.id}`));
+    expect(removed.status).toBe(200);
+    expect(await listModelRolePresets()).toEqual([]);
+
+    const missing = await call(action, send('DELETE', undefined, '?id=nope'));
+    expect(missing.status).toBe(404);
+  });
+
+  test('PUT writes the whole map through config.yml, dropping blank selectors', async () => {
+    const res = await call(action, send('PUT', { roles: { default: 'kenari/deepseek-v4-flash', tiny: '' } }));
+    const body = await res.json() as { success: boolean; roles: Record<string, string> };
+    expect(res.status).toBe(200);
+    expect(body.roles).toEqual({ default: 'kenari/deepseek-v4-flash' });
+
+    // Read back through the loader: the map really landed in the file.
+    const reloaded = await call(loader, send('GET'));
+    expect((await reloaded.json() as { roles: Record<string, string> }).roles)
+      .toEqual({ default: 'kenari/deepseek-v4-flash' });
+  });
+});