pantheon-opencode 1.5.0-beta.3 → 1.5.0-beta.5

package/scripts/install/strings.mjs

@@ -0,0 +1,129 @@
+/**
+ * strings.mjs — installer strings with locale auto-detection.
+ *
+ * LANG/LC_ALL/LC_MESSAGES starting with "pt" selects the PT-BR table;
+ * everything else (and the absence of a locale) selects EN. A plain string
+ * table — deliberately no i18n framework (YAGNI).
+ *
+ * Scope: the user journey (banner → install steps → health → summary →
+ * next steps). Deep diagnostics (per-file copy detail, doctor output) and
+ * the model-picker wizard remain single-language by design.
+ */
+
+const TABLE = {
+  en: {
+    installing: 'Installing...',
+    dryRun: 'DRY RUN',
+    canceled: 'Installation canceled — nothing was broken; run init again anytime.',
+    canceledShort: 'Installation canceled.',
+    installFailed: (msg) => `❌ Installation failed: ${msg}`,
+    failHintNoMcp:
+      '   Run with --no-mcp to skip Python dependencies:\n     npx pantheon-opencode init --no-mcp',
+    failHintForce:
+      '   Or retry with --force to recreate the venv:\n     npx pantheon-opencode init --force',
+    runningHealthCheck: 'Running health check...',
+    installedTitle: (v) => `✅ Pantheon OpenCode v${v} installed!`,
+    nextSteps: 'Next steps:',
+    nextVerify: '1. Verify installation:\n     npx pantheon-opencode doctor',
+    nextLaunch: '2. Launch OpenCode',
+    nextAgents: '3. Invoke agents with @agent-name in chat',
+    nextProject: '4. For project-local install:\n     npx pantheon-opencode init --project',
+    // install steps
+    globalLayout:
+      'Global config directory detected — using flat layout (agents/, skills/, commands/)',
+    installingAgents: 'Installing agents',
+    installingSkills: 'Installing skills',
+    installingInstructions: 'Installing instructions',
+    installingPrompts: 'Installing prompts',
+    installingCommands: 'Installing commands',
+    installingPlugins: 'Installing plugins',
+    settingUpRuntime: 'Setting up Python virtual environment',
+    healthSection: 'Health Check',
+    runningHealthChecks: 'Running health checks',
+    runtimeFailed: (msg) => `Python runtime setup failed: ${msg}`,
+    runtimeSkippedMcp:
+      'MCP servers were NOT configured because the Python runtime is unavailable. ' +
+      'Fix python3 (or free disk space) and re-run init to add them; everything else was installed.',
+    prereqMissing:
+      'runtime prerequisites missing — install the tools above, or re-run with --no-mcp to install without Python MCP servers',
+    v2Migrating: 'Migrating config to V2 native format...',
+    // summary (printSummary)
+    summaryInstalled: (target) => `OpenCode installed in ${target}`,
+    summaryWithErrors: (target) => `Installation finished WITH ERRORS in ${target}`,
+    summaryComponents: (created, skipped) =>
+      `  Components:\t${created} installed, ${skipped} skipped`,
+    summaryErrors: (n) => `  ${n} error(s) found`,
+    summaryWarnings: (n) => `  ${n} warning(s) — run 'doctor' for details`,
+    summaryNext: '  Next steps:',
+    summaryNextAgents: '   • Configure your agents in opencode.json',
+    summaryNextMcp: '   • Add MCP servers in opencode.json (mcp section)',
+    summaryNextDoctor: "   • Run 'opencode doctor' to verify the installation",
+  },
+  pt: {
+    installing: 'Instalando...',
+    dryRun: 'SIMULAÇÃO',
+    canceled: 'Instalação cancelada — nada foi quebrado; rode init de novo quando quiser.',
+    canceledShort: 'Instalação cancelada.',
+    installFailed: (msg) => `❌ Instalação falhou: ${msg}`,
+    failHintNoMcp:
+      '   Rode com --no-mcp para pular dependências Python:\n     npx pantheon-opencode init --no-mcp',
+    failHintForce:
+      '   Ou tente de novo com --force para recriar a venv:\n     npx pantheon-opencode init --force',
+    runningHealthCheck: 'Rodando verificação de saúde...',
+    installedTitle: (v) => `✅ Pantheon OpenCode v${v} instalado!`,
+    nextSteps: 'Próximos passos:',
+    nextVerify: '1. Verifique a instalação:\n     npx pantheon-opencode doctor',
+    nextLaunch: '2. Abra o OpenCode',
+    nextAgents: '3. Invoc agentes com @nome-do-agente no chat',
+    nextProject: '4. Para instalar no projeto:\n     npx pantheon-opencode init --project',
+    // install steps
+    globalLayout:
+      'Diretório de config global detectado — layout plano (agents/, skills/, commands/)',
+    installingAgents: 'Instalando agentes',
+    installingSkills: 'Instalando skills',
+    installingInstructions: 'Instalando instruções',
+    installingPrompts: 'Instalando prompts',
+    installingCommands: 'Instalando comandos',
+    installingPlugins: 'Instalando plugins',
+    settingUpRuntime: 'Configurando ambiente virtual Python',
+    healthSection: 'Verificação de saúde',
+    runningHealthChecks: 'Rodando verificações de saúde',
+    runtimeFailed: (msg) => `Falha ao configurar o runtime Python: ${msg}`,
+    runtimeSkippedMcp:
+      'Os servidores MCP NÃO foram configurados porque o runtime Python está indisponível. ' +
+      'Corrija o python3 (ou libere espaço em disco) e rode init de novo para adicioná-los; todo o resto foi instalado.',
+    prereqMissing:
+      'pré-requisitos do runtime ausentes — instale as ferramentas acima, ou rode de novo com --no-mcp para instalar sem os MCPs Python',
+    v2Migrating: 'Migrando config para o formato nativo V2...',
+    // summary (printSummary)
+    summaryInstalled: (target) => `OpenCode instalado em ${target}`,
+    summaryWithErrors: (target) => `Instalação concluída COM ERROS em ${target}`,
+    summaryComponents: (created, skipped) =>
+      `  Componentes:\t${created} instalados, ${skipped} pulados`,
+    summaryErrors: (n) => `  ${n} erro(s) encontrados`,
+    summaryWarnings: (n) => `  ${n} aviso(s) — rode 'doctor' para detalhes`,
+    summaryNext: '  Próximos passos:',
+    summaryNextAgents: '   • Configure seus agentes em opencode.json',
+    summaryNextMcp: '   • Adicione MCP servers em opencode.json (seção mcp)',
+    summaryNextDoctor: "   • Rode 'opencode doctor' para verificar a instalação",
+  },
+}
+
+/** Pure locale resolution (exported for tests). */
+export function detectLocale(env = process.env) {
+  const raw = env.LC_ALL ?? env.LC_MESSAGES ?? env.LANG ?? ''
+  return /^pt/i.test(raw) ? 'pt' : 'en'
+}
+
+/** Pure table access (exported for tests and explicit-locale callers). */
+export function stringsFor(locale) {
+  return TABLE[locale] ?? TABLE.en
+}
+
+let cached = null
+
+/** Locale-resolved string table for the current process. */
+export function strings(env = process.env) {
+  if (cached === null) cached = stringsFor(detectLocale(env))
+  return cached
+}

