pantheon-opencode 1.4.0 → 1.4.2

package/src/pantheon/delegation-finalize.ts

@@ -172,24 +172,48 @@ export const DELEGATION_DEFAULTS = {
 
 // ─── Output pulling ────────────────────────────────────────────────────
 
-/** Concatenate every non-empty text part across the child's messages. */
-async function pullOutput(client: DelegationClient, childSessionID: string): Promise<string> {
+interface PulledOutput {
+  text: string
+  /** True only when the child produced an assistant message or tool activity. */
+  hasWork: boolean
+}
+
+/** Pull visible text and structurally identify real child work. */
+async function pullOutput(client: DelegationClient, childSessionID: string): Promise<PulledOutput> {
   if (typeof client.session.messages !== 'function')
-    return '(child session messages API unavailable)'
+    return { text: '(child session messages API unavailable)', hasWork: false }
   try {
     const bundles = await client.session.messages({ path: { id: childSessionID } })
     const lines: string[] = []
+    let hasWork = false
     for (const bundle of bundles) {
+      const hasToolPart = (bundle.parts ?? []).some((part) => part.type === 'tool')
+      const hasTextPart = (bundle.parts ?? []).some(
+        (part) => part.type === 'text' && typeof part.text === 'string' && part.text.trim() !== '',
+      )
+      if (
+        bundle.info?.role === 'assistant' &&
+        bundle.info.error === undefined &&
+        (hasToolPart || hasTextPart)
+      ) {
+        hasWork = true
+      }
       for (const part of bundle.parts ?? []) {
+        if (
+          part.type === 'tool' &&
+          bundle.info?.role === 'assistant' &&
+          bundle.info.error === undefined
+        )
+          hasWork = true
         if (part.type === 'text' && typeof part.text === 'string' && part.text.trim() !== '') {
           lines.push(part.text)
         }
       }
     }
-    return lines.join('\n\n')
+    return { text: lines.join('\n\n'), hasWork }
   } catch (err: unknown) {
     const reason = err instanceof Error ? err.message : String(err)
-    return `(failed to pull child session output: ${reason})`
+    return { text: `(failed to pull child session output: ${reason})`, hasWork: false }
   }
 }
 
@@ -311,9 +335,18 @@ export async function finalizeDelegation(
   const job = deps.board.get(childSessionID)
   if (!job) return undefined
 
-  const output = await pullOutput(deps.client, childSessionID)
+  const pulled = await pullOutput(deps.client, childSessionID)
+  const output = pulled.text
+  const effectiveOpts: FinalizeInput =
+    opts.state === 'completed' && !pulled.hasWork
+      ? {
+          state: 'error',
+          error: opts.error ?? 'Child session produced no assistant or tool output',
+          ...(opts.timedOut !== undefined ? { timedOut: opts.timedOut } : {}),
+        }
+      : opts
   const outputDir = deps.options.outputDir ?? DELEGATION_DEFAULTS.outputDir
-  await writeDelegationReport(outputDir, job, renderDelegationMarkdown(job, output, opts))
+  await writeDelegationReport(outputDir, job, renderDelegationMarkdown(job, output, effectiveOpts))
 
   const status: {
     taskID: string
@@ -323,15 +356,15 @@ export async function finalizeDelegation(
     resultSummary?: string
   } = {
     taskID: childSessionID,
-    state: opts.state,
+    state: effectiveOpts.state,
     resultSummary: summarizeOutput(output),
   }
-  if (opts.error !== undefined) status.error = opts.error
-  if (opts.timedOut !== undefined) status.timedOut = opts.timedOut
+  if (effectiveOpts.error !== undefined) status.error = effectiveOpts.error
+  if (effectiveOpts.timedOut !== undefined) status.timedOut = effectiveOpts.timedOut
 
   const current = deps.board.get(childSessionID)
   if (current !== undefined) {
-    if (current.state === 'running' || current.state === opts.state) {
+    if (current.state === 'running' || current.state === effectiveOpts.state) {
       await deps.board.updateStatus(status)
     }
     // Terminal in a DIFFERENT state (e.g. timeout already recorded) — the

package/src/pantheon/delegation-toast.ts

@@ -0,0 +1,73 @@
+import type { BackgroundJobRecord } from './background-job-board.ts'
+
+type ToastCategory = 'errors' | 'delegations' | 'council'
+
+const toastMode = (process.env.PANTHEON_TOASTS ?? '').trim().toLowerCase()
+const enabledToastCategories: ReadonlySet<ToastCategory> = (() => {
+  switch (toastMode) {
+    case 'off':
+      return new Set()
+    case 'errors':
+      return new Set(['errors'])
+    case 'council':
+      return new Set(['errors', 'council'])
+    case 'all':
+      return new Set(['errors', 'delegations', 'council'])
+    default:
+      return new Set(['errors', 'delegations', 'council'])
+  }
+})()
+const terminalToastsShown = new Set<string>()
+const terminalStates = new Set(['completed', 'error', 'cancelled'])
+
+/** Match the lifecycle toast gate used by pantheon-hooks. */
+export function delegationToastEnabled(): boolean {
+  return enabledToastCategories.has('delegations')
+}
+
+export type ToastClient = {
+  tui?: {
+    showToast?: (input: {
+      body: {
+        title?: string
+        message: string
+        variant: 'info' | 'success' | 'warning' | 'error'
+        duration: number
+      }
+    }) => Promise<unknown>
+  }
+}
+
+/** Best-effort visual completion signal; never affects board finalization. */
+export async function showDelegationTerminalToast(
+  client: ToastClient,
+  job: Pick<BackgroundJobRecord, 'taskID' | 'alias' | 'agent' | 'state' | 'timedOut'>,
+): Promise<void> {
+  try {
+    if (!delegationToastEnabled()) return
+    const isTerminal = job.timedOut || terminalStates.has(job.state)
+    if (isTerminal) {
+      if (terminalToastsShown.has(job.taskID)) return
+      terminalToastsShown.add(job.taskID)
+    }
+    const showToast = client.tui?.showToast
+    if (typeof showToast !== 'function') return
+    const state = job.timedOut ? 'timeout' : job.state
+    const variant =
+      state === 'completed'
+        ? 'success'
+        : state === 'error' || state === 'timeout'
+          ? 'error'
+          : 'warning'
+    await showToast({
+      body: {
+        title: 'Delegação concluída',
+        message: `${job.alias} (${job.agent}) — ${state}`,
+        variant,
+        duration: 4000,
+      },
+    })
+  } catch {
+    // TUI is optional (and may disappear during shutdown); completion is durable.
+  }
+}

package/src/pantheon/delegation.ts

@@ -58,14 +58,9 @@ import {
   finalizeDelegation as finalizeDelegationReport,
   readDelegationReport,
 } from './delegation-finalize.ts'
-import {
-  type IdleChildScanDeps,
-  finalizeIdleChildrenWithoutMd,
-  startIdleChildScan,
-} from './delegation-notify.ts'
+import { finalizeIdleChildrenWithoutMd } from './delegation-notify.ts'
 import { createPantheonLogger } from './logger.ts'
 import { buildAgentListDescription } from './permission-globs.ts'
-import { missingProviderKeyEnv, resolveActivePreset } from './presets.mjs'
 import { buildStopInstruction, cappedSummary, DEFAULT_MAX_STEPS } from './step-cap.ts'
 
 export type {
@@ -217,8 +212,10 @@ async function bootstrapChild(
     const remainingMs = timeoutMs - (now() - startedAt)
     if (hasMessagesAPI) {
       try {
+        const messagesAPI = client.session.messages
+        if (messagesAPI === undefined) continue
         const messages = await boundedProbe(
-          client.session.messages!({ path: { id: childSessionID } }),
+          messagesAPI({ path: { id: childSessionID } }),
           remainingMs,
         )
         if (messages !== undefined) {
@@ -231,8 +228,10 @@ async function bootstrapChild(
     }
     if (hasStatusAPI) {
       try {
+        const statusAPI = client.session.get
+        if (statusAPI === undefined) continue
         const status = await boundedProbe(
-          client.session.get!({ path: { id: childSessionID } }),
+          statusAPI({ path: { id: childSessionID } }),
           timeoutMs - (now() - startedAt),
         )
         if (status !== undefined) {
@@ -591,93 +590,59 @@ export interface ChildSessionModelRef {
   providerID: string
 }
 
-/**
- * Known-good fallback model (P1, 2026-08-11 — release 1.3.4, updated
- * 2026-08-21 for sandbox without PANTHEON_OPENCODE_API_KEY): when an
- * AUTO-RESOLVED model (routing.yml agent entry / active preset) points at a
- * provider whose API key is not configured, the child is dispatched on the
- * `opencode-go` provider instead — `opencode-go/deepseek-v4-flash`
- * via https://opencode.ai/zen/go/v1 works without an external API key
- * (Go subscription / opencode auth, sandbox default). Validated with the
- * same providerKeyConfigured gate as the resolved model, with an
- * opencode-go exception for the sandbox; an explicit caller-supplied
- * `model` always wins over this fallback.
- */
-const FALLBACK_MODEL = 'opencode-go/deepseek-v4-flash'
+const MODEL_REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._:+-]*$/
+const MODEL_REF_HINT =
+  'Expected a non-empty "provider/model-id" reference with exactly one slash, no whitespace/control characters, backslashes, or path traversal. Remove the override or use that format.'
+
+type ModelOverrideSource = 'explicit' | 'agentModels'
+
+function invalidModelOverride(source: ModelOverrideSource): string {
+  return `pantheon_delegate rejected: invalid ${source} model override. ${MODEL_REF_HINT}`
+}
 
 /**
  * Split a `provider/model` model ID (e.g. `opencode/deepseek-v4-flash-free`)
  * into the `{ id, providerID }` ref the session.create body expects.
- * Returns undefined for malformed IDs (no slash, empty segments).
+ * Returns undefined for malformed or unsafe IDs.
  */
-function splitModelRef(model: string): ChildSessionModelRef | undefined {
+function splitModelRef(model: unknown): ChildSessionModelRef | undefined {
+  if (typeof model !== 'string' || !MODEL_REF_PATTERN.test(model)) return undefined
   const slash = model.indexOf('/')
-  if (slash <= 0 || slash === model.length - 1) return undefined
   return { providerID: model.slice(0, slash), id: model.slice(slash + 1) }
 }
 
 /**
- * Resolve the child session model with priority:
- *   1. explicit `model` option passed to the delegate tool;
- *   2. `options.agentModels[agent]` (routing.yml agent entry, case-insensitive);
- *   3. the active preset's agent entry via resolveActivePreset();
- *   4. fallback: undefined — the child is created without a model (the
- *      caller warns) so opencode's default applies.
+ * Resolve the child session model from explicit or agent-specific overrides.
+ * When neither override is present, return undefined so OpenCode can apply
+ * native model inheritance.
  */
 function resolveChildModel(
   options: DelegationOptions,
   agent: string,
   explicitModel?: string,
-): ChildSessionModelRef | undefined {
+): { model: ChildSessionModelRef | undefined; error: string | undefined } {
   // (a) explicit model option on the delegate tool call
-  if (explicitModel !== undefined && explicitModel !== '') {
+  if (explicitModel !== undefined) {
     const ref = splitModelRef(explicitModel)
-    if (ref !== undefined) return ref
+    if (ref !== undefined) return { model: ref, error: undefined }
+    return { model: undefined, error: invalidModelOverride('explicit') }
   }
   const key = agent.toLowerCase()
-  // (b) routing.yml agent entry wired through options.agentModels
+  // (b) agent-specific model override (routing.yml agent entry via agentModels)
   const mapped = options.agentModels?.[key]
-  if (mapped !== undefined && mapped !== '') {
+  if (mapped !== undefined) {
     const ref = splitModelRef(mapped)
-    if (ref !== undefined) return ref
-  }
-  // (c) active preset agent entry (resolveActivePreset reads routing.yml
-  // presets + .pantheon/active-preset.json). Guarded — a broken routing.yml
-  // must never kill the delegate.
-  try {
-    const presetModel = resolveActivePreset({
-      ...(options.presetEnv !== undefined ? { env: options.presetEnv } : {}),
-      ...(options.logger !== undefined ? { logger: options.logger } : {}),
-    })?.agents?.[key]?.model
-    if (presetModel !== undefined && presetModel !== '') {
-      const ref = splitModelRef(presetModel)
-      if (ref !== undefined) return ref
-    }
-  } catch (err: unknown) {
-    const reason = err instanceof Error ? err.message : String(err)
-    options.logger?.warn?.(`[pantheon-delegate] active preset resolution failed: ${reason}`)
+    if (ref !== undefined) return { model: ref, error: undefined }
+    return { model: undefined, error: invalidModelOverride('agentModels') }
   }
-  return undefined
+  return { model: undefined, error: undefined }
 }
 
 /**
- * Resolve a USABLE child model for a delegate dispatch, gating the resolved
- * provider's API key (P1, 2026-08-11 — release 1.3.4):
- *
- *   1. resolve the model with the existing precedence (explicit `model` >
- *      options.agentModels > active preset) — see resolveChildModel.
- *   2. provider key gate: the resolved provider requires its apiKeyEnv env
- *      var (routing.yml preset defs — same source applyPreset enforces at
- *      startup). No gate (native providers) or key present → usable as-is.
- *   3. key MISSING + EXPLICIT caller model → respected anyway (user intent),
- *      warned.
- *   4. key MISSING + AUTO-resolved model → fall back to FALLBACK_MODEL
- *      (validated the same way). Fallback also unusable → returns an `error`
- *      TEXT (the caller returns it from the tool — never throws) and the
- *      caller registers NO job on the board.
- *
- * The no-model case (nothing resolved) keeps the pre-existing behavior:
- * warn and let the child use opencode's default.
+ * Resolve a child model without selecting a provider or model on the caller's
+ * behalf. OpenCode owns native inheritance when this returns no model; if the
+ * host requires one, its session.create/promptAsync error is returned with
+ * the normal diagnostic rather than silently choosing a fallback.
  *
  * @returns `{ model, error }` — at most one of `model` / `error` is set;
  *   both may be unset (no model resolved, warn emitted).
@@ -687,50 +652,13 @@ function resolveUsableChildModel(
   agent: string,
   explicitModel: string | undefined,
 ): { model: ChildSessionModelRef | undefined; error: string | undefined } {
-  const env = options.presetEnv ?? process.env
-  const explicit = explicitModel !== undefined && explicitModel !== ''
-  const warn = (msg: string) => options.logger?.warn?.(msg)
-
-  const model = resolveChildModel(options, agent, explicitModel)
-  if (model === undefined) {
-    warn(
-      `[pantheon-delegate] no model resolved for agent "${agent}" — ` +
-        "child session will use opencode's default model (may require API keys)",
-    )
-    return { model: undefined, error: undefined }
-  }
-
-  const missingVar = missingProviderKeyEnv(model.providerID, { env })
-  if (missingVar === undefined) return { model, error: undefined }
-
-  if (explicit) {
-    // Rule of precedence: the caller's explicit model is respected — warn only.
-    warn(
-      `[pantheon-delegate] model "${explicitModel}" provider "${model.providerID}" requires ` +
-        `API key ${missingVar} (unset) — respecting the explicit model anyway`,
-    )
-    return { model, error: undefined }
-  }
-
-  // Auto-resolved (agentModels / preset) → try the known-good fallback.
-  const fallback = splitModelRef(FALLBACK_MODEL)
-  if (
-    fallback !== undefined &&
-    (fallback.providerID === 'opencode-go' ||
-      missingProviderKeyEnv(fallback.providerID, { env }) === undefined)
-  ) {
-    warn(
-      `[pantheon-delegate] provider "${model.providerID}" requires API key ${missingVar} ` +
-        `(unset) — falling back to ${FALLBACK_MODEL}`,
-    )
-    return { model: fallback, error: undefined }
-  }
-
-  const message =
-    `pantheon_delegate: no usable model for agent "${agent}" — provider "${model.providerID}" ` +
-    `requires API key (set ${missingVar} or PANTHEON_MODEL_PRESET)`
-  warn(`[pantheon-delegate] ${message}`)
-  return { model: undefined, error: message }
+  const resolved = resolveChildModel(options, agent, explicitModel)
+  if (resolved.error !== undefined || resolved.model !== undefined) return resolved
+  options.logger?.warn?.(
+    `[pantheon-delegate] no model resolved for agent "${agent}" — ` +
+      'omitting model so OpenCode can inherit it from the parent session',
+  )
+  return resolved
 }
 
 // ─── Factory ───────────────────────────────────────────────────────────
@@ -900,13 +828,9 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
       // session.create failure → return a clear error as TEXT (tools return
       // errors as text, not thrown) and register NO job on the board — an
       // unhandled rejection here would otherwise lose the failure entirely.
-      // The child model is resolved with a provider API-key gate (P1): the
-      // resolved model (explicit `model` > options.agentModels > active
-      // preset) is used when its provider key is configured; an explicit
-      // caller model is always respected (warned); an auto-resolved model
-      // whose provider key is missing falls back to the known-good
-      // opencode-go/deepseek-v4-flash; if nothing usable remains the
-      // failure is returned as TEXT below — no session, no board job.
+      // Resolution order: explicit delegate model > active-preset agent model
+      // > omit (native inheritance). small_model is never used for delegated
+      // children.
       const resolved = resolveUsableChildModel(options, args.agent, args.model)
       if (resolved.error !== undefined) {
         if (budgetReserved && budgetKey !== undefined)