pantheon-opencode 1.4.0 → 1.4.2

package/scripts/install/opencode.mjs

@@ -43,6 +43,7 @@ import {
   syncDir,
   writeIfChanged,
 } from './shared.mjs'
+
 import { setupVenv, venvPythonPath } from './venv.mjs'
 
 const COMPONENT_NAMES = [
@@ -59,6 +60,16 @@ function deepClone(value) {
   return JSON.parse(JSON.stringify(value))
 }
 
+function readJsonConfig(filePath) {
+  if (!existsSync(filePath)) return {}
+
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'))
+  } catch (cause) {
+    throw new Error(`Invalid JSON in ${filePath}`, { cause })
+  }
+}
+
 function mergeMissing(target, source) {
   if (!source || typeof source !== 'object' || Array.isArray(source)) return target
   if (!target || typeof target !== 'object' || Array.isArray(target)) return deepClone(source)
@@ -274,6 +285,11 @@ export async function installOpenCode(
     }
   }
 
+  const pantheonConfigPath = join(ROOT, 'opencode.json')
+  const targetConfigPath = join(target, 'opencode.json')
+  const config = readJsonConfig(targetConfigPath)
+  const pantheonConfig = readJsonConfig(pantheonConfigPath)
+
   // Determine layout based on install scope.
   // Global config dir (~/.opencode or ~/.config/opencode) uses a flat layout:
   //   agents/   skills/   commands/   plugins/
