ompchamber 1.0.0 → 1.2.0

package/src/server/routes/models/root.ts

@@ -3,190 +3,28 @@ import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-
 import { getDb } from '@/server/db.server';
 import { INITIAL_MODELS_CATALOG } from '@/client/data/models/catalog';
 import { isMockMode } from '@/server/mock.server';
-import type { AIModelOption, ModelEntry, ModelsData, ProviderItem } from '@/shared/types';
+import type { AIModelOption, ModelsData, ProviderItem } from '@/shared/types';
 import { readSettingsJson, writeSettingsJson } from '@/server/lib/db/settings-store';
-import { runUtilityCommand, type OmpModel } from '@/server/lib/omp/rpc/utility';
-import { readDisabledProviders } from '@/server/lib/omp/config/roles';
-import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+import { modelKey } from '@/shared/lib/models/identity';
+import {
+  EMPTY_MODELS,
+  SAFE_MODEL_LOAD_FAILURE_MESSAGE,
+  invalidateModelsCache,
+  loadModelsWithCache,
+  readStoredProvidersForModels,
+} from '@/server/lib/models/registry.server';
+import {
+  readModelPreferencesFor,
+  recordRecentPreference,
+  toggleFavoritePreference,
+} from '@/server/lib/models/preferences.server';
 
 const MODELS_CATALOG_KEY = 'omp_models_catalog';
 const SELECTED_MODEL_KEY = 'omp_selected_model';
-const PROVIDERS_CONFIG_KEY = 'omp_providers_config';
 
-const MODELS_CACHE_TTL_MS = 60_000;
-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.
- */
-async function readStoredProvidersForModels(): Promise<ProviderItem[]> {
-  try {
-    const db = await getDb();
-    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_CONFIG_KEY, null);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter((provider): provider is ProviderItem => (
-      typeof provider === 'object' && provider !== null
-      && typeof (provider as ProviderItem).slug === 'string'
-      && (provider as ProviderItem).disabled === true
-    ));
-  } 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_CONFIG_KEY, null);
-    if (!Array.isArray(parsed)) return new Set();
-    const hidden = new Set<string>();
-    for (const provider of parsed) {
-      if (typeof provider?.slug !== 'string' || !Array.isArray(provider.models)) continue;
-      for (const model of provider.models) {
-        if (typeof model?.id === 'string' && model.isVisible === false) {
-          hidden.add(hiddenModelKey(provider.slug, model.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))
-  ));
-}
-
-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((model): model is OmpModel => (
-          typeof model === 'object' && model !== null
-          && typeof (model as OmpModel).id === 'string'
-          && typeof (model as OmpModel).provider === 'string'
-        ))
-        .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: ModelEntry[] = 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((provider): provider is { id: string; name: string; authenticated: boolean } => (
-      typeof provider === 'object' && provider !== null
-      && typeof (provider as { id?: unknown }).id === 'string'
-      && typeof (provider as { name?: unknown }).name === 'string'
-      && typeof (provider as { authenticated?: unknown }).authenticated === 'boolean'
-    ))
-    : [];
-  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 };
-}
-
-const EMPTY_MODELS: ModelsData = {
-  models: {},
-  modelList: [],
-  defaultModel: null,
-  thinkingLevels: {},
-};
-
-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;
-}
-
-function invalidateModelsCache(): void {
-  invalidateModelsCaches();
+/** Error text for a 500 envelope without leaking a non-Error throw as `undefined`. */
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
 }
 
 /** Parse a persisted { provider, modelId|id } reference without trusting the JSON shape. */
@@ -200,7 +38,7 @@ function readSelectedModelRef(value: unknown): { provider: string; modelId: stri
 }
 
 /** The user's persisted pick resolved against the live registry; null when stale or unparseable. */
