claude-code-rust 0.9.0 → 0.11.0

package/README.md

@@ -25,11 +25,9 @@ Claude Code Rust replaces the stock Claude Code terminal interface with a native
 npm install -g claude-code-rust
 ```
 
-The published package installs a `claude-rs` command and fetches the matching
-prebuilt release binary for your platform during install.
+The published package installs a `claude-rs` command and fetches the matching prebuilt release binary for your platform during install.
 
-If `claude-rs` resolves to an older global shim, ensure your npm global bin
-directory comes first on `PATH` or remove the stale shim before retrying.
+If `claude-rs` resolves to an older global shim, ensure your npm global bin directory comes first on `PATH` or remove the stale shim before retrying.
 
 ## Usage
 
@@ -63,13 +61,22 @@ Three-layer design:
 
 This project is pre-1.0 and under active development. See [CONTRIBUTING.md](CONTRIBUTING.md) for how to get involved.
 
+## Limitations
+
+Startup is still constrained by the upstream Claude Agent SDK runtime that this TUI wraps. The Rust interface itself is fast, but end-to-end readiness can still take noticeable time before a session is fully available. Improving that remains an active area of work.
+
 ## License
 
-This project is licensed under the [Apache License 2.0](LICENSE).
-Apache-2.0 was chosen to keep usage and redistribution straightforward for individual users, downstream packagers, and commercial adopters.
+This project is licensed under the [Apache License 2.0](LICENSE). Apache-2.0 was chosen to keep usage and redistribution straightforward for individual users, downstream packagers, and commercial adopters.
+
+## Disclaimer and Legal Notice
+
+This project is not affiliated with, endorsed by, or supported by Anthropic.
+
+A quick note on where this project stands, since I know people worry about this kind of thing: claude-code-rust is a terminal UI that I wrote from scratch in Rust. It is not a fork, copy or port of the latest Claude Code source leak -- it talks to Anthropic's official [Agent SDK](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/agent-sdk) as a runtime dependency instead, the same way any other third-party tool would. No Anthropic source code was read or used as reference at any point during development.
+
+The project uses your existing Claude Code subscription via the Agent SDK and the Agent SDK's terms allow building on top of it. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
 
-## Disclaimer
+This project's source code is licensed under [Apache-2.0](LICENSE). The Agent SDK itself is proprietary and governed by [Anthropic's Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms).
 
-This project is an unofficial terminal UI for Claude Code and is not affiliated with, endorsed by, or supported by Anthropic.
-Use it at your own risk.
 For official Claude documentation, see [https://claude.ai/docs](https://claude.ai/docs).

package/agent-sdk/README.md

@@ -1,6 +1,6 @@
 # claude-rs agent-sdk bridge
 
-Initial scaffold for the NDJSON stdio bridge that will connect Rust (`claude-code-rust`) with `@anthropic-ai/claude-agent-sdk`.
+NDJSON stdio bridge that connects the Rust TUI (`claude-code-rust`) with `@anthropic-ai/claude-agent-sdk`. Spawned as a child process by the Rust binary and communicates via line-delimited JSON envelopes over stdin/stdout.
 
 ## Local build
 

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

@@ -1,5 +1,7 @@
+import { resolveCurrentModel } from "./session_lifecycle.js";
 const MODE_NAMES = {
     default: "Default",
+    auto: "Auto",
     acceptEdits: "Accept Edits",
     bypassPermissions: "Bypass Permissions",
     plan: "Plan",
@@ -7,11 +9,67 @@ const MODE_NAMES = {
 };
 const MODE_OPTIONS = [
     { id: "default", name: "Default", description: "Standard permission flow" },
+    { id: "auto", name: "Auto", description: "Model-classified permission approvals" },
     { id: "acceptEdits", name: "Accept Edits", description: "Auto-approve edit operations" },
     { id: "plan", name: "Plan", description: "No tool execution" },
     { id: "dontAsk", name: "Don't Ask", description: "Reject non-approved tools" },
     { id: "bypassPermissions", name: "Bypass Permissions", description: "Auto-approve all tools" },
 ];
+const BASE_SUPPORTED_MODE_IDS = [
+    "default",
+    "acceptEdits",
+    "plan",
+    "dontAsk",
+];
+function currentModelSupportsAutoMode(session) {
+    const currentModel = session.currentModel ?? resolveCurrentModel(session);
+    return currentModel.supports_auto_mode === true;
+}
+function modeInfoForId(mode) {
+    return MODE_OPTIONS.find((entry) => entry.id === mode) ?? {
+        id: mode,
+        name: MODE_NAMES[mode],
+    };
+}
+function uniqueModeIds(modeIds) {
+    const unique = new Set(modeIds);
+    const ordered = MODE_OPTIONS.map((entry) => entry.id).filter((mode) => unique.has(mode));
+    const extras = Array.from(unique).filter((mode) => !ordered.includes(mode));
+    return [...ordered, ...extras];
+}
+function computedSupportedModeIds(session) {
+    const supported = [...BASE_SUPPORTED_MODE_IDS];
+    if (currentModelSupportsAutoMode(session)) {
+        supported.push("auto");
+    }
+    if (session.supportsBypassPermissionsMode) {
+        supported.push("bypassPermissions");
+    }
+    if (session.mode) {
+        supported.push(session.mode);
+    }
+    return uniqueModeIds(supported);
+}
+export function refreshSupportedModesForSession(session) {
+    const computed = computedSupportedModeIds(session);
+    session.supportedModeIds = computed.filter((mode) => mode === session.mode || !session.runtimeUnavailableModeIds.includes(mode));
+}
+export function markModeUnavailableForSession(session, mode) {
+    if (session.runtimeUnavailableModeIds.includes(mode)) {
+        return false;
+    }
+    session.runtimeUnavailableModeIds = [...session.runtimeUnavailableModeIds, mode];
+    refreshSupportedModesForSession(session);
+    return true;
+}
+export function permissionModeFailureLooksUnsupported(mode, message) {
+    const normalizedMessage = message.toLowerCase();
+    return (normalizedMessage.includes("cannot set permission mode to") &&
+        normalizedMessage.includes(mode.toLowerCase()));
+}
+export function availableModesForSession(session) {
+    return session.supportedModeIds.map(modeInfoForId);
+}
 function asRecord(value, context) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error(`${context} must be an object`);
@@ -205,6 +263,16 @@ export function parseCommandEnvelope(line) {
                     command: "get_status_snapshot",
                     session_id: expectString(raw, "session_id", "get_status_snapshot"),
                 };
+            case "get_context_usage":
+                return {
+                    command: "get_context_usage",
+                    session_id: expectString(raw, "session_id", "get_context_usage"),
+                };
+            case "reload_plugins":
+                return {
+                    command: "reload_plugins",
+                    session_id: expectString(raw, "session_id", "reload_plugins"),
+                };
             case "mcp_status":
             case "get_mcp_snapshot":
                 return {
@@ -341,6 +409,7 @@ function parseQuestionAnnotation(value) {
 }
 export function toPermissionMode(mode) {
     if (mode === "default" ||
+        mode === "auto" ||
         mode === "acceptEdits" ||
         mode === "bypassPermissions" ||
         mode === "plan" ||
@@ -349,10 +418,10 @@ export function toPermissionMode(mode) {
     }
     return null;
 }
-export function buildModeState(mode) {
+export function buildModeState(session, mode) {
     return {
         current_mode_id: mode,
         current_mode_name: MODE_NAMES[mode],
-        available_modes: MODE_OPTIONS,
+        available_modes: availableModesForSession(session),
     };
 }

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

@@ -1,6 +1,8 @@
 import { listSessions } from "@anthropic-ai/claude-agent-sdk";
 import { buildModeState } from "./commands.js";
 import { mapSdkSessions } from "./history.js";
+import { bridgeLogger, LOG_TARGETS, logBridgeEventSent } from "./logger.js";
+import { resolveCurrentModel } from "./session_lifecycle.js";
 const SESSION_LIST_LIMIT = 50;
 let sessionListingDir;
 export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
@@ -17,7 +19,9 @@ export function writeEvent(event, requestId) {
         ...(requestId ? { request_id: requestId } : {}),
         ...event,
     };
-    process.stdout.write(`${JSON.stringify(envelope)}\n`);
+    const serialized = JSON.stringify(envelope);
+    logBridgeEventSent(event, requestId, Buffer.byteLength(serialized) + 1);
+    process.stdout.write(`${serialized}\n`);
 }
 export function failConnection(message, requestId) {
     writeEvent({ event: "connection_failed", message }, requestId);
@@ -25,34 +29,110 @@ export function failConnection(message, requestId) {
 export function slashError(sessionId, message, requestId) {
     writeEvent({ event: "slash_error", session_id: sessionId, message }, requestId);
 }
+export function emitRuntimeReloadCompleted(sessionId, requestId) {
+    writeEvent({ event: "runtime_reload_completed", session_id: sessionId }, requestId);
+}
+export function emitRuntimeReloadFailed(sessionId, message, requestId) {
+    writeEvent({ event: "runtime_reload_failed", session_id: sessionId, message }, requestId);
+}
 export function emitMcpOperationError(sessionId, error, requestId) {
     writeEvent({ event: "mcp_operation_error", session_id: sessionId, error }, requestId);
 }
 export function emitSessionUpdate(sessionId, update) {
     writeEvent({ event: "session_update", session_id: sessionId, update });
 }
-export function emitConnectEvent(session) {
+export function emitPermissionRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "permission_request_emitted",
+        message: "permission request emitted",
+        outcome: "success",
+        sessionId,
+        toolCallId: request.tool_call.tool_call_id,
+        count: request.options.length,
+        fields: {
+            option_count: request.options.length,
+            tool_title: request.tool_call.title,
+        },
+    });
+    writeEvent({ event: "permission_request", session_id: sessionId, request });
+}
+export function emitQuestionRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "question_request_emitted",
+        message: "question request emitted",
+        outcome: "success",
+        sessionId,
+        toolCallId: request.tool_call.tool_call_id,
+        count: request.prompt.options.length,
+        fields: {
+            question_index: request.question_index,
+            total_questions: request.total_questions,
+            option_count: request.prompt.options.length,
+            header: request.prompt.header,
+        },
+    });
+    writeEvent({ event: "question_request", session_id: sessionId, request });
+}
+export function emitElicitationRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "elicitation_request_emitted",
+        message: "elicitation request emitted",
+        outcome: "success",
+        sessionId,
+        requestId: request.request_id,
+        fields: {
+            server_name: request.server_name,
+            mode: request.mode,
+            has_url: request.url !== undefined,
+            has_requested_schema: request.requested_schema !== undefined,
+        },
+    });
+    writeEvent({ event: "elicitation_request", session_id: sessionId, request });
+}
+function buildConnectBridgeEvent(session, eventName) {
     const historyUpdates = session.resumeUpdates;
-    const connectEvent = session.connectEvent === "session_replaced"
+    return eventName === "session_replaced"
         ? {
             event: "session_replaced",
             session_id: session.sessionId,
             cwd: session.cwd,
-            model_name: session.model,
+            current_model: session.currentModel ?? resolveCurrentModel(session),
             available_models: session.availableModels,
-            mode: session.mode ? buildModeState(session.mode) : null,
+            mode: session.mode ? buildModeState(session, session.mode) : null,
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
         }
         : {
             event: "connected",
             session_id: session.sessionId,
             cwd: session.cwd,
-            model_name: session.model,
+            current_model: session.currentModel ?? resolveCurrentModel(session),
             available_models: session.availableModels,
-            mode: session.mode ? buildModeState(session.mode) : null,
+            mode: session.mode ? buildModeState(session, session.mode) : null,
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
         };
-    writeEvent(connectEvent, session.connectRequestId);
+}
+function logConnectEventEmission(session, eventName, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: eventName === "session_replaced" ? "session_replaced_emitted" : "session_connected_emitted",
+        message: eventName === "session_replaced" ? "session replaced event emitted" : "session connected event emitted",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            history_update_count: session.resumeUpdates?.length ?? 0,
+            available_model_count: session.availableModels.length,
+            stale_session_count: session.sessionsToCloseAfterConnect?.length ?? 0,
+        },
+    });
+}
+export function emitConnectEvent(session) {
+    const bridgeEvent = buildConnectBridgeEvent(session, session.connectEvent);
+    logConnectEventEmission(session, session.connectEvent, session.connectRequestId);
+    writeEvent(bridgeEvent, session.connectRequestId);
     session.connectRequestId = undefined;
     session.connected = true;
     session.authHintSent = false;
@@ -65,7 +145,7 @@ export function emitConnectEvent(session) {
     }
     void (async () => {
         // Lazy import to break circular dependency at module-evaluation time.
-        const { sessions, closeSession } = await import("./session_lifecycle.js");
+        const { sessions, closeSessionWithLogging } = await import("./session_lifecycle.js");
         for (const stale of staleSessions) {
             if (stale === session) {
                 continue;
@@ -73,19 +153,54 @@ export function emitConnectEvent(session) {
             if (sessions.get(stale.sessionId) === stale) {
                 sessions.delete(stale.sessionId);
             }
-            await closeSession(stale);
+            await closeSessionWithLogging(stale, { reason: "stale_after_connect" });
         }
         refreshSessionsList();
     })();
 }
+export function emitSessionReplacedEvent(session, requestId) {
+    const bridgeEvent = buildConnectBridgeEvent(session, "session_replaced");
+    logConnectEventEmission(session, "session_replaced", requestId);
+    writeEvent(bridgeEvent, requestId);
+    session.resumeUpdates = undefined;
+    refreshSessionsList();
+}
 export async function emitSessionsList(requestId) {
+    bridgeLogger.debug({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "sessions_list_requested",
+        message: "sessions list requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        fields: {
+            has_listing_dir: sessionListingDir !== undefined,
+            limit: SESSION_LIST_LIMIT,
+        },
+    });
     try {
         const sdkSessions = await listSessions(currentSessionListOptions());
-        writeEvent({ event: "sessions_listed", sessions: mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT) }, requestId);
+        const sessions = mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT);
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "sessions_list_completed",
+            message: "sessions list completed",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            count: sessions.length,
+            fields: { session_count: sessions.length },
+        });
+        writeEvent({ event: "sessions_listed", sessions }, requestId);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.error(`[sdk warn] listSessions failed: ${message}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "sessions_list_failed",
+            message: "failed to list SDK sessions",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            fields: { error_message: message },
+        });
         writeEvent({ event: "sessions_listed", sessions: [] }, requestId);
     }
 }

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

