pantheon-opencode 1.5.0-beta.2 → 1.5.0-beta.20

package/src/pantheon/shared-board.ts

@@ -0,0 +1,37 @@
+/**
+ * Process-wide BackgroundJobBoard singleton shared by every Pantheon plugin
+ * surface (src/plugin.ts V1, src/plugins/pantheon-hooks.ts).
+ *
+ * WHY globalThis and not a module-level `const`: opencode loads each plugin
+ * TWICE from two different filesystem paths (the installed npm package AND
+ * the repo source — see src/pantheon/plugin-once.ts). Each load is a separate
+ * module instance, so a plain ESM singleton would yield TWO boards: the
+ * native-task mirror in pantheon-hooks would register jobs on one instance
+ * while the finalize path (session.idle + idle scan in plugin.ts) listens on
+ * the other, and the job would never finalize. A globalThis-anchored value is
+ * process-global by construction, deduping both module copies.
+ *
+ * The persistence file and signal dir are RELATIVE paths — the board operates
+ * against the opencode project root (the cwd of the plugin process), matching
+ * the pre-existing plugin.ts wiring exactly.
+ */
+import { BackgroundJobBoard } from './background-job-board.ts'
+import { FilePersistenceAdapter } from './file-persistence.ts'
+
+const BOARD_KEY = '__pantheonSharedBoard'
+
+/** Construction inputs mirror the original plugin.ts module-scope board. */
+const BOARD_OPTIONS = {
+  maxConcurrentPerAgent: 3,
+  signalDir: '.pantheon/deepwork/board-signals',
+} as const
+
+export function getSharedBoard(): BackgroundJobBoard {
+  const host = globalThis as { [BOARD_KEY]?: BackgroundJobBoard }
+  const existing = host[BOARD_KEY]
+  if (existing instanceof BackgroundJobBoard) return existing
+  const board = new BackgroundJobBoard(BOARD_OPTIONS)
+  board.setPersistence(new FilePersistenceAdapter('.pantheon/board/state.json'))
+  host[BOARD_KEY] = board
+  return board
+}

package/src/pantheon/task-result-guard.ts

