pantheon-opencode 1.3.6 → 1.4.0

package/src/pantheon/context-sandbox.ts

@@ -0,0 +1,273 @@
+/**
+ * Tool Output Sandboxing — Context Window Optimization (v2 P0)
+ *
+ * Truncates oversized tool outputs before they flood the context window.
+ * Pure truncation with metadata — no tiktoken, no LLM summarization (YAGNI).
+ *
+ * Hook: tool.execute.after — intercepts read/grep/glob/webfetch outputs.
+ *
+ * @module pantheon/context-sandbox
+ */
+
+export interface ToolExecuteAfterInput {
+  tool: string
+  sessionID: string
+  callID: string
+  args?: unknown
+}
+
+export interface ToolExecuteAfterOutput {
+  title?: string
+  output: string
+  metadata?: Record<string, unknown>
+}
+
+export type ToolExecuteAfterHandler = (
+  input: ToolExecuteAfterInput,
+  output: ToolExecuteAfterOutput,
+) => Promise<void>
+
+export interface SandboxToolLimits {
+  read: { maxLines: number; keepHead: number; keepTail: number }
+  grep: { maxResults: number; keepTop: number }
+  glob: { maxFiles: number; keepTop: number }
+  webfetch: { maxChars: number; keepHead: number }
+}
+
+export interface ContextSandboxConfig {
+  enabled: boolean
+  limits: SandboxToolLimits
+}
+
+/** Default limits — sensatos, cobrem 80% do problema com ~30 LOC. */
+export const DEFAULT_LIMITS: SandboxToolLimits = {
+  read: { maxLines: 200, keepHead: 50, keepTail: 10 },
+  grep: { maxResults: 20, keepTop: 10 },
+  glob: { maxFiles: 50, keepTop: 20 },
+  webfetch: { maxChars: 5000, keepHead: 2000 },
+}
+
+export const DEFAULT_CONFIG: ContextSandboxConfig = {
+  enabled: true,
+  limits: DEFAULT_LIMITS,
+}
+
+// ─── Pure sandbox functions ──────────────────────────────────────────────
+
+/**
+ * Sandbox truncation for `read` tool output.
+ * Input is expected to be line-numbered read output (e.g. "1: foo").
+ * If lines > maxLines, keep head + marker + tail.
+ */
+export function sandboxRead(output: string, limits = DEFAULT_LIMITS.read): string {
+  const lines = output.split('\n')
+  // trailing empty after final newline is not a real line — drop it for counting
+  const effectiveCount =
+    lines.length > 0 && lines[lines.length - 1] === '' ? lines.length - 1 : lines.length
+  if (effectiveCount <= limits.maxLines) return output
+
+  const head = lines.slice(0, limits.keepHead)
+  const tail =
+    limits.keepTail > 0
+      ? lines.slice(Math.max(limits.keepHead, effectiveCount - limits.keepTail), effectiveCount)
+      : []
+  const hidden = effectiveCount - head.length - tail.length
+  const marker = `[TRUNCATED: ${hidden} lines hidden — showing ${head.length} head + ${tail.length} tail of ${effectiveCount} total lines]`
+
+  // Preserve trailing newline semantics of original if present
+  const hadTrailingNewline = output.endsWith('\n')
+  const parts = [...head, marker, ...tail]
+  let result = parts.join('\n')
+  if (hadTrailingNewline) result += '\n'
+  return result
+}
+
+/**
+ * Sandbox truncation for `grep` tool output.
+ * Each non-empty line is considered a match. Keeps top N, drops tail.
+ */
+export function sandboxGrep(output: string, limits = DEFAULT_LIMITS.grep): string {
+  const lines = output.split('\n')
+  const effectiveCount =
+    lines.length > 0 && lines[lines.length - 1] === '' ? lines.length - 1 : lines.length
+  // Count non-empty? spec says 20 results — treat every line as result for simplicity,
+  // but filter obvious empties: if effective count includes empty trailing, already handled.
+  // Use effectiveCount as result count.
+  if (effectiveCount <= limits.maxResults) return output
+
+  const head = lines.slice(0, limits.keepTop)
+  const hidden = effectiveCount - head.length
+  const marker = `[TRUNCATED: Showing ${head.length} of ${effectiveCount} matches — ${hidden} more hidden. Use more specific pattern.]`
+  const hadTrailingNewline = output.endsWith('\n')
+  let result = [...head, marker].join('\n')
+  if (hadTrailingNewline) result += '\n'
+  return result
+}
+
+/**
+ * Sandbox truncation for `glob` tool output.
+ * Each line is a file path. Keeps top N.
+ */
+export function sandboxGlob(output: string, limits = DEFAULT_LIMITS.glob): string {
+  const lines = output.split('\n')
+  const effectiveCount =
+    lines.length > 0 && lines[lines.length - 1] === '' ? lines.length - 1 : lines.length
+  if (effectiveCount <= limits.maxFiles) return output
+
+  const head = lines.slice(0, limits.keepTop)
+  const hidden = effectiveCount - head.length
+  const marker = `[TRUNCATED: showing ${head.length} of ${effectiveCount} files — ${hidden} more hidden]`
+  const hadTrailingNewline = output.endsWith('\n')
+  let result = [...head, marker].join('\n')
+  if (hadTrailingNewline) result += '\n'
+  return result
+}
+
+/**
+ * Sandbox truncation for `webfetch` tool output.
+ * Character-based: keep head chars, drop rest.
+ */
+export function sandboxWebfetch(output: string, limits = DEFAULT_LIMITS.webfetch): string {
+  if (output.length <= limits.maxChars) return output
+  const head = output.slice(0, limits.keepHead)
+  const hidden = output.length - head.length
+  const marker = `\n[TRUNCATED: Content truncated — showing first ${head.length} of ${output.length} chars, ${hidden} chars hidden]\n`
+  return head + marker
+}
+
+/**
+ * Dispatch sandbox truncation by tool name. Pure function — no I/O.
+ * Unknown tools pass through unchanged.
+ */
+export function sandboxOutput(
+  tool: string,
+  output: string,
+  limits: SandboxToolLimits = DEFAULT_LIMITS,
+): string {
+  if (typeof output !== 'string' || output.length === 0) return output
+  const normalized = tool.trim().toLowerCase()
+  switch (normalized) {
+    case 'read':
+      return sandboxRead(output, limits.read)
+    case 'grep':
+      return sandboxGrep(output, limits.grep)
+    case 'glob':
+      return sandboxGlob(output, limits.glob)
+    case 'webfetch':
+    case 'fetch':
+    case 'web_fetch':
+      return sandboxWebfetch(output, limits.webfetch)
+    default:
+      return output
+  }
+}
+
+// ─── Plugin hook factory ───────────────────────────────────────────────
+
+/**
+ * Resolve sandbox config from opencode.json `context_sandbox` block.
+ * Fail-open: any missing/invalid field falls back to defaults.
+ */
+export function resolveSandboxConfig(raw?: unknown): ContextSandboxConfig {
+  if (raw === null || raw === undefined || typeof raw !== 'object')
+    return { ...DEFAULT_CONFIG, limits: { ...DEFAULT_LIMITS } }
+  const obj = raw as Record<string, unknown>
+  const enabled = typeof obj.enabled === 'boolean' ? obj.enabled : true
+  const limitsRaw = obj.limits as Record<string, unknown> | undefined
+
+  const limits: SandboxToolLimits = {
+    read: {
+      maxLines:
+        typeof limitsRaw?.read === 'object' &&
+        limitsRaw.read !== null &&
+        typeof (limitsRaw.read as Record<string, unknown>).maxLines === 'number'
+          ? ((limitsRaw.read as Record<string, unknown>).maxLines as number)
+          : DEFAULT_LIMITS.read.maxLines,
+      keepHead:
+        typeof limitsRaw?.read === 'object' &&
+        limitsRaw.read !== null &&
+        typeof (limitsRaw.read as Record<string, unknown>).keepHead === 'number'
+          ? ((limitsRaw.read as Record<string, unknown>).keepHead as number)
+          : DEFAULT_LIMITS.read.keepHead,
+      keepTail:
+        typeof limitsRaw?.read === 'object' &&
+        limitsRaw.read !== null &&
+        typeof (limitsRaw.read as Record<string, unknown>).keepTail === 'number'
+          ? ((limitsRaw.read as Record<string, unknown>).keepTail as number)
+          : DEFAULT_LIMITS.read.keepTail,
+    },
+    grep: {
+      maxResults:
+        typeof limitsRaw?.grep === 'object' &&
+        limitsRaw.grep !== null &&
+        typeof (limitsRaw.grep as Record<string, unknown>).maxResults === 'number'
+          ? ((limitsRaw.grep as Record<string, unknown>).maxResults as number)
+          : DEFAULT_LIMITS.grep.maxResults,
+      keepTop:
+        typeof limitsRaw?.grep === 'object' &&
+        limitsRaw.grep !== null &&
+        typeof (limitsRaw.grep as Record<string, unknown>).keepTop === 'number'
+          ? ((limitsRaw.grep as Record<string, unknown>).keepTop as number)
+          : DEFAULT_LIMITS.grep.keepTop,
+    },
+    glob: {
+      maxFiles:
+        typeof limitsRaw?.glob === 'object' &&
+        limitsRaw.glob !== null &&
+        typeof (limitsRaw.glob as Record<string, unknown>).maxFiles === 'number'
+          ? ((limitsRaw.glob as Record<string, unknown>).maxFiles as number)
+          : DEFAULT_LIMITS.glob.maxFiles,
+      keepTop:
+        typeof limitsRaw?.glob === 'object' &&
+        limitsRaw.glob !== null &&
+        typeof (limitsRaw.glob as Record<string, unknown>).keepTop === 'number'
+          ? ((limitsRaw.glob as Record<string, unknown>).keepTop as number)
+          : DEFAULT_LIMITS.glob.keepTop,
+    },
+    webfetch: {
+      maxChars:
+        typeof limitsRaw?.webfetch === 'object' &&
+        limitsRaw.webfetch !== null &&
+        typeof (limitsRaw.webfetch as Record<string, unknown>).maxChars === 'number'
+          ? ((limitsRaw.webfetch as Record<string, unknown>).maxChars as number)
+          : DEFAULT_LIMITS.webfetch.maxChars,
+      keepHead:
+        typeof limitsRaw?.webfetch === 'object' &&
+        limitsRaw.webfetch !== null &&
+        typeof (limitsRaw.webfetch as Record<string, unknown>).keepHead === 'number'
+          ? ((limitsRaw.webfetch as Record<string, unknown>).keepHead as number)
+          : DEFAULT_LIMITS.webfetch.keepHead,
+    },
+  }
+  return { enabled, limits }
+}
+
+/**
+ * Create the `tool.execute.after` handler that sandboxes oversized outputs.
+ * The handler mutates `output.output` in-place and tags metadata when truncated.
+ * Fail-open: never throws.
+ */
+export function createContextSandbox(
+  config: ContextSandboxConfig = DEFAULT_CONFIG,
+): ToolExecuteAfterHandler {
+  // Capture mutable reference — caller (plugin config hook) may update limits live
+  const cfgRef = config
+  return async (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput): Promise<void> => {
+    try {
+      if (!cfgRef.enabled) return
+      if (typeof output.output !== 'string') return
+      const before = output.output
+      const after = sandboxOutput(input.tool, before, cfgRef.limits)
+      if (after !== before) {
+        output.output = after
+        output.metadata = {
+          ...(output.metadata ?? {}),
+          truncated: true,
+          sandbox: input.tool.toLowerCase(),
+        }
+      }
+    } catch {
+      // never break the tool result
+    }
+  }
+}

