pantheon-opencode 1.3.3 → 1.3.4

package/src/agents/zeus.md

@@ -153,8 +153,12 @@ pantheon_delegate({prompt, agent, description?, read_only?})
   -> cria sessao filha, registra no board, retorna alias: [apo-1]
 pantheon_delegation_read({id: "apo-1"})
   -> BLOQUEIA ate o job terminar, retorna o report markdown, marca reconciled
+  -> durante a espera, mostra o que o agente esta fazendo: seccao final "## Agent Activity"
+     (amostra as messages do child a cada ~2s; tool calls + args truncados / texto)
 pantheon_delegation_list()
   -> lista jobs da sessao, com [unread] para jobs terminados nao lidos
+  -> jobs RUNNING mostram "last activity:" (ultima acao visivel do child)
+  -> fail-open: sem suporte a messages, formato atual inalterado
 ```
 
 - **Read-only enforcement:** agentes read-only (apollo, gaia — `read_only_agents` no routing.yml) tem `edit`, `write`, `bash`, `task` NEGADOS dentro da sessao delegada (o guard de `tool.execute.before` THROW com mensagem acionavel). Use `read_only: true` no delegate para qualquer agente de investigacao.
@@ -164,7 +168,7 @@ pantheon_delegation_list()
 ### DELEGATION_RULES (plugin path)
 
 1. **NUNCA** polle `pantheon_delegation_list` para checar se um job terminou.
-2. Voce SERA notificado via `task-notification` injetado no chat quando um job atinge estado terminal.
+2. Voce NAO recebe notificacao injetada no chat — politica do usuario: ZERO `task-notification` no transcript. Visibilidade de conclusao: marcador `[unread]` em `pantheon_delegation_list`, `pantheon_delegation_read({id})`, toasts TUI (pantheon-hooks) e carry-forward de compactacao.
 3. Use `pantheon_delegation_read({id})` APENAS para fan-in explicito / recuperacao de resultado sob demanda (bloqueia ate o fim).
 4. `pantheon_delegation_list` e para diagnostico, nao para polling.
 
@@ -282,7 +286,7 @@ Wave: dispare N, colete com tolerancia a falha
 ```
 
 ### Plugin Enforcer (auto — session.idle hook)
-O plugin re-injeta "Incomplete tasks remain..." em sessões root/não-board que
+O plugin re-injeta "Continue: pending todos remain — review and proceed." em sessões root/não-board que
 vão a idle com todos incompletos. Guards (todos no `src/pantheon/todo-enforcer.ts`):
 - **User-activity (30s)** — após uma mensagem do usuário (`chat.message` hook),
   a injeção é suprimida por `user_activity_quiet_ms: 30000`.

package/src/pantheon/background-job-board.ts

@@ -11,17 +11,19 @@
  */
 
 import { mkdir, rename, writeFile } from 'node:fs/promises'
-import { join, dirname } from 'node:path'
+import { dirname, join } from 'node:path'
+
+import { createPantheonLogger } from './logger.ts'
+
+// Silence-by-default TUI policy (pantheon-hooks L42-58): console output in a
+// plugin renders into the opencode TUI — the "lixo". Board internals log to
+// .pantheon/logs/hooks.log; console echo is opt-in via PANTHEON_HOOKS_LOG=1.
+const log = createPantheonLogger({ module: 'BackgroundJobBoard' })
 
 // ─── Types ─────────────────────────────────────────────────────────────
 
 /** Valid states for a background job. */