@@ -0,0 +1,106 @@
+/**
+ * Task Result Guard — detects empty task() results from native opencode
+ * subagent calls and converts them to explicit errors.
+ *
+ * Bug context (reproduced 2026-09-10): task() native creates a child session
+ * that inherits the parent transcript. When the payload exceeds the provider's
+ * admission limit (e.g. free-tier max_outstanding_uncached_prefill_tokens=1000
+ * vs 57k incoming tokens), the stream errors with BackendAdmissionRejected.
+ * The error is NOT propagated — the child loop exits normally, the child
+ * session goes idle with zero assistant/tool output, and opencode marks the
+ * task as `completed` with empty content. The parent LLM receives an empty
+ * result and proceeds as if the task succeeded.
+ *
+ * The guard intercepts this in the `tool.execute.after` hook: when the tool
+ * is `task` and the output is empty/whitespace-only, it replaces the output
+ * with an explicit error message so the parent sees a failure, not silence.
+ *
+ * Pure TypeScript — zero runtime dependencies. Meant to be wired into the
+ * `combinedAfter` hook chain in plugin.ts alongside the sandbox and read
+ * enhancer handlers.
+ *
+ * @module task-result-guard
+ */
+
+import { createPantheonLogger } from './logger.ts'
+
+const log = createPantheonLogger({ module: 'pantheon-task-result-guard' })
+
+// ─── Types ─────────────────────────────────────────────────────────────
+
+/** Input shape of the opencode `tool.execute.after` hook. */
+export interface TaskGuardInput {
+  tool: string
+  sessionID: string
+  callID: string
+  args: unknown
+}
+
+/** Output shape of the opencode `tool.execute.after` hook (mutable). */
+export interface TaskGuardOutput {
+  title?: string
+  output: string
+  metadata?: Record<string, unknown>
+}
+
+/** The `tool.execute.after` handler shape. */
+export type TaskResultGuardHandler = (
+  input: TaskGuardInput,
+  output: TaskGuardOutput,
+) => Promise<void>
+
+export interface TaskResultGuardOptions {
+  /** Injectable logger (defaults to the Pantheon file log). */
+  logger?: { warn: (message: string) => void }
+}
+
+// ─── Constants ─────────────────────────────────────────────────────────
+
+/**
+ * The error message injected when a task() result is empty.
+ * Keeps the historical "no assistant or tool output" contract text.
+ */
+export const EMPTY_TASK_ERROR =
+  'ERROR: task() returned empty output — child session produced no assistant or tool output. ' +
+  'This typically means the provider rejected the request (admission control / rate limit) ' +
+  'or the child session crashed before producing any response. ' +
+  'Consider splitting the work into a smaller task() or retrying the child session.'
+
+// ─── Implementation ────────────────────────────────────────────────────
+
+/**
+ * Whether a result carries any text content (whitespace-only counts as empty).
+ */
+function isEmptyOutput(output: unknown): boolean {
+  if (output == null) return true
+  if (typeof output !== 'string') return true
+  return output.trim() === ''
+}
+
+/**
+ * Create a task result guard handler for the `tool.execute.after` hook.
+ *
+ * When the tool is `task` and the output is empty/whitespace-only, replaces
+ * the output with an explicit error message. All other tools pass through
+ * untouched.
+ *
+ * @returns A `ToolExecuteAfterHandler`-compatible async function.
+ */
+export function createTaskResultGuard(options?: TaskResultGuardOptions): TaskResultGuardHandler {
+  const warn = options?.logger?.warn ?? ((message: string) => log.warn(message))
+
+  return async (input: TaskGuardInput, output: TaskGuardOutput): Promise<void> => {
+    // Only intercept the `task` tool — all others pass through untouched.
+    if (input.tool !== 'task') return
+
+    // Only flag truly empty results — non-empty content is the happy path.
+    if (!isEmptyOutput(output.output)) return
+
+    warn(
+      `[task-result-guard] Empty task() result detected on session ${input.sessionID} ` +
+        `(callID=${input.callID}). Replacing with explicit error.`,
+    )
+
+    output.output = EMPTY_TASK_ERROR
+  }
+}

package/src/pantheon/todo-enforcer.ts

@@ -2,9 +2,9 @@
  * TODO Enforcer (Wave 1) — keeps root/non-board sessions working on their
  * todo list when the session goes idle.
  *
- * The plugin's `event` hook dispatches `session.idle`: board-child sessions go
- * to the delegation finalize path (`handleDelegationEvent`), everything else
- * (roots, non-board sessions) goes to `TodoEnforcer.onIdle`. The enforcer
+ * The plugin's `event` hook dispatches `session.idle`: board-child sessions
+ * are owned by the board transition path, everything else (roots, non-board
+ * sessions) goes to `TodoEnforcer.onIdle`. The enforcer
  * re-injects a continuation prompt when the session went idle with incomplete
  * todos, so the agent keeps working on its task list instead of stopping.
  *

package/src/pantheon/tool-ceiling.ts

