@cortexkit/opencode-magic-context 0.16.2 → 0.17.0

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;;;;;;0BAA0qpB,CAAC;;;;;;EAD55uB"}
+{"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/native-binding.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Native-binding resolver for Electron-runtime mismatches.
+ *
+ * Why this module exists
+ * ----------------------
+ * `better-sqlite3` uses raw v8/nan bindings, so its compiled `.node` file is
+ * locked to a specific NODE_MODULE_VERSION (Node-API ABI revision). When
+ * OpenCode Desktop (Electron 41 → ABI 145) loads a plugin whose `node_modules`
+ * was populated by `bun install` / `npm install` under a different runtime,
+ * the fetched prebuild is for `node-vNNN` (e.g. ABI 137 for Node 22) and
+ * Electron refuses to load it with:
+ *
+ *   The module '...better_sqlite3.node' was compiled against a different
+ *   Node.js version using NODE_MODULE_VERSION 137. This version of Node.js
+ *   requires NODE_MODULE_VERSION 145.
+ *
+ * `onnxruntime-node` (used by `@huggingface/transformers` for local
+ * embeddings) is N-API v3 and is ABI-stable across runtimes, so it does NOT
+ * have this problem. Only `better-sqlite3` is affected.
+ *
+ * What this does
+ * --------------
+ * On plugin load, before constructing any `Database`:
+ *
+ *  1. If we are NOT running under Electron (`process.versions.electron` is
+ *     unset), return null. Bun uses `bun:sqlite` and never reaches this code;
+ *     Pi/Node-CLI install matching Node-vNNN prebuilds via npm, which work
+ *     natively against the on-disk binary.
+ *
+ *  2. If we ARE on Electron, locate the `.node` file path that
+ *     `better-sqlite3`'s default `bindings()` lookup would try first. Probe
+ *     its ABI by attempting a sandboxed `process.dlopen`. If it succeeds
+ *     (Electron-compatible), return null — the default lookup will work.
+ *
+ *  3. Otherwise, look for a cached Electron prebuild at
+ *     `<XDG_CACHE_HOME>/cortexkit/native-bindings/better-sqlite3/v<version>/electron-v<abi>-<platform>-<arch>/better_sqlite3.node`.
+ *     Download it from the `WiseLibs/better-sqlite3` GitHub release if
+ *     missing, extract with `nanotar` (pure-JS, ~45 KB, zero deps), validate
+ *     the ABI, and return the absolute path.
+ *
+ * The caller (`sqlite.ts`) then passes this path through `better-sqlite3`'s
+ * documented `nativeBinding` constructor option:
+ *
+ *   new Database(filename, { nativeBinding: <our cached path> })
+ *
+ * `better-sqlite3` calls `require()` directly on that path, bypassing the
+ * normal `bindings()` lookup chain. This is a first-class API the maintainer
+ * added for exactly this kind of cross-runtime extension scenario — see
+ * `node_modules/better-sqlite3/lib/database.js` `nativeBinding` handling.
+ *
+ * Why we don't replace the on-disk binary
+ * ---------------------------------------
+ * An earlier iteration copied the cached Electron binary over the in-tree
+ * `node_modules/.../better_sqlite3.node`. That worked but mutates a shared
+ * resource: in monorepo dev setups (or any case where multiple runtimes
+ * share one `node_modules`), a Pi process opening the plugin from the same
+ * workspace would then load the Electron-ABI binary and fail. Returning a
+ * separate cached path keeps the on-disk file untouched so each runtime
+ * sees the binary it needs.
+ *
+ * Failure modes
+ * -------------
+ * If GitHub is unreachable (corporate firewall, offline laptop, rate limit)
+ * AND no cached binary exists, this throws. The caller (sqlite.ts →
+ * openDatabase) surfaces a `storage unavailable` error and Magic Context
+ * disables itself for the run. The user can connect to the network and
+ * restart, or wait for a cached binary from a previous successful launch.
+ */
+/**
+ * Resolve the absolute path to a `better-sqlite3` `.node` binary that the
+ * current runtime can load.
+ *
+ *   - Returns `null` outside Electron (Bun uses `bun:sqlite`; Pi/Node CLI
+ *     loads matching prebuilds from `node_modules` natively).
+ *   - Returns `null` on Electron when the on-disk binary already matches
+ *     the runtime's ABI (rare but possible — a future OpenCode build that
+ *     post-install-rebuilds for Electron would hit this fast path).
+ *   - Returns the cached/downloaded prebuild path on Electron when the
+ *     on-disk binary's ABI doesn't match.
+ *
+ * The returned path is suitable as the `nativeBinding` option to
+ * `new Database(filename, { nativeBinding })`. better-sqlite3 calls `require()`
+ * directly on it, bypassing the default `bindings()` lookup chain — this is
+ * a documented public API in better-sqlite3, not an internal hack.
+ */
+export declare function resolveBetterSqliteNativeBinding(): Promise<string | null>;
+//# sourceMappingURL=native-binding.d.ts.map

package/dist/shared/native-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-binding.d.ts","sourceRoot":"","sources":["../../src/shared/native-binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AA2IH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuF/E"}

package/dist/shared/sqlite.d.ts

@@ -25,18 +25,6 @@
  * is either rewritten to common-subset patterns or hidden behind the helpers
  * in `./sqlite-helpers.ts`.
  */
-/**
- * Database constructor compatible with both bun:sqlite and better-sqlite3.
- *
- * The TypeScript type intentionally references @types/better-sqlite3 because
- * its definitions are richer than @types/bun's bun:sqlite types and bun:sqlite
- * is a structural superset for the API surface we use. Calls written against
- * this type work correctly under both runtimes at runtime.
- *
- * @types/better-sqlite3 uses `export = Database` (CommonJS interop), which
- * surfaces in TypeScript as `import Database = require("better-sqlite3")`.
- * We capture the DatabaseConstructor type from the namespace re-export.
- */
 import type BetterSqlite3 from "better-sqlite3";
 export declare const Database: typeof BetterSqlite3;
 /** Instance type alias used by helpers and storage modules. */

package/dist/shared/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/shared/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAmCH;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAC;AAEhD,eAAO,MAAM,QAAQ,EAAE,OAAO,aAA4B,CAAC;AAE3D,+DAA+D;AAC/D,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,CAAC"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/shared/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAC;AAsFhD,eAAO,MAAM,QAAQ,EAAE,OAAO,aAA4B,CAAC;AAE3D,+DAA+D;AAC/D,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,CAAC"}

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.2",
+	"version": "0.17.0",
 	"type": "module",
 	"description": "OpenCode plugin for Magic Context — cross-session memory and context management",
 	"main": "dist/index.js",
@@ -46,6 +46,7 @@
 		"ai-tokenizer": "^1.0.6",
 		"better-sqlite3": "^12.9.0",
 		"comment-json": "^4.2.5",
+		"nanotar": "^0.3.0",
 		"zod": "^4.1.8"
 	},
 	"devDependencies": {

package/src/shared/conflict-detector.ts

@@ -365,7 +365,7 @@ export function formatConflictShort(result: ConflictResult): string {
         "",
         ...result.reasons.map((r) => `• ${r}`),
         "",
-        "Fix: run `bunx --bun @cortexkit/opencode-magic-context@latest doctor`",
+        "Fix: run `npx @cortexkit/opencode-magic-context@latest doctor`",
     ];
     return lines.join("\n");
 }

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;
 }