pantheon-opencode 1.5.0-beta.8 → 1.5.0

package/src/pantheon/cost-command.ts

@@ -21,9 +21,8 @@ import { homedir } from 'node:os'
 import { delimiter, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { z } from 'zod'
-
-import type { ToolContextLike } from './delegation.ts'
 import type { NativeTaskStatus } from './native-task-status.ts'
+import type { ToolContextLike } from './tool-context.ts'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)

package/src/pantheon/delegation-enforce.ts

@@ -1,7 +1,7 @@
 /**
  * Read-Only Enforcement (Phase 4) — deny mutating tools inside sessions that
- * were delegated as read-only (advisory `read_only: true` on
- * pantheon_delegate, or the agent ∈ `readOnlyAgents` from routing.yml).
+ * were delegated as read-only (an explicit read-only flag, or the agent ∈
+ * `readOnlyAgents` from routing.yml).
  *
  * OpenCode hook: `tool.execute.before`. The hook shape is
  * `(input, output) => Promise<void>`; THROWING from the hook denies the tool
@@ -22,8 +22,10 @@
  * fail-closed when the runtime matrix is wired: missing agent identity or
  * target metadata is denied rather than inferred.
  *
- * The registry is populated by delegation.ts at delegate time: the CHILD
- * session is registered when the delegate call is read-only.
+ * The registry is populated by the plugin's `chat.params` hook — the only
+ * place the SDK exposes the active agent: when the session's agent is
+ * read-only (apollo, gaia — routing.yml `background_delegation.read_only_agents`),
+ * the session is registered; `session.deleted` unregisters it.
  *
  * @module delegation-enforce
  */
@@ -147,7 +149,6 @@ export function isDelegationAllowed(
 function targetFromTool(tool: string, args: unknown): string | undefined {
   if (args === null || typeof args !== 'object') return undefined
   const record = args as Record<string, unknown>
-  if (tool === 'pantheon_delegate') return normalizeDelegationAgent(record.agent)
   if (tool === 'task') {
     return normalizeDelegationAgent(record.subagent_type ?? record.subagentType)
   }
@@ -236,9 +237,10 @@ export function zeusReadGuard(tool: string, args: unknown, agent: string | undef
 // ─── Registry ──────────────────────────────────────────────────────────
 
 /**
- * Read-only session registry. `createDelegationTools` registers child
- * sessions here; the plugin's `tool.execute.before` guard consults it.
- * Process-wide singleton for plugin wiring + factory for test isolation.
+ * Read-only session registry. The plugin's `chat.params` hook registers
+ * sessions whose active agent is read-only (see {@link syncReadOnlySession});
+ * the `tool.execute.before` guard consults it. Process-wide singleton for
+ * plugin wiring + factory for test isolation.
  */
 export class ReadOnlySessionRegistry {
   private readonly sessions = new Map<string, ReadOnlyEntry>()
@@ -279,6 +281,50 @@ export class ReadOnlySessionRegistry {
 /** Process-wide registry wired into the plugin. */
 export const readOnlyRegistry = new ReadOnlySessionRegistry()
 
+// ─── Read-Only Agent Policy ────────────────────────────────────────────
+
+/**
+ * Agents that must stay investigation-only. Mirrors
+ * `background_delegation.read_only_agents` in routing.yml — the parity is
+ * enforced by tests/pantheon/delegation-enforce.test.ts so the two cannot
+ * drift silently.
+ */
+export const READ_ONLY_AGENTS: ReadonlySet<string> = new Set(['apollo', 'gaia'])
+
+/**
+ * Whether an agent identity belongs to the read-only set. Identity is never
+ * inferred from prompts or tool names — only the normalized agent name counts.
+ */
+export function isReadOnlyAgent(
+  agent: unknown,
+  readOnlyAgents: ReadonlySet<string> = READ_ONLY_AGENTS,
+): boolean {
+  const normalized = normalizeDelegationAgent(agent)
+  return normalized !== undefined && readOnlyAgents.has(normalized)
+}
+
+/**
+ * Sync the read-only registry with a session's active agent. Called from the
+ * plugin's `chat.params` hook: a read-only agent registers the session;
+ * anything else (unknown/absent/non-read-only) unregisters it, which also
+ * covers an in-session agent switch. Returns whether the session is now
+ * registered.
+ */
+export function syncReadOnlySession(
+  registry: ReadOnlySessionRegistry,
+  sessionID: string,
+  agent: unknown,
+  readOnlyAgents: ReadonlySet<string> = READ_ONLY_AGENTS,
+): boolean {
+  const normalized = normalizeDelegationAgent(agent)
+  if (normalized === undefined || !readOnlyAgents.has(normalized)) {
+    registry.unregister(sessionID)
+    return false
+  }
+  registry.register(sessionID, { agent: normalized })
+  return true
+}
+
 // ─── Guard ─────────────────────────────────────────────────────────────
 
 /**
@@ -291,19 +337,18 @@ export function createEnforcementGuard(input: {
   options?: EnforcementGuardOptions
 }): ToolExecuteBeforeHandler {
   const blockedTools = input.options?.blockedTools ?? DEFAULT_BLOCKED_TOOLS
-  const prefix = input.options?.messagePrefix ?? 'pantheon_delegate guard'
+  const prefix = input.options?.messagePrefix ?? 'pantheon delegation guard'
 
   return async (hook: ToolExecuteBeforeInput, output?: ToolExecuteBeforeOutput): Promise<void> => {
-    const isDelegationTool = hook.tool === 'task' || hook.tool === 'pantheon_delegate'
+    const isDelegationTool = hook.tool === 'task'
     if (isDelegationTool && input.options?.isChildSession?.(hook.sessionID) === true) {
       throw new Error(
         `${prefix}: session ${hook.sessionID} is a child session — delegation tools are denied ` +
           'to prevent nested delegation',
       )
     }
-    // pantheon_delegate has the authoritative ToolContext.agent at execution
-    // time, so its matrix check lives in delegation.ts. The hook only has the
-    // session-scoped agent learned from chat.params for native task().
+    // The hook only has the session-scoped agent learned from chat.params,
+    // so the runtime matrix check for native task() lives here.
     if (
       hook.tool === 'task' &&
       input.options?.isRootSession !== undefined &&
@@ -336,7 +381,7 @@ export function createEnforcementGuard(input: {
         `This session was delegated for investigation only (read-only agent); it cannot ` +
         `modify files, run commands, or spawn subagents. ` +
         `If a write result is needed, dispatch a write-capable agent ` +
-        `(e.g. hermes, aphrodite) with pantheon_delegate instead.`,
+        `(e.g. hermes, aphrodite) with native task() instead.`,
     )
   }
 }

package/src/pantheon/goal-loop.ts

@@ -17,11 +17,11 @@
 import { z } from 'zod'
 
 import type { BackgroundJobBoard } from './background-job-board.ts'
-import type { ToolContextLike } from './delegation.ts'
 import { GoalStore } from './goal-store.ts'
 import { createPantheonLogger } from './logger.ts'
 import { safeSessionPath } from './session-guard.ts'
 import type { TodoEnforcerMessage } from './todo-enforcer.ts'
+import type { ToolContextLike } from './tool-context.ts'
 
 // Silence-by-default TUI policy (pantheon-hooks L42-58): warn → hooks.log,
 // console echo opt-in via PANTHEON_HOOKS_LOG=1. `deps.logger` stays for tests.

package/src/pantheon/goal-store.ts

@@ -15,7 +15,7 @@
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
-import { assertSafeParentSessionID } from './delegation-finalize.ts'
+import { assertSafeParentSessionID } from './session-id.ts'
 
 export type GoalStatus = 'pending' | 'in_progress' | 'done'
 

package/src/pantheon/idle-continuation.ts

@@ -5,9 +5,8 @@
  * Priority: an ACTIVE GOAL owns the idle — `GoalLoop.onIdle` continues the
  * goal. Without an active goal, the TODO enforcer gets the idle (it
  * self-guards on its own enabled flag + guards). Board-child sessions never
- * reach the dispatcher — the plugin's event hook routes those to the
- * delegation finalize path first (`handleDelegationEvent` returns true) and
- * only calls the dispatcher on the `!delegated` branch.
+ * reach the dispatcher — the plugin's event hook owns board transitions and
+ * only calls the dispatcher for non-board sessions.
  *
  * Independently testable — the loop and enforcer are structural interfaces;
  * the real GoalLoop/TodoEnforcer satisfy them.
@@ -34,9 +33,8 @@ export interface IdleDispatcher {
 }
 
 /**
- * Build the idle router. The plugin event hook calls this only on the
- * `!delegated` branch of `handleDelegationEvent`, so board children never
- * arrive here.
+ * Build the idle router. The plugin event hook calls this only for non-board
+ * sessions, so board children never arrive here.
  */
 export function createIdleDispatcher(deps: {
   goalLoop: GoalLoopLike

package/src/pantheon/model-command.ts

@@ -23,8 +23,6 @@ import { lstat, mkdir, open, rename, unlink } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, dirname, join, resolve } from 'node:path'
 import { z } from 'zod'
-
-import type { ToolContextLike } from './delegation.ts'
 import {
   capabilityEntry,
   hasVision,
@@ -32,6 +30,7 @@ import {
   normalizeCapability,
   resolveActivePreset,
 } from './presets.mjs'
+import type { ToolContextLike } from './tool-context.ts'
 
 export type ModelScope = 'project' | 'global'
 export type ModelAction = 'status' | 'show' | 'set' | 'reset'

package/src/pantheon/native-task-status.ts

@@ -2,8 +2,8 @@
  * Native Task Status — classifies BackgroundJobRecord results from native
  * task() delegation into actionable status codes.
  *
- * Pure module — zero external dependencies. Consumed by native-probe.ts
- * and the delegation manager to decide retry/skip/escalate strategy.
+ * Pure module — zero external dependencies. Consumed by the tool-ceiling and
+ * cost layers to decide retry/skip/escalate strategy.
  *
  * @module native-task-status
  */

package/src/pantheon/presets.d.mts

@@ -104,26 +104,6 @@ export interface RoutingRetryPolicyOptions {
   logger?: { warn?: (msg: string) => void }
 }
 
-/**
- * R1: per-error-type retry policy from routing.yml `retry_policy`
- * (auth/rate_limit/timeout/other → max retries). Fail-open → null.
- */
-export declare function loadRoutingRetryPolicy(
-  options?: RoutingRetryPolicyOptions,
-): Record<string, number> | null
-
-export interface RoutingCooldownResult {
-  allowed_fails: number
-  cooldown_time_seconds: number
-}
-
-/**
- * R1: provider cooldown config from routing.yml `cooldown`. Fail-open → null.
- */
-export declare function loadRoutingCooldown(
-  options?: RoutingRetryPolicyOptions,
-): RoutingCooldownResult | null
-
 /**
  * R4: per-agent step caps from routing.yml `agents.<name>.max_steps`.
  * Fail-open → {} (no agent capped).

package/src/pantheon/presets.mjs

@@ -213,70 +213,6 @@ function loadRoutingYaml(routingPath) {
   return routing && typeof routing === 'object' ? routing : null
 }
 
-const RETRY_ERROR_TYPES = new Set(['auth', 'rate_limit', 'timeout', 'other'])
-
-/**
- * Load the R1 per-error-type retry policy from routing.yml (`retry_policy:`).
- * Fail-open: missing/unparseable config yields null (the caller falls back
- * to DEFAULT_RETRY_POLICY) and warns via the optional logger.
- *
- * @param {object} [opts]
- * @param {string} [opts.routingPath]
- * @param {{warn?: Function}} [opts.logger]
- * @returns {Record<string, number>|null} error-type → max retries
- */
-export function loadRoutingRetryPolicy({ routingPath, logger = console } = {}) {
-  try {
-    const routing = loadRoutingYaml(routingPath)
-    const policy = routing?.retry_policy
-    if (!policy || typeof policy !== 'object' || Array.isArray(policy)) return null
-    const out = {}
-    for (const [type, max] of Object.entries(policy)) {
-      if (RETRY_ERROR_TYPES.has(type) && Number.isSafeInteger(max) && max >= 0) {
-        out[type] = max
-      }
-    }
-    return Object.keys(out).length > 0 ? out : null
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err)
-    logger.warn?.(`presets: routing.yml retry_policy unavailable (${reason})`)
-    return null
-  }
-}
-
-/**
- * Load the R1 provider cooldown config from routing.yml (`cooldown:`).
- * Fail-open: missing/unparseable config yields null (caller falls back to
- * DEFAULT_COOLDOWN).
- *
- * @param {object} [opts]
- * @param {string} [opts.routingPath]
- * @param {{warn?: Function}} [opts.logger]
- * @returns {{allowed_fails: number, cooldown_time_seconds: number}|null}
- */
-export function loadRoutingCooldown({ routingPath, logger = console } = {}) {
-  try {
-    const routing = loadRoutingYaml(routingPath)
-    const cooldown = routing?.cooldown
-    if (!cooldown || typeof cooldown !== 'object' || Array.isArray(cooldown)) return null
-    const allowedFails = cooldown.allowed_fails
-    const cooldownTimeSeconds = cooldown.cooldown_time_seconds
-    if (
-      !Number.isSafeInteger(allowedFails) ||
-      allowedFails < 1 ||
-      !Number.isSafeInteger(cooldownTimeSeconds) ||
-      cooldownTimeSeconds < 1
-    ) {
-      return null
-    }
-    return { allowed_fails: allowedFails, cooldown_time_seconds: cooldownTimeSeconds }
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err)
-    logger.warn?.(`presets: routing.yml cooldown unavailable (${reason})`)
-    return null
-  }
-}
-
 /**
  * Load the R4 per-agent step caps from routing.yml
  * (`agents.<name>.max_steps`). Fail-open: missing config yields {}.

package/src/pantheon/session-guard.ts

@@ -10,8 +10,8 @@
  * never throw, never send the placeholder).
  *
  * Mirrors the TUI's `src/plugins/tui/src/index.tsx` contract verbatim so both
- * sides agree on what "valid" means. The TUI file remains self-contained
- * (dist/tui.tsx is a raw copy, no relative imports), so its local copy is kept
+ * sides agree on what "valid" means. The TUI plugin ships as a bundle
+ * (dist/tui.js) without the src/pantheon tree, so its local copy is kept
  * in sync — this module is the shared source for `src/pantheon/*` and
  * `src/plugin.ts`.
  *

package/src/pantheon/session-id.ts

@@ -0,0 +1,30 @@
+/**
+ * Session ID safety — reject session IDs that could escape a per-session
+ * output directory.
+ *
+ * Shared helper for the file-backed stores that remain after the delegate
+ * removal (goal-store and friends) — it no longer lives alongside the
+ * deleted delegation module.
+ *
+ * `sessionID` is embedded in a path
+ * `<dir>/<sessionID>/file.json` — `path.join` does NOT strip `..`, so a
+ * traversing ID would write outside the sandbox. Call this BEFORE any path
+ * construction.
+ *
+ * @module session-id
+ */
+
+/**
+ * Reject session IDs that could escape the target directory.
+ *
+ * @throws {Error} When the ID contains `..`, `/`, or `\`.
+ */
+export function assertSafeParentSessionID(parentSessionID: string): void {
+  if (
+    parentSessionID.includes('..') ||
+    parentSessionID.includes('/') ||
+    parentSessionID.includes('\\')
+  ) {
+    throw new Error(`Invalid parentSessionID: ${parentSessionID}`)
+  }
+}

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

@@ -58,14 +58,13 @@ export interface TaskResultGuardOptions {
 
 /**
  * The error message injected when a task() result is empty.
- * Matches the existing delegation-finalize.ts contract:
- * "Child session produced no assistant or tool output".
+ * 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 using pantheon_delegate (clean context) instead of task() for large payloads.'
+  'Consider splitting the work into a smaller task() or retrying the child session.'
 
 // ─── Implementation ────────────────────────────────────────────────────
 

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