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

package/src/pantheon/cost-tracker.ts

@@ -1,108 +0,0 @@
-/**
- * Cost Tracker (Wave 4, PR #46) — JSONL cost ledger for background
- * delegations. Every delegation that finishes (or times out) records one
- * line; the ledger lives at `.pantheon/costs/delegations.jsonl` and gives
- * Nyx / the /cost command a durable, human-readable cost history.
- *
- * record() APPENDS (appendFile + parent dir auto-create), never rewrites.
- * A missing ledger is an EMPTY ledger — list() → [], summary() → zeros,
- * no crash. Injectable clock not needed: timestamp is caller-provided
- * (ISO 8601), matching the delegation toolset's timestamping style.
- *
- * @module cost-tracker
- */
-import { appendFile, mkdir, readFile } from 'node:fs/promises'
-import { dirname } from 'node:path'
-
-/** One delegation cost event. */
-export interface CostRecord {
-  /** Board task ID (e.g. "ses_child_1" or the job alias "apo-1"). */
-  taskId: string
-  /** Session that owns the delegation — list(sessionID?) filters on this. */
-  sessionID?: string
-  /** Delegated agent name (e.g. "hermes"). */
-  agent: string
-  /** Model ID actually used (e.g. "opencode/deepseek-v4-flash"). */
-  model: string
-  tokensInput: number
-  tokensOutput: number
-  /** Cost in USD (already computed by the caller). */
-  costUsd: number
-  /** ISO 8601 timestamp of the record. */
-  timestamp: string
-}
-
-/** Aggregate across the whole ledger. */
-export interface CostSummary {
-  count: number
-  totalCostUsd: number
-  totalTokensInput: number
-  totalTokensOutput: number
-}
-
-export interface CostTrackerOptions {
-  /** Ledger path. Default: ".pantheon/costs/delegations.jsonl". */
-  filePath?: string
-}
-
-export interface CostTracker {
-  /** Append one record to the ledger (creates the parent dir on first write). */
-  record(entry: CostRecord): Promise<void>
-  /** All records, optionally filtered by sessionID. Missing file → []. */
-  list(sessionID?: string): Promise<CostRecord[]>
-  /** Aggregate totals across the whole ledger. Missing file → zeros. */
-  summary(): Promise<CostSummary>
-}
-
-/** Parse the ledger file; missing file → empty array (never throws). */
-async function readLedger(filePath: string): Promise<CostRecord[]> {
-  let raw: string
-  try {
-    raw = await readFile(filePath, 'utf8')
-  } catch {
-    return []
-  }
-  const records: CostRecord[] = []
-  for (const line of raw.split('\n')) {
-    if (line.trim() === '') continue
-    try {
-      records.push(JSON.parse(line) as CostRecord)
-    } catch {
-      // Skip malformed lines — a partial ledger never breaks the reader.
-    }
-  }
-  return records
-}
-
-export function createCostTracker(options?: CostTrackerOptions): CostTracker {
-  const filePath = options?.filePath ?? '.pantheon/costs/delegations.jsonl'
-
-  return {
-    async record(entry: CostRecord): Promise<void> {
-      await mkdir(dirname(filePath), { recursive: true })
-      await appendFile(filePath, `${JSON.stringify(entry)}\n`, 'utf8')
-    },
-
-    async list(sessionID?: string): Promise<CostRecord[]> {
-      const records = await readLedger(filePath)
-      if (sessionID === undefined) return records
-      return records.filter((r) => r.sessionID === sessionID)
-    },
-
-    async summary(): Promise<CostSummary> {
-      const records = await readLedger(filePath)
-      const summary: CostSummary = {
-        count: records.length,
-        totalCostUsd: 0,
-        totalTokensInput: 0,
-        totalTokensOutput: 0,
-      }
-      for (const r of records) {
-        summary.totalCostUsd += r.costUsd
-        summary.totalTokensInput += r.tokensInput
-        summary.totalTokensOutput += r.tokensOutput
-      }
-      return summary
-    },
-  }
-}

package/src/pantheon/dispatch-guard.ts

