geneseed 2.0.0

package/adapters/opencode/plugins/geneseed-ponytail.js

@@ -0,0 +1,148 @@
+// Geneseed — OpenCode ponytail plugin (sustained minimal-code mode).
+//
+// The `ponytail` skill (src/skills/ponytail.md) is the invokable, themed source of
+// truth for the "laziest solution that works" discipline. This plugin is its
+// SUSTAINED counterpart: once you opt in with `/ponytail lite|full|ultra`, it appends
+// a compact ruleset to the system prompt EVERY turn so the agent does not drift back
+// to over-building mid-session, and persists the level across turns. Mirrors the
+// upstream ponytail OpenCode plugin (DietrichGebert/ponytail) but is self-contained —
+// no shared `hooks/` module to require, no external state convention.
+//
+// OPT-IN by default (Geneseed treats ponytail as a skill, not an always-on Law): the
+// mode starts at `off` and nothing is injected until you switch it on. Set
+// GENESEED_PONYTAIL=lite|full|ultra to make a level the default for new installs, or
+// GENESEED_PONYTAIL=off (the default) to keep it dormant until asked.
+//
+// Two hooks, mirroring the upstream design:
+//   - experimental.chat.system.transform  — append the ruleset at the active level.
+//   - command.execute.before              — intercept `/ponytail <level>` and persist
+//     it; the switch applies from the NEXT turn (the transform reads what the command
+//     wrote). Levels: lite | full | ultra | off.
+//
+// State lives beside OpenCode's config as `.geneseed-ponytail` (one word: the level),
+// so it survives restarts. Quiet by default; GENESEED_DEBUG=1 logs switches. Every
+// failure is swallowed — it never blocks a session. Experimental hooks; on a build
+// that lacks `chat.system.transform` the plugin simply never injects (the skill still
+// covers the invokable path).
+
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+const MODES = new Set(["lite", "full", "ultra", "off"])
+const DEBUG = !!process.env.GENESEED_DEBUG
+function log(msg) { if (DEBUG) console.error(`[geneseed-ponytail] ${msg}`) }
+
+// --- pure helpers (exported for tests) ---------------------------------------
+
+// Normalise a raw mode string to a known level, or null if unrecognised. Tolerant of
+// surrounding whitespace and case; "normal"/"stop"/"none" are spelled as `off`.
+function normalizeMode(raw) {
+  const s = String(raw ?? "").trim().toLowerCase()
+  if (!s) return null
+  if (s === "normal" || s === "stop" || s === "none" || s === "disable") return "off"
+  return MODES.has(s) ? s : null
+}
+
+// The default level when no switch has been made yet — $GENESEED_PONYTAIL, else `off`.
+// Opt-in: Geneseed keeps ponytail dormant until the user asks for it.
+function defaultMode() {
+  return normalizeMode(process.env.GENESEED_PONYTAIL) || "off"
+}
+
+// The compact ruleset appended to the system prompt for a non-off level. Kept lean on
+// purpose — it rides every turn, so ponytail eats its own dog food. null when off.
+function ponytailInstructions(mode) {
+  if (mode === "off" || !MODES.has(mode)) return null
+  const ladder =
+    "Before writing code, climb the ladder and stop at the first rung that holds: " +
+    "(1) does this need to exist at all? speculative need → skip it, say so in one line; " +
+    "(2) stdlib does it? use it; (3) native platform feature covers it? prefer it; " +
+    "(4) an already-installed dependency solves it? use it, never add a new one for what a few lines do; " +
+    "(5) can it be one line? one line; (6) only then the minimum code that works."
+  const rules =
+    "No abstraction with one implementation, no scaffolding \"for later\", deletion over addition, " +
+    "fewest files, shortest working diff. Mark deliberate shortcuts with a `ponytail:` comment naming " +
+    "the ceiling and upgrade path. Non-trivial logic leaves ONE runnable check. Never simplify away " +
+    "input validation at trust boundaries, error handling that prevents data loss, security, " +
+    "accessibility basics, hardware calibration, or anything explicitly requested. Output code first, " +
+    "then at most three short lines: skipped X, add when Y."
+  const level = {
+    lite: "LITE: build what's asked, but name the lazier alternative in one line and let the user pick.",
+    full: "FULL: enforce the ladder. Stdlib and native first, shortest diff, shortest explanation.",
+    ultra: "ULTRA: YAGNI extremist. Ship the one-liner and challenge the rest of the requirement in the same breath.",
+  }[mode]
+  return `PONYTAIL MODE — write the laziest solution that works (lazy = efficient, not careless).\n${level}\n${ladder}\n${rules}`
+}
+
+// --- state (flag file beside the OpenCode config) ----------------------------
+
+function statePath() {
+  // Same precedence as build._opencode_config_dir() and activity's configBase()
+  // ($OPENCODE_CONFIG_DIR > $XDG_CONFIG_HOME/opencode > ~/.config/opencode) — an
+  // XDG-only check diverges whenever $OPENCODE_CONFIG_DIR is set, so the /ponytail
+  // toggle would land in a different dir than the console reads.
+  const cfg =
+    process.env.OPENCODE_CONFIG_DIR ||
+    path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "opencode")
+  return path.join(cfg, ".geneseed-ponytail")
+}
+
+function readMode() {
+  try {
+    return normalizeMode(fs.readFileSync(statePath(), "utf8")) || defaultMode()
+  } catch {
+    return defaultMode()
+  }
+}
+
+function writeMode(mode) {
+  try {
+    const p = statePath()
+    fs.mkdirSync(path.dirname(p), { recursive: true })
+    fs.writeFileSync(p, mode)
+    return true
+  } catch (err) {
+    log(`could not persist mode: ${err?.message ?? err}`)
+    return false
+  }
+}
+
+// --- plugin ------------------------------------------------------------------
+
+export const GeneseedPonytail = async () => ({
+  // Append the ruleset to the system prompt every turn at the active level.
+  "experimental.chat.system.transform": async (_input, output) => {
+    try {
+      const mode = readMode()
+      const text = ponytailInstructions(mode)
+      if (!text) return
+      if (Array.isArray(output?.system)) output.system.push(text)
+    } catch (err) {
+      log(`transform error: ${err?.message ?? err}`)
+    }
+  },
+
+  // Persist `/ponytail <level>`; the next turn's injection follows it. A bare
+  // `/ponytail` with no argument means `full` (the conventional on switch).
+  "command.execute.before": async (input) => {
+    try {
+      if (!input || input.command !== "ponytail") return
+      const arg = (input.arguments || "").trim()
+      const mode = normalizeMode(arg) || (arg ? null : "full")
+      if (!mode) { log(`ignored unknown level: ${arg}`); return }
+      writeMode(mode)
+      log(`ponytail ${mode}`)
+    } catch (err) {
+      log(`command error: ${err?.message ?? err}`)
+    }
+  },
+})
+
+// ponytail: OpenCode treats every export in a plugin file as a plugin and rejects
+// any that isn't a function — a bare helper export crashes startup ("null is not an
+// object") or logs "not a function". Hang the test helpers off the factory instead;
+// they ride along for `import`, invisible to the loader. Upgrade path: none needed.
+Object.assign(GeneseedPonytail, { normalizeMode, defaultMode, ponytailInstructions })
+
+export default GeneseedPonytail

