remote-codex 0.11.25 → 0.11.27

package/packages/claude/src/runtimeAdapter.ts

@@ -45,10 +45,12 @@ import {
   hiddenInitPrompt,
   isHiddenContinuationMessage,
   isHiddenInitMessage,
+  limitErrorFromHistoryItems,
   partialReasoningDelta,
   partialTextDelta,
   resultForToolUse,
   suppressedClaudeToolUseIds,
+  taskNotificationToolResult,
   toolUseFromPartialStart,
   toolUseToHistoryItem,
   toolResultBlocks,
@@ -748,6 +750,14 @@ function queryResultError(message: SDKMessage): string | null {
   return message.errors?.join('\n') || message.stop_reason || 'Claude turn failed.';
 }
 
+function statusForHistoricalItems(items: AgentHistoryItem[]) {
+  const limitError = limitErrorFromHistoryItems(items);
+  return {
+    status: limitError ? ('failed' as const) : ('completed' as const),
+    error: limitError,
+  };
+}
+
 function assistantMessagePayload(message: SDKMessage) {
   return message.type === 'assistant' ? message.message : null;
 }
@@ -863,6 +873,10 @@ function streamMessageId(event: unknown) {
   return messageIdFromPayload(message);
 }
 
+function sessionMessageTimestamp(message: SessionMessage) {
+  return typeof message.uuid === 'string' ? isoFromUuidV7(message.uuid) : null;
+}
+
 function addOrUpdateItem(state: ActiveClaudeTurn, item: AgentHistoryItem) {
   if (!state.items.has(item.id)) {
     state.itemOrder.push(item.id);
@@ -876,6 +890,68 @@ function orderedItems(state: ActiveClaudeTurn) {
     .filter((item): item is AgentHistoryItem => Boolean(item));
 }
 
+function withHistoryItemCreatedAt<T extends AgentHistoryItem>(
+  item: T,
+  createdAt: string | null | undefined,
+): T {
+  if (item.createdAt || !createdAt) {
+    return item;
+  }
+  return { ...item, createdAt };
+}
+
+function latestReasoningItem(state: ActiveClaudeTurn) {
+  const lastItemId = state.itemOrder.at(-1);
+  const lastItem = lastItemId ? state.items.get(lastItemId) : null;
+  return lastItem?.kind === 'reasoning' ? lastItem : null;
+}
+
+function joinReasoningText(left: string, right: string) {
+  if (!left) {
+    return right;
+  }
+  if (!right) {
+    return left;
+  }
+  if (right.startsWith(left)) {
+    return right;
+  }
+  if (left.endsWith(right)) {
+    return left;
+  }
+  return `${left}\n\n${right}`;
+}
+
+function isRunningHistoryItemStatus(status: string | null | undefined) {
+  const normalized = status?.trim().toLowerCase();
+  return (
+    normalized === 'running' ||
+    normalized === 'pending' ||
+    normalized === 'in_progress' ||
+    normalized === 'in progress'
+  );
+}
+
+function finalizeTurnItems(
+  state: ActiveClaudeTurn,
+  status: AgentTurn['status'],
+  completedAt: string,
+) {
+  return orderedItems(state).map((item) => {
+    if (item.kind === 'userMessage') {
+      return item;
+    }
+    if (status === 'completed' && isRunningHistoryItemStatus(item.status)) {
+      return {
+        ...item,
+        status: 'completed',
+        createdAt: item.createdAt ?? completedAt,
+      };
+    }
+    return withHistoryItemCreatedAt(item, completedAt);
+  });
+}
+
 function stringFromRecord(value: Record<string, unknown>, key: string) {
   const raw = value[key];
   return typeof raw === 'string' && raw.trim() ? raw : null;
@@ -1235,7 +1311,15 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     const sessions = await this.withClaudeConfigEnv(() => this.listSessionsFn({} as ListSessionsOptions));
     return sessions.map((session) => {
       this.knownSessionIds.add(session.sessionId);
-      return sessionSummaryFromInfo(session);
+      const summary = sessionSummaryFromInfo(session);
+      const activeTurn = this.activeTurnForSession(summary.providerSessionId);
+      return activeTurn
+        ? {
+            ...summary,
+            status: 'running' as const,
+            updatedAt: summary.updatedAt ?? activeTurn.startedAt,
+          }
+        : summary;
     });
   }
 
@@ -1418,9 +1502,12 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         tools: { type: 'preset', preset: 'claude_code' },
       }),
     });
