claude-code-rust 0.14.2 → 0.14.4

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

@@ -11,12 +11,20 @@ function isEffortLevel(value) {
 function normalizeModelKey(id) {
     const original = id.trim();
     if (!original) {
-        return { original, family: "unknown", versionParts: [], variantParts: [], buildParts: [] };
+        return {
+            original,
+            family: "unknown",
+            versionParts: [],
+            variantParts: [],
+            buildParts: [],
+        };
     }
     const lower = original.toLowerCase();
     const contextMatch = lower.match(/\[([^[\]]+)\]$/);
     const contextSuffix = contextMatch?.[1];
-    const withoutContext = contextMatch ? lower.slice(0, contextMatch.index) : lower;
+    const withoutContext = contextMatch
+        ? lower.slice(0, contextMatch.index)
+        : lower;
     const withoutPrefix = withoutContext.startsWith("claude-")
         ? withoutContext.slice("claude-".length)
         : withoutContext;
@@ -82,7 +90,8 @@ function modelKeysAreCompatible(leftId, rightId) {
 function sameContextSuffix(leftId, rightId) {
     const left = normalizeModelKey(leftId);
     const right = normalizeModelKey(rightId);
-    return (left.contextSuffix?.toLowerCase() ?? "") === (right.contextSuffix?.toLowerCase() ?? "");
+    return ((left.contextSuffix?.toLowerCase() ?? "") ===
+        (right.contextSuffix?.toLowerCase() ?? ""));
 }
 function sameFamilyAndVersion(leftId, rightId) {
     const left = normalizeModelKey(leftId);
@@ -129,7 +138,9 @@ function humanizeModelId(id) {
             : normalized.family === "sonnet"
                 ? "Sonnet"
                 : "Haiku";
-    const versionLabel = normalized.versionParts.length > 0 ? ` ${normalized.versionParts.join(".")}` : "";
+    const versionLabel = normalized.versionParts.length > 0
+        ? ` ${normalized.versionParts.join(".")}`
+        : "";
     const contextLabel = normalized.contextSuffix?.toLowerCase() === "1m"
         ? " [1M]"
         : normalized.contextSuffix
@@ -181,7 +192,8 @@ export function mapAvailableModels(models) {
     })
         .map((entry) => ({
         id: entry.value,
-        ...(typeof entry.resolvedModel === "string" && entry.resolvedModel.trim().length > 0
+        ...(typeof entry.resolvedModel === "string" &&
+            entry.resolvedModel.trim().length > 0
             ? { resolved_model: entry.resolvedModel.trim() }
             : {}),
         display_name: entry.displayName,
@@ -198,7 +210,8 @@ export function mapAvailableModels(models) {
         ...(typeof entry.supportsAutoMode === "boolean"
             ? { supports_auto_mode: entry.supportsAutoMode }
             : {}),
-        ...(typeof entry.description === "string" && entry.description.trim().length > 0
+        ...(typeof entry.description === "string" &&
+            entry.description.trim().length > 0
             ? { description: entry.description }
             : {}),
     }));

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

@@ -1,7 +1,13 @@
 const SESSION_PERMISSION_DESTINATIONS = new Set(["session", "cliArg"]);
-const PERSISTENT_PERMISSION_DESTINATIONS = new Set(["userSettings", "projectSettings", "localSettings"]);
+const PERSISTENT_PERMISSION_DESTINATIONS = new Set([
+    "userSettings",
+    "projectSettings",
+    "localSettings",
+]);
 function formatPermissionRule(rule) {
-    return rule.ruleContent === undefined ? rule.toolName : `${rule.toolName}(${rule.ruleContent})`;
+    return rule.ruleContent === undefined
+        ? rule.toolName
+        : `${rule.toolName}(${rule.ruleContent})`;
 }
 export function formatPermissionUpdates(updates) {
     if (!updates || updates.length === 0) {
@@ -9,8 +15,12 @@ export function formatPermissionUpdates(updates) {
     }
     return updates
         .map((update) => {
-        if (update.type === "addRules" || update.type === "replaceRules" || update.type === "removeRules") {
-            const rules = update.rules.map((rule) => formatPermissionRule(rule)).join(", ");
+        if (update.type === "addRules" ||
+            update.type === "replaceRules" ||
+            update.type === "removeRules") {
+            const rules = update.rules
+                .map((rule) => formatPermissionRule(rule))
+                .join(", ");
             return `${update.type}:${update.behavior}:${update.destination}=[${rules}]`;
         }
         if (update.type === "setMode") {
@@ -44,7 +54,9 @@ export function permissionOptionsFromSuggestions(suggestions) {
     const hasSessionScoped = scoped.session.length > 0;
     const hasPersistentScoped = scoped.persistent.length > 0;
     const sessionOnly = hasSessionScoped && !hasPersistentScoped;
-    const options = [{ option_id: "allow_once", name: "Allow once", kind: "allow_once" }];
+    const options = [
+        { option_id: "allow_once", name: "Allow once", kind: "allow_once" },
+    ];
     options.push({
         option_id: sessionOnly ? "allow_session" : "allow_always",
         name: sessionOnly ? "Allow for session" : "Always allow",
@@ -57,7 +69,11 @@ export function permissionResultFromOutcome(outcome, toolCallId, inputData, sugg
     const scopedSuggestions = splitPermissionSuggestionsByScope(suggestions);
     if (outcome.outcome === "selected") {
         if (outcome.option_id === "allow_once") {
-            return { behavior: "allow", updatedInput: inputData, toolUseID: toolCallId };
+            return {
+                behavior: "allow",
+                updatedInput: inputData,
+                toolUseID: toolCallId,
+            };
         }
         if (outcome.option_id === "allow_session") {
             const sessionSuggestions = scopedSuggestions.session;
@@ -105,7 +121,15 @@ export function permissionResultFromOutcome(outcome, toolCallId, inputData, sugg
                 toolUseID: toolCallId,
             };
         }
-        return { behavior: "deny", message: "Permission denied", toolUseID: toolCallId };
+        return {
+            behavior: "deny",
+            message: "Permission denied",
+            toolUseID: toolCallId,
+        };
     }
-    return { behavior: "deny", message: "Permission cancelled", toolUseID: toolCallId };
+    return {
+        behavior: "deny",
+        message: "Permission cancelled",
+        toolUseID: toolCallId,
+    };
 }

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

@@ -6,17 +6,19 @@ import { bridgeLogger, LOG_TARGETS, logSdkStderrLine } from "./logger.js";
 import { AsyncQueue } from "./shared.js";
 import { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
 import { failConnection, emitSessionUpdate, emitConnectEvent, emitPermissionRequestEvent, emitElicitationRequestEvent, emitUserDialogRequestEvent, } from "./events.js";
-import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.js";
+import { ensureToolCallVisible, setToolCallStatus } from "./tool_calls.js";
 import { isToolSearchToolName } from "./tooling.js";
 import { requestExitPlanModeApproval, requestAskUserQuestionAnswers, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "./user_interaction.js";
-import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
+import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents, } from "./agents.js";
 import { mapSdkSlashCommands, updateAvailableCommands, } from "./available_commands.js";
 import { emitAuthRequired, emitFastModeUpdate, setFastModeSnapshotIfChanged, } from "./error_classification.js";
 import { mapAvailableModels, resolveCurrentModel, currentModelsEqual, } from "./model_metadata.js";
 import { shouldEmitStartupAuthRequiredForAccount } from "./account_metadata.js";
 export { mapAvailableModels, resolveCurrentModel } from "./model_metadata.js";
 export { shouldEmitStartupAuthRequiredForAccount } from "./account_metadata.js";
-const BRIDGE_RUNTIME_PROCESS_NAME = process.platform === "win32" ? "claude-rs-bridge-bun.exe" : "claude-rs-bridge-bun";
+const BRIDGE_RUNTIME_PROCESS_NAME = process.platform === "win32"
+    ? "claude-rs-bridge-bun.exe"
+    : "claude-rs-bridge-bun";
 const BRIDGE_RUNTIME_GUARD_PROMPT = `Do not terminate the Claude Rust bridge runtime process \`${BRIDGE_RUNTIME_PROCESS_NAME}\`; ` +
     "when cleaning up development servers, only stop processes by explicit PIDs you started in this session.";
 const STARTUP_FALLBACK_MODEL_ALIAS = "fable";
@@ -82,7 +84,9 @@ function normalizeRefusalFallbackPayload(payload) {
             ? { guidance_text: optionalString(payload.guidanceText) }
             : {}),
         ...(optionalStringArray(payload.retractedMessageUuids) !== undefined
-            ? { retracted_message_uuids: optionalStringArray(payload.retractedMessageUuids) }
+            ? {
+                retracted_message_uuids: optionalStringArray(payload.retractedMessageUuids),
+            }
             : {}),
     };
 }
@@ -93,8 +97,14 @@ function normalizeRefusalFallbackPayload(payload) {
  */
 function buildRefusalFallbackOptions(payload) {
     return [
-        { option_id: "retry_fallback", label: `Switch to ${payload.fallback_model}` },
-        { option_id: "edit_prompt", label: `Edit prompt and retry with ${payload.original_model}` },
+        {
+            option_id: "retry_fallback",
+            label: `Switch to ${payload.fallback_model}`,
+        },
+        {
+            option_id: "edit_prompt",
+            label: `Edit prompt and retry with ${payload.original_model}`,
+        },
     ];
 }
 function settingsObjectFromLaunchSettings(launchSettings) {
@@ -110,7 +120,9 @@ function normalizedSettingsFromLaunchSettings(launchSettings) {
         ...settings,
         feedbackDrafts: "off",
     };
-    const sandbox = settings.sandbox && typeof settings.sandbox === "object" && !Array.isArray(settings.sandbox)
+    const sandbox = settings.sandbox &&
+        typeof settings.sandbox === "object" &&
+        !Array.isArray(settings.sandbox)
         ? settings.sandbox
         : undefined;
     if (sandbox?.enabled === true && sandbox.failIfUnavailable === undefined) {
@@ -247,10 +259,12 @@ export async function closeAllSessions(options = {}) {
 }
 export async function createSession(params) {
     const input = new AsyncQueue();
-    const provisionalSessionId = params.resume ?? randomUUID();
+    const provisionalSessionId = params.sessionId ??
+        (params.resume && !params.forkSession ? params.resume : randomUUID());
     const initialModel = initialSessionModel(params.launchSettings);
     const initialMode = initialSessionMode(params.launchSettings);
-    const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings).allowDangerouslySkipPermissions === true;
+    const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings)
+        .allowDangerouslySkipPermissions === true;
     const historyUpdateCount = params.resumeUpdates?.length ?? 0;
     const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
     const staleSessionBeforeRegisterCount = params.sessionsToCloseBeforeRegister?.length ?? 0;
@@ -260,7 +274,11 @@ export async function createSession(params) {
         const toolUseId = options.toolUseID;
         if (isToolSearchToolName(toolName)) {
             session?.hiddenToolUseIds.add(toolUseId);
-            return { behavior: "allow", updatedInput: inputData, toolUseID: toolUseId };
+            return {
+                behavior: "allow",
+                updatedInput: inputData,
+                toolUseID: toolUseId,
+            };
         }
         if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
             const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
@@ -321,6 +339,8 @@ export async function createSession(params) {
             connect_event: params.connectEvent,
             resume_requested: params.resume !== undefined,
             resume_session_at: params.resumeSessionAt ?? "<none>",
+            resume_drops_turn: params.resumeDropsTurn ?? "<none>",
+            fork_session: params.forkSession === true,
             history_update_count: historyUpdateCount,
             stale_session_count: staleSessionCount,
             stale_session_before_register_count: staleSessionBeforeRegisterCount,
@@ -333,6 +353,8 @@ export async function createSession(params) {
                 cwd: params.cwd,
                 resume: params.resume,
                 resumeSessionAt: params.resumeSessionAt,
+                resumeDropsTurn: params.resumeDropsTurn,
+                forkSession: params.forkSession,
                 launchSettings: params.launchSettings,
                 provisionalSessionId,
                 input,
@@ -379,6 +401,10 @@ export async function createSession(params) {
         query: queryHandle,
         input,
         connected: false,
+        ...(params.deferConnect ? { deferConnect: true } : {}),
+        ...(params.resumeDropsTurn
+            ? { resumeDropsTurn: params.resumeDropsTurn }
+            : {}),
         closing: false,
         connectEvent: params.connectEvent,
         connectRequestId: params.requestId,
@@ -400,7 +426,9 @@ export async function createSession(params) {
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
             ? { resumeUpdates: params.resumeUpdates }
             : {}),
-        ...(params.restoredInput !== undefined ? { restoredInput: params.restoredInput } : {}),
+        ...(params.restoredInput !== undefined
+            ? { restoredInput: params.restoredInput }
+            : {}),
         ...(params.pendingRewindResult !== undefined
             ? { pendingRewindResult: params.pendingRewindResult }
             : {}),
@@ -425,6 +453,8 @@ export async function createSession(params) {
             connect_event: session.connectEvent,
             resume_requested: params.resume !== undefined,
             resume_session_at: params.resumeSessionAt ?? "<none>",
+            resume_drops_turn: params.resumeDropsTurn ?? "<none>",
+            fork_session: params.forkSession === true,
         },
     });
     bridgeLogger.info({
@@ -451,10 +481,14 @@ export async function createSession(params) {
             eventName: "session_initialization_completed",
             message: "session initialization completed",
             outcome: "success",
-            ...(session.connectRequestId ? { requestId: session.connectRequestId } : {}),
+            ...(session.connectRequestId
+                ? { requestId: session.connectRequestId }
+                : {}),
             sessionId: session.sessionId,
             fields: {
-                available_model_count: Array.isArray(result.models) ? result.models.length : 0,
+                available_model_count: Array.isArray(result.models)
+                    ? result.models.length
+                    : 0,
                 connect_event: session.connectEvent,
                 history_update_count: session.resumeUpdates?.length ?? 0,
             },
@@ -464,7 +498,12 @@ export async function createSession(params) {
         const { buildModeState, refreshSupportedModesForSession } = await import("./commands.js");
         refreshSupportedModesForSession(session);
         const fastModeChanged = setFastModeSnapshotIfChanged(session, result.fast_mode_state, result.fast_mode_disabled_reason);
-        if (!session.connected) {
+        if (!session.connected &&
+            session.deferConnect &&
+            !session.initializationError) {
+            session.initializationReady = true;
+        }
+        else if (!session.connected) {
             emitConnectEvent(session);
         }
         else {
@@ -495,16 +534,21 @@ export async function createSession(params) {
             return;
         }
         const message = error instanceof Error ? error.message : String(error);
+        session.initializationError = message;
         bridgeLogger.error({
             target: LOG_TARGETS.APP_SESSION,
             eventName: "session_initialization_failed",
             message: "session initialization failed before connect",
             outcome: "failure",
-            ...(session.connectRequestId ? { requestId: session.connectRequestId } : {}),
+            ...(session.connectRequestId
+                ? { requestId: session.connectRequestId }
+                : {}),
             sessionId: session.sessionId,
             fields: { error_message: message },
         });
-        failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
+        if (!session.deferConnect) {
+            failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
+        }
         session.connectRequestId = undefined;
     });
     session.queryConsumerTask = (async () => {
@@ -528,11 +572,16 @@ export async function createSession(params) {
                     ...(params.requestId ? { requestId: params.requestId } : {}),
                     sessionId: session.sessionId,
                 });
-                failConnection("agent stream ended before session initialization", params.requestId);
+                session.initializationError =
+                    "agent stream ended before session initialization";
+                if (!session.deferConnect) {
+                    failConnection("agent stream ended before session initialization", params.requestId);
+                }
             }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            session.initializationError = message;
             bridgeLogger.error({
                 target: LOG_TARGETS.APP_SESSION,
                 eventName: "session_stream_failed_before_connect",
@@ -542,11 +591,65 @@ export async function createSession(params) {
                 sessionId: session.sessionId,
                 fields: { error_message: message },
             });
-            failConnection(`agent stream failed: ${message}`, params.requestId);
+            if (!session.deferConnect) {
+                failConnection(`agent stream failed: ${message}`, params.requestId);
+            }
         }
     })();
     return session;
 }
+export async function awaitSessionInitialization(session) {
+    await session.initializationTask;
+    if (session.deferConnect &&
+        session.resumeDropsTurn &&
+        !session.initializationError) {
+        // The guard is evaluated at fork time and a refusal is delivered as a result event,
+        // not as a rejected initialization request. A post-initialize control response is
+        // the protocol barrier proving that startup messages have reached the SDK; yield
+        // once more so the bridge's query consumer can process the already-enqueued result.
+        try {
+            await session.query.getContextUsage();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            bridgeLogger.warn({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_resume_guard_barrier_failed",
+                message: "guarded resume control fence failed",
+                outcome: "failure",
+                sessionId: session.sessionId,
+                fields: { error_message: message },
+            });
+            throw new Error(`guarded resume validation fence failed: ${message}`);
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+        session.resumeGuardFenceComplete = true;
+    }
+    if (session.initializationError) {
+        throw new Error(session.initializationError);
+    }
+    if (session.deferConnect && !session.initializationReady) {
+        throw new Error("candidate session did not reach initialization readiness");
+    }
+    if (!session.deferConnect && !session.connected) {
+        throw new Error("session did not connect after initialization");
+    }
+}
+export function commitDeferredSession(session) {
+    if (!session.deferConnect ||
+        !session.initializationReady ||
+        session.initializationError ||
+        (session.resumeDropsTurn !== undefined && !session.resumeGuardFenceComplete)) {
+        throw new Error("candidate session is not ready to commit");
+    }
+    const deferredAuthRequired = session.deferredAuthRequired;
+    session.deferredAuthRequired = undefined;
+    session.deferConnect = false;
+    emitConnectEvent(session);
+    if (deferredAuthRequired) {
+        emitAuthRequired(session, deferredAuthRequired.detail);
+    }
+}
 function logSdkProcessSpawnStarted(options, includeArgsPreview) {
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_SDK,
@@ -622,14 +725,19 @@ function startupModelOption(launchSettings) {
 }
 function initialSessionMode(launchSettings) {
     const settings = settingsObjectFromLaunchSettings(launchSettings);
-    const permissions = settings?.permissions && typeof settings.permissions === "object" && !Array.isArray(settings.permissions)
+    const permissions = settings?.permissions &&
+        typeof settings.permissions === "object" &&
+        !Array.isArray(settings.permissions)
         ? settings.permissions
         : undefined;
-    return permissionModeFromSettingsValue(permissions?.defaultMode) ?? DEFAULT_PERMISSION_MODE;
+    return (permissionModeFromSettingsValue(permissions?.defaultMode) ??
+        DEFAULT_PERMISSION_MODE);
 }
 function startupPermissionModeOptions(launchSettings) {
     const settings = settingsObjectFromLaunchSettings(launchSettings);
-    const permissions = settings?.permissions && typeof settings.permissions === "object" && !Array.isArray(settings.permissions)
+    const permissions = settings?.permissions &&
+        typeof settings.permissions === "object" &&
+        !Array.isArray(settings.permissions)
         ? settings.permissions
         : undefined;
     const permissionMode = permissionModeFromSettingsValue(permissions?.defaultMode);
@@ -667,10 +775,9 @@ export function buildQueryOptions(params) {
         includePartialMessages: true,
         promptSuggestions: true,
         enableFileCheckpointing: true,
-        // ProposeSkills reports only a proposal count and expects a native review
-        // surface. Keep it out of this host until claude-rs can display the actual
-        // proposal input and accept/reject it without losing content.
-        disallowedTools: ["ProposeSkills"],
+        // Proposal tools require native review and lifecycle surfaces that the
+        // public headless SDK does not currently expose to this host.
+        disallowedTools: ["ProposeSkills", "ProposeGoal"],
         executable: "bun",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
         settings,
@@ -679,7 +786,9 @@ export function buildQueryOptions(params) {
         toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
         systemPrompt,
         ...(params.launchSettings.agent_progress_summaries !== undefined
-            ? { agentProgressSummaries: params.launchSettings.agent_progress_summaries }
+            ? {
+                agentProgressSummaries: params.launchSettings.agent_progress_summaries,
+            }
             : {}),
         ...(params.claudeCodeExecutable
             ? { pathToClaudeCodeExecutable: params.claudeCodeExecutable }
@@ -724,10 +833,18 @@ export function buildQueryOptions(params) {
         // --setting-sources argument.
         settingSources: DEFAULT_SETTING_SOURCES,
         resume: params.resume,
-        ...(params.resumeSessionAt ? { resumeSessionAt: params.resumeSessionAt } : {}),
+        ...(params.resumeSessionAt
+            ? { resumeSessionAt: params.resumeSessionAt }
+            : {}),
+        ...(params.resumeDropsTurn
+            ? { resumeDropsTurn: params.resumeDropsTurn }
+            : {}),
+        ...(params.forkSession
+            ? { forkSession: true, sessionId: params.provisionalSessionId }
+            : {}),
         ...(shouldPassCanUseTool ? { canUseTool: params.canUseTool } : {}),
-        onElicitation: async (request) => {
-            const requestId = randomUUID();
+        onElicitation: async (request, options) => {
+            const requestId = options.requestId;
             const mode = request.mode === "form" || request.mode === "url"
                 ? request.mode
                 : typeof request.url === "string" && request.url.trim().length > 0
@@ -735,21 +852,26 @@ export function buildQueryOptions(params) {
                     : "form";
             const normalized = {
                 request_id: requestId,
-                server_name: typeof request.serverName === "string" && request.serverName.trim().length > 0
+                server_name: typeof request.serverName === "string" &&
+                    request.serverName.trim().length > 0
                     ? request.serverName
                     : "unknown",
-                message: typeof request.message === "string" && request.message.trim().length > 0
+                message: typeof request.message === "string" &&
+                    request.message.trim().length > 0
                     ? request.message
                     : "<no message>",
                 mode,
                 ...(typeof request.url === "string" && request.url.trim().length > 0
                     ? { url: request.url }
                     : {}),
-                ...(typeof request.elicitationId === "string" && request.elicitationId.trim().length > 0
+                ...(typeof request.elicitationId === "string" &&
+                    request.elicitationId.trim().length > 0
                     ? { elicitation_id: request.elicitationId }
                     : {}),
                 ...(request.requestedSchema
-                    ? { requested_schema: request.requestedSchema }
+                    ? {
+                        requested_schema: request.requestedSchema,
+                    }
                     : {}),
             };
             bridgeLogger.info({
@@ -781,8 +903,37 @@ export function buildQueryOptions(params) {
                     resolve({ action: "cancel" });
                     return;
                 }
+                if (currentSession.pendingElicitations.has(requestId)) {
+                    bridgeLogger.warn({
+                        target: LOG_TARGETS.BRIDGE_PERMISSION,
+                        eventName: "elicitation_request_dropped",
+                        message: "duplicate elicitation request dropped",
+                        outcome: "dropped",
+                        sessionId: params.sessionIdForLogs(),
+                        requestId,
+                        fields: { reason: "duplicate_request_id" },
+                    });
+                    resolve({ action: "cancel" });
+                    return;
+                }
+                let settled = false;
+                const settle = (result) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    currentSession.pendingElicitations.delete(requestId);
+                    options.signal.removeEventListener("abort", onAbort);
+                    resolve(result);
+                };
+                const onAbort = () => settle({ action: "cancel" });
+                if (options.signal.aborted) {
+                    settle({ action: "cancel" });
+                    return;
+                }
+                options.signal.addEventListener("abort", onAbort);
                 currentSession.pendingElicitations.set(requestId, {
-                    resolve,
+                    resolve: settle,
                     serverName: normalized.server_name,
                     elicitationId: normalized.elicitation_id,
                 });
@@ -807,13 +958,15 @@ export function buildQueryOptions(params) {
                     message: "request_user_dialog received for unknown kind; cancelled",
                     outcome: "cancelled",
                     sessionId: params.sessionIdForLogs(),
-                    ...(typeof request.toolUseID === "string" ? { toolCallId: request.toolUseID } : {}),
+                    ...(typeof request.toolUseID === "string"
+                        ? { toolCallId: request.toolUseID }
+                        : {}),
                     fields: { dialog_kind: request.dialogKind },
                 });
                 return { behavior: "cancelled" };
             }
             const payload = normalizeRefusalFallbackPayload(request.payload);
-            const requestId = randomUUID();
+            const requestId = options.requestId;
             const dialogRequest = {
                 request_id: requestId,
                 dialog_kind: REFUSAL_FALLBACK_DIALOG_KIND,
@@ -827,7 +980,9 @@ export function buildQueryOptions(params) {
                 outcome: "start",
                 sessionId: params.sessionIdForLogs(),
                 requestId,
-                ...(typeof request.toolUseID === "string" ? { toolCallId: request.toolUseID } : {}),
+                ...(typeof request.toolUseID === "string"
+                    ? { toolCallId: request.toolUseID }
+                    : {}),
                 fields: {
                     dialog_kind: request.dialogKind,
                     original_model: payload.original_model,
@@ -849,6 +1004,19 @@ export function buildQueryOptions(params) {
                     resolve("cancelled");
                     return;
                 }
+                if (currentSession.pendingUserDialogs.has(requestId)) {
+                    bridgeLogger.warn({
+                        target: LOG_TARGETS.APP_SESSION,
+                        eventName: "user_dialog_request_dropped",
+                        message: "duplicate user dialog request dropped",
+                        outcome: "dropped",
+                        sessionId: params.sessionIdForLogs(),
+                        requestId,
+                        fields: { reason: "duplicate_request_id" },
+                    });
+                    resolve("cancelled");
+                    return;
+                }
                 let settled = false;
                 const settle = (value) => {
                     if (settled) {
@@ -884,7 +1052,9 @@ export function handlePermissionResponse(command) {
         toolCallId: command.tool_call_id,
         fields: {
             response_kind: command.outcome.outcome,
-            selected_option: command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled",
+            selected_option: command.outcome.outcome === "selected"
+                ? command.outcome.option_id
+                : "cancelled",
         },
     });
     const session = sessionById(command.session_id);
@@ -1021,8 +1191,11 @@ export function handleQuestionResponse(command) {
         fields: {
             tool_name: resolver.toolName,
             response_kind: command.outcome.outcome,
-            selected_option_count: command.outcome.outcome === "answered" ? command.outcome.selected_option_ids.length : 0,
-            has_annotation: command.outcome.outcome === "answered" && command.outcome.annotation !== undefined,
+            selected_option_count: command.outcome.outcome === "answered"
+                ? command.outcome.selected_option_ids.length
+                : 0,
+            has_annotation: command.outcome.outcome === "answered" &&
+                command.outcome.annotation !== undefined,
         },
     });
     resolver.onOutcome(command.outcome);
@@ -1037,7 +1210,9 @@ export function handleUserDialogResponse(command) {
         requestId: command.request_id,
         fields: {
             response_kind: command.outcome.outcome,
-            selected_option: command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled",
+            selected_option: command.outcome.outcome === "selected"
+                ? command.outcome.option_id
+                : "cancelled",
         },
     });
     const session = sessionById(command.session_id);
@@ -1069,7 +1244,9 @@ export function handleUserDialogResponse(command) {
         return;
     }
     session.pendingUserDialogs.delete(command.request_id);
-    const choice = command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled";
+    const choice = command.outcome.outcome === "selected"
+        ? command.outcome.option_id
+        : "cancelled";
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_PERMISSION,
         eventName: "user_dialog_response_applied",
@@ -1136,9 +1313,11 @@ export function handleElicitationResponse(command) {
     });
     pending.resolve({
         action: command.action,
-        ...(normalizeSdkElicitationContent(command.content) ? {
-            content: normalizeSdkElicitationContent(command.content),
-        } : {}),
+        ...(normalizeSdkElicitationContent(command.content)
+            ? {
+                content: normalizeSdkElicitationContent(command.content),
+            }
+            : {}),
     });
 }
 export function shouldInvalidateResolvedRuntimeModel(previousRequestedId, previousSessionModel, nextRequestedId) {