@circuitwall/jarela 2.2.0 → 2.3.0

package/.next/standalone/.next/server/chunks/46.js

@@ -498,6 +498,7 @@ function runMigrations(db) {
     ensureCredentialsTable(db);
     ensureCredentialsLabelAndDefaultColumns(db);
     ensureModelConfigCredentialIdColumn(db);
+    ensureModelConfigEnabledColumn(db);
     ensureAgentConfigsToolCredentialsColumn(db);
     seedAgentConfigs(db);
     backfillDeveloperInteractiveTerminalTools(db);
@@ -662,6 +663,11 @@ function ensureThreadChannelSummariesTable(db) {
     if (!cols.some((column)=>column.name === "summary_before_seq")) {
         db.exec("ALTER TABLE thread_channel_summaries ADD COLUMN summary_before_seq INTEGER");
     }
+    // Stored topic segments (JSON array) so the next compaction can merge new
+    // activity into them instead of re-summarising the channel from scratch.
+    if (!cols.some((column)=>column.name === "topics")) {
+        db.exec("ALTER TABLE thread_channel_summaries ADD COLUMN topics TEXT");
+    }
 }
 // ADR-0041. Immutable per-assistant-turn snapshot of LLM usage. Written once
 // alongside addMessage(...,"assistant",...) and never updated, so the
@@ -1484,6 +1490,14 @@ function ensureModelConfigCredentialIdColumn(db) {
         db.exec("ALTER TABLE model_configs ADD COLUMN credential_id TEXT");
     }
 }
+// ADR-0102: disabled model configs stay saved but are hidden from model
+// selection, routing, and default fallback. Existing rows default to enabled.
+function ensureModelConfigEnabledColumn(db) {
+    const cols = db.prepare("PRAGMA table_info(model_configs)").all();
+    if (!cols.some((c)=>c.name === "enabled")) {
+        db.exec("ALTER TABLE model_configs ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1");
+    }
+}
 // Idempotent backfill: for each model_config still carrying an inline
 // `api_key` (and no `credential_id` yet), create a credential row and
 // link by id. Strips the api_key / base_url / extra_headers fields from
@@ -7315,17 +7329,17 @@ function pickGitHubCompatOptions(params) {
     return out;
 }
 const tokenCache = new Map();
