pantheon-opencode 1.3.5-beta.57.2e03676 → 1.3.5

package/README.md

@@ -4,7 +4,7 @@
 <p align="center">
   <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="docs/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>
   <a href="commands/"><img src="https://img.shields.io/badge/commands-11-red" alt="Commands"></a>
   <a href="https://github.com/ils15/pantheon/actions"><img src="https://img.shields.io/github/actions/workflow/status/ils15/pantheon/ci.yml?branch=main&label=CI" alt="CI"></a>
@@ -22,7 +22,7 @@ Supports **OpenCode** — multi-agent orchestration for your editor.
 
 | Resource | Link |
 |----------|------|
-| 📖 **Agent Reference** | [src/agents/README.md](src/agents/README.md) — all 14 agents |
+| 📖 **Agent Reference** | [docs/agents/README.md](docs/agents/README.md) — all 14 agents |
 | 📖 **Skills Reference** | [src/skills/README.md](src/skills/README.md) — all 21 skills |
 | 🚀 **Installation Guide** | [docs/INSTALLATION.md](docs/INSTALLATION.md) |
 | 🔌 **MCP Server Guide** | [docs/mcp-recommendations.md](docs/mcp-recommendations.md) — recommended MCP servers for each project type |
@@ -324,7 +324,7 @@ child model's provider before dispatching (single source of truth:
 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
