ltmoerdani · ltmoerdani · Aug 17, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026
diff --git a/scripts/staged-lint.ts b/scripts/staged-lint.ts
@@ -49,9 +49,11 @@ function run(cmd: string, args: string[]): CommandResult {
   return { status: res.status, output: `${res.stdout}${res.stderr}`.trim() };
 }
 
-/** Staged (added/copied/modified) file paths relative to the repo root. */
+/** Staged (added/copied/modified/renamed) file paths relative to the repo root. */
 function stagedFiles(): string[] {
-  const res = run("git", ["diff", "--cached", "--name-only", "-z", "--diff-filter=ACM"]);
+  // Include renamed (R) files and enable rename detection so a staged rename's
+  // new path is linted too.
+  const res = run("git", ["diff", "--cached", "--name-only", "-z", "--find-renames", "--diff-filter=ACMR"]);
   if (res.status !== 0) {
     return [];
   }
@@ -88,6 +90,13 @@ function resolveImport(fromFile: string, spec: string): string | undefined {
     path.join(base, "index.ts"),
     path.join(base, "index.js"),
   ];
+  // NodeNext-style: in ESM, `./foo.js` resolves to `./foo.ts`. Without this,
+  // changing foo.ts would not lint its dependents (this repo imports ESM
+  // scripts with `.js` specifiers that map to `.ts` sources).
+  if (/\.(js|cjs|mjs)$/.test(base)) {
+    const tsBase = base.replace(/\.(js|cjs|mjs)$/, "");
+    candidates.unshift(`${tsBase}.ts`, `${tsBase}.tsx`);
+  }
   for (const candidate of candidates) {
     try {
       statSync(candidate);

diff --git a/src/autocomplete/provider.ts b/src/autocomplete/provider.ts
@@ -89,7 +89,12 @@ export class OpenCodeInlineCompletionProvider implements vscode.InlineCompletion
       };
 
       const tokenSubscription = token.onCancellationRequested(() => {
-        this.debouncer.cancel();
+        // Do NOT cancel the shared debouncer here: VS Code may cancel this
+        // request's token AFTER a newer keystroke already scheduled its own
+        // debounced run, and aborting the debouncer would kill that newer
+        // pending suggestion. The debouncer cancels the previous run itself
+        // when the next debounce() is scheduled; here we only resolve this
+        // request's promise as "no suggestion".
         finish(undefined);
       });
 

diff --git a/src/chatParts.ts b/src/chatParts.ts
@@ -23,7 +23,11 @@ export function createUsageDataParts(usage: UsageSnapshot): vscode.LanguageModel
 }
 
 export function isInternalDataPart(part: vscode.LanguageModelDataPart): boolean {
-  return part.mimeType === OPENCODE_USAGE_DATA_MIME || part.mimeType === COPILOT_USAGE_DATA_MIME;
+  return (
+    part.mimeType === OPENCODE_USAGE_DATA_MIME ||
+    part.mimeType === COPILOT_USAGE_DATA_MIME ||
+    part.mimeType === OPENCODE_REASONING_DATA_MIME
+  );
 }
 
 /**

diff --git a/src/commands/diagnostics.ts b/src/commands/diagnostics.ts
@@ -11,7 +11,15 @@ export async function showModelPickerDiagnostics(): Promise<void> {
   const sections: string[] = [];
 
   for (const vendor of vendors) {
-    const models = await vscode.lm.selectChatModels({ vendor });
+    let models: readonly vscode.LanguageModelChat[];
+    try {
+      models = await vscode.lm.selectChatModels({ vendor });
+    } catch (error) {
+      // One failing vendor (e.g. no Copilot models installed) must not abort
+      // the whole diagnostics report.
+      sections.push(`## vendor: ${vendor}`, "", `selection error: ${error instanceof Error ? error.message : String(error)}`, "");
+      continue;
+    }
     sections.push(`## vendor: ${vendor}`, "", `models: ${String(models.length)}`, "");
     for (const model of models) {
       const internalModel = model as unknown as { configurationSchema?: unknown; detail?: unknown };

diff --git a/src/commands/thinkingPicker.ts b/src/commands/thinkingPicker.ts
@@ -1,19 +1,20 @@
 import * as vscode from "vscode";
 import { CONFIG_SECTION } from "../config";
-import { getSettings } from "../provider/settings";
-import type { ThinkingSettings } from "../thinking";
+import { getSettings, THINKING_ALLOWED_VALUES } from "../provider/settings";
 
 /** Pick a model family then set its Thinking effort (writes config). */
 export async function showThinkingEffortPicker(): Promise<void> {
-  const families: { label: string; key: keyof ThinkingSettings; options: string[] }[] = [
-    { label: "DeepSeek (deepseek-v4-*)", key: "deepseek", options: ["off", "low", "medium", "high", "max"] },
-    { label: "GLM (glm-5, glm-5.1, glm-5.2)", key: "glm", options: ["off", "high", "max"] },
-    { label: "Kimi (kimi-k2.*)", key: "kimi", options: ["on", "off"] },
-    { label: "Mimo (mimo-v2.*)", key: "mimo", options: ["off", "low", "medium", "high"] },
-    { label: "MiniMax (minimax-m*)", key: "minimax", options: ["off", "on"] },
-    { label: "OpenAI GPT (gpt-*)", key: "openai", options: ["off", "low", "medium", "high", "xhigh"] },
-    { label: "Qwen (qwen3.*)", key: "qwen", options: ["auto", "on", "off"] },
-    { label: "Qwen Thinking Budget", key: "qwenBudget", options: ["auto", "4096", "16384", "32768", "81920"] },
+  // Single source of truth (shared with request-time validation) so the option
+  // lists can never drift from what the request builder actually accepts.
+  const families: { label: string; key: keyof typeof THINKING_ALLOWED_VALUES; options: string[] }[] = [
+    { label: "DeepSeek (deepseek-v4-*)", key: "deepseek", options: [...THINKING_ALLOWED_VALUES.deepseek] },
+    { label: "GLM (glm-5, glm-5.1, glm-5.2)", key: "glm", options: [...THINKING_ALLOWED_VALUES.glm] },
+    { label: "Kimi (kimi-k2.*)", key: "kimi", options: [...THINKING_ALLOWED_VALUES.kimi] },
+    { label: "Mimo (mimo-v2.*)", key: "mimo", options: [...THINKING_ALLOWED_VALUES.mimo] },
+    { label: "MiniMax (minimax-m*)", key: "minimax", options: [...THINKING_ALLOWED_VALUES.minimax] },
+    { label: "OpenAI GPT (gpt-*)", key: "openai", options: [...THINKING_ALLOWED_VALUES.openai] },
+    { label: "Qwen (qwen3.*)", key: "qwen", options: [...THINKING_ALLOWED_VALUES.qwen] },
+    { label: "Qwen Thinking Budget", key: "qwenBudget", options: [...THINKING_ALLOWED_VALUES.qwenBudget] },
   ];
   const settings = getSettings().thinking;
   const family = await vscode.window.showQuickPick(

diff --git a/src/config.ts b/src/config.ts
@@ -235,6 +235,8 @@ export const COMPLETION_USAGE_MAX_DAYS = 370;
 
 export const PROFILES_REGISTRY_KEY = "opencodego.profiles.v1";
 export const ACTIVE_PROFILE_KEY = "opencodego.activeProfile.v1";
+/** Set once the user explicitly picks a profile — auto-resolution must not override it. */
+export const ACTIVE_PROFILE_EXPLICIT_KEY = "opencodego.activeProfileExplicit.v1";
 export const MIGRATED_KEY = "opencodego.migratedTo.v1";
 export const LEGACY_SECRET_KEY = SECRET_KEY;
 export const LEGACY_FINGERPRINT = "legacy";

diff --git a/src/core/routing.ts b/src/core/routing.ts
@@ -224,7 +224,10 @@ export function normalizeGoogleStreamEvent(data: unknown): unknown {
     return [
       {
         index,
-        id: "",
+        // Gemini has no native tool-call ids; emit a stable synthetic one so
+        // downstream tool-call parts carry a real callId (empty ids made calls
+        // indistinguishable and broke reasoning replication).
+        id: `google-tool-${String(index)}`,
         type: "function",
         function: {
           name: part.functionCall.name,
@@ -273,14 +276,14 @@ export function normalizeGoogleFullResponse(data: unknown): unknown {
     .filter((part) => typeof part.text === "string" && part.thought === true)
     .map((part) => part.text as string)
     .join("");
-  const toolCalls = parts.flatMap((part) => {
+  const toolCalls = parts.flatMap((part, index) => {
     if (!isRecord(part.functionCall) || typeof part.functionCall.name !== "string") {
       return [];
     }
 
     return [
       {
-        id: "",
+        id: `google-tool-${String(index)}`,
         type: "function",
         function: {
           name: part.functionCall.name,

diff --git a/src/errors.ts b/src/errors.ts
@@ -223,19 +223,26 @@ function parseRetryAfter(value: string | undefined): number | undefined {
   return Number.isFinite(dateMs) ? Math.max(0, dateMs - Date.now()) : parseDurationLike(value);
 }
 
+/** Ceiling for a seconds-remaining reset value — anything larger is nonsense. */
+const MAX_RESET_REMAINING_SECONDS = 24 * 60 * 60;
+
 function parseResetAfter(value: string | undefined): number | undefined {
   if (!value) {
     return undefined;
   }
   const numeric = Number(value);
   if (Number.isFinite(numeric) && numeric >= 0) {
     if (numeric > 1_000_000_000_000) {
+      // Epoch milliseconds (past timestamps clamp to 0).
       return Math.max(0, numeric - Date.now());
     }
     if (numeric > 1_000_000_000) {
+      // Epoch seconds (past timestamps clamp to 0).
       return Math.max(0, numeric * 1000 - Date.now());
     }
-    return numeric * 1000;
+    // Seconds remaining — cap so an absurd header value can't produce a
+    // multi-year "retry in" estimate in the error message.
+    return Math.min(numeric, MAX_RESET_REMAINING_SECONDS) * 1000;
   }
   const durationMs = parseDurationLike(value);
   if (durationMs !== undefined) {

diff --git a/src/extension.ts b/src/extension.ts
@@ -5,8 +5,11 @@ import { showModelPickerDiagnostics } from "./commands/diagnostics";
 import { showThinkingEffortPicker } from "./commands/thinkingPicker";
 import { configureUtilityModels, toggleProviderEnabled } from "./commands/providers";
 import {
+  ACTIVE_PROFILE_EXPLICIT_KEY,
   CONFIG_SECTION,
   DEFAULT_USAGE_CHART_DAYS,
+  GO_EVER_TRACKED_KEY,
+  GO_SERVER_USAGE_KEY,
   SETTING_AGENTS_WINDOW,
   SETTING_AUTO_ENABLE_AGENTS_WINDOW,
   SETTING_SHOW_PROVIDER_PREFIX,
@@ -316,6 +319,10 @@ export function activate(context: vscode.ExtensionContext) {
       ctx.globalState.update(`opencodego.usageLog.v1.${fp}`, []);
       ctx.globalState.update(`opencodego.usageBaseline.v1.${fp}`, {});
       ctx.globalState.update(`opencodego.sessionCosts.v1.${fp}`, []);
+      // Also clear the per-profile server snapshot + ever-tracked flags so a
+      // re-added profile (same key) doesn't resurrect stale meters/state.
+      ctx.globalState.update(`${GO_SERVER_USAGE_KEY}.${fp}`, undefined);
+      ctx.globalState.update(`${GO_EVER_TRACKED_KEY}.${fp}`, undefined);
 
       const remaining = readProfiles(ctx).filter((p) => p.fingerprint !== fp);
       await writeProfiles(ctx, remaining);
@@ -324,6 +331,9 @@ export function activate(context: vscode.ExtensionContext) {
       if (activeProfileFingerprint === fp) {
         setActiveProfileFingerprint(LEGACY_FINGERPRINT);
         await writeActiveProfile(ctx, LEGACY_FINGERPRINT);
+        // The user's explicit choice was deleted — clear the flag so auto-
+        // selection resumes for the remaining profiles.
+        await ctx.globalState.update(ACTIVE_PROFILE_EXPLICIT_KEY, undefined);
       }
 
       refreshGoUsageStatusBar();
@@ -376,10 +386,11 @@ export function activate(context: vscode.ExtensionContext) {
         const autoEnabled = vscode.workspace.getConfiguration(CONFIG_SECTION).get<boolean>(SETTING_AUTO_ENABLE_AGENTS_WINDOW, true);
         if (agentsWindowEnabled && autoEnabled) {
           void ensureAgentsWindowSupport(context);
-        } else if (!agentsWindowEnabled) {
-          // We may have enabled core settings for the Agents window; revert
-          // them when the user turns the feature off so the user's global
-          // configuration is restored.
+        } else {
+          // Revert the core settings we auto-enabled when either the feature
+          // is turned off OR auto-configuration is disabled — otherwise a
+          // user who only disables `autoEnableAgentsWindow` is left with the
+          // extension's settings permanently flipped in their global config.
           void revertAgentsWindowSupport(context);
         }
       }

diff --git a/src/models/metadata.ts b/src/models/metadata.ts
@@ -184,7 +184,6 @@ const MODEL_LIMITS_BY_PROVIDER: Record<ProviderVendor, Record<string, BaseModelL
     "qwen3.5-plus": { contextWindow: 262144, maxOutputTokens: 65536 },
     "gpt-5.6-luna": { contextWindow: 1050000, maxOutputTokens: 128000 },
     "hy3-preview": { contextWindow: 256000, maxOutputTokens: 64000 },
-    "ring-2.6-1t": { contextWindow: 262000, maxOutputTokens: 66000 },
   },
   [ZEN_VENDOR]: {
     "claude-opus-4-7": { contextWindow: 1000000, maxOutputTokens: 128000 },

diff --git a/src/provider/OpenCodeProvider.ts b/src/provider/OpenCodeProvider.ts
@@ -11,6 +11,7 @@ import {
   type ResolvedModelMetadata,
 } from "../models/metadata";
 import { resolveModelRouting } from "../core/routing";
+import { lookupModelRegistryEntry } from "../core/registry";
 import { extractThinkingOverride, resolveThinkingConfig, thinkingFamily, thinkingProviderFor } from "../thinking";
 import { buildOpenCodeGatewayAuthHeaders } from "../openCodeAuth";
 import { streamAnthropicMessages as runStreamAnthropicMessages } from "../transports/anthropic";
@@ -621,7 +622,10 @@ export class OpenCodeProvider implements vscode.LanguageModelChatProvider<OpenCo
       const sharedFields: Omit<OpenCodeModel, "id" | "targetChatSessionType"> = {
         rawModelId: modelId,
         name: providerModelDisplayName(this.definition.modelNamePrefix, modelId, showProviderPrefix),
-        family: `${this.definition.isAgentVariant && this.definition.baseVendor ? this.definition.baseVendor : this.definition.vendor}-${modelId}-${MODEL_METADATA_REVISION}`,
+        // A stable real family name (e.g. "deepseek", "gpt") so VS Code's
+        // family-based model selection/grouping works — a per-model unique
+        // string previously broke `modelFamily` routing and sticky grouping.
+        family: lookupModelRegistryEntry(modelId).family,
         // Include effective limits in version so VS Code invalidates stale
         // picker metadata after limit changes (eg. 2M -> 262K corrections).
         version: `1.2.0-${MODEL_METADATA_REVISION}-${String(limits.contextWindow)}-${String(limits.maxOutputTokens)}`,
@@ -971,6 +975,7 @@ export class OpenCodeProvider implements vscode.LanguageModelChatProvider<OpenCo
             this.storeReasoningContent(toolCallIds, reasoningContent);
           },
         });
+        this.log(`Request completed: model=${model.id}`);
         return;
       }
 

diff --git a/src/provider/definitions.ts b/src/provider/definitions.ts
@@ -132,6 +132,7 @@ export const PROVIDERS: Record<ProviderDefinition["vendor"], ProviderDefinition>
       "mimo-v2-pro",
       "mimo-v2.5",
       "mimo-v2.5-pro",
+      "minimax-m3",
       "minimax-m2.7",
       "minimax-m2.5",
       "qwen3.7-max",

diff --git a/src/provider/messages.ts b/src/provider/messages.ts
@@ -157,6 +157,19 @@ export async function convertMessage(
       continue;
     }
 
+    if (part instanceof vscode.LanguageModelDataPart && isReasoningMarkerPart(part)) {
+      // Thinking-off responses carry their reasoning in a marker data part
+      // (see streaming.ts / gateway bug #37635); echo it as reasoning_content
+      // on the next turn or DeepSeek's validator 400s. Must be checked BEFORE
+      // isInternalDataPart (which now includes the marker MIME) so the marker
+      // is processed rather than skipped as an internal usage part.
+      const reasoning = readReasoningMarker(part);
+      if (reasoning) {
+        thinkingTextParts.push(reasoning);
+      }
+      continue;
+    }
+
     if (part instanceof vscode.LanguageModelDataPart && isInternalDataPart(part)) {
       continue;
     }
@@ -169,17 +182,6 @@ export async function convertMessage(
       continue;
     }
 
-    if (part instanceof vscode.LanguageModelDataPart && isReasoningMarkerPart(part)) {
-      // Thinking-off responses carry their reasoning in a marker data part
-      // (see streaming.ts / gateway bug #37635); echo it as reasoning_content
-      // on the next turn or DeepSeek's validator 400s.
-      const reasoning = readReasoningMarker(part);
-      if (reasoning) {
-        thinkingTextParts.push(reasoning);
-      }
-      continue;
-    }
-
     const text = partToText(part);
     if (text) {
       textParts.push(text);
@@ -307,6 +309,12 @@ export function normalizeMessages(messages: ApiMessage[]): ApiMessage[] {
       !prevHasToolCalls &&
       !msgHasToolCalls
     ) {
+      // Merging two assistant messages must not drop the second one's
+      // reasoning_content — DeepSeek-style models require it echoed back on
+      // the next turn. Concatenate both into the merged message.
+      if (message.reasoning_content) {
+        previous.reasoning_content = [previous.reasoning_content, message.reasoning_content].filter(Boolean).join("\n");
+      }
       previous.content = `${prevContent}\n\n${msgContent}`.trim();
     } else {
       normalized.push({ ...message });