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

package/CHANGELOG.md

@@ -18,6 +18,44 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## ✅ Closed Issues
 
+## [v1.5.0-beta.15] - 2026-09-15
+
+<!-- Add new changes here. Running `node scripts/versioning.mjs apply` will
+     move this section to a versioned entry and reset the template below. -->
+
+## 🆕 What's New
+
+- **Delegation `read` devolve o relatório completo:** o retorno de `read` passa a
+  ler o relatório integral do disco (com cap configurável e marker explícito de
+  truncamento) em vez do recibo resumido — o conteúdo é o mesmo tanto no caminho
+  nativo quanto no legado, com paridade garantida entre eles.
+- **`sanitizeReceiptText` UTF-8-safe:** a sanitização de recibos deixou de corromper
+  caracteres multibyte; acentuação e demais codepoints UTF-8 são preservados no
+  caminho nativo e no legado.
+- **TUI — cor de status na row inteira:** cada linha do painel Delegations passa a
+  ser pintada pelo estado — vermelho = falha, verde = concluído, amarelo = em
+  andamento — com o glyph mantido como canal redundante para acessibilidade.
+
+## 🐞 Fixed
+
+- **TUI — painel Delegations só da sessão ativa:** o painel deixa de renderizar
+  rows cross-session/órfãs que causavam "Session not found" ao clicar; a lista
+  agora cobre apenas a sessão ativa, mantendo a retenção de concluídas (2 min)
+  e falhas (10 min).
+- **Guards de estado e navegação órfã:** transições prematuras para `done` são
+  bloqueadas e a navegação defensiva ignora alvos órfãos, evitando seleção
+  inválida no painel.
+- **Isolamento do board nos testes:** testes que importam o plugin real agora
+  isolam o BackgroundJobBoard, eliminando o fantasma "preserve this running
+  delegation"; o board real foi limpo.
+- **Lean no core:** 17 módulos mortos de `src/pantheon/` removidos, ~38% dos
+  arquivos de teste removidos/consolidados e docs/scripts órfãos limpos, com
+  testes mínimos readicionados para os módulos vivos (tool-ceiling, native-probe).
+- **Flake de TTL determinístico:** `test_ttl_expiry_real_time` deixou de competir
+  com a truncagem de microssegundos do SQLite — o teste agora espera o início de
+  um segundo limpo antes do store e usa margem sobre o TTL, eliminando o flake
+  dependente de carga (test-only).
+
 ## [v1.5.0-beta.14] - 2026-09-14
 
 <!-- Add new changes here. Running `node scripts/versioning.mjs apply` will

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.5.0-beta.14",
+  "version": "1.5.0-beta.15",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "type": "module",
   "publishConfig": {

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pantheon",
   "publisher": "ils15",
-  "version": "1.5.0-beta.14",
+  "version": "1.5.0-beta.15",
   "displayName": "Pantheon",
   "description": "Conductor-Delegate orchestration platform with 14 specialized agents, 21 skills, and OpenCode support.",
   "agents": "./src/agents",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.backends._legacy:_Backend"
 
 [project]
 name = "pantheon"
-version = "1.5.0-beta.14"
+version = "1.5.0-beta.15"
 description = "Multi-agent orchestration framework"
 requires-python = ">=3.11"
 dependencies = []
@@ -37,10 +37,8 @@ ignore = ["E501"]
 "scripts/scrub-secrets.py" = ["N999"]
 # These modules defer optional/heavy imports until the corresponding command is used.
 "scripts/vector_memory/*.py" = ["PLC0415"]
-"tests/test_code_mode_args.py" = ["PLC0415"]
 "tests/test_code_mode_sandbox.py" = ["PLC0415", "N806"]
 "tests/test_code_mode_server.py" = ["PLC0415"]
-"tests/test_eval_store.py" = ["PLC0415", "PLR2004"]
 "tests/test_memory_mcp_server.py" = ["PLC0415", "PLR2004"]
 # Existing public APIs and test fixtures are intentionally broad/simple; refactoring
 # them would be behavior-affecting rather than a mechanical lint correction.
@@ -54,8 +52,7 @@ ignore = ["E501"]
 "scripts/vector_memory/query.py" = ["PLR0913"]
 "src/mcp/eval_store.py" = ["PLR2004"]
 "tests/test_code_mode_frontmatter.py" = ["PLR2004"]
-"tests/test_eval_judge.py" = ["PLR2004"]
-"tests/test_eval_static.py" = ["PLR2004"]
+"tests/test_eval.py" = ["PLR2004"]
 "tests/test_mcp_persistence_server.py" = ["PLR2004"]
 
 [tool.mypy]

package/src/agents/zeus.md

@@ -301,32 +301,10 @@ vão a idle com todos incompletos. Guards (todos no `src/pantheon/todo-enforcer.
 
 ## Wave 4 (PR #46): Empty-Result Retry + /cost + Themis Tier
 
-### Empty-Result Retry (dispatch-guard — MANUAL orchestration)
-OpenCode 1.18.x NAO permite interceptar a conclusao de `task()` via hooks,
-entao o `src/pantheon/dispatch-guard.ts` e uma lib pura usada POR VOCE na
-orquestracao (NAO esta wired no plugin):
-
-```
-import { createDispatchGuard } from '.../src/pantheon/dispatch-guard.ts'  # via code-mode ou subagente
-
-guard = createDispatchGuard({ retryOnEmpty: true, logger: { warn: console.warn } })
-
-# classificar resultado de task_status/wait:
-#   'content'      → tem texto, pronto
-#   'empty-mode1'  → SEM texto E SEM tokens (nada voltou)      → RETRY 1x
-#   'empty-mode2'  → SEM texto, MAS tokens (raciocinou, perdeu a parte de texto;
-#                    assinatura da falha themis Wave-2)         → RETRY 1x
-
-out = await guard.maybeRetry(result, async () => { ...task() de novo... })
-# out.retried=true se redisparou; CAP DURO de 1 retry — nunca 2x.
-# Se o retry voltar vazio, `out.retried=false` — NAO tente de novo: escale.
-```
-Regra: retry 1x APENAS em `empty-mode1`/`empty-mode2`. Resultado com conteudo
-nunca redispara. Apos 1 retry vazio → escalate (mesma regra do TODO Enforcer).
-
-> **Waves DEVEM usar `zeusDelegateWithRetry`** (`src/pantheon/zeus-delegate-with-retry.ts`) — encapsula `delegate → waitForTerminal → classify → retry 1x → escalate` com cap duro 1; se ainda vazio throw `ZeusEscalationError` (escale: tente outro agente, simplifique, manual).
-> Uso alto-nível: `import { zeusDelegateWithRetry } from './pantheon/zeus-delegate-with-retry.ts'` → `await zeusDelegateWithRetry({ board, client, sessionID, agent, prompt })`.
-> Uso baixo-nível: `createZeusRetryHelper().executeWithRetry(first, () => secondRead())` — classifica empty e decide retry/escalate (mesmo cap 1).
+### Empty-Result Retry (runtime — automatic)
+Empty-response detection (`empty-mode1` / `empty-mode2`) and stuck-agent
+classification are wired at runtime in `delegation-classifier.ts` (consumed by
+`delegation.ts`). No manual retry helper is required.
 
 ### /cost — pantheon_cost tool (WIRED no plugin)
 `pantheon_cost({ days?: number })` le o `opencode.db` READ-ONLY usando o backend

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

@@ -2,7 +2,7 @@
  * Background Job Board — state machine for tracking background agent jobs.
  *
  * Tracks jobs through a state machine (running → completed/error/cancelled → reconciled),
- * supports alias generation per session, persistence via adapter, auto-wake signal files,
+ * supports alias generation per session, persistence via adapter, wake signal files,
  * and terminal state listeners (persist-before-notify write-ahead-log pattern).
  *
  * Pure TypeScript — zero external dependencies beyond Node.js builtins (fs/path).
@@ -123,7 +123,7 @@ export interface BoardOptions {
   /** Maximum completed jobs kept per agent for reuse (default: 3). */
   maxReusablePerAgent?: number
   /**
-   * Directory for auto-wake signal files.
+   * Directory for wake signal files.
    * When set, a `.signal.json` file is atomically written on every terminal transition.
    * When null or undefined, no signal files are written.
    */
@@ -175,7 +175,7 @@ function getAgentPrefix(agent: string): string {
  * - Strict state machine with validated transitions
  * - Per-session, per-agent alias generation (apo-1, her-2, …)
  * - Optional persistence via injected PersistenceAdapter
- * - Optional auto-wake signal files on terminal transitions
+ * - Optional wake signal files on terminal transitions
  * - Terminal state listeners with persist-before-notify guarantee
  * - expire/prune helpers for session lifecycle management
  */
@@ -652,7 +652,7 @@ export class BackgroundJobBoard {
   }
 
   /**
-   * Delete the auto-wake signal file for an alias (`<alias>.signal.json`).
+   * Delete the wake signal file for an alias (`<alias>.signal.json`).
    * No-op (false) when no signalDir is configured or the file is absent.
    * The delegate manager calls this on the spot right after auto-reconcile.
    */

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).