package/scripts/install-mcp.mjs

@@ -221,6 +221,7 @@ export const MCPS = {
         type: 'local',
         command: VENV_PYTHON,
         args: [CODE_MODE_SERVER],
+        cwd: '.',
       },
     },
     env: [],

package/scripts/probe-pantheon-cost.mjs

@@ -28,6 +28,15 @@ function emit(status, detail, checks = []) {
   if (status === 'FAIL') process.exitCode = 1
 }
 
+function diagnostic(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  const stderr =
+    error && typeof error === 'object' && typeof error.stderr === 'string'
+      ? error.stderr.trim()
+      : ''
+  return stderr === '' ? message : `${message}; stderr: ${stderr}`
+}
+
 function ambiental(detail) {
   emit('AMBIENTAL', detail)
 }
@@ -295,7 +304,7 @@ async function main() {
     checks.push('incompatible schema: PASS')
     emit('PASS', 'offline synthetic DB checks passed; no real DB was read', checks)
   } catch (error) {
-    emit('FAIL', error instanceof Error ? error.message : String(error), checks)
+    emit('FAIL', diagnostic(error), checks)
   } finally {
     rmSync(root, { recursive: true, force: true })
   }

package/scripts/release-beta-version.mjs

@@ -14,18 +14,13 @@
  * compatibility only; it is no longer generated.
  */
 
