pantheon-opencode 1.3.2 → 1.3.4

package/README.md

@@ -2,7 +2,7 @@
 <h1 align="center">Pantheon</h1>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-v1.0.0-blue" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-v1.3.4-blue" alt="Version"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License"></a>
   <a href="src/agents/README.md"><img src="https://img.shields.io/badge/agents-14-purple" alt="Agents"></a>
   <a href="src/skills/README.md"><img src="https://img.shields.io/badge/skills-21-orange" alt="Skills"></a>
@@ -183,6 +183,159 @@ export OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true
 opencode
 ```
 
+### Background Delegation
+
+Zeus (and other root sessions) can dispatch agents as **background child sessions**
+via three delegation tools, tracked on a persistent job board
+(`.pantheon/board/state.json`, 24h TTL) with reports written to
+`.pantheon/delegations/<parent>/<alias>.md`:
+
+| Tool | Signature | Behavior |
+|------|-----------|----------|
+| `pantheon_delegate` | `{prompt, agent, description?, read_only?}` | Creates a child session (parentID = caller), registers it on the job board, arms a 15-minute timeout, and fire-and-forgets `promptAsync` on the child. Returns the readable alias (e.g. `apo-1`). Only root sessions may delegate (sub-sessions are rejected by the depth guard). |
+| `pantheon_delegation_read` | `{id}` | Blocks (`waitForTerminal`, up to 15 min) until the delegation reaches a terminal state, returns the report markdown, and marks the job reconciled. Resolves by alias or task ID. |
+| `pantheon_delegation_list` | `{}` | Lists the current session's delegations with `[unread]` on finished, unreconciled jobs. |
+
+**Agent activity visibility.** While `pantheon_delegation_read` blocks on a
+running job, it samples the child session's messages every ~2s and appends the
+collected lines to the report as a trailing `## Agent Activity` section (latest
+tool calls with truncated args, or user/assistant text, capped at ~200 chars per
+line) — so you can see what the agent is doing during the wait. Likewise,
+`pantheon_delegation_list` shows a `last activity:` line for running jobs.
+Fail-open: if the child session messages are unavailable (or empty), the read
+returns the report exactly as before — the activity sampling never breaks the
+delegation read.
+
+**Completion visibility — no chat injection.** User policy: ZERO delegation
+notifications in the chat transcript — no `<task-notification>` block is ever
+injected into a `chat.message` output (the old queue + flush channel was
+removed). When a job reaches a terminal state (completion observed via
+`session.idle`/`session.error` on the child, or the timeout finalize path), the
+plugin writes a file-only audit log line (echo opt-in via `PANTHEON_HOOKS_LOG`).
+Completion visibility lives in the legitimate channels: the board `[unread]`
+marker (`pantheon_delegation_list`), `pantheon_delegation_read`, TUI toasts
+(pantheon-hooks, `PANTHEON_TOASTS` gate) and compaction carry-forward. Reconcile
+is an acknowledgment, not a completion — it never re-fires the terminal
+transition.
+
+**Timeout:** `background_delegation.timeout_ms` (default `900000` = 15 min). A job
+that has not reached a terminal state is finalized as `error`/`timedOut`.
+
+**Read-only enforcement:** delegating with `read_only: true`, or delegating to an
+agent in `background_delegation.read_only_agents` (`apollo`, `gaia`), registers
+the child session as read-only — the `tool.execute.before` guard denies
+`edit`/`write`/`bash`/`task` inside that session.
+
+**Compaction carry-forward:** during context compaction, running and unread
+terminal delegations (capped at `background_delegation.max_compaction_items`,
+default 10) are carried into the compacted context so the parent doesn't lose
+track of in-flight work.
+
+**Compaction summary v2 (1.3.4):** the `experimental.session.compacting` hook
+now emits sections in a stable order — `<pantheon-context directive>`
+("preserve these sections verbatim in the summarized context", emitted only
+when at least one other section follows), `<mission_context>` (active,
+non-done goals), `<todo_context>` (pending todos), then the delegation blocks
+(running, then unread terminal ≤ `max_compaction_items`) byte-for-byte
+unchanged. Each source is fail-open: a disabled, unscoped (no sessionID),
+throwing, or empty source omits its section (warned to `hooks.log`), and a
+totally-empty state returns nothing — the hook injects nothing, preserving
+the pre-1.3.4 behavior.
+
+**Post-compaction todo preservation (1.3.4):** the session's todo list is
+captured via the `session.todo` GET at compacting time and restored by
+intercepting the first `todowrite` after `session.compacted` — opencode
+1.18.x exposes no todo write API, so that first `todowrite` has its args
+rewritten with the exact captured list (no model cooperation, zero transcript
+noise). Subsequent `todowrite` calls inside the 5s restore window are denied
+with a clear "retry in a moment" error; the snapshot TTL is 60s. Fail-open: a
+failed capture, expired snapshot, or malformed hook output degrades to a
+logged warn and pass-through.
+
+**Post-compaction state re-assertion (1.3.4):** on `session.compacted`, fresh
+state — running/unread delegations from the board + active goals, capped at 10
+lines — is re-injected as a `<system-reminder>` into the session's next
+message via the shared chat-reminder buffer (`chat-reminders.ts`, the same P0
+messageID guard that protects subagent fires). A session with nothing to
+assert is a silent skip.
+
+**Preemptive compaction check (1.3.4):** a pure threshold core
+(`preemptive-compact.ts`) warns the model before the context fills: at 78%
+usage, re-warning only when usage rose ≥5pp since the last warning. It is
+dormant / ready-to-wire — opencode 1.18.x exposes no runtime context-usage
+percentage, so nothing observes it yet; when a source appears, the caller
+wires it in (the enqueue callback is injected).
+
+**Model API-key validation (1.3.4):** `pantheon_delegate` gates the resolved
+child model's provider before dispatching (single source of truth:
+`routing.yml` preset definitions' `apiKeyEnv` — the same check `applyPreset`
+enforces at startup). If an **auto-resolved** model (`options.agentModels` or
+the active preset) points to a provider that requires an API key
+(`apiKeyEnv`) and the env var is unset, the delegate falls back to
+`opencode/deepseek-v4-flash-free` (validated the same way). If the fallback is
+also unusable, the tool returns a clear error **text** (never throws) naming
+the missing env var — and registers **no job** on the board. An **explicit**
+`model` passed by the caller is always respected (warned, not overridden).
+Setting `PANTHEON_MODEL_PRESET` to a preset whose providers have keys, or
+filling the required `PANTHEON_*_API_KEY` env var for the preset's provider,
+resolves the fallback path. If nothing resolves at all (no model, no preset),
+the child keeps using opencode's default model (warned).
+
+**agentModels wiring (1.3.4):** the delegate now also resolves the child model
+via `routing.yml` — `loadRoutingAgentModels` extracts the per-agent models of
+the FIRST-listed preset (the static default, `go-deepseek` today) and passes
+them as `options.agentModels`, branch (b) of the resolve precedence: explicit
+`model` > `options.agentModels` > active preset > opencode default. Delegation
+no longer depends exclusively on the active preset — a delegated child gets a
+sane per-agent model even when no preset is active. Fail-open: a missing or
+unparseable routing.yml yields `{}` (previous behavior, warned).
+
+**Delegation log hygiene (1.3.4):** `delegations.log` now records the real
+`task_id` (omitted when empty, never `""`) and a **numeric** `duration_ms`
+(null when unset) so downstream aggregation works. The idle-flush log entry is
+deduplicated: the flush logs a summary (count + aggregated line count) and the
+reminder content is logged exactly once, at `chat.message` delivery — no more
+duplicate lines for the same notification.
+
+**Env vars & config:**
+
+- `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` — required (see launch block above).
+- `PANTHEON_TOASTS` — TUI toast gate for the delegation lifecycle signals.
+  Default `{errors, delegations, council}`; `PANTHEON_TOASTS=off` disables all
+  TUI toasts (delegation signals then only surface via the board `[unread]`
+  marker, `pantheon_delegation_read` and the on-disk audit log — never via
+  chat.message injection from the plugin).
+- `background_delegation` section in `src/routing.yml` — `timeout_ms`,
+  `poll_ms`, `max_compaction_items`, `prune_ttl_ms`, `read_only_agents`,
+  `session_max`, `retry_count`.
+
+See `src/agents/zeus.md` for the agent-facing delegation protocol and
+`src/pantheon/delegation.ts` for the tool implementations.
+
+### Real-time Delegations panel (1.3.4)
+
+The TUI sidebar ships a live **Delegations** panel (open by default, above the
+collapsed Sessions list). Its primary source is `api.client.session.children`,
+so it shows **both** kinds of background work in one place:
+
+- **`pantheon_delegate` children** — rendered with their board alias tag
+  (`[apo-1]`) and enriched from the `.pantheon/delegations/` report.
+- **Native `task()` children** — rendered with a distinct `[task]` tag (info
+  color) when no board report exists for the session.
+
+Rows animate through the delegation lifecycle — a 140ms spinner plus
+`DELEGATING` / `WORKING` / `READING RESULT` / `DONE` / `DONE (TIMED OUT)` /
+`ERROR` / `CANCELLED` — and **clicking a row navigates to the child session**
+(route API, guarded; mouse enabled in `tui.json`). The panel also reads the
+md reports from **every** session (`readAllDelegationEntries`), so the full
+delegation history renders even when no session is focused. Refresh is driven
+by session events + `message.part.updated/removed` (live version bumps) with a
+1s safety poll; every re-fetch appends a diagnostic
+`panel: children=N md=N events=N` line to `.pantheon/logs/hooks.log`
+(silence-by-default policy — see `PANTHEON_HOOKS_LOG`). Everything is
+fail-open: a missing children API or directory renders `Delegations (0)` /
+the md history instead of erroring.
+
 > **Modes:** Interactive TUI with checkbox selection (default TTY), or `--headless` for scripts/CI.
 > **Minimal:** `--headless --no-mcp` installs only agents (~2s).
 > **Full:** `--headless` also creates Python venv + MCP servers (memory, persistence, KV, vision).