@@ -1,109 +0,0 @@
-/**
- * Dispatch Guard (Wave 4, PR #46) — auto-retry-on-empty for background
- * delegations. Classifies a dispatch result and redispatch once when it
- * came back empty.
- *
- * Failure signature classification:
- *   - 'content'     — text content present, nothing to do.
- *   - 'empty-mode1' — NO content AND NO tokens: the dispatch returned
- *                     nothing at all (no reply / early abort).
- *   - 'empty-mode2' — no text part but tokens present: reasoning happened
- *                     but the text part was lost — the themis Wave-2
- *                     failure signature that triggered this guard.
- *
- * Retry cap is HARD at 1 (never 2x). The guard is stateful per instance:
- * one retry budget total. It is a PURE library — it does NOT intercept
- * task() (opencode 1.18.x cannot intercept task completion via hooks, so
- * integration is manual-orchestration; see zeus.md "Empty-Result Retry").
- *
- * @module dispatch-guard
- */
-
-import { createPantheonLogger } from './logger.ts'
-
-// Silence-by-default TUI policy (pantheon-hooks L42-58): the default warn
-// fallback logs to .pantheon/logs/hooks.log; console echo is opt-in via
-// PANTHEON_HOOKS_LOG=1. `logger` injection stays for tests.
-const log = createPantheonLogger({ module: 'pantheon-dispatch-guard' })
-
-/** A dispatch result — the minimal shape needed to classify emptiness. */
-export interface DispatchResultLike {
-  /** Text content of the result (task_result / report markdown). */
-  content?: string | null
-  /** Input tokens (present when the model actually reasoned). */
-  tokensInput?: number
-  /** Output tokens (present when the model actually reasoned). */
-  tokensOutput?: number
-  /** R1: the failure that produced this result (classified by retry-policy). */
-  error?: unknown
-}
-
-/** Classification of a dispatch result. */
-export type DispatchClassification = 'content' | 'empty-mode1' | 'empty-mode2'
-
-export interface DispatchGuardOptions {
-  /** Enable auto-retry on empty results. Default: true. */
-  retryOnEmpty?: boolean
-  /** Injectable logger (defaults to the Pantheon file log, env-gated echo). */
-  logger?: { warn: (message: string) => void }
-}
-
-export interface DispatchGuard {
-  /** Classify a result: content, empty-mode1 (nothing), empty-mode2 (reasoning, no text). */
-  classifyResult(result: DispatchResultLike): DispatchClassification
-  /**
-   * Redispatch ONCE when the result is empty and retryOnEmpty is enabled.
-   * A retried result that is STILL empty is returned as-is — the cap of 1
-   * is never exceeded. Never throws.
-   */
-  maybeRetry(
-    result: DispatchResultLike,
-    redispatch: () => Promise<DispatchResultLike>,
-  ): Promise<{
-    classification: DispatchClassification
-    retried: boolean
-    result: DispatchResultLike
-  }>
-}
-
-/** 1-based retry budget — the hard cap. Never 2x. */
-const MAX_RETRIES = 1
-
-/** Whether a result carries any text content (whitespace-only counts as empty). */
-function hasContent(result: DispatchResultLike): boolean {
-  return typeof result.content === 'string' && result.content.trim() !== ''
-}
-
-/** Whether the result carries any token counts (i.e. the model actually ran). */
-function hasTokens(result: DispatchResultLike): boolean {
-  return (result.tokensInput ?? 0) > 0 || (result.tokensOutput ?? 0) > 0
-}
-
-export function createDispatchGuard(options?: DispatchGuardOptions): DispatchGuard {
-  const retryOnEmpty = options?.retryOnEmpty ?? true
-  const warn = options?.logger?.warn ?? ((message: string) => log.warn(message))
-  // Per-instance retry budget — the "cap 1" enforcement point.
-  let retriesUsed = 0
-
-  return {
-    classifyResult(result: DispatchResultLike): DispatchClassification {
-      if (hasContent(result)) return 'content'
-      return hasTokens(result) ? 'empty-mode2' : 'empty-mode1'
-    },
-
-    async maybeRetry(result, redispatch) {
-      const classification = this.classifyResult(result)
-      if (!retryOnEmpty || classification === 'content' || retriesUsed >= MAX_RETRIES) {
-        return { classification, retried: false, result }
-      }
-      retriesUsed += 1
-      warn(`dispatch returned ${classification}; retrying once (cap ${MAX_RETRIES})`)
-      const retriedResult = await redispatch()
-      return {
-        classification: this.classifyResult(retriedResult),
-        retried: true,
-        result: retriedResult,
-      }
-    },
-  }
-}

package/src/pantheon/permission-eval.ts

