feat(FN-1191): hot-swap active executor sessions on model changes

- Show resolved default executor, validator, and planning models in the task Model tab
- Pass merged settings into the Model tab from TaskDetailModal so default badges reflect effective runtime resolution
- Hot-swap active single-session executor models when task overrides change, including fallback to project defaults when overrides are cleared
- Add dashboard and executor tests for default model display, hot-swap behavior, fallback logic, and failure logging
- Document hot-swap behavior and limitations in AGENTS.md and add a patch changeset for @gsxdsm/fusion

.changeset/fn-1191-model-hot-swap.md

@@ -0,0 +1,5 @@
+---
+"@gsxdsm/fusion": patch
+---
+
+Show resolved default models in the task Model tab and hot-swap active executor sessions when per-task executor model settings change during single-session execution.

AGENTS.md

@@ -1301,7 +1301,7 @@ To clear overrides, select "Use default" for both fields and save. To reset thin
 
 ### Engine Behavior
 
-- **Executor**: When both `modelProvider` and `modelId` are set on a task, the executor uses those instead of global settings when creating the agent session.
+- **Executor**: When both `modelProvider` and `modelId` are set on a task, the executor uses those instead of global settings when creating the agent session. In single-session execution mode, changing these fields on an in-progress task hot-swaps the active session model immediately (no pause/resume required). In step-session mode (`runStepsInNewSessions`), currently-running steps are not hot-swapped; changes apply when the next step session is created.
 - **Reviewer**: When both `validatorModelProvider` and `validatorModelId` are set, the reviewer uses those instead of global settings. The validator model is passed via `ReviewOptions` to `reviewStep()`.
 - **Planning**: When both `planningModelProvider` and `planningModelId` are set, the triage agent uses those instead of global settings for task specification.
 - **Thinking Level**: When `thinkingLevel` is set to a value other than `"off"`, the executor uses that reasoning effort level instead of the global default. Configurable from the Model tab in the task detail modal and during task creation. Valid values: `"off"`, `"minimal"`, `"low"`, `"medium"`, `"high"`.

packages/dashboard/app/components/ModelSelectorTab.tsx

@@ -1,7 +1,7 @@
 import { useState, useEffect, useCallback, useMemo, useRef } from "react";
 import { fetchModels, updateTask, updateGlobalSettings } from "../api";
 import type { ModelInfo } from "../api";
-import type { Task, TaskDetail } from "@fusion/core";
+import type { Settings, Task, TaskDetail } from "@fusion/core";
 import type { ToastType } from "../hooks/useToast";
 import { CustomModelDropdown } from "./CustomModelDropdown";
 import { ProviderIcon } from "./ProviderIcon";
@@ -10,6 +10,7 @@ interface ModelSelectorTabProps {
   task: Task | TaskDetail;
   addToast: (message: string, type?: ToastType) => void;
   onTaskUpdated?: (task: Task) => void;
+  settings?: Settings;
 }
 
 interface ModelSelection {
@@ -42,6 +43,51 @@ function getPlanningSelection(task: Task | TaskDetail): ModelSelection {
   };
 }
 
