pantheon-opencode 1.5.0-beta.8 → 1.5.0

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/native-probe.ts

@@ -1,234 +0,0 @@
-/**
- * Native Probe — lazy capability detection for native task() delegation.
- *
- * The probe is invoked on the FIRST native delegation of a session (not at
- * startup). It creates a child session with a minimal "ping" prompt, waits
- * for idle, and classifies the output.
- *
- * Results are cached per probe instance (singleton guard):
- *   - UNAVAILABLE is TERMINAL — no retry.
- *   - AVAILABLE is also cached — no re-probe.
- *
- * Uses the OpenCode V1 session API (session.create + promptAsync) injected via
- * the parent context.
- *
- * @module native-probe
- */
-
-import { createPantheonLogger } from './logger.ts'
-
-const log = createPantheonLogger({ module: 'native-probe' })
-
-// ─── Types ─────────────────────────────────────────────────────────────
-
-/** Possible outcomes of a native capability probe. */
-export type NativeProbeResult = {
-  status: 'AVAILABLE' | 'UNAVAILABLE' | 'UNSUPPORTED'
-}
-
-/** Minimal V1 client shape needed by the probe (session.create + promptAsync). */
-export interface ProbeClient {
-  session: {
-    create: (input: { body: { parentID: string } }) => Promise<{ id: string }>
-    promptAsync: (input: {
-      path: { id: string }
-      body: { agent: string; parts: Array<{ type: 'text'; text: string }> }
-    }) => Promise<unknown>
-  }
-}
-
-/** Context injected into the probe function. */
-export interface NativeProbeContext {
-  client: ProbeClient
-  parentSessionID: string
-}
-
-/** Options for a single probe invocation. */
-export interface NativeProbeOptions {
-  /** Timeout in milliseconds. Default: 30000. */
-  timeoutMs?: number
-}
-
-/** The probe function signature. */
-export type NativeProbeFn = (
-  ctx: NativeProbeContext,
-  options?: NativeProbeOptions,
-) => Promise<NativeProbeResult>
-
-// ─── Helpers ───────────────────────────────────────────────────────────
-
-/** Default timeout for the probe. */
-const DEFAULT_TIMEOUT_MS = 30_000
-
-/** Sentinel value indicating a timeout occurred. */
-const TIMEOUT_SENTINEL = Symbol('timeout')
-
-/**
- * Wrap a promise with a timeout.
- * Returns the value on success, throws the original error on rejection,
- * or returns TIMEOUT_SENTINEL if the timeout fires first.
- */
-async function withTimeout<T>(
-  promise: Promise<T>,
-  ms: number,
-): Promise<T | typeof TIMEOUT_SENTINEL> {
-  return new Promise<T | typeof TIMEOUT_SENTINEL>((resolve, reject) => {
-    const timer = setTimeout(() => resolve(TIMEOUT_SENTINEL), ms)
-    void promise.then(
-      (value) => {
-        clearTimeout(timer)
-        resolve(value)
-      },
-      (err: unknown) => {
-        clearTimeout(timer)
-        reject(err)
-      },
-    )
-  })
-}
-
-/**
- * Extract text content from a promptAsync response.
- * Returns empty string if no recognizable content found.
- */
-function extractOutput(result: unknown): string {
-  if (result == null) return ''
-  if (typeof result === 'string') return result
-  if (typeof result === 'object') {
-    const obj = result as Record<string, unknown>
-    // Check common shapes: { output }, { content }, { text }
-    if (typeof obj.output === 'string') return obj.output
-    if (typeof obj.content === 'string') return obj.content
-    if (typeof obj.text === 'string') return obj.text
-  }
-  // Non-empty object → treat as content (accepted message, etc.)
-  if (typeof result === 'object' && result !== null) {
-    return 'acknowledged'
-  }
-  return ''
-}
-
-function isUnsupportedError(message: string): boolean {
-  const lower = message.toLowerCase()
-  return (
-    lower.includes('not available') ||
-    lower.includes('not supported') ||
-    lower.includes('unsupported') ||
-    lower.includes('method not found')
-  )
-}
-
-// ─── Implementation ────────────────────────────────────────────────────
-
-/**
- * Create a native probe function with per-instance caching.
- *
- * The probe is LAZY: it does not run at startup. Call it on the first
- * native delegation of the session. The result is cached — subsequent
- * calls return the cached value without re-probing.
- *
- * @returns A probe function that caches results per instance.
- */
-export function createNativeProbe(): NativeProbeFn {
-  let cachedResult: NativeProbeResult | null = null
-  let inFlight: Promise<NativeProbeResult> | null = null
-
-  return async (
-    ctx: NativeProbeContext,
-    options?: NativeProbeOptions,
-  ): Promise<NativeProbeResult> => {
-    // Return cached result if available (singleton guard)
-    if (cachedResult !== null) {
-      return cachedResult
-    }
-    // Concurrent first dispatches share one probe instead of creating multiple
-    // child sessions. The promise is cleared only after a terminal result.
-    if (inFlight !== null) return inFlight
-
-    inFlight = probe(ctx, options)
-    try {
-      return await inFlight
-    } finally {
-      inFlight = null
-    }
-  }
-
-  async function probe(
-    ctx: NativeProbeContext,
-    options?: NativeProbeOptions,
-  ): Promise<NativeProbeResult> {
-    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS
-
-    // ── Phase 1: create child session ──────────────────────────────
-    let childID: string
-    try {
-      const createResult = await withTimeout(
-        ctx.client.session.create({ body: { parentID: ctx.parentSessionID } }),
-        timeoutMs,
-      )
-      if (createResult === TIMEOUT_SENTINEL) {
-        // Timeout during session.create → UNAVAILABLE
-        log.warn('[Native Probe] session.create timed out after', timeoutMs, 'ms')
-        const result: NativeProbeResult = { status: 'UNAVAILABLE' }
-        cachedResult = result
-        return result
-      }
-      childID = createResult.id
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err)
-      log.error('[Native Probe] session.create failed:', msg)
-      // Check for unsupported API patterns
-      if (isUnsupportedError(msg)) {
-        const result: NativeProbeResult = { status: 'UNSUPPORTED' }
-        cachedResult = result
-        return result
-      }
-      // Other creation failures → UNAVAILABLE
-      const result: NativeProbeResult = { status: 'UNAVAILABLE' }
-      cachedResult = result
-      return result
-    }
-
-    // ── Phase 2: send probe prompt ─────────────────────────────────
-    let promptResult: unknown
-    try {
-      const raw = await withTimeout(
-        ctx.client.session.promptAsync({
-          path: { id: childID },
-          body: { agent: 'probe', parts: [{ type: 'text', text: 'Reply with PONG.' }] },
-        }),
-        timeoutMs,
-      )
-      if (raw === TIMEOUT_SENTINEL) {
-        // Timeout during promptAsync → UNAVAILABLE
-        log.warn('[Native Probe] promptAsync timed out after', timeoutMs, 'ms')
-        const result: NativeProbeResult = { status: 'UNAVAILABLE' }
-        cachedResult = result
-        return result
-      }
-      promptResult = raw
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err)
-      log.error('[Native Probe] promptAsync failed:', msg)
-      if (isUnsupportedError(msg)) {
-        const result: NativeProbeResult = { status: 'UNSUPPORTED' }
-        cachedResult = result
-        return result
-      }
-      // promptAsync error → UNAVAILABLE
-      const result: NativeProbeResult = { status: 'UNAVAILABLE' }
-      cachedResult = result
-      return result
-    }
-
-    // ── Phase 3: classify output ───────────────────────────────────
-    const output = extractOutput(promptResult)
-    const hasContent = output.trim() !== ''
-
-    const result: NativeProbeResult = {
-      status: hasContent ? 'AVAILABLE' : 'UNAVAILABLE',
-    }
-    cachedResult = result
-    return result
-  }
-}

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' }
-}