@stigmer/react 3.12.4 → 3.12.6

package/src/schedule/ScheduleDetailView.tsx

@@ -37,7 +37,7 @@ import {
   type RunConfig,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/invocation_pb";
 import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
-import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import {
   cadenceToCron,
@@ -60,6 +60,11 @@ import {
   toProtoServiceTier,
   type ServiceTierOption,
 } from "../models/service-tier.js";
+import {
+  fromProtoThinkingMode,
+  toProtoThinkingMode,
+  type ThinkingModeOption,
+} from "../models/thinking-mode.js";
 import { deriveScheduleState, formatNextFire } from "./scheduleState.js";
 import {
   ScheduleRunsCompactList,
@@ -599,10 +604,10 @@ export function ScheduleDetailView({
             {editable && target ? (
               <EngineModelInlineEditor
                 invocation={target}
-                onSave={(harness, modelName, serviceTier) =>
+                onSave={(harness, modelName, serviceTier, thinkingMode) =>
                   saveSpecField("engine-model", (s) => {
                     if (s.target.case === "agent") {
-                      applyEngineModel(s.target.value, harness, modelName, serviceTier);
+                      applyEngineModel(s.target.value, harness, modelName, serviceTier, thinkingMode);
                     }
                   })
                 }
@@ -1016,6 +1021,7 @@ function EngineModelInlineEditor({
     harness: Harness,
     modelName: string,
     serviceTier: ServiceTierOption,
+    thinkingMode: ThinkingModeOption,
   ) => Promise<boolean>;
   readonly isSaving: boolean;
   readonly error?: string;
@@ -1024,6 +1030,7 @@ function EngineModelInlineEditor({
   const [modelName, setModelName] = useState("");
   const [harness, setHarness] = useState<HarnessOption>("cursor");
   const [serviceTier, setServiceTier] = useState<ServiceTierOption>("standard");
+  const [thinkingMode, setThinkingMode] = useState<ThinkingModeOption>("disabled");
 
   const startEdit = () => {
     setModelName(invocation.runConfig?.modelName ?? "");
@@ -1035,6 +1042,9 @@ function EngineModelInlineEditor({
     setServiceTier(
       fromProtoServiceTier(invocation.runConfig?.serviceTier) ?? "standard",
     );
+    setThinkingMode(
+      fromProtoThinkingMode(invocation.runConfig?.thinkingMode) ?? "disabled",
+    );
     setIsEditing(true);
   };
 
@@ -1056,6 +1066,8 @@ function EngineModelInlineEditor({
           onHarnessChange={setHarness}
           serviceTier={serviceTier}
           onServiceTierChange={setServiceTier}
+          thinkingMode={thinkingMode}
+          onThinkingModeChange={setThinkingMode}
           placeholderLabel="Platform default"
           disabled={isSaving}
         />
@@ -1065,6 +1077,7 @@ function EngineModelInlineEditor({
             onClick={() => {
               setModelName("");
               setServiceTier("standard");
+              setThinkingMode("disabled");
             }}
             disabled={isSaving}
             className="stg:rounded-md stg:px-2 stg:py-1 stg:text-[0.65rem] stg:text-muted-foreground stg:hover:text-foreground stg:focus-visible:outline-none stg:focus-visible:ring-2 stg:focus-visible:ring-ring stg:disabled:pointer-events-none stg:disabled:opacity-50"
@@ -1084,6 +1097,7 @@ function EngineModelInlineEditor({
             modelName !== "" ? toProtoHarness(harness) : Harness.UNSPECIFIED,
             modelName,
             serviceTier,
+            thinkingMode,
           );
           if (ok) setIsEditing(false);
         }}
@@ -1169,14 +1183,17 @@ function applyEngineModel(
   harness: Harness,
   modelName: string,
   serviceTier: ServiceTierOption,
+  thinkingMode: ThinkingModeOption,
 ): void {
   invocation.harness = harness;
   invocation.runConfig = normalizeRunConfig(
     modelName,
     invocation.runConfig?.maxCostUsd ?? 0,
     invocation.runConfig?.maxToolRounds ?? 0,
-    // The tier rides the model choice: no model, no tier (#357).
+    // The variant attributes ride the model choice: no model, no tier and
+    // no thinking (#357/#772).
     modelName.trim() !== "" ? serviceTier : "standard",
+    modelName.trim() !== "" ? thinkingMode : "disabled",
   );
 }
 
@@ -1190,6 +1207,7 @@ function applyBudget(
     maxCostUsd ?? 0,
     invocation.runConfig?.maxToolRounds ?? 0,
     fromProtoServiceTier(invocation.runConfig?.serviceTier) ?? "standard",
+    fromProtoThinkingMode(invocation.runConfig?.thinkingMode) ?? "disabled",
   );
 }
 
@@ -1198,12 +1216,14 @@ function normalizeRunConfig(
   maxCostUsd: number,
   maxToolRounds: number,
   serviceTier: ServiceTierOption,
+  thinkingMode: ThinkingModeOption,
 ): RunConfig | undefined {
   const fields: {
     modelName?: string;
     maxCostUsd?: number;
     maxToolRounds?: number;
     serviceTier?: ServiceTier;
+    thinkingMode?: ThinkingMode;
   } = {};
   if (modelName.trim() !== "") fields.modelName = modelName.trim();
   if (maxCostUsd > 0) fields.maxCostUsd = maxCostUsd;
@@ -1211,6 +1231,8 @@ function normalizeRunConfig(
   // Only an active fast choice is carried — an untouched tier stays
   // absent, preserving the unspecified-vs-explicit ledger distinction (#357).
   if (serviceTier === "fast") fields.serviceTier = toProtoServiceTier(serviceTier);
+  // The tier's #772 twin: only an active enabled choice is carried.
+  if (thinkingMode === "enabled") fields.thinkingMode = toProtoThinkingMode(thinkingMode);
 
   return Object.keys(fields).length > 0
     ? create(RunConfigSchema, fields)
@@ -1429,6 +1451,9 @@ function EngineModelSummary({
   if (invocation?.runConfig?.serviceTier === ServiceTier.FAST) {
     parts.push("Fast tier");
   }
+  if (invocation?.runConfig?.thinkingMode === ThinkingMode.ENABLED) {
+    parts.push("Thinking");
+  }
   return <span className="stg:text-sm stg:text-foreground">{parts.join(" · ")}</span>;
 }
 

package/src/schedule/ScheduleForm.tsx

@@ -16,6 +16,7 @@ import { useGitHubConnection } from "../github/useGitHubConnection.js";
 import { ModelSelector } from "../models/ModelSelector.js";
 import { toProtoHarness, type HarnessOption } from "../models/harness.js";
 import { toProtoServiceTier, type ServiceTierOption } from "../models/service-tier.js";
+import { toProtoThinkingMode, type ThinkingModeOption } from "../models/thinking-mode.js";
 import { Switch } from "../switch/Switch.js";
 import { useStigmerPortalContainer } from "../portal-container.js";
 import { useWorkspaceEntries } from "../workspace/useWorkspaceEntries.js";
@@ -116,6 +117,8 @@ export function ScheduleForm({
   // is picked. No model pinned = no tier pinned (fast requires a model,
   // and the form's reset button clears both).
   const [serviceTier, setServiceTier] = useState<ServiceTierOption>("standard");
+  // Thinking mode: the tier's #772 twin, capability-scoped the same way.
+  const [thinkingMode, setThinkingMode] = useState<ThinkingModeOption>("disabled");
 
   const [budgetUsd, setBudgetUsd] = useState("");
 
@@ -152,7 +155,7 @@ export function ScheduleForm({
       if (!canSubmit || !agentRef) return;
 
       clearError();
-      const runConfig = buildRunConfig(modelName, budgetUsd, serviceTier);
+      const runConfig = buildRunConfig(modelName, budgetUsd, serviceTier, thinkingMode);
       try {
         const schedule = await create({
           name: trimmedName,
@@ -195,6 +198,7 @@ export function ScheduleForm({
       modelName,
       modelHarness,
       serviceTier,
+      thinkingMode,
       budgetUsd,
       workspace,
       onComplete,
@@ -362,6 +366,8 @@ export function ScheduleForm({
             onHarnessChange={setModelHarness}
             serviceTier={serviceTier}
             onServiceTierChange={setServiceTier}
+            thinkingMode={thinkingMode}
+            onThinkingModeChange={setThinkingMode}
             placeholderLabel="Platform default"
             disabled={isCreating}
           />
@@ -371,6 +377,7 @@ export function ScheduleForm({
               onClick={() => {
                 setModelName("");
                 setServiceTier("standard");
+                setThinkingMode("disabled");
               }}
               disabled={isCreating}
               className={cn(
@@ -514,6 +521,7 @@ function buildRunConfig(
   modelName: string,
   budgetUsd: string,
   serviceTier: ServiceTierOption,
+  thinkingMode: ThinkingModeOption,
 ): RunConfigInput | undefined {
   const model = modelName.trim();
   const cost = Number.parseFloat(budgetUsd);
@@ -528,6 +536,11 @@ function buildRunConfig(
   if (serviceTier === "fast" && model !== "") {
     config.serviceTier = toProtoServiceTier(serviceTier);
   }
+  // The tier's #772 twin: thinking is a per-model capability, same
+  // only-explicit-enabled + requires-a-model contract.
+  if (thinkingMode === "enabled" && model !== "") {
+    config.thinkingMode = toProtoThinkingMode(thinkingMode);
+  }
 
   return Object.keys(config).length > 0 ? config : undefined;
 }

package/src/session/NewSessionViewer.tsx

@@ -9,6 +9,7 @@ import type { WorkspaceContentSearcher } from "../workspace/WorkspaceContentSear
 import type { InteractionModeOption } from "../composer/index.js";
 import { SessionComposer } from "../composer/index.js";
 import type { HarnessOption } from "../models/harness.js";
+import type { AccountExecutionDefaults } from "../identity-account/useAccountExecutionDefaults.js";
 import { SessionViewerLayout } from "./SessionViewerLayout.js";
 import { useWorkspaceEditors } from "../internal/store/index.js";
 import { WorkspaceSurface } from "../workspace/WorkspaceSurface.js";
@@ -163,6 +164,15 @@ export interface NewSessionViewerProps {
    */
   readonly defaultHarness?: HarnessOption;
 
+  /**
+   * The user's account-level execution defaults, typically from
+   * `useAccountExecutionDefaults()`. Seeds the harness and model pickers
+   * under the layered precedence documented on
+   * {@link UseNewSessionFlowOptions.accountDefaults}; explicit device
+   * picks always win. Ignored for the `"guest"` audience.
+   */
+  readonly accountDefaults?: AccountExecutionDefaults;
+
   /** Agent to auto-select on mount (used for draft flows). */
   readonly initialAgentRef?: ResourceRef;
   /**
@@ -253,6 +263,7 @@ export function NewSessionViewer({
   panelOpen,
   onPanelOpenChange,
   defaultHarness,
+  accountDefaults,
   initialAgentRef,
   initialInstanceId,
   initialAttachments,
@@ -269,6 +280,7 @@ export function NewSessionViewer({
     onError,
     getRuntimeEnv,
     defaultHarness,
+    accountDefaults,
     audience,
     runConfig,
   });

package/src/session/__tests__/useNewSessionFlow.test.tsx

@@ -805,6 +805,157 @@ describe("useNewSessionFlow", () => {
     });
   });
 
+  describe("accountDefaults (oss#293 Phase 1.5 layered seed)", () => {
+    // Two native models so "stored pick outranks account default" is
+    // distinguishable; the shared TEST_MODELS carries one per harness.
+    const SEED_MODELS = parseRegistryJson({
+      models: [
+        { id: "claude-sonnet-4.6", displayName: "Claude Sonnet 4.6", shortDescription: "", speedTier: "fast", provider: "anthropic", harness: "native", costTier: "standard", featured: true, pricing: { inputPricePerMillion: 3, outputPricePerMillion: 15, cacheWritePricePerMillion: 3.75, cacheReadPricePerMillion: 0.3 } },
+        { id: "gpt-5.3", displayName: "GPT 5.3", shortDescription: "", speedTier: "fast", provider: "openai", harness: "native", costTier: "standard", featured: false, pricing: { inputPricePerMillion: 2, outputPricePerMillion: 8, cacheWritePricePerMillion: 2, cacheReadPricePerMillion: 0.2 } },
+        { id: "default", displayName: "Cursor Auto", shortDescription: "", speedTier: "fast", provider: "cursor", harness: "cursor", costTier: "standard", featured: true, pricing: { inputPricePerMillion: 1.25, outputPricePerMillion: 6, cacheWritePricePerMillion: 1.25, cacheReadPricePerMillion: 0.25 } },
+        { id: "composer-2.5", displayName: "Composer 2.5", shortDescription: "", speedTier: "fast", provider: "cursor", harness: "cursor", costTier: "standard", featured: false, pricing: { inputPricePerMillion: 1, outputPricePerMillion: 5, cacheWritePricePerMillion: 1, cacheReadPricePerMillion: 0.1 } },
+      ],
+    });
+
+    function seedWrapper() {
+      const state: ModelRegistryState = { models: SEED_MODELS, isLoading: false, error: null, refetch: () => {} };
+      return function Wrapper({ children }: { children: ReactNode }) {
+        return (
+          <ModelRegistryContext.Provider value={state}>
+            {children}
+          </ModelRegistryContext.Provider>
+        );
+      };
+    }
+
+    it("seeds the harness when nothing is stored", () => {
+      const opts = { ...defaultOptions(), accountDefaults: { harness: "cursor" as const } };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(result.current.harness).toBe("cursor");
+    });
+
+    it("a stored harness choice outranks the account default", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "native");
+      const opts = { ...defaultOptions(), accountDefaults: { harness: "cursor" as const } };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(result.current.harness).toBe("native");
+    });
+
+    it("the account harness outranks the embedder defaultHarness", () => {
+      const opts = {
+        ...defaultOptions(),
+        defaultHarness: "native" as const,
+        accountDefaults: { harness: "cursor" as const },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(result.current.harness).toBe("cursor");
+    });
+
+    it("never persists the seeded harness — only explicit choices", () => {
+      const opts = { ...defaultOptions(), accountDefaults: { harness: "cursor" as const } };
+      renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBeNull();
+    });
+
+    it("a late-arriving harness seed applies when the user has not picked (whoAmI resolves after mount)", () => {
+      const base: Parameters<typeof useNewSessionFlow>[0] = defaultOptions();
+      const { result, rerender } = renderHook(
+        (opts: Parameters<typeof useNewSessionFlow>[0]) => useNewSessionFlow(opts),
+        { wrapper: seedWrapper(), initialProps: base },
+      );
+      expect(result.current.harness).toBe("native");
+
+      rerender({ ...base, accountDefaults: { harness: "cursor" as const } });
+
+      expect(result.current.harness).toBe("cursor");
+      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBeNull();
+    });
+
+    it("a late-arriving harness seed never overrides an explicit pick this mount", () => {
+      const base: Parameters<typeof useNewSessionFlow>[0] = defaultOptions();
+      const { result, rerender } = renderHook(
+        (opts: Parameters<typeof useNewSessionFlow>[0]) => useNewSessionFlow(opts),
+        { wrapper: seedWrapper(), initialProps: base },
+      );
+      act(() => result.current.setHarness("native"));
+
+      rerender({ ...base, accountDefaults: { harness: "cursor" as const } });
+
+      expect(result.current.harness).toBe("native");
+    });
+
+    it("seeds the model for the active harness when nothing is stored", () => {
+      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(result.current.modelId).toBe("gpt-5.3");
+    });
+
+    it("a stored model pick outranks the account default", async () => {
+      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, "claude-sonnet-4.6");
+      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      // The stored restore lands in a passive effect once the registry is
+      // ready; the account seed must not win the race before it.
+      await act(async () => {});
+      expect(result.current.modelId).toBe("claude-sonnet-4.6");
+    });
+
+    it("self-heals a stale account model to the platform default (undefined)", () => {
+      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "retired-model" } };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(result.current.modelId).toBeUndefined();
+    });
+
+    it("never persists the seeded model — only explicit choices", () => {
+      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
+      renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_NATIVE)).toBeNull();
+    });
+
+    it("follows the active harness: cursorModel seeds cursor sessions", () => {
+      const opts = {
+        ...defaultOptions(),
+        accountDefaults: { harness: "cursor" as const, nativeModel: "gpt-5.3", cursorModel: "composer-2.5" },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      expect(result.current.harness).toBe("cursor");
+      expect(result.current.modelId).toBe("composer-2.5");
+    });
+
+    it("submits the seeded model explicitly — the pill promise (#663) and the DD-003 seed rule", async () => {
+      const opts = { ...defaultOptions(), accountDefaults: { nativeModel: "gpt-5.3" } };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateExecution.mock.calls[0][0].modelName).toBe("gpt-5.3");
+    });
+
+    it("guest audience ignores accountDefaults entirely", () => {
+      const opts = {
+        ...defaultOptions(),
+        audience: "guest" as const,
+        accountDefaults: { harness: "native" as const, nativeModel: "gpt-5.3", cursorModel: "composer-2.5" },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: seedWrapper() });
+
+      // Platform share policy: cursor harness, no client model.
+      expect(result.current.harness).toBe("cursor");
+      expect(result.current.modelId).toBeUndefined();
+    });
+  });
+
   describe("submit while default agent is loading", () => {
     it("awaits default agent and creates session when fetch resolves", async () => {
       const resolvedAgent = { status: { defaultInstanceId: "awaited-inst" } };

package/src/session/run-config.ts

@@ -1,4 +1,5 @@
 import type { ServiceTierOption } from "../models/service-tier.js";
+import type { ThinkingModeOption } from "../models/thinking-mode.js";
 
 /**
  * Owner-pinned execution config for a session surface
@@ -39,6 +40,14 @@ export interface SessionRunConfig {
    * pin is a host configuration error and throws at submit.
    */
   readonly serviceTier?: ServiceTierOption;
+  /**
+   * Thinking mode for every execution (stigmer/stigmer#772).
+   * `"enabled"` requires {@link modelName} under the same contract as
+   * {@link serviceTier}: thinking is a per-model capability (the server
+   * refuses it fail-closed for Auto), so a mode pin without a model pin
+   * is a host configuration error and throws at submit.
+   */
+  readonly thinkingMode?: ThinkingModeOption;
 }
 
 /**
@@ -56,4 +65,11 @@ export function assertValidRunConfig(runConfig: SessionRunConfig): void {
         + "dimension. Pin the model the surface should run.",
     );
   }
+  if (runConfig.thinkingMode === "enabled" && !runConfig.modelName) {
+    throw new Error(
+      "SessionRunConfig: thinkingMode \"enabled\" requires modelName — "
+        + "thinking is a per-model capability and Auto (no pinned model) has "
+        + "no variant dimensions. Pin the model the surface should run.",
+    );
+  }
 }

package/src/session/useNewSessionFlow.ts

@@ -1,7 +1,8 @@
 "use client";
 
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { getUserMessage, type McpServerUsageInput, type ResourceRef } from "@stigmer/sdk";
+import type { AccountExecutionDefaults } from "../identity-account/useAccountExecutionDefaults.js";
 import type { AgentResolution } from "../agent/index.js";
 import { useDefaultAgent } from "../agent/index.js";
 import { useModelRegistry } from "../models/index.js";
@@ -102,6 +103,26 @@ export interface UseNewSessionFlowOptions {
    * @default DEFAULT_HARNESS ("native")
    */
   readonly defaultHarness?: HarnessOption;
+  /**
+   * The user's account-level execution defaults
+   * (`IdentityAccountPreferences.default_*`), typically from
+   * `useAccountExecutionDefaults()`. A SEED in the layered precedence —
+   * explicit device-local choices always outrank it:
+   *
+   * - harness: stored choice > `accountDefaults.harness` >
+   *   {@link defaultHarness} > platform default. May arrive after mount
+   *   (whoAmI resolves async); a late value still seeds unless the user
+   *   has already picked a harness this mount.
+   * - model: stored per-harness choice > the account's model for the
+   *   active harness (validated against the registry; a stale model
+   *   silently falls through) > the harness default.
+   *
+   * Seeded values are never persisted to localStorage — the account
+   * preference keeps applying until the user decides. Ignored for the
+   * `"guest"` audience (platform share policy owns guest config), and
+   * consumers must not fetch identity for guest/embed surfaces.
+   */
+  readonly accountDefaults?: AccountExecutionDefaults;
   /**
    * Who this flow serves. `"guest"` adapts the orchestration to the
    * guest principal's permission model: the org default-agent lookup
@@ -162,7 +183,12 @@ export interface UseNewSessionFlowReturn {
   /** Switch the harness. Resets the model if invalid for the new harness. */
   readonly setHarness: (harness: HarnessOption) => void;
 
-  /** Currently selected model ID (persisted per-harness to localStorage). */
+  /**
+   * The model an untouched send will run: the explicit device pick when
+   * one exists (persisted per-harness to localStorage), else the account
+   * default for the active harness. `undefined` resolves to the harness
+   * default downstream.
+   */
   readonly modelId: string | undefined;
   /** Update the selected model. Automatically persists to localStorage. */
   readonly setModelId: (id: string) => void;
@@ -269,6 +295,10 @@ export function useNewSessionFlow(
     sessionContext,
   } = options;
   const isGuest = options.audience === "guest";
+  // Guests never inherit account defaults — the platform share policy owns
+  // guest execution config (GUEST_HARNESS reasoning), and identity-derived
+  // preferences must never shape a share/embed surface.
+  const accountDefaults = isGuest ? undefined : options.accountDefaults;
   // Guests never carry a client pin: guest execution config is owned by
   // the server-side share policy (GUEST_HARNESS reasoning). Validated at
   // render so a statically-wrong pin (fast tier, no model) fails in the
@@ -277,6 +307,7 @@ export function useNewSessionFlow(
   if (runConfig) assertValidRunConfig(runConfig);
   const pinnedModelName = runConfig?.modelName;
   const pinnedServiceTier = runConfig?.serviceTier;
+  const pinnedThinkingMode = runConfig?.thinkingMode;
   const contextTarget = useExecutionTarget();
   const executionTarget = options.executionTarget ?? contextTarget;
   const adapter = useRunnerAdapter();
@@ -293,13 +324,30 @@ export function useNewSessionFlow(
     // touch localStorage: a browser previously used in the Console must not
     // leak its stored harness into a share/embed session.
     if (isGuest) return GUEST_HARNESS;
-    if (typeof window === "undefined") return defaultHarness ?? DEFAULT_HARNESS;
+    if (typeof window === "undefined")
+      return accountDefaults?.harness ?? defaultHarness ?? DEFAULT_HARNESS;
     // Only explicit user choices are persisted (see setHarness), so a
-    // stored value always outranks the embedder's defaultHarness.
+    // stored value always outranks the account default and the embedder's
+    // defaultHarness.
     const stored = localStorage.getItem(STORAGE_KEY_HARNESS);
     if (stored === "native" || stored === "cursor") return stored;
-    return defaultHarness ?? DEFAULT_HARNESS;
+    return accountDefaults?.harness ?? defaultHarness ?? DEFAULT_HARNESS;
   });
+  // Set once the user picks a harness this mount — a late-arriving account
+  // default must never override an explicit choice (the composer's
+  // userOverrodeModel idiom).
+  const harnessTouchedRef = useRef(false);
+
+  // Account defaults resolve async (whoAmI): when the harness seed arrives
+  // after mount, apply it once — unless the user has picked or a stored
+  // choice exists. Never persisted: seeding must not masquerade as a user
+  // choice, or the account preference would stop applying elsewhere.
+  useEffect(() => {
+    const seed = accountDefaults?.harness;
+    if (isGuest || harnessTouchedRef.current || !seed) return;
+    if (typeof window !== "undefined" && localStorage.getItem(STORAGE_KEY_HARNESS)) return;
+    setHarnessRaw(seed);
+  }, [isGuest, accountDefaults?.harness]);
 
   const stigmer = useStigmer();
   const { getModel, isLoading: isModelsLoading } = useModelRegistry({ harness });
@@ -326,8 +374,26 @@ export function useNewSessionFlow(
 
   const validModelId = modelId && getModel(modelId) ? modelId : undefined;
 
+  // The account's model for the active harness, registry-validated the same
+  // way as the stored choice (a stale/removed preference silently falls
+  // through to the harness default — self-healing). Derived, never written
+  // into `modelId` state: the persist effect below stores only explicit
+  // choices, and a derived seed cannot leak into localStorage.
+  const accountModelForHarness =
+    harness === "cursor" ? accountDefaults?.cursorModel : accountDefaults?.nativeModel;
+  const accountModelId =
+    accountModelForHarness && getModel(accountModelForHarness)
+      ? accountModelForHarness
+      : undefined;
+
+  // Layered precedence: explicit device pick > account default. The result
+  // feeds the composer's model pill AND the submit path, so the pill always
+  // shows what an untouched send will run (#663).
+  const effectiveModelId = validModelId ?? accountModelId;
+
   const setHarness = useCallback(
     (h: HarnessOption) => {
+      harnessTouchedRef.current = true;
       setHarnessRaw(h);
       // Guests have no harness picker; if a caller invokes this anyway, the
       // guest surface must never write into the Console's preference keys.
@@ -415,14 +481,20 @@ export function useNewSessionFlow(
           // The owner pin wins over the composer and the restored
           // preference (#664); the pinned tier is stamped only as
           // "fast" — standard stays off the wire, preserving the #357
-          // UNSPECIFIED-vs-explicit telemetry distinction.
-          modelName: pinnedModelName ?? selectedModel ?? validModelId,
+          // UNSPECIFIED-vs-explicit telemetry distinction. The effective
+          // model carries the account-default seed explicitly (DD-003:
+          // the preference is a seed; the execution spec is the record).
+          modelName: pinnedModelName ?? selectedModel ?? effectiveModelId,
           runtimeEnv,
           attachments: context?.attachments,
           interactionMode: context?.interactionMode,
           serviceTier: pinnedModelName
             ? (pinnedServiceTier === "fast" ? "fast" : undefined)
             : context?.serviceTier,
+          // The tier's #772 twin, same pin-wins + only-explicit-enabled rule.
+          thinkingMode: pinnedModelName
+            ? (pinnedThinkingMode === "enabled" ? "enabled" : undefined)
+            : context?.thinkingMode,
           workspaceFileRefs: context?.workspaceFileRefs,
           autoApproveAll,
         };
@@ -514,9 +586,10 @@ export function useNewSessionFlow(
       autoApproveAll,
       adapter,
       getRuntimeEnv,
-      validModelId,
+      effectiveModelId,
       pinnedModelName,
       pinnedServiceTier,
+      pinnedThinkingMode,
       workspace,
       mcpServerUsages,
       skillRefs,
@@ -539,7 +612,7 @@ export function useNewSessionFlow(
   return {
     harness,
     setHarness,
-    modelId: validModelId,
+    modelId: effectiveModelId,
     setModelId,
     agentRef,
     setAgentRef,