claude-code-rust 0.12.3 → 0.13.0

package/README.md

@@ -9,6 +9,10 @@ A native Rust terminal interface for Claude Code. Drop-in replacement for Anthro
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-green.svg)](https://nodejs.org/)
 
+<p align="center">
+  <img src="assets/banner.png" alt="Claude Code Rust running a Read tool call with syntax-highlighted output" width="900">
+</p>
+
 ## About
 
 Claude Code Rust replaces the stock Claude Code terminal interface with a native Rust binary built on [Ratatui](https://ratatui.rs/). It connects to the same Claude API through a local Agent SDK bridge. Core Claude Code functionality - tool calls, file editing, terminal commands, and permissions - works unchanged.
@@ -43,15 +47,17 @@ Full documentation is available at [srothgan.github.io/claude-code-rust](https:/
 
 ## Why
 
-The stock Claude Code TUI runs on Node.js with React Ink. This causes real problems:
+The stock Claude Code TUI runs on Node.js with React Ink, which renders by redrawing full frames over raw ANSI escape codes. This causes real, widely-reported problems:
 
-- **Memory**: 200-400MB baseline vs ~20-50MB for a native binary
-- **Startup**: 2-5 seconds vs under 100ms
-- **Scrollback**: Broken virtual scrolling that loses history
-- **Input latency**: Event queue delays on keystroke handling
-- **Copy/paste**: Custom implementation instead of native terminal support
+- **Flickering**: The whole view is redrawn on every status update, causing constant flicker — bad enough to crash editors' integrated terminals during long sessions
+- **CPU**: Sustained high CPU even when idle, and runaway loops that spawn multiple background processes
+- **Memory**: 200-400MB baseline (and climbing with conversation length) vs ~20-50MB for a native binary
+- **Resize**: Window resizing leaves duplicated frames in scrollback, loses lines when shrinking, and can garble the display
+- **Input latency**: Keystrokes echo with visible delay as context fills up, and noticeably worse on Windows
+- **Scrollback**: Hijacks the terminal's native scrollback, erasing history you can no longer scroll back to
+- **Paste**: Large pastes can flood stdout and freeze the terminal
 
-Claude Code Rust fixes all of these by compiling to a single native binary with direct terminal control via Crossterm.
+Claude Code Rust addresses these by compiling to a single native binary with diffed, direct terminal control via Crossterm and Ratatui — no full-frame redraws, no Node runtime overhead.
 
 ## Documentation
 

package/agent-sdk/dist/bridge/commands.js

@@ -95,6 +95,13 @@ function expectEffortLevel(record, key, context) {
     }
     return value;
 }
+function expectRewindRestoreMode(record, key, context) {
+    const value = expectString(record, key, context);
+    if (value === "both" || value === "conversation" || value === "code") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be one of both, conversation, code`);
+}
 function expectNonEmptyStringOrNull(record, key, context) {
     const value = record[key];
     if (value === null) {
@@ -281,6 +288,19 @@ export function parseCommandEnvelope(line) {
                     command: "get_context_usage",
                     session_id: expectString(raw, "session_id", "get_context_usage"),
                 };
+            case "get_rewind_targets":
+                return {
+                    command: "get_rewind_targets",
+                    session_id: expectString(raw, "session_id", "get_rewind_targets"),
+                };
+            case "rewind":
+                return {
+                    command: "rewind",
+                    session_id: expectString(raw, "session_id", "rewind"),
+                    target_user_message_id: expectString(raw, "target_user_message_id", "rewind"),
+                    restore_mode: expectRewindRestoreMode(raw, "restore_mode", "rewind"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "rewind"),
+                };
             case "reload_plugins":
                 return {
                     command: "reload_plugins",

package/agent-sdk/dist/bridge/events.js

@@ -6,7 +6,9 @@ import { resolveCurrentModel } from "./session_lifecycle.js";
 const SESSION_LIST_LIMIT = 50;
 let sessionListingDir;
 export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
-    return dir ? { dir, includeWorktrees: true, limit } : { limit };
+    return dir
+        ? { dir, includeProgrammatic: true, includeWorktrees: true, limit }
+        : { includeProgrammatic: true, limit };
 }
 export function setSessionListingDir(dir) {
     sessionListingDir = dir;
@@ -121,6 +123,7 @@ function buildConnectBridgeEvent(session, eventName) {
             available_models: session.availableModels,
             mode: session.mode ? buildModeState(session, session.mode) : null,
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+            ...(session.restoredInput !== undefined ? { restored_input: session.restoredInput } : {}),
         }
         : {
             event: "connected",
@@ -144,6 +147,7 @@ function logConnectEventEmission(session, eventName, requestId) {
             history_update_count: session.resumeUpdates?.length ?? 0,
             available_model_count: session.availableModels.length,
             stale_session_count: session.sessionsToCloseAfterConnect?.length ?? 0,
+            has_restored_input: session.restoredInput !== undefined,
         },
     });
 }
@@ -151,10 +155,15 @@ export function emitConnectEvent(session) {
     const bridgeEvent = buildConnectBridgeEvent(session, session.connectEvent);
     logConnectEventEmission(session, session.connectEvent, session.connectRequestId);
     writeEvent(bridgeEvent, session.connectRequestId);
+    if (session.pendingRewindResult) {
+        writeEvent({ ...session.pendingRewindResult, session_id: session.sessionId }, session.connectRequestId);
+        session.pendingRewindResult = undefined;
+    }
     session.connectRequestId = undefined;
     session.connected = true;
     session.authHintSent = false;
     session.resumeUpdates = undefined;
+    session.restoredInput = undefined;
     const staleSessions = session.sessionsToCloseAfterConnect;
     session.sessionsToCloseAfterConnect = undefined;
     if (!staleSessions || staleSessions.length === 0) {
@@ -180,7 +189,12 @@ export function emitSessionReplacedEvent(session, requestId) {
     const bridgeEvent = buildConnectBridgeEvent(session, "session_replaced");
     logConnectEventEmission(session, "session_replaced", requestId);
     writeEvent(bridgeEvent, requestId);
+    if (session.pendingRewindResult) {
+        writeEvent({ ...session.pendingRewindResult, session_id: session.sessionId }, requestId);
+        session.pendingRewindResult = undefined;
+    }
     session.resumeUpdates = undefined;
+    session.restoredInput = undefined;
     refreshSessionsList();
 }
 export async function emitSessionsList(requestId) {

package/agent-sdk/dist/bridge/logger.js

@@ -71,6 +71,10 @@ function commandSessionId(command) {
         case "question_response":
         case "elicitation_response":
         case "get_status_snapshot":
+        case "get_context_usage":
+        case "get_rewind_targets":
+        case "rewind":
+        case "reload_plugins":
         case "mcp_status":
         case "mcp_reconnect":
         case "mcp_toggle":
@@ -105,6 +109,8 @@ function commandToolCallId(command) {
         case "elicitation_response":
         case "get_status_snapshot":
         case "get_context_usage":
+        case "get_rewind_targets":
+        case "rewind":
         case "reload_plugins":
         case "mcp_status":
         case "mcp_reconnect":
@@ -141,6 +147,8 @@ function eventToolCallId(event) {
         case "sessions_listed":
         case "status_snapshot":
         case "context_usage":
+        case "rewind_targets":
+        case "rewind_result":
         case "mcp_snapshot":
             return undefined;
     }
@@ -183,6 +191,8 @@ function protocolEventLevel(event) {
         case "sessions_listed":
         case "status_snapshot":
         case "context_usage":
+        case "rewind_targets":
+        case "rewind_result":
         case "runtime_reload_completed":
         case "mcp_set_servers_result":
         case "mcp_snapshot":

package/agent-sdk/dist/bridge/mcp_metadata.js

@@ -48,6 +48,16 @@ function optionalTimeout(record, context) {
     }
     return value;
 }
+function optionalRequestTimeoutMs(record, context) {
+    const value = record.request_timeout_ms;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 1000) {
+        throw new Error(`${context}.request_timeout_ms must be an integer >= 1000`);
+    }
+    return value;
+}
 function optionalAlwaysLoad(record, context) {
     const value = record.always_load;
     if (value === undefined) {
@@ -98,6 +108,7 @@ export function parseMcpServerConfig(value, context) {
         throw new Error(`${context}.type must be a string`);
     }
     const timeout = optionalTimeout(record, context);
+    const requestTimeoutMs = optionalRequestTimeoutMs(record, context);
     const alwaysLoad = optionalAlwaysLoad(record, context);
     switch (type) {
         case "stdio": {
@@ -114,6 +125,7 @@ export function parseMcpServerConfig(value, context) {
                 ...(optionalStringArray(record, "args", context) ? { args: optionalStringArray(record, "args", context) } : {}),
                 ...(optionalStringMap(record, "env", context) ? { env: optionalStringMap(record, "env", context) } : {}),
                 ...(timeout === undefined ? {} : { timeout }),
+                ...(requestTimeoutMs === undefined ? {} : { request_timeout_ms: requestTimeoutMs }),
                 ...(alwaysLoad === undefined ? {} : { always_load: alwaysLoad }),
             };
         }
@@ -130,6 +142,7 @@ export function parseMcpServerConfig(value, context) {
                 ...(optionalStringMap(record, "headers", context) ? { headers: optionalStringMap(record, "headers", context) } : {}),
                 ...(tools === undefined ? {} : { tools }),
                 ...(timeout === undefined ? {} : { timeout }),
+                ...(requestTimeoutMs === undefined ? {} : { request_timeout_ms: requestTimeoutMs }),
                 ...(alwaysLoad === undefined ? {} : { always_load: alwaysLoad }),
             };
         }
@@ -148,6 +161,9 @@ function toSdkToolPolicies(tools) {
         ...(tool.org_max_permission === undefined ? {} : { org_max_permission: tool.org_max_permission }),
     }));
 }
+function sdkRequestTimeoutConfig(config) {
+    return config.request_timeout_ms === undefined ? {} : { requestTimeoutMs: config.request_timeout_ms };
+}
 export function bridgeMcpConfigToSdk(config) {
     switch (config.type) {
         case "stdio":
@@ -157,6 +173,7 @@ export function bridgeMcpConfigToSdk(config) {
                 ...(config.args ? { args: config.args } : {}),
                 ...(config.env ? { env: config.env } : {}),
                 ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...sdkRequestTimeoutConfig(config),
                 ...(config.always_load === undefined ? {} : { alwaysLoad: config.always_load }),
             };
         case "sse":
@@ -166,6 +183,7 @@ export function bridgeMcpConfigToSdk(config) {
                 ...(config.headers ? { headers: config.headers } : {}),
                 ...(config.tools ? { tools: toSdkToolPolicies(config.tools) } : {}),
                 ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...sdkRequestTimeoutConfig(config),
                 ...(config.always_load === undefined ? {} : { alwaysLoad: config.always_load }),
             };
         case "http":
@@ -175,6 +193,7 @@ export function bridgeMcpConfigToSdk(config) {
                 ...(config.headers ? { headers: config.headers } : {}),
                 ...(config.tools ? { tools: toSdkToolPolicies(config.tools) } : {}),
                 ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...sdkRequestTimeoutConfig(config),
                 ...(config.always_load === undefined ? {} : { alwaysLoad: config.always_load }),
             };
     }
@@ -250,6 +269,16 @@ export function mapMcpServerStatus(status) {
             : [],
     };
 }
+function sdkRequestTimeoutMs(config) {
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+        return undefined;
+    }
+    const raw = config;
+    const value = raw.requestTimeoutMs ?? raw.request_timeout_ms;
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value)
+        ? value
+        : undefined;
+}
 export function mapMcpServerStatusConfig(config) {
     switch (config.type) {
         case "stdio":
@@ -259,6 +288,7 @@ export function mapMcpServerStatusConfig(config) {
                 ...(Array.isArray(config.args) && config.args.length > 0 ? { args: config.args } : {}),
                 ...(config.env ? { env: config.env } : {}),
                 ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(sdkRequestTimeoutMs(config) === undefined ? {} : { request_timeout_ms: sdkRequestTimeoutMs(config) }),
                 ...(config.alwaysLoad === undefined ? {} : { always_load: config.alwaysLoad }),
             };
         case "sse": {
@@ -269,6 +299,7 @@ export function mapMcpServerStatusConfig(config) {
                 ...(config.headers ? { headers: config.headers } : {}),
                 ...(tools === undefined ? {} : { tools }),
                 ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(sdkRequestTimeoutMs(config) === undefined ? {} : { request_timeout_ms: sdkRequestTimeoutMs(config) }),
                 ...(config.alwaysLoad === undefined ? {} : { always_load: config.alwaysLoad }),
             };
         }
@@ -280,6 +311,7 @@ export function mapMcpServerStatusConfig(config) {
                 ...(config.headers ? { headers: config.headers } : {}),
                 ...(tools === undefined ? {} : { tools }),
                 ...(config.timeout === undefined ? {} : { timeout: config.timeout }),
+                ...(sdkRequestTimeoutMs(config) === undefined ? {} : { request_timeout_ms: sdkRequestTimeoutMs(config) }),
                 ...(config.alwaysLoad === undefined ? {} : { always_load: config.alwaysLoad }),
             };
         }
@@ -321,6 +353,7 @@ function mcpStatusConfigDiagnostics(config) {
             return {
                 config_type: "stdio",
                 ...(config.timeout === undefined ? {} : { timeout_ms: config.timeout }),
+                ...(config.request_timeout_ms === undefined ? {} : { request_timeout_ms: config.request_timeout_ms }),
                 ...(config.always_load === undefined ? {} : { always_load: config.always_load }),
                 configured_tool_policy_count: 0,
             };
@@ -329,6 +362,7 @@ function mcpStatusConfigDiagnostics(config) {
             return {
                 config_type: config.type,
                 ...(config.timeout === undefined ? {} : { timeout_ms: config.timeout }),
+                ...(config.request_timeout_ms === undefined ? {} : { request_timeout_ms: config.request_timeout_ms }),
                 ...(config.always_load === undefined ? {} : { always_load: config.always_load }),
                 configured_tool_policy_count: config.tools?.length ?? 0,
             };
@@ -359,6 +393,7 @@ export function summarizeMcpServersForDiagnostics(servers) {
             config_type: config.config_type,
             ...(server.scope ? { scope: server.scope } : {}),
             ...(config.timeout_ms === undefined ? {} : { timeout_ms: config.timeout_ms }),
+            ...(config.request_timeout_ms === undefined ? {} : { request_timeout_ms: config.request_timeout_ms }),
             ...(config.always_load === undefined ? {} : { always_load: config.always_load }),
             tool_count: server.tools.length,
             configured_tool_policy_count: config.configured_tool_policy_count,

package/agent-sdk/dist/bridge/message_handlers.js

@@ -90,6 +90,162 @@ function emitSystemNoticeUpdate(session, severity, message) {
     }
     emitSessionUpdate(session.sessionId, { type: "system_notice_update", severity, message: trimmed });
 }
+const MAX_INFORMATIONAL_DEDUP_KEYS = 256;
+function shouldEmitInformationalMessage(session, level, content, toolUseId) {
+    if (!toolUseId) {
+        return true;
+    }
+    const key = `${toolUseId}\u0000${level}\u0000${content}`;
+    if (session.informationalDedupKeys.has(key)) {
+        return false;
+    }
+    session.informationalDedupKeys.add(key);
+    while (session.informationalDedupKeys.size > MAX_INFORMATIONAL_DEDUP_KEYS) {
+        const first = session.informationalDedupKeys.values().next().value;
+        if (typeof first !== "string") {
+            break;
+        }
+        session.informationalDedupKeys.delete(first);
+    }
+    return true;
+}
+function handleInformationalSystemMessage(session, msg) {
+    const content = typeof msg.content === "string" ? msg.content.trim() : "";
+    if (!content) {
+        return;
+    }
+    const level = typeof msg.level === "string" ? msg.level : "info";
+    const toolUseId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
+    if (!shouldEmitInformationalMessage(session, level, content, toolUseId)) {
+        return;
+    }
+    switch (level) {
+        case "notice":
+            emitSystemNoticeUpdate(session, "info", content);
+            return;
+        case "suggestion":
+            emitSystemNoticeUpdate(session, "info", `Suggestion: ${content}`);
+            return;
+        case "warning":
+            emitSystemNoticeUpdate(session, "warning", content);
+            return;
+        case "info":
+            if (msg.prevent_continuation === true) {
+                emitSystemNoticeUpdate(session, "warning", content);
+            }
+            return;
+        default:
+            bridgeLogger.debug({
+                target: LOG_TARGETS.BRIDGE_SDK,
+                eventName: "sdk_informational_level_unhandled",
+                message: "SDK informational message ignored for unknown level",
+                outcome: "ignored",
+                sessionId: session.sessionId,
+                toolCallId: toolUseId || undefined,
+                fields: {
+                    informational_level: level,
+                },
+            });
+    }
+}
+function trimmedStringField(msg, field) {
+    const value = msg[field];
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function ensureSentencePunctuation(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function modelRefusalNoFallbackMessage(msg) {
+    const model = trimmedStringField(msg, "original_model") ?? "the selected model";
+    const base = `Could not continue with ${model}: model refused the request and no fallback model is configured.`;
+    const explanation = trimmedStringField(msg, "api_refusal_explanation");
+    const category = trimmedStringField(msg, "api_refusal_category");
+    const content = trimmedStringField(msg, "content");
+    const detail = explanation
+        ? `Reason: ${explanation}`
+        : category
+            ? `Refusal category: ${category}`
+            : content;
+    const detailSentence = detail ? ensureSentencePunctuation(detail) : "";
+    return detailSentence ? `${base} ${detailSentence}` : base;
+}
+function handleModelRefusalNoFallbackMessage(session, msg) {
+    const message = modelRefusalNoFallbackMessage(msg);
+    emitSystemNoticeUpdate(session, "warning", message);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "sdk_model_refusal_no_fallback_received",
+        message: "SDK model refusal without fallback received",
+        outcome: "success",
+        sessionId: session.sessionId,
+        requestId: trimmedStringField(msg, "request_id"),
+        fields: {
+            original_model: trimmedStringField(msg, "original_model"),
+            api_refusal_category: trimmedStringField(msg, "api_refusal_category"),
+            refused_user_message_uuid: trimmedStringField(msg, "refused_user_message_uuid"),
+            sdk_message_uuid: trimmedStringField(msg, "uuid"),
+            sdk_message_session_id: trimmedStringField(msg, "session_id"),
+            has_api_refusal_explanation: trimmedStringField(msg, "api_refusal_explanation") !== undefined,
+            has_content: trimmedStringField(msg, "content") !== undefined,
+        },
+    });
+}
+function workerShutdownMessage(reason) {
+    const trimmed = reason.trim();
+    return trimmed ? `Claude worker is shutting down: ${trimmed}` : "Claude worker is shutting down.";
+}
+function handleWorkerShuttingDownSystemMessage(session, msg) {
+    const reason = typeof msg.reason === "string" ? msg.reason.trim() : "";
+    if (!session.connected) {
+        bridgeLogger.debug({
+            target: LOG_TARGETS.BRIDGE_SDK,
+            eventName: "sdk_worker_shutdown_preconnect_ignored",
+            message: "SDK worker shutdown ignored before session connect",
+            outcome: "ignored",
+            sessionId: session.sessionId,
+            fields: {
+                reason: reason || undefined,
+            },
+        });
+        return;
+    }
+    session.pendingWorkerShutdown = { reason };
+}
+function cancelPendingWorkerShutdown(session) {
+    if (!session.pendingWorkerShutdown) {
+        return;
+    }
+    bridgeLogger.debug({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_worker_shutdown_cancelled",
+        message: "SDK worker shutdown ignored after later stream activity",
+        outcome: "ignored",
+        sessionId: session.sessionId,
+        fields: {
+            reason: session.pendingWorkerShutdown.reason || undefined,
+        },
+    });
+    session.pendingWorkerShutdown = undefined;
+}
+export function flushPendingWorkerShutdown(session) {
+    const pending = session.pendingWorkerShutdown;
+    if (!pending) {
+        return;
+    }
+    session.pendingWorkerShutdown = undefined;
+    if (!session.connected) {
+        return;
+    }
+    emitSystemNoticeUpdate(session, "warning", workerShutdownMessage(pending.reason));
+}
 function notificationSeverity(priority) {
     return priority === "high" || priority === "immediate" ? "warning" : "info";
 }
@@ -675,12 +831,19 @@ function terminalReasonFromValue(value) {
 export function handleSdkMessage(session, message) {
     const msg = message;
     const type = typeof msg.type === "string" ? msg.type : "";
+    const subtype = type === "system" && typeof msg.subtype === "string" ? msg.subtype : "";
+    if (subtype !== "worker_shutting_down") {
+        cancelPendingWorkerShutdown(session);
+    }
     logSdkMessageOrigin(session, msg);
     if (type === "system") {
-        const subtype = typeof msg.subtype === "string" ? msg.subtype : "";
         if (handleFallbackRetractionMessage(session, subtype, msg)) {
             return;
         }
+        if (subtype === "model_refusal_no_fallback") {
+            handleModelRefusalNoFallbackMessage(session, msg);
+            return;
+        }
         if (subtype === "commands_changed") {
             updateAvailableCommands(session, "commands_changed", mapSdkSlashCommands(msg.commands));
             return;
@@ -690,6 +853,14 @@ export function handleSdkMessage(session, message) {
             emitSystemNoticeUpdate(session, notificationSeverity(msg.priority), text);
             return;
         }
+        if (subtype === "informational") {
+            handleInformationalSystemMessage(session, msg);
+            return;
+        }
+        if (subtype === "worker_shutting_down") {
+            handleWorkerShuttingDownSystemMessage(session, msg);
+            return;
+        }
         if (subtype === "mirror_error") {
             const error = typeof msg.error === "string" ? msg.error : "";
             const key = asRecordOrNull(msg.key);

package/agent-sdk/dist/bridge/model_metadata.js

@@ -1,11 +1,6 @@
-const OPUS_MODEL_ALIAS = "opus";
+const DEFAULT_MODEL_ALIAS = "fable";
 const MAX_MODEL_VERSION_PARTS = 2;
 const RELEASE_BUILD_TOKEN = /^20\d{6}$/;
-function isUnavailableModelId(id) {
-    const normalized = id.trim().toLowerCase();
-    // TODO: Revisit only after a product decision if Anthropic restores Fable 5 access.
-    return normalized === "fable" || normalized.startsWith("claude-fable-5");
-}
 function isEffortLevel(value) {
     return (value === "low" ||
         value === "medium" ||
@@ -19,7 +14,7 @@ function normalizeModelKey(id) {
         return { original, family: "unknown", versionParts: [], variantParts: [], buildParts: [] };
     }
     const lower = original.toLowerCase();
-    const contextMatch = lower.match(/\[([^\]]+)\]$/);
+    const contextMatch = lower.match(/\[([^[\]]+)\]$/);
     const contextSuffix = contextMatch?.[1];
     const withoutContext = contextMatch ? lower.slice(0, contextMatch.index) : lower;
     const withoutPrefix = withoutContext.startsWith("claude-")
@@ -27,7 +22,10 @@ function normalizeModelKey(id) {
         : withoutContext;
     const parts = withoutPrefix.split("-").filter((part) => part.length > 0);
     const familyPart = parts[0] ?? "";
-    const family = familyPart === "opus" || familyPart === "sonnet" || familyPart === "haiku"
+    const family = familyPart === "fable" ||
+        familyPart === "opus" ||
+        familyPart === "sonnet" ||
+        familyPart === "haiku"
         ? familyPart
         : "unknown";
     const versionParts = [];
@@ -36,6 +34,10 @@ function normalizeModelKey(id) {
     if (family !== "unknown") {
         for (const part of parts.slice(1)) {
             if (/^\d+$/.test(part)) {
+                if (versionParts.length > 0 && RELEASE_BUILD_TOKEN.test(part)) {
+                    buildParts.push(part);
+                    continue;
+                }
                 if (versionParts.length < MAX_MODEL_VERSION_PARTS) {
                     const parsed = Number.parseInt(part, 10);
                     if (Number.isFinite(parsed)) {
@@ -120,11 +122,13 @@ function humanizeModelId(id) {
     if (normalized.family === "unknown") {
         return id;
     }
-    const familyLabel = normalized.family === "opus"
-        ? "Opus"
-        : normalized.family === "sonnet"
-            ? "Sonnet"
-            : "Haiku";
+    const familyLabel = normalized.family === "fable"
+        ? "Fable"
+        : normalized.family === "opus"
+            ? "Opus"
+            : normalized.family === "sonnet"
+                ? "Sonnet"
+                : "Haiku";
     const versionLabel = normalized.versionParts.length > 0 ? ` ${normalized.versionParts.join(".")}` : "";
     const contextLabel = normalized.contextSuffix?.toLowerCase() === "1m"
         ? " [1M]"
@@ -144,19 +148,23 @@ function currentModelIsAuthoritative(resolvedId, requestedId) {
     return true;
 }
 function resolveCatalogModel(availableModels, resolvedId, requestedId) {
-    const exactResolved = availableModels.find((entry) => entry.id === resolvedId);
+    const exactResolved = availableModels.find((entry) => entry.id === resolvedId || entry.resolved_model === resolvedId);
     if (exactResolved) {
         return exactResolved;
     }
     if (requestedId) {
-        const exactRequested = availableModels.find((entry) => entry.id === requestedId);
+        const exactRequested = availableModels.find((entry) => entry.id === requestedId || entry.resolved_model === requestedId);
         if (exactRequested &&
-            modelKeysAreCompatible(exactRequested.id, resolvedId) &&
+            (modelKeysAreCompatible(exactRequested.id, resolvedId) ||
+                (exactRequested.resolved_model !== undefined &&
+                    modelKeysAreCompatible(exactRequested.resolved_model, resolvedId))) &&
             !hasVariantSiblingConflict(availableModels, exactRequested.id, resolvedId)) {
             return exactRequested;
         }
     }
-    const compatible = availableModels.filter((entry) => modelKeysAreCompatible(entry.id, resolvedId) &&
+    const compatible = availableModels.filter((entry) => (modelKeysAreCompatible(entry.id, resolvedId) ||
+        (entry.resolved_model !== undefined &&
+            modelKeysAreCompatible(entry.resolved_model, resolvedId))) &&
         !hasVariantSiblingConflict(availableModels, entry.id, resolvedId));
     return compatible.length === 1 ? compatible[0] : undefined;
 }
@@ -168,12 +176,14 @@ export function mapAvailableModels(models) {
         .filter((entry) => {
         return (typeof entry?.value === "string" &&
             entry.value.trim().length > 0 &&
-            !isUnavailableModelId(entry.value) &&
             typeof entry.displayName === "string" &&
             entry.displayName.trim().length > 0);
     })
         .map((entry) => ({
         id: entry.value,
+        ...(typeof entry.resolvedModel === "string" && entry.resolvedModel.trim().length > 0
+            ? { resolved_model: entry.resolvedModel.trim() }
+            : {}),
         display_name: entry.displayName,
         supports_effort: entry.supportsEffort === true,
         supported_effort_levels: Array.isArray(entry.supportedEffortLevels)
@@ -198,9 +208,9 @@ export function resolveCurrentModel(session) {
     const resolvedId = session.resolvedRuntimeModelId?.trim() ||
         session.model.trim() ||
         requestedId ||
-        OPUS_MODEL_ALIAS;
+        DEFAULT_MODEL_ALIAS;
     const catalogModel = resolveCatalogModel(session.availableModels, resolvedId, requestedId);
-    const runtimeDisplayId = resolvedId || requestedId || OPUS_MODEL_ALIAS;
+    const runtimeDisplayId = resolvedId || requestedId || DEFAULT_MODEL_ALIAS;
     const displayNameShort = shortDisplayNameForModelId(runtimeDisplayId);
     const displayNameLong = catalogModel?.display_name ?? humanizeModelId(runtimeDisplayId);
     return {