@stablekernel/opencode-cursor 0.7.1-next.0 → 0.7.1-next.2

package/CHANGELOG.md

@@ -4,6 +4,52 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.7.1-next.2] — 2026-08-04 (pre-release)
+
+Pre-release of the auto-compaction suppression (#92). Not yet on `latest`; install with
+`npm install @stablekernel/opencode-cursor@next` to test.
+
+- **opencode's threshold-triggered auto-compaction is now suppressed for Cursor models by
+  default.** The Cursor agent runtime already self-compacts on its own context threshold
+  (`preCompact` hook with `trigger: "auto"`), so opencode-driven compaction was redundant —
+  and it caused two real failures. First, the compaction turn runs with zero tools declared
+  while the Cursor agent uses its own tools anyway, which opencode rejects (`Tool call not
+  allowed while generating summary`) — mitigated in 0.7.1-next.1 (#91), and now avoided
+  entirely for the automatic trigger. Second, compaction rewrites the transcript, which
+  classifies as a divergence and mints a **fresh Cursor agentId** — and every distinct
+  agentId permanently holds a guarded SQLite `store.db`/`-wal`/`-shm` triple that
+  `agent.close()` cannot release (it only flushes analytics and releases the executor lease).
+  That descriptor growth fed an uncatchable `EXC_GUARD` process kill.
+
+  Suppression uses a large `limit.input` — the value opencode uses as its compaction
+  threshold — leaving the real `limit.context` intact so the TUI context gauge and cost
+  reporting still work. Manual `/compact` is unaffected and still relies on #91's fix.
+
+  **Tradeoff:** this suppresses the proactive threshold trigger only, and opencode has no
+  reactive context-overflow recovery wired up for this provider, so its transcript is no
+  longer trimmed automatically. Ordinary turns send only the new message, but a cold replay
+  (new session, expired agent, changed MCP set) resends everything; if that overflows the
+  model the turn fails and `/compact` is the manual recovery. Opt back out with
+  `provider.cursor.options.autoCompaction: true`.
+
+## [0.7.1-next.1] — 2026-08-03 (pre-release)
+
+Pre-release of the compaction fix (#91). Not yet on `latest`; install with
+`npm install @stablekernel/opencode-cursor@next` to test.
+
+- **Fixed: auto-compaction (and manual `/compact`) failed with `Tool call not
+  allowed while generating summary` whenever the Cursor agent used a tool while
+  summarizing.** opencode declares zero tools on a compaction/summary turn, but
+  the Cursor agent runs its own tools regardless; the provider forwarded that
+  activity as provider-executed `tool-call` parts, which opencode's summary
+  guard rejects. The provider now routes no-tools turns through the existing
+  `"reasoning"` tool-display path, so Cursor's tool activity surfaces as
+  reasoning text instead of crossing the tool-execution boundary. Manual
+  `/compact` was affected all along; **auto**-compaction became reachable only
+  in 0.7.1-next.0, because #89 published real per-model context windows —
+  pre-0.7.1 opencode saw `limit.context: 0` for every Cursor model, and a zero
+  context limit structurally disables the auto-compaction trigger.
+
 ## [0.7.1-next.0] — 2026-08-03 (pre-release)
 
 Pre-release of the skills bridge (#90) and per-model context limits + pricing
@@ -30,17 +76,17 @@ Pre-release of the skills bridge (#90) and per-model context limits + pricing
   through opencode's structured plugin logging rather than the terminal,
   matching 0.7.0's logging change. `config.skills.urls` (HTTP catalogs) and
   skills bundled inside opencode plugin packages are not yet supported.
-- **Per-model context limits and pricing generated from Cursor's docs.** The
-  plugin now ships a generated `src/model-limits.ts` (regenerated on schedule via
-  `scripts/sync-model-limits.mjs`, with a CI drift check that fails the job if
-  the committed data falls behind Cursor's published tables). Each resolved
-  model carries a context-window limit and per-token pricing, emitted on the
-  config channel opencode reads so the TUI can show cost and token counts.
-  High-output frontier models carry a separate output-token limit. A
-  `models` generator CLI (`scripts/sync-model-limits-cli.mjs`) is import-pure
-  and calls `main()` unconditionally; the drift check captures stdout and
-  requires the run summary line, so "exited 0 having done nothing" fails
-  instead of passing for free.
+  Skills bridge contributed by Wayne Simpson (@WayneSimpson).
+- **Per-model context limits and pricing generated from Cursor's docs.** Each
+  resolved model now carries a context-window limit and per-token pricing,
+  emitted on the config channel opencode reads so the TUI can show cost and
+  token counts. High-output frontier models carry a separate output-token
+  limit. The data ships as a generated `src/model-limits.ts`, produced from
+  Cursor's published tables by `npm run sync:model-limits`; a weekly CI job
+  re-checks the committed data against those tables and fails if it has fallen
+  behind (it verifies only — regenerating is a manual step).
+- **Dependency bumps:** `@ai-sdk/provider` 3.0.13 → 3.0.14, `@types/node`
+  26.0.0 → 26.1.2, `vitest` 4.1.9 → 4.1.10 (dev-dependencies group, #88).
 
 ## [0.7.0] — 2026-07-30
 

package/README.md

@@ -187,6 +187,7 @@ See [SECURITY.md](./SECURITY.md) for the full threat model.
 | `toolDisplay` | `"blocks"` | How Cursor's internal tool activity is shown — see [Tool display](#tool-display) |
 | `systemPrompt` | `"rules"` | How opencode's system prompt reaches the agent — see [System prompt](#system-prompt) |
 | `transport` | — | Cursor agent transport (`"http1"` \| `"http2-direct"` \| `"sidecar"`) — see [Transport](#transport) |
+| `autoCompaction` | `false` | Let opencode drive auto-compaction. Off by default because the Cursor agent self-compacts — see [Compaction](#compaction) |
 
 | Environment variable | Default | Meaning |
 | --- | --- | --- |
@@ -413,12 +414,52 @@ open a PR.
 - **`"reasoning"`** — compact inline lines (`[tool] write {"path":…}`). Works on any host; use
   this on older opencode versions.
 
+Turns where the host declares no tools at all — compaction/summary and title generation — always
+use `"reasoning"` regardless of this setting. opencode rejects tool parts on a summary turn, so
+Cursor's tool activity is folded into reasoning text there instead.
+
 To force the fallback:
 
 ```json
 { "provider": { "cursor": { "options": { "toolDisplay": "reasoning" } } } }
 ```
 
+## Compaction
+
+**opencode's threshold-triggered auto-compaction is suppressed for Cursor models by default.** The
+Cursor agent runtime compacts its own conversation as it approaches its context threshold, so a
+second, opencode-driven pass is redundant — and it is actively harmful here:
+
+- The compaction turn asks the model to summarize with **no tools available**. The Cursor agent runs
+  its own tools regardless, which opencode rejects outright
+  (`Tool call not allowed while generating summary`).
+- Compaction rewrites the transcript, so the next turn no longer matches what the Cursor agent saw.
+  The plugin correctly treats that as a divergence and creates a **fresh Cursor agent** — and every
+  distinct agent permanently holds its own SQLite store open for the life of the process, which has
+  been observed to crash opencode outright.
+
+The suppression works by emitting a very large `limit.input`, which is what opencode uses as its
+compaction threshold. The real `limit.context` is left untouched, so the TUI's context-window gauge
+and cost reporting keep working.
+
+> [!IMPORTANT]
+> This suppresses the **proactive** threshold trigger only, and opencode has no reactive
+> context-overflow recovery wired up for this provider. In exchange, opencode's transcript is no
+> longer trimmed automatically, so it grows for the life of the session. Ordinary turns send only
+> the new message to an already-running agent, but a *cold replay* — a new session, an expired
+> agent, or a changed MCP server set — resends the whole transcript. If that ever overflows the
+> model, the turn fails with a provider error and the fix is to run `/compact` manually.
+>
+> Set `autoCompaction: true` if you would rather have opencode keep bounding the transcript for you.
+
+Manual `/compact` is unaffected and still works — it has no threshold gate.
+
+To hand compaction back to opencode:
+
+```json
+{ "provider": { "cursor": { "options": { "autoCompaction": true } } } }
+```
+
 ## Transport
 
 opencode runs on [Bun](https://bun.sh), whose `node:http2` client is incompatible with the Cursor

package/dist/plugin/index.js

@@ -55,6 +55,7 @@ var MODEL_CONTEXT_LIMITS = {
   "grok-4.5": 256e3
 };
 var DEFAULT_CONTEXT_LIMIT = 2e5;
+var NO_AUTO_COMPACTION_INPUT_LIMIT = 1e9;
 function resolveContextLimit(modelId) {
   let best;
   let bestLen = 0;
@@ -313,7 +314,7 @@ async function discoverModels(options = {}) {
 function modelSupportsReasoning(item) {
   return (item.parameters ?? []).some((p) => /think|reason/i.test(p.id));
 }
-function toOpencodeModels(items) {
+function toOpencodeModels(items, opts = {}) {
   const out = {};
   for (const item of items) {
     const params = defaultModelParams(item);
@@ -329,6 +330,10 @@ function toOpencodeModels(items) {
       options: Object.keys(params).length > 0 ? { params } : {},
       limit: {
         context: resolveContextLimit(item.id),
+        // Suppress opencode's auto-compaction unless the user opts in: the
+        // Cursor agent self-compacts, and opencode's compaction mints a
+        // fresh agentId per cycle, permanently leaking guarded SQLite fds.
+        ...opts.autoCompaction ? {} : { input: NO_AUTO_COMPACTION_INPUT_LIMIT },
         output: resolveOutputLimit(item.id)
       },
       cost: {
@@ -348,7 +353,7 @@ var NPM_PACKAGE = "@stablekernel/opencode-cursor";
 function providerNpm() {
   return process.env.OPENCODE_CURSOR_PROVIDER_NPM?.trim() || NPM_PACKAGE;
 }
-function buildModelV2Map(items) {
+function buildModelV2Map(items, opts = {}) {
   const out = {};
   for (const item of items) {
     const params = defaultModelParams(item);
@@ -370,7 +375,11 @@ function buildModelV2Map(items) {
         const c = resolveCost(item.id);
         return { input: c.input, output: c.output, cache: { read: c.cacheRead, write: c.cacheWrite } };
       })(),
-      limit: { context: resolveContextLimit(item.id), output: resolveOutputLimit(item.id) },
+      limit: {
+        context: resolveContextLimit(item.id),
+        ...opts.autoCompaction ? {} : { input: NO_AUTO_COMPACTION_INPUT_LIMIT },
+        output: resolveOutputLimit(item.id)
+      },
       status: "active",
       options: Object.keys(params).length > 0 ? { params } : {},
       headers: {},
@@ -785,7 +794,7 @@ function clearVersionCache() {
   }
 }
 function getLocalVersion() {
-  if (true) return "0.7.1-next.0";
+  if (true) return "0.7.1-next.2";
   try {
     const require2 = createRequire(import.meta.url);
     const pkg = require2("../package.json");
@@ -1473,6 +1482,7 @@ var CursorPlugin = async (input) => {
   let resolvedCwd = directory ?? process.cwd();
   let forwardMcp = true;
   let userMcp = {};
+  let autoCompaction = false;
   let forwardSkills = true;
   let skillFilterOptions;
   let lastSkillHash = "";
@@ -1505,6 +1515,7 @@ var CursorPlugin = async (input) => {
       config.provider ??= {};
       const existing = config.provider[PROVIDER_ID] ?? {};
       const existingOptions = existing.options ?? {};
+      autoCompaction = existingOptions["autoCompaction"] === true;
       forwardMcp = existingOptions["forwardMcp"] !== false;
       userMcp = existingOptions["mcpServers"] ?? {};
       const mcpServers = forwardMcp ? { ...userMcp, ...translateMcpServers(config.mcp) } : userMcp;
@@ -1558,7 +1569,10 @@ var CursorPlugin = async (input) => {
           ...Object.keys(modelParamDefaults).length > 0 ? { modelParamDefaults } : {},
           ...currentSkillsCatalogue ? { skillsCatalogue: currentSkillsCatalogue } : {}
         },
-        models: { ...toOpencodeModels(models), ...existing.models ?? {} }
+        models: {
+          ...toOpencodeModels(models, { autoCompaction }),
+          ...existing.models ?? {}
+        }
       };
     },
     provider: {
@@ -1566,7 +1580,7 @@ var CursorPlugin = async (input) => {
       models: async (_provider, ctx) => {
         const apiKey = apiKeyFromAuth(ctx.auth);
         const { models } = await discoverModels({ apiKey });
-        return buildModelV2Map(models);
+        return buildModelV2Map(models, { autoCompaction });
       }
     },
     // Bridge opencode's session id to the provider: it lands in