-    const userItem = userMessageToHistoryItem(`${providerTurnId}:user`, {
-      content: input.prompt,
-    });
+    const userItem = withHistoryItemCreatedAt(
+      userMessageToHistoryItem(`${providerTurnId}:user`, {
+        content: input.prompt,
+      }),
+      startedAt,
+    );
     const initialItems = input.hidden ? [] : [userItem];
     const state: ActiveClaudeTurn = {
       providerSessionId: input.providerSessionId,
@@ -1511,6 +1598,15 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     }
   }
 
+  private activeTurnForSession(providerSessionId: string) {
+    for (const state of this.activeTurns.values()) {
+      if (state.providerSessionId === providerSessionId && !state.completed) {
+        return state;
+      }
+    }
+    return null;
+  }
+
   private reconcileActiveTranscriptTurn(
     providerSessionId: string,
     turns: AgentTurn[],
@@ -1594,31 +1690,16 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
   private async consumeQuery(state: ActiveClaudeTurn) {
     const rawMessages: SDKMessage[] = [];
+    let terminalStatus: AgentTurn['status'] | null = null;
+    let terminalError: string | null = null;
     try {
       for await (const message of state.query) {
         rawMessages.push(message);
-        if (state.completed) {
-          continue;
-        }
         this.consumeMessage(state, message);
         const status = queryResultStatus(message);
         if (status) {
-          state.completed = true;
-          this.deleteActiveTurn(state);
-          this.emitUsage(state);
-          this.emitRuntimeEvent({
-            type: 'turn.completed',
-            provider: 'claude',
-            providerSessionId: state.providerSessionId,
-            turn: buildAgentTurn({
-              providerTurnId: state.providerTurnId,
-              startedAt: state.startedAt,
-              status: state.interrupted ? 'interrupted' : status,
-              error: queryResultError(message),
-              items: orderedItems(state),
-              rawTurn: rawMessages,
-            }),
-          });
+          terminalStatus = status;
+          terminalError = queryResultError(message);
         }
       }
 
@@ -1626,6 +1707,13 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         state.completed = true;
         this.deleteActiveTurn(state);
         this.emitUsage(state);
+        const completedAt = new Date().toISOString();
+        const limitError = limitErrorFromHistoryItems(orderedItems(state));
+        const status = state.interrupted
+          ? 'interrupted'
+          : limitError
+            ? 'failed'
+          : terminalStatus ?? 'completed';
         this.emitRuntimeEvent({
           type: 'turn.completed',
           provider: 'claude',
@@ -1633,8 +1721,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
           turn: buildAgentTurn({
             providerTurnId: state.providerTurnId,
             startedAt: state.startedAt,
-            status: state.interrupted ? 'interrupted' : 'completed',
-            items: orderedItems(state),
+            status,
+            error: limitError ?? terminalError,
+            items: finalizeTurnItems(state, status, completedAt),
             rawTurn: rawMessages,
           }),
         });
@@ -1656,6 +1745,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
   private consumeMessage(state: ActiveClaudeTurn, message: SDKMessage) {
     this.captureUsage(state, message);
+    const messageCreatedAt = new Date().toISOString();
 
     if (message.type === 'system' && message.subtype === 'init') {
       this.updateToolboxItemsFromSystemInit(message);
@@ -1677,8 +1767,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         event: message.event,
       });
       if (toolItem) {
-        addOrUpdateItem(state, toolItem);
-        this.emitItem(state, toolItem, 'item.started');
+        const nextItem = withHistoryItemCreatedAt(toolItem, messageCreatedAt);
+        addOrUpdateItem(state, nextItem);
+        this.emitItem(state, nextItem, 'item.started');
         return;
       }
 
@@ -1688,16 +1779,22 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       });
       if (reasoningItem) {
         const existing = state.items.get(reasoningItem.id);
-        const nextItem: AgentHistoryItem = existing?.kind === 'reasoning'
+        const previousReasoning = existing?.kind === 'reasoning'
+          ? existing
+          : latestReasoningItem(state);
+        const nextItem: AgentHistoryItem = previousReasoning
           ? {
-              ...existing,
-              text: `${existing.text}${reasoningItem.text}`,
-              status: reasoningItem.status ?? existing.status ?? null,
+              ...previousReasoning,
+              text:
+                previousReasoning.id === reasoningItem.id
+                  ? `${previousReasoning.text}${reasoningItem.text}`
+                  : joinReasoningText(previousReasoning.text, reasoningItem.text),
+              status: reasoningItem.status ?? previousReasoning.status ?? null,
             }
-          : reasoningItem;
+          : withHistoryItemCreatedAt(reasoningItem, messageCreatedAt);
         addOrUpdateItem(state, nextItem);
-        this.emitItem(state, nextItem, existing ? 'item.completed' : 'item.started', {
-          force: Boolean(existing),
+        this.emitItem(state, nextItem, previousReasoning ? 'item.completed' : 'item.started', {
+          force: Boolean(previousReasoning),
         });
         return;
       }
@@ -1715,6 +1812,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
             })
           : markTransientAgentHistoryItem({
               id: delta.itemId,
+              createdAt: messageCreatedAt,
               kind: 'agentMessage',
               text: delta.delta,
             });
@@ -1732,6 +1830,19 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     }
 
     if (message.type === 'user') {
+      const taskNotification = taskNotificationToolResult(message.message);
+      if (taskNotification && !state.suppressedToolUseIds.has(taskNotification.toolUseId)) {
+        const item = resultForToolUse({
+          toolUseId: taskNotification.toolUseId,
+          result: message.tool_use_result ?? taskNotification.result,
+          previous: state.items.get(taskNotification.toolUseId) ?? null,
+        });
+        const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+        addOrUpdateItem(state, nextItem);
+        this.emitItem(state, nextItem, 'item.completed');
+        return;
+      }
+
       const rawToolResults = toolResultBlocks(message.message);
       const toolResults = rawToolResults.filter(
         (toolResult) => !state.suppressedToolUseIds.has(toolResult.toolUseId),
@@ -1743,8 +1854,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
             result: message.tool_use_result ?? toolResult.result,
             previous: state.items.get(toolResult.toolUseId) ?? null,
           });
