@stigmer/react 3.12.5 → 3.12.7

package/src/channel/__tests__/ChannelRunConfigDialog.test.tsx

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
+import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { AgentChannelInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { ModelRegistryContext } from "../../models/ModelRegistryContext";
+import type { ModelInfo } from "../../models/registry";
+import { ChannelRunConfigDialog } from "../ChannelRunConfigDialog";
+
+// happy-dom does not implement the native dialog show/close methods.
+beforeAll(() => {
+  HTMLDialogElement.prototype.showModal = function showModal() {
+    this.open = true;
+  };
+  HTMLDialogElement.prototype.close = function close() {
+    this.open = false;
+  };
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+      class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      };
+  }
+});
+
+afterEach(cleanup);
+
+/**
+ * The console's first run_config editor (stigmer/stigmer#792). The pinned
+ * behaviors are the edit-surface contracts the rest of the platform relies
+ * on: `max_tool_rounds` (the operator knob this editor never renders)
+ * survives every save verbatim, an all-empty draft clears the block
+ * ("empty = inherit"), and untouched variant switches stay off the wire
+ * (the #357/#772 unspecified-vs-explicit ledger distinction).
+ */
+
+const MODELS: ModelInfo[] = [
+  {
+    modelId: "claude-haiku-4-5",
+    provider: "anthropic",
+    displayName: "Haiku 4.5",
+    shortDescription: "Fast Claude with optional thinking",
+    speedTier: "fast",
+    costTier: "economy",
+    harness: "cursor",
+    featured: true,
+    serviceTiers: [],
+    thinkingCapable: true,
+  },
+];
+
+function makeChannel(runConfig?: {
+  modelName?: string;
+  maxCostUsd?: number;
+  maxToolRounds?: number;
+  serviceTier?: ServiceTier;
+  thinkingMode?: ThinkingMode;
+}) {
+  return {
+    metadata: {
+      id: "ach_1",
+      name: "Support Slack",
+      slug: "support-slack",
+      org: "acme",
+      labels: {},
+    },
+    spec: {
+      agentRef: { org: "acme", slug: "support-agent" },
+      enabled: true,
+      providerConfig: { case: "slack", value: {} },
+      environmentRefs: [],
+      ...(runConfig
+        ? {
+            runConfig: {
+              modelName: runConfig.modelName ?? "",
+              maxCostUsd: runConfig.maxCostUsd ?? 0,
+              maxToolRounds: runConfig.maxToolRounds ?? 0,
+              serviceTier: runConfig.serviceTier ?? ServiceTier.UNSPECIFIED,
+              thinkingMode: runConfig.thinkingMode ?? ThinkingMode.UNSPECIFIED,
+            },
+          }
+        : {}),
+    },
+    status: { installState: 2 },
+  } as never;
+}
+
+function createMockStigmer() {
+  const apply = vi.fn().mockResolvedValue({});
+  const client = { agentChannel: { apply } } as never;
+  return { client, apply };
+}
+
+function Providers({
+  client,
+  children,
+}: {
+  client: unknown;
+  children: ReactNode;
+}) {
+  return (
+    <StigmerContext.Provider value={client as never}>
+      <ModelRegistryContext.Provider
+        value={{ models: MODELS, isLoading: false, error: null, refetch: vi.fn() }}
+      >
+        {children}
+      </ModelRegistryContext.Provider>
+    </StigmerContext.Provider>
+  );
+}
+
+function renderDialog(channel: unknown) {
+  const { client, apply } = createMockStigmer();
+  const onSaved = vi.fn();
+  render(
+    <Providers client={client}>
+      <ChannelRunConfigDialog
+        open
+        onOpenChange={vi.fn()}
+        channel={channel as never}
+        onSaved={onSaved}
+      />
+    </Providers>,
+  );
+  return { apply, onSaved };
+}
+
+async function save() {
+  fireEvent.click(screen.getByRole("button", { name: "Save" }));
+}
+
+describe("ChannelRunConfigDialog", () => {
+  it("preserves max_tool_rounds verbatim even though it never renders", async () => {
+    const { apply } = renderDialog(
+      makeChannel({ modelName: "claude-haiku-4-5", maxToolRounds: 25 }),
+    );
+
+    expect(screen.queryByText(/tool round/i)).toBeNull();
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig?.maxToolRounds).toBe(25);
+    expect(input.runConfig?.modelName).toBe("claude-haiku-4-5");
+  });
+
+  it("clears run_config entirely when the draft is emptied (empty = inherit)", async () => {
+    const { apply } = renderDialog(
+      makeChannel({ modelName: "claude-haiku-4-5", maxCostUsd: 2 }),
+    );
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reset to platform default" }),
+    );
+    fireEvent.change(screen.getByLabelText(/Budget per run/), {
+      target: { value: "" },
+    });
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig).toBeUndefined();
+  });
+
+  it("carries an actively enabled thinking mode, and only then", async () => {
+    const { apply } = renderDialog(makeChannel({ modelName: "claude-haiku-4-5" }));
+
+    fireEvent.click(screen.getByRole("button", { name: /Haiku 4\.5/ }));
+    fireEvent.click(await screen.findByRole("switch", { name: "Thinking" }));
+    fireEvent.keyDown(document.activeElement ?? document.body, { key: "Escape" });
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig?.thinkingMode).toBe(ThinkingMode.ENABLED);
+    // The untouched tier stays absent — never stamped as an explicit
+    // STANDARD by a save (#357 ledger distinction).
+    expect(input.runConfig?.serviceTier).toBeUndefined();
+  });
+
+  it("round-trips a stored thinking pin into the switch state", async () => {
+    renderDialog(
+      makeChannel({
+        modelName: "claude-haiku-4-5",
+        thinkingMode: ThinkingMode.ENABLED,
+      }),
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /Haiku 4\.5/ }));
+    const toggle = await screen.findByRole("switch", { name: "Thinking" });
+    expect(toggle.getAttribute("aria-checked")).toBe("true");
+  });
+
+  it("collects a budget without requiring a model pin", async () => {
+    const { apply } = renderDialog(makeChannel());
+
+    fireEvent.change(screen.getByLabelText(/Budget per run/), {
+      target: { value: "1.5" },
+    });
+    await save();
+
+    await waitFor(() => expect(apply).toHaveBeenCalledOnce());
+    const input = apply.mock.calls[0][0] as AgentChannelInput;
+    expect(input.runConfig?.maxCostUsd).toBe(1.5);
+    expect(input.runConfig?.modelName).toBeUndefined();
+  });
+});

