ompchamber 1.0.0 → 1.1.0

package/src/shared/lib/models/preferences.test.ts

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The preference rules are shared verbatim by the server (which persists the
+ * arrays) and the picker (which applies them optimistically), so these lock the
+ * behaviour both sides read back: composite keys, most-recent-first order, and
+ * the five-entry cap.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  EMPTY_MODEL_PREFERENCES,
+  RECENT_MODELS_LIMIT,
+  applyModelPreferences,
+  filterKnownKeys,
+  readModelPreferences,
+  recordRecentKey,
+  toggleFavoriteKey,
+} from '@/shared/lib/models/preferences';
+import type { AIModelOption } from '@/shared/types';
+
+describe('toggleFavoriteKey', () => {
+  test('adds an unknown key at the end and removes a known one', () => {
+    expect(toggleFavoriteKey(['a:1'], 'b:2')).toEqual(['a:1', 'b:2']);
+    expect(toggleFavoriteKey(['a:1', 'b:2'], 'a:1')).toEqual(['b:2']);
+  });
+
+  test('keys on provider + id, so the same id under another provider is a separate favorite', () => {
+    // The registry serves `deepseek-v4-pro` from both `deepseek` and `kenari`.
+    // An id-only list would unstar both rows when either is clicked.
+    const favorites = toggleFavoriteKey([], 'deepseek:deepseek-v4-pro');
+    expect(toggleFavoriteKey(favorites, 'kenari:deepseek-v4-pro')).toEqual([
+      'deepseek:deepseek-v4-pro',
+      'kenari:deepseek-v4-pro',
+    ]);
+  });
+});
+
+describe('recordRecentKey', () => {
+  test('moves a re-picked model to the front instead of duplicating it', () => {
+    expect(recordRecentKey(['a:1', 'b:2', 'c:3'], 'b:2')).toEqual(['b:2', 'a:1', 'c:3']);
+  });
+
+  test('caps the list at five, evicting the oldest entry', () => {
+    const full = ['a:1', 'b:2', 'c:3', 'd:4', 'e:5'];
+    const next = recordRecentKey(full, 'f:6');
+
+    expect(next).toHaveLength(RECENT_MODELS_LIMIT);
+    expect(next[0]).toBe('f:6');
+    expect(next).not.toContain('e:5');
+  });
+
+  test('re-picking inside a full list keeps the other four', () => {
+    const full = ['a:1', 'b:2', 'c:3', 'd:4', 'e:5'];
+    expect(recordRecentKey(full, 'c:3')).toEqual(['c:3', 'a:1', 'b:2', 'd:4', 'e:5']);
+  });
+});
+
+describe('readModelPreferences', () => {
+  test('reads a well-formed pair', () => {
+    expect(readModelPreferences({ favorites: ['a:1'], recentKeys: ['b:2'] }))
+      .toEqual({ favorites: ['a:1'], recentKeys: ['b:2'] });
+  });
+
+  test('drops non-string entries and caps an over-long recent list', () => {
+    const raw = {
+      favorites: ['a:1', 7, null, ''],
+      recentKeys: ['a:1', 'b:2', 'c:3', 'd:4', 'e:5', 'f:6', 'g:7'],
+    };
+
+    expect(readModelPreferences(raw)).toEqual({
+      favorites: ['a:1'],
+      recentKeys: ['a:1', 'b:2', 'c:3', 'd:4', 'e:5'],
+    });
+  });
+
+  test('an absent or malformed row yields empty rails', () => {
+    expect(readModelPreferences(null)).toEqual(EMPTY_MODEL_PREFERENCES);
+    expect(readModelPreferences('nonsense')).toEqual(EMPTY_MODEL_PREFERENCES);
+    expect(readModelPreferences({ favorites: 'not-a-list' })).toEqual(EMPTY_MODEL_PREFERENCES);
+  });
+});
+
+describe('filterKnownKeys', () => {
+  test('drops keys the registry no longer serves', () => {
+    // A model removed from models.yml, or every model of a disconnected
+    // provider, must not hold a slot in the five-entry rail.
+    const known = new Set(['a:1', 'c:3']);
+    expect(filterKnownKeys(['a:1', 'gone:9', 'c:3'], known)).toEqual(['a:1', 'c:3']);
+  });
+
+  test('pruning before a write frees the slot instead of merely hiding it', () => {
+    // The rail reads at most five entries. A stale key left in the stored array
+    // occupies one of them across every reload, so the user sees four models
+    // and the fifth pick appears to do nothing.
+    const stored = ['gone:9', 'a:1', 'b:2', 'c:3', 'd:4'];
+    const pruned = recordRecentKey(filterKnownKeys(stored, new Set(['a:1', 'b:2', 'c:3', 'd:4', 'e:5'])), 'e:5');
+
+    expect(pruned).toEqual(['e:5', 'a:1', 'b:2', 'c:3', 'd:4']);
+    expect(pruned).toHaveLength(RECENT_MODELS_LIMIT);
+  });
+});
+
+describe('applyModelPreferences', () => {
+  const rows: AIModelOption[] = [
+    { id: '1', name: 'One', provider: 'a' },
+    { id: '2', name: 'Two', provider: 'a', isFavorite: true },
+    { id: '3', name: 'Three', provider: 'b' },
+  ];
+
+  test('lights only the rows named by the stored key list', () => {
+    const applied = applyModelPreferences(rows, { favorites: ['b:3'], recentKeys: [] });
+
+    // Truthiness is the contract the star reads: a registry row has no
+    // `isFavorite` field at all, so `false` and `undefined` both mean "unlit".
+    expect(applied.map((m) => Boolean(m.isFavorite))).toEqual([false, false, true]);
+  });
+
+  test('leaves already-correct rows identical so only the changed row re-renders', () => {
+    const applied = applyModelPreferences(rows, { favorites: [], recentKeys: [] });
+
+    expect(applied[0]).toBe(rows[0]);
+    expect(applied[2]).toBe(rows[2]);
+    expect(applied[1]).not.toBe(rows[1]);
+    expect(applied[1].isFavorite).toBe(false);
+  });
+});

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

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Favorite + recent model preferences, keyed by the composite `provider:id`
+ * identity (`modelKey`). A model id alone is not unique — the omp registry
+ * serves the same id from several providers — so an id-keyed favorite list
+ * lights up every provider's row and records the wrong "recent".
+ *
+ * Pure list operations only: the server persists the arrays (one
+ * `app_settings` row) and the picker applies them optimistically, so both
+ * sides MUST agree on the ordering and the cap. Keeping the rules here is what
+ * makes them agree — a second copy in the route or the hook would drift.
+ */
+
+import type { AIModelOption, ModelPreferences } from '@/shared/types';
+import { modelKey } from '@/shared/lib/models/identity';
+
+/** How many last-used models the RECENT rail holds. */
+export const RECENT_MODELS_LIMIT = 5;
+
+/** Used before the first write, and when a payload carries no preferences. */
+export const EMPTY_MODEL_PREFERENCES: ModelPreferences = { favorites: [], recentKeys: [] };
+
+/** Add or remove one key; the relative order of the survivors is untouched. */
+export function toggleFavoriteKey(favorites: readonly string[], key: string): string[] {
+  return favorites.includes(key)
+    ? favorites.filter((entry) => entry !== key)
+    : [...favorites, key];
+}
+
+/**
+ * Move a key to the front of the recents, de-duplicated and capped. Re-picking
+ * a model must not leave a second copy behind — the rail would then show the
+ * same model twice and the cap would evict a genuinely older entry.
+ */
+export function recordRecentKey(
+  recentKeys: readonly string[],
+  key: string,
+  limit: number = RECENT_MODELS_LIMIT,
+): string[] {
+  return [key, ...recentKeys.filter((entry) => entry !== key)].slice(0, Math.max(1, limit));
+}
+
+/**
+ * Drop keys the live registry no longer offers — a model removed from
+ * models.yml, or every model of a provider the user disconnected. Without this
+ * a stale key holds one of the five recent slots forever, so a rail that looks
+ * empty is hiding real entries behind keys nothing can render.
+ */
+export function filterKnownKeys(keys: readonly string[], known: ReadonlySet<string>): string[] {
+  return keys.filter((key) => known.has(key));
+}
+
+/** Parse a persisted preferences row without trusting the JSON shape. */
+export function readModelPreferences(value: unknown): ModelPreferences {
+  const source = typeof value === 'object' && value !== null ? value as Record<string, unknown> : {};
+  const strings = (input: unknown): string[] =>
+    Array.isArray(input) ? input.filter((entry): entry is string => typeof entry === 'string' && entry.length > 0) : [];
+  return {
+    favorites: strings(source.favorites),
+    recentKeys: strings(source.recentKeys).slice(0, RECENT_MODELS_LIMIT),
+  };
+}
+
+/**
+ * Stamp the favorite flag onto a catalog list. The registry carries no
+ * favorites of its own — it is a read-only view of omp's config — so the picker
+ * learns which rows are starred from the preference store, never from the
+ * catalog's own `isFavorite` (that is MOCK seed data).
+ *
+ * The comparison is by truthiness, not identity: a registry row has no
+ * `isFavorite` field at all, so an `undefined !== false` test would rebuild
+ * every row on every load and re-render the whole panel. Rows whose star state
+ * already reads correctly are returned untouched.
+ */
+export function applyModelPreferences(
+  models: AIModelOption[],
+  preferences: ModelPreferences,
+): AIModelOption[] {
+  const favorites = new Set(preferences.favorites);
+  return models.map((model) => {
+    const isFavorite = favorites.has(modelKey(model));
+    return Boolean(model.isFavorite) === isFavorite ? model : { ...model, isFavorite };
+  });
+}

