pantheon-opencode 1.4.3 → 1.5.0-beta.10

package/scripts/install/plugin.mjs

@@ -4,13 +4,12 @@
 
 import { execSync } from 'node:child_process'
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { warning } from './cli-ui.mjs'
-import { writeIfChanged } from './shared.mjs'
+import { isAbsolute, join, resolve } from 'node:path'
+import { ROOT, writeIfChanged } from './shared.mjs'
 
 /**
  * Copy a plugin's runtime payload (src/index.tsx → index.tsx, dist/*,
- * package.json) from source to destination. Pure file copy — no npm install.
+ * package.json and package-lock.json) from source to destination.
  * @param {string} srcDir - Source plugin directory (e.g. ROOT/src/plugins/tui)
  * @param {string} dstDir - Destination plugin directory
  * @param {object} [options]
@@ -58,6 +57,19 @@ export function copyPluginFiles(srcDir, dstDir, { dryRun = false } = {}) {
     else result.skipped++
   }
 
+  // Copy the lockfile so dependency installation is reproducible. A missing
+  // lockfile is intentionally not synthesized by the installer.
+  const lockSrc = join(srcDir, 'package-lock.json')
+  if (existsSync(lockSrc)) {
+    const lockStatus = writeIfChanged(
+      join(dstDir, 'package-lock.json'),
+      readFileSync(lockSrc, 'utf8'),
+      dryRun,
+    )
+    if (lockStatus === 'created') result.created++
+    else result.skipped++
+  }
+
   return result
 }
 
@@ -81,14 +93,10 @@ export function installPlugin(srcDir, dstDir, { dryRun = false, clean = false }
   result.created += copyResult.created
   result.skipped += copyResult.skipped
 
-  // Install plugin dependencies (@opentui/core, @opentui/solid, solid-js)
+  // Install plugin dependencies (@opentui/core, @opentui/solid, solid-js).
+  // Lockfile installation is the only accepted dependency path.
   if (!dryRun) {
-    try {
-      execSync('npm install --omit=dev --no-audit', { cwd: dstDir, stdio: 'pipe' })
-    } catch (e) {
-      warning(`Failed to install TUI plugin dependencies: ${e.message}`)
-      result.errors++
-    }
+    execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: dstDir, stdio: 'pipe' })
   }
 
   return result
@@ -102,11 +110,7 @@ export function installPlugin(srcDir, dstDir, { dryRun = false, clean = false }
  */
 export function installPluginDependencies(pluginDir, { dryRun = false } = {}) {
   if (dryRun) return
-  try {
-    execSync('npm install --omit=dev --no-audit', { cwd: pluginDir, stdio: 'pipe' })
-  } catch (e) {
-    warning(`Failed to install plugin dependencies: ${e.message}`)
-  }
+  execSync('npm ci --omit=dev --no-audit --no-fund', { cwd: pluginDir, stdio: 'pipe' })
 }
 
 /**
@@ -137,42 +141,70 @@ export function registerPlugin(tuiJsonPath, pluginId, { dryRun = false } = {}) {
 }
 
 /**
- * Suffix patterns that identify a Pantheon TUI registration as STALE. Every
- * reference shape ever written by previous installers must be covered:
- *   - dist file refs (both the old in-package src/plugins/tui target and the
- *     copied plugins/pantheon-tui target, tsx and js eras)
- *   - the in-package source dir (src/plugins/tui) — a registration pointing
- *     into the installed package breaks on reinstall/upgrade (the dir is
- *     replaced under a live registration)
- *   - bare copied dirs (plugins/pantheon-tui) from any OLD install target —
- *     indistinguishable from the current copied dir without knowing the
- *     install target, so they are flagged too; syncTuiRegistration keeps the
- *     current ref via unregister-then-register
- *   - node_modules copies (npx cache installs of the vendored plugin)
+ * Exact relative markers written by previous installers. These are intentionally
+ * complete references, not suffixes: a user-owned path may contain
+ * `pantheon-opencode` or end in the same filename without being ours.
  */
 export const TUI_STALE_SUFFIXES = [
-  '/src/plugins/tui/dist/tui.tsx',
-  '/src/plugins/tui/dist/tui.js',
-  '/src/plugins/tui',
-  '/plugins/pantheon-tui/dist/tui.tsx',
-  '/plugins/pantheon-tui/dist/tui.js',
-  '/plugins/pantheon-tui',
-  '/node_modules/pantheon-tui',
+  'plugins/pantheon-tui',
+  'plugins/pantheon-tui/dist/tui.tsx',
+  'plugins/pantheon-tui/dist/tui.js',
+  'npx pantheon-tui',
+  'npx -y pantheon-tui',
+  'npx:pantheon-tui',
+]
+
+const PACKAGE_TUI_PATHS = [
+  join(ROOT, 'src', 'plugins', 'tui'),
+  join(ROOT, 'src', 'plugins', 'tui', 'dist', 'tui.tsx'),
+  join(ROOT, 'src', 'plugins', 'tui', 'dist', 'tui.js'),
 ]
 
+function normalizePluginPath(ref) {
+  return ref.replaceAll('\\', '/')
+}
+
+function exactManagedPaths(knownPantheonPaths) {
+  return new Set(
+    [...PACKAGE_TUI_PATHS, ...knownPantheonPaths]
+      .filter((path) => typeof path === 'string')
+      .map((path) => normalizePluginPath(path)),
+  )
+}
+
+function isExactNpxMarker(ref) {
+  return (
+    /^npx(?:\s+-y)?\s+pantheon-tui(?:@[A-Za-z0-9._-]+)?$/i.test(ref) ||
+    /^npx:pantheon-tui(?:@[A-Za-z0-9._-]+)?$/i.test(ref) ||
+    /(?:^|\/)\.npm\/_npx\/[^/]+\/node_modules\/pantheon-tui(?:\/|$)/i.test(ref)
+  )
+}
+
 /**
- * Whether a single tui.json plugin entry is a stale Pantheon TUI reference.
+ * Return whether a registration is unambiguously one of our old TUI refs.
+ *
  * @param {unknown} ref - tui.json plugin entry
+ * @param {string[]} [knownPantheonPaths=[]] - paths owned by this installer
  * @returns {boolean}
  */
-export function isStaleTuiRef(ref) {
+export function isPantheonTuiRef(ref, knownPantheonPaths = []) {
   if (typeof ref !== 'string') return false
-  if (ref === 'plugins/pantheon-tui') return true
-  const normalized = ref.replaceAll('\\', '/')
-  // npx spec strings ("npx pantheon-tui", "npx -y pantheon-tui",
-  // "npx:pantheon-tui") and npx cache paths end with /node_modules/pantheon-tui.
-  if (/^npx[\s:]/i.test(normalized) && normalized.includes('pantheon-tui')) return true
-  return TUI_STALE_SUFFIXES.some((suffix) => normalized.endsWith(suffix))
+  const normalized = normalizePluginPath(ref)
+  if (TUI_STALE_SUFFIXES.includes(normalized)) return true
+  if (isExactNpxMarker(normalized)) return true
+
+  const knownPaths = exactManagedPaths(knownPantheonPaths)
+  if (knownPaths.has(normalized)) return true
+  return isAbsolute(normalized) && knownPaths.has(normalizePluginPath(resolve(normalized)))
+}
+
+/**
+ * Whether a single tui.json plugin entry is a stale Pantheon TUI reference.
+ * @param {unknown} ref - tui.json plugin entry
+ * @returns {boolean}
+ */
+export function isStaleTuiRef(ref, knownPantheonPaths = []) {
+  return isPantheonTuiRef(ref, knownPantheonPaths)
 }
 
 /**
@@ -181,8 +213,10 @@ export function isStaleTuiRef(ref) {
  * @param {unknown[]} pluginArray - tui.json plugin array
  * @returns {string[]}
  */
-export function staleTuiRefs(pluginArray) {
-  return (Array.isArray(pluginArray) ? pluginArray : []).filter(isStaleTuiRef)
+export function staleTuiRefs(pluginArray, knownPantheonPaths = []) {
+  return (Array.isArray(pluginArray) ? pluginArray : []).filter((ref) =>
+    isStaleTuiRef(ref, knownPantheonPaths),
+  )
 }
 
 /**
@@ -193,7 +227,11 @@ export function staleTuiRefs(pluginArray) {
  * @param {boolean} [options.dryRun=false]
  * @returns {'created'|'skipped'}
  */
-export function unregisterPlugin(tuiJsonPath, pluginId, { dryRun = false } = {}) {
+export function unregisterPlugin(
+  tuiJsonPath,
+  pluginId,
+  { dryRun = false, knownPantheonPaths = [] } = {},
+) {
   if (!existsSync(tuiJsonPath)) {
     // Nothing to clean — and never create an empty tui.json in a location
     // OpenCode reads (the cross-location cleanup also touches global config
@@ -215,10 +253,12 @@ export function unregisterPlugin(tuiJsonPath, pluginId, { dryRun = false } = {})
   // bare copy dirs from previous install targets, and npx cache copies.
   // Without removing the absolute paths, each init run accumulates another
   // TUI plugin and OpenCode loads stale copies.
-  const exactStale = [pluginId, `${pluginId}/dist/tui.tsx`, `${pluginId}/dist/tui.js`]
+  const exactStale = new Set(
+    [pluginId, `${pluginId}/dist/tui.tsx`, `${pluginId}/dist/tui.js`].map(normalizePluginPath),
+  )
   tuiConfig.plugin = tuiConfig.plugin.filter((ref) => {
-    if (exactStale.includes(ref)) return false
-    return !isStaleTuiRef(ref)
+    if (typeof ref === 'string' && exactStale.has(normalizePluginPath(ref))) return false
+    return !isPantheonTuiRef(ref, knownPantheonPaths)
   })
   const tuiContent = `${JSON.stringify(tuiConfig, null, 2)}\n`
   return writeIfChanged(tuiJsonPath, tuiContent, dryRun)

package/scripts/install/shared.mjs

@@ -1,13 +1,16 @@
 /**
- * shared.mjs — Shared utilities for Pantheon platform installers
+ * 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,
@@ -26,8 +29,6 @@ import yaml from 'js-yaml'
 export const __dirname = dirname(fileURLToPath(import.meta.url))
 export const ROOT = join(__dirname, '..', '..')
 export const AGENTS_DIR = join(ROOT, 'src', 'agents')
-// PLATFORM_DIR is deprecated — platform/ was removed in v1.0
-export const PLATFORM_DIR = join(ROOT, 'platform')
 
 // Auto-detect agent names from agents/ directory
 export function getAgentNames() {
@@ -43,33 +44,7 @@ export function getAgentNames() {
 // Cached constant for backward compatibility
 export const AGENT_NAMES = getAgentNames()
 
-// DEPRECATED: OpenCode-only since v1.0
-export const PLATFORM_DETECTORS = {
-  opencode: (target) =>
-    existsSync(join(target, 'opencode.json')) ||
-    existsSync(join(target, 'platform', 'opencode', 'opencode.json')),
-  claude: (target) => existsSync(join(target, '.claude')) || existsSync(join(target, 'CLAUDE.md')),
-  cursor: (target) =>
-    existsSync(join(target, '.cursor')) || existsSync(join(target, '.cursorrules')),
-  windsurf: (target) =>
-    existsSync(join(target, '.windsurf')) || existsSync(join(target, '.windsurfrules')),
-  copilot: (target) =>
-    existsSync(join(target, '.github', 'copilot-instructions.md')) ||
-    existsSync(join(target, '.vscode')),
-  continue: (target) =>
-    existsSync(join(target, '.continue', 'config.yaml')) || existsSync(join(target, '.continue')),
-  cline: (target) => existsSync(join(target, '.clinerules')),
-}
-
-export const summary = {
-  opencode: { created: 0, skipped: 0, errors: 0 },
-  claude: { created: 0, skipped: 0, errors: 0 },
-  cursor: { created: 0, skipped: 0, errors: 0 },
-  windsurf: { created: 0, skipped: 0, errors: 0 },
-  copilot: { created: 0, skipped: 0, errors: 0 },
-  continue: { created: 0, skipped: 0, errors: 0 },
-  cline: { created: 0, skipped: 0, errors: 0 },
-}
+export const summary = { opencode: { created: 0, skipped: 0, errors: 0, warnings: 0 } }
 
 export function showHelp() {
   console.log(`
@@ -78,9 +53,7 @@ pantheon-init.mjs — Pantheon OpenCode installer
 Usage:
   npx pantheon-opencode init                                        auto-detect, cwd
   npx pantheon-opencode init --project                              auto-detect, project
-  npx pantheon-opencode init --project --platforms opencode,claude  specific platforms
-  npx pantheon-opencode init --project --platforms all              all platforms
-  npx pantheon-opencode init --detect                               detect platforms without installing
+  npx pantheon-opencode init --project                              install in a project
   npx pantheon-opencode init --project --dry-run                    preview without writing
   npx pantheon-opencode init --project --backup                     create timestamped backup before writing
   npx pantheon-opencode init --project --clean                      wipe + fresh install (all components)
@@ -101,19 +74,8 @@ Clean mode (--clean):
   re-installs fresh from source. Useful after removing/renaming agents or skills.
   OFF by default — without --clean only copies new/changed files (never deletes).
 
-Platforms:
+Platform:
   opencode    → .opencode/agents/ + opencode.json
-  claude       → .claude/agents/ + CLAUDE.md + settings.json
-  cursor       → .cursor/rules/ (renamed .mdc files)
-  windsurf     → .windsurf/agents/ + .windsurfrules
-  copilot      → .github/agents/ symlinks + .vscode/settings.json check
-  continue     → .continue/rules/ + .continue/config.yaml
-  cline        → .clinerules/ (no extension, plain markdown)
-  all          → install every platform
-
-When --platforms is omitted, the script auto-detects which platforms
-the target project already supports (based on config files present).
-If none are detected, ALL platforms are installed.
 `)
 }
 
@@ -206,63 +168,25 @@ export function createBackup(target) {
 }
 
 export function detectAndReport(target) {
-  const PLATFORM_LABELS = {
-    opencode: 'OpenCode',
-    claude: 'Claude Code',
-    cursor: 'Cursor',
-    windsurf: 'Windsurf',
-    copilot: 'VS Code / Copilot',
-    continue: 'Continue.dev',
-    cline: 'Cline',
-  }
-
-  const CONFIG_FILES = {
-    opencode: () => 'opencode.json',
-    claude: () => '.claude/ or CLAUDE.md',
-    cursor: () => '.cursor/ or .cursorrules',
-    windsurf: () => '.windsurf/ or .windsurfrules',
-    copilot: () => '.github/copilot-instructions.md or .vscode/',
-    continue: () => '.continue/config.yaml or .continue/',
-    cline: () => '.clinerules',
-  }
+  const found = detectPlatforms(target).length > 0
 
   console.log(`\n  🔍 Pantheon Platform Detection`)
   console.log(`     Target: ${target}\n`)
 
-  const results = []
-  for (const [platform, detector] of Object.entries(PLATFORM_DETECTORS)) {
-    const found = detector(target)
-    results.push({ platform, found })
-  }
-
-  // Table header
   console.log(`  ${'Platform'.padEnd(12)} ${'Detected?'.padEnd(12)} Config file`)
   console.log(`  ${'─'.repeat(55)}`)
-
-  const detected = results.filter((r) => r.found)
-  for (const r of results) {
-    const status = r.found ? '✅ YES' : '❌ no'
-    const configFile = r.found ? CONFIG_FILES[r.platform]() : '(not found)'
-    console.log(`  ${PLATFORM_LABELS[r.platform].padEnd(12)} ${status.padEnd(12)} ${configFile}`)
-  }
-
-  console.log(`\n  📊 ${detected.length} of ${results.length} platforms detected.`)
-  if (detected.length > 0) {
-    const names = detected.map((r) => r.platform).join(',')
-    console.log(`  → Install with: npx pantheon-opencode init --platforms ${names}`)
+  const status = (found ? '✅ YES' : '❌ no').padEnd(12)
+  console.log(`  ${'OpenCode'.padEnd(12)} ${status} ${found ? 'opencode.json' : '(not found)'}`)
+  console.log(`\n  📊 ${found ? 1 : 0} of 1 platforms detected.`)
+  if (found) {
+    console.log('  → Install with: npx pantheon-opencode init')
   }
 
-  return detected.map((r) => r.platform)
+  return found ? ['opencode'] : []
 }
 
 export function detectPlatforms(target) {
-  const detected = []
-  for (const [platform, detector] of Object.entries(PLATFORM_DETECTORS)) {
-    if (detector(target)) {
-      detected.push(platform)
-    }
-  }
-  return detected
+  return existsSync(join(target, 'opencode.json')) ? ['opencode'] : []
 }
 
 export function sourceDirValid(dir) {
@@ -339,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 []
@@ -569,16 +531,6 @@ export function validateMcpServers(mcpServers, _agentTools = []) {
 }
 
 export function printSummary(target, platforms) {
-  const PLATFORM_LABELS = {
-    opencode: 'OpenCode',
-    claude: 'Claude Code',
-    cursor: 'Cursor',
-    windsurf: 'Windsurf',
-    copilot: 'VS Code / Copilot',
-    continue: 'Continue.dev',
-    cline: 'Cline',
-  }
-
   console.log('')
   console.log('='.repeat(60))
   console.log('📋 Installation Summary')
@@ -590,7 +542,7 @@ export function printSummary(target, platforms) {
   let totalErrors = 0
 
   for (const platform of platforms) {
-    const label = PLATFORM_LABELS[platform] ?? platform
+    const label = platform === 'opencode' ? 'OpenCode' : platform
     const stats = summary[platform]
     totalCreated += stats.created
     totalSkipped += stats.skipped
@@ -624,62 +576,6 @@ export function printSummary(target, platforms) {
     console.log('')
   }
 
-  if (platforms.includes('claude')) {
-    console.log('  Claude Code:')
-    console.log(`    - Run \`claude\` in ${target}`)
-    console.log('    - Agents in .claude/agents/')
-    console.log('    - Skills in .claude/skills/')
-    console.log('    - Settings in .claude/settings.json')
-    console.log('')
-  }
-
-  if (platforms.includes('cursor')) {
-    console.log('  Cursor:')
-    console.log(`    - Rules in .cursor/rules/ (.mdc format)`)
-    console.log('    - Skills in .cursor/skills/')
-    console.log('    - AGENTS.md in project root')
-    console.log('    - Use @agent-name in Agent mode')
-    console.log('')
-  }
-
-  if (platforms.includes('windsurf')) {
-    console.log('  Windsurf (Cascade):')
-    console.log(`    - Rules in .windsurf/rules/`)
-    console.log('    - Skills in .windsurf/skills/')
-    console.log('    - Workflows in .windsurf/workflows/ (/orchestrate, /code-review)')
-    console.log('    - AGENTS.md in project root')
-    console.log('')
-  }
-
-  if (platforms.includes('copilot')) {
-    console.log('  VS Code / Copilot:')
-    console.log(`    - Agents in .github/agents/`)
-    console.log('    - Ensure .vscode/settings.json has plugin config')
-    console.log('    - Use @agent-name in VS Code Copilot Chat')
-    console.log('    - Plugin manifest in plugin.json')
-    console.log('')
-  }
-
-  if (platforms.includes('continue')) {
-    console.log('  Continue.dev:')
-    console.log(`    - Rules in .continue/rules/`)
-    console.log('    - Config in .continue/config.yaml')
-    console.log('    - Rules are injected into system prompts (no @name invocation)')
-    console.log('    - Edit config.yaml to set API keys and models')
-    console.log('    - Use /reload to apply config changes')
-    console.log('')
-  }
-
-  if (platforms.includes('cline')) {
-    console.log('  Cline:')
-    console.log(`    - Agent rules in .clinerules/ (no extension, plain markdown)`)
-    console.log('    - Skills in .clinerules/skills/')
-    console.log('    - Commands in .clinerules/commands/')
-    console.log('    - AGENTS.md in project root')
-    console.log('    - Invoke agents with @agent-name in Cline chat')
-    console.log('')
-  }
-
   console.log('  📚 Full documentation: https://github.com/ils15/pantheon')
   console.log('  🐛 Report issues: https://github.com/ils15/pantheon/issues')
 }

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