@@ -533,27 +549,6 @@ export async function installOpenCode(
   //    Reads TARGET's existing config first, then merges Pantheon settings
   //    on top. Preserves user's MCP, provider, plugin, compaction, theme.
   // -----------------------------------------------------------------------
-  const pantheonConfigPath = join(ROOT, 'opencode.json')
-  const targetConfigPath = join(target, 'opencode.json')
-
-  let config = {}
-  if (existsSync(targetConfigPath)) {
-    try {
-      config = JSON.parse(readFileSync(targetConfigPath, 'utf8'))
-    } catch {
-      config = {}
-    }
-  }
-
-  let pantheonConfig = {}
-  if (existsSync(pantheonConfigPath)) {
-    try {
-      pantheonConfig = JSON.parse(readFileSync(pantheonConfigPath, 'utf8'))
-    } catch {
-      pantheonConfig = {}
-    }
-  }
-
   // --------------------------------------------------------------------
   // A. Parse canonical agent config from agents/*.agent.md frontmatter
   //    and merge into opencode.json config.
@@ -622,61 +617,64 @@ export async function installOpenCode(
     'disable_model_invocation',
   ]
 
-  if (!config.agent) config.agent = {}
-
-  for (const [agentName, agentCfg] of Object.entries(canonicalAgentConfig)) {
-    if (!agentCfg || typeof agentCfg !== 'object') continue
+  if (config.agent === undefined) config.agent = {}
+
+  if (config.agent && typeof config.agent === 'object' && !Array.isArray(config.agent)) {
+    for (const [agentName, agentCfg] of Object.entries(canonicalAgentConfig)) {
+      if (!agentCfg || typeof agentCfg !== 'object') continue
+
+      if (Object.hasOwn(config.agent, agentName)) {
+        // ── Agent exists in target config ──
+        // Update framework-managed fields from canonical source
+        // Preserve user-customized fields (model, provider, mcp, etc.)
+        const existing = config.agent[agentName]
+        if (!existing || typeof existing !== 'object' || Array.isArray(existing)) continue
+        if (agentSources[agentName]) existing.source = agentSources[agentName]
+        for (const field of MANAGED_FIELDS) {
+          if (field in agentCfg) {
+            existing[field] = JSON.parse(JSON.stringify(agentCfg[field]))
+          }
+        }
+        // Remove stale fields that are no longer in canonical config
+        delete existing.model
+        delete existing.small_model
+      } else {
+        // ── New agent ──
+        const newAgent = {}
+        if (agentSources[agentName]) newAgent.source = agentSources[agentName]
+        if (agentCfg.description) newAgent.description = agentCfg.description
+
+        // Copy all framework-managed fields from canonical config
+        for (const field of MANAGED_FIELDS) {
+          if (field in agentCfg) {
+            newAgent[field] = JSON.parse(JSON.stringify(agentCfg[field]))
+          }
+        }
 
-    if (config.agent[agentName]) {
-      // ── Agent exists in target config ──
-      // Update framework-managed fields from canonical source
-      // Preserve user-customized fields (model, provider, mcp, etc.)
-      const existing = config.agent[agentName]
-      if (agentSources[agentName]) existing.source = agentSources[agentName]
-      for (const field of MANAGED_FIELDS) {
-        if (field in agentCfg) {
-          existing[field] = JSON.parse(JSON.stringify(agentCfg[field]))
+        // Ensure bash permission is set from canonical (default to deny if missing)
+        if (newAgent.permission === undefined) {
+          newAgent.permission = {}
         }
-      }
-      // Remove stale fields that are no longer in canonical config
-      delete existing.model
-      delete existing.small_model
-    } else {
-      // ── New agent ──
-      const newAgent = {}
-      if (agentSources[agentName]) newAgent.source = agentSources[agentName]
-      if (agentCfg.description) newAgent.description = agentCfg.description
-
-      // Copy all framework-managed fields from canonical config
-      for (const field of MANAGED_FIELDS) {
-        if (field in agentCfg) {
-          newAgent[field] = JSON.parse(JSON.stringify(agentCfg[field]))
+        if (newAgent.permission.bash === undefined && agentCfg.permission?.bash) {
+          newAgent.permission.bash = JSON.parse(JSON.stringify(agentCfg.permission.bash))
         }
-      }
 
-      // Ensure bash permission is set from canonical (default to deny if missing)
-      if (!newAgent.permission) {
-        newAgent.permission = {}
-      }
-      if (!newAgent.permission.bash && agentCfg.permission?.bash) {
-        newAgent.permission.bash = JSON.parse(JSON.stringify(agentCfg.permission.bash))
+        config.agent[agentName] = newAgent
       }
-
-      config.agent[agentName] = newAgent
     }
-  }
 
-  // Remove stale agents (exist in target config but not in canonical source)
-  // Only removes agents whose source is managed (starts with our prefix)
-  // so user-defined agents with different source paths are preserved.
-  const canonicalNames = new Set(Object.keys(canonicalAgentConfig))
-  for (const [agentName, agentCfg] of Object.entries(config.agent)) {
-    const source = agentCfg?.source || ''
-    if (source.startsWith(agentPrefix) && !canonicalNames.has(agentName)) {
-      delete config.agent[agentName]
+    // Remove stale agents (exist in target config but not in canonical source)
+    // Only removes agents whose source is managed (starts with our prefix)
+    // so user-defined agents with different source paths are preserved.
+    const canonicalNames = new Set(Object.keys(canonicalAgentConfig))
+    for (const [agentName, agentCfg] of Object.entries(config.agent)) {
+      const source = agentCfg?.source || ''
+      if (source.startsWith(agentPrefix) && !canonicalNames.has(agentName)) {
+        delete config.agent[agentName]
+      }
     }
+    if (Object.keys(config.agent).length === 0) delete config.agent
   }
-  if (Object.keys(config.agent).length === 0) delete config.agent
 
   // --------------------------------------------------------------------
   // B. Commands from .md frontmatter (commands.json removed)
@@ -687,19 +685,16 @@ export async function installOpenCode(
   // --------------------------------------------------------------------
   // B.5 Ensure critical top-level OpenCode config sections
   // --------------------------------------------------------------------
-  if (!config.default_agent && pantheonConfig.default_agent) {
+  if (config.default_agent === undefined && pantheonConfig.default_agent !== undefined) {
     config.default_agent = pantheonConfig.default_agent
   }
-  // Merge top-level model/small_model from the repo config when the target
-  // config has no top-level `model` (fresh sandbox installs have none). The
-  // repo's opencode.json carries the default pair
-  // (opencode-go/deepseek-v4-flash); a user-set model is never overwritten.
-  if (!config.model && pantheonConfig.model) {
-    config.model = pantheonConfig.model
-    if (!config.small_model && pantheonConfig.small_model) {
-      config.small_model = pantheonConfig.small_model
-    }
-  }
+  // Apply only explicit top-level model overrides. Existing values remain
+  // untouched and an install without either flag leaves both fields absent.
+  const modelFlag = typeof opts.model === 'string' && opts.model !== '' ? opts.model : undefined
+  const smallModelFlag =
+    typeof opts.smallModel === 'string' && opts.smallModel !== '' ? opts.smallModel : undefined
+  if (modelFlag !== undefined) config.model = modelFlag
+  if (smallModelFlag !== undefined) config.small_model = smallModelFlag
   // Merge subagent_depth HERE (the config merge always runs, including on a
   // fresh install) instead of a file-existence-gated block, so run #1 already
   // produces the final config — run #2 must be a byte-identical no-op (#19).
@@ -710,16 +705,24 @@ export async function installOpenCode(
   // experimental (preserving the user's choice) and default fresh installs to
   // experimental.subagent_depth = 2. V1 reads experimental.subagent_depth
   // too, so the V1-shape config stays valid under both versions.
-  if (config.experimental === undefined || typeof config.experimental !== 'object') {
+  if (config.experimental === undefined) {
     config.experimental = {}
   }
-  if (config.subagent_depth !== undefined) {
-    if (config.experimental.subagent_depth === undefined) {
-      config.experimental.subagent_depth = config.subagent_depth
+  if (
+    typeof config.experimental === 'object' &&
+    config.experimental !== null &&
+    !Array.isArray(config.experimental)
+  ) {
+    if (config.subagent_depth !== undefined) {
+      if (config.experimental.subagent_depth === undefined) {
+        config.experimental.subagent_depth = config.subagent_depth
+      }
+      delete config.subagent_depth
+    } else if (config.experimental.subagent_depth === undefined) {
+      config.experimental.subagent_depth = 2
     }
+  } else if (config.subagent_depth !== undefined) {
     delete config.subagent_depth
-  } else if (config.experimental.subagent_depth === undefined) {
-    config.experimental.subagent_depth = 2
   }
 
   // --------------------------------------------------------------------
@@ -735,74 +738,82 @@ export async function installOpenCode(
   // The source opencode.json keeps its dev path for local development; the
   // transform happens at install/sync time only.
 
-  if (!Array.isArray(config.plugin)) {
+  if (config.plugin === undefined) {
     config.plugin = []
   }
-  if (Array.isArray(pantheonConfig.plugin)) {
-    for (const plugin of pantheonConfig.plugin) {
-      const resolved = resolveInstalledPlugin(plugin)
+  if (Array.isArray(config.plugin)) {
+    if (Array.isArray(pantheonConfig.plugin)) {
+      for (const plugin of pantheonConfig.plugin) {
+        const resolved = resolveInstalledPlugin(plugin)
+        const file = basename(resolved)
+        // Replace any pre-existing entry for the same plugin file (e.g. a stale
+        // dev-machine path from an earlier install) so upgrades stay hermetic.
+        config.plugin = config.plugin.filter((p) => basename(p) !== file)
+        config.plugin.push(resolved)
+      }
+    }
+
+    // The two Pantheon plugins MUST always be registered, on fresh installs AND
+    // upgrades. The packaged opencode.json carries no `plugin` key (dev-machine
+    // paths removed in 3e552cc), so config.plugin would otherwise only contain
+    // whatever the user had — a fresh install would register NOTHING and lose
+    // delegation tools, GoalLoop, cost command, hashline and vision. Register
+    // both unconditionally, replacing any stale entry for the same file
+    // (basename-dedup) so installs and upgrades are idempotent and hermetic
+    // while preserving any user plugins.
+    const ensurePantheonPlugin = (ref) => {
+      const resolved = resolveInstalledPlugin(ref)
       const file = basename(resolved)
-      // Replace any pre-existing entry for the same plugin file (e.g. a stale
-      // dev-machine path from an earlier install) so upgrades stay hermetic.
       config.plugin = config.plugin.filter((p) => basename(p) !== file)
       config.plugin.push(resolved)
     }
+    // Root-level delegation plugin (PR #45): tools, GoalLoop, cost, hashline.
+    ensurePantheonPlugin('src/plugin.ts')
+    // Runtime hooks plugin: chat hooks, hook-runner, TUI wiring.
+    ensurePantheonPlugin('src/plugins/pantheon-hooks.ts')
   }
 
-  // The two Pantheon plugins MUST always be registered, on fresh installs AND
-  // upgrades. The packaged opencode.json carries no `plugin` key (dev-machine
-  // paths removed in 3e552cc), so config.plugin would otherwise only contain
-  // whatever the user had — a fresh install would register NOTHING and lose
-  // delegation tools, GoalLoop, cost command, hashline and vision. Register
-  // both unconditionally, replacing any stale entry for the same file
-  // (basename-dedup) so installs and upgrades are idempotent and hermetic
-  // while preserving any user plugins.
-  const ensurePantheonPlugin = (ref) => {
-    const resolved = resolveInstalledPlugin(ref)
-    const file = basename(resolved)
-    config.plugin = config.plugin.filter((p) => basename(p) !== file)
-    config.plugin.push(resolved)
-  }
-  // Root-level delegation plugin (PR #45): tools, GoalLoop, cost, hashline.
-  ensurePantheonPlugin('src/plugin.ts')
-  // Runtime hooks plugin: chat hooks, hook-runner, TUI wiring.
-  ensurePantheonPlugin('src/plugins/pantheon-hooks.ts')
-
-  if (!config.provider && pantheonConfig.provider) {
+  if (config.provider === undefined && pantheonConfig.provider !== undefined) {
     config.provider = deepClone(pantheonConfig.provider)
-  } else if (config.provider && pantheonConfig.provider) {
+  } else if (config.provider !== undefined && pantheonConfig.provider !== undefined) {
     mergeMissing(config.provider, pantheonConfig.provider)
   }
 
-  if (!config.compaction && pantheonConfig.compaction) {
+  if (config.compaction === undefined && pantheonConfig.compaction !== undefined) {
     config.compaction = deepClone(pantheonConfig.compaction)
-  } else if (config.compaction && pantheonConfig.compaction) {
+  } else if (config.compaction !== undefined && pantheonConfig.compaction !== undefined) {
     mergeMissing(config.compaction, pantheonConfig.compaction)
   }
 
   // --------------------------------------------------------------------
   // C. Merge permissions
   // --------------------------------------------------------------------
-  if (!config.permission) config.permission = {}
-  if (pantheonConfig.permission) {
+  if (config.permission === undefined) config.permission = {}
+  if (pantheonConfig.permission !== undefined) {
     mergeMissing(config.permission, pantheonConfig.permission)
   }
-  if (componentSet.has('skills')) {
-    config.permission.skill = { '*': 'allow' }
-  }
-  if (!config.permission.bash) {
-    config.permission.bash = {
-      'git *': 'allow',
-      'npm *': 'allow',
-      'npx *': 'allow',
-      'pytest *': 'allow',
-      'ruff *': 'allow',
-      'black *': 'allow',
-      'pip *': 'allow',
-      'docker *': 'allow',
-      'curl *': 'allow',
-      'gh *': 'allow',
-      'make *': 'allow',
+  if (
+    typeof config.permission === 'object' &&
+    config.permission !== null &&
+    !Array.isArray(config.permission)
+  ) {
+    if (componentSet.has('skills')) {
+      config.permission.skill = { '*': 'allow' }
+    }
+    if (config.permission.bash === undefined) {
+      config.permission.bash = {
+        'git *': 'allow',
+        'npm *': 'allow',
+        'npx *': 'allow',
+        'pytest *': 'allow',
+        'ruff *': 'allow',
+        'black *': 'allow',
+        'pip *': 'allow',
+        'docker *': 'allow',
+        'curl *': 'allow',
+        'gh *': 'allow',
+        'make *': 'allow',
+      }
     }
   }
 
@@ -816,9 +827,9 @@ export async function installOpenCode(
   // glob is no longer needed — keeping it would duplicate content under V1
   // and is ignored under V2 anyway. Only ensure AGENTS.md is present.
   const pantheonInstructions = ['AGENTS.md']
-  if (!config.instructions) {
+  if (config.instructions === undefined) {
     config.instructions = [...pantheonInstructions]
-  } else {
+  } else if (Array.isArray(config.instructions)) {
     // Strip stale per-file instruction globs from PREVIOUS installs
     // (e.g. `instructions/*.instructions.md` / `src/instructions/*.md`).
     // The merge is additive-only otherwise, so without this filter existing
@@ -838,7 +849,7 @@ export async function installOpenCode(
   // --------------------------------------------------------------------
   // E. Ensure $schema
   // --------------------------------------------------------------------
-  if (!config.$schema) {
+  if (config.$schema === undefined) {
     config.$schema = 'https://opencode.ai/config.json'
   }
 
@@ -1009,12 +1020,14 @@ export async function installOpenCode(
   }
 
   // -----------------------------------------------------------------------
-  // 5. Model preset selection (--components agents). Interactive picker runs
+  // 5. Model preset selection (--components agents). Interactive wizard runs
   //    unless autoYes (use defaults) or an explicit --preset was given.
+  //    Q1 default "herdar do chat" (inherit) writes no active-preset.json —
+  //    delegates inherit the parent chat model (native inheritance).
   // -----------------------------------------------------------------------
   if (interactive && !dryRun && !autoYes && !opts.preset) {
-    const { runModelPicker } = await import('./model-picker.mjs')
-    await runModelPicker({ presetDir: target, logger: console })
+    const { runInitWizard } = await import('./model-picker.mjs')
+    await runInitWizard({ presetDir: target, logger: console })
   }
 
   if (opts.preset && !dryRun) {

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
   }
 }