+function resolveEffectiveExecutor(
+  task: Task | TaskDetail,
+  settings?: Settings,
+): ModelSelection {
+  if (task.modelProvider && task.modelId) {
+    return { provider: task.modelProvider, modelId: task.modelId };
+  }
+  if (settings?.defaultProvider && settings.defaultModelId) {
+    return { provider: settings.defaultProvider, modelId: settings.defaultModelId };
+  }
+  return {};
+}
+
+function resolveEffectiveValidator(
+  task: Task | TaskDetail,
+  settings?: Settings,
+): ModelSelection {
+  if (task.validatorModelProvider && task.validatorModelId) {
+    return { provider: task.validatorModelProvider, modelId: task.validatorModelId };
+  }
+  if (settings?.validatorProvider && settings.validatorModelId) {
+    return { provider: settings.validatorProvider, modelId: settings.validatorModelId };
+  }
+  if (settings?.defaultProvider && settings.defaultModelId) {
+    return { provider: settings.defaultProvider, modelId: settings.defaultModelId };
+  }
+  return {};
+}
+
+function resolveEffectivePlanning(
+  task: Task | TaskDetail,
+  settings?: Settings,
+): ModelSelection {
+  if (task.planningModelProvider && task.planningModelId) {
+    return { provider: task.planningModelProvider, modelId: task.planningModelId };
+  }
+  if (settings?.planningProvider && settings.planningModelId) {
+    return { provider: settings.planningProvider, modelId: settings.planningModelId };
+  }
+  if (settings?.defaultProvider && settings.defaultModelId) {
+    return { provider: settings.defaultProvider, modelId: settings.defaultModelId };
+  }
+  return {};
+}
+
 function parseModelValue(value: string): ModelSelection {
   if (!value) {
     return { provider: undefined, modelId: undefined };
@@ -79,7 +125,7 @@ function getSuccessToastMessage(target: "executor" | "validator" | "planning", s
   return `${label} model set to ${selection.provider}/${selection.modelId}`;
 }
 
-export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelectorTabProps) {
+export function ModelSelectorTab({ task, addToast, onTaskUpdated, settings }: ModelSelectorTabProps) {
   const [availableModels, setAvailableModels] = useState<ModelInfo[]>([]);
   const [favoriteProviders, setFavoriteProviders] = useState<string[]>([]);
   const [favoriteModels, setFavoriteModels] = useState<string[]>([]);
@@ -176,6 +222,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
   const executorValue = useMemo(() => getDropdownValue(selectedExecutor), [selectedExecutor]);
   const validatorValue = useMemo(() => getDropdownValue(selectedValidator), [selectedValidator]);
   const planningValue = useMemo(() => getDropdownValue(selectedPlanning), [selectedPlanning]);
+  const effectiveExecutor = useMemo(() => resolveEffectiveExecutor(task, settings), [task, settings]);
+  const effectiveValidator = useMemo(() => resolveEffectiveValidator(task, settings), [task, settings]);
+  const effectivePlanning = useMemo(() => resolveEffectivePlanning(task, settings), [task, settings]);
   const isSaving = savingTarget !== null;
 
   const saveSelection = useCallback(
@@ -389,7 +438,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
             <label htmlFor="executorModel">Executor Model</label>
             <div className="model-selector-current">
               {executorUsingDefault ? (
-                <span className="model-badge model-badge-default">Using default</span>
+                <span className="model-badge model-badge-default">
+                  Using default{effectiveExecutor.provider && effectiveExecutor.modelId ? ` (${effectiveExecutor.provider}/${effectiveExecutor.modelId})` : ""}
+                </span>
               ) : (
                 <span className="model-badge model-badge-custom">
                   {savedExecutor.provider && <ProviderIcon provider={savedExecutor.provider} size="sm" />}
@@ -417,7 +468,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
             <label htmlFor="validatorModel">Validator Model</label>
             <div className="model-selector-current">
               {validatorUsingDefault ? (
-                <span className="model-badge model-badge-default">Using default</span>
+                <span className="model-badge model-badge-default">
+                  Using default{effectiveValidator.provider && effectiveValidator.modelId ? ` (${effectiveValidator.provider}/${effectiveValidator.modelId})` : ""}
+                </span>
               ) : (
                 <span className="model-badge model-badge-custom">
                   {savedValidator.provider && <ProviderIcon provider={savedValidator.provider} size="sm" />}
@@ -445,7 +498,9 @@ export function ModelSelectorTab({ task, addToast, onTaskUpdated }: ModelSelecto
             <label htmlFor="planningModel">Planning Model</label>
             <div className="model-selector-current">
               {planningUsingDefault ? (
-                <span className="model-badge model-badge-default">Using default</span>
+                <span className="model-badge model-badge-default">
+                  Using default{effectivePlanning.provider && effectivePlanning.modelId ? ` (${effectivePlanning.provider}/${effectivePlanning.modelId})` : ""}
+                </span>
               ) : (
                 <span className="model-badge model-badge-custom">
                   {savedPlanning.provider && <ProviderIcon provider={savedPlanning.provider} size="sm" />}

packages/dashboard/app/components/TaskDetailModal.tsx

@@ -929,7 +929,7 @@ export function TaskDetailModal({
             </div>
           ) : activeTab === "model" ? (
             <div className="detail-section">
-              <ModelSelectorTab task={task} addToast={addToast} onTaskUpdated={onTaskUpdated} />
+              <ModelSelectorTab task={task} addToast={addToast} onTaskUpdated={onTaskUpdated} settings={settings} />
             </div>
           ) : activeTab === "logs" ? (
             <div className={`detail-section${logSubview === "agent-log" ? " detail-section--agent-log" : ""}`}>

packages/dashboard/app/components/__tests__/ModelSelectorTab.test.tsx

@@ -142,6 +142,108 @@ describe("ModelSelectorTab", () => {
     expect(within(planningSection!).getByText("Using default")).toBeInTheDocument();
   });
 
+  it("shows resolved default model in badge when settings are provided", async () => {
+    render(
+      <ModelSelectorTab
+        task={FAKE_TASK}
+        addToast={mockAddToast}
+        settings={{
+          defaultProvider: "anthropic",
+          defaultModelId: "claude-sonnet-4-5",
+        }}
+      />,
+    );
+
+    await waitForSelectors();
+
+    const executorSection = getSection("Executor Model");
+    expect(within(executorSection!).getByText("Using default (anthropic/claude-sonnet-4-5)")).toBeInTheDocument();
+  });
+
+  it("shows 'Using default' without resolution when settings prop is undefined", async () => {
+    render(<ModelSelectorTab task={FAKE_TASK} addToast={mockAddToast} />);
+
+    await waitForSelectors();
+
+    const executorSection = getSection("Executor Model");
+    expect(within(executorSection!).getByText("Using default")).toBeInTheDocument();
+    expect(within(executorSection!).queryByText(/Using default \(.+\)/)).not.toBeInTheDocument();
+  });
+
+  it("shows validator resolved model using validator settings then default fallback", async () => {
+    render(
+      <ModelSelectorTab
+        task={FAKE_TASK}
+        addToast={mockAddToast}
+        settings={{
+          validatorProvider: "openai",
+          validatorModelId: "gpt-4o",
+          defaultProvider: "anthropic",
+          defaultModelId: "claude-sonnet-4-5",
+        }}
+      />,
+    );
+
+    await waitForSelectors();
+
+    const validatorSection = getSection("Validator Model");
+    expect(within(validatorSection!).getByText("Using default (openai/gpt-4o)")).toBeInTheDocument();
+  });
+
+  it("shows planning resolved model using planning settings then default fallback", async () => {
+    render(
+      <ModelSelectorTab
+        task={FAKE_TASK}
+        addToast={mockAddToast}
+        settings={{
+          planningProvider: "google",
+          planningModelId: "gemini-2.5-pro",
+          defaultProvider: "anthropic",
+          defaultModelId: "claude-sonnet-4-5",
+        }}
+      />,
+    );
+
+    await waitForSelectors();
+
+    const planningSection = getSection("Planning Model");
+    expect(within(planningSection!).getByText("Using default (google/gemini-2.5-pro)")).toBeInTheDocument();
+  });
+
+  it("updates resolved model when settings change", async () => {
+    const { rerender } = render(
+      <ModelSelectorTab
+        task={FAKE_TASK}
+        addToast={mockAddToast}
+        settings={{
+          defaultProvider: "anthropic",
+          defaultModelId: "claude-sonnet-4-5",
+        }}
+      />,
+    );
+
+    await waitForSelectors();
+
+    const executorSection = getSection("Executor Model");
+    expect(within(executorSection!).getByText("Using default (anthropic/claude-sonnet-4-5)")).toBeInTheDocument();
+
+    rerender(
+      <ModelSelectorTab
+        task={FAKE_TASK}
+        addToast={mockAddToast}
+        settings={{
+          defaultProvider: "openai",
+          defaultModelId: "gpt-4o",
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      const nextExecutorSection = getSection("Executor Model");
+      expect(within(nextExecutorSection!).getByText("Using default (openai/gpt-4o)")).toBeInTheDocument();
+    });
+  });
+
   it("shows current custom model when overrides are set", async () => {
     const taskWithModels = {
       ...FAKE_TASK,

packages/engine/src/executor.test.ts

@@ -88,6 +88,14 @@ vi.mock("@mariozechner/pi-coding-agent", () => {
       open: vi.fn().mockReturnValue(mockSessionManager),
       inMemory: vi.fn().mockReturnValue(mockSessionManager),
     },
+    ModelRegistry: vi.fn().mockImplementation(() => ({
+      find: vi.fn(),
+      refresh: vi.fn(),
+    })),
+    AuthStorage: {
+      create: vi.fn().mockReturnValue({}),
+    },
+    getAgentDir: vi.fn().mockReturnValue("/tmp/agent-dir"),
   };
 });
 
@@ -2812,6 +2820,196 @@ describe("TaskExecutor pause behavior", () => {
   });
 });
 
+describe("TaskExecutor executor model hot-swap", () => {
+  const buildUpdatedTask = (overrides: Partial<Task> = {}): Task => ({
+    id: "FN-001",
+    title: "Model task",
+    description: "Test model updates",
+    column: "in-progress",
+    paused: false,
+    dependencies: [],
+    steps: [],
+    currentStep: 0,
+    log: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  });
+
+  const flushTaskUpdated = async () => {
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("hot-swaps executor model on active session when modelProvider/modelId change", async () => {
+    const store = createMockStore();
+    const setModel = vi.fn().mockResolvedValue(undefined);
+    const findModel = vi.fn().mockReturnValue({
+      provider: { name: "openai" },
+      id: "gpt-4o",
+      name: "GPT-4o",
+    });
+
+    const executor = new TaskExecutor(store, "/tmp/test");
+    (executor as any)._modelRegistry = { find: findModel };
+    (executor as any).activeSessions.set("FN-001", {
+      session: { setModel, dispose: vi.fn() },
+      seenSteeringIds: new Set(),
+      lastModelProvider: "anthropic",
+      lastModelId: "claude-sonnet-4-5",
+    });
+
+    store._trigger("task:updated", buildUpdatedTask({
+      modelProvider: "openai",
+      modelId: "gpt-4o",
+    }));
+
+    await flushTaskUpdated();
+
+    expect(setModel).toHaveBeenCalledTimes(1);
+    expect(setModel).toHaveBeenCalledWith(expect.objectContaining({
+      provider: expect.objectContaining({ name: "openai" }),
+      id: "gpt-4o",
+    }));
+    expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Model changed to openai/gpt-4o");
+  });
+
+  it("does not attempt hot-swap when no active session exists", async () => {
+    const store = createMockStore();
+    const setModel = vi.fn().mockResolvedValue(undefined);
+
+    new TaskExecutor(store, "/tmp/test");
+
+    store._trigger("task:updated", buildUpdatedTask({
+      modelProvider: "openai",
+      modelId: "gpt-4o",
+    }));
+
+    await flushTaskUpdated();
+
+    expect(setModel).not.toHaveBeenCalled();
+  });
+
+  it("does not hot-swap when model fields are unchanged", async () => {
+    const store = createMockStore();
+    const setModel = vi.fn().mockResolvedValue(undefined);
+    const findModel = vi.fn();
+
+    const executor = new TaskExecutor(store, "/tmp/test");
+    (executor as any)._modelRegistry = { find: findModel };
+    (executor as any).activeSessions.set("FN-001", {
+      session: { setModel, dispose: vi.fn() },
+      seenSteeringIds: new Set(),
+      lastModelProvider: "anthropic",
+      lastModelId: "claude-sonnet-4-5",
+    });
+
+    store._trigger("task:updated", buildUpdatedTask({
+      modelProvider: "anthropic",
+      modelId: "claude-sonnet-4-5",
+    }));
+
+    await flushTaskUpdated();
+
+    expect(findModel).not.toHaveBeenCalled();
+    expect(setModel).not.toHaveBeenCalled();
+  });
+
+  it("hot-swaps to settings default when override is cleared", async () => {
+    const store = createMockStore();
+    const setModel = vi.fn().mockResolvedValue(undefined);
+    const findModel = vi.fn().mockReturnValue({
+      provider: { name: "openai" },
+      id: "gpt-4o",
+      name: "GPT-4o",
+    });
+
+    store.getSettings.mockResolvedValue({
+      defaultProvider: "openai",
+      defaultModelId: "gpt-4o",
+    });
+
+    const executor = new TaskExecutor(store, "/tmp/test");
+    (executor as any)._modelRegistry = { find: findModel };
+    (executor as any).activeSessions.set("FN-001", {
+      session: { setModel, dispose: vi.fn() },
+      seenSteeringIds: new Set(),
+      lastModelProvider: "anthropic",
+      lastModelId: "claude-sonnet-4-5",
+    });
+
+    store._trigger("task:updated", buildUpdatedTask({
+      modelProvider: undefined,
+      modelId: undefined,
+    }));
+
+    await flushTaskUpdated();
+
+    expect(findModel).toHaveBeenCalledWith("openai", "gpt-4o");
+    expect(setModel).toHaveBeenCalledTimes(1);
+  });
+
+  it("logs error and continues when setModel fails", async () => {
+    const store = createMockStore();
+    const setModel = vi.fn().mockRejectedValue(new Error("API key not found"));
+    const findModel = vi.fn().mockReturnValue({
+      provider: { name: "openai" },
+      id: "gpt-4o",
+      name: "GPT-4o",
+    });
+
+    const executor = new TaskExecutor(store, "/tmp/test");
+    (executor as any)._modelRegistry = { find: findModel };
+    (executor as any).activeSessions.set("FN-001", {
+      session: { setModel, dispose: vi.fn() },
+      seenSteeringIds: new Set(),
+      lastModelProvider: "anthropic",
+      lastModelId: "claude-sonnet-4-5",
+    });
+
+    store._trigger("task:updated", buildUpdatedTask({
+      modelProvider: "openai",
+      modelId: "gpt-4o",
+    }));
+
+    await flushTaskUpdated();
+
+    expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Model change failed: API key not found");
+    expect((executor as any).activeSessions.has("FN-001")).toBe(true);
+  });
+
+  it("does not attempt hot-swap on paused task", async () => {
+    const store = createMockStore();
+    const setModel = vi.fn().mockResolvedValue(undefined);
+    const dispose = vi.fn();
+    const findModel = vi.fn();
+
+    const executor = new TaskExecutor(store, "/tmp/test");
+    (executor as any)._modelRegistry = { find: findModel };
+    (executor as any).activeSessions.set("FN-001", {
+      session: { setModel, dispose },
+      seenSteeringIds: new Set(),
+      lastModelProvider: "anthropic",
+      lastModelId: "claude-sonnet-4-5",
+    });
+
+    store._trigger("task:updated", buildUpdatedTask({
+      paused: true,
+      modelProvider: "openai",
+      modelId: "gpt-4o",
+    }));
+
+    await flushTaskUpdated();
+
+    expect(dispose).toHaveBeenCalledTimes(1);
+    expect(findModel).not.toHaveBeenCalled();
+    expect(setModel).not.toHaveBeenCalled();
+  });
+});
+
 describe("TaskExecutor global pause behavior", () => {
   beforeEach(() => {
     vi.clearAllMocks();

packages/engine/src/executor.ts

@@ -9,7 +9,7 @@ import { generateWorktreeName, slugify } from "./worktree-names.js";
 import { Type, type Static } from "@mariozechner/pi-ai";
 import { createKbAgent, describeModel, promptWithFallback, compactSessionContext } from "./pi.js";
 import { reviewStep, type ReviewVerdict } from "./reviewer.js";
-import { SessionManager, type ToolDefinition, type AgentSession } from "@mariozechner/pi-coding-agent";
+import { AuthStorage, ModelRegistry, SessionManager, getAgentDir, type ToolDefinition, type AgentSession } from "@mariozechner/pi-coding-agent";
 import { PRIORITY_EXECUTE, type AgentSemaphore } from "./concurrency.js";
 import type { WorktreePool } from "./worktree-pool.js";
 import { AgentLogger } from "./agent-logger.js";
@@ -241,6 +241,8 @@ export class TaskExecutor {
   private activeSessions = new Map<string, {
     session: AgentSession;
     seenSteeringIds: Set<string>;
+    lastModelProvider?: string | null;
+    lastModelId?: string | null;
   }>();
   /** Active step-session executors per task (mutually exclusive with activeSessions). */
   private activeStepExecutors = new Map<string, StepSessionExecutor>();
@@ -262,6 +264,16 @@ export class TaskExecutor {
   private totalSpawnedCount = 0;
   /** Token cap detector for proactive context compaction. */
   private tokenCapDetector = new TokenCapDetector();
+  private _modelRegistry?: InstanceType<typeof ModelRegistry>;
+
+  private get modelRegistry(): InstanceType<typeof ModelRegistry> {
+    if (!this._modelRegistry) {
+      const authStorage = AuthStorage.create();
+      this._modelRegistry = new ModelRegistry(authStorage, join(getAgentDir(), "models.json"));
+      this._modelRegistry.refresh();
+    }
+    return this._modelRegistry;
+  }
 
   /** Returns the set of task IDs currently being executed. */
   getExecutingTaskIds(): Set<string> {
@@ -344,6 +356,42 @@ export class TaskExecutor {
         return;
       }
 
+      // Handle executor model hot-swap on active single-session executions
+      if (this.activeSessions.has(task.id) && !task.paused) {
+        const activeEntry = this.activeSessions.get(task.id)!;
+        const providerChanged = task.modelProvider !== activeEntry.lastModelProvider;
+        const modelIdChanged = task.modelId !== activeEntry.lastModelId;
+
+        if (providerChanged || modelIdChanged) {
+          activeEntry.lastModelProvider = task.modelProvider;
+          activeEntry.lastModelId = task.modelId;
+
+          const settings = await this.store.getSettings();
+          const newProvider = task.modelProvider && task.modelId
+            ? task.modelProvider
+            : settings?.defaultProvider;
+          const newModelId = task.modelProvider && task.modelId
+            ? task.modelId
+            : settings?.defaultModelId;
+
+          if (newProvider && newModelId) {
+            try {
+              const model = this.modelRegistry.find(newProvider, newModelId);
+              if (model) {
+                await activeEntry.session.setModel(model);
+                executorLog.log(`${task.id}: executor model hot-swapped to ${newProvider}/${newModelId}`);
+                await this.store.logEntry(task.id, `Model changed to ${newProvider}/${newModelId}`);
+              } else {
+                executorLog.log(`${task.id}: model ${newProvider}/${newModelId} not found in registry for hot-swap`);
+              }
+            } catch (err: any) {
+              executorLog.error(`${task.id}: failed to hot-swap model: ${err.message}`);
+              await this.store.logEntry(task.id, `Model change failed: ${err.message}`);
+            }
+          }
+        }
+      }
+
       // Handle steering comments - inject new ones into the running session
       // Only process if session is active (activeSessions check is sufficient
       // since entries are only added when a task is in-progress)
@@ -1061,7 +1109,12 @@ export class TaskExecutor {
             seenSteeringIds.add(comment.id);
           }
         }
-        this.activeSessions.set(task.id, { session, seenSteeringIds });
+        this.activeSessions.set(task.id, {
+          session,
+          seenSteeringIds,
+          lastModelProvider: detail.modelProvider,
+          lastModelId: detail.modelId,
+        });
 
         // Register with stuck task detector for heartbeat monitoring
         stuckDetector?.trackTask(task.id, session);
@@ -1232,7 +1285,12 @@ export class TaskExecutor {
             // Reassign so finally{} disposes the correct session
             session = retrySession;
             sessionRef.current = retrySession;
-            this.activeSessions.set(task.id, { session: retrySession, seenSteeringIds });
+            this.activeSessions.set(task.id, {
+              session: retrySession,
+              seenSteeringIds,
+              lastModelProvider: detail.modelProvider,
+              lastModelId: detail.modelId,
+            });
             stuckDetector?.trackTask(task.id, retrySession);
 
             const retryPrompt = [