@@ -29,14 +29,14 @@ function pushResumeTextChunk(updates, role, text) {
     }
     updates.push({ type: "user_message_chunk", content: { type: "text", text } });
 }
-function pushResumeToolUse(updates, toolCalls, block) {
+function pushResumeToolUse(updates, toolCalls, block, parentToolUseId) {
     const toolUseId = typeof block.id === "string" ? block.id : "";
     if (!toolUseId) {
         return;
     }
     const name = typeof block.name === "string" ? block.name : "Tool";
     const input = asRecordOrNull(block.input) ?? {};
-    const toolCall = createToolCall(toolUseId, name, input);
+    const toolCall = createToolCall(toolUseId, name, input, parentToolUseId);
     toolCall.status = "in_progress";
     toolCalls.set(toolUseId, toolCall);
     updates.push({ type: "tool_call", tool_call: toolCall });
@@ -75,7 +75,7 @@ export function mapSdkSessionInfo(info) {
         session_id: info.sessionId,
         summary: summaryFromSession(info),
         last_modified_ms: info.lastModified,
-        file_size_bytes: info.fileSize,
+        file_size_bytes: info.fileSize ?? 0,
         ...(nonEmptyTrimmed(info.cwd) ? { cwd: info.cwd?.trim() } : {}),
         ...(nonEmptyTrimmed(info.gitBranch) ? { git_branch: info.gitBranch?.trim() } : {}),
         ...(nonEmptyTrimmed(info.customTitle) ? { custom_title: info.customTitle?.trim() } : {}),
@@ -106,6 +106,11 @@ export function mapSessionMessagesToUpdates(messages) {
         for (const message of messageCandidates(entry.message)) {
             const roleCandidate = message.role;
             const role = roleCandidate === "assistant" || roleCandidate === "user" ? roleCandidate : fallbackRole;
+            const parentToolUseId = typeof entry.parent_tool_use_id === "string"
+                ? entry.parent_tool_use_id
+                : typeof message.parent_tool_use_id === "string"
+                    ? message.parent_tool_use_id
+                    : null;
             const content = Array.isArray(message.content) ? message.content : [];
             for (const item of content) {
                 const block = asRecordOrNull(item);
@@ -121,7 +126,7 @@ export function mapSessionMessagesToUpdates(messages) {
                     continue;
                 }
                 if (isToolUseBlockType(blockType) && role === "assistant") {
-                    pushResumeToolUse(updates, toolCalls, block);
+                    pushResumeToolUse(updates, toolCalls, block, parentToolUseId);
                     continue;
                 }
                 if (TOOL_RESULT_TYPES.has(blockType)) {

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

@@ -0,0 +1,253 @@
+const LOG_SCHEMA = "claude-rs-log/v1";
+const DIAGNOSTICS_ENABLED = process.env.CLAUDE_RS_BRIDGE_DIAGNOSTICS === "1";
+export const LOG_TARGETS = {
+    APP_AUTH: "app.auth",
+    APP_CACHE: "app.cache",
+    APP_CONFIG: "app.config",
+    APP_COMMAND: "app.command",
+    APP_NETWORK: "app.network",
+    APP_INPUT: "app.input",
+    APP_PASTE: "app.paste",
+    APP_PERF: "app.perf",
+    APP_RENDER: "app.render",
+    APP_SESSION: "app.session",
+    APP_TOOL: "app.tool",
+    APP_UPDATE: "app.update",
+    BRIDGE_LIFECYCLE: "bridge.lifecycle",
+    BRIDGE_MCP: "bridge.mcp",
+    BRIDGE_PERMISSION: "bridge.permission",
+    BRIDGE_PROTOCOL: "bridge.protocol",
+    BRIDGE_SDK: "bridge.sdk",
+};
+function definedFields(fields) {
+    if (!fields) {
+        return undefined;
+    }
+    const entries = Object.entries(fields).filter(([, value]) => value !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function writeDiagnostic(level, event) {
+    if (!DIAGNOSTICS_ENABLED) {
+        return;
+    }
+    const envelope = {
+        schema: LOG_SCHEMA,
+        timestamp: new Date().toISOString(),
+        level,
+        target: event.target,
+        event_name: event.eventName,
+        message: event.message,
+        ...(event.outcome ? { outcome: event.outcome } : {}),
+        ...(event.sessionId ? { session_id: event.sessionId } : {}),
+        ...(event.requestId ? { request_id: event.requestId } : {}),
+        ...(event.toolCallId ? { tool_call_id: event.toolCallId } : {}),
+        ...(event.commandId ? { command_id: event.commandId } : {}),
+        ...(event.terminalId ? { terminal_id: event.terminalId } : {}),
+        ...(event.errorKind ? { error_kind: event.errorKind } : {}),
+        ...(event.errorCode ? { error_code: event.errorCode } : {}),
+        ...(event.durationMs !== undefined ? { duration_ms: event.durationMs } : {}),
+        ...(event.count !== undefined ? { count: event.count } : {}),
+        ...(event.sizeBytes !== undefined ? { size_bytes: event.sizeBytes } : {}),
+    };
+    const fields = definedFields(event.fields);
+    if (fields) {
+        envelope.fields = fields;
+    }
+    process.stderr.write(`${JSON.stringify(envelope)}\n`);
+}
+function previewText(value, limit) {
+    return value.length > limit ? `${value.slice(0, limit)}...` : value;
+}
+function commandSessionId(command) {
+    switch (command.command) {
+        case "resume_session":
+        case "prompt":
+        case "cancel_turn":
+        case "set_model":
+        case "set_mode":
+        case "generate_session_title":
+        case "rename_session":
+        case "permission_response":
+        case "question_response":
+        case "elicitation_response":
+        case "get_status_snapshot":
+        case "mcp_status":
+        case "mcp_reconnect":
+        case "mcp_toggle":
+        case "mcp_set_servers":
+        case "mcp_authenticate":
+        case "mcp_clear_auth":
+        case "mcp_oauth_callback_url":
+            return command.session_id;
+        case "create_session":
+            return command.resume;
+        case "initialize":
+        case "new_session":
+        case "shutdown":
+            return undefined;
+    }
+}
+function commandToolCallId(command) {
+    switch (command.command) {
+        case "permission_response":
+        case "question_response":
+            return command.tool_call_id;
+        case "initialize":
+        case "create_session":
+        case "resume_session":
+        case "prompt":
+        case "cancel_turn":
+        case "set_model":
+        case "set_mode":
+        case "generate_session_title":
+        case "rename_session":
+        case "new_session":
+        case "elicitation_response":
+        case "get_status_snapshot":
+        case "get_context_usage":
+        case "reload_plugins":
+        case "mcp_status":
+        case "mcp_reconnect":
+        case "mcp_toggle":
+        case "mcp_set_servers":
+        case "mcp_authenticate":
+        case "mcp_clear_auth":
+        case "mcp_oauth_callback_url":
+        case "shutdown":
+            return undefined;
+    }
+}
+function eventToolCallId(event) {
+    switch (event.event) {
+        case "permission_request":
+        case "question_request":
+            return event.request.tool_call.tool_call_id;
+        case "connected":
+        case "auth_required":
+        case "connection_failed":
+        case "session_update":
+        case "elicitation_request":
+        case "elicitation_complete":
+        case "mcp_auth_redirect":
+        case "mcp_operation_error":
+        case "turn_complete":
+        case "turn_error":
+        case "slash_error":
+        case "runtime_reload_completed":
+        case "runtime_reload_failed":
+        case "session_replaced":
+        case "initialized":
+        case "sessions_listed":
+        case "status_snapshot":
+        case "context_usage":
+        case "mcp_snapshot":
+            return undefined;
+    }
+}
+function protocolCommandLevel(command) {
+    switch (command.command) {
+        case "initialize":
+        case "create_session":
+        case "resume_session":
+        case "new_session":
+        case "shutdown":
+            return "info";
+        default:
+            return "debug";
+    }
+}
+function protocolEventLevel(event) {
+    switch (event.event) {
+        case "initialized":
+        case "connected":
+        case "session_replaced":
+            return "info";
+        case "connection_failed":
+            return "error";
+        case "auth_required":
+        case "mcp_operation_error":
+        case "turn_error":
+        case "slash_error":
+        case "runtime_reload_failed":
+            return "warn";
+        case "session_update":
+        case "permission_request":
+        case "question_request":
+        case "elicitation_request":
+        case "elicitation_complete":
+        case "mcp_auth_redirect":
+        case "turn_complete":
+            return "trace";
+        case "sessions_listed":
+        case "status_snapshot":
+        case "context_usage":
+        case "runtime_reload_completed":
+        case "mcp_snapshot":
+            return "debug";
+    }
+}
+export const bridgeLogger = {
+    error(event) {
+        writeDiagnostic("error", event);
+    },
+    warn(event) {
+        writeDiagnostic("warn", event);
+    },
+    info(event) {
+        writeDiagnostic("info", event);
+    },
+    debug(event) {
+        writeDiagnostic("debug", event);
+    },
+    trace(event) {
+        writeDiagnostic("trace", event);
+    },
+};
+export function logSdkStderrLine(line, sessionId) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return;
+    }
+    const lowered = trimmed.toLowerCase();
+    const level = lowered.startsWith("error") || lowered.includes("panic")
+        ? "error"
+        : lowered.startsWith("warn")
+            ? "warn"
+            : "debug";
+    writeDiagnostic(level, {
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_stderr_line",
+        message: "SDK stderr line received",
+        ...(sessionId ? { sessionId } : {}),
+        fields: {
+            preview: previewText(trimmed, 240),
+            preview_chars: Math.min(trimmed.length, 240),
+            line_chars: trimmed.length,
+        },
+    });
+}
+export function logBridgeCommandReceived(command, requestId) {
+    writeDiagnostic(protocolCommandLevel(command), {
+        target: LOG_TARGETS.BRIDGE_PROTOCOL,
+        eventName: "bridge_command_received",
+        message: "bridge command received",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        ...(commandSessionId(command) ? { sessionId: commandSessionId(command) } : {}),
+        ...(commandToolCallId(command) ? { toolCallId: commandToolCallId(command) } : {}),
+        fields: { bridge_command: command.command },
+    });
+}
+export function logBridgeEventSent(event, requestId, sizeBytes) {
+    writeDiagnostic(protocolEventLevel(event), {
+        target: LOG_TARGETS.BRIDGE_PROTOCOL,
+        eventName: "bridge_event_sent",
+        message: "bridge event sent",
+        outcome: event.event === "connection_failed" ? "failure" : "success",
+        ...(requestId ? { requestId } : {}),
+        ...("session_id" in event ? { sessionId: event.session_id } : {}),
+        ...(eventToolCallId(event) ? { toolCallId: eventToolCallId(event) } : {}),
+        sizeBytes,
+        fields: { bridge_event: event.event },
+    });
+}