pantheon-opencode 1.3.2 → 1.3.4

package/src/plugin.ts

@@ -1,12 +1,52 @@
 import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import type { PluginConfig } from 'opencode'
 import { BackgroundJobBoard } from './pantheon/background-job-board.ts'
+import { reassertAfterCompaction } from './pantheon/compaction-assert.ts'
+import { createCostCommand } from './pantheon/cost-command.ts'
+import {
+  collectRootSessionIDs,
+  createDelegationTools,
+  type DelegationClient,
+} from './pantheon/delegation.ts'
+import { buildCompactionContext } from './pantheon/delegation-compaction.ts'
+import { createEnforcementGuard, readOnlyRegistry } from './pantheon/delegation-enforce.ts'
+import { handleDelegationEvent } from './pantheon/delegation-notify.ts'
 import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
-import { applyActivePresetToConfig } from './pantheon/presets.mjs'
+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 { pantheonPluginOnce } from './pantheon/plugin-once.ts'
+import { applyActivePresetToConfig, loadRoutingAgentModels } from './pantheon/presets.mjs'
+import {
+  TODO_ENFORCER_DEFAULTS,
+  TodoEnforcer,
+  type TodoEnforcerClient,
+  todoEnforcerEnabledFromEnv,
+} from './pantheon/todo-enforcer.ts'
+import { TodoPreserver } from './pantheon/todo-preserve.ts'
 import { activePresetCandidates, createVisionHandler } from './pantheon/vision.ts'
 
 // ─── Background Job Board Singleton ────────────────────────────────────
 
