@circuitwall/jarela 2.2.0 → 2.3.0

package/app/api/v1/models/[name]/compact-threads/route.ts

@@ -23,7 +23,7 @@ import { z } from "zod";
 import { listAgentConfigs } from "@/lib/stores/agent-configs";
 import { getDefaultModelConfig } from "@/lib/stores/model-config";
 import { listThreadsByAgent, getRecentMessagesWindow } from "@/lib/stores/threads";
-import { compactThreadWarmContext } from "@/lib/agents/warm-summary-background";
+import { compactThreadWarmContext, isManualCompactionRunning, trackManualCompaction } from "@/lib/agents/warm-summary-background";
 import { getProvider } from "@/lib/providers";
 import type { ProviderParams } from "@/lib/providers/types";
 import { errorMessage } from "@/lib/utils/error";
@@ -77,17 +77,20 @@ export async function POST(req: NextRequest, { params }: Params) {
       const msgs = getRecentMessagesWindow(t.thread_id, 0, undefined, "foreground");
       if (msgs.length <= keep_last) { skipped += 1; continue; }
       const hotStart = msgs[msgs.length - keep_last]!;
+      if (isManualCompactionRunning(t.thread_id)) { skipped += 1; continue; }
       try {
-        const committed = await compactThreadWarmContext(t.thread_id, hotStart.seq, {
-          expectedHotSinceSeq: t.hot_since_seq ?? null,
-          alignTopicBoundary: false,
-          allowEmptySummary: true,
-          providerOverride: {
-            provider,
-            modelId: using.model_id,
-            params: (using.params ?? {}) as ProviderParams,
-          },
-        });
+        const committed = await trackManualCompaction(t.thread_id, hotStart.seq, (attempt) =>
+          compactThreadWarmContext(t.thread_id, hotStart.seq, {
+            expectedHotSinceSeq: t.hot_since_seq ?? null,
+            alignTopicBoundary: false,
+            allowEmptySummary: true,
+            attempt,
+            providerOverride: {
+              provider,
+              modelId: using.model_id,
+              params: (using.params ?? {}) as ProviderParams,
+            },
+          }));
         if (committed) compacted += 1;
         else skipped += 1;
       } catch (e) {

package/app/api/v1/models/[name]/route.test.ts

@@ -0,0 +1,89 @@
+import { afterAll, afterEach, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { NextRequest } from "next/server";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-model-route-"));
+process.env.JARELA_DB_DIR = tmpRoot;
+
+const { upsertModelConfig, deleteModelConfig, listModelConfigs, getModelConfig } = await import("@/lib/stores/model-config");
+const { PATCH, PUT } = await import("./route");
+
+const ctx = (name: string) => ({ params: Promise.resolve({ name }) });
+const json = (method: string, name: string, body: unknown) => new NextRequest(
+  `http://localhost/api/v1/models/${name}`,
+  { method, body: JSON.stringify(body), headers: { "Content-Type": "application/json" } },
+);
+const defaults = () => listModelConfigs().filter((r) => r.is_default === 1).map((r) => r.name);
+
+afterEach(() => {
+  for (const r of listModelConfigs()) deleteModelConfig(r.name);
+});
+
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* */ }
+});
+
+describe("PATCH /api/v1/models/[name]", () => {
+  it("switches the default without touching params", async () => {
+    upsertModelConfig("alpha", "anthropic", "claude-x", { temperature: 0.1 }, true);
+    upsertModelConfig("beta", "anthropic", "claude-y", { temperature: 0.7 }, false);
+    const before = getModelConfig("beta")!.params;
+
+    const res = await PATCH(json("PATCH", "beta", { is_default: true }), ctx("beta"));
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({ name: "beta", is_default: true, enabled: true });
+    expect(defaults()).toEqual(["beta"]);
+    expect(getModelConfig("beta")!.params).toBe(before);
+  });
+
+  it("disables a model and promotes another default atomically", async () => {
+    upsertModelConfig("alpha", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("beta", "anthropic", "claude-y", {}, false);
+
+    const res = await PATCH(json("PATCH", "alpha", { enabled: false }), ctx("alpha"));
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({ enabled: false, is_default: false });
+    expect(defaults()).toEqual(["beta"]);
+  });
+
+  it("re-enables and sets default in one request", async () => {
+    upsertModelConfig("alpha", "anthropic", "claude-x", {}, true);
+    upsertModelConfig("beta", "anthropic", "claude-y", {}, false);
+    await PATCH(json("PATCH", "beta", { enabled: false }), ctx("beta"));
+
+    const res = await PATCH(json("PATCH", "beta", { enabled: true, is_default: true }), ctx("beta"));
+
+    expect(res.status).toBe(200);
+    expect(defaults()).toEqual(["beta"]);
+  });
+
+  it("returns 409 when disabling the last enabled model and 404 for unknown models", async () => {
+    upsertModelConfig("solo", "anthropic", "claude-x", {}, true);
+
+    expect((await PATCH(json("PATCH", "solo", { enabled: false }), ctx("solo"))).status).toBe(409);
+    expect(getModelConfig("solo")!.enabled).toBe(1);
+    expect((await PATCH(json("PATCH", "ghost", { is_default: true }), ctx("ghost"))).status).toBe(404);
+  });
+
+  it("rejects empty, contradictory, and unknown-field bodies", async () => {
+    upsertModelConfig("solo", "anthropic", "claude-x", {}, true);
+    for (const body of [{}, { enabled: false, is_default: true }, { is_default: false }, { params: {} }]) {
+      expect((await PATCH(json("PATCH", "solo", body), ctx("solo"))).status).toBe(400);
+    }
+  });
+});
+
+describe("PUT /api/v1/models/[name]", () => {
+  it("keeps the default flag when is_default is omitted", async () => {
+    upsertModelConfig("alpha", "anthropic", "claude-x", {}, true);
+
+    const res = await PUT(json("PUT", "alpha", { provider: "anthropic", model_id: "claude-x", params: { temperature: 0.3 } }), ctx("alpha"));
+
+    expect(res.status).toBe(200);
+    expect(defaults()).toEqual(["alpha"]);
+  });
+});

package/app/api/v1/models/[name]/route.ts

@@ -1,6 +1,16 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { deleteModelConfig, getModelConfig, upsertModelConfig, withModelConfigMutation } from "@/lib/stores/model-config";
+import {
+  deleteModelConfig,
+  getModelConfig,
+  isModelConfigEnabled,
+  ModelConfigStateError,
+  setDefaultModelConfig,
+  setModelConfigEnabled,
+  upsertModelConfig,
+  withModelConfigMutation,
+} from "@/lib/stores/model-config";
+import { withDbTransaction } from "@/lib/db/transaction";
 import { validateBody } from "@/lib/api/responses";
 import { parseJsonSafe } from "@/lib/utils/json";
 import { enrichParamsWithDiscoveredContext } from "@/lib/models/discover-context-window";
@@ -15,6 +25,17 @@ const PutBody = z.object({
   credential_id: z.string().nullable().optional(),
 });
 
+// Targeted state changes that must not re-send (and re-process) the whole
+// config. Each request is applied in a single transaction.
+const PatchBody = z.object({
+  enabled: z.boolean().optional(),
+  is_default: z.literal(true).optional(),
+}).strict().refine((b) => b.enabled !== undefined || b.is_default !== undefined, {
+  message: "provide enabled and/or is_default",
+}).refine((b) => !(b.enabled === false && b.is_default === true), {
+  message: "a disabled model cannot be the default",
+});
+
 // Mirror /api/v1/models GET: never echo plaintext secrets back to the
 // client. Authoritative storage lives in `credentials`; per-model rows
 // retain only non-secret overrides post-migration.
@@ -64,13 +85,43 @@ export async function PUT(req: NextRequest, { params }: Params) {
       body.provider,
       body.model_id,
       enriched,
-      body.is_default ?? false,
+      body.is_default,
       body.credential_id ?? null,
     );
-    return NextResponse.json({ ...r, params: redactInlineParams(r.params), is_default: Boolean(r.is_default) });
+    return NextResponse.json(toResponse(r));
   });
 }
 