package/bin/pantheon-init.mjs

@@ -7,204 +7,244 @@
  * Thin CLI wrapper that parses arguments and delegates to
  * installOpenCode() from scripts/install/opencode.mjs.
  */
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { fileURLToPath } from 'url'
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(__dirname, '..');
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ROOT = path.resolve(__dirname, '..')
 
-const REQUIRED_NODE_MAJOR = 18;
+const REQUIRED_NODE_MAJOR = 18
 if (parseInt(process.versions.node.split('.')[0], 10) < REQUIRED_NODE_MAJOR) {
-  console.error(`❌ Node.js >= ${REQUIRED_NODE_MAJOR} required (current: ${process.versions.node})`);
-  process.exit(1);
+  console.error(`❌ Node.js >= ${REQUIRED_NODE_MAJOR} required (current: ${process.versions.node})`)
+  process.exit(1)
+}
+
+function readVersion() {
+  try {
+    const pkgPath = path.join(ROOT, 'package.json')
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version || '?'
+  } catch {
+    return '?'
+  }
 }
 
 function printUsage() {
-  console.log('Pantheon OpenCode — Multi-agent orchestration platform');
-  console.log('');
-  console.log('Usage:');
-  console.log('  npx pantheon-opencode init              # Install globally');
-  console.log('  npx pantheon-opencode init --project    # Install in project');
-  console.log('  npx pantheon-opencode init --dry-run    # Preview only');
-  console.log('  npx pantheon-opencode init --no-mcp       # Skip MCP + venv');
-  console.log('  npx pantheon-opencode init --force        # Overwrite + recreate venv');
-  console.log('  npx pantheon-opencode init --doctor       # Run health check after install');
-  console.log('  npx pantheon-opencode init --interactive  # Force interactive TUI mode');
-  console.log('  npx pantheon-opencode init --headless     # Force non-interactive mode');
-  console.log('  npx pantheon-opencode init -y             # Skip confirmations, use defaults');
-  console.log('  npx pantheon-opencode init --preset <name> # Install and activate model preset');
-  console.log('  npx pantheon-opencode set-tier <name>      # Set active model preset (global)');
-  console.log('  npx pantheon-opencode set-tier <name> --project  # Set active model preset (project)');
-  console.log('  npx pantheon-opencode prune               # List legacy artifacts (dry-run)');
-  console.log('  npx pantheon-opencode prune --apply       # Remove stale backups');
-  console.log('  npx pantheon-opencode --help              # Show this help');
+  console.log('Pantheon OpenCode — Multi-agent orchestration platform')
+  console.log('')
+  console.log('Usage:')
+  console.log('  npx pantheon-opencode init              # Install globally')
+  console.log('  npx pantheon-opencode init --project    # Install in project')
+  console.log('  npx pantheon-opencode init --dry-run    # Preview only')
+  console.log('  npx pantheon-opencode init --no-mcp       # Skip MCP + venv')
+  console.log('  npx pantheon-opencode init --force        # Overwrite + recreate venv')
+  console.log('  npx pantheon-opencode init --doctor       # Run health check after install')
+  console.log('  npx pantheon-opencode init --interactive  # Force interactive TUI mode')
+  console.log('  npx pantheon-opencode init --headless     # Force non-interactive mode')
+  console.log('  npx pantheon-opencode init -y             # Skip confirmations, use defaults')
+  console.log('  npx pantheon-opencode init --preset <name> # Install and activate model preset')
+  console.log('  npx pantheon-opencode set-tier <name>      # Set active model preset (global)')
+  console.log(
+    '  npx pantheon-opencode set-tier <name> --project  # Set active model preset (project)',
+  )
+  console.log('  npx pantheon-opencode prune               # List legacy artifacts (dry-run)')
+  console.log('  npx pantheon-opencode prune --apply       # Remove stale backups')
+  console.log('  npx pantheon-opencode doctor [--profile]  # Run health check')
+  console.log('  npx pantheon-opencode --version, -v       # Print version and exit')
+  console.log('  npx pantheon-opencode --help              # Show this help')
 }
 
 async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
