@krtclcdy/tersio 2.4.0 → 2.5.0

package/cli/uninstall.js

@@ -0,0 +1,171 @@
+// 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.
+async function updateJsonFile(filePath, mutate, dryRunNote, writeNote, dryRun) {
+    const raw = await readTextIfExists(filePath);
+    if (!raw)
+        return;
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        debug(`Could not parse ${filePath}`);
+        return;
+    }
+    if (!mutate(data))
+        return;
+    if (dryRun) {
+        console.log(`  [dry-run] ${dryRunNote}`);
+        return;
+    }
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    console.log(`  [write] ${writeNote}`);
+}
+function dropKey(section, key) {
+    if (!section || typeof section !== 'object')
+        return false;
+    const record = section;
+    if (!(key in record))
+        return false;
+    delete record[key];
+    return true;
+}
+async function removeUninstallTarget(target, shouldDryRun, recursive = true) {
+    try {
+        if (shouldDryRun) {
+            console.log(`  [dry-run] would remove ${target}`);
+            return;
+        }
+        if (recursive)
+            await fs.rm(target, { recursive: true, force: true });
+        else
+            await fs.unlink(target);
+        console.log(`  [rm] ${target}`);
+    }
+    catch {
+        debug(`Could not remove ${target}`);
+    }
+}
+async function runUninstall(options = {}) {
+    const shouldDryRun = options.dryRun ?? dryRun;
+    const confirmed = (options.yes ?? yes) || shouldDryRun;
+    // Ponytail ships with Tersio's presets, so a full uninstall removes it too;
+    // --keep-ponytail opts out and reinstall always preserves it.
+    const shouldRemovePonytail = options.removePonytail ?? (removePonytail || !keepPonytail);
+    const shouldRemoveRtk = options.removeRtk ?? removeRtk;
+    console.log('\n=== Tersio Uninstall ===\n');
+    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);
+    const pluginsDir = OMP_PLUGINS_DIR;
+    const ponytailPkgDir = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail');
+    const targets = [
+        'caveman-session',
+        'rtk-session',
+        'ai-addons-updater',
+        'combo-toggle',
+        'shared',
+        // Only consumed by ai-addons-updater (removed above); otherwise orphaned.
+        '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.
+        'aaa-combo-boot',
+    ].map((dir) => path.join(extDir, dir));
+    console.log('Will remove:');
+    for (const t of targets) {
+        console.log(`  ${t}`);
+    }
+    if (shouldRemovePonytail) {
+        console.log(`  ${ponytailPkgDir} (ponytail plugin package)`);
+    }
+    if (shouldRemoveRtk) {
+        console.log(`  ${rtkBin}`);
+    }
+    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;
+            }
+        }
+    }
+    // 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.
+    const configRaw = await readTextIfExists(configPath);
+    if (configRaw) {
+        let lines = configRaw.split('\n');
+        const before = lines.length;
+        lines = lines.filter((l) => {
+            if (l.includes('combo-toggle') || l.includes('mode-reinforcement'))
+                return false;
+            if (shouldRemovePonytail && l.includes('ponytail') && l.includes('pi-extension'))
+                return false;
+            return true;
+        });
+        if (lines.length !== before) {
+            if (shouldDryRun)
+                console.log(`  [dry-run] would remove ${before - lines.length} config.yml entries`);
+            else
+                await writeConfigLines(configPath, lines, `  [write] Updated config.yml (removed ${before - lines.length} entries)`);
+        }
+    }
+    // Remove the Ponytail plugin package the installer added (dep, files,
+    // lock entry); the config.yml entry was filtered above.
+    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);
+        try {
+            if (shouldDryRun)
+                console.log(`  [dry-run] would remove ${ponytailPkgDir}`);
+            else {
+                await fs.rm(ponytailPkgDir, { recursive: true, force: true });
+                console.log(`  [rm] ${ponytailPkgDir}`);
+                await fs.rm(path.dirname(ponytailPkgDir));
+                console.log(`  [rm] ${path.dirname(ponytailPkgDir)} (empty scope)`);
+            }
+        }
+        catch {
+            debug('Could not remove ponytail package dir (scope may hold other packages)');
+        }
+        const lockPath = path.join(pluginsDir, 'omp-plugins.lock.json');
+        await updateJsonFile(lockPath, (data) => dropKey(data.plugins, '@dietrichgebert/ponytail'), `would remove @dietrichgebert/ponytail from ${lockPath}`, `Removed @dietrichgebert/ponytail from ${lockPath}`, shouldDryRun);
+    }
+    // Remove our plugin registration from ~/.omp/plugins
+    const pluginsPkgPath = path.join(pluginsDir, 'package.json');
+    await updateJsonFile(pluginsPkgPath, (data) => dropKey(data.dependencies, PACKAGE_NAME), `would remove ${PACKAGE_NAME} from ${pluginsPkgPath}`, `Removed ${PACKAGE_NAME} from plugins/package.json`, shouldDryRun);
+    const selfPluginDir = path.join(pluginsDir, 'node_modules', PACKAGE_NAME);
+    if ((await readTextIfExists(path.join(selfPluginDir, 'package.json'))) !== null) {
+        await removeUninstallTarget(selfPluginDir, shouldDryRun);
+    }
+    // Remove RTK binary if requested
+    if (shouldRemoveRtk)
+        await removeUninstallTarget(rtkBin, shouldDryRun, false);
+    console.log('\nDone. Restart OMP for changes to take effect.');
+    return true;
+}
+const SCOPE_MAP = { user: '1', project: '2', both: '3' };
+export { runUninstall };