+export async function PATCH(req: NextRequest, { params }: Params) {
+  const { name } = await params;
+  const body = await validateBody(req, PatchBody);
+  if (body instanceof NextResponse) return body;
+  try {
+    const r = withDbTransaction(() => {
+      let row = getModelConfig(name);
+      if (!row) throw new ModelConfigStateError(`Model config "${name}" not found`, 404);
+      if (body.enabled !== undefined) row = setModelConfigEnabled(name, body.enabled);
+      if (body.is_default) row = setDefaultModelConfig(name);
+      return row;
+    });
+    return NextResponse.json(toResponse(r));
+  } catch (err) {
+    if (err instanceof ModelConfigStateError) {
+      return NextResponse.json({ error: err.message }, { status: err.status });
+    }
+    throw err;
+  }
+}
+
+function toResponse(r: NonNullable<ReturnType<typeof getModelConfig>>) {
+  return {
+    ...r,
+    params: redactInlineParams(r.params),
+    is_default: Boolean(r.is_default),
+    enabled: isModelConfigEnabled(r),
+  };
+}
+
 export async function DELETE(_req: NextRequest, { params }: Params) {
   const { name } = await params;
   return withModelConfigMutation(name, () => {

package/app/api/v1/models/route.ts

@@ -7,7 +7,7 @@
 
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { getModelConfig, listModelConfigs, upsertModelConfig, withModelConfigMutation } from "@/lib/stores/model-config";
+import { getModelConfig, isModelConfigEnabled, listModelConfigs, upsertModelConfig, withModelConfigMutation } from "@/lib/stores/model-config";
 import { createdResponse, cachedJson, validateBody } from "@/lib/api/responses";
 import { parseJsonSafe } from "@/lib/utils/json";
 import { enrichParamsWithDiscoveredContext } from "@/lib/models/discover-context-window";
@@ -65,6 +65,7 @@ export function GET() {
     ...r,
     params: redactInlineParams(r.params),
     is_default: Boolean(r.is_default),
+    enabled: isModelConfigEnabled(r),
   })), 15, 60);
 }
 
