@cortexkit/opencode-magic-context 0.16.3 → 0.17.1

package/dist/plugin/hooks/create-session-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAU7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBAqDyvJ,CAAC;;;;;;;;;;;;qBAArnE,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAA62pB,CAAC;;;;;;EAD/lvB"}
+{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAU7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBAqDyvJ,CAAC;;;;;;;;;;;;qBAA/1D,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAulpB,CAAC;;;;;;EAD/lvB"}

package/dist/plugin/rpc-handlers.d.ts

@@ -3,8 +3,11 @@
  * and returns typed responses for TUI consumption.
  */
 import type { MagicContextConfig } from "../config/schema/magic-context";
+import { type ContextDatabase as Database } from "../features/magic-context/storage";
 import type { LiveSessionState } from "../hooks/magic-context/live-session-state";
 import type { MagicContextRpcServer } from "../shared/rpc-server";
+import type { SidebarSnapshot } from "../shared/rpc-types";
+export declare function buildSidebarSnapshot(db: Database, sessionId: string, directory: string, liveSessionState?: LiveSessionState, injectionBudgetTokens?: number): SidebarSnapshot;
 /**
  * Register all RPC handlers on the server.
  */

package/dist/plugin/rpc-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-handlers.d.ts","sourceRoot":"","sources":["../../src/plugin/rpc-handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAMzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAQlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAkflE;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,gBAAgB,CAAC;CACtC,GACF,IAAI,CA8HN"}
+{"version":3,"file":"rpc-handlers.d.ts","sourceRoot":"","sources":["../../src/plugin/rpc-handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EAAE,KAAK,eAAe,IAAI,QAAQ,EAAgB,MAAM,mCAAmC,CAAC;AAQnG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AASlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,qBAAqB,CAAC;AAmDzE,wBAAgB,oBAAoB,CAChC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,GAC/B,eAAe,CAySjB;AAoMD;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,gBAAgB,CAAC;CACtC,GACF,IAAI,CAoIN"}

package/dist/shared/models-dev-cache.d.ts

@@ -14,10 +14,9 @@
  *      Used during cold starts before the API cache warms up and in any
  *      code path that cannot reach the SDK client.
  *
- * The public getters (`getModelsDevContextLimit()` and
- * `getModelsDevInterleavedField()`) are synchronous: they check the API cache
- * first, then the file cache. The plugin warms and refreshes the API cache
- * from `src/index.ts` at startup and on a timer.
+ * The public getter (`getModelsDevContextLimit()`) is synchronous: it checks
+ * the API cache first, then the file cache. The plugin warms and refreshes
+ * the API cache from `src/index.ts` at startup and on a timer.
  */
 interface OpencodeClientLike {
     config: {
@@ -52,12 +51,6 @@ export declare function refreshModelLimitsFromApi(client: OpencodeClientLike): P
  * Returns `undefined` if neither layer knows the model.
  */
 export declare function getModelsDevContextLimit(providerID: string, modelID: string): number | undefined;
-/**
- * Returns the provider-specific interleaved reasoning field when the model
- * requires one (for example `reasoning_content` for Moonshot/Kimi style
- * providers). Undefined means the cache has no such capability recorded.
- */
-export declare function getModelsDevInterleavedField(providerID: string, modelID: string): string | undefined;
 /** Clear in-memory caches (for testing). */
 export declare function clearModelsDevCache(): void;
 /** Inspection helpers (for logging / debugging). */

package/dist/shared/models-dev-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models-dev-cache.d.ts","sourceRoot":"","sources":["../../src/shared/models-dev-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AASH,UAAU,kBAAkB;IACxB,MAAM,EAAE;QACJ,SAAS,EAAE,MAAM,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE;gBAAE,SAAS,CAAC,EAAE,OAAO,CAAA;aAAE,CAAA;SAAE,CAAC,CAAC;KAChE,CAAC;CACL;AAqND;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkDzF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAchG;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAkBpB;AAED,4CAA4C;AAC5C,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C;AAED,oDAAoD;AACpD,wBAAgB,sBAAsB,IAAI;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACrB,CAOA"}
+{"version":3,"file":"models-dev-cache.d.ts","sourceRoot":"","sources":["../../src/shared/models-dev-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,UAAU,kBAAkB;IACxB,MAAM,EAAE;QACJ,SAAS,EAAE,MAAM,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE;gBAAE,SAAS,CAAC,EAAE,OAAO,CAAA;aAAE,CAAA;SAAE,CAAC,CAAC;KAChE,CAAC;CACL;AA4MD;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmEzF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAchG;AAED,4CAA4C;AAC5C,wBAAgB,mBAAmB,IAAI,IAAI,CAO1C;AAED,oDAAoD;AACpD,wBAAgB,sBAAsB,IAAI;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACrB,CAOA"}

package/dist/shared/tag-transcript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tag-transcript.d.ts","sourceRoot":"","sources":["../../src/shared/tag-transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAM/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,cAAc,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACjC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACnC;AAyDD,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE,oBAAyB,GACnC,mBAAmB,CA+JrB"}
+{"version":3,"file":"tag-transcript.d.ts","sourceRoot":"","sources":["../../src/shared/tag-transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAM/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,cAAc,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACjC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACnC;AAyDD,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE,oBAAyB,GACnC,mBAAmB,CAoKrB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cortexkit/opencode-magic-context",
-	"version": "0.16.3",
+	"version": "0.17.1",
 	"type": "module",
 	"description": "OpenCode plugin for Magic Context — cross-session memory and context management",
 	"main": "dist/index.js",
@@ -41,8 +41,8 @@
 	},
 	"dependencies": {
 		"@huggingface/transformers": "^4.1.0",
-		"@opencode-ai/plugin": "^1.2.26",
-		"@opencode-ai/sdk": "^1.2.26",
+		"@opencode-ai/plugin": "^1.14.39",
+		"@opencode-ai/sdk": "^1.14.39",
 		"ai-tokenizer": "^1.0.6",
 		"better-sqlite3": "^12.9.0",
 		"comment-json": "^4.2.5",
@@ -71,6 +71,6 @@
 		"tui"
 	],
 	"peerDependencies": {
-		"@opencode-ai/plugin": ">=1.2.0"
+		"@opencode-ai/plugin": ">=1.14.0"
 	}
 }

package/src/shared/models-dev-cache.test.ts

@@ -6,7 +6,6 @@ import {
     clearModelsDevCache,
     getModelsDevCacheState,
     getModelsDevContextLimit,
-    getModelsDevInterleavedField,
     refreshModelLimitsFromApi,
 } from "./models-dev-cache";
 
@@ -276,62 +275,6 @@ describe("models-dev-cache", () => {
         expect(state.apiCount).toBe(1);
     });
 
-    test("reads interleaved reasoning field metadata from models.json", () => {
-        const opencodeDir = join(tempDir, "opencode");
-        mkdirSync(opencodeDir, { recursive: true });
-        writeFileSync(
-            join(opencodeDir, "models.json"),
-            JSON.stringify({
-                "opencode-go": {
-                    models: {
-                        "kimi-k2.6": {
-                            limit: { context: 262144 },
-                            interleaved: { field: "reasoning_content" },
-                        },
-                        "plain-model": {
-                            limit: { context: 262144 },
-                        },
-                    },
-                },
-            }),
-        );
-
-        expect(getModelsDevInterleavedField("opencode-go", "kimi-k2.6")).toBe("reasoning_content");
-        expect(getModelsDevInterleavedField("opencode-go", "plain-model")).toBeUndefined();
-    });
-
-    test("API cache exposes interleaved reasoning metadata", async () => {
-        const mockClient = {
-            config: {
-                providers: async () => ({
-                    data: {
-                        providers: [
-                            {
-                                id: "opencode-go",
-                                models: {
-                                    "kimi-k2.6": {
-                                        limit: { context: 262144 },
-                                        capabilities: {
-                                            interleaved: { field: "reasoning_content" },
-                                        },
-                                    },
-                                    "plain-model": {
-                                        limit: { context: 262144 },
-                                        capabilities: { interleaved: false },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                }),
-            },
-        };
-        await refreshModelLimitsFromApi(mockClient);
-
-        expect(getModelsDevInterleavedField("opencode-go", "kimi-k2.6")).toBe("reasoning_content");
-        expect(getModelsDevInterleavedField("opencode-go", "plain-model")).toBeUndefined();
-    });
-
     test("refreshModelLimitsFromApi tolerates empty/malformed responses", async () => {
         // Undefined data.
         await refreshModelLimitsFromApi({
@@ -356,6 +299,70 @@ describe("models-dev-cache", () => {
         expect(getModelsDevCacheState().apiLoaded).toBe(false);
     });
 
+    test("suppresses repeated logs when API count oscillates between known sizes", async () => {
+        // Simulates github-copilot's /models endpoint returning different model sets
+        // between calls. We want first sighting of each new size to log, but once a
+        // size has been seen before, further flips between known sizes should be
+        // silent (with one "oscillating" notice).
+        const sizeA = {
+            data: {
+                providers: [
+                    {
+                        id: "p",
+                        models: {
+                            m1: { limit: { context: 100 } },
+                            m2: { limit: { context: 100 } },
+                            m3: { limit: { context: 100 } },
+                        },
+                    },
+                ],
+            },
+        };
+        const sizeB = {
+            data: {
+                providers: [
+                    {
+                        id: "p",
+                        models: {
+                            m1: { limit: { context: 100 } },
+                            m2: { limit: { context: 100 } },
+                        },
+                    },
+                ],
+            },
+        };
+
+        const clientA = { config: { providers: async () => sizeA } };
+        const clientB = { config: { providers: async () => sizeB } };
+
+        // First sighting of size 3 → logs "loaded 3 entries".
+        await refreshModelLimitsFromApi(clientA);
+        expect(getModelsDevCacheState().apiCount).toBe(3);
+
+        // First sighting of size 2 → logs "loaded 2 entries (was 3)".
+        await refreshModelLimitsFromApi(clientB);
+        expect(getModelsDevCacheState().apiCount).toBe(2);
+
+        // Second sighting of size 3 → logs the "oscillating" notice once.
+        await refreshModelLimitsFromApi(clientA);
+        expect(getModelsDevCacheState().apiCount).toBe(3);
+
+        // Second sighting of size 2 → silent (no new log expected).
+        await refreshModelLimitsFromApi(clientB);
+        expect(getModelsDevCacheState().apiCount).toBe(2);
+
+        // Third sighting of size 3 → still silent.
+        await refreshModelLimitsFromApi(clientA);
+        expect(getModelsDevCacheState().apiCount).toBe(3);
+
+        // The cache itself still updates on every call (model contents are correct
+        // for whichever provider response just arrived). The suppression is purely
+        // a logging concern. Last call was clientA → all three models present.
+        expect(getModelsDevContextLimit("p", "m1")).toBe(100);
+        expect(getModelsDevContextLimit("p", "m2")).toBe(100);
+        expect(getModelsDevContextLimit("p", "m3")).toBe(100);
+    });
+
     test("falls back to file layer when API provider/model key is missing", async () => {
         const opencodeDir = join(tempDir, "opencode");
         mkdirSync(opencodeDir, { recursive: true });

package/src/shared/models-dev-cache.ts

@@ -14,10 +14,9 @@
  *      Used during cold starts before the API cache warms up and in any
  *      code path that cannot reach the SDK client.
  *
- * The public getters (`getModelsDevContextLimit()` and
- * `getModelsDevInterleavedField()`) are synchronous: they check the API cache
- * first, then the file cache. The plugin warms and refreshes the API cache
- * from `src/index.ts` at startup and on a timer.
+ * The public getter (`getModelsDevContextLimit()`) is synchronous: it checks
+ * the API cache first, then the file cache. The plugin warms and refreshes
+ * the API cache from `src/index.ts` at startup and on a timer.
  */
 
 import { createHash } from "node:crypto";
@@ -33,18 +32,30 @@ interface OpencodeClientLike {
     };
 }
 
-const RELOAD_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes, matches OpenCode's TTL
+// File-cache fallback only. The primary `models.json` API refresh is driven
+// by `setInterval(refreshModelLimitsFromApi, ...)` in `index.ts` at a 1-hour
+// cadence; this 5-minute interval governs the on-disk-cache fallback path
+// when the API loader hasn't run yet (e.g. during plugin warmup).
+const RELOAD_INTERVAL_MS = 5 * 60 * 1000;
 
 interface CachedModelMetadata {
     limit?: number;
-    interleavedField?: string;
 }
 
-type InterleavedConfig = boolean | { field?: string } | undefined;
-
 /** Populated async from OpenCode SDK. Primary source of truth when available. */
 let apiCache: Map<string, CachedModelMetadata> | null = null;
 let apiLoadedAt = 0;
+/**
+ * Recently-seen API cache sizes, used to detect oscillation between two
+ * stable values (typically caused by upstream provider plugins like
+ * github-copilot whose `/models` endpoint returns slightly different model
+ * sets between calls based on `model_picker_enabled` toggles). Once the
+ * same size has been observed before, we stop logging count changes —
+ * the count is a function of upstream behavior we can't control, and
+ * repeated logs only add noise.
+ */
+const recentlySeenApiSizes = new Set<number>();
+let oscillationLogged = false;
 
 /** Populated sync from disk as fallback. */
 let fileCache: Map<string, CachedModelMetadata> | null = null;
@@ -110,47 +121,28 @@ function resolveLimit(limit: { context?: number; input?: number } | undefined):
     return undefined;
 }
 
-function resolveInterleavedField(interleaved: InterleavedConfig): string | undefined {
-    if (
-        interleaved &&
-        typeof interleaved === "object" &&
-        typeof interleaved.field === "string" &&
-        interleaved.field.length > 0
-    ) {
-        return interleaved.field;
-    }
-    return undefined;
-}
-
 function setCachedModelMetadata(
     cache: Map<string, CachedModelMetadata>,
     key: string,
     model:
         | {
               limit?: { context?: number; input?: number };
-              capabilities?: { interleaved?: InterleavedConfig };
-              interleaved?: InterleavedConfig;
               experimental?: { modes?: Record<string, unknown> };
           }
         | undefined,
 ): void {
     const limit = resolveLimit(model?.limit);
-    const interleavedField =
-        resolveInterleavedField(model?.capabilities?.interleaved) ??
-        resolveInterleavedField(model?.interleaved);
 
-    if (limit === undefined && interleavedField === undefined) {
+    if (limit === undefined) {
         return;
     }
 
-    const value: CachedModelMetadata = {};
-    if (limit !== undefined) value.limit = limit;
-    if (interleavedField !== undefined) value.interleavedField = interleavedField;
+    const value: CachedModelMetadata = { limit };
     cache.set(key, value);
 
     // OpenCode creates derived model IDs from experimental.modes
     // e.g. gpt-5.4 + modes.fast → gpt-5.4-fast. These inherit the same
-    // context limit and interleaved-reasoning contract as the parent model.
+    // context limit as the parent model.
     const modes = model?.experimental?.modes;
     if (modes && typeof modes === "object") {
         for (const mode of Object.keys(modes)) {
@@ -176,8 +168,6 @@ function loadModelsDevMetadataFromFile(): Map<string, CachedModelMetadata> {
                         string,
                         {
                             limit?: { context?: number; input?: number };
-                            capabilities?: { interleaved?: InterleavedConfig };
-                            interleaved?: InterleavedConfig;
                             experimental?: { modes?: Record<string, unknown> };
                         }
                     >;
@@ -273,8 +263,6 @@ export async function refreshModelLimitsFromApi(client: OpencodeClientLike): Pro
                     string,
                     {
                         limit?: { context?: number; input?: number };
-                        capabilities?: { interleaved?: InterleavedConfig };
-                        interleaved?: InterleavedConfig;
                         experimental?: { modes?: Record<string, unknown> };
                     }
                 >;
@@ -288,15 +276,34 @@ export async function refreshModelLimitsFromApi(client: OpencodeClientLike): Pro
         const previousSize = apiCache?.size ?? null;
         apiCache = map;
         apiLoadedAt = Date.now();
-        // Log only on first successful load or when the model count changes,
-        // so the 5-minute periodic refresh doesn't spam the log.
-        if (previousSize === null || previousSize !== map.size) {
+
+        // Log policy:
+        //   - Always log the first successful load.
+        //   - Log a count change once per new size we haven't seen before.
+        //   - When the count returns to a previously-seen size, log an
+        //     "oscillation" message exactly once explaining the cause, then
+        //     stay silent on further flips between known sizes.
+        if (previousSize === null) {
+            recentlySeenApiSizes.add(map.size);
             sessionLog(
                 "global",
-                `models-dev-cache: API layer loaded ${map.size} model metadata entries${
-                    previousSize !== null ? ` (was ${previousSize})` : ""
-                }`,
+                `models-dev-cache: API layer loaded ${map.size} model metadata entries`,
             );
+        } else if (previousSize !== map.size) {
+            const sizeAlreadySeen = recentlySeenApiSizes.has(map.size);
+            recentlySeenApiSizes.add(map.size);
+            if (!sizeAlreadySeen) {
+                sessionLog(
+                    "global",
+                    `models-dev-cache: API layer loaded ${map.size} model metadata entries (was ${previousSize})`,
+                );
+            } else if (!oscillationLogged) {
+                oscillationLogged = true;
+                sessionLog(
+                    "global",
+                    `models-dev-cache: API count oscillating between ${[...recentlySeenApiSizes].sort((a, b) => a - b).join(" ↔ ")} — likely upstream provider plugin returning slightly different model sets between calls (e.g. github-copilot's /models endpoint toggling model_picker_enabled). Suppressing further size-change logs.`,
+                );
+            }
         }
     } catch (error) {
         sessionLog(
@@ -334,38 +341,12 @@ export function getModelsDevContextLimit(providerID: string, modelID: string): n
     return fileCache.get(key)?.limit;
 }
 
-/**
- * Returns the provider-specific interleaved reasoning field when the model
- * requires one (for example `reasoning_content` for Moonshot/Kimi style
- * providers). Undefined means the cache has no such capability recorded.
- */
-export function getModelsDevInterleavedField(
-    providerID: string,
-    modelID: string,
-): string | undefined {
-    const key = `${providerID}/${modelID}`;
-
-    if (apiCache) {
-        const fromApi = apiCache.get(key)?.interleavedField;
-        if (typeof fromApi === "string" && fromApi.length > 0) {
-            return fromApi;
-        }
-    }
-
-    const now = Date.now();
-    if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
-        fileLastAttempt = now;
-        fileCache = loadModelsDevMetadataFromFile();
-    }
-
-    const fromFile = fileCache.get(key)?.interleavedField;
-    return typeof fromFile === "string" && fromFile.length > 0 ? fromFile : undefined;
-}
-
 /** Clear in-memory caches (for testing). */
 export function clearModelsDevCache(): void {
     apiCache = null;
     apiLoadedAt = 0;
+    recentlySeenApiSizes.clear();
+    oscillationLogged = false;
     fileCache = null;
     fileLastAttempt = 0;
 }