pantheon-opencode 1.4.2 → 1.4.3

package/README.md

@@ -218,113 +218,28 @@ incompatible schema.
 
 ### Background Delegation
 
-Zeus (and other root sessions) can dispatch agents as **background child sessions**
-via three delegation tools, tracked on a persistent job board
-(`.pantheon/board/state.json`, 24h TTL) with reports written to
-`.pantheon/delegations/<parent>/<alias>.md`:
-
-| Tool | Signature | Behavior |
-|------|-----------|----------|
-| `pantheon_delegate` | `{prompt, agent, description?, read_only?, model?}` | Creates a child session (parentID = caller), registers it on the job board, arms a 15-minute timeout, and sends `promptAsync` to the child. `model` is optional and uses `provider/model-id`. Returns the readable alias (e.g. `apo-1`). Only root sessions may delegate (sub-sessions are rejected by the depth guard). |
-| `pantheon_delegation_read` | `{id}` | Blocks (`waitForTerminal`, up to 15 min) until the delegation reaches a terminal state, returns the report markdown, and marks the job reconciled. Resolves by alias or task ID. |
-| `pantheon_delegation_list` | `{}` | Lists the current session's delegations with `[unread]` on finished, unreconciled jobs. |
-
-**Agent activity visibility.** While `pantheon_delegation_read` blocks on a
-running job, it samples the child session's messages every ~2s and appends the
-collected lines to the report as a trailing `## Agent Activity` section (latest
-tool calls with truncated args, or user/assistant text, capped at ~200 chars per
-line) — so you can see what the agent is doing during the wait. Likewise,
-`pantheon_delegation_list` shows a `last activity:` line for running jobs.
-Fail-open: if the child session messages are unavailable (or empty), the read
-returns the report exactly as before — the activity sampling never breaks the
-delegation read.
+Zeus (and other root sessions) dispatch agents as **background child sessions**
+via OpenCode's native `task(background=true, ...)` API. The plugin layer keeps a
+persistent job board (`BackgroundJobBoard`, `.pantheon/board/state.json`, 24h
+TTL) that tracks in-flight work and carries it forward across context
+compaction, so a compacted session does not lose track of running delegations.
+
+The plugin no longer ships a delegate toolset (`pantheon_delegate`,
+`pantheon_delegation_read`, `pantheon_delegation_list` were removed in 1.4.3).
+Dispatch and result collection use the native `task()` / `task_status()` API.
 
 **Completion visibility — zero chat noise.** Delegation notifications are never
 injected into the chat transcript: neither `chat.message` nor any other chat
 hook or transcript marker is used as a delivery channel. When a job reaches a
-terminal state (completion observed via `session.idle`/`session.error` on the
-child, or the timeout finalize path), the plugin writes a file-only audit log
-line (echo opt-in via `PANTHEON_HOOKS_LOG`). Completion visibility lives in the
-legitimate channels: the board `[unread]` marker
-(`pantheon_delegation_list`), `pantheon_delegation_read`, TUI toasts
-(`PANTHEON_TOASTS` gate), and compaction carry-forward. Reconcile is an
-acknowledgment, not a completion — it never re-fires the terminal transition.
+terminal state, the plugin writes a file-only audit log line (echo opt-in via
+`PANTHEON_HOOKS_LOG`). Completion visibility lives in the legitimate channels:
+the board `[unread]` marker, TUI toasts (`PANTHEON_TOASTS` gate), and compaction
+carry-forward. Reconcile is an acknowledgment, not a completion — it never
+re-fires the terminal transition.
 
 **Timeout:** `background_delegation.timeout_ms` (default `900000` = 15 min). A job
 that has not reached a terminal state is finalized as `error`/`timedOut`.
 