package/src/pantheon/delegation-notify.ts

@@ -21,6 +21,11 @@
  * acknowledgment, not a completion), so every job gets exactly ONE terminal
  * transition — never a reconciled echo. Unknown sessions are ignored.
  *
+ * `finalizeIdleChildrenWithoutMd` proactively finalizes children that are
+ * idle on the board but have no MD report on disk — eliminates the phantom
+ * "running" window during `pullOutput` (Fix 2 for the TUI stale-running bug).
+ * Wired into a periodic scan via `startIdleChildScan` (default 30 s cadence).
+ *
  * Pure TypeScript — zero runtime dependencies beyond the board types.
  *
  * Follow-up (Themis review, Phase 5): `extractErrorMessage` handles the two
@@ -38,6 +43,9 @@ import type { FinalizeInput } from './delegation-finalize.ts'
 
 export type { FinalizeInput } from './delegation-finalize.ts'
 
+/** Default cadence for the proactive idle-child scan (30 s). */
+export const IDLE_SCAN_INTERVAL_MS = 30_000
+
 // ─── Types ─────────────────────────────────────────────────────────────
 
 /** Structural view of the event payload the `event` hook receives. */
@@ -98,3 +106,92 @@ export async function handleDelegationEvent(
   }
   return true
 }
+
+// ─── Proactive finalize (Fix 2) ────────────────────────────────────────
+
+/** Dependencies for idle-child scanning. */
+export interface IdleChildScanDeps {
+  /** Look up a board job by session ID (child session IDs are task IDs). */
+  board: {
+    get(taskID: string): BackgroundJobRecord | undefined
+    list(parentSessionID?: string): BackgroundJobRecord[]
+  }
+  /** Bound Phase 2 finalize — clears the timeout timer + writes the report. */
+  finalize: (childSessionID: string, opts: FinalizeInput) => Promise<unknown>
+  /**
+   * Check whether an MD report exists for the given board job.
+   * Receives the full job record so the caller can construct the report
+   * path from `job.parentSessionID` + `job.alias`.
+   * If the function throws, the scan skips that child (fail-open).
+   */
+  hasReport: (job: BackgroundJobRecord) => boolean
+  /** Optional logger for diagnostic messages. */
+  logger?: { info?: (msg: string) => void; warn?: (msg: string) => void }
+}
+
+/**
+ * Scan running board jobs for children whose sessions are idle but have no MD
+ * report on disk, and proactively finalize them. This eliminates the phantom
+ * "running" window that occurs between `session.idle` firing and the
+ * `pullOutput`→`writeDelegationReport` cycle completing.
+ *
+ * Called from the periodic idle-child scan (`startIdleChildScan`, default 30 s).
+ * The scan is O(N) where N = number of running jobs (typically < 10).
+ *
+ * Each child is finalized exactly once — the board's same-terminal idempotency
+ * ensures repeated scans are harmless. Errors are caught per-child so one
+ * failure never blocks the rest.
+ *
+ * @returns Number of children finalized (for diagnostics).
+ */
+export async function finalizeIdleChildrenWithoutMd(
+  deps: IdleChildScanDeps,
+): Promise<number> {
+  const runningJobs = deps.board
+    .list()
+    .filter((j: BackgroundJobRecord) => j.state === 'running')
+
+  let finalized = 0
+  for (const job of runningJobs) {
+    try {
+      // If the child already has an MD report, finalize was already handled
+      // by handleDelegationEvent — skip.
+      if (deps.hasReport(job)) continue
+      // Child is idle on the board but has no report — proactively finalize.
+      await deps.finalize(job.taskID, { state: 'completed' })
+      finalized++
+    } catch (err) {
+      deps.logger?.warn?.(
+        `[delegation-notify] proactive finalize failed for ${job.taskID}: ${err}`,
+      )
+    }
+  }
+  return finalized
+}
+
+// ─── Periodic scan launcher ─────────────────────────────────────────────
+
+/**
+ * Start a periodic scan that proactively finalizes idle board children
+ * without MD reports. The scan runs every `intervalMs` (default 30 s) and
+ * is **unref'd** so it never holds the process open on its own.
+ *
+ * The timer is idempotent — calling this function multiple times is safe
+ * (each call creates an independent timer, but the underlying finalize
+ * operation is itself idempotent due to the board's same-terminal guard).
+ *
+ * @returns A `NodeJS.Timeout` handle that can be cleared with
+ *   `clearInterval(handle)` to stop the scan.
+ */
+export function startIdleChildScan(
+  deps: IdleChildScanDeps,
+  intervalMs: number = IDLE_SCAN_INTERVAL_MS,
+): NodeJS.Timeout {
+  const timer = setInterval(() => {
+    void finalizeIdleChildrenWithoutMd(deps).catch((err) => {
+      deps.logger?.warn?.(`[delegation-notify] periodic idle scan failed: ${err}`)
+    })
+  }, intervalMs)
+  timer.unref()
+  return timer
+}