@@ -1,284 +0,0 @@
-/**
- * S1 — Deny-first permission evaluation + PreToolUse-style hooks.
- *
- * Deny rules checked BEFORE allow rules. User-level denies cannot be
- * overridden by project config. Hook exit-code semantics:
- *   exit 0 → allow, exit 2 → hard deny, missing/throw → fail-open.
- *
- * @module permission-eval
- */
-
-// ─── Types ─────────────────────────────────────────────────────────────
-
-/** Result of a permission evaluation. */
-export interface PermissionResult {
-  allowed: boolean
-  reason: 'allow' | 'deny' | 'hook_deny' | 'no_match'
-  message?: string
-}
-
-/** Hook script result (mirrors hook-runner.ts HookResult). */
-export interface HookResult {
-  code: number
-  stdout: string
-  stderr: string
-  /** When true, the hook script was not found — treat as fail-open. */
-  missing?: boolean
-}
-
-/**
- * PreToolUse hook function signature.
- * exit 0 → allow, exit 2 → hard deny, exit 1 → soft deny.
- * Throw = fail-open.
- */
-export type PreToolUseHook = (tool: string, args: unknown) => Promise<HookResult> | HookResult
-
-/** Permission configuration. */
-export interface PermissionConfig {
-  /** Deny rules — evaluated first. User-level denies override project allows. */
-  deny: readonly string[]
-  /** Allow rules — evaluated after deny. */
-  allow: readonly string[]
-  /** Optional hooks configuration. */
-  hooks?: {
-    /** PreToolUse hook function (in-process, not script path). */
-    preToolUse?: PreToolUseHook
-  }
-}
-
-// ─── Pattern matching ──────────────────────────────────────────────────
-
-/**
- * Parse a permission rule pattern into { tool, argPattern }.
- *
- * Supported formats:
- *   - "tool"             → tool="tool", argPattern="*"
- *   - "tool:*"           → tool="tool", argPattern="*"
- *   - "tool:subcommand"  → tool="tool", argPattern="subcommand"
- *   - "tool(pattern)"    → tool="tool", argPattern="pattern" (full match)
- *   - "*:*"              → tool="*", argPattern="*"
- *   - "git push:*"       → tool="git push", argPattern="*" (subcommand prefix)
- */
-function parsePattern(pattern: string): { tool: string; argPattern: string } {
-  // Handle "tool(pattern)" format — the content inside parens is the full
-  // arg pattern. Colons inside parens are literal, not separators.
-  const parenMatch = /^([^(]+)\(([^)]+)\)$/.exec(pattern)
-  if (parenMatch) {
-    const tool = parenMatch[1] ?? ''
-    const argPattern = parenMatch[2] ?? ''
-    return { tool, argPattern }
-  }
-
-  // Handle "tool:argPattern" or just "tool"
-  const colonIdx = pattern.indexOf(':')
-  if (colonIdx === -1) {
-    return { tool: pattern, argPattern: '*' }
-  }
-  const argPattern = pattern.slice(colonIdx + 1)
-  return {
-    tool: pattern.slice(0, colonIdx),
-    // Empty argPattern after colon = wildcard (e.g. "*:" matches any args)
-    argPattern: argPattern === '' ? '*' : argPattern,
-  }
-}
-
-/**
- * Convert a glob-like pattern to a regex. `*` matches any sequence.
- * Anchored to full match.
- */
-function globToRegex(pattern: string): RegExp {
-  const escaped = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*/g, '.*')
-    .replace(/\?/g, '.')
-  return new RegExp(`^${escaped}$`)
-}
-
-/** Extract a string representation from tool args for pattern matching. */
-function argsToString(args: unknown): string {
-  if (args === null || args === undefined) return ''
-  if (typeof args === 'string') return args
-  if (typeof args === 'object') {
-    const record = args as Record<string, unknown>
-    // Try common field names
-    for (const key of ['command', 'cmd', 'query', 'pattern', 'filePath', 'path', 'url']) {
-      if (typeof record[key] === 'string') return record[key]
-    }
-    return JSON.stringify(args)
-  }
-  return String(args)
-}
-
-/**
- * Build a combined string for matching: "toolName argString".
- * This allows patterns like "git push:*" to match tool="git" with args
- * containing "push".
- */
-function combinedString(tool: string, args: unknown): string {
-  const argsStr = argsToString(args)
-  return argsStr !== '' ? `${tool} ${argsStr}` : tool
-}
-
-/**
- * Check if a tool+args matches a permission rule pattern.
- * Returns true when the pattern matches.
- *
- * Matching strategy:
- *   1. Wildcard tool ("*") → match any tool with argPattern
- *   2. Direct tool match → check argPattern against args
- *   3. Combined match (for "git push:*" style patterns) → prefix match
- */
-function matchesRule(pattern: string, tool: string, args: unknown): boolean {
-  const { tool: patternTool, argPattern } = parsePattern(pattern)
-
-  // Wildcard tool: match any tool
-  if (patternTool === '*') {
-    if (argPattern === '*') return true
-    const argsStr = argsToString(args)
-    return globToRegex(argPattern).test(argsStr)
-  }
-
-  // Check direct tool match
-  if (globToRegex(patternTool).test(tool)) {
-    if (argPattern === '*') return true
-    const argsStr = argsToString(args)
-    return globToRegex(argPattern).test(argsStr)
-  }
-
-  // Combined match for patterns with spaces (e.g. "git push:*")
-  // The pattern tool includes a subcommand that appears in args.
-  // Use prefix matching: "git push" matches "git push origin main"
-  if (patternTool.includes(' ')) {
-    const combined = combinedString(tool, args)
-    // Prefix match: combined starts with pattern tool
-    if (combined.startsWith(patternTool)) {
-      return true
-    }
-  }
-
-  return false
-}
-
-// ─── Evaluation ────────────────────────────────────────────────────────
-
-/**
- * Evaluate a permission config against a tool+args invocation.
- *
- * Evaluation order:
- *   1. Check deny rules (user-level first, then project-level)
- *   2. If no deny matched, run the PreToolUse hook
- *   3. If hook exits 0 (or missing), check allow rules
- *   4. If no allow matched → deny (implicit deny)
- *
- * User-level denies override project-level allows: a deny in the user config
- * cannot be cancelled by an allow in the project config.
- */
-export function evaluatePermission(
-  config: PermissionConfig,
-  invocation: { tool: string; args?: unknown },
-): PermissionResult {
-  const { tool, args } = invocation
-
-  // ── Step 1: Deny-first check ────────────────────────────────────────
-  for (const pattern of config.deny) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: false, reason: 'deny', message: `denied by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 2: PreToolUse hook ─────────────────────────────────────────
-  if (config.hooks?.preToolUse !== undefined) {
-    try {
-      const hookResult = config.hooks.preToolUse(tool, args)
-      // Support both sync and async hooks
-      // For sync hooks (non-Promise), check immediately
-      if (!(hookResult instanceof Promise)) {
-        // missing flag: hook script not found → fail-open
-        if (hookResult.missing === true) {
-          // Fall through to config evaluation (fail-open)
-        } else if (hookResult.code === 2) {
-          return {
-            allowed: false,
-            reason: 'hook_deny',
-            message: `hook hard deny (exit 2): ${hookResult.stderr}`,
-          }
-        } else if (hookResult.code !== 0) {
-          return {
-            allowed: false,
-            reason: 'hook_deny',
-            message: `hook deny (exit ${hookResult.code}): ${hookResult.stderr}`,
-          }
-        }
-        // Hook exited 0 (or missing) → fall through to allow check
-      }
-      // For async hooks, we cannot await in a sync function.
-      // Use evaluatePermissionAsync for async hooks.
-    } catch {
-      // Hook throw → fail-open: fall through to config evaluation
-    }
-  }
-
-  // ── Step 3: Allow check ─────────────────────────────────────────────
-  for (const pattern of config.allow) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: true, reason: 'allow', message: `allowed by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 4: No match → implicit deny ────────────────────────────────
-  return { allowed: false, reason: 'no_match', message: 'no matching allow rule' }
-}
-
-/**
- * Async version of evaluatePermission that properly awaits hooks.
- * Use this when hooks may be async (e.g., shell scripts).
- */
-export async function evaluatePermissionAsync(
-  config: PermissionConfig,
-  invocation: { tool: string; args?: unknown },
-): Promise<PermissionResult> {
-  const { tool, args } = invocation
-
-  // ── Step 1: Deny-first check ────────────────────────────────────────
-  for (const pattern of config.deny) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: false, reason: 'deny', message: `denied by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 2: PreToolUse hook ─────────────────────────────────────────
-  if (config.hooks?.preToolUse !== undefined) {
-    try {
-      const hookResult = await config.hooks.preToolUse(tool, args)
-      // missing flag: hook script not found → fail-open
-      if (hookResult.missing === true) {
-        // Fall through to config evaluation (fail-open)
-      } else if (hookResult.code === 2) {
-        return {
-          allowed: false,
-          reason: 'hook_deny',
-          message: `hook hard deny (exit 2): ${hookResult.stderr}`,
-        }
-      } else if (hookResult.code !== 0) {
-        return {
-          allowed: false,
-          reason: 'hook_deny',
-          message: `hook deny (exit ${hookResult.code}): ${hookResult.stderr}`,
-        }
-      }
-      // Hook exited 0 (or missing) → fall through to allow check
-    } catch {
-      // Hook throw → fail-open: fall through to config evaluation
-    }
-  }
-
-  // ── Step 3: Allow check ─────────────────────────────────────────────
-  for (const pattern of config.allow) {
-    if (matchesRule(pattern, tool, args)) {
-      return { allowed: true, reason: 'allow', message: `allowed by rule: ${pattern}` }
-    }
-  }
-
-  // ── Step 4: No match → implicit deny ────────────────────────────────
-  return { allowed: false, reason: 'no_match', message: 'no matching allow rule' }
-}

package/src/pantheon/preemptive-compact.ts

@@ -1,76 +0,0 @@
-/**
- * Preemptive Compaction Check (release-134 Phase 5) — dormant, ready-to-wire.
- *
- * WHY: the SDK 1.18.x exposes NO runtime source of context-usage percentage,
- * so there is nothing to observe at runtime yet. This module is the pure
- * decision core that warns the model BEFORE the context fills up — ready to
- * be wired to a future usage source, but deliberately NOT wired today.
- *
- * HOW: `preemptiveCompactCheck` is a pure function: given the current usage
- * fraction and the last fraction at which a warning was emitted, it decides
- * whether to warn again (threshold + re-warn step) and returns the effective
- * `lastWarnedPct`. The `enqueue` callback is INJECTED by the caller — this
- * module stays standalone and does NOT import the shared chat-reminders
- * buffer.
- *
- * YAGNI: no background timers, no polling, no plugin wiring. When (if) the
- * SDK exposes a usage source, the caller wires it into this check.
- *
- * FAIL-OPEN: the whole check is wrapped — an enqueue failure returns the
- * previous state and never throws.
- *
- * @module preemptive-compact
- */
-
-// ─── Constants ─────────────────────────────────────────────────────────
-
-/** Warn when context usage reaches this fraction (78%). */
-export const PREEMPTIVE_COMPACTION_THRESHOLD = 0.78
-
-/** Re-warn only when usage rose at least this much since the last warning (5pp). */
-export const PREEMPTIVE_REWARN_STEP = 0.05
-
-// ─── Types ─────────────────────────────────────────────────────────────
-
-/** Dependencies threaded to preemptiveCompactCheck (wired from plugin.ts). */
-export interface PreemptiveCompactDeps {
-  /** The session whose context usage is being checked. */
-  sessionID: string
-  /** Current context usage as a fraction (0..1). */
-  usagePct: number
-  /** Last fraction at which a warning was emitted (undefined = never). */
-  lastWarnedPct: number | undefined
-  /** Injectable enqueue (testable). The module stays standalone. */
-  enqueue: (text: string) => void
-}
-
-// ─── Decision ──────────────────────────────────────────────────────────
-
-/**
- * Pure decision: should a warning be emitted at the given usage?
- * True when usage is at/above the threshold AND either no warning was
- * emitted yet or usage rose by at least the re-warn step since the last one.
- */
-export function shouldWarn(usagePct: number, lastWarnedPct: number | undefined): boolean {
-  if (usagePct < PREEMPTIVE_COMPACTION_THRESHOLD) return false
-  if (lastWarnedPct === undefined) return true
-  return usagePct >= lastWarnedPct + PREEMPTIVE_REWARN_STEP
-}
-
-/**
- * Preemptive compaction check: when a warning should fire, enqueue the
- * reminder and return the usage fraction as the new `lastWarnedPct`.
- * Otherwise (or on any failure) return the previous `lastWarnedPct`.
- * NEVER throws — the hook must never break the session.
- */
-export function preemptiveCompactCheck(deps: PreemptiveCompactDeps): number | undefined {
-  try {
-    if (!shouldWarn(deps.usagePct, deps.lastWarnedPct)) return deps.lastWarnedPct
-    deps.enqueue(
-      `context usage at ${Math.round(deps.usagePct * 100)}% — consider compacting before continuing`,
-    )
-    return deps.usagePct
-  } catch {
-    return deps.lastWarnedPct
-  }
-}