claude-code-rust 0.10.0 → 0.11.0

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

@@ -51,6 +51,7 @@ function updateOutcome(status) {
         case "completed":
             return "success";
         case "failed":
+        case "killed":
             return "failure";
         case "in_progress":
             return "partial";
@@ -60,6 +61,25 @@ function updateOutcome(status) {
             return "partial";
     }
 }
+function parentToolUseIdFromMeta(meta) {
+    if (!meta || typeof meta !== "object") {
+        return null;
+    }
+    const claudeCode = "claudeCode" in meta && meta.claudeCode && typeof meta.claudeCode === "object" ? meta.claudeCode : undefined;
+    const parentToolUseId = claudeCode && "parentToolUseId" in claudeCode && typeof claudeCode.parentToolUseId === "string"
+        ? claudeCode.parentToolUseId
+        : null;
+    return parentToolUseId;
+}
+function mergeTaskMetadata(current, update) {
+    if (update === undefined) {
+        return current;
+    }
+    return {
+        ...(current ?? {}),
+        ...update,
+    };
+}
 function applyFieldsToBase(base, fields) {
     if (fields.title !== undefined) {
         base.title = fields.title;
@@ -82,6 +102,9 @@ function applyFieldsToBase(base, fields) {
     if (fields.output_metadata !== undefined) {
         base.output_metadata = fields.output_metadata;
     }
+    if (fields.task_metadata !== undefined) {
+        base.task_metadata = mergeTaskMetadata(base.task_metadata, fields.task_metadata);
+    }
     if (fields.meta !== undefined) {
         base.meta = fields.meta;
     }
@@ -132,10 +155,11 @@ function logToolCallUpdateEmitted(sessionId, toolUseId, fields, base, updateKind
             location_count: fields.locations?.length,
             raw_output_chars: rawOutput?.length,
             has_output_metadata: fields.output_metadata !== undefined || base?.output_metadata !== undefined,
+            has_task_metadata: fields.task_metadata !== undefined || base?.task_metadata !== undefined,
             failure_kind: failureKind,
         },
     };
-    if (nextStatus === "failed") {
+    if (nextStatus === "failed" || nextStatus === "killed") {
         bridgeLogger.warn(commonEvent);
         return;
     }
@@ -165,11 +189,12 @@ export function emitToolCallUpdate(session, toolUseId, fields, updateKind) {
         applyFieldsToBase(base, fields);
     }
 }
-export function emitToolCall(session, toolUseId, name, input) {
-    const toolCall = createToolCall(toolUseId, name, input);
+export function emitToolCall(session, toolUseId, name, input, parentToolUseId = null) {
+    const existing = session.toolCalls.get(toolUseId);
+    const resolvedParentToolUseId = parentToolUseId ?? parentToolUseIdFromMeta(existing?.meta);
+    const toolCall = createToolCall(toolUseId, name, input, resolvedParentToolUseId);
     const status = "in_progress";
     toolCall.status = status;
-    const existing = session.toolCalls.get(toolUseId);
     if (!existing) {
         emitInitialToolCall(session, toolCall);
         return;
@@ -187,12 +212,17 @@ export function emitToolCall(session, toolUseId, name, input) {
     }
     emitToolCallUpdate(session, toolUseId, fields, "refresh");
 }
-export function ensureToolCallVisible(session, toolUseId, toolName, input) {
+export function ensureToolCallVisible(session, toolUseId, toolName, input, parentToolUseId = null) {
     const existing = session.toolCalls.get(toolUseId);
     if (existing) {
+        const existingParentToolUseId = parentToolUseIdFromMeta(existing.meta);
+        if (parentToolUseId && existingParentToolUseId !== parentToolUseId) {
+            const refreshed = createToolCall(toolUseId, toolName, input, parentToolUseId);
+            emitToolCallUpdate(session, toolUseId, { meta: refreshed.meta }, "refresh");
+        }
         return existing;
     }
-    const toolCall = createToolCall(toolUseId, toolName, input);
+    const toolCall = createToolCall(toolUseId, toolName, input, parentToolUseId);
     emitInitialToolCall(session, toolCall);
     return toolCall;
 }
@@ -238,7 +268,8 @@ export function emitToolProgressUpdate(session, toolUseId, toolName) {
     }
     if (existing.status === "in_progress" ||
         existing.status === "completed" ||
-        existing.status === "failed") {
+        existing.status === "failed" ||
+        existing.status === "killed") {
         return;
     }
     emitToolCallUpdate(session, toolUseId, { status: "in_progress" }, "progress");
@@ -249,7 +280,7 @@ export function emitToolSummaryUpdate(session, toolUseId, summary) {
         return;
     }
     const fields = {
-        status: base.status === "failed" ? "failed" : "completed",
+        status: base.status === "failed" || base.status === "killed" ? base.status : "completed",
         raw_output: summary,
         content: [{ type: "content", content: { type: "text", text: summary } }],
     };
@@ -290,3 +321,60 @@ export function taskProgressText(msg) {
     }
     return description || lastTool;
 }
+function taskPatchStatus(value) {
+    switch (value) {
+        case "pending":
+            return "pending";
+        case "running":
+            return "in_progress";
+        case "completed":
+            return "completed";
+        case "failed":
+            return "failed";
+        case "killed":
+            return "killed";
+        default:
+            return undefined;
+    }
+}
+function buildTaskMetadata(patch) {
+    const taskMetadata = {};
+    if (typeof patch.error === "string" && patch.error.length > 0) {
+        taskMetadata.error = patch.error;
+    }
+    if (typeof patch.is_backgrounded === "boolean") {
+        taskMetadata.is_backgrounded = patch.is_backgrounded;
+    }
+    if (typeof patch.end_time === "number" && Number.isFinite(patch.end_time) && patch.end_time >= 0) {
+        taskMetadata.end_time = Math.trunc(patch.end_time);
+    }
+    if (typeof patch.total_paused_ms === "number" &&
+        Number.isFinite(patch.total_paused_ms) &&
+        patch.total_paused_ms >= 0) {
+        taskMetadata.total_paused_ms = Math.trunc(patch.total_paused_ms);
+    }
+    return Object.keys(taskMetadata).length > 0 ? taskMetadata : undefined;
+}
+export function taskUpdatedFields(msg) {
+    const patch = msg.patch && typeof msg.patch === "object" ? msg.patch : {};
+    const fields = {};
+    const status = taskPatchStatus(patch.status);
+    const description = typeof patch.description === "string" ? patch.description : "";
+    const error = typeof patch.error === "string" ? patch.error : "";
+    if (status) {
+        fields.status = status;
+    }
+    if (description) {
+        fields.raw_output = description;
+        fields.content = [{ type: "content", content: { type: "text", text: description } }];
+    }
+    else if ((status === "failed" || status === "killed") && error) {
+        fields.raw_output = error;
+        fields.content = [{ type: "content", content: { type: "text", text: error } }];
+    }
+    const taskMetadata = buildTaskMetadata(patch);
+    if (taskMetadata) {
+        fields.task_metadata = taskMetadata;
+    }
+    return fields;
+}

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

@@ -110,7 +110,7 @@ function editDiffContent(name, input) {
     }
     return [];
 }
-export function createToolCall(toolUseId, name, input) {
+export function createToolCall(toolUseId, name, input, parentToolUseId = null) {
     return {
         tool_call_id: toolUseId,
         title: toolTitle(name, input),
@@ -122,6 +122,7 @@ export function createToolCall(toolUseId, name, input) {
         meta: {
             claudeCode: {
                 toolName: name,
+                parentToolUseId,
             },
         },
     };
@@ -134,18 +135,33 @@ function resultRecordCandidates(rawResult, rawContent) {
             candidates.push(record);
         }
     };
+    const pushRecords = (value) => {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                pushRecord(entry);
+            }
+            return;
+        }
+        pushRecord(value);
+    };
     const pushNestedRecords = (value) => {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                pushNestedRecords(entry);
+            }
+            return;
+        }
         const record = asRecordOrNull(value);
         if (!record) {
             return;
         }
-        pushRecord(record.result);
-        pushRecord(record.data);
-        pushRecord(record.content);
+        pushRecords(record.result);
+        pushRecords(record.data);
+        pushRecords(record.content);
     };
-    pushRecord(rawResult);
+    pushRecords(rawResult);
     pushNestedRecords(rawResult);
-    pushRecord(rawContent);
+    pushRecords(rawContent);
     pushNestedRecords(rawContent);
     return candidates;
 }