+  const args = process.argv.slice(2)
+  const command = args[0]
+
+  // --version / -v: print the package version and exit. Must run before any
+  // install/help dispatch so it never touches the filesystem beyond reading
+  // package.json.
+  if (command === '--version' || command === '-v') {
+    console.log(readVersion())
+    process.exit(0)
+  }
 
   // prune handles its own --help (delegated to scripts/prune.mjs), so its
   // dispatch must run BEFORE the generic --help check.
   if (command === 'prune') {
-    const { spawnSync } = await import('child_process');
-    const pruneScript = path.join(ROOT, 'scripts', 'prune.mjs');
+    const { spawnSync } = await import('child_process')
+    const pruneScript = path.join(ROOT, 'scripts', 'prune.mjs')
     const result = spawnSync(process.execPath, [pruneScript, ...args.slice(1)], {
       stdio: 'inherit',
       cwd: ROOT,
-    });
-    process.exit(result.status ?? 1);
+    })
+    process.exit(result.status ?? 1)
+  }
+
+  // doctor delegates to scripts/doctor.mjs (same spawnSync pattern as prune).
+  // Forwarding the FULL args (profile, target, --fix, ...) keeps the packaged
+  // CLI a thin wrapper; the doctor banner reports the resolved profile.
+  if (command === 'doctor') {
+    const { spawnSync } = await import('child_process')
+    const doctorScript = path.join(ROOT, 'scripts', 'doctor.mjs')
+    const result = spawnSync(process.execPath, [doctorScript, ...args.slice(1)], {
+      stdio: 'inherit',
+      cwd: ROOT,
+    })
+    process.exit(result.status ?? 1)
   }
 