-          addOrUpdateItem(state, item);
-          this.emitItem(state, item, 'item.completed');
+          const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+          addOrUpdateItem(state, nextItem);
+          this.emitItem(state, nextItem, 'item.completed');
         }
         return;
       }
@@ -1776,12 +1888,13 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         messageId: assistantMessageId,
         message: payload,
       })) {
-        const existing = state.items.get(item.id);
-        addOrUpdateItem(state, item);
-        if (item.kind !== 'agentMessage' && !existing) {
-          this.emitItem(state, item, 'item.started');
-        } else if (item.kind !== 'agentMessage' && existing) {
-          this.emitItem(state, item, 'item.started', { force: true });
+        const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+        const existing = state.items.get(nextItem.id);
+        addOrUpdateItem(state, nextItem);
+        if (nextItem.kind !== 'agentMessage' && !existing) {
+          this.emitItem(state, nextItem, 'item.started');
+        } else if (nextItem.kind !== 'agentMessage' && existing) {
+          this.emitItem(state, nextItem, 'item.started', { force: true });
         }
       }
       return;
@@ -1796,8 +1909,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         result: message.tool_use_result ?? message.message,
         previous: state.items.get(message.parent_tool_use_id) ?? null,
       });
-      addOrUpdateItem(state, item);
-      this.emitItem(state, item, 'item.completed');
+      const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+      addOrUpdateItem(state, nextItem);
+      this.emitItem(state, nextItem, 'item.completed');
       return;
     }
 