@@ -230,15 +246,9 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     if (toolName === "Bash") {
         for (const candidate of candidates) {
             const hasAssistantAutoBackgrounded = typeof candidate.assistantAutoBackgrounded === "boolean";
-            const hasTokenSaverOutput = typeof candidate.tokenSaverOutput === "string" && candidate.tokenSaverOutput.length > 0;
-            if (hasAssistantAutoBackgrounded || hasTokenSaverOutput) {
+            if (hasAssistantAutoBackgrounded) {
                 const bashMetadata = {};
-                if (hasAssistantAutoBackgrounded) {
-                    bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
-                }
-                if (hasTokenSaverOutput) {
-                    bashMetadata.token_saver_active = true;
-                }
+                bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
                 return {
                     bash: bashMetadata,
                 };
@@ -246,14 +256,6 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
         }
         return undefined;
     }
-    if (toolName === "ExitPlanMode") {
-        for (const candidate of candidates) {
-            if (typeof candidate.isUltraplan === "boolean") {
-                return { exit_plan_mode: { is_ultraplan: candidate.isUltraplan } };
-            }
-        }
-        return undefined;
-    }
     if (toolName === "TodoWrite") {
         for (const candidate of candidates) {
             if (typeof candidate.verificationNudgeNeeded === "boolean") {
@@ -476,8 +478,7 @@ function findBashResultRecord(rawResult, rawContent) {
         "stderr" in candidate ||
         "backgroundTaskId" in candidate ||
         "backgroundedByUser" in candidate ||
-        "assistantAutoBackgrounded" in candidate ||
-        "tokenSaverOutput" in candidate);
+        "assistantAutoBackgrounded" in candidate);
 }
 function bashBackgroundMessage(record) {
     const backgroundTaskId = typeof record.backgroundTaskId === "string" ? record.backgroundTaskId : "";
@@ -511,16 +512,48 @@ function buildBashDisplayOutput(record) {
     }
     return segments.join("\n");
 }
+function fileUnchangedResultText(rawResult, rawContent) {
+    for (const candidate of resultRecordCandidates(rawResult, rawContent)) {
+        if (candidate.type !== "file_unchanged") {
+            continue;
+        }
+        const file = asRecordOrNull(candidate.file);
+        const filePath = typeof file?.filePath === "string" ? file.filePath.trim() : "";
+        if (filePath) {
+            return `File unchanged: ${filePath}`;
+        }
+    }
+    return "";
+}
+function agentTitleFromAgentOutput(rawResult, rawContent) {
+    for (const candidate of resultRecordCandidates(rawResult, rawContent)) {
+        const agentType = typeof candidate.agentType === "string" ? candidate.agentType.trim() : "";
+        if (agentType) {
+            return agentType;
+        }
+    }
+    return "";
+}
 export function buildToolResultFields(isError, rawContent, base, rawResult) {
     const toolName = resolveToolName(base);
+    const fields = {
+        status: isError ? "failed" : "completed",
+    };
+    const fileUnchangedText = !isError && toolName === "Read" ? fileUnchangedResultText(rawResult, rawContent) : "";
+    if (fileUnchangedText) {
+        fields.raw_output = fileUnchangedText;
+        fields.content = [{ type: "content", content: { type: "text", text: fileUnchangedText } }];
+        return fields;
+    }
+    const agentTitle = !isError && toolName === "Agent" ? agentTitleFromAgentOutput(rawResult, rawContent) : "";
+    if (agentTitle) {
+        fields.title = agentTitle;
+    }
     const bashResultRecord = toolName === "Bash" ? findBashResultRecord(rawResult, rawContent) : undefined;
     const normalizedRawOutput = normalizeToolResultText(rawContent, isError);
     const rawOutput = bashResultRecord
         ? buildBashDisplayOutput(bashResultRecord)
         : normalizedRawOutput || JSON.stringify(rawContent);
-    const fields = {
-        status: isError ? "failed" : "completed",
-    };
     if (rawOutput) {
         fields.raw_output = rawOutput;
     }

package/agent-sdk/dist/bridge.js

@@ -4,11 +4,12 @@ import { dirname, join } from "node:path";
 import readline from "node:readline";
 import { pathToFileURL } from "node:url";
 import { getSessionMessages, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
-import { parseCommandEnvelope, toPermissionMode } from "./bridge/commands.js";
-import { writeEvent, failConnection, slashError, emitSessionUpdate, emitSessionsList, currentSessionListOptions, setSessionListingDir, } from "./bridge/events.js";
+import { buildModeState, markModeUnavailableForSession, parseCommandEnvelope, permissionModeFailureLooksUnsupported, refreshSupportedModesForSession, toPermissionMode, } from "./bridge/commands.js";
+import { writeEvent, failConnection, slashError, emitRuntimeReloadCompleted, emitRuntimeReloadFailed, emitSessionUpdate, emitSessionsList, currentSessionListOptions, setSessionListingDir, } from "./bridge/events.js";
 import { contentFromPrompt } from "./bridge/message_handlers.js";
-import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, } from "./bridge/session_lifecycle.js";
+import { sessions, sessionById, createSession, closeAllSessions, handleElicitationResponse, handlePermissionResponse, handleQuestionResponse, emitCurrentModelUpdate, refreshCurrentModel, shouldInvalidateResolvedRuntimeModel, } from "./bridge/session_lifecycle.js";
 import { mapSessionMessagesToUpdates } from "./bridge/history.js";
+import { emitAvailableAgentsIfChanged, mapAvailableAgents } from "./bridge/agents.js";
 import { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, handleMcpAuthenticateCommand, handleMcpClearAuthCommand, handleMcpOauthCallbackUrlCommand, handleMcpReconnectCommand, handleMcpSetServersCommand, handleMcpStatusCommand, handleMcpToggleCommand, staleMcpAuthCandidates, } from "./bridge/mcp.js";
 import { bridgeLogger, LOG_TARGETS, logBridgeCommandReceived } from "./bridge/logger.js";
 // Re-exports: all symbols that tests and external consumers import from bridge.js.
@@ -21,10 +22,10 @@ export { parseCommandEnvelope } from "./bridge/commands.js";
 export { buildSessionListOptions } from "./bridge/events.js";
 export { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./bridge/permissions.js";
 export { mapSessionMessagesToUpdates, mapSdkSessions, } from "./bridge/history.js";
-export { handleTaskSystemMessage } from "./bridge/message_handlers.js";
+export { handleSdkMessage, handleTaskSystemMessage } from "./bridge/message_handlers.js";
 export { mapAvailableAgents } from "./bridge/agents.js";
-export { buildQueryOptions, mapAvailableModels } from "./bridge/session_lifecycle.js";
-export { parseFastModeState, parseRateLimitStatus, buildRateLimitUpdate, } from "./bridge/state_parsing.js";
+export { attachRequestUserDialogInterceptor, buildQueryOptions, mapAvailableModels, } from "./bridge/session_lifecycle.js";
+export { parseFastModeState, parseRateLimitStatus, parseRuntimeSessionState, parseApiRetryError, buildRateLimitUpdate, buildApiRetryUpdate, normalizeSettingsParseError, normalizeSettingsParseErrors, } from "./bridge/state_parsing.js";
 export { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, staleMcpAuthCandidates };
 export function buildSessionMutationOptions(cwd) {
     return cwd ? { dir: cwd } : undefined;
@@ -42,7 +43,7 @@ export async function generatePersistedSessionTitle(query, description) {
     }
     return title;
 }
-const EXPECTED_AGENT_SDK_VERSION = "0.2.74";
+const EXPECTED_AGENT_SDK_VERSION = "0.2.104";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {
@@ -238,7 +239,7 @@ async function handleCommand(command, requestId) {
             if (content.length === 0) {
                 return;
             }
-            session.input.enqueue({
+            const message = {
                 type: "user",
                 session_id: session.sessionId,
                 parent_tool_use_id: null,
@@ -246,7 +247,8 @@ async function handleCommand(command, requestId) {
                     role: "user",
                     content,
                 },
-            });
+            };
+            session.input.enqueue(message);
             return;
         }
         case "cancel_turn": {
@@ -264,13 +266,80 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
                 return;
             }
-            await session.query.setModel(command.model);
-            session.model = command.model;
-            emitSessionUpdate(session.sessionId, {
-                type: "config_option_update",
-                option_id: "model",
-                value: command.model,
+            bridgeLogger.info({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "set_model_started",
+                message: "set model started",
+                outcome: "start",
+                sessionId: session.sessionId,
+                requestId,
+                fields: {
+                    requested_model: command.model,
+                    previous_requested_model: session.requestedModelId,
+                    previous_session_model: session.model,
+                    previous_resolved_runtime_model: session.resolvedRuntimeModelId,
+                    previous_current_model: session.currentModel?.resolved_id,
+                },
             });
+            try {
+                const previousRequestedModel = session.requestedModelId;
+                const previousSessionModel = session.model;
+                await session.query.setModel(command.model);
+                session.requestedModelId = command.model;
+                session.model = command.model;
+                const invalidatedResolvedRuntimeModel = shouldInvalidateResolvedRuntimeModel(previousRequestedModel, previousSessionModel, command.model);
+                if (invalidatedResolvedRuntimeModel) {
+                    session.resolvedRuntimeModelId = undefined;
+                }
+                const changed = refreshCurrentModel(session, true);
+                const forcedCurrentModelUpdate = !changed && emitCurrentModelUpdate(session);
+                bridgeLogger.info({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "set_model_succeeded",
+                    message: "set model completed",
+                    outcome: "success",
+                    sessionId: session.sessionId,
+                    requestId,
+                    fields: {
+                        requested_model: command.model,
+                        session_model_after: session.model,
+                        resolved_runtime_model_after: session.resolvedRuntimeModelId,
+                        current_model_after: session.currentModel?.resolved_id,
+                        current_model_display_short: session.currentModel?.display_name_short,
+                        current_model_display_long: session.currentModel?.display_name_long,
+                        current_model_update_emitted: changed || forcedCurrentModelUpdate,
+                        current_model_update_forced: forcedCurrentModelUpdate,
+                        resolved_runtime_model_invalidated: invalidatedResolvedRuntimeModel,
+                    },
+                });
+                refreshSupportedModesForSession(session);
+                if (session.mode) {
+                    emitSessionUpdate(session.sessionId, {
+                        type: "mode_state_update",
+                        mode: buildModeState(session, session.mode),
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "set_model_failed",
+                    message: "set model failed",
+                    outcome: "failure",
+                    sessionId: session.sessionId,
+                    requestId,
+                    fields: {
+                        requested_model: command.model,
+                        error_message: message,
+                        previous_requested_model: session.requestedModelId,
+                        previous_session_model: session.model,
+                        previous_resolved_runtime_model: session.resolvedRuntimeModelId,
+                        previous_current_model: session.currentModel?.resolved_id,
+                    },
+                });
+                slashError(command.session_id, `failed to set model: ${message}`, requestId);
+            }
             return;
         }
         case "set_mode": {
@@ -284,12 +353,28 @@ async function handleCommand(command, requestId) {
                 slashError(command.session_id, `unsupported mode: ${command.mode}`, requestId);
                 return;
             }
-            await session.query.setPermissionMode(mode);
-            session.mode = mode;
-            emitSessionUpdate(session.sessionId, {
-                type: "current_mode_update",
-                current_mode_id: mode,
-            });
+            try {
+                await session.query.setPermissionMode(mode);
+                session.mode = mode;
+                refreshSupportedModesForSession(session);
+                emitSessionUpdate(session.sessionId, {
+                    type: "current_mode_update",
+                    current_mode_id: mode,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (permissionModeFailureLooksUnsupported(mode, message)) {
+                    const changed = markModeUnavailableForSession(session, mode);
+                    if (changed && session.mode) {
+                        emitSessionUpdate(session.sessionId, {
+                            type: "mode_state_update",
+                            mode: buildModeState(session, session.mode),
+                        });
+                    }
+                }
+                slashError(command.session_id, `failed to set mode to ${mode}: ${message}`, requestId);
+            }
             return;
         }
         case "generate_session_title": {
@@ -347,6 +432,7 @@ async function handleCommand(command, requestId) {
                         subscription_type: account.subscriptionType,
                         token_source: account.tokenSource,
                         api_key_source: account.apiKeySource,
+                        api_provider: account.apiProvider,
                     },
                 });
                 writeEvent({
@@ -358,6 +444,7 @@ async function handleCommand(command, requestId) {
                         subscription_type: account.subscriptionType,
                         token_source: account.tokenSource,
                         api_key_source: account.apiKeySource,
+                        api_provider: account.apiProvider,
                     },
                 }, requestId);
             }
@@ -376,6 +463,100 @@ async function handleCommand(command, requestId) {
             }
             return;
         }
+        case "get_context_usage": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                const usage = await session.query.getContextUsage();
+                if (typeof usage.model === "string" && usage.model.trim().length > 0) {
+                    session.resolvedRuntimeModelId = usage.model.trim();
+                    refreshCurrentModel(session, true);
+                }
+                const rawPercentage = typeof usage.percentage === "number" ? usage.percentage : undefined;
+                const normalizedPercentage = rawPercentage === undefined || !Number.isFinite(rawPercentage)
+                    ? undefined
+                    : Math.max(0, Math.min(100, Math.round(rawPercentage)));
+                bridgeLogger.debug({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "context_usage_succeeded",
+                    message: "session context usage received from SDK",
+                    outcome: "success",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: {
+                        raw_percentage: rawPercentage,
+                        normalized_percentage: normalizedPercentage,
+                        total_tokens: typeof usage.totalTokens === "number" ? usage.totalTokens : undefined,
+                        max_tokens: typeof usage.maxTokens === "number" ? usage.maxTokens : undefined,
+                        raw_max_tokens: typeof usage.rawMaxTokens === "number" ? usage.rawMaxTokens : undefined,
+                        model: typeof usage.model === "string" ? usage.model : undefined,
+                    },
+                });
+                writeEvent({
+                    event: "context_usage",
+                    session_id: session.sessionId,
+                    ...(normalizedPercentage !== undefined ? { percentage: normalizedPercentage } : {}),
+                }, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "context_usage_failed",
+                    message: "failed to get session context usage",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                writeEvent({
+                    event: "context_usage",
+                    session_id: session.sessionId,
+                }, requestId);
+            }
+            return;
+        }
+        case "reload_plugins": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                const result = await session.query.reloadPlugins();
+                const commands = Array.isArray(result.commands)
+                    ? result.commands.map((entry) => ({
+                        name: entry.name,
+                        description: entry.description ?? "",
+                        input_hint: entry.argumentHint ?? undefined,
+                    }))
+                    : [];
+                emitSessionUpdate(session.sessionId, {
+                    type: "available_commands_update",
+                    commands,
+                });
+                emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
+                await handleMcpStatusCommand(session, requestId);
+                emitRuntimeReloadCompleted(session.sessionId, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "reload_plugins_failed",
+                    message: "failed to reload session plugins",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                emitRuntimeReloadFailed(session.sessionId, message, requestId);
+            }
+            return;
+        }
         case "mcp_status": {
             const session = sessionById(command.session_id);
             if (!session) {
@@ -465,6 +646,7 @@ async function handleCommand(command, requestId) {
                 ...(requestId ? { requestId } : {}),
             });
             process.exit(0);
+            return;
         default:
             bridgeLogger.error({
                 target: LOG_TARGETS.BRIDGE_PROTOCOL,