pantheon-opencode 1.4.3 → 1.5.0-beta.10

package/scripts/doctor.mjs

@@ -4,16 +4,15 @@
  * doctor.mjs — Pantheon health check CLI tool
  *
  * Validates that a Pantheon installation is working correctly:
- *   - Agent file presence across canonical → platform
+ *   - Canonical agent file presence
  *   - MCP configuration (gh_grep, Context7, etc.)
  *   - Permission/frontmatter mismatches
- *   - Sync freshness
+ *   - OpenCode artifact freshness
  *   - Git status
  *
  * Usage:
  *   node scripts/doctor.mjs                          # auto-detect, cwd
  *   node scripts/doctor.mjs --target /path/to/project
- *   node scripts/doctor.mjs --platform opencode
  *   node scripts/doctor.mjs --fix                    # attempt auto-fixes
  *   node scripts/doctor.mjs --verbose
  *   node scripts/doctor.mjs --help
@@ -23,7 +22,8 @@
  */
 
 import { spawn as spawnAsync, spawnSync } from 'node:child_process'
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -35,15 +35,6 @@ import { fileURLToPath } from 'node:url'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = join(__dirname, '..')
 const AGENTS_DIR = join(ROOT, 'src', 'agents')
-const PLATFORM_DIR = join(ROOT, 'platform')
-
-// All known platforms (must match platform/ subdirectories with adapter.json)
-const _ALL_PLATFORMS = ['opencode']
-
-const PLATFORM_LABELS = {
-  opencode: 'OpenCode',
-}
-
 // ---------------------------------------------------------------------------
 // State
 // ---------------------------------------------------------------------------
@@ -73,9 +64,6 @@ function parseArgs(argv) {
       case '--target':
         args.target = argv[++i]
         break
-      case '--platform':
-        args.platform = argv[++i]
-        break
       case '--fix':
         args.fix = true
         break
@@ -157,19 +145,18 @@ function showHelp() {
  Usage:
    node scripts/doctor.mjs                              auto-detect, cwd
    node scripts/doctor.mjs --target /path/to/project     target project
-   node scripts/doctor.mjs --platform opencode           specific platform
    node scripts/doctor.mjs --profile global|lite|sandbox profile policy
    node scripts/doctor.mjs --fix                         attempt auto-fixes
    node scripts/doctor.mjs --verbose                     detailed output
    node scripts/doctor.mjs --help                        show this help
 
  Checks:
-   A. Agent Files          — canonical vs platform sync
+   A. Agent Files          — canonical agent files
    B. MCP Configuration    — opencode.json MCP settings (Config layer)
    B.5 MCP Spawn Paths     — local MCP exe/args resolve to existing files
    B.6 MCP Runtime Smoke   — spawn each local MCP + JSON-RPC initialize handshake
    C. Permission Checks    — frontmatter validation
-   D. Sync Status          — npm run sync freshness
+   D. OpenCode Status      — OpenCode artifact layout
    E. Git Status           — uncommitted changes
    F. Runtime Layer        — venv python + pinned pip dependencies
 
@@ -256,7 +243,7 @@ function spawn(prog, args, cwd = null) {
 // Check A: Agent Files
 // ---------------------------------------------------------------------------
 
-function checkAgentFiles(args) {
+function checkAgentFiles() {
   section('A. Agent Files')
 
   const canonical = getCanonicalAgentNames()
@@ -265,86 +252,6 @@ function checkAgentFiles(args) {
     return
   }
   pass(`${canonical.length} canonical agents found in agents/`)
-
-  // Determine which platforms to check
-  if (!existsSync(PLATFORM_DIR)) {
-    info(
-      `Platform component not distributed in this package — platform check skipped (${args.profile} profile)`,
-    )
-    return
-  }
-  const platformDirs = readdirSync(PLATFORM_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && d.name !== '_template' && d.name !== 'plans')
-    .map((d) => d.name)
-    .filter((name) => !args.platform || name === args.platform)
-
-  if (platformDirs.length === 0) {
-    info(
-      `No platform directories found in platform/ — platform check skipped (${args.profile} profile)`,
-    )
-    return
-  }
-
-  for (const platform of platformDirs) {
-    const adapterPath = join(PLATFORM_DIR, platform, 'adapter.json')
-    if (!existsSync(adapterPath)) {
-      info(`${platform}: no adapter.json — skipping`)
-      continue
-    }
-
-    const adapter = readJson(adapterPath)
-    if (!adapter) {
-      warn(`${platform}: adapter.json parse error — skipping`)
-      continue
-    }
-
-    const label = PLATFORM_LABELS[platform] ?? platform
-    const outputDir = adapter.outputDir ?? 'agents'
-    const ext = adapter.fileExtension ?? '.md'
-    const agentDir = join(PLATFORM_DIR, platform, outputDir)
-
-    if (!existsSync(agentDir)) {
-      if (adapter.skipAgentSync) {
-        info(`${label}: agent sync skipped (skipAgentSync) — n/a`)
-        continue
-      }
-      warn(`${label}: output directory missing: ${agentDir}`)
-      continue
-    }
-
-    if (adapter.skipAgentSync) {
-      info(`${label}: agent sync skipped (skipAgentSync) — skipping agent check`)
-      continue
-    }
-
-    const platformFiles = readdirSync(agentDir)
-      .filter((f) => statSync(join(agentDir, f)).isFile() && f.endsWith(ext))
-      .map((f) => f.replace(new RegExp(`${ext}$`), ''))
-
-    // Check every canonical agent exists in platform output
-    let allPresent = true
-    const missing = []
-    for (const agent of canonical) {
-      if (!platformFiles.includes(agent)) {
-        missing.push(agent)
-        allPresent = false
-      }
-    }
-
-    // Detect phantom agents (in platform but not canonical — stale)
-    const phantom = platformFiles.filter((f) => !canonical.includes(f))
-
-    if (allPresent && phantom.length === 0) {
-      pass(`${label}: all ${canonical.length} agents present`)
-    } else {
-      if (missing.length > 0) {
-        error(`${label}: ${missing.length} canonical agent(s) missing: ${missing.join(', ')}`)
-      }
-      if (phantom.length > 0) {
-        warn(`${label}: ${phantom.length} stale agent(s) in output: ${phantom.join(', ')}`)
-      }
-    }
-  }
 }
 
 // ---------------------------------------------------------------------------
@@ -364,10 +271,12 @@ export function resolveOpenCodeConfigDir(env = process.env) {
  * @returns {{label:string, path:string, data:object}[]}
  */
 export function collectMcpConfigs(args) {
-  const candidates = [
-    { label: 'project root', path: join(args.target, 'opencode.json') },
-    { label: 'repository root', path: join(ROOT, 'opencode.json') },
-  ]
+  const candidates = [{ label: 'project root', path: join(args.target, 'opencode.json') }]
+  // The package's own template is useful when doctor is run from the
+  // repository, but must not be treated as a user's config from an installed
+  // package. Otherwise every global/project sandbox reports false MCP errors.
+  if (resolve(args.target) === resolve(ROOT))
+    candidates.push({ label: 'repository root', path: join(ROOT, 'opencode.json') })
 
   // OpenCode resolves user configuration independently of cwd. Keep the
   // project-local .opencode config for repository checks, but always include
@@ -481,7 +390,7 @@ function checkMcpConfig(args) {
     // ENOENT-on-spawn failure class (dead hardcoded path, ambiguous relative
     // path) before opencode tries to spawn the server.
     for (const [name, mcpEntry] of Object.entries(mcp)) {
-      if (!mcpEntry || mcpEntry.type !== 'local') continue
+      if (mcpEntry?.type !== 'local') continue
       const cmd = mcpEntry.command
       if (!Array.isArray(cmd) || cmd.length === 0) {
         warn(`${cfg.label}: MCP "${name}" has no command array`)
@@ -495,11 +404,13 @@ function checkMcpConfig(args) {
         )
         continue
       }
-      if (!existsSync(exe)) {
-        error(`${cfg.label}: MCP "${name}" executable does not exist: ${exe}`)
+      const effectiveCwd = resolveMcpCwd(mcpEntry, cfg.path)
+      const effectiveExe = exe.startsWith('/') ? exe : resolve(effectiveCwd, exe)
+      if (!existsSync(effectiveExe)) {
+        error(`${cfg.label}: MCP "${name}" executable does not exist: ${effectiveExe}`)
         continue
       }
-      const deadArgs = cmd.slice(1).filter((a) => a.startsWith('/') && !existsSync(a))
+      const deadArgs = resolveMcpScriptPaths(mcpEntry, cfg.path).filter((path) => !existsSync(path))
       if (deadArgs.length > 0) {
         error(`${cfg.label}: MCP "${name}" has missing script path(s): ${deadArgs.join(', ')}`)
       }
@@ -620,9 +531,13 @@ async function checkMcpRuntimeSmoke(args) {
   const local = []
   for (const cfg of collectMcpConfigs(args)) {
     for (const [name, entry] of Object.entries(cfg.data.mcp ?? {})) {
-      if (!entry || entry.type !== 'local') continue
+      if (entry?.type !== 'local') continue
       if (!Array.isArray(entry.command) || entry.command.length === 0) continue
-      local.push({ name, command: entry.command, cwd: dirname(cfg.path), source: cfg.label })
+      const cwd = resolveMcpCwd(entry, cfg.path)
+      const command = entry.command.map((part, index) =>
+        index === 0 || part.startsWith('-') || part.startsWith('/') ? part : resolve(cwd, part),
+      )
+      local.push({ name, command, cwd, source: cfg.label })
     }
   }
 
@@ -702,8 +617,7 @@ function checkPermissionMismatches(args) {
   }
 
   // Determine which agent directories to check
-  // Validation script checks ~/.config/opencode/agents and platform/opencode/agents
-  // Let's run it regardless
+  // Validate the canonical agents and the OpenCode installation independently.
   info('Running validate-agent-frontmatter.py...')
 
   const result = spawn('python3', [validator])
@@ -789,14 +703,35 @@ function checkPermissionMismatches(args) {
 }
 
 // ---------------------------------------------------------------------------
-// Check D: Sync Status
+// Check D: OpenCode Status
 // ---------------------------------------------------------------------------
 
-function checkSyncStatus(_args) {
-  section('D. Sync Status')
-
-  // Platform sync removed in v1.0 (OpenCode-only)
-  info('Sync check skipped — platform sync was removed in v1.0')
+function checkSyncStatus(args) {
+  section('D. OpenCode Status')
+  const agentsDir = join(args.target, '.opencode', 'agents')
+  if (existsSync(agentsDir)) {
+    pass('OpenCode agents directory is present')
+    // Content gate: validate pantheon://agents CONTENT (zeus/hermes present),
+    // not just connectivity/directory presence.
+    const agentFiles = readdirSync(agentsDir).filter((f) => f.endsWith('.md'))
+    if (agentFiles.length === 0) {
+      warn('OpenCode agents directory is empty — pantheon://agents will serve no agents')
+    } else {
+      const names = new Set(agentFiles.map((f) => f.replace(/\.md$/, '').toLowerCase()))
+      const missingCanonical = ['zeus', 'hermes'].filter((n) => !names.has(n))
+      if (missingCanonical.length > 0) {
+        error(
+          `pantheon://agents content check failed — missing canonical agents in ${agentsDir}: ${missingCanonical.join(', ')}`,
+        )
+      } else {
+        pass(
+          `pantheon://agents content validated (zeus, hermes + ${agentFiles.length - 2} more agents)`,
+        )
+      }
+    }
+  } else {
+    info('OpenCode agents directory not present — project may use global agents')
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -813,8 +748,16 @@ function checkGitStatus(args) {
     return
   }
 
-  // Check for uncommitted changes in agents/ and platform/
-  const gitStatus = spawn('git', ['status', '--porcelain', '--', 'agents/', 'platform/'])
+  // Check the repository source and OpenCode configuration paths.
+  const gitStatus = spawn('git', [
+    'status',
+    '--porcelain',
+    '--',
+    'src/agents/',
+    'src/instructions/',
+    '.opencode/',
+    'opencode.json',
+  ])
 
   if (gitStatus.status !== 0) {
     warn('Could not check git status')
@@ -824,7 +767,7 @@ function checkGitStatus(args) {
   const lines = gitStatus.stdout ? gitStatus.stdout.split('\n').filter(Boolean) : []
 
   if (lines.length === 0) {
-    pass('No uncommitted changes in agents/ or platform/')
+    pass('No uncommitted changes in Pantheon/OpenCode paths')
     return
   }
 
@@ -851,7 +794,7 @@ function checkGitStatus(args) {
   if (deleted.length > 0) details.push(`${deleted.length} deleted`)
   if (untracked.length > 0) details.push(`${untracked.length} untracked`)
 
-  warn(`${total} uncommitted change(s) in agents/ or platform/ (${details.join(', ')})`)
+  warn(`${total} uncommitted change(s) in Pantheon/OpenCode paths (${details.join(', ')})`)
   if (args.verbose) {
     for (const f of modified.slice(0, 10)) {
       console.log(`    M  ${f}`)
@@ -963,8 +906,7 @@ function checkRequirementLine(line, installed) {
 function checkVenvLayer(args) {
   section('F. Runtime Layer — Venv, Python & Dependencies')
 
-  const configDir = resolveOpenCodeConfigDir()
-  const venvPython = join(configDir, '.venv', 'bin', 'python3')
+  const venvPython = resolveRuntimePython(args)
 
   if (!existsSync(venvPython)) {
     if (args.profile === 'lite') {
@@ -1013,6 +955,236 @@ function checkVenvLayer(args) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Check F.2: Code-Mode Scripts Directory
+// ---------------------------------------------------------------------------
+
+/**
+ * Verify the code-mode scripts directory exists for the resolved runtime
+ * root (project → <target>/.opencode, otherwise the global config dir).
+ * When absent, create it with a warning so the pantheon-code-mode MCP
+ * server has a stable home (mirrors the installer's runtime seeding).
+ */
+export function checkCodeModeDir(args) {
+  section('F.2 Code-Mode Scripts')
+  const env = args.env ?? process.env
+  const target = resolve(env.PANTHEON_PROJECT ?? args.target)
+  const projectCandidates = [
+    join(target, '.opencode', '.pantheon', 'code-mode'),
+    join(target, '.pantheon', 'code-mode'),
+  ]
+  // Seeding semantics: an existing project candidate wins; a project
+  // install (.opencode present) gets its runtime dir created when missing.
+  // Only targets with no project layout fall back to the global config dir.
+  const codeModeDir =
+    projectCandidates.find((candidate) => existsSync(candidate)) ??
+    (existsSync(join(target, '.opencode'))
+      ? projectCandidates[0]
+      : join(resolveOpenCodeConfigDir(env), '.pantheon', 'code-mode'))
+  if (existsSync(codeModeDir)) {
+    pass(`Code-mode scripts directory exists: ${codeModeDir}`)
+    return codeModeDir
+  }
+  warn(`Code-mode scripts directory missing — creating empty ${codeModeDir}`)
+  try {
+    mkdirSync(codeModeDir, { recursive: true })
+    info(`Created ${codeModeDir} (run \`pantheon-opencode init --components runtime\` to seed it)`)
+  } catch (err) {
+    error(`Cannot create code-mode directory ${codeModeDir}: ${err.message}`)
+  }
+  return codeModeDir
+}
+
+/** Resolve code-mode using the same project-first rule as the MCP server. */
+export function resolveCodeModeDir(args) {
+  const env = args.env ?? process.env
+  const target = resolve(env.PANTHEON_PROJECT ?? args.target)
+  const projectCandidates = [
+    join(target, '.opencode', '.pantheon', 'code-mode'),
+    join(target, '.pantheon', 'code-mode'),
+  ]
+  const projectDir = projectCandidates.find((candidate) => existsSync(candidate))
+  if (projectDir) return projectDir
+  return join(resolveOpenCodeConfigDir(env), '.pantheon', 'code-mode')
+}
+
+/** Validate a code-mode manifest without modifying it. */
+export function validateCodeModeManifest(codeModeDir) {
+  const manifestPath = join(codeModeDir, 'manifest.json')
+  if (!existsSync(manifestPath)) {
+    return { ok: false, message: `Code-mode manifest missing: ${manifestPath}` }
+  }
+
+  let data
+  try {
+    data = JSON.parse(readFileSync(manifestPath, 'utf8'))
+  } catch {
+    return { ok: false, message: `Code-mode manifest malformed: ${manifestPath}` }
+  }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return { ok: false, message: 'Code-mode manifest malformed: root must be an object' }
+  }
+  if (data.version !== 1) {
+    return { ok: false, message: 'Code-mode manifest malformed: version must be 1' }
+  }
+  if (!data.scripts || typeof data.scripts !== 'object' || Array.isArray(data.scripts)) {
+    return { ok: false, message: 'Code-mode manifest malformed: scripts must be an object' }
+  }
+
+  const listed = Object.keys(data.scripts)
+  const invalid = listed.filter(
+    (name) => typeof data.scripts[name] !== 'string' || !/^[a-f0-9]{64}$/i.test(data.scripts[name]),
+  )
+  if (invalid.length) {
+    return { ok: false, message: `Code-mode manifest invalid digest: ${invalid.join(', ')}` }
+  }
+
+  const actualScripts = readdirSync(codeModeDir).filter(
+    (name) =>
+      (name.endsWith('.py') || name.endsWith('.sh')) && statSync(join(codeModeDir, name)).isFile(),
+  )
+  const missing = listed.filter((name) => !existsSync(join(codeModeDir, name)))
+  const extra = actualScripts.filter((name) => !Object.hasOwn(data.scripts, name))
+  const differing = listed.filter((name) => {
+    const path = join(codeModeDir, name)
+    if (!existsSync(path)) return false
+    const digest = createHash('sha256').update(readFileSync(path)).digest('hex')
+    return digest !== data.scripts[name].toLowerCase()
+  })
+  if (missing.length || extra.length || differing.length) {
+    const names = [...new Set([...missing, ...extra, ...differing])]
+    return {
+      ok: false,
+      message: `Code-mode manifest mismatch: ${differing.length + missing.length + extra.length}/${listed.length} scripts differ — ${names.join(', ')}`,
+    }
+  }
+  return { ok: true, count: listed.length, total: actualScripts.length }
+}
+
+/** Run the diagnostic manifest check after directory validation. */
+export function checkCodeModeManifest(args) {
+  const codeModeDir = resolveCodeModeDir(args)
+  const result = validateCodeModeManifest(codeModeDir)
+  if (!result.ok) {
+    error(result.message)
+    return
+  }
+  pass(`✅ Code-mode manifest valid: ${result.count}/${result.total} scripts verified`)
+}
+
+/** Resolve the venv created by init for either a project or global install. */
+export function resolveRuntimePython(args) {
+  const target = resolve(args.target)
+  const isProject = existsSync(join(target, '.opencode'))
+  const runtimeRoot = isProject ? target : resolveOpenCodeConfigDir(args.env ?? process.env)
+  return join(runtimeRoot, '.venv', 'bin', 'python3')
+}
+
+/** Return relative script arguments as absolute paths using an MCP entry cwd. */
+export function resolveMcpScriptPaths(entry, configPath = '') {
+  const cwd = resolveMcpCwd(entry, configPath)
+  if (!Array.isArray(entry?.command)) return []
+  return entry.command
+    .slice(1)
+    .filter(
+      (arg) =>
+        typeof arg === 'string' &&
+        !arg.startsWith('-') &&
+        (arg.endsWith('.py') || arg.includes('/')),
+    )
+    .map((arg) => (arg.startsWith('/') ? arg : resolve(cwd, arg)))
+}
+
+/** Resolve an MCP entry's cwd relative to the config file, as OpenCode does. */
+export function resolveMcpCwd(entry, configPath = '') {
+  const configured = entry?.cwd
+  if (typeof configured === 'string' && configured !== '') {
+    return configured.startsWith('/') ? configured : resolve(dirname(configPath), configured)
+  }
+  return dirname(configPath)
+}
+
+// ---------------------------------------------------------------------------
+// Check H2: installed-version drift (beta.5)
+// ---------------------------------------------------------------------------
+
+/**
+ * Prerelease-aware comparison for pantheon versions (X.Y.Z or X.Y.Z-beta.N).
+ * A stable release outranks any beta of the same core version. Returns
+ * <0, 0, >0 (a - b). The shared compareVersions/parseVersion above ignores
+ * the `-beta.N` suffix (it only reads 4 numeric groups), which would make
+ * every beta pair compare equal.
+ */
+function comparePantheonVersions(a, b) {
+  const parse = (v) => {
+    const m = String(v)
+      .trim()
+      .match(/^(\d+)\.(\d+)\.(\d+)(?:-beta\.(\d+))?$/)
+    if (!m) return null
+    return {
+      core: [+m[1], +m[2], +m[3]],
+      beta: m[4] === undefined ? Number.POSITIVE_INFINITY : +m[4],
+    }
+  }
+  const pa = parse(a)
+  const pb = parse(b)
+  if (!pa || !pb) return 0
+  for (let i = 0; i < 3; i++) {
+    if (pa.core[i] !== pb.core[i]) return pa.core[i] - pb.core[i]
+  }
+  return pa.beta - pb.beta
+}
+
+/**
+ * Compare the version recorded in the installation marker
+ * (<config>/.pantheon/install-state.json, written by the postinstall sync)
+ * against this package's version. When the package is newer, the config
+ * merge/venv/MCP wiring may be stale — point the user at `update`.
+ * Advisory only: a missing marker (pre-beta.5 install) is not an error.
+ */
+export function checkInstallVersionDrift(args) {
+  section('H2 Installed Version')
+  const env = args.env ?? process.env
+  let pkgVersion = null
+  try {
+    pkgVersion = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')).version
+  } catch {
+    return 'no-marker'
+  }
+  if (!pkgVersion) return 'no-marker'
+
+  const statePath = join(resolveOpenCodeConfigDir(env), '.pantheon', 'install-state.json')
+  let installed = null
+  if (existsSync(statePath)) {
+    try {
+      installed = JSON.parse(readFileSync(statePath, 'utf8')).pantheon_version ?? null
+    } catch {
+      installed = null
+    }
+  }
+  if (!installed) {
+    info('No installation version marker found (pre-beta.5 install) — skipping drift check')
+    return 'no-marker'
+  }
+  const drift = comparePantheonVersions(pkgVersion, installed)
+  if (drift > 0) {
+    warn(
+      `Package v${pkgVersion} is newer than the last-synced installation (v${installed}) — ` +
+        'run `npx pantheon-opencode update` (or re-run init) to refresh config, venv and MCP entries',
+    )
+    return 'package-newer'
+  }
+  if (drift < 0) {
+    warn(
+      `Installation marker (v${installed}) is newer than this package (v${pkgVersion}) — ` +
+        'the doctor is running from a different install than the last sync',
+    )
+    return 'install-newer'
+  }
+  pass(`Installation in sync with package v${pkgVersion}`)
+  return 'sync'
+}
+
 // ---------------------------------------------------------------------------
 // Check G: AGENTS.md freshness
 // ---------------------------------------------------------------------------
@@ -1285,16 +1457,18 @@ async function main() {
     process.exit(2)
   }
 
-  // Verify it looks like a Pantheon project (has agents/ and platform/)
-  const agentsOk = existsSync(join(args.target, 'agents'))
-  const platformOk = existsSync(join(args.target, 'platform'))
+  // Verify it looks like a Pantheon project or an OpenCode install target.
+  const agentsOk = existsSync(join(args.target, 'src', 'agents'))
+  const opencodeOk = existsSync(join(args.target, '.opencode'))
 
-  if (!agentsOk && !platformOk) {
+  if (!agentsOk && !opencodeOk) {
     // Maybe they pointed at a project root that isn't Pantheon
     // Check if this is a Pantheon install target (has opencode.json with mcp)
     const opencodeJson = readJson(join(args.target, 'opencode.json'))
     if (!opencodeJson) {
-      warn(`Target does not appear to be a Pantheon project (no agents/ or platform/ directory)`)
+      warn(
+        'Target does not appear to be a Pantheon project (no src/agents/ or .opencode/ directory)',
+      )
     }
   }
 
@@ -1306,6 +1480,9 @@ async function main() {
   checkAgentFiles(args)
   checkMcpConfig(args)
   checkVenvLayer(args)
+  checkCodeModeDir(args)
+  checkCodeModeManifest(args)
+  checkInstallVersionDrift(args)
   await checkMcpRuntimeSmoke(args)
   checkPermissionMismatches(args)
   checkSyncStatus(args)