package/cli/update.js

@@ -0,0 +1,202 @@
+// cli/update.ts — update check, per-add-on plan, latest-installer run.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { BUN_BIN_DIR, IS_WINDOWS, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_BIN, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, SCOPE_MAP, dryRun, execP, parseJsonObject, scopeFlag, verbose, } from './common.js';
+import { execNetwork } from './interactive.js';
+import { readTextIfExists } from '../extensions/lib/utils.js';
+import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, fetchJson, httpsGet, normalizeRtkVersion, sha256Hex, } from '../extensions/lib/utils.js';
+const UPDATE_CHECK_TTL_MS = 6 * 60 * 60 * 1000;
+function newerThan(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] || 0) !== (pb[i] || 0))
+            return (pa[i] || 0) > (pb[i] || 0);
+    }
+    return false;
+}
+async function latestPublishedVersion() {
+    try {
+        const args = IS_WINDOWS
+            ? ['/d', '/s', '/c', 'npm', 'view', PACKAGE_NAME, 'version', '--prefer-online']
+            : ['view', PACKAGE_NAME, 'version', '--prefer-online'];
+        const r = await execNetwork('Checking npm registry for tersio updates', IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm', args, {
+            timeout: 4000,
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+            shell: false,
+        });
+        return r.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// Returns a newer published version, or null. Reads the registry at most once
+// per TTL (cached under OMP_PLUGINS_DIR) and stays silent on failure.
+async function checkForUpdate() {
+    const cachePath = path.join(OMP_PLUGINS_DIR, 'tersio-update-check.json');
+    const cached = parseJsonObject(await readTextIfExists(cachePath));
+    const cacheFresh = typeof cached?.lastCheck === 'number' && Date.now() - cached.lastCheck < UPDATE_CHECK_TTL_MS;
+    if (cacheFresh && cached?.latest)
+        return newerThan(cached.latest, PACKAGE_VERSION) ? cached.latest : null;
+    const latest = await latestPublishedVersion();
+    if (latest) {
+        await fs.mkdir(OMP_PLUGINS_DIR, { recursive: true }).catch(() => { });
+        await fs.writeFile(cachePath, JSON.stringify({ latest, lastCheck: Date.now() }) + '\n', 'utf8').catch(() => { });
+        return newerThan(latest, PACKAGE_VERSION) ? latest : null;
+    }
+    // Registry unreachable: fall back to a stale cache rather than staying silent.
+    return cached?.latest && newerThan(cached.latest, PACKAGE_VERSION) ? cached.latest : null;
+}
+// Race a probe against a timeout; slow or failing probes resolve null so the
+// update plan stays best-effort and never blocks the update itself.
+async function settle(work, ms) {
+    let timer;
+    try {
+        return await Promise.race([
+            work.then((value) => value, () => null),
+            new Promise((resolve) => { timer = setTimeout(() => resolve(null), ms); }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// Plain `npm view <spec> version` with no spinner, for background probes.
+async function npmViewVersion(spec, timeoutMs) {
+    try {
+        const exe = IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm';
+        const args = IS_WINDOWS
+            ? ['/d', '/s', '/c', 'npm', 'view', spec, 'version', '--prefer-online']
+            : ['view', spec, 'version', '--prefer-online'];
+        const r = await execP(exe, args, { timeout: timeoutMs, maxBuffer: 1024 * 1024, windowsHide: true, shell: false });
+        return r.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// Run a child with inherited stdio for live output. Used when the child
+// renders its own interactive UI (the delegated installer runs Clack
+// spinners), which a concurrent outer spinner would corrupt into stray bars.
+async function execInherit(cmd, args) {
+    const code = await new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('close', resolve);
+    });
+    if (code !== 0)
+        throw new Error(`${cmd} exited with code ${code}`);
+}
+// Current → latest per add-on. Every probe is capped and nullable; the plan
+// prints `unknown` for anything unreachable and the update proceeds anyway.
+async function probeUpdatePlan(cliLatest) {
+    const rtkBin = path.join(BUN_BIN_DIR, RTK_BINARY_NAME);
+    const ponytailPkg = path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
+    const ruleDest = path.join(OMP_AGENT_DIR, 'extensions', 'caveman-session', 'rule.md');
+    const [rtkLocal, rtkRelease, ruleLocalText, ruleRemoteText, ponytailLocalText, ponytailLatest] = await Promise.all([
+        settle(execP(rtkBin, ['--version'], { timeout: 5000 }).then((r) => normalizeRtkVersion(r.stdout.trim() || r.stderr.trim()) || null), 6000),
+        settle(fetchJson(RTK_RELEASE_API).then((r) => normalizeRtkVersion(r.tag_name) || null), 4000),
+        readTextIfExists(ruleDest),
+        settle(httpsGet(CAVEMAN_REMOTE_RULE), 4000),
+        readTextIfExists(ponytailPkg),
+        settle(npmViewVersion('@dietrichgebert/ponytail', 4000), 5000),
+    ]);
+    const shortHash = (text) => text === null ? null : sha256Hex(text).slice(0, 8);
+    return {
+        cli: cliLatest,
+        rtk: [rtkLocal, rtkRelease],
+        rule: [shortHash(ruleLocalText), shortHash(ruleRemoteText)],
+        ponytail: [ponytailLocalText ? parseJsonObject(ponytailLocalText)?.version ?? null : null, ponytailLatest],
+    };
+}
+function planLine(name, current, latest) {
+    if (!current && !latest)
+        console.log(`  ${name}: unknown`);
+    else if (!latest)
+        console.log(`  ${name}: ${current} (latest unknown)`);
+    else if (current === latest)
+        console.log(`  ${name}: ${current} (up to date)`);
+    else
+        console.log(`  ${name}: ${current ?? 'missing'} → ${latest}`);
+}
+async function runLatestUpdate() {
+    const updateScope = scopeFlag || 'user';
+    if (!Object.hasOwn(SCOPE_MAP, updateScope)) {
+        console.error(`[fail] Invalid --scope: ${updateScope}. Use: user, project, both`);
+        process.exitCode = 1;
+        return;
+    }
+    const forwardedArgs = ['--yes', '--scope', updateScope];
+    if (dryRun)
+        forwardedArgs.push('--dry-run');
+    if (verbose)
+        forwardedArgs.push('--verbose');
+    const npmCommand = IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm';
+    console.log('=== Updating Tersio ===');
+    // Resolve the target explicitly: `npm view --prefer-online` beats the local
+    // metadata cache, so a stale `@latest` can never pin an older release.
+    const cliLatest = await latestPublishedVersion();
+    const target = cliLatest && /^\d+\.\d+\.\d+$/.test(cliLatest) ? `@${cliLatest}` : '@latest';
+    // Current → latest per add-on. Best-effort; unreachable probes print as
+    // unknown and never block the update.
+    const plan = await probeUpdatePlan(cliLatest);
+    planLine('Tersio', PACKAGE_VERSION, plan.cli);
+    planLine('RTK', plan.rtk[0], plan.rtk[1]);
+    planLine('Caveman rule', plan.rule[0], plan.rule[1]);
+    planLine('Ponytail', plan.ponytail[0], plan.ponytail[1]);
+    console.log('');
+    // The npx delegation below only refreshes the OMP-side files; the globally
+    // installed CLI keeps its old version until npm -g runs. Refresh both.
+    const globalArgs = IS_WINDOWS
+        ? ['/d', '/s', '/c', 'npm', 'install', '-g', `${PACKAGE_NAME}${target}`, '--no-audit', '--no-fund', '--prefer-online']
+        : ['install', '-g', `${PACKAGE_NAME}${target}`, '--no-audit', '--no-fund', '--prefer-online'];
+    if (dryRun) {
+        console.log(`  [dry-run] would run: npm install -g ${PACKAGE_NAME}${target} --no-audit --no-fund --prefer-online`);
+    }
+    else {
+        try {
+            const globalResult = await execNetwork(`Updating global Tersio CLI to ${PACKAGE_NAME}${target}`, npmCommand, globalArgs, {
+                timeout: 300000,
+                maxBuffer: 10 * 1024 * 1024,
+                windowsHide: true,
+                shell: false,
+            });
+            if (globalResult.stdout)
+                process.stdout.write(globalResult.stdout);
+            if (globalResult.stderr)
+                process.stderr.write(globalResult.stderr);
+            console.log(`  [ok] CLI updated to ${PACKAGE_NAME}${target}`);
+        }
+        catch (e) {
+            console.log(`  [warn] Global CLI update skipped: ${e.message}`);
+            console.log(`  [hint] Manual: npm install -g ${PACKAGE_NAME}${target} --no-audit --no-fund --prefer-online`);
+        }
+    }
+    const npmArgs = [
+        'exec',
+        '--yes',
+        '--prefer-online',
+        `--package=${PACKAGE_NAME}${target}`,
+        '--',
+        PACKAGE_BIN,
+        '--apply-update',
+        ...forwardedArgs,
+    ];
+    const npmCommandArgs = IS_WINDOWS ? ['/d', '/s', '/c', 'npm', ...npmArgs] : npmArgs;
+    // Inherited stdio, no outer spinner: the delegated installer renders its
+    // own Clack UI live, which capture-then-dump would corrupt into stray bars.
+    console.log(`  Running ${PACKAGE_NAME}${target} installer...`);
+    try {
+        await execInherit(npmCommand, npmCommandArgs);
+        console.log('\n=== Update complete ===');
+    }
+    catch (e) {
+        const err = e;
+        console.error(`\n[fail] Could not run ${PACKAGE_NAME}${target}: ${err.message}`);
+        process.exitCode = 1;
+    }
+}
+export { checkForUpdate, runLatestUpdate };

package/extensions/caveman-session/index.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, reconcileSharedComboEntries, sessionEntries, setSharedComboMode } from '../shared/session-state.js';
+import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, reconcileSharedComboEntries, sessionEntries, setSharedComboMode } from '../shared/session-state.js';
 import { readCavemanDefault } from '../shared/plugin-settings.js';
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
 const RULE_PATH = join(CAVERN_DIR, 'rule.md');
@@ -66,7 +66,10 @@ export default function cavemanSessionExtension(pi) {
         pi.appendEntry?.('caveman-mode', { mode: normalized });
         setSharedComboMode('caveman', normalized);
         syncStatus(ctx);
-        const msg = normalized === 'off' ? 'Caveman mode off.' : `Caveman mode set to ${normalized}.`;
+        const active = activeModesSummary(getSharedComboState());
+        const msg = normalized === 'off'
+            ? `Caveman off. Active: ${active}.`
+            : `Caveman ${normalized} on — terse replies for this session. Active: ${active}.`;
         ctx?.ui?.notify?.(msg, 'info');
         return true;
     }

package/extensions/combo-toggle/index.js

@@ -3,7 +3,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { asPromptArray, COMBO_LEVELS, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, normalizeComboLevel, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, systemPromptIncludes, } from '../shared/session-state.js';
+import { activeModesSummary, asPromptArray, COMBO_LEVELS, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, normalizeComboLevel, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, systemPromptIncludes, } from '../shared/session-state.js';
 import { readComboDefault } from '../shared/plugin-settings.js';
 const require = createRequire(import.meta.url);
 const PONYTAIL_FALLBACK_INTENSITY = {
@@ -110,7 +110,8 @@ export default function comboToggleExtension(pi) {
             }
             persistPreset(level);
             useState(setSharedComboLevel(level), ctx);
-            ctx?.ui?.notify?.(`Combo ${level} applied: ${levelSummary(getSharedComboState())}`, 'info');
+            const active = activeModesSummary(getSharedComboState());
+            ctx?.ui?.notify?.(level === 'off' ? `Combo off — all tersio modes inactive for this session. Active: ${active}.` : `Combo ${level} on — ${active} active for this session.`, 'info');
             if (ctx?.reload)
                 await ctx.reload();
         },
@@ -126,7 +127,7 @@ export default function comboToggleExtension(pi) {
             if (fallback !== 'off') {
                 persistPreset(fallback);
                 useState(setSharedComboLevel(fallback), ctx);
-                ctx?.ui?.notify?.(`Combo default applied: ${fallback}`, 'info');
+                ctx?.ui?.notify?.(`Combo default applied: ${fallback} — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
             }
         }
     });

package/extensions/rtk-session/index.js

@@ -1,6 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
-import { asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, paintStatusBar, reconcileSharedComboEntries, sessionEntries, setSharedComboMode } from '../shared/session-state.js';
+import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, paintStatusBar, reconcileSharedComboEntries, sessionEntries, setSharedComboMode } from '../shared/session-state.js';
 import { readRtkDefault } from '../shared/plugin-settings.js';
 const DEFAULT_ENABLED = false;
 function asBoolean(value) {
@@ -44,7 +44,8 @@ export default function rtkSessionExtension(pi) {
         pi.appendEntry?.('rtk-mode', { enabled });
         setSharedComboMode('rtk', enabled);
         syncStatus(ctx);
-        ctx?.ui?.notify?.(`RTK mode ${enabled ? 'on' : 'off'}.`, 'info');
+        const active = activeModesSummary(getSharedComboState());
+        ctx?.ui?.notify?.(enabled ? `RTK on — compact shell output for this session. Active: ${active}.` : `RTK off. Active: ${active}.`, 'info');
     }
     pi.setLabel?.('RTK session toggle');
     pi.registerCommand?.('rtk', {

package/extensions/shared/session-state.js

@@ -36,9 +36,6 @@ function isPresetLevel(value) {
 function isKnownLevel(value) {
     return value === 'custom' || isPresetLevel(value);
 }
-function levelForIndividualModes(modes) {
-    return modes.caveman === 'off' && modes.rtk === 'off' && modes.ponytail === 'off' ? 'off' : 'custom';
-}
 function normalizedState(modes, level = deriveLevel(modes)) {
     const state = {
         caveman: normalizeMode('caveman', modes?.caveman) || 'off',
@@ -115,21 +112,21 @@ export function setSharedComboMode(name, value) {
     if (!mode)
         return getSharedComboState();
     const modes = { ...getSharedComboState(), [name]: mode };
-    return publish(normalizedState(modes, levelForIndividualModes(modes)));
+    // Derive the level from the final triplet so a redundant same-value write
+    // (entry replay on resume, upstream ponytail re-affirming its mode) cannot
+    // strand a matching preset at 'custom' and drop the combo bar.
+    return publish(normalizedState(modes));
 }
 export function reconcileSharedComboEntries(entries) {
     let modes = { ...COMBO_LEVELS.off };
-    let level = 'off';
     if (Array.isArray(entries)) {
         for (const entry of entries) {
             if (entry?.type !== 'custom')
                 continue;
             if (entry.customType === 'combo-level') {
                 const preset = normalizeComboLevel(entry?.data?.level);
-                if (preset) {
+                if (preset)
                     modes = { ...COMBO_LEVELS[preset] };
-                    level = preset;
-                }
                 continue;
             }
             const name = MODE_ENTRY_TYPES[entry.customType ?? ''] ?? null;
@@ -137,13 +134,18 @@ export function reconcileSharedComboEntries(entries) {
                 continue;
             const value = name === 'rtk' ? entry?.data?.enabled : entry?.data?.mode;
             const mode = normalizeMode(name, value);
-            if (mode) {
+            if (mode)
                 modes[name] = mode;
-                level = levelForIndividualModes(modes);
-            }
         }
     }
-    return publish(normalizedState(modes, level));
+    // The level always reflects the final mode triplet, never the write order:
+    // a preset entry followed by the same values reconciles back to the preset.
+    return publish(normalizedState(modes));
+}
+// One-line session-wide mode summary for change confirmations, e.g.
+// `caveman=ULTRA, rtk=ON, ponytail=ULTRA`.
+export function activeModesSummary(state) {
+    return `caveman=${state.caveman.toUpperCase()}, rtk=${state.rtk.toUpperCase()}, ponytail=${state.ponytail.toUpperCase()}`;
 }
 export function setSharedComboListener(listener) {
     bridge().listener = typeof listener === 'function' ? listener : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "✂️ Token-saving OMP add-ons: terse Caveman replies, compact RTK shell output, lean Ponytail code calls — one-command combo presets.",
   "keywords": [
     "omp",
@@ -107,10 +107,11 @@
   },
   "files": [
     "tersio.js",
+    "cli/**/*.js",
     "extensions/**/*.js"
   ],
   "scripts": {
-    "clean": "rm -f tersio.js extensions/**/*.js",
+    "clean": "rm -f tersio.js cli/*.js extensions/**/*.js",
     "build": "tsc",
     "prepublishOnly": "npm run build",
     "check": "tsc --noEmit",