package/src/pantheon/delegation.ts

@@ -58,6 +58,11 @@ import {
   finalizeDelegation as finalizeDelegationReport,
   readDelegationReport,
 } from './delegation-finalize.ts'
+import {
+  type IdleChildScanDeps,
+  finalizeIdleChildrenWithoutMd,
+  startIdleChildScan,
+} from './delegation-notify.ts'
 import { createPantheonLogger } from './logger.ts'
 import { buildAgentListDescription } from './permission-globs.ts'
 import { missingProviderKeyEnv, resolveActivePreset } from './presets.mjs'
@@ -71,6 +76,8 @@ export type {
   FinalizeInput,
 } from './delegation-finalize.ts'
 export { DELEGATION_DEFAULTS } from './delegation-finalize.ts'
+export type { IdleChildScanDeps } from './delegation-notify.ts'
+export { finalizeIdleChildrenWithoutMd, startIdleChildScan } from './delegation-notify.ts'
 
 // Fase B3: these are runtime controls, not routing/frontmatter fields. The
 // plugin reads them from the environment, while tests and embedders can pass
@@ -326,6 +333,8 @@ export interface DelegationToolset {
     childSessionID: string,
     opts: FinalizeInput,
   ) => Promise<BackgroundJobRecord | undefined>
+  /** Proactive finalize for idle children without MD reports (Fix 2). */
+  finalizeIdleChildrenWithoutMd: typeof finalizeIdleChildrenWithoutMd
 }
 
 /** Input for createDelegationTools(). */