@@ -1817,8 +1931,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
           status: 'running',
         });
         if (item) {
-          addOrUpdateItem(state, item);
-          this.emitItem(state, item, 'item.started');
+          const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+          addOrUpdateItem(state, nextItem);
+          this.emitItem(state, nextItem, 'item.started');
         } else {
           state.suppressedToolUseIds.add(toolUseId);
         }
@@ -1840,13 +1955,15 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
           }
         : {
             id: toolUseId,
+            createdAt: messageCreatedAt,
             kind: 'toolCall',
             text: `${message.tool_name} denied`,
             detailText: typeof message.message === 'string' ? message.message : null,
             status: 'denied',
           };
-      addOrUpdateItem(state, item);
-      this.emitItem(state, item, 'item.completed');
+      const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+      addOrUpdateItem(state, nextItem);
+      this.emitItem(state, nextItem, 'item.completed');
     }
   }
 
@@ -2076,6 +2193,18 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
           itemsById: new Map(),
         };
       }
+      const previous = current.items.at(-1);
+      if (item.kind === 'reasoning' && previous?.kind === 'reasoning') {
+        const merged = {
+          ...previous,
+          text: joinReasoningText(previous.text, item.text),
+          status: item.status ?? previous.status ?? null,
+        };
+        current.items[current.items.length - 1] = merged;
+        current.itemsById.set(previous.id, merged);
+        current.itemsById.set(item.id, merged);
+        return;
+      }
       const existingIndex = current.items.findIndex((entry) => entry.id === item.id);
       if (existingIndex >= 0) {
         current.items[existingIndex] = item;
@@ -2087,6 +2216,25 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
     for (const message of messages) {
       if (message.type === 'user') {
+        const taskNotification = taskNotificationToolResult(message.message);
+        if (taskNotification) {
+          if (suppressedToolUseIds.has(taskNotification.toolUseId)) {
+            continue;
+          }
+          const previous = current?.itemsById.get(taskNotification.toolUseId) ?? null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              resultForToolUse({
+                toolUseId: taskNotification.toolUseId,
+                result: message.tool_use_result ?? taskNotification.result,
+                previous,
+              }),
+              sessionMessageTimestamp(message) ?? current?.startedAt,
+            ),
+          );
+          continue;
+        }
+
         const rawToolResults = toolResultBlocks(message.message);
         const toolResults = rawToolResults.filter(
           (toolResult) => !suppressedToolUseIds.has(toolResult.toolUseId),
@@ -2094,11 +2242,16 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         if (toolResults.length > 0) {
           for (const toolResult of toolResults) {
             const previous = current?.itemsById.get(toolResult.toolUseId) ?? null;
-            upsertCurrentItem(resultForToolUse({
-              toolUseId: toolResult.toolUseId,
-              result: toolResult.result,
-              previous,
-            }));
+            upsertCurrentItem(
+              withHistoryItemCreatedAt(
+                resultForToolUse({
+                  toolUseId: toolResult.toolUseId,
+                  result: toolResult.result,
+                  previous,
+                }),
+                sessionMessageTimestamp(message) ?? current?.startedAt,
+              ),
+            );
           }
           continue;
         }
@@ -2118,24 +2271,28 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
         }
         skippingHiddenInit = false;
         if (current && current.items.length > 0) {
+          const outcome = statusForHistoricalItems(current.items);
           turns.push(buildAgentTurn({
             providerTurnId: current.providerTurnId,
             startedAt: current.startedAt,
-            status: 'completed',
+            status: outcome.status,
+            error: outcome.error,
             items: current.items,
           }));
         }
         const messageUuid = message.uuid ?? randomUUID();
+        const userStartedAt = isoFromUuidV7(messageUuid);
         const userItem = await this.userMessageToHistoryItem(
           messageUuid,
           message.message,
           context,
         );
+        const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
           providerTurnId: `claude-turn-${messageUuid}`,
-          startedAt: isoFromUuidV7(messageUuid),
-          items: [userItem],
-          itemsById: new Map([[messageUuid, userItem]]),
+          startedAt: userStartedAt,
+          items: [stampedUserItem],
+          itemsById: new Map([[messageUuid, stampedUserItem]]),
         };
         continue;
       }
