@krtclcdy/tersio 2.23.0 → 2.24.0

package/cli/pi-layer.js

@@ -0,0 +1,37 @@
+// cli/pi-layer.ts — the Pi extension layer as data: the five extension directories plus shared/ and lib/.
+import path from 'node:path';
+import { layerDirs, layerEntries, reportLayer } from './layer.js';
+const INSTALLED_EXTENSIONS = [
+    ['caveman-session', 'caveman session mode'],
+    ['rtk-session', 'rtk session mode'],
+    ['ai-addons-updater', 'add-on updater'],
+    ['combo-toggle', 'combo preset switch'],
+    ['tersio-commands', '/tersio command'],
+];
+// Imported by the extension directories but never loaded by Pi itself, so they stay out of the install list and only...
+const MODULE_DIRECTORIES = [
+    ['shared', 'Pi types, session bridge, usage and pricing store'],
+    ['lib', 'shared installer and updater helpers'],
+];
+export const PI_EXTENSION_DIRS = layerDirs(INSTALLED_EXTENSIONS);
+export const PI_MODULE_DIRS = layerDirs(MODULE_DIRECTORIES);
+export function piLayer(home) {
+    const relocated = process.env.PI_CODING_AGENT_DIR;
+    const base = relocated && relocated.trim() !== '' ? relocated : path.join(home, '.pi', 'agent');
+    const extDir = path.join(base, 'extensions');
+    return {
+        extDir,
+        rtkExtension: path.join(extDir, 'rtk.ts'),
+        installed: layerEntries(extDir, INSTALLED_EXTENSIONS),
+        modules: layerEntries(extDir, MODULE_DIRECTORIES),
+    };
+}
+// Every directory the layer owns. Removal walks this list and nothing else.
+export function piExtensionTargets(layer) {
+    return [...layer.installed, ...layer.modules].map((entry) => entry.path);
+}
+// Reports the layer without needing a platform rtk binary name.
+export function reportPiLayer(home, exists) {
+    const { present, missing } = reportLayer(piLayer(home).extDir, [INSTALLED_EXTENSIONS, MODULE_DIRECTORIES], exists);
+    return { extensions: present, missing, installed: present.length > 0 };
+}

package/cli/pi-wiring.js