+// Silence-by-default TUI policy (pantheon-hooks L42-58): console output in a
+// plugin writes to the process stdout/stderr, which the opencode TUI renders
+// directly into the terminal — the "lixo". Every line goes to
+// .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 })
+
 const board = new BackgroundJobBoard({
   maxConcurrentPerAgent: 3,
   signalDir: '.pantheon/deepwork/board-signals',
@@ -15,16 +55,174 @@ const persistence = new FilePersistenceAdapter('.pantheon/board/state.json')
 board.setPersistence(persistence)
 board
   .recoverRunningJobs()
-  .catch((err) => console.error('[Pantheon Plugin] Failed to recover running jobs:', err))
+  .catch((err) => log.error('[Pantheon Plugin] Failed to recover running jobs:', err))
+// ─── Phase 3: Board terminal audit log ─────────────────────────────────
+
+// The onTerminal listener is the completion AUDIT point: it writes a
+// file-only log line (console echo opt-in via PANTHEON_HOOKS_LOG). There is
+// deliberately NO chat delivery — the user policy is zero delegation
+// notifications in the transcript. Completion visibility lives in the board
+// `[unread]` marker (pantheon_delegation_list), pantheon_delegation_read,
+// TUI toasts (pantheon-hooks, PANTHEON_TOASTS gate) and compaction
+// carry-forward.
 board.onTerminal((taskID: string) => {
   const job = board.get(taskID)
-  if (job) {
-    console.log(
-      `[Pantheon Plugin] Board terminal: [${job.alias}] ${job.description} → ${job.state}${job.resultSummary ? ` — ${job.resultSummary}` : ''}`,
-    )
-  }
+  if (!job) return
+  log.info(
+    `[Pantheon Plugin] Board terminal: [${job.alias}] ${job.description} → ${job.state}${job.resultSummary ? ` — ${job.resultSummary}` : ''}`,
+  )
+})
+
+// Periodically prune terminal/reconciled jobs (24h TTL, every 30 min).
+// pruneExpired is async and internally swallows persistence errors, so the
+// void-catch here is purely defensive. .unref() ensures the timer never
+// keeps the process alive on its own.
+setInterval(
+  () => {
+    void board
+      .pruneExpired(86_400_000)
+      .catch((err: unknown) => log.error('[Pantheon Plugin] Background board prune failed:', err))
+  },
+  30 * 60 * 1000,
+).unref()
+
+// ─── Phase 4: Read-Only Enforcement + Compaction Context ───────────────
+
+// The read-only registry is populated by createDelegationTools (delegation.ts)
+// when a delegate is read-only (explicit flag or agent ∈ readOnlyAgents).
+// The guard denies edit/write/bash/task inside those sessions by throwing
+// from tool.execute.before; unknown sessions are allowed (safe default).
+const enforcementGuard = createEnforcementGuard({
+  getReadOnlySessions: () => readOnlyRegistry.sessionIDs(),
 })
 
+// Mirrors routing.yml background_delegation.max_compaction_items.
+const COMPACTION_MAX_ITEMS = 10
+
+// Root-session registry for the delegation depth guard: sessions created
+// without a parentID are roots. Populated from TWO sources:
+//   1. the `session.created` event hook (live roots — fires for sessions
+//      created while the plugin runs);
+//   2. a fail-open startup seed from client.session.list() in the config
+//      hook (compaction-134) — opencode does NOT replay session.created
+//      events for sessions that exist before plugin load, so without the
+//      seed a resumed root would never enter this set after a restart.
+// delegation.ts additionally falls back to knownChildren ("any session WE
+// created is a sub-session; unknown sessions are roots") so the depth guard
+// works even when this set is incomplete.
+const rootSessions = new Set<string>()
+
+/**
+ * Seed resumed root sessions without making OpenCode startup depend on the
+ * session API responding. Some OpenCode environments do not have the API
+ * ready while plugin config hooks run; awaiting session.list() there leaves
+ * the TUI stuck before it can open. The delegation layer already treats an
+ * unknown session as a root, so this enrichment is deliberately best-effort.
+ */
+function seedRootSessionsInBackground(input: PluginInput): void {
+  // Fail-open: environments without the session API (client.session absent or
+  // not yet wired while config hooks run) must NOT break startup. `session`
+  // is captured and the method invoked on it so `this` stays bound; the
+  // delegation layer already treats unknown sessions as roots, so skipping
+  // the seed is always safe.
+  const session = input.client.session
+  if (typeof session?.list !== 'function') return
+  void session
+    .list()
+    .then((result) => {
+      if (!result.error && Array.isArray(result.data)) {
+        const seeded = collectRootSessionIDs(result.data)
+        if (seeded.size > 0) {
+          for (const id of seeded) rootSessions.add(id)
+          log.info(`[Pantheon Plugin] Seeded ${seeded.size} root session(s) from session.list`)
+        }
+      }
+    })
+    .catch((err) => {
+      log.warn('[Pantheon Plugin] Root session seed failed (fail-open):', err)
+    })
+}
+
+/** Extract the SDK error message ({name, data: {message}}) or a fallback. */
+function sdkErrorMessage(error: { data?: { message?: string } } | null | undefined): string {
+  const message = error?.data?.message
+  return typeof message === 'string' && message.trim() !== '' ? message : 'request failed'
+}
+
+/**
+ * Adapt the opencode SDK client to the structural DelegationClient the
+ * delegation toolset expects: the SDK wraps every call in a
+ * `{data, error, request, response}` result while delegation.ts uses direct
+ * returns. Errors surface as throws so the toolset's own error handling
+ * (tool errors returned as TEXT) keeps working.
+ */
+function adaptDelegationClient(client: PluginInput['client']): DelegationClient {
+  return {
+    session: {
+      create: async (input) => {
+        const body: {
+          parentID?: string
+          title?: string
+          model?: { id: string; providerID: string }
+        } = { parentID: input.body.parentID }
+        if (input.body.title !== undefined) body.title = input.body.title
+        // Forward the routed child model (E2E fix): without it the child
+        // falls back to the key-gated default model and dies at startup.
+        if (input.body.model !== undefined) body.model = input.body.model
+        const result = await client.session.create({ body })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return { id: result.data.id }
+      },
+      promptAsync: async (input) => {
+        const result = await client.session.promptAsync({
+          path: input.path,
+          body: { agent: input.body.agent, parts: input.body.parts },
+        })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+      messages: async (input) => {
+        const result = await client.session.messages({ path: input.path })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+    },
+  }
+}
+
+/**
+ * Adapt the opencode SDK client to the structural TodoEnforcerClient the
+ * todo enforcer expects: unwraps the SDK `{data, error, request, response}`
+ * result and surfaces errors as throws (the enforcer swallows + logs them,
+ * so the event hook can never break the session).
+ */
+function adaptTodoEnforcerClient(client: PluginInput['client']): TodoEnforcerClient {
+  return {
+    session: {
+      todo: async (input) => {
+        const result = await client.session.todo({ path: input.path })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+      messages: async (input) => {
+        const result = await client.session.messages({ path: input.path })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+      children: async (input) => {
+        const result = await client.session.children({ path: input.path })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+      promptAsync: async (input) => {
+        const result = await client.session.promptAsync({ path: input.path, body: input.body })
+        if (result.error) throw new Error(sdkErrorMessage(result.error))
+        return result.data
+      },
+    },
+  }
+}
+
 /**
  * Pantheon plugin for OpenCode. Pasted images are intercepted via the
  * `chat.message` hook (proven to fire in opencode 1.18.11). When a provider
@@ -52,10 +250,91 @@ board.onTerminal((taskID: string) => {
  * Helpers live in src/pantheon/vision.ts and are imported from there directly.
  */
 const plugin: Plugin = async (input: PluginInput) => {
+  // 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
+  // config (repo source paths), so this module loads from TWO filesystem
+  // paths in the same process and the factory would otherwise run twice. The
+  // second invocation becomes a no-op: an empty hooks object (every Hooks
+  // field is optional) → hooks/tools register exactly once.
+  if (pantheonPluginOnce('pantheon:plugin')) {
+    return {}
+  }
   const vision = createVisionHandler(input)
+  // Phase 2/3: background delegation toolset + the bound finalize lifecycle
+  // hook. Completion is observed through the event hook below
+  // (session.idle / session.error on a child) → finalizeDelegation.
+  const delegation = createDelegationTools({
+    board,
+    client: adaptDelegationClient(input.client),
+    options: {
+      rootSessions,
+      readOnlyAgents: new Set(['apollo', 'gaia']),
+      agentModels: routingAgentModels,
+    },
+  })
+
+  // Wave 1 (PR #46): TODO continuation enforcer for root/non-board sessions.
+  // Mirrors routing.yml `todo_enforcer` (plugin scope has no routing.yml
+  // access — COMPACTION_MAX_ITEMS pattern). The event hook routes non-board
+  // session.idle events here; board-child idles go to finalizeDelegation.
+  // Runtime kill-switch: PANTHEON_TODO_ENFORCER=off (routing.yml is a doc
+  // mirror only — the env var is the real switch, PANTHEON_TOASTS pattern).
+  const todoEnforcer = new TodoEnforcer({
+    client: adaptTodoEnforcerClient(input.client),
+    board,
+    options: { ...TODO_ENFORCER_DEFAULTS, enabled: todoEnforcerEnabledFromEnv() },
+  })
+
+  // release-134 Phase 3: post-compaction todo restore. Captures the session's
+  // todo list in 'experimental.session.compacting', activates the snapshot on
+  // 'session.compacted', and rewrites the first post-compaction `todowrite`
+  // with the exact list (todo-preserve.ts). Additive + fail-open: every step
+  // degrades to a logged warn, never throws in a hook.
+  const todoPreserver = new TodoPreserver({
+    client: adaptTodoEnforcerClient(input.client),
+  })
+
+  // Wave 3 (PR #46): full-auto goal loop — opt-in (`full_auto.enabled:
+  // false` default, mirrored by GOAL_LOOP_DEFAULTS). File-based GoalStore
+  // (`.pantheon/goals/<sessionID>.json` — the plugin layer cannot reach MCP
+  // KV). Idle routing: an active goal owns the idle (goal loop); otherwise
+  // the todo enforcer gets it (see idle-continuation.ts).
+  const goalStore = new GoalStore({ dir: '.pantheon/goals' })
+  const goalLoop = new GoalLoop({
+    store: goalStore,
+    client: adaptTodoEnforcerClient(input.client),
+    board,
+    options: GOAL_LOOP_DEFAULTS,
+  })
+  const goalTools = goalLoop.tools()
+  const idleDispatcher = createIdleDispatcher({ goalLoop, todoEnforcer })
+
+  // Wave 2 (PR #46): hashline — tag-anchored edits. The read enhancer
+  // (tool.execute.after) augments `read` output with per-line sha256 tags
+  // (`12#XJ|content`); hashline_edit anchors edits to those refs. Additive —
+  // the plugin has no tool.execute.after yet, and pantheon-hooks.ts (a
+  // separate plugin instance) keeps its own. Mirrors routing.yml `hashline`.
+  const hashlineEdit = createHashlineEditTool()
+  const readEnhancer = createReadEnhancer()
+
+  // Wave 4 (PR #46): /cost — delegation cost + token visibility. Reads
+  // opencode.db read-only (node:sqlite, falls back to scripts/cost.mjs).
+  // Fully wired (unlike dispatch-guard, which is manual-orchestration-only
+  // because opencode 1.18.x cannot intercept task completion via hooks).
+  const costCommand = createCostCommand()
 
   return {
     config: async (config: PluginConfig) => {
+      // compaction-134 seed: opencode does NOT replay `session.created`
+      // events for sessions that exist before plugin load, so after a
+      // restart the resumed ROOT session never enters rootSessions and the
+      // depth guard would reject its pantheon_delegate calls. Seed the
+      // registry from session.list() in the background — every session
+      // WITHOUT a parentID is a root. Fail-open: a failed/throttled list
+      // leaves the set untouched (delegation.ts treats unknown sessions as
+      // roots), and config setup must never wait for the session API.
+      seedRootSessionsInBackground(input)
       config.agentsPath = config.agentsPath ?? []
       config.agentsPath.push(new URL('./agents', import.meta.url).pathname)
       config.skillsPaths = config.skillsPaths ?? []
@@ -74,9 +353,7 @@ const plugin: Plugin = async (input: PluginInput) => {
           candidates: activePresetCandidates(),
         })
         if (resolved) {
-          console.log(
-            `[Pantheon Plugin] Applied model preset: ${resolved.name} (${resolved.source})`,
-          )
+          log.info(`[Pantheon Plugin] Applied model preset: ${resolved.name} (${resolved.source})`)
         }
       } catch {
         // Fully STATIC warning — the thrown error object is tainted because
@@ -89,12 +366,128 @@ const plugin: Plugin = async (input: PluginInput) => {
         // emitted by applyActivePresetToConfig's own logger before it throws.
         // The catch binding is intentionally omitted so no tainted value can
         // ever reach this log line (CodeQL alert #11).
-        console.warn('[plugin] preset application failed (see logs for details)')
+        log.warn('[plugin] preset application failed (see logs for details)')
       }
     },
-    'chat.message': vision.chatMessage,
+    // Phase 2: background delegation tools (structural — matches the `tool`
+    // hook field shape; read_only sessions feed the Phase 4 registry).
+    tool: {
+      pantheon_delegate: delegation.pantheon_delegate,
+      pantheon_delegation_read: delegation.pantheon_delegation_read,
+      pantheon_delegation_list: delegation.pantheon_delegation_list,
+      hashline_edit: hashlineEdit,
+      // Wave 3 (PR #46): full-auto goal tools (single active goal/session).
+      pantheon_goal_create: goalTools.pantheon_goal_create,
+      pantheon_goal_update: goalTools.pantheon_goal_update,
+      pantheon_goal_get: goalTools.pantheon_goal_get,
+      // Wave 4 (PR #46): /cost — delegation cost report from opencode.db.
+      pantheon_cost: costCommand.pantheon_cost,
+    },
+    '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.
+      // Wave 1: a user message is activity — the todo enforcer's
+      // user-activity gate skips injection for userActivityQuietMs afterwards.
+      todoEnforcer.noteUserActivity(hookInput.sessionID)
+    },
     'experimental.chat.messages.transform': vision.messagesTransform,
-    event: vision.event,
+    event: async ({ event: ev }) => {
+      // Phase 3: sessions created without a parent are roots for the depth guard.
+      if (ev.type === 'session.created') {
+        const info = ev.properties.info
+        if (info && info.parentID === undefined) rootSessions.add(info.id)
+      }
+      // release-134 Phase 3: activate the todo snapshot captured at
+      // compacting time — the first todowrite within the restore window is
+      // 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
+      // chat delivery — see the onTerminal listener above). Unknown sessions
+      // are a no-op.
+      try {
+        const delegated = await handleDelegationEvent(ev, {
+          board,
+          finalize: (childSessionID, opts) => delegation.finalizeDelegation(childSessionID, opts),
+        })
+        // Wave 1/3: non-board idle → idle dispatcher. Board children are
+        // handled by handleDelegationEvent above; everything else (roots,
+        // non-board sessions) is routed by priority: an active goal owns the
+        // idle (goal loop), otherwise the todo enforcer re-injects. Neither
+        // onIdle ever throws (internal failures are logged + swallowed), so
+        // the session is safe.
+        if (!delegated && ev.type === 'session.idle') {
+          await idleDispatcher.onIdle(ev.properties.sessionID)
+        }
+      } catch (err) {
+        // The event hook must never break the session.
+        log.error('[Pantheon Plugin] Delegation event handling failed:', err)
+      }
+      await vision.event({ event: ev })
+    },
+    // Phase 4: deny mutating tools in read-only delegated sessions. Additive
+    // key — does not touch Phase 3's tools/event/onTerminal/chat.message.
+    'tool.execute.before': async (input, output) => {
+      // Chain: the read-only enforcement guard runs first (denies mutating
+      // tools in read-only sessions), then release-134 Phase 3 rewrites the
+      // first post-compaction `todowrite` with the captured todo snapshot.
+      // Both are no-ops for non-matching sessions/tools; the preserver is
+      // fail-open (only its intentional restore denial throws).
+      await enforcementGuard(input)
+      await todoPreserver.beforeTodoWrite(input, output)
+    },
+    // Wave 2 (PR #46): augment `read` output with hashline tags. Additive —
+    // pantheon-hooks.ts (a separate plugin instance) owns its own
+    // tool.execute.after, so there is no key collision. Non-read tools pass
+    // through untouched.
+    'tool.execute.after': readEnhancer,
+    // Phase 4 + release-134 Phase 2: keep the session's working state across
+    // compaction — preservation directive, active goals (<mission_context>),
+    // pending todos (<todo_context>), and in-flight background delegations
+    // (running + unread terminal ≤ max_compaction_items). Guarded: only
+    // pushes when there is something to preserve; a build failure must never
+    // break the experimental compaction hook.
+    'experimental.session.compacting': async (_input, output) => {
+      try {
+        const blocks = await buildCompactionContext(board, {
+          sessionID: _input.sessionID,
+          maxItems: COMPACTION_MAX_ITEMS,
+          goals: {
+            enabled: GOAL_LOOP_DEFAULTS.enabled,
+            list: (sessionID: string) => goalStore.list(sessionID),
+          },
+          todos: {
+            enabled: todoEnforcerEnabledFromEnv(),
+            list: (sessionID: string) => todoEnforcer.listPendingTodos(sessionID),
+          },
+        })
+        if (blocks.length > 0) {
+          output.context.push(...blocks)
+        }
+        // release-134 Phase 3 (additive): snapshot the session's full todo
+        // list for post-compaction restore. Best-effort — a GET failure is
+        // logged and the compaction proceeds normally.
+        await todoPreserver.capture(_input.sessionID)
+      } catch (err: unknown) {
+        log.warn('[Pantheon Plugin] Compaction context build failed:', err)
+      }
+    },
   }
 }
 

package/src/plugins/pantheon-hooks.ts

@@ -186,7 +186,14 @@ 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 { type HookPayload, type HookResult, runHook } from './hook-runner.ts'
+import { pantheonPluginOnce } from '../pantheon/plugin-once.ts'
 
 /** Tools that represent a subagent delegation (opencode `task` tool etc.). */
 const DELEGATION_TOOL_RE = /^(task|.*delegate.*|.*subagent.*)$/i
@@ -424,6 +431,15 @@ const TASK_ID_TEXT_RE = /\btask\s+id="(ses_[^"]+)"/i
  * 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
@@ -432,20 +448,6 @@ const TASK_ID_TEXT_RE = /\btask\s+id="(ses_[^"]+)"/i
  * session.idle flushes the buffer into ONE fresh aggregated entry (see
  * flushIdleReminders) so completions survive until the next user message.
  */
-const CHAT_REMINDER_MAX = 10
-const CHAT_REMINDER_TTL_MS = 60_000
-const pendingChatReminders: { text: string; at: number }[] = []
-
-/** Queue one chat-reminder line, pruning expired entries first. Never throws. */
-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 })
-}
 
 /** Variants accepted by the opencode TUI showToast (TuiShowToastData.body.variant). */
 type ToastVariant = 'info' | 'success' | 'warning' | 'error'
