feat(chat): add "Off" option to Reasoning Effort dropdown (thinking on/off)

Add an "Off" choice as the FIRST option in the per-conversation Reasoning
Effort selector. Selecting it disables extended thinking ENTIRELY for the
conversation's turns — NOT "set the effort to its lowest level". The two axes
are kept SEPARATE on the wire (per the umans API model, where thinking-off is
`reasoning_effort: "none"`, distinct from the effort level):

- `reasoningEffort` is the thinking-DEPTH ladder (low→max) — UNCHANGED.
- `thinking` is the on/off switch — a NEW per-conversation boolean.

Turning thinking off PRESERVES the persisted effort level, so an off→on toggle
restores the previously-chosen depth. The selector CONFLATES the two axes into
one <select> (UX); the wire does not.

Pure logic (reasoning-effort.ts): ThinkingSelection = "off" | ReasoningEffort,
selectionOptions() (Off first + the ladder, default marked), isThinkingSelection,
effectiveSelection(persistedEffort, persistedThinking), + FE-local PROPOSED wire
types (ThinkingResponse, SetThinkingRequest) + SaveThinkingSelection port. The
existing effortOptions()/isReasoningEffort()/effectiveEffort() are UNCHANGED — the
heartbeat feature reuses them (its own dropdown is unaffected).

Store: `thinking` state (boolean|null, null⇒ON default), refreshThinking() (GET,
alongside refreshReasoningEffort() on every focus/draft/switch), setThinking()
(PUT). App.svelte's saveThinkingSelection adapter fans one selection out: "off"
→ PUT /thinking {thinking:false} (effort untouched); a level → ensure thinking ON
(if off) then PUT /reasoning-effort {level}.

Backend contract gap (CR-14, backend-handoff.md §2l): the backend has NO
thinking-off mechanism today (umans mapReasoningEffort can't emit "none"). The FE
is built against the PROPOSED additive contract (GET/PUT /conversations/:id/thinking
+ ThinkingResponse/SetThinkingRequest; umans maps thinking===false →
reasoning_effort:"none"). Until shipped, GET /thinking 404s and refreshThinking()
leaves `thinking` null⇒ON — the selector gracefully shows the effort level, no crash.

Verification: typecheck 0/0, 1128 tests green (run TWICE — touches the shared fetch
fake), biome clean, build OK. 9 files (8 source + backend-handoff.md).

3 files changed, 218 insertions, 9 deletions

diff --git a/src/app/App.svelte b/src/app/App.svelte
index 7e5ac7d..f87eddb 100644
--- a/src/app/App.svelte
+++ b/src/app/App.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import type { ImageInput, ReasoningEffort } from "@dispatch/transport-contract";
+	import type { ImageInput } from "@dispatch/transport-contract";
 	import type { InvokeMessage } from "@dispatch/ui-contract";
 	import { tick } from "svelte";
 	import Table from "../components/Table.svelte";
@@ -17,8 +17,9 @@
 		ReasoningEffortSelector,
 		type CompactNowResult,
 		type ComposerStatus,
-		type ReasoningEffortSaveResult,
 		type SaveCompactPercentResult,
+		type ThinkingSelection,
+		type ThinkingSelectionSaveResult,
 	} from "../features/chat";
 	import { manifest as conversationCacheManifest } from "../features/conversation-cache";
 	import { manifest as markdownManifest } from "../features/markdown";
@@ -317,14 +318,35 @@
 			: { ok: false, error: result.error };
 	}
 