-async function loadPersistedModelOption(modelList: ModelEntry[]): Promise<AIModelOption | null> {
+async function loadPersistedModelOption(modelList: ModelsData['modelList']): Promise<AIModelOption | null> {
   try {
     const db = await getDb();
     const selected = readSelectedModelRef(await readSettingsJson<unknown>(db, SELECTED_MODEL_KEY, null));
@@ -220,37 +58,44 @@ async function loadPersistedModelOption(modelList: ModelEntry[]): Promise<AIMode
   }
 }
 
-export async function loader({ request }: LoaderFunctionArgs) {
-  const mock = isMockMode();
+/**
+ * MOCK mode keeps the SQLite-backed demo catalog, but the favorite/recent
+ * rails come from the same preference store as real mode — the catalog's own
+ * `isFavorite`/`isRecent` flags are only its seed.
+ */
+async function loadMockModels() {
+  const db = await getDb();
+  const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
+  const stored: AIModelOption[] = Array.isArray(catalog) && catalog.length > 0 ? catalog : INITIAL_MODELS_CATALOG;
+  // Demo mode has no config.yml to read, so the disable flag lives on the
+  // stored provider overlay. Filtering here keeps the model picker honest
+  // in MOCK=true too — the settings page must be able to prove the switch.
+  const disabledSlugs = new Set(
+    (await readStoredProvidersForModels()).map((provider: ProviderItem) => provider.slug.trim().toLowerCase()),
+  );
+  const models = stored.filter((model) => !disabledSlugs.has(model.provider.trim().toLowerCase()));
+  const persisted = await readSettingsJson<AIModelOption | null>(db, SELECTED_MODEL_KEY, null);
+  // Every provider disabled ⇒ empty list and no selection; the composer must
+  // see that honestly instead of holding on to a hidden provider's model.
+  let selectedModel: AIModelOption | null = models[5] || models[0] || null;
+  if (persisted && persisted.id && persisted.provider) {
+    const match = models.find(m => m.id === persisted.id && m.provider === persisted.provider);
+    if (match) selectedModel = match;
+  }
+  return { models, selectedModel, modelPreferences: await readModelPreferencesFor(models), isMock: true };
+}
 
+export async function loader({ request }: LoaderFunctionArgs) {
   // MOCK mode keeps the SQLite-backed catalog (chamber demo behavior).
-  if (mock) {
+  if (isMockMode()) {
     try {
-      const db = await getDb();
-      const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
-      const stored: AIModelOption[] = Array.isArray(catalog) && catalog.length > 0 ? catalog : INITIAL_MODELS_CATALOG;
-      // Demo mode has no config.yml to read, so the disable flag lives on the
-      // stored provider overlay. Filtering here keeps the model picker honest
-      // in MOCK=true too — the settings page must be able to prove the switch.
-      const disabledSlugs = new Set(
-        (await readStoredProvidersForModels()).map((provider) => provider.slug.trim().toLowerCase()),
-      );
-      const models = stored.filter((model) => !disabledSlugs.has(model.provider.trim().toLowerCase()));
-      const persisted = await readSettingsJson<AIModelOption | null>(db, SELECTED_MODEL_KEY, null);
-      // Every provider disabled ⇒ empty list and no selection; the composer must
-      // see that honestly instead of holding on to a hidden provider's model.
-      let selectedModel: AIModelOption | null = models[5] || models[0] || null;
-      if (persisted && persisted.id && persisted.provider) {
-        const match = models.find(m => m.id === persisted.id && m.provider === persisted.provider);
-        if (match) selectedModel = match;
-      }
-      return json({ models, selectedModel, isMock: mock });
-    } catch (error: any) {
+      return json(await loadMockModels());
+    } catch (error: unknown) {
       return json({
-        error: error.message,
+        error: errorMessage(error),
         models: INITIAL_MODELS_CATALOG,
         selectedModel: INITIAL_MODELS_CATALOG[5] || INITIAL_MODELS_CATALOG[0] || null,
-        isMock: mock,
+        isMock: true,
       }, { status: 500 });
     }
   }
@@ -261,8 +106,13 @@ export async function loader({ request }: LoaderFunctionArgs) {
   void request;
   try {
     const data = await loadModelsWithCache();
-    // The selection changes independently of the 60s registry cache.
-    return json({ ...data, selectedModel: await loadPersistedModelOption(data.modelList) });
+    // The selection and the preferences change independently of the 60s
+    // registry cache, so both are read fresh on every request.
+    return json({
+      ...data,
+      selectedModel: await loadPersistedModelOption(data.modelList),
+      modelPreferences: await readModelPreferencesFor(data.modelList),
+    });
   } catch {
     return json({ ...EMPTY_MODELS, modelError: SAFE_MODEL_LOAD_FAILURE_MESSAGE });
   }
@@ -272,23 +122,42 @@ export async function action({ request }: ActionFunctionArgs) {
   try {
     const db = await getDb();
     const body = await request.json();
+    const mock = isMockMode();
 
     const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
     // The shipped demo catalog is MOCK-only: a real install starts from an empty
     // list, so a demo model can never be persisted into its stored catalog.
     let models: AIModelOption[] = Array.isArray(catalog)
       ? catalog
-      : (isMockMode() ? INITIAL_MODELS_CATALOG : []);
+      : (mock ? INITIAL_MODELS_CATALOG : []);
 
     const { actionType, modelId, provider, thinkingLevel, model, models: newModels } = body;
 
+    /**
+     * Composite keys the registry currently serves. Preference writes prune
+     * against it so a model that left models.yml — or whose provider was
+     * disconnected — cannot hold one of the five recent slots. Real mode reads
+     * the same 60s-cached registry the loader serves; MOCK uses its demo list.
+     */
+    const knownModelKeys = async (): Promise<Set<string>> => {
+      const live = mock ? models : (await loadModelsWithCache()).modelList;
+      return new Set(live.map((entry) => modelKey(entry)));
+    };
+
     // Model-scoped mutations must match provider + id: the registry serves the
     // same model id from several providers, so an id-only match rewrites the
     // first provider's entry instead of the one the user acted on.
     if (actionType === 'toggleFavorite' && modelId && provider) {
-      models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, isFavorite: !m.isFavorite } : m);
-      await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
-      return json({ success: true, models });
+      // Favorites live in the preference store, NOT in the model catalog: the
+      // catalog is a MOCK-only demo list that real mode never reads back, so a
+      // star written there vanished on the next render.
+      const preferences = await toggleFavoritePreference(modelKey({ provider, id: modelId }), await knownModelKeys());
+      // Keep the demo catalog's flag in step so MOCK mode's own views agree.
+      if (mock) {
+        models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, isFavorite: !m.isFavorite } : m);
+        await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
+      }
+      return json({ success: true, models, modelPreferences: preferences });
     }
 
     if (actionType === 'setThinking' && modelId && provider && thinkingLevel) {
@@ -308,8 +177,12 @@ export async function action({ request }: ActionFunctionArgs) {
       const parsedModel = readSelectedModelRef(model);
       if (parsedModel) {
         invalidateModelsCache();
-        // Live set_model against the current session is handled by the agent
-        // RPC bridge; here we only persist the selection for session spawn.
+        // "The user picked this model" is one event: recording the recent here
+        // keeps a second request from ever disagreeing with the selection.
+        await recordRecentPreference(
+          modelKey({ provider: parsedModel.provider, id: parsedModel.modelId }),
+          await knownModelKeys(),
+        );
       }
       return json({ success: true, selectedModel: model });
     }
@@ -326,7 +199,7 @@ export async function action({ request }: ActionFunctionArgs) {
     }
 
     return json({ error: 'Invalid action or parameters' }, { status: 400 });
-  } catch (error: any) {
-    return json({ error: error.message }, { status: 500 });
+  } catch (error: unknown) {
+    return json({ error: errorMessage(error) }, { status: 500 });
   }
 }

package/src/server/routes/settings/commands.ts

@@ -5,6 +5,7 @@ import { getDb } from '@/server/db.server';
 import { DEFAULT_COMMANDS_LIST } from '@/client/data/settings/command';
 import { isMockMode } from '@/server/mock.server';
 import type { CommandItem } from '@/shared/types';
+import { isRecord } from '@/shared/lib/util/guards';
 import { createSettingsListStore } from '@/server/lib/db/settings-store';
 import { runUtilityCommand } from '@/server/lib/omp/rpc/utility';
 
@@ -16,27 +17,67 @@ const commandsStore = createSettingsListStore<CommandItem>({
   plural: 'commands',
 });
 
-/** Read live agent commands (skill/custom/extension/file sources) via RPC. */
+/** Command sources the chamber surfaces in the composer (mcp_prompt is not user-typable). */
+const AGENT_COMMAND_SOURCES: Record<string, true> = {
+  builtin: true,
+  skill: true,
+  custom: true,
+  extension: true,
+  file: true,
+};
+
+/**
+ * Live slash commands from the agent's `get_available_commands`, mapped into
+ * the chamber's CommandItem. Aliases, subcommands and the argument hint ride
+ * along: they are what the composer's `/` popup needs to behave like omp's own
+ * editor (`/models` completing to the alias, `/fast ` offering on|off|status).
+ * Anything malformed is dropped rather than trusted.
+ */
+function toLiveCommandItem(value: unknown): CommandItem | null {
+  if (!isRecord(value)) return null;
+  const name = typeof value.name === 'string' ? value.name : '';
+  if (!name) return null;
+  if (typeof value.source !== 'string' || !AGENT_COMMAND_SOURCES[value.source]) return null;
+
+  const aliases = Array.isArray(value.aliases)
+    ? value.aliases.filter((alias): alias is string => typeof alias === 'string' && alias.length > 0)
+    : [];
+
+  const hint = isRecord(value.input) && typeof value.input.hint === 'string' ? value.input.hint : undefined;
+
+  const subcommands = Array.isArray(value.subcommands)
+    ? value.subcommands.flatMap((sub) => {
+        if (!isRecord(sub) || typeof sub.name !== 'string' || !sub.name) return [];
+        return [{
+          name: sub.name,
+          ...(typeof sub.description === 'string' ? { description: sub.description } : {}),
+          ...(typeof sub.usage === 'string' ? { usage: sub.usage } : {}),
+        }];
+      })
+    : [];
+
+  return {
+    id: `omp-live-${name}`,
+    name,
+    description: typeof value.description === 'string' ? value.description : '',
+    scope: 'user',
+    template: `/${name}`,
+    isBuiltIn: true,
+    ...(aliases.length ? { aliases } : {}),
+    ...(subcommands.length ? { subcommands } : {}),
+    ...(hint ? { inputHint: hint } : {}),
+  };
+}
+
+/** Read live agent commands (builtin/skill/custom/extension/file sources) via RPC. */
 async function loadAgentCommands(): Promise<CommandItem[]> {
   try {
     const data = await runUtilityCommand<{ commands?: unknown }>({ type: 'get_available_commands' }, 30_000);
-    const available = Array.isArray(data.commands) ? data.commands : [];
-    const agentSources = new Set(['builtin', 'skill', 'custom', 'extension', 'file']);
-    return available
-      .filter((c) => agentSources.has((c as { source?: string })?.source ?? ''))
-      .map((c) => {
-        const command = c as { name?: string; description?: string; source?: string };
-        const name = typeof command.name === 'string' ? command.name : '';
-        return {
-          id: `omp-live-${name}`,
-          name,
-          description: typeof command.description === 'string' ? command.description : '',
-          scope: 'user' as const,
-          template: `/${name}`,
-          isBuiltIn: true,
-        };
-      })
-      .filter((c) => c.name.length > 0);
+    if (!Array.isArray(data.commands)) return [];
+    return data.commands.flatMap((command) => {
+      const item = toLiveCommandItem(command);
+      return item ? [item] : [];
+    });
   } catch {
     return [];
   }

package/src/shared/lib/chat/attachments.test.ts

@@ -0,0 +1,208 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Attachment metadata across the two representations the composer handles.
+ *
+ * A LIVE attachment carries `file: File`; a REPLAYED one — out of the queue row
+ * or back out of committed history — does not, because `JSON.stringify(new
+ * File(…))` is `{}`. Every accessor and every assembly path must therefore work
+ * from the persisted display fields, which is what used to break: a queued or
+ * retried send read `a.file.name` and threw, and the image payload filter
+ * matched on a `data:` preview the composer never produces.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import type { Attachment } from '@/shared/types';
+import {
+  applyTextAttachmentBudget,
+  attachmentImage,
+  attachmentName,
+  attachmentSize,
+  attachmentType,
+  composeMessageWithTextAttachments,
+  isImageAttachment,
+  isTextAttachment,
+  looksLikeTextFile,
+  prepareQueuedAttachments,
+  readTextAttachments,
+} from '@/shared/lib/chat/attachments';
+
+function liveFile(name: string, body: string, type = ''): File {
+  return new File([body], name, { type });
+}
+
+function liveAttachment(overrides: Partial<Attachment> & { id: string }): Attachment {
+  return { preview: '', ...overrides };
+}
+
+/** What the queue row and committed history actually hold. */
+function replayed(attachments: Attachment[]): Attachment[] {
+  return JSON.parse(JSON.stringify(attachments)) as Attachment[];
+}
+
+describe('attachment metadata accessors', () => {
+  test('read a live file, and fall back to the persisted fields', () => {
+    const live = liveAttachment({ id: 'a', name: 'notes.md', type: 'text/markdown', size: 99, file: liveFile('notes.md', '# hi', 'text/markdown') });
+    expect(attachmentName(live)).toBe('notes.md');
+    expect(attachmentType(live)).toBe('text/markdown');
+    expect(attachmentSize(live)).toBe(4); // the live handle is authoritative
+
+    const replay = replayed([live])[0];
+    // `JSON.stringify` renders a File as an empty object — not as undefined —
+    // so the replay path must treat a truthiness check as unreliable and read
+    // the display fields first.
+    expect(replay.file as unknown).toEqual({});
+    expect(attachmentName(replay)).toBe('notes.md');
+    expect(attachmentType(replay)).toBe('text/markdown');
+    expect(attachmentSize(replay)).toBe(99);
+  });
+
+  test('never throw on an attachment with neither a file nor a name', () => {
+    const bare = { id: 'x', preview: '' } as Attachment;
+    expect(attachmentName(bare)).toBe('attachment');
+    expect(attachmentType(bare)).toBe('');
+    expect(attachmentSize(bare)).toBe(0);
+    expect(isTextAttachment(bare)).toBe(false);
+    expect(attachmentImage(bare)).toBeNull();
+  });
+});
+
+describe('text vs image classification', () => {
+  test('code files with no browser MIME type still inline', () => {
+    // `File.type` is empty for most source files, so the extension decides.
+    for (const name of ['script.py', 'app.tsx', 'query.sql', 'Dockerfile.json', 'data.yaml']) {
+      expect(isTextAttachment({ name, type: '', file: liveFile(name, 'x') })).toBe(true);
+    }
+  });
+
+  test('a browser-reported text MIME type is enough on its own', () => {
+    expect(isTextAttachment({ name: 'LICENSE', type: 'text/plain', file: liveFile('LICENSE', 'x', 'text/plain') })).toBe(true);
+    expect(isTextAttachment({ name: 'blob.bin', type: 'application/json', file: liveFile('blob.bin', '{}', 'application/json') })).toBe(true);
+  });
+
+  test('binaries and images never consume the inline budget', () => {
+    expect(isTextAttachment({ name: 'app.dmg', type: 'application/octet-stream', file: liveFile('app.dmg', 'x', 'application/octet-stream') })).toBe(false);
+    // An image whose name happens to look textual is still an image.
+    expect(isTextAttachment({ name: 'trap.md', type: 'image/png', file: liveFile('trap.md', 'x', 'image/png') })).toBe(false);
+    expect(isImageAttachment({ name: 'trap.md', type: 'image/png', file: liveFile('trap.md', 'x', 'image/png') })).toBe(true);
+  });
+});
+
+describe('image payloads', () => {
+  test('carry the omp ImageContent type and the persisted MIME type', () => {
+    const payload = attachmentImage({
+      type: 'image/png',
+      dataBase64: 'iVBORw0KGgo=',
+    });
+    expect(payload).toEqual({ type: 'image', data: 'iVBORw0KGgo=', mimeType: 'image/png' });
+  });
+
+  test('a replay with a blob preview still yields its payload', () => {
+    // The old server-side filter matched `preview.startsWith('data:image/')`
+    // and so found nothing: the composer's preview is a blob URL.
+    const [replay] = replayed([
+      liveAttachment({ id: 'i', name: 's.png', type: 'image/png', preview: 'blob:http://x/1', dataBase64: 'AAAA', file: liveFile('s.png', 'x', 'image/png') }),
+    ]);
+    expect(attachmentImage(replay)?.data).toBe('AAAA');
+  });
+
+  test('an unread image yields nothing rather than a blank payload', () => {
+    expect(attachmentImage({ type: 'image/png', dataBase64: '' })).toBeNull();
+    expect(attachmentImage({ type: 'image/png' })).toBeNull();
+  });
+});
+
+describe('text contents', () => {
+  test('are read from a live file, and from `content` on a replay', async () => {
+    const live = [liveAttachment({ id: 't', name: 'notes.md', type: 'text/markdown', file: liveFile('notes.md', '# hi', 'text/markdown') })];
+    expect((await readTextAttachments(live)).map((f) => f.content)).toEqual(['# hi']);
+
+    const replay = replayed(await prepareQueuedAttachments(live));
+    expect(replay[0].file).toBeUndefined();
+    expect(replay[0].content).toBe('# hi');
+    expect((await readTextAttachments(replay)).map((f) => f.content)).toEqual(['# hi']);
+  });
+
+  test('a replay without a persisted copy is flagged, not silently dropped', async () => {
+    // It used to be filtered out, which sent a prompt naming a file whose
+    // contents never arrived — with nothing in the UI to say so.
+    const files = await readTextAttachments([
+      { id: 't', name: 'notes.md', type: 'text/markdown', preview: '' },
+    ]);
+    expect(files.map((f) => ({ name: f.name, missing: f.missing, content: f.content }))).toEqual([
+      { name: 'notes.md', missing: true, content: '' },
+    ]);
+  });
+
+  test('carry their attachment id so the caller can map them back', async () => {
+    const files = await readTextAttachments([
+      { id: 'keep', name: 'a.md', type: 'text/markdown', preview: '', content: 'a' },
+      { id: 'drop', name: 'b.bin', type: 'application/octet-stream', preview: '', content: 'b' },
+    ]);
+    expect(files.map((f) => f.id)).toEqual(['keep']);
+  });
+
+  test('are fenced with a language that matches the file', () => {
+    const py = [{ name: 'script.py', mimeType: 'text/x-python', content: 'x=1', size: 3 }];
+    expect(composeMessageWithTextAttachments('go', py)).toContain('```python');
+  });
+});
+
+describe('inline budget', () => {
+  test('counts replayed attachments, so repeated drops stop at the cap', () => {
+    const existing = Array.from({ length: 10 }, (_, i) => ({ name: `f${i}.md`, type: 'text/markdown', size: 10, content: 'x' }));
+    const { accepted, skipped } = applyTextAttachmentBudget([liveFile('extra.md', 'x', 'text/markdown')], existing);
+    expect(accepted).toEqual([]);
+    expect(skipped.map((f) => f.name)).toEqual(['extra.md']);
+  });
+
+  test('lets an image through when the text budget is spent', () => {
+    const existing = Array.from({ length: 10 }, (_, i) => ({ name: `f${i}.md`, type: 'text/markdown', size: 10, content: 'x' }));
+    const { accepted, skipped } = applyTextAttachmentBudget([liveFile('shot.png', 'x', 'image/png')], existing);
+    expect(accepted.map((f) => f.name)).toEqual(['shot.png']);
+    expect(skipped).toEqual([]);
+  });
+});
+
+describe('content sniffing for unclassified files', () => {
+  test('a file whose name and MIME say nothing is recognised as text', async () => {
+    // A promised-file drag from another app arrives like this: real bytes, a
+    // generic name, no usable type. Deciding from metadata alone left it
+    // attached but never inlined.
+    expect(await looksLikeTextFile(liveFile('document', 'IMPORTANT\ncode: ABC'))).toBe(true);
+    expect(await looksLikeTextFile(liveFile('file', '# Title\n\nBody'))).toBe(true);
+  });
+
+  test('binary content is refused', async () => {
+    const png = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    expect(await looksLikeTextFile(new File([png], 'download'))).toBe(false);
+    // A NUL byte is decisive: no text encoding this app handles contains one.
+    expect(await looksLikeTextFile(new File([new Uint8Array([65, 66, 0, 67])], 'blob'))).toBe(false);
+  });
+
+  test('an empty file is not treated as text', async () => {
+    expect(await looksLikeTextFile(liveFile('empty', ''))).toBe(false);
+  });
+
+  test('a sniffed attachment keeps its content through the read path', async () => {
+    // The sniffer's verdict is recorded on the attachment at attach time, so the
+    // send path must honour it even though the name still says nothing — and a
+    // bare `content` string must NOT be enough to smuggle a binary through.
+    const sniffed: Attachment = {
+      id: 'x',
+      name: 'document',
+      type: '',
+      size: 20,
+      preview: '',
+      content: 'IMPORTANT\ncode: ABC',
+      sniffedText: true,
+    };
+    const read = await readTextAttachments([sniffed]);
+    expect(read.map((f) => ({ name: f.name, content: f.content }))).toEqual([
+      { name: 'document', content: 'IMPORTANT\ncode: ABC' },
+    ]);
+  });
+});