-  if (args.includes('--help')) { printUsage(); process.exit(0); }
+  if (args.includes('--help')) {
+    printUsage()
+    process.exit(0)
+  }
 
   if (command === 'set-tier') {
-    const isProject = args.includes('--project');
-    const isDryRun = args.includes('--dry-run');
-    const name = args[1];
+    const isProject = args.includes('--project')
+    const isDryRun = args.includes('--dry-run')
+    const name = args[1]
 
-    const { loadPresetDefs } = await import('../src/pantheon/presets.mjs');
-    const { writeActivePreset } = await import('../scripts/install/model-picker.mjs');
-    const presets = loadPresetDefs();
-    const presetList = `none, ${Object.keys(presets).join(', ')}`;
+    const { loadPresetDefs } = await import('../src/pantheon/presets.mjs')
+    const { writeActivePreset } = await import('../scripts/install/model-picker.mjs')
+    const presets = loadPresetDefs()
+    const presetList = `none, ${Object.keys(presets).join(', ')}`
 
     if (!name) {
-      console.error('❌ set-tier requires a preset name');
-      console.error(`   Available: ${presetList}`);
-      process.exit(1);
+      console.error('❌ set-tier requires a preset name')
+      console.error(`   Available: ${presetList}`)
+      process.exit(1)
     }
     if (name !== 'none' && !presets[name]) {
-      console.error(`❌ Unknown preset "${name}"`);
-      console.error(`   Available: ${presetList}`);
-      process.exit(1);
+      console.error(`❌ Unknown preset "${name}"`)
+      console.error(`   Available: ${presetList}`)
+      process.exit(1)
     }
 
     // Fail-fast: every provider's API key env var must be set before writing
     if (name !== 'none') {
       for (const [pid, provider] of Object.entries(presets[name].providers || {})) {
         if (!process.env[provider.apiKeyEnv]) {
-          console.error(`❌ Missing required API key configuration for provider "${pid}"`);
-          console.error('   Set the provider API key environment variable and retry.');
-          process.exit(1);
+          console.error(`❌ Missing required API key configuration for provider "${pid}"`)
+          console.error('   Set the provider API key environment variable and retry.')
+          process.exit(1)
         }
       }
     }
 
     const presetDir = isProject
       ? process.cwd()
-      : path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'opencode');
-    const filePath = path.join(presetDir, '.pantheon', 'active-preset.json');
-    const bakPath = path.join(presetDir, '.pantheon', 'active-preset.json.bak');
+      : path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'opencode')
+    const filePath = path.join(presetDir, '.pantheon', 'active-preset.json')
+    const bakPath = path.join(presetDir, '.pantheon', 'active-preset.json.bak')
 
