pantheon-opencode 1.5.0-beta.14 → 1.5.0-beta.16

package/src/pantheon/delegate-manager.ts

@@ -23,13 +23,16 @@
  * @module delegate-manager
  */
 
+import { join } from 'node:path'
 import { z } from 'zod'
 import type { BackgroundJobBoard, BackgroundJobRecord } from './background-job-board.ts'
 import type { DelegationToolset } from './delegation.ts'
 import {
+  capReportOutput,
   DELEGATION_DEFAULTS,
   type DelegationClient,
   readDelegationReport,
+  resolveReadMaxChars,
 } from './delegation-finalize.ts'
 import { createNativeProbe, type NativeProbeFn, type ProbeClient } from './native-probe.ts'
 import { classifyNativeResult, type NativeTaskStatus } from './native-task-status.ts'
@@ -66,10 +69,14 @@ export type NativeTaskFn = (input: NativeTaskInput) => Promise<NativeTaskResult>
 /** Minimal launch receipt: id, agent, state, one short line. */
 export interface ManagerReceipt {
   id: string
+  /** Board alias of the job (e.g. `apo-1`) — report files are keyed by it. */
+  alias: string
   agent: string
   state: 'reconciled' | 'error'
   status: NativeTaskStatus
   line: string
+  /** Verified child output (when the task completed with content). */
+  output?: string
 }
 
 export interface LaunchArgs {
@@ -109,6 +116,15 @@ export interface DelegateManagerOptions {
   nativeProbe?: NativeProbeFn
   /** V1 client used by the lazy capability probe. */
   probeClient?: ProbeClient
+  /** Base directory for delegation reports (default `.pantheon/delegations`). */
+  outputDir?: string
+  /**
+   * Inline cap (chars) for report content returned to the caller. Oversized
+   * reports keep head+tail with an explicit `[TRUNCATED …]` marker pointing
+   * at the full report file. Default: PANTHEON_DELEGATION_READ_MAX_CHARS
+   * or 50_000.
+   */
+  readMaxChars?: number
 }
 
 export interface DelegateManager {
@@ -139,7 +155,9 @@ export function resolveDelegateMode(
 
 const LINE_MAX = 160
 
-/** Remove terminal escapes and control characters from untrusted child output. */
+/** Remove terminal escapes and control characters from untrusted child output.
+ *  UTF-8 text (accents, emoji) is PRESERVED — only ANSI sequences, C0/C1
+ *  controls and DEL are stripped; receipt/report lines stay human-readable. */
 export function sanitizeReceiptText(text: string): string {
   let clean = ''
   let skippingAnsi = false
@@ -154,7 +172,8 @@ export function sanitizeReceiptText(text: string): string {
       skippingAnsi = true
       continue
     }
-    if (char === '\n' || char === '\t' || (code >= 0x20 && code <= 0x7e)) clean += char
+    const isControl = code < 0x20 || (code >= 0x7f && code <= 0x9f)
+    if (!isControl || char === '\n' || char === '\t') clean += char
   }
   return clean
 }
@@ -219,7 +238,13 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
     stepCap,
     nativeProbe,
     probeClient,
+    outputDir = DELEGATION_DEFAULTS.outputDir,
+    readMaxChars,
   } = options
+  const inlineMaxChars = readMaxChars ?? resolveReadMaxChars(env)
+
+  /** Report file path for a job alias (the durable full report). */
+  const reportPathFor = (alias: string): string => join(outputDir, parentSessionID, `${alias}.md`)
 
   // Strict native mode: foregroundFallback and models are overridden.
   // The user-facing options are ignored when PANTHEON_DELEGATE_MODE=native.
@@ -310,7 +335,14 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
           LINE_MAX,
         )
       : boardLine(settled ?? job)
-    return { id: taskID, agent: job.agent, state: failed ? 'error' : 'reconciled', status, line }
+    return {
+      id: taskID,
+      alias,
+      agent: job.agent,
+      state: failed ? 'error' : 'reconciled',
+      status,
+      line,
+    }
   }
 
   /** Apply a terminal transition best-effort: a racing hook may have gotten there first. */
@@ -354,7 +386,11 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
       await applyTerminal(taskID, 'completed', {
         resultSummary: firstLine(outcome.result.content, 500),
       })
-      return await settle(taskID, record.alias)
+      const settled = await settle(taskID, record.alias)
+      // The task() call already blocked until completion — return the verified
+      // output in the receipt (the parent reads the full report via the alias
+      // when needed). The tool layer caps it inline.
+      return { ...settled, output: outcome.result.content }
     } finally {
       pendingByAgent.set(key, Math.max(0, pending(args.agent) - 1))
     }
@@ -403,7 +439,17 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
       },
       ok ? undefined : (outcome as { ok: false; error?: string }).error,
     )
-    return { id, agent: args.agent, state: ok ? 'reconciled' : 'error', status, line }
+    return {
+      id,
+      alias: id,
+      agent: args.agent,
+      state: ok ? 'reconciled' : 'error',
+      status,
+      line,
+      ...(ok
+        ? { output: (outcome as { ok: true; result: NativeTaskResult }).result.content ?? '' }
+        : {}),
+    }
   }
 
   return {
@@ -416,8 +462,10 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
         const maxSteps = stepCap.maxStepsFor(args.agent)
         if (stepCap.isCapped(args.agent)) {
           const line = cappedSummary(args.agent, maxSteps ?? DEFAULT_MAX_STEPS).slice(0, LINE_MAX)
+          const cappedId = `cap-${Date.now()}`
           return {
-            id: `cap-${Date.now()}`,
+            id: cappedId,
+            alias: cappedId,
             agent: args.agent,
             state: 'reconciled',
             status: 'ESCALATE',
@@ -432,8 +480,10 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
       if (isNativeMode) {
         const unavailableStatus = await ensureNativeAvailable()
         if (unavailableStatus !== undefined) {
+          const probeId = `probe-${parentSessionID}`
           return {
-            id: `probe-${parentSessionID}`,
+            id: probeId,
+            alias: probeId,
             agent: args.agent,
             state: 'error',
             status: unavailableStatus,
@@ -464,6 +514,13 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
       )
       if (terminal.state !== 'reconciled') await board.markReconciled(terminal.taskID)
       await board.deleteSignal(terminal.alias)
+      // Full report first (same contract as the legacy engine): the md file
+      // written by finalizeDelegation carries the complete child output. The
+      // one-line resultSummary is only a fallback when no report was written.
+      const md = await readDelegationReport(outputDir, terminal)
+      if (md !== undefined) {
+        return capReportOutput(md, inlineMaxChars, reportPathFor(terminal.alias))
+      }
       if (terminal.state === 'error' && !terminal.resultSummary) {
         return `# Delegation Report — ${terminal.alias}\n\nERROR: ${sanitizeReceiptText(terminal.lastStatusError ?? 'failed')}\n`
       }
@@ -640,6 +697,7 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
       ? {}
       : { promptTimeoutMs: managerOptions.timeoutMs }),
   })
+  const inlineMaxChars = managerOptions.readMaxChars ?? resolveReadMaxChars(env)
   const managers = new Map<string, DelegateManager>()
   const managerFor = (parentSessionID: string): DelegateManager => {
     const existing = managers.get(parentSessionID)
@@ -652,6 +710,7 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
       parentSessionID,
       env,
       ...(stepCap === undefined ? {} : { stepCap }),
+      ...(wiring.outputDir === undefined ? {} : { outputDir: wiring.outputDir }),
       nativeProbe,
       probeClient: client,
     })
@@ -702,7 +761,21 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
           ...(args.model === undefined ? {} : { model: args.model }),
           taskID: childID,
         })
-        return `status: ${receipt.status}\n${receipt.line}`
+        // The launch blocked until the child finished — return the verified
+        // output inline (capped head+tail with a pointer to the full report),
+        // not just a status line. Foreground receipts carry no report file,
+        // so the marker points at pantheon_delegation_read instead.
+        const header = `status: ${receipt.status}\n${receipt.line}`
+        if (receipt.output === undefined || receipt.output.trim() === '') return header
+        const reportPath =
+          receipt.alias === receipt.id
+            ? undefined
+            : join(
+                wiring.outputDir ?? DELEGATION_DEFAULTS.outputDir,
+                ctx.sessionID,
+                `${receipt.alias}.md`,
+              )
+        return `${header}\n\n${capReportOutput(receipt.output, inlineMaxChars, reportPath)}`
       },
     },
     pantheon_delegation_read: {
@@ -739,6 +812,10 @@ export interface PluginNativeDelegationWiring {
   agentModels: Record<string, string | undefined>
   stepCap: StepCapTracker
   wallClockTimeoutMs?: number
+  /** Base directory for delegation reports (default `.pantheon/delegations`). */
+  outputDir?: string
+  /** Inline cap (chars) for delegation report content (default env or 50_000). */
+  readMaxChars?: number
   finalizeDelegation: DelegationToolset['finalizeDelegation']
 }
 export type PluginNativeDelegation = NativeDelegateToolset & {
@@ -751,15 +828,23 @@ export function buildPluginNativeDelegation(
     ...createNativeDelegateTools({
       board: wiring.board,
       client: wiring.client,
+      ...(wiring.outputDir === undefined ? {} : { outputDir: wiring.outputDir }),
       isRootSession: wiring.isRootSession,
       registerChildSession: wiring.registerChildSession,
       registerReadOnlySession: wiring.registerReadOnlySession,
       isReadOnlyAgent: (agent) => wiring.readOnlyAgents.has(agent.toLowerCase()),
       agentModel: (agent) => wiring.agentModels[agent.toLowerCase()],
       stepCap: wiring.stepCap,
-      ...(wiring.wallClockTimeoutMs === undefined
+      ...(wiring.wallClockTimeoutMs === undefined && wiring.readMaxChars === undefined
         ? {}
-        : { managerOptions: { timeoutMs: wiring.wallClockTimeoutMs } }),
+        : {
+            managerOptions: {
+              ...(wiring.wallClockTimeoutMs === undefined
+                ? {}
+                : { timeoutMs: wiring.wallClockTimeoutMs }),
+              ...(wiring.readMaxChars === undefined ? {} : { readMaxChars: wiring.readMaxChars }),
+            },
+          }),
     }),
     finalizeDelegation: wiring.finalizeDelegation,
   }

package/src/pantheon/delegation-classifier.ts

@@ -8,8 +8,7 @@
  *   - `timeout` (timeout-with-partial / timeout-empty / timeout-exhausted)
  *   - `error` — provider or infrastructure failure
  *
- * Integrates with the existing `dispatch-guard.ts` classification for
- * empty-response detection and provides a structured `DelegationResult`
+ * Provides empty-response detection and a structured `DelegationResult`
  * that replaces raw-text returns.
  *
  * @module delegation-classifier
@@ -17,7 +16,7 @@
 
 // ─── Types ─────────────────────────────────────────────────────────────
 
-/** Empty-response mode classification (matches dispatch-guard). */
+/** Empty-response mode classification (empty-mode1 / empty-mode2). */
 export type EmptyMode = 'empty-mode1' | 'empty-mode2'
 
 /** Timeout sub-type based on partial output and retry history. */
@@ -82,7 +81,7 @@ const NO_OUTPUT_RE = /_No output captured\._/i
 
 /**
  * Classify whether a response is empty, empty-with-tokens, or has content.
- * Matches the dispatch-guard classification (empty-mode1, empty-mode2).
+ * Classifies empty-mode1 (no text/tokens) vs empty-mode2 (tokens, no text).
  *
  * @param text The response text (may be null/undefined).
  * @param tokens Optional token counts for mode2 detection.

package/src/pantheon/delegation-finalize.ts

@@ -157,6 +157,13 @@ export interface DelegationOptions {
   /** Injectable clock/sleeper for deterministic watchdog tests. */
   now?: () => number
   sleep?: (ms: number) => Promise<void>
+  /**
+   * Inline cap (chars) for report content returned by pantheon_delegation_read.
+   * Oversized reports keep head+tail with an explicit `[TRUNCATED …]` marker
+   * pointing at the full report file. Default: PANTHEON_DELEGATION_READ_MAX_CHARS
+   * or 50_000.
+   */
+  readMaxChars?: number
   /**
    * Kill-switch: when false, all delegation tools (delegate/read/list) throw
    * immediately. Mirrors `PANTHEON_DELEGATION=off` from the native manager.
@@ -276,6 +283,62 @@ function summarizeOutput(output: string): string {
   return firstLine.length > 120 ? `${firstLine.slice(0, 120)}…` : firstLine
 }
 
+// ─── Report inline cap ─────────────────────────────────────────────────
+//
+// Delegation reports are returned INLINE to the orchestrator (tool result).
+// A very large child output must be capped BEFORE it floods the parent
+// context — but a hard mid-content cut loses the report header AND the
+// conclusion. The cap keeps head + tail with an explicit marker pointing at
+// the full report (the durable `.pantheon/delegations/<parent>/<alias>.md`
+// file or the read tool), mirroring how comparable agent hosts surface
+// oversized tool output.
+
+/** Default inline cap for delegation report content (chars). */
+export const DELEGATION_READ_MAX_CHARS = 50_000
+/** Lower bound for PANTHEON_DELEGATION_READ_MAX_CHARS. */
+export const DELEGATION_READ_MAX_CHARS_MIN = 1_000
+
+/** Resolve the inline report cap from the environment (default 50k, min 1k). */
+export function resolveReadMaxChars(env: Record<string, string | undefined> = process.env): number {
+  const raw = env.PANTHEON_DELEGATION_READ_MAX_CHARS?.trim()
+  if (raw === undefined || raw === '') return DELEGATION_READ_MAX_CHARS
+  const value = Number(raw)
+  return Number.isSafeInteger(value) && value >= DELEGATION_READ_MAX_CHARS_MIN
+    ? value
+    : DELEGATION_READ_MAX_CHARS
+}
+
+/**
+ * Cap report markdown for inline return: ≤ `maxChars` passes through
+ * untouched; anything larger keeps the head (60% of the budget) + tail (25%)
+ * with an explicit `[TRUNCATED …]` marker between them. `reportPath` names
+ * the durable full-report file in the marker; without it the marker points
+ * at `pantheon_delegation_read`. Pure — no I/O.
+ */
+export function capReportOutput(md: string, maxChars: number, reportPath?: string): string {
+  if (md.length <= maxChars) return md
+  if (maxChars < 200) {
+    // Budget too small for a head+tail split — keep what fits after the marker.
+    const marker = capReportMarker(md.length, 0, reportPath)
+    return `${md.slice(0, Math.max(0, maxChars - marker.length - 1))}\n${marker}`
+  }
+  const headLen = Math.floor(maxChars * 0.6)
+  const tailLen = Math.floor(maxChars * 0.25)
+  return `${md.slice(0, headLen)}\n${capReportMarker(md.length, headLen + tailLen, reportPath)}\n${md.slice(md.length - tailLen)}`
+}
+
+function capReportMarker(
+  totalChars: number,
+  keptChars: number,
+  reportPath: string | undefined,
+): string {
+  const where =
+    reportPath !== undefined
+      ? `full report: ${reportPath}`
+      : 'read the full report with pantheon_delegation_read'
+  return `[TRUNCATED: ${totalChars - keptChars} of ${totalChars} chars hidden — ${where}]`
+}
+
 // ─── Report persistence ────────────────────────────────────────────────
 
 /**
@@ -387,13 +450,12 @@ export async function finalizeDelegation(
     // report above still captures this finalize; the board state stands.
   }
 
-  // P1-1: Delete the auto-wake signal file to prevent leaks. The board
-  // writes .signal.json on every terminal transition, but the legacy path
-  // never called deleteSignal — only the native delegate-manager did.
-  // The consumer (auto-wake.ts consumeWakeSignals) is intentionally NOT
-  // wired in the event hook: finalizeDelegation already handles the
-  // terminal transition, so consuming signals would be redundant and risks
-  // double-processing. deleteSignal on finalize is sufficient.
+  // P1-1: Delete the wake signal file to prevent leaks. The board writes
+  // .signal.json on every terminal transition, but the legacy path never
+  // called deleteSignal — only the native delegate-manager did.
+  // finalizeDelegation already handles the terminal transition, so
+  // consuming signals would be redundant; deleteSignal on finalize is
+  // sufficient.
   await deps.board.deleteSignal(job.alias)
 
   // P1-4: Prune old completed jobs and enforce the hard entry cap. The

package/src/pantheon/delegation.ts

@@ -35,6 +35,7 @@
  * @module delegation
  */
 
+import { join } from 'node:path'
 import { z } from 'zod'
 
 import type { BackgroundJobBoard, BackgroundJobRecord } from './background-job-board.ts'
@@ -49,6 +50,7 @@ import {
   readOnlyRegistry,
 } from './delegation-enforce.ts'
 import {
+  capReportOutput,
   DELEGATION_DEFAULTS,
   type DelegationClient,
   type DelegationDeps,
@@ -57,6 +59,7 @@ import {
   type FinalizeInput,
   finalizeDelegation as finalizeDelegationReport,
   readDelegationReport,
+  resolveReadMaxChars,
 } from './delegation-finalize.ts'
 import { finalizeIdleChildrenWithoutMd } from './delegation-notify.ts'
 import { createPantheonLogger } from './logger.ts'
@@ -814,6 +817,10 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
 
   const knownChildren = new Set<string>()
   const timers = new Map<string, NodeJS.Timeout>()
+  // Inline cap for report content returned by pantheon_delegation_read —
+  // oversized reports keep head+tail with an explicit marker pointing at the
+  // full report file (never a silent mid-content cut).
+  const inlineMaxChars = options.readMaxChars ?? resolveReadMaxChars()
   // Fase B3: per-parent-session delegation budget tracking, scoped to this
   // factory/process instance. Keyed by `${parentSessionID}:${parentAgent}->${targetAgent}`;
   // it is not restart-persistent because the factory has no reliable store.
@@ -1276,6 +1283,11 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       if (md === undefined) {
         return `Delegation [${terminal.alias}] reached state ${terminal.state} but no report file was found.`
       }
+      // Classify on the FULL report (markers may sit at either end), but
+      // return the inline-capped markdown so a huge child output cannot
+      // flood the parent context — the marker points at the full file.
+      const reportPath = join(outputDir, terminal.parentSessionID, `${terminal.alias}.md`)
+      const cappedMd = capReportOutput(md, inlineMaxChars, reportPath)
 
       // Classify the result for stuck-agent detection
       const classification = classifyStuckAgent(md)
@@ -1284,15 +1296,15 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
 
       if (classification.status === 'success') {
         await board.markReconciled(job.taskID)
-        // Backward compatible: success reports returned as-is
-        if (!hasActivity) return md
-        return `${md.replace(/\n+$/, '')}${activitySuffix}`
+        // Backward compatible: success reports returned as-is (capped)
+        if (!hasActivity) return cappedMd
+        return `${cappedMd.replace(/\n+$/, '')}${activitySuffix}`
       }
 
       // Non-success: build structured DelegationResult and format
       const delegationResult: DelegationResult = {
         status: classification.status === 'empty' ? 'empty' : classification.status,
-        content: md,
+        content: cappedMd,
         retryCount: 0,
         partialResult: classification.partialResult,
         recommendation: classification.recommendation,

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/plugin-v2.ts

@@ -681,12 +681,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}` }
     },

package/src/plugin.ts

@@ -66,10 +66,10 @@ import { activePresetCandidates, createVisionHandler } from './pantheon/vision.t
 const log = createPantheonLogger({ module: 'pantheon-plugin' })
 
 // R4: per-agent step caps from routing.yml `agents.<name>.max_steps`
-// (fail-open → {} = no agent capped). R1 retry_policy/cooldown are NOT
-// wired here — the plugin has no retry path (opencode cannot intercept task
-// completion); zeus waves load them via presets.mjs loaders and pass them
-// to zeusDelegateWithRetry explicitly.
+// (fail-open → {} = no agent capped). The R1 retry_policy/cooldown block and
+// its presets.mjs loaders were removed together with their only consumer
+// (zeus-delegate-with-retry.ts); the plugin has no retry path (opencode cannot
+// intercept task completion).
 const stepCapTracker = new StepCapTracker(loadRoutingMaxSteps({ logger: log }))
 
 // O5: permission.task glob rules from routing.yml `permission.task`
@@ -517,8 +517,8 @@ const plugin: Plugin = async (input: PluginInput) => {
 
   // Wave 4 (PR #46): /cost — delegation cost + token visibility. Reads
   // opencode.db read-only via the single node:sqlite backend.
-  // Fully wired (unlike dispatch-guard, which is manual-orchestration-only
-  // because opencode 1.18.x cannot intercept task completion via hooks).
+  // Fully wired. (opencode 1.18.x cannot intercept task completion via hooks,
+  // so empty-result handling lives in delegation-classifier.ts.)
   const costCommand = createCostCommand()
   const modelCommand = createModelCommand()
 

package/src/plugins/pantheon-hooks.ts

@@ -783,7 +783,7 @@ function delegationAgent(tool: string, args?: unknown): string {
  * panel tracks the child end-to-end. Fire-and-forget and silent: a mirror
  * failure must never surface into the tool call or the transcript.
  * registerLaunchIfAbsent keeps it idempotent against any other dispatcher
- * (v2-events, plugin double-load, repeated after-hook firings).
+ * (plugin double-load, repeated after-hook firings).
  */
 function mirrorNativeBackgroundDispatch(
   input: { tool: string; sessionID: string },