@@ -0,0 +1,92 @@
+// Install and remove Tersio's Pi extension tree: Pi loads ~/.pi/agent/extensions/<dir>/index.ts through jiti, no build...
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+import { rewritePortImports } from './layer.js';
+import { piExtensionTargets, piLayer } from './pi-layer.js';
+// `$HOME`-relative form of a path, for output that must stay readable.
+function rel(target, home) {
+    if (!home)
+        return target;
+    const prefix = home.endsWith(path.sep) ? home : `${home}${path.sep}`;
+    return target.startsWith(prefix) ? `~/${target.slice(prefix.length).split(path.sep).join('/')}` : target;
+}
+export function piExtensionDir(home) {
+    return piLayer(home).extDir;
+}
+// Writes only when the content differs, leaving a `.bak` of what it replaced.
+async function writeIfChanged(target, content, options) {
+    const current = await readTextIfExists(target);
+    if (current === content)
+        return false;
+    if (options.dryRun)
+        return true;
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    if (current !== null)
+        await fs.copyFile(target, `${target}.bak`).catch(() => { });
+    await fs.writeFile(target, content, 'utf8');
+    return true;
+}
+async function exists(target) {
+    try {
+        await fs.stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Returns the paths it changed, so a no-op re-run is not counted as work.
+export async function installPiTersio(home, tree, options = {}) {
+    const extDir = piExtensionDir(home);
+    const written = [];
+    for (const [from, to] of tree.sources) {
+        const content = await readTextIfExists(from);
+        if (content === null) {
+            // Named by its path under the extension dir, never by the repo source.
+            if (!options.quiet) {
+                console.log(`  [fail] Pi extension source missing: ${to}`);
+                console.log('  [hint] Reinstall tersio — extensions/pi ships with the CLI');
+            }
+            continue;
+        }
+        if (await writeIfChanged(path.join(extDir, to), rewritePortImports(content), options))
+            written.push(to);
+    }
+    for (const [dir, rule] of tree.rules) {
+        if (rule === null)
+            continue;
+        const target = path.join(dir, 'rule.md');
+        if (await writeIfChanged(path.join(extDir, target), rule, options))
+            written.push(target);
+    }
+    if (written.length > 0 && !options.quiet) {
+        console.log(`  ${options.dryRun ? '[dry-run] would write' : '[write]'} Pi — ${written.length} file(s) under ${rel(extDir, home)}`);
+    }
+    return written;
+}
+// Removes the Pi tree: every directory the layer owns, the `.bak` copies, and the flat module a pre-tree install wrote at...
+export async function removePiTersio(home, options = {}) {
+    let removed = false;
+    for (const target of [...piExtensionTargets(piLayer(home)), path.join(piExtensionDir(home), 'tersio.ts')]) {
+        if (!(await exists(target)))
+            continue;
+        if (!options.quiet) {
+            console.log(`  ${options.dryRun ? '[dry-run] would remove' : '[rm]'} ${rel(target, home)}`);
+        }
+        if (!options.dryRun) {
+            await fs.rm(target, { recursive: true, force: true });
+            await fs.rm(`${target}.bak`, { force: true, recursive: true });
+        }
+        removed = true;
+    }
+    return removed;
+}
+// True when any module of the Pi tree is present.
+export async function piTersioInstalled(home) {
+    for (const entry of piLayer(home).installed) {
+        if (await exists(path.join(entry.path, 'index.ts')))
+            return true;
+    }
+    return false;
+}

package/cli/profile.js

@@ -1,12 +1,14 @@
 // cli/profile.ts — session-start defaults profile (combo/caveman/rtk/ponytail)
 // plus the display-currency default for usage/dashboard reports.
-// Single source for reading/writing the omp plugin settings lock entry.
-// Extracted from cli/install.ts so both install and settings share it.
-import { promises as fs } from 'node:fs';
+// Stored in ~/.tersio/settings.json, which every host reads. Extracted from
+// cli/install.ts so both install and settings share it.
+import { existsSync, promises as fs } from 'node:fs';
 import path from 'node:path';
-import { CAVEMAN_DEFAULTS, COMBO_PRESET_MODES, OMP_PLUGINS_DIR, PACKAGE_NAME, PONYTAIL_DEFAULTS, verbose, } from './common.js';
+import { CAVEMAN_DEFAULTS, COMBO_PRESET_MODES, PACKAGE_NAME, PONYTAIL_DEFAULTS, verbose, } from './common.js';
+import os from 'node:os';
 import { DEFAULT_CURRENCY, isCurrencyCode } from './currency.js';
 import { readTextIfExists } from '../extensions/lib/utils.js';
+import { tersioSettingsFile } from '../extensions/shared/plugin-settings.js';
 function defaultProfile() {
     return {
         comboDefault: 'off',
@@ -16,29 +18,16 @@ function defaultProfile() {
         currency: DEFAULT_CURRENCY,
     };
 }
-// Stored profile from the live lock file: update/reinstall runs without flags
-// or prompts must preserve the user's choice, never reset it to off.
+// Stored profile: ~/.tersio/settings.json. An install that predates that file
+// kept the same values as OMP plugin settings, so seed from there once and
+// never lose a user's choice.
 async function storedProfile() {
     const base = defaultProfile();
-    const raw = await readTextIfExists(path.join(OMP_PLUGINS_DIR, 'omp-plugins.lock.json'));
-    if (!raw)
-        return base;
-    let stored;
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || !('settings' in parsed))
-            return base;
-        const settings = parsed.settings;
-        if (!settings || typeof settings !== 'object' || !(PACKAGE_NAME in settings))
-            return base;
-        const entry = settings[PACKAGE_NAME];
-        if (!entry || typeof entry !== 'object')
-            return base;
-        stored = entry;
-    }
-    catch {
+    const stored = (await readTextIfExists(tersioSettingsFile())) !== null
+        ? parseStored(await readTextIfExists(tersioSettingsFile()))
+        : parseStored(await readTextIfExists(legacyOmpLockPath()));
+    if (!stored)
         return base;
-    }
     if (typeof stored.comboDefault === 'string' && stored.comboDefault in COMBO_PRESET_MODES)
         base.comboDefault = stored.comboDefault;
     if (typeof stored.cavemanDefault === 'string' && CAVEMAN_DEFAULTS.has(stored.cavemanDefault))
@@ -52,25 +41,34 @@ async function storedProfile() {
     }
     return base;
 }
-// Persist the profile as omp plugin settings so `omp plugin config get`
-// reflects the choice and the extensions pick it up on session start.
-async function writePluginSettings(profile, options) {
-    const pluginsDir = OMP_PLUGINS_DIR;
-    const lockPath = path.join(pluginsDir, 'omp-plugins.lock.json');
-    let config = {};
-    const existing = await readTextIfExists(lockPath);
-    if (existing) {
-        try {
-            config = JSON.parse(existing);
-        }
-        catch {
-            config = {};
-        }
+function legacyOmpLockPath() {
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    return [
+        path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
+        path.join(configHome, 'omp', 'plugins', 'omp-plugins.lock.json'),
+    ].find((p) => existsSync(p)) ?? path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json');
+}
+function parseStored(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        const direct = parsed;
+        const nested = direct.settings?.[PACKAGE_NAME];
+        return (nested ?? direct);
     }
-    config.plugins = config.plugins || {};
-    config.settings = config.settings || {};
-    config.settings[PACKAGE_NAME] = {
-        ...(config.settings[PACKAGE_NAME] || {}),
+    catch {
+        return null;
+    }
+}
+// Persist the profile where every host reads it. `omp plugin config get` no
+// longer reports it; `tersio settings` does.
+async function writePluginSettings(profile, options) {
+    const file = tersioSettingsFile();
+    const values = {
+        ...(parseStored(await readTextIfExists(file)) ?? {}),
         comboDefault: profile.comboDefault,
         comboSetupComplete: true,
         cavemanDefault: profile.cavemanDefault,
@@ -80,12 +78,12 @@ async function writePluginSettings(profile, options) {
     };
     if (options.dryRun) {
         if (verbose && !options.quiet)
-            console.log(`  [dry-run] would write plugin settings (${PACKAGE_NAME}) to ${lockPath}`);
+            console.log(`  [dry-run] would write session defaults to ${file}`);
         return;
     }
-    await fs.mkdir(pluginsDir, { recursive: true });
-    await fs.writeFile(lockPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
-    console.log(`  [write] Plugin settings in ${lockPath}`);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, `${JSON.stringify(values, null, 2)}\n`, 'utf8');
+    console.log(`  [write] Session defaults in ${file}`);
 }
 function formatProfile(profile) {
     return `combo=${profile.comboDefault} (caveman=${profile.cavemanDefault} · rtk=${profile.rtkDefault ? 'on' : 'off'} · ponytail=${profile.ponytailDefault}) · currency=${profile.currency}`;

package/cli/reset.js

@@ -3,9 +3,8 @@
 // derived view. Session transcripts (~/.omp/agent/sessions) and the RTK
 // database are host/tool-owned and are never touched; the watermark only
 // changes what tersio shows.
-import { cancel as clackCancel, confirm as clackConfirm } from '@clack/prompts';
 import { dryRun, yes } from './common.js';
-import { ask, closeRL, tty } from './interactive.js';
+import { confirmDestructive } from './interactive.js';
 import { clearUsageLedger, importSessionTokens, ledgerPath, markReset, readUsage, sessionsDir } from '../extensions/shared/usage-ledger.js';
 import { clearUsageDb, usageDbPath } from '../extensions/shared/usage-store.js';
 import { readRtkGain, rtkDbPath } from '../extensions/shared/rtk-gain.js';
@@ -25,30 +24,8 @@ async function runReset() {
         console.log('Nothing to reset — no statistics recorded.');
         return true;
     }
-    if (!yes) {
-        if (tty()) {
-            closeRL();
-            const confirmedChoice = await clackConfirm({ message: 'Clear tersio statistics?', initialValue: false });
-            if (typeof confirmedChoice !== 'boolean') {
-                clackCancel('Aborted.');
-                closeRL();
-                return false;
-            }
-            if (!confirmedChoice) {
-                console.log('Aborted.');
-                closeRL();
-                return false;
-            }
-        }
-        else {
-            const answer = await ask('\nProceed? [y/N]: ');
-            if (!answer.toLowerCase().startsWith('y')) {
-                console.log('Aborted.');
-                closeRL();
-                return false;
-            }
-        }
-    }
+    if (!yes && !(await confirmDestructive('Clear tersio statistics?')))
+        return false;
     const cleared = clearUsageLedger();
     const dbCleared = clearUsageDb();
     const ts = markReset();

package/cli/rtk-wiring.js

@@ -1,12 +1,9 @@
 // cli/rtk-wiring.ts — wire the installed rtk binary into OMP.
 // `rtk init -g --agent omp` writes rtk's tool_call extension to
-// ~/.omp/agent/extensions/rtk.ts, and we register that path in config.yml
-// (OMP only loads listed extensions — rtk init does not register it).
-// Once loaded, OMP rewrites bash commands to rtk before execution, so every
-// rewritten call lands in rtk's history.db and shows metered savings.
-// Fail-open: a failed wire only downgrades to manual `rtk` prefixing.
-// Deliberately free of cli/common.ts imports (argv side effects) so tests
-// can load it directly.
+// ~/.omp/agent/extensions/rtk.ts but does not register it, and OMP loads only
+// listed extensions, so we add the path to config.yml. Every rewritten bash
+// call then lands in rtk's history.db. Fail-open: a failed wire only downgrades
+// to manual `rtk` prefixing. No cli/common.ts import (argv side effects).
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,8 +31,7 @@ function execFileP(cmd, args, timeout) {
         });
     });
 }
-// Idempotent: rtk rewrites its extension file on every init run, so
-// reinstalling tersio refreshes the wiring for free.
+// Idempotent: rtk rewrites its file on every init run.
 export async function wireRtkOmp(rtkBin, options = {}) {
     if (!options.dryRun)
         debugWire(options, 'Wiring rtk → OMP (bash tool_call rewrite)…');
@@ -47,14 +43,13 @@ export async function wireRtkOmp(rtkBin, options = {}) {
     await ensureRtkInConfig(options);
     return true;
 }
-// The rtk.ts path rtk init writes (mirrors OMP_AGENT_DIR in cli/common.ts
-// without importing it — see header note on argv side effects).
+// The rtk.ts path rtk init writes (OMP_AGENT_DIR inlined; see header note).
 function rtkExtensionPath() {
     const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
     return path.join(home, '.omp', 'agent', 'extensions', 'rtk.ts');
 }
-// OMP loads only listed extensions: append rtk.ts after the existing entries
-// (or create the key) so a fresh wire takes effect on next OMP start.
+// Append rtk.ts after the existing entries (or create the key) so the wire
+// takes effect on the next OMP start.
 export async function ensureRtkInConfig(options) {
     const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
     const configPath = path.join(home, '.omp', 'agent', 'config.yml');
@@ -98,8 +93,8 @@ async function runRtkInit(rtkBin, options) {
         return true;
     }
     catch (first) {
-        // A freshly written binary can lose its first exec to macOS Gatekeeper
-        // verification; give it one settle-and-retry before reporting failure.
+        // A fresh binary can lose its first exec to macOS Gatekeeper, so settle and
+        // retry once before reporting failure.
         await new Promise((resolve) => setTimeout(resolve, 2000));
         try {
             await execFileP(rtkBin, ['init', '-g', '--agent', 'omp'], 30000);

package/cli/uninstall.js

@@ -1,12 +1,81 @@
 // cli/uninstall.ts — remove managed extensions, plugins, and binaries.
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { cancel as clackCancel, confirm as clackConfirm } from '@clack/prompts';
-import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, RTK_BINARY_NAME, dryRun, keepPonytail, removePonytail, removeRtk, yes, debug, writeConfigLines, } from './common.js';
-import { ask, closeRL, tty } from './interactive.js';
-import { readTextIfExists } from '../extensions/lib/utils.js';
-// Read-modify-write a JSON file. mutate returns true when it changed
-// something; no change (or unreadable file) means no output at all.
+import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, RTK_BINARY_NAME, args, dryRun, keepPonytail, removePonytail, removeRtk, yes, debug, writeConfigLines, } from './common.js';
+import { askInteractiveChoice, closeRL, confirmDestructive, tty } from './interactive.js';
+import { detectHosts, hostHint, hostLabel, parseHostArg } from './hosts.js';
+import { findHoistedPackage, piAgentDir, readTextIfExists } from '../extensions/lib/utils.js';
+import { fileURLToPath } from 'node:url';
+import { tersioSettingsFile } from '../extensions/shared/plugin-settings.js';
+// The pi tree mirrors the OMP one. Ponytail and rtk stay: a package and a
+// shared binary are not ours to delete.
+const PONYTAIL_PKG = '@dietrichgebert/ponytail';
+const PI_TREE_DIRS = [
+    'caveman-session',
+    'rtk-session',
+    'ai-addons-updater',
+    'combo-toggle',
+    'tersio-commands',
+    'shared',
+    'lib',
+];
+// One `pi remove`, for both packages the installer adds there.
+async function piRemove(spec, shouldDryRun) {
+    if (shouldDryRun) {
+        console.log(`  [dry-run] would run: pi remove ${spec}`);
+        return;
+    }
+    try {
+        const { execFile } = await import('node:child_process');
+        await new Promise((resolve, reject) => {
+            execFile('pi', ['remove', spec], { timeout: 120000 }, (err, _out, errOut) => {
+                if (err)
+                    reject(new Error(String(errOut).trim() || err.message));
+                else
+                    resolve();
+            });
+        });
+        console.log(`  [ok] removed the pi package ${spec}`);
+    }
+    catch (e) {
+        console.log(`  [fail] pi remove: ${e.message}`);
+        console.log(`  [hint] Manual: pi remove ${spec}`);
+    }
+}
+// Only the skill directories the installer copied, never pi's own skills dir.
+async function removeCopiedPonytailSkills(shouldDryRun) {
+    const source = findHoistedPackage(PONYTAIL_PKG, path.dirname(fileURLToPath(import.meta.url)), 'skills');
+    if (!source)
+        return;
+    for (const entry of await fs.readdir(source, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            await removeUninstallTarget(path.join(piAgentDir(), 'skills', entry.name), shouldDryRun);
+    }
+}
+// pi owns its package dir, so removal is `pi remove`; the tree and the defaults
+// file are ours. Ponytail goes too unless --keep-ponytail, matching the OMP
+// route, so neither host keeps a package we installed on its behalf.
+async function removePiLayer(host, shouldDryRun, shouldRemovePonytail) {
+    const targets = PI_TREE_DIRS.map((dir) => path.join(piAgentDir(), 'extensions', dir));
+    if (!host.installed && !host.declared) {
+        console.log(`  [skip] ${host.label} — nothing installed (${host.installCmd})`);
+        return false;
+    }
+    if (host.declared)
+        await piRemove(`npm:${PACKAGE_NAME}`, shouldDryRun);
+    if (shouldRemovePonytail) {
+        await piRemove(`npm:${PONYTAIL_PKG}`, shouldDryRun);
+        await removeCopiedPonytailSkills(shouldDryRun);
+    }
+    await Promise.all(targets.map((t) => removeUninstallTarget(t, shouldDryRun)));
+    await clearSessionDefaults(shouldDryRun);
+    return true;
+}
+// ~/.tersio/settings.json holds nothing but Tersio's values, so it goes whole.
+async function clearSessionDefaults(shouldDryRun) {
+    await removeUninstallTarget(tersioSettingsFile(), shouldDryRun, false);
+}
+// Read-modify-write a JSON file; mutate returning false prints nothing.
 async function updateJsonFile(filePath, mutate, dryRunNote, writeNote, dryRun) {
     const raw = await readTextIfExists(filePath);
     if (!raw)
@@ -56,11 +125,52 @@ async function removeUninstallTarget(target, shouldDryRun, recursive = true) {
 async function runUninstall(options = {}) {
     const shouldDryRun = options.dryRun ?? dryRun;
     const confirmed = (options.yes ?? yes) || shouldDryRun;
-    // Ponytail is bundled with Tersio's presets, so a full uninstall removes
-    // its copy too; --keep-ponytail opts out and reinstall always preserves it.
+    // Ponytail ships with Tersio, so a full uninstall removes it.
     const shouldRemovePonytail = options.removePonytail ?? (removePonytail || !keepPonytail);
     const shouldRemoveRtk = options.removeRtk ?? removeRtk;
     console.log('\n=== Tersio Uninstall ===\n');
+    // A TTY user picks the host; only hosts with tersio on them are offered.
+    const installed = detectHosts().filter((host) => host.installed);
+    let host = options.host ?? 'omp';
+    try {
+        host = parseHostArg(args) ?? host;
+    }
+    catch (e) {
+        console.error(`[fail] ${e.message}`);
+        process.exit(1);
+    }
+    if (!options.host && tty() && !confirmed) {
+        if (installed.length === 0) {
+            console.log('Tersio is not installed for any agent on this machine. Nothing to remove.');
+            closeRL();
+            return false;
+        }
+        if (installed.length > 1) {
+            const choice = await askInteractiveChoice('Uninstall Tersio from which agent?', installed.map((h) => ({
+                value: h.id,
+                label: hostLabel(h),
+                hint: hostHint(h),
+            })), host);
+            if (choice.status !== 'selected') {
+                closeRL();
+                return false;
+            }
+            host = choice.value;
+        }
+        else {
+            host = installed[0].id;
+        }
+    }
+    const selected = detectHosts().find((h) => h.id === host);
+    if (host === 'pi') {
+        const removed = await removePiLayer(selected, shouldDryRun, shouldRemovePonytail);
+        if (removed)
+            console.log('\nDone. Restart pi for changes to take effect.');
+        closeRL();
+        return removed;
+    }
+    if (!selected.installed)
+        console.log(`  [note] ${selected.label} has no tersio install; removing what is left behind.`);
     const extDir = path.join(OMP_AGENT_DIR, 'extensions');
     const configPath = path.join(OMP_AGENT_DIR, 'config.yml');
     const rtkBin = path.join(BUN_BIN_DIR, RTK_BINARY_NAME);
@@ -73,10 +183,9 @@ async function runUninstall(options = {}) {
         'combo-toggle',
         'tersio-commands',
         'shared',
-        // Only consumed by ai-addons-updater (removed above); otherwise orphaned.
+        // Only the updater reads it, and it runs before this.
         'lib',
-        // Legacy always-on combo helper; imports shared/session-state.js, so it
-        // breaks with a module-not-found warning once the shared dir is removed.
+        // Legacy: imports session-state.js, so it warns once that module is gone.
         'aaa-combo-boot',
     ].map((dir) => path.join(extDir, dir));
     console.log('Will remove:');
@@ -90,33 +199,11 @@ async function runUninstall(options = {}) {
         console.log(`  ${rtkBin}`);
         console.log(`  ${path.join(extDir, 'rtk.ts')} (rtk OMP wiring)`);
     }
-    if (!confirmed) {
-        if (tty()) {
-            closeRL();
-            const confirmedChoice = await clackConfirm({ message: 'Remove the listed Tersio files?', initialValue: false });
-            if (typeof confirmedChoice !== 'boolean') {
-                clackCancel('Aborted.');
-                closeRL();
-                return false;
-            }
-            if (!confirmedChoice) {
-                console.log('Aborted.');
-                closeRL();
-                return false;
-            }
-        }
-        else {
-            const answer = await ask('\nProceed? [y/N]: ');
-            if (!answer.toLowerCase().startsWith('y')) {
-                console.log('Aborted.');
-                closeRL();
-                return false;
-            }
-        }
-    }
+    if (!confirmed && !(await confirmDestructive('Remove the listed Tersio files?')))
+        return false;
     // Remove extension directories (independent paths, so concurrently).
     await Promise.all(targets.map((t) => removeUninstallTarget(t, shouldDryRun)));
-    // Remove Combo and mode-reinforcement registrations; Ponytail only when requested.
+    // Remove Combo, mode-reinforcement, and rtk registrations; Ponytail on request.
     const configRaw = await readTextIfExists(configPath);
     if (configRaw) {
         let lines = configRaw.split('\n');
@@ -126,6 +213,11 @@ async function runUninstall(options = {}) {
                 return false;
             if (shouldRemovePonytail && l.includes('ponytail') && l.includes('pi-extension'))
                 return false;
+            // Our rtk wiring, absolute or relative. Leaving it listed would keep
+            // OMP loading a hook for a package that is no longer installed.
+            const entry = l.trim().replace(/^-\s*/, '').replace(/^['"]|['"]$/g, '');
+            if (entry.endsWith(`extensions${path.sep}rtk.ts`) || entry.endsWith('extensions/rtk.ts'))
+                return false;
             return true;
         });
         if (lines.length !== before) {
@@ -135,8 +227,7 @@ async function runUninstall(options = {}) {
                 await writeConfigLines(configPath, lines, `  [write] Updated config.yml (removed ${before - lines.length} entries)`);
         }
     }
-    // Remove the bundled Ponytail copy (dep entry exists only on
-    // pre-bundle installs); the config.yml entry was filtered above.
+    // Remove the bundled Ponytail copy; its config.yml entry is already filtered.
     if (shouldRemovePonytail) {
         const pluginsPkgPath = path.join(pluginsDir, 'package.json');
         await updateJsonFile(pluginsPkgPath, (data) => dropKey(data.dependencies, '@dietrichgebert/ponytail'), `would remove @dietrichgebert/ponytail from ${pluginsPkgPath}`, 'Removed @dietrichgebert/ponytail from plugins/package.json', shouldDryRun);
@@ -163,13 +254,13 @@ async function runUninstall(options = {}) {
     if ((await readTextIfExists(path.join(selfPluginDir, 'package.json'))) !== null) {
         await removeUninstallTarget(selfPluginDir, shouldDryRun);
     }
-    // Remove RTK binary if requested. rtk.ts is rtk-owned but installed by our
-    // wiring step; with the binary gone it would pass through harmlessly, so
-    // only drop it on a full rtk removal.
-    if (shouldRemoveRtk) {
+    // Our rtk wiring goes with the rest: leaving the file would keep OMP
+    // rewriting bash calls to a package this uninstall just removed. The binary
+    // stays unless --remove-rtk, since it is a shared tool on PATH.
+    await removeUninstallTarget(path.join(extDir, 'rtk.ts'), shouldDryRun);
+    if (shouldRemoveRtk)
         await removeUninstallTarget(rtkBin, shouldDryRun, false);
-        await removeUninstallTarget(path.join(extDir, 'rtk.ts'), shouldDryRun);
-    }
+    await clearSessionDefaults(shouldDryRun);
     console.log('\nDone. Restart OMP for changes to take effect.');
     return true;
 }