@nightlab-agent/opencode-subagent-cap 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.1.1 (2026-11-01)
+
+Fixes slots that were kept or freed wrongly:
+- A slash-command subtask that was cancelled or failed before it started kept its place in the queue, so
+  with a cap of 1 every later `task` call waited forever. Slots and queue places a turn leaves behind are
+  now freed when that session goes idle.
+- A slash-command subtask naming an agent that does not exist now gives its slot back.
+- When calls in two sessions share a call id, the first one finishing no longer frees the other's slot
+  too, which let one more call run than the cap.
+- A call whose turn ended (Esc) while it was looking up its parent session is refused instead of
+  queued with no one to free it.
+
+Re-run in opencode 1.19.5 with a test model: cap 2 of 4 calls, cap 1 with a failing call, and cap 1 with
+nested calls behave as in 0.1.0. The slash-command path is covered by a unit test only.
+
 ## 0.1.0 (2026-11-01)
 
 First release. Caps parallel `task` subagents in opencode 1.19 (tested on 1.19.5) (`OPENCODE_SUBAGENT_MAX`, default 2);

package/README.md

@@ -65,7 +65,7 @@ test only).
 - It does not support the opencode 2.x line (`@opencode/cli`), where the subagent tool and the plugin
   hooks are different.
 - Subtasks started by a slash command go through the same hooks in the 1.19.5 source, but that
-  path has not been tested.
+  path has not been run in opencode (covered by a unit test only).
 - It does not cap across separate opencode processes: each process has its own count.
 - A waiting `task` call shows as running in the UI until its slot comes; the wait is not shown (per the 1.19.5 source).
 

package/gate.js

@@ -7,9 +7,10 @@ const KEEP_ENDED = 500 // ended calls remembered for the race below; oldest drop
 export function createGate(max) {
   let running = 0
   const queue = []
-  const held = new Map() // callID -> how many slots it holds (a reused id can hold two)
+  const held = new Map() // callID -> sessions holding a slot under it (a reused id can hold two)
   const ended = new Map() // callID -> status, for calls that ended before they asked for a slot
-  const released = new Set() // calls whose slot was given back, so a late end event is not kept
+  const released = new Set() // slots given back by the after hook, so the end event that follows is not counted again
+  const endedFirst = new Set() // slots given back by the end event, so a late after hook is not counted again
 
   function remember(set, id) {
     set instanceof Map ? set.set(id, true) : set.add(id)
@@ -28,31 +29,43 @@ export function createGate(max) {
         continue
       }
       running++
-      held.set(w.callID, (held.get(w.callID) ?? 0) + 1)
+      held.set(w.callID, [...(held.get(w.callID) ?? []), w.sessionID])
       w.resolve()
     }
   }
 
   return {
-    acquire(callID) {
+    acquire(callID, sessionID) {
       return new Promise((resolve, reject) => {
-        queue.push({ callID, resolve, reject })
+        queue.push({ callID, sessionID, resolve, reject })
         admitNext()
       })
     },
     release(callID, status) {
-      const n = held.get(callID)
-      if (n) {
-        n > 1 ? held.set(callID, n - 1) : held.delete(callID)
+      if (status ? released.delete(callID) : endedFirst.delete(callID)) return admitNext()
+      const holders = held.get(callID)
+      if (holders) {
+        holders.length > 1 ? held.set(callID, holders.slice(1)) : held.delete(callID)
         running--
-        remember(released, callID)
-      } else if (status && !released.delete(callID)) {
+        remember(status ? endedFirst : released, callID)
+      } else if (status) {
         const i = queue.findIndex((w) => w.callID === callID)
         if (i >= 0) refuse(queue.splice(i, 1)[0])
         else remember(ended, callID)
       }
       admitNext()
     },
+    // The session finished its turn (idle): anything it still holds or waits for can only leak,
+    // e.g. a slash-command subtask cancelled while it waited, or one that named an unknown agent.
+    releaseSession(sessionID) {
+      for (const [callID, holders] of held) {
+        const keep = holders.filter((s) => s !== sessionID)
+        running -= holders.length - keep.length
+        keep.length ? held.set(callID, keep) : held.delete(callID)
+      }
+      for (let i = queue.length - 1; i >= 0; i--) if (queue[i].sessionID === sessionID) refuse(queue.splice(i, 1)[0])
+      admitNext()
+    },
     stats: () => ({ max, running, waiting: queue.length, ended: ended.size }),
   }
 }

package/index.js

@@ -8,6 +8,7 @@ const DONE = new Set(["completed", "error"])
 export const SubagentCap = async ({ client }) => {
   const gate = createGate(readMax())
   const parentOf = new Map()
+  const idleCount = new Map() // sessionID -> turns ended, to catch an Esc during the parent lookup
 
   // A failed lookup counts as nested (not queued, not cached): queuing a call that really is
   // nested would deadlock, while letting one top-level call through only misses the cap once.
@@ -28,13 +29,21 @@ export const SubagentCap = async ({ client }) => {
     "tool.execute.before": async (input, output) => {
       if (input.tool !== "task") return
       if (output?.args?.background) return
+      const turn = idleCount.get(input.sessionID)
       if (await isNested(input.sessionID)) return
-      await gate.acquire(input.callID)
+      if (idleCount.get(input.sessionID) !== turn) throw new Error(`subagent-cap: ${input.callID} ended while it waited for a slot`)
+      await gate.acquire(input.callID, input.sessionID)
     },
     "tool.execute.after": async (input) => {
       if (input.tool === "task") gate.release(input.callID)
     },
     event: async ({ event }) => {
+      if (event?.type === "session.idle") {
+        const id = event.properties?.sessionID
+        idleCount.set(id, (idleCount.get(id) ?? 0) + 1)
+        if (idleCount.size > 500) idleCount.delete(idleCount.keys().next().value)
+        return gate.releaseSession(id)
+      }
       if (event?.type !== "message.part.updated") return
       const part = event.properties?.part
       if (part?.type !== "tool" || part.tool !== "task") return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nightlab-agent/opencode-subagent-cap",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "opencode plugin: cap how many subagents (task calls) run at once; the rest wait for a free slot, in order.",
   "type": "module",
   "main": "index.js",