package/src/channel/index.ts

@@ -69,6 +69,8 @@ export type { ConnectWhatsAppDialogProps } from "./ConnectWhatsAppDialog.js";
 
 export { ChannelCredentialsDialog } from "./ChannelCredentialsDialog.js";
 export type { ChannelCredentialsDialogProps } from "./ChannelCredentialsDialog.js";
+export { ChannelRunConfigDialog } from "./ChannelRunConfigDialog.js";
+export type { ChannelRunConfigDialogProps } from "./ChannelRunConfigDialog.js";
 
 export { ChannelToolCredentials } from "./ChannelToolCredentials.js";
 export type { ChannelToolCredentialsProps } from "./ChannelToolCredentials.js";

package/src/channel/useSaveAgentChannel.ts

@@ -66,9 +66,11 @@ export function agentChannelToInput(channel: AgentChannel): AgentChannelInput {
           })),
         }
       : {}),
-    // The console does not edit run_config (yet) — it rides through
-    // opaquely so a settings save or pause/resume toggle never wipes an
-    // override set via the CLI or API.
+    // run_config rides through verbatim so a settings save or
+    // pause/resume toggle never wipes an override set elsewhere (the
+    // ChannelRunConfigDialog — the one surface that edits it, #792 —
+    // overrides this copy with its own draft; CLI/API overrides survive
+    // every other save).
     ...(spec?.runConfig
       ? {
           runConfig: {
@@ -76,6 +78,7 @@ export function agentChannelToInput(channel: AgentChannel): AgentChannelInput {
             maxCostUsd: spec.runConfig.maxCostUsd,
             maxToolRounds: spec.runConfig.maxToolRounds,
             serviceTier: spec.runConfig.serviceTier,
+            thinkingMode: spec.runConfig.thinkingMode,
           },
         }
       : {}),

package/src/channel-app/ChannelAppDetailPanel.tsx

@@ -2,7 +2,7 @@
 
 import { type FormEvent, useCallback, useId, useMemo, useState } from "react";
 import { cn } from "@stigmer/theme";
-import { getUserMessage } from "@stigmer/sdk";
+import { getUserMessage, toChannelAppUpdateInput } from "@stigmer/sdk";
 import type { ChannelApp } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
 import { useStigmer } from "../hooks.js";
 import { useUpdateChannelApp } from "./useUpdateChannelApp.js";
@@ -229,10 +229,10 @@ function SlackAppDetail({
 
       clearError();
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override only the slack arm this form owns.
         const updated = await update({
-          name,
-          org: channelApp.metadata?.org ?? "",
-          ...(channelApp.metadata?.slug ? { slug: channelApp.metadata.slug } : {}),
+          ...toChannelAppUpdateInput(channelApp),
           slack: {
             clientId: clientId.trim(),
             // The redaction marker means "keep the stored value" — the
@@ -246,7 +246,7 @@ function SlackAppDetail({
         // error state is managed by useUpdateChannelApp
       }
     },
-    [canSave, clearError, update, name, channelApp.metadata, clientId, clientSecret, signingSecret, onUpdated],
+    [canSave, clearError, update, channelApp, clientId, clientSecret, signingSecret, onUpdated],
   );
 
   return (
@@ -379,10 +379,10 @@ function WhatsAppAppDetail({
 
       clearError();
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override only the whatsapp arm this form owns.
         const updated = await update({
-          name,
-          org: channelApp.metadata?.org ?? "",
-          ...(channelApp.metadata?.slug ? { slug: channelApp.metadata.slug } : {}),
+          ...toChannelAppUpdateInput(channelApp),
           whatsapp: {
             appId: metaAppId.trim(),
             // The redaction marker means "keep the stored value" — the
@@ -397,7 +397,7 @@ function WhatsAppAppDetail({
         // error state is managed by useUpdateChannelApp
       }
     },
-    [canSave, clearError, update, name, channelApp.metadata, metaAppId, appSecret, accessToken, verifyToken, onUpdated],
+    [canSave, clearError, update, channelApp, metaAppId, appSecret, accessToken, verifyToken, onUpdated],
   );
 
   return (

package/src/channel-app/__tests__/channelAppWhatsApp.test.tsx

@@ -228,6 +228,8 @@ describe("ChannelAppDetailPanel — WhatsApp branch", () => {
 
     await waitFor(() => expect(update).toHaveBeenCalled());
     expect(update).toHaveBeenCalledWith({
+      // The generated mapper carries metadata.id for exact update addressing.
+      id: "chapp_1",
       name: "Acme WhatsApp",
       org: "acme",
       slug: "acme-whatsapp",

package/src/channel-app/__tests__/channelAppWipeSafety.test.tsx

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  ChannelAppSchema,
+  type ChannelApp,
+} from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
+import type { ChannelAppInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { ChannelAppDetailPanel } from "../ChannelAppDetailPanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug: both detail forms
+ * must spread `toChannelAppUpdateInput` and override only their provider
+ * arm, so identity fields and any future spec field survive the save.
+ * Secrets follow the redaction contract: the form is seeded with the
+ * server's redaction marker, and sending the marker back means "keep the
+ * stored value" (per-field, verified by the backend's
+ * TestRedactAndEncryptCoverEveryProviderArm).
+ */
+
+const REDACTED = "***REDACTED***";
+
+const SLACK_APP: ChannelApp = create(ChannelAppSchema, {
+  metadata: {
+    id: "chapp_1",
+    name: "Acme Slack",
+    slug: "acme-slack",
+    org: "acme",
+    labels: { team: "support" },
+  },
+  spec: {
+    providerConfig: {
+      case: "slack",
+      value: {
+        clientId: "1234.5678",
+        clientSecret: REDACTED,
+        signingSecret: REDACTED,
+      },
+    },
+  },
+});
+
+function renderPanel(update: ReturnType<typeof vi.fn>) {
+  const client = {
+    baseUrl: "https://api.stigmer.ai",
+    channelapp: { update, delete: vi.fn(async () => ({})) },
+  } as never;
+  return render(
+    <StigmerContext.Provider value={client}>
+      <ChannelAppDetailPanel
+        channelApp={SLACK_APP}
+        consoleOrigin="https://console.acme.example"
+      />
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("ChannelAppDetailPanel save payload (slack arm)", () => {
+  it("spreads the complete mapped input and overrides only the slack config", async () => {
+    const update = vi.fn(async (_input: ChannelAppInput) => SLACK_APP);
+    renderPanel(update);
+
+    const clientId = await screen.findByLabelText(/client id/i);
+    fireEvent.change(clientId, { target: { value: "9999.0000" } });
+    fireEvent.click(screen.getByRole("button", { name: /save credentials/i }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // The edited field, plus per-field keep-markers for untouched secrets.
+    expect(input.slack).toEqual({
+      clientId: "9999.0000",
+      clientSecret: REDACTED,
+      signingSecret: REDACTED,
+    });
+    // Identity and unrendered metadata survive via the mapper spread.
+    expect(input.name).toBe("Acme Slack");
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("acme-slack");
+    expect(input.labels).toEqual({ team: "support" });
+    // The other provider arm stays absent — the oneof is preserved.
+    expect(input.whatsapp).toBeUndefined();
+  });
+});

package/src/composer/ComposerToolbar.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { useId } from "react";
 import { cn } from "@stigmer/theme";
 import {
   Tooltip,
@@ -7,12 +8,14 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "../internal/tooltip.js";
+import { Switch } from "../switch/Switch.js";
 import { ContextPopover } from "./ContextPopover.js";
 import { ConfigureMenu, type ConfigureMenuItem } from "./ConfigureMenu.js";
 import { ModelSelector } from "../models/ModelSelector.js";
 import { HarnessSelector } from "../models/HarnessSelector.js";
 import type { HarnessOption } from "../models/harness.js";
 import type { ServiceTierOption } from "../models/service-tier.js";
+import type { ThinkingModeOption } from "../models/thinking-mode.js";
 import { InteractionModePicker, type InteractionModeOption } from "./InteractionModePicker.js";
 import {
   PaperclipIcon,
@@ -22,6 +25,18 @@ import {
 } from "./icons.js";
 import { SpinnerIcon } from "../internal/SpinnerIcon.js";
 
+/**
+ * Wiring for the always-available "auto-approve tool calls" toggle
+ * (stigmer/stigmer#816). Presence renders the control; omission keeps the
+ * toolbar byte-identical for consumers that don't wire it (DD-011).
+ */
+export interface ComposerAutoApproveProps {
+  /** Whether auto-approve is currently armed for this conversation. */
+  readonly armed: boolean;
+  /** Called with the next value when the user flips the toggle. */
+  readonly onChange: (armed: boolean) => void;
+}
+
 export interface ComposerToolbarProps {
   readonly disabled: boolean;
   readonly isSubmitting: boolean;
@@ -46,6 +61,14 @@ export interface ComposerToolbarProps {
   readonly interactionMode?: InteractionModeOption;
   readonly onInteractionModeChange: (mode: InteractionModeOption) => void;
 
+  /**
+   * Always-available auto-approve toggle (#816). Deliberately NOT bound to
+   * {@link disabled}: the walk-away user flips it exactly while a turn
+   * streams, so it stays interactive under the composer lock — the same
+   * exemption the Stop button carries.
+   */
+  readonly autoApprove?: ComposerAutoApproveProps;
+
   readonly showModelSelector: boolean;
   readonly modelId?: string;
   readonly onModelChange: (id: string) => void;
@@ -53,6 +76,10 @@ export interface ComposerToolbarProps {
   readonly serviceTier?: ServiceTierOption;
   /** Enables the fast-tier switch inside the model selector's options area. */
   readonly onServiceTierChange?: (tier: ServiceTierOption) => void;
+  /** Current thinking mode for the selected model (#772). */
+  readonly thinkingMode?: ThinkingModeOption;
+  /** Enables the thinking switch inside the model selector's options area. */
+  readonly onThinkingModeChange?: (mode: ThinkingModeOption) => void;
 
   // -- Right group: Secondary actions (icon-only) ---------------------------
 
@@ -123,13 +150,17 @@ export function ComposerToolbar({
   showInteractionModePicker,
   interactionMode,
   onInteractionModeChange,
+  autoApprove,
   showModelSelector,
   modelId,
   onModelChange,
   serviceTier,
   onServiceTierChange,
+  thinkingMode,
+  onThinkingModeChange,
 }: ComposerToolbarProps) {
   const showHarnessSeparate = showHarnessSelector && !showModelSelector;
+  const autoApproveLabelId = useId();
 
   return (
     <div className="stg:flex stg:items-center stg:justify-between stg:gap-2 stg:border-t stg:border-border-muted stg:px-3 stg:py-2">
@@ -161,9 +192,45 @@ export function ComposerToolbar({
             onHarnessChange={showHarnessSelector ? onHarnessChange : undefined}
             serviceTier={serviceTier}
             onServiceTierChange={onServiceTierChange}
+            thinkingMode={thinkingMode}
+            onThinkingModeChange={onThinkingModeChange}
             disabled={disabled}
           />
         )}
+
+        {/* Auto-approve (#816): primary state like Mode and Model — armed
+            vs gated is something the user glances at before walking away.
+            Never bound to `disabled` (see ComposerAutoApproveProps): the
+            whole point is flipping it while a turn streams. Scoped provider:
+            this tooltip does not share the icon cluster's hover-delay group. */}
+        {autoApprove && (
+          <TooltipProvider>
+            <Tooltip>
+              <TooltipTrigger render={<span className="stg:inline-flex" />}>
+                <span className="stg:flex stg:shrink-0 stg:items-center stg:gap-1.5 stg:px-1">
+                  <label
+                    id={autoApproveLabelId}
+                    htmlFor={`${autoApproveLabelId}-switch`}
+                    className="stg:cursor-pointer stg:select-none stg:text-xs stg:text-muted-foreground"
+                  >
+                    Auto-approve
+                  </label>
+                  <Switch
+                    id={`${autoApproveLabelId}-switch`}
+                    checked={autoApprove.armed}
+                    onCheckedChange={autoApprove.onChange}
+                    aria-labelledby={autoApproveLabelId}
+                  />
+                </span>
+              </TooltipTrigger>
+              <TooltipContent side="top">
+                {autoApprove.armed
+                  ? "Tool calls run without asking — this conversation only. Turn off to be asked again."
+                  : "Run this conversation's tool calls without asking for approval, including the run in progress."}
+              </TooltipContent>
+            </Tooltip>
+          </TooltipProvider>
+        )}
       </div>
 
       {/* ---- Right group: Secondary actions (icon-only) + Send ----

package/src/composer/SessionComposer.tsx

@@ -4,10 +4,11 @@ import { forwardRef, memo, useCallback, useEffect, useImperativeHandle, useMemo,
 import { cn } from "@stigmer/theme";
 import { getUserMessage, type AttachmentInput, type EnvVarInput, type McpServerUsageInput, type ResourceRef } from "@stigmer/sdk";
 import { useComposer } from "./useComposer.js";
-import { ComposerToolbar } from "./ComposerToolbar.js";
+import { ComposerToolbar, type ComposerAutoApproveProps } from "./ComposerToolbar.js";
 import { type ConfigureMenuItem } from "./ConfigureMenu.js";
 import type { HarnessOption } from "../models/harness.js";
 import { FAST_SERVICE_TIER, type ServiceTierOption } from "../models/service-tier.js";
+import type { ThinkingModeOption } from "../models/thinking-mode.js";
 import type { InteractionModeOption } from "./InteractionModePicker.js";
 import { parseModelKey } from "../models/registry.js";
 import { useModelRegistry } from "../models/useModelRegistry.js";
@@ -164,6 +165,14 @@ export interface SessionComposerSubmitContext {
    * Pass to execution creation as `execution_config.service_tier`.
    */
   readonly serviceTier?: ServiceTierOption;
+  /**
+   * Thinking mode the user actively selected for this execution
+   * (stigmer/stigmer#772). Only ever `"enabled"` — an untouched mode means
+   * "platform default" and is carried as `undefined`, the same
+   * unspecified-vs-explicit contract as {@link serviceTier}.
+   * Pass to execution creation as `execution_config.thinking_mode`.
+   */
+  readonly thinkingMode?: ThinkingModeOption;
   /**
    * Workspace-relative file paths the user referenced via drag-to-reference.
    *
@@ -291,6 +300,16 @@ export interface SessionComposerProps {
   /** Show the model selector. @default true */
   readonly showModelSelector?: boolean;
 
+  /**
+   * Always-visible "auto-approve tool calls" toggle in the toolbar
+   * (stigmer/stigmer#816). Presence renders it; omission keeps the composer
+   * byte-identical (DD-011). Stays interactive while the composer is
+   * `disabled` — the walk-away user flips it exactly while a turn streams —
+   * so consumers must only wire it on surfaces whose viewer may submit
+   * approvals (never guest/observer). See {@link ComposerAutoApproveProps}.
+   */
+  readonly autoApprove?: ComposerAutoApproveProps;
+
   /**
    * Workspace state managed by {@link useWorkspaceEntries}.
    * When provided, renders a workspace trigger in the toolbar
@@ -608,6 +627,7 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
   defaultModelId,
   onModelChange,
   showModelSelector = true,
+  autoApprove,
   workspace,
   gitHubConnection,
   enableGitHub = true,
@@ -663,6 +683,9 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
   // selection below (#663) — state here records the user's intent only.
   const [serviceTier, setServiceTier] = useState<ServiceTierOption>("standard");
 
+  // Thinking mode (#772): the tier's twin, same intent-vs-effective split.
+  const [thinkingMode, setThinkingMode] = useState<ThinkingModeOption>("disabled");
+
   // Active harness mirror: controlled hosts (both viewers) keep the
   // `harness` prop current, but with `showHarnessSelector` the dropdown
   // lives inside ModelSelector and an uncontrolled host would leave the
@@ -837,10 +860,26 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
         ? "fast"
         : "standard";
 
-    return { modelId: effectiveModelId, model: effectiveModel, serviceTier: effectiveServiceTier };
+    // "enabled" rides under the identical rule, keyed on the capability
+    // (cursor-harness models only — v1 has no native thinking mapping, #772).
+    const effectiveThinkingMode: ThinkingModeOption =
+      thinkingMode === "enabled"
+        && effectiveModel !== undefined
+        && effectiveModel.harness === "cursor"
+        && effectiveModel.thinkingCapable === true
+        ? "enabled"
+        : "disabled";
+
+    return {
+      modelId: effectiveModelId,
+      model: effectiveModel,
+      serviceTier: effectiveServiceTier,
+      thinkingMode: effectiveThinkingMode,
+    };
   }, [
     modelId,
     serviceTier,
+    thinkingMode,
     showModelSelector,
     isRegistryLoading,
     registryGetByKey,
@@ -1054,15 +1093,19 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
       // explicit distinction is load-bearing telemetry (#357).
       const submitServiceTier =
         effective.serviceTier === "fast" ? effective.serviceTier : undefined;
+      // The tier's #772 twin: only an in-effect "enabled" is carried.
+      const submitThinkingMode =
+        effective.thinkingMode === "enabled" ? effective.thinkingMode : undefined;
 
       const context: SessionComposerSubmitContext | undefined =
         hasEnv || hasAttachments || effectiveMode || hasFileRefs || buildFromPlan
-        || submitServiceTier
+        || submitServiceTier || submitThinkingMode
           ? {
               runtimeEnv: hasEnv ? env : undefined,
               attachments: hasAttachments ? attachmentInputs : undefined,
               interactionMode: effectiveMode,
               serviceTier: submitServiceTier,
+              thinkingMode: submitThinkingMode,
               workspaceFileRefs: hasFileRefs ? [...fileRefs.refs] : undefined,
               buildFromPlan,
             }
@@ -1888,12 +1931,15 @@ const SessionComposerInner = forwardRef<SessionComposerHandle, SessionComposerPr
           interactionMode={interactionMode}
           onInteractionModeChange={handleInteractionModeChange}
           showModelSelector={showModelSelector}
+          autoApprove={autoApprove}
           // The pill renders the effective selection — the same value the
           // submit payload carries (#663), never a fallback of its own.
           modelId={effective.modelId}
           onModelChange={handleModelChange}
           serviceTier={serviceTier}
           onServiceTierChange={setServiceTier}
+          thinkingMode={thinkingMode}
+          onThinkingModeChange={setThinkingMode}
         />
       </div>
     </div>