@@ -0,0 +1,159 @@
+/** Host-real context ceiling probe for C9/tool filtering. */
+
+import type { PluginInput } from '@opencode-ai/plugin'
+import { createPantheonLogger, type PantheonLogger } from './logger.ts'
+import type { NativeTaskStatus } from './native-task-status.ts'
+
+export interface ToolCeilingSnapshot {
+  usage: { inputTokens: number; outputTokens: number }
+  limit: { contextTokens: number }
+  supportsToolFiltering: boolean
+}
+
+export type ToolCeilingResult =
+  | {
+      status: 'OK'
+      ceiling: number
+      usage: ToolCeilingSnapshot['usage']
+      limit: ToolCeilingSnapshot['limit']
+    }
+  | { status: Exclude<NativeTaskStatus, 'OK'>; detail: string }
+
+export type HostToolCeilingSource = () => unknown | Promise<unknown>
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isFiniteNonNegative(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+}
+
+function isSnapshot(value: unknown): value is ToolCeilingSnapshot {
+  if (!isRecord(value) || !isRecord(value.usage) || !isRecord(value.limit)) return false
+  return (
+    isFiniteNonNegative(value.usage.inputTokens) &&
+    isFiniteNonNegative(value.usage.outputTokens) &&
+    isFiniteNonNegative(value.limit.contextTokens) &&
+    typeof value.supportsToolFiltering === 'boolean'
+  )
+}
+
+/** Probe exact host usage/limit without estimation, fallback, or retry. */
+export async function probeToolCeiling(source?: HostToolCeilingSource): Promise<ToolCeilingResult> {
+  if (source === undefined)
+    return { status: 'UNSUPPORTED', detail: 'host SDK exposes no context probe' }
+
+  let raw: unknown
+  try {
+    raw = await source()
+  } catch (error: unknown) {
+    return { status: 'UNAVAILABLE', detail: error instanceof Error ? error.message : String(error) }
+  }
+  if (!isSnapshot(raw))
+    return { status: 'CORRUPT_DATA', detail: 'host context probe returned malformed data' }
+  if (raw.supportsToolFiltering === false) {
+    return { status: 'UNSUPPORTED', detail: 'host SDK does not filter tools' }
+  }
+  const used = raw.usage.inputTokens + raw.usage.outputTokens
+  if (used > raw.limit.contextTokens) {
+    return { status: 'CORRUPT_DATA', detail: 'host usage exceeds context limit' }
+  }
+  return {
+    status: 'OK',
+    ceiling: raw.limit.contextTokens - used,
+    usage: raw.usage,
+    limit: raw.limit,
+  }
+}
+
+/**
+ * Read a ceiling from the actual OpenCode SDK event and provider catalogue.
+ *
+ * `message.updated` is the SDK's runtime usage source (`info.tokens`). The
+ * provider catalogue supplies the selected model's context limit and its
+ * `capabilities.toolcall` flag. This adapter intentionally does not accept a
+ * caller-provided snapshot/callback, so tests cannot accidentally turn a
+ * fixture into a claimed host probe.
+ */
+export async function probeToolCeilingFromHost(
+  client: PluginInput['client'],
+  event: unknown,
+): Promise<ToolCeilingResult> {
+  if (!isRecord(event) || event.type !== 'message.updated' || !isRecord(event.properties)) {
+    return { status: 'UNSUPPORTED', detail: 'host SDK event has no message usage' }
+  }
+  const info = event.properties.info
+  if (
+    !isRecord(info) ||
+    typeof info.providerID !== 'string' ||
+    typeof info.modelID !== 'string' ||
+    !isRecord(info.tokens)
+  ) {
+    return { status: 'UNSUPPORTED', detail: 'host SDK message has no token usage' }
+  }
+  const providerID = info.providerID as string
+  const modelID = info.modelID as string
+  const tokens = info.tokens as Record<string, unknown>
+
+  let providersResult: unknown
+  try {
+    providersResult = await client.config.providers()
+  } catch (error: unknown) {
+    return { status: 'UNAVAILABLE', detail: error instanceof Error ? error.message : String(error) }
+  }
+  if (!isRecord(providersResult) || providersResult.error !== undefined) {
+    return { status: 'UNAVAILABLE', detail: 'host SDK provider catalogue unavailable' }
+  }
+  const data = providersResult.data
+  if (!isRecord(data) || !Array.isArray(data.providers)) {
+    return { status: 'CORRUPT_DATA', detail: 'host SDK provider catalogue malformed' }
+  }
+
+  const provider = data.providers.find(
+    (candidate) =>
+      isRecord(candidate) &&
+      candidate.id === providerID &&
+      isRecord(candidate.models) &&
+      isRecord(candidate.models[modelID]),
+  )
+  if (!isRecord(provider) || !isRecord(provider.models)) {
+    return { status: 'UNSUPPORTED', detail: 'host SDK model metadata unavailable' }
+  }
+  const model = provider.models[modelID]
+  if (!isRecord(model) || !isRecord(model.limit) || !isRecord(model.capabilities)) {
+    return { status: 'UNSUPPORTED', detail: 'host SDK model ceiling capability unavailable' }
+  }
+
+  return probeToolCeiling(() => ({
+    usage: { inputTokens: tokens.input, outputTokens: tokens.output },
+    limit: { contextTokens: (model.limit as Record<string, unknown>).context },
+    supportsToolFiltering: (model.capabilities as Record<string, unknown>).toolcall,
+  }))
+}
+
+const log = createPantheonLogger({ module: 'pantheon-tool-ceiling' })
+
+/**
+ * Handle the host usage event and retain the result for the compaction hook.
+ * Malformed SDK events are diagnostic-only: they must never break the event
+ * pipeline or create an entry under an invalid session identifier.
+ */
+export async function handleToolCeilingEvent(
+  client: PluginInput['client'],
+  event: unknown,
+  ceilings: Map<string, ToolCeilingResult>,
+  logger: Pick<PantheonLogger, 'warn'> = log,
+): Promise<ToolCeilingResult> {
+  const sessionID = (
+    event as { properties?: { info?: { sessionID?: unknown } } } | null | undefined
+  )?.properties?.info?.sessionID
+  if (typeof sessionID !== 'string' || sessionID.trim() === '') {
+    logger.warn('[Pantheon Plugin] message.updated event has no valid sessionID')
+    return { status: 'UNSUPPORTED', detail: 'host SDK event has no valid sessionID' }
+  }
+
+  const result = await probeToolCeilingFromHost(client, event)
+  ceilings.set(sessionID, result)
+  return result
+}