@@ -79,13 +80,14 @@ export async function POST(req: NextRequest) {
       body.provider,
       body.model_id,
       enriched,
-      body.is_default ?? false,
+      body.is_default,
       body.credential_id ?? null,
     );
     return createdResponse({
       ...r,
       params: redactInlineParams(r.params),
       is_default: Boolean(r.is_default),
+      enabled: isModelConfigEnabled(r),
     });
   });
 }

package/app/api/v1/providers/[provider]/models/route.test.ts

@@ -0,0 +1,53 @@
+import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { NextRequest } from "next/server";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-provider-models-"));
+process.env.JARELA_DB_DIR = tmpRoot;
+
+const { upsertModelConfig, deleteModelConfig } = await import("@/lib/stores/model-config");
+const { GET } = await import("./route");
+
+const params = { params: Promise.resolve({ provider: "github-copilot" }) };
+const request = () => new NextRequest("http://localhost/api/v1/providers/github-copilot/models?fresh=1");
+
+afterEach(() => {
+  deleteModelConfig("copilot-config");
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* */ }
+});
+
+describe("provider model catalogs", () => {
+  it("rejects a retired PAT config as a configuration error", async () => {
+    upsertModelConfig("copilot-config", "github-copilot", "gpt-4o", {
+      api_key: "github_pat_synthetic",
+    }, true);
+
+    const response = await GET(request(), params);
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toMatchObject({
+      error: expect.stringMatching(/PAT.*GitHub Models.*retired/i),
+    });
+  });
+
+  it("ignores a GITHUB_TOKEN PAT and returns the curated Copilot list", async () => {
+    upsertModelConfig("copilot-config", "github-copilot", "gpt-4o", {}, true);
+    vi.stubEnv("GITHUB_TOKEN", "ghp_synthetic");
+    const fetch = vi.fn();
+    vi.stubGlobal("fetch", fetch);
+
+    const response = await GET(request(), params);
+
+    expect(response.status).toBe(200);
+    const models = await response.json() as Array<{ id: string }>;
+    expect(models.length).toBeGreaterThan(0);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});

package/app/api/v1/providers/[provider]/models/route.ts

@@ -56,10 +56,19 @@ export async function GET(req: NextRequest, { params }: Params) {
       },
     });
   } catch (err) {
-    return NextResponse.json({ error: String(err) }, { status: 500 });
+    return catalogErrorResponse(err);
   }
 }
 
