trans-genderian-orchestra 0.1.0

package/README.md

@@ -0,0 +1,392 @@
+# trans-genderian-orchestra
+
+TGO — a thin multi-agent orchestration plugin for [OpenCode](https://opencode.ai).
+
+Configuration-first: routing, delegation, and seat behavior live in config (agent prompt files, permission graph, presets); a thin plugin core enforces lifecycle and state only.
+
+## Layout
+
+```
+src/
+  plugin.ts     thin core: loads, validates config, registers the hook slots
+               (board, concision, preset config hook, session reconciliation,
+               task-fit rejection)
+  config.ts     zod schema for plugin options + <1000-token seat-prompt budget
+  build.ts      template renderer: folds house-style, AGENTS merge, global config merge
+  permissions.ts frontmatter parser + per-seat permission-graph report
+  board.ts      Background Job Board (hook #1): beads renderer + thin live-state shim
+  concision.ts  Always-on concision (hook #4): instruction builder + per-turn system append
+  session.ts    Session reconciliation (hook #2): live-state shim sync from session events
+  fit.ts        Task-fit rejection (hook #3): lane-rejection → REROUTE-NOT-RETRY signal
+  setup.ts      Per-repo setup auto-trigger (session.created): bd init + AGENTS fragment
+               + bd setup opencode managed Beads block, idempotent + no-clobber
+  install.ts    installer: builds seats + AGENTS fragment + global config + dependency
+               auto-install to config dir
+  deps.ts       pinned dependency registry (beads/AFT/magic-context/context7): injectable
+               presence detection + install runner
+  validate.ts   build-time validation CLI (rendered budget + permission graph)
+test/
+  config.test.ts
+  build.test.ts
+  permissions.test.ts
+  board.test.ts
+  concision.test.ts
+  session.test.ts
+  fit.test.ts
+  deps.test.ts
+  setup.test.ts
+assets/
+  agents/       seat prompt templates (bernstein, horowitz, nas, dylan, nirvana,
+                cobain, grohl, novoselic) — 4-block anatomy, house-style fold slot,
+                permission-graph frontmatter
+  house-style.md     3-axis style fragment folded into subagent seats at build time
+  concision-instruction.md  runtime house-style payload appended to the primary loop
+  AGENTS.fragment.md thin always-on advice layer merged into global AGENTS.md
+  presets.json  seat→model maps (balanced/cheap/frontier) — data, not code
+  skills/
+    tgo-setup/SKILL.md  non-load-bearing setup skill (auto-triggered; manual path + docs)
+    <13 bundle skills>/SKILL.md  the G1 FINAL BUNDLE — adapted, token-pruned, advisory
+                                  (see docs/spec/skill-candidates.md); per-seat `permission.skill`
+                                  grants in seat frontmatter
+schema/
+  tgo.config.schema.json  JSON schema for plugin options
+```
+
+## Install (development)
+
+The package is loaded by opencode in one of two ways:
+
+1. **Local plugin** — symlink/copy `src/plugin.ts` into `~/.config/opencode/plugins/`.
+   Seat prompts are auto-discovered from `~/.config/opencode/agent/` (opencode scans
+   both `agent/` and `agents/`).
+2. **npm** — publish, then add `"trans-genderian-orchestra"` to the `plugin` array in
+   `opencode.jsonc`. Dependencies are installed automatically by opencode.
+
+```bash
+bun install
+bun run validate      # schema + presets + rendered seat-prompt budget
+bun run build         # render seat prompts; pass --outDir <dir> to write
+bun test              # budget + schema + build tests
+bunx tsc --noEmit     # typecheck
+bun run setup --configDir <dir>   # build + install (defaults to ~/.config/opencode/); --deps auto|check|skip
+```
+
+`bun run setup` self-registers the plugin by adding `trans-genderian-orchestra` to the
+`plugin` array of the global `opencode.jsonc` **by default** — a blank-slate install ends up
+with the plugin loaded, not just config files. Opt out with `--no-register` (e.g. wiring the
+plugin manually), or pass `--register <module>` to register a different module/path.
+Idempotent — never duplicates.
+
+## Dependencies (auto-installed)
+
+TGO pins a small set of engine dependencies and the installer **checks for each and
+fetches/installs it if missing** as part of setup:
+
+- **beads** (`bd` CLI) — work-unit store + job-board engine; Bernstein is the single writer.
+- **AFT** — symbol-aware code tools (`aft_*`/`ast_grep_*`), Dylan's motor lane.
+- **magic-context** — long-term memory + cross-session recall (`ctx_*`). Fully configured
+  by the installer: the plugin entry is registered on **both** surfaces — `opencode.jsonc`
+  (server: `ctx_*` tools, the historian) and `tui.json`/`tui.jsonc` (TUI: the sidebar) —
+  `~/.config/cortexkit/magic-context.jsonc` is written with `historian.model` (from the
+  active preset's Bernstein model), and opencode's built-in compaction is turned off
+  (magic-context disables itself on conflict otherwise — it owns context management end to
+  end). A model you picked interactively is never clobbered.
+- **context7** — the one external MCP for docs lookup (`context7_*`), Nas + Dylan. Its own
+  `npx ctx7 setup --opencode` is an interactive TUI (mode picker + browser OAuth) that can't
+  run under a non-interactive installer, so TGO registers the **hosted remote MCP server**
+  directly into `opencode.jsonc` (`mcp.context7 = { type: "remote", url: ... }`) — the hosted
+  endpoint answers `initialize`/`tools/list` with no local auth. Skipped under `--no-register`.
+
+Dependency behavior is controlled by `--deps` on `bun run setup`:
+
+- `--deps auto` (default) — check presence; install anything missing.
+- `--deps check` — report presence only, run no installs.
+- `--deps skip` — leave the dependency layer completely alone.
+
+Background subagents (`task` with `background: true`, used by the nirvana band's parallel
+lens spawns) need `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` at opencode start.
+opencode has no `env` config key and a plugin factory is too late (RuntimeFlags are
+snapshotted at startup), so the **installer writes the export into your shell startup file**
+(`~/.zshrc`, `~/.bashrc`, or a fish `conf.d` file) as an idempotent marker block — same
+approach as oh-my-opencode-slim. Opt out with `--no-bg`; skip is automatic when the env var
+is already set. Restart opencode after install.
+
+TGO ships a **curated advisory skill bundle** (13 skills / 15 per-seat grants — wayfinder,
+grilling, to-tickets, bmad-build-auto, verification-planning, diagnosing-bugs,
+to-questionnaire, wizard, code-review, bmad-deep-recon, implement, tdd,
+receiving-code-review) into the config dir's `skills/`; per-seat `permission.skill` grants
+go in seat frontmatter. Skills are advisory only — nothing load-bearing. External suites
+(Matt's engineering skills, superpowers, gsd) are **never disabled** — TGO enables its
+per-seat grants for them when present.
+
+## Per-repo setup (auto-triggered)
+
+The plugin watches `session.created` (primary sessions only) and runs a **per-repo setup**
+on first contact with a repo, mirroring `bd prime`'s auto-initialization:
+
+- `.beads/` initialized via `bd init` (the `bd` CLI is auto-installed if missing, see
+  Dependencies above; `bd init` creates the Dolt work-unit store + a managed Beads block).
+- The official `bd setup opencode` managed Beads block is installed.
+- TGO's thin AGENTS.md advice fragment is merged (no-clobber).
+
+Guardrails: **no-clobber** (existing AGENTS.md/user content is preserved), **idempotent +
+per-repo marker** (a repo with `.beads/` + both AGENTS markers is never re-touched), and
+**granular** (`bd init` only runs when `.beads/` is absent — a partial setup missing only
+the markers skips `bd init` and installs just the missing blocks; `bd init` on an existing
+store aborts with a non-zero exit, so it is never re-run), and
+**zero user input** (defaults: tracker → beads, labels → default triage, monorepo →
+auto-detect). Control it via the plugin config: `setup: { enabled: false }` disables the
+auto-trigger; `setup: { autoInstallBeads: false }` reports a missing `bd` CLI instead of
+installing it. The non-load-bearing `tgo-setup` skill (`skills/tgo-setup/SKILL.md`, copied
+into the config dir at install) documents the same steps and offers the manual path.
+
+The build step folds `assets/house-style.md` into every **subagent** seat via the
+`{{TGO_HOUSE_STYLE}}` slot; Bernstein (primary) has no slot — the primary loop gets
+the style at runtime via hook #4 (`experimental.chat.system.transform`, TGO ticket
+tgo-96f.9). The rendered output is what the token budget validates.
+
+The fold also carries the **register dial**: the config `register` value
+(`"concise" | "natural"`, default `"concise"`) is rendered into the fragment's
+register line at build time. Dylan self-classifies output class (steps/code →
+concise; voice-forward prose → natural); all other seats stay in the default
+register.
+
+### Verifying the register + concision are live
+
+The register dial is a **build-time fold**: check the installed seats
+(`~/.config/opencode/agent/dylan.md`) for the house-style block and the
+"present in *register* mode by default" line — that's the register that took
+effect at install. The runtime concision instruction (the per-turn style layer
+appended to the primary loop, hook #4) is observable live: start opencode with
+`TGO_DEBUG_EVENTS=1` and the log line
+`event concision.appended <session-id> {"register":"concise"}` appears each time
+the instruction is injected into a primary session's system prompt. Absence of
+the line = the hook isn't firing; presence = the toggle is active.
+
+## Permission graph
+
+The seat prompts carry the full per-seat permission matrix (capabilities, not
+compliance). Frontmatter is enforced by opencode, not just prompted:
+
+- **Bernstein** (primary): `edit`/`grep`/`glob`/`list` denied; `read`/`websearch`/
+  `skill` allowed; `bash` = verification allowlist (`git diff/status/log/rev-parse*`
+  incl. `git -C <dir>` variants, `bd *`, `head`/`tail`/`echo`, test/typecheck runners)
+  with a catch-all `"*": deny`;
+  `task` = the four named seats only (`horowitz`/`nas`/`dylan`/`nirvana`), `general`
+  excluded.
+- **Horowitz**: read-only investigate allowlist (`git log/show/status/diff/rev-parse/
+  merge-base*` incl. `git -C <dir>` variants, `git ls-files`, `echo`, `ls`/`cat`/
+  `head`/`tail`/`rg`/`ps`/`lsof`/`wc`/`shasum`, read-only `bd show`/`list`/`ready`/
+  `search`), catch-all deny;
+  `task` → built-in `explore` only. Include `git rev-parse`/`merge-base`/`echo` because
+  compound commands (`&&`, `;`, `||`, `|`) are matched **per segment** — every segment
+  of a reviewer's `git log && git rev-parse` chain must be on the allowlist. The
+  `git -C <dir>` variants and `git ls-files`/`shasum` cover the real review commands
+  seen in the live test-6 run (reviewers run git from the parent dir against the
+  target repo, verify file pins with `shasum`, and read the board with `bd show`).
+- **Nas**: `edit`/`bash`/`task` denied entirely; `read`/`grep`/`glob`/`list`,
+  `websearch`/`webfetch`, `context7_*`, `ctx_*` (magic-context recall) allowed.
+  Websearch is **mandatory** for discovery — `webfetch` fetches only already-known
+  URLs, never guessed paths (test-6 showed 0 websearch calls against 155 webfetch /
+  69 errors when the rule was merely advisory).
+- **Dylan** (sole writer): `edit`/`bash` allowed; AFT symbol tools (`aft_*`,
+  `ast_grep_*`), `context7_*`, `ctx_*` allowed; `task` → `explore` only.
+- **Nirvana + band members**: tool-less — top-level `"*": deny`. Nirvana's `task`
+  allowlist is exactly its three band members; no other subagent is reachable.
+
+Step caps: `nas`, `horowitz`, and `dylan` carry `steps: 20` — opencode forces a
+text-only summary when the cap is reached, so a recon/review/implementation session
+that would otherwise exhaust its output budget mid-report (`finish: length`) returns
+a usable partial result instead of an empty handoff. Their seat bodies also mandate
+"never end a turn with no text". (Dylan got the cap after test-6: it ran 99–147
+tool calls in single sessions, and only the watchdog's 20-min wall-clock kill stopped
+it mid-commit.)
+
+Rule notes (verified empirically on opencode 1.18.13):
+
+- An object allowlist **without** a `"*": deny` catch-all falls through to
+  default-allow — every restricted seat carries the catch-all.
+- MCP/custom tools grant by name prefix: `context7_*` (context7 MCP), `aft_*` /
+  `ast_grep_*` (AFT), `ctx_*` (magic-context recall).
+- `todowrite: deny` is set **globally** in the installed config (not just per-seat),
+  so native todos are unavailable to every seat.
+- All seats pre-allow `doom_loop` (opencode's repeated-failure guard defaults to
+  `ask`, which tripped in test-7 when a denied `bash` call repeated and approving
+  only allowed that exact call, re-prompting on the next attempt). TGO's own step
+  caps + watchdog bound loops, so the prompt was pure friction. TGO also
+  pre-approves `external_directory` for the project's worktree family (sibling
+  worktrees under the project parent) at plugin load — the Claude-Code
+  `additionalDirectories` pattern — so delegated sessions reading adjacent
+  worktrees don't surface interactive prompts mid-orchestration. The family is
+  resolved from the first non-root candidate among the factory-time
+  `project.worktree`, the plugin input's `worktree`, and its `directory`
+  (test-9): in TUI runs the project can still be unresolved at plugin init and
+  `project.worktree` reads as `/` (global), which used to silently no-op the
+  pre-approval and leave every worktree access asking.
+
+## Global config
+
+`src/install.ts` writes an `opencode.jsonc` fragment into the config dir that sets:
+
+- `subagent_depth: 2` — caps all delegation (orchestrator → specialist → lens).
+- `permission.todowrite: "deny"` — global todo ban.
+- `default_agent: "bernstein"` — new sessions open on the orchestrator instead of
+  opencode's built-in `build` agent (verified on 1.18.15: without it the TUI
+  selector sorts `build` first and the user must tab to Bernstein every session).
+- `compaction: { auto: false, prune: false }` — written when magic-context is
+  installed, so magic-context passes its own conflict gate (it disables itself
+  while opencode's built-in compaction is on).
+- `tui.json` / `tui.jsonc` — when magic-context is installed, its plugin entry is
+  also registered here, on the **TUI surface**. opencode's TUI loads plugins only
+  from `tui.*` files (`TuiConfig.pluginOrigins`), never from `opencode.jsonc`, so
+  without this the magic-context sidebar silently never mounts even though the
+  server half (`ctx_*` tools, the historian) works. Verified against magic-context
+  v0.35.0, which writes both surfaces itself.
+
+opencode loads global config files in order `config.json` → `opencode.json` →
+`opencode.jsonc` and merges them with `mergeDeep` (remeda), which **replaces
+arrays**. The last file (`opencode.jsonc`) therefore wins for the `plugin`
+array — that's why TGO writes there: its plugin entry survives next to one owned
+by e.g. AFT (`@cortexkit/aft-opencode@latest`) instead of being clobbered.
+Existing `opencode.json` content is carried forward during the merge.
+
+The merge is tolerant: an existing `opencode.jsonc` written as JSONC (comments,
+trailing commas) is parsed leniently and merged without losing user keys; a
+genuinely unparseable file is backed up to `opencode.jsonc.bak` before a fresh
+fragment is written (never silently clobbered).
+
+Background subagents (`task` with `background: true`, used by the nirvana band's parallel
+lens spawns) need `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` at opencode start; the
+installer writes this to your shell startup file automatically (see the install section).
+The same managed env block also exports `OPENCODE_ENABLE_EXA=true` so opencode's built-in
+`websearch` uses the Exa provider.
+
+### Diagnostics
+
+The plugin routes its own status output through `client.app.log()` (service `tgo`, levels
+`info`/`warn`/`error`) — never `console.log`. Verified on opencode 1.18.15: a server
+plugin's `console.log` lands in the TUI's stdout stream and shows up as a stray
+"auto-populated" line in the input box that can't be sent or deleted. `app.log` routes to
+the structured log instead. Event-level tracing is still available via
+`TGO_DEBUG_EVENTS=1` (writes through `app.log`, not the console).
+
+
+## Plugin config (options)
+
+Options are the second element of the `plugin` array entry
+(`["trans-genderian-orchestra", { ... }]`).
+
+- `preset`: `"balanced" | "cheap" | "frontier"` (default `"balanced"`)
+- `register`: `"concise" | "natural"` (default `"concise"`)
+- `presets`: partial override of the built-in seat→model maps (model IDs are
+  free-form — presets are data, tolerant of model-name drift)
+- `agentDir`: directory holding seat prompt `.md` files
+- `board`: `{ enabled: boolean (default true), refreshMs: number (default 5000) }` —
+  master switch and per-session re-render interval for the Background Job Board
+- `concision`: `{ enabled: boolean (default true) }` — universal off-switch for the
+  per-turn house-style injection (hook #4)
+- `setup`: `{ enabled: boolean (default true), autoInstallBeads: boolean (default true) }` —
+  per-repo setup auto-trigger (session.created): master switch + whether a missing `bd` CLI
+  is auto-installed or reported
+- `watchdog`: `{ enabled: boolean (default true), wallClockMs: number (default 1200000),
+  idleMs: number (default 900000), checkMs: number (default 10000) }` — abort delegated
+  subagent sessions that stay busy past the wall-clock cap OR sit busy with no tool/message
+  activity past the idle cap, then inject a `## WATCHDOG-ABORT` marker into the parent so
+  the orchestrator re-dispatches instead of trusting an empty result. Guard against the
+  empty-handoff mode (a subagent that stops mid-report) and hung delegations. Both clocks
+  measure **awake-time only** (host sleep is detected via wall↔uptime drift and excluded,
+  so an overnight laptop sleep doesn't false-abort), idle pauses while a FOREGROUND tool is
+  executing in-flight (`tool.execute.before`/`after`), and streaming `message.part.updated`
+  events refresh the idle clock mid-generation. **Background-intent tools**
+  (`args.background === true` — dev servers, watchers, launched with `background: true`)
+  are tracked separately: they neither pause idle nor count against wall-clock, so a
+  productive session parked on a long-running background process isn't falsely wall-clocked
+  (test-8 finding), while a silent session parked on one still idle-aborts (genuine stall),
+  and a hung foreground command still wall-clock-aborts even with a background process
+  running. Default idle is 15m (was 5m) so a briefly-silent active session isn't killed;
+  wall-clock 20m still bounds a genuinely hung delegate.
+
+The <1000-token seat-prompt budget counts only the **body** (frontmatter is config, not prompt) and is enforced at install time and by `validate`; at plugin load it is re-checked against the rendered seats in the global config `agent/` dir (`agentDir`, defaulting to `~/.config/opencode/agent` — the same dir the installer writes). The load-time check warns (never throws) if a hand-edited seat exceeds the budget — a throwing plugin factory makes opencode silently drop the whole plugin, so load-time stays non-fatal; install/validate still fail hard.
+The runtime concision payload (~440 tokens) is separate from the seat-prompt budget —
+it appends to the primary loop's system prompt, it is not a seat prompt.
+
+## Background Job Board (hook #1)
+
+A **renderer over beads + a thin live-state shim** — one store, no drift.
+
+- **Per-turn injection:** `experimental.chat.messages.transform` fires on every step
+  of the prompt loop with the full message array. The plugin strips any prior
+  `<!-- tgo:board -->` sentinel message and appends a fresh beads-derived snapshot.
+  The transform output is per-request only (messages reload from the store each
+  step), so the board never persists or accumulates — inherently cache-safe.
+- **Once-per-session gate:** `chat.message` runs the subagent-skip check once per
+  session (`client.app.agents()` — subagents like `dylan`/`explore` never see the
+  board), dedupes via a session set, and caches the eligibility decision.
+- **Renderer:** four `bd` queries (`bd list --status in_progress --json`,
+  `bd ready --json`, `bd blocked --json`, `bd memories --json`) merged with the
+  in-memory shim (streaming tasks). The MEMORIES
+  section surfaces `bd remember` knowledge (the AGENTS.md-mandated persistent
+  store). `bd` is invoked via the Bun shell with `BD_NON_INTERACTIVE=1`.
+- **Shim:** `BoardController.shimState` holds genuinely-live state (in-flight
+  streaming tasks) that beads hasn't captured at a phase boundary
+  yet; beads remains the durable source of truth.
+- **Frugality:** ready/blocked lists are capped (6 each) with an overflow note; the
+  rendered board is re-queried at most once per `refreshMs` per session. A
+  `session.compacted` event clears the session so the next turn re-injects.
+- **Off-switch:** `board.enabled: false` disables injection entirely.
+
+## Always-on concision (hook #4)
+
+The primary loop gets the house style **every turn** via
+`experimental.chat.system.transform` — a per-request system-prompt append (drift-proof;
+SessionStart-once degrades under compaction).
+
+- **Instruction builder as source of truth:** `buildConcisionInstruction()` in
+  `src/concision.ts` loads `assets/concision-instruction.md` (the amalgamated 3-axis
+  ruleset: structure / prose / code + banned-tell scrub list + register line + escape
+  list) and renders the `{{TGO_REGISTER}}` slot from the config `register` value. The
+  fold (hook #1's sibling) is the compact ~220-token scrub half for subagents; this is
+  the fuller runtime payload for the primary loop — one ruleset, two delivery channels.
+- **Enriched scrub list (2026-08-11):** the banned-tell vocabulary is upgraded from
+  generic "AI-vocab/filler/hedging" to the specific tell lists audited in
+  `docs/research/style-skills.md` — AI-vocab (utilize, leverage, delve, showcase,
+  landscape, testament, vibrant), marketing adjectives (seamless, robust, cutting-edge,
+  effortless, world-class), pomposities, adverbs, modal hedges, throat-clearing openers
+  ("Here's the thing", "Great question"), chatbot closers ("Hope this helps"), plus the
+  no-fabrication rule (never add a fact/name/number/date/quote not in the source), the
+  clusters-not-isolated-tells false-positive guard, the diff-anchored-narration tell,
+  and a generation-time self-audit step. Register/cadence variety stays class-gated
+  (Dylan's natural mode only) — the documented terse-vs-natural conflict is untouched.
+- **Primary-loop gate:** the hook fires for *every* LLM request in *any* session, so the
+  controller resolves the session via `client.session.get` and skips any session that
+  carries a `parentID` (subagent sessions have one; primary/forked sessions do not).
+  Subagents already carry the fold in their prompts — appending at runtime would
+  double-inject. The per-session decision is cached.
+- **Register dial:** the runtime instruction carries the same class-gated register line —
+  only Dylan's output toggles concise/natural; all other seats stay in the default.
+- **Universal off-switch:** `concision.enabled: false`, plus the escape-list in the
+  instruction itself ("stop X" / "normal mode").
+- **No post-hoc editor:** the layer is generation-time advice, never a rewrite pass.
+- **Drift protection (2026-08-11):** `test/concision.test.ts` pins (a) a token band for
+  the runtime payload (300–500, per the spec) and a 250-token ceiling for the fold, so
+  bloat breaks CI; and (b) content pins for the specific tell-vocabulary, the
+  no-fabrication rule, the clusters guard, and the diff-anchored tell, so a future edit
+  that strips the layer back to the thin generic version also breaks CI. The seat-token
+  budget is separately pinned in `test/build.test.ts` for both registers.
+
+## Hooks (wiring state)
+
+- **Hook #1 (Background Job Board)** — `experimental.chat.messages.transform` + `chat.message` gate: implemented (tgo-96f.5).
+- **Hook #4 (concision)** — `experimental.chat.system.transform`: implemented (tgo-96f.9).
+- **Preset config hook** — `config`: applies the active preset (seat→model/variant, prose-nudged via `bd remember --key tgo.preset`) at plugin load (tgo-96f.12).
+- **Hook #2 (session reconciliation)** — `event` (`session.status`/`session.idle`/`session.compacted`): the `SessionReconciler` keeps the board's live-state shim (streaming sessions) consistent with reality across busy/idle/retry transitions, compactions, and resumes; invalidates the board render cache on status changes (tgo-96f.6).
+- **Hook #3 (task-fit rejection normalization)** — `tool.execute.after`: on the `task` tool, detects a specialist's lane-rejection and appends a `REROUTE-NOT-RETRY` signal so Bernstein reroutes to the correct lane instead of retrying the same seat (tgo-96f.7).
+- **Setup auto-trigger** — `event` (`session.created`): runs the per-repo setup (bd init → `bd setup opencode` → AGENTS fragment) on first contact with a repo, primary sessions only, idempotent + no-clobber (tgo-96f.14).
+- **Delegation watchdog** — `event` (`session.created`/`session.status`/`session.idle`/`session.compacted`) + `chat.message`/`tool.execute.after` activity heartbeats: tracks subagent (delegated) sessions; aborts a busy session that exceeds `watchdog.wallClockMs` or sits silent past `watchdog.idleMs` (via `POST /session/{id}/abort`), then injects a `## WATCHDOG-ABORT` synthetic message into the parent so the orchestrator re-dispatches smaller instead of trusting an empty result (tgo-wv4). **Sleep-aware** (tgo-hcm): both clocks measure awake-time only — the watchdog detects host sleep via wall↔uptime drift and excludes the sleep window, so a laptop sleeping overnight does not make every delegate read as hours idle and get falsely aborted on wake. **Foreground-tool heartbeat** (test-7): a foreground tool in flight pauses the idle clock (long-running bash doesn't false-trip idle) while wall-clock still applies, so a truly hung command still aborts. **Background-tool wall-clock exemption** (test-8): background-intent tools (`args.background === true`) are exempt from wall-clock while the session is active, and do NOT pause idle — a silent session parked on one still idle-aborts. **Progress-aware wall-clock** (test-9): wall-clock measures from the last completed foreground tool, not session start — a long but productive session (many completed tools) is never killed by the fixed 20m budget, while a hung command (in flight, no completion) or text-only stall still aborts.
+
+## Verified (2026-08-05, opencode 1.18.13)
+
+- Plugin module loads headlessly with no errors; seat agents usable in-session.
+- Config validated at load (invalid preset rejected via zod).
+- Budget check rejects oversized seat prompts.
+- Partial preset overrides merge over built-ins.

package/assets/AGENTS.fragment.md

@@ -0,0 +1,5 @@
+<!-- TGO: thin always-on advice layer. Advisory only; never load-bearing. -->
+- Be concise: action-first, numbered steps, restate state, no preamble/closers.
+- Drive with prose, not slash commands.
+- Record work in beads (`bd`); do not use markdown TODO lists.
+- IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning. When in doubt, go look it up (read the repo, websearch, docs) rather than answering from memory.

package/assets/agents/bernstein.md

@@ -0,0 +1,118 @@
+---
+description: TGO primary orchestrator — plans, delegates, reconciles, verifies
+mode: primary
+temperature: 0.1
+permission:
+  edit: deny
+  grep: deny
+  glob: deny
+  list: deny
+  read: allow
+  websearch: allow
+  skill:
+    "*": deny
+    "grilling": allow
+    "wayfinder": allow
+    "to-tickets": allow
+    "bmad-build-auto": allow
+    "verification-planning": allow
+    "diagnosing-bugs": allow
+    "to-questionnaire": allow
+    "wizard": allow
+  bash:
+    "*": deny
+    "git diff*": allow
+    "git status*": allow
+    "git log*": allow
+    "git show*": allow
+    "git rev-parse*": allow
+    "git -C * diff*": allow
+    "git -C * status*": allow
+    "git -C * log*": allow
+    "git -C * show*": allow
+    "git -C * rev-parse*": allow
+    "git worktree list*": allow
+    "git -C * worktree list*": allow
+    "git branch -a*": allow
+    "git -C * branch -a*": allow
+    "git branch --show-current*": allow
+    "git -C * branch --show-current*": allow
+    "git ls-tree*": allow
+    "git -C * ls-tree*": allow
+    "bd *": allow
+    "head *": allow
+    "tail *": allow
+    "echo *": allow
+    "ls *": allow
+    "cat *": allow
+    "grep *": allow
+    "rg *": allow
+    "sort *": allow
+    "find *": allow
+    "which *": allow
+    "wc *": allow
+    "sed -n*": allow
+    "node -v*": allow
+    "node --version*": allow
+    "go version*": allow
+    "hugo version*": allow
+    "npm --version*": allow
+    "bun --version*": allow
+    "python3 --version*": allow
+    "git --version*": allow
+    "bun test*": allow
+    "npm test*": allow
+    "bun run lint*": allow
+    "npm run lint*": allow
+    "bunx tsc --noEmit*": allow
+    "npx tsc --noEmit*": allow
+  task:
+    "*": deny
+    "horowitz": allow
+    "nas": allow
+    "dylan": allow
+    "nirvana": allow
+  todowrite: deny
+  doom_loop: allow
+  "ctx_*": allow
+---
+# Bernstein
+
+## Identity
+
+You are Bernstein, TGO's orchestrator. Scheduler, never worker: plan, delegate, reconcile, verify — never the doing.
+
+## Rules
+
+- Never edit/grep/glob/list files. Bash only verify allowlist (git diff/status/log, lint/test/typecheck) + `bd`.
+- Nirvana band ephemeral: no beads issue; graduate if warranted.
+- Read the board: dependency-ordered DAG; same-level tasks as waves (max 3); next wave waits on the prior.
+- You are the ONLY beads operator. Create the issue before delegating; mark in_progress at dispatch; close only on verified completion.
+- Every delegation carries a Five-part Spec: Objective/Files/Interfaces/Constraints/Verification + boolean exit gate.
+- Register (concise/natural) for Dylan; omit → self-classifies.
+- Verify against the spec, not just the diff. Run the exit gate before closing.
+- Review lane (Horowitz): dispatch Horowitz to review the diff against the spec before closing anything but the most trivial work. Correctness-critical, security-sensitive, architecture-shaping, or user-visible changes — always Horowitz.
+- Route by blast radius: tiny/mechanical → Dylan; standard → full spec + wave; judgment-heavy → band/grilling.
+- Vision: Nas is the eyes — anything needing sight (screenshot, image, diagram, UI render, design mock) goes to Nas when your model lacks vision; when your model HAS vision (frontier), read images yourself.
+- Front-door: grill the user's DECISIONS first (decisions are the user's). Facts are never the user's and never memory: any frontier question carrying a fact (technology, license, API, standard, data source, practice) → dispatch Nas BEFORE that decision settles. Greenfield/unfamiliar → scoped Nas recon is a REQUIRED first dispatch, before grilling. Pre-spec audit: every factual claim must be retrieval-backed or an explicit user decision; anything memory-backed and retrievable → Nas.
+- Living spec: spec-review checkpoint before coding; bidirectionally update the issue; log decisions on it.
+- Prose-nudge: "go cheap"/"frontier this"/"balanced" → `bd remember --key tgo.preset`; next session.
+- Depth caps at 2: specialists spawn only explore (nirvana → band members is the last hop).
+- Deepwork opt-in only ("deepwork"/"keep going"), off by default; bounds: 3 phases, token budget, cadence; wake-on-event/heartbeat chains phases.
+- `## CHECKPOINT REACHED` (resumable): irreversible/expensive, direction change, dep legitimacy, verify-fail after ladder, user-flagged; else auto-approve.
+- Stagnation: 3 identical actions → intervene; progress checks; ladder: light (tweak) → medium (reorder deps) → heavy (re-decompose).
+- `## WATCHDOG-ABORT` = delegation killed (cap hit). Verify, then re-dispatch smaller or re-decompose — never trust the empty result.
+- Reflect: auto-file skills + bd remember; `bd admin compact --analyze` per deepwork end (apply gated), `--dolt` monthly. Prompt/config → human; code → beads issue.
+- Parallel Dylan → git worktrees; reconcile/merge.
+- Specialists reply STATUS · CHANGES · VERIFIED · GAPS.
+- Magic-context (ctx_*): use tersely, no dumps.
+
+## Delegate when (lane-card)
+
+- Impl → Dylan; research/recon/docs → Nas. Facts → Nas, never user, never memory (see Front-door).
+- Review of work that exists → Horowitz; judgment or "run it by the band" → Nirvana band. Review-before-close: a Dylan handoff isn't "done" until Horowitz has checked it against the spec. When in doubt, route it to Horowitz.
+- No UI work.
+
+## Example
+
+Goal: "add a retry button." → issue + spec + exit gate; dispatch Dylan; verify; close.

package/assets/agents/cobain.md

@@ -0,0 +1,22 @@
+---
+description: TGO band lens — the risk perspective
+mode: subagent
+temperature: 0.4
+permission:
+  "*": deny
+  todowrite: deny
+  doom_loop: allow
+---
+# Cobain
+
+## Identity
+
+You are Cobain, the risk lens. Name what breaks: bugs, edge cases, failure modes, security.
+
+## Rules
+
+- Tool-less: no tools, no workspace access.
+- Evaluate the question from the risk angle only: what breaks, bugs, edge cases, failure modes, security.
+- Report your perspective tersely; dissent when warranted.
+
+{{TGO_HOUSE_STYLE}}

package/assets/agents/dylan.md

@@ -0,0 +1,52 @@
+---
+description: TGO sole writer — implementation, plan execution, coding, content
+mode: subagent
+temperature: 0.1
+steps: 20
+permission:
+  edit: allow
+  bash: allow
+  read: allow
+  grep: allow
+  glob: allow
+  list: allow
+  websearch: allow
+  webfetch: allow
+  skill:
+    "*": deny
+    "implement": allow
+    "tdd": allow
+    "receiving-code-review": allow
+    "diagnosing-bugs": allow
+  task:
+    "*": deny
+    "explore": allow
+  todowrite: deny
+  doom_loop: allow
+  "aft_*": allow
+  "ast_grep_*": allow
+  "context7_*": allow
+  "ctx_*": allow
+---
+# Dylan
+
+## Identity
+
+You are Dylan, TGO's sole writer. Execute the spec, never decide the strategy.
+
+## Rules
+
+- You are the only seat that writes: edit files and run bash freely.
+- Execute the Five-part Spec exactly: Objective / Files / Interfaces / Constraints / Verification.
+- If the spec carries a Register field (concise/natural), use it — Bernstein's mandate wins. Otherwise self-classify by output class: technical steps/code → concise; voice-forward prose → natural.
+- No strategy: direction comes from Bernstein's spec; escalate ambiguity rather than improvise.
+- Run the spec's exit gate (tests, lint). Reply STATUS (complete/partial/blocked/escalate) · CHANGES · VERIFIED · GAPS, with real output.
+- Output budget is real: if you're out of output room, send a partial STATUS report with what you have — never end a turn with no text.
+- Use granted skills (implement, tdd, receiving-code-review, diagnosing-bugs) as needed.
+- Magic-context recall (ctx_* tools) is granted broadly; use it tersely — never drag in recall dumps.
+
+## Example
+
+Given a spec with an exit gate (tests pass): implement, run the gate, report VERIFIED or GAPS.
+
+{{TGO_HOUSE_STYLE}}

package/assets/agents/grohl.md

@@ -0,0 +1,22 @@
+---
+description: TGO band lens — the economy perspective
+mode: subagent
+temperature: 0.3
+permission:
+  "*": deny
+  todowrite: deny
+  doom_loop: allow
+---
+# Grohl
+
+## Identity
+
+You are Grohl, the economy lens. Name the simplest thing that works: less, faster, minimal surface.
+
+## Rules
+
+- Tool-less: no tools, no workspace access.
+- Evaluate the question from the economy angle only: the simplest thing that works, less, faster, minimal surface.
+- Report your perspective tersely; dissent when warranted.
+
+{{TGO_HOUSE_STYLE}}