@cloudcli-ai/cloudcli 1.37.3 → 1.37.4

package/server/modules/providers/tests/claude-auth.test.ts

@@ -5,6 +5,7 @@ import path from 'node:path';
 import test from 'node:test';
 
 import { ClaudeProviderAuth } from '@/modules/providers/list/claude/claude-auth.provider.js';
+import type { ProviderAuthStatus, ProviderAuthSubscriptionOverride } from '@/shared/types.js';
 
 // checkCredentials() is private, but unlike getStatus() it never shells out to the
 // `claude` CLI — it only reads env vars and ~/.claude files. Calling it directly
@@ -15,11 +16,29 @@ type CheckCredentialsResult = {
   email: string | null;
   method: string | null;
   error?: string;
+  subscriptionOverride?: ProviderAuthSubscriptionOverride;
 };
 
 const checkCredentials = (auth: ClaudeProviderAuth): Promise<CheckCredentialsResult> =>
   (auth as unknown as { checkCredentials: () => Promise<CheckCredentialsResult> }).checkCredentials();
 
+// getStatus() is the public API the route serves, but it first shells out to
+// `claude --version`. Stubbing checkInstalled() lets the test cover the mapping
+// from checkCredentials() to the wire shape without the CLI.
+const getStatusWithCliInstalled = (auth: ClaudeProviderAuth): Promise<ProviderAuthStatus> => {
+  (auth as unknown as { checkInstalled: () => boolean }).checkInstalled = () => true;
+  return auth.getStatus();
+};
+
+const validSubscriptionCredentials = (email?: string) => ({
+  claudeAiOauth: {
+    accessToken: 'valid-token',
+    refreshToken: 'live-refresh-token',
+    expiresAt: Date.now() + 60 * 60 * 1000,
+  },
+  ...(email ? { email } : {}),
+});
+
 const ENV_KEYS = ['CLAUDE_CODE_OAUTH_TOKEN', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'] as const;
 
 const withEnv = async (
@@ -206,3 +225,134 @@ test('checkCredentials: ANTHROPIC_API_KEY takes precedence over CLAUDE_CODE_OAUT
     );
   });
 });
