@plainconceptsplatform/agent-harness 2.7.0 → 3.0.1

package/cli/steps/optimization/quota.js

@@ -16,11 +16,6 @@ export function splitPackageSpec(spec) {
   return { name: spec.slice(0, separator), version: spec.slice(separator + 1) }
 }
 
-function ensurePlugin(config) {
-  if (!Array.isArray(config.plugin)) config.plugin = []
-  if (!config.plugin.includes(PLUGIN)) config.plugin.push(PLUGIN)
-}
-
 export async function installQuota(options = {}) {
   if (!options.skipHeader) header('Installing opencode-quota')
 
@@ -57,9 +52,14 @@ export async function installQuota(options = {}) {
     const opencodeDir = path.join(process.cwd(), '.opencode')
     const opencodePath = path.join(process.cwd(), 'opencode.jsonc')
     const pkgPath = path.join(opencodeDir, 'package.json')
-    const tuiPath = path.join(opencodeDir, 'tui.json')
-    const quotaDir = path.join(opencodeDir, 'opencode-quota')
-    const quotaPath = path.join(quotaDir, 'quota-toast.json')
+
+    // opencode-quota 5.x reads its settings from `opencode-quota/quota-toast.jsonc`
+    // next to the OpenCode config (project root), not from `.opencode/`. The old
+    // `.opencode/opencode-quota/quota-toast.json` is the v4 location and is migrated
+    // below so the settings actually take effect.
+    const quotaDir = path.join(process.cwd(), 'opencode-quota')
+    const quotaPath = path.join(quotaDir, 'quota-toast.jsonc')
+    const legacyQuotaPath = path.join(opencodeDir, 'opencode-quota', 'quota-toast.json')
 
     let opencodeText = JSON.stringify({ $schema: 'https://opencode.ai/config.json' }, null, 2)
     let opencode
@@ -78,18 +78,20 @@ export async function installQuota(options = {}) {
       ? await fse.readJson(pkgPath)
       : {}
 
-    const tui = await fse.pathExists(tuiPath)
-      ? await fse.readJson(tuiPath)
-      : { $schema: 'https://opencode.ai/tui.json' }
-
-    const plugins = Array.isArray(opencode.plugin) ? opencode.plugin : []
+    // V2 configures server plugins under `plugins`. A V1 `plugin` array found
+    // here is carried over so the quota entry is not lost when the config
+    // patcher has not run first.
+    const plugins = Array.isArray(opencode.plugins)
+      ? [...opencode.plugins]
+      : Array.isArray(opencode.plugin)
+        ? [...opencode.plugin]
+        : []
     if (!plugins.includes(PLUGIN)) {
       plugins.push(PLUGIN)
-      opencodeText = applyEdits(opencodeText, modify(opencodeText, ['plugin'], plugins, {
+      opencodeText = applyEdits(opencodeText, modify(opencodeText, ['plugins'], plugins, {
         formattingOptions: { insertSpaces: true, tabSize: 2 },
       }))
     }
-    ensurePlugin(tui)
 
     if (!pkg.dependencies) pkg.dependencies = {}
     const { name: pkgName, version: pkgVersion } = splitPackageSpec(PLUGIN)
@@ -98,18 +100,32 @@ export async function installQuota(options = {}) {
     await fse.ensureDir(opencodeDir)
     await fse.writeFile(opencodePath, opencodeText, 'utf-8')
     await fse.writeJson(pkgPath, pkg, { spaces: 2 })
-    await fse.writeJson(tuiPath, tui, { spaces: 2 })
 
-    const quotaConfig = await fse.pathExists(quotaPath)
-      ? await fse.readJson(quotaPath)
-      : {}
+    // Carry over any existing settings (new location first, then the legacy
+    // v4 file) and layer the recommended defaults on top. The edge defaults
+    // disable toasts and reset notifications and keep slash reports inline.
+    let quotaConfig = {}
+    if (await fse.pathExists(quotaPath)) {
+      quotaConfig = await fse.readJson(quotaPath)
+    } else if (await fse.pathExists(legacyQuotaPath)) {
+      quotaConfig = await fse.readJson(legacyQuotaPath)
+    }
 
     Object.assign(quotaConfig, quotaPreset.defaults)
 
     await fse.ensureDir(quotaDir)
     await fse.writeJson(quotaPath, quotaConfig, { spaces: 2 })
 
-    success('opencode-quota configured (manual setup)')
+    if (await fse.pathExists(legacyQuotaPath)) {
+      await fse.remove(legacyQuotaPath)
+      const legacyDir = path.dirname(legacyQuotaPath)
+      if ((await fse.readdir(legacyDir)).length === 0) {
+        await fse.remove(legacyDir)
+      }
+      info('Moved opencode-quota settings to opencode-quota/quota-toast.jsonc')
+    }
+
+    success('opencode-quota configured (popups and notifications disabled)')
     info('Restart OpenCode and run /quota to verify')
     return { optedIn: true, installed: true }
   } catch (err) {

package/cli/utils/copy.js

@@ -40,7 +40,6 @@ function isTemplateTest(relativePath) {
 export function isManagedContentPath(relativePath) {
   const normalized = relativePath.split(path.sep).join('/')
   if (normalized.startsWith('.opencode/plugins/')) return true
-  if (normalized === '.opencode/tui/pc-subagents.tsx') return true
   if (normalized.startsWith('.opencode/commands/') && !MARKER_COMMANDS.has(normalized)) return true
   return normalized === 'openspec/specs/.gitkeep' || normalized === 'openspec/changes/archive/.gitkeep'
 }

package/harness/.opencode/_gitignore

@@ -1,9 +1,9 @@
-node_modules
-harness-run.json
-harness.user.json
-harness-managed.json
-source-roots.json
-tmp/
-*-engineer.*.md
-agents/build.md
-agents/plan.md
+node_modules
+harness-run.json
+harness.user.json
+harness-managed.json
+source-roots.json
+tmp/
+*-engineer.*.md
+agents/build.md
+agents/plan.md

package/harness/.opencode/package.json

@@ -1,9 +1,5 @@
 {
   "dependencies": {
-    "@opencode-ai/plugin": "1.18.19",
-    "@mohak34/opencode-notifier": "0.2.8",
-    "@opentui/core": "0.5.6",
-    "@opentui/solid": "0.5.6",
-    "solid-js": "1.9.12"
+    "@opencode/plugin": "2.0.22"
   }
 }

package/harness/.opencode/plugins/pc-subagent-monitor.js

@@ -1,219 +1,184 @@
-// pc-subagent-monitor: tracks spawned subagents in .opencode/harness-run.json for
-// live TUI display and crash recovery, and holds a wave to agents.maxConcurrent.
+// pc-subagent-monitor: holds a spawn wave to agents.maxConcurrent and keeps a
+// live record of child sessions in .opencode/harness-run.json.
 //
-// It throws in exactly one case: to deny a spawn over the cap. Every other
-// failure, including its own bugs, is swallowed — a monitor that breaks the run
-// it is watching is worse than no monitor.
-
+// OpenCode 2 denies through the permission system, not by throwing from a tool
+// hook, so the cap is a `subagent` permission rule: an `evaluate` hook counts
+// the children of the asking session and denies the launch over the limit.
+//
+// Child sessions are observed from the event stream. V2 does not document the
+// event type strings (the payload schema is an opaque `string`), so the handler
+// is deliberately tolerant and, with PC_HARNESS_DEBUG set, prints every event
+// type once so the names can be pinned from a real run. Counting via the event
+// stream is the iteration-one mechanism; `ctx.session` in the plugin context is
+// not documented to expose `list`, so it is not used here.
+
+import { Plugin } from "@opencode/plugin"
 import fs from "node:fs/promises"
 import path from "node:path"
 
-// A spawn that has been allowed but whose session has not appeared yet. A wave
-// is one assistant turn, and opencode calls tool.execute.before for every
-// task() in that turn before the first child session exists, so counting live
-// sessions alone would let an entire wave through whatever the cap says.
-//
-// The slot is released when the session lands, and expires otherwise:
-// tool.execute.after never fires for a tool that threw, so a failed spawn must
-// not hold a slot for the rest of the run.
 const PENDING_TTL_MS = 15_000
 
-export const PcSubagentMonitor = async ({ directory, client }) => {
-  const root = directory || process.cwd()
-  const statePath = path.join(root, ".opencode", "harness-run.json")
-  const state = { updatedAt: null, agents: {} }
-  const pending = []
-
-  try {
-    const prev = JSON.parse(await fs.readFile(statePath, "utf-8"))
-    if (prev?.agents && typeof prev.agents === "object") {
-      for (const [id, entry] of Object.entries(prev.agents)) {
-        if (entry?.status === "running") entry.stale = true
-        state.agents[id] = entry
+export default Plugin.define({
+  id: "pc.subagent-monitor",
+  async setup(ctx) {
+    const root = ctx.location.directory || process.cwd()
+    const statePath = path.join(root, ".opencode", "harness-run.json")
+    const state = { updatedAt: null, agents: {} }
+    const pending = []
+    const seenTypes = new Set()
+    let capCache = null
+
+    try {
+      const prev = JSON.parse(await fs.readFile(statePath, "utf-8"))
+      if (prev?.agents && typeof prev.agents === "object") {
+        for (const [id, entry] of Object.entries(prev.agents)) {
+          if (entry?.status === "running") entry.stale = true
+          state.agents[id] = entry
+        }
       }
+    } catch {
+      // fresh start
     }
-  } catch {
-    // fresh start
-  }
-
-  let _modelsCache = null
-  async function loadModels() {
-    if (_modelsCache) return _modelsCache
-    const result = { build: null, fast: null, plan: null }
-    for (const file of ["harness.user.json", "harness.json"]) {
-      try {
-        const raw = await fs.readFile(path.join(root, ".opencode", file), "utf-8")
-        const { models = {} } = JSON.parse(raw)
-        for (const tier of ["build", "fast", "plan"]) {
-          if (!result[tier] && models[tier]) result[tier] = models[tier]
+
+    let persistScheduled = false
+    function persist() {
+      if (persistScheduled) return
+      persistScheduled = true
+      queueMicrotask(async () => {
+        persistScheduled = false
+        state.updatedAt = new Date().toISOString()
+        try {
+          await fs.mkdir(path.dirname(statePath), { recursive: true })
+          const tmpPath = `${statePath}.tmp`
+          await fs.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8")
+          await fs.rename(tmpPath, statePath)
+        } catch {
+          // best-effort
         }
-      } catch {
-        continue
-      }
+      })
     }
-    _modelsCache = result
-    return result
-  }
-
-  async function modelForAgent(agent) {
-    if (!agent) return null
-    const dotIdx = agent.lastIndexOf(".")
-    const tier = dotIdx !== -1 ? agent.slice(dotIdx + 1) : null
-    if (tier && ["build", "fast", "plan"].includes(tier)) {
-      const models = await loadModels()
-      return models[tier] ?? null
+
+    function pruneStale() {
+      for (const [id, entry] of Object.entries(state.agents)) {
+        if (entry?.stale) delete state.agents[id]
+      }
     }
-    return null
-  }
-
-  function parseTasks(title) {
-    if (!title) return []
-    const m = /^\s*([\d]+(?:\.[\d]+)*(?:\s*,\s*[\d]+(?:\.[\d]+)*)*)/.exec(title)
-    return m ? m[1].split(",").map(s => s.trim()) : []
-  }
-
-  // Debounced persist: coalesce rapid writes when multiple subagents spawn
-  // in the same microtask batch (e.g. a wave of 5 task() calls).
-  let _persistScheduled = false
-  async function persist() {
-    if (_persistScheduled) return
-    _persistScheduled = true
-    queueMicrotask(async () => {
-      _persistScheduled = false
-      state.updatedAt = new Date().toISOString()
+
+    async function maxConcurrent() {
+      if (capCache) return capCache
+      let configured = 3
       try {
-        await fs.mkdir(path.dirname(statePath), { recursive: true })
-        const tmpPath = `${statePath}.tmp`
-        await fs.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8")
-        await fs.rename(tmpPath, statePath)
+        const raw = await fs.readFile(path.join(root, ".opencode", "harness.json"), "utf-8")
+        const value = JSON.parse(raw)?.agents?.maxConcurrent
+        if (Number.isFinite(value)) configured = value
       } catch {
-        // best-effort
+        // no config yet; the CLI's own default is 3
       }
-    })
-  }
-
-  function sessionInfo(props) {
-    const info = props?.info ?? props ?? {}
-    return {
-      id: info.id ?? info.sessionID ?? props?.sessionID,
-      parentID: info.parentID ?? info.parentId,
-      agent: info.agent,
-      title: info.title,
+      capCache = Math.min(5, Math.max(1, Math.trunc(configured)))
+      return capCache
     }
-  }
 
-  function pruneStale() {
-    for (const [id, entry] of Object.entries(state.agents)) {
-      if (entry?.stale) delete state.agents[id]
+    function runningFor(parentID) {
+      return Object.values(state.agents)
+        .filter(entry => entry?.status === "running" && !entry.stale && entry.parentID === parentID)
+        .length
     }
-  }
 
-  let _capCache = null
-  async function maxConcurrent() {
-    if (_capCache) return _capCache
-    let configured = 3
-    try {
-      const raw = await fs.readFile(path.join(root, ".opencode", "harness.json"), "utf-8")
-      const value = JSON.parse(raw)?.agents?.maxConcurrent
-      if (Number.isFinite(value)) configured = value
-    } catch {
-      // no config yet; the CLI's own default is 3
-    }
-    _capCache = Math.min(5, Math.max(1, Math.trunc(configured)))
-    return _capCache
-  }
-
-  function runningFor(parentID) {
-    return Object.values(state.agents)
-      .filter(entry => entry?.status === "running" && !entry.stale && entry.parentID === parentID)
-      .length
-  }
-
-  function livePending(parentID) {
-    const now = Date.now()
-    for (let i = pending.length - 1; i >= 0; i--) {
-      if (now - pending[i].at > PENDING_TTL_MS) pending.splice(i, 1)
+    function livePending(parentID) {
+      const now = Date.now()
+      for (let i = pending.length - 1; i >= 0; i--) {
+        if (now - pending[i].at > PENDING_TTL_MS) pending.splice(i, 1)
+      }
+      return pending.filter(entry => entry.parentID === parentID).length
     }
-    return pending.filter(entry => entry.parentID === parentID).length
-  }
 
-  function releasePending(parentID) {
-    const index = pending.findIndex(entry => entry.parentID === parentID)
-    if (index !== -1) pending.splice(index, 1)
-  }
-
-  return {
-    // The cap was prose in pc-plan-apply ("you enforce the cap"), which asked
-    // the lead to count its own parallel calls. Six disjoint groups and a cap
-    // of three is exactly the moment a model stops counting.
-    "tool.execute.before": async (input) => {
-      if (input?.tool !== "task") return
+    function releasePending(parentID) {
+      const index = pending.findIndex(entry => entry.parentID === parentID)
+      if (index !== -1) pending.splice(index, 1)
+    }
 
+    // The cap was prose in pc-plan-apply ("you enforce the cap"), which asked the
+    // lead to count its own parallel calls. Six disjoint groups and a cap of
+    // three is exactly the moment a model stops counting.
+    await ctx.permission.hook("evaluate", async event => {
+      if (event.action !== "subagent") return
       let cap
       let live
       try {
         pruneStale()
         cap = await maxConcurrent()
-        live = runningFor(input.sessionID) + livePending(input.sessionID)
+        live = runningFor(event.sessionID) + livePending(event.sessionID)
         if (live < cap) {
-          pending.push({ parentID: input.sessionID, at: Date.now() })
+          pending.push({ parentID: event.sessionID, at: Date.now() })
           return
         }
       } catch (error) {
-        // Compute inside the try, deny outside it, so this catch can never
-        // swallow the one exception the hook is meant to raise.
         console.error(`[harness] concurrency check failed open: ${error?.message}`)
         return
       }
+      deny(event, live, cap)
+    })
 
-      throw new Error(
+    function deny(event, live, cap) {
+      event.effect = "deny"
+      event.message =
         `[harness] ${live} subagents are already in flight and agents.maxConcurrent is ${cap}.\n` +
-        "Collect a running worker before spawning another. A denied spawn is not a failed task: re-issue it in the next wave.",
-      )
-    },
-    event: async ({ event }) => {
+        "Collect a running worker before spawning another. A denied spawn is not a failed task: re-issue it in the next wave."
+    }
+
+    function extractSession(event) {
+      const data = event?.data ?? event?.properties ?? event ?? {}
+      const info = data?.info ?? data?.session ?? data ?? {}
+      const id = info.id ?? info.sessionID ?? data.sessionID
+      const parentID = info.parentID ?? info.parentId ?? data.parentID
+      const status = info.status ?? data.status
+      return { id, parentID, agent: info.agent ?? null, title: info.title ?? null, status }
+    }
+
+    const controller = new AbortController()
+    void (async () => {
       try {
-        if (!event?.type?.startsWith("session.")) return
-        const info = sessionInfo(event.properties)
-        if (!info.id) return
-
-        if (event.type === "session.created" && info.parentID) {
-          pruneStale()
-          // The spawn this session came from no longer needs its pending slot;
-          // the session itself is now what the cap counts.
-          releasePending(info.parentID)
-
-          state.agents[info.id] = {
-            agent: info.agent ?? null,
-            parentID: info.parentID,
-            model: await modelForAgent(info.agent),
-            tasks: parseTasks(info.title),
-            title: info.title ?? null,
-            status: "running",
-            startedAt: new Date().toISOString(),
-            endedAt: null,
+        for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+          try {
+            const type = String(event?.type ?? "")
+            if (process.env.PC_HARNESS_DEBUG && type && !seenTypes.has(type)) {
+              seenTypes.add(type)
+              console.error(`[pc-subagent-monitor] event: ${type}`)
+            }
+            const { id, parentID, agent, title, status } = extractSession(event)
+            if (!id || !parentID) continue
+
+            if (status === "running" || /created|started/.test(type)) {
+              pruneStale()
+              releasePending(parentID)
+              state.agents[id] = {
+                agent,
+                parentID,
+                title,
+                status: "running",
+                startedAt: new Date().toISOString(),
+                endedAt: null,
+              }
+              await persist()
+              continue
+            }
+
+            const entry = state.agents[id]
+            if (!entry) continue
+            if (status === "idle" || /idle|completed|succeeded|failed/.test(type)) {
+              entry.status = "done"
+              entry.endedAt = new Date().toISOString()
+              await persist()
+            }
+          } catch {
+            // monitoring must never disrupt the run
           }
-          await persist()
-          return
-        }
-
-        const entry = state.agents[info.id]
-        if (!entry) return
-
-        if (event.type === "session.idle" && entry.status === "running") {
-          entry.status = "done"
-          entry.endedAt = new Date().toISOString()
-          await persist()
-          client?.tui?.showToast?.({
-            body: {
-              message: `subagent done: ${entry.title ?? info.id}`,
-              variant: "success",
-            },
-          })
         }
       } catch {
-        // monitoring must never disrupt the run
+        // stream aborted on unload
       }
-    },
-  }
-}
+    })()
+
+    return () => controller.abort()
+  },
+})