-	// Adapt the store's reasoning-effort result to the chat feature's port.
-	async function saveReasoningEffort(
-		level: ReasoningEffort,
-	): Promise<ReasoningEffortSaveResult | null> {
-		const result = await store.setReasoningEffort(level);
+	// Adapt the store's reasoning-effort + thinking results to the chat
+	// feature's combined selector port. The selector sends ONE selection ("off"
+	// or a level); the adapter fans it out to the right per-axis PUT(s). "off" is
+	// a SEPARATE signal from the effort level: it persists `thinking: false`
+	// (the umans route maps that to `reasoning_effort: "none"`), leaving the
+	// effort level untouched so an off→on toggle restores it. A level ensures
+	// thinking is ON (the level is meaningless while thinking is off) then sets
+	// the effort level.
+	async function saveThinkingSelection(
+		selection: ThinkingSelection,
+	): Promise<ThinkingSelectionSaveResult | null> {
+		if (selection === "off") {
+			const result = await store.setThinking(false);
+			if (result === null) return null;
+			return result.ok
+				? { ok: true, selection: "off" }
+				: { ok: false, error: result.error };
+		}
+		// A level: enable thinking first if it is currently off, then set the level.
+		if (store.thinking === false) {
+			const on = await store.setThinking(true);
+			if (on !== null && !on.ok) {
+				return { ok: false, error: on.error };
+			}
+		}
+		const result = await store.setReasoningEffort(selection);
 		if (result === null) return null;
 		return result.ok
-			? { ok: true, reasoningEffort: result.reasoningEffort }
+			? { ok: true, selection: result.reasoningEffort }
 			: { ok: false, error: result.error };
 	}
 
@@ -728,7 +750,11 @@
 			     re-mount per conversation — incl. switching between drafts — and can't
 			     bleed across tabs. Editable for a draft too (cwd + effort apply from turn 1). -->
 			{#key store.currentConversationId}
-				<ReasoningEffortSelector persisted={store.reasoningEffort} save={saveReasoningEffort} />
+				<ReasoningEffortSelector
+					persistedEffort={store.reasoningEffort}
+					persistedThinking={store.thinking}
+					save={saveThinkingSelection}
+				/>
 				<CwdField cwd={store.cwd} canEdit={true} save={saveCwd} />
 				<ComputerField
 					computerId={store.computerId}
diff --git a/src/app/store.svelte.ts b/src/app/store.svelte.ts
index 22b0a25..e0491ab 100644
--- a/src/app/store.svelte.ts
+++ b/src/app/store.svelte.ts
@@ -54,6 +54,7 @@ import {
 } from "../core/protocol";
 import type { ChatStore, HistorySync, MetricsSync } from "../features/chat";
 import { createChatStore } from "../features/chat";
+import type { SetThinkingRequest, ThinkingResponse } from "../features/chat/reasoning-effort";
 import type {
   ConcurrencyCooldownResult,
   ConcurrencyDeleteResult,
@@ -132,6 +133,14 @@ export type ReasoningEffortResult =
   | { readonly ok: true; readonly reasoningEffort: ReasoningEffort }
   | { readonly ok: false; readonly error: string };
 
+/**
+ * Outcome of `PUT /conversations/:id/thinking` (PROPOSED — see
+ * `backend-handoff.md`; the endpoint is not yet shipped by the backend).
+ */
+export type ThinkingResult =
+  | { readonly ok: true; readonly thinking: boolean }
+  | { readonly ok: false; readonly error: string };
+
 /** Outcome of `POST /conversations/:id/compact` (manual compaction). */
 export type CompactResult =
   | { readonly ok: true; readonly response: CompactResponse }
@@ -273,6 +282,22 @@ export interface AppStore {
    */
   setReasoningEffort(level: ReasoningEffort): Promise<ReasoningEffortResult | null>;
   /**
+   * The workspace conversation's persisted thinking flag, or null when never
+   * set (the server then resolves turns with thinking ON — the default).
+   * `false` ⇒ thinking disabled entirely (the SEPARATE "off" axis — NOT a
+   * zero-effort level; the umans route maps it to `reasoning_effort: "none"`).
+   * PROPOSED backend contract — see `backend-handoff.md`.
+   */
+  readonly thinking: boolean | null;
+  /**
+   * Persist the workspace conversation's thinking flag
+   * (`PUT /conversations/:id/thinking`). Works for a draft too (its id survives
+   * promotion), so the first turn already runs with the chosen setting. Takes
+   * effect from the NEXT turn; resolution stays server-owned.
+   * PROPOSED backend contract — see `backend-handoff.md`.
+   */
+  setThinking(enabled: boolean): Promise<ThinkingResult | null>;
+  /**
    * Manually trigger conversation compaction (`POST /conversations/:id/compact`).
    * Summarizes old messages + retains the most recent N. Returns null when no
    * conversation is focused (a draft has nothing to compact).
@@ -729,6 +754,30 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
     }
   }
 
+  // The workspace conversation's persisted thinking flag (SEPARATE from the
+  // effort level). Seeded from the backend on focus change; null = never set
+  // (thinking ON — the default). PROPOSED endpoint (see backend-handoff.md):
+  // a 404 (endpoint not yet shipped) leaves `thinking` null ⇒ ON (default), so
+  // the selector simply shows the effort level until the backend ships it.
+  let thinking = $state<boolean | null>(null);
+
+  /** Refetch the workspace conversation's thinking flag (works for a draft too). */
+  async function refreshThinking(): Promise<void> {
+    const id = workspaceConversationId();
+    // Clear immediately so a switch never shows the PREVIOUS conversation's
+    // setting while the fetch is in flight (null ⇒ ON, the default).
+    thinking = null;
+    try {
+      const res = await fetchImpl(`${httpBase}/conversations/${encodeURIComponent(id)}/thinking`);
+      if (!res.ok) return;
+      const data = (await res.json()) as ThinkingResponse;
+      // Guard a slow response losing a race with a conversation switch.
+      if (workspaceConversationId() === id) thinking = data.thinking ?? null;
+    } catch (err) {
+      reportError("Failed to load thinking setting", err);
+    }
+  }
+
   // The workspace conversation's auto-compact percent. Seeded from the
   // backend on focus change; null = not yet fetched. 0 = disabled.
   let compactPercent = $state<number | null>(null);
@@ -975,6 +1024,7 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
     void refreshCwd();
     void refreshComputer();
     void refreshReasoningEffort();
+    void refreshThinking();
     void refreshCompactPercent();
   }
 
@@ -1208,6 +1258,7 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
   void refreshComputer();
   void refreshModel();
   void refreshReasoningEffort();
+  void refreshThinking();
   void refreshCompactPercent();
   void refreshVisionSettings();
 
@@ -1243,6 +1294,7 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
       void refreshComputer();
       void refreshModel();
       void refreshReasoningEffort();
+      void refreshThinking();
       void refreshCompactPercent();
     },
     get activeChat(): ChatStore {
@@ -1286,6 +1338,9 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
     get reasoningEffort(): ReasoningEffort | null {
       return reasoningEffort;
     },
+    get thinking(): boolean | null {
+      return thinking;
+    },
     get compactPercent(): number | null {
       return compactPercent;
     },
@@ -1340,6 +1395,7 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
         void refreshCwd();
         void refreshComputer();
         void refreshReasoningEffort();
+        void refreshThinking();
         void refreshCompactPercent();
         // Now send on the promoted store
         chatStores.get(conversationId)?.send(text, images);
@@ -1386,6 +1442,7 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
       void refreshComputer();
       void refreshModel();
       void refreshReasoningEffort();
+      void refreshThinking();
       void refreshCompactPercent();
     },
 
@@ -1401,6 +1458,7 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
       void refreshComputer();
       void refreshModel();
       void refreshReasoningEffort();
+      void refreshThinking();
       void refreshCompactPercent();
     },
 
@@ -1587,6 +1645,37 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
       }
     },
 