+
+// Issue #568: Claude Code silently prefers ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN
+// over the `claude /login` subscription, billing every request to the key. The
+// status must say so — and only when a usable login is really being bypassed.
+
+test('checkCredentials: ANTHROPIC_API_KEY in the process env alongside a valid subscription login reports the override', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, validSubscriptionCredentials('someone@example.com'));
+
+    await withEnv({ ANTHROPIC_API_KEY: 'test-api-key' }, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      // The existing fields are untouched: the key still wins and keeps its label.
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'api_key');
+      assert.equal(status.email, 'API Key Auth');
+      assert.deepEqual(status.subscriptionOverride, {
+        variable: 'ANTHROPIC_API_KEY',
+        source: 'process_env',
+        subscriptionEmail: 'someone@example.com',
+      });
+    });
+  });
+});
+
+test('checkCredentials: ANTHROPIC_AUTH_TOKEN in the process env alongside a valid subscription login names the auth token', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, validSubscriptionCredentials());
+
+    await withEnv({ ANTHROPIC_AUTH_TOKEN: 'test-auth-token', ANTHROPIC_API_KEY: 'test-api-key' }, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.method, 'api_key');
+      assert.equal(status.email, 'Auth Token');
+      assert.deepEqual(status.subscriptionOverride, {
+        variable: 'ANTHROPIC_AUTH_TOKEN',
+        source: 'process_env',
+        subscriptionEmail: null,
+      });
+    });
+  });
+});
+
+test('checkCredentials: ANTHROPIC_API_KEY in settings.json env alongside a valid subscription login points at settings.json', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeSettingsFile(homeDir, { ANTHROPIC_API_KEY: 'test-api-key-from-settings' });
+    await writeCredentialsFile(homeDir, validSubscriptionCredentials('someone@example.com'));
+
+    await withEnv({}, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.method, 'api_key');
+      assert.equal(status.email, 'API Key Auth');
+      assert.deepEqual(status.subscriptionOverride, {
+        variable: 'ANTHROPIC_API_KEY',
+        source: 'settings_file',
+        subscriptionEmail: 'someone@example.com',
+      });
+    });
+  });
+});
+
+test('checkCredentials: ANTHROPIC_API_KEY with no credentials file reports no override', async () => {
+  await withTempHome(async () => {
+    await withEnv({ ANTHROPIC_API_KEY: 'test-api-key' }, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'api_key');
+      assert.equal(status.subscriptionOverride, undefined);
+    });
+  });
+});
+
+test('checkCredentials: ANTHROPIC_API_KEY with an expired subscription login reports no override', async () => {
+  await withTempHome(async (homeDir) => {
+    // Nothing usable is being bypassed here, so warning would only confuse.
+    await writeCredentialsFile(homeDir, {
+      claudeAiOauth: {
+        accessToken: 'stale-token',
+        refreshToken: 'stale-refresh-token',
+        expiresAt: 1_000_000_000_000,
+        refreshTokenExpiresAt: 1_000_000_000_000,
+      },
+    });
+
+    await withEnv({ ANTHROPIC_API_KEY: 'test-api-key' }, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'api_key');
+      assert.equal(status.subscriptionOverride, undefined);
+    });
+  });
+});
+
+test('checkCredentials: a valid subscription login with no API key reports credentials_file and no override', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, validSubscriptionCredentials('someone@example.com'));
+
+    await withEnv({}, async () => {
+      const status = await checkCredentials(new ClaudeProviderAuth());
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'credentials_file');
+      assert.equal(status.email, 'someone@example.com');
+      assert.equal(status.subscriptionOverride, undefined);
+    });
+  });
+});
+
+test('getStatus: passes the subscription override through to the wire shape, and omits the key when there is none', async () => {
+  await withTempHome(async (homeDir) => {
+    await writeCredentialsFile(homeDir, validSubscriptionCredentials('someone@example.com'));
+
+    await withEnv({ ANTHROPIC_API_KEY: 'test-api-key' }, async () => {
+      const status = await getStatusWithCliInstalled(new ClaudeProviderAuth());
+      assert.equal(status.installed, true);
+      assert.equal(status.provider, 'claude');
+      assert.equal(status.authenticated, true);
+      assert.equal(status.method, 'api_key');
+      assert.equal(status.email, 'API Key Auth');
+      assert.deepEqual(status.subscriptionOverride, {
+        variable: 'ANTHROPIC_API_KEY',
+        source: 'process_env',
+        subscriptionEmail: 'someone@example.com',
+      });
+    });
+
+    await withEnv({}, async () => {
+      const status = await getStatusWithCliInstalled(new ClaudeProviderAuth());
+      assert.equal(status.method, 'credentials_file');
+      // Omitted, not null: existing JSON consumers see exactly the old payload.
+      assert.equal('subscriptionOverride' in status, false);
+    });
+  });
+});

package/server/modules/providers/tests/claude-background-work.test.ts