@@ -2145,6 +2302,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       }
 
       if (message.type === 'assistant') {
+        const assistantCreatedAt = sessionMessageTimestamp(message) ?? current?.startedAt;
         for (const toolUseId of suppressedClaudeToolUseIds(message.message)) {
           suppressedToolUseIds.add(toolUseId);
           current?.itemsById.delete(toolUseId);
@@ -2153,7 +2311,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
           messageId: message.uuid ?? randomUUID(),
           message: message.message,
         })) {
-          upsertCurrentItem(item);
+          upsertCurrentItem(withHistoryItemCreatedAt(item, assistantCreatedAt));
         }
         continue;
       }
@@ -2163,21 +2321,28 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
           continue;
         }
         const previous = current?.itemsById.get(message.parent_tool_use_id) ?? null;
-        upsertCurrentItem(resultForToolUse({
-          toolUseId: message.parent_tool_use_id,
-          result: isRecord(message.message) && 'content' in message.message
-            ? message.message.content
-            : message.message,
-          previous,
-        }));
+        upsertCurrentItem(
+          withHistoryItemCreatedAt(
+            resultForToolUse({
+              toolUseId: message.parent_tool_use_id,
+              result: isRecord(message.message) && 'content' in message.message
+                ? message.message.content
+                : message.message,
+              previous,
+            }),
+            sessionMessageTimestamp(message) ?? current?.startedAt,
+          ),
+        );
       }
     }
 
     if (current && current.items.length > 0) {
+      const outcome = statusForHistoricalItems(current.items);
       turns.push(buildAgentTurn({
         providerTurnId: current.providerTurnId,
         startedAt: current.startedAt,
-        status: 'completed',
+        status: outcome.status,
+        error: outcome.error,
         items: current.items,
       }));
     }

package/packages/codex/src/historyItems.ts

@@ -509,6 +509,7 @@ export function shouldPersistLiveHistoryItem(item: ThreadHistoryItemDto) {
     item.kind === 'agentToolCall' ||
     item.kind === 'skillToolCall' ||
     item.kind === 'toolCall' ||
+    item.kind === 'reasoning' ||
     item.kind === 'webSearch'
   );
 }

package/packages/codex/src/modelPricing.test.ts

@@ -71,9 +71,9 @@ describe('modelPricing', () => {
     expect(estimate?.totalUsd).toBeCloseTo(0.125625, 10);
   });
 