package/src/shared/lib/models/provider-models.ts

@@ -63,6 +63,14 @@ export function mergeProviderModels(
   return { merged: [...existing, ...added], added, addedCount: added.length };
 }
 
+/**
+ * Register newly added provider models on the chamber's catalog.
+ *
+ * `isFavorite` is deliberately NOT sent: the picker derives favorites from the
+ * stored preference keys, so a catalog flag would be a second, silently
+ * ignored source of truth for the FAVORITES rail. A new provider's models are
+ * starred by the user, not by this sync.
+ */
 export async function syncProviderModelsToCatalog(
   providerName: string,
   models: ProviderModel[],
@@ -81,7 +89,6 @@ export async function syncProviderModelsToCatalog(
               provider: providerName,
               contextWindow: model.contextWindow?.split(' ')[0] || '128K',
               thinkingLevel: 'Default',
-              isFavorite: true,
               capabilities: ['Tool calling', 'Reasoning'],
               inputFormats: ['text'],
               outputFormats: ['text'],

package/src/shared/lib/omp/subagent/label.test.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers the boundaries of the subagent label derivation: the Target-section
+ * scan (heading level, colon variant, section end) and the two identity shapes.
+ *
+ * These are the cases where the label is derived from prompt text the caller
+ * controls, so a wrong boundary silently renders template boilerplate or a
+ * section name where the assignment's headline belongs.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { assignmentTarget, subagentHeaderTitle, subagentRowLabel } from '@/shared/lib/omp/subagent/label';
+import type { SubagentInfo } from '@/shared/types/omp/subagent';
+
+/** Minimal roster entry — only the fields the label helpers read. */
+function makeSubagent(overrides: Partial<SubagentInfo> = {}): SubagentInfo {
+  return { id: 'Scout', agent: 'task', status: 'completed', index: 0, ...overrides };
+}
+
+describe('assignmentTarget', () => {
+  test('reads the headline under the task template Target section', () => {
+    const task = 'Complete assignment thoroughly:\n\n# Target\nCount .tsx files under src/.\n\n# Change\nNone.\n\n# Acceptance\nReport the integer.';
+    expect(assignmentTarget(task)).toBe('Count .tsx files under src/.');
+  });
+
+  test('stops at the next heading so Change prose never becomes the headline', () => {
+    const task = '# Target\nMap the panel data model.\n\n# Change\nDo the thing';
+    expect(assignmentTarget(task)).toBe('Map the panel data model.');
+  });
+
+  test('accepts any heading level and a trailing colon', () => {
+    expect(assignmentTarget('## Target:\nHeadline here')).toBe('Headline here');
+    expect(assignmentTarget('### Target\nHeadline here')).toBe('Headline here');
+  });
+
+  test('skips an empty Target section instead of promoting the next section', () => {
+    expect(assignmentTarget('# Target\n\n# Change\nDo the thing')).toBe('Do the thing');
+  });
+
+  test('falls back to the first prose line when no Target section exists', () => {
+    expect(assignmentTarget('Fix the sidebar expand bug')).toBe('Fix the sidebar expand bug');
+    expect(assignmentTarget('# Scope\nNot a target section')).toBe('Not a target section');
+  });
+
+  test('never returns the template lead-in or a bare heading', () => {
+    expect(assignmentTarget('Complete assignment thoroughly:')).toBeUndefined();
+    expect(assignmentTarget('# Target')).toBeUndefined();
+  });
+
+  test('returns undefined for absent or empty text', () => {
+    expect(assignmentTarget(undefined)).toBeUndefined();
+    expect(assignmentTarget('   \n\n  ')).toBeUndefined();
+  });
+});
+
+describe('subagentHeaderTitle', () => {
+  test('appends the model role recorded on a history entry', () => {
+    expect(subagentHeaderTitle(makeSubagent({ modelRole: 'smol' }))).toBe('Scout (task:smol)');
+  });
+
+  test('falls back to the role carried by a live progress frame', () => {
+    expect(subagentHeaderTitle(makeSubagent({ progress: { modelRole: 'task' } }))).toBe('Scout (task:task)');
+  });
+
+  test('omits the role when the run recorded none', () => {
+    expect(subagentHeaderTitle(makeSubagent())).toBe('Scout (task)');
+  });
+});
+
+describe('subagentRowLabel', () => {
+  test('appends the assignment headline to the identity', () => {
+    const subagent = makeSubagent({ task: 'Complete assignment thoroughly:\n\n# Target\nHeadline here.\n\n# Change\nx' });
+    expect(subagentRowLabel(subagent)).toBe('Scout (task): Headline here.');
+  });
+
+  test('reads the assignment field when the task template is absent', () => {
+    expect(subagentRowLabel(makeSubagent({ assignment: '# Target\nFrom the assignment field.' })))
+      .toBe('Scout (task): From the assignment field.');
+  });
+
+  test('falls back to the description, then to the bare identity', () => {
+    expect(subagentRowLabel(makeSubagent({ description: 'fallback description' }))).toBe('Scout (task): fallback description');
+    expect(subagentRowLabel(makeSubagent())).toBe('Scout (task)');
+  });
+
+  test('keeps the identity when the assignment has no usable headline', () => {
+    expect(subagentRowLabel(makeSubagent({ task: '# Target' }))).toBe('Scout (task)');
+  });
+});

package/src/shared/lib/omp/subagent/label.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * One-line labels for a subagent roster entry.
+ *
+ * A delegated assignment is a task prompt, not a sentence. The wire carries it
+ * twice: `assignment` is the document the caller wrote, and `task` is that same
+ * document wrapped by the task tool's template ("Complete assignment
+ * thoroughly:" followed by `# Target` / `# Change` / `# Acceptance` sections).
+ * Rendering either verbatim in a 268px sidebar row would spend the whole row on
+ * the template's lead-in, so a row shows the Target section's headline — the
+ * one line that says what the agent is for.
+ *
+ * The two surfaces differ only in what they append to the identity:
+ *   roster row  →  `id (agent): target`
+ *   banner      →  `id (agent:modelRole)`
+ */
+
+import type { SubagentInfo } from '@/shared/types/omp/subagent';
+
+/** Any markdown heading — the boundary between prompt sections. */
+const HEADING_RE = /^#{1,6}\s+\S/;
+/** The section the task prompt template mandates as the assignment's summary. */
+const TARGET_HEADING_RE = /^#{1,6}\s+target\s*:?\s*$/i;
+/** The task template's own lead-in; it says nothing about the assignment. */
+const LEAD_IN_RE = /^complete (the )?assignment\b/i;
+
+/** First line of `lines` that has content, trimmed. */
+function firstLine(lines: string[]): string | undefined {
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+/**
+ * The headline of a delegated assignment: the first line of its `# Target`
+ * section, falling back to the prompt's own first prose line when there is no
+ * such section (or it is empty).
+ */
+export function assignmentTarget(text: string | undefined): string | undefined {
+  if (!text) return undefined;
+  const lines = text.split('\n');
+  const headingAt = lines.findIndex((line) => TARGET_HEADING_RE.test(line.trim()));
+  if (headingAt !== -1) {
+    // Bounded by the next heading: an empty Target section must not promote the
+    // Change/Acceptance prose that follows it into the headline.
+    const body = lines.slice(headingAt + 1);
+    const nextHeading = body.findIndex((line) => HEADING_RE.test(line.trim()));
+    const headline = firstLine(nextHeading === -1 ? body : body.slice(0, nextHeading));
+    if (headline) return headline;
+  }
+  // No Target section, or an empty one: the prompt's first prose line. Headings
+  // are skipped because a section name is not a summary of the assignment.
+  return firstLine(lines.filter((line) => {
+    const trimmed = line.trim();
+    return !HEADING_RE.test(trimmed) && !LEAD_IN_RE.test(trimmed);
+  }));
+}
+
+/** `id (agent:modelRole)`, or `id (agent)` when no role was recorded. Live
+ *  snapshots carry the role on `progress`; history entries carry it top-level,
+ *  because the on-disk fold records it from the parent's task toolResult rather
+ *  than from a progress frame. */
+export function subagentHeaderTitle(subagent: SubagentInfo): string {
+  const role = subagent.modelRole ?? subagent.progress?.modelRole;
+  return role
+    ? `${subagent.id} (${subagent.agent}:${role})`
+    : `${subagent.id} (${subagent.agent})`;
+}
+
+/** `id (agent): target` — the roster row's one-line label. The description is
+ *  the fallback for entries whose assignment text never reached the roster. */
+export function subagentRowLabel(subagent: SubagentInfo): string {
+  const target = assignmentTarget(subagent.task)
+    ?? assignmentTarget(subagent.assignment)
+    ?? subagent.description;
+  const identity = `${subagent.id} (${subagent.agent})`;
+  return target ? `${identity}: ${target}` : identity;
+}

package/src/shared/lib/workspace/panel-widths.test.ts

@@ -5,37 +5,63 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { mergePanelWidths, normalizePanelWidths } from '@/shared/lib/workspace/panel-widths';
+import {
+  HANDLE_WIDTH,
+  MIN_CHAT_PANEL_WIDTH,
+  mergePanelWidths,
+  normalizePanelWidths,
+  resolvePanelWidth,
+} from '@/shared/lib/workspace/panel-widths';
 
 describe('normalizePanelWidths', () => {
   test('keeps every panel slot from a current blob', () => {
     const raw = {
       left: 342,
-      editor: 620,
-      diff: 900,
-      right: { files: 300, browser: 804 },
+      editor: { px: 620, fraction: 0.54 },
+      diff: { fraction: 0.6 },
+      right: { files: { px: 300, fraction: 0.26 }, browser: { px: 804 } },
     };
 
     expect(normalizePanelWidths(raw, 'files')).toEqual(raw);
   });
 
+  test('reads a bare number as the px-only shape and keeps it for conversion', () => {
+    // Blobs written before fractions existed: the pixel width must survive so
+    // the layout can convert it once the group's area is known.
+    const widths = normalizePanelWidths({ left: 342, editor: 620, right: { files: 300 } }, 'files');
+
+    expect(widths).toEqual({ left: 342, editor: { px: 620 }, right: { files: { px: 300 } } });
+  });
+
   test('adopts a legacy shared right width into the view that was open', () => {
     const widths = normalizePanelWidths({ left: 342, editor: 620, right: 1091 }, 'browser');
 
-    expect(widths.right).toEqual({ browser: 1091 });
+    expect(widths.right).toEqual({ browser: { px: 1091 } });
     expect(widths.left).toBe(342);
-    expect(widths.editor).toBe(620);
+    expect(widths.editor).toEqual({ px: 620 });
+  });
+
+  test('drops an out-of-range fraction instead of trusting it', () => {
+    // A fraction is a share of the area, so 0 and >1 are meaningless; the px
+    // fallback in the same slot survives, and a slot left with neither unit
+    // disappears rather than being kept as an empty object.
+    const widths = normalizePanelWidths(
+      { editor: { px: 620, fraction: 1.25 }, diff: { fraction: 0 }, right: { files: { fraction: -0.5 } } },
+      'files',
+    );
+
+    expect(widths).toEqual({ editor: { px: 620 } });
   });
 
   test('drops unusable entries instead of trusting the blob', () => {
     // `chat` is an obsolete slot — the chat column is the filler now — and a
     // blob written before that must not resurrect it.
     const widths = normalizePanelWidths(
-      { left: -10, chat: 700, editor: 620.4, diff: null, right: { files: 0, bogus: 300, git: 260 } },
+      { left: -10, chat: 700, editor: { px: 620.4 }, diff: null, right: { files: { px: 0 }, bogus: 300, git: { px: 260 } } },
       'files',
     );
 
-    expect(widths).toEqual({ editor: 620, right: { git: 260 } });
+    expect(widths).toEqual({ editor: { px: 620 }, right: { git: { px: 260 } } });
   });
 
   test('tolerates a missing or malformed blob', () => {
@@ -48,25 +74,94 @@ describe('mergePanelWidths', () => {
   test('merging one view keeps every other remembered width', () => {
     const stored = {
       left: 342,
-      editor: 620,
-      diff: 900,
-      right: { files: 300, git: 260 },
+      editor: { px: 620, fraction: 0.54 },
+      diff: { fraction: 0.6 },
+      right: { files: { px: 300, fraction: 0.26 }, git: { px: 260 } },
     };
 
-    const merged = mergePanelWidths(stored, { right: { browser: 804 } });
+    const merged = mergePanelWidths(stored, { right: { browser: { px: 804, fraction: 0.7 } } });
 
-    expect(merged.right).toEqual({ files: 300, git: 260, browser: 804 });
+    expect(merged.right).toEqual({
+      files: { px: 300, fraction: 0.26 },
+      git: { px: 260 },
+      browser: { px: 804, fraction: 0.7 },
+    });
     expect(merged.left).toBe(342);
-    expect(merged.editor).toBe(620);
-    expect(merged.diff).toBe(900);
+    expect(merged.editor).toEqual({ px: 620, fraction: 0.54 });
+    expect(merged.diff).toEqual({ fraction: 0.6 });
+  });
+
+  test('a patch adds a unit without discarding the one already stored', () => {
+    // A drag reports px + fraction together, but the conversion pass reports a
+    // fraction alone; it must not erase the px fallback it was derived from.
+    const merged = mergePanelWidths({ editor: { px: 620 } }, { editor: { fraction: 0.54 } });
+
+    expect(merged.editor).toEqual({ px: 620, fraction: 0.54 });
   });
 
   test('a resized panel replaces only its own slot', () => {
     const merged = mergePanelWidths(
-      { left: 300, editor: 620, diff: 900, right: { files: 300 } },
-      { editor: 480 },
+      { left: 300, editor: { px: 620 }, diff: { px: 900 }, right: { files: { px: 300 } } },
+      { editor: { px: 480, fraction: 0.4 } },
     );
 
-    expect(merged).toEqual({ left: 300, editor: 480, diff: 900, right: { files: 300 } });
+    expect(merged).toEqual({
+      left: 300,
+      editor: { px: 480, fraction: 0.4 },
+      diff: { px: 900 },
+      right: { files: { px: 300 } },
+    });
+  });
+});
+
+describe('resolvePanelWidth', () => {
+  const base = {
+    defaultFraction: 0.6,
+    defaultPx: 600,
+    min: 320,
+    siblingMin: 0,
+    handleCount: 0,
+  };
+
+  test('opens at its default share of the measured area', () => {
+    expect(resolvePanelWidth({ ...base, available: 1000 })).toBe(600);
+  });
+
+  test('falls back to the pixel width before the area is known', () => {
+    // Not zero: a panel whose area has not been measured yet must still render
+    // at the width it is supposed to open at.
+    expect(resolvePanelWidth({ ...base, available: null })).toBe(600);
+    expect(resolvePanelWidth({ ...base, available: null, stored: { px: 512 } })).toBe(512);
+  });
+
+  test('a px-only value holds its pixel width; only a fraction follows the area', () => {
+    // The conversion is an identity (`px / available * available`), which is
+    // the point: a pixel value someone chose is honoured as written rather than
+    // being rescaled behind their back. It stops following the window only
+    // until that slot is dragged once, which stores a fraction alongside it.
+    expect(resolvePanelWidth({ ...base, available: 1000, stored: { px: 480 } })).toBe(480);
+    expect(resolvePanelWidth({ ...base, available: 2000, stored: { px: 480 } })).toBe(480);
+    // With both units stored, the fraction is what the panel follows.
+    expect(resolvePanelWidth({ ...base, available: 2000, stored: { px: 480, fraction: 0.24 } })).toBe(480);
+    expect(resolvePanelWidth({ ...base, available: 2000, stored: { px: 480, fraction: 0.3 } })).toBe(600);
+  });
+
+  test('a stored fraction beats the default share', () => {
+    // 0.45 of 1000 is 450: above the 320 floor and below the 0.6 default, so
+    // the result can only come from the stored fraction.
+    expect(resolvePanelWidth({ ...base, available: 1000, stored: { px: 480, fraction: 0.45 } })).toBe(450);
+  });
+
+  test('the ceiling leaves the chat its floor, the siblings theirs, and the handles their width', () => {
+    const available = 2000;
+    const expected = available - MIN_CHAT_PANEL_WIDTH - 320 - 2 * HANDLE_WIDTH;
+
+    expect(resolvePanelWidth({ ...base, available, siblingMin: 320, handleCount: 2, stored: { fraction: 0.9 } })).toBe(expected);
+  });
+
+  test('the floor wins over a ceiling squeezed below it', () => {
+    // A window too narrow for the chat floor, a sibling and this panel: the
+    // panel keeps its minimum and the row clips, rather than collapsing.
+    expect(resolvePanelWidth({ ...base, available: 400, siblingMin: 320, handleCount: 2 })).toBe(320);
   });
 });