pantheon-opencode 1.3.7 → 1.4.1

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,20 +590,6 @@ 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'
-
 /**
  * Split a `provider/model` model ID (e.g. `opencode/deepseek-v4-flash-free`)
  * into the `{ id, providerID }` ref the session.create body expects.
@@ -617,12 +602,10 @@ function splitModelRef(model: string): ChildSessionModelRef | undefined {
 }
 
 /**
- * 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 only an explicitly supplied model. A routing profile's `model` is
+ * passed through as `options.agentModels`; profiles without one, and agents
+ * without a profile, intentionally resolve to undefined so the OpenCode
+ * parent session can provide inheritance.
  */
 function resolveChildModel(
   options: DelegationOptions,
@@ -641,43 +624,14 @@ function resolveChildModel(
     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}`)
-  }
   return 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 model 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 +641,15 @@ 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(
+    options.logger?.warn?.(
       `[pantheon-delegate] no model resolved for agent "${agent}" — ` +
-        "child session will use opencode's default model (may require API keys)",
+        'omitting model so OpenCode can inherit it from the parent session',
     )
     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 }
+  return { model, error: undefined }
 }
 
 // ─── Factory ───────────────────────────────────────────────────────────
@@ -900,13 +819,8 @@ 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.
+      // Only an explicit delegate model or routing profile model is sent.
+      // Otherwise omit it so OpenCode inherits the parent model.
       const resolved = resolveUsableChildModel(options, args.agent, args.model)
       if (resolved.error !== undefined) {
         if (budgetReserved && budgetKey !== undefined)

package/src/pantheon/presets.d.mts

@@ -86,13 +86,14 @@ export declare function loadPresetDefs(routingPath?: string): Record<string, Pre
 
 export interface RoutingAgentModelsOptions {
   routingPath?: string
+  candidates?: string[]
+  env?: Record<string, string | undefined>
   logger?: { warn?: (msg: string) => void }
 }
 
 /**
- * Lowercase agent → "provider/model" mapping from routing.yml's FIRST
- * (default) preset — the static source for the delegation toolset's
- * options.agentModels. Fail-open: missing/corrupt routing.yml → {}.
+ * Lowercase agent → "provider/model" mapping from the explicitly active
+ * routing profile. No active profile (or a profile without model) → {}.
  */
 export declare function loadRoutingAgentModels(
   options?: RoutingAgentModelsOptions,

package/src/pantheon/presets.mjs

@@ -345,46 +345,42 @@ export function loadRoutingPermissionTask({ routingPath, logger = console } = {}
 }
 
 /**
- * Load the DEFAULT agent → model mapping from routing.yml for the delegation
+ * Load the active routing profile's agent → model mapping for the delegation
  * toolset (Fase 6 — wiring agentModels).
  *
  * routing.yml keeps per-agent models ONLY inside presets
  * (`presets.<name>.agents.<agent>.model`) — the top-level `agents:` section
- * carries no model field. The FIRST-listed preset is the static default
- * (go-deepseek today): a mapping INDEPENDENT of the active preset, so a
- * delegated child always gets a sane per-agent model even when no preset is
- * active — delegation no longer depends 100% on the active preset (branch (b)
- * of resolveChildModel, which outranks the active-preset branch (c)).
+ * carries no model field. No profile means an empty mapping; there is no
+ * implicit first/default preset or fallback model.
  *
- * Fail-open: a missing or unparseable routing.yml yields {} (the caller keeps
- * the previous behavior — active preset / opencode default) and warns via the
+ * Fail-open: a missing or unparseable routing.yml yields {} and warns via the
  * optional logger; it NEVER throws at startup.
  *
  * @param {object} [opts]
  * @param {string} [opts.routingPath]
+ * @param {string[]} [opts.candidates]
+ * @param {Record<string, string|undefined>} [opts.env]
  * @param {{warn?: Function}} [opts.logger]
  * @returns {Record<string, string>} lowercase agent → "provider/model"
  */
-export function loadRoutingAgentModels({ routingPath, logger = console } = {}) {
-  let defs
+export function loadRoutingAgentModels({ routingPath, candidates, env, logger = console } = {}) {
   try {
-    defs = loadPresetDefs(routingPath)
+    const active = resolveActivePreset({ routingPath, candidates, env, logger })
+    if (active === null) return {}
+    const models = {}
+    for (const [agent, spec] of Object.entries(active.agents ?? {})) {
+      if (spec && typeof spec === 'object' && typeof spec.model === 'string' && spec.model !== '') {
+        models[agent.toLowerCase()] = spec.model
+      }
+    }
+    return models
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err)
     logger.warn?.(
-      `presets: routing.yml agent models unavailable (${reason}) — delegation falls back to the active preset/default`,
+      `presets: routing.yml active profile models unavailable (${reason}) — child model omitted`,
     )
     return {}
   }
-  const names = Object.keys(defs)
-  if (names.length === 0) return {}
-  const models = {}
-  for (const [agent, spec] of Object.entries(defs[names[0]]?.agents ?? {})) {
-    if (spec && typeof spec === 'object' && typeof spec.model === 'string' && spec.model !== '') {
-      models[agent.toLowerCase()] = spec.model
-    }
-  }
-  return models
 }
 
 /**

package/src/plugin.ts

@@ -1,9 +1,16 @@
-import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import type { PluginConfig } from 'opencode'
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
+import type { Plugin, PluginInput } from '@opencode-ai/plugin'
+import type { PluginConfig } from 'opencode'
 import { BackgroundJobBoard } from './pantheon/background-job-board.ts'
-import { reassertAfterCompaction } from './pantheon/compaction-assert.ts'
+import { createCommandNormalizer } from './pantheon/command-normalizer.ts'
+import {
+  type ContextSandboxConfig,
+  createContextSandbox,
+  resolveSandboxConfig,
+  DEFAULT_CONFIG as SANDBOX_DEFAULT_CONFIG,
+  DEFAULT_LIMITS as SANDBOX_DEFAULT_LIMITS,
+} from './pantheon/context-sandbox.ts'
 import { createCostCommand } from './pantheon/cost-command.ts'
 import {
   collectRootSessionIDs,
@@ -21,6 +28,7 @@ import {
   zeusReadGuard,
 } from './pantheon/delegation-enforce.ts'
 import { handleDelegationEvent } from './pantheon/delegation-notify.ts'
+import { showDelegationTerminalToast, type ToastClient } from './pantheon/delegation-toast.ts'
 import { FilePersistenceAdapter } from './pantheon/file-persistence.ts'
 import { GOAL_LOOP_DEFAULTS, GoalLoop, GoalStore } from './pantheon/goal-loop.ts'
 import { createReadEnhancer } from './pantheon/hashline/read-enhancer.ts'
@@ -54,17 +62,6 @@ import { activePresetCandidates, createVisionHandler } from './pantheon/vision.t
 // .pantheon/logs/hooks.log; the console echo is opt-in via PANTHEON_HOOKS_LOG=1.
 const log = createPantheonLogger({ module: 'pantheon-plugin' })
 
-// Fase 6 (release-134): the delegation toolset's options.agentModels (branch
-// (b) of resolveChildModel) is wired from routing.yml's default (first)
-// preset — a STATIC per-agent model mapping independent of the active preset,
-// so delegated children get a sane model even without an active preset (the
-// previous production wiring left branch (b) dead: delegation depended 100%
-// on the active preset). Built ONCE at module load, never per dispatch.
-// Fail-open: a missing/corrupt routing.yml yields {} (warned by the helper)
-// and delegation falls back to the active preset / opencode default — the
-// plugin never throws at startup.
-const routingAgentModels = loadRoutingAgentModels({ logger: log })
-
 // 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
@@ -82,6 +79,7 @@ const board = new BackgroundJobBoard({
 })
 const persistence = new FilePersistenceAdapter('.pantheon/board/state.json')
 board.setPersistence(persistence)
+let terminalToastClient: ToastClient = {}
 board
   .recoverRunningJobs()
   .catch((err) => log.error('[Pantheon Plugin] Failed to recover running jobs:', err))
@@ -100,6 +98,8 @@ board.onTerminal((taskID: string) => {
   log.info(
     `[Pantheon Plugin] Board terminal: [${job.alias}] ${job.description} → ${job.state}${job.resultSummary ? ` — ${job.resultSummary}` : ''}`,
   )
+  // Deliberately direct-to-TUI: onTerminal must not inject chat/transcript text.
+  void showDelegationTerminalToast(terminalToastClient, job)
 })
 
 // Periodically prune terminal/reconciled jobs (24h TTL, every 30 min).
@@ -131,6 +131,13 @@ const enforcementGuard = createEnforcementGuard({
   },
 })
 
+// Fase 1 (command-normalizer): deterministic `python` → `python3` rewrite for
+// `bash` commands (PEP 394 — Ubuntu 20.04+ has no bare `python`). Unlike the
+// enforcement guard above (which THROWS to deny), this guard REWRITES the
+// command in place and lets it run. Logs every rewrite + `python -c` warning
+// to the shared hooks.log for @nyx frequency measurement.
+const commandNormalizer = createCommandNormalizer({ logger: log })
+
 // Mirrors routing.yml background_delegation.max_compaction_items.
 const COMPACTION_MAX_ITEMS = 10
 
@@ -208,8 +215,7 @@ function adaptDelegationClient(client: PluginInput['client']): DelegationClient
           model?: { id: string; providerID: string }
         } = { parentID: input.body.parentID }
         if (input.body.title !== undefined) body.title = input.body.title
-        // Forward the routed child model (E2E fix): without it the child
-        // falls back to the key-gated default model and dies at startup.
+        // Forward a model only when the active routing profile supplied one.
         if (input.body.model !== undefined) body.model = input.body.model
         const result = await client.session.create({ body })
         if (result.error) throw new Error(sdkErrorMessage(result.error))
@@ -328,6 +334,7 @@ function adaptTodoEnforcerClient(client: PluginInput['client']): TodoEnforcerCli
  * Helpers live in src/pantheon/vision.ts and are imported from there directly.
  */
 const plugin: Plugin = async (input: PluginInput) => {
+  terminalToastClient = input.client as unknown as ToastClient
   // release-134: runtime guard against DOUBLE registration (duplicate toasts +
   // duplicate task_ids in one process — 2026-08-12 live logs). opencode
   // merges the global config (npm-package plugin paths) with the project
@@ -362,7 +369,12 @@ const plugin: Plugin = async (input: PluginInput) => {
       },
       enforceRuntimeMatrix: true,
       readOnlyAgents: new Set(['apollo', 'gaia']),
-      agentModels: routingAgentModels,
+      // Only an explicitly active routing profile may provide child models.
+      // An empty map deliberately lets OpenCode inherit the parent model.
+      agentModels: loadRoutingAgentModels({
+        candidates: activePresetCandidates(),
+        logger: log,
+      }),
       delegationBudgets,
       stepCapTracker,
       ...(routingPermissionTask != null ? { permissionTask: routingPermissionTask } : {}),
@@ -436,6 +448,24 @@ const plugin: Plugin = async (input: PluginInput) => {
   const hashlineEdit = createHashlineEditTool()
   const readEnhancer = createReadEnhancer()
 
+  // Context Window Optimization (v2 P0) — tool output sandboxing
+  // Pure truncation hook: read/grep/glob/webfetch → head + [TRUNCATED] + tail
+  // Fail-open: never throws, disabled via opencode.json context_sandbox.enabled
+  const sandboxConfig: ContextSandboxConfig = {
+    enabled: SANDBOX_DEFAULT_CONFIG.enabled,
+    limits: {
+      read: { ...SANDBOX_DEFAULT_LIMITS.read },
+      grep: { ...SANDBOX_DEFAULT_LIMITS.grep },
+      glob: { ...SANDBOX_DEFAULT_LIMITS.glob },
+      webfetch: { ...SANDBOX_DEFAULT_LIMITS.webfetch },
+    },
+  }
+  const sandboxHandler = createContextSandbox(sandboxConfig)
+  const combinedAfter: typeof readEnhancer = async (input, output) => {
+    await sandboxHandler(input, output)
+    await readEnhancer(input, output)
+  }
+
   // Wave 4 (PR #46): /cost — delegation cost + token visibility. Reads
   // opencode.db read-only (node:sqlite, falls back to scripts/cost.mjs).
   // Fully wired (unlike dispatch-guard, which is manual-orchestration-only
@@ -452,6 +482,15 @@ const plugin: Plugin = async (input: PluginInput) => {
       // WITHOUT a parentID is a root. Fail-open: a failed/throttled list
       // leaves the set untouched (delegation.ts treats unknown sessions as
       // roots), and config setup must never wait for the session API.
+      // Context sandbox config — opencode.json → context_sandbox: {enabled, limits}
+      try {
+        const raw = (config as unknown as Record<string, unknown>).context_sandbox
+        const resolved = resolveSandboxConfig(raw)
+        sandboxConfig.enabled = resolved.enabled
+        sandboxConfig.limits = resolved.limits
+      } catch {
+        // fail-open: keep defaults
+      }
       seedRootSessionsInBackground(input)
       config.agentsPath = config.agentsPath ?? []
       config.agentsPath.push(new URL('./agents', import.meta.url).pathname)
@@ -504,9 +543,7 @@ const plugin: Plugin = async (input: PluginInput) => {
     'chat.message': async (hookInput, output) => {
       await vision.chatMessage(hookInput, output)
       // No delegation notification delivery here — the user policy is ZERO
-      // notification text injected into the chat transcript (previously the
-      // notifier.flushQueue prepend). pantheon-hooks' chat-reminders.ts keeps
-      // its own <system-reminder> channel, untouched.
+      // notification text injected into the chat transcript.
       // Wave 1: a user message is activity — the todo enforcer's
       // user-activity gate skips injection for userActivityQuietMs afterwards.
       todoEnforcer.noteUserActivity(hookInput.sessionID)
@@ -531,17 +568,6 @@ const plugin: Plugin = async (input: PluginInput) => {
       // rewritten with the exact list (see todo-preserve.ts). Fail-open.
       if (ev.type === 'session.compacted') {
         await todoPreserver.onCompacted(ev.properties.sessionID)
-        // release-134 Phase 4: re-assert post-compaction state — enqueue a
-        // fresh-state reminder (running/unread board jobs + active goals) for
-        // the session's next chat.message delivery. Fail-open (never throws).
-        await reassertAfterCompaction({
-          sessionID: ev.properties.sessionID,
-          board,
-          goals: {
-            enabled: GOAL_LOOP_DEFAULTS.enabled,
-            list: (s: string) => goalStore.list(s),
-          },
-        })
       }
       // Phase 3: observe completion on child sessions → finalizeDelegation.
       // The board transition fires onTerminal → the file-only audit log (no
@@ -578,13 +604,16 @@ const plugin: Plugin = async (input: PluginInput) => {
       // no-ops for non-matching sessions/tools.
       zeusReadGuard(input.tool, output?.args, sessionAgents.get(input.sessionID))
       await enforcementGuard(input, output)
+      await commandNormalizer(input, output)
       await todoPreserver.beforeTodoWrite(input, output)
     },
-    // Wave 2 (PR #46): augment `read` output with hashline tags. Additive —
+    // Wave 2 (PR #46) + Context Sandbox (v2 P0): sandbox truncates oversized
+    // outputs BEFORE hashline tags (so tags remain stable on kept lines).
+    // Additive —
     // pantheon-hooks.ts (a separate plugin instance) owns its own
     // tool.execute.after, so there is no key collision. Non-read tools pass
     // through untouched.
-    'tool.execute.after': readEnhancer,
+    'tool.execute.after': combinedAfter,
     // Phase 4 + release-134 Phase 2: keep the session's working state across
     // compaction — preservation directive, active goals (<mission_context>),
     // pending todos (<todo_context>), and in-flight background delegations