pantheon-opencode 1.4.0 → 1.4.1

package/README.md

@@ -2,7 +2,7 @@
 <h1 align="center">Pantheon</h1>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-v1.3.6--beta-blue" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-v1.4.1--candidate-blue" alt="Version"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License"></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>
@@ -239,17 +239,16 @@ Fail-open: if the child session messages are unavailable (or empty), the read
 returns the report exactly as before — the activity sampling never breaks the
 delegation read.
 
-**Completion visibility — no chat injection.** User policy: ZERO delegation
-notifications in the chat transcript — no `<task-notification>` block is ever
-injected into a `chat.message` output (the old queue + flush channel was
-removed). When a job reaches a terminal state (completion observed via
-`session.idle`/`session.error` on the child, or the timeout finalize path), the
-plugin writes a file-only audit log line (echo opt-in via `PANTHEON_HOOKS_LOG`).
-Completion visibility lives in the legitimate channels: the board `[unread]`
-marker (`pantheon_delegation_list`), `pantheon_delegation_read`, TUI toasts
-(pantheon-hooks, `PANTHEON_TOASTS` gate) and compaction carry-forward. Reconcile
-is an acknowledgment, not a completion — it never re-fires the terminal
-transition.
+**Completion visibility — zero chat noise.** Delegation notifications are never
+injected into the chat transcript: neither `chat.message` nor any other chat
+hook or transcript marker is used as a delivery channel. When a job reaches a
+terminal state (completion observed via `session.idle`/`session.error` on the
+child, or the timeout finalize path), the plugin writes a file-only audit log
+line (echo opt-in via `PANTHEON_HOOKS_LOG`). Completion visibility lives in the
+legitimate channels: the board `[unread]` marker
+(`pantheon_delegation_list`), `pantheon_delegation_read`, TUI toasts
+(`PANTHEON_TOASTS` gate), and compaction carry-forward. Reconcile is an
+acknowledgment, not a completion — it never re-fires the terminal transition.
 
 **Timeout:** `background_delegation.timeout_ms` (default `900000` = 15 min). A job
 that has not reached a terminal state is finalized as `error`/`timedOut`.
@@ -338,10 +337,9 @@ logged warn and pass-through.
 
 **Post-compaction state re-assertion (1.3.4):** on `session.compacted`, fresh
 state — running/unread delegations from the board + active goals, capped at 10
-lines — is re-injected as a `<system-reminder>` into the session's next
-message via the shared chat-reminder buffer (`chat-reminders.ts`, the same P0
-messageID guard that protects subagent fires). A session with nothing to
-assert is a silent skip.
+lines — remains available through compaction carry-forward and the board
+(`pantheon_delegation_list` / `pantheon_delegation_read`). A session with
+nothing to assert is a silent skip; no chat transcript injection is performed.
 
 **Preemptive compaction check (1.3.4):** a pure threshold core
 (`preemptive-compact.ts`) warns the model before the context fills: at 78%
@@ -350,36 +348,22 @@ dormant / ready-to-wire — opencode 1.18.x exposes no runtime context-usage
 percentage, so nothing observes it yet; when a source appears, the caller
 wires it in (the enqueue callback is injected).
 