package/adapters/opencode/plugins/geneseed-workflow.js

@@ -0,0 +1,183 @@
+// Geneseed — OpenCode workflow plugin.
+//
+// Registers ONE custom tool, `workflow`, that runs saved, code-driven orchestration
+// scripts from the sibling `workflows/` dir (`.opencode/workflows/` in a per-repo
+// emit, `<config>/workflows/` global). The model calls `workflow({ name, args })`;
+// the named script — not the model — drives the control flow, spawning subagents via
+// the runtime (`_runtime.js`). This is the deterministic counterpart to the
+// model-driven `council` / `parallel-agents` skills. See
+// adapters/opencode/workflows/_runtime.js and
+// docs/specs/2026-06-09-opencode-workflow-primitive.md.
+//
+// Saved workflows ONLY — no model-authored/eval'd scripts (v1). Synchronous: the tool
+// blocks until the workflow finishes; a phase-by-phase trace and the full result are
+// written to `.geneseed/workflow-runs/<runId>.log`. Every failure is contained and
+// reported, never thrown into the session.
+//
+// Quiet by default; GENESEED_DEBUG=1 logs to stderr. GENESEED_WORKFLOWS_DIR overrides
+// where saved workflows are loaded from.
+
+import { promises as fs } from "node:fs"
+import * as path from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const DEBUG = !!process.env.GENESEED_DEBUG
+function dlog(m) { if (DEBUG) console.error(`[geneseed-workflow] ${m}`) }
+
+const __dir = path.dirname(fileURLToPath(import.meta.url))
+const WORKFLOWS_DIR = process.env.GENESEED_WORKFLOWS_DIR
+  ? path.resolve(process.env.GENESEED_WORKFLOWS_DIR)
+  : path.resolve(__dir, "..", "workflows")
+
+const NAME_RE = /^[a-z0-9][a-z0-9_-]*$/i
+
+async function listWorkflows() {
+  try {
+    const entries = await fs.readdir(WORKFLOWS_DIR)
+    return entries
+      .filter((f) => f.endsWith(".js") && !f.startsWith("_"))
+      .map((f) => f.slice(0, -3))
+      .sort()
+  } catch { return [] }
+}
+
+async function loadWorkflow(name) {
+  if (!NAME_RE.test(name)) throw new Error(`invalid workflow name: ${name}`)
+  const file = path.join(WORKFLOWS_DIR, `${name}.js`)
+  const rel = path.relative(WORKFLOWS_DIR, file)
+  if (rel.startsWith("..") || path.isAbsolute(rel)) throw new Error("workflow path escapes workflows dir")
+  await fs.access(file)
+  // Cache-bust: Node's ESM cache holds the first import for the process lifetime,
+  // so an edited workflow script would otherwise run stale until OpenCode restarts.
+  const mod = await import(pathToFileURL(file).href + "?t=" + Date.now())
+  const run = mod.default || mod.run
+  if (typeof run !== "function") throw new Error(`workflow "${name}" has no default/run export`)
+  return { meta: mod.meta || { name }, run }
+}
+
+function nowStamp() {
+  // Plugin-side only (NOT inside a workflow script) — a run id needs wall-clock; the
+  // runtime itself stays clock-free for reproducibility.
+  const d = new Date()
+  const p = (n) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`
+}
+
+function safeJson(v) {
+  try { return JSON.stringify(v, null, 2) } catch { return String(v) }
+}
+
+function summarize(name, result, stats, tracePath) {
+  const head = `workflow "${name}" complete — ${stats.agentCount} agent run(s)` +
+    (stats.spent ? `, ~${stats.spent} output tokens` : "") +
+    (stats.phases.length ? `, phases: ${stats.phases.join(" → ")}` : "")
+  let body = safeJson(result)
+  if (body.length > 2000) body = body.slice(0, 2000) + `\n… (truncated — full result in ${tracePath})`
+  return `${head}\n\nResult:\n${body}\n\nTrace: ${tracePath}`
+}
+
+async function writeTrace(rootDir, runId, lines) {
+  if (!rootDir) return "(no trace file — unknown working dir)"
+  try {
+    const dir = path.join(rootDir, ".geneseed", "workflow-runs")
+    await fs.mkdir(dir, { recursive: true })
+    const file = path.join(dir, `${runId}.log`)
+    await fs.writeFile(file, lines.join("\n") + "\n", "utf8")
+    return file
+  } catch (e) { dlog(`trace write failed: ${e?.message || e}`); return "(trace write failed)" }
+}
+
+export const GeneseedWorkflow = async (ctx) => {
+  const { client, directory, worktree } = ctx
+  const rootDir = worktree || directory
+  let toolHelper
+  try { ({ tool: toolHelper } = await import("@opencode-ai/plugin")) }
+  catch { dlog("@opencode-ai/plugin tool helper unavailable — registering a raw tool def") }
+
+  // One-line load banner (always on) so a restart visibly confirms the plugin loaded
+  // and the `workflow` tool is registered — and WARNS if this OpenCode build lacks the
+  // custom-tool helper (the silent "tool never appears" failure).
+  try {
+    const names = await listWorkflows()
+    const warn = toolHelper ? ""
+      : " — WARN: @opencode-ai/plugin 'tool' helper missing; the workflow tool may NOT register on this OpenCode version"
+    console.error(`[geneseed-workflow] loaded — tool 'workflow' registered, ${names.length} workflow(s) [${names.join(", ") || "none"}] from ${WORKFLOWS_DIR}${warn}`)
+  } catch (e) { console.error(`[geneseed-workflow] loaded but could not list workflows: ${e?.message || e}`) }
+
+  // Normalize the `args` parameter. OpenCode's tool layer can deliver a structured
+  // object param as a JSON STRING (or drop it) when the schema is untyped — so coerce
+  // a string back to an object and reject non-object shapes to `{}`. Without this, the
+  // workflow script's `args` arrives empty and every `args.foo` read is undefined.
+  const normalizeArgs = (raw) => {
+    let a = raw ?? {}
+    if (typeof a === "string") {
+      try { a = JSON.parse(a) } catch { a = {} }
+    }
+    if (a == null || typeof a !== "object" || Array.isArray(a)) a = {}
+    return a
+  }
+
+  const execute = async (argv) => {
+    const name = (argv?.name || "").trim()
+    const available = await listWorkflows()
+    if (!name) {
+      return `Available workflows: ${available.join(", ") || "(none found in " + WORKFLOWS_DIR + ")"}.\n` +
+        `Run one with workflow({ name, args }).`
+    }
+    if (!available.includes(name)) {
+      return `Unknown workflow "${name}". Available: ${available.join(", ") || "(none)"}.`
+    }
+
+    let wf
+    try { wf = await loadWorkflow(name) }
+    catch (e) { return `Failed to load workflow "${name}": ${e?.message || e}` }
+
+    const runId = `${name}-${nowStamp()}`
+    const lines = []
+    const sink = (line) => lines.push(line)
+    sink(`# workflow ${name} — ${wf.meta?.description || ""}`)
+
+    // Lazily import the runtime so a broken runtime never blocks tool registration.
+    let createRuntime
+    try { ({ createRuntime } = await import(pathToFileURL(path.join(WORKFLOWS_DIR, "_runtime.js")).href + "?t=" + Date.now())) }
+    catch (e) { return `Workflow runtime unavailable: ${e?.message || e}` }
+
+    const rt = createRuntime({ client, directory, worktree, args: normalizeArgs(argv?.args), log: sink })
+    let result, failed = null
+    try { result = await wf.run(rt) }
+    catch (e) { failed = e; sink(`✗ workflow error: ${e?.stack || e?.message || e}`) }
+
+    const stats = rt._stats()
+    sink(`\n# done — ${stats.agentCount} agent run(s), ~${stats.spent} output tokens`)
+    if (!failed) sink(`# result:\n${safeJson(result)}`)
+    const tracePath = await writeTrace(rootDir, runId, lines)
+
+    if (failed) return `Workflow "${name}" failed: ${failed?.message || failed}\nTrace: ${tracePath}`
+    return summarize(name, result, stats, tracePath)
+  }
+
+  const def = {
+    description:
+      "Run a saved, code-driven Geneseed workflow that orchestrates subagents " +
+      "deterministically (parallel fan-out, find→verify pipeline, phased handoff). " +
+      "Call with no name to list available workflows.",
+    args: toolHelper
+      ? {
+          name: toolHelper.schema.string().optional().describe("saved workflow name; omit to list available"),
+          // Keep this `any()` — it's the only param shape known to register cleanly on
+          // this OpenCode build (record()/object schemas wedged tool registration → every
+          // session message stuck "queued"). The provider may still deliver the object as
+          // a JSON string or empty; normalizeArgs() in execute() recovers both cases.
+          args: toolHelper.schema.any().optional().describe("inputs passed to the workflow script as `args` (object, or a JSON object string)"),
+        }
+      : {
+          name: { type: "string", description: "saved workflow name; omit to list available" },
+          args: { type: "object", description: "inputs passed to the workflow script as `args`" },
+        },
+    async execute(argv) { return execute(argv) },
+  }
+
+  return { tool: { workflow: toolHelper ? toolHelper(def) : def } }
+}
+
+export default GeneseedWorkflow

