pantheon-opencode 1.6.0-beta.1 → 1.6.0-beta.10

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/shared.mjs

@@ -7,6 +7,7 @@ import {
   copyFileSync,
   cpSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readdirSync,
   readFileSync,
@@ -24,7 +25,7 @@ if (parseInt(process.versions.node.split('.')[0], 10) < REQUIRED_NODE_MAJOR) {
   process.exit(1)
 }
 
-import yaml from 'js-yaml'
+import { dump, load } from 'js-yaml'
 
 export const __dirname = dirname(fileURLToPath(import.meta.url))
 export const ROOT = join(__dirname, '..', '..')
@@ -257,17 +258,105 @@ export function copyFiles(srcDir, dstDir, dryRun, renameMap = null, clean = fals
   return { created, skipped }
 }
 
-export function writeIfChanged(filePath, content, dryRun) {
-  const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : null
+/**
+ * `lstat` that returns `null` instead of throwing for an absent path.
+ *
+ * Deliberately `lstat`, not `stat`/`existsSync`: both of those follow the link,
+ * so a DANGLING symlink reads as absent and the atomic rename below would then
+ * silently replace the link itself. `lstat` sees the link and lets the write
+ * guard refuse it.
+ */
+function lstatOrNull(filePath) {
+  try {
+    return lstatSync(filePath)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Read a path's raw text, or `null` when it cannot be read (absent, dangling
+ * symlink target, permission error). The caller decides what "unreadable"
+ * means; this never throws.
+ */
+function readFileOrNull(filePath) {
+  try {
+    return readFileSync(filePath, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Atomically create/overwrite a text file, skipping an unchanged write.
+ *
+ * @param {string} filePath - destination path
+ * @param {string} content - full file content
+ * @param {boolean} dryRun - when true, compute the outcome without writing
+ * @param {object} [options]
+ * @param {string|null} [options.expectedContent] - the raw content the caller
+ *   read this path from, if any. When supplied, the write proceeds only if the
+ *   on-disk content STILL matches it — compared once up front AND again
+ *   immediately before the rename; otherwise it returns `'conflict'` and leaves
+ *   the file alone. This is a best-effort COMPARE-BEFORE-WRITE guard, NOT a
+ *   filesystem CAS: the final re-read and the rename are still two syscalls, so
+ *   a writer that lands between them is not prevented. What it does close is
+ *   the window the installer actually races with — a config the caller parsed
+ *   going stale during the same run — and it keeps the target and the `.bak`
+ *   consistent with the bytes that were checked.
+ * @param {(existing: string|null) => void} [options.beforeRecheck] - runs after
+ *   the initial content check and before the last-moment re-read. Injection
+ *   point so tests can simulate a concurrent writer landing in the window;
+ *   production callers omit it (undefined is a no-op).
+ * @param {(existing: string|null) => void} [options.beforeSwap] - runs after the
+ *   expected-content checks pass and immediately before the rename, so side
+ *   effects that must not fire on a conflict (e.g. the `.bak` copy) live here.
+ * @returns {'created'|'skipped'|'conflict'}
+ */
+export function writeIfChanged(filePath, content, dryRun, options = {}) {
+  const { expectedContent, beforeSwap, beforeRecheck } = options
+
+  // Refuse to write through/over a symlink. A dangling symlink is invisible to
+  // existsSync, and rename-over-link would replace the link rather than its
+  // target — both are silent redirections the installer must not perform.
+  const stat = lstatOrNull(filePath)
+  if (stat?.isSymbolicLink()) {
+    throw new Error(`Refusing to write through symlink: ${filePath}`)
+  }
+
+  const existing = stat === null ? null : readFileOrNull(filePath)
   if (existing === content) {
     return 'skipped'
   }
+  if (expectedContent !== undefined && existing !== expectedContent) {
+    // The file changed since the caller read it (or appeared/disappeared).
+    // Do not clobber the newer content; the caller decides how to react.
+    return 'conflict'
+  }
   if (!dryRun) {
+    // Seam for a concurrent writer to land between the read above and the
+    // re-read below. No production caller passes this.
+    if (typeof beforeRecheck === 'function') beforeRecheck(existing)
+
     // 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')
+
+    // Last-moment re-read. The initial compare and this rename are separate
+    // syscalls, so a concurrent writer can land in between; re-check the
+    // expected bytes immediately before the swap. On a mismatch, drop the temp
+    // and leave the target AND any existing `.bak` byte-identical.
+    if (expectedContent !== undefined) {
+      const current = readFileOrNull(filePath)
+      if (current !== expectedContent) {
+        rmSync(tmpPath, { force: true })
+        return 'conflict'
+      }
+    }
+
+    if (typeof beforeSwap === 'function') beforeSwap(existing)
     renameSync(tmpPath, filePath)
   }
   return 'created'
@@ -277,12 +366,31 @@ export function writeIfChanged(filePath, content, dryRun) {
  * 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.
+ *
+ * The backup is created INSIDE the `beforeSwap` hook, so it fires only after
+ * both expected-content checks pass (the initial compare and the last-moment
+ * re-read before the rename). A conflict observed at either point leaves the
+ * target AND any pre-existing `.bak` untouched, rather than overwriting the
+ * user's last known-good backup with a stale copy on a no-op write.
+ *
+ * @param {string} filePath
+ * @param {string} content
+ * @param {boolean} dryRun
+ * @param {object} [options] - forwarded to {@link writeIfChanged}
  */
-export function writeConfigWithBackup(filePath, content, dryRun) {
-  if (!dryRun && existsSync(filePath)) {
-    copyFileSync(filePath, `${filePath}.bak`)
-  }
-  return writeIfChanged(filePath, content, dryRun)
+export function writeConfigWithBackup(filePath, content, dryRun, options = {}) {
+  return writeIfChanged(filePath, content, dryRun, {
+    expectedContent: options.expectedContent,
+    beforeRecheck: options.beforeRecheck,
+    beforeSwap: (existing) => {
+      if (existing === null) return
+      try {
+        copyFileSync(filePath, `${filePath}.bak`)
+      } catch {
+        // Best-effort: a backup failure must not block the install.
+      }
+    },
+  })
 }
 
 /**
@@ -326,10 +434,10 @@ export function collectSkillNames() {
  * Returns { fm: object, body: string } or null if no frontmatter.
  */
 export function parseFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/)
+  const match = content.match(/^---\r?\n([\s\S]*?)(?:\r?\n)?---\r?\n?([\s\S]*)$/)
   if (!match) return null
   return {
-    fm: yaml.load(match[1]) ?? {},
+    fm: match[1].trim() ? (load(match[1]) ?? {}) : {},
     body: match[2],
   }
 }
@@ -339,9 +447,9 @@ export function parseFrontmatter(content) {
  * Uses long-line mode and avoids unnecessary quoting.
  */
 export function serializeFm(fm) {
-  return yaml.dump(fm, {
+  return dump(fm, {
     lineWidth: -1,
-    quotingType: '"',
+    quoteStyle: 'double',
     forceQuotes: false,
     noRefs: true,
   })

package/scripts/install/vision-prompt.mjs

@@ -0,0 +1,161 @@
+/**
+ * vision-prompt.mjs — optional vision step of `pantheon-opencode init`.
+ *
+ * After the model-preset wizard, an interactive TTY session is offered a
+ * three-way choice for the vision model:
+ *   1. automatic discovery (default, Enter) — writes nothing
+ *   2. pin a `provider/model`              — merges `visionModel` into the
+ *      GLOBAL vision config (~/.config/opencode/opencode-vision.json)
+ *   3. skip                                 — writes nothing
+ *
+ * Non-interactive runs (no TTY, `--yes`, `--headless`, automated sandboxes)
+ * never reach this module: `installOpenCode` only calls it when
+ * `interactive && !dryRun && !autoYes`. Automatic discovery therefore stays
+ * the default in every non-interactive flow and no run blocks on stdin.
+ *
+ * The write mirrors the `/pantheon-vision` command: atomic, `.bak` backup,
+ * and a MERGE — existing keys are never overwritten.
+ */
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { writeConfigWithBackup } from './shared.mjs'
+
+const CONFIG_FILENAME = 'opencode-vision.json'
+/** `provider/model` — exactly one slash, no surrounding whitespace. */
+const MODEL_PATTERN = /^[^\s/]+\/[^\s/]+$/
+const MAX_PIN_ATTEMPTS = 3
+
+/** Global vision config path, honoring `XDG_CONFIG_HOME` (same rule as the plugin). */
+export function globalVisionConfigPath(env = process.env) {
+  const home = env.HOME?.trim() || homedir()
+  const xdg = env.XDG_CONFIG_HOME?.trim() || join(home, '.config')
+  return join(xdg, 'opencode', CONFIG_FILENAME)
+}
+
+/** True when `value` looks like a `provider/model` id (one slash, no spaces). */
+export function isValidVisionModel(value) {
+  return typeof value === 'string' && MODEL_PATTERN.test(value.trim())
+}
+
+/**
+ * Merge `visionModel` into a vision config, preserving every other key.
+ * Defaults to the GLOBAL config; pass `configPath` to target another file
+ * (e.g. the project config `.opencode/opencode-vision.json`). Creates the
+ * parent directory when missing; never overwrites existing keys. A corrupted
+ * JSON file is left byte-identical (the caller decides what to tell the user)
+ * rather than clobbered.
+ *
+ * A concurrent writer that changes the file between the read and the atomic
+ * swap makes `writeConfigWithBackup` return `'conflict'`: the write is aborted,
+ * `wrote` is `false`, and the newer content is left untouched.
+ *
+ * @param {object} [opts]
+ * @param {Record<string, string|undefined>} [opts.env]
+ * @param {boolean} [opts.dryRun]
+ * @param {string} [opts.configPath] - explicit target file (defaults to global)
+ * @param {(existing: string|null) => void} [opts.beforeRecheck] - test seam
+ *   forwarded to `writeConfigWithBackup` to simulate a concurrent writer.
+ * @returns {{path: string, wrote: boolean, reason: 'created'|'skipped'|'conflict'|'corrupt'|'dry-run'}}
+ */
+export function mergeVisionModel(
+  model,
+  { env = process.env, dryRun = false, beforeRecheck, configPath: target } = {},
+) {
+  const configPath = target ?? globalVisionConfigPath(env)
+  let parsed = {}
+  let existingRaw
+  if (existsSync(configPath)) {
+    existingRaw = readFileSync(configPath, 'utf8')
+    try {
+      const data = JSON.parse(existingRaw)
+      if (data && typeof data === 'object' && !Array.isArray(data)) parsed = data
+    } catch {
+      return { path: configPath, wrote: false, reason: 'corrupt' }
+    }
+  }
+  if (dryRun) return { path: configPath, wrote: false, reason: 'dry-run' }
+  const next = { ...parsed, visionModel: model }
+  const content = `${JSON.stringify(next, null, 2)}\n`
+  mkdirSync(dirname(configPath), { recursive: true })
+  const status = writeConfigWithBackup(configPath, content, false, {
+    expectedContent: existingRaw,
+    beforeRecheck,
+  })
+  return { path: configPath, wrote: status === 'created', reason: status }
+}
+
+/**
+ * Ask the interactive vision question. `rl` may be injected (tests / an
+ * existing readline interface); otherwise a private one is created and closed.
+ * Returns `{action, visionModel?, wrote?, path?}` — never throws on bad input,
+ * and never writes for the default/skip paths.
+ *
+ * @param {{rl?: object, logger?: object, env?: Record<string, string|undefined>, dryRun?: boolean, beforeRecheck?: (existing: string|null) => void}} [opts]
+ */
+export async function runVisionPrompt({
+  rl,
+  logger = console,
+  env = process.env,
+  dryRun = false,
+  beforeRecheck,
+} = {}) {
+  let iface = rl
+  let closeAfter = false
+  if (!iface) {
+    const { createInterface } = await import('node:readline/promises')
+    iface = createInterface({ input: process.stdin, output: process.stdout })
+    closeAfter = true
+  }
+  try {
+    logger.log?.('')
+    logger.log?.('Vision — how should images be described?')
+    logger.log?.(
+      '  1) Automatic discovery (default) — pick a vision-capable model from the host catalog',
+    )
+    logger.log?.('  2) Pin a provider/model (e.g. opencode-go/mimo-v2.5)')
+    logger.log?.('  3) Skip')
+    const answer = (await iface.question('Choice [1]: ')).trim().toLowerCase()
+
+    if (answer === '' || answer === '1' || answer === 'auto' || answer === 'discovery') {
+      logger.log?.('Vision: automatic discovery (no config written).')
+      return { action: 'auto' }
+    }
+    if (answer === '3' || answer === 'skip' || answer === 'no') {
+      logger.log?.('Vision: skipped (no config written).')
+      return { action: 'skip' }
+    }
+    if (answer === '2' || answer === 'pin') {
+      for (let attempt = 0; attempt < MAX_PIN_ATTEMPTS; attempt++) {
+        const raw = (await iface.question('provider/model (e.g. opencode-go/mimo-v2.5): ')).trim()
+        if (!isValidVisionModel(raw)) {
+          logger.warn?.(`Invalid model "${raw}" — expected provider/model (one slash, no spaces).`)
+          continue
+        }
+        const result = mergeVisionModel(raw, { env, dryRun, beforeRecheck })
+        if (result.reason === 'corrupt') {
+          logger.warn?.(
+            `Vision config at ${result.path} is not valid JSON — leaving it untouched; fix it and re-run.`,
+          )
+          return { action: 'pin', visionModel: raw, wrote: false, path: result.path }
+        }
+        if (result.reason === 'conflict') {
+          logger.warn?.(
+            `Vision: not saved — config at ${result.path} was modified concurrently; re-run to retry.`,
+          )
+        } else {
+          logger.log?.(`Vision: pinned ${raw} in ${result.path}.`)
+        }
+        return { action: 'pin', visionModel: raw, wrote: result.wrote, path: result.path }
+      }
+      logger.warn?.('Vision: no valid model entered — skipping (no config written).')
+      return { action: 'skip' }
+    }
+    logger.warn?.(
+      `Unknown choice "${answer}" — defaulting to automatic discovery (no config written).`,
+    )
+    return { action: 'auto' }
+  } finally {
+    if (closeAfter) iface.close()
+  }
+}

package/scripts/install-mcp.mjs

@@ -24,6 +24,7 @@ import { homedir } from 'node:os'
 import { basename, dirname, join, resolve } from 'node:path'
 import { createInterface } from 'node:readline'
 import { fileURLToPath } from 'node:url'
+import { migrateMcpEntrypointPaths } from './install/config-migration.mjs'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = join(__dirname, '..')
@@ -70,11 +71,11 @@ function resolveServerScript(relPath) {
 }
 
 const VENV_PYTHON = resolveVenvPython()
-const MCP_RESOURCES_SERVER = resolveServerScript('scripts/mcp_resources_server.py')
-const CODE_MODE_SERVER = resolveServerScript('scripts/code_mode_server.py')
-const MEMORY_MCP_SERVER = resolveServerScript('scripts/memory_mcp_server.py')
-const MCP_PERSISTENCE_SERVER = resolveServerScript('scripts/mcp_persistence_server.py')
-const PANTHEON_VISION_SERVER = resolveServerScript('src/mcp/pantheon_vision_server.py')
+const MCP_RESOURCES_SERVER = resolveServerScript('scripts/mcp_resources.py')
+const CODE_MODE_SERVER = resolveServerScript('scripts/code_mode.py')
+const MEMORY_MCP_SERVER = resolveServerScript('scripts/memory_mcp.py')
+const MCP_PERSISTENCE_SERVER = resolveServerScript('scripts/mcp_persistence.py')
+const PANTHEON_VISION_SERVER = resolveServerScript('src/mcp/pantheon_vision.py')
 
 // ---------------------------------------------------------------------------
 // MCP Definitions
@@ -209,7 +210,7 @@ export const MCPS = {
       if (existsSync(scriptPath)) {
         return { ok: true, message: 'server script present' }
       }
-      return { ok: false, message: 'mcp_resources_server.py not found at resolved path' }
+      return { ok: false, message: 'mcp_resources.py not found at resolved path' }
     },
   },
   'pantheon-code-mode': {
@@ -230,7 +231,7 @@ export const MCPS = {
       if (existsSync(scriptPath)) {
         return { ok: true, message: 'server script present' }
       }
-      return { ok: false, message: 'code_mode_server.py not found at resolved path' }
+      return { ok: false, message: 'code_mode.py not found at resolved path' }
     },
   },
   'pantheon-memory': {
@@ -251,7 +252,7 @@ export const MCPS = {
       if (existsSync(scriptPath)) {
         return { ok: true, message: 'server script present' }
       }
-      return { ok: false, message: 'memory_mcp_server.py not found at resolved path' }
+      return { ok: false, message: 'memory_mcp.py not found at resolved path' }
     },
   },
   'pantheon-persistence': {
@@ -272,7 +273,7 @@ export const MCPS = {
       if (existsSync(scriptPath)) {
         return { ok: true, message: 'server script present' }
       }
-      return { ok: false, message: 'mcp_persistence_server.py not found at resolved path' }
+      return { ok: false, message: 'mcp_persistence.py not found at resolved path' }
     },
   },
   'pantheon-vision': {
@@ -471,8 +472,22 @@ function writeMcpConfig(platformName, mcpKey, dryRun, force) {
     config[key] = {}
   }
 
+  // Heal pre-rename MCP entrypoint paths before the skip check, so re-running
+  // the installer repairs an existing config whose `*_server.py` paths were
+  // orphaned by the entrypoint rename. Without this the rename is a silent
+  // break for every already-installed config (see config-migration.mjs).
+  const healed = migrateMcpEntrypointPaths(config[key])
+
   // Check if the MCP already has an entry
   if (config[key][mcpKey] && !force) {
+    if (healed > 0 && !dryRun) {
+      writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8')
+      return {
+        status: 'healed',
+        path: configPath,
+        reason: `Updated ${healed} stale MCP entrypoint path(s) in ${platform.configFile}`,
+      }
+    }
     return {
       status: 'skipped',
       reason: `Already exists in ${platform.configFile} (use --force to overwrite)`,
@@ -705,6 +720,10 @@ function logResult(platformLabel, mcpKey, result) {
       console.log(`  ⏭️  ${label} — ${result.reason}`)
       progress.skipped.push({ platform: platformLabel, mcp: mcpKey, reason: result.reason })
       break
+    case 'healed':
+      console.log(`  🩹 ${label} — ${result.reason}`)
+      progress.installed.push({ platform: platformLabel, mcp: mcpKey })
+      break
     case 'dry-run': {
       const desc =
         result.entry?.type === 'remote' || result.entry?.type === 'http'

package/scripts/{mcp_persistence_server.py → mcp_persistence.py}

@@ -5,7 +5,7 @@ Key-Value store with FTS5 full-text search, TTL-based expiration,
 and namespace isolation. Uses SQLite with zero external dependencies.
 
 Usage:
-    python scripts/mcp_persistence_server.py
+    python scripts/mcp_persistence.py
 """
 
 from __future__ import annotations
@@ -25,7 +25,7 @@ from pathlib import Path
 from typing import Annotated
 
 from _pantheon_paths import pantheon_home, pantheon_project
-from mcp.server.fastmcp import FastMCP
+from fastmcp import FastMCP
 from pydantic import Field
 
 # ── Schema ──────────────────────────────────────────────────────────────────────

package/{src/mcp/mcp_resources_server.py → scripts/mcp_resources.py}

@@ -7,7 +7,7 @@ Provides MCP resources for the Pantheon agent framework:
   plans/status, memory-bank files
 
 Usage:
-    python scripts/mcp_resources_server.py
+    python scripts/mcp_resources.py
 """
 
 from __future__ import annotations
@@ -19,7 +19,7 @@ from typing import Any
 import yaml
 from _pantheon_paths import has_symlink_component, pantheon_home, pantheon_project
 from eval_store import get_latest_eval, list_evals
-from mcp.server.fastmcp import FastMCP
+from fastmcp import FastMCP
 
 # ── Path Resolution ──────────────────────────────────────────────────────────
 _PANTHEON_HOME: Path = pantheon_home()

package/scripts/{memory_mcp_server.py → memory_mcp.py}

@@ -19,7 +19,7 @@ Tools:
     memory_stats   — DB statistics
 
 Usage:
-    python scripts/memory_mcp_server.py
+    python scripts/memory_mcp.py
 """
 
 from __future__ import annotations
@@ -33,7 +33,7 @@ from pathlib import Path
 from typing import Annotated, Any
 
 from _pantheon_paths import pantheon_home
-from mcp.server.fastmcp import FastMCP
+from fastmcp import FastMCP
 from pydantic import BeforeValidator, Field
 
 # ── Paths ─────────────────────────────────────────────────────────────────────

package/scripts/probe-context-rehydrate.mjs

@@ -15,7 +15,7 @@ import { fileURLToPath } from 'node:url'
 
 const requestedVersion = valueFor('--version')
 const jsonOutput = process.argv.includes('--json')
-const runtime = fileURLToPath(new URL('./mcp_persistence_server.py', import.meta.url))
+const runtime = fileURLToPath(new URL('./mcp_persistence.py', import.meta.url))
 
 function valueFor(name) {
   const index = process.argv.indexOf(name)
@@ -63,6 +63,12 @@ spec.loader.exec_module(module)
 
 async def call(name, arguments):
     result = await module.mcp.call_tool(name, arguments)
+    structured = getattr(result, "structured_content", None)
+    if structured is not None:
+        metadata = getattr(result, "meta", None) or {}
+        if metadata.get("fastmcp", {}).get("wrap_result"):
+            return structured.get("result") if isinstance(structured, dict) else structured
+        return structured
     if isinstance(result, tuple):
         structured = result[1]
         if structured is not None:
@@ -186,7 +192,7 @@ async function main() {
     return
   }
   if (!existsSync(runtime)) {
-    unavailable('installed package does not include mcp_persistence_server.py')
+    unavailable('installed package does not include mcp_persistence.py')
     return
   }