+`opencode-go/deepseek-v4-flash` (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).
@@ -518,7 +518,7 @@ Domain Specialist
   └── Gaia — remote sensing: LULC analysis, scientific literature
 ```
 
-> See [src/agents/README.md](src/agents/README.md) for the complete reference — each agent's
+> See [docs/agents/README.md](docs/agents/README.md) for the complete reference — each agent's
 > tools, model assignment, behavioral rules, and invocation patterns.
 
 ### Architecture Diagram
@@ -1097,7 +1097,7 @@ Pantheon draws from the broader multi-agent landscape while diverging in key way
 | [CHANGELOG.md](CHANGELOG.md) | Release history |
 | [docs/INSTALLATION.md](docs/INSTALLATION.md) | Installation guide |
 | [docs/platforms/opencode.md](docs/platforms/opencode.md) | OpenCode setup guide |
-| [src/agents/README.md](src/agents/README.md) | Agent directory |
+| [docs/agents/README.md](docs/agents/README.md) | Agent directory |
 | [src/skills/README.md](src/skills/README.md) | Skill directory |
 | [docs/mcp-tools.md](docs/mcp-tools.md) | Canonical MCP tool registry |
 | [docs/mcp-user-guide.md](docs/mcp-user-guide.md) | Adding custom MCP servers |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.3.5-beta.57.2e03676",
+  "version": "1.3.5",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",
@@ -51,6 +51,7 @@
     "skills-lock.json",
     "scripts/*.sh",
     "src/agents/*.md",
+    "!src/agents/README.md",
     "bin/*.mjs",
     "AGENTS.md",
     "opencode.json",

package/scripts/doctor.mjs

@@ -187,6 +187,26 @@ function showHelp() {
 // Helper utilities
 // ---------------------------------------------------------------------------
 
+/** @type {Set<string>} agent-defining frontmatter fields */
+const AGENT_FRONTMATTER_FIELDS = new Set(['name', 'description', 'mode'])
+
+/**
+ * Return true if the file content has YAML frontmatter containing at least
+ * one agent-defining field (name, description, or mode). Non-agent .md files
+ * such as README.md are excluded.
+ * @param {string} content
+ * @returns {boolean}
+ */
+export function isValidAgentFile(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+  if (!match) return false
+  const fm = match[1]
+  for (const field of AGENT_FRONTMATTER_FIELDS) {
+    if (new RegExp(`(?:^|\\r?\\n)${field}\\s*:`).test(fm)) return true
+  }
+  return false
+}
+
 /**
  * Collect canonical agent names from agents/*.md
  * @returns {string[]} sorted list of agent names (without extension)
@@ -195,7 +215,9 @@ function getCanonicalAgentNames() {
   if (!existsSync(AGENTS_DIR)) return []
   return readdirSync(AGENTS_DIR)
     .filter((f) => f.endsWith('.md'))
-    .map((f) => f.replace(/\.agent\.md$/, ''))
+    .map((f) => ({ name: f, path: join(AGENTS_DIR, f) }))
+    .filter(({ path: p }) => isValidAgentFile(readFileSync(p, 'utf8')))
+    .map(({ name }) => name.replace(/\.agent\.md$/, ''))
     .sort()
 }
 
@@ -1125,7 +1147,15 @@ export function deriveInstalledAgentFiles(configs) {
       continue
     }
     for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith('.md')) files.push(join(directory, entry.name))
+      if (!entry.isFile() || !entry.name.endsWith('.md')) continue
+      const filePath = join(directory, entry.name)
+      try {
+        if (isValidAgentFile(readFileSync(filePath, 'utf8'))) {
+          files.push(filePath)
+        }
+      } catch {
+        // unreadable — skip
+      }
     }
   }
   return [...new Set(files)].sort()

package/scripts/install/agents-md.mjs

@@ -76,7 +76,7 @@ export function readCanonicalAgents() {
   if (!existsSync(AGENTS_DIR)) return []
 
   const files = readdirSync(AGENTS_DIR)
-    .filter((f) => f.endsWith('.agent.md') || f.endsWith('.md'))
+    .filter((f) => (f.endsWith('.agent.md') || f.endsWith('.md')) && f.toLowerCase() !== 'readme.md')
     .sort()
 
   const agents = []

package/scripts/install/opencode.mjs

@@ -558,7 +558,9 @@ export async function installOpenCode(
     const agentsDir = join(ROOT, 'src', 'agents')
     if (!existsSync(agentsDir)) return {}
     const sources = {}
-    const files = readdirSync(agentsDir).filter((f) => f.endsWith('.agent.md') || f.endsWith('.md'))
+    const files = readdirSync(agentsDir).filter(
+      (f) => (f.endsWith('.agent.md') || f.endsWith('.md')) && f.toLowerCase() !== 'readme.md',
+    )
     for (const f of files) {
       const name = f.replace(/\.(agent\.)?md$/, '')
       sources[name] = `${agentPrefix}/${name}.md`
@@ -570,7 +572,9 @@ export async function installOpenCode(
     const agentsDir = join(ROOT, 'src', 'agents')
     if (!existsSync(agentsDir)) return {}
     const config = {}
-    const files = readdirSync(agentsDir).filter((f) => f.endsWith('.agent.md') || f.endsWith('.md'))
+    const files = readdirSync(agentsDir).filter(
+      (f) => (f.endsWith('.agent.md') || f.endsWith('.md')) && f.toLowerCase() !== 'readme.md',
+    )
     for (const f of files) {
       const name = f.replace(/\.(agent\.)?md$/, '')
       const content = readFileSync(join(agentsDir, f), 'utf8')

package/scripts/install/shared.mjs

@@ -33,7 +33,7 @@ export const PLATFORM_DIR = join(ROOT, 'platform')
 export function getAgentNames() {
   if (!existsSync(AGENTS_DIR)) return []
   return readdirSync(AGENTS_DIR)
-    .filter((f) => f.endsWith('.agent.md') || f.endsWith('.md'))
+    .filter((f) => (f.endsWith('.agent.md') || f.endsWith('.md')) && f.toLowerCase() !== 'readme.md')
     .map((f) => f.replace(/\.(agent\.)?md$/, ''))
     .sort()
 }
@@ -277,9 +277,11 @@ export function copyFiles(srcDir, dstDir, dryRun, renameMap = null, clean = fals
   // Build set of expected destination filenames (after rename)
   const dstNames = new Set()
   for (const entry of entries) {
+    if (entry.toLowerCase() === 'readme.md') continue
     const srcFile = join(srcDir, entry)
     if (!existsSync(srcFile)) continue
     const dstName = renameMap ? (renameMap(entry) ?? entry) : entry
+    if (dstName.toLowerCase() === 'readme.md') continue
     dstNames.add(dstName)
 
     const dstFile = join(dstDir, dstName)

package/src/agents/apollo.md

@@ -2,6 +2,9 @@
 name: apollo
 description: "Read-only investigation scout — 3-10 parallel searches across codebase, external docs, and GitHub. Called by: athena, zeus, hermes, aphrodite, demeter. No edits, no commands."
 mode: subagent
+visible: false
+tools:
+  task: false
 reasoning_effort: low
 permission:
   read: allow

package/src/agents/gaia.md

@@ -2,6 +2,9 @@
 name: gaia
 description: "Remote sensing domain specialist — satellite image processing, spectral analysis, SAR, change detection, time series, ML/DL classification. Read-only analysis of geospatial data."
 mode: subagent
+visible: false
+tools:
+  task: false
 reasoning_effort: low
 permission:
   read: allow

package/src/agents/zeus.md

@@ -37,7 +37,7 @@ skills:
 
 ## Golden Rule
 
-**Coordenador APENAS.** Leu arquivo → delegue. Nunca implemente, nunca edite, nunca debugue.
+**Coordenador APENAS. Zeus NUNCA lê arquivos de código-fonte.** Toda leitura de `src/`, `tests/`, `scripts/` vai para @apollo. Leia apenas: config, docs, memory bank, delegação.
 
 
 ## 🔒 Fusion-Style Enforcement
@@ -324,6 +324,10 @@ out = await guard.maybeRetry(result, async () => { ...task() de novo... })
 Regra: retry 1x APENAS em `empty-mode1`/`empty-mode2`. Resultado com conteudo
 nunca redispara. Apos 1 retry vazio → escalate (mesma regra do TODO Enforcer).
 
+> **Waves DEVEM usar `zeusDelegateWithRetry`** (`src/pantheon/zeus-delegate-with-retry.ts`) — encapsula `delegate → waitForTerminal → classify → retry 1x → escalate` com cap duro 1; se ainda vazio throw `ZeusEscalationError` (escale: tente outro agente, simplifique, manual).
+> Uso alto-nível: `import { zeusDelegateWithRetry } from './pantheon/zeus-delegate-with-retry.ts'` → `await zeusDelegateWithRetry({ board, client, sessionID, agent, prompt })`.
+> Uso baixo-nível: `createZeusRetryHelper().executeWithRetry(first, () => secondRead())` — classifica empty e decide retry/escalate (mesmo cap 1).
+
 ### /cost — pantheon_cost tool (WIRED no plugin)
 `pantheon_cost({ days?: number })` le o `opencode.db` READ-ONLY (node:sqlite;
 fallback `scripts/cost.mjs`) e devolve tabela markdown de custo + tokens por

package/src/pantheon/delegation-enforce.ts

@@ -169,6 +169,70 @@ export const DEFAULT_BLOCKED_TOOLS: ReadonlySet<string> = new Set([
   'hashline_edit',
 ])
 
+// ─── Zeus Read Guard ──────────────────────────────────────────────────
+
+/**
+ * Path patterns that Zeus must NOT read directly. Zeus must delegate
+ * codebase reads to @apollo to avoid context bloat and enforce separation
+ * of concerns.
+ */
+export const ZEUS_READ_DENY_PATTERNS: ReadonlyArray<RegExp> = [
+  /^src\//,
+  /^tests?\//,
+  /^scripts?\//,
+]
+
+/**
+ * Path exceptions that Zeus MAY read even if they match a deny pattern.
+ * Markdown files, .pantheon/ configs, and memories/ are operational context
+ * that Zeus legitimately needs.
+ */
+export const ALLOWED_PATHS: ReadonlyArray<RegExp> = [
+  /\.md$/,
+  /\.pantheon\//,
+  /memories\//,
+]
+
+/**
+ * Zeus read guard. When the active agent is Zeus, deny read/glob/grep calls
+ * that target source code, tests, or scripts — Zeus must delegate those to
+ * @apollo. Allowed paths (markdown, .pantheon/, memories/) are exempt.
+ *
+ * Non-Zeus sessions are never affected.
+ *
+ * @throws {Error} when Zeus attempts a denied read
+ */
+export function zeusReadGuard(
+  tool: string,
+  args: unknown,
+  agent: string | undefined,
+): void {
+  if (agent !== 'zeus') return
+  if (tool !== 'read' && tool !== 'glob' && tool !== 'grep') return
+
+  const record = args as Record<string, unknown> | undefined
+  const filePath =
+    typeof record?.filePath === 'string'
+      ? record.filePath
+      : typeof record?.pattern === 'string'
+        ? record.pattern
+        : undefined
+
+  if (!filePath) return
+
+  for (const pattern of ZEUS_READ_DENY_PATTERNS) {
+    if (pattern.test(filePath)) {
+      // Check allowed-path exceptions before denying
+      for (const allowed of ALLOWED_PATHS) {
+        if (allowed.test(filePath)) return
+      }
+      throw new Error(
+        `Zeus cannot read ${filePath} — delegate to @apollo`,
+      )
+    }
+  }
+}
+
 // ─── Registry ──────────────────────────────────────────────────────────
 
 /**

package/src/pantheon/delegation.ts

@@ -365,15 +365,18 @@ export interface ChildSessionModelRef {
 }
 
 /**
- * Known-good fallback model (P1, 2026-08-11 — release 1.3.4): when an
+ * Known-good fallback model (P1, 2026-08-11 — release 1.3.4, updated
+ * 2026-08-21 for sandbox without PANTHEON_OPENCODE_API_KEY): when an
  * AUTO-RESOLVED model (routing.yml agent entry / active preset) points at a
  * provider whose API key is not configured, the child is dispatched on the
- * native `opencode` provider instead — verified to work in the field without
- * an external provider key. Validated with the same providerKeyConfigured
- * gate as the resolved model; an explicit caller-supplied `model` always wins
- * over this fallback.
+ * `opencode-go` provider instead — `opencode-go/deepseek-v4-flash`
+ * via https://opencode.ai/zen/go/v1 works without an external API key
+ * (Go subscription / opencode auth, sandbox default). Validated with the
+ * same providerKeyConfigured gate as the resolved model, with an
+ * opencode-go exception for the sandbox; an explicit caller-supplied
+ * `model` always wins over this fallback.
  */
-const FALLBACK_MODEL = 'opencode/deepseek-v4-flash-free'
+const FALLBACK_MODEL = 'opencode-go/deepseek-v4-flash'
 
 /**
  * Split a `provider/model` model ID (e.g. `opencode/deepseek-v4-flash-free`)
@@ -484,7 +487,7 @@ function resolveUsableChildModel(
 
   // Auto-resolved (agentModels / preset) → try the known-good fallback.
   const fallback = splitModelRef(FALLBACK_MODEL)
-  if (fallback !== undefined && missingProviderKeyEnv(fallback.providerID, { env }) === undefined) {
+  if (fallback !== undefined && (fallback.providerID === 'opencode-go' || missingProviderKeyEnv(fallback.providerID, { env }) === undefined)) {
     warn(
       `[pantheon-delegate] provider "${model.providerID}" requires API key ${missingVar} ` +
         `(unset) — falling back to ${FALLBACK_MODEL}`,
@@ -653,7 +656,7 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       // preset) is used when its provider key is configured; an explicit
       // caller model is always respected (warned); an auto-resolved model
       // whose provider key is missing falls back to the known-good
-      // opencode/deepseek-v4-flash-free; if nothing usable remains the
+      // opencode-go/deepseek-v4-flash; if nothing usable remains the
       // failure is returned as TEXT below — no session, no board job.
       const resolved = resolveUsableChildModel(options, args.agent, args.model)
       if (resolved.error !== undefined) {

package/src/pantheon/goal-loop.ts

@@ -20,6 +20,7 @@ import type { BackgroundJobBoard } from './background-job-board.ts'
 import type { ToolContextLike } from './delegation.ts'
 import { GoalStore } from './goal-store.ts'
 import { createPantheonLogger } from './logger.ts'
+import { safeSessionPath } from './session-guard.ts'
 import type { TodoEnforcerMessage } from './todo-enforcer.ts'
 
 // Silence-by-default TUI policy (pantheon-hooks L42-58): warn → hooks.log,
@@ -188,8 +189,13 @@ export class GoalLoop {
     this.lastContinuationAt.set(sessionID, now)
     const inherited = await this.inheritAgentOrModel(sessionID)
     const prompt = GOAL_CONTINUATION_PROMPT.replace('{objective}', goal.objective)
+    const promptPath = safeSessionPath(sessionID)
+    if (!promptPath) {
+      this.warn(`goal continuation skipped: invalid sessionID "${sessionID}"`)
+      return
+    }
     await this.client.session.promptAsync({
-      path: { id: sessionID },
+      path: promptPath.path,
       body: {
         ...(inherited.agent !== undefined ? { agent: inherited.agent } : {}),
         ...(inherited.model !== undefined ? { model: inherited.model } : {}),
@@ -206,7 +212,12 @@ export class GoalLoop {
    * continuation runs in the same context as the session's last turn.
    */
   private async inheritAgentOrModel(sessionID: string): Promise<InheritedContext> {
-    const messages = await this.client.session.messages({ path: { id: sessionID } })
+    const path = safeSessionPath(sessionID)
+    if (!path) {
+      this.warn(`inherit skipped: invalid sessionID "${sessionID}"`)
+      return {}
+    }
+    const messages = await this.client.session.messages(path)
     for (const msg of [...messages].reverse()) {
       const info = msg.info
       if (info === undefined || info.role !== 'assistant') continue

package/src/pantheon/presets.mjs

@@ -402,6 +402,7 @@ function providerDefKeyConfigured(provider, env) {
  * @returns {string|undefined} missing env var name, or undefined when usable
  */
 export function missingProviderKeyEnv(providerID, { env = process.env, routingPath } = {}) {
+  if (providerID === 'opencode-go') return undefined
   const defs = loadPresetDefs(routingPath)
   for (const def of Object.values(defs)) {
     const provider = def?.providers?.[providerID]

package/src/pantheon/session-guard.ts

@@ -0,0 +1,50 @@
+/**
+ * Session Guard — shared server-side validation for session IDs.
+ *
+ * Opencode session IDs always start with "ses". The TUI previously forwarded
+ * the literal template placeholder "{sessionID}" (URL-encoded as "%7BsessionID%7D")
+ * into `session.children`, causing ~1.5 errors/s from the 1s safety poll.
+ * This module is the single chokepoint: every `client.session.*({path:{id}})`;
+ * call site MUST go through `safeSessionPath`/`buildChildrenPath`, which
+ * reject placeholders before they reach the server (fail-open: warn + return,
+ * never throw, never send the placeholder).
+ *
+ * Mirrors the TUI's `src/plugins/tui/src/index.tsx` contract verbatim so both
+ * sides agree on what "valid" means. The TUI file remains self-contained
+ * (dist/tui.tsx is a raw copy, no relative imports), so its local copy is kept
+ * in sync — this module is the shared source for `src/pantheon/*` and
+ * `src/plugin.ts`.
+ *
+ * @module session-guard
+ */
+
+/**
+ * Server-aligned session id validity: opencode rejects anything not starting
+ * with "ses" (SchemaError). Mirrors that exact contract — nothing stricter,
+ * nothing looser — so "{sessionID}", "%7BsessionID%7D", "", "wrk_…" never
+ * reach a path.
+ */
+export function isValidSessionId(id: unknown): id is string {
+  return typeof id === 'string' && id.startsWith('ses')
+}
+
+/**
+ * The single choke point for every `session.*({path:{id}})` call.
+ * Returns `{path:{id}}` ONLY for a server-valid id; otherwise null so the
+ * caller skips the call entirely (fail-open).
+ */
+export function safeSessionPath(id: unknown): { path: { id: string } } | null {
+  if (!isValidSessionId(id)) return null
+  return { path: { id } }
+}
+
+/**
+ * Build the `session.children` path ONLY from a validated session id.
+ * Delegates to {@link safeSessionPath} — the single choke point. Returns
+ * null for null/invalid ids so the caller skips the fetch.
+ */
+export function buildChildrenPath(
+  id: string | null | undefined,
+): { path: { id: string } } | null {
+  return safeSessionPath(id)
+}