package/adapters/opencode/workflows/_runtime.js

@@ -0,0 +1,277 @@
+// Geneseed — deterministic workflow runtime (OpenCode).
+//
+// The API handed to every saved workflow script: agent(), parallel(), pipeline(),
+// phase(), log(), budget, args. It is code-driven orchestration — the script, not
+// the model, decides the control flow. Child work runs as real OpenCode sessions
+// spawned through the plugin's SDK `client`; orchestration logic here is pure and
+// unit-testable against a mock client (see tests/workflow_runtime.test.mjs).
+//
+// SDK binding note: OpenCode's session API shape shifts between versions, so the
+// child-session helpers below are defensive (envelope/`data` unwrap, multiple parts
+// shapes, graceful degradation). The orchestration primitives do not depend on it.
+//
+// Determinism: this runtime uses no Date.now()/Math.random(), so a run is a pure
+// function of (workflow, args, child replies). Saved scripts SHOULD likewise avoid
+// wall-clock/random for reproducibility (pass timestamps via args). This is an
+// authoring convention — imported modules cannot have their globals shadowed — not a
+// hard sandbox guard. See docs/specs/2026-06-09-opencode-workflow-primitive.md.
+
+import * as os from "node:os"
+
+const DEBUG = !!process.env.GENESEED_DEBUG
+function dlog(m) { if (DEBUG) console.error(`[geneseed-workflow] ${m}`) }
+
+export const MAX_AGENTS = 1000
+export const MAX_ITEMS = 4096
+
+export function concurrencyCap() {
+  let cpu = 4
+  try { cpu = (os.cpus() || []).length || 4 } catch {}
+  return Math.max(1, Math.min(16, cpu - 2))
+}
+
+// A tiny promise-pool limiter: at most `max` in flight; the rest queue.
+export function createLimiter(max) {
+  let active = 0
+  const queue = []
+  const pump = () => {
+    if (active >= max || queue.length === 0) return
+    active++
+    const { fn, resolve, reject } = queue.shift()
+    Promise.resolve().then(fn).then(
+      (v) => { active--; resolve(v); pump() },
+      (e) => { active--; reject(e); pump() },
+    )
+  }
+  return (fn) => new Promise((resolve, reject) => { queue.push({ fn, resolve, reject }); pump() })
+}
+
+// ---- structured-output validation -------------------------------------------
+// Accepts a Zod schema (.safeParse), a predicate fn (value) => true | "error", or a
+// tiny JSON-schema-like descriptor ({ type, required, properties }).
+export function validateSchema(schema, value) {
+  if (!schema) return { ok: true, value }
+  if (typeof schema === "function") {
+    const r = schema(value)
+    if (r === true) return { ok: true, value }
+    return { ok: false, error: typeof r === "string" ? r : "predicate rejected value" }
+  }
+  if (typeof schema.safeParse === "function") {
+    const r = schema.safeParse(value)
+    return r.success
+      ? { ok: true, value: r.data }
+      : { ok: false, error: r.error?.message || "schema mismatch" }
+  }
+  const t = schema.type
+  if (t === "array") return Array.isArray(value) ? { ok: true, value } : { ok: false, error: "expected array" }
+  if (t === "object" || schema.properties || schema.required) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return { ok: false, error: "expected object" }
+    for (const k of (schema.required || [])) if (!(k in value)) return { ok: false, error: `missing key: ${k}` }
+    return { ok: true, value }
+  }
+  if (t && typeof value !== t) return { ok: false, error: `expected ${t}` }
+  return { ok: true, value }
+}
+
+// First balanced {...} or [...] span in a string (string-literal aware).
+function sliceBalanced(text) {
+  const start = (() => {
+    const a = text.indexOf("{"), b = text.indexOf("[")
+    if (a < 0) return b
+    if (b < 0) return a
+    return Math.min(a, b)
+  })()
+  if (start < 0) return null
+  const open = text[start], close = open === "{" ? "}" : "]"
+  let depth = 0, inStr = false, esc = false
+  for (let i = start; i < text.length; i++) {
+    const c = text[i]
+    if (inStr) {
+      if (esc) esc = false
+      else if (c === "\\") esc = true
+      else if (c === '"') inStr = false
+    } else if (c === '"') inStr = true
+    else if (c === open) depth++
+    else if (c === close) { depth--; if (depth === 0) return text.slice(start, i + 1) }
+  }
+  return null
+}
+
+export function extractJson(text) {
+  if (typeof text !== "string") return undefined
+  const candidates = []
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i)
+  if (fence) candidates.push(fence[1].trim())
+  candidates.push(text.trim())
+  const braced = sliceBalanced(text)
+  if (braced) candidates.push(braced)
+  for (const c of candidates) {
+    try { return JSON.parse(c) } catch { /* try next */ }
+  }
+  return undefined
+}
+
+// ---- defensive SDK helpers --------------------------------------------------
+function unwrap(res) {
+  if (res && typeof res === "object" && "data" in res && res.data &&
+      res.id === undefined && res.parts === undefined) return res.data
+  return res
+}
+function sessionId(created) {
+  const c = unwrap(created)
+  return c?.id ?? c?.sessionID ?? c?.session?.id
+}
+function partsText(parts) {
+  if (!Array.isArray(parts)) return ""
+  return parts
+    .filter((p) => p && (p.type === "text" || typeof p.text === "string"))
+    .map((p) => p.text || "")
+    .join("\n")
+    .trim()
+}
+async function lastAssistantText(client, sid) {
+  try {
+    const res = await client.session.messages({ path: { id: sid } })
+    const u = unwrap(res)
+    const list = Array.isArray(res) ? res : (Array.isArray(u) ? u : (u?.data ?? []))
+    for (let i = list.length - 1; i >= 0; i--) {
+      const m = list[i]
+      const role = m?.info?.role ?? m?.role
+      if (role && role !== "assistant") continue
+      const t = partsText(m?.parts ?? m?.info?.parts ?? [])
+      if (t) return t
+    }
+  } catch (e) { dlog(`messages read failed: ${e?.message || e}`) }
+  return ""
+}
+function usageFrom(res) {
+  const r = unwrap(res)
+  const tok = r?.tokens ?? r?.info?.tokens ?? r?.assistant?.tokens
+  return { input: Number(tok?.input ?? 0) || 0, output: Number(tok?.output ?? 0) || 0 }
+}
+
+async function runChildSession(client, { prompt, agent, model, title }) {
+  if (!client?.session?.create || !client?.session?.prompt) {
+    throw new Error("OpenCode SDK session API unavailable")
+  }
+  let created
+  try { created = await client.session.create({ body: { title: title || "geneseed-workflow" } }) }
+  catch { created = await client.session.create() }
+  const sid = sessionId(created)
+  if (!sid) throw new Error("could not create child session")
+  try {
+    const body = { parts: [{ type: "text", text: prompt }] }
+    if (agent) body.agent = agent
+    if (model) body.model = model
+    let res = null
+    try { res = await client.session.prompt({ path: { id: sid }, body }) }
+    catch (e) { dlog(`prompt failed: ${e?.message || e}`) }
+    const r = unwrap(res)
+    let text = partsText(r?.parts ?? r?.info?.parts ?? [])
+    if (!text) text = await lastAssistantText(client, sid)
+    return { text, usage: usageFrom(res) }
+  } finally {
+    try { await client.session.delete?.({ path: { id: sid } }) } catch { /* best effort */ }
+  }
+}
+
+// ---- the runtime ------------------------------------------------------------
+export function createRuntime(ctx) {
+  const { client, directory, worktree, log: sink } = ctx
+  const args = ctx.args || {}
+  const cap = ctx.concurrency || concurrencyCap()
+  const limit = createLimiter(cap)
+  let agentCount = 0
+  let spent = 0
+  const budgetTotal =
+    (args && typeof args.budget === "number") ? args.budget
+    : (typeof ctx.budget === "number" ? ctx.budget : null)
+  const phases = []
+  const trace = []
+  const emit = (line) => { trace.push(line); if (typeof sink === "function") sink(line) }
+
+  // Budget meters OUTPUT tokens only (deliberate, per the v1 spec): output is what
+  // the workflow author controls via prompt design; input varies with repo size and
+  // would make the same script exhaust wildly different budgets across machines.
+  const budget = {
+    get total() { return budgetTotal },
+    spent: () => spent,
+    remaining: () => (budgetTotal == null ? Infinity : Math.max(0, budgetTotal - spent)),
+  }
+
+  async function spawn(prompt, opts) {
+    return limit(() => runChildSession(client, {
+      prompt, agent: opts.agent, model: opts.model, title: `geneseed-wf:${opts.label}`,
+    }))
+  }
+
+  async function agent(prompt, opts = {}) {
+    if (agentCount >= MAX_AGENTS) throw new Error(`workflow agent cap (${MAX_AGENTS}) exceeded`)
+    if (budgetTotal != null && spent >= budgetTotal) {
+      throw new Error(`workflow token budget (${budgetTotal}) exhausted`)
+    }
+    agentCount++
+    const label = opts.label || String(prompt).slice(0, 40)
+    emit(`· agent: ${label}`)
+    let out
+    try { out = await spawn(prompt, { ...opts, label }) }
+    catch (e) { emit(`✗ agent failed: ${label} — ${e?.message || e}`); return null }
+    spent += out.usage?.output || 0
+    if (!opts.schema) return out.text
+
+    let lastErr = "no JSON found in reply"
+    for (let attempt = 0; attempt <= 2; attempt++) {
+      const parsed = extractJson(out.text)
+      if (parsed !== undefined) {
+        const v = validateSchema(opts.schema, parsed)
+        if (v.ok) return v.value
+        lastErr = v.error
+      }
+      if (attempt === 2) break
+      emit(`↻ retry ${label} (schema): ${lastErr}`)
+      try {
+        out = await spawn(
+          `${prompt}\n\nYour previous reply did not satisfy the required schema (${lastErr}). ` +
+          `Reply with ONLY a single valid JSON value — no prose, no code fence.`,
+          { ...opts, label: `${label}:retry${attempt + 1}` },
+        )
+        spent += out.usage?.output || 0
+      } catch (e) { lastErr = String(e?.message || e); break }
+    }
+    emit(`✗ schema unmet: ${label} — ${lastErr}`)
+    return null
+  }
+
+  function phase(title) { phases.push(title); emit(`\n=== phase: ${title} ===`) }
+  function log(msg) { emit(`  ${msg}`) }
+
+  // BARRIER fan-out: awaits all thunks. A throwing thunk resolves to null.
+  async function parallel(thunks) {
+    if (!Array.isArray(thunks)) throw new Error("parallel() needs an array of thunks")
+    if (thunks.length > MAX_ITEMS) throw new Error(`parallel() item cap (${MAX_ITEMS}) exceeded`)
+    return Promise.all(thunks.map((fn) =>
+      Promise.resolve().then(fn).catch((e) => { emit(`✗ parallel unit: ${e?.message || e}`); return null })))
+  }
+
+  // NO-BARRIER staged flow: each item runs all stages independently. A throwing
+  // stage drops that item to null and skips its remaining stages.
+  async function pipeline(items, ...stages) {
+    if (!Array.isArray(items)) throw new Error("pipeline() needs an array of items")
+    if (items.length > MAX_ITEMS) throw new Error(`pipeline() item cap (${MAX_ITEMS}) exceeded`)
+    return Promise.all(items.map(async (item, i) => {
+      let acc = item
+      for (let s = 0; s < stages.length; s++) {
+        try { acc = await stages[s](acc, item, i) }
+        catch (e) { emit(`✗ pipeline item ${i} stage ${s}: ${e?.message || e}`); return null }
+      }
+      return acc
+    }))
+  }
+
+  return {
+    agent, parallel, pipeline, phase, log, budget, args, directory, worktree,
+    _stats: () => ({ agentCount, spent, cap, phases: [...phases], trace: [...trace] }),
+  }
+}
+
+export default createRuntime