-    let prevName = '(none)';
+    let prevName = '(none)'
     if (fs.existsSync(filePath)) {
       try {
-        prevName = JSON.parse(fs.readFileSync(filePath, 'utf8')).preset || '(unknown)';
-      } catch { prevName = '(unknown)'; }
+        prevName = JSON.parse(fs.readFileSync(filePath, 'utf8')).preset || '(unknown)'
+      } catch {
+        prevName = '(unknown)'
+      }
     }
 
     if (name === 'none') {
       if (isDryRun) {
-        console.log('[dry-run] Would clear model preset');
+        console.log('[dry-run] Would clear model preset')
       } else {
         if (fs.existsSync(filePath)) {
-          fs.mkdirSync(path.dirname(bakPath), { recursive: true });
-          fs.copyFileSync(filePath, bakPath);
-          fs.rmSync(filePath, { force: true });
+          fs.mkdirSync(path.dirname(bakPath), { recursive: true })
+          fs.copyFileSync(filePath, bakPath)
+          fs.rmSync(filePath, { force: true })
         }
-        console.log('Model preset cleared. Using opencode defaults.');
-        console.log(`   Backup: ${bakPath}`);
+        console.log('Model preset cleared. Using opencode defaults.')
+        console.log(`   Backup: ${bakPath}`)
       }
-      return;
+      return
     }
 