-function isLikelyGitHubPat(token) {
-    return token.startsWith("ghp_") || token.startsWith("github_pat_") || token.startsWith("gho_");
+function isGitHubPat(token) {
+    return token.startsWith("ghp_") || token.startsWith("github_pat_");
 }
-async function getCopilotToken(pat) {
-    if (!pat) throw new Error("GitHub Copilot: no API key configured for token exchange.");
-    const cached = tokenCache.get(pat);
+async function exchangeCopilotSessionToken(githubToken) {
+    if (!githubToken) throw new Error("GitHub Copilot: no API key configured for token exchange.");
+    const cached = tokenCache.get(githubToken);
     if (cached && cached.expiresAt - Date.now() > 60000) return cached.token;
-    tokenCache.delete(pat);
+    tokenCache.delete(githubToken);
     const res = await fetch("https://api.github.com/copilot_internal/v2/token", {
         headers: {
-            Authorization: `token ${pat}`,
+            Authorization: `token ${githubToken}`,
             "User-Agent": "Jarela/1.0"
         },
         signal: AbortSignal.timeout(30000)
@@ -7333,17 +7347,17 @@ async function getCopilotToken(pat) {
     if (!res.ok) {
         const body = await (0,error/* readErrorBody */.N)(res);
         if (res.status === 401) {
-            throw new Error(`GitHub Copilot: token exchange failed (401). ` + `Ensure your PAT has the "copilot" scope and that you have an active Copilot subscription. ` + `Details: ${body}`);
+            throw new Error(`GitHub Copilot: token exchange failed (401). ` + `Check that this GitHub account has an active Copilot subscription and the credential is valid. ` + `Details: ${body}`);
         }
         if (res.status === 404) {
-            throw new Error("GitHub Copilot token exchange endpoint was not found for this credential. " + "Personal Access Tokens are not accepted directly by Copilot chat. " + "Use a Copilot session token in params.copilot_session_token, or a credential that supports token exchange.");
+            throw new Error("GitHub Copilot could not exchange this credential for a session token. " + "Use the in-app device-flow sign-in or set params.copilot_session_token.");
         }
         throw new Error(`GitHub Copilot: token exchange failed (${res.status}): ${body}`);
     }
     const json = await res.json();
     if (!json.token) throw new Error("GitHub Copilot: token exchange returned no token");
     const expiresAt = json.expires_at ? new Date(json.expires_at).getTime() : Date.now() + 28 * 60000;
-    tokenCache.set(pat, {
+    tokenCache.set(githubToken, {
         token: json.token,
         expiresAt
     });
@@ -7374,7 +7388,6 @@ async function resolveCopilotAuth(params) {
     const explicitSessionToken = params.copilot_session_token?.trim();
     if (explicitSessionToken && explicitSessionToken.length > 0) {
         return {
-            kind: "copilot-api",
             baseURL: params.base_url ?? "https://api.githubcopilot.com",
             apiKey: explicitSessionToken,
             headers: {
@@ -7384,9 +7397,8 @@ async function resolveCopilotAuth(params) {
     }
     const oauthToken = (0,github_copilot_auth.getStoredOAuthToken)();
     if (oauthToken) {
-        const token = await getCopilotToken(oauthToken);
+        const token = await exchangeCopilotSessionToken(oauthToken);
         return {
-            kind: "copilot-api",
             baseURL: params.base_url ?? "https://api.githubcopilot.com",
             apiKey: token,
             headers: {
@@ -7394,23 +7406,14 @@ async function resolveCopilotAuth(params) {
             }
         };
     }
-    if (apiKey && isLikelyGitHubPat(apiKey)) {
-        return {
-            kind: "models-rest",
-            baseURL: params.base_url ?? "https://models.github.ai/inference",
-            apiKey,
-            headers: {
-                Accept: "application/vnd.github+json",
-                "X-GitHub-Api-Version": "2026-03-10"
-            }
-        };
+    if (apiKey && isGitHubPat(apiKey)) {
+        throw new Error("GitHub Copilot: this provider's GitHub PAT route used GitHub Models, which has been retired. " + "Use the in-app device-flow sign-in or set copilot_session_token.");
     }
     if (!apiKey) {
         throw new Error("GitHub Copilot: not signed in. Use the in-app device-flow login, or set api_key / copilot_session_token.");
     }
-    const token = await getCopilotToken(apiKey);
+    const token = await exchangeCopilotSessionToken(apiKey);
     return {
-        kind: "copilot-api",
         baseURL: params.base_url ?? "https://api.githubcopilot.com",
         apiKey: token,
         headers: {
@@ -7421,14 +7424,9 @@ async function resolveCopilotAuth(params) {
 // Anthropic SDK client pointed at Copilot's native `/v1/messages` endpoint.
 // Copilot accepts the Anthropic request shape (including `cache_control`
 // ephemeral breakpoints) for Claude-family models when called with a
-// session token. The PAT-only `models.github.ai` fallback does NOT expose
-// this endpoint, so we surface a clear error there instead of silently
-// downgrading to a path that strips the cache markers.
+// Copilot session token.
 async function resolvedAnthropicClient(params) {
     const auth = await resolveCopilotAuth(params);
-    if (auth.kind !== "copilot-api") {
-        throw new Error("GitHub Copilot: Claude models require a Copilot session token (OAuth or copilot_session_token). " + "Personal Access Tokens route to GitHub Models REST, which does not expose the native Messages API.");
-    }
     return new client/* Anthropic */.NB({
         // The SDK requires an apiKey field; we authenticate via authToken
         // (Authorization: Bearer ...) per Copilot's contract. The empty
@@ -9481,14 +9479,14 @@ const INTEGRATIONS = {
     "github-copilot": {
         label: "GitHub Copilot",
         category: "llm",
-        description: "Routes chat-completion requests through your Copilot subscription. Paste a GitHub PAT " + "with `copilot` scope from github.com/settings/tokens, or run the device-flow sign-in in " + "the Models panel.",
+        description: "Routes chat-completion requests through your Copilot subscription. Use the device-flow " + "sign-in in the Models panel; legacy GitHub PAT authentication is no longer supported.",
         fields: [
             {
                 key: "api_key",
-                label: "GitHub PAT",
-                placeholder: "ghp_… or github_pat_…",
+                label: "Legacy GitHub PAT (unsupported)",
+                placeholder: "Use Models panel sign-in",
                 secret: true,
-                required: true
+                required: false
             }
         ]
     },
@@ -9758,6 +9756,7 @@ function saveIntegration(name, incoming) {
             if (f.required && !v.trim()) return {
                 error: `"${f.key}" cannot be empty`
             };
+            if (!v.trim()) continue;
             merged[f.key] = v;
             if (existing[f.key] !== v) touched.push(f.key);
         }
@@ -9904,11 +9903,17 @@ function isRetryableProviderStreamError(msg) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Ac: () => (/* binding */ getModelConfig),
 /* harmony export */   D1: () => (/* binding */ listModelConfigs),
+/* harmony export */   FO: () => (/* binding */ isModelConfigEnabled),
 /* harmony export */   JI: () => (/* binding */ deleteModelConfig),
+/* harmony export */   LZ: () => (/* binding */ ModelConfigStateError),
 /* harmony export */   TN: () => (/* binding */ upsertModelConfig),
+/* harmony export */   Z1: () => (/* binding */ setModelConfigEnabled),
+/* harmony export */   dj: () => (/* binding */ setDefaultModelConfig),
 /* harmony export */   h5: () => (/* binding */ withModelConfigMutation),
+/* harmony export */   "if": () => (/* binding */ listEnabledModelConfigs),
 /* harmony export */   lB: () => (/* binding */ getDefaultModelConfig),
-/* harmony export */   mN: () => (/* binding */ getModelParams)
+/* harmony export */   mN: () => (/* binding */ getModelParams),
+/* harmony export */   np: () => (/* binding */ resolveRunnableModelConfig)
 /* harmony export */ });
 /* harmony import */ var _lib_db__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46);
 /* harmony import */ var _lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10938);
@@ -9924,6 +9929,14 @@ const now = ()=>new Date().toISOString();
 function withModelConfigMutation(name, operation) {
     return (0,_lib_utils_keyed_mutation__WEBPACK_IMPORTED_MODULE_4__/* .withKeyedMutation */ .m)(`model-config:${name}`, operation);
 }
+class ModelConfigStateError extends Error {
+    constructor(message, status){
+        super(message), this.status = status;
+    }
+}
+function isModelConfigEnabled(cfg) {
+    return !!cfg && cfg.enabled !== 0;
+}
 // `params` holds the provider API key alongside hyperparameters and is
 // stored encrypted at rest (ADR-0005). Decrypt before returning rows.
 function decryptRow(row) {
@@ -9936,18 +9949,74 @@ function listModelConfigs() {
     const rows = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare("SELECT * FROM model_configs ORDER BY is_default DESC, name ASC").all();
     return rows.map(decryptRow);
 }
+/** Model configs that may be offered for selection or routing. */ function listEnabledModelConfigs() {
+    return listModelConfigs().filter(isModelConfigEnabled);
+}
 function getModelConfig(name) {
     const row = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare("SELECT * FROM model_configs WHERE name=?").get(name) ?? null;
     return row ? decryptRow(row) : null;
 }
 function getDefaultModelConfig() {
     const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
-    const row = db.prepare("SELECT * FROM model_configs WHERE is_default=1 LIMIT 1").get() ?? null;
+    const row = db.prepare("SELECT * FROM model_configs WHERE is_default=1 AND enabled=1 LIMIT 1").get() ?? null;
     if (row) return decryptRow(row);
-    const fallback = db.prepare("SELECT * FROM model_configs ORDER BY name ASC LIMIT 1").get() ?? null;
+    const fallback = db.prepare("SELECT * FROM model_configs WHERE enabled=1 ORDER BY name ASC LIMIT 1").get() ?? null;
     return fallback ? decryptRow(fallback) : null;
 }
-function upsertModelConfig(name, provider, model_id, params, is_default, credential_id = null) {
+/**
+ * Resolve the config a run should use: the named config when it exists and is
+ * enabled, otherwise the workspace default. A disabled assignment therefore
+ * falls back without being cleared, so re-enabling restores it.
+ */ function resolveRunnableModelConfig(name) {
+    const named = name ? getModelConfig(name) : null;
+    if (named && isModelConfigEnabled(named)) return named;
+    return getDefaultModelConfig();
+}
+/** Atomically make `name` the only default model config. */ function setDefaultModelConfig(name) {
+    return (0,_lib_db_transaction__WEBPACK_IMPORTED_MODULE_3__/* .withDbTransaction */ .J)(()=>{
+        const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+        const target = getModelConfig(name);
+        if (!target) throw new ModelConfigStateError(`Model config "${name}" not found`, 404);
+        if (!isModelConfigEnabled(target)) {
+            throw new ModelConfigStateError(`Model config "${name}" is disabled; enable it before making it the default`, 409);
+        }
+        const t = now();
+        db.prepare("UPDATE model_configs SET is_default=0, updated_at=? WHERE is_default=1 AND name<>?").run(t, name);
+        db.prepare("UPDATE model_configs SET is_default=1, updated_at=? WHERE name=?").run(t, name);
+        return getModelConfig(name);
+    });
+}
+/**
+ * Enable or disable a model config. Disabling the default promotes the
+ * alphabetically-first other enabled config in the same transaction, and the
+ * last enabled config cannot be disabled so runs always have a model.
+ */ function setModelConfigEnabled(name, enabled) {
+    return (0,_lib_db_transaction__WEBPACK_IMPORTED_MODULE_3__/* .withDbTransaction */ .J)(()=>{
+        const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
+        const target = getModelConfig(name);
+        if (!target) throw new ModelConfigStateError(`Model config "${name}" not found`, 404);
+        if (isModelConfigEnabled(target) === enabled) return target;
+        const t = now();
+        if (enabled) {
+            db.prepare("UPDATE model_configs SET enabled=1, updated_at=? WHERE name=?").run(t, name);
+            return getModelConfig(name);
+        }
+        const next = db.prepare("SELECT name FROM model_configs WHERE enabled=1 AND name<>? ORDER BY name ASC LIMIT 1").get(name);
+        if (!next?.name) {
+            throw new ModelConfigStateError("At least one model config must stay enabled", 409);
+        }
+        db.prepare("UPDATE model_configs SET enabled=0, is_default=0, updated_at=? WHERE name=?").run(t, name);
+        if (target.is_default === 1) {
+            db.prepare("UPDATE model_configs SET is_default=1, updated_at=? WHERE name=?").run(t, next.name);
+        }
+        return getModelConfig(name);
+    });
+}
+/**
+ * Insert or update a model config. `is_default` undefined keeps the current
+ * flag (false for new rows); true atomically clears every other default and
+ * re-enables the row, because the default must always be selectable.
+ */ function upsertModelConfig(name, provider, model_id, params, is_default, credential_id = null) {
     return (0,_lib_db_transaction__WEBPACK_IMPORTED_MODULE_3__/* .withDbTransaction */ .J)(()=>{
         const t = now();
         const existing = getModelConfig(name);
@@ -9963,9 +10032,11 @@ function upsertModelConfig(name, provider, model_id, params, is_default, credent
             ...decodeInlineParams(existing),
             ...params
         };
+        const finalDefault = is_default ?? existing?.is_default === 1;
+        const finalEnabled = finalDefault || !existing || isModelConfigEnabled(existing);
         const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
-        if (is_default) db.prepare("UPDATE model_configs SET is_default=0").run();
-        db.prepare("INSERT OR REPLACE INTO model_configs (name,provider,model_id,params,is_default,credential_id,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?)").run(name, provider, model_id, (0,_lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_1__/* .encrypt */ .w)(JSON.stringify(mergedParams)), is_default ? 1 : 0, finalCredId, created_at, t);
+        if (finalDefault) db.prepare("UPDATE model_configs SET is_default=0 WHERE name<>?").run(name);
+        db.prepare("INSERT OR REPLACE INTO model_configs (name,provider,model_id,params,is_default,enabled,credential_id,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)").run(name, provider, model_id, (0,_lib_crypto_envelope__WEBPACK_IMPORTED_MODULE_1__/* .encrypt */ .w)(JSON.stringify(mergedParams)), finalDefault ? 1 : 0, finalEnabled ? 1 : 0, finalCredId, created_at, t);
         return getModelConfig(name);
     });
 }
@@ -9978,10 +10049,10 @@ function deleteModelConfig(name) {
         // Automatically reset any agent pointing to this deleted model config to NULL (automatic / default model)
         db.prepare("UPDATE agent_configs SET model_config_name = NULL WHERE model_config_name = ?").run(name);
         // Avoid the "no default" state: if the deleted row was the default and any
-        // other rows remain, promote the alphabetically-first remaining row so
+        // other enabled rows remain, promote the alphabetically-first one so
         // agents that fall back to the default keep working.
         if (wasDefault) {
-            const next = db.prepare("SELECT name FROM model_configs ORDER BY name ASC LIMIT 1").get();
+            const next = db.prepare("SELECT name FROM model_configs WHERE enabled=1 ORDER BY name ASC LIMIT 1").get();
             if (next?.name) db.prepare("UPDATE model_configs SET is_default=1 WHERE name=?").run(next.name);
         }
         return true;
@@ -10482,9 +10553,8 @@ function isStructuredMemoryEligible(record, policy) {
 /* unused harmony export storeOAuthToken */
 /* harmony import */ var _lib_stores_memory__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(80956);
 /* harmony import */ var _lib_utils_error__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(22032);
-// GitHub Copilot device-flow login. Lets users sign in with their Copilot
-// subscription instead of pasting a PAT (which can't be exchanged for a
-// Copilot session token and gets rate-limited on the Models REST API).
+// GitHub Copilot device-flow login. The legacy PAT path depended on GitHub
+// Models, which has been retired; use this flow for Copilot Chat access.
 //
 // Flow (RFC 8628):
 //   1. POST github.com/login/device/code with the VS Code Copilot client_id.

package/.next/standalone/.next/server/chunks/466.js

@@ -124,6 +124,54 @@ exports.modules = {
 }
 
 
+/***/ }),
+
+/***/ 3872:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Fu: () => (/* binding */ resolveAgentModel),
+/* harmony export */   b_: () => (/* binding */ isModelEnabled),
+/* harmony export */   xu: () => (/* binding */ agentModelStatus)
+/* harmony export */ });
+/**
+ * Resolve which `ModelConfig` will actually be used for an agent at runtime.
+ *
+ * Mirrors what `lib/agents/llm.ts` does server-side: when an agent has an
+ * enabled `model_config_name`, that wins; otherwise the workspace-wide
+ * default among enabled models is used. Both client (BridgeEditor, AgentEditor capability hints)
+ * and server need the same logic — this is the single source of truth.
+ *
+ * Returns `null` only when neither the requested config nor the default
+ * exists in the provided list (typically: no models configured yet).
+ */ function resolveAgentModel(agent, models) {
+    const enabled = models.filter(isModelEnabled);
+    const defaultModel = enabled.find((m)=>m.is_default) ?? enabled[0] ?? null;
+    if (!agent?.model_config_name) return defaultModel;
+    return enabled.find((m)=>m.name === agent.model_config_name) ?? defaultModel;
+}
+/** Disabled configs stay stored but are skipped by runtime resolution. */ function isModelEnabled(model) {
+    return model.enabled !== false;
+}
+/**
+ * Diagnose whether an agent has a runnable model RIGHT NOW. Used by the
+ * Scheduled Tasks and Watchers panels to surface model-availability issues
+ * before an unattended run silently no-ops with `no_model`.
+ */ function agentModelStatus(agent, models) {
+    if (!agent) return {
+        state: "no-agent"
+    };
+    const effectiveModel = resolveAgentModel(agent, models);
+    if (effectiveModel) return {
+        state: "ok",
+        model: effectiveModel
+    };
+    return {
+        state: "no-model"
+    };
+}
+
+
 /***/ }),
 
 /***/ 4990:
@@ -707,6 +755,11 @@ async function request(path, init) {
                     "Content-Type": "application/json",
                     ...fetchInit.headers
                 },
+                // The in-memory list/value caches above are the client cache layer
+                // and are invalidated on writes. The browser HTTP cache would honor
+                // the server's short max-age and serve a stale list right after a
+                // save, so bypass it unless a caller opts in.
+                cache: "no-store",
                 ...fetchInit,
                 signal: timeoutCtrl.signal
             });
@@ -816,6 +869,14 @@ const api = {
                         action
                     }),
                     cache: "no-store"
+                }),
+            retryItem: (itemId)=>request("/lifecycle/adoption", {
+                    method: "POST",
+                    body: JSON.stringify({
+                        action: "retry",
+                        item_id: itemId
+                    }),
+                    cache: "no-store"
                 })
         }
     },
@@ -997,6 +1058,10 @@ const api = {
         delete: (thread_id)=>request(`/threads/${thread_id}`, {
                 method: "DELETE"
             }),
+        // What the thread is doing now (run phase, queued turns, compaction).
+        activity: (thread_id)=>request(`/threads/${thread_id}/activity`, {
+                cache: "no-store"
+            }),
         // Abort the active agent run on this thread. The server's stream loop
         // catches the resulting AbortError and emits an `error` + `done` so
         // any UI queue-drain hook (e.g. ChatView) still fires.
@@ -1120,6 +1185,17 @@ const api = {
             if (false) {}
             return updated;
         },
+        patch: async (name, data)=>{
+            const updated = await request(`/models/${encodeURIComponent(name)}`, {
+                method: "PATCH",
+                body: JSON.stringify(data)
+            });
+            // Enabling/disabling or setting the default can move the default flag
+            // on other rows, so drop the cached list instead of patching one row.
+            invalidateModelListCache();
+            if (false) {}
+            return updated;
+        },
         delete: async (name)=>{
             const res = await request(`/models/${encodeURIComponent(name)}`, {
                 method: "DELETE"
@@ -1239,7 +1315,10 @@ const api = {
         }
     },
     dashboard: {
-        metrics: (days = 30)=>request(`/dashboard/metrics?days=${encodeURIComponent(String(days))}`),
+        // Read-only aggregates: the server's 30s HTTP cache is intended here.
+        metrics: (days = 30)=>request(`/dashboard/metrics?days=${encodeURIComponent(String(days))}`, {
+                cache: "default"
+            }),
         pricingTask: ()=>request("/dashboard/pricing-task"),
         setupPricingTask: ()=>request("/dashboard/pricing-task", {
                 method: "POST",
@@ -2669,6 +2748,8 @@ function IconPicker({ form }) {
     });
 }
 
+// EXTERNAL MODULE: ./lib/agents/effective-model.ts
+var effective_model = __webpack_require__(3872);
 // EXTERNAL MODULE: ./lib/providers/capabilities.ts
 var capabilities = __webpack_require__(46069);
 // EXTERNAL MODULE: ./components/models/CapBadges.tsx
@@ -2688,10 +2769,13 @@ var feature_readiness = __webpack_require__(34974);
 
 
 
+
 function ModelSection({ form, models, integrations, onClose }) {
     const { dispatch } = (0,AppContext/* useAppContext */.U)();
-    const defaultModel = models.find((m)=>m.is_default);
-    const selectedModel = models.find((m)=>m.name === form.modelConfigName) ?? defaultModel;
+    const enabledModels = models.filter(effective_model/* isModelEnabled */.b_);
+    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 = (0,feature_readiness/* computeFeatureReadiness */.s)({
         models,
         integrations,
@@ -2746,7 +2830,7 @@ function ModelSection({ form, models, integrations, onClose }) {
                         className: "text-[11px] text-amber-700 dark:text-amber-400",
                         children: "No default fallback model is configured yet."
                     }),
-                    form.modelConfigName && models.find((m)=>m.name === form.modelConfigName) && /*#__PURE__*/ (0,react_jsx_runtime.jsx)("p", {
+                    forcedModel && /*#__PURE__*/ (0,react_jsx_runtime.jsx)("p", {
                         className: "text-[11px] text-sky-700 dark:text-sky-400",
                         children: "This agent currently has a forced model override. Clear it in Advanced settings to return to router-driven selection."
                     })
@@ -4485,6 +4569,7 @@ function ToolCredentialRow({ tool, options, selectedId, onChange }) {
 
 
 
+
 const Divider = ()=>/*#__PURE__*/ (0,react_jsx_runtime.jsx)("hr", {
         className: "border-border/60 my-2"
     });
@@ -4509,7 +4594,7 @@ function AdvancedSection({ form, models, integrations, isFullMode, onClose }) {
                                 value: "",
                                 children: "Automatic routing (recommended)"
                             }),
-                            models.map((m)=>{
+                            models.filter((m)=>(0,effective_model/* isModelEnabled */.b_)(m) || m.name === form.modelConfigName).map((m)=>{
                                 const vision = (0,capabilities/* modelSupportsImages */.Q5)(m.provider, m.model_id);
                                 return /*#__PURE__*/ (0,react_jsx_runtime.jsxs)("option", {
                                     value: m.name,
@@ -4519,12 +4604,17 @@ function AdvancedSection({ form, models, integrations, isFullMode, onClose }) {
                                         " \xb7 ",
                                         m.provider,
                                         " / ",
-                                        m.model_id
+                                        m.model_id,
+                                        (0,effective_model/* isModelEnabled */.b_)(m) ? "" : " (disabled)"
                                     ]
                                 }, m.name);
                             })
                         ]
                     }),
+                    selectedModel && !(0,effective_model/* isModelEnabled */.b_)(selectedModel) && /*#__PURE__*/ (0,react_jsx_runtime.jsx)("p", {
+                        className: "text-[11px] text-amber-700 dark:text-amber-400",
+                        children: "This model is disabled, so the agent uses automatic routing until it is enabled again."
+                    }),
                     selectedModel && /*#__PURE__*/ (0,react_jsx_runtime.jsx)(SelectedModelDescription, {
                         model: selectedModel,
                         prefix: "Forced"
@@ -5698,7 +5788,7 @@ function StepCredentials({ definitions, integrations, onChanged }) {
         }),
         eyebrow: "Step 2 \xb7 Credentials",
         title: "Connect provider credentials in the UI first",
-        description: "Use the built-in credential forms as the main setup path. They work for Claude, GPT, Gemini, Copilot, and other providers without depending on your shell environment.",
+        description: "Use the built-in credential forms as the main setup path for Claude, GPT, Gemini, and other providers. GitHub Copilot uses device-flow sign-in in the Models panel.",
         children: [
             /*#__PURE__*/ (0,react_jsx_runtime.jsxs)("div", {
                 className: "rounded-xl border border-accent/30 bg-accent/5 px-3 py-2.5 text-xs text-fg",
@@ -5902,10 +5992,7 @@ function StepModel({ models, onChanged }) {
     }
     async function handleSetDefault(m) {
         try {
-            await client/* api */.FH.models.update(m.name, {
-                provider: m.provider,
-                model_id: m.model_id,
-                params: m.params,
+            await client/* api */.FH.models.patch(m.name, {
                 is_default: true
             });
             onChanged();
@@ -6040,7 +6127,7 @@ function StepModel({ models, onChanged }) {
                                 /*#__PURE__*/ (0,react_jsx_runtime.jsxs)("div", {
                                     className: "flex shrink-0 items-center gap-0.5",
                                     children: [
-                                        !m.is_default && /*#__PURE__*/ (0,react_jsx_runtime.jsx)("button", {
+                                        !m.is_default && m.enabled !== false && /*#__PURE__*/ (0,react_jsx_runtime.jsx)("button", {
                                             type: "button",
                                             onClick: (e)=>{
                                                 e.stopPropagation();
@@ -8796,7 +8883,7 @@ function AuthHeader({ status, polling, onSignIn, onSignOut }) {
                     }),
                     /*#__PURE__*/ (0,react_jsx_runtime.jsx)("p", {
                         className: "text-fg-faint mt-0.5",
-                        children: "Unlocks full model context windows (vs. the 8k cap on raw PATs via GitHub Models)."
+                        children: "Required for Copilot models; GitHub PAT authentication is no longer supported."
                     })
                 ]
             }),