-**Runtime delegation environment variables:**
-
-| Variable | Default | Scope and behavior |
-|---|---:|---|
-| `PANTHEON_ATHENA_APOLLO_BUDGET` | `5` dispatches | In-memory per `createDelegationTools()` factory/process instance and parent session, for the `athena → apollo` read-only exception. |
-| `PANTHEON_HERMES_APOLLO_BUDGET` | `5` dispatches | In-memory per `createDelegationTools()` factory/process instance and parent session, for the `hermes → apollo` read-only exception. |
-| `PANTHEON_DELEGATION_TIMEOUT_MS` | `900000` ms (15 min) | Per delegated child wall-clock timeout. The value is read when the plugin factory is created; unset or invalid values use the default. |
-
-Budgets are reserved before asynchronous child-session creation, so real
-concurrent calls cannot overshoot them. They reset when the factory/process
-restarts. If `ToolContext.agent` is missing, the default runtime matrix rejects
-the delegation (fail-closed); no caller identity or budget is inferred from the
-target, prompt, or session state. An explicitly legacy host using
-`enforceRuntimeMatrix: false` skips the budget because the caller cannot be
-identified and emits a warning. These budgets are separate from
-`background_delegation.max_concurrent_per_agent`: concurrency limits the number
-of currently running children, while an exception budget limits total dispatch
-reservations for that parent session during the factory lifetime.
-
-**Read-only enforcement:** delegating with `read_only: true`, or delegating to an
-agent in `background_delegation.read_only_agents` (`apollo`, `gaia`), registers
-the child session as read-only — the `tool.execute.before` guard denies
-`edit`/`write`/`bash`/`task` inside that session.
-
-**Delegated model resolution:** the optional child model is resolved in this
-order: (1) explicit `model` on `pantheon_delegate`; (2) the target agent's
-model in the active preset; (3) the current model of the parent session; (4)
-no model, allowing OpenCode's native inheritance. `small_model` is never used
-for delegates. When a model resolves, the same `provider/model-id` is sent as
-`{providerID, id}` to both `session.create` and `promptAsync`, including the
-single safe bootstrap retry; the retry does not select a different model. If
-the resolution lookup yields no model, the model field is omitted and the
-delegation continues with native inheritance.
-
-Model availability is not inferred from the string. The provider must exist in
-OpenCode and the referenced model must be available through that provider's
-account, subscription, or configured endpoint; otherwise the child host may
-reject startup. An active preset supplies provider configuration and model
-mappings, but does not make an unavailable provider or model available.
-
-**R1 — Per-error-type retry + provider cooldown (LiteLLM pattern):**
-`retry_policy` in `src/routing.yml` maps an error class (`auth`, `rate_limit`,
-`timeout`, `other`) to max retries before escalating — `auth` is never retried
-(0), `rate_limit` gets 3, `timeout` 2, `other` 1. Retries use exponential
-backoff (base 1s, doubling, capped 30s). `cooldown` (`allowed_fails`,
-`cooldown_time_seconds`) skips a provider for the configured window after that
-many consecutive failures; a success resets the counter. Enforcement lives in
-`RetryPolicyEngine` (`src/pantheon/retry-policy.ts`) and the R1 path of
-`zeusDelegateWithRetry` (`src/pantheon/zeus-delegate-with-retry.ts`) — pass
-`retryPolicy`/`cooldown`/`provider` to `createZeusRetryHelper`. In-memory only
-(no Redis).
-
-**R4 — Per-agent step caps:** `agents.<name>.max_steps` in `src/routing.yml`
-gives each agent a step budget (e.g. `apollo: 25`, `themis: 25`, `athena: 15`).
-When an agent reaches `max_steps` it is forced to summarize-and-stop: a
-delegation to an already-capped agent is skipped with a `[STEP CAP REACHED]`
-summary (no child session created), and a dispatch that hits the cap appends a
-stop instruction to the prompt. Enforcement: `StepCapTracker`
-(`src/pantheon/step-cap.ts`) wired into `pantheon_delegate`. The tracker is
-**permanent-per-process** — counters accumulate for the process lifetime and
-are intentionally not reset on success/session end (a per-session reset would
-let an agent exceed its process budget).
-
-**O5 — Permission globs for delegation:** `permission.task` in `src/routing.yml`
-controls which subagents an agent may invoke via glob patterns (last matching
-rule wins). A deny removes the agent from the delegate tool description
-entirely (not just blocks the call) — preventing circular delegation at the
-permission layer. Default `"*": allow` keeps the existing runtime matrix
-(zeus → anyone; athena/hermes → apollo only). Enforcement:
-`src/pantheon/permission-globs.ts` + the `permissionTask` option on
-`createDelegationTools` / `createEnforcementGuard`.
-
 **Compaction carry-forward:** during context compaction, running and unread
 terminal delegations (capped at `background_delegation.max_compaction_items`,
 default 10) are carried into the compacted context so the parent doesn't lose