-    const result = writeActivePreset(presetDir, name, { dryRun: isDryRun, source: 'cli' });
+    const result = writeActivePreset(presetDir, name, { dryRun: isDryRun, source: 'cli' })
 
-    console.log(`Model preset set: ${prevName} → ${name}`);
+    console.log(`Model preset set: ${prevName} → ${name}`)
     for (const [agent, spec] of Object.entries(presets[name].agents || {})) {
-      console.log(`   ${agent}: ${spec.model} [${spec.reasoning_effort}]`);
+      console.log(`   ${agent}: ${spec.model} [${spec.reasoning_effort}]`)
     }
-    const providerNames = Object.keys(presets[name].providers || {});
-    console.log(`   Providers: ${providerNames.join(', ') || 'none'}`);
-    if (result.backupPath) console.log(`   Backup: ${result.backupPath}`);
-    return;
+    const providerNames = Object.keys(presets[name].providers || {})
+    console.log(`   Providers: ${providerNames.join(', ') || 'none'}`)
+    if (result.backupPath) console.log(`   Backup: ${result.backupPath}`)
+    return
   }
 
   if (command === 'init' || !command) {
-    const isProject = args.includes('--project');
-    const isDryRun = args.includes('--dry-run');
-    const skipMCP = args.includes('--no-mcp');
-    const forceReinstall = args.includes('--force');
-    const runDoctor = args.includes('--doctor');
-    const forceInteractive = args.includes('--interactive');
-    const forceHeadless = args.includes('--headless');
-    const autoYes = args.includes('--yes') || args.includes('-y');
-    const presetIndex = args.indexOf('--preset');
-    const presetOpt = presetIndex >= 0 ? (args[presetIndex + 1] ?? null) : null;
-
-    const components = ['agents', 'skills', 'instructions', 'commands', 'plugins'];
-    if (!skipMCP) components.push('runtime');
+    const isProject = args.includes('--project')
+    const isDryRun = args.includes('--dry-run')
+    const skipMCP = args.includes('--no-mcp')
+    const forceReinstall = args.includes('--force')
+    const runDoctor = args.includes('--doctor')
+    const forceInteractive = args.includes('--interactive')
+    const forceHeadless = args.includes('--headless')
+    const autoYes = args.includes('--yes') || args.includes('-y')
+    const presetIndex = args.indexOf('--preset')
+    const presetOpt = presetIndex >= 0 ? (args[presetIndex + 1] ?? null) : null
+
+    const components = ['agents', 'skills', 'instructions', 'commands', 'plugins']
+    if (!skipMCP) components.push('runtime')
 
     // Version info
-    let version = '?';
-    try {
-      const pkgPath = path.join(ROOT, 'package.json');
-      version = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version || '?';
-    } catch { /* use default */ }
+    const version = readVersion()
 
-    console.log('');
+    console.log('')
     if (!forceInteractive || isDryRun) {
-      console.log(`Pantheon OpenCode v${version} — ${isDryRun ? 'DRY RUN' : 'Installing...'}`);
-      console.log('');
+      console.log(`Pantheon OpenCode v${version} — ${isDryRun ? 'DRY RUN' : 'Installing...'}`)
+      console.log('')
     }
 
     try {
-      const { installOpenCode } = await import('../scripts/install/opencode.mjs');
-      const target = isProject ? process.cwd() : undefined;
+      const { installOpenCode } = await import('../scripts/install/opencode.mjs')
+      const target = isProject ? process.cwd() : undefined
       await installOpenCode(target, isDryRun, forceReinstall, components, {
         interactive: forceInteractive,
         headless: forceHeadless,
         yes: autoYes,
         preset: presetOpt,
-      });
+      })
     } catch (err) {
-      console.error(`❌ Installation failed: ${err.message}\n   Run with --no-mcp to skip Python dependencies:\n     npx pantheon-opencode init --no-mcp\n   Or retry with --force to recreate the venv:\n     npx pantheon-opencode init --force`);
-      process.exit(1);
+      console.error(
+        `❌ Installation failed: ${err.message}\n   Run with --no-mcp to skip Python dependencies:\n     npx pantheon-opencode init --no-mcp\n   Or retry with --force to recreate the venv:\n     npx pantheon-opencode init --force`,
+      )
+      process.exit(1)
     }
 
     if (runDoctor && !isDryRun) {
-      console.log('');
-      console.log('  Running health check...');
+      console.log('')
+      console.log('  Running health check...')
       try {
-        const { spawnSync } = await import('child_process');
-        const doctorScript = path.join(ROOT, 'scripts', 'doctor.mjs');
-        spawnSync(process.execPath, [doctorScript], { stdio: 'inherit', cwd: ROOT });
+        const { spawnSync } = await import('child_process')
+        const doctorScript = path.join(ROOT, 'scripts', 'doctor.mjs')
+        spawnSync(process.execPath, [doctorScript], { stdio: 'inherit', cwd: ROOT })
       } catch {
-        console.log('  ⚠️  Could not run doctor.mjs');
+        console.log('  ⚠️  Could not run doctor.mjs')
       }
     }
 