+// Raised when the saved configuration itself is unusable, so callers get a
+// 4xx they can act on instead of a generic server error.
+class CatalogConfigError extends Error {}
+
+function catalogErrorResponse(err: unknown): NextResponse {
+  const status = err instanceof CatalogConfigError ? 400 : 500;
+  return NextResponse.json({ error: String(err) }, { status });
+}
+
 // POST allows the editor to ship the in-form credentials (api_key /
 // base_url / extra_headers) before the user has saved them. We never cache
 // these responses since they're keyed on user-supplied secrets.
@@ -71,7 +80,7 @@ export async function POST(req: NextRequest, { params }: Params) {
     const models = await fetchCatalog(provider, body.params);
     return NextResponse.json(models, { headers: { "Cache-Control": "no-store" } });
   } catch (err) {
-    return NextResponse.json({ error: String(err) }, { status: 500 });
+    return catalogErrorResponse(err);
   }
 }
 
@@ -162,13 +171,8 @@ async function fetchOpenAICatalog(): Promise<CatalogModel[]> {
 // ── GitHub Copilot ────────────────────────────────────────────────────────────
 
 async function fetchGitHubCopilotCatalog(): Promise<CatalogModel[]> {
-  // We deliberately do NOT return the broad GitHub Models cross-publisher
-  // registry here — that lists hundreds of models from every vendor, which is
-  // confusing when the user is configuring the "github-copilot" provider
-  // specifically. We mirror what Copilot Chat actually serves: its own
-  // /models endpoint when we have an exchangeable credential, else a curated
-  // fallback list. Users who want the raw GitHub Models catalog can type the
-  // namespaced model id directly into the Model ID field.
+  // Use Copilot Chat's account-specific /models endpoint when an exchangeable
+  // credential is available, otherwise return a curated fallback list.
 
   // 1. Prefer the in-app device-flow OAuth token — it can be exchanged.
   const { getStoredOAuthToken } = await import("@/lib/providers/github-copilot-auth");
@@ -193,8 +197,16 @@ async function fetchGitHubCopilotCatalog(): Promise<CatalogModel[]> {
         if (list.length > 0) return list;
       } catch { /* fall through */ }
     }
-    const apiKey = (params.api_key as string | undefined) ?? process.env.GITHUB_TOKEN;
-    if (apiKey && !isLikelyGitHubPat(apiKey)) {
+    // Only the Copilot config's own api_key is considered: GITHUB_TOKEN belongs
+    // to the GitHub integration and is usually a PAT unrelated to Copilot.
+    const apiKey = (params.api_key as string | undefined)?.trim();
+    if (apiKey && isLikelyGitHubPat(apiKey)) {
+      throw new CatalogConfigError(
+        "GitHub Copilot: PAT model discovery used GitHub Models, which has been retired. " +
+        "Use device-flow sign-in in the Models panel or set copilot_session_token.",
+      );
+    }
+    if (apiKey) {
       try {
         const sessionToken = await exchangeCopilotSessionToken(apiKey);
         const list = await fetchCopilotChatCatalog(sessionToken);
@@ -203,8 +215,7 @@ async function fetchGitHubCopilotCatalog(): Promise<CatalogModel[]> {
     }
   }
 
-  // 3. Fallback: curated known-models list. Works even on a PAT — those
-  //    model IDs are valid on both Models API and Copilot Chat.
+  // 3. Fallback: curated known-models list when no credential can be exchanged.
   return githubCopilotKnownModels();
 }
 
@@ -241,13 +252,13 @@ async function fetchCopilotChatCatalog(sessionToken: string): Promise<CatalogMod
 }
 
 function isLikelyGitHubPat(token: string): boolean {
-  return token.startsWith("ghp_") || token.startsWith("github_pat_") || token.startsWith("gho_");
+  return token.startsWith("ghp_") || token.startsWith("github_pat_");
 }
 
-async function exchangeCopilotSessionToken(pat: string): Promise<string> {
+async function exchangeCopilotSessionToken(githubToken: string): Promise<string> {
   const res = await fetch("https://api.github.com/copilot_internal/v2/token", {
     headers: {
-      Authorization: `token ${pat}`,
+      Authorization: `token ${githubToken}`,
       "User-Agent": "Jarela/1.0",
     },
   });

package/app/api/v1/threads/[thread_id]/activity/route.ts

@@ -0,0 +1,19 @@
+/**
+ * UI-internal — `GET /api/v1/threads/[thread_id]/activity`
+ *
+ * One snapshot of what the thread is doing (agent turn phase, queued turns,
+ * compaction), polled by the chat so it can show and resume activity that
+ * started elsewhere: the scheduler, a watcher, a bridge, or another device.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getThread } from "@/lib/stores/threads";
+import { getThreadActivity } from "@/lib/agents/thread-activity";
+
+type Params = { params: Promise<{ thread_id: string }> };
+
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { thread_id } = await params;
+  if (!getThread(thread_id)) return NextResponse.json({ error: "Thread not found" }, { status: 404 });
+  return NextResponse.json(getThreadActivity(thread_id), { headers: { "Cache-Control": "no-store" } });
+}

package/app/api/v1/threads/[thread_id]/context-pin/route.test.ts

@@ -27,6 +27,7 @@ vi.mock("@/lib/agents/context-boundary", () => ({
 vi.mock("@/lib/agents/warm-summary-background", () => ({
   pendingCompactionBoundary: () => null,
   pendingCompactionBoundarySeq: () => null,
+  currentChannelSummaries: () => [],
 }));
 vi.mock("@/lib/agents/conversation-summary", () => ({ parseStoredTopics: () => null }));
 

package/app/api/v1/threads/[thread_id]/context-pin/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { getThread, getThreadMessageBySeq } from "@/lib/stores/threads";
 import { moveThreadContextBoundary } from "@/lib/agents/context-boundary";
-import { pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
+import { currentChannelSummaries, pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
 import { parseStoredTopics } from "@/lib/agents/conversation-summary";
 
 type Params = { params: Promise<{ thread_id: string }> };
@@ -43,6 +43,7 @@ export async function PATCH(req: NextRequest, { params }: Params) {
     warm_summary_source_messages: updated?.warm_summary_source_messages ?? null,
     warm_summary_source_chars: updated?.warm_summary_source_chars ?? null,
     warm_summary_topics: parseStoredTopics(updated?.warm_summary_topics),
+    warm_channel_summaries: currentChannelSummaries(thread_id, updated?.hot_since_seq),
     pending_hot_since: pendingCompactionBoundary(thread_id),
     pending_hot_since_seq: pendingCompactionBoundarySeq(thread_id),
   });

package/app/api/v1/threads/[thread_id]/route.ts

@@ -18,8 +18,9 @@ import { getMessageUsageByIds } from "@/lib/stores/message-usage";
 import { getAgentConfig } from "@/lib/stores/agent-configs";
 import { getModelConfig, getModelParams } from "@/lib/stores/model-config";
 import { messageToResponse, resolveContextWindowTokens } from "@/lib/api/serializers";
-import { pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
+import { currentChannelSummaries, isManualCompactionRunning, pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
 import { parseStoredTopics } from "@/lib/agents/conversation-summary";
+import { getThreadActivity } from "@/lib/agents/thread-activity";
 import { getCheckpointer } from "@/lib/agents/checkpointer";
 import { errorMessage } from "@/lib/utils/error";
 
@@ -84,9 +85,12 @@ export async function GET(req: NextRequest, { params }: Params) {
   return NextResponse.json({
     ...thread,
     warm_summary_topics: parseStoredTopics(thread.warm_summary_topics),
+    warm_channel_summaries: currentChannelSummaries(thread_id, thread.hot_since_seq),
     context_window_tokens: contextWindowTokens,
     pending_hot_since: pendingCompactionBoundary(thread_id),
     pending_hot_since_seq: pendingCompactionBoundarySeq(thread_id),
+    manual_compaction_pending: isManualCompactionRunning(thread_id),
+    activity: getThreadActivity(thread_id),
     // No server-side filtering: clients receive every message with its
     // `category` tag and apply the chat-panel filter toolbar on the
     // render side. Keeping the raw transcript over the wire means audit

package/components/agents/agent-editor/AdvancedSection.tsx

@@ -9,6 +9,7 @@ import { VoiceFields } from "./VoiceFields";
 import { ToolCredentialsSection } from "./ToolCredentialsSection";
 import { Select } from "@/components/ui/Select";
 import { modelSupportsImages } from "@/lib/providers/capabilities";
+import { isModelEnabled } from "@/lib/agents/effective-model";
 import { SelectedModelDescription } from "./ModelSection";
 
 interface Props {
@@ -31,15 +32,20 @@ export function AdvancedSection({ form, models, integrations, isFullMode, onClos
         </p>
         <Select value={form.modelConfigName} onChange={(e) => form.setModelConfigName(e.target.value)}>
           <option value="">Automatic routing (recommended)</option>
-          {models.map((m) => {
+          {models.filter((m) => isModelEnabled(m) || m.name === form.modelConfigName).map((m) => {
             const vision = modelSupportsImages(m.provider, m.model_id);
             return (
               <option key={m.name} value={m.name}>
-                {vision ? "📷 " : ""}{m.name} · {m.provider} / {m.model_id}
+                {vision ? "📷 " : ""}{m.name} · {m.provider} / {m.model_id}{isModelEnabled(m) ? "" : " (disabled)"}
               </option>
             );
           })}
         </Select>
+        {selectedModel && !isModelEnabled(selectedModel) && (
+          <p className="text-[11px] text-amber-700 dark:text-amber-400">
+            This model is disabled, so the agent uses automatic routing until it is enabled again.
+          </p>
+        )}
         {selectedModel && <SelectedModelDescription model={selectedModel} prefix="Forced" />}
       </div>
       <Divider />

package/components/agents/agent-editor/ModelSection.tsx

@@ -1,4 +1,5 @@
 import type { ModelConfig } from "@/api/types";
+import { isModelEnabled } from "@/lib/agents/effective-model";
 import { isProviderClassified, modelSupportsImages } from "@/lib/providers/capabilities";
 import { CapBadges } from "@/components/models/CapBadges";
 import { ProviderLogo } from "@/components/models/ProviderLogo";
@@ -19,8 +20,10 @@ interface Props {
 
 export function ModelSection({ form, models, integrations, onClose }: Props) {
   const { dispatch } = useAppContext();
-  const defaultModel = models.find((m) => m.is_default);
-  const selectedModel = models.find((m) => m.name === form.modelConfigName) ?? defaultModel;
+  const enabledModels = models.filter(isModelEnabled);
+  const defaultModel = enabledModels.find((m) => m.is_default) ?? enabledModels[0];
+  const forcedModel = enabledModels.find((m) => m.name === form.modelConfigName);
+  const selectedModel = forcedModel ?? defaultModel;
   const readiness = computeFeatureReadiness({
     models,
     integrations,
@@ -48,7 +51,7 @@ export function ModelSection({ form, models, integrations, onClose }: Props) {
         ) : (
           <p className="text-[11px] text-amber-700 dark:text-amber-400">No default fallback model is configured yet.</p>
         )}
-        {form.modelConfigName && models.find((m) => m.name === form.modelConfigName) && (
+        {forcedModel && (
           <p className="text-[11px] text-sky-700 dark:text-sky-400">
             This agent currently has a forced model override. Clear it in Advanced settings to return to router-driven selection.
           </p>