package/src/pantheon/tool-context.ts

@@ -0,0 +1,23 @@
+/**
+ * Tool Context — the structural view of the context opencode passes to a
+ * tool's `execute()`.
+ *
+ * Extracted from `delegation.ts` (Fase 2 of the delegate removal) so the
+ * surviving structural tools (cost-command, model-command, goal-loop) no
+ * longer depend on the delegation module. Pure type — zero runtime code.
+ *
+ * @module tool-context
+ */
+
+/** Structural view of the tool context opencode passes to execute(). */
+export interface ToolContextLike {
+  sessionID: string
+  directory?: string
+  worktree?: string
+  /**
+   * The OpenCode SDK's ToolContext declares this as required. It remains
+   * optional here because the structural test/embedding surface can be
+   * supplied by older hosts; enforcement must skip when it is absent.
+   */
+  agent?: string
+}

package/src/pantheon/v2-bridge.ts

@@ -17,7 +17,6 @@
  */
 
 import type { BackgroundJobBoard } from './background-job-board.ts'
-import type { DelegationClient } from './delegation-finalize.ts'
 import type { GoalStore } from './goal-store.ts'
 import type { TodoEnforcer } from './todo-enforcer.ts'
 
@@ -57,8 +56,6 @@ export interface VisionHandler {
 export interface PantheonV2Bridge {
   /** Background job board — tracks running/completed/cancelled delegated jobs. */
   board?: BackgroundJobBoard
-  /** Structural delegation client — creates child sessions and sends prompts. */
-  delegationClient?: DelegationClient
   /** Goal store — file-based persistence for full-auto goal loop. */
   goalStore?: GoalStore
   /** Todo enforcer — idle continuation when todos are incomplete. */
@@ -85,7 +82,7 @@ export const BRIDGE_OPTIONS_KEY = '__pantheonV1Bridge' as const
  * @example
  * ```ts
  * // In V1 plugin setup (plugin.ts):
- * const bridge = createV2Bridge({ board, delegationClient, goalStore, ... })
+ * const bridge = createV2Bridge({ board, goalStore, ... })
  * // Then pass bridge to V2 context via options
  * ```
  */

package/src/plugin-v2.ts

@@ -2,7 +2,7 @@
  * Pantheon V2 Plugin — full orchestration plugin for OpenCode V2.
  *
  * Registers:
- * - 9 orchestration tools via V2 tool.transform (with V1 bridge fallback)
+ * - 6 orchestration tools via V2 tool.transform (with V1 bridge fallback)
  * - 4 event subscriptions (session.created, idle, error, compacted)
  * - Session hooks (prompt, context) and tool hooks (execute.before/after)
  * - Permission hooks for custom authorization
@@ -408,11 +408,11 @@ async function onSessionIdle(_event: V2SessionEvent): Promise<void> {
 }
 
 async function onSessionError(_event: V2SessionEvent): Promise<void> {
-  // Error handling — delegation finalize as error.
+  // Error handling — board transition to error.
   const bridge = resolveBridge()
   if (bridge?.board != null) {
-    // Bridge available: delegation error handling is done by V1 event hook.
-    // V2 only logs — V1 finalizeDelegation handles the board transition.
+    // Bridge available: error handling is done by the V1 event hook.
+    // V2 only logs — V1 owns the board transition.
   }
 }
 
@@ -640,9 +640,6 @@ function createV2ToolDefinitionsFromContext(_context: PluginContext): V2ToolDef[
     'infrastructure through the V2 bridge (src/pantheon/v2-bridge.ts).'
 
   const toolNames = [
-    'pantheon_delegate',
-    'pantheon_delegation_read',
-    'pantheon_delegation_list',
     'hashline_edit',
     'pantheon_goal_create',
     'pantheon_goal_get',
@@ -652,14 +649,6 @@ function createV2ToolDefinitionsFromContext(_context: PluginContext): V2ToolDef[
   ]
 
   const toolDescriptions: Record<string, string> = {
-    pantheon_delegate:
-      'Dispatch a background agent as a child session and register it on the job board. ' +
-      'Returns the readable alias (e.g. "apo-1"); read the result with pantheon_delegation_read.',
-    pantheon_delegation_read:
-      'Block until a background delegation finishes (completed/error/cancelled), then return ' +
-      'its report markdown (with a trailing agent-activity section) and mark the job reconciled.',
-    pantheon_delegation_list:
-      'List background delegations for the current session, with [unread] for finished jobs.',
     hashline_edit:
       'Edit a file anchored by hashline refs (LINE#TAG) instead of raw line numbers. ' +
       'Ops: replace, append, prepend, delete. ALL refs validated against ORIGINAL file first.',
@@ -681,12 +670,10 @@ function createV2ToolDefinitionsFromContext(_context: PluginContext): V2ToolDef[
     name,
     description: toolDescriptions[name] ?? `Pantheon tool: ${name}`,
     input: { type: 'object' as const, properties: {} },
-    // FOLLOW-UP: connect the real wrappers from
-    // src/pantheon/v2-tool-definitions.ts (createV2ToolDefinitions with
-    // costCommand/goalTools) once V1 infrastructure is resolvable in the V2
-    // standalone context. The before/after factories in v2-hooks.ts:216-282
-    // are likewise unwired. Until then, placeholders resolve to the object
-    // shape so the beta host never sees a bare string.
+    // FOLLOW-UP: wire the real tool wrappers (costCommand/goalTools) once V1
+    // infrastructure is resolvable in the V2 standalone context. Until then,
+    // placeholders resolve to the object shape so the beta host never sees a
+    // bare string.
     execute: async (_input: Record<string, unknown>, _context: unknown): Promise<V2ToolResult> => {
       return { output: `${name}: ${v2UnavailableMessage}` }
     },