-    console.log('');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log(`  ✅ Pantheon OpenCode v${version} installed!`);
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log('');
-    console.log('  Next steps:');
-    console.log('  1. Verify installation:');
-    console.log('     npx pantheon-opencode doctor');
-    console.log('  2. Launch your AI coding tool (OpenCode, Claude Code, Cursor, etc.)');
-    console.log('  3. Invoke agents with @agent-name in chat');
-    console.log('  4. For project-local install:');
-    console.log('     npx pantheon-opencode init --project');
-    console.log('');
-
-    return;
+    console.log('')
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+    console.log(`  ✅ Pantheon OpenCode v${version} installed!`)
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+    console.log('')
+    console.log('  Next steps:')
+    console.log('  1. Verify installation:')
+    console.log('     npx pantheon-opencode doctor')
+    console.log('  2. Launch your AI coding tool (OpenCode, Claude Code, Cursor, etc.)')
+    console.log('  3. Invoke agents with @agent-name in chat')
+    console.log('  4. For project-local install:')
+    console.log('     npx pantheon-opencode init --project')
+    console.log('')
+
+    return
   }
 
-  printUsage();
-  process.exit(1);
+  printUsage()
+  process.exit(1)
 }
 
-main().catch(err => { console.error('Error:', err.stack); process.exit(1); });
+main().catch((err) => {
+  console.error('Error:', err.stack)
+  process.exit(1)
+})

package/opencode.json

@@ -29,7 +29,6 @@
     }
   },
   "instructions": ["AGENTS.md", "src/instructions/*.instructions.md"],
