pantheon-opencode 1.4.0 → 1.4.2

package/src/pantheon/presets.d.mts

@@ -86,13 +86,14 @@ export declare function loadPresetDefs(routingPath?: string): Record<string, Pre
 
 export interface RoutingAgentModelsOptions {
   routingPath?: string
+  candidates?: string[]
+  env?: Record<string, string | undefined>
   logger?: { warn?: (msg: string) => void }
 }
 
 /**
- * Lowercase agent → "provider/model" mapping from routing.yml's FIRST
- * (default) preset — the static source for the delegation toolset's
- * options.agentModels. Fail-open: missing/corrupt routing.yml → {}.
+ * Lowercase agent → "provider/model" mapping from the explicitly active
+ * routing profile. No active profile (or a profile without model) → {}.
  */
 export declare function loadRoutingAgentModels(
   options?: RoutingAgentModelsOptions,

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 },
 ]
@@ -345,46 +334,42 @@ export function loadRoutingPermissionTask({ routingPath, logger = console } = {}
 }
 
 /**
- * Load the DEFAULT agent → model mapping from routing.yml for the delegation
+ * Load the active routing profile's agent → model mapping for the delegation
  * toolset (Fase 6 — wiring agentModels).
  *
  * routing.yml keeps per-agent models ONLY inside presets
  * (`presets.<name>.agents.<agent>.model`) — the top-level `agents:` section
- * carries no model field. The FIRST-listed preset is the static default
- * (go-deepseek today): a mapping INDEPENDENT of the active preset, so a
- * delegated child always gets a sane per-agent model even when no preset is
- * active — delegation no longer depends 100% on the active preset (branch (b)
- * of resolveChildModel, which outranks the active-preset branch (c)).
+ * carries no model field. No profile means an empty mapping; there is no
+ * implicit first/default preset or fallback model.
  *
- * Fail-open: a missing or unparseable routing.yml yields {} (the caller keeps
- * the previous behavior — active preset / opencode default) and warns via the
+ * Fail-open: a missing or unparseable routing.yml yields {} and warns via the
  * optional logger; it NEVER throws at startup.
  *
  * @param {object} [opts]
  * @param {string} [opts.routingPath]
+ * @param {string[]} [opts.candidates]
+ * @param {Record<string, string|undefined>} [opts.env]
  * @param {{warn?: Function}} [opts.logger]
  * @returns {Record<string, string>} lowercase agent → "provider/model"
  */