-import {
-  SEMVER_PATTERN,
-  validateInventory,
-  writeInventoryVersion,
-} from './manifest-inventory.mjs'
+import { SEMVER_PATTERN, validateInventory, writeInventoryVersion } from './manifest-inventory.mjs'
 
 const STABLE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
 // Current committed sequential beta line.
 const BETA_LINE = /^(\d+\.\d+\.\d+)-beta\.(\d+)$/
 // Legacy PR+SHA beta scheme, accepted for recovery only.
-const LEGACY_BETA =
-  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*\.[0-9a-f]{7}$/
+const LEGACY_BETA = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*\.[0-9a-f]{7}$/
 const BETA_RELEASE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*$/
 
 export function nextStableVersion(latest, intent = 'patch') {

package/scripts/sync-artifacts.mjs

@@ -0,0 +1,169 @@
+/**
+ * sync-artifacts.mjs — postinstall freshness sync for copy-only artifacts.
+ *
+ * Guarantees that an `npm install -g pantheon-opencode` (or npx cache
+ * refresh) brings an EXISTING installation up to date for everything that is
+ * a pure byte-compare copy: agents + routing.yml, skills, AGENTS.md,
+ * commands, the runtime MCP scripts, the code-mode payload and tiers.json.
+ *
+ * Deliberately NOT done here (they belong to `pantheon-opencode init` /
+ * `update`, which the doctor points at when versions drift):
+ *   - opencode.json merge (config keys, plugin registration, MCP entries)
+ *   - venv/pip setup
+ *   - tui.json registration changes
+ *
+ * The user's opencode.json already references the installed package root for
+ * plugins, so after a package update those references hit the NEW code
+ * automatically; this sync refreshes the COPIES that would otherwise stay
+ * stale until the next manual init.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+import {
+  collectSkillNames,
+  copyFiles,
+  installSkills,
+  ROOT,
+  syncDir,
+  writeIfChanged,
+} from './install/shared.mjs'
+
+/** Canonical MCP script sources — mirrors installOpenCode phase 2.10. */
+const MCP_SCRIPTS = {
+  'mcp_resources_server.py': () => join(ROOT, 'src', 'mcp', 'mcp_resources_server.py'),
+  'code_mode_server.py': () => join(ROOT, 'src', 'mcp', 'code_mode_server.py'),
+  'memory_mcp_server.py': () => join(ROOT, 'src', 'mcp', 'memory_mcp_server.py'),
+  'mcp_persistence_server.py': () => join(ROOT, 'src', 'mcp', 'mcp_persistence_server.py'),
+  '_pantheon_paths.py': () => join(ROOT, 'src', 'mcp', '_pantheon_paths.py'),
+  'mcp_codemap_module.py': () => join(ROOT, 'src', 'mcp', 'mcp_codemap_module.py'),
+  'pantheon_vision_server.py': () => join(ROOT, 'src', 'mcp', 'pantheon_vision_server.py'),
+  'eval_store.py': () => join(ROOT, 'src', 'mcp', 'eval_store.py'),
+  'scrub-secrets.py': () => join(ROOT, 'scripts', 'scrub-secrets.py'),
+}
+
+/**
+ * Sync all copy-only artifacts from the installed package into configDir
+ * (the GLOBAL OpenCode config dir). Byte-compare idempotent; never throws.
+ * @returns {{ created: number, skipped: number, errors: string[] }}
+ */
+export function syncCopyArtifacts(configDir) {
+  const result = { created: 0, skipped: 0, errors: [] }
+  const bump = (r) => {
+    result.created += r.created
+    result.skipped += r.skipped
+  }
+
+  // ── agents + routing.yml ──
+  try {
+    const dstAgents = join(configDir, 'agents')
+    if (existsSync(join(ROOT, 'src', 'agents'))) {
+      mkdirSync(dstAgents, { recursive: true })
+      bump(copyFiles(join(ROOT, 'src', 'agents'), dstAgents, false))
+      const routing = join(ROOT, 'src', 'routing.yml')
+      if (existsSync(routing)) {
+        if (
+          writeIfChanged(join(configDir, 'routing.yml'), readFileSync(routing, 'utf8'), false) ===
+          'created'
+        ) {
+          result.created++
+        } else result.skipped++
+      }
+    }
+  } catch (err) {
+    result.errors.push(`agents: ${err.message}`)
+  }
+
+  // ── skills ──
+  try {
+    const names = collectSkillNames()
+    if (names.length > 0) bump(installSkills(names, configDir, false, ''))
+  } catch (err) {
+    result.errors.push(`skills: ${err.message}`)
+  }
+
+  // ── instructions (AGENTS.md) ──
+  try {
+    const src = join(ROOT, 'AGENTS.md')
+    if (existsSync(src)) {
+      if (
+        writeIfChanged(join(configDir, 'AGENTS.md'), readFileSync(src, 'utf8'), false) === 'created'
+      ) {
+        result.created++
+      } else result.skipped++
+    }
+  } catch (err) {
+    result.errors.push(`instructions: ${err.message}`)
+  }
+
+  // ── commands (*.md) ──
+  try {
+    const srcCmds = join(ROOT, 'commands')
+    if (existsSync(srcCmds)) {
+      bump(syncDir(srcCmds, join(configDir, 'commands'), false, false, (f) => f.endsWith('.md')))
+    }
+  } catch (err) {
+    result.errors.push(`commands: ${err.message}`)
+  }
+
+  // ── runtime payload (MCP scripts, code-mode, tiers) ──
+  try {
+    const dstScripts = join(configDir, 'scripts')
+    mkdirSync(dstScripts, { recursive: true })
+    for (const [name, srcFn] of Object.entries(MCP_SCRIPTS)) {
+      const src = srcFn()
+      if (!existsSync(src)) continue
+      const content = readFileSync(src, 'utf8')
+      const dst = join(dstScripts, name)
+      if (writeIfChanged(dst, content, false) === 'created') {
+        statSync(dst)
+        result.created++
+      } else result.skipped++
+    }
+
+    const req = join(ROOT, 'src', 'mcp', 'requirements-vision.txt')
+    if (existsSync(req)) {
+      if (
+        writeIfChanged(
+          join(configDir, 'requirements-vision.txt'),
+          readFileSync(req, 'utf8'),
+          false,
+        ) === 'created'
+      ) {
+        result.created++
+      } else result.skipped++
+    }
+
+    const srcCodeMode = join(ROOT, '.pantheon', 'code-mode')
+    const dstCodeMode = join(configDir, '.pantheon', 'code-mode')
+    if (existsSync(srcCodeMode)) {
+      bump(syncDir(srcCodeMode, dstCodeMode, false, false))
+    }
+
+    const srcTiers = join(ROOT, '.pantheon', 'tiers.json')
+    const dstTiers = join(configDir, '.pantheon', 'tiers.json')
+    if (existsSync(srcTiers)) {
+      if (writeIfChanged(dstTiers, readFileSync(srcTiers, 'utf8'), false) === 'created')
+        result.created++
+      else result.skipped++
+    }
+  } catch (err) {
+    result.errors.push(`runtime: ${err.message}`)
+  }
+
+  return result
+}
+
+/** Drop stale entries in dst that no longer exist in src (agents/skills dirs). */
+export function pruneMissing(srcDir, dstDir) {
+  if (!existsSync(srcDir) || !existsSync(dstDir)) return 0
+  const src = new Set(readdirSync(srcDir))
+  let removed = 0
+  for (const entry of readdirSync(dstDir)) {
+    if (!src.has(entry)) {
+      rmSync(join(dstDir, entry), { recursive: true, force: true })
+      removed++
+    }
+  }
+  return removed
+}

package/scripts/sync-tui.mjs

@@ -13,7 +13,7 @@ import { execSync } from 'node:child_process'
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 const ROOT = join(__dirname, '..')
@@ -106,46 +106,136 @@ function copyPluginFiles(srcDir, dstDir) {
   return result
 }
 
-// ── Main ───────────────────────────────────────────────────────────────
+// ── npm env hygiene ────────────────────────────────────────────────────
 
-try {
-  const configDir = resolveConfigDir()
-  if (!configDir) {
-    // User hasn't run init yet — silent exit, no error
-    process.exit(0)
-  }
+/**
+ * npm lifecycle env vars that put a nested `npm ci` into global context and
+ * make it abort with ECIGLOBAL ("`npm ci` does not work for global packages").
+ * When the package itself is installed with `npm install -g`, npm injects these
+ * into the postinstall environment; the TUI dependency sync is a local
+ * operation and must never inherit them.
+ */
+const GLOBAL_NPM_ENV_KEYS = new Set([
+  'npm_config_global',
+  'npm_config_globalconfig',
+  'npm_config_prefix',
+  'npm_config_location',
+])
 
-  const tuiCopyDir = join(configDir, 'plugins', 'pantheon-tui')
-  if (!existsSync(tuiCopyDir)) {
-    // TUI plugin not installed — silent exit
-    process.exit(0)
+/**
+ * Return a copy of `env` with global-context npm config vars removed.
+ * Matching is case-insensitive so Windows-style uppercase keys are handled.
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {NodeJS.ProcessEnv}
+ */
+export function sanitizeNpmEnv(env = process.env) {
+  const clean = { ...env }
+  for (const key of Object.keys(clean)) {
+    if (GLOBAL_NPM_ENV_KEYS.has(key.toLowerCase())) delete clean[key]
   }
+  return clean
+}
 
-  // Source: TUI plugin inside the installed package
-  const tuiSrcDir = join(ROOT, 'src', 'plugins', 'tui')
-  if (!existsSync(tuiSrcDir)) {
-    throw new Error(`TUI plugin source not found: ${tuiSrcDir}`)
-  }
+// ── Main ───────────────────────────────────────────────────────────────
+
+async function main() {
+  try {
+    const configDir = resolveConfigDir()
+    if (!configDir) {
+      // User hasn't run init yet — silent exit, no error
+      process.exit(0)
+    }
 
-  // Compare versions before copy
-  const installedVersion = readVersion(join(tuiCopyDir, 'package.json'))
-  const sourceVersion = readVersion(join(tuiSrcDir, 'package.json'))
+    const tuiCopyDir = join(configDir, 'plugins', 'pantheon-tui')
+    if (!existsSync(tuiCopyDir)) {
+      // beta.5: no TUI install (plugins component omitted) — skip the TUI
+      // sync but STILL refresh the copy-only artifacts below.
+      const { syncCopyArtifacts } = await import('./sync-artifacts.mjs')
+      const synced = syncCopyArtifacts(configDir)
+      if (synced.errors.length > 0) {
+        for (const e of synced.errors) console.error(`  ⚠️  artifact sync: ${e}`)
+      }
+      console.log(
+        `  Artifacts synced: ${synced.created} updated, ${synced.skipped} already current`,
+      )
+      return
+    }
 
-  // Copy fresh files
-  const { created } = copyPluginFiles(tuiSrcDir, tuiCopyDir)
+    // Source: TUI plugin inside the installed package
+    const tuiSrcDir = join(ROOT, 'src', 'plugins', 'tui')
+    if (!existsSync(tuiSrcDir)) {
+      throw new Error(`TUI plugin source not found: ${tuiSrcDir}`)
+    }
 
-  // Lockfile installation is the only accepted dependency path.
-  execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: tuiCopyDir, stdio: 'pipe' })
+    // Compare versions before copy
+    const installedVersion = readVersion(join(tuiCopyDir, 'package.json'))
+    const sourceVersion = readVersion(join(tuiSrcDir, 'package.json'))
+
+    // Copy fresh files
+    const { created } = copyPluginFiles(tuiSrcDir, tuiCopyDir)
+
+    // Lockfile installation is the only accepted dependency path. Strip
+    // global-context npm vars so a global postinstall can't trigger ECIGLOBAL.
+    execSync('npm ci --omit=dev --no-audit --no-fund', {
+      cwd: tuiCopyDir,
+      stdio: 'pipe',
+      env: sanitizeNpmEnv(),
+    })
+
+    // Log result
+    if (installedVersion && sourceVersion && installedVersion === sourceVersion && created === 0) {
+      console.log(`  TUI plugin already up to date (v${sourceVersion})`)
+    } else {
+      console.log(
+        `  TUI plugin updated to v${sourceVersion || 'latest'}${installedVersion ? ` (was v${installedVersion})` : ''}`,
+      )
+    }
 
-  // Log result
-  if (installedVersion && sourceVersion && installedVersion === sourceVersion && created === 0) {
-    console.log(`  TUI plugin already up to date (v${sourceVersion})`)
-  } else {
-    console.log(
-      `  TUI plugin updated to v${sourceVersion || 'latest'}${installedVersion ? ` (was v${installedVersion})` : ''}`,
-    )
+    // ── beta.5 freshness guarantee: refresh ALL copy-only artifacts ──
+    // Agents, skills, AGENTS.md, commands, MCP scripts, code-mode payload.
+    // The plugin references in opencode.json already point INTO this package,
+    // so only the copies would go stale after a package update.
+    const { syncCopyArtifacts } = await import('./sync-artifacts.mjs')
+    const { readState, writeState } = await import('./install/state.mjs')
+    const pkgVersion = readVersion(join(ROOT, 'package.json')) ?? 'unknown'
+    const synced = syncCopyArtifacts(configDir)
+    if (synced.errors.length > 0) {
+      for (const e of synced.errors) console.error(`  ⚠️  artifact sync: ${e}`)
+    }
+    console.log(`  Artifacts synced: ${synced.created} updated, ${synced.skipped} already current`)
+
+    // Version marker so doctor can detect a stale installation and point the
+    // user at `pantheon-opencode update` for the full refresh (config merge,
+    // venv, MCP entries).
+    try {
+      const previous = readState(configDir)
+      writeState(configDir, {
+        pantheon_version: pkgVersion,
+        previous_version: previous?.pantheon_version ?? null,
+      })
+      if (previous?.pantheon_version && previous.pantheon_version !== pkgVersion) {
+        console.log(
+          `  ⚠️  Installation moved ${previous.pantheon_version} → ${pkgVersion}. ` +
+            'Run `npx pantheon-opencode init` to refresh config/venv/MCP entries.',
+        )
+      }
+    } catch {
+      // Marker is best-effort — never fail the postinstall over it.
+    }
+  } catch (err) {
+    console.error(`❌ TUI sync failed: ${err.message}`)
+    process.exitCode = 1
   }
-} catch (err) {
-  console.error(`❌ TUI sync failed: ${err.message}`)
-  process.exitCode = 1
+}
+
+// Only run when invoked directly (`node scripts/sync-tui.mjs`). Importing this
+// module for unit tests must not trigger the side-effecting postinstall sync.
+const isDirectRun =
+  Boolean(process.argv[1]) && pathToFileURL(process.argv[1]).href === import.meta.url
+
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error(`❌ TUI sync failed: ${err.message}`)
+    process.exitCode = 1
+  })
 }

package/src/agents/zeus.md

@@ -329,8 +329,8 @@ nunca redispara. Apos 1 retry vazio → escalate (mesma regra do TODO Enforcer).
 > Uso baixo-nível: `createZeusRetryHelper().executeWithRetry(first, () => secondRead())` — classifica empty e decide retry/escalate (mesmo cap 1).
 
 ### /cost — pantheon_cost tool (WIRED no plugin)
-`pantheon_cost({ days?: number })` le o `opencode.db` READ-ONLY (node:sqlite;
-fallback `scripts/cost.mjs`) e devolve tabela markdown de custo + tokens por
+`pantheon_cost({ days?: number })` le o `opencode.db` READ-ONLY usando o backend
+unico `node:sqlite`; se indisponivel, retorna `UNSUPPORTED`, sem fallback. Devolve tabela markdown de custo + tokens por
 agente nos ultimos N dias (default 7). Uso: quando Nyx pedir visibilidade de
 custo, ou antes de escalar tier — decida se o batch valeu o preco.