opencode-codeops 1.10.1 → 1.10.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to CodeOps are recorded here.
 
+## 1.10.3 — 2026-10-04
+
+### Fixes
+
+- effort: prefer the model variant over the reasoning-support flag
+
+## 1.10.2 — 2026-10-04
+
+### Fixes
+
+- effort: remember dispatch markers per session
+
 ## 1.10.1 — 2026-10-04
 
 ### Features

package/_shared/reasoning-effort.md

@@ -43,6 +43,10 @@ A dispatch marker is one standalone line in a dispatch message:
 For quality-agent packets the marker follows the dispatch header; for packet kinds without a
 header it is the first line. `exec-plan` owns the composition rule.
 
+A captured marker is remembered for the whole session: every request in that session uses it
+until a newer marker replaces it or the session ends. This is what keeps the marker effective
+when the host passes a later user message to the request hook.
+
 ## Precedence
 
 The most specific source wins:

package/bin/lib/reasoning-effort.mjs

@@ -309,9 +309,13 @@ export function modelSupportsReasoning(model) {
  * The runtime model carries a `variants` record whose entries are the exact
  * provider options for each level (for example `reasoningEffort`, or a nested
  * `reasoning.effort`). This function is the only place that mapping is
- * consumed, so the plugin never hardcodes a provider key. The function is
- * pure: it returns a new object when a change applies and the original object
- * reference otherwise.
+ * consumed, so the plugin never hardcodes a provider key. A matching variant
+ * is applied even when the model's reasoning capability flag is absent or
+ * false: the variant itself is the provider-known option set, and the host
+ * applies inherited variants the same way. Only when no variants record
+ * exists does the documented `reasoningEffort` passthrough require an
+ * explicit reasoning capability. The function is pure: it returns a new
+ * object when a change applies and the original object reference otherwise.
  *
  * @param options - Current provider options
  * @param level - Candidate level from {@link resolveEffort}
@@ -320,7 +324,6 @@ export function modelSupportsReasoning(model) {
  */
 export function applyEffort(options, level, model) {
   if (!isRoutingReasoning(level)) return options
-  if (!modelSupportsReasoning(model)) return options
 
   const variants = extractModelVariants(model)
   if (variants !== undefined) {
@@ -330,6 +333,7 @@ export function applyEffort(options, level, model) {
     return deepMergePlain(options, variantOptions)
   }
 
+  if (!modelSupportsReasoning(model)) return options
   return { ...options, reasoningEffort: level }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codeops",
-  "version": "1.10.1",
+  "version": "1.10.3",
   "description": "Specification-first engineering for complex systems — CodeOps plugin for OpenCode",
   "type": "module",
   "engines": {

package/plugin/index.ts

@@ -12,10 +12,12 @@ import {
 import {
   appendEffortTrace,
   applyEffort,
+  extractModelVariants,
   findEffortMarker,
   isEffortLevel,
   isEffortTraceEnabled,
   isRoutingReasoning,
+  modelSupportsReasoning,
   readRoutingReasoning,
   readSessionEffort,
   resolveEffort,
@@ -196,9 +198,9 @@ function traceEffort(
 // ---------------------------------------------------------------------------
 export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
   // Reasoning-effort state lives for the lifetime of this plugin instance:
-  // one entry per user message that carried a dispatch marker, plus a
-  // deduplication set for unsupported-level warnings.
-  const effortMarkers = new Map<string, { sessionID: string; level: EffortLevel }>()
+  // the latest dispatch-marker level per session, plus a deduplication set
+  // for unsupported-level warnings.
+  const effortMarkers = new Map<string, EffortLevel>()
   const warnedEffortLevels = new Set<string>()
   const effortTraceEnabled = isEffortTraceEnabled(process.env.CODEOPS_EFFORT_TRACE)
 
@@ -221,9 +223,7 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
         const info = (event.properties as { info: { id: string } }).info
         removeSessionTmpDir(info.id)
         try {
-          for (const [messageID, entry] of effortMarkers) {
-            if (entry.sessionID === info.id) effortMarkers.delete(messageID)
-          }
+          effortMarkers.delete(info.id)
         } catch {
           await warnContentFree(client, "Could not clear captured reasoning-effort markers.")
         }
@@ -288,8 +288,9 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
 
     // -----------------------------------------------------------------------
     // Hook 6: capture a dispatch marker from an incoming user message. The
-    // marker travels in the dispatch packet text; storing it by message id
-    // lets the later chat.params hook apply it to the same request.
+    // marker travels in the dispatch packet text; it is remembered for the
+    // whole session, because the later chat.params hook receives the latest
+    // user message, which can differ from the message that carried it.
     // -----------------------------------------------------------------------
     "chat.message": async (input, output) => {
       try {
@@ -298,7 +299,7 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
         )
         const level = findEffortMarker(texts)
         if (level !== undefined) {
-          effortMarkers.set(output.message.id, { sessionID: input.sessionID, level })
+          effortMarkers.set(input.sessionID, level)
           traceEffort(effortTraceEnabled, input.sessionID, {
             event: "capture",
             messageID: output.message.id,
@@ -317,8 +318,7 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
     // -----------------------------------------------------------------------
     "chat.params": async (input, output) => {
       try {
-        const stored = effortMarkers.get(input.message.id)
-        const marker = stored && stored.sessionID === input.sessionID ? stored.level : undefined
+        const marker = effortMarkers.get(input.sessionID)
         const session = readSessionEffort(input.sessionID)
         const routing = readRoutingReasoning(readRoutingConfig(directory), input.agent)
         const level = resolveEffort({ marker, session, routing })
@@ -350,6 +350,8 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
           level,
           source,
           applied: changed,
+          reasoningSupported: modelSupportsReasoning(input.model),
+          variantLevels: Object.keys(extractModelVariants(input.model) ?? {}),
         })
         if (!changed) {
           if (marker !== undefined) {