-export function loadRoutingAgentModels({ routingPath, logger = console } = {}) {
-  let defs
+export function loadRoutingAgentModels({ routingPath, candidates, env, logger = console } = {}) {
   try {
-    defs = loadPresetDefs(routingPath)
+    const active = resolveActivePreset({ routingPath, candidates, env, logger })
+    if (active === null) return {}
+    const models = {}
+    for (const [agent, spec] of Object.entries(active.agents ?? {})) {
+      if (spec && typeof spec === 'object' && typeof spec.model === 'string' && spec.model !== '') {
+        models[agent.toLowerCase()] = spec.model
+      }
+    }
+    return models
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err)
     logger.warn?.(
-      `presets: routing.yml agent models unavailable (${reason}) — delegation falls back to the active preset/default`,
+      `presets: routing.yml active profile models unavailable (${reason}) — child model omitted`,
     )
     return {}
   }
-  const names = Object.keys(defs)
-  if (names.length === 0) return {}
-  const models = {}
-  for (const [agent, spec] of Object.entries(defs[names[0]]?.agents ?? {})) {
-    if (spec && typeof spec === 'object' && typeof spec.model === 'string' && spec.model !== '') {
-      models[agent.toLowerCase()] = spec.model
-    }
-  }
-  return models
 }
 
 /**
@@ -517,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
 }
 
 /**
@@ -536,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]
@@ -587,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/zeus-delegate-with-retry.ts

@@ -272,9 +272,9 @@ export async function zeusDelegateWithRetry(
     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).
+    // 1. Create child session (parentID = caller). When a model is resolved,
+    // the same model is forwarded to session.create and promptAsync; otherwise
+    // both requests omit it so the host keeps native model inheritance.
     let childID: string
     try {
       const created = await client.session.create({
@@ -310,10 +310,15 @@ export async function zeusDelegateWithRetry(
     // 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.
+    const promptBody = {
+      agent: opts.agent,
+      ...(opts.model !== undefined ? { model: opts.model } : {}),
+      parts: [{ type: 'text' as const, text: opts.prompt }],
+    }
     void client.session
       .promptAsync({
         path: childPath.path,
-        body: { agent: opts.agent, parts: [{ type: 'text', text: opts.prompt }] },
+        body: promptBody,
       })
       .catch((err: unknown) => {
         const reason = err instanceof Error ? err.message : String(err)

package/src/plugin.ts

@@ -4,7 +4,6 @@ import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import type { PluginConfig } from 'opencode'
 import { BackgroundJobBoard } from './pantheon/background-job-board.ts'
 import { createCommandNormalizer } from './pantheon/command-normalizer.ts'
-import { reassertAfterCompaction } from './pantheon/compaction-assert.ts'
 import {
   type ContextSandboxConfig,
   createContextSandbox,
@@ -29,12 +28,14 @@ import {
   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,
@@ -62,17 +63,6 @@ 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' })
 
-// Fase 6 (release-134): the delegation toolset's options.agentModels (branch
-// (b) of resolveChildModel) is wired from routing.yml's default (first)
-// preset — a STATIC per-agent model mapping independent of the active preset,
-// so delegated children get a sane model even without an active preset (the
-// previous production wiring left branch (b) dead: delegation depended 100%
-// on the active preset). Built ONCE at module load, never per dispatch.
-// Fail-open: a missing/corrupt routing.yml yields {} (warned by the helper)
-// and delegation falls back to the active preset / opencode default — the
-// plugin never throws at startup.
-const routingAgentModels = loadRoutingAgentModels({ logger: log })
-
 // 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
@@ -90,6 +80,7 @@ const board = new BackgroundJobBoard({
 })
 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))
@@ -108,6 +99,8 @@ board.onTerminal((taskID: string) => {
   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).
@@ -223,8 +216,7 @@ function adaptDelegationClient(client: PluginInput['client']): DelegationClient
           model?: { id: string; providerID: string }
         } = { parentID: input.body.parentID }
         if (input.body.title !== undefined) body.title = input.body.title
-        // Forward the routed child model (E2E fix): without it the child
-        // falls back to the key-gated default model and dies at startup.
+        // 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))
@@ -343,6 +335,7 @@ 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
@@ -377,7 +370,12 @@ const plugin: Plugin = async (input: PluginInput) => {
       },
       enforceRuntimeMatrix: true,
       readOnlyAgents: new Set(['apollo', 'gaia']),
-      agentModels: routingAgentModels,
+      // 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 } : {}),
@@ -474,6 +472,7 @@ const plugin: Plugin = async (input: PluginInput) => {
   // 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) => {
@@ -542,13 +541,13 @@ const plugin: Plugin = async (input: PluginInput) => {
       pantheon_goal_get: goalTools.pantheon_goal_get,
       // Wave 4 (PR #46): /cost — delegation cost report 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)
       // No delegation notification delivery here — the user policy is ZERO
-      // notification text injected into the chat transcript (previously the
-      // notifier.flushQueue prepend). pantheon-hooks' chat-reminders.ts keeps
-      // its own <system-reminder> channel, untouched.
+      // notification text injected into the chat transcript.
       // Wave 1: a user message is activity — the todo enforcer's
       // user-activity gate skips injection for userActivityQuietMs afterwards.
       todoEnforcer.noteUserActivity(hookInput.sessionID)
@@ -573,17 +572,6 @@ const plugin: Plugin = async (input: PluginInput) => {
       // rewritten with the exact list (see todo-preserve.ts). Fail-open.
       if (ev.type === 'session.compacted') {
         await todoPreserver.onCompacted(ev.properties.sessionID)
-        // release-134 Phase 4: re-assert post-compaction state — enqueue a
-        // fresh-state reminder (running/unread board jobs + active goals) for
-        // the session's next chat.message delivery. Fail-open (never throws).
-        await reassertAfterCompaction({
-          sessionID: ev.properties.sessionID,
-          board,
-          goals: {
-            enabled: GOAL_LOOP_DEFAULTS.enabled,
-            list: (s: string) => goalStore.list(s),
-          },
-        })
       }
       // Phase 3: observe completion on child sessions → finalizeDelegation.
       // The board transition fires onTerminal → the file-only audit log (no

package/src/plugins/pantheon-hooks.ts

@@ -79,7 +79,7 @@
  *       PANTHEON_TOASTS=council       → {errors, council}
  *       PANTHEON_TOASTS=all           → {errors, delegations, council}
  *     Unknown values fall back to the default. The gate controls the TUI
- *     display + chat-reminder fallback ONLY — every fired toast is also
+ *     display only — every fired toast is also
  *     recorded to the structured log + hooks.log (script 'toast', level
  *     'info') so the toast trail stays auditable at any setting.
  *   - Severity priority (2026-08-06): errors/blockers — hook failures
@@ -96,15 +96,9 @@
  *     One group buffer at a time (groups rarely overlap); a task call more
  *     than OLYMPIANS_DETECT_WINDOW_MS after the previous one starts a fresh
  *     group.
- *   - session.idle flush (2026-08-06): the `event` hook additionally handles
- *     `session.idle`. When the orchestrator goes idle, pending completion
- *     reminders are flushed as ONE aggregated chat reminder (individual
- *     "✅ <agent> concluiu" lines collapse into "✅ N agentes concluídos (...)")
- *     and re-armed with a fresh timestamp — so the completion summary
- *     survives until the next user message (delivered via chat.message) instead
- *     of expiring after CHAT_REMINDER_TTL_MS while the user reads the reply.
- *     Partial groups (some members completed, some never reported) and
- *     interrupted council counters are also flushed/reset here.
+ *   - session.idle handling (2026-08-06): the `event` hook additionally handles
+ *     `session.idle` to reset partial aggregation state and interrupted council
+ *     counters. Completion visibility remains in the board and TUI only.
  *   - Council notifications (new category 2026-08-06): a `task` whose prompt/
  *     description matches "council"/"conselho"/"synthesi" is treated as council
  *     activity — "🏛️ Council: especialistas consultados" on start and
@@ -122,11 +116,8 @@
  *     with wrk"). The upstream fix (server-side workspace tagging) only exists
  *     in NEWER opencode versions. THEREFORE on 1.18.13 the toast path below is
  *     a documented TUI no-op and agent-lifecycle feedback is surfaced via the
- *     oh-my-openagent fallback pattern: a `chat.message` hook injects queued
- *     signals (see pendingChatReminders / enqueueChatReminder below) as ONE
- *     <system-reminder> text part into the next user message. Toasts stay in
- *     place for future opencode versions that render them — upgrade opencode
- *     for real TUI toasts.
+ *     no transcript fallback is used. Toasts stay in place for future opencode
+ *     versions that render them — upgrade opencode for real TUI toasts.
  *   - tool.execute.after payload fix (P1-1 follow-up, 2026-08-06): the after
  *     hook receives `(input, output)` where `output` = {title, output,
  *     metadata} — the REAL tool result. It is now merged into the payload
@@ -185,13 +176,6 @@
 import { appendFile, mkdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import type { Part } from '@opencode-ai/sdk'
-import {
-  CHAT_REMINDER_TTL_MS,
-  drainFreshChatReminders,
-  enqueueChatReminder,
-  pendingChatReminders,
-} from '../pantheon/chat-reminders.ts'
 import { pantheonPluginOnce } from '../pantheon/plugin-once.ts'
 import { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
 
@@ -231,7 +215,7 @@ type ToastCategory = 'errors' | 'delegations' | 'council'
  * of enabled categories; every notification declares its category and is
  * skipped unless enabled. "off" = empty set, "all" = every category. Unknown
  * values fall back to the default. The gate controls the TUI display +
- * chat-reminder fallback ONLY — the structured log + hooks.log channels
+ * display only — the structured log + hooks.log channels
  * always write (every fired toast is recorded via reportFailure with script
  * 'toast').
  */