package/adapters/opencode/workflows/council.js

@@ -0,0 +1,64 @@
+// council — the `council` skill as deterministic code.
+//
+// Seats the standing stance agents, gathers their steelmanned positions in parallel
+// (each in its own isolated context, no groupthink), then a neutral chair synthesises
+// a verdict and preserves the strongest dissent. The model-driven `council` skill asks
+// the agent to convene seats in prose; this runs the same shape on rails.
+//
+// args: { motion?: string, question?: string, seats?: string[] }
+//   motion  — the decision/change/claim under debate (required).
+//   seats   — optional subset of seat roles to convene (default: the core six).
+
+export const meta = {
+  name: "council",
+  description: "Council debate as code: stance agents argue in parallel, a chair returns a verdict + preserved dissent.",
+  phases: [{ title: "Positions" }, { title: "Synthesis" }],
+}
+
+// [role, charter] — role doubles as the OpenCode subagent name (Geneseed emits these).
+const SEATS = [
+  ["advocate", "the strongest case FOR the motion — the prize, the cost of inaction"],
+  ["skeptic", "devil's advocate — failure modes, hidden assumptions, why NOT"],
+  ["pragmatist", "cost, effort, and complexity weighed against the payoff (YAGNI)"],
+  ["steward", "long-term architecture, technical debt, and maintainability"],
+  ["operator", "running it in production — reliability, on-call, operational cost"],
+  ["empiricist", "every claim held to evidence; what would prove or disprove it"],
+]
+
+export default async function run(rt) {
+  const { agent, parallel, phase, log, args } = rt
+  const motion = args?.motion || args?.question
+  if (!motion) return { error: "pass args.motion (the decision, change, or claim to debate)" }
+
+  const wanted = Array.isArray(args?.seats) && args.seats.length ? args.seats : null
+  const seats = wanted ? SEATS.filter(([role]) => wanted.includes(role)) : SEATS
+  if (!seats.length) {
+    return { error: `no seats matched ${JSON.stringify(wanted)} — valid: ${SEATS.map(([r]) => r).join(", ")}` }
+  }
+  if (wanted && seats.length < wanted.length) {
+    log(`ignored unknown seat name(s): ${wanted.filter((w) => !SEATS.some(([r]) => r === w)).join(", ")}`)
+  }
+
+  phase("Positions")
+  const briefs = (await parallel(seats.map(([role, charter]) => () =>
+    agent(
+      `You are the ${role} on a decision council. Motion: "${motion}".\n` +
+      `Argue ONLY this stance: ${charter}. Give a tight, steelmanned brief — ` +
+      `no hedging, no strawmen.`,
+      { label: `seat:${role}`, phase: "Positions", agent: role },
+    ).then((text) => ({ role, text }))))).filter((b) => b && b.text)
+
+  phase("Synthesis")
+  const dossier = briefs.map((b) => `### ${b.role}\n${b.text}`).join("\n\n")
+  const verdict = await agent(
+    `You are the neutral chair of a decision council. Motion: "${motion}".\n\n` +
+    `The seat briefs:\n\n${dossier}\n\n` +
+    `Synthesise in a neutral voice: state the verdict and its reasoning, record the ` +
+    `single strongest surviving dissent verbatim, list what would change the verdict, ` +
+    `and name one next action. The council advises — do not write code or push anything.`,
+    { label: "chair", phase: "Synthesis" },
+  )
+
+  log(`debated "${motion}" across ${briefs.length} seat(s)`)
+  return { motion, seats: seats.map(([r]) => r), verdict, briefs }
+}