@@ -1182,5 +1191,6 @@ export function createDelegationTools(input: CreateDelegationToolsInput): Delega
     pantheon_delegation_read,
     pantheon_delegation_list,
     finalizeDelegation: finalize,
+    finalizeIdleChildrenWithoutMd,
   }
 }

package/src/pantheon/tui-version-check.ts

@@ -0,0 +1,72 @@
+/**
+ * tui-version-check.ts — Runtime staleness check for the TUI plugin copy
+ *
+ * Compares the version in the user's copied TUI plugin package.json against
+ * the version of the installed pantheon-opencode package. If mismatched,
+ * logs a one-time warning. Does NOT auto-sync (safety first).
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+const ROOT = join(__dirname, '..', '..')
+
+/**
+ * Detect the user's OpenCode config directory (same logic as sync-tui.mjs).
+ * Priority: $XDG_CONFIG_HOME/opencode → ~/.opencode → null
+ */
+function resolveConfigDir(): string | null {
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config')
+  const xdgDir = join(xdgConfig, 'opencode')
+  if (existsSync(xdgDir)) return xdgDir
+
+  const homeDir = join(homedir(), '.opencode')
+  if (existsSync(homeDir)) return homeDir
+
+  return null
+}
+
+/**
+ * Read the `version` field from a package.json, or null on failure.
+ */
+function readVersion(pkgPath: string): string | null {
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Run the TUI version staleness check. Call once at plugin init.
+ *
+ * @param logger - Logging function (defaults to console.warn)
+ */
+export function checkTuiVersionStaleness(
+  logger: (msg: string) => void = console.warn,
+): void {
+  try {
+    const configDir = resolveConfigDir()
+    if (!configDir) return // Not initialized — nothing to check
+
+    const tuiCopyDir = join(configDir, 'plugins', 'pantheon-tui')
+    if (!existsSync(tuiCopyDir)) return // TUI not installed
+
+    const copyVersion = readVersion(join(tuiCopyDir, 'package.json'))
+    if (!copyVersion) return // Can't read version — skip
+
+    // Read the installed package version from the repo root's package.json
+    const currentVersion = readVersion(join(ROOT, 'package.json'))
+    if (!currentVersion) return // Can't determine current version — skip
+
+    if (copyVersion !== currentVersion) {
+      logger(
+        `⚠️  TUI plugin v${copyVersion} is outdated. Current: v${currentVersion}. Run: npx pantheon-opencode init`,
+      )
+    }
+  } catch {
+    // Fail-open — version check must never block plugin initialization
+  }
+}

package/src/plugin.ts

@@ -1,7 +1,17 @@
+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 { createCommandNormalizer } from './pantheon/command-normalizer.ts'
 import { reassertAfterCompaction } from './pantheon/compaction-assert.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,
@@ -9,6 +19,7 @@ import {
   type DelegationClient,
   resolveDelegationBudgets,
   resolveDelegationTimeoutMs,
+  startIdleChildScan,
 } from './pantheon/delegation.ts'
 import { buildCompactionContext } from './pantheon/delegation-compaction.ts'
 import {
@@ -40,6 +51,7 @@ import {
   todoEnforcerEnabledFromEnv,
 } from './pantheon/todo-enforcer.ts'
 import { TodoPreserver } from './pantheon/todo-preserve.ts'
+import { checkTuiVersionStaleness } from './pantheon/tui-version-check.ts'
 import { activePresetCandidates, createVisionHandler } from './pantheon/vision.ts'
 
 // ─── Background Job Board Singleton ────────────────────────────────────
@@ -127,6 +139,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
 
@@ -334,6 +353,9 @@ const plugin: Plugin = async (input: PluginInput) => {
   if (pantheonPluginOnce('pantheon:plugin')) {
     return {}
   }
+  // Runtime TUI version staleness check — warns if the copied TUI plugin
+  // is older than the installed package. Runs once, fail-open, no auto-sync.
+  checkTuiVersionStaleness((msg) => log.warn(msg))
   const vision = createVisionHandler(input)
   // Phase 2/3: background delegation toolset + the bound finalize lifecycle
   // hook. Completion is observed through the event hook below
@@ -363,6 +385,28 @@ const plugin: Plugin = async (input: PluginInput) => {
     },
   })
 
+  // Proactive idle-child scan (Fix 2): finalize children that are idle on the
+  // board but have no MD report on disk — eliminates the phantom "running"
+  // window. Runs every 30s (configurable via PANTHEON_IDLE_SCAN_INTERVAL_MS),
+  // unref'd so it never holds the process open. Fail-open by design.
+  const idleScanIntervalMs = Number(process.env.PANTHEON_IDLE_SCAN_INTERVAL_MS) || undefined
+  startIdleChildScan(
+    {
+      board,
+      finalize: (childSessionID, opts) => delegation.finalizeDelegation(childSessionID, opts),
+      hasReport: (job) => {
+        try {
+          const filePath = join('.pantheon/delegations', job.parentSessionID, `${job.alias}.md`)
+          return existsSync(filePath)
+        } catch {
+          return false
+        }
+      },
+      logger: log,
+    },
+    idleScanIntervalMs,
+  )
+
   // Wave 1 (PR #46): TODO continuation enforcer for root/non-board sessions.
   // Mirrors routing.yml `todo_enforcer` (plugin scope has no routing.yml
   // access — COMPACTION_MAX_ITEMS pattern). The event hook routes non-board
@@ -407,6 +451,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
@@ -423,6 +485,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)
@@ -549,13 +620,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