-  "plugin": ["/home/ils15/pantheon/src/plugins/pantheon-hooks.ts"],
   "mcp": {
     "bifrost": {
       "type": "remote",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",
@@ -21,7 +21,7 @@
     "version:status": "node scripts/versioning.mjs status",
     "version:apply": "node scripts/versioning.mjs apply",
     "version:check": "node scripts/version-check.mjs",
-    "release:dry-run": "node scripts/versioning.mjs status && npm pack --dry-run",
+    "release:dry-run": "node scripts/versioning.mjs status && node scripts/release-notes.mjs && npm pack --dry-run",
     "publish:next": "npm publish --tag next --access public",
     "lint": "npx biome ci .",
     "typecheck": "npx tsc --noEmit",
@@ -30,7 +30,8 @@
     "hooks:install": "pre-commit install",
     "hooks:update": "pre-commit autoupdate",
     "test:security": "npm run secret-scan && node tests/test_install_mcp_vision.mjs && node tests/test_doctor_layers.mjs",
-    "test:node": "node --test tests/*.mjs",
+    "test:node": "node --test tests/*.mjs tests/pantheon/*.mjs",
+    "test:ts": "for f in tests/pantheon/*.test.ts; do npx tsx \"$f\" || exit 1; done",
     "test": "python3 -m pytest tests/ -q 2>&1 || echo \"No tests found\"",
     "test:ci": "python3 -m pytest tests/ -q --tb=short 2>&1 || true"
   },
@@ -63,10 +64,14 @@
     "scripts/hooks/**",
     "src/mcp/requirements*",
     "src/plugins/tui/**",
-    "src/skills/**"
+    "!src/plugins/tui/node_modules/**",
+    "src/skills/**",
+    "!**/__pycache__/**",
+    "!**/*.pyc"
   ],
   "dependencies": {
-    "js-yaml": "^4.3.0"
+    "js-yaml": "^4.3.0",
+    "zod": "4.1.8"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.8.0",

package/scripts/cost.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * cost.mjs — read-only cost aggregation from opencode.db (Wave 4, PR #46).
+ *
+ * Fallback for the `pantheon_cost` tool when node:sqlite is unavailable in
+ * the plugin process (node < 22.5). Uses node:sqlite itself and prints a
+ * single JSON object to stdout:
+ *   { ok: true,  days, rows: [{agent, costUsd, tokensInput, tokensOutput}] }
+ *   { ok: false, error: "<message>" }          (exit code 1)
+ *
+ * NEVER writes to the database — opened read-only. Malformed rows are
+ * skipped; assistant messages carry the authoritative cost + tokens.
+ *
+ * Usage: node scripts/cost.mjs <dbPath> <days>
+ */
+import { existsSync } from 'node:fs'
+import { DatabaseSync } from 'node:sqlite'
+
+/**
+ * Fail via exitCode + natural process exit (NEVER process.exit right after
+ * stdout.write — the pipe is async and the write can be truncated).
+ */
+function fail(message) {
+  process.stderr.write(`cost.mjs: ${message}\n`)
+  process.stdout.write(JSON.stringify({ ok: false, error: message }))
+  process.exitCode = 1
+}
+
+function main() {
+  const [, , dbPath, daysArg] = process.argv
+  const days = Number(daysArg ?? '7')
+
+  if (!dbPath) return fail('missing <dbPath> argument')
+  if (!existsSync(dbPath)) return fail(`database not found: ${dbPath}`)
+
+  try {
+    const db = new DatabaseSync(dbPath, { readOnly: true })
+    const since = Date.now() - days * 86_400_000
+    const rows = db.prepare('SELECT data FROM message WHERE time_created >= ?').all(since)
+    db.close()
+
+    const byAgent = new Map()
+    for (const row of rows) {
+      try {
+        const outer = JSON.parse(String(row.data))
+        const info = typeof outer.data === 'string' ? JSON.parse(outer.data) : outer
+        if (info.role !== 'assistant') continue
+        const agent = typeof info.agent === 'string' && info.agent !== '' ? info.agent : null
+        if (!agent) continue
+        const costUsd = Number(info.cost) || 0
+        const tokensInput = Number(info.tokens?.input) || 0
+        const tokensOutput = Number(info.tokens?.output) || 0
+        const acc = byAgent.get(agent) ?? { agent, costUsd: 0, tokensInput: 0, tokensOutput: 0 }
+        acc.costUsd += costUsd
+        acc.tokensInput += tokensInput
+        acc.tokensOutput += tokensOutput
+        byAgent.set(agent, acc)
+      } catch {
+        // Skip malformed rows — a partial ledger never breaks the report.
+      }
+    }
+    const result = [...byAgent.values()].sort((a, b) => b.costUsd - a.costUsd)
+    process.stdout.write(JSON.stringify({ ok: true, days, rows: result }))
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err))
+  }
+}
+
+main()