@@ -427,26 +411,8 @@ const BACKGROUND_DISPATCH_TEXT_RE =
 const TASK_ID_TEXT_RE = /\btask\s+id="(ses_[^"]+)"/i
 
 /**
- * 1.18.13 chat.message fallback buffer (oh-my-openagent pattern — see header):
- * opencode 1.18.13 drops tui.toast.show events (untagged), so every signal
- * that would fire a toast is ALSO queued here and injected into the next user
- * message by the 'chat.message' hook as a single <system-reminder> text part.
- *
- * The buffer itself lives in the SHARED chat-reminders.ts module: this plugin
- * file must export EXACTLY ONE function-valued export (legacy loader —
- * see the IMPORTANT note at the top), so the enqueue API cannot be exported
- * from here. Importing the shared module instead gives src/plugin.ts (a
- * separate plugin file, loaded via plain dynamic import) the SAME buffer
- * instance — release-134 Phase 4 (compaction-assert.ts) enqueues
- * post-compaction state re-assertions here and this hook delivers them.
- *
- * Bounded: at most CHAT_REMINDER_MAX entries, each expiring
- * CHAT_REMINDER_TTL_MS after its tool event. Consumed (and cleared) by the
- * chat.message hook. Full-buffer enqueues are SKIPPED, never unbounded — the
- * olympians/3-in-6s aggregates still cover delegation groups, matching the
- * "throttled toasts are skipped, never backlogged" anti-spam philosophy.
- * session.idle flushes the buffer into ONE fresh aggregated entry (see
- * flushIdleReminders) so completions survive until the next user message.
+ * Delegation lifecycle state is intentionally not mirrored into the transcript.
+ * The board/list/read tools and TUI toasts are the supported visibility channels.
  */
 
 /** Variants accepted by the opencode TUI showToast (TuiShowToastData.body.variant). */
