pantheon-opencode 1.6.0-beta.7 → 1.6.0-beta.9

package/scripts/install/opencode.mjs

@@ -56,6 +56,7 @@ import {
   writeConfigWithBackup,
   writeIfChanged,
 } from './shared.mjs'
+import { createInitialState, hasState, readState, setComponentState, writeState } from './state.mjs'
 import { strings } from './strings.mjs'
 
 import { setupVenv, venvPythonPath } from './venv.mjs'
@@ -135,6 +136,74 @@ export const MANAGED_FIELDS = Object.freeze([
   'disable_model_invocation',
 ])
 
+const PANTHEON_MCP_SERVERS = Object.freeze([
+  'pantheon-resources',
+  'pantheon-memory',
+  'pantheon-code-mode',
+  'pantheon-persistence',
+  'pantheon-vision',
+])
+
+function normalizeMcpPermissionSegment(value) {
+  return value.replace(/[^a-zA-Z0-9_]/g, '_')
+}
+
+/**
+ * Translate an agent's `mcp_tools` frontmatter into per-tool native
+ * permissions. V1 matches the original server-tool names; V2 normalizes
+ * punctuation to underscores. Emitting both spellings keeps the same source
+ * metadata valid for either host. Unlisted bundled Pantheon servers default to
+ * deny; unrelated user MCP servers are not touched.
+ *
+ * @param {Record<string, 'all' | string[]>} mcpTools
+ * @returns {Record<string, 'allow' | 'deny'>}
+ */
+export function deriveNativeMcpPermissions(mcpTools) {
+  if (mcpTools === null || typeof mcpTools !== 'object' || Array.isArray(mcpTools)) {
+    throw new TypeError('mcp_tools must be an object keyed by MCP server name')
+  }
+
+  const servers = new Set([...PANTHEON_MCP_SERVERS, ...Object.keys(mcpTools)])
+  const permissions = {}
+
+  for (const server of servers) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(server)) {
+      throw new TypeError(`mcp_tools server name is invalid: ${server}`)
+    }
+    const tools = Object.hasOwn(mcpTools, server) ? mcpTools[server] : []
+    if (
+      tools !== 'all' &&
+      (!Array.isArray(tools) ||
+        tools.some((tool) => typeof tool !== 'string' || !/^[a-zA-Z0-9._-]+$/.test(tool)))
+    ) {
+      throw new TypeError(`mcp_tools.${server} must be "all" or an array of tool names`)
+    }
+
+    const serverAliases = new Set([server, normalizeMcpPermissionSegment(server)])
+    for (const alias of serverAliases) permissions[`${alias}_*`] = 'deny'
+  }
+
+  for (const server of servers) {
+    const tools = Object.hasOwn(mcpTools, server) ? mcpTools[server] : []
+    const serverAliases = new Set([server, normalizeMcpPermissionSegment(server)])
+    if (tools === 'all') {
+      for (const alias of serverAliases) permissions[`${alias}_*`] = 'allow'
+      continue
+    }
+
+    for (const tool of tools) {
+      const toolAliases = new Set([tool, normalizeMcpPermissionSegment(tool)])
+      for (const serverAlias of serverAliases) {
+        for (const toolAlias of toolAliases) {
+          permissions[`${serverAlias}_${toolAlias}`] = 'allow'
+        }
+      }
+    }
+  }
+
+  return permissions
+}
+
 function deepClone(value) {
   return JSON.parse(JSON.stringify(value))
 }
@@ -226,26 +295,23 @@ function mergeMissing(target, source) {
 }
 
 /**
- * Resolve a plugin ref from the repository-root opencode.json to its stable
- * installed form.
+ * Resolve a plugin ref from the repository-root opencode.json to a path INSIDE
+ * the installed package.
  *
  * Only exact Pantheon plugin identities are resolved into the installed
  * package. In particular, a third-party absolute path ending in
  * `src/plugin.ts` or `src/plugins/pantheon-hooks.ts` is not evidence that the
- * plugin belongs to Pantheon and must be preserved verbatim. V1 remains a pair
- * of package-local paths; V2 uses an exact npm version so it is independent of
- * the installer's global prefix or transient npx cache.
+ * plugin belongs to Pantheon and must be preserved verbatim.
  */
 export function resolveInstalledPlugin(plugin) {
   if (typeof plugin !== 'string') return plugin
   const normalized = normalizePluginRef(plugin)
-  if (normalized === PANTHEON_V2_PLUGIN || normalized === PANTHEON_V2_LEGACY_FILE) {
-    return PANTHEON_V2_PACKAGE_SPEC
-  }
   if (PANTHEON_PLUGIN_IDENTITIES.has(normalized)) return join(ROOT, normalized)
+  // Legacy V2 file ref (pre-directory-contract): migrate to the installed
+  // plugin directory so the beta loader accepts the entry.
+  if (normalized === PANTHEON_V2_LEGACY_FILE) return join(ROOT, PANTHEON_V2_PLUGIN)
   const identity = managedPluginIdentity(plugin)
   if (identity !== null && isAbsolute(normalized)) {
-    if (identity === PANTHEON_V2_PLUGIN) return PANTHEON_V2_PACKAGE_SPEC
     return INSTALLED_PANTHEON_PLUGIN_PATHS.get(identity) ?? plugin
   }
   return plugin
@@ -267,14 +333,7 @@ const PANTHEON_V2_PLUGIN = 'src/plugin-v2'
 const PANTHEON_V2_LEGACY_FILE = 'src/plugin-v2.ts'
 const PANTHEON_V1_EXPORT = 'pantheon-opencode/plugin'
 const PANTHEON_V2_EXPORT = 'pantheon-opencode/plugin-v2'
-const PACKAGE_MANIFEST = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'))
-const PANTHEON_V2_PACKAGE_SPEC = `${PACKAGE_MANIFEST.name}@${PACKAGE_MANIFEST.version}`
-// Installation origin probe: npm copies (global prefix, npx cache) always live
-// under a `node_modules` directory; a repo checkout does not. From a checkout —
-// or between a version bump and its publish — the V2 pin above names a version
-// that may not exist on the npm registry yet, and the host cannot resolve it
-// until publish. Advisory only: the install itself is structurally correct.
-const RUNNING_FROM_NPM_INSTALL = import.meta.url.includes('/node_modules/')
+const PANTHEON_PACKAGE_REF = /^pantheon-opencode(?:@[^/]+)?(?:\/(plugin|plugin-v2))?$/
 const PANTHEON_PLUGIN_IDENTITIES = new Set([
   PANTHEON_V1_PLUGIN,
   PANTHEON_V1_HOOKS,
@@ -303,14 +362,22 @@ function managedPluginIdentity(ref) {
   const normalized = normalizePluginRef(ref)
   if (typeof normalized !== 'string') return null
 
+  // Older installs registered the package root itself (often pinned to a
+  // beta version) in OpenCode's plural `plugins` list. Treat all exact npm
+  // specs for this package as managed so an update removes the old cached
+  // copy before registering the current package path. Do not match similarly
+  // named third-party packages such as `pantheon-opencode-fork`.
+  const packageRef = normalized.match(PANTHEON_PACKAGE_REF)
+  if (packageRef !== null) {
+    if (packageRef[1] === 'plugin') return PANTHEON_V1_PLUGIN
+    return PANTHEON_V2_PLUGIN
+  }
+
   if (PANTHEON_PLUGIN_IDENTITIES.has(normalized)) return normalized
   if (normalized === PANTHEON_V2_LEGACY_FILE) return PANTHEON_V2_PLUGIN
   if (normalized === PANTHEON_V1_EXPORT || normalized.startsWith(`${PANTHEON_V1_EXPORT}@`)) {
     return PANTHEON_V1_PLUGIN
   }
-  if (normalized === PACKAGE_MANIFEST.name || normalized.startsWith(`${PACKAGE_MANIFEST.name}@`)) {
-    return PANTHEON_V2_PLUGIN
-  }
   if (normalized === PANTHEON_V2_EXPORT || normalized.startsWith(`${PANTHEON_V2_EXPORT}@`)) {
     return PANTHEON_V2_PLUGIN
   }
@@ -475,15 +542,14 @@ export function isGlobalConfigDir(target) {
  * package; the loader must NEVER be pointed at that in-package dir (a package
  * reinstall/upgrade replaces the dir under a live registration and leaves
  * diverging copies loading). Instead the installer always copies it into the
- * config dir's plugins/ dir and registers THAT copy:
+ * config dir's plugins/ dir and uses THAT copy:
  *
- *   <configDir>/plugins/pantheon-tui      (dist/ + package.json + index.tsx)
+ *   <configDir>/plugins/pantheon-tui      (tui.ts + dist/ + package manifests)
  *
- * The loader reads the copied package.json `exports` map:
- *   exports["./tui"]    → dist/tui.js     (COMPILED Solid output)
- *   exports["./server"] → dist/server.js  (no-op server() stub)
+ * V1 registers that copy through tui.json. V2 discovers the local plugin's
+ * index.ts + tui.ts pair; the V2 shim re-exports dist/tui-v2.js.
  *
- * @param {string} configDir - directory holding tui.json (target for global
+ * @param {string} configDir - OpenCode config directory (target for global
  *   installs, <target>/.opencode for project installs)
  * @returns {string} absolute path of the copied plugin directory
  */
@@ -509,23 +575,20 @@ export function tuiConfigLocations(target) {
 }
 
 /**
- * Sync the Pantheon TUI plugin registration across EVERY tui.json location
- * OpenCode reads.
+ * Sync the Pantheon TUI plugin payload and V1 registration. V2 discovers the
+ * copied local-plugin entrypoints and does not use a project tui.json.
  *
  * Contract (single source of truth):
- *   1. ALWAYS copy src/plugins/tui → <configDir>/plugins/pantheon-tui
- *      (dist/* + package.json + index.tsx) so the registered reference is a
- *      directory that exists and carries the loader contract (exports →
- *      dist/tui.js, dist/server.js). The copy is idempotent: a second run is
- *      byte-identical.
+ *   1. ALWAYS copy src/plugins/tui → <configDir>/plugins/pantheon-tui with the
+ *      selected host entrypoints and compiled bundle. The copy is idempotent.
  *   2. Clean stale Pantheon TUI refs from ALL tui.json locations OpenCode
  *      loads — ~/.opencode, $XDG_CONFIG_HOME/opencode and
  *      <target>/.opencode — covering every old reference shape: dist file
  *      paths, in-package src/plugins/tui dirs, bare plugins/pantheon-tui
  *      copies, and npx paths. A stale ref left in the non-target location
  *      would still be loaded and break the TUI.
- *   3. Register EXACTLY the copied directory in the selected target only —
- *      exactly ONE Pantheon TUI reference exists system-wide after install.
+ *   3. V1 registers the copied directory in the selected target. V2 relies on
+ *      local-plugin discovery and does not write a project tui.json entry.
  *
  * @param {string} target - install target directory
  * @param {object} [opts]
@@ -533,18 +596,19 @@ export function tuiConfigLocations(target) {
  * @param {boolean} [opts.dryRun=false]
  * @returns {'created'|'skipped'} status for the target registration
  */
-export function syncTuiRegistration(target, { isGlobal = false, dryRun = false } = {}) {
+export function syncTuiRegistration(
+  target,
+  { isGlobal = false, dryRun = false, version = 'v1' } = {},
+) {
   const configDir = isGlobal ? target : join(target, '.opencode')
   const targetTuiConfigPath = join(configDir, 'tui.json')
 
-  // 1. Always copy the single source of truth into the target config's
-  //    plugins/pantheon-tui. Registering this copied directory (never the
-  //    in-package src/plugins/tui) keeps installs hermetic and idempotent:
-  //    the ref points at a dir that exists and has dist/tui.js.
+  // 1. Copy the host-specific plugin into the target config's
+  //    plugins/pantheon-tui. This keeps the installed entry hermetic.
   const tuiSrcDir = join(ROOT, 'src', 'plugins', 'tui')
   const tuiCopyDir = resolveTuiCopyTarget(configDir)
   if (existsSync(tuiSrcDir)) {
-    copyPluginFiles(tuiSrcDir, tuiCopyDir, { dryRun })
+    copyPluginFiles(tuiSrcDir, tuiCopyDir, { dryRun, version })
   }
 
   // 2. Clean stale Pantheon TUI refs from every location OpenCode reads.
@@ -560,6 +624,11 @@ export function syncTuiRegistration(target, { isGlobal = false, dryRun = false }
     })
   }
 
+  // OpenCode V2 discovers local plugins from the config plugins directories;
+  // its TUI plugin API is exposed by the sibling tui.ts entrypoint. V1 still
+  // requires the explicit tui.json registration.
+  if (version === 'v2') return 'skipped'
+
   // 3. Register the copied directory in the selected target only.
   return registerPlugin(targetTuiConfigPath, tuiCopyDir, { dryRun })
 }
@@ -796,14 +865,13 @@ export async function installOpenCode(
     }
   }
 
-  // Determine layout based on install scope.
-  // Global config dir (~/.opencode or ~/.config/opencode) uses a flat layout:
-  //   agents/   skills/   commands/   plugins/
-  // Project installs use the .opencode/ sub-directory layout:
-  //   .opencode/agents/   .opencode/skills/   .opencode/commands/
+  // V1 project installs use the legacy .opencode/agents layout. OpenCode V2's
+  // active config directory is the project root and its agent loader scans
+  // <config-dir>/{agent,agents}/**, so V2 project agents must be at ./agents.
+  // Global installs are flat for both versions.
   const isGlobal = isGlobalConfigDir(target)
   const _subDir = isGlobal ? '' : '.opencode'
-  const agentPrefix = isGlobal ? 'agents' : '.opencode/agents'
+  const agentPrefix = isGlobal || version === 'v2' ? 'agents' : '.opencode/agents'
 
   configure({ dryRun })
 
@@ -822,7 +890,7 @@ export async function installOpenCode(
       stats.errors++
     } else {
       const agentStep = step(S.installingAgents)
-      const dstDir = isGlobal ? join(target, 'agents') : join(target, '.opencode', 'agents')
+      const dstDir = join(target, agentPrefix)
       if (!dryRun) mkdirSync(dstDir, { recursive: true })
       if (clean && existsSync(dstDir) && !dryRun) {
         const existing = readdirSync(dstDir)
@@ -902,9 +970,7 @@ export async function installOpenCode(
     // already-installed Pantheon agents, but must not create agents the user
     // did not install. Full agent installs do this in phase 1 above.
     if (!componentSet.has('agents')) {
-      const installedAgents = isGlobal
-        ? join(target, 'agents')
-        : join(target, '.opencode', 'agents')
+      const installedAgents = join(target, agentPrefix)
       const sourceAgents = join(ROOT, 'src', 'agents')
       if (existsSync(installedAgents) && existsSync(sourceAgents)) {
         const refreshed = copyAgentPrompts(sourceAgents, installedAgents, dryRun, true)
@@ -934,7 +1000,11 @@ export async function installOpenCode(
   if (componentSet.has('commands')) {
     section('\u26A1 Commands')
     const srcCmds = join(ROOT, 'commands')
-    const dstCmds = isGlobal ? join(target, 'commands') : join(target, '.opencode', 'commands')
+    // V2 project sandboxes use OPENCODE_CONFIG_DIR=<project root>, so OpenCode
+    // discovers custom commands from <target>/commands. V1 project installs
+    // keep the standard .opencode/commands layout; global installs are flat.
+    const commandDir = isGlobal || version === 'v2' ? 'commands' : '.opencode/commands'
+    const dstCmds = join(target, commandDir)
     if (existsSync(srcCmds)) {
       const cmdResult = syncDir(srcCmds, dstCmds, dryRun, clean, (f) => f.endsWith('.md'))
       stats.created += cmdResult.created
@@ -959,7 +1029,7 @@ export async function installOpenCode(
     const dstPluginDir = isGlobal
       ? join(target, 'plugins', 'pantheon-tui')
       : join(target, '.opencode', 'plugins', 'pantheon-tui')
-    const pluginStats = installPlugin(srcPluginDir, dstPluginDir, { dryRun, clean })
+    const pluginStats = installPlugin(srcPluginDir, dstPluginDir, { dryRun, clean, version })
     stats.created += pluginStats.created
     stats.skipped += pluginStats.skipped
     stats.errors += pluginStats.errors
@@ -971,7 +1041,7 @@ export async function installOpenCode(
   if (componentSet.has('plugins')) {
     let tuiStatus
     try {
-      tuiStatus = syncTuiRegistration(target, { isGlobal, dryRun })
+      tuiStatus = syncTuiRegistration(target, { isGlobal, dryRun, version })
     } catch (cause) {
       error(`TUI plugin setup failed: ${cause.message}`)
       stats.errors++
@@ -1000,6 +1070,7 @@ export async function installOpenCode(
       'mcp_persistence.py',
       'pantheon_vision.py',
       'eval_store.py',
+      'themis_heuristic_scan.py',
     ]
     const srcScriptsDir = join(ROOT, 'scripts')
     // Canonical MCP server sources live in src/mcp/. Map them explicitly so the
@@ -1154,6 +1225,12 @@ export async function installOpenCode(
       if (fm.permission) {
         agent.permission = JSON.parse(JSON.stringify(fm.permission))
       }
+      if (fm.mcp_tools !== undefined) {
+        agent.permission = {
+          ...(agent.permission ?? {}),
+          ...deriveNativeMcpPermissions(fm.mcp_tools),
+        }
+      }
 
       config[name] = agent
     }
@@ -1266,12 +1343,16 @@ export async function installOpenCode(
   // --------------------------------------------------------------------
   // B.5.1 Hermetic plugin resolution (packaging fix)
   // --------------------------------------------------------------------
-  // A developer running from a checkout may have a repository-root
-  // opencode.json with machine-specific plugin paths. V1 rewrites its two
-  // managed entries to paths under the installed package. V2 instead writes
-  // the exact package-root npm spec so it survives global-prefix and npx-cache
-  // changes; a source-checkout V2 install warns that the version may not yet
-  // exist on npm. Third-party paths remain untouched in either generation.
+  // A developer running from a checkout has a repository-root opencode.json
+  // that may reference plugins via developer-machine absolute paths (e.g.
+  // <dev>/pantheon/.../src/plugin.ts or
+  // <dev>/pantheon/.../src/plugins/pantheon-hooks.ts). Copying those
+  // verbatim into the user's config would break every global install on any
+  // other machine. resolveInstalledPlugin() rewrites each entry to the plugin
+  // file inside the INSTALLED package (derived from ROOT — never hardcoded),
+  // so both dev and global installs resolve to a path that actually exists.
+  // The source opencode.json keeps its dev path for local development; the
+  // transform happens at install/sync time only.
 
   if (version === 'v1') {
     // V1 loads the singular `plugin` list. Remove every Pantheon V2 entry from
@@ -1332,13 +1413,18 @@ export async function installOpenCode(
         }
       }
     }
-    // V2 plugin entries are resolved by OpenCode as npm packages. Pin the
-    // exact current version and use the package-root export, which is the V2
-    // default plugin. Unlike an absolute path into ROOT, this survives moving
-    // between a global install and an npx cache; unlike an unpinned package,
-    // it cannot silently change underneath an existing config. Legacy local
-    // directory/file refs are recognized via managedPluginIdentity and are
-    // replaced here.
+    // The beta resolves every `plugins` entry through npm install, so an
+    // `a/b` shorthand (e.g. the published `pantheon-opencode/plugin-v2`
+    // export) is treated as a GitHub repo and dies with NpmInstallFailedError
+    // (beta log evidence). The beta loader additionally requires each entry
+    // to be a DIRECTORY with a real index.js/index.ts — a file path warns
+    // "must be a directory" and a symlink is ignored (sandbox probe
+    // evidence). Register the V2 plugin DIRECTORY inside the INSTALLED
+    // package — exactly like V1's ensurePantheonPlugin, but pointing at
+    // src/plugin-v2 whose index.ts shim re-exports the real entry.
+    // Legacy refs (npm shorthand, the old src/plugin-v2.ts file path) are
+    // recognized via managedPluginIdentity and already stripped above, so
+    // they migrate here.
     const resolvedV2 = resolveInstalledPlugin(PANTHEON_V2_PLUGIN)
     config.plugins = config.plugins.filter(
       (plugin) => pluginReferenceIdentity(plugin) !== pluginReferenceIdentity(resolvedV2),
@@ -1522,16 +1608,6 @@ export async function installOpenCode(
       configToWrite.plugins,
       config.context_sandbox,
     )
-
-    // Bootstrap chicken-and-egg: the pin names the CURRENT package version,
-    // which exists on the registry only after publish. From an npm install
-    // (global prefix / npx cache) that is the published version by
-    // construction; from a repo checkout the pin may point at an unpublished
-    // version the host cannot resolve. Warn instead of failing — the config is
-    // structurally correct and the pin realigns once the version is out.
-    if (!RUNNING_FROM_NPM_INSTALL) {
-      warning(S.v2UnpublishedPin(PANTHEON_V2_PACKAGE_SPEC))
-    }
   }
 
   const configContent = `${JSON.stringify(configToWrite, null, 2)}\n`
@@ -1635,4 +1711,25 @@ export async function installOpenCode(
   if (stats.errors > 0) {
     throw new Error(`installation completed with ${stats.errors} error(s); see output above`)
   }
+
+  // Record the component state only after the install has completed. The
+  // postinstall marker can predate `init` and start with every component
+  // pending; leaving it untouched made a healthy beta install look incomplete
+  // to `doctor` forever. Unselected components retain their previous state.
+  if (!dryRun) {
+    const packageVersion = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')).version
+    let state = readState(target)
+    if (!state && hasState(target)) {
+      throw new Error('Installation state exists but cannot be read; refusing to replace it')
+    }
+    state ??= createInitialState(packageVersion)
+    state.pantheon_version = packageVersion
+    for (const component of ['agents', 'skills', 'plugins', 'runtime']) {
+      if (!componentSet.has(component)) continue
+      const status = component === 'runtime' && !runtimeHealthy ? 'failed' : 'installed'
+      const componentVersion = state.components?.[component]?.version ?? 1
+      setComponentState(state, component, componentVersion, status)
+    }
+    writeState(target, state)
+  }
 }

package/scripts/install/plugin.mjs

@@ -8,24 +8,24 @@ import { isAbsolute, join, resolve } from 'node:path'
 import { ROOT, writeIfChanged } from './shared.mjs'
 
 /**
- * Copy a plugin's runtime payload (the bundled dist/*, package.json and
- * package-lock.json) from source to destination. Only the bundle is copied —
- * the raw TSX source is never shipped to the destination, so the plugin can
- * be modularized without the loader needing relative imports.
+ * Copy a plugin's runtime payload (the root TUI loader, bundled dist/*,
+ * package.json and package-lock.json) from source to destination. The raw TSX
+ * implementation is never shipped to the destination; tui.ts only re-exports
+ * the host-specific bundle so the local plugin stays hermetic.
  * @param {string} srcDir - Source plugin directory (e.g. ROOT/src/plugins/tui)
  * @param {string} dstDir - Destination plugin directory
  * @param {object} [options]
  * @param {boolean} [options.dryRun=false] - If true, don't write files
+ * @param {'v1'|'v2'} [options.version='v1'] - Host plugin generation
  * @returns {{ created: number, skipped: number }}
  */
-export function copyPluginFiles(srcDir, dstDir, { dryRun = false } = {}) {
+export function copyPluginFiles(srcDir, dstDir, { dryRun = false, version = 'v1' } = {}) {
   const result = { created: 0, skipped: 0 }
 
   if (!dryRun) mkdirSync(dstDir, { recursive: true })
   if (!dryRun) mkdirSync(join(dstDir, 'dist'), { recursive: true })
 
   // Drop legacy raw copies from previous installs (root index.tsx + dist/tui.tsx).
-  // The loader consumes only the bundle, so stale raws must not linger.
   if (!dryRun) {
     rmSync(join(dstDir, 'index.tsx'), { force: true })
     rmSync(join(dstDir, 'dist', 'tui.tsx'), { force: true })
@@ -45,15 +45,45 @@ export function copyPluginFiles(srcDir, dstDir, { dryRun = false } = {}) {
   // Copy package.json
   const pkgSrc = join(srcDir, 'package.json')
   if (existsSync(pkgSrc)) {
+    const packageJson = JSON.parse(readFileSync(pkgSrc, 'utf8'))
+    if (version === 'v2' && packageJson.exports?.['./tui-v2']) {
+      packageJson.exports['./tui'] = packageJson.exports['./tui-v2']
+    }
     const pkgStatus = writeIfChanged(
       join(dstDir, 'package.json'),
-      readFileSync(pkgSrc, 'utf8'),
+      `${JSON.stringify(packageJson, null, 2)}\n`,
       dryRun,
     )
     if (pkgStatus === 'created') result.created++
     else result.skipped++
   }
 
+  // Each host generation receives its own root loader and compiled bundle.
+  const tuiEntrySrc = join(srcDir, version === 'v2' ? 'tui-v2.ts' : 'tui.ts')
+  if (existsSync(tuiEntrySrc)) {
+    const entryStatus = writeIfChanged(
+      join(dstDir, 'tui.ts'),
+      readFileSync(tuiEntrySrc, 'utf8'),
+      dryRun,
+    )
+    if (entryStatus === 'created') result.created++
+    else result.skipped++
+  }
+
+  const v2ServerEntry = join(srcDir, 'index-v2.ts')
+  const v2ServerDestination = join(dstDir, 'index.ts')
+  if (version === 'v2' && existsSync(v2ServerEntry)) {
+    const entryStatus = writeIfChanged(
+      v2ServerDestination,
+      readFileSync(v2ServerEntry, 'utf8'),
+      dryRun,
+    )
+    if (entryStatus === 'created') result.created++
+    else result.skipped++
+  } else if (!dryRun) {
+    rmSync(v2ServerDestination, { force: true })
+  }
+
   // 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')
@@ -79,14 +109,18 @@ export function copyPluginFiles(srcDir, dstDir, { dryRun = false } = {}) {
  * @param {boolean} [options.clean=false] - If true, remove existing before install
  * @returns {{ created: number, skipped: number, errors: number }}
  */
-export function installPlugin(srcDir, dstDir, { dryRun = false, clean = false } = {}) {
+export function installPlugin(
+  srcDir,
+  dstDir,
+  { dryRun = false, clean = false, version = 'v1' } = {},
+) {
   const result = { created: 0, skipped: 0, errors: 0 }
 
   if (clean && existsSync(dstDir) && !dryRun) {
     rmSync(dstDir, { recursive: true, force: true })
   }
 
-  const copyResult = copyPluginFiles(srcDir, dstDir, { dryRun })
+  const copyResult = copyPluginFiles(srcDir, dstDir, { dryRun, version })
   result.created += copyResult.created
   result.skipped += copyResult.skipped
 

package/scripts/install/strings.mjs

@@ -47,10 +47,6 @@ const TABLE = {
     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...',
-    v2UnpublishedPin: (spec) =>
-      `V2 plugin is pinned to ${spec}, but this installer is running from a source checkout — ` +
-      'that version may not be published to npm yet, so OpenCode cannot resolve the pin until it is. ' +
-      'Run the installer from the published package (npx pantheon-opencode init) to avoid this.',
     // summary (printSummary)
     summaryInstalled: (target) => `OpenCode installed in ${target}`,
     summaryWithErrors: (target) => `Installation finished WITH ERRORS in ${target}`,
@@ -99,10 +95,6 @@ const TABLE = {
     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...',
-    v2UnpublishedPin: (spec) =>
-      `Plugin V2 fixado em ${spec}, mas este installer está rodando de um checkout do código-fonte — ` +
-      'essa versão pode ainda não estar publicada no npm, então o OpenCode não resolve o pin até a publicação. ' +
-      'Rode o installer pelo pacote publicado (npx pantheon-opencode init) para evitar isso.',
     // summary (printSummary)
     summaryInstalled: (target) => `OpenCode instalado em ${target}`,
     summaryWithErrors: (target) => `Instalação concluída COM ERROS em ${target}`,

package/scripts/probe-pantheon-cost.mjs

@@ -8,10 +8,9 @@
  * temporary synthetic opencode database. A missing fixture runtime is also
  * AMBIENTAL rather than a false PASS.
  */
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync } from 'node:fs'
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
 
 const requestedVersion = valueFor('--version')
 const jsonOutput = process.argv.includes('--json')
@@ -152,27 +151,19 @@ async function main() {
     return
   }
 
-  const root = mkdtempSync(join(tmpdir(), 'pantheon-cost-probe-'))
   let DatabaseSync
   let createCostCommand
   try {
     ;({ DatabaseSync } = await import('node:sqlite'))
-    // Node's built-in TS stripping deliberately refuses files under
-    // node_modules. Exercise the shipped command from an isolated temp copy
-    // while resolving its runtime dependencies through the installed package.
-    const runtimeSource = join(root, 'cost-command.ts')
-    const packageNodeModules = fileURLToPath(new URL('../node_modules/', import.meta.url))
-    copyFileSync(fileURLToPath(source), runtimeSource)
-    symlinkSync(packageNodeModules, join(root, 'node_modules'), 'dir')
-    ;({ createCostCommand } = await import(pathToFileURL(runtimeSource).href))
+    ;({ createCostCommand } = await import(source.href))
   } catch (error) {
-    rmSync(root, { recursive: true, force: true })
     ambiental(
       `pantheon_cost fixture runtime unavailable: ${error instanceof Error ? error.message : String(error)}`,
     )
     return
   }
 
+  const root = mkdtempSync(join(tmpdir(), 'pantheon-cost-probe-'))
   const dataHome = join(root, 'data')
   const opencodeDir = join(dataHome, 'opencode')
   // Every real installation writes `opencode.db`; the v1/v2 distinction is the
@@ -263,7 +254,6 @@ async function main() {
 
     const restore = setEnvironment({
       XDG_DATA_HOME: dataHome,
-      OPENCODE_DB: undefined,
       PANTHEON_OPENCODE_VERSION: requestedVersion,
       PANTHEON_COST_DB: undefined,
     })
@@ -294,7 +284,6 @@ async function main() {
 
     const envRestore = setEnvironment({
       XDG_DATA_HOME: dataHome,
-      OPENCODE_DB: undefined,
       PANTHEON_OPENCODE_VERSION: requestedVersion,
       PANTHEON_COST_DB: envDb,
     })
@@ -319,7 +308,6 @@ async function main() {
 
     const explicitRestore = setEnvironment({
       XDG_DATA_HOME: dataHome,
-      OPENCODE_DB: undefined,
       PANTHEON_OPENCODE_VERSION: requestedVersion,
       PANTHEON_COST_DB: envDb,
     })
@@ -341,7 +329,6 @@ async function main() {
 
     const missingRestore = setEnvironment({
       XDG_DATA_HOME: join(root, 'missing-data'),
-      OPENCODE_DB: undefined,
       PANTHEON_OPENCODE_VERSION: requestedVersion,
       PANTHEON_COST_DB: undefined,
     })

package/scripts/sync-artifacts.mjs

@@ -40,6 +40,7 @@ const MCP_SCRIPTS = {
   'pantheon_vision.py': () => join(ROOT, 'src', 'mcp', 'pantheon_vision.py'),
   'eval_store.py': () => join(ROOT, 'src', 'mcp', 'eval_store.py'),
   'scrub-secrets.py': () => join(ROOT, 'scripts', 'scrub-secrets.py'),
+  'themis_heuristic_scan.py': () => join(ROOT, 'scripts', 'themis_heuristic_scan.py'),
 }
 
 /**