pantheon-opencode 1.4.1 → 1.4.3

package/src/pantheon/presets.mjs

@@ -33,12 +33,13 @@ export const EFFORT_RANK = { low: 0, medium: 1, high: 2 }
 /**
  * Capability table: reasoning-effort ceiling + image-input (vision) support.
  *
- * `vision` flags mark models that accept image input. Verified against
- * models.dev api.json on 2026-08-02 (council decision): qwen3.7-max,
- * minimax-m2.5 and minimax-m2.7 and glm-5.1/glm-5.2 are TEXT-ONLY (vision:
- * false); mimo-v2.5 / mimo-v2.5-free / qwen3.7-plus / minimax-m3 and the
- * o-series (o1/o3/o4) are multimodal (models.dev input: text+image).
- * claude-* and gpt-5.6-* carry native image support.
+ * `vision` flags mark models that accept image input. Verified 2026-08-27:
+ * deepseek-v4-pro high, deepseek-v4-flash medium text-only; mimo-v2.5 /
+ * mimo-v2.5-free multimodal low; qwen3.6-plus-free / qwen3.8-max text-only;
+ * glm-5.3-flash high text-only; kimi-k2.7-code high, kimi-k3 medium text-only;
+ * nemotron-3-super-free high text-only; big-pickle medium text-only;
+ * minimax-m3 multimodal high; gpt-5.6 family native image support.
+ * Removed: minimax-m2.5, kimi-k2.5, glm-5.1/5.2, ox-alpha (deprecated 2026).
  */
 export const CAPABILITY_TABLE = [
   { prefix: 'deepseek/deepseek-v4-pro', maxEffort: 'high', stripEffort: false, vision: false },
@@ -60,31 +61,18 @@ export const CAPABILITY_TABLE = [
   // entry above matches 'mimo/v2.5' (full-string) but NOT 'mimo-v2.5'
   // (segment 'mimo-v2.5' has no slash, so 'mimo/' prefix cannot match).
   { prefix: 'mimo-v2.5', maxEffort: 'low', stripEffort: false, vision: true },
-  // mimo-v2.5-pro is text-only per models.dev api.json (2026-08-02).
-  // Explicit entry needed: the 'mimo-v2.5' prefix substring-matches
-  // 'mimo-v2.5-pro' (longest-prefix wins), which would wrongly report
-  // vision: true for a text-only model.
+  // mimo-v2.5-pro is text-only per models.dev api.json (2026-08-27).
   { prefix: 'mimo-v2.5-pro', maxEffort: 'low', stripEffort: false, vision: false },
-  // opencode-go (OpenCode Go subscription) — bare segment prefixes so
-  // opencode-go/<model> IDs match; the provider-scoped deepseek/ entries
-  // above still win by length for deepseek/ models. glm-5.1/glm-5.2 are
-  // text-only per models.dev api.json (2026-08-02).
-  { prefix: 'glm-5.2', maxEffort: 'medium', stripEffort: false, vision: false },
-  { prefix: 'glm-5.1', maxEffort: 'medium', stripEffort: false, vision: false },
-  { prefix: 'kimi-k2.6', maxEffort: 'high', stripEffort: false, vision: true },
-  // qwen3.7-max is text-only per models.dev api.json (2026-08-02); the
-  // multimodal variant is qwen3.7-plus.
+  // Go subscription specific — bare segment prefixes so opencode-go/<model> IDs match
+  { prefix: 'glm-5.3-flash', maxEffort: 'high', stripEffort: false, vision: false },
+  { prefix: 'kimi-k2.7-code', maxEffort: 'high', stripEffort: false, vision: false },
+  { prefix: 'kimi-k3', maxEffort: 'medium', stripEffort: false, vision: false },
+  { prefix: 'qwen3.8-max', maxEffort: 'high', stripEffort: false, vision: false },
+  { prefix: 'qwen3.6-plus-free', maxEffort: 'medium', stripEffort: false, vision: false },
+  // Legacy qwen3.7 retained for capability checks (not used in new presets)
   { prefix: 'qwen3.7-max', maxEffort: 'high', stripEffort: false, vision: false },
-  // qwen3.7-plus IS multimodal (models.dev input: text+image) but image
-  // turns through the OpenCode Go gateway return HTTP 500 (opencode#33942
-  // + #29956). Flag stays true per models.dev; presets must NOT use it as a
-  // vision fallback — minimax-m3 is the confirmed opencode-go fallback.
   { prefix: 'qwen3.7-plus', maxEffort: 'medium', stripEffort: false, vision: true },
-  // minimax-m2.7 / minimax-m2.5 are text-only per models.dev api.json
-  // (2026-08-02). minimax-m3 is the vision-capable MiniMax on opencode-go
-  // (confirmed multimodal via the Go gateway, opencode#29956).
   { prefix: 'minimax-m2.7', maxEffort: 'medium', stripEffort: false, vision: false },
-  { prefix: 'minimax-m2.5', maxEffort: 'medium', stripEffort: false, vision: false },
   { prefix: 'minimax-m3', maxEffort: 'high', stripEffort: false, vision: true },
   // BARE prefix — needed for opencode-go/deepseek-v4-flash (segment match);
   // provider-scoped deepseek/deepseek-v4-flash entry still wins by length
@@ -94,9 +82,10 @@ export const CAPABILITY_TABLE = [
   // provider-scoped deepseek/deepseek-v4-pro entry still wins by length.
   { prefix: 'deepseek-v4-pro', maxEffort: 'high', stripEffort: false, vision: false },
   // opencode (Zen free tier) — bare segment prefixes for opencode/<model>.
-  // big-pickle / nemotron-3-ultra-free / north-mini-code-free verified
-  // text-only via models.dev (2026-08-02).
+  // big-pickle / nemotron-3-super-free / north-mini-code-free verified
+  // text-only via models.dev (2026-08-27).
   { prefix: 'big-pickle', maxEffort: 'medium', stripEffort: false, vision: false },
+  { prefix: 'nemotron-3-super-free', maxEffort: 'high', stripEffort: false, vision: false },
   { prefix: 'nemotron-3-ultra-free', maxEffort: 'high', stripEffort: false, vision: false },
   { prefix: 'north-mini-code-free', maxEffort: 'high', stripEffort: false, vision: false },
 ]
@@ -513,8 +502,13 @@ function providerDefKeyConfigured(provider, env) {
   if (!provider || typeof provider !== 'object') return true
   const envVar = provider.apiKeyEnv
   if (typeof envVar !== 'string' || envVar === '') return true
-  const key = env[envVar]
-  return typeof key === 'string' && key.trim() !== ''
+  const candidates =
+    envVar === 'PANTHEON_OPENCODE_API_KEY' ? [envVar, 'OPENCODE_GO_API_KEY'] : [envVar]
+  for (const candidate of candidates) {
+    const key = env[candidate]
+    if (typeof key === 'string' && key.trim() !== '') return true
+  }
+  return false
 }
 
 /**
@@ -532,7 +526,6 @@ 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]
@@ -583,7 +576,11 @@ export function applyPreset(config, resolved, { env = process.env } = {}) {
     config.provider[id] ??= {}
     config.provider[id].options ??= {}
     config.provider[id].options.baseURL = provider.baseURL
-    config.provider[id].options.apiKey = env[provider.apiKeyEnv]
+    const apiKey =
+      provider.apiKeyEnv === 'PANTHEON_OPENCODE_API_KEY'
+        ? (env[provider.apiKeyEnv] ?? env.OPENCODE_GO_API_KEY)
+        : env[provider.apiKeyEnv]
+    config.provider[id].options.apiKey = apiKey
   }
 
   for (const [agent, spec] of Object.entries(resolved.agents ?? {})) {

package/src/pantheon/tool-context.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared tool-context types and path guards used by the preserved tool
+ * modules (cost-command, goal-loop, model-command, goal-store).
+ *
+ * These were previously exported from the removed delegation modules; they
+ * are hoisted here so the surviving subsystems keep a single source of truth
+ * without depending on the deleted delegate machinery.
+ *
+ * @module tool-context
+ */
+
+/**
+ * The structural tool-execution context a tool's `execute` receives. Mirrors
+ * the OpenCode SDK's ToolContext but keeps every field optional so the
+ * structural test/embedding surface can be supplied by older hosts.
+ */
+export interface ToolContextLike {
+  sessionID: string
+  directory?: string
+  worktree?: string
+  /**
+   * The OpenCode SDK's ToolContext declares this as required. It remains
+   * optional here because the structural test/embedding surface can be
+   * supplied by older hosts; enforcement must skip when it is absent.
+   */
+  agent?: string
+}
+
+/**
+ * Path-traversal guard for session IDs embedded in file paths. Throws on
+ * `..`, `/`, `\`. Used by goal-store to keep goal files inside their dir.
+ */
+export function assertSafeParentSessionID(parentSessionID: string): void {
+  if (
+    parentSessionID.includes('..') ||
+    parentSessionID.includes('/') ||
+    parentSessionID.includes('\\')
+  ) {
+    throw new Error(`Invalid parentSessionID: ${parentSessionID}`)
+  }
+}

package/src/plugin.ts

@@ -1,5 +1,3 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
 import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import type { PluginConfig } from 'opencode'
 import { BackgroundJobBoard } from './pantheon/background-job-board.ts'
@@ -12,14 +10,6 @@ import {
   DEFAULT_LIMITS as SANDBOX_DEFAULT_LIMITS,
 } from './pantheon/context-sandbox.ts'
 import { createCostCommand } from './pantheon/cost-command.ts'
-import {
-  collectRootSessionIDs,
-  createDelegationTools,
-  type DelegationClient,
-  resolveDelegationBudgets,
-  resolveDelegationTimeoutMs,
-  startIdleChildScan,
-} from './pantheon/delegation.ts'
 import { buildCompactionContext } from './pantheon/delegation-compaction.ts'
 import {
   createEnforcementGuard,
@@ -27,23 +17,16 @@ import {
   SessionHierarchyRegistry,
   zeusReadGuard,
 } from './pantheon/delegation-enforce.ts'
-import { handleDelegationEvent } from './pantheon/delegation-notify.ts'
-import { showDelegationTerminalToast, type ToastClient } from './pantheon/delegation-toast.ts'
 import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
 import { GOAL_LOOP_DEFAULTS, GoalLoop, GoalStore } from './pantheon/goal-loop.ts'
 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 { createModelCommand } from './pantheon/model-command.ts'
 import { pantheonPluginOnce } from './pantheon/plugin-once.ts'
-import {
-  applyActivePresetToConfig,
-  loadRoutingAgentModels,
-  loadRoutingMaxSteps,
-  loadRoutingPermissionTask,
-} from './pantheon/presets.mjs'
+import { applyActivePresetToConfig } from './pantheon/presets.mjs'
 import { safeSessionPath } from './pantheon/session-guard.ts'
-import { StepCapTracker } from './pantheon/step-cap.ts'
 import {
   TODO_ENFORCER_DEFAULTS,
   TodoEnforcer,
@@ -62,24 +45,12 @@ import { activePresetCandidates, createVisionHandler } from './pantheon/vision.t
 // .pantheon/logs/hooks.log; the console echo is opt-in via PANTHEON_HOOKS_LOG=1.
 const log = createPantheonLogger({ module: 'pantheon-plugin' })
 
-// R4: per-agent step caps from routing.yml `agents.<name>.max_steps`
-// (fail-open → {} = no agent capped). R1 retry_policy/cooldown are NOT
-// wired here — the plugin has no retry path (opencode cannot intercept task
-// completion); zeus waves load them via presets.mjs loaders and pass them
-// to zeusDelegateWithRetry explicitly.
-const stepCapTracker = new StepCapTracker(loadRoutingMaxSteps({ logger: log }))
-
-// O5: permission.task glob rules from routing.yml `permission.task`
-// (fail-open → undefined = existing runtime matrix only).
-const routingPermissionTask = loadRoutingPermissionTask({ logger: log })
-
 const board = new BackgroundJobBoard({
   maxConcurrentPerAgent: 3,
   signalDir: '.pantheon/deepwork/board-signals',
 })
 const persistence = new FilePersistenceAdapter('.pantheon/board/state.json')
 board.setPersistence(persistence)
-let terminalToastClient: ToastClient = {}
 board
   .recoverRunningJobs()
   .catch((err) => log.error('[Pantheon Plugin] Failed to recover running jobs:', err))
@@ -89,17 +60,13 @@ board
 // file-only log line (console echo opt-in via PANTHEON_HOOKS_LOG). There is
 // deliberately NO chat delivery — the user policy is zero delegation
 // notifications in the transcript. Completion visibility lives in the board
-// `[unread]` marker (pantheon_delegation_list), pantheon_delegation_read,
-// TUI toasts (pantheon-hooks, PANTHEON_TOASTS gate) and compaction
-// carry-forward.
+// `[unread]` marker and compaction carry-forward.
 board.onTerminal((taskID: string) => {
   const job = board.get(taskID)
   if (!job) return
   log.info(
     `[Pantheon Plugin] Board terminal: [${job.alias}] ${job.description} → ${job.state}${job.resultSummary ? ` — ${job.resultSummary}` : ''}`,
   )
-  // Deliberately direct-to-TUI: onTerminal must not inject chat/transcript text.
-  void showDelegationTerminalToast(terminalToastClient, job)
 })
 
 // Periodically prune terminal/reconciled jobs (24h TTL, every 30 min).
@@ -117,10 +84,10 @@ setInterval(
 
 // ─── Phase 4: Read-Only Enforcement + Compaction Context ───────────────
 
-// The read-only registry is populated by createDelegationTools (delegation.ts)
-// when a delegate is read-only (explicit flag or agent ∈ readOnlyAgents).
-// The guard denies edit/write/bash/task inside those sessions by throwing
-// from tool.execute.before; unknown sessions are allowed (safe default).
+// The read-only registry is populated when a child session is launched
+// read-only (explicit flag or agent ∈ readOnlyAgents). The guard denies
+// edit/write/bash/task inside those sessions by throwing from
+// tool.execute.before; unknown sessions are allowed (safe default).
 const enforcementGuard = createEnforcementGuard({
   getReadOnlySessions: () => readOnlyRegistry.sessionIDs(),
   options: {
@@ -141,7 +108,7 @@ const commandNormalizer = createCommandNormalizer({ logger: log })
 // Mirrors routing.yml background_delegation.max_compaction_items.
 const COMPACTION_MAX_ITEMS = 10
 
-// Root-session registry for the delegation depth guard: sessions created
+// Root-session registry for the child-session depth guard: sessions created
 // without a parentID are roots. Populated from TWO sources:
 //   1. the `session.created` event hook (live roots — fires for sessions
 //      created while the plugin runs);
@@ -149,9 +116,9 @@ const COMPACTION_MAX_ITEMS = 10
 //      hook (compaction-134) — opencode does NOT replay session.created
 //      events for sessions that exist before plugin load, so without the
 //      seed a resumed root would never enter this set after a restart.
-// delegation.ts additionally falls back to knownChildren ("any session WE
-// created is a sub-session; unknown sessions are roots") so the depth guard
-// works even when this set is incomplete.
+// The hierarchy registry additionally falls back to known children ("any
+// session WE created is a sub-session; unknown sessions are roots") so the
+// depth guard works even when this set is incomplete.
 const rootSessions = new Set<string>()
 const sessionHierarchy = new SessionHierarchyRegistry()
 const sessionAgents = new Map<string, string>()
@@ -160,14 +127,14 @@ const sessionAgents = new Map<string, string>()
  * Seed resumed root sessions without making OpenCode startup depend on the
  * session API responding. Some OpenCode environments do not have the API
  * ready while plugin config hooks run; awaiting session.list() there leaves
- * the TUI stuck before it can open. The delegation layer already treats an
+ * the TUI stuck before it can open. The hierarchy registry already treats an
  * unknown session as a root, so this enrichment is deliberately best-effort.
  */
 function seedRootSessionsInBackground(input: PluginInput): void {
   // Fail-open: environments without the session API (client.session absent or
   // not yet wired while config hooks run) must NOT break startup. `session`
   // is captured and the method invoked on it so `this` stays bound; the
-  // delegation layer already treats unknown sessions as roots, so skipping
+  // hierarchy registry already treats unknown sessions as roots, so skipping
   // the seed is always safe.
   const session = input.client.session
   if (typeof session?.list !== 'function') return
@@ -177,10 +144,15 @@ function seedRootSessionsInBackground(input: PluginInput): void {
     .then((result) => {
       if (!result.error && Array.isArray(result.data)) {
         sessionHierarchy.completeSeed(result.data)
-        const seeded = collectRootSessionIDs(result.data)
-        if (seeded.size > 0) {
-          for (const id of seeded) rootSessions.add(id)
-          log.info(`[Pantheon Plugin] Seeded ${seeded.size} root session(s) from session.list`)
+        let seeded = 0
+        for (const info of result.data) {
+          if (info.parentID === undefined) {
+            rootSessions.add(info.id)
+            seeded += 1
+          }
+        }
+        if (seeded > 0) {
+          log.info(`[Pantheon Plugin] Seeded ${seeded} root session(s) from session.list`)
         }
       } else {
         sessionHierarchy.failSeed()
@@ -198,62 +170,6 @@ function sdkErrorMessage(error: { data?: { message?: string } } | null | undefin
   return typeof message === 'string' && message.trim() !== '' ? message : 'request failed'
 }
 
-/**
- * Adapt the opencode SDK client to the structural DelegationClient the
- * delegation toolset expects: the SDK wraps every call in a
- * `{data, error, request, response}` result while delegation.ts uses direct
- * returns. Errors surface as throws so the toolset's own error handling
- * (tool errors returned as TEXT) keeps working.
- */
-function adaptDelegationClient(client: PluginInput['client']): DelegationClient {
-  return {
-    session: {
-      create: async (input) => {
-        const body: {
-          parentID?: string
-          title?: string
-          model?: { id: string; providerID: string }
-        } = { parentID: input.body.parentID }
-        if (input.body.title !== undefined) body.title = input.body.title
-        // Forward a model only when the active routing profile supplied one.
-        if (input.body.model !== undefined) body.model = input.body.model
-        const result = await client.session.create({ body })
-        if (result.error) throw new Error(sdkErrorMessage(result.error))
-        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: path.path,
-          body: {
-            agent: input.body.agent,
-            ...(input.body.model !== undefined
-              ? { model: { providerID: input.body.model.providerID, modelID: input.body.model.id } }
-              : {}),
-            parts: input.body.parts,
-          },
-        })
-        if (result.error) throw new Error(sdkErrorMessage(result.error))
-        return result.data
-      },
-      messages: async (input) => {
-        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
-      },
-    },
-  }
-}
-
 /**
  * Adapt the opencode SDK client to the structural TodoEnforcerClient the
  * todo enforcer expects: unwraps the SDK `{data, error, request, response}`
@@ -334,7 +250,6 @@ function adaptTodoEnforcerClient(client: PluginInput['client']): TodoEnforcerCli
  * Helpers live in src/pantheon/vision.ts and are imported from there directly.
  */
 const plugin: Plugin = async (input: PluginInput) => {
-  terminalToastClient = input.client as unknown as ToastClient
   // release-134: runtime guard against DOUBLE registration (duplicate toasts +
   // duplicate task_ids in one process — 2026-08-12 live logs). opencode
   // merges the global config (npm-package plugin paths) with the project
@@ -349,67 +264,12 @@ const plugin: Plugin = async (input: PluginInput) => {
   // is older than the installed package. Runs once, fail-open, no auto-sync.
   checkTuiVersionStaleness((msg) => log.warn(msg))
   const vision = createVisionHandler(input)
-  // Phase 2/3: background delegation toolset + the bound finalize lifecycle
-  // hook. Completion is observed through the event hook below
-  // (session.idle / session.error on a child) → finalizeDelegation.
-  // Fase B3: runtime controls for the two read-only exceptions and the real
-  // per-child wall-clock timer. No task_budget field is injected into the
-  // plugin/frontmatter; these are enforced by delegation.ts itself.
-  const delegationBudgets = resolveDelegationBudgets()
-  const wallClockTimeoutMs = resolveDelegationTimeoutMs()
-
-  const delegation = createDelegationTools({
-    board,
-    client: adaptDelegationClient(input.client),
-    options: {
-      rootSessions,
-      isChildSession: (sessionID) => sessionHierarchy.isChild(sessionID),
-      registerChildSession: (sessionID, parentID) => {
-        sessionHierarchy.register({ id: sessionID, parentID })
-      },
-      enforceRuntimeMatrix: true,
-      readOnlyAgents: new Set(['apollo', 'gaia']),
-      // Only an explicitly active routing profile may provide child models.
-      // An empty map deliberately lets OpenCode inherit the parent model.
-      agentModels: loadRoutingAgentModels({
-        candidates: activePresetCandidates(),
-        logger: log,
-      }),
-      delegationBudgets,
-      stepCapTracker,
-      ...(routingPermissionTask != null ? { permissionTask: routingPermissionTask } : {}),
-      ...(wallClockTimeoutMs !== undefined ? { wallClockTimeoutMs } : {}),
-    },
-  })
-
-  // Proactive idle-child scan (Fix 2): finalize children that are idle on the
-  // board but have no MD report on disk — eliminates the phantom "running"
-  // window. Runs every 30s (configurable via PANTHEON_IDLE_SCAN_INTERVAL_MS),
-  // unref'd so it never holds the process open. Fail-open by design.
-  const idleScanIntervalMs = Number(process.env.PANTHEON_IDLE_SCAN_INTERVAL_MS) || undefined
-  startIdleChildScan(
-    {
-      board,
-      finalize: (childSessionID, opts) => delegation.finalizeDelegation(childSessionID, opts),
-      hasReport: (job) => {
-        try {
-          const filePath = join('.pantheon/delegations', job.parentSessionID, `${job.alias}.md`)
-          return existsSync(filePath)
-        } catch {
-          return false
-        }
-      },
-      logger: log,
-    },
-    idleScanIntervalMs,
-  )
-
   // Wave 1 (PR #46): TODO continuation enforcer for root/non-board sessions.
   // Mirrors routing.yml `todo_enforcer` (plugin scope has no routing.yml
-  // access — COMPACTION_MAX_ITEMS pattern). The event hook routes non-board
-  // session.idle events here; board-child idles go to finalizeDelegation.
-  // Runtime kill-switch: PANTHEON_TODO_ENFORCER=off (routing.yml is a doc
-  // mirror only — the env var is the real switch, PANTHEON_TOASTS pattern).
+  // access — COMPACTION_MAX_ITEMS pattern). The event hook routes all
+  // session.idle events here. Runtime kill-switch: PANTHEON_TODO_ENFORCER=off
+  // (routing.yml is a doc mirror only — the env var is the real switch,
+  // PANTHEON_TOASTS pattern).
   const todoEnforcer = new TodoEnforcer({
     client: adaptTodoEnforcerClient(input.client),
     board,
@@ -466,22 +326,23 @@ const plugin: Plugin = async (input: PluginInput) => {
     await readEnhancer(input, output)
   }
 
-  // Wave 4 (PR #46): /cost — delegation cost + token visibility. Reads
+  // Wave 4 (PR #46): /cost — cost + token visibility by agent. Reads
   // opencode.db read-only (node:sqlite, falls back to scripts/cost.mjs).
   // Fully wired (unlike dispatch-guard, which is manual-orchestration-only
   // because opencode 1.18.x cannot intercept task completion via hooks).
   const costCommand = createCostCommand()
+  const modelCommand = createModelCommand()
 
   return {
     config: async (config: PluginConfig) => {
       // compaction-134 seed: opencode does NOT replay `session.created`
       // events for sessions that exist before plugin load, so after a
       // restart the resumed ROOT session never enters rootSessions and the
-      // depth guard would reject its pantheon_delegate calls. Seed the
-      // registry from session.list() in the background — every session
-      // WITHOUT a parentID is a root. Fail-open: a failed/throttled list
-      // leaves the set untouched (delegation.ts treats unknown sessions as
-      // roots), and config setup must never wait for the session API.
+      // depth guard would treat it as a child. Seed the registry from
+      // session.list() in the background — every session WITHOUT a parentID
+      // is a root. Fail-open: a failed/throttled list leaves the set
+      // untouched (the hierarchy registry treats unknown sessions as roots),
+      // and config setup must never wait for the session API.
       // Context sandbox config — opencode.json → context_sandbox: {enabled, limits}
       try {
         const raw = (config as unknown as Record<string, unknown>).context_sandbox
@@ -526,19 +387,19 @@ const plugin: Plugin = async (input: PluginInput) => {
         log.warn('[plugin] preset application failed (see logs for details)')
       }
     },
-    // Phase 2: background delegation tools (structural — matches the `tool`
-    // hook field shape; read_only sessions feed the Phase 4 registry).
+    // Phase 2: structural tool registrations (matches the `tool` hook field
+    // shape). Native task() owns orchestration; the plugin registers the
+    // deterministic /pantheon-model, /cost and full-auto goal tools.
     tool: {
-      pantheon_delegate: delegation.pantheon_delegate,
-      pantheon_delegation_read: delegation.pantheon_delegation_read,
-      pantheon_delegation_list: delegation.pantheon_delegation_list,
       hashline_edit: hashlineEdit,
       // Wave 3 (PR #46): full-auto goal tools (single active goal/session).
       pantheon_goal_create: goalTools.pantheon_goal_create,
       pantheon_goal_update: goalTools.pantheon_goal_update,
       pantheon_goal_get: goalTools.pantheon_goal_get,
-      // Wave 4 (PR #46): /cost — delegation cost report from opencode.db.
+      // Wave 4 (PR #46): /cost — cost report by agent from opencode.db.
       pantheon_cost: costCommand.pantheon_cost,
+      // Deterministic /pantheon-model management of top-level model fields.
+      pantheon_model: modelCommand.pantheon_model,
     },
     'chat.message': async (hookInput, output) => {
       await vision.chatMessage(hookInput, output)
@@ -569,22 +430,13 @@ const plugin: Plugin = async (input: PluginInput) => {
       if (ev.type === 'session.compacted') {
         await todoPreserver.onCompacted(ev.properties.sessionID)
       }
-      // Phase 3: observe completion on child sessions → finalizeDelegation.
-      // The board transition fires onTerminal → the file-only audit log (no
-      // chat delivery — see the onTerminal listener above). Unknown sessions
-      // are a no-op.
+      // Native task() children are owned by OpenCode. Idle routing for
+      // generic root/non-board sessions remains priority ordered: an active
+      // goal owns the idle (goal loop), otherwise the todo enforcer
+      // re-injects. Neither onIdle ever throws (internal failures are logged
+      // + swallowed), so the session is safe.
       try {
-        const delegated = await handleDelegationEvent(ev, {
-          board,
-          finalize: (childSessionID, opts) => delegation.finalizeDelegation(childSessionID, opts),
-        })
-        // Wave 1/3: non-board idle → idle dispatcher. Board children are
-        // handled by handleDelegationEvent above; everything else (roots,
-        // non-board sessions) is routed by priority: an active goal owns the
-        // idle (goal loop), otherwise the todo enforcer re-injects. Neither
-        // onIdle ever throws (internal failures are logged + swallowed), so
-        // the session is safe.
-        if (!delegated && ev.type === 'session.idle') {
+        if (ev.type === 'session.idle') {
           await idleDispatcher.onIdle(ev.properties.sessionID)
         }
       } catch (err) {

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

@@ -1 +1 @@
-{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAy6BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EASA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBAkHmB,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,sBACA,cACA,4BACC;;cASU;;;;cAKA;;;;;;;;;iBAUG,mBACd,OAAO,iBACP,aACA,uBACC;;;iBAWa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAQ9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAc5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KAmFS;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;;;;;;iBA0Ca,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KAiLU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAucI,QAAQ;EAAoB"}
+{"version":3,"file":"tui.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;KAo7BY;;EAEV;;EAEA;;;;EAIA;;EAEA;EACA;;EASA;;EAEA;EACA;EACA;;EAEA;;;;EAIA;;;;;;;;;;;iBAsBc,wBACd,aACA,oBACA,qBACC;;;;;;iBAkHmB,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,sBACA,cACA,4BACC;;cASU;;;;cAKA;;;;;;;;;iBAUG,mBACd,OAAO,iBACP,aACA,uBACC;;;iBAWa,WAAW;;;iBAcX,kBAAkB,OAAO,iBAAiB;;;KAQ9C;iBAQI,mBAAmB,OAAO,kBAAkB;iBAc5C,wBAAwB,OAAO;;iBAoB/B,uBAAuB;;;;;;;iBAWvB,4BACd,mBAAmB,mBACnB,eAAe,wBACd;;KAmFS;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;;;;;;iBA0Ca,4BACd;EAAS,YAAY,cAAc,SAAS;eAC5C;;;;;KAiLU;EACV,KAAK,YAAY;;EAEjB;;EAEA;;cAucI,QAAQ;EAAoB"}

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

@@ -164,7 +164,7 @@ async function detectVersion(api) {
 			if (ver) return ver;
 		}
 	} catch {}
-	return null;
+	return "1.4.2";
 }
 /**
 * usage-bar — AI subscription usage gauge for the opencode TUI.

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

@@ -150,7 +150,7 @@ async function resolvePresetForTui(
 }
 
 /* ─── Version Detection ────────────────────────────────────
- * 100% dinâmico — zero fallback hardcoded.
+ * 100% dinâmico — fallback embutido em build (__PANTHEON_VERSION__).
  * Se falhar, retorna null e a View omite a versão.
  *
  * Try order:
@@ -159,7 +159,12 @@ async function resolvePresetForTui(
  *   1. api.client.file.read package.json
  *   2. git describe --tags
  *   3. opencode --version
- *   4. null                                                      */
+ *   4. __PANTHEON_VERSION__ (tsdown define — build-time embed)
+ *   5. null                                                      */
+
+// Build-time embedded version (tsdown `define` in tsdown.config.ts). Injected
+// only into the bundled dist/tui.js; the raw dist/tui.tsx copy falls through.
+declare const __PANTHEON_VERSION__: string | undefined
 
 async function detectVersion(api: TuiPluginApi): Promise<string | null> {
   // Try 0a: installed location (2 levels: dist/tui.js → pantheon-tui/package.json)
@@ -223,6 +228,12 @@ async function detectVersion(api: TuiPluginApi): Promise<string | null> {
     /* fall through */
   }
 
+  // Try 4: build-time embedded version (tsdown define) — last-resort fallback
+  // so the sidebar ALWAYS shows a version even when every probe above fails.
+  if (typeof __PANTHEON_VERSION__ !== 'undefined' && __PANTHEON_VERSION__) {
+    return __PANTHEON_VERSION__
+  }
+
   return null // sem fallback — versão não aparece
 }
 

package/src/plugins/tui/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pantheon-tui",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pantheon-tui",
-      "version": "1.4.1",
+      "version": "1.4.3",
       "license": "MIT",
       "dependencies": {
         "@opencode-ai/plugin": ">=1.14.0",

package/src/plugins/tui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pantheon-tui",
   "type": "module",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "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": {