@krtclcdy/tersio 2.25.5 → 2.25.7

package/dist/cli/dashboard.js

@@ -1,4 +1,4 @@
-// Serves the built Dashboard with local usage APIs. Binds 127.0.0.1 only; --export writes a file instead. No Promise.withResolvers: Node 20.12 lacks it.
+// Dashboard server + usage APIs. Binds 127.0.0.1; --export writes a file. No Promise.withResolvers (Node 20.12).
 import { spawn } from 'node:child_process';
 import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
@@ -11,11 +11,11 @@ import { isCurrencyCode } from './currency.js';
 import { OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_VERSION, } from './common.js';
 import { BACKUP_SCHEDULES, formatCliStatus, storedProfile, writePluginSettings } from './profile.js';
 import { normalizeComboLevel } from '../extensions/shared/session-state.js';
-import { CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS } from './common.js';
+import { CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS, PSTACK_DEFAULTS } from './common.js';
 import { PACKAGE_NAME } from './common.js';
-import { findPackageRoot, resolveRtkBinary } from '../extensions/shared/utils.js';
+import { findPackageRoot, resolveRtkBinary, ruleBodyProblem } from '../extensions/shared/utils.js';
 import { BACKUP_KEEP, backupDir, backupDiskBytes, createDataBackup, dataSources, deleteDataBackup, listDataBackups, restoreDataBackup } from './backups.js';
-import { readBackupSchedule } from '../extensions/shared/usage-store.js';
+import { readBackupSchedule, syncUsageDb } from '../extensions/shared/usage-store.js';
 import { agentDbPath, emptyRequestEntry, isAgentView, isRangeKey, readAgentRequestEntry, readAgentStats, readSessionTrace, statsDbPath } from '../extensions/shared/agent-stats.js';
 const DASHBOARD_DIST = path.join(findPackageRoot(path.dirname(fileURLToPath(import.meta.url))), 'dashboard', 'dist');
 const DASHBOARD_INDEX = path.join(DASHBOARD_DIST, 'index.html');
@@ -51,9 +51,12 @@ async function brandDataUri() {
 }
 /** The range a page opens on, matching the reference dashboard. */
 const DEFAULT_AGENT_RANGE = '24h';
-/** The omp aggregate spawns a sqlite3 process per query group, so a repeat poll reuses it. */
+/** Poll memo TTL: every poll re-reads the aggregate, so a repeat poll reuses the last answer. */
 const AGENT_REFRESH_MS = 5000;
+/** A sync walks every transcript, so it runs at most this often even while a poll outruns it. */
+const AGENT_SYNC_MS = 15_000;
 let agentMemo = null;
+let lastSyncAt = 0;
 function fileStamp(file) {
     try {
         const stat = statSync(file);
@@ -63,15 +66,25 @@ function fileStamp(file) {
         return '-';
     }
 }
-/** Reads the omp databases, unless the same window and view were read recently and nothing moved. */
-function agentStats(range, view = 'all') {
-    const stamp = `${fileStamp(statsDbPath())}|${fileStamp(agentDbPath())}`;
+/** Both sources: the usage store carries every host's rows, agent.db only omp's quota snapshots. */
+function storeStamp() {
+    return `${fileStamp(statsDbPath())}|${fileStamp(agentDbPath())}`;
+}
+/** Syncs before reading past the throttle; without it a page misses pi and OpenCode rows. */
+function agentStats(range, view = 'all', offset = 0) {
     const held = agentMemo;
-    if (held && held.range === range && held.view === view && held.stamp === stamp && Date.now() - held.at < AGENT_REFRESH_MS) {
+    if (held && held.range === range && held.view === view && held.offset === offset && held.stamp === storeStamp() && Date.now() - held.at < AGENT_REFRESH_MS) {
         return held.value;
     }
-    const value = readAgentStats(range, view);
-    agentMemo = { range, view, stamp, at: Date.now(), value };
+    if (Date.now() - lastSyncAt >= AGENT_SYNC_MS) {
+        lastSyncAt = Date.now();
+        try {
+            syncUsageDb();
+        }
+        catch { /* a store that will not write still reads the rows it already holds */ }
+    }
+    const value = readAgentStats(range, view, Date.now(), offset);
+    agentMemo = { range, view, offset, stamp: storeStamp(), at: Date.now(), value };
     return value;
 }
 /** `?range=` on any of the omp routes; an unknown value falls back to the default. */
@@ -86,8 +99,14 @@ function viewFrom(url) {
     const raw = queryParam(url, 'view');
     return isAgentView(raw) ? raw : 'all';
 }
-function agentJson(range, view) {
-    return JSON.stringify({ range, view, agent: agentStats(range, view) });
+/** `?offset=` in whole rows, floored; a later page starts further back instead of clamping at the cap. */
+function offsetFrom(url) {
+    const raw = queryParam(url, 'offset');
+    const value = raw === null ? 0 : Number(raw);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function agentJson(range, view, offset) {
+    return JSON.stringify({ range, view, offset, agent: agentStats(range, view, offset) });
 }
 // Runs outside any agent session, so it reports the persisted defaults.
 async function statusJson() {
@@ -98,6 +117,7 @@ async function statusJson() {
         caveman: profile.cavemanDefault,
         rtk: profile.rtkDefault ? 'on' : 'off',
         ponytail: profile.ponytailDefault,
+        pstack: profile.pstackDefault,
     });
 }
 // Local-only health: find each agent on PATH, run `--version`, report both.
@@ -282,18 +302,29 @@ function computeDoctorRows() {
     }
     catch { /* missing config is reported by extension rows */ }
     const duplicateExtensions = [...new Set(explicitEntries.filter((entry, index) => explicitEntries.indexOf(entry) !== index))];
-    addon('Unique config registrations', true, 'ok', 'Extensions');
-    // A listed extension whose file is gone makes the host warn on every load, so surface it rather than leaving the user with only a startup message.
+    addon('Unique config registrations', duplicateExtensions.length === 0, duplicateExtensions.length ? duplicateExtensions.join(', ') : 'ok', 'Extensions');
+    // A listed extension whose file is gone makes the host warn on every load, so surface it here.
     const dangling = explicitEntries
         .filter((entry) => entry.includes(`extensions${path.sep}`) || entry.includes('extensions/'))
         .filter((entry) => !ok(path.isAbsolute(entry) ? entry : path.resolve(OMP_AGENT_DIR, entry)));
     addon('Extension files present', dangling.length === 0, dangling.length ? dangling.join(', ') : 'ok', 'Extensions');
-    ext('Caveman extension', path.join(tersioPluginDir, 'extensions', 'caveman-session', 'index.ts'));
-    ext('RTK extension', path.join(tersioPluginDir, 'extensions', 'rtk-session', 'index.ts'));
-    const rule = path.join(tersioPluginDir, 'extensions', 'caveman-session', 'rule.md');
+    ext('Caveman extension', path.join(tersioPluginDir, 'extensions', 'caveman', 'index.ts'));
+    ext('pstack extension', path.join(tersioPluginDir, 'extensions', 'pstack', 'index.ts'));
+    ext('RTK extension', path.join(tersioPluginDir, 'extensions', 'rtk', 'session.ts'));
+    const rule = path.join(tersioPluginDir, 'extensions', 'caveman', 'rule.md');
     const ruleAge = ageStr(rule);
     const ruleAt = absTime(rule);
     addon('Caveman rule', ruleAge !== null, ruleAge && ruleAt ? `(updated ${ruleAge} · ${ruleAt})` : rule);
+    // The pstack body is a Tersio fork with no remote, so this row proves it is usable, not current.
+    const pstackRule = path.join(tersioPluginDir, 'extensions', 'pstack', 'rule.md');
+    let pstackProblem = 'missing — run: tersio install';
+    try {
+        pstackProblem = ruleBodyProblem(readFileSync(pstackRule, 'utf8'));
+    }
+    catch { /* missing stays */ }
+    const pstackAge = ageStr(pstackRule);
+    const pstackAt = absTime(pstackRule);
+    addon('pstack rule', pstackProblem === null, pstackProblem ?? `(updated ${pstackAge} · ${pstackAt})`);
     const rtkVer = rtkBin ? rtkVersion(rtkBin) : null;
     const rtkAge = rtkBin ? ageStr(rtkBin) : null;
     const rtkAt = rtkBin ? absTime(rtkBin) : null;
@@ -314,7 +345,7 @@ function computeDoctorRows() {
     addon('Prices feed', pricesAge !== null, pricesAge && pricesAt ? `(pulled ${pricesAge} · ${pricesAt})` : prices, 'Usage');
     return rows;
 }
-// Recompute when forced, missing, or past the schedule; a report holding a retired label is stale by definition.
+// A report holding any of these labels is stale by definition.
 const RETIRED_DIAG_LABELS = new Set([
     'OMP CLI',
     'Tersio CLI',
@@ -335,11 +366,10 @@ const RETIRED_DIAG_LABELS = new Set([
 function isRetiredReport(report) {
     return report.rows.some((r) => RETIRED_DIAG_LABELS.has(r.label));
 }
-// Recompute when forced, missing, retired, or past the schedule.
+// Recompute when forced, missing, retired, or past schedule; manual schedules recompute on open, dated ones reuse.
 function getDoctorReport(force) {
     const saved = readDiagReport();
     const ttl = saved ? DIAG_TTL_MS[saved.schedule] : 0;
-    // Manual recomputes on open; a dated schedule reuses the saved report.
     if (!force && saved && !isRetiredReport(saved) && ttl > 0 && Date.now() - saved.checkedAt < ttl)
         return saved;
     const report = { rows: computeDoctorRows(), checkedAt: Date.now(), schedule: saved?.schedule ?? 'manual' };
@@ -373,6 +403,12 @@ async function saveDefaults(body) {
             return { ok: false, error: 'unknown ponytail level' };
         profile.ponytailDefault = v;
     }
+    if (body.pstackDefault !== undefined) {
+        const v = String(body.pstackDefault);
+        if (!PSTACK_DEFAULTS.has(v))
+            return { ok: false, error: 'unknown pstack level' };
+        profile.pstackDefault = v;
+    }
     if (body.backupSchedule !== undefined) {
         const v = String(body.backupSchedule);
         if (!BACKUP_SCHEDULES.has(v))
@@ -392,6 +428,7 @@ async function saveDefaults(body) {
             cavemanDefault: profile.cavemanDefault,
             rtkDefault: profile.rtkDefault,
             ponytailDefault: profile.ponytailDefault,
+            pstackDefault: profile.pstackDefault,
             backupSchedule: profile.backupSchedule,
         },
     };
@@ -423,7 +460,7 @@ function openBrowser(url) {
     const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
     spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
 }
-// Replacers throughout: session data holds `$'` (shell quoting) and literal `</script>`, which String.replace would mangle.
+// Replacers throughout: session data holds `$'` (shell quoting) and `</script>`, which String.replace would mangle.
 function escapeInline(json) {
     return json.replace(/<\/(script)/gi, '<\\/$1');
 }
@@ -444,20 +481,13 @@ function parseOwnJson(json, field) {
 async function exportDashboard(exportFile, currency) {
     requireDashboardBundle();
     const [bundle, icon] = await Promise.all([readSegment(DASHBOARD_INDEX), brandDataUri()]);
-    // The bundle is minified, so the brand fetch reaches the file as `fetch(\`brand.webp\`)` or
-    // `fetch("brand.webp")` depending on the bundler's quote choice. Match either, or the exported
-    // card silently loses its mark. `atob` returns one char per byte, and a Blob encodes a string
-    // as UTF-8, so the bytes go through a Uint8Array first: a webp is binary and every byte at or
-    // above 0x80 would otherwise double and corrupt the image.
+    // Minified: fetch reads `fetch(\`brand.webp\`)` or `fetch("brand.webp")`; a mismatch loses the card's mark.
     const b64 = icon.split(',')[1] ?? '';
-    // atob yields one char per byte; a Blob encodes a string as UTF-8, so the bytes pass through a
-    // Uint8Array or every byte at or above 0x80 doubles and the webp comes out corrupt.
+    // atob yields one byte per char, so a Uint8Array is needed or bytes >= 0x80 double and corrupt the webp.
     const brandBytes = `(() => { const c = atob(${JSON.stringify(b64)}); const v = new Uint8Array(c.length); for (let i = 0; i < c.length; i++) v[i] = c.charCodeAt(i); return v; })()`;
     const inline = bundle
         .replace('window.__TERSIO_SNAP = null;', () => `window.__TERSIO_SNAP = ${escapeInline(JSON.stringify({ currency, agent: agentStats(DEFAULT_AGENT_RANGE), health: parseOwnJson(healthJson(), 'health'), doctor: getDoctorReport(false) }))};`)
-        // A mark reaches the bundle three ways: an HTML attribute in `index.html`, and a JSX prop
-        // esbuild compiled with a backtick. Match any of `"`, `'`, and `` ` ``, or an exported file
-        // keeps a bare reference that file:// cannot resolve.
+        // A mark is an HTML attribute or JSX prop; match every quote or the file keeps an unresolvable reference.
         .replace(/((?:src|href)[=:][ \t]*)([`"'])brand\.webp\2/g, (_all, head, quote) => `${head}${quote}${icon}${quote}`)
         .replace(/fetch\(([`"])brand\.webp\1\)/g, () => `Promise.resolve({ ok: true, blob: async () => new Blob([${brandBytes}], { type: "image/webp" }) })`);
     await fs.writeFile(exportFile, inline, 'utf8');
@@ -492,7 +522,7 @@ async function runDashboard(options) {
             }
             const action = String(body.action ?? '');
             const name = String(body.name ?? '');
-            // A missing sqlite3, or a locked file, is a 500 with a message rather than a silent no-op.
+            // A missing SQLite engine, or a locked file, is a 500 with a message rather than a silent no-op.
             try {
                 if (action === 'create') {
                     const made = await createDataBackup();
@@ -530,6 +560,7 @@ async function runDashboard(options) {
                     cavemanDefault: profile.cavemanDefault,
                     rtkDefault: profile.rtkDefault,
                     ponytailDefault: profile.ponytailDefault,
+                    pstackDefault: profile.pstackDefault,
                     backupSchedule: profile.backupSchedule,
                     currency: options.currency,
                 }));
@@ -576,7 +607,7 @@ async function runDashboard(options) {
         }
         if (req.url === '/api/agent' || req.url?.startsWith('/api/agent?')) {
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(agentJson(rangeFrom(req.url), viewFrom(req.url)));
+            res.end(agentJson(rangeFrom(req.url), viewFrom(req.url), offsetFrom(req.url)));
             return;
         }
         if (req.url?.startsWith('/api/agent/session')) {
@@ -691,4 +722,4 @@ async function runDashboard(options) {
         });
     });
 }
-export { runDashboard, saveDashboardCurrency, readDiagSchedule, setDiagSchedule };
+export { runDashboard, saveDashboardCurrency, readDiagSchedule, setDiagSchedule, offsetFrom };

package/dist/cli/doctor-fix.js

@@ -1,20 +1,119 @@
 import { existsSync, promises as fs } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
-import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, execP, readPluginsPackage, } from './common.js';
+import { BUN_BIN_DIR, HOME, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, bundledPonytailSpec, execP, ponytailOverride, readPluginsPackage, } from './common.js';
 import { execNetwork, sayTagged } from './interactive.js';
 import { wireRtkOmp, wireRtkOpencode, wireRtkPi, ensureRtkInConfig } from './rtk-wiring.js';
-import { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, rtkPlatformSpec, sha256File, } from '../extensions/shared/utils.js';
+import { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, resolveHostBinary, rtkPlatformSpec, sha256File, } from '../extensions/shared/utils.js';
 import { runLatestUpdate } from './update.js';
-import { OPENCODE_ENTRY, TREE_FILES, syncTreeFiles, treeFilesFor } from './manifest.js';
+import { OPENCODE_ENTRY, TREE_FILES, isObsoleteTreeFile, syncPluginManifest, syncTreeFiles, treeFilesFor } from './manifest.js';
 import { detectHosts, hostExtensionsDir } from './hosts.js';
-// 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.
+/** Pids of `opencode serve --service` processes whose service manager no longer tracks them. The orphan holds the managed port, so the next start exits 1. */
+export function serviceOrphanPids() {
+    const bin = resolveHostBinary('opencode', path.join(HOME, '.opencode', 'bin'));
+    if (!bin)
+        return [];
+    let status = '';
+    try {
+        status = spawnSync(bin, ['service', 'status'], { encoding: 'utf8' }).stdout.trim().toLowerCase();
+    }
+    catch {
+        return [];
+    }
+    if (serviceRunning(status))
+        return [];
+    let out = '';
+    try {
+        out = spawnSync('pgrep', ['-f', 'opencode serve --service'], { encoding: 'utf8' }).stdout ?? '';
+    }
+    catch {
+        return [];
+    }
+    // Only digits: the value comes from another process, and `process.kill` throws on anything else.
+    return out.split(/[\s,]+/).filter((line) => /^\d+$/.test(line.trim())).map((line) => line.trim());
+}
+/** Whether OpenCode reports its service running, and whether a serve process is alive. */
+export function serviceState() {
+    const bin = resolveHostBinary('opencode', path.join(HOME, '.opencode', 'bin'));
+    if (!bin)
+        return null;
+    let status = '';
+    try {
+        status = spawnSync(bin, ['service', 'status'], { encoding: 'utf8' }).stdout.trim().toLowerCase();
+    }
+    catch {
+        return null;
+    }
+    if (status === '')
+        return null;
+    let live = false;
+    try {
+        const out = spawnSync('pgrep', ['-f', 'opencode serve --service'], { encoding: 'utf8' }).stdout ?? '';
+        live = out.split(/[\s,]+/).some((line) => /^\d+$/.test(line.trim()));
+    }
+    catch {
+        live = false;
+    }
+    return { status, live };
+}
+/** A running service reports its URL, so the word is only one of the answers. */
+export function serviceRunning(status) {
+    return status === 'running' || status.startsWith('http://') || status.startsWith('https://');
+}
+/** Every obsolete file under `dest`, or an empty list. `treeFilesFor` is what the install writes. */
+async function obsoleteFiles(dest, id) {
+    const keep = new Set(treeFilesFor(id));
+    const out = [];
+    const walk = async (dir, rel) => {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            const child = rel ? `${rel}/${entry.name}` : entry.name;
+            const at = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(at, child);
+                continue;
+            }
+            if (keep.has(child))
+                continue;
+            if (isObsoleteTreeFile(child, id))
+                out.push(child);
+        }
+    };
+    await walk(dest, '');
+    return out;
+}
+/** Obsolete top-level directories, empty or not: a debris name is a whole directory, so a repair must drop the directory, not only the files inside it. */
+async function obsoleteDirs(dest, id) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dest, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (isObsoleteTreeFile(entry.name, id))
+            out.push(entry.name);
+    }
+    return out;
+}
+// A written tree is the install for both hosts, so --fix restores it for whichever hosts have it.
 async function fixExtensionTrees() {
-    // The OpenCode entry is foreign to the pi and omp loaders: it imports @opencode/plugin, which
-    // those hosts do not carry. One shared filter, so a repair cannot drop it into the wrong tree.
+    // The entry imports @opencode/plugin, which pi and omp lack, so one shared filter keeps repairs out of their trees.
     const forHost = (id) => treeFilesFor(id);
-    // A tree from before the entry moved to the extensions root held a nested copy, and a repair
-    // written against the old filter may have left the entry at the root. Remove both strays.
+    // Older trees nested the entry; a repair under the old filter may have left it at the root, so remove both strays.
     const scrubOpencodeEntry = async (dest) => {
         for (const target of [path.join(dest, OPENCODE_ENTRY), path.join(dest, 'opencode')]) {
             if (!existsSync(target))
@@ -29,7 +128,7 @@ async function fixExtensionTrees() {
     };
     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.
+        // Repair a partly-present tree: a half-written one is this run's case, and it reads as "not installed".
         const present = forHost(host.id).filter((file) => existsSync(path.join(dest, file))).length;
         if (present === 0) {
             if (host.id !== 'opencode')
@@ -40,21 +139,38 @@ async function fixExtensionTrees() {
         const missing = await syncTreeFiles(dest, forHost(host.id), { dryRun, verbose });
         for (const from of missing)
             sayTagged(`  [warn] bundled source missing: ${from}`);
+        // Writing the current tree repairs stale and missing at once; dropped debris needs removal, else it survives.
+        const debris = (await obsoleteFiles(dest, host.id)).sort();
+        for (const rel of debris) {
+            const at = path.join(dest, ...rel.split('/'));
+            if (dryRun) {
+                sayTagged(`  [dry-run] would remove debris ${at}`);
+                continue;
+            }
+            await fs.rm(at, { force: true });
+            sayTagged(`  [rm] debris ${at}`);
+        }
+        for (const rel of await obsoleteDirs(dest, host.id)) {
+            const at = path.join(dest, ...rel.split('/'));
+            if (dryRun) {
+                sayTagged(`  [dry-run] would remove debris dir ${at}`);
+                continue;
+            }
+            await fs.rm(at, { recursive: true, force: true });
+            sayTagged(`  [rm] debris dir ${at}`);
+        }
         if (host.id !== 'opencode')
             await scrubOpencodeEntry(dest);
         if (!dryRun)
             sayTagged(`  [ok] ${host.label} extension tree: ${dest}`);
     }
 }
-// The tree alone does nothing on OpenCode without its entrypoint registered in opencode.json.
-// The tersio tree ships the rtk rewrite, so the rtk plugin entry is redundant.
+// On OpenCode the tree is inert without its entry in opencode.json, and the rtk plugin entry is redundant beside it.
 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');
-    // The loader resolves <pluginDir>/server.ts, and the entry is that file. A tree from before the
-    // entry moved to the extensions root held a root shim that re-exported a nested copy, so the
-    // real entry is written in place and the stale nested tree is dropped.
+    // The loader resolves <pluginDir>/server.ts: an entry at the extensions root leaves a shim to a nested copy.
     const nested = path.join(dir, 'opencode');
     const staleNested = (await readTextIfExists(path.join(nested, 'server.ts'))) !== null;
     await syncTreeFiles(dir, TREE_FILES.filter((file) => !file.includes('/')), { dryRun, verbose });
@@ -97,6 +213,28 @@ async function fixExtensions(pluginsDir) {
     const missing = await syncTreeFiles(pluginExtDir, TREE_FILES, { dryRun, verbose }, (file) => ruleFile(file) && existsSync(path.join(pluginExtDir, ...file.split('/'))));
     for (const from of missing)
         sayTagged(`  [warn] bundled source missing: ${from}`);
+    // omp loads this tree, so its debris is what doctor reports: the package tree, compared against every entry.
+    const debris = (await obsoleteFiles(pluginExtDir, 'opencode')).sort();
+    for (const rel of debris) {
+        const at = path.join(pluginExtDir, ...rel.split('/'));
+        if (dryRun) {
+            sayTagged(`  [dry-run] would remove debris ${at}`);
+            continue;
+        }
+        await fs.rm(at, { force: true });
+        sayTagged(`  [rm] debris ${at}`);
+    }
+    for (const rel of await obsoleteDirs(pluginExtDir, 'opencode')) {
+        const at = path.join(pluginExtDir, ...rel.split('/'));
+        if (dryRun) {
+            sayTagged(`  [dry-run] would remove debris dir ${at}`);
+            continue;
+        }
+        await fs.rm(at, { recursive: true, force: true });
+        sayTagged(`  [rm] debris dir ${at}`);
+    }
+    // A synced tree is not enough: omp loads only the entries its manifest names.
+    await syncPluginManifest(path.dirname(pluginExtDir), { dryRun, verbose });
     // Writing is not atomic, so re-read rather than assume the tree is whole.
     if (dryRun)
         return;
@@ -206,13 +344,22 @@ async function fixPonytail(pluginsDir) {
     await fs.mkdir(pluginsDir, { recursive: true });
     const pkgPath = path.join(pluginsDir, 'package.json');
     const pkg = await readPluginsPackage(pkgPath);
-    // Drop the legacy separate entry: ponytail is a tersio dependency now.
-    if ('@dietrichgebert/ponytail' in pkg.dependencies) {
-        delete pkg.dependencies['@dietrichgebert/ponytail'];
-        console.log('  [migrate] dropped separate @dietrichgebert/ponytail dependency (now bundled with tersio)');
-    }
     if (!(PACKAGE_NAME in pkg.dependencies))
         pkg.dependencies[PACKAGE_NAME] = `^${PACKAGE_VERSION}`;
+    // npm resolves the *published* tersio, whose range can lag this tree; the override is what reaches the loaded copy.
+    const localSpec = await bundledPonytailSpec();
+    if (localSpec !== null) {
+        if (pkg.dependencies['@dietrichgebert/ponytail'] !== localSpec)
+            pkg.dependencies['@dietrichgebert/ponytail'] = localSpec;
+        if (ponytailOverride(pkg) !== localSpec) {
+            pkg.overrides = { ...(typeof pkg.overrides === 'object' && pkg.overrides !== null ? pkg.overrides : {}), '@dietrichgebert/ponytail': localSpec };
+            const note = 'forced with overrides, so the nested copy is dropped';
+            if (dryRun)
+                sayTagged(`  [dry-run] would pin @dietrichgebert/ponytail → ${localSpec} (${note})`);
+            else
+                console.log(`  [pin] @dietrichgebert/ponytail → ${localSpec} (${note})`);
+        }
+    }
     if (dryRun) {
         console.log('  [dry-run] would run: npm install --no-audit --no-fund (in plugins dir)');
         return;
@@ -222,10 +369,46 @@ async function fixPonytail(pluginsDir) {
         throw new Error(`bundled ponytail restore failed: ${e.message}`);
     });
 }
+/** The decisive line of a failed command, so one [warn] line carries the reason. */
+function shortError(e) {
+    return ((e.stderr) || e.message || '').trim().slice(0, 200);
+}
 async function fixCli() {
     console.log('  Doctor --fix: updating CLI + add-ons');
     await runLatestUpdate();
 }
+/** OpenCode's manager can lose its daemonized serve process, so `stop` and `restart` cannot reach it: kill the orphan by pid, then start the service again. */
+async function fixOpencodeService() {
+    const orphans = serviceOrphanPids();
+    if (orphans.length === 0) {
+        sayTagged('  [skip] no orphaned OpenCode serve process; the service answers');
+        return;
+    }
+    for (const pid of orphans) {
+        if (dryRun) {
+            sayTagged(`  [dry-run] would stop the orphaned serve process (pid ${pid})`);
+            continue;
+        }
+        try {
+            process.kill(Number(pid), 'SIGTERM');
+            sayTagged(`  [ok] stopped the orphaned serve process (pid ${pid})`);
+        }
+        catch (e) {
+            sayTagged(`  [warn] pid ${pid} already gone: ${shortError(e)}`);
+        }
+    }
+    if (dryRun)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const bin = resolveHostBinary('opencode', path.join(HOME, '.opencode', 'bin'));
+    if (!bin) {
+        sayTagged('  [warn] opencode not found on PATH; start it with `opencode service start`');
+        return;
+    }
+    await execNetwork('Starting the OpenCode service', bin, ['service', 'start'], { timeout: 60000 }).catch((e) => {
+        throw new Error(`service start failed: ${shortError(e)}`);
+    });
+}
 async function runDoctorRepairs(targets) {
     const all = targets.includes('all');
     const want = (t) => all || targets.includes(t);
@@ -253,6 +436,8 @@ async function runDoctorRepairs(targets) {
         await attempt('ponytail', () => fixPonytail(OMP_PLUGINS_DIR));
     if (want('cli'))
         await attempt('cli', fixCli);
+    if (want('service'))
+        await attempt('opencode service', fixOpencodeService);
     return failed;
 }
 export { runDoctorRepairs };