@@ -462,11 +428,6 @@ type ToastOptions = {
   dedupeKey?: string
   /** Optional TUI toast headline (opencode showToast body.title). */
   title?: string
-  /**
-   * Optional text for the 1.18.13 chat.message <system-reminder> fallback.
-   * Defaults to `message` when omitted — the reminder mirrors the toast.
-   */
-  reminder?: string
 }
 
 /** Logging context threaded through safeRun — provided by the plugin input. */
@@ -757,10 +718,6 @@ async function notifyToast(ctx: HookContext, opts: ToastOptions): Promise<void>
       toastShown.add(opts.dedupeKey)
     }
     if (!toastCategoryEnabled(opts.category)) return
-    // 1.18.13 fallback: queue the same signal for the chat.message hook (the
-    // TUI drops tui.toast.show on 1.18.13 — see header). Enqueued even if
-    // showToast fails, so headless/no-TUI servers still surface feedback.
-    enqueueChatReminder(opts.reminder ?? opts.message)
     await ctx.client.tui.showToast({
       body: {
         ...(opts.title !== undefined ? { title: opts.title } : {}),
@@ -907,7 +864,7 @@ async function agentFailedToast(
 ): Promise<void> {
   const raw = result?.output ?? result?.title ?? ''
   // Fix 1: the failure reason echoes tool RESULT content — mask any token so
-  // the toast/chat-reminder/hooks.log trail never exposes a raw secret.
+  // the toast/hooks.log trail never exposes a raw secret.
   const reason = maskSecret(
     trim(typeof raw === 'string' && raw.trim() !== '' ? raw : 'tool failed', 120),
   )
@@ -1057,40 +1014,7 @@ function onCouncilDone(ctx: HookContext): void {
   }
 }
 
-/**
- * session.idle flush (see header): aggregate any pending chat reminders into
- * ONE fresh <system-reminder> entry (individual ✅ completions collapse into
- * "✅ N agentes concluídos (...)"), report partial groups whose members never
- * all completed, and reset interrupted council counters. The chat.message
- * hook remains the delivery path — the flushed entry has a fresh timestamp so
- * it survives until the next user message instead of expiring while the user
- * reads the reply.
- */
 function flushIdleReminders(ctx: HookContext): void {
-  if (ENABLED_TOAST_CATEGORIES.size === 0) {
-    pendingChatReminders.length = 0
-    activeOlympians = null
-    return
-  }
-  const now = Date.now()
-  const fresh = pendingChatReminders.filter((r) => now - r.at <= CHAT_REMINDER_TTL_MS)
-  pendingChatReminders.length = 0
-
-  // Partial group: some members completed but the group never finished (their
-  // completion was suppressed waiting for the aggregate). Report the subset.
-  const partialGroup = activeOlympians
-  if (partialGroup !== null) {
-    const done = [...partialGroup.agents].filter((a) => !partialGroup.pendingCompletions.has(a))
-    if (partialGroup.detected && partialGroup.doneCount > 0 && done.length > 0) {
-      fresh.push({
-        text:
-          done.length === 1
-            ? `✅ ${done[0]} concluiu`
-            : `✅ ${done.length} agentes concluídos (${done.sort().join(', ')})`,
-        at: now,
-      })
-    }
-  }
   activeOlympians = null
 
   // Interrupted council counters must not block a later council's verdict —
@@ -1105,34 +1029,12 @@ function flushIdleReminders(ctx: HookContext): void {
     councilStartNotified = false
   }
 
-  // Collapse individual ✅ completions into one aggregate line.
-  const doneAgents: string[] = []
-  const others: string[] = []
-  for (const r of fresh) {
-    const m = /^✅ (.+?) concluiu$/.exec(r.text)
-    if (m?.[1] !== undefined) doneAgents.push(m[1])
-    else others.push(r.text)
-  }
-  const lines: string[] = []
-  if (doneAgents.length > 0) {
-    lines.push(
-      doneAgents.length === 1
-        ? `✅ ${doneAgents[0]} concluiu`
-        : `✅ ${doneAgents.length} agentes concluídos (${doneAgents.sort().join(', ')})`,
-    )
-  }
-  lines.push(...others)
-  if (lines.length === 0) return
-
-  // ONE aggregated entry, fresh timestamp — chat.message delivers it next.
-  enqueueChatReminder(lines.join('\n'))
-  // 1.3.4 dedup: log a SUMMARY here (count only), never the joined body — the
-  // SAME lines used to be echoed twice (idle-flush with " | ", chat-reminder
-  // delivery with "\n"). The content is logged exactly once, at delivery.
   void reportFailure(
     ctx,
-    `[pantheon-hooks:idle-flush] ${fresh.length} reminder(s) flushed into the chat buffer (${lines.length} line(s) after aggregation)`,
-    { script: 'idle-flush', count: fresh.length, lineCount: lines.length },
+    '[pantheon-hooks:idle-flush] delegation state reset',
+    {
+      script: 'idle-flush',
+    },
     'info',
   )
 }
@@ -1213,7 +1115,7 @@ const plugin: Plugin = async ({ client, directory }) => {
   // merges the global config (npm-package plugin paths) with the project
   // config (repo source paths), so this module loads from TWO filesystem
   // paths in the same process and the factory would otherwise run twice —
-  // every hook (tool.execute.before/after, chat.message, event) firing
+  // every lifecycle hook (tool.execute.before/after and event) firing
   // TWICE. The second invocation becomes a no-op (empty hooks object) so
   // hooks register exactly once.
   if (pantheonPluginOnce('pantheon:hooks')) {
@@ -1439,51 +1341,6 @@ const plugin: Plugin = async ({ client, directory }) => {
         // Never let a hook take down the opencode session.
       }
     },
-    // 1.18.13 fallback (Path C, oh-my-openagent pattern): the TUI drops
-    // tui.toast.show events on opencode 1.18.13 (untagged — see header), so
-    // queued agent-lifecycle signals (delegation start/done, hook failures,
-    // olympians/council summaries) are injected here as ONE <system-reminder> text
-    // part into the next user message, then cleared.
-    // P0 (2026-08-11, live E2E — release blocker): this hook ALSO fires for the
-    // child session's client.session.promptAsync (the old "subagent prompts use
-    // a different path" claim is FALSE on 1.18.13), where input.messageID is
-    // EMPTY/undefined. Injecting there with `?? ''` produced a part opencode's
-    // schema rejects (SchemaError: Expected a string starting with "msg", got
-    // "") → prompt_async failed → every delegation died in ~20ms. The guard
-    // below skips injection ENTIRELY on that path WITHOUT draining the buffer,
-    // so the reminder still lands on the parent's next real message.
-    'chat.message': async (input, output) => {
-      try {
-        if (ENABLED_TOAST_CATEGORIES.size === 0) return
-        if (pendingChatReminders.length === 0) return
-        // Subagent promptAsync fires have no messageID — injecting any part
-        // with an empty messageID crashes the child session (schema reject).
-        // Early return BEFORE the buffer drain keeps the reminder queued for
-        // the parent's next real (msg_-ID'd) message.
-        if (!input.messageID) return
-        const body = drainFreshChatReminders()
-        if (body === undefined) return
-        // Minimal TextPart — the core backfills messageID/sessionID for
-        // hook-injected parts (see opencode chat.message trigger pipeline).
-        // The guard above guarantees input.messageID is a non-empty string,
-        // so no `?? ''` fallback is needed (an explicit "" is schema-rejected).
-        output.parts.push({
-          id: `prt_${crypto.randomUUID()}`,
-          sessionID: input.sessionID,
-          messageID: input.messageID,
-          type: 'text',
-          text: `<system-reminder>\n${body}\n</system-reminder>`,
-        } satisfies Part)
-        await reportFailure(
-          ctx,
-          `[pantheon-hooks:chat-reminder] ${body}`,
-          { script: 'chat-reminder' },
-          'info',
-        )
-      } catch {
-        // Never let a hook take down the opencode session.
-      }
-    },
     event: async ({ event: ev }) => {
       try {
         if (ev.type === 'session.created') {

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.