@@ -353,8 +268,7 @@ logged warn and pass-through.
 
 **Post-compaction state re-assertion (1.3.4):** on `session.compacted`, fresh
 state — running/unread delegations from the board + active goals, capped at 10
-lines — remains available through compaction carry-forward and the board
-(`pantheon_delegation_list` / `pantheon_delegation_read`). A session with
+lines — remains available through compaction carry-forward. A session with
 nothing to assert is a silent skip; no chat transcript injection is performed.
 
 **Preemptive compaction check (1.3.4):** a pure threshold core
@@ -378,8 +292,8 @@ omits the child model.
 **Delegation log hygiene (1.3.4):** `delegations.log` now records the real
 `task_id` (omitted when empty, never `""`) and a **numeric** `duration_ms`
 (null when unset) so downstream aggregation works. Terminal events are
-file-only audit entries; completion is surfaced by TUI toast (when enabled),
-the board, and the list/read tools — never by chat delivery.
+file-only audit entries; completion is surfaced by TUI toast (when enabled)
+and the board — never by chat delivery.
 
 **Env vars & config:**
 
@@ -387,14 +301,13 @@ the board, and the list/read tools — never by chat delivery.
 - `PANTHEON_TOASTS` — TUI toast gate for the delegation lifecycle signals.
   Default `{errors, delegations, council}`; `PANTHEON_TOASTS=off` disables all
   TUI toasts (delegation signals then only surface via the board `[unread]`
-  marker, `pantheon_delegation_read` and the on-disk audit log — never via
-  chat.message injection from the plugin).
+  marker and the on-disk audit log — never via chat.message injection from the
+  plugin).
 - `background_delegation` section in `src/routing.yml` — `timeout_ms`,
-  `poll_ms`, `max_compaction_items`, `prune_ttl_ms`, `read_only_agents`,
-  `session_max`, `retry_count`.
+  `poll_ms`, `max_compaction_items`, `prune_ttl_ms`, `session_max`,
+  `retry_count`.
 
-See `src/agents/zeus.md` for the agent-facing delegation protocol and
-`src/pantheon/delegation.ts` for the tool implementations.
+See `src/agents/zeus.md` for the agent-facing delegation protocol.
 
 ### Real-time Delegations panel (1.3.4)
 
@@ -402,7 +315,7 @@ The TUI sidebar ships a live **Delegations** panel (open by default, above the
 collapsed Sessions list). Its primary source is `api.client.session.children`,
 so it shows **both** kinds of background work in one place:
 
-- **`pantheon_delegate` children** — rendered with their board alias tag
+- **Board-tracked children** — rendered with their board alias tag
   (`[apo-1]`) and enriched from the `.pantheon/delegations/` report.
 - **Native `task()` children** — rendered with a distinct `[task]` tag (info
   color) when no board report exists for the session.