+    async setThinking(enabled: boolean): Promise<ThinkingResult | null> {
+      const id = workspaceConversationId();
+      const body: SetThinkingRequest = { thinking: enabled };
+      try {
+        const res = await fetchImpl(
+          `${httpBase}/conversations/${encodeURIComponent(id)}/thinking`,
+          {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+          },
+        );
+        if (!res.ok) {
+          const errBody = (await res.json().catch(() => null)) as { error?: string } | null;
+          return {
+            ok: false,
+            error: errBody?.error ?? `Set thinking failed (HTTP ${res.status})`,
+          };
+        }
+        const data = (await res.json()) as ThinkingResponse;
+        const next = data.thinking ?? enabled;
+        if (workspaceConversationId() === id) thinking = next;
+        return { ok: true, thinking: next };
+      } catch (err) {
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : "Set thinking request failed",
+        };
+      }
+    },
+
     stopGeneration(): void {
       const conversationId = tabsStore.activeConversationId;
       if (conversationId === null) return;
diff --git a/src/app/store.test.ts b/src/app/store.test.ts
index a945ea7..dbceec5 100644
--- a/src/app/store.test.ts
+++ b/src/app/store.test.ts
@@ -891,6 +891,100 @@ describe("createAppStore", () => {
     store.dispose();
   });
 
+  it("seeds thinking from GET /conversations/:id/thinking (null = never set ⇒ ON)", async () => {
+    const base = fakeFetchImpl();
+    const fetchImpl: typeof fetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      if (url.endsWith("/thinking")) {
+        return new Response(JSON.stringify({ conversationId: "x", thinking: false }), {
+          status: 200,
+        });
+      }
+      return base(input, init);
+    };
+    const ws = fakeSocket();
+    const store = createAppStore({
+      socketFactory: () => ws,
+      fetchImpl,
+      localStorage: createFakeStorage(),
+    });
+    ws.resolveOpen();
+
+    await vi.waitFor(() => {
+      expect(store.thinking).toBe(false);
+    });
+
+    store.dispose();
+  });
+
+  it("treats a missing thinking endpoint (404) as 'never set' (null ⇒ ON)", async () => {
+    // The thinking endpoint is PROPOSED (backend-handoff.md); until the backend
+    // ships it, GET 404s and `thinking` stays null ⇒ the selector shows the
+    // effort level (thinking ON, the default) — graceful, never a crash.
+    const base = fakeFetchImpl();
+    const fetchImpl: typeof fetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      if (url.endsWith("/thinking")) {
+        return new Response("not found", { status: 404 });
+      }
+      return base(input, init);
+    };
+    const ws = fakeSocket();
+    const store = createAppStore({
+      socketFactory: () => ws,
+      fetchImpl,
+      localStorage: createFakeStorage(),
+    });
+    ws.resolveOpen();
+
+    // give the (404ing) fetch a tick to settle
+    await vi.waitFor(() => {
+      expect(store.reasoningEffort).not.toBe(undefined);
+    });
+    expect(store.thinking).toBeNull();
+
+    store.dispose();
+  });
+
+  it("setThinking PUTs the flag and updates local state from the echo", async () => {
+    const calls: { url: string; method: string; body: string | undefined }[] = [];
+    const base = fakeFetchImpl();
+    const fetchImpl: typeof fetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      calls.push({ url, method: init?.method ?? "GET", body: init?.body as string | undefined });
+      if (url.endsWith("/thinking") && init?.method === "PUT") {
+        const sent = JSON.parse(init.body as string) as { thinking: boolean };
+        return new Response(JSON.stringify({ conversationId: "x", thinking: sent.thinking }), {
+          status: 200,
+        });
+      }
+      if (url.endsWith("/thinking")) {
+        return new Response(JSON.stringify({ conversationId: "x", thinking: null }), {
+          status: 200,
+        });
+      }
+      return base(input, init);
+    };
+    const ws = fakeSocket();
+    const store = createAppStore({
+      socketFactory: () => ws,
+      fetchImpl,
+      localStorage: createFakeStorage(),
+    });
+    ws.resolveOpen();
+
+    const result = await store.setThinking(false);
+    expect(result).toEqual({ ok: true, thinking: false });
+    expect(store.thinking).toBe(false);
+
+    const put = calls.find((c) => c.method === "PUT" && c.url.endsWith("/thinking"));
+    expect(put).toBeDefined();
+    expect(put?.url).toContain(`/conversations/${store.currentConversationId}/`);
+    expect(JSON.parse(put?.body ?? "{}")).toEqual({ thinking: false });
+
+    store.dispose();
+  });
+
   it("does NOT re-scope a scope:'global' surface on conversation switch (no churn)", () => {
     const ws = fakeSocket();
     const store = createAppStore({