@@ -0,0 +1,213 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  createBackgroundWorkTracker,
+  startsBackgroundWork,
+} from '@/modules/providers/list/claude/claude-runtime.provider.js';
+
+// Only turns that start work outliving the turn hold their CLI process open. A
+// turn scored `false` here has its stdin released the moment `result` arrives,
+// and the CLI reads that EOF as print wind-down — so anything still running dies.
+const turn = (...blocks: Array<{ name: string; input?: Record<string, unknown> }>) => ({
+  type: 'assistant',
+  message: { content: blocks.map((block) => ({ type: 'tool_use', input: {}, ...block })) },
+});
+
+test('a backgrounded Bash holds the process open', () => {
+  assert.equal(startsBackgroundWork(turn({ name: 'Bash', input: { run_in_background: true } })), true);
+});
+
+test('a foreground Bash does not', () => {
+  assert.equal(startsBackgroundWork(turn({ name: 'Bash', input: { run_in_background: false } })), false);
+});
+
+test('a backgrounded Agent holds the process open', () => {
+  // The gap this suite exists for: a background agent used to be scored as
+  // nothing outstanding, so the CLI wound down and killed it mid-run.
+  assert.equal(startsBackgroundWork(turn({ name: 'Agent', input: { run_in_background: true } })), true);
+});
+
+test('an Agent with no run_in_background holds the process open', () => {
+  // `run_in_background` is optional on AgentInput and agents background by
+  // default, so an omitted field means background, not foreground.
+  assert.equal(startsBackgroundWork(turn({ name: 'Agent', input: { prompt: 'Investigate' } })), true);
+});
+
+test('a foreground Agent does not', () => {
+  // It never pushes a follow-up turn, so holding for it would pin the process
+  // for the full BG_WAIT_CEILING_MS.
+  assert.equal(startsBackgroundWork(turn({ name: 'Agent', input: { run_in_background: false } })), false);
+});
+
+test('a Workflow holds the process open', () => {
+  // WorkflowInput has no foreground option: every call returns a task id
+  // immediately and reports back in a later turn.
+  assert.equal(startsBackgroundWork(turn({ name: 'Workflow', input: { script: 'export const meta = {}' } })), true);
+});
+
+test('a deferred-work tool holds the process open', () => {
+  assert.equal(startsBackgroundWork(turn({ name: 'Monitor' })), true);
+});
+
+test('a turn that starts nothing lasting does not', () => {
+  assert.equal(startsBackgroundWork(turn({ name: 'Read' })), false);
+});
+
+test('one backgrounded agent among foreground calls is enough', () => {
+  assert.equal(
+    startsBackgroundWork(
+      turn(
+        { name: 'Read' },
+        { name: 'Agent', input: { run_in_background: false } },
+        { name: 'Agent', input: { run_in_background: true } },
+      ),
+    ),
+    true,
+  );
+});
+
+test('a message carrying no tool calls does not', () => {
+  assert.equal(startsBackgroundWork({ type: 'result', message: { content: 'done' } }), false);
+  assert.equal(startsBackgroundWork({ type: 'assistant', message: { content: [] } }), false);
+  assert.equal(startsBackgroundWork({}), false);
+});
+
+// Once the turn's `result` is out, the tracker below is the only record of
+// what the held process is still running: the running-sessions list reads it
+// and a stop request is refused unless it names one of its tasks. The event
+// shapes are the SDK's own, as a real query emits them.
+const started = (taskId: string, extra: Record<string, unknown> = {}) => ({
+  type: 'system',
+  subtype: 'task_started',
+  task_id: taskId,
+  tool_use_id: `toolu_${taskId}`,
+  description: `Task ${taskId}`,
+  task_type: 'local_agent',
+  ...extra,
+});
+const notified = (taskId: string, status: string) => ({
+  type: 'system', subtype: 'task_notification', task_id: taskId, tool_use_id: `toolu_${taskId}`, status, summary: '', output_file: '',
+});
+const updated = (taskId: string, patch: Record<string, unknown>) => ({
+  type: 'system', subtype: 'task_updated', task_id: taskId, patch,
+});
+
+test('a task_started with a tool_use_id adds the task under its session', () => {
+  const tracker = createBackgroundWorkTracker();
+  const before = Date.now();
+  // The session's own turn issued the call, so the task is its own work.
+  tracker.apply('s1', {
+    type: 'assistant',
+    parent_tool_use_id: null,
+    message: { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_t1', name: 'Workflow', input: {} }] },
+  });
+  tracker.apply('s1', started('t1', { task_type: 'local_workflow', workflow_name: 'spec' }));
+
+  const [entry] = tracker.list();
+  assert.equal(tracker.list().length, 1);
+  assert.equal(entry.sessionId, 's1');
+  assert.equal(entry.tasks.length, 1);
+  const { startedAt, ...task } = entry.tasks[0];
+  assert.deepEqual(task, {
+    taskId: 't1',
+    toolUseId: 'toolu_t1',
+    taskType: 'local_workflow',
+    description: 'Task t1',
+    workflowName: 'spec',
+  });
+  assert.ok(startedAt >= before && startedAt <= Date.now());
+  assert.equal(tracker.hasOutstanding('s1'), true);
+  assert.equal(tracker.has('s1', 't1'), true);
+});
+
+test('a task started for a call the session itself made is its own; one from inside an agent is nested', () => {
+  // Verified on a real run: a workflow agent that backgrounds `sleep 60` puts
+  // a `task_started` on the parent's stream, with a tool_use_id from the
+  // agent's transcript. The parent transcript has no card for it, and the
+  // pill would otherwise read "3 tasks" for one workflow.
+  const tracker = createBackgroundWorkTracker();
+  tracker.apply('s1', {
+    type: 'assistant',
+    parent_tool_use_id: null,
+    message: { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_t1', name: 'Workflow', input: {} }] },
+  });
+  tracker.apply('s1', started('t1', { task_type: 'local_workflow', workflow_name: 'spec' }));
+  tracker.apply('s1', started('t2', { task_type: 'local_bash', description: 'Sleep for 60 seconds' }));
+
+  const [entry] = tracker.list();
+  assert.deepEqual(entry.tasks.map((task) => [task.taskId, task.nested ?? false]), [['t1', false], ['t2', true]]);
+  assert.equal(tracker.has('s1', 't2'), true, 'a nested task can still be stopped');
+
+  // The set of own calls dies with the session, like the tasks.
+  tracker.clear('s1');
+  tracker.apply('s1', started('t1', { task_type: 'local_workflow' }));
+  assert.equal(tracker.list()[0].tasks[0].nested, true);
+});
+
+test('a task_started without a tool_use_id is not tracked', () => {
+  // Housekeeping tasks the CLI starts on its own have no launching call and
+  // nothing in the transcript to show them under.
+  const tracker = createBackgroundWorkTracker();
+  tracker.apply('s1', { type: 'system', subtype: 'task_started', task_id: 'ambient', description: 'x' });
+
+  assert.deepEqual(tracker.list(), []);
+  assert.equal(tracker.hasOutstanding('s1'), false);
+});
+
+test('a task_notification removes the task whatever its status', () => {
+  const tracker = createBackgroundWorkTracker();
+  tracker.apply('s1', started('t1'));
+  tracker.apply('s1', started('t2'));
+  tracker.apply('s1', notified('t1', 'completed'));
+
+  assert.equal(tracker.has('s1', 't1'), false);
+  assert.equal(tracker.has('s1', 't2'), true);
+  assert.equal(tracker.hasOutstanding('s1'), true);
+
+  tracker.apply('s1', notified('t2', 'stopped'));
+  assert.equal(tracker.hasOutstanding('s1'), false);
+  assert.deepEqual(tracker.list(), []);
+});
+
+test('a terminal task_updated removes the task', () => {
+  const tracker = createBackgroundWorkTracker();
+  for (const [taskId, status] of [['a', 'completed'], ['b', 'failed'], ['c', 'killed']]) {
+    tracker.apply('s1', started(taskId));
+    tracker.apply('s1', updated(taskId, { status, end_time: 1 }));
+    assert.equal(tracker.has('s1', taskId), false, `${status} settles the task`);
+  }
+  assert.equal(tracker.hasOutstanding('s1'), false);
+});
+
+test('a non-terminal task_updated keeps the task', () => {
+  const tracker = createBackgroundWorkTracker();
+  tracker.apply('s1', started('t1'));
+  tracker.apply('s1', updated('t1', { status: 'running' }));
+  tracker.apply('s1', updated('t1', { is_backgrounded: true }));
+  tracker.apply('s1', updated('t1', { status: 'paused' }));
+
+  assert.equal(tracker.has('s1', 't1'), true);
+  assert.equal(tracker.hasOutstanding('s1'), true);
+});
+
+test('clearing a session empties it and leaves the others alone', () => {
+  const tracker = createBackgroundWorkTracker();
+  tracker.apply('s1', started('t1'));
+  tracker.apply('s2', started('t2'));
+  tracker.clear('s1');
+
+  assert.equal(tracker.hasOutstanding('s1'), false);
+  assert.equal(tracker.has('s1', 't1'), false);
+  assert.deepEqual(tracker.list().map((entry) => entry.sessionId), ['s2']);
+});
+
+test('messages that are not task events leave the set untouched', () => {
+  const tracker = createBackgroundWorkTracker();
+  tracker.apply('s1', started('t1'));
+  tracker.apply('s1', { type: 'assistant', message: { content: [] } });
+  tracker.apply('s1', { type: 'system', subtype: 'task_progress', task_id: 't1', description: 'x', usage: {} });
+  tracker.apply('s1', { type: 'result', task_id: 't1' });
+
+  assert.equal(tracker.has('s1', 't1'), true);
+});

package/server/modules/providers/tests/claude-compaction.test.ts

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
+
+const provider = new ClaudeSessionsProvider();
+const SESSION_ID = 'claude-compaction-1';
+
+/**
+ * Both records that describe a compaction are `system` events, which normalized
+ * to nothing before this: the boundary carries the numbers, the status says one
+ * is running. Each becomes one ordinary assistant row, so a client that knows
+ * nothing of `compact` still reads the sentence.
+ */
+test('a compact boundary becomes one row carrying its numbers', () => {
+  const [row, ...rest] = provider.normalizeMessage({
+    type: 'system',
+    subtype: 'compact_boundary',
+    uuid: 'u-1',
+    timestamp: '2026-01-01T00:00:00.000Z',
+    compactMetadata: {
+      trigger: 'manual',
+      preTokens: 335_402,
+      postTokens: 10_120,
+      durationMs: 142_000,
+    },
+  }, SESSION_ID);
+
+  assert.equal(rest.length, 0);
+  assert.equal(row.kind, 'text');
+  assert.equal(row.role, 'assistant');
+  assert.equal(row.content, 'Compacted · manual · 335k → 10k tokens · 2m 22s');
+  assert.deepEqual(row.compact, {
+    phase: 'done',
+    trigger: 'manual',
+    preTokens: 335_402,
+    postTokens: 10_120,
+    durationMs: 142_000,
+  });
+});
+
+test('the live spelling of the metadata reads the same', () => {
+  const [row] = provider.normalizeMessage({
+    type: 'system',
+    subtype: 'compact_boundary',
+    compact_metadata: { trigger: 'auto', pre_tokens: 1_240_000, post_tokens: 18_000, duration_ms: 45_000 },
+  }, SESSION_ID);
+
+  assert.equal(row.content, 'Compacted · auto · 1.2M → 18k tokens · 45s');
+  assert.equal(row.compact?.trigger, 'auto');
+});
+
+test('a boundary with no metadata still says a compaction happened', () => {
+  const [row] = provider.normalizeMessage({
+    type: 'system',
+    subtype: 'compact_boundary',
+  }, SESSION_ID);
+
+  assert.equal(row.content, 'Compacted · auto');
+  assert.equal(row.compact?.phase, 'done');
+});
+
+test('a compacting status becomes a running row, and other statuses none', () => {
+  const [running] = provider.normalizeMessage({
+    type: 'system',
+    subtype: 'status',
+    status: 'compacting',
+  }, SESSION_ID);
+
+  assert.equal(running.content, 'Compacting conversation…');
+  assert.equal(running.compact?.phase, 'running');
+
+  assert.deepEqual(
+    provider.normalizeMessage({ type: 'system', subtype: 'status', status: 'requesting' }, SESSION_ID),
+    [],
+  );
+});
+
+test('a failed compaction says so, with the reason when there is one', () => {
+  const [failed] = provider.normalizeMessage({
+    type: 'system',
+    subtype: 'status',
+    compact_result: 'failed',
+    compact_error: 'context still too large',
+  }, SESSION_ID);
+
+  assert.equal(failed.content, 'Compaction failed: context still too large');
+  assert.equal(failed.compact?.phase, 'failed');
+  assert.equal(failed.compact?.error, 'context still too large');
+});
+
+test('the summary keeps its flag, so the client can fold it into the row', () => {
+  const [row] = provider.normalizeMessage({
+    type: 'user',
+    isCompactSummary: true,
+    message: { role: 'user', content: 'This session is being continued from a previous conversation.' },
+  }, SESSION_ID);
+
+  assert.equal(row.role, 'assistant');
+  assert.equal(row.isCompactSummary, true);
+});

package/server/modules/providers/tests/claude-message-model.test.ts

@@ -0,0 +1,160 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
+
+const SESSION_ID = 'claude-model-session';
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'claude-model-db-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+/**
+ * One assistant transcript row in the shape Claude Code writes it: the model
+ * that answered sits on `message.model`, beside the content parts.
+ */
+const assistantRow = (uuid: string, model: string | undefined, content: unknown) => ({
+  parentUuid: 'user-1',
+  isSidechain: false,
+  type: 'assistant',
+  uuid,
+  timestamp: '2026-07-10T00:00:01.000Z',
+  cwd: '/workspace/demo',
+  sessionId: SESSION_ID,
+  message: { role: 'assistant', ...(model === undefined ? {} : { model }), content },
+});
+
+test('an assistant reply carries the model that answered it', () => {
+  const messages = new ClaudeSessionsProvider().normalizeMessage(
+    assistantRow('asst-1', 'claude-opus-5', [
+      { type: 'thinking', thinking: 'weighing the options' },
+      { type: 'text', text: 'Here is the plan.' },
+      { type: 'tool_use', id: 'toolu_1', name: 'Read', input: { file_path: '/repo/a.ts' } },
+    ]),
+    SESSION_ID,
+  );
+
+  const prose = messages.find((message) => message.kind === 'text');
+  assert.equal(prose?.model, 'claude-opus-5');
+
+  // Only prose has a footer to show it in; a tool call and a reasoning block
+  // are drawn as cards, so stamping them would carry a model nothing renders.
+  assert.equal(messages.find((message) => message.kind === 'tool_use')?.model, undefined);
+  assert.equal(messages.find((message) => message.kind === 'thinking')?.model, undefined);
+});
+
+test('an assistant reply whose content is a bare string carries the model too', () => {
+  const [prose] = new ClaudeSessionsProvider().normalizeMessage(
+    assistantRow('asst-2', 'claude-haiku-4-5-20251001', 'Done.'),
+    SESSION_ID,
+  );
+
+  assert.equal(prose?.kind, 'text');
+  assert.equal(prose?.model, 'claude-haiku-4-5-20251001');
+});
+
+test('the reported model id is passed through verbatim, suffix and all', () => {
+  // Claude Code writes the base id on assistant rows today, even in 1M-context
+  // sessions. The normalizer must still never rewrite what the provider wrote:
+  // if a `[1m]` id ever appears, it has to reach the client as itself.
+  const [prose] = new ClaudeSessionsProvider().normalizeMessage(
+    assistantRow('asst-3', 'claude-opus-5[1m]', [{ type: 'text', text: 'Reading the whole repo.' }]),
+    SESSION_ID,
+  );
+
+  assert.equal(prose?.model, 'claude-opus-5[1m]');
+});
+
+test('a locally fabricated row reports no model at all', () => {
+  // Claude Code stamps rows it synthesized itself — the usage-limit notice, an
+  // API-error placeholder — with `<synthetic>`. No request ran, so there is no
+  // model to name, and a guessed one would be a lie about what was charged.
+  const [prose] = new ClaudeSessionsProvider().normalizeMessage(
+    assistantRow('asst-4', '<synthetic>', [{ type: 'text', text: 'Claude usage limit reached.' }]),
+    SESSION_ID,
+  );
+
+  assert.equal(prose?.kind, 'text');
+  assert.equal(prose?.model, undefined);
+});
+
+test('a user turn carries no model, because no transcript records one', () => {
+  const [turn] = new ClaudeSessionsProvider().normalizeMessage(
+    {
+      type: 'user',
+      uuid: 'user-1',
+      timestamp: '2026-07-10T00:00:00.000Z',
+      sessionId: SESSION_ID,
+      message: { role: 'user', content: 'Plan the refactor.' },
+    },
+    SESSION_ID,
+  );
+
+  assert.equal(turn?.role, 'user');
+  assert.equal(turn?.model, undefined);
+});
+
+test('Claude history replays the model of every assistant turn from the transcript', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'claude-model-history-'));
+
+  try {
+    const transcriptPath = path.join(tempRoot, `${SESSION_ID}.jsonl`);
+    await writeFile(
+      transcriptPath,
+      [
+        JSON.stringify({
+          parentUuid: null,
+          isSidechain: false,
+          type: 'user',
+          uuid: 'user-1',
+          timestamp: '2026-07-10T00:00:00.000Z',
+          cwd: '/workspace/demo',
+          sessionId: SESSION_ID,
+          message: { role: 'user', content: 'Plan the refactor.' },
+        }),
+        JSON.stringify(assistantRow('asst-1', 'claude-opus-5', [{ type: 'text', text: 'Here is the plan.' }])),
+        JSON.stringify(assistantRow('asst-2', '<synthetic>', [{ type: 'text', text: 'Claude usage limit reached.' }])),
+        '',
+      ].join('\n'),
+      'utf8',
+    );
+
+    await withIsolatedDatabase(async () => {
+      const now = new Date().toISOString();
+      sessionsDb.createSession(SESSION_ID, 'claude', tempRoot, 'Model session', now, now, transcriptPath);
+
+      const history = await new ClaudeSessionsProvider().fetchHistory(SESSION_ID, {
+        providerSessionId: SESSION_ID,
+      });
+
+      const replies = history.messages.filter((message) => message.kind === 'text' && message.role === 'assistant');
+      assert.equal(replies.length, 2);
+      assert.equal(replies[0]?.model, 'claude-opus-5');
+      assert.equal(replies[1]?.model, undefined);
+      assert.equal(history.messages.find((message) => message.role === 'user')?.model, undefined);
+    });
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});