-**Model API-key validation (1.3.4):** `pantheon_delegate` gates the resolved
-child model's provider before dispatching (single source of truth:
-`routing.yml` preset definitions' `apiKeyEnv` — the same check `applyPreset`
-enforces at startup). If an **auto-resolved** model (`options.agentModels` or
-the active preset) points to a provider that requires an API key
-(`apiKeyEnv`) and the env var is unset, the delegate falls back to
-`opencode-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).
-Setting `PANTHEON_MODEL_PRESET` to a preset whose providers have keys, or
-filling the required `PANTHEON_*_API_KEY` env var for the preset's provider,
-resolves the fallback path. If nothing resolves at all (no model, no preset),
-the child keeps using opencode's default model (warned).
-
-**agentModels wiring (1.3.4):** the delegate now also resolves the child model
-via `routing.yml` — `loadRoutingAgentModels` extracts the per-agent models of
-the FIRST-listed preset (the static default, `go-deepseek` today) and passes
-them as `options.agentModels`, branch (b) of the resolve precedence: explicit
-`model` > `options.agentModels` > active preset > opencode default. Delegation
-no longer depends exclusively on the active preset — a delegated child gets a
-sane per-agent model even when no preset is active. Fail-open: a missing or
-unparseable routing.yml yields `{}` (previous behavior, warned).
+**Model selection (1.4.1):** the child session inherits the parent session's
+model through OpenCode. A model override is supplied only when the active
+routing profile defines one; no model API-key validation is performed here.
+
+**agentModels wiring (1.3.4):** `loadRoutingAgentModels` extracts only the
+per-agent models from the explicitly active routing profile and passes them as
+`options.agentModels`. No active profile, missing profile entry, or profile
+without `model` produces an empty map; there is no implicit first-preset or
+DeepSeek fallback. A missing or unparseable `routing.yml` is fail-open and
+omits the child model.
 
 **Delegation log hygiene (1.3.4):** `delegations.log` now records the real
 `task_id` (omitted when empty, never `""`) and a **numeric** `duration_ms`
-(null when unset) so downstream aggregation works. The idle-flush log entry is
-deduplicated: the flush logs a summary (count + aggregated line count) and the
-reminder content is logged exactly once, at `chat.message` delivery — no more
-duplicate lines for the same notification.
+(null when unset) so downstream aggregation works. Terminal events are
+file-only audit entries; completion is surfaced by TUI toast (when enabled),
+the board, and the list/read tools — never by chat delivery.
 
 **Env vars & config:**
 
@@ -1040,11 +1024,17 @@ Use the isolated sandbox (`~/pantheon-sandbox/`) — **never** the dev environme
 
 **Happy path (clean edit):** any normal tool call (exit 0) is **silent** — no console output by design, even though the audit hooks append their log files (`sessions.log`, `delegations.log`). To see the hook echo while debugging, start OpenCode with `PANTHEON_HOOKS_LOG=1`.
 
-**Delegation path (chat.message reminders):** on OpenCode 1.18.13 the TUI drops `tui.toast.show` events, so delegation signals are injected into the next user message as a single `<system-reminder>` text part (oh-my-openagent fallback pattern). Ask something that dispatches subagents (e.g. *"dispare 2 subagentes apollo em paralelo para listar arquivos e comparar resultados"*) and expect:
+**Delegation path (zero chat noise):** delegation signals are surfaced through
+TUI toasts (when enabled), the board's `[unread]` marker, and the
+`pantheon_delegation_list` / `pantheon_delegation_read` tools. Ask something
+that dispatches subagents (e.g. *"dispare 2 subagentes apollo em paralelo para
+listar arquivos e comparar resultados"*) and expect:
 
-- A `<system-reminder>` in the chat with `🚀 apollo em execução` / `✅ apollo concluiu` (or the aggregate `✅ N agentes concluídos (...)` for 3+ agents completing within 6s)
+- A TUI toast with `🚀 apollo em execução` / `✅ apollo concluiu` when
+  `PANTHEON_TOASTS` permits it
+- `[unread]` in `pantheon_delegation_list` until the terminal result is read
 - An honest append to `logs/agent-sessions/delegations.log`: the **real agent name** (extracted from `tool_input.subagent_type`, never `unknown` when present) and a **non-fabricated status** — `success` only on explicit completion evidence, `failure` for refusals/errors, `unknown` otherwise
-- With `export PANTHEON_TOASTS=off` before starting OpenCode: no toasts/reminders at all
+- With `export PANTHEON_TOASTS=off` before starting OpenCode: no toasts; board/list/read and audit-log visibility remain available
 
 ### Pre-commit hooks (local secret gate)
 

package/opencode.json

@@ -14,8 +14,6 @@
   "experimental": {
     "subagent_depth": 2
   },
-  "model": "opencode-go/deepseek-v4-flash",
-  "small_model": "opencode-go/deepseek-v4-flash",
   "permission": {
     "skill": {
       "*": "allow"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",

package/src/pantheon/chat-reminders.ts

@@ -1,79 +1,9 @@
 /**
- * Chat Reminders (release-134 Phase 4) — the SHARED <system-reminder> buffer.
+ * Retired transcript-notification module.
  *
- * WHY a shared module (not owned by pantheon-hooks.ts):
- *   1. opencode's legacy plugin loader (verified in the 1.18.16 source,
- *      packages/opencode/src/plugin/index.ts getLegacyPlugins) does
- *      `Object.values(mod)` and treats EVERY export as a plugin factory —
- *      a non-function export throws `TypeError("Plugin export is not a
- *      function")` and a function export is invoked with a PluginInput.
- *      pantheon-hooks.ts therefore cannot EXPORT the enqueue API.
- *   2. src/plugin.ts (a separate plugin file) must ENQUEUE into the SAME
- *      buffer the pantheon-hooks `chat.message` hook drains — a local copy
- *      would enqueue into a buffer that is never delivered.
- *   3. opencode loads plugins via plain `await import(entry)` (PluginLoader),
- *      so both plugin files importing this module resolve to ONE module
- *      instance (Bun/Node module cache) → one shared buffer.
- *
- * release-134 Phase 4 uses this buffer for the post-compaction state
- * re-assertion: `reassertAfterCompaction` (compaction-assert.ts) enqueues a
- * fresh-state block here, and the existing chat.message delivery path
- * (pantheon-hooks.ts) injects it as a <system-reminder> into the session's
- * next message. Zero new delivery code — the P0 messageID guard already
- * protects subagent promptAsync fires.
- *
- * Bounded: at most CHAT_REMINDER_MAX entries, each expiring
- * CHAT_REMINDER_TTL_MS after enqueue. Full-buffer enqueues are SKIPPED,
- * never unbounded. No background timers — expiry is only checked on enqueue
- * and on delivery (drainFreshChatReminders).
+ * Delegation lifecycle state must not be queued for delivery into user
+ * messages. Visibility is provided by the board/list/read tools and TUI
+ * toasts; this intentionally exports no delivery API.
  *
  * @module chat-reminders
  */
-
-/**
- * Hard cap on queued reminder entries (anti-spam philosophy, matching the
- * "throttled signals are skipped, never backlogged" rule).
- */
-export const CHAT_REMINDER_MAX = 10
-
-/** How long a queued reminder stays deliverable (pruned after ~60s). */
-export const CHAT_REMINDER_TTL_MS = 60_000
-
-/** One queued reminder: the text plus its enqueue timestamp. */
-export interface ChatReminderEntry {
-  text: string
-  at: number
-}
-
-/** The shared buffer — module-level state, consumed by the chat.message hook. */
-export const pendingChatReminders: ChatReminderEntry[] = []
-
-/**
- * Queue one chat-reminder entry, pruning expired entries first. Never throws.
- * A full buffer skips the push (bounded, never backlogged).
- */
-export function enqueueChatReminder(text: string): void {
-  const now = Date.now()
-  for (let i = pendingChatReminders.length - 1; i >= 0; i--) {
-    const r = pendingChatReminders[i]
-    if (r !== undefined && now - r.at > CHAT_REMINDER_TTL_MS) pendingChatReminders.splice(i, 1)
-  }
-  if (pendingChatReminders.length >= CHAT_REMINDER_MAX) return
-  pendingChatReminders.push({ text, at: now })
-}
-
-/**
- * Deliver (drain) every FRESH reminder as one joined block: expired entries
- * are dropped, the buffer is cleared in all cases (no leak). Returns
- * undefined when nothing fresh remains — the caller skips injection.
- *
- * This is the delivery helper the pantheon-hooks `chat.message` hook calls
- * AFTER its P0 messageID guard (empty messageID → early return, buffer kept).
- */
-export function drainFreshChatReminders(): string | undefined {
-  const now = Date.now()
-  const fresh = pendingChatReminders.filter((r) => now - r.at <= CHAT_REMINDER_TTL_MS)
-  pendingChatReminders.length = 0
-  if (fresh.length === 0) return undefined
-  return fresh.map((r) => r.text).join('\n')
-}

package/src/pantheon/compaction-assert.ts

@@ -1,37 +1,31 @@
 /**
- * Compaction Re-Assert (release-134 Phase 4) — re-inject fresh state after
- * compaction.
+ * Compaction Re-Assert (release-134 Phase 4) — detect fresh state after
+ * compaction without writing to the chat transcript.
  *
  * WHY: after a session is compacted, the system state may have changed since
  * the summary was built (new background delegations launched, results
  * delivered, goals updated). The compacted session's context is frozen at
  * summary time — the model would operate on stale state.
  *
- * HOW: the `session.compacted` event hook calls `reassertAfterCompaction`,
- * which builds a COMPACT fresh-state block (running + unread delegations from
- * the board, active goals from the GoalStore — same gating as Phase 2) and
- * enqueues it into the SHARED chat-reminder buffer (chat-reminders.ts). The
- * existing pantheon-hooks `chat.message` hook delivers it as a
- * <system-reminder> into the session's next message — zero new delivery
- * code, and the P0 messageID guard already protects subagent fires.
+ * HOW: the compaction lifecycle keeps the board and goal stores authoritative;
+ * the `experimental.session.compacting` hook builds the context that is
+ * consumed by the compaction itself. Chat is never used as a delivery channel.
  *
  * Deliberately NOT `session.promptAsync({noReply:true})`: the sprint 4+7
  * spike refuted noReply as a push mechanism on this opencode build (nothing
  * is delivered to the parent).
  *
- * FAIL-OPEN: every source (board list, goals list, enqueue) is wrapped —
+ * FAIL-OPEN: every source (board list and goals list) is wrapped —
  * a failure logs a warn via the silence-by-default logger and the hook never
  * throws. A session with NO fresh state (nothing running/unread/goals) is a
- * SILENT skip (no warn, no reminder). The block is capped at
+ * SILENT skip (no warn). The block is capped at
  * REASSERT_MAX_LINES item lines (1 header) so it stays compact.
  *
- * Pure TypeScript — zero runtime deps beyond the board/goal types and the
- * shared reminder buffer.
+ * Pure TypeScript — zero runtime deps beyond the board/goal types.
  *
  * @module compaction-assert
  */
 import type { BackgroundJobBoard } from './background-job-board.ts'
-import { enqueueChatReminder } from './chat-reminders.ts'
 import type { CompactionGoalSource } from './delegation-compaction.ts'
 import { createPantheonLogger } from './logger.ts'
 
@@ -51,16 +45,16 @@ export const REASSERT_HEADER = 'State re-assertion after compaction — the summ
 
 /** Dependencies threaded to reassertAfterCompaction (wired from plugin.ts). */
 export interface CompactionAssertDeps {
-  /** The compacted session whose next message receives the reminder. */
+  /** The session whose compaction context is being prepared. */
   sessionID: string
   /** Board query surface — `list` is all the re-assertion needs. */
   board: Pick<BackgroundJobBoard, 'list'>
   /** Goal source for the goals block (optional — same gating as Phase 2). */
   goals?: CompactionGoalSource
-  /** Injectable enqueue (testable). Defaults to the shared chat buffer. */
-  enqueue?: (text: string) => void
   /** Injectable warn logger (testable). Defaults to silence-by-default. */
   logger?: { warn: (message: string) => void }
+  /** Non-chat delivery sink (for example a pending `output.context` block). */
+  deliverContext?: (context: string[]) => void | Promise<void>
 }
 
 // ─── Formatting ────────────────────────────────────────────────────────
@@ -135,26 +129,32 @@ async function buildStateLines(
 }
 
 /**
- * Re-assert fresh state for a compacted session: build the compact block and
- * enqueue it as a chat reminder (delivered on the session's next message).
+ * Re-assert fresh state for a compacted session and return the context block
+ * to the non-chat caller. The caller can hand this array to OpenCode's
+ * `output.context` or persist it through the board; constructing it here and
+ * throwing it away would make the hook a no-op.
  *
- * Returns true when a reminder was enqueued; false when there was nothing to
- * assert (silent skip) or a source failed (warned). NEVER throws — the event
- * hook must never break the session.
+ * Returns the fresh-state context when found, or undefined when there was
+ * nothing to assert (silent skip) or a source failed (warned). NEVER throws —
+ * the event hook must never break the session.
  */
-export async function reassertAfterCompaction(deps: CompactionAssertDeps): Promise<boolean> {
+export async function reassertAfterCompaction(
+  deps: CompactionAssertDeps,
+): Promise<string[] | undefined> {
   // Silence-by-default logger: file-only warn, console echo opt-in via
   // PANTHEON_HOOKS_LOG=1 (TUI pollution policy, pantheon-hooks L42-58).
   const warn = deps.logger?.warn ?? ((message: string) => log.warn(message))
   try {
     const lines = await buildStateLines(deps, warn)
-    if (lines === undefined) return false
-    const enqueue = deps.enqueue ?? enqueueChatReminder
-    enqueue(`${REASSERT_HEADER}\n${lines.join('\n')}`)
-    return true
+    if (lines === undefined) return undefined
+    // This is a context return value, not a chat message. The caller owns the
+    // supported delivery path (output.context or persisted board state).
+    const context = [REASSERT_HEADER, ...lines]
+    await deps.deliverContext?.(context)
+    return context
   } catch (err: unknown) {
     const reason = err instanceof Error ? err.message : String(err)
     warn(`compaction re-assert failed for session ${deps.sessionID}: ${reason}`)
-    return false
+    return undefined
   }
 }

package/src/pantheon/delegation-finalize.ts

@@ -172,24 +172,48 @@ export const DELEGATION_DEFAULTS = {
 
 // ─── Output pulling ────────────────────────────────────────────────────
 
-/** Concatenate every non-empty text part across the child's messages. */
-async function pullOutput(client: DelegationClient, childSessionID: string): Promise<string> {
+interface PulledOutput {
+  text: string
+  /** True only when the child produced an assistant message or tool activity. */
+  hasWork: boolean
+}
+
+/** Pull visible text and structurally identify real child work. */
+async function pullOutput(client: DelegationClient, childSessionID: string): Promise<PulledOutput> {
   if (typeof client.session.messages !== 'function')
-    return '(child session messages API unavailable)'
+    return { text: '(child session messages API unavailable)', hasWork: false }
   try {
     const bundles = await client.session.messages({ path: { id: childSessionID } })
     const lines: string[] = []
+    let hasWork = false
     for (const bundle of bundles) {
+      const hasToolPart = (bundle.parts ?? []).some((part) => part.type === 'tool')
+      const hasTextPart = (bundle.parts ?? []).some(
+        (part) => part.type === 'text' && typeof part.text === 'string' && part.text.trim() !== '',
+      )
+      if (
+        bundle.info?.role === 'assistant' &&
+        bundle.info.error === undefined &&
+        (hasToolPart || hasTextPart)
+      ) {
+        hasWork = true
+      }
       for (const part of bundle.parts ?? []) {
+        if (
+          part.type === 'tool' &&
+          bundle.info?.role === 'assistant' &&
+          bundle.info.error === undefined
+        )
+          hasWork = true
         if (part.type === 'text' && typeof part.text === 'string' && part.text.trim() !== '') {
           lines.push(part.text)
         }
       }
     }
-    return lines.join('\n\n')
+    return { text: lines.join('\n\n'), hasWork }
   } catch (err: unknown) {
     const reason = err instanceof Error ? err.message : String(err)
-    return `(failed to pull child session output: ${reason})`
+    return { text: `(failed to pull child session output: ${reason})`, hasWork: false }
   }
 }
 
@@ -311,9 +335,18 @@ export async function finalizeDelegation(
   const job = deps.board.get(childSessionID)
   if (!job) return undefined
 
-  const output = await pullOutput(deps.client, childSessionID)
+  const pulled = await pullOutput(deps.client, childSessionID)
+  const output = pulled.text
+  const effectiveOpts: FinalizeInput =
+    opts.state === 'completed' && !pulled.hasWork
+      ? {
+          state: 'error',
+          error: opts.error ?? 'Child session produced no assistant or tool output',
+          ...(opts.timedOut !== undefined ? { timedOut: opts.timedOut } : {}),
+        }
+      : opts
   const outputDir = deps.options.outputDir ?? DELEGATION_DEFAULTS.outputDir
-  await writeDelegationReport(outputDir, job, renderDelegationMarkdown(job, output, opts))
+  await writeDelegationReport(outputDir, job, renderDelegationMarkdown(job, output, effectiveOpts))
 
   const status: {
     taskID: string
@@ -323,15 +356,15 @@ export async function finalizeDelegation(
     resultSummary?: string
   } = {
     taskID: childSessionID,
-    state: opts.state,
+    state: effectiveOpts.state,
     resultSummary: summarizeOutput(output),
   }
-  if (opts.error !== undefined) status.error = opts.error
-  if (opts.timedOut !== undefined) status.timedOut = opts.timedOut
+  if (effectiveOpts.error !== undefined) status.error = effectiveOpts.error
+  if (effectiveOpts.timedOut !== undefined) status.timedOut = effectiveOpts.timedOut
 
   const current = deps.board.get(childSessionID)
   if (current !== undefined) {
-    if (current.state === 'running' || current.state === opts.state) {
+    if (current.state === 'running' || current.state === effectiveOpts.state) {
       await deps.board.updateStatus(status)
     }
     // Terminal in a DIFFERENT state (e.g. timeout already recorded) — the

package/src/pantheon/delegation-toast.ts

@@ -0,0 +1,73 @@
+import type { BackgroundJobRecord } from './background-job-board.ts'
+
+type ToastCategory = 'errors' | 'delegations' | 'council'
+
+const toastMode = (process.env.PANTHEON_TOASTS ?? '').trim().toLowerCase()
+const enabledToastCategories: ReadonlySet<ToastCategory> = (() => {
+  switch (toastMode) {
+    case 'off':
+      return new Set()
+    case 'errors':
+      return new Set(['errors'])
+    case 'council':
+      return new Set(['errors', 'council'])
+    case 'all':
+      return new Set(['errors', 'delegations', 'council'])
+    default:
+      return new Set(['errors', 'delegations', 'council'])
+  }
+})()
+const terminalToastsShown = new Set<string>()
+const terminalStates = new Set(['completed', 'error', 'cancelled'])
+
+/** Match the lifecycle toast gate used by pantheon-hooks. */
+export function delegationToastEnabled(): boolean {
+  return enabledToastCategories.has('delegations')
+}
+
+export type ToastClient = {
+  tui?: {
+    showToast?: (input: {
+      body: {
+        title?: string
+        message: string
+        variant: 'info' | 'success' | 'warning' | 'error'
+        duration: number
+      }
+    }) => Promise<unknown>
+  }
+}
+
+/** Best-effort visual completion signal; never affects board finalization. */
+export async function showDelegationTerminalToast(
+  client: ToastClient,
+  job: Pick<BackgroundJobRecord, 'taskID' | 'alias' | 'agent' | 'state' | 'timedOut'>,
+): Promise<void> {
+  try {
+    if (!delegationToastEnabled()) return
+    const isTerminal = job.timedOut || terminalStates.has(job.state)
+    if (isTerminal) {
+      if (terminalToastsShown.has(job.taskID)) return
+      terminalToastsShown.add(job.taskID)
+    }
+    const showToast = client.tui?.showToast
+    if (typeof showToast !== 'function') return
+    const state = job.timedOut ? 'timeout' : job.state
+    const variant =
+      state === 'completed'
+        ? 'success'
+        : state === 'error' || state === 'timeout'
+          ? 'error'
+          : 'warning'
+    await showToast({
+      body: {
+        title: 'Delegação concluída',
+        message: `${job.alias} (${job.agent}) — ${state}`,
+        variant,
+        duration: 4000,
+      },
+    })
+  } catch {
+    // TUI is optional (and may disappear during shutdown); completion is durable.
+  }
+}

package/src/pantheon/delegation.ts

@@ -58,14 +58,9 @@ import {
   finalizeDelegation as finalizeDelegationReport,
   readDelegationReport,
 } from './delegation-finalize.ts'
-import {
-  type IdleChildScanDeps,
-  finalizeIdleChildrenWithoutMd,
-  startIdleChildScan,
-} from './delegation-notify.ts'
+import { finalizeIdleChildrenWithoutMd } from './delegation-notify.ts'
 import { createPantheonLogger } from './logger.ts'
 import { buildAgentListDescription } from './permission-globs.ts'
-import { missingProviderKeyEnv, resolveActivePreset } from './presets.mjs'
 import { buildStopInstruction, cappedSummary, DEFAULT_MAX_STEPS } from './step-cap.ts'
 
 export type {
@@ -217,8 +212,10 @@ async function bootstrapChild(
     const remainingMs = timeoutMs - (now() - startedAt)
     if (hasMessagesAPI) {
       try {
+        const messagesAPI = client.session.messages
+        if (messagesAPI === undefined) continue
         const messages = await boundedProbe(
-          client.session.messages!({ path: { id: childSessionID } }),
+          messagesAPI({ path: { id: childSessionID } }),
           remainingMs,
         )
         if (messages !== undefined) {
@@ -231,8 +228,10 @@ async function bootstrapChild(
     }
     if (hasStatusAPI) {
       try {
+        const statusAPI = client.session.get
+        if (statusAPI === undefined) continue
         const status = await boundedProbe(
-          client.session.get!({ path: { id: childSessionID } }),
+          statusAPI({ path: { id: childSessionID } }),
           timeoutMs - (now() - startedAt),
         )
         if (status !== undefined) {
@@ -591,20 +590,6 @@ export interface ChildSessionModelRef {
   providerID: string
 }
 
-/**
- * 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
- * `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-go/deepseek-v4-flash'
-
 /**
  * Split a `provider/model` model ID (e.g. `opencode/deepseek-v4-flash-free`)
  * into the `{ id, providerID }` ref the session.create body expects.
@@ -617,12 +602,10 @@ function splitModelRef(model: string): ChildSessionModelRef | undefined {
 }
 
 /**
- * Resolve the child session model with priority:
- *   1. explicit `model` option passed to the delegate tool;
- *   2. `options.agentModels[agent]` (routing.yml agent entry, case-insensitive);
- *   3. the active preset's agent entry via resolveActivePreset();
- *   4. fallback: undefined — the child is created without a model (the
- *      caller warns) so opencode's default applies.
+ * Resolve only an explicitly supplied model. A routing profile's `model` is
+ * passed through as `options.agentModels`; profiles without one, and agents
+ * without a profile, intentionally resolve to undefined so the OpenCode
+ * parent session can provide inheritance.
  */
 function resolveChildModel(
   options: DelegationOptions,
@@ -641,43 +624,14 @@ function resolveChildModel(
     const ref = splitModelRef(mapped)
     if (ref !== undefined) return ref
   }
-  // (c) active preset agent entry (resolveActivePreset reads routing.yml
-  // presets + .pantheon/active-preset.json). Guarded — a broken routing.yml
-  // must never kill the delegate.
-  try {
-    const presetModel = resolveActivePreset({
-      ...(options.presetEnv !== undefined ? { env: options.presetEnv } : {}),
-      ...(options.logger !== undefined ? { logger: options.logger } : {}),
-    })?.agents?.[key]?.model
-    if (presetModel !== undefined && presetModel !== '') {
-      const ref = splitModelRef(presetModel)
-      if (ref !== undefined) return ref
-    }
-  } catch (err: unknown) {
-    const reason = err instanceof Error ? err.message : String(err)
-    options.logger?.warn?.(`[pantheon-delegate] active preset resolution failed: ${reason}`)
-  }
   return undefined
 }
 
 /**
- * Resolve a USABLE child model for a delegate dispatch, gating the resolved
- * provider's API key (P1, 2026-08-11 — release 1.3.4):
- *
- *   1. resolve the model with the existing precedence (explicit `model` >
- *      options.agentModels > active preset) — see resolveChildModel.
- *   2. provider key gate: the resolved provider requires its apiKeyEnv env
- *      var (routing.yml preset defs — same source applyPreset enforces at
- *      startup). No gate (native providers) or key present → usable as-is.
- *   3. key MISSING + EXPLICIT caller model → respected anyway (user intent),
- *      warned.
- *   4. key MISSING + AUTO-resolved model → fall back to FALLBACK_MODEL
- *      (validated the same way). Fallback also unusable → returns an `error`
- *      TEXT (the caller returns it from the tool — never throws) and the
- *      caller registers NO job on the board.
- *
- * The no-model case (nothing resolved) keeps the pre-existing behavior:
- * warn and let the child use opencode's default.
+ * Resolve a child model without selecting a provider or model on the caller's
+ * behalf. OpenCode owns model inheritance when this returns no model; if the
+ * host requires one, its session.create/promptAsync error is returned with
+ * the normal diagnostic rather than silently choosing a fallback.
  *
  * @returns `{ model, error }` — at most one of `model` / `error` is set;
  *   both may be unset (no model resolved, warn emitted).
@@ -687,50 +641,15 @@ function resolveUsableChildModel(
   agent: string,
   explicitModel: string | undefined,
 ): { model: ChildSessionModelRef | undefined; error: string | undefined } {
-  const env = options.presetEnv ?? process.env
-  const explicit = explicitModel !== undefined && explicitModel !== ''
-  const warn = (msg: string) => options.logger?.warn?.(msg)
-
   const model = resolveChildModel(options, agent, explicitModel)
   if (model === undefined) {
-    warn(
+    options.logger?.warn?.(
       `[pantheon-delegate] no model resolved for agent "${agent}" — ` +
-        "child session will use opencode's default model (may require API keys)",
+        'omitting model so OpenCode can inherit it from the parent session',
     )
     return { model: undefined, error: undefined }
   }
-
-  const missingVar = missingProviderKeyEnv(model.providerID, { env })
-  if (missingVar === undefined) return { model, error: undefined }
-
-  if (explicit) {
-    // Rule of precedence: the caller's explicit model is respected — warn only.
-    warn(
-      `[pantheon-delegate] model "${explicitModel}" provider "${model.providerID}" requires ` +
-        `API key ${missingVar} (unset) — respecting the explicit model anyway`,
-    )
-    return { model, error: undefined }
-  }
-
-  // Auto-resolved (agentModels / preset) → try the known-good fallback.
-  const fallback = splitModelRef(FALLBACK_MODEL)
-  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}`,
-    )
-    return { model: fallback, error: undefined }
-  }
-
-  const message =
-    `pantheon_delegate: no usable model for agent "${agent}" — provider "${model.providerID}" ` +
-    `requires API key (set ${missingVar} or PANTHEON_MODEL_PRESET)`
-  warn(`[pantheon-delegate] ${message}`)
-  return { model: undefined, error: message }
+  return { model, error: undefined }
 }
 
 // ─── Factory ───────────────────────────────────────────────────────────
@@ -900,13 +819,8 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       // session.create failure → return a clear error as TEXT (tools return
       // errors as text, not thrown) and register NO job on the board — an
       // unhandled rejection here would otherwise lose the failure entirely.
-      // The child model is resolved with a provider API-key gate (P1): the
-      // resolved model (explicit `model` > options.agentModels > active
-      // 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-go/deepseek-v4-flash; if nothing usable remains the
-      // failure is returned as TEXT below — no session, no board job.
+      // Only an explicit delegate model or routing profile model is sent.
+      // Otherwise omit it so OpenCode inherits the parent model.
       const resolved = resolveUsableChildModel(options, args.agent, args.model)
       if (resolved.error !== undefined) {
         if (budgetReserved && budgetKey !== undefined)

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

@@ -345,46 +345,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
 }
 
 /**

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,6 +28,7 @@ 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'
@@ -62,17 +62,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 +79,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 +98,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 +215,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 +334,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 +369,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 } : {}),
@@ -546,9 +543,7 @@ const plugin: Plugin = async (input: PluginInput) => {
     '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 +568,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/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pantheon-tui",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pantheon-tui",
-      "version": "1.3.2",
+      "version": "1.4.1",
       "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.0",
+  "version": "1.4.1",
   "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": {