@@ -1124,10 +1126,13 @@ function flushIdleReminders(ctx: HookContext): void {
 
   // 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] ${lines.join(' | ')}`,
-    { script: 'idle-flush', count: fresh.length },
+    `[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 },
     'info',
   )
 }
@@ -1203,6 +1208,17 @@ async function safeRun(
 }
 
 const plugin: Plugin = async ({ client, directory }) => {
+  // 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
+  // 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
+  // TWICE. The second invocation becomes a no-op (empty hooks object) so
+  // hooks register exactly once.
+  if (pantheonPluginOnce('pantheon:hooks')) {
+    return {}
+  }
   const ctx: HookContext = { client, directory }
   return {
     'tool.execute.before': async (input, output) => {
@@ -1427,35 +1443,41 @@ const plugin: Plugin = async ({ client, directory }) => {
     // 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. chat.message fires only
-    // for user-initiated messages (subagent prompts use a different path), so
-    // this surfaces in the main session exactly when the user is watching.
-    // session.idle flushes the buffer into ONE fresh aggregated entry first
-    // (flushIdleReminders). Same PANTHEON_TOASTS gate as toasts: the buffer
-    // only receives gated signals, and the empty-set check below is a
-    // defensive backstop.
+    // 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
-        const now = Date.now()
-        const fresh = pendingChatReminders.filter((r) => now - r.at <= CHAT_REMINDER_TTL_MS)
-        pendingChatReminders.length = 0
-        if (fresh.length === 0) return
-        const body = fresh.map((r) => r.text).join('\n')
+        // 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 ?? '',
+          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', count: fresh.length },
+          { script: 'chat-reminder' },
           'info',
         )
       } catch {

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

@@ -0,0 +1,17 @@
+//#region src/server.d.ts
+/**
+ * No-op server stub for the opencode plugin loader.
+ *
+ * The opencode plugin host requires every plugin (TUI included) to expose a
+ * `server()` entry via `exports["./server"]` (or package.json `main`). When
+ * that entry is missing the host fails to attach the plugin's server half and
+ * the TUI runtime never wires the reactive channel — the initial JSX mounts
+ * but effects/refresh/events stay dead (the "mudo panel" symptom).
+ *
+ * This stub satisfies the loader contract; pantheon-tui is TUI-only and has
+ * no background server work of its own.
+ */
+declare function server(): {};
+//#endregion
+export { server as default };
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"mappings":";;;;;;;;;;;;;iBAYwB"}

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

@@ -0,0 +1,20 @@
+//#region src/server.ts
+/**
+* No-op server stub for the opencode plugin loader.
+*
+* The opencode plugin host requires every plugin (TUI included) to expose a
+* `server()` entry via `exports["./server"]` (or package.json `main`). When
+* that entry is missing the host fails to attach the plugin's server half and
+* the TUI runtime never wires the reactive channel — the initial JSX mounts
+* but effects/refresh/events stay dead (the "mudo panel" symptom).
+*
+* This stub satisfies the loader contract; pantheon-tui is TUI-only and has
+* no background server work of its own.
+*/
+function server() {
+	return {};
+}
+//#endregion
+export { server as default };
+
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":[],"sources":["../src/server.ts"],"sourcesContent":["/**\n * No-op server stub for the opencode plugin loader.\n *\n * The opencode plugin host requires every plugin (TUI included) to expose a\n * `server()` entry via `exports[\"./server\"]` (or package.json `main`). When\n * that entry is missing the host fails to attach the plugin's server half and\n * the TUI runtime never wires the reactive channel — the initial JSX mounts\n * but effects/refresh/events stay dead (the \"mudo panel\" symptom).\n *\n * This stub satisfies the loader contract; pantheon-tui is TUI-only and has\n * no background server work of its own.\n */\nexport default function server() {\n  return {}\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAwB,SAAS;CAC/B,OAAO,CAAC;AACV"}