-export type BackgroundJobState =
-  | 'running'
-  | 'completed'
-  | 'error'
-  | 'cancelled'
-  | 'reconciled'
+export type BackgroundJobState = 'running' | 'completed' | 'error' | 'cancelled' | 'reconciled'
 
 /** Terminal states that can transition to reconciled. */
 const TERMINAL_STATES: ReadonlySet<BackgroundJobState> = new Set([
@@ -35,10 +37,7 @@ const TERMINAL_STATES: ReadonlySet<BackgroundJobState> = new Set([
  * Each entry defines which target states are reachable from the current state.
  * Only running → terminal, or same-terminal → same-terminal (idempotent re-notify).
  */
-const UPDATE_TRANSITIONS: Record<
-  BackgroundJobState,
-  ReadonlySet<BackgroundJobState>
-> = {
+const UPDATE_TRANSITIONS: Record<BackgroundJobState, ReadonlySet<BackgroundJobState>> = {
   running: new Set(['completed', 'error', 'cancelled']),
   completed: new Set(['completed']),
   error: new Set(['error']),
@@ -371,6 +370,13 @@ export class BackgroundJobBoard {
    * Valid: only `completed`, `error`, or `cancelled` → `reconciled`.
    * Idempotent: already-reconciled jobs are returned as-is.
    * Rejected: `running` → `reconciled`.
+   *
+   * Reconcile is an ACKNOWLEDGMENT, not a completion event: it does NOT fire
+   * the terminal listeners (onTerminal) and does NOT resolve waiters — the
+   * terminal transition already did both. Firing them here produced a second
+   * `<task-notification>` per job (completed + reconciled) in the parent
+   * transcript; waiters are covered by `waitForTerminal` resolving immediately
+   * for already-terminal/reconciled jobs.
    */
   async markReconciled(taskID: string): Promise<BackgroundJobRecord | undefined> {
     const job = this.jobs.get(taskID)
@@ -386,7 +392,6 @@ export class BackgroundJobBoard {
       )
     }
 
-    const wasTerminalUnreconciled = job.terminalUnreconciled
     job.state = 'reconciled'
     job.updatedAt = Date.now()
     job.terminalUnreconciled = false
@@ -394,10 +399,6 @@ export class BackgroundJobBoard {
     await this.persistRecord(job)
     await this.writeSignal(job)
 
-    if (wasTerminalUnreconciled) {
-      this.notifyTerminal(job.taskID)
-    }
-
     return job
   }
 
@@ -415,17 +416,14 @@ export class BackgroundJobBoard {
   list(parentSessionID?: string): BackgroundJobRecord[] {
     const all = Array.from(this.jobs.values())
     if (!parentSessionID) return [...all]
-    return all.filter(j => j.parentSessionID === parentSessionID)
+    return all.filter((j) => j.parentSessionID === parentSessionID)
   }
 
   /**
    * Resolve a job by either taskID or alias within a parent session.
    * Checks exact taskID first, then falls back to alias matching.
    */
-  resolve(
-    parentSessionID: string,
-    taskIDOrAlias: string,
-  ): BackgroundJobRecord | undefined {
+  resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined {
     // Exact taskID match (session-scoped)
     const byID = this.jobs.get(taskIDOrAlias)
     if (byID?.parentSessionID === parentSessionID) return byID
@@ -538,7 +536,7 @@ export class BackgroundJobBoard {
     const jobs = this.list(parentSessionID)
     if (jobs.length === 0) return undefined
 
-    const lines = jobs.map(j => {
+    const lines = jobs.map((j) => {
       const status =
         j.state === 'completed'
           ? 'OK'
@@ -595,10 +593,7 @@ export class BackgroundJobBoard {
     try {
       await this.persistence.saveJob(record)
     } catch (err) {
-      console.error(
-        `[BackgroundJobBoard] Failed to persist job ${record.taskID}:`,
-        err,
-      )
+      log.error(`[BackgroundJobBoard] Failed to persist job ${record.taskID}:`, err)
     }
   }
 
@@ -607,10 +602,7 @@ export class BackgroundJobBoard {
     try {
       await this.persistence.deleteJob(taskID)
     } catch (err) {
-      console.error(
-        `[BackgroundJobBoard] Failed to delete persisted job ${taskID}:`,
-        err,
-      )
+      log.error(`[BackgroundJobBoard] Failed to delete persisted job ${taskID}:`, err)
     }
   }
 
@@ -619,10 +611,7 @@ export class BackgroundJobBoard {
       try {
         listener(taskID)
       } catch (err) {
-        console.error(
-          `[BackgroundJobBoard] Terminal listener error for ${taskID}:`,
-          err,
-        )
+        log.error(`[BackgroundJobBoard] Terminal listener error for ${taskID}:`, err)
       }
     }
     this.resolveTerminalWaiters(taskID)
@@ -648,10 +637,7 @@ export class BackgroundJobBoard {
       await writeFile(tmpPath, content, 'utf-8')
       await rename(tmpPath, signalPath)
     } catch (err) {
-      console.error(
-        `[BackgroundJobBoard] Failed to write signal for ${record.alias}:`,
-        err,
-      )
+      log.error(`[BackgroundJobBoard] Failed to write signal for ${record.alias}:`, err)
     }
   }
 }

package/src/pantheon/chat-reminders.ts

@@ -0,0 +1,79 @@
+/**
+ * Chat Reminders (release-134 Phase 4) — the SHARED <system-reminder> buffer.
+ *
+ * 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).
+ *
+ * @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

@@ -0,0 +1,160 @@
+/**
+ * Compaction Re-Assert (release-134 Phase 4) — re-inject fresh state after
+ * compaction.
+ *
+ * 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.
+ *
+ * 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 —
+ * 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
+ * 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.
+ *
+ * @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'
+
+// Silence-by-default TUI policy (pantheon-hooks L42-58): console echo is
+// opt-in via PANTHEON_HOOKS_LOG=1. `deps.logger` injection stays for tests.
+const log = createPantheonLogger({ module: 'pantheon-compaction' })
+
+// ─── Constants ─────────────────────────────────────────────────────────
+
+/** Max fresh-state item lines (running + unread + goals) in the block. */
+export const REASSERT_MAX_LINES = 10
+
+/** Header line — tells the model the summary may be stale. */
+export const REASSERT_HEADER = 'State re-assertion after compaction — the summary may be stale:'
+
+// ─── Types ─────────────────────────────────────────────────────────────
+
+/** Dependencies threaded to reassertAfterCompaction (wired from plugin.ts). */
+export interface CompactionAssertDeps {
+  /** The compacted session whose next message receives the reminder. */
+  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 }
+}
+
+// ─── Formatting ────────────────────────────────────────────────────────
+
+/** One-line terminal status label, mirroring formatForPrompt. */
+function terminalLabel(state: string): string {
+  switch (state) {
+    case 'completed':
+      return 'OK'
+    case 'error':
+      return 'ERR'
+    case 'cancelled':
+      return 'CAN'
+    default:
+      return state.toUpperCase()
+  }
+}
+
+/** Collapse whitespace and truncate a description/objective. */
+function truncate(text: string, max = 80): string {
+  const flat = text.trim().replace(/\s+/g, ' ')
+  return flat.length <= max ? flat : `${flat.slice(0, max)}…`
+}
+
+// ─── Build ─────────────────────────────────────────────────────────────
+
+/**
+ * Build the compact fresh-state lines: running delegations first (active work
+ * is the freshest signal), then unread terminal delegations, then active
+ * goals (only while the line budget allows). Returns undefined when there is
+ * nothing to assert (silent skip) or a source failed (warn + skip).
+ */
+async function buildStateLines(
+  deps: CompactionAssertDeps,
+  warn: (message: string) => void,
+): Promise<string[] | undefined> {
+  const lines: string[] = []
+  try {
+    const jobs = deps.board.list(deps.sessionID)
+    const running = jobs
+      .filter((j) => j.state === 'running')
+      .sort((a, b) => a.launchedAt - b.launchedAt)
+    const unread = jobs
+      .filter((j) => j.terminalUnreconciled)
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+
+    for (const job of running) {
+      if (lines.length >= REASSERT_MAX_LINES) break
+      lines.push(`  running [${job.alias}] ${job.agent} — ${truncate(job.description)}`)
+    }
+    for (const job of unread) {
+      if (lines.length >= REASSERT_MAX_LINES) break
+      lines.push(
+        `  unread [${job.alias}] ${job.agent} — ${truncate(job.description)} — ${terminalLabel(job.state)}`,
+      )
+    }
+
+    const source = deps.goals
+    if (lines.length < REASSERT_MAX_LINES && source !== undefined && source.enabled) {
+      const goals = await source.list(deps.sessionID)
+      for (const goal of goals.filter((g) => g.status !== 'done')) {
+        if (lines.length >= REASSERT_MAX_LINES) break
+        lines.push(`  goal [${goal.id}] ${truncate(goal.objective)} — ${goal.status}`)
+      }
+    }
+  } catch (err: unknown) {
+    const reason = err instanceof Error ? err.message : String(err)
+    warn(`compaction re-assert failed for session ${deps.sessionID}: ${reason}`)
+    return undefined
+  }
+  return lines.length === 0 ? undefined : lines
+}
+
+/**
+ * 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).
+ *
+ * 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.
+ */
+export async function reassertAfterCompaction(deps: CompactionAssertDeps): Promise<boolean> {
+  // 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
+  } catch (err: unknown) {
+    const reason = err instanceof Error ? err.message : String(err)
+    warn(`compaction re-assert failed for session ${deps.sessionID}: ${reason}`)
+    return false
+  }
+}

package/src/pantheon/delegation-compaction.ts

@@ -1,11 +1,24 @@
 /**
- * Delegation Compaction Context (Phase 4) — build the context blocks injected
- * by the `experimental.session.compacting` hook so a compacted session does
- * not lose track of its in-flight background delegations.
+ * Compaction Context (Phase 4 + release-134 Phase 2) — build the context
+ * blocks injected by the `experimental.session.compacting` hook so a
+ * compacted session does not lose its working state: in-flight background
+ * delegations, active goals and pending todos.
  *
- * Returns a string[] (empty when there is nothing to preserve):
- *   - "Background Delegations (running):" — every running job launched by the
- *     session (active work is never capped): alias, agent, started ISO,
+ * Returns a Promise<string[]> (empty when there is nothing to preserve).
+ * Section order is stable:
+ *   - "<pantheon-context directive>" — preservation directive (prefix,
+ *     PANTHEON_COMPACTION_DIRECTIVE). Emitted whenever at least one other
+ *     section follows; a totally-empty state returns [] (an orphan
+ *     directive is noise).
+ *   - "<mission_context>" — active (non-done) goals from `opts.goals`:
+ *     "  [id] objective — status". Omitted when the goal source is absent,
+ *     disabled, unscoped (no sessionID), fails, or has no active goals.
+ *   - "<todo_context>" — pending (not completed/cancelled) todos from
+ *     `opts.todos`: "  [id] description — status". Omitted when the todo
+ *     source is absent, disabled, unscoped (no sessionID), fails, or has
+ *     no pending todos.
+ *   - "Background Delegations (running):" — every running job launched by
+ *     the session (active work is never capped): alias, agent, started ISO,
  *     truncated prompt.
  *   - "Background Delegations (finished, unread):" — terminal-unreconciled
  *     jobs, newest first, capped at `maxItems` (default 10, matching
@@ -21,14 +34,52 @@
  */
 
 import type { BackgroundJobBoard, BackgroundJobRecord } from './background-job-board.ts'
+import type { Goal } from './goal-store.ts'
+import { createPantheonLogger } from './logger.ts'
+import type { TodoLike } from './todo-enforcer.ts'
+
+// Silence-by-default TUI policy (pantheon-hooks L42-58): the default warn
+// fallback logs to .pantheon/logs/hooks.log; console echo is opt-in via
+// PANTHEON_HOOKS_LOG=1. `deps.logger` injection stays for tests.
+const log = createPantheonLogger({ module: 'pantheon-compaction' })
+
+// ─── Constants ─────────────────────────────────────────────────────────
+
+/**
+ * Preservation directive (release-134 Phase 2): the native compaction
+ * prompt keeps every pushed section, so this prefix asks the model to keep
+ * the pantheon sections verbatim — not paraphrased, merged, or dropped.
+ */
+export const PANTHEON_COMPACTION_DIRECTIVE =
+  'preserve these sections verbatim in the summarized context'
 
 // ─── Types ─────────────────────────────────────────────────────────────
 
+/** Source for the <mission_context> section (active goals). */
+export interface CompactionGoalSource {
+  /** True when the goal loop is enabled; false/undefined → section omitted. */
+  enabled: boolean
+  /** List the session's goals (any status; the builder keeps non-done). */
+  list(sessionID: string): Promise<Goal[]>
+}
+
+/** Source for the <todo_context> section (pending todos). */
+export interface CompactionTodoSource {
+  /** True when the todo enforcer is enabled; false/undefined → section omitted. */
+  enabled: boolean
+  /** List the session's todos (any status; the builder keeps pending). */
+  list(sessionID: string): Promise<TodoLike[]>
+}
+
 export interface CompactionContextOptions {
   /** Scope to jobs launched by this session; omit for all jobs. */
   sessionID?: string
   /** Cap on unread terminal jobs kept (default 10). */
   maxItems?: number
+  /** Goal source for <mission_context> (optional — omitted when absent). */
+  goals?: CompactionGoalSource
+  /** Todo source for <todo_context> (optional — omitted when absent). */
+  todos?: CompactionTodoSource
 }
 
 /** Prompt truncation length for a context line. */
@@ -71,17 +122,69 @@ function unreadTerminalLine(job: BackgroundJobRecord): string {
   )
 }
 
-// ─── Build ─────────────────────────────────────────────────────────────
+// ─── Sections ──────────────────────────────────────────────────────────
 
 /**
- * Build the compaction context blocks for a session's background delegations.
- * Returns an empty array when there is nothing to preserve (caller skips the
- * hook injection entirely).
+ * `<mission_context>` — active (non-done) goals for the session.
+ * Returns undefined when the section must be omitted: no goal source, the
+ * goal loop is disabled, no sessionID (per-session data cannot be scoped),
+ * the source throws (logged, fail-open), or no active goals remain.
  */
-export function buildCompactionContext(
-  board: BackgroundJobBoard,
-  opts: CompactionContextOptions = {},
-): string[] {
+async function missionContextBlock(opts: CompactionContextOptions): Promise<string | undefined> {
+  const source = opts.goals
+  if (opts.sessionID === undefined || source === undefined || !source.enabled) return undefined
+
+  let goals: Goal[]
+  try {
+    goals = await source.list(opts.sessionID)
+  } catch (err: unknown) {
+    const reason = err instanceof Error ? err.message : String(err)
+    log.warn(`compaction goal context failed for session ${opts.sessionID}: ${reason}`)
+    return undefined
+  }
+
+  const active = goals.filter((goal) => goal.status !== 'done')
+  if (active.length === 0) return undefined
+
+  const lines = active.map((goal) => `  [${goal.id}] ${goal.objective} — ${goal.status}`)
+  return `<mission_context>\n${lines.join('\n')}`
+}
+
+/**
+ * `<todo_context>` — pending (not completed/cancelled) todos for the
+ * session. Returns undefined when the section must be omitted: no todo
+ * source, the enforcer is disabled, no sessionID, the source throws
+ * (logged, fail-open), or no pending todos remain.
+ */
+async function todoContextBlock(opts: CompactionContextOptions): Promise<string | undefined> {
+  const source = opts.todos
+  if (opts.sessionID === undefined || source === undefined || !source.enabled) return undefined
+
+  let todos: TodoLike[]
+  try {
+    todos = await source.list(opts.sessionID)
+  } catch (err: unknown) {
+    const reason = err instanceof Error ? err.message : String(err)
+    log.warn(`compaction todo context failed for session ${opts.sessionID}: ${reason}`)
+    return undefined
+  }
+
+  const pending = todos.filter((todo) => todo.status !== 'completed' && todo.status !== 'cancelled')
+  if (pending.length === 0) return undefined
+
+  const lines = pending.map((todo) => {
+    const label = todo.content?.trim() || todo.id || '(no description)'
+    const id = todo.id !== undefined && todo.id !== '' ? `[${todo.id}] ` : ''
+    return `  ${id}${label} — ${todo.status}`
+  })
+  return `<todo_context>\n${lines.join('\n')}`
+}
+
+/**
+ * `<delegation_context>` — the existing delegation blocks, byte-for-byte
+ * unchanged from Phase 4 (running, then unread terminal ≤ maxItems).
+ */
+function delegationBlocks(board: BackgroundJobBoard, opts: CompactionContextOptions): string[] {
   const maxItems = opts.maxItems ?? 10
   const jobs = opts.sessionID !== undefined ? board.list(opts.sessionID) : board.list()
 
@@ -93,8 +196,6 @@ export function buildCompactionContext(
     .sort((a, b) => b.updatedAt - a.updatedAt)
     .slice(0, maxItems)
 
-  if (running.length === 0 && unreadTerminal.length === 0) return []
-
   const blocks: string[] = []
   if (running.length > 0) {
     blocks.push(`Background Delegations (running):\n${running.map(runningLine).join('\n')}`)
@@ -108,3 +209,29 @@ export function buildCompactionContext(
   }
   return blocks
 }
+
+// ─── Build ─────────────────────────────────────────────────────────────
+
+/**
+ * Build the compaction context blocks for a session: preservation
+ * directive, active goals, pending todos, and in-flight background
+ * delegations. Returns an empty array when there is nothing to preserve
+ * (caller skips the hook injection entirely).
+ */
+export async function buildCompactionContext(
+  board: BackgroundJobBoard,
+  opts: CompactionContextOptions = {},
+): Promise<string[]> {
+  const [mission, todo] = await Promise.all([missionContextBlock(opts), todoContextBlock(opts)])
+  const delegation = delegationBlocks(board, opts)
+
+  // Totally-empty state → nothing to preserve; a lone directive is noise.
+  if (mission === undefined && todo === undefined && delegation.length === 0) return []
+
+  const blocks: string[] = []
+  blocks.push(`<pantheon-context directive>\n${PANTHEON_COMPACTION_DIRECTIVE}`)
+  if (mission !== undefined) blocks.push(mission)
+  if (todo !== undefined) blocks.push(todo)
+  blocks.push(...delegation)
+  return blocks
+}

package/src/pantheon/delegation-finalize.ts

@@ -26,7 +26,14 @@ import type { BackgroundJobBoard, BackgroundJobRecord } from './background-job-b
 /** A minimal structural view of one message bundle from session.messages(). */
 export interface DelegationMessageBundle {
   info?: { role?: string; finish?: string; error?: unknown }
-  parts?: Array<{ type?: string; text?: string }>
+  parts?: Array<{
+    type?: string
+    text?: string
+    /** Tool name on `tool` parts — used by the activity sampler. */
+    tool?: string
+    /** Tool input on `tool` parts (opencode SDK ToolPart.metadata). */
+    metadata?: { input?: unknown }
+  }>
 }
 
 /** Minimal structural view of the opencode SDK session client we use. */