pantheon-opencode 1.5.0-beta.1 → 1.5.0-beta.11

package/scripts/install/opencode.mjs

@@ -12,6 +12,7 @@
  * isolation is handled at runtime via OPENCODE_DB.
  */
 
+import { createHash } from 'node:crypto'
 import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { dirname, isAbsolute, join, resolve } from 'node:path'
@@ -34,6 +35,7 @@ import { detectVersion, runMigrations } from './migrate.mjs'
 import { resolveOpenCodeVersion } from './opencode-version.mjs'
 import { copyPluginFiles, installPlugin, registerPlugin, unregisterPlugin } from './plugin.mjs'
 import {
+  checkRuntimePrerequisites,
   collectSkillNames,
   copyFiles,
   installSkills,
@@ -42,8 +44,10 @@ import {
   sourceDirValid,
   summary,
   syncDir,
+  writeConfigWithBackup,
   writeIfChanged,
 } from './shared.mjs'
+import { strings } from './strings.mjs'
 
 import { setupVenv, venvPythonPath } from './venv.mjs'
 
@@ -61,6 +65,34 @@ function deepClone(value) {
   return JSON.parse(JSON.stringify(value))
 }
 
+/**
+ * (Re)generate the code-mode manifest with SHA-256 digests for every bundled
+ * script. This is the explicit installation opt-in: the MCP server only
+ * executes scripts listed here whose on-disk hash matches. Missing or empty
+ * directories approve nothing (0) — execution is never implicit.
+ */
+function writeCodeModeManifest(dir, dryRun) {
+  if (!existsSync(dir)) return 0
+  let names
+  try {
+    names = readdirSync(dir)
+      .filter((name) => /\.(sh|py)$/i.test(name) && !name.startsWith('.'))
+      .sort()
+  } catch {
+    return 0
+  }
+  if (names.length === 0) return 0
+  const scripts = {}
+  for (const name of names) {
+    scripts[name] = createHash('sha256')
+      .update(readFileSync(join(dir, name)))
+      .digest('hex')
+  }
+  const payload = `${JSON.stringify({ version: 1, scripts }, null, 2)}\n`
+  writeIfChanged(join(dir, 'manifest.json'), payload, dryRun)
+  return names.length
+}
+
 function readJsonConfig(filePath) {
   if (!existsSync(filePath)) return {}
 
@@ -185,6 +217,21 @@ function managedPluginIdentity(ref) {
     if (absolutePath === normalizePluginPath(resolve(ROOT, PANTHEON_V2_LEGACY_FILE))) {
       return PANTHEON_V2_PLUGIN
     }
+    // beta.5: stale refs from OTHER installed copies of this package (older
+    // nvm prefixes, npx cache hashes). Only paths inside
+    // `node_modules/pantheon-opencode/` count as installed copies — a dev
+    // checkout elsewhere (e.g. a vendor folder named pantheon-opencode) remains
+    // protected by the third-party rule above.
+    const installedMarker = '/node_modules/pantheon-opencode/'
+    const withSlashes = normalizePluginPath(normalized)
+    const markerIndex = withSlashes.lastIndexOf(installedMarker)
+    if (markerIndex !== -1) {
+      const suffix = withSlashes.slice(markerIndex + installedMarker.length)
+      if (suffix === PANTHEON_V1_PLUGIN) return PANTHEON_V1_PLUGIN
+      if (suffix === PANTHEON_V1_HOOKS) return PANTHEON_V1_HOOKS
+      if (suffix === PANTHEON_V2_PLUGIN) return PANTHEON_V2_PLUGIN
+      if (suffix === PANTHEON_V2_LEGACY_FILE) return PANTHEON_V2_PLUGIN
+    }
   }
 
   return null
@@ -343,6 +390,45 @@ export function syncTuiRegistration(target, { isGlobal = false, dryRun = false }
   return registerPlugin(targetTuiConfigPath, tuiCopyDir, { dryRun })
 }
 
+/**
+ * beta.5: set up the Python venv + run the health check. Never throws —
+ * failures are reported as warnings and return false so the caller omits
+ * MCP entries from the config (entries pointing at a missing venv would
+ * make every MCP fail to launch). `deps` is injectable for tests.
+ */
+export function setupRuntimePhase(target, { dryRun, clean, isGlobal }, stats, deps = {}) {
+  const S = strings()
+  const setup = deps.setupVenv ?? setupVenv
+  const check = deps.healthCheck ?? healthCheck
+  try {
+    const venvSpinner = spinner(S.settingUpRuntime)
+    setup(target, { dryRun, force: clean })
+    venvSpinner(true)
+    const runtimeTarget = isGlobal ? target : join(target, '.opencode')
+    const health = check(runtimeTarget, { dryRun, pythonTarget: target })
+
+    section(`\uD83D\uDD0D ${S.healthSection}`)
+    const healthStep = step(S.runningHealthChecks)
+    for (const p of health.passed) success(`${p.check}: ${p.detail}`)
+    for (const w of health.warnings) warning(`${w.check}: ${w.detail}`)
+    for (const f of health.failed) error(`${f.check}: ${f.detail}`)
+
+    if (health.failed.length > 0) {
+      healthStep(false)
+      warning(`${health.failed.length} check(s) failed — review above`)
+      stats.warnings += health.failed.length
+      return false
+    }
+    healthStep(true)
+    return true
+  } catch (err) {
+    error(S.runtimeFailed(err.message))
+    warning(S.runtimeSkippedMcp)
+    stats.warnings += 1
+    return false
+  }
+}
+
 export async function installOpenCode(
   target,
   dryRun = false,
@@ -357,6 +443,7 @@ export async function installOpenCode(
 
   const componentSet = new Set(components)
   const stats = summary.opencode
+  const S = strings()
 
   // V1/V2 dual-version awareness (Phase 3): the installer builds a unified
   // config, then applies V2-native migration (migrateV1toV2) when
@@ -405,6 +492,17 @@ export async function installOpenCode(
   const config = readJsonConfig(targetConfigPath)
   const pantheonConfig = readJsonConfig(pantheonConfigPath)
 
+  // beta.5 preflight: fail BEFORE any files are written when the runtime
+  // component needs toolchain pieces that are missing. Nothing has been
+  // copied yet at this point, so the failure is clean.
+  if (componentSet.has('runtime') && !dryRun) {
+    const missing = checkRuntimePrerequisites()
+    if (missing.length > 0) {
+      for (const problem of missing) error(problem)
+      throw new Error(S.prereqMissing)
+    }
+  }
+
   // Determine layout based on install scope.
   // Global config dir (~/.opencode or ~/.config/opencode) uses a flat layout:
   //   agents/   skills/   commands/   plugins/
@@ -417,7 +515,7 @@ export async function installOpenCode(
   configure({ dryRun })
 
   if (isGlobal) {
-    info('Global config directory detected — using flat layout (agents/, skills/, commands/)')
+    info(S.globalLayout)
   }
 
   // -----------------------------------------------------------------------
@@ -430,7 +528,7 @@ export async function installOpenCode(
       warning(`Agent source directory not found: ${srcDir}`)
       stats.errors++
     } else {
-      const agentStep = step('Installing agents')
+      const agentStep = step(S.installingAgents)
       const dstDir = isGlobal ? join(target, 'agents') : join(target, '.opencode', 'agents')
       if (!dryRun) mkdirSync(dstDir, { recursive: true })
       if (clean && existsSync(dstDir) && !dryRun) {
@@ -665,6 +763,13 @@ export async function installOpenCode(
       stats.created++
     }
 
+    // B3-08: explicit installation mode — seed the manifest with SHA-256
+    // digests so the server never executes a script implicitly.
+    const approvedScripts = writeCodeModeManifest(dstCodeModeDir, dryRun)
+    if (approvedScripts > 0) {
+      info(`Code-mode manifest: ${approvedScripts} script(s) approved`)
+    }
+
     // ── tiers.json ──
     const srcTiers = join(ROOT, '.pantheon', 'tiers.json')
     const dstTiers = join(runtimeTarget, '.pantheon', 'tiers.json')
@@ -676,6 +781,17 @@ export async function installOpenCode(
     }
   }
 
+  // -----------------------------------------------------------------------
+  // 2.11 Setup virtual environment + health check (--components runtime)
+  // beta.5: runs BEFORE the config write and is no longer fatal — on failure
+  // the install completes without MCP entries (which would point at a venv
+  // that does not exist) instead of aborting a half-done installation.
+  // -----------------------------------------------------------------------
+  let runtimeHealthy = !componentSet.has('runtime')
+  if (componentSet.has('runtime')) {
+    runtimeHealthy = setupRuntimePhase(target, { dryRun, clean, isGlobal }, stats)
+  }
+
   // -----------------------------------------------------------------------
   // 3. Create/update opencode.json (always runs)
   //    Reads TARGET's existing config first, then merges Pantheon settings
@@ -1017,8 +1133,10 @@ export async function installOpenCode(
 
   // --------------------------------------------------------------------
   // F.5 MCP server entries (for runtime-deployed scripts)
+  // beta.5: skipped when the Python runtime setup failed — entries pointing
+  // at a venv that does not exist would make every MCP fail to launch.
   // --------------------------------------------------------------------
-  if (componentSet.has('runtime')) {
+  if (componentSet.has('runtime') && runtimeHealthy) {
     config.mcp = config.mcp || {}
     // MCP stays a flat named-server map for BOTH V1 and V2: OpenCode 1.18.x
     // has no `mcp.servers` wrapper and rejects one with
@@ -1102,12 +1220,12 @@ export async function installOpenCode(
   // before writing. V1 path is untouched (zero regression).
   let configToWrite = config
   if (version === 'v2') {
-    info('Migrating config to V2 native format...')
+    info(S.v2Migrating)
     configToWrite = migrateV1toV2(config)
   }
 
   const configContent = `${JSON.stringify(configToWrite, null, 2)}\n`
-  const status = writeIfChanged(targetConfigPath, configContent, dryRun)
+  const status = writeConfigWithBackup(targetConfigPath, configContent, dryRun)
   if (status === 'created') stats.created++
   else stats.skipped++
 
@@ -1128,40 +1246,15 @@ export async function installOpenCode(
   }
 
   // -----------------------------------------------------------------------
-  // 4. Setup virtual environment + health check (--components runtime)
+  // 4. (runtime setup moved to 2.11 — before the config write — so MCP
+  //    entries are only added when the Python runtime is actually healthy)
   // -----------------------------------------------------------------------
-  if (componentSet.has('runtime')) {
-    try {
-      const venvSpinner = spinner('Setting up Python virtual environment')
-      setupVenv(target, { dryRun, force: clean })
-      venvSpinner(true)
-      const runtimeTarget = isGlobal ? target : join(target, '.opencode')
-      const health = healthCheck(runtimeTarget, { dryRun, pythonTarget: target })
-
-      // Print health summary
-      section('\uD83D\uDD0D Health Check')
-      const healthStep = step('Running health checks')
-      for (const p of health.passed) success(`${p.check}: ${p.detail}`)
-      for (const w of health.warnings) warning(`${w.check}: ${w.detail}`)
-      for (const f of health.failed) error(`${f.check}: ${f.detail}`)
-
-      if (health.failed.length > 0) {
-        healthStep(false)
-        warning(`${health.failed.length} check(s) failed — review above`)
-        stats.errors += health.failed.length
-      } else {
-        healthStep(true)
-      }
-    } catch (err) {
-      error(`Setup failed: ${err.message}`)
-      throw err // Fatal — abort installation
-    }
-  }
 
   if (interactive && !dryRun) {
     const created = stats.created
     const skipped = stats.skipped
     const errors = stats.errors
+    const warnings = stats.warnings ?? 0
 
     process.stdout.write('\n')
     process.stdout.write(
@@ -1179,11 +1272,14 @@ export async function installOpenCode(
       process.stdout.write(`  ${colors.dim('\u2014')} ${skipped} already up-to-date\n`)
     if (errors > 0)
       process.stdout.write(`  ${colors.yellow('\u26a0')} ${errors} error(s) encountered\n`)
+    if (warnings > 0)
+      process.stdout.write(
+        `  ${colors.yellow('\u26a0')} ${warnings} warning(s) — run 'pantheon-opencode doctor' for details\n`,
+      )
     process.stdout.write('\n')
     process.stdout.write(`  ${colors.bold('Next steps:')}\n`)
     process.stdout.write(`  ${colors.dim('\u2022')} Configure agents in opencode.json\n`)
-    process.stdout.write(`  ${colors.dim('\u2022')} Add MCP servers in mcp.json\n`)
-    process.stdout.write(`  ${colors.dim('\u2022')} Run 'opencode doctor' to verify\n`)
+    process.stdout.write(`  ${colors.dim('\u2022')} Run 'pantheon-opencode doctor' to verify\n`)
     process.stdout.write(
       `  ${colors.dim('\u2022')} Run 'opencode' to start using Pantheon agents\n`,
     )
@@ -1207,4 +1303,10 @@ export async function installOpenCode(
     const { writeActivePreset } = await import('./model-picker.mjs')
     writeActivePreset(target, opts.preset, { source: 'cli' })
   }
+
+  // Fail-closed: accumulated stats.errors (bad sources, missing requirements,
+  // failed health checks) must never masquerade as a successful installation.
+  if (stats.errors > 0) {
+    throw new Error(`installation completed with ${stats.errors} error(s); see output above`)
+  }
 }

package/scripts/install/plugin.mjs

@@ -5,7 +5,6 @@
 import { execSync } from 'node:child_process'
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs'
 import { isAbsolute, join, resolve } from 'node:path'
-import { warning } from './cli-ui.mjs'
 import { ROOT, writeIfChanged } from './shared.mjs'
 
 /**
@@ -95,31 +94,9 @@ export function installPlugin(srcDir, dstDir, { dryRun = false, clean = false }
   result.skipped += copyResult.skipped
 
   // Install plugin dependencies (@opentui/core, @opentui/solid, solid-js).
-  // npm ci is deterministic when the copied lockfile is present. The legacy
-  // fallback is opt-in because npm install may rewrite the dependency graph.
+  // Lockfile installation is the only accepted dependency path.
   if (!dryRun) {
-    try {
-      execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: dstDir, stdio: 'pipe' })
-    } catch (e) {
-      if (process.env.PANTHEON_ALLOW_NPM_INSTALL_FALLBACK === '1') {
-        warning(`npm ci failed; explicit fallback enabled: ${e.message}`)
-        try {
-          execSync('npm install --omit=dev --no-audit --no-fund --package-lock=false', {
-            cwd: dstDir,
-            stdio: 'pipe',
-          })
-        } catch (fallbackError) {
-          warning(`Failed to install TUI plugin dependencies: ${fallbackError.message}`)
-          result.errors++
-        }
-      } else {
-        warning(
-          `npm ci failed; dependencies were not changed. Set ` +
-            `PANTHEON_ALLOW_NPM_INSTALL_FALLBACK=1 to explicitly allow npm install: ${e.message}`,
-        )
-        result.errors++
-      }
-    }
+    execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: dstDir, stdio: 'pipe' })
   }
 
   return result
@@ -133,14 +110,7 @@ export function installPlugin(srcDir, dstDir, { dryRun = false, clean = false }
  */
 export function installPluginDependencies(pluginDir, { dryRun = false } = {}) {
   if (dryRun) return
-  try {
-    execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: pluginDir, stdio: 'pipe' })
-  } catch (e) {
-    warning(
-      `npm ci failed; dependencies were not changed. Set ` +
-        `PANTHEON_ALLOW_NPM_INSTALL_FALLBACK=1 to explicitly allow npm install: ${e.message}`,
-    )
-  }
+  execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: pluginDir, stdio: 'pipe' })
 }
 
 /**

package/scripts/install/shared.mjs

@@ -2,12 +2,15 @@
  * shared.mjs — Shared utilities for the OpenCode installer
  */
 
+import { spawnSync } from 'node:child_process'
 import {
+  copyFileSync,
   cpSync,
   existsSync,
   mkdirSync,
   readdirSync,
   readFileSync,
+  renameSync,
   rmSync,
   statSync,
   writeFileSync,
@@ -41,7 +44,7 @@ export function getAgentNames() {
 // Cached constant for backward compatibility
 export const AGENT_NAMES = getAgentNames()
 
-export const summary = { opencode: { created: 0, skipped: 0, errors: 0 } }
+export const summary = { opencode: { created: 0, skipped: 0, errors: 0, warnings: 0 } }
 
 export function showHelp() {
   console.log(`
@@ -260,11 +263,49 @@ export function writeIfChanged(filePath, content, dryRun) {
     return 'skipped'
   }
   if (!dryRun) {
-    writeFileSync(filePath, content, 'utf8')
+    // Atomic write: write a temp sibling and rename over the target so a
+    // crash mid-write can never leave a truncated file behind (rename is
+    // atomic within the same directory).
+    const tmpPath = `${filePath}.tmp-${process.pid}`
+    writeFileSync(tmpPath, content, 'utf8')
+    renameSync(tmpPath, filePath)
   }
   return 'created'
 }
 
+/**
+ * beta.5: write the user's opencode.json with a same-directory backup of the
+ * previous content. The installer rewrites the whole config; a `.bak` gives
+ * the user a one-step recovery if a merge ever goes wrong.
+ */
+export function writeConfigWithBackup(filePath, content, dryRun) {
+  if (!dryRun && existsSync(filePath)) {
+    copyFileSync(filePath, `${filePath}.bak`)
+  }
+  return writeIfChanged(filePath, content, dryRun)
+}
+
+/**
+ * beta.5 preflight: verify the toolchain pieces the runtime component needs
+ * BEFORE any files are written, so a missing python3/npm fails in seconds
+ * with a clear message instead of aborting a half-done install.
+ * Returns a list of human-readable problems (empty = all good).
+ */
+export function checkRuntimePrerequisites(env = process.env) {
+  const problems = []
+  const checks = [
+    { cmd: 'python3', hint: 'install Python 3.10+ (https://www.python.org/downloads/)' },
+    { cmd: 'npm', hint: 'install Node.js 22+ (https://nodejs.org) — npm ships with it' },
+  ]
+  for (const { cmd, hint } of checks) {
+    const probe = spawnSync(cmd, ['--version'], { encoding: 'utf8', timeout: 10_000, env })
+    if (probe.error || probe.status !== 0) {
+      problems.push(`${cmd} not found or not runnable — ${hint}`)
+    }
+  }
+  return problems
+}
+
 export function collectSkillNames() {
   const skillsDir = join(ROOT, 'src', 'skills')
   if (!existsSync(skillsDir)) return []

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: [],