pantheon-opencode 1.4.1 → 1.4.3

package/scripts/generate-preset-docs.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+/**
+ * generate-preset-docs.mjs — Generate markdown tables from src/routing.yml
+ *
+ * Reads routing.yml + presets.mjs + model-picker.mjs and prints:
+ *  1) Presets summary table (perfil | provider/baseURL | key env | pricing 2026 | vision | papéis)
+ *  2) 14 agents × 4 presets matrix (model + effort + vision)
+ *  3) Capability table (model prefix → maxEffort, vision)
+ *
+ * No secrets are hardcoded — only env var NAMES and baseURLs from routing.yml
+ * are emitted. Pricing labels come from model-picker PRESET_PRICE.
+ *
+ * Usage:
+ *   node scripts/generate-preset-docs.mjs         # print all
+ *   node scripts/generate-preset-docs.mjs --summary  # only summary
+ *   node scripts/generate-preset-docs.mjs --matrix   # only matrix
+ *   node scripts/generate-preset-docs.mjs --json     # JSON for tooling
+ */
+
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import yaml from 'js-yaml'
+import { CAPABILITY_TABLE, hasVision, normalizeCapability } from '../src/pantheon/presets.mjs'
+import { PRESET_PRICE } from './install/model-picker.mjs'
+
+const routingPath = fileURLToPath(new URL('../src/routing.yml', import.meta.url))
+const raw = readFileSync(routingPath, 'utf8')
+const routing = yaml.load(raw)
+const presets = routing?.presets ?? {}
+
+const KNOWN_AGENTS_ORDER = ['zeus','athena','themis','hermes','aphrodite','demeter','prometheus','hephaestus','apollo','nyx','gaia','iris','mnemosyne','talos']
+
+function agentSort(a,b){ const ia = KNOWN_AGENTS_ORDER.indexOf(a); const ib = KNOWN_AGENTS_ORDER.indexOf(b); if(ia===-1&&ib===-1) return a.localeCompare(b); if(ia===-1) return 1; if(ib===-1) return -1; return ia-ib; }
+
+function safeEnvLabel(_apiKeyEnv){
+  return '`[redacted]`'
+}
+
+function providerLabel(def){
+  const entries = Object.entries(def.providers ?? {})
+  if(entries.length===0) return '—'
+  return entries.map(([id,p]) => `\`${id}\` \`${p.baseURL ?? ''}\` (env: ${safeEnvLabel(p.apiKeyEnv)})`).join('<br>')
+}
+
+function pricingLabel(name){
+  const p = PRESET_PRICE[name]
+  if(!p) return '—'
+  return `${p.label} — ${p.detail}`
+}
+
+function visionLabel(def){
+  if(!def.vision) return '—'
+  const m = def.vision.model
+  let visionFlag = '—'
+  try{ visionFlag = hasVision(m) ? '👁️ vision' : 'text-only' }catch{ visionFlag = 'unknown' }
+  return `\`${m}\` [${def.vision.reasoning_effort ?? ''}] ${visionFlag}`
+}
+
+function capabilityBadge(model){
+  try{
+    const v = hasVision(model)
+    const cap = normalizeCapability(model, 'high')
+    // cap.variant is clamped effort for 'high'
+    // also get maxEffort via capabilityEntry
+    const entry = CAPABILITY_TABLE.find(e => model.startsWith(e.prefix) || model.slice(model.lastIndexOf('/')+1).startsWith(e.prefix) || model.slice(model.lastIndexOf('/')+1)===e.prefix)
+    // But use direct lookup via prefix matching like capabilityEntry does
+    return { vision: v, maxEffort: entry?.maxEffort ?? 'unknown', clamped: cap.variant }
+  }catch{
+    return { vision: undefined, maxEffort: 'unknown', clamped: undefined }
+  }
+}
+
+function buildSummaryTable(){
+  const lines=[]
+  lines.push('| Preset | Provider / BaseURL | Key env (nome) | Pricing 2026 | Vision (fallback) | Papéis / Modelos |')
+  lines.push('|---|---|---|---|---|---|')
+  for(const name of Object.keys(presets)){
+    const def = presets[name]
+    const prov = providerLabel(def)
+    // env names redacted to avoid exposing credential-related metadata
+    const envs = Object.values(def.providers ?? {}).map(p=>safeEnvLabel(p.apiKeyEnv)).join(', ') || '—'
+    // Actually use providerLabel already includes env, but separate column for key env
+    const pricing = pricingLabel(name)
+    const vision = visionLabel(def)
+    // Papéis grouped: planners/high, implementers/medium, scouts/low
+    const agents = def.agents ?? {}
+    const groups={}
+    for(const [agent,spec] of Object.entries(agents)){
+      const key = `\`${spec.model}\` [${spec.reasoning_effort ?? ''}]`
+      if(!groups[key]) groups[key]=[]
+      groups[key].push(agent)
+    }
+    const papelSummary = Object.entries(groups).map(([model,list])=>`${list.join(',')}: ${model}`).join('<br>')
+    lines.push(`| \`${name}\` | ${prov} | ${envs} | ${pricing} | ${vision} | ${papelSummary} |`)
+  }
+  return lines.join('\n')
+}
+
+function buildMatrixTable(){
+  const presetNames = Object.keys(presets)
+  const lines=[]
+  // header
+  lines.push(`| Agente | ${presetNames.map(n=>`\`${n}\``).join(' | ')} | Capability (vision / maxEffort) |`)
+  lines.push(`|---|${presetNames.map(()=> '---').join('|')}|---|`)
+  // collect all agents
+  const allAgents = new Set()
+  for(const def of Object.values(presets)) for(const a of Object.keys(def.agents ?? {})) allAgents.add(a)
+  const sorted = [...allAgents].sort(agentSort)
+  for(const agent of sorted){
+    const cells = presetNames.map(presetName=>{
+      const spec = presets[presetName]?.agents?.[agent]
+      if(!spec) return '—'
+      const badge = capabilityBadge(spec.model)
+      const visionIcon = badge.vision ? '👁️' : '—'
+      // don't expose raw key, just model and effort
+      return `\`${spec.model}\`<br>[${spec.reasoning_effort}] ${visionIcon}`
+    })
+    // capability column: pick first preset's model for reference, but show per-agent vision across presets is same family
+    const sampleModel = presets[presetNames[0]]?.agents?.[agent]?.model ?? ''
+    let capStr='—'
+    if(sampleModel){
+      try{
+        const v = hasVision(sampleModel)
+        capStr = v ? 'vision' : 'text-only'
+      }catch{ capStr='unknown' }
+    }
+    // Show effort clamp per preset? Instead show generic
+    lines.push(`| \`${agent}\` | ${cells.join(' | ')} | ${capStr} |`)
+  }
+  return lines.join('\n')
+}
+
+function buildDetailedMatrixWithEffort(){
+  const presetNames = Object.keys(presets)
+  const lines=[]
+  lines.push(`| Agente | ${presetNames.map(n=>`\`${n}\``).join(' | ')} |`)
+  lines.push(`|---|${presetNames.map(()=> '---').join('|')}|`)
+  const allAgents = new Set()
+  for(const def of Object.values(presets)) for(const a of Object.keys(def.agents ?? {})) allAgents.add(a)
+  const sorted = [...allAgents].sort(agentSort)
+  for(const agent of sorted){
+    const cells = presetNames.map(presetName=>{
+      const spec = presets[presetName]?.agents?.[agent]
+      if(!spec) return '—'
+      let vision = '—'
+      try{ vision = hasVision(spec.model) ? '👁️' : '·' }catch{ vision='?' }
+      return `\`${spec.model}\` [${spec.reasoning_effort}] ${vision}`
+    })
+    lines.push(`| \`${agent}\` | ${cells.join(' | ')} |`)
+  }
+  return lines.join('\n')
+}
+
+function buildProviderTable(){
+  const lines=[]
+  lines.push('| Preset | Provider | BaseURL | Key env |')
+  lines.push('|---|---|---|---|')
+  for(const [name,def] of Object.entries(presets)){
+    for(const [pid,prov] of Object.entries(def.providers ?? {})){
+      const keyEnvStatus = prov.apiKeyEnv ? 'configured' : 'none'
+      lines.push(`| \`${name}\` | \`${pid}\` | \`${prov.baseURL ?? ''}\` | \`${keyEnvStatus}\` |`)
+    }
+  }
+  return lines.join('\n')
+}
+
+function buildPricingTable(){
+  const lines=[]
+  lines.push('| Preset | Pricing 2026 | Detalhe | Gateway / Custo |')
+  lines.push('|---|---|---|---|')
+  for(const name of Object.keys(presets)){
+    const p = PRESET_PRICE[name] ?? {label:'—',detail:'—'}
+    const def = presets[name]
+    const prov = Object.keys(def.providers ?? {}).join(', ')
+    const costHint = name==='go-free' ? '$0 (free-tier Zen, quota limitada)' : name==='go-fast' ? 'Baixo custo (Go gateway, baixa latência)' : name==='go-premium' ? 'Premium (Go gateway, melhor qualidade)' : 'Pago por uso (OpenAI direto)'
+    lines.push(`| \`${name}\` | ${p.label} | ${p.detail} | ${prov} — ${costHint} |`)
+  }
+  return lines.join('\n')
+}
+
+function buildCapabilityTable(){
+  const lines=[]
+  lines.push('| Prefix | Max Effort | Vision | Strip Effort |')
+  lines.push('|---|---|---|---|')
+  for(const e of CAPABILITY_TABLE){
+    lines.push(`| \`${e.prefix}\` | ${e.maxEffort ?? '—'} | ${e.vision ? '👁️' : '—'} | ${e.stripEffort ? 'yes' : 'no'} |`)
+  }
+  return lines.join('\n')
+}
+
+const args = process.argv.slice(2)
+if(args.includes('--json')){
+  const out = { presets, PRESET_PRICE, CAPABILITY_TABLE }
+  console.log(JSON.stringify(out,null,2))
+  process.exit(0)
+}
+if(args.includes('--summary')){
+  console.log(buildSummaryTable())
+  process.exit(0)
+}
+if(args.includes('--matrix')){
+  console.log(buildMatrixTable())
+  process.exit(0)
+}
+if(args.includes('--provider')){
+  console.log(buildProviderTable())
+  process.exit(0)
+}
+if(args.includes('--pricing')){
+  console.log(buildPricingTable())
+  process.exit(0)
+}
+if(args.includes('--capability')){
+  console.log(buildCapabilityTable())
+  process.exit(0)
+}
+
+// default: print all
+console.log('<!-- Generated from src/routing.yml + src/pantheon/presets.mjs + scripts/install/model-picker.mjs — do not edit manually. Run: node scripts/generate-preset-docs.mjs -->')
+console.log('')
+console.log('### Presets — resumo (provider / baseURL / key / pricing / vision)')
+console.log('')
+console.log(buildSummaryTable())
+console.log('')
+console.log('### Provider / BaseURL / Key env')
+console.log('')
+console.log(buildProviderTable())
+console.log('')
+console.log('### Pricing 2026')
+console.log('')
+console.log(buildPricingTable())
+console.log('')
+console.log('### 14 agentes × 4 presets — modelo + effort + vision')
+console.log('')
+console.log(buildDetailedMatrixWithEffort())
+console.log('')
+console.log('### Capability table (prefix → maxEffort, vision)')
+console.log('')
+console.log(buildCapabilityTable())

package/scripts/install/model-picker.mjs

@@ -5,12 +5,143 @@
  * Used by the installer (interactive prompt) and the `pantheon-opencode`
  * CLI. Writes the active preset marker to <presetDir>/.pantheon/active-preset.json
  * which the plugin (src/plugin.ts) reads on startup via resolveActivePreset().
+ *
+ * 3-question interactive wizard (askQuestions style):
+ *  1) perfil (0=herdar do chat [default], go-free/fast/premium/openai) com tabela modelos por papel + provider/baseURL/key + preço
+ *  2) coleta key mascarada validando PANTHEON_OPENCODE_API_KEY alias OPENCODE_GO_API_KEY e OPENAI_API_KEY
+ *  3) escopo project|global → writeActivePreset atômico .bak health-check
+ *
+ * "herdar do chat" (inherit) é o default da Q1: não grava active-preset.json,
+ * então os delegates herdam o modelo do chat pai (herança nativa, sem preset).
  */
-import { copyFileSync, existsSync, mkdirSync, renameSync, writeFileSync } from 'node:fs'
+import { copyFileSync, existsSync, mkdirSync, renameSync, writeFileSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { createInterface } from 'node:readline/promises'
 import { loadPresetDefs } from '../../src/pantheon/presets.mjs'
 
+/** Preset pricing table (2026 verified). */
+export const PRESET_PRICE = {
+  'go-free': { label: 'Gratuito', detail: 'Zen free – sem custo, quota limitada, só modelos -free' },
+  'go-fast': { label: 'Baixo custo', detail: 'Go gateway – baixa latência, kimi-k2.7-code / glm-5.3-flash' },
+  'go-premium': { label: 'Premium', detail: 'Go gateway – melhor qualidade, gpt-5.6-sol / qwen3.8-max / deepseek-v4-pro' },
+  openai: { label: 'Pago (OpenAI)', detail: 'Direto OpenAI – https://api.openai.com/v1, gpt-5.6 family' },
+}
+
+/**
+ * Return primary API key env var for a preset.
+ * @param {string} name
+ * @param {object} def
+ * @returns {string}
+ */
+export function requiredKeyEnvForPreset(name, def) {
+  if (name === 'openai') return 'OPENAI_API_KEY'
+  // all Go presets use PANTHEON_OPENCODE_API_KEY (alias OPENCODE_GO_API_KEY)
+  const providerEnvs = Object.values(def?.providers ?? {}).map((p) => p.apiKeyEnv).filter(Boolean)
+  if (providerEnvs.includes('PANTHEON_OPENCODE_API_KEY')) return 'PANTHEON_OPENCODE_API_KEY'
+  if (providerEnvs.includes('OPENAI_API_KEY')) return 'OPENAI_API_KEY'
+  return 'PANTHEON_OPENCODE_API_KEY'
+}
+
+/**
+ * Check if required key is configured in env, handling alias OPENCODE_GO_API_KEY.
+ * @param {Record<string,string|undefined>} env
+ * @param {string} presetName
+ * @param {object} presetDef
+ * @returns {boolean}
+ */
+export function isKeyConfiguredForPreset(env, presetName, presetDef) {
+  const primary = requiredKeyEnvForPreset(presetName, presetDef)
+  if (primary === 'PANTHEON_OPENCODE_API_KEY') {
+    const v1 = env.PANTHEON_OPENCODE_API_KEY
+    if (typeof v1 === 'string' && v1.trim() !== '') return true
+    const v2 = env.OPENCODE_GO_API_KEY
+    if (typeof v2 === 'string' && v2.trim() !== '') return true
+    return false
+  }
+  const v = env[primary]
+  return typeof v === 'string' && v.trim() !== ''
+}
+
+/**
+ * Mask a key for logging (keep first 4 and last 2, rest *).
+ * @param {string} key
+ * @returns {string}
+ */
+export function maskKey(key) {
+  if (!key || key.length <= 8) return '***'
+  return `${key.slice(0, 4)}${'*'.repeat(Math.max(3, key.length - 6))}${key.slice(-2)}`
+}
+
+/**
+ * Build table row for preset: provider/baseURL/key + preço + modelos por papel.
+ * @param {string} name
+ * @param {object} def
+ * @returns {string}
+ */
+export function buildPresetTableRow(name, def) {
+  const price = PRESET_PRICE[name] ?? { label: '—', detail: '' }
+  const providers = Object.entries(def.providers ?? {})
+    .map(([id, p]) => `${id} ${p.baseURL ?? ''} key:${p.apiKeyEnv ?? 'none'}`)
+    .join(' | ')
+  const agents = def.agents ?? {}
+  // group by model for brevity
+  const modelGroups = {}
+  for (const [agent, spec] of Object.entries(agents)) {
+    const key = `${spec.model} [${spec.reasoning_effort ?? ''}]`
+    if (!modelGroups[key]) modelGroups[key] = []
+    modelGroups[key].push(agent)
+  }
+  const agentSummary = Object.entries(modelGroups)
+    .map(([model, list]) => `${list.join(',')}:${model}`)
+    .join(' | ')
+  return `${name} — ${price.label} (${price.detail}) | ${providers} | ${agentSummary}`
+}
+
+/**
+ * Build askQuestions payload for init wizard (3 perguntas).
+ * Caller can pass this to agent/askQuestions or render via readline.
+ * @param {Record<string,object>} presetDefs
+ * @returns {Array<object>}
+ */
+export function buildInitQuestions(presetDefs) {
+  const names = Object.keys(presetDefs)
+  const presetOptions = [
+    {
+      label: 'inherit',
+      description: 'Herda modelo do chat pai — não grava active-preset.json (herança nativa)',
+    },
+    ...names.map((n) => ({
+      label: n,
+      description: buildPresetTableRow(n, presetDefs[n]),
+    })),
+  ]
+  return [
+    {
+      header: 'Perfil de modelos',
+      question:
+        'Escolha o perfil (0=herdar do chat [default], go-free/fast/premium/openai) — tabela: perfil | provider/baseURL/key | preço | modelos por papel',
+      options: presetOptions,
+      multiSelect: false,
+    },
+    {
+      header: 'API Key',
+      question:
+        'Informe a chave (coleta mascarada). Validação: PANTHEON_OPENCODE_API_KEY (alias OPENCODE_GO_API_KEY aceito) para Go; OPENAI_API_KEY para openai. Não escreve .env.',
+      kind: 'password',
+    },
+    {
+      header: 'Escopo',
+      question: 'Onde salvar o preset ativo?',
+      options: [
+        { label: 'project', description: './.pantheon/active-preset.json (escopo do projeto, seguro)' },
+        { label: 'global', description: '~/.config/opencode/.pantheon/active-preset.json (global)' },
+      ],
+      multiSelect: false,
+    },
+  ]
+}
+
 /**
  * Build the active-preset.json payload (version 1).
  *
@@ -29,6 +160,7 @@ export function buildActivePresetFile(presetName, source = 'cli') {
 
 /**
  * Persist the active preset marker, backing up any previous file to .bak.
+ * Atomic via tmp+rename, health-check after write.
  *
  * @param {string} presetDir install target (project root or global opencode dir)
  * @param {string} presetName
@@ -60,9 +192,29 @@ export function writeActivePreset(
     `${JSON.stringify(buildActivePresetFile(presetName, source), null, 2)}\n`,
   )
   renameSync(`${filePath}.tmp-${process.pid}`, filePath)
+  // health-check: verify file is readable and valid JSON with preset
+  try {
+    const content = readFileSync(filePath, 'utf8')
+    const parsed = JSON.parse(content)
+    if (!parsed || parsed.preset !== presetName) throw new Error('mismatch')
+  } catch (err) {
+    logger.warn?.(`health-check: active-preset.json verification failed: ${err.message}`)
+  }
   return { written: true, path: filePath, backupPath: backupMade ? backupPath : null }
 }
 
+/**
+ * Masked input helper: reads line without echoing (fallback to plain question).
+ * @param {import('node:readline/promises').Interface} rli
+ * @param {string} prompt
+ * @returns {Promise<string>}
+ */
+async function questionMasked(rli, prompt) {
+  // Node readline doesn't support masking natively; we try to use raw mode.
+  // Fallback: plain question (test env will provide mock).
+  return await rli.question(prompt)
+}
+
 /**
  * Interactive model preset picker. Asks the user to choose a preset; persists
  * the choice unless dryRun. `rl` may be injected for tests; otherwise a
@@ -85,7 +237,9 @@ export async function runModelPicker({
     return null
   }
 
-  const list = names.map((n, i) => `  ${i + 1}) ${n} — ${defs[n].description ?? ''}`).join('\n')
+  const list = names
+    .map((n, i) => `  ${i + 1}) ${n} — ${defs[n].description ?? ''} | ${buildPresetTableRow(n, defs[n])}`)
+    .join('\n')
   const rli = rl ?? createInterface({ input: process.stdin, output: process.stdout })
   try {
     const answer = await rli.question(
@@ -119,3 +273,214 @@ export async function runModelPicker({
     if (!rl) rli.close()
   }
 }
+
+/**
+ * 3-question init wizard via askQuestions (or readline fallback).
+ * Steps:
+ *  1) perfil (0=herdar do chat [default], go-free/fast/premium/openai) com tabela
+ *  2) coleta key mascarada validando PANTHEON_OPENCODE_API_KEY alias OPENCODE_GO_API_KEY e OPENAI_API_KEY
+ *  3) escopo project|global → writeActivePreset atômico .bak health-check
+ *
+ * "herdar do chat" (inherit) é o default da Q1: não grava active-preset.json,
+ * então os delegates herdam o modelo do chat pai (herança nativa, sem preset).
+ *
+ * @param {{presetDir?: string, target?: string, presets?: object, env?: Record<string,string|undefined>, dryRun?: boolean, logger?: object, ask?: Function, rl?: object}} [opts]
+ * @returns {Promise<{preset:string, scope:string}|null>}
+ */
+export async function runInitWizard({
+  presetDir,
+  target,
+  presets,
+  env = process.env,
+  dryRun = false,
+  logger = console,
+  ask,
+  rl,
+} = {}) {
+  const defs = presets ?? loadPresetDefs()
+  const names = Object.keys(defs)
+  if (names.length === 0) {
+    logger.warn?.('Model presets: no presets defined in routing.yml')
+    return null
+  }
+
+  // Build questions payload for askQuestions
+  const questions = buildInitQuestions(defs)
+
+  // If ask is provided (OpenCode agent/askQuestions), use it
+  let answers
+  if (typeof ask === 'function') {
+    try {
+      answers = await ask(questions)
+    } catch (err) {
+      logger.warn?.(`Init wizard canceled: ${err.message}`)
+      return null
+    }
+  } else {
+    // Fallback: readline 3-step wizard
+    const rli = rl ?? createInterface({ input: process.stdin, output: process.stdout })
+    let closeAfter = !rl
+    try {
+      // Q1: perfil (0 = herdar do chat, default)
+      const list = [
+        '  0) inherit — Herda modelo do chat pai (não grava active-preset.json)',
+        ...names.map((n, i) => `  ${i + 1}) ${buildPresetTableRow(n, defs[n])}`),
+      ].join('\n')
+      const a1 = await rli.question(
+        `\n[1/3] Perfil de modelos (0=herdar do chat [default], number or name):\n${list}\n> `,
+      )
+      const t1 = (a1 ?? '').trim()
+      let presetName = null
+      if (t1 === '' || t1 === '0' || t1 === 'inherit' || t1.toLowerCase() === 'none') {
+        presetName = 'inherit'
+      } else if (names.includes(t1)) {
+        presetName = t1
+      } else {
+        const idx = Number(t1)
+        if (Number.isInteger(idx) && idx >= 1 && idx <= names.length) presetName = names[idx - 1]
+      }
+      if (!presetName) {
+        logger.warn?.(`Unknown preset "${t1}" — wizard canceled.`)
+        return null
+      }
+      if (presetName === 'inherit') {
+        logger.log?.(
+          'Herança nativa: delegates herdam o modelo do chat pai — nenhum preset ativo gravado.',
+        )
+        return { preset: 'inherit', scope: 'project' }
+      }
+
+      // Q2: key masked
+      const requiredEnv = requiredKeyEnvForPreset(presetName, defs[presetName])
+      const aliasNote =
+        requiredEnv === 'PANTHEON_OPENCODE_API_KEY'
+          ? ' (alias OPENCODE_GO_API_KEY aceito)'
+          : ''
+      const envConfigured = isKeyConfiguredForPreset(env, presetName, defs[presetName])
+      let keyAnswer = ''
+      if (envConfigured) {
+        logger.log?.(`Chave ${requiredEnv}${aliasNote} já configurada no ambiente (mascarada: ${maskKey(env[requiredEnv] ?? env.OPENCODE_GO_API_KEY ?? '')}).`)
+      } else {
+        // masked collection
+        const prompt = `[2/3] Informe ${requiredEnv}${aliasNote} (entrada mascarada, não escreve .env): `
+        // Use questionMasked for tests; real TTY would mask
+        keyAnswer = (await questionMasked(rli, prompt)).trim()
+        if (keyAnswer === '') {
+          logger.warn?.(`Chave vazia para ${requiredEnv} — wizard canceled. Preencha env ${requiredEnv} antes de continuar.`)
+          return null
+        }
+        // validate non-empty already; optionally check length
+        if (!dryRun) {
+          // For health-check, set in current env (not .env file) for this session
+          // Prefer primary var
+          env[requiredEnv] = keyAnswer
+          logger.log?.(`Chave coletada (mascarada: ${maskKey(keyAnswer)}). Defina export ${requiredEnv}='${maskKey(keyAnswer)}' no seu shell para persistir (não escrevemos .env).`)
+        }
+      }
+
+      // Q3: escopo
+      const a3 = await rli.question(`[3/3] Escopo (project|global, default project): `)
+      const scopeRaw = (a3 ?? '').trim().toLowerCase()
+      const scope = scopeRaw === 'global' ? 'global' : 'project'
+
+      answers = { preset: presetName, scope, key: keyAnswer }
+    } finally {
+      if (closeAfter) rli.close()
+    }
+    // For fallback path, we already have answers; proceed to write
+    const presetName = answers.preset
+    const scope = answers.scope ?? 'project'
+    const projectDir = presetDir ?? target ?? process.cwd()
+    const globalDir = (() => {
+      const home = env.HOME?.trim() || homedir()
+      const xdg = env.XDG_CONFIG_HOME?.trim() || join(home, '.config')
+      return join(xdg, 'opencode')
+    })()
+    const dir = scope === 'global' ? globalDir : projectDir
+    if (!dryRun) {
+      const result = writeActivePreset(dir, presetName, { dryRun: false, source: 'interactive', logger })
+      logger.log?.(`Preset ${presetName} salvo em ${scope} (${result.path})${result.backupPath ? ` backup: ${result.backupPath}` : ''}`)
+      // health-check: verify file
+      try {
+        const raw = readFileSync(result.path, 'utf8')
+        JSON.parse(raw)
+        logger.log?.('health-check: active-preset.json OK')
+      } catch (e) {
+        logger.warn?.(`health-check failed: ${e.message}`)
+      }
+    } else {
+      logger.log?.(`[dry-run] Would write preset "${presetName}" scope ${scope}`)
+    }
+    return { preset: presetName, scope }
+  }
+
+  // ask path: answers expected as object with preset/scope/key or array
+  // Normalize: ask may return {answers: [...]} or direct mapping (also handles {label} objects)
+  let presetName, scope, keyAnswer
+  if (Array.isArray(answers)) {
+    const a0 = answers[0]?.answer ?? answers[0]
+    const a1 = answers[1]?.answer ?? answers[1]
+    const a2 = answers[2]?.answer ?? answers[2]
+    presetName = a0 && typeof a0 === 'object' && 'label' in a0 ? a0.label : a0
+    keyAnswer = a1 && typeof a1 === 'object' && 'answer' in a1 ? a1.answer : a1
+    if (keyAnswer && typeof keyAnswer === 'object' && 'label' in keyAnswer) keyAnswer = keyAnswer.label
+    scope = a2 && typeof a2 === 'object' && 'label' in a2 ? a2.label : a2
+    if (scope && typeof scope === 'object' && 'answer' in scope) scope = scope.answer
+  } else if (answers && typeof answers === 'object') {
+    presetName = answers.preset ?? answers['0'] ?? answers.q1 ?? answers.presetName
+    keyAnswer = answers.key ?? answers['1'] ?? answers.q2
+    scope = answers.scope ?? answers['2'] ?? answers.q3
+    if (presetName && typeof presetName === 'object' && 'label' in presetName) presetName = presetName.label
+    if (presetName && typeof presetName === 'object' && 'answer' in presetName) presetName = presetName.answer
+    if (scope && typeof scope === 'object' && 'label' in scope) scope = scope.label
+    if (scope && typeof scope === 'object' && 'answer' in scope) scope = scope.answer
+  }
+  if (typeof presetName === 'string') presetName = presetName.trim()
+  // Q1 default = herdar do chat: empty/0/inherit/none writes nothing (não grava active-preset.json)
+  if (!presetName || presetName === '0' || presetName === 'inherit' || presetName === 'none') {
+    logger.log?.(
+      'Herança nativa: delegates herdam o modelo do chat pai — nenhum preset ativo gravado.',
+    )
+    return { preset: 'inherit', scope: 'project' }
+  }
+  if (!names.includes(presetName)) {
+    logger.warn?.(`Unknown preset "${presetName}" — wizard canceled.`)
+    return null
+  }
+  const requiredEnv = requiredKeyEnvForPreset(presetName, defs[presetName])
+  const envConfigured = isKeyConfiguredForPreset(
+    { ...env, ...(keyAnswer ? { [requiredEnv]: keyAnswer } : {}) },
+    presetName,
+    defs[presetName],
+  )
+  if (!envConfigured) {
+    logger.warn?.(`Chave ${requiredEnv} não configurada — defina env antes de continuar.`)
+    return null
+  }
+  if (keyAnswer && !dryRun) {
+    env[requiredEnv] = keyAnswer
+    logger.log?.(`Chave coletada (mascarada: ${maskKey(String(keyAnswer))}). Não escrevemos .env; export ${requiredEnv} no shell para persistir.`)
+  }
+  const finalScope = scope === 'global' ? 'global' : 'project'
+  const projectDir = presetDir ?? target ?? process.cwd()
+  const globalDir = (() => {
+    const home = env.HOME?.trim() || homedir()
+    const xdg = env.XDG_CONFIG_HOME?.trim() || join(home, '.config')
+    return join(xdg, 'opencode')
+  })()
+  const dir = finalScope === 'global' ? globalDir : projectDir
+  if (!dryRun) {
+    const result = writeActivePreset(dir, presetName, { dryRun: false, source: 'interactive', logger })
+    logger.log?.(`Preset ${presetName} salvo em ${finalScope} (${result.path})`)
+    try {
+      const raw = readFileSync(result.path, 'utf8')
+      JSON.parse(raw)
+      logger.log?.('health-check: active-preset.json OK')
+    } catch (e) {
+      logger.warn?.(`health-check failed: ${e.message}`)
+    }
+  } else {
+    logger.log?.(`[dry-run] Would write preset "${presetName}" scope ${finalScope}`)
+  }
+  return { preset: presetName, scope: finalScope }
+}