package/src/pantheon/todo-enforcer.ts

@@ -49,6 +49,7 @@
 
 import type { BackgroundJobBoard } from './background-job-board.ts'
 import { createPantheonLogger } from './logger.ts'
+import { buildChildrenPath, safeSessionPath } from './session-guard.ts'
 
 // Silence-by-default TUI policy (pantheon-hooks L42-58): the default warn
 // fallback logs to .pantheon/logs/hooks.log; console echo is opt-in via
@@ -233,8 +234,13 @@ export class TodoEnforcer {
    */
   async listPendingTodos(sessionID: string): Promise<TodoLike[]> {
     if (!this.options.enabled) return []
+    const path = safeSessionPath(sessionID)
+    if (!path) {
+      this.warn(`todo list skipped: invalid sessionID "${sessionID}"`)
+      return []
+    }
     try {
-      const todos = await this.client.session.todo({ path: { id: sessionID } })
+      const todos = await this.client.session.todo(path)
       return todos.filter((todo) => todo.status !== 'completed' && todo.status !== 'cancelled')
     } catch (err: unknown) {
       const reason = err instanceof Error ? err.message : String(err)
@@ -280,7 +286,12 @@ export class TodoEnforcer {
     // still waiting on it, so skip.
     if ((await this.activeChildren(sessionID, now)) > 0) return
 
-    const todos = await this.client.session.todo({ path: { id: sessionID } })
+    const path = safeSessionPath(sessionID)
+    if (!path) {
+      this.warn(`todo check skipped: invalid sessionID "${sessionID}"`)
+      return
+    }
+    const todos = await this.client.session.todo(path)
     const incomplete = todos.filter(
       (todo) => todo.status !== 'completed' && todo.status !== 'cancelled',
     ).length
@@ -328,8 +339,13 @@ export class TodoEnforcer {
     // (throwing) injection still applies the cooldown — no hot retry loop.
     this.lastInjectionAt.set(sessionID, now)
     const inherited = await this.inheritAgentOrModel(sessionID)
+    const promptPath = safeSessionPath(sessionID)
+    if (!promptPath) {
+      this.warn(`todo injection skipped: invalid sessionID "${sessionID}"`)
+      return
+    }
     await this.client.session.promptAsync({
-      path: { id: sessionID },
+      path: promptPath.path,
       body: {
         ...(inherited.agent !== undefined ? { agent: inherited.agent } : {}),
         ...(inherited.model !== undefined ? { model: inherited.model } : {}),
@@ -368,8 +384,13 @@ export class TodoEnforcer {
    * version-sensitive runtimes.
    */
   private async activeChildren(sessionID: string, now: number): Promise<number> {
+    const path = safeSessionPath(sessionID)
+    if (!path) {
+      this.warn(`children check skipped: invalid sessionID "${sessionID}"`)
+      return 0
+    }
     try {
-      const children = await this.client.session.children({ path: { id: sessionID } })
+      const children = await this.client.session.children(path)
       return children.filter((child) => this.isChildActive(child, now)).length
     } catch (err: unknown) {
       const reason = err instanceof Error ? err.message : String(err)
@@ -398,7 +419,12 @@ export class TodoEnforcer {
    * SDK then applies the session default.
    */
   private async inheritAgentOrModel(sessionID: string): Promise<InheritedContext> {
-    const messages = await this.client.session.messages({ path: { id: sessionID } })
+    const path = safeSessionPath(sessionID)
+    if (!path) {
+      this.warn(`inherit skipped: invalid sessionID "${sessionID}"`)
+      return {}
+    }
+    const messages = await this.client.session.messages(path)
     for (const msg of [...messages].reverse()) {
       const info = msg.info
       if (info === undefined || info.role !== 'assistant') continue

package/src/pantheon/todo-preserve.ts

@@ -48,6 +48,7 @@
  */
 
 import { createPantheonLogger } from './logger.ts'
+import { safeSessionPath } from './session-guard.ts'
 import type { TodoLike } from './todo-enforcer.ts'
 
 // Silence-by-default TUI policy (pantheon-hooks L42-58): console echo is
@@ -173,8 +174,13 @@ export class TodoPreserver {
    */
   async capture(sessionID: string): Promise<void> {
     this.pruneExpired()
+    const path = safeSessionPath(sessionID)
+    if (!path) {
+      this.warn(`todo snapshot capture skipped: invalid sessionID "${sessionID}"`)
+      return
+    }
     try {
-      const todos = await this.client.session.todo({ path: { id: sessionID } })
+      const todos = await this.client.session.todo(path)
       if (todos.length === 0) {
         // Nothing to preserve → drop any stale entry so no restore happens.
         this.snapshots.delete(sessionID)

package/src/pantheon/vision.ts

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url'
 import type { Hooks, PluginInput } from '@opencode-ai/plugin'
 import type { FilePart, Part, TextPart, UserMessage } from '@opencode-ai/sdk'
 import type { ResolvedPreset } from './presets.mjs'
-import { hasVision, resolveActivePreset, visionBrokenOnGateway } from './presets.mjs'
+import { CAPABILITY_TABLE, hasVision, resolveActivePreset, visionBrokenOnGateway } from './presets.mjs'
 
 // ─── Constants ────────────────────────────────────────────────────────────
 
@@ -121,9 +121,30 @@ type NativeVisionEndpoint = { modelID: string; baseURL: string }
 
 export type VisionMode = 'native' | 'tool' | 'auto'
 
+/**
+ * Check whether a provider is text-only by examining CAPABILITY_TABLE.
+ * A provider is text-only if ALL provider-qualified entries (prefix starting
+ * with `providerID/`) have `vision: false`. If no provider-qualified entries
+ * exist, the provider is unknown → returns false (fail-open).
+ */
+export function providerIsTextOnly(providerID: string): boolean {
+  const providerEntries = CAPABILITY_TABLE.filter((entry) =>
+    entry.prefix.startsWith(`${providerID}/`),
+  )
+  if (providerEntries.length === 0) return false
+  return providerEntries.every((entry) => !entry.vision)
+}
+
 /** Return whether OpenCode's current model is known to accept image input. */
-export function modelAcceptsImages(model: ModelInfo | undefined): boolean {
-  if (!model) return true
+export function modelAcceptsImages(
+  model: ModelInfo | undefined,
+  providerID?: string,
+): boolean {
+  if (!model) {
+    // Fail-closed for known text-only providers
+    if (providerID && providerIsTextOnly(providerID)) return false
+    return true
+  }
   try {
     const id = `${model.providerID}/${model.modelID}`
     // Provider/gateway-aware: a model can be vision-capable per models.dev
@@ -1230,7 +1251,7 @@ export function createVisionHandler(input: PluginInput) {
       const message: UserMessage | undefined = output?.message
       if (!message || message.role !== 'user') return
       const model = hookInput?.model ?? message.model
-      if (modelAcceptsImages(model)) {
+      if (modelAcceptsImages(model, model?.providerID)) {
         nativeVisionSessions.add(hookInput.sessionID)
         return
       }

package/src/pantheon/zeus-delegate-with-retry.ts

@@ -0,0 +1,332 @@
+/**
+ * Zeus Delegate With Retry (Wave 4, empty-mode fix) — helper for Zeus waves.
+ *
+ * Opencode 1.18.x cannot intercept `task()` completion via hooks, so the
+ * `dispatch-guard` lib is NOT wired in the plugin. Zeus waves MUST use this
+ * helper manually: it encapsulates
+ *
+ *   delegate → waitForTerminal → classify via createDispatchGuard
+ *            → maybeRetry 1x on empty-mode1/mode2 → escalate
+ *
+ * Retry cap is HARD at 1 (never 2x). The guard is stateful per helper
+ * instance — one retry budget total. Fail-open on missing APIs is NOT
+ * applicable here: a failed delegate throws/log+escalate so the wave can
+ * decide (a) retry with different agent, (b) simplify, (c) manual.
+ *
+ * Two usage shapes:
+ *   1. High-level: `zeusDelegateWithRetry({ board, client, sessionID, agent, prompt })`
+ *      — creates child session, registers board, promptAsync, waitForTerminal,
+ *        reads report, classifies, retries once if empty, escalates if still empty.
+ *   2. Low-level: `createZeusRetryHelper()` — wraps a generic
+ *      `() => Promise<DispatchResultLike>` pair via `executeWithRetry`.
+ *
+ * The high-level helper is the one Zeus waves should import:
+ *
+ * ```ts
+ * import { zeusDelegateWithRetry } from './pantheon/zeus-delegate-with-retry.ts'
+ * const { report, alias, taskID, retried, classification } =
+ *   await zeusDelegateWithRetry({ board, client, sessionID, agent: 'apollo', prompt })
+ * ```
+ *
+ * If the result is empty after one retry, the helper THROWS with an
+ * `EscalationError` — the wave must catch and escalate to the user (see
+ * `src/agents/zeus.md` "Waves with Retry").
+ *
+ * Pure TypeScript — no direct SDK import. Board/client are structural.
+ *
+ * @module zeus-delegate-with-retry
+ */
+
+import type { BackgroundJobBoard } from './background-job-board.ts'
+import type { DelegationClient } from './delegation-finalize.ts'
+import { readDelegationReport } from './delegation-finalize.ts'
+import { DELEGATION_DEFAULTS } from './delegation-finalize.ts'
+import {
+  createDispatchGuard,
+  type DispatchClassification,
+  type DispatchGuard,
+  type DispatchGuardOptions,
+  type DispatchResultLike,
+} from './dispatch-guard.ts'
+import { createPantheonLogger } from './logger.ts'
+import { safeSessionPath } from './session-guard.ts'
+
+const log = createPantheonLogger({ module: 'pantheon-zeus-retry' })
+
+// ─── Types ───────────────────────────────────────────────────────────────
+
+export interface ZeusDelegateWithRetryOptions {
+  /** Board singleton (same instance the plugin uses). */
+  board: BackgroundJobBoard
+  /** Delegation client (adapted SDK client, e.g. adaptDelegationClient). */
+  client: DelegationClient
+  /** Parent session that delegates (must be a valid ses_ id). */
+  sessionID: string
+  /** Target agent (e.g. "apollo", "hermes"). */
+  agent: string
+  /** Task prompt delivered to the background agent. */
+  prompt: string
+  /** Human-readable description shown on the job board. */
+  description?: string
+  /** Explicit model for the child session (provider/model). */
+  model?: { id: string; providerID: string }
+  /** Timeout for board.waitForTerminal (ms). Default: DELEGATION_DEFAULTS.readTimeoutMs */
+  readTimeoutMs?: number
+  /** Retry on empty results. Default: true */
+  retryOnEmpty?: boolean
+  /** Injectable logger. Default: file log (PANTHEON_HOOKS_LOG gate). */
+  logger?: { warn: (message: string) => void; info?: (message: string) => void }
+  /** Output dir for delegation reports. Default: DELEGATION_DEFAULTS.outputDir */
+  outputDir?: string
+}
+
+export interface ZeusDelegateResult {
+  /** Job alias (e.g. "apo-1"). */
+  alias: string
+  /** Child session id (= board task id). */
+  taskID: string
+  /** Report markdown (with Agent Activity section when sampled). */
+  report: string
+  /** Classification of the final result. */
+  classification: DispatchClassification
+  /** True when a retry was fired (cap 1). */
+  retried: boolean
+}
+
+/**
+ * Thrown when a delegate returns empty even after one retry — the wave must
+ * escalate (try different agent, simplify scope, or manual intervention).
+ */
+export class ZeusEscalationError extends Error {
+  constructor(
+    public readonly agent: string,
+    public readonly prompt: string,
+    public readonly classification: DispatchClassification,
+  ) {
+    super(
+      `Zeus delegate escalate: agent "${agent}" returned ${classification} even after retry (prompt: "${prompt.slice(0, 80)}") — escalate to user: (a) try different agent, (b) simplify scope, (c) manual`,
+    )
+    this.name = 'ZeusEscalationError'
+  }
+}
+
+// ─── Low-level helper — wraps any async delegate+read pair ───────────────
+
+/**
+ * Low-level retry helper. Zeus waves that already have a `delegate+read`
+ * pair can use this directly without the board/client machinery:
+ *
+ * ```ts
+ * const guard = createZeusRetryHelper({ logger })
+ * const out = await guard.executeWithRetry(
+ *   () => firstRead(),
+ *   () => secondRead(),
+ * )
+ * if (out.escalate) throw new ZeusEscalationError(...)
+ * ```
+ */
+export interface ZeusRetryHelper {
+  guard: DispatchGuard
+  /**
+   * Classify `first` and, if empty and budget allows, run `redispatch` once.
+   * Returns the final result plus escalation flag (true when still empty after
+   * the one allowed retry).
+   */
+  executeWithRetry(
+    first: DispatchResultLike,
+    redispatch: () => Promise<DispatchResultLike>,
+  ): Promise<{
+    result: DispatchResultLike
+    classification: DispatchClassification
+    retried: boolean
+    escalate: boolean
+  }>
+}
+
+export function createZeusRetryHelper(
+  options?: DispatchGuardOptions,
+): ZeusRetryHelper {
+  const guard = createDispatchGuard(options)
+  return {
+    guard,
+    async executeWithRetry(first, redispatch) {
+      const out = await guard.maybeRetry(first, redispatch)
+      const escalate = out.classification !== 'content'
+      return {
+        result: out.result,
+        classification: out.classification,
+        retried: out.retried,
+        escalate,
+      }
+    },
+  }
+}
+
+// ─── High-level helper — full delegate → wait → read → retry → escalate ───
+
+/**
+ * High-level helper Zeus waves MUST use (see `src/agents/zeus.md`).
+ * Delegates a background agent as a child session, waits for terminal,
+ * classifies via `createDispatchGuard`, retries ONCE on empty-mode1/mode2,
+ * and escalates (throws `ZeusEscalationError`) if still empty.
+ *
+ * Not wired automatically in the plugin — opencode 1.18.x cannot intercept
+ * task completion via hooks, so wiring is manual-orchestration only.
+ */
+export async function zeusDelegateWithRetry(
+  opts: ZeusDelegateWithRetryOptions,
+): Promise<ZeusDelegateResult> {
+  const logger = opts.logger ?? log
+  const warn = logger.warn.bind(logger)
+  const board = opts.board
+  const client = opts.client
+  const sessionID = opts.sessionID
+
+  const sessionPath = safeSessionPath(sessionID)
+  if (!sessionPath) {
+    warn(`zeusDelegateWithRetry: invalid sessionID "${sessionID}" — aborting`)
+    throw new Error(`invalid sessionID: ${sessionID}`)
+  }
+
+  const readTimeoutMs = opts.readTimeoutMs ?? DELEGATION_DEFAULTS.readTimeoutMs
+  const outputDir = opts.outputDir ?? DELEGATION_DEFAULTS.outputDir
+  const retryHelper = createZeusRetryHelper({
+    retryOnEmpty: opts.retryOnEmpty ?? true,
+    logger,
+  })
+
+  // One delegate+read attempt. Factored so maybeRetry can invoke a second
+  // attempt with a fresh child session + board job.
+  async function runOnce(): Promise<{
+    alias: string
+    taskID: string
+    report: string
+    dispatchResult: DispatchResultLike
+  }> {
+    // 1. Create child session (parentID = caller). No model forwarding here —
+    // delegation.ts resolves models via routing.yml; this helper uses the
+    // bare SDK default unless opts.model is supplied (explicit caller intent).
+    let childID: string
+    try {
+      const created = await client.session.create({
+        body: {
+          parentID: sessionID,
+          title: opts.description ?? opts.prompt.slice(0, 80),
+          ...(opts.model !== undefined ? { model: opts.model } : {}),
+        },
+      })
+      childID = created.id
+    } catch (err: unknown) {
+      const reason = err instanceof Error ? err.message : String(err)
+      warn(`zeusDelegateWithRetry: session.create failed: ${reason}`)
+      throw new Error(`delegate session.create failed: ${reason}`)
+    }
+
+    const childPath = safeSessionPath(childID)
+    if (!childPath) {
+      warn(`zeusDelegateWithRetry: child sessionID invalid "${childID}"`)
+      throw new Error(`invalid child sessionID: ${childID}`)
+    }
+
+    // 2. Register on board (taskID == child session id)
+    const job = await board.registerLaunch({
+      taskID: childID,
+      parentSessionID: sessionID,
+      agent: opts.agent,
+      description: opts.description ?? opts.prompt,
+      objective: opts.prompt,
+    })
+
+    // 3. Fire-and-forget promptAsync on the child. Completion is observed via
+    // board.waitForTerminal, not via noReply — the spike refuted noReply.
+    // A promptAsync failure is logged but does not abort the wait — the board
+    // timeout will finalize the job.
+    void client.session
+      .promptAsync({
+        path: childPath.path,
+        body: { agent: opts.agent, parts: [{ type: 'text', text: opts.prompt }] },
+      })
+      .catch((err: unknown) => {
+        const reason = err instanceof Error ? err.message : String(err)
+        warn(`zeusDelegateWithRetry: promptAsync failed for ${childID}: ${reason}`)
+      })
+
+    // 4. Wait for terminal state
+    let terminal: Awaited<ReturnType<BackgroundJobBoard['waitForTerminal']>>
+    try {
+      terminal = await board.waitForTerminal(childID, readTimeoutMs)
+    } catch {
+      // Timed out waiting — treat as empty so the guard retries once
+      return {
+        alias: job.alias,
+        taskID: childID,
+        report: '',
+        dispatchResult: { content: '' },
+      }
+    }
+
+    // 5. Read report markdown
+    const report = (await readDelegationReport(outputDir, terminal)) ?? ''
+
+    // DispatchResultLike for classification: content = report markdown.
+    // Tokens are unavailable from the board/report path → mode1 when empty.
+    const dispatchResult: DispatchResultLike = { content: report }
+
+    return { alias: job.alias, taskID: childID, report, dispatchResult }
+  }
+
+  // First attempt
+  const first = await runOnce()
+
+  // Classify + maybe retry once — capture second run's metadata via closure
+  let secondRun: typeof first | undefined
+  const out = await retryHelper.executeWithRetry(first.dispatchResult, async () => {
+    const second = await runOnce()
+    secondRun = second
+    return second.dispatchResult
+  })
+
+  // When retried, return second run's report or escalate
+  if (out.retried && secondRun !== undefined) {
+    if (out.classification === 'content') {
+      return {
+        alias: secondRun.alias,
+        taskID: secondRun.taskID,
+        report: secondRun.report,
+        classification: out.classification,
+        retried: true,
+      }
+    }
+    // Still empty after retry → escalate
+    throw new ZeusEscalationError(opts.agent, opts.prompt, out.classification)
+  }
+
+  // No retry, or first was content
+  if (out.classification !== 'content') {
+    // Empty and retry budget exhausted (or retryOnEmpty:false) → escalate
+    // But if we already retried and failed we threw above; this path is for
+    // the case where maybeRetry did NOT retry (budget exhausted or disabled)
+    // and the first result was empty. Per spec, one retry is allowed — if
+    // maybeRetry didn't retry, we should NOT auto-escalate here unless the
+    // guard's budget was used. Instead, treat as final empty that still
+    // requires escalation when retried==false but classification empty and
+    // retryOnEmpty was true but guard had no budget left? The guard already
+    // enforces cap 1, so after one retry escalate is required. For the
+    // first-attempt-empty with no retry (retryOnEmpty false), we still escalate
+    // so the wave knows to handle it.
+    if (out.retried) {
+      throw new ZeusEscalationError(opts.agent, opts.prompt, out.classification)
+    }
+    // No retry happened — still empty. Escalate so the wave doesn't silently
+    // use an empty report.
+    throw new ZeusEscalationError(opts.agent, opts.prompt, out.classification)
+  }
+
+  return {
+    alias: first.alias,
+    taskID: first.taskID,
+    report: first.report,
+    classification: out.classification,
+    retried: out.retried,
+  }
+}

package/src/plugin.ts

@@ -15,6 +15,7 @@ import {
   createEnforcementGuard,
   readOnlyRegistry,
   SessionHierarchyRegistry,
+  zeusReadGuard,
 } from './pantheon/delegation-enforce.ts'
 import { handleDelegationEvent } from './pantheon/delegation-notify.ts'
 import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
@@ -23,6 +24,7 @@ import { createReadEnhancer } from './pantheon/hashline/read-enhancer.ts'
 import { createHashlineEditTool } from './pantheon/hashline/tool.ts'
 import { createIdleDispatcher } from './pantheon/idle-continuation.ts'
 import { createPantheonLogger } from './pantheon/logger.ts'
+import { safeSessionPath } from './pantheon/session-guard.ts'
 import { pantheonPluginOnce } from './pantheon/plugin-once.ts'
 import { applyActivePresetToConfig, loadRoutingAgentModels } from './pantheon/presets.mjs'
 import {
@@ -193,15 +195,25 @@ function adaptDelegationClient(client: PluginInput['client']): DelegationClient
         return { id: result.data.id }
       },
       promptAsync: async (input) => {
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] promptAsync skipped: invalid sessionID "${input.path.id}"`)
+          throw new Error(`invalid sessionID: ${input.path.id}`)
+        }
         const result = await client.session.promptAsync({
-          path: input.path,
+          path: path.path,
           body: { agent: input.body.agent, parts: input.body.parts },
         })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       messages: async (input) => {
-        const result = await client.session.messages({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] messages skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.messages({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
@@ -219,22 +231,42 @@ function adaptTodoEnforcerClient(client: PluginInput['client']): TodoEnforcerCli
   return {
     session: {
       todo: async (input) => {
-        const result = await client.session.todo({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] todo skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.todo({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       messages: async (input) => {
-        const result = await client.session.messages({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] messages skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.messages({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       children: async (input) => {
-        const result = await client.session.children({ path: input.path })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] children skipped: invalid sessionID "${input.path.id}"`)
+          return []
+        }
+        const result = await client.session.children({ path: path.path })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
       promptAsync: async (input) => {
-        const result = await client.session.promptAsync({ path: input.path, body: input.body })
+        const path = safeSessionPath(input.path.id)
+        if (!path) {
+          log.warn(`[Pantheon Plugin] promptAsync skipped: invalid sessionID "${input.path.id}"`)
+          throw new Error(`invalid sessionID: ${input.path.id}`)
+        }
+        const result = await client.session.promptAsync({ path: path.path, body: input.body })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
         return result.data
       },
@@ -484,11 +516,13 @@ const plugin: Plugin = async (input: PluginInput) => {
     // Phase 4: deny mutating tools in read-only delegated sessions. Additive
     // key — does not touch Phase 3's tools/event/onTerminal/chat.message.
     'tool.execute.before': async (input, output) => {
-      // Chain: the read-only enforcement guard runs first (denies mutating
-      // tools in read-only sessions), then release-134 Phase 3 rewrites the
-      // first post-compaction `todowrite` with the captured todo snapshot.
-      // Both are no-ops for non-matching sessions/tools; the preserver is
-      // fail-open (only its intentional restore denial throws).
+      // Chain: Zeus read guard runs first (denies read/glob/grep of source
+      // code when the active agent is Zeus — delegate to @apollo), then the
+      // read-only enforcement guard (denies mutating tools in read-only
+      // sessions), then release-134 Phase 3 rewrites the first
+      // post-compaction `todowrite` with the captured todo snapshot. All are
+      // no-ops for non-matching sessions/tools.
+      zeusReadGuard(input.tool, output?.args, sessionAgents.get(input.sessionID))
       await enforcementGuard(input, output)
       await todoPreserver.beforeTodoWrite(input, output)
     },

package/src/plugins/tui/dist/tui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAm5BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBA8GmB,sBAAsB,cAAc,QAAQ;;;;;;;;iBAwC5C,yBAAyB,eAAe,QAAQ;;;;;;;;iBAWtD,sBACd;EAAS;EAAoB;eAC7B;;;;;;iBAYc,YAAY;;;iBAMZ,WAAW;;;;iBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;iBAWhD,sBACd,cAAc,mBACd,uBACC;;;iBAQa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAO9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAS5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KA2DS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;KAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;iBAac,wBACd,MAAM,oBACN,eACC;;;iBA+Ea,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBA+Fc,sBACd,KAAK,YAAY,sBACjB;;;;;;iBAiBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA2Ba,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;iBAWc,kBAAkB,MAAM,sBAAsB;;;;;;iBAqB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;iBA8Da,iBAAiB,cAAc;;;;KAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;iBASlC,wBAAwB,SAAS;;;;;;;;iBAmBjC,gBAAgB;EAAgB;IAAQ;;;;;;;iBASxC,kBAAkB;EAAkC;IAAQ;;;;KAKhE;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;iBAQY,mBAAmB;;;;;iBASnB,cAAc,OAAO;;;;;;;;;;;;;;iBAiBrB,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBAwCa,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KA8KU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAicI,QAAQ;EAAoB"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAq6BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBA8GmB,sBAAsB,cAAc,QAAQ;;;;;;;;iBAwC5C,yBAAyB,eAAe,QAAQ;;;;;;;;iBAWtD,sBACd;EAAS;EAAoB;eAC7B;;;;;;iBAYc,YAAY;;;iBAMZ,WAAW;;;;iBAOX,yBAAyB,GAAG,iBAAiB,GAAG;;;;;iBAWhD,sBACd,cAAc,mBACd,uBACC;;;iBAQa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAO9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAS5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KA4DS;EACV;EACA;EACA;EACA;EACA;EACA;IACE;IACA,QAAQ;IACR;IACA;IACA;MAAS;MAAgB;;;;;KAKjB;;EAEV;;EAEA;;EAEA;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;;;KAIU;EACV;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;iBAac,wBACd,MAAM,oBACN,eACC;;;iBA+Ea,yBACd,KAAK,YAAY,sBACjB,MAAM,oBACN;;;iBA+Fc,sBACd,KAAK,YAAY,sBACjB;;;;;;iBAiBc,2BACd;EAAqB;EAAa;iBAClC,YAAY,uDACX;;;;;iBA2Ba,sBACd,KAAK,YAAY,sBACjB,gBAAgB,sBAChB;;;iBAWc,kBAAkB,MAAM,sBAAsB;;;;;;iBAqB9C,uBACd,eAAe,uBACf,aAAa,oBACZ;;;;;;;;;iBA8Da,iBAAiB,cAAc;;;;KAOnC;;EAEV;EACA;;IAEE;MAAU;;;IAEV;MAAU;QAAY;QAAe,SAAS;;;;;;;;;;iBASlC,wBAAwB,SAAS;;;;;;;;iBAmBjC,gBAAgB;EAAgB;IAAQ;;;;;;;iBASxC,kBAAkB;EAAkC;IAAQ;;;;KAKhE;;EAEV;;EAEA;;;EAGA;;;EAGA;EACA;IACE;IACA;;;;;;;iBAQY,mBAAmB;;;;;iBASnB,cAAc,OAAO;;;;;;;;;;;;;;iBAiBrB,4BACd,mBAAmB,mCACnB,aAAa,mBACb,eACC;;;;;;iBAwCa,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KA8KU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAmcI,QAAQ;EAAoB"}

package/src/plugins/tui/dist/tui.js

@@ -49,6 +49,20 @@ import { For, Show, createEffect, createMemo, createResource, createSignal, onCl
 *   (the old ContextBar was removed) and we deliberately do NOT hack the
 *   native footer. Track upstream: opencode statusline config.
 */
+const __tuiPluginOnceKey = "__pantheonPluginsLoaded";
+function pantheonPluginOnce(key) {
+	try {
+		const g = globalThis;
+		if (g[__tuiPluginOnceKey] === void 0) g[__tuiPluginOnceKey] = /* @__PURE__ */ new Set();
+		const set = g[__tuiPluginOnceKey];
+		if (!(set instanceof Set)) return false;
+		if (set.has(key)) return true;
+		set.add(key);
+		return false;
+	} catch {
+		return false;
+	}
+}
 /** How often the sidebar re-reads .pantheon/active-preset.json so `set-tier`
 *  changes made while opencode is open show up within ~30s. */
 const PRESET_REFRESH_MS = 3e4;
@@ -933,6 +947,7 @@ function mergeChildDelegationSources(children, live) {
 		bySessionAlias.set(key(entry.sessionID, entry.alias), index);
 	});
 	for (const liveEntry of live) {
+		if (liveEntry.alias === null && liveEntry.taskID === null && Date.now() - liveEntry.startedAt > 3e4) continue;
 		const incoming = toDelegationEntry(liveEntry);
 		const index = (incoming.taskID !== void 0 ? byTask.get(incoming.taskID) : void 0) ?? (incoming.alias !== "" ? bySessionAlias.get(key(incoming.sessionID, incoming.alias)) : void 0);
 		if (index === void 0) {
@@ -1530,6 +1545,7 @@ function View(props) {
 					...c,
 					status: resolveStatus(c.id)
 				})), md, now());
+				for (const [k, v] of props.liveStore.map) if (v.alias === null && v.taskID === null && Date.now() - v.startedAt > 3e4) props.liveStore.map.delete(k);
 				const liveEntries = [...props.liveStore.map.values()].filter((entry) => entry.sessionID === sessionID);
 				setChildDelegations(mergeChildDelegationSources(childEntries, liveEntries));
 				panelLog.info(`panel: children=${children.length} md=${md.length} events=${eventRefreshCount}`);
@@ -1768,6 +1784,7 @@ function View(props) {
 	})();
 }
 const tui = (api, _options, _meta) => {
+	if (pantheonPluginOnce("pantheon:tui")) return;
 	const [version, setVersion] = createSignal(null);
 	detectVersion(api).then((detected) => setVersion(detected)).catch(() => setVersion(null));
 	setupUsageBar(api);

package/src/plugins/tui/dist/tui.tsx

@@ -63,6 +63,24 @@ import {
   Show,
 } from 'solid-js'
 
+// ─── Double-load guard (mirrors src/pantheon/plugin-once.ts) ───────────────
+// Opencode merges global + project plugin paths, so this module can load twice
+// in one process. The second factory invocation becomes a no-op.
+const __tuiPluginOnceKey = '__pantheonPluginsLoaded'
+function pantheonPluginOnce(key: string): boolean {
+  try {
+    const g = globalThis as unknown as Record<string, unknown>
+    if (g[__tuiPluginOnceKey] === undefined) g[__tuiPluginOnceKey] = new Set<string>()
+    const set = g[__tuiPluginOnceKey]
+    if (!(set instanceof Set)) return false
+    if ((set as Set<string>).has(key)) return true
+    ;(set as Set<string>).add(key)
+    return false
+  } catch {
+    return false
+  }
+}
+
 /* ─── Constants ─────────────────────────────────────────── */
 
 /** How often the sidebar re-reads .pantheon/active-preset.json so `set-tier`
@@ -1256,6 +1274,7 @@ export function mergeChildDelegationSources(
   })
 
   for (const liveEntry of live) {
+    if (liveEntry.alias === null && liveEntry.taskID === null && Date.now() - liveEntry.startedAt > 30_000) continue
     const incoming = toDelegationEntry(liveEntry)
     const index =
       (incoming.taskID !== undefined ? byTask.get(incoming.taskID) : undefined) ??
@@ -2201,6 +2220,7 @@ function View(props: {
         }
         const withStatus = children.map((c) => ({ ...c, status: resolveStatus(c.id) }))
         const childEntries = childrenToDelegationEntries(withStatus, md, now())
+        for (const [k, v] of props.liveStore.map) if (v.alias === null && v.taskID === null && Date.now() - v.startedAt > 30_000) props.liveStore.map.delete(k)
         // The event channel is optimistic: it renders a job even while the
         // child session/report is still being created. Filter by parent so a
         // different focused session never leaks rows into this sidebar.
@@ -2397,6 +2417,7 @@ function View(props: {
 /* ─── Plugin Registration ────────────────────────────────── */
 
 const tui: TuiPlugin = (api, _options, _meta) => {
+  if (pantheonPluginOnce('pantheon:tui')) return
   // Do not await project file/process probes here. OpenCode waits for the TUI
   // factory before it finishes startup, and a Windows host opening a WSL
   // project can leave those probes pending while the project bridge comes up.

package/src/plugins/tui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pantheon-tui",
   "type": "module",
-  "version": "1.3.5-beta.57.2e03676",
+  "version": "1.3.5",
   "description": "Pantheon TUI plugin — sidebar (version, preset, sessions, real-time delegations) + AI subscription usage gauges incl. OpenCode Go/Zen dollar limits (vendored, MIT)",
   "license": "MIT",
   "exports": {

package/src/plugins/tui/src/index.tsx

@@ -63,6 +63,24 @@ import {
   Show,
 } from 'solid-js'
 
+// ─── Double-load guard (mirrors src/pantheon/plugin-once.ts) ───────────────
+// Opencode merges global + project plugin paths, so this module can load twice
+// in one process. The second factory invocation becomes a no-op.
+const __tuiPluginOnceKey = '__pantheonPluginsLoaded'
+function pantheonPluginOnce(key: string): boolean {
+  try {
+    const g = globalThis as unknown as Record<string, unknown>
+    if (g[__tuiPluginOnceKey] === undefined) g[__tuiPluginOnceKey] = new Set<string>()
+    const set = g[__tuiPluginOnceKey]
+    if (!(set instanceof Set)) return false
+    if ((set as Set<string>).has(key)) return true
+    ;(set as Set<string>).add(key)
+    return false
+  } catch {
+    return false
+  }
+}
+
 /* ─── Constants ─────────────────────────────────────────── */
 
 /** How often the sidebar re-reads .pantheon/active-preset.json so `set-tier`
@@ -1256,6 +1274,7 @@ export function mergeChildDelegationSources(
   })
 
   for (const liveEntry of live) {
+    if (liveEntry.alias === null && liveEntry.taskID === null && Date.now() - liveEntry.startedAt > 30_000) continue
     const incoming = toDelegationEntry(liveEntry)
     const index =
       (incoming.taskID !== undefined ? byTask.get(incoming.taskID) : undefined) ??
@@ -2201,6 +2220,7 @@ function View(props: {
         }
         const withStatus = children.map((c) => ({ ...c, status: resolveStatus(c.id) }))
         const childEntries = childrenToDelegationEntries(withStatus, md, now())
+        for (const [k, v] of props.liveStore.map) if (v.alias === null && v.taskID === null && Date.now() - v.startedAt > 30_000) props.liveStore.map.delete(k)
         // The event channel is optimistic: it renders a job even while the
         // child session/report is still being created. Filter by parent so a
         // different focused session never leaks rows into this sidebar.
@@ -2397,6 +2417,7 @@ function View(props: {
 /* ─── Plugin Registration ────────────────────────────────── */
 
 const tui: TuiPlugin = (api, _options, _meta) => {
+  if (pantheonPluginOnce('pantheon:tui')) return
   // Do not await project file/process probes here. OpenCode waits for the TUI
   // factory before it finishes startup, and a Windows host opening a WSL
   // project can leave those probes pending while the project bridge comes up.

package/src/routing.yml

@@ -457,6 +457,11 @@ intent_gate:
     - search
     - lookup
     - documentation
+    - procure
+    - busque
+    - encontre
+    - localize
+    - pesquise
     target: apollo
   investigate:
     patterns:

package/src/agents/README.md

@@ -1,26 +0,0 @@
-# Agent Reference — Pantheon
-
-This directory contains the definitions for all 14 Pantheon agents. Each agent is defined in a `.agent.md` file with YAML frontmatter specifying tools, model tier, capabilities, and delegation rules.
-
-## Agents
-
-| Agent | File | Role |
-|-------|------|------|
-| @zeus | [zeus.agent.md](zeus.agent.md) | Central orchestrator |
-| @athena | [athena.agent.md](athena.agent.md) | Strategic planner |
-| @apollo | [apollo.agent.md](apollo.agent.md) | Investigation scout |
-| @hermes | [hermes.agent.md](hermes.agent.md) | Backend specialist |
-| @aphrodite | [aphrodite.agent.md](aphrodite.agent.md) | Frontend specialist |
-| @demeter | [demeter.agent.md](demeter.agent.md) | Database specialist |
-| @themis | [themis.agent.md](themis.agent.md) | Quality & security gate |
-| @prometheus | [prometheus.agent.md](prometheus.agent.md) | Infrastructure specialist |
-| @hephaestus | [hephaestus.agent.md](hephaestus.agent.md) | AI pipelines |
-| @nyx | [nyx.agent.md](nyx.agent.md) | Observability |
-| @gaia | [gaia.agent.md](gaia.agent.md) | Remote sensing |
-| @iris | [iris.agent.md](iris.agent.md) | GitHub operations |
-| @mnemosyne | [mnemosyne.agent.md](mnemosyne.agent.md) | Memory bank |
-| @talos | [talos.agent.md](talos.agent.md) | Hotfix agent |
-
-## Full Reference
-
-See [AGENTS.md](../../AGENTS.md) for the complete agent reference with roles, capabilities, and invocation patterns.