fix: new threads keep their project's last-used model and modes

apps/mobile/src/features/threads/new-task-flow-provider.tsx

@@ -74,6 +74,7 @@ import {
   isAtomCommandInterrupted,
   squashAtomCommandFailure,
 } from "@t3tools/client-runtime/state/runtime";
+import { resolveProjectLastUsedSettings } from "@t3tools/client-runtime/state/project-last-used-settings";
 import { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
 import { type VcsRef } from "@t3tools/client-runtime/state/vcs";
 import {
@@ -407,8 +408,19 @@ export function NewTaskFlowProvider(
   const draftStartFromOrigin = selectedProjectDraft.workspaceSelection?.startFromOrigin;
   const startFromOrigin =
     isGitRepo && (draftStartFromOrigin ?? projectSettings.settings.newWorktreesStartFromOrigin);
-  const defaultRuntimeMode = projectSettings.settings.defaultRuntimeMode;
+  const lastUsed = selectedProject
+    ? resolveProjectLastUsedSettings(threads, {
+        environmentId: selectedProject.environmentId,
+        projectId: selectedProject.id,
+      })
+    : null;
   const managedPolicy = selectedEnvironmentServerConfig?.managedPolicy;
+  // A mode configured on the project wins over its history, which yields to the policy ceiling.
+  const defaultRuntimeMode = resolveNewThreadRuntimeMode(
+    projectSettings.sources.defaultRuntimeMode === "project" ? undefined : lastUsed?.runtimeMode,
+    projectSettings.settings.defaultRuntimeMode,
+    managedPolicy,
+  );
   const runtimeMode = resolveNewThreadRuntimeMode(
     selectedProjectDraft.runtimeMode,
     defaultRuntimeMode,
@@ -422,33 +434,56 @@ export function NewTaskFlowProvider(
     selectedProjectDraft.modelSelection ?? null,
     selectedProject?.id ?? null,
   );
-  const projectDefaultModelSelection = resolveDefaultableModelSelection(
+  // A model configured on the project wins over its history; the
+  // environment's default only applies after the project's history.
+  const configuredDefaultModelSelection = resolveDefaultableModelSelection(
     selectedEnvironmentServerConfig,
     projectSettings.settings.defaultModelSelection,
     selectedProject?.id ?? null,
   );
+  const projectDefaultModelSelection =
+    projectSettings.sources.defaultModelSelection === "environment"
+      ? null
+      : configuredDefaultModelSelection;
+  const environmentDefaultModelSelection =
+    projectDefaultModelSelection === null ? configuredDefaultModelSelection : null;
+  const lastUsedModelSelection = resolveDefaultableModelSelection(
+    selectedEnvironmentServerConfig,
+    lastUsed?.modelSelection ?? null,
+    selectedProject?.id ?? null,
+  );
   const stickyModelSelection = resolveDefaultableModelSelection(
     selectedEnvironmentServerConfig,
     storedStickyModelSelection,
     selectedProject?.id ?? null,
   );
   const modelOptions = buildModelOptions(
     selectedEnvironmentServerConfig,
-    draftModelSelection ?? projectDefaultModelSelection ?? stickyModelSelection,
+    draftModelSelection ??
+      projectDefaultModelSelection ??
+      lastUsedModelSelection ??
+      environmentDefaultModelSelection ??
+      stickyModelSelection,
     undefined,
     selectedProject?.id ?? null,
   );
 
   const selectedDefaultModel = resolveNewTaskModelSelection({
     draftSelection: draftModelSelection,
     projectDefaultSelection: projectDefaultModelSelection,
+    lastUsedSelection: lastUsedModelSelection,
+    environmentDefaultSelection: environmentDefaultModelSelection,
     stickySelection: stickyModelSelection,
     modelOptions,
   });
   const selectedModel = resolveNewThreadModelSelection({
     defaultSelection: selectedDefaultModel,
     explicitSelection:
-      draftModelSelection ?? (projectDefaultModelSelection ? null : stickyModelSelection),
+      draftModelSelection ??
+      (projectDefaultModelSelection
+        ? null
+        : (lastUsedModelSelection ??
+          (environmentDefaultModelSelection ? null : stickyModelSelection))),
     fallbackSelection: selectedEnvironmentServerConfig?.settings.fallbackModelSelection ?? null,
     providers: selectedEnvironmentServerConfig?.providers ?? [],
     ...(selectedEnvironmentServerConfig

apps/mobile/src/lib/modelOptions.test.ts

@@ -535,9 +535,11 @@ describe("mobile model options", () => {
     expect(resolveDefaultableModelSelection(null, legacy, null)).toBe(legacy);
   });
 
-  it("resolves new tasks from draft, project, sticky, then provider defaults", () => {
+  it("resolves new tasks from draft, project, last-used, environment, sticky, then provider defaults", () => {
     const draft = { instanceId: ProviderInstanceId.make("codex"), model: "draft" };
     const project = { instanceId: ProviderInstanceId.make("codex"), model: "project" };
+    const lastUsed = { instanceId: ProviderInstanceId.make("codex"), model: "last-used" };
+    const environment = { instanceId: ProviderInstanceId.make("claudeAgent"), model: "env" };
     const sticky = { instanceId: ProviderInstanceId.make("codex"), model: "sticky" };
     const providerDefault = {
       selection: { instanceId: ProviderInstanceId.make("codex"), model: "default" },
@@ -546,19 +548,26 @@ describe("mobile model options", () => {
     const resolve = (
       draftSelection: ModelSelection | null,
       projectDefaultSelection: ModelSelection | null,
+      lastUsedSelection: ModelSelection | null,
       stickySelection: ModelSelection | null,
+      environmentDefaultSelection: ModelSelection | null = null,
     ) =>
       resolveNewTaskModelSelection({
         draftSelection,
         projectDefaultSelection,
+        lastUsedSelection,
+        environmentDefaultSelection,
         stickySelection,
         modelOptions: [providerDefault],
       });
 
-    expect(resolve(draft, project, sticky)).toBe(draft);
-    expect(resolve(null, project, sticky)).toBe(project);
-    expect(resolve(null, null, sticky)).toBe(sticky);
-    expect(resolve(null, null, null)).toBe(providerDefault.selection);
+    expect(resolve(draft, project, lastUsed, sticky)).toBe(draft);
+    expect(resolve(null, project, lastUsed, sticky)).toBe(project);
+    expect(resolve(null, null, lastUsed, sticky)).toBe(lastUsed);
+    expect(resolve(null, null, lastUsed, sticky, environment)).toBe(lastUsed);
+    expect(resolve(null, null, null, sticky, environment)).toBe(environment);
+    expect(resolve(null, null, null, sticky)).toBe(sticky);
+    expect(resolve(null, null, null, null)).toBe(providerDefault.selection);
 
     const unavailable = { ...providerDefault, isUnavailable: true };
     expect(

apps/mobile/src/lib/modelOptions.ts

@@ -263,12 +263,16 @@ export function resolveDefaultableModelSelection(
 export function resolveNewTaskModelSelection(input: {
   readonly draftSelection: ModelSelection | null;
   readonly projectDefaultSelection: ModelSelection | null;
+  readonly lastUsedSelection?: ModelSelection | null;
+  readonly environmentDefaultSelection?: ModelSelection | null;
   readonly stickySelection: ModelSelection | null;
   readonly modelOptions: ReadonlyArray<ModelOption>;
 }): ModelSelection | null {
   return (
     input.draftSelection ??
     input.projectDefaultSelection ??
+    input.lastUsedSelection ??
+    input.environmentDefaultSelection ??
     input.stickySelection ??
     input.modelOptions.find((option) => option.isDefault && !option.isUnavailable)?.selection ??
     input.modelOptions.find((option) => !option.isUnavailable)?.selection ??

apps/web/src/components/ChatView.tsx

@@ -251,6 +251,7 @@ import {
   resolveThreadDetailRef,
   useEnvironmentSupportsServerBrowser,
   useProject,
+  useProjectLastUsedRuntimeMode,
   useQuietThreadProjection,
   useThreadUpdatedAt,
   useThreadLastVisitedAt,
@@ -260,6 +261,8 @@ import {
   useQuietThreadShell,
   useThreadCheckpointSummaries,
 } from "../state/entities";
+import { resolveDefaultRuntimeMode } from "../lib/chatThreadActions";
+import { useManagedPolicy } from "../state/managedPolicy";
 import { useEnvironmentShellHasSnapshot } from "../state/shell";
 import { ChatComposer, type ChatComposerHandle } from "./chat/ChatComposer";
 import { DraftHeroHeadline } from "./chat/DraftHeroHeadline";
@@ -936,8 +939,17 @@ export default function ChatView(props: ChatViewProps) {
   const [, setThreadErrorBannerDismissTick] = useState(0);
   const threadErrorIsServerRuntimeError =
     localServerError === null && visibleThreadError === serverRuntime?.lastError;
-  const defaultRuntimeMode = resolveProjectSettings(settings, activeThread?.projectId ?? null)
-    .settings.defaultRuntimeMode;
+  const managedPolicy = useManagedPolicy(environmentId);
+  const draftLastUsedRuntimeMode = useProjectLastUsedRuntimeMode(
+    !isServerThread && activeThread
+      ? scopeProjectRef(activeThread.environmentId, activeThread.projectId)
+      : null,
+  );
+  const defaultRuntimeMode = resolveDefaultRuntimeMode(
+    resolveProjectSettings(settings, activeThread?.projectId ?? null),
+    draftLastUsedRuntimeMode,
+    managedPolicy,
+  );
   const runtimeMode =
     composerRuntimeMode ??
     (isServerThread ? activeThread?.runtimeMode : undefined) ??

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

@@ -16,7 +16,7 @@ import { useProjectPin } from "~/hooks/useProjectGroupUpdate";
 import { useScratchProject } from "~/hooks/useScratchProject";
 import { isTriagePrompt } from "~/hooks/useStartTriage";
 import { useClientSettings } from "~/hooks/useSettings";
-import { hasExplicitComposerModelSelection } from "~/lib/chatThreadActions";
+import { retargetDraftToProject } from "~/lib/chatThreadActions";
 import {
   deriveLogicalProjectKeyFromSettings,
   pickableProjectGroups,
@@ -52,9 +52,6 @@ import { InlineButton } from "../ui/button";
 import { DraftProjectName } from "./DraftProjectName";
 import { DraftHeroProjectHeading } from "./DraftHeroProjectHeading";
 import { TriageDraftHero } from "./TriageDraftHero";
-import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
-import { resolveProjectDefaultProviderModelSelection } from "../../providerInstances";
-import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
 
 const ADD_PROJECT_VALUE = "add-project";
 
@@ -81,16 +78,11 @@ export function DraftHeroHeadline({
   const primaryEnvironmentId = usePrimaryEnvironmentId();
   const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings);
   const projectSortOrder = useClientSettings((settings) => settings.sidebarProjectSortOrder);
-  const setLogicalProjectDraftThreadId = useComposerDraftStore(
-    (store) => store.setLogicalProjectDraftThreadId,
-  );
   const getComposerDraft = useComposerDraftStore((store) => store.getComposerDraft);
   // A boolean, so typing in a draft does not re-render the hero.
   const isTriageDraftPrompt = useComposerDraftStore((store) =>
     draftId ? isTriagePrompt(store.getComposerDraft(draftId)?.prompt ?? "") : false,
   );
-  const applyStickyState = useComposerDraftStore((store) => store.applyStickyState);
-  const setModelSelection = useComposerDraftStore((store) => store.setModelSelection);
   const openAddProject = () => openCommandPalette({ open: "add-project" });
   const { scratchEnvironmentId, scratchWorkspaceRootFor, openScratchProject } = useScratchProject();
   const openProjectDraft = useNewThreadHandler();
@@ -203,46 +195,20 @@ export function DraftHeroHeadline({
       void openProjectDraft(scopeProjectRef(project.environmentId, project.id));
       return;
     }
-    setLogicalProjectDraftThreadId(
-      logicalProjectKey,
-      scopeProjectRef(project.environmentId, project.id),
+    const targetServerConfig = environments.find(
+      (environment) => environment.environmentId === project.environmentId,
+    )?.serverConfig;
+    retargetDraftToProject({
       draftId,
-    );
-    if (!hasExplicitComposerModelSelection(currentDraft)) {
-      applyStickyState(draftId);
-      const environmentConfig = environments.find(
-        (environment) => environment.environmentId === project.environmentId,
-      )?.serverConfig;
-      const environmentSettings = environmentConfig?.settings;
-      const defaultSelection = environmentSettings
-        ? resolveProjectSettings(environmentSettings, project.id, project).settings
-            .defaultModelSelection
-        : project.defaultModelSelection;
-      const fallbackResolution = resolveNewThreadModelSelection({
-        defaultSelection:
-          defaultSelection ??
-          (useComposerDraftStore.getState().stickyActiveProvider !== null || !environmentSettings
-            ? null
-            : resolveProjectDefaultProviderModelSelection(
-                providersByEnvironment.get(project.environmentId) ?? [],
-                environmentSettings,
-                project.id,
-              )),
-        fallbackSelection: environmentSettings?.fallbackModelSelection ?? null,
-        providers: providersByEnvironment.get(project.environmentId) ?? [],
-        ...(environmentSettings ? { settings: environmentSettings } : {}),
-        projectId: project.id,
-        now: Date.now(),
-      });
-      const defaultModelSelection = fallbackResolution.fallback
-        ? fallbackResolution.selection
-        : defaultSelection;
-      if (defaultModelSelection) {
-        setModelSelection(draftId, defaultModelSelection, {
-          replaceOptions: true,
-        });
-      }
-    }
+      projectRef: scopeProjectRef(project.environmentId, project.id),
+      project,
+      environmentSettings: targetServerConfig?.settings,
+      managedPolicy: targetServerConfig?.managedPolicy,
+      providers: providersByEnvironment.get(project.environmentId) ?? [],
+      threads,
+      logicalProjectKey,
+      refreshModel: true,
+    });
   };
   const startScratch = async (): Promise<boolean> => {
     if (scratchTargetEnvironmentId === null || isScratchDraft) {

apps/web/src/components/chat/useDraftEnvironmentRouting.ts

@@ -18,7 +18,8 @@ import {
 } from "@t3tools/client-runtime/state/project-grouping";
 import { useComposerDraftStore, DraftId } from "../../composerDraftStore";
 import { type EnvironmentPresentation, useEnvironmentProviders } from "../../state/environments";
-import { useProjects } from "../../state/entities";
+import { readThreadShells, useProjects } from "../../state/entities";
+import { retargetDraftToProject } from "../../lib/chatThreadActions";
 import type { DraftSessionState } from "../../composerDraftStore";
 
 interface DraftEnvironmentRoutingInput {
@@ -68,9 +69,6 @@ export function useDraftEnvironmentRouting(input: DraftEnvironmentRoutingInput)
   } = input;
   const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
   const getDraftSession = useComposerDraftStore((store) => store.getDraftSession);
-  const setLogicalProjectDraftThreadId = useComposerDraftStore(
-    (store) => store.setLogicalProjectDraftThreadId,
-  );
   const allProjects = useProjects();
   const { openScratchProject } = useScratchProject();
   const needsLoadBalancing = automaticEnvironment && !draftThread?.loadBalancedEnvironmentId;
@@ -118,19 +116,32 @@ export function useDraftEnvironmentRouting(input: DraftEnvironmentRoutingInput)
       (environment) => environment.environmentId === loadBalancing.environmentId,
     );
     if (!target?.projectId) return;
-    setDraftThreadContext(draftId, {
+    retargetDraftToProject({
+      draftId,
       projectRef: scopeProjectRef(target.environmentId, target.projectId),
-      environmentSelection: "auto",
-      loadBalancedEnvironmentId: target.environmentId,
+      project:
+        allProjects.find(
+          (project) =>
+            project.environmentId === target.environmentId && project.id === target.projectId,
+        ) ?? null,
+      environmentSettings: environmentById.get(target.environmentId)?.serverConfig?.settings,
+      managedPolicy: environmentById.get(target.environmentId)?.serverConfig?.managedPolicy,
+      providers: providersByEnvironment.get(target.environmentId) ?? [],
+      threads: readThreadShells(),
+      logicalProjectKey: null,
+      routing: { environmentSelection: "auto", loadBalancedEnvironmentId: target.environmentId },
+      refreshModel: false,
     });
   }, [
     needsLoadBalancing,
     loadBalancing.pending,
     loadBalancing.environmentId,
     draftId,
     logicalProjectEnvironments,
+    allProjects,
+    environmentById,
+    providersByEnvironment,
     sendInFlightRef,
-    setDraftThreadContext,
   ]);
   const onAutoEnvironment = () => {
     if (envLocked || !draftId) return;
@@ -221,21 +232,20 @@ export function useDraftEnvironmentRouting(input: DraftEnvironmentRoutingInput)
         currentDraft.projectId !== originalDraft.projectId
       )
         return;
-      const projectRef = scopeProjectRef(target.environmentId, project.id);
-      if (activeProjectIsScratch) {
-        setLogicalProjectDraftThreadId(
-          deriveLogicalProjectKeyFromSettings(project, projectGroupingSettings),
-          projectRef,
-          draftId,
-          { environmentSelection: "manual", loadBalancedEnvironmentId: null },
-        );
-      } else {
-        setDraftThreadContext(draftId, {
-          projectRef,
-          environmentSelection: "manual",
-          loadBalancedEnvironmentId: null,
-        });
-      }
+      retargetDraftToProject({
+        draftId,
+        projectRef: scopeProjectRef(target.environmentId, project.id),
+        project,
+        environmentSettings: environmentById.get(target.environmentId)?.serverConfig?.settings,
+        managedPolicy: environmentById.get(target.environmentId)?.serverConfig?.managedPolicy,
+        providers: providersByEnvironment.get(target.environmentId) ?? [],
+        threads: readThreadShells(),
+        logicalProjectKey: activeProjectIsScratch
+          ? deriveLogicalProjectKeyFromSettings(project, projectGroupingSettings)
+          : null,
+        routing: { environmentSelection: "manual", loadBalancedEnvironmentId: null },
+        refreshModel: true,
+      });
     };
     const finish = () => {
       if (environmentChangeRef.current === request) environmentChangeRef.current = null;