package/src/plugins/tui/dist/tui.d.ts

@@ -11,7 +11,7 @@ type DelegationEntry = {
   taskID?: string;
   /** Agent name, e.g. "apollo". */
   agent: string;
-  state: 'running' | 'completed' | 'error' | 'startup_failed' | 'startup_unknown' | 'cancelled';
+  state: 'running' | 'completed' | 'error' | 'startup_failed' | 'startup_unknown' | 'cancelled' | 'stale-running';
   /** Epoch ms of the `Started` header. */
   startedAt: number;
   /** Epoch ms of the `Finalized` header — null while still running. */
@@ -77,7 +77,22 @@ declare function compareDelegationEntries(a: DelegationEntry, b: DelegationEntry
  *  recent terminal reports (capped). Pure — so the history-only panel (no
  *  sessionID) is testable without the TUI runtime. The header count uses the
  *  same "running + recentes" list. */
-declare function visibleDelegationList(all: readonly DelegationEntry[], maxTerminal?: number): DelegationEntry[];
+declare function visibleDelegationList(all: readonly DelegationEntry[], maxTerminal?: number, now?: number, staleThresholdMs?: number): DelegationEntry[];
+/** Default stale-running threshold: 30 minutes. */
+declare const STALE_RUNNING_THRESHOLD_MS: number;
+/** Idle silence window: if no updatedAt change in this window, the entry is
+ *  considered stale. Combined with the stale-running threshold to produce the
+ *  display-only `stale-running` state. */
+declare const IDLE_SILENCE_MS: number;
+/**
+ * Mark a running entry as `stale-running` if it has been running longer than
+ * the threshold AND has no recent activity (no `updatedAt` change in the last
+ * `IDLE_SILENCE_MS`). This is DISPLAY-ONLY — the board state is unchanged.
+ *
+ * A `stale-running` entry renders with a warning indicator but the underlying
+ * delegation is still treated as running by the backend.
+ */
+declare function markStaleIfRunning(entry: DelegationEntry, now: number, thresholdMs?: number): DelegationEntry;
 /** Compact elapsed-time label: "5m 12s", "1h 30m", "2d 4h" — ticks every
  *  second for running jobs. */
 declare function fmtElapsed(ms: number): string;
@@ -306,5 +321,5 @@ declare const plugin: TuiPluginModule & {
   id: string;
 };
 //#endregion
-export { ChildDelegationLike, DelegationActivity, DelegationEntry, DelegationToolPart, LiveDelegationEntry, LiveDelegationStore, ParsedDelegationToolPart, TuiSessionSources, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, fmtElapsed, isValidSessionId, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, safeSessionPath, seedLiveDelegationMap, toDelegationEntry, tuiLogPath, visibleDelegationList };
+export { ChildDelegationLike, DelegationActivity, DelegationEntry, DelegationToolPart, IDLE_SILENCE_MS, LiveDelegationEntry, LiveDelegationStore, ParsedDelegationToolPart, STALE_RUNNING_THRESHOLD_MS, TuiSessionSources, buildChildrenPath, childStatusToState, childrenToDelegationEntries, collectDelegationToolParts, compareDelegationEntries, plugin as default, delegationActivity, delegationActivityLabel, delegationElapsed, delegationSpinnerFrame, delegationTag, fmtElapsed, isValidSessionId, markStaleIfRunning, mergeChildDelegationSources, mergeDelegationSources, navigateToDelegationSession, panelLogDir, parseDelegationMarkdown, parseDelegationToolPart, readAllDelegationEntries, readDelegationEntries, reduceDelegationToolPart, removeDelegationEntry, resolveCurrentSessionID, resolveDelegationsDir, safeSessionPath, seedLiveDelegationMap, toDelegationEntry, tuiLogPath, visibleDelegationList };
 //# sourceMappingURL=tui.d.ts.map