-  it('prices Claude Sonnet and its 1M context option from the local pricing config', () => {
+  it('prices current Claude Sonnet aliases from the local pricing config', () => {
     expect(supportsFastMode('sonnet')).toBe(false);
-    expect(contextWindowForModel('sonnet')).toBe(200000);
+    expect(contextWindowForModel('sonnet')).toBe(1000000);
     expect(contextWindowForModel('sonnet[1m]')).toBe(1000000);
 
     const standardEstimate = estimateTurnPrice(sampleUsage, {
@@ -83,9 +83,9 @@ describe('modelPricing', () => {
     expect(standardEstimate).toMatchObject({
       pricingModelKey: 'sonnet',
       pricingTierKey: 'standard',
-      inputUsd: 0.003,
-      cachedInputUsd: 0.00015,
-      outputUsd: 0.0225,
+      inputUsd: 0.002,
+      cachedInputUsd: 0.0001,
+      outputUsd: 0.015,
     });
 
     const oneMillionEstimate = estimateTurnPrice(sampleUsage, {
@@ -95,22 +95,35 @@ describe('modelPricing', () => {
     expect(oneMillionEstimate).toMatchObject({
       pricingModelKey: 'sonnet[1m]',
       pricingTierKey: 'standard',
-      inputUsd: 0.006,
-      cachedInputUsd: 0.0003,
-      outputUsd: 0.03375,
+      inputUsd: 0.002,
+      cachedInputUsd: 0.0001,
+      outputUsd: 0.015,
     });
   });
 
-  it('prices current Claude Opus and Haiku aliases from the local pricing config', () => {
-    expect(contextWindowForModel('claude-opus-4-7')).toBe(200000);
+  it('prices current Claude Fable, Opus, and Haiku aliases from the local pricing config', () => {
+    expect(contextWindowForModel('fable')).toBe(1000000);
+    expect(contextWindowForModel('opus')).toBe(1000000);
     expect(contextWindowForModel('claude-haiku-4-5')).toBe(200000);
 
+    const fableEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'fable',
+      pricingTierKey: 'standard',
+    });
+    expect(fableEstimate).toMatchObject({
+      pricingModelKey: 'fable',
+      pricingTierKey: 'standard',
+      inputUsd: 0.01,
+      cachedInputUsd: 0.0005,
+      outputUsd: 0.075,
+    });
+
     const opusEstimate = estimateTurnPrice(sampleUsage, {
-      pricingModelKey: 'claude-opus-4-7',
+      pricingModelKey: 'opus',
       pricingTierKey: 'standard',
     });
     expect(opusEstimate).toMatchObject({
-      pricingModelKey: 'claude-opus-4-7',
+      pricingModelKey: 'opus',
       pricingTierKey: 'standard',
       inputUsd: 0.005,
       cachedInputUsd: 0.00025,
@@ -130,6 +143,51 @@ describe('modelPricing', () => {
     });
   });
 
+  it('prices explicit Claude API model ids, including fast Opus and legacy Opus', () => {
+    expect(contextWindowForModel('claude-sonnet-5')).toBe(1000000);
+    expect(contextWindowForModel('claude-sonnet-4-6')).toBe(1000000);
+    expect(contextWindowForModel('claude-opus-4-8')).toBe(1000000);
+    expect(supportsFastMode('claude-opus-4-8')).toBe(true);
+    expect(supportsFastMode('claude-opus-4-7')).toBe(true);
+    expect(contextWindowForModel('claude-opus-4-1')).toBe(200000);
+
+    const sonnet5Estimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'claude-sonnet-5',
+      pricingTierKey: 'standard',
+    });
+    expect(sonnet5Estimate).toMatchObject({
+      pricingModelKey: 'claude-sonnet-5',
+      pricingTierKey: 'standard',
+      inputUsd: 0.002,
+      cachedInputUsd: 0.0001,
+      outputUsd: 0.015,
+    });
+
+    const opusFastEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'claude-opus-4-8',
+      pricingTierKey: 'fast',
+    });
+    expect(opusFastEstimate).toMatchObject({
+      pricingModelKey: 'claude-opus-4-8',
+      pricingTierKey: 'fast',
+      inputUsd: 0.01,
+      cachedInputUsd: 0.0005,
+      outputUsd: 0.075,
+    });
+
+    const legacyOpusEstimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'claude-opus-4-1',
+      pricingTierKey: 'standard',
+    });
+    expect(legacyOpusEstimate).toMatchObject({
+      pricingModelKey: 'claude-opus-4-1',
+      pricingTierKey: 'standard',
+      inputUsd: 0.015,
+      cachedInputUsd: 0.00075,
+      outputUsd: 0.1125,
+    });
+  });
+
   it('normalizes Claude date-stamped runtime model names to local pricing keys', () => {
     expect(contextWindowForModel('claude-sonnet-4-5-20250929')).toBe(200000);
     expect(supportsFastMode('claude-sonnet-4-5-20250929')).toBe(false);