claude-code-rust 0.12.2 → 0.12.4

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

@@ -23,6 +23,8 @@ const WORKFLOW_TOOL_NAME = "Workflow";
 const PROJECTS_TOOL_NAME = "Projects";
 const ARTIFACT_TOOL_NAME = "Artifact";
 const SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME = "ShowOnboardingRolePicker";
+const READ_MCP_RESOURCE_TOOL_NAME = "ReadMcpResource";
+const READ_MCP_RESOURCE_DIR_TOOL_NAME = "ReadMcpResourceDir";
 const SEARCH_OUTPUT_MODES = new Set(["content", "files_with_matches", "count"]);
 function isCronToolName(name) {
     return CRON_TOOL_NAMES.has(name);
@@ -50,6 +52,12 @@ function inputBoolean(input, key) {
 function isAgentLikeToolName(name) {
     return name === "Agent" || name === "Task";
 }
+export function isShellToolName(name) {
+    return name === "Bash" || name === "PowerShell";
+}
+function isMcpResourceReadToolName(name) {
+    return name === READ_MCP_RESOURCE_TOOL_NAME || name === READ_MCP_RESOURCE_DIR_TOOL_NAME;
+}
 function agentInputTitle(name, input) {
     if (!isAgentLikeToolName(name)) {
         return undefined;
@@ -135,11 +143,13 @@ function formatGrepTitle(input) {
     return flags.length > 0 ? `${scoped} (${flags.join(", ")})` : scoped;
 }
 export function normalizeToolKind(name) {
+    if (isShellToolName(name)) {
+        return "execute";
+    }
     switch (name) {
-        case "Bash":
-            return "execute";
         case "Read":
-        case "ReadMcpResource":
+        case READ_MCP_RESOURCE_TOOL_NAME:
+        case READ_MCP_RESOURCE_DIR_TOOL_NAME:
             return "read";
         case "Write":
         case "Edit":
@@ -189,7 +199,7 @@ export function toolTitle(name, input, context = {}) {
     if (agentTitle) {
         return agentTitle;
     }
-    if (name === "Bash") {
+    if (isShellToolName(name)) {
         const command = typeof input.command === "string" ? input.command : "";
         return command || "Terminal";
     }
@@ -264,14 +274,14 @@ export function toolTitle(name, input, context = {}) {
     if ((name === "Read" || name === "Write" || name === "Edit") && typeof input.file_path === "string") {
         return `${name} ${input.file_path}`;
     }
-    if (name === "ReadMcpResource") {
+    if (isMcpResourceReadToolName(name)) {
         const uri = typeof input.uri === "string" ? input.uri : "";
         const server = typeof input.server === "string" ? input.server : "";
         if (server && uri) {
-            return `ReadMcpResource ${server} ${uri}`;
+            return `${name} ${server} ${uri}`;
         }
         if (uri) {
-            return `ReadMcpResource ${uri}`;
+            return `${name} ${uri}`;
         }
     }
     return name;
@@ -436,6 +446,37 @@ function mcpResourceContentFromResult(rawResult, rawContent) {
     }
     return [];
 }
+function mcpResourceDirTextFromResult(toolName, rawResult, rawContent) {
+    if (toolName !== READ_MCP_RESOURCE_DIR_TOOL_NAME) {
+        return undefined;
+    }
+    for (const candidate of collectResultCandidates(rawResult, rawContent)) {
+        if (!Array.isArray(candidate.resources)) {
+            continue;
+        }
+        const lines = [];
+        for (const entry of candidate.resources) {
+            const record = asRecordOrNull(entry);
+            if (!record) {
+                continue;
+            }
+            const name = nonEmptyString(record.name);
+            const uri = nonEmptyString(record.uri);
+            if (!name || !uri) {
+                continue;
+            }
+            const mimeType = nonEmptyString(record.mimeType);
+            const suffix = mimeType
+                ? mimeType === "inode/directory"
+                    ? " (directory)"
+                    : ` (${mimeType})`
+                : "";
+            lines.push(`${name} - ${uri}${suffix}`);
+        }
+        return lines.length > 0 ? lines.join("\n") : "No resources found.";
+    }
+    return undefined;
+}
 function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     const candidates = collectResultCandidates(rawResult, rawContent);
     const metadata = {};
@@ -684,14 +725,14 @@ function editDiffFromResult(rawResult, rawInput) {
     }
     return editDiffFromInput(rawInput);
 }
-function findBashResultRecord(rawResult, rawContent) {
+function findShellResultRecord(rawResult, rawContent) {
     return resultRecordCandidates(rawResult, rawContent).find((candidate) => "stdout" in candidate ||
         "stderr" in candidate ||
         "backgroundTaskId" in candidate ||
         "backgroundedByUser" in candidate ||
         "assistantAutoBackgrounded" in candidate);
 }
-function bashBackgroundMessage(record) {
+function shellBackgroundMessage(record) {
     const backgroundTaskId = typeof record.backgroundTaskId === "string" ? record.backgroundTaskId : "";
     if (!backgroundTaskId) {
         return "";
@@ -704,7 +745,7 @@ function bashBackgroundMessage(record) {
     }
     return `Command is running in background with ID: ${backgroundTaskId}.`;
 }
-function buildBashDisplayOutput(record) {
+function buildShellDisplayOutput(record) {
     const segments = [];
     const stdout = typeof record.stdout === "string" ? record.stdout : "";
     const stderr = typeof record.stderr === "string" ? record.stderr : "";
@@ -717,7 +758,7 @@ function buildBashDisplayOutput(record) {
     if (record.interrupted === true) {
         segments.push("Command was aborted before completion.");
     }
-    const backgroundMessage = bashBackgroundMessage(record);
+    const backgroundMessage = shellBackgroundMessage(record);
     if (backgroundMessage) {
         segments.push(backgroundMessage);
     }
@@ -1600,8 +1641,8 @@ function enterPlanModeStructuredOutputHandled(toolName, rawResult, rawContent) {
     }
     return false;
 }
-function readMcpResourceErrorText(toolName, rawResult, rawContent) {
-    if (toolName !== "ReadMcpResource") {
+function mcpResourceReadErrorText(toolName, rawResult, rawContent) {
+    if (!isMcpResourceReadToolName(toolName)) {
         return undefined;
     }
     for (const candidate of collectResultCandidates(rawResult, rawContent)) {
@@ -1671,13 +1712,23 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
     if (agentTitle) {
         fields.title = agentTitle;
     }
-    const readMcpResourceError = readMcpResourceErrorText(toolName, rawResult, rawContent);
+    const readMcpResourceError = mcpResourceReadErrorText(toolName, rawResult, rawContent);
     if (readMcpResourceError) {
         fields.status = "failed";
         fields.raw_output = readMcpResourceError;
         fields.content = [{ type: "content", content: { type: "text", text: readMcpResourceError } }];
         return fields;
     }
+    const readMcpResourceDirOutput = !isError
+        ? mcpResourceDirTextFromResult(toolName, rawResult, rawContent)
+        : undefined;
+    if (readMcpResourceDirOutput !== undefined) {
+        fields.raw_output = readMcpResourceDirOutput;
+        fields.content = [
+            { type: "content", content: { type: "text", text: readMcpResourceDirOutput } },
+        ];
+        return fields;
+    }
     const searchOutput = !isError ? searchResultText(toolName, rawResult, rawContent) : undefined;
     if (searchOutput !== undefined) {
         fields.raw_output = searchOutput;
@@ -1777,10 +1828,12 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
         }
         return fields;
     }
-    const bashResultRecord = toolName === "Bash" ? findBashResultRecord(rawResult, rawContent) : undefined;
+    const shellResultRecord = isShellToolName(toolName)
+        ? findShellResultRecord(rawResult, rawContent)
+        : undefined;
     const normalizedRawOutput = normalizeToolResultText(rawContent, isError);
-    const rawOutput = bashResultRecord
-        ? buildBashDisplayOutput(bashResultRecord)
+    const rawOutput = shellResultRecord
+        ? buildShellDisplayOutput(shellResultRecord)
         : normalizedRawOutput || JSON.stringify(rawContent);
     if (rawOutput && !(isTaskToolName(toolName) && !isError)) {
         fields.raw_output = rawOutput;
@@ -1820,7 +1873,7 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
             return fields;
         }
     }
-    if (!isError && toolName === "ReadMcpResource") {
+    if (!isError && toolName === READ_MCP_RESOURCE_TOOL_NAME) {
         const structuredResourceContent = mcpResourceContentFromResult(rawResult, rawContent);
         if (structuredResourceContent.length > 0) {
             fields.content = structuredResourceContent;

package/agent-sdk/dist/bridge.js

@@ -18,7 +18,7 @@ import { bridgeLogger, LOG_TARGETS, logBridgeCommandReceived } from "./bridge/lo
 export { AsyncQueue } from "./bridge/shared.js";
 export { asRecordOrNull } from "./bridge/shared.js";
 export { CACHE_SPLIT_POLICY, previewKilobyteLabel } from "./bridge/cache_policy.js";
-export { buildToolResultFields, createToolCall, normalizeToolKind, normalizeToolResultText, unwrapToolUseResult, } from "./bridge/tooling.js";
+export { buildToolResultFields, createToolCall, isShellToolName, normalizeToolKind, normalizeToolResultText, unwrapToolUseResult, } from "./bridge/tooling.js";
 export { looksLikeAuthRequired } from "./bridge/auth.js";
 export { parseCommandEnvelope } from "./bridge/commands.js";
 export { buildSessionListOptions } from "./bridge/events.js";
@@ -36,6 +36,63 @@ export { MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS, staleMcpAuthCandidates };
 export function buildSessionMutationOptions(cwd) {
     return cwd ? { dir: cwd } : undefined;
 }
+function normalizeRewindTargetText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function userTextPartsFromSessionMessage(message) {
+    const record = message;
+    if (record.type !== "user") {
+        return undefined;
+    }
+    const payload = record.message;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return undefined;
+    }
+    const content = payload.content;
+    if (typeof content === "string") {
+        const firstText = normalizeRewindTargetText(content);
+        return firstText ? { firstText, inputText: content } : undefined;
+    }
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    const textBlocks = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object" || Array.isArray(block)) {
+            continue;
+        }
+        const blockRecord = block;
+        if (blockRecord.type === "text" && typeof blockRecord.text === "string") {
+            textBlocks.push(blockRecord.text);
+        }
+    }
+    const firstText = textBlocks.map(normalizeRewindTargetText).find((text) => text.length > 0);
+    return firstText ? { firstText, inputText: textBlocks.join("\n").trim() } : undefined;
+}
+export function rewindTargetsFromSessionMessages(messages) {
+    const targets = [];
+    let previousAssistantUuid;
+    messages.forEach((message, index) => {
+        const record = message;
+        const uuid = typeof record.uuid === "string" ? record.uuid.trim() : "";
+        if (record.type === "assistant" && uuid) {
+            previousAssistantUuid = uuid;
+            return;
+        }
+        const textParts = userTextPartsFromSessionMessage(message);
+        if (!uuid || !textParts) {
+            return;
+        }
+        targets.push({
+            uuid,
+            first_text: textParts.firstText,
+            input_text: textParts.inputText,
+            index,
+            ...(previousAssistantUuid ? { previous_assistant_uuid: previousAssistantUuid } : {}),
+        });
+    });
+    return targets.reverse();
+}
 export function canGenerateSessionTitle(query) {
     return typeof query.generateSessionTitle === "function";
 }
@@ -72,7 +129,7 @@ export function emitAgentConfigOptionUpdate(sessionId, agent) {
         value: agent,
     });
 }
-const EXPECTED_AGENT_SDK_VERSION = "0.3.177";
+const EXPECTED_AGENT_SDK_VERSION = "0.3.193";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {
@@ -119,6 +176,309 @@ export async function handleReloadPluginsCommand(session, requestId) {
         emitRuntimeReloadFailed(session.sessionId, message, requestId);
     }
 }
+function resolveRewindTarget(messages, targetUserMessageId) {
+    let previousAssistantUuid;
+    let textUserCountBeforeTarget = 0;
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        const record = message;
+        const uuid = typeof record.uuid === "string" ? record.uuid.trim() : "";
+        if (record.type === "assistant" && uuid) {
+            previousAssistantUuid = uuid;
+            continue;
+        }
+        const textParts = userTextPartsFromSessionMessage(message);
+        if (!textParts) {
+            continue;
+        }
+        if (uuid === targetUserMessageId) {
+            if (!previousAssistantUuid && textUserCountBeforeTarget > 0) {
+                return null;
+            }
+            if (previousAssistantUuid) {
+                const anchorIndex = messages.findIndex((candidate) => {
+                    const candidateRecord = candidate;
+                    return candidateRecord.uuid === previousAssistantUuid;
+                });
+                if (anchorIndex < 0) {
+                    return null;
+                }
+                return {
+                    inputText: textParts.inputText,
+                    previousAssistantUuid,
+                    targetIndex: index,
+                    retainedMessages: messages.slice(0, anchorIndex + 1),
+                };
+            }
+            return {
+                inputText: textParts.inputText,
+                targetIndex: index,
+                retainedMessages: [],
+            };
+        }
+        if (uuid) {
+            textUserCountBeforeTarget += 1;
+        }
+    }
+    return null;
+}
+export function buildRewindConversationPlan(messages, targetUserMessageId) {
+    const resolved = resolveRewindTarget(messages, targetUserMessageId);
+    if (!resolved) {
+        return null;
+    }
+    return {
+        ...resolved,
+        resumeUpdates: mapSessionMessagesToUpdates(resolved.retainedMessages),
+    };
+}
+function mapRewindFilesResult(result) {
+    return {
+        can_rewind: result.canRewind,
+        ...(result.error ? { error: result.error } : {}),
+        files_changed: result.filesChanged ?? [],
+        ...(result.insertions !== undefined ? { insertions: result.insertions } : {}),
+        ...(result.deletions !== undefined ? { deletions: result.deletions } : {}),
+    };
+}
+async function rewindFiles(session, targetUserMessageId, dryRun) {
+    if (typeof session.query.rewindFiles !== "function") {
+        return {
+            can_rewind: false,
+            error: "file rewind is not supported by this SDK runtime",
+            files_changed: [],
+        };
+    }
+    return mapRewindFilesResult(await session.query.rewindFiles(targetUserMessageId, { dryRun }));
+}
+function emitRewindResult(sessionId, restoreMode, status, requestId, fileResult, message) {
+    writeEvent({
+        event: "rewind_result",
+        session_id: sessionId,
+        restore_mode: restoreMode,
+        status,
+        ...(fileResult ? { file_result: fileResult } : {}),
+        ...(message ? { message } : {}),
+    }, requestId);
+}
+async function replaceConversationForRewind(command, session, targetUserMessageId, requestId, pendingRewindResult) {
+    const historyMessages = await getSessionMessages(command.session_id, {
+        dir: session.cwd,
+        includeSystemMessages: true,
+    });
+    const resolved = buildRewindConversationPlan(historyMessages, targetUserMessageId);
+    if (!resolved) {
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_failed",
+            message: "conversation rewind target was stale or inconsistent",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                history_message_count: historyMessages.length,
+                reason: "target_not_found_or_inconsistent",
+            },
+        });
+        throw new Error(`unknown rewind target: ${targetUserMessageId}`);
+    }
+    const resumeUpdates = resolved.resumeUpdates;
+    const staleSessions = Array.from(sessions.values());
+    setSessionListingDir(session.cwd);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "rewind_target_resolved",
+        message: "conversation rewind target resolved",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            target_user_message_id: targetUserMessageId,
+            target_index: resolved.targetIndex,
+            previous_assistant_uuid: resolved.previousAssistantUuid ?? "<none>",
+            history_message_count: historyMessages.length,
+            retained_message_count: resolved.retainedMessages.length,
+            retained_update_count: resumeUpdates.length,
+            stale_session_count: staleSessions.length,
+        },
+    });
+    if (!resolved.previousAssistantUuid) {
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_first_message_branch",
+            message: "conversation rewind target is first user message; creating fresh replacement",
+            outcome: "start",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                history_message_count: historyMessages.length,
+                stale_session_count: staleSessions.length,
+            },
+        });
+        await createSession({
+            cwd: session.cwd,
+            launchSettings: command.launch_settings,
+            connectEvent: "session_replaced",
+            requestId,
+            restoredInput: resolved.inputText,
+            ...(pendingRewindResult ? { pendingRewindResult } : {}),
+            ...(staleSessions.length > 0 ? { sessionsToCloseAfterConnect: staleSessions } : {}),
+        });
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_replacement_created",
+            message: "conversation rewind replacement session created",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                resume_session_at: "<none>",
+                retained_message_count: 0,
+                retained_update_count: 0,
+                stale_session_count: staleSessions.length,
+            },
+        });
+        return;
+    }
+    const sessionsToCloseAfterConnect = staleSessions.filter((stale) => stale !== session);
+    await createSession({
+        cwd: session.cwd,
+        resume: command.session_id,
+        resumeSessionAt: resolved.previousAssistantUuid,
+        launchSettings: command.launch_settings,
+        connectEvent: "session_replaced",
+        requestId,
+        sessionsToCloseBeforeRegister: [session],
+        ...(resumeUpdates.length > 0 ? { resumeUpdates } : {}),
+        restoredInput: resolved.inputText,
+        ...(pendingRewindResult ? { pendingRewindResult } : {}),
+        ...(sessionsToCloseAfterConnect.length > 0 ? { sessionsToCloseAfterConnect } : {}),
+    });
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "rewind_replacement_created",
+        message: "conversation rewind replacement session created",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        sessionId: command.session_id,
+        fields: {
+            target_user_message_id: targetUserMessageId,
+            resume_session_at: resolved.previousAssistantUuid,
+            retained_message_count: resolved.retainedMessages.length,
+            retained_update_count: resumeUpdates.length,
+            stale_session_count: staleSessions.length,
+        },
+    });
+}
+async function handleRewind(command, requestId) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+        return;
+    }
+    const targetUserMessageId = command.target_user_message_id.trim();
+    if (!targetUserMessageId) {
+        slashError(command.session_id, "rewind target cannot be empty", requestId);
+        return;
+    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "rewind_requested",
+        message: "rewind requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            target_user_message_id: targetUserMessageId,
+            restore_mode: command.restore_mode,
+        },
+    });
+    if (command.restore_mode === "conversation") {
+        try {
+            await replaceConversationForRewind(command, session, targetUserMessageId, requestId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            bridgeLogger.error({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "rewind_failed",
+                message: "conversation rewind failed",
+                outcome: "failure",
+                ...(requestId ? { requestId } : {}),
+                sessionId: session.sessionId,
+                fields: {
+                    target_user_message_id: targetUserMessageId,
+                    restore_mode: command.restore_mode,
+                    error_message: message,
+                },
+            });
+            slashError(command.session_id, `failed to rewind conversation: ${message}`, requestId);
+        }
+        return;
+    }
+    let appliedFileResult;
+    try {
+        const dryRunResult = await rewindFiles(session, targetUserMessageId, true);
+        if (!dryRunResult.can_rewind) {
+            slashError(command.session_id, dryRunResult.error ?? "failed to dry-run file rewind", requestId);
+            return;
+        }
+        appliedFileResult = await rewindFiles(session, targetUserMessageId, false);
+        if (!appliedFileResult.can_rewind) {
+            slashError(command.session_id, appliedFileResult.error ?? "failed to restore code", requestId);
+            return;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_failed",
+            message: "file rewind failed",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                restore_mode: command.restore_mode,
+                error_message: message,
+            },
+        });
+        slashError(command.session_id, `failed to restore code: ${message}`, requestId);
+        return;
+    }
+    if (command.restore_mode === "code") {
+        emitRewindResult(session.sessionId, command.restore_mode, "success", requestId, appliedFileResult);
+        return;
+    }
+    try {
+        await replaceConversationForRewind(command, session, targetUserMessageId, requestId, {
+            event: "rewind_result",
+            restore_mode: command.restore_mode,
+            status: "success",
+            file_result: appliedFileResult,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "rewind_failed",
+            message: "conversation rewind failed after file restore",
+            outcome: "partial_failure",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                target_user_message_id: targetUserMessageId,
+                restore_mode: command.restore_mode,
+                error_message: message,
+            },
+        });
+        emitRewindResult(session.sessionId, command.restore_mode, "partial_failure", requestId, appliedFileResult, `Code was restored, but the conversation could not be rewound: ${message}`);
+    }
+}
 async function handleCommand(command, requestId) {
     logBridgeCommandReceived(command, requestId);
     const sdkVersionError = agentSdkVersionCompatibilityError();
@@ -597,6 +957,54 @@ async function handleCommand(command, requestId) {
             }
             return;
         }
+        case "get_rewind_targets": {
+            const session = sessionById(command.session_id);
+            if (!session) {
+                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                return;
+            }
+            try {
+                const historyMessages = await getSessionMessages(command.session_id, {
+                    dir: session.cwd,
+                    includeSystemMessages: true,
+                });
+                const targets = rewindTargetsFromSessionMessages(historyMessages);
+                bridgeLogger.info({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "rewind_targets_loaded",
+                    message: "rewind targets loaded from session history",
+                    outcome: "success",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: {
+                        history_message_count: historyMessages.length,
+                        target_count: targets.length,
+                    },
+                });
+                writeEvent({
+                    event: "rewind_targets",
+                    session_id: session.sessionId,
+                    targets,
+                }, requestId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                bridgeLogger.warn({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "rewind_targets_failed",
+                    message: "failed to load rewind targets",
+                    outcome: "failure",
+                    ...(requestId ? { requestId } : {}),
+                    sessionId: session.sessionId,
+                    fields: { error_message: message },
+                });
+                slashError(command.session_id, `failed to load rewind targets: ${message}`, requestId);
+            }
+            return;
+        }
+        case "rewind":
+            await handleRewind(command, requestId);
+            return;
         case "reload_plugins": {
             const session = sessionById(command.session_id);
             if (!session) {