Cycle reasoning effort with Shift+Tab and show it on the prompt

Shift+Tab walks the current model's supported effort ladder (wrapping),
rebuilds inference sources so the next turn picks it up, and refreshes the
prompt border label. Plain Tab still toggles focus. Docs no longer claim
Shift+Tab toggles auto mode.

Author: TheGreatAxios

README.md

@@ -77,7 +77,7 @@ The chat director adds context management on top of the reactor:
 
 ## Permissions and auto mode
 
-Corbits Code defaults to **auto mode** (`auto = true`). Workspace file writes/edits/deletes and unconstrained shell commands run without per-action prompts. Pass `--no-auto` to start in ask-on-every-consequential-action mode, or press **SHIFT+TAB** in the TUI to toggle at any time. Enabling auto prints a one-line reminder of the envelope below.
+Corbits Code defaults to **auto mode** (`auto = true`). Workspace file writes/edits/deletes and unconstrained shell commands run without per-action prompts. Pass `--no-auto` to start in ask-on-every-consequential-action mode (there is currently no in-session key to toggle auto). Press **Shift+Tab** in the TUI to cycle reasoning effort for the current model. Enabling auto prints a one-line reminder of the envelope below.
 
 ### What auto allows
 

src/config/index.ts

@@ -468,7 +468,8 @@ export async function loadConfig(
   // writes/edits and unconstrained shell) run without prompting, while shell
   // file-mutation stays denied and installs / recursive rm / worktree /
   // sensitive-path / opaque-wrapper shell still ask. Pass --no-auto to revert
-  // to ask-on-every-write, or toggle live in the TUI with SHIFT+TAB.
+  // to ask-on-every-write. There is currently no in-session key to toggle auto;
+  // Shift+Tab in the TUI cycles reasoning effort instead.
   let auto = true;
   let configPath: string | undefined;
   let provider: string | undefined;

src/permission/gate.ts

@@ -253,8 +253,9 @@ export type PermissionGate = {
   // Whether auto mode is currently on. Auto mode auto-approves non-destructive
   // consequential actions (file writes/edits, unconstrained shell) without prompting.
   getAuto: () => boolean;
-  // Turn auto mode on or off for the rest of the session. SHIFT+TAB in the TUI
-  // wires the toggle here so a switch takes effect on the next tool call.
+  // Turn auto mode on or off for the rest of the session. Live callers (slash
+  // commands, settings) wire the toggle here so a switch takes effect on the
+  // next tool call. There is currently no in-session key chord for this.
   setAuto: (value: boolean) => void;
   // Whether --dangerously-skip-permissions is active for this session. Immutable
   // after gate construction; pre-gate sandboxes (path-escape, shell cwd bounds)

src/provider/reasoning-effort.test.ts

@@ -5,6 +5,7 @@ import {
   isReasoningEffort,
   supportedEfforts,
   validateEffort,
+  cycleReasoningEffort,
   setModelReasoningCapabilities,
   modelReasoningCapability,
   clampEffort,
@@ -98,6 +99,27 @@ describe("validateEffort", () => {
   });
 });
 
+describe("cycleReasoningEffort", () => {
+  afterEach(() => setModelReasoningCapabilities({}));
+
+  test("walks the gpt-5 ladder and wraps", () => {
+    expect(cycleReasoningEffort("gpt-5", undefined)).toBe("minimal");
+    expect(cycleReasoningEffort("gpt-5", "minimal")).toBe("low");
+    expect(cycleReasoningEffort("gpt-5", "low")).toBe("medium");
+    expect(cycleReasoningEffort("gpt-5", "medium")).toBe("high");
+    expect(cycleReasoningEffort("gpt-5", "high")).toBe("minimal");
+  });
+
+  test("starts at the first supported level when current is unsupported", () => {
+    expect(cycleReasoningEffort("gpt-5", "xhigh")).toBe("minimal");
+  });
+
+  test("returns undefined for a non-reasoning model", () => {
+    setModelReasoningCapabilities({ "chat-only-model": false });
+    expect(cycleReasoningEffort("chat-only-model", "medium")).toBeUndefined();
+  });
+});
+
 describe("reasoning capability gate", () => {
   afterEach(() => setModelReasoningCapabilities({}));
 

src/provider/reasoning-effort.ts

@@ -96,6 +96,25 @@ export function validateEffort(
   };
 }
 
+/**
+ * Next effort on the model's supported ladder (wraps around). Returns undefined
+ * when the model supports no reasoning effort — callers flash a status and leave
+ * the session config alone.
+ */
+export function cycleReasoningEffort(
+  model: string,
+  current: ReasoningEffort | undefined,
+  isCodex = false,
+): ReasoningEffort | undefined {
+  const supported = supportedEfforts(model, undefined, isCodex);
+  if (supported.length === 0) return undefined;
+  if (current === undefined || !supported.includes(current)) {
+    return supported[0];
+  }
+  const idx = supported.indexOf(current);
+  return supported[(idx + 1) % supported.length];
+}
+
 // ---------------------------------------------------------------------------
 // Role-based product defaults (CL-5162)
 //

src/tui/keybindings.test.ts

@@ -37,6 +37,7 @@ import {
   setSentMessageHistory,
   setShellBridgeHooks,
   setShellExitHandler,
+  setEffortCycleHandler,
   clearShellBridgeHooks,
   setShellRunState,
   shellFocusPrompt,
@@ -98,7 +99,7 @@ function chordsOf(keys: string): readonly (string | null)[] {
     const bytes = chordBytes(token.trim())
     // A token nothing can encode and that is not the known kitty-only chord is
     // a typo in the catalog, not an untestable chord.
-    if (bytes === null && token.trim() !== "Ctrl+Enter") {
+    if (bytes === null && token.trim() !== "Ctrl+Enter" && token.trim() !== "Shift+Tab") {
       throw new Error(`catalog row "${keys}" has unreadable chord "${token.trim()}"`)
     }
     return bytes
@@ -371,6 +372,22 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
       expect(focusOwner(shell.focus)).toBe("prompt")
     },
   },
+  "Shift+Tab": {
+    group: "surfaces",
+    probe: ({ h, shell }) => {
+      let cycles = 0
+      setEffortCycleHandler(shell, () => {
+        cycles++
+      })
+      shellFocusPrompt(shell)
+      const before = focusOwner(shell.focus)
+      // Classic terminals often emit CSI Z for Shift+Tab; the harness can also
+      // inject name:"tab" with shift:true, which is what the shell handler reads.
+      h.pressKey("Tab", { shift: true })
+      expect(cycles).toBe(1)
+      expect(focusOwner(shell.focus)).toBe(before)
+    },
+  },
   Esc: {
     group: "surfaces",
     probe: async ({ h, shell, chords }) => {

src/tui/keybindings.ts

@@ -30,6 +30,7 @@ export const SHELL_SHORTCUTS: readonly ShellShortcut[] = [
   { keys: "Alt+T", description: "show or hide the task list above the prompt" },
   { keys: "Alt+O", description: "observe a live subagent session; a system row says so when there is none" },
   { keys: "Tab", description: "move focus between the prompt and the transcript" },
+  { keys: "Shift+Tab", description: "cycle reasoning effort for the current model" },
   { keys: "Esc", description: "close the open overlay, or leave subagent observe" },
   { keys: "Ctrl+B / Ctrl+F", description: "move the cursor back / forward one character" },
   { keys: "Ctrl+D", description: "delete the character under the cursor" },

src/tui/runner.ts

@@ -48,11 +48,12 @@ import { modelOptionId } from "./model-catalog.js";
 import type { SessionModeScope } from "./command-surfaces.js";
 import { resolveWaitForApproval, type ToolWatchdogConfig } from "./tool-execution-watchdog.js";
 import { attachApprovalBudget, createGateRequestApproval } from "./request-approval.js";
-import { codexProfileFromProviderName } from "../config/codex-providers.js";
+import { codexProfileFromProviderName, isCodexProviderName } from "../config/codex-providers.js";
 import { xaiProfileFromProviderName } from "../config/xai-providers.js";
 import type { PluginsAdmin, PluginDescriptor } from "../plugins/admin.js";
 import type { PluginManifest } from "../plugins/manifest.js";
 import { createInferenceDependencies } from "../provider/inference-dependencies.js";
+import { cycleReasoningEffort } from "../provider/reasoning-effort.js";
 import { getValidCodexToken } from "../auth/codex/session.js";
 import { getValidXaiToken } from "../auth/xai/session.js";
 import { refreshCodexInstructions } from "../auth/codex/instructions.js";
@@ -164,11 +165,14 @@ import { mountRunnerHost } from "./runner-host.js";
 import {
   applyFocus,
   attachClipboardImage,
+  setEffortCycleHandler,
   setMentionSuggestionSource,
+  setPromptModelLabel,
   setPromptRecognitionSource,
   setSentMessageHistory,
   setShellInputSuspended,
   setShellRunState,
+  setStatusFlash,
   surfaceSystemNotice,
 } from "./shell.js";
 import {
@@ -2409,6 +2413,29 @@ export async function runTUI(initialConfig: Config): Promise<number> {
     agentNames: liveAgentProfiles.map((profile) => profile.id),
   }));
 
+  // Shift+Tab: cycle reasoning effort for the live model and rebuild sources so
+  // the next inference turn picks up the new providerOptions.reasoning_effort.
+  setEffortCycleHandler(host.shell, () => {
+    const next = cycleReasoningEffort(
+      config.model,
+      config.reasoningEffort,
+      isCodexProviderName(config.providerName),
+    );
+    if (next === undefined) {
+      setStatusFlash(host.shell, "this model has no reasoning effort levels");
+      return;
+    }
+    config = { ...config, reasoningEffort: next };
+    const bundle = buildSessionSources();
+    agentProxy.setSources(bundle.sources, bundle.defaultSource);
+    setPromptModelLabel(host.shell, {
+      profile: config.providerName,
+      model: config.model,
+      effort: next,
+    });
+    setStatusFlash(host.shell, `reasoning effort: ${next}`);
+  });
+
   // Recall spans the whole session, including what was sent before a resume.
   void loadSentMessages(config.cwd, sessionId)
     .then((sent) => setSentMessageHistory(host.shell, sent))

src/tui/shell.ts

@@ -223,6 +223,17 @@ export function clearShellExitHandler(shell: AppShell): void {
   shellExitHandlers.delete(shell)
 }
 
+const effortCycleHandlers = new WeakMap<AppShell, () => void>()
+
+/** Shift+Tab host callback: cycle reasoning effort for the live session. */
+export function setEffortCycleHandler(shell: AppShell, onCycle: () => void): void {
+  effortCycleHandlers.set(shell, onCycle)
+}
+
+export function clearEffortCycleHandler(shell: AppShell): void {
+  effortCycleHandlers.delete(shell)
+}
+
 /** Optional Wave-4 bridge hooks (runtime-bridge attaches exclusively). */
 export type ShellBridgeHooks = {
   onSubmit: (
@@ -3874,6 +3885,7 @@ export function handleOverlayAnswerKey(
 
   if (
     key.name === "tab" &&
+    !key.shift &&
     !key.ctrl &&
     !key.meta &&
     !key.option &&
@@ -5093,7 +5105,7 @@ export function handleSlashPopupKey(shell: AppShell, key: KeyEvent): boolean {
 
   const active = shell.paletteCommands[shell.overlayList.activeIndex]
 
-  if (key.name === "tab" && !key.ctrl && !key.meta && !key.option) {
+  if (key.name === "tab" && !key.shift && !key.ctrl && !key.meta && !key.option) {
     if (active) setPromptText(shell, `/${active.id} `)
     closeSlashPopup(shell)
     return true
@@ -5820,7 +5832,18 @@ export function createAppShell(
       shell.sentHistory = sentHistoryOnEdit(shell.sentHistory)
     }
 
-    if (key.name === "tab" && !key.ctrl && !key.meta && !key.option) {
+    if (
+      ((key.name === "tab" && key.shift) || key.name === "backtab") &&
+      !key.ctrl &&
+      !key.meta &&
+      !key.option
+    ) {
+      key.preventDefault()
+      effortCycleHandlers.get(shell)?.()
+      return
+    }
+
+    if (key.name === "tab" && !key.ctrl && !key.meta && !key.option && !key.shift) {
       key.preventDefault()
       toggleShellFocus(shell)
       return