feat(web): add reasoning cycle keybindings

apps/server/src/keybindings.test.ts

@@ -188,6 +188,35 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
     }).pipe(Effect.provide(makeKeybindingsLayer())),
   );
 
+  it.effect("ships configurable thread navigation defaults", () =>
+    Effect.sync(() => {
+      const defaultsByCommand = new Map(
+        Keybindings.DEFAULT_KEYBINDINGS.map((binding) => [binding.command, binding.key] as const),
+      );
+
+      assert.equal(defaultsByCommand.get("thread.previous"), "mod+shift+[");
+      assert.equal(defaultsByCommand.get("thread.next"), "mod+shift+]");
+      assert.equal(defaultsByCommand.get("thread.copyReference"), "mod+shift+c");
+      assert.equal(defaultsByCommand.get("thread.settle"), "mod+shift+s");
+      assert.equal(defaultsByCommand.get("thread.pin"), "mod+shift+p");
+      assert.equal(defaultsByCommand.get("thread.jump.1"), "mod+1");
+      assert.equal(defaultsByCommand.get("thread.jump.9"), "mod+9");
+      assert.equal(defaultsByCommand.get("modelPicker.toggle"), "mod+shift+m");
+      assert.equal(defaultsByCommand.get("themeEditor.toggle"), "mod+alt+shift+t");
+      assert.equal(defaultsByCommand.get("filePicker.toggle"), "mod+p");
+      assert.equal(defaultsByCommand.get("projectSearch.toggle"), "mod+shift+f");
+      assert.equal(defaultsByCommand.get("sidebar.toggle"), "mod+b");
+      assert.equal(defaultsByCommand.get("rightPanel.toggle"), "mod+alt+b");
+      assert.isFalse(defaultsByCommand.has("rightPanel.toggleMaximized"));
+      assert.equal(defaultsByCommand.get("rightPanel.close"), "mod+w");
+      assert.equal(defaultsByCommand.get("terminal.splitVertical"), "mod+shift+d");
+      assert.equal(defaultsByCommand.get("modelPicker.jump.1"), "mod+1");
+      assert.equal(defaultsByCommand.get("modelPicker.jump.9"), "mod+9");
+      assert.equal(defaultsByCommand.get("reasoning.decrease"), "mod+alt+,");
+      assert.equal(defaultsByCommand.get("reasoning.increase"), "mod+alt+.");
+    }),
+  );
+
   it.effect("uses defaults in runtime when config is malformed without overriding file", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;

apps/web/src/components/chat/ChatComposer.tsx

@@ -49,8 +49,12 @@ import {
   wouldTextPasteExceedLimit,
 } from "@t3tools/client-runtime/text-paste";
 import { serializeComposerFileLink } from "@t3tools/shared/composerTrigger";
+import {
+  createModelSelection,
+  normalizeModelSlug,
+  resolveReasoningTransition,
+} from "@t3tools/shared/model";
 import { folderDropTarget, resolveDroppedFolderPath } from "./folderDrop";
-import { createModelSelection, normalizeModelSlug } from "@t3tools/shared/model";
 import { USAGE_LIMITS_COMMAND } from "@t3tools/shared/usageLimits";
 import {
   memo,
@@ -76,6 +80,7 @@ import {
   detectComposerTrigger,
   expandCollapsedComposerCursor,
   formatAssistantCitationForComposer,
+  mapComposerCursorAcrossLeadingPromptChange,
   replaceTextRange,
 } from "../../composer-logic";
 import { DISCONNECTED_COMPOSER_PLACEHOLDER } from "../../composerPlaceholder";
@@ -178,7 +183,11 @@ import {
 import { isCommandPaletteOpen } from "../../commandPaletteBus";
 import { getTerminalFocusOwner } from "../../lib/terminalFocus";
 import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
-import { resolveShortcutCommand, shortcutLabelForCommand } from "../../keybindings";
+import {
+  reasoningCycleDirectionFromCommand,
+  resolveShortcutCommand,
+  shortcutLabelForCommand,
+} from "../../keybindings";
 import {
   type TerminalContextDraft,
   type TerminalContextSelection,
@@ -943,6 +952,7 @@ import {
   XIcon,
 } from "lucide-react";
 import { proposedPlanTitle } from "../../proposedPlan";
+import { getProviderModelCapabilities } from "../../providerModels";
 import { hasProviderSetup } from "./ProviderStatusBanner";
 import {
   applyProviderInstanceSettings,
@@ -1745,6 +1755,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
           })
       : null);
   const setComposerDraftPrompt = useComposerDraftStore((store) => store.setPrompt);
+  const setProviderModelOptions = useComposerDraftStore((store) => store.setProviderModelOptions);
   const addComposerDraftImages = useComposerDraftStore((store) => store.addImages);
   const removeComposerDraftImage = useComposerDraftStore((store) => store.removeImage);
   const addComposerDraftFiles = useComposerDraftStore((store) => store.addFiles);
@@ -3054,10 +3065,27 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   // ------------------------------------------------------------------
   // Sync refs back to parent
   // ------------------------------------------------------------------
+  const restoreDraftAfterPendingRef = useRef(false);
   useEffect(() => {
+    // While a pending question is visible, promptRef is temporarily the
+    // custom-answer buffer. Restore the draft as soon as that editor state
+    // ends, even when the draft prompt itself did not change.
+    if (activePendingProgress !== null) {
+      restoreDraftAfterPendingRef.current = true;
+      return;
+    }
     promptRef.current = prompt;
+    if (restoreDraftAfterPendingRef.current) {
+      // The cursor and trigger still describe the custom-answer buffer, or a
+      // draft that changed while hidden behind an approval, so rebuild both
+      // from the restored draft instead of clamping them.
+      restoreDraftAfterPendingRef.current = false;
+      setComposerCursor(collapseExpandedComposerCursor(prompt, prompt.length));
+      setComposerTrigger(detectComposerTrigger(prompt, prompt.length));
+      return;
+    }
     setComposerCursor((existing) => clampCollapsedComposerCursor(prompt, existing));
-  }, [prompt, promptRef]);
+  }, [activePendingProgress, prompt, promptRef]);
 
   useEffect(() => {
     if (composerSubmissionError === null) return;
@@ -5207,6 +5235,87 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     setIsStashMenuOpen(false);
   }, [prompt]);
 
+  const applyReasoningCycle = useCallback(
+    (direction: "increase" | "decrease") => {
+      const editorShowsDraftPrompt = !isComposerApprovalState && activePendingProgress === null;
+      const currentPrompt = editorShowsDraftPrompt
+        ? promptRef.current
+        : (getComposerDraft(composerDraftTarget)?.prompt ?? "");
+      const currentModelOptions = composerModelOptions?.[selectedInstanceId];
+      const transition = resolveReasoningTransition({
+        capabilities: getProviderModelCapabilities(
+          selectedProviderModels,
+          selectedModel,
+          selectedProvider,
+          settings.planModeEnabled,
+        ),
+        modelOptions: currentModelOptions,
+        prompt: currentPrompt,
+        action: { type: "cycle", direction },
+      });
+      if (transition.status === "blocked") {
+        toastManager.add({
+          type: "info",
+          title: "Remove “ultrathink” from the prompt text to change reasoning.",
+        });
+        return;
+      }
+      if (transition.status === "unsupported") {
+        toastManager.add({
+          type: "info",
+          title: "This model has no reasoning levels to switch between.",
+        });
+        return;
+      }
+      if (transition.status !== "changed") return;
+      if (transition.prompt !== currentPrompt) {
+        setPrompt(transition.prompt);
+        // When a pending question or approval hides the editor, the draft
+        // is updated in the store only. The cursor and trigger belong to
+        // the visible editor state and are rebuilt from the draft by the
+        // sync effect once it is shown again.
+        if (!editorShowsDraftPrompt) {
+          restoreDraftAfterPendingRef.current = true;
+        } else {
+          // The editor is mounted whenever it shows the draft; the fallback
+          // only guards the ref during teardown.
+          const currentExpandedCursor =
+            composerEditorRef.current?.readSnapshot().expandedCursor ?? currentPrompt.length;
+          const nextExpandedCursor = mapComposerCursorAcrossLeadingPromptChange(
+            currentPrompt,
+            transition.prompt,
+            currentExpandedCursor,
+          );
+          promptRef.current = transition.prompt;
+          setComposerCursor(collapseExpandedComposerCursor(transition.prompt, nextExpandedCursor));
+          setComposerTrigger(detectComposerTrigger(transition.prompt, nextExpandedCursor));
+        }
+      }
+      if (transition.modelOptions !== currentModelOptions) {
+        setProviderModelOptions(composerDraftTarget, selectedProvider, transition.modelOptions, {
+          instanceId: selectedInstanceId,
+          model: selectedModel,
+          persistSticky: true,
+        });
+      }
+    },
+    [
+      activePendingProgress,
+      composerDraftTarget,
+      composerModelOptions,
+      getComposerDraft,
+      isComposerApprovalState,
+      promptRef,
+      selectedInstanceId,
+      selectedModel,
+      selectedProvider,
+      selectedProviderModels,
+      setPrompt,
+      setProviderModelOptions,
+      settings.planModeEnabled,
+    ],
+  );
+
   useEffect(() => {
     const handler = (event: globalThis.KeyboardEvent) => {
       const command = resolveShortcutCommand(event, keybindings, {
@@ -5216,14 +5325,20 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
           modelPickerOpen: isComposerModelPickerOpen,
         },
       });
-      if (command !== "composer.stash") return;
-      // Always claim the shortcut so the browser save dialog never opens,
-      // even when the composer is in a state that can't stash.
+      const reasoningDirection = reasoningCycleDirectionFromCommand(command);
+      if (command !== "composer.stash" && reasoningDirection === null) return;
+      // Always claim recognized composer shortcuts, including in states where
+      // the requested mutation is unavailable.
       event.preventDefault();
       event.stopPropagation();
+      if (reasoningDirection !== null && event.repeat) return;
       if (isCommandPaletteOpen() || isRevertingCheckpoint) {
         return;
       }
+      if (reasoningDirection !== null) {
+        applyReasoningCycle(reasoningDirection);
+        return;
+      }
       if (pendingUserInputs.length > 0 && !isComposerApprovalState) {
         setIsStashMenuOpen((open) => !open);
         return;
@@ -5237,6 +5352,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     return () => window.removeEventListener("keydown", handler, true);
   }, [
     activePendingProgress,
+    applyReasoningCycle,
     isComposerApprovalState,
     isComposerModelPickerOpen,
     keybindings,

apps/web/src/components/chat/TraitsPicker.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vite-plus/test";
 import { ProviderDriverKind, type ProviderOptionDescriptor } from "@t3tools/contracts";
-import { buildTraitsTriggerDisplay, buildUnavailableModelOptionDescriptors } from "./TraitsPicker";
+import {
+  buildTraitsTriggerDisplay,
+  buildUnavailableModelOptionDescriptors,
+  resolveTraitsSelectChange,
+} from "./TraitsPicker";
 
 function selectDescriptor(
   id: string,
@@ -156,6 +160,57 @@ describe("buildTraitsTriggerDisplay", () => {
   });
 });
 
+describe("resolveTraitsSelectChange", () => {
+  it("routes reasoning selections through the shared preserving transition", () => {
+    const modelOptions = [
+      { id: "future", value: "keep" },
+      { id: "reasoningEffort", value: "high" },
+      { id: "contextWindow", value: "1m" },
+    ] as const;
+
+    expect(
+      resolveTraitsSelectChange({
+        caps: { optionDescriptors: [EFFORT, CONTEXT_WINDOW] },
+        descriptors: [EFFORT, CONTEXT_WINDOW],
+        descriptor: EFFORT,
+        value: "max",
+        prompt: "unchanged prompt",
+        modelOptions,
+      }),
+    ).toEqual({
+      prompt: "unchanged prompt",
+      modelOptions: [
+        { id: "future", value: "keep" },
+        { id: "reasoningEffort", value: "max" },
+        { id: "contextWindow", value: "1m" },
+      ],
+    });
+    expect(modelOptions[1]?.value).toBe("high");
+  });
+
+  it("retains the generic descriptor path for non-reasoning traits", () => {
+    expect(
+      resolveTraitsSelectChange({
+        caps: { optionDescriptors: [EFFORT, CONTEXT_WINDOW] },
+        descriptors: [EFFORT, CONTEXT_WINDOW],
+        descriptor: CONTEXT_WINDOW,
+        value: "200k",
+        prompt: "unchanged prompt",
+        modelOptions: [
+          { id: "reasoningEffort", value: "high" },
+          { id: "contextWindow", value: "1m" },
+        ],
+      }),
+    ).toEqual({
+      prompt: "unchanged prompt",
+      modelOptions: [
+        { id: "reasoningEffort", value: "high" },
+        { id: "contextWindow", value: "200k" },
+      ],
+    });
+  });
+});
+
 describe("buildUnavailableModelOptionDescriptors", () => {
   it("shows only saved values without inventing alternatives", () => {
     expect(