@@ -674,7 +587,7 @@ and is pinned to concrete `provider/model` IDs in [src/routing.yml](src/routing.
 The abstract tiers above are pinned to concrete `provider/model` IDs by **4 built-in model presets**.
 Cada preset mapeia os 14 agentes para um modelo específico + `reasoning_effort` por papel (planners/reviewers, implementers, scouts).
 
-> **Default = herdar do chat (sem `active-preset.json`)** — sem preset ativo, os delegates **herdam nativamente** o modelo do chat pai ([herança nativa](src/pantheon/delegation.ts)). O instalador **não grava** `active-preset.json` quando você escolhe `0`/`inherit` no wizard (ou não seleciona preset via `--preset`). A resolução do modelo delegado segue: `explicit model` em `pantheon_delegate` > modelo do agente-alvo no preset ativo > modelo atual da sessão pai > herança nativa (sem `model`, sem `small_model`). `small_model` nunca é usado para delegates.
+> **Default = herdar do chat (sem `active-preset.json`)** — sem preset ativo, os delegates **herdam nativamente** o modelo do chat pai. O instalador **não grava** `active-preset.json` quando você escolhe `0`/`inherit` no wizard (ou não seleciona preset via `--preset`). A resolução do modelo delegado segue: modelo do agente-alvo no preset ativo > modelo atual da sessão pai > herança nativa (sem `model`, sem `small_model`). `small_model` nunca é usado para delegates.
 
 Tabelas abaixo são **geradas a partir de [src/routing.yml](src/routing.yml)** — rode `node scripts/generate-preset-docs.mjs` para regenerar. Nenhum segredo é hardcoded: apenas nomes de env vars (`PANTHEON_OPENCODE_API_KEY`, `OPENAI_API_KEY`) e `baseURL`s.
 
@@ -1141,16 +1054,15 @@ Use the isolated sandbox (`~/pantheon-sandbox/`) — **never** the dev environme
 **Happy path (clean edit):** any normal tool call (exit 0) is **silent** — no console output by design, even though the audit hooks append their log files (`sessions.log`, `delegations.log`). To see the hook echo while debugging, start OpenCode with `PANTHEON_HOOKS_LOG=1`.
 
 **Delegation path (zero chat noise):** delegation signals are surfaced through
-TUI toasts (when enabled), the board's `[unread]` marker, and the
-`pantheon_delegation_list` / `pantheon_delegation_read` tools. Ask something
+TUI toasts (when enabled) and the board's `[unread]` marker. Ask something
 that dispatches subagents (e.g. *"dispare 2 subagentes apollo em paralelo para
 listar arquivos e comparar resultados"*) and expect:
 
 - A TUI toast with `🚀 apollo em execução` / `✅ apollo concluiu` when
   `PANTHEON_TOASTS` permits it
-- `[unread]` in `pantheon_delegation_list` until the terminal result is read
+- `[unread]` on the board until the terminal result is read
 - An honest append to `logs/agent-sessions/delegations.log`: the **real agent name** (extracted from `tool_input.subagent_type`, never `unknown` when present) and a **non-fabricated status** — `success` only on explicit completion evidence, `failure` for refusals/errors, `unknown` otherwise
-- With `export PANTHEON_TOASTS=off` before starting OpenCode: no toasts; board/list/read and audit-log visibility remain available
+- With `export PANTHEON_TOASTS=off` before starting OpenCode: no toasts; board and audit-log visibility remain available
 
 ### Pre-commit hooks (local secret gate)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",

package/src/agents/zeus.md

@@ -144,33 +144,23 @@ task_status(task_id="ses_xxx", wait=true)
   -> bloqueia ate completar: { state: "completed", task_result: "..." }
 ```
 
-### Pantheon Delegation Tools (plugin) — 3-tool API
+### Pantheon Delegation — BackgroundJobBoard (plugin)
 
-O plugin Pantheon adiciona 3 tools de delegacao gerenciada pelo BackgroundJobBoard:
+O plugin Pantheon mantém um **BackgroundJobBoard** persistente
+(`.pantheon/board/state.json`) que rastreia trabalho em voo e o carrega para o
+contexto de compactação. O toolset de delegação do plugin
+(`pantheon_delegate`, `pantheon_delegation_read`, `pantheon_delegation_list`)
+foi **removido em 1.4.3** — dispatch e coleta usam a API nativa
+`task(background=true)` / `task_status(wait=true)`.
 
-```
-pantheon_delegate({prompt, agent, description?, read_only?})
-  -> cria sessao filha, registra no board, retorna alias: [apo-1]
-pantheon_delegation_read({id: "apo-1"})
-  -> BLOQUEIA ate o job terminar, retorna o report markdown, marca reconciled
-  -> durante a espera, mostra o que o agente esta fazendo: seccao final "## Agent Activity"
-     (amostra as messages do child a cada ~2s; tool calls + args truncados / texto)
-pantheon_delegation_list()
-  -> lista jobs da sessao, com [unread] para jobs terminados nao lidos
-  -> jobs RUNNING mostram "last activity:" (ultima acao visivel do child)
-  -> fail-open: sem suporte a messages, formato atual inalterado
-```
-
-- **Read-only enforcement:** agentes read-only (apollo, gaia — `read_only_agents` no routing.yml) tem `edit`, `write`, `bash`, `task` NEGADOS dentro da sessao delegada (o guard de `tool.execute.before` THROW com mensagem acionavel). Use `read_only: true` no delegate para qualquer agente de investigacao.
-- **Depth-2 hard-enforced:** sessao read-only NAO cria subagentes (`task` bloqueado) — investigacao nunca vira arvore.
 - **Compactacao:** jobs em voo (running + unread terminal) sao injetados no contexto de compactacao via `experimental.session.compacting` — delegacao em andamento nao se perde ao compactar.
 
-### DELEGATION_RULES (plugin path)
+### DELEGATION_RULES (native task path)
 
-1. **NUNCA** polle `pantheon_delegation_list` para checar se um job terminou.
-2. Voce NAO recebe notificacao injetada no chat — politica do usuario: ZERO `task-notification` no transcript. Visibilidade de conclusao: marcador `[unread]` em `pantheon_delegation_list`, `pantheon_delegation_read({id})`, toasts TUI (pantheon-hooks) e carry-forward de compactacao.
-3. Use `pantheon_delegation_read({id})` APENAS para fan-in explicito / recuperacao de resultado sob demanda (bloqueia ate o fim).
-4. `pantheon_delegation_list` e para diagnostico, nao para polling.
+1. **NUNCA** polle `task_status` para checar se um job terminou — use `wait=true` para fan-in explicito.
+2. Voce NAO recebe notificacao injetada no chat — politica do usuario: ZERO `task-notification` no transcript. Visibilidade de conclusao: marcador `[unread]` no board, toasts TUI (pantheon-hooks) e carry-forward de compactacao.
+3. Use `task_status({task_id, wait: true})` APENAS para fan-in explicito / recuperacao de resultado sob demanda (bloqueia ate o fim).
+4. `task_status` sem `wait` e para diagnostico, nao para polling.
 
 ### Background (sempre usar)
 - **Apollo, Hermes, Aphrodite, Demeter, Hephaestus, Prometheus**
@@ -324,9 +314,8 @@ out = await guard.maybeRetry(result, async () => { ...task() de novo... })
 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).
+> **Waves DEVEM usar `dispatch-guard`** (`src/pantheon/dispatch-guard.ts`) — encapsula `task → classify → retry 1x → escalate` com cap duro 1; se ainda vazio throw `ZeusEscalationError` (escale: tente outro agente, simplifique, manual).
+> Uso alto-nível: `import { createDispatchGuard } from './pantheon/dispatch-guard.ts'` → `await guard.maybeRetry(result, () => task(...))`.
 
 ### /cost — pantheon_cost tool (WIRED no plugin)
 `pantheon_cost({ days?: number })` le o `opencode.db` READ-ONLY (node:sqlite;

package/src/pantheon/cost-command.ts

@@ -1,6 +1,6 @@
 /**
  * Cost Command (Wave 4, PR #46) — `pantheon_cost` structural tool: cost +
- * token visibility for delegation traffic, straight from opencode.db.
+ * token visibility by agent, straight from opencode.db.
  *
  * Reads the opencode session database READ-ONLY (sum cost + tokens by
  * agent over the last N days → markdown table). Zero new dependencies:
@@ -13,8 +13,8 @@
  * dbPath resolution: explicit option > env PANTHEON_COST_DB > the version-aware
  * default selected by PANTHEON_OPENCODE_VERSION (v1 or v2). An unset version
  * deliberately preserves V1 behavior. The tool is wired in
- * plugin.ts alongside the delegation toolset (usable by zeus and any agent
- * with tool access — no routing change needed).
+ * plugin.ts (usable by zeus and any agent with tool access — no routing change
+ * needed).
  *
  * @module cost-command
  */
@@ -25,7 +25,7 @@ import { join } from 'node:path'
 import { promisify } from 'node:util'
 import { z } from 'zod'
 
-import type { ToolContextLike } from './delegation.ts'
+import type { ToolContextLike } from './tool-context.ts'
 
 const execFileAsync = promisify(execFile)
 
@@ -44,7 +44,7 @@ export interface CostCommandOptions {
 
 export type OpenCodeVersion = 'v1' | 'v2'
 
-/** One cost tool: description + zod args shape + execute (delegation.ts shape). */
+/** One cost tool: description + zod args shape + execute. */
 export interface CostTool<Args extends z.ZodRawShape = typeof costArgs> {
   description: string
   args: Args
@@ -62,7 +62,7 @@ const costArgs = {
     .min(1)
     .max(365)
     .optional()
-    .describe('Number of days of delegation history to include (default 7).'),
+    .describe('Number of days of cost history to include (default 7).'),
 } satisfies z.ZodRawShape
 
 /** Return the safe, isolated state DB name for an OpenCode version. */
@@ -239,7 +239,7 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
   return {
     pantheon_cost: {
       description:
-        'Report delegation cost + token usage by agent over the last N days, read from opencode.db (read-only, no writes).',
+        'Report cost + token usage by agent over the last N days, read from opencode.db (read-only, no writes).',
       args: costArgs,
       execute,
     },

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 (advisory `read_only: true` on the native
+ * `task` delegate, 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
@@ -18,11 +18,11 @@
  *   - `task` is blocked too, which hard-enforces depth-2: a read-only agent
  *     cannot spawn its own subagents.
  *
- * Unknown sessions are allowed for ordinary tools. Delegation tools are
- * fail-closed when the runtime matrix is wired: missing agent identity or
+ * Unknown sessions are allowed for ordinary tools. The runtime matrix is
+ * fail-closed when wired: missing agent identity or
  * target metadata is denied rather than inferred.
  *
- * The registry is populated by delegation.ts at delegate time: the CHILD
+ * The registry is populated at delegate time: the CHILD
  * session is registered when the delegate call is read-only.
  *
  * @module delegation-enforce
@@ -147,7 +147,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,7 +235,7 @@ export function zeusReadGuard(tool: string, args: unknown, agent: string | undef
 // ─── Registry ──────────────────────────────────────────────────────────
 
 /**
- * Read-only session registry. `createDelegationTools` registers child
+ * Read-only session registry. The plugin's delegate wiring registers child
  * sessions here; the plugin's `tool.execute.before` guard consults it.
  * Process-wide singleton for plugin wiring + factory for test isolation.
  */
@@ -291,19 +290,19 @@ 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 ?? '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 native task() delegate has the authoritative ToolContext.agent at
+    // execution time, so its matrix check lives in dispatch-guard.ts. The hook
+    // only has the session-scoped agent learned from chat.params.
     if (
       hook.tool === 'task' &&
       input.options?.isRootSession !== undefined &&
@@ -336,7 +335,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 the native task() tool 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.
@@ -103,7 +103,7 @@ const goalUpdateArgs = {
 
 const goalGetArgs = {} satisfies z.ZodRawShape
 
-/** One structural goal tool: description + zod args shape + execute (delegation.ts shape). */
+/** One structural goal tool: description + zod args shape + execute. */
 export type GoalTool<Args extends z.ZodRawShape> = {
   description: string
   args: Args

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 './tool-context.ts'
 
 export type GoalStatus = 'pending' | 'in_progress' | 'done'
 

package/src/pantheon/hashline/tool.ts

@@ -2,8 +2,8 @@
  * Hashline edit tool (Wave 2, PR #46) — structural `hashline_edit` tool that
  * anchors edits to stable sha256 content tags instead of fragile line numbers.
  *
- * Tool shape matches the delegation tools (`{description, args, execute}`,
- * zod-validated — same import pattern as delegation.ts).
+ * Tool shape follows the plugin tool convention (`{description, args, execute}`,
+ * zod-validated) used across the Pantheon toolset.
  *
  * Safety model (council-approved):
  *   1. ALL refs are validated against the ORIGINAL file snapshot BEFORE any