@krtclcdy/tersio 2.24.0 → 2.25.0

package/cli/doctor-fix.js

@@ -3,48 +3,98 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, execP, readPluginsPackage, writeIfChanged, } from './common.js';
-import { execNetwork } from './interactive.js';
-import { wireRtkOmp, ensureRtkInConfig } from './rtk-wiring.js';
+import { execNetwork, sayTagged } from './interactive.js';
+import { wireRtkOmp, wireRtkOpencode, wireRtkPi, ensureRtkInConfig } from './rtk-wiring.js';
 import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, rtkPlatformSpec, sha256File, } from '../extensions/lib/utils.js';
 import { runLatestUpdate } from './update.js';
-import { TREE_FILES, sourcePath } from './manifest.js';
+import { OPENCODE_SERVER_SHIM, TREE_FILES, sourcePath } from './manifest.js';
 import { detectHosts, hostExtensionsDir } from './hosts.js';
 const EXT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
-// A written tree is the install for both hosts now, so --fix restores it for
-// whichever hosts have it, alongside the OMP package when that is present.
+// A written tree is the install for both hosts now, so --fix restores it for whichever hosts have it, alongside the OMP package when that is present.
 async function fixExtensionTrees() {
+    // The opencode entrypoint is foreign to pi/omp loaders: never copy it there, and remove strays.
+    const forHost = (id) => TREE_FILES.filter((file) => id === 'opencode' || !file.startsWith('opencode/'));
+    const scrubOpencodeDir = async (dest) => {
+        const dir = path.join(dest, 'opencode');
+        if (!existsSync(dir))
+            return;
+        if (dryRun) {
+            sayTagged(`  [dry-run] would remove foreign ${dir}`);
+            return;
+        }
+        await fs.rm(dir, { recursive: true, force: true });
+        sayTagged(`  [rm] foreign ${dir}`);
+    };
     for (const host of detectHosts()) {
         const dest = hostExtensionsDir(host.id);
-        // Repair a host whose tree is partly there: a half-written tree is exactly
-        // the case this runs for, and it reads as "not installed" to the detector.
-        const present = TREE_FILES.filter((file) => existsSync(path.join(dest, file))).length;
-        if (present === 0)
+        // Repair a host whose tree is partly there: a half-written tree is exactly the case this runs for, and it reads as "not installed" to the detector.
+        const present = forHost(host.id).filter((file) => existsSync(path.join(dest, file))).length;
+        if (present === 0) {
+            if (host.id !== 'opencode')
+                await scrubOpencodeDir(dest);
             continue;
+        }
         await fs.mkdir(dest, { recursive: true });
-        for (const file of TREE_FILES) {
+        for (const file of forHost(host.id)) {
             const from = path.join(EXT_DIR, ...file.split('/'));
             const text = await readTextIfExists(from);
             if (text === null)
-                console.log(`  [warn] bundled source missing: ${from}`);
+                sayTagged(`  [warn] bundled source missing: ${from}`);
             else
                 await writeIfChanged(path.join(dest, file), text, { dryRun, verbose });
         }
+        if (host.id !== 'opencode')
+            await scrubOpencodeDir(dest);
         if (!dryRun)
-            console.log(`  [ok] ${host.label} extension tree: ${dest}`);
+            sayTagged(`  [ok] ${host.label} extension tree: ${dest}`);
+    }
+}
+// The tree alone does nothing on OpenCode without its entrypoint registered in opencode.json.
+async function fixOpencodeEntry() {
+    const { HOME } = await import('./common.js');
+    const dir = path.join(HOME, '.config', 'opencode', 'plugins', 'tersio');
+    const configPath = path.join(HOME, '.config', 'opencode', 'opencode.json');
+    const nested = path.join(dir, 'opencode', 'server.ts');
+    const nestedText = await readTextIfExists(nested);
+    if (!nestedText)
+        return;
+    // The loader resolves <pluginDir>/server.ts, so mirror the entry at the tree root.
+    await writeIfChanged(path.join(dir, 'server.ts'), OPENCODE_SERVER_SHIM, { dryRun, verbose });
+    const raw = await readTextIfExists(configPath);
+    let config = {};
+    try {
+        config = raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return;
     }
+    const plugins = Array.isArray(config.plugins) ? [...config.plugins] : [];
+    const withoutTersio = plugins.filter((p) => typeof p !== 'string' || !p.includes('/opencode/plugins/tersio'));
+    if (withoutTersio.includes(dir))
+        return;
+    withoutTersio.push(dir);
+    config.plugins = withoutTersio;
+    if (dryRun) {
+        sayTagged(`  [dry-run] would register tersio in ${configPath}`);
+        return;
+    }
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    sayTagged(`  [ok] OpenCode plugin entry: ${configPath}`);
 }
 async function fixExtensions(pluginsDir) {
     await fixExtensionTrees();
+    await fixOpencodeEntry();
     console.log('  Doctor --fix: restoring plugin extension files');
-    const tersioPluginDir = path.join(pluginsDir, 'node_modules', '@krtclcdy', 'tersio');
-    const pluginExtDir = path.join(tersioPluginDir, 'extensions');
+    const pluginExtDir = path.join(pluginsDir, 'node_modules', '@krtclcdy', 'tersio', 'extensions');
     await fs.mkdir(pluginExtDir, { recursive: true });
-    for (const [from, to] of TREE_FILES.map((file) => [sourcePath(file), file])) {
-        const text = await readTextIfExists(from);
+    // rule.md is skipped: its live content is the upstream fetch, not the bundle.
+    for (const file of TREE_FILES.filter((f) => f !== 'caveman-session/rule.md')) {
+        const text = await readTextIfExists(sourcePath(file));
         if (text === null)
-            console.log(`  [warn] bundled source missing: ${from}`);
+            sayTagged(`  [warn] bundled source missing: ${sourcePath(file)}`);
         else
-            await writeIfChanged(path.join(pluginExtDir, to), text, { dryRun, verbose });
+            await writeIfChanged(path.join(pluginExtDir, ...file.split('/')), text, { dryRun, verbose });
     }
     const ruleDest = path.join(pluginExtDir, 'caveman-session', 'rule.md');
     if ((await readTextIfExists(ruleDest)) === null) {
@@ -63,13 +113,21 @@ async function fixExtensions(pluginsDir) {
                 console.log('  [warn] Caveman rule unreachable and no bundled rule exists');
         }
     }
+    // Writing is not atomic, so re-read rather than assume the tree is whole.
+    if (dryRun)
+        return;
+    const missing = TREE_FILES.filter((file) => !existsSync(path.join(pluginExtDir, ...file.split('/'))));
+    if (missing.length > 0)
+        sayTagged(`  [fail] tree incomplete: ${missing.join(', ')}`);
+    else
+        sayTagged(`  [ok] extension tree: ${TREE_FILES.length} files`);
 }
 async function fixRegistrations(agentDir, pluginsDir) {
     console.log('  Doctor --fix: repairing config.yml registrations');
     const configPath = path.join(agentDir, 'config.yml');
     if ((await readTextIfExists(configPath)) === null) {
         if (dryRun)
-            console.log(`  [dry-run] would create ${configPath}`);
+            sayTagged(`  [dry-run] would create ${configPath}`);
         else {
             await fs.mkdir(agentDir, { recursive: true });
             await fs.writeFile(configPath, 'extensions:\n', 'utf8');
@@ -88,7 +146,7 @@ async function fixRegistrations(agentDir, pluginsDir) {
     if (!(PACKAGE_NAME in pkg.dependencies)) {
         pkg.dependencies[PACKAGE_NAME] = `^${PACKAGE_VERSION}`;
         if (dryRun)
-            console.log(`  [dry-run] would register ${PACKAGE_NAME} in ${pkgPath}`);
+            sayTagged(`  [dry-run] would register ${PACKAGE_NAME} in ${pkgPath}`);
         else {
             await fs.mkdir(pluginsDir, { recursive: true });
             await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
@@ -99,7 +157,7 @@ async function fixRtk(binDir) {
     console.log('  Doctor --fix: repairing RTK binary + wiring');
     const binDest = path.join(binDir, RTK_BINARY_NAME);
     if (dryRun) {
-        console.log(`  [dry-run] would download a checksum-verified rtk to ${binDest} and wire it into OMP`);
+        sayTagged(`  [dry-run] would download a checksum-verified rtk to ${binDest} and wire it into OMP`);
         return;
     }
     const spec = rtkPlatformSpec();
@@ -117,12 +175,16 @@ async function fixRtk(binDir) {
             httpsGet(checksAsset.browser_download_url).catch(() => null),
             httpsDownload(asset.browser_download_url, archivePath),
         ]);
-        if (checks) {
-            const expected = parseChecksum(checks, asset.name);
-            if (expected && await sha256File(archivePath) !== expected)
-                throw new Error(`checksum mismatch for ${asset.name}`);
-            debug('RTK checksum verified');
-        }
+        // Same rule as the installer: an unverifiable binary is not installed.
+        const unverified = (why) => new Error(`${why} for ${asset.name}. Re-run with --allow-unverified to accept it`);
+        if (!checks)
+            throw unverified('checksums.txt could not be downloaded');
+        const expected = parseChecksum(checks, asset.name);
+        if (!expected)
+            throw unverified('checksums.txt has no entry');
+        if (await sha256File(archivePath) !== expected)
+            throw new Error(`checksum mismatch for ${asset.name}`);
+        debug('RTK checksum verified');
         const extractDir = path.join(tmpDir, 'extracted');
         await fs.mkdir(extractDir, { recursive: true });
         if (asset.name.endsWith('.zip'))
@@ -144,6 +206,14 @@ async function fixRtk(binDir) {
     }
     if (!(await wireRtkOmp(binDest, { dryRun, verbose })))
         throw new Error('rtk wiring failed');
+    // Fail-open: a missing host wire must not fail the repair.
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    if (existsSync(path.join(home, '.config', 'opencode', 'plugins', 'tersio'))) {
+        await wireRtkOpencode(binDest, { dryRun, verbose });
+    }
+    if (existsSync(path.join(home, '.pi', 'agent', 'extensions'))) {
+        await wireRtkPi(binDest, { dryRun, verbose });
+    }
 }
 async function fixPonytail(pluginsDir) {
     console.log('  Doctor --fix: restoring bundled Ponytail');
@@ -180,11 +250,11 @@ async function runDoctorRepairs(targets) {
         try {
             await work();
             if (!dryRun)
-                console.log(`  [ok] ${label}`);
+                sayTagged(`  [ok] ${label}`);
         }
         catch (e) {
             failed.push(label);
-            console.log(`  [fail] ${label}: ${(e.message || '').slice(0, 200)}`);
+            sayTagged(`  [fail] ${label}: ${(e.message || '').slice(0, 200)}`);
         }
     };
     if (want('extensions'))

package/cli/doctor.js

@@ -1,34 +1,31 @@
 // cli/doctor.ts — installation health checks.
 import { existsSync, promises as fs } from 'node:fs';
 import path from 'node:path';
-import { OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, args, dryRun, fix, yes, execP, parseJsonObject, relTime, } from './common.js';
-import { detectHosts, missingTreeFiles, ompPackageDir } from './hosts.js';
+import { OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, args, dryRun, fix, yes, execP, parseJsonObject, relTime, } from './common.js';
+import { detectHosts, hostExtensionsDir, ompPackageDir } from './hosts.js';
 import { askInteractiveChoice, askInteractiveConfirm, runInteractivePhase } from './interactive.js';
 import { usageDbPath } from '../extensions/shared/usage-store.js';
 import { pricesCachePath } from '../extensions/shared/pricing.js';
 import { readTextIfExists, resolveRtkBinary } from '../extensions/lib/utils.js';
+import { TREE_FILES } from './manifest.js';
 async function runDoctor(recheck = false) {
     console.log('\n=== Tersio Doctor ===');
-    // OMP loads the plugin from its plugins dir; pi loads the same package as a
-    // pi package, which its own settings.json declares and its npm dir holds.
+    // OMP loads the plugin from its plugins dir; pi loads the same package as a pi package, which its own settings.json declares and its npm dir holds.
     const pluginsDir = OMP_PLUGINS_DIR;
     const rtkBin = resolveRtkBinary();
     // Ponytail
     const ponytailPkg = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
-    const ponytailExt = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js');
     const tersioPluginDir = path.join(pluginsDir, 'node_modules', '@krtclcdy', 'tersio');
     const cavemanIndex = path.join(tersioPluginDir, 'extensions', 'caveman-session', 'index.ts');
     const cavemanRule = path.join(tersioPluginDir, 'extensions', 'caveman-session', 'rule.md');
     const rtkIndex = path.join(tersioPluginDir, 'extensions', 'rtk-session', 'index.ts');
     const updaterIndex = path.join(tersioPluginDir, 'extensions', 'ai-addons-updater', 'index.ts');
-    // Independent probes start concurrently; sections report in fixed order as
-    // their data settles. Every probe resolves instead of rejecting.
+    // Independent probes start concurrently; sections report in fixed order as their data settles. Every probe resolves instead of rejecting.
     const hosts = detectHosts();
     const probes = {
         ompPkgText: readTextIfExists(path.join(ompPackageDir(), 'package.json')),
         configText: readTextIfExists(path.join(OMP_AGENT_DIR, 'config.yml')),
         ponytailPkgText: readTextIfExists(ponytailPkg),
-        ponytailExtText: readTextIfExists(ponytailExt),
         rtkBinText: rtkBin ? readTextIfExists(rtkBin) : Promise.resolve(null),
         cavemanIndexText: readTextIfExists(cavemanIndex),
         cavemanRuleText: readTextIfExists(cavemanRule),
@@ -43,7 +40,7 @@ async function runDoctor(recheck = false) {
         const err = e;
         return err.stdout?.trim() || err.stderr?.trim() || null;
     }) : Promise.resolve(null);
-    const [[ompPkgText, configText], [cavemanIndexText, rtkIndexText, updaterIndexText, ponytailPkgText, ponytailExtText], [cavemanRuleText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime, pricesMtime]] = await runInteractivePhase('Checking installation', () => Promise.all([
+    const [[ompPkgText, configText], [cavemanIndexText, rtkIndexText, updaterIndexText, ponytailPkgText], [cavemanRuleText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime, pricesMtime]] = await runInteractivePhase('Checking installation', () => Promise.all([
         Promise.all([
             probes.ompPkgText,
             probes.configText,
@@ -53,7 +50,6 @@ async function runDoctor(recheck = false) {
             probes.rtkIndexText,
             probes.updaterIndexText,
             probes.ponytailPkgText,
-            probes.ponytailExtText,
         ]),
         Promise.all([
             probes.cavemanRuleText,
@@ -65,8 +61,7 @@ async function runDoctor(recheck = false) {
             probes.pricesMtime,
         ]),
     ]));
-    // Categorized output with a tally; success rows stay quiet (no path echoes)
-    // while failures print the expected path or fix so they stay actionable.
+    // Categorized output with a tally; success rows stay quiet (no path echoes) while failures print the expected path or fix so they stay actionable.
     const tally = { ok: 0, missing: 0, warn: 0 };
     function absDate(ms) {
         const d = new Date(ms);
@@ -88,48 +83,45 @@ async function runDoctor(recheck = false) {
         tally.warn++;
         console.log(`  ⚠️ ${label}: warn ${detail}`);
     }
-    // A host you do not use is not a fault, so it stays out of the tally and only
-    // carries the one line that installs it.
+    // A host you do not use is not a fault, so it stays out of the tally and only carries the one line that installs it.
     function unused(label, detail) {
         console.log(`  —  ${label}: not installed ${detail}`);
     }
     section('Hosts');
     for (const host of hosts) {
+        // pi can hold a working tree while reading as not installed; use the tree as ground truth.
+        const piTree = (host.id === 'pi' && !host.installed && existsSync(hostExtensionsDir('pi')))
+            ? hostExtensionsDir('pi')
+            : null;
+        if (piTree !== null) {
+            check(host.label, true, `extensions ${PACKAGE_NAME} ${PACKAGE_VERSION}`);
+            continue;
+        }
         if (!host.installed) {
-            // A pi declaration without the tree or the package is a broken install,
-            // so it stays a counted row rather than reading as "not installed".
+            // A pi declaration without the tree or the package is a broken install, so it stays a counted row rather than reading as "not installed".
             if (host.declared)
                 check(host.label, false, `declared (${host.declared}) but not installed`);
             else
                 unused(host.label, `· ${host.installCmd}`);
             continue;
         }
-        const where = host.via === 'tree' ? `extensions in ${host.dir}` : `package ${PACKAGE_NAME}`;
-        check(host.label, true, `${where}${host.version ? ` ${host.version}` : ''}`);
+        // One line per host, omp style: kind and version, no path echo.
+        const kind = host.via === 'tree' ? 'extensions' : 'package';
+        check(host.label, true, `${kind} ${PACKAGE_NAME}${host.version ? ` ${host.version}` : ''}`);
     }
     section('Extensions & plugins');
-    const ompEntry = hosts.find((host) => host.id === 'omp');
-    if (ompEntry?.via === 'package') {
+    if (hosts.find((host) => host.id === 'omp')?.via === 'package') {
         const explicitEntries = (configText ?? '').split('\n')
             .map((line) => line.trim().replace(/^-\s*/, '').replace(/^['"]|['"]$/g, ''))
             .filter((line) => line.startsWith('/') || line.startsWith('.'));
         const duplicateExtensions = [...new Set(explicitEntries.filter((entry, index) => explicitEntries.indexOf(entry) !== index))];
         check('Unique config registrations', duplicateExtensions.length === 0, duplicateExtensions.length ? duplicateExtensions.join(', ') : '');
-        const retiredReinforcement = explicitEntries.filter((entry) => entry.endsWith('/shared/mode-reinforcement.ts')).length;
-        if (retiredReinforcement === 0)
-            check('No retired reinforcement', true);
-        else
-            warnLine('Retired reinforcement registration', `${retiredReinforcement} found; run doctor --fix registrations`);
-        check('Caveman extension', existsSync(path.join(tersioPluginDir, 'extensions', 'caveman-session', 'index.ts')), existsSync(path.join(tersioPluginDir, 'extensions', 'caveman-session', 'index.ts')) ? '' : path.join(tersioPluginDir, 'extensions', 'caveman-session', 'index.ts'));
-        check('RTK extension', existsSync(path.join(tersioPluginDir, 'extensions', 'rtk-session', 'index.ts')), existsSync(path.join(tersioPluginDir, 'extensions', 'rtk-session', 'index.ts')) ? '' : path.join(tersioPluginDir, 'extensions', 'rtk-session', 'index.ts'));
-        check('Updater extension', existsSync(path.join(tersioPluginDir, 'extensions', 'ai-addons-updater', 'index.ts')), existsSync(path.join(tersioPluginDir, 'extensions', 'ai-addons-updater', 'index.ts')) ? '' : path.join(tersioPluginDir, 'extensions', 'ai-addons-updater', 'index.ts'));
-        check('Ponytail extension', existsSync(path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js')), existsSync(path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js')) ? '' : path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js'));
-    }
-    for (const host of hosts) {
-        if (!host.installed || host.via !== 'tree')
-            continue;
-        const missing = missingTreeFiles(host.id);
-        check(`${host.label} extension tree`, missing.length === 0, missing.length ? `${missing.length} missing in ${host.dir}` : '');
+        // A half-written tree imports a module that is absent; OMP then drops the extension.
+        const extDir = path.join(tersioPluginDir, 'extensions');
+        const missing = TREE_FILES.filter((file) => !existsSync(path.join(extDir, ...file.split('/'))));
+        check('Extension tree', missing.length === 0, missing.length === 0
+            ? `${TREE_FILES.length} files ok`
+            : `${missing.length} of ${TREE_FILES.length} missing: ${missing.join(', ')}`);
     }
     section('Usage & records');
     console.log(`  Usage DB (tersio-owned · local hosted): ${usageDbPath()}`);
@@ -140,6 +132,11 @@ async function runDoctor(recheck = false) {
     check('Caveman rule', cavemanRuleText !== null, ruleAge);
     const rtkAge = rtkMtime ? `(updated ${relTime(Date.now() - rtkMtime.mtimeMs)} · ${absDate(rtkMtime.mtimeMs)})` : '';
     check('RTK binary', rtkBin !== null, rtkBinText === null ? 'not found in PATH' : [rtkVersion, rtkAge].filter(Boolean).join(' '));
+    // rtk_run needs a host exec API, which doctor cannot assume.
+    if (rtkBin === null)
+        unused('RTK exec', '· install Tersio to place rtk in ~/.bun/bin');
+    else if (!hosts.some((host) => host.installed && (host.id === 'omp' || host.id === 'opencode')))
+        warnLine('RTK exec', 'no installed host exposes an exec API — rtk_run is unavailable; call rtk from bash instead');
     if (rtkBinText !== null && !rtkVersion)
         warnLine('RTK version', 'unavailable — binary may not be executable');
     const ponytailAge = ponytailMtime ? `(updated ${relTime(Date.now() - ponytailMtime.mtimeMs)} · ${absDate(ponytailMtime.mtimeMs)})` : '';

package/cli/hosts.js

@@ -1,15 +1,15 @@
-// cli/hosts.ts — the agent hosts Tersio installs into, and what is on disk.
-// One detector, shared by the doctor rows, the install menu, and the uninstall
-// menu, so the three can never disagree about what is installed.
+// cli/hosts.ts — the agent hosts Tersio installs into, and what is on disk. One detector, shared by the doctor and both menus, so they cannot disagree.
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { HOME, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION } from './common.js';
 import { TREE_FILES } from './manifest.js';
 import { piAgentDir } from '../extensions/lib/utils.js';
 export function hostExtensionsDir(id, agentDir = piAgentDir()) {
-    return id === 'omp'
-        ? path.join(HOME, '.omp', 'agent', 'extensions')
-        : path.join(agentDir, 'extensions');
+    if (id === 'omp')
+        return path.join(HOME, '.omp', 'agent', 'extensions');
+    if (id === 'opencode')
+        return path.join(HOME, '.config', 'opencode', 'plugins', 'tersio');
+    return path.join(agentDir, 'extensions');
 }
 export function missingTreeFiles(id, agentDir = piAgentDir()) {
     const dir = hostExtensionsDir(id, agentDir);
@@ -33,9 +33,7 @@ function packageVersion(dir) {
         return null;
     }
 }
-// The tersio package pi has declared in its own settings.json, or null. pi
-// writes the declaration on install and identifies a source by name, so an npm
-// spec, a git URL, and a local path all count when they name this package.
+// The tersio package pi declared in its own settings.json, or null. pi identifies a source by name, so an npm spec, git URL, or path all count.
 export function piTersioSource(agentDir = piAgentDir()) {
     let settings;
     try {
@@ -63,32 +61,31 @@ export function piTersioSource(agentDir = piAgentDir()) {
 const HOSTS = [
     { id: 'omp', label: 'Oh My Pi', bin: 'omp', installCmd: `omp plugin install ${PACKAGE_NAME}`, removeCmd: `omp plugin remove ${PACKAGE_NAME}` },
     { id: 'pi', label: 'Pi', bin: 'pi', installCmd: `pi install npm:${PACKAGE_NAME}`, removeCmd: `pi remove npm:${PACKAGE_NAME}` },
+    { id: 'opencode', label: 'OpenCode', bin: 'opencode', installCmd: `tersio install --host opencode`, removeCmd: `tersio uninstall --host opencode` },
 ];
 function detect(agentDir = piAgentDir()) {
     return HOSTS.map((host) => {
-        const pkgDir = host.id === 'omp' ? ompPackageDir() : piPackageDir(agentDir);
+        const pkgDir = host.id === 'omp' ? ompPackageDir() : host.id === 'pi' ? piPackageDir(agentDir) : null;
         const tree = hostExtensionsDir(host.id, agentDir);
-        // A tree wins: it is what the installer writes, and it carries no
-        // package.json, so its version is ours.
+        // A tree wins: it is what the installer writes, and it carries no package.json, so its version is ours.
         const via = missingTreeFiles(host.id, agentDir).length === 0
             ? 'tree'
-            : existsSync(pkgDir) ? 'package' : null;
+            : pkgDir && existsSync(pkgDir) ? 'package' : null;
         return {
             ...host,
             installed: via !== null,
             via,
             declared: host.id === 'omp'
-                ? (existsSync(pkgDir) ? `plugin ${PACKAGE_NAME}` : null)
-                : piTersioSource(agentDir),
-            version: via === 'tree' ? PACKAGE_VERSION : via === 'package' ? packageVersion(pkgDir) : null,
+                ? (pkgDir && existsSync(pkgDir) ? `plugin ${PACKAGE_NAME}` : null)
+                : host.id === 'pi'
+                    ? piTersioSource(agentDir)
+                    : existsSync(tree) ? 'plugin tree' : null,
+            version: via === 'tree' ? PACKAGE_VERSION : via === 'package' && pkgDir ? packageVersion(pkgDir) : null,
             dir: via === 'tree' ? tree : via === 'package' ? pkgDir : null,
         };
     });
 }
-/**
- * The menu label, with the current state in brackets: the version when the
- * package is already there, so a rerun shows what it would replace.
- */
+/** Menu label with current state in brackets, so a rerun shows what it replaces. */
 export function hostLabel(host) {
     if (host.installed && host.version)
         return `${host.label} (installed ${host.version})`;
@@ -98,21 +95,21 @@ export function hostLabel(host) {
         return `${host.label} (package declared, not on disk)`;
     return `${host.label} (not installed)`;
 }
+// Hints render inline, so menus name the install and doctor keeps the path.
 export function hostHint(host) {
-    if (host.installed && host.dir)
-        return host.dir;
+    if (host.installed && host.via)
+        return host.via === 'tree' ? 'extension tree' : 'plugin package';
     return host.installCmd;
 }
-// `--host omp|pi` from raw argv; undefined when absent. Throws on an unknown
-// value so the caller can exit(1) with the message.
+// `--host omp|pi` from raw argv; undefined when absent. Throws on an unknown value so the caller can exit(1) with the message.
 export function parseHostArg(argv) {
     const i = argv.indexOf('--host');
     const raw = (i === -1 ? undefined : argv[i + 1]) ?? argv.find((a) => a.startsWith('--host='))?.slice('--host='.length);
     if (raw === undefined)
         return undefined;
     const value = raw.trim().toLowerCase();
-    if (value !== 'omp' && value !== 'pi')
-        throw new Error(`Invalid --host: ${raw}. Valid: omp, pi`);
+    if (value !== 'omp' && value !== 'pi' && value !== 'opencode')
+        throw new Error(`Invalid --host: ${raw}. Valid: omp, pi, opencode`);
     return value;
 }
 export { HOME, detect as detectHosts };