@krtclcdy/tersio 2.25.0 → 2.25.2

package/cli/doctor-fix.js

@@ -5,7 +5,7 @@ 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, 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 { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, rtkPlatformSpec, sha256File, } from '../extensions/lib/utils.js';
 import { runLatestUpdate } from './update.js';
 import { OPENCODE_SERVER_SHIM, TREE_FILES, sourcePath } from './manifest.js';
 import { detectHosts, hostExtensionsDir } from './hosts.js';
@@ -50,16 +50,20 @@ async function fixExtensionTrees() {
     }
 }
 // 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.
 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)
+    if (!(await readTextIfExists(nested)))
         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 });
+    if (dryRun)
+        sayTagged(`  [dry-run] would remove the redundant rtk plugin entry`);
+    else
+        await fs.rm(path.join(HOME, '.config', 'opencode', 'plugins', 'rtk.ts'), { force: true }).catch(() => { });
     const raw = await readTextIfExists(configPath);
     let config = {};
     try {
@@ -69,11 +73,11 @@ async function fixOpencodeEntry() {
         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))
+    const kept = plugins.filter((p) => typeof p !== 'string' || !p.endsWith('/opencode/plugins/rtk.ts'));
+    if (kept.length === plugins.length && kept.includes(dir))
         return;
-    withoutTersio.push(dir);
-    config.plugins = withoutTersio;
+    kept.push(dir);
+    config.plugins = kept;
     if (dryRun) {
         sayTagged(`  [dry-run] would register tersio in ${configPath}`);
         return;
@@ -88,30 +92,17 @@ async function fixExtensions(pluginsDir) {
     console.log('  Doctor --fix: restoring plugin extension files');
     const pluginExtDir = path.join(pluginsDir, 'node_modules', '@krtclcdy', 'tersio', 'extensions');
     await fs.mkdir(pluginExtDir, { recursive: true });
-    // 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')) {
+    // Rule bodies are never overwritten: they can be newer upstream fetches.
+    const ruleFile = (f) => /^caveman-session\/rule.*\.md$/.test(f);
+    for (const file of TREE_FILES) {
+        const dest = path.join(pluginExtDir, ...file.split('/'));
+        if (ruleFile(file) && existsSync(dest))
+            continue;
         const text = await readTextIfExists(sourcePath(file));
         if (text === null)
             sayTagged(`  [warn] bundled source missing: ${sourcePath(file)}`);
         else
-            await writeIfChanged(path.join(pluginExtDir, ...file.split('/')), text, { dryRun, verbose });
-    }
-    const ruleDest = path.join(pluginExtDir, 'caveman-session', 'rule.md');
-    if ((await readTextIfExists(ruleDest)) === null) {
-        const bundled = await readTextIfExists(path.join(EXT_DIR, 'caveman-session', 'rule.md'));
-        if (bundled !== null) {
-            await writeIfChanged(ruleDest, bundled, { dryRun, verbose });
-        }
-        else {
-            const rule = await Promise.race([
-                httpsGet(CAVEMAN_REMOTE_RULE).catch(() => null),
-                new Promise((resolve) => setTimeout(() => resolve(null), 8000)),
-            ]);
-            if (rule !== null)
-                await writeIfChanged(ruleDest, rule, { dryRun, verbose });
-            else
-                console.log('  [warn] Caveman rule unreachable and no bundled rule exists');
-        }
+            await writeIfChanged(dest, text, { dryRun, verbose });
     }
     // Writing is not atomic, so re-read rather than assume the tree is whole.
     if (dryRun)

package/cli/doctor.js

@@ -17,7 +17,7 @@ async function runDoctor(recheck = false) {
     const ponytailPkg = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
     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 cavemanRule = (name) => path.join(tersioPluginDir, 'extensions', 'caveman-session', name);
     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.
@@ -28,11 +28,13 @@ async function runDoctor(recheck = false) {
         ponytailPkgText: readTextIfExists(ponytailPkg),
         rtkBinText: rtkBin ? readTextIfExists(rtkBin) : Promise.resolve(null),
         cavemanIndexText: readTextIfExists(cavemanIndex),
-        cavemanRuleText: readTextIfExists(cavemanRule),
+        cavemanRuleText: readTextIfExists(cavemanRule('rule.md')),
+        cavemanUltraText: readTextIfExists(cavemanRule('rule-ultra.md')),
+        cavemanWenyanText: readTextIfExists(cavemanRule('rule-wenyan.md')),
         rtkIndexText: readTextIfExists(rtkIndex),
         updaterIndexText: readTextIfExists(updaterIndex),
         rtkMtime: rtkBin ? fs.stat(rtkBin).catch(() => null) : Promise.resolve(null),
-        ruleMtime: fs.stat(cavemanRule).catch(() => null),
+        ruleMtime: fs.stat(cavemanRule('rule.md')).catch(() => null),
         ponytailMtime: fs.stat(ponytailPkg).catch(() => null),
         pricesMtime: fs.stat(pricesCachePath()).catch(() => null),
     };
@@ -40,7 +42,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], [cavemanRuleText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime, pricesMtime]] = await runInteractivePhase('Checking installation', () => Promise.all([
+    const [[ompPkgText, configText], [cavemanIndexText, rtkIndexText, updaterIndexText, ponytailPkgText], [cavemanRuleText, cavemanUltraText, cavemanWenyanText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime, pricesMtime]] = await runInteractivePhase('Checking installation', () => Promise.all([
         Promise.all([
             probes.ompPkgText,
             probes.configText,
@@ -53,6 +55,8 @@ async function runDoctor(recheck = false) {
         ]),
         Promise.all([
             probes.cavemanRuleText,
+            probes.cavemanUltraText,
+            probes.cavemanWenyanText,
             probes.ruleMtime,
             probes.rtkBinText,
             probes.rtkMtime,
@@ -129,7 +133,9 @@ async function runDoctor(recheck = false) {
     check('Prices feed', pricesMtime !== null, pricesAge || pricesCachePath());
     section('Add-ons');
     const ruleAge = ruleMtime ? `(updated ${relTime(Date.now() - ruleMtime.mtimeMs)} · ${absDate(ruleMtime.mtimeMs)})` : '';
-    check('Caveman rule', cavemanRuleText !== null, ruleAge);
+    const cavemanRules = [['rule.md', cavemanRuleText], ['rule-ultra.md', cavemanUltraText], ['rule-wenyan.md', cavemanWenyanText]];
+    const missingRules = cavemanRules.filter(([, text]) => text === null).map(([name]) => name);
+    check('Caveman rule', missingRules.length === 0, missingRules.length ? `missing: ${missingRules.join(', ')}` : 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.

package/cli/install.js

@@ -13,7 +13,7 @@ import { runReset } from './reset.js';
 import { runUsage } from './usage.js';
 import { runDashboard } from './dashboard.js';
 import { wireRtkOmp, wireRtkOpencode, wireRtkPi } from './rtk-wiring.js';
-import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, httpsDownload, parseChecksum, piAgentDir, readTextIfExists, resolveRtkBinary, rtkPlatformSpec, sha256File, } from '../extensions/lib/utils.js';
+import { CAVEMAN_REMOTE_ULTRA, CAVEMAN_REMOTE_WENYAN, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, httpsDownload, parseChecksum, piAgentDir, readTextIfExists, resolveRtkBinary, rtkPlatformSpec, sha256File, } from '../extensions/lib/utils.js';
 import { formatCliStatus, storedProfile, storedProfileSync, writePluginSettings } from './profile.js';
 import { runSettings } from './settings.js';
 import { tersioSettingsFile } from '../extensions/shared/plugin-settings.js';
@@ -356,39 +356,40 @@ async function stepRtkSession(extDir, options) {
         console.log('  RTK session — install session mode');
     await copySources(extDir, filesUnder('rtk-session'), 'rtk-session/index.ts', options);
 }
-// One fetch serves the install; dry runs stay offline and preview the bundled rule's destination.
-async function fetchCavemanRule(options) {
-    const bundled = await readTextIfExists(sourcePath('caveman-session/rule.md'));
-    if (options.dryRun)
-        return bundled;
-    try {
-        return await withInteractiveSpinner('Fetching Caveman rule', () => httpsGet(CAVEMAN_REMOTE_RULE));
-    }
-    catch (e) {
-        if (bundled !== null) {
-            debug(`Using bundled Caveman rule: ${e.message}`);
-            return bundled;
-        }
-        sayTagged(`  [warn] Could not fetch caveman rule: ${e.message}`);
-        return null;
-    }
-}
-async function stepCaveman(extDir, rule, options) {
+// rule.md ships with the package; the other bodies track upstream skills.
+const CAVEMAN_RULES = [
+    ['rule.md', null],
+    ['rule-ultra.md', CAVEMAN_REMOTE_ULTRA],
+    ['rule-wenyan.md', CAVEMAN_REMOTE_WENYAN],
+];
+async function stepCaveman(extDir, options) {
     if (!options.quiet)
-        console.log('  Caveman — fetch rule and install session mode');
+        console.log('  Caveman — install session mode and rule bodies');
     const cavemanDir = path.join(extDir, 'caveman-session');
     if (!options.dryRun)
         await fs.mkdir(cavemanDir, { recursive: true });
-    const ruleDest = path.join(cavemanDir, 'rule.md');
-    if (rule === null && (await readTextIfExists(ruleDest)) !== null) {
-        debug('Keeping existing rule.md');
-    }
-    else if (rule === null) {
-        console.log('  [skip] Caveman rule.md unavailable');
-        sayTagged(`  [hint] Manual: ${CAVEMAN_REMOTE_RULE}`);
-    }
-    else {
-        await writeIfChanged(ruleDest, rule, options);
+    for (const [name, remote] of CAVEMAN_RULES) {
+        const bundled = await readTextIfExists(sourcePath(`caveman-session/${name}`));
+        let rule = bundled;
+        if (remote && !options.dryRun) {
+            try {
+                rule = await withInteractiveSpinner(`Fetching Caveman ${name}`, () => httpsGet(remote));
+            }
+            catch (e) {
+                if (bundled === null)
+                    sayTagged(`  [warn] Could not fetch caveman ${name}: ${e.message}`);
+                else
+                    debug(`Using bundled Caveman ${name}: ${e.message}`);
+            }
+        }
+        if (rule === null) {
+            if (remote)
+                sayTagged(`  [hint] Manual: ${remote}`);
+            console.log(`  [skip] Caveman ${name} unavailable`);
+        }
+        else {
+            await writeIfChanged(path.join(cavemanDir, name), rule, options);
+        }
     }
     await copySources(extDir, filesUnder('caveman-session').filter(([, to]) => to.endsWith('index.ts')), 'caveman-session/index.ts', options);
 }
@@ -459,18 +460,22 @@ async function stepOpencode(options) {
         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))
-        withoutTersio.push(dir);
-    config.plugins = withoutTersio;
-    if (!options.dryRun)
+    // The tree ships the rtk rewrite, so its own plugin entry is redundant.
+    const kept = plugins.filter((p) => typeof p !== 'string' || !p.endsWith('/opencode/plugins/rtk.ts'));
+    if (!kept.includes(dir))
+        kept.push(dir);
+    config.plugins = kept;
+    if (!options.dryRun) {
         await fs.mkdir(path.dirname(configPath), { recursive: true });
+        await fs.rm(path.join(HOME, '.config', 'opencode', 'plugins', 'rtk.ts'), { force: true }).catch(() => { });
+    }
     await writeIfChanged(configPath, `${JSON.stringify(config, null, 2)}\n`, options);
 }
 async function resolveProfile(opts = {}) {
     // Seed from the stored defaults so flag-less runs keep them.
     const profile = await storedProfile();
     // One numbered prompt for all three modes, for a real terminal user with no default flags. Never for --apply-update, and never for a script.
+    let comboChosen = comboDefaultFlag !== undefined;
     if (tty() && !profileFlagsGiven && !applyUpdate) {
         const choice = await askInteractiveChoice('Session-start defaults — Combo preset', [
             { value: 'off', label: 'off' },
@@ -478,8 +483,10 @@ async function resolveProfile(opts = {}) {
             { value: 'balanced', label: 'balanced', hint: 'caveman=full, rtk=on, ponytail=full' },
             { value: 'max', label: 'max', hint: 'caveman=ultra, rtk=on, ponytail=ultra' },
         ], profile.comboDefault);
-        if (choice.status === 'selected')
+        if (choice.status === 'selected') {
             profile.comboDefault = choice.value;
+            comboChosen = true;
+        }
         else {
             closeRL();
             process.exit(130);
@@ -488,10 +495,13 @@ async function resolveProfile(opts = {}) {
     // Explicit flags always win over the Combo preset.
     if (comboDefaultFlag !== undefined)
         profile.comboDefault = comboDefaultFlag;
-    const preset = COMBO_PRESET_MODES[profile.comboDefault] ?? COMBO_PRESET_MODES.off;
-    profile.cavemanDefault = preset.caveman;
-    profile.rtkDefault = preset.rtk;
-    profile.ponytailDefault = preset.ponytail;
+    // A stored per-mode choice survives installs and updates; only a chosen preset rewrites it.
+    if (comboChosen) {
+        const preset = COMBO_PRESET_MODES[profile.comboDefault] ?? COMBO_PRESET_MODES.off;
+        profile.cavemanDefault = preset.caveman;
+        profile.rtkDefault = preset.rtk;
+        profile.ponytailDefault = preset.ponytail;
+    }
     if (cavemanDefaultFlag !== undefined)
         profile.cavemanDefault = cavemanDefaultFlag;
     if (rtkDefaultFlag !== undefined)
@@ -506,7 +516,8 @@ let updatePromptDone = false;
 // Bare `tersio` at a terminal picks a command; scripts and flags install.
 async function runCommandMenu() {
     printWelcome();
-    const newer = await checkForUpdate();
+    // Interactive launches always check; scripts use the cached verdict.
+    const newer = await checkForUpdate(true);
     if (typeof newer === 'string' && !dryRun) {
         const answer = await askInteractiveConfirm(`tersio ${newer} is available (installed ${PACKAGE_VERSION}). Install it now?`);
         if (answer.status === 'confirmed' && answer.value) {
@@ -636,50 +647,73 @@ async function stepPiLayer(options) {
         sayTagged(`  [note] pi also has a tersio package (${declared}) — remove one, or both copies load: pi remove npm:${PACKAGE_NAME}`);
     if (!options.quiet)
         console.log(`  Pi — write the extension tree (${extDir})`);
-    const cavemanRule = await fetchCavemanRule(options);
     await stepSharedSessionState(extDir, options);
     // OMP loads rtk-session from its plugin manifest, so only the pi tree copies it.
     await copySources(extDir, filesUnder('rtk-session'), 'rtk-session/index.ts', options);
-    await stepCaveman(extDir, cavemanRule, options);
+    await stepCaveman(extDir, options);
     await stepCombo(extDir, options);
     await stepTersioCommands(extDir, options);
     await stepUpdater(extDir, options);
     await stepPonytailForPi(agentDir, options);
 }
-// Ponytail for pi: install the package, or copy the bundled skills offline.
+// A local dir, not an npm spec: pi only version-checks npm entries, so this avoids the update nag.
+const PI_PONYTAIL_FILES = [
+    'pi-extension/index.js',
+    'hooks/ponytail-instructions.js',
+    'hooks/ponytail-config.js',
+    'skills/ponytail/SKILL.md',
+];
+const PI_PONYTAIL_PACKAGE = `${JSON.stringify({ name: 'ponytail', version: '0.0.0', private: true, pi: { extensions: ['./pi-extension/index.js'], skills: ['./skills'] } }, null, 2)}\n`;
 async function stepPonytailForPi(agentDir, options) {
     if (!options.quiet)
-        console.log('  Ponytail — ensure the pi package');
-    if (!options.dryRun) {
+        console.log('  Ponytail — write the local pi package');
+    const root = findHoistedPackage('@dietrichgebert/ponytail', path.dirname(fileURLToPath(import.meta.url)));
+    const dest = path.join(agentDir, 'ponytail');
+    if (!root) {
+        console.log('  [skip] Ponytail package not found next to the CLI');
+        console.log('  [hint] The /ponytail command will not work; run: tersio update --host pi');
+        return;
+    }
+    await writeIfChanged(path.join(dest, 'package.json'), PI_PONYTAIL_PACKAGE, options);
+    for (const rel of PI_PONYTAIL_FILES) {
+        let text;
         try {
-            await execNetwork('Installing Ponytail for pi', 'pi', ['install', 'npm:@dietrichgebert/ponytail'], { timeout: 300000 });
-            return;
+            text = await fs.readFile(path.join(root, ...rel.split('/')), 'utf8');
         }
-        catch (e) {
-            sayTagged(`  [fail] pi install ponytail: ${shortError(e)}`);
+        catch {
+            sayTagged(`  [fail] Ponytail file missing: ${rel}`);
+            return;
         }
+        await writeIfChanged(path.join(dest, ...rel.split('/')), text, options);
     }
-    const skills = findHoistedPackage('@dietrichgebert/ponytail', path.dirname(fileURLToPath(import.meta.url)), 'skills');
-    if (!skills) {
-        console.log('  [skip] Ponytail package not found next to the CLI — skills not copied');
-        console.log('  [hint] The /ponytail command will not work; run: pi install npm:@dietrichgebert/ponytail');
+    if (options.dryRun)
         return;
+    try {
+        await execNetwork('Removing the pi npm copy of Ponytail', 'pi', ['remove', 'npm:@dietrichgebert/ponytail'], { timeout: 120000 });
     }
-    const dest = path.join(agentDir, 'skills');
-    if (options.dryRun) {
-        if (verbose && !options.quiet)
-            sayTagged(`  [dry-run] would copy Ponytail skills to ${dest}`);
-        return;
+    catch (e) {
+        sayTagged(`  [warn] pi remove ponytail: ${shortError(e)}`);
     }
-    for (const entry of await fs.readdir(skills, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        const to = path.join(dest, entry.name);
-        await fs.rm(to, { recursive: true, force: true });
-        await fs.cp(path.join(skills, entry.name), to, { recursive: true });
-        if (!options.quiet)
-            sayTagged(`  [write] skill ${entry.name} → ${to}`);
+    await registerPiLocalPonytail(agentDir, dest, options);
+}
+// pi lists package sources in settings; swap the npm spec for the local dir.
+async function registerPiLocalPonytail(agentDir, dest, options) {
+    const settingsPath = path.join(agentDir, 'settings.json');
+    let settings;
+    try {
+        settings = JSON.parse(await fs.readFile(settingsPath, 'utf8'));
+    }
+    catch {
+        return;
     }
+    const packages = (Array.isArray(settings.packages) ? settings.packages : []);
+    const kept = packages.filter((p) => typeof p !== 'string' || !p.startsWith('npm:@dietrichgebert/ponytail'));
+    if (!kept.includes(dest))
+        kept.push(dest);
+    settings.packages = kept;
+    await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+    if (!options.quiet)
+        sayTagged(`  [write] pi package source → ${dest}`);
 }
 async function runInstall() {
     // Without this guard a picked command re-enters here with command === null and loops straight back into the picker.
@@ -799,14 +833,13 @@ async function runInstall() {
         closeRL();
         return;
     }
-    const cavemanRule = await fetchCavemanRule(installOptions);
     await capture('shared', () => stepSharedSessionState(userExtDir, installOptions));
     let selfPlugin = false;
     await capture('self-plugin', async () => { selfPlugin = await stepSelfPlugin(OMP_PLUGINS_DIR, installOptions); });
     await capture('ponytail', () => stepPonytail(OMP_PLUGINS_DIR, installOptions));
     await capture('rtk', () => stepRtk(BUN_BIN_DIR, installOptions));
     await capture('rtk session', () => stepRtkSession(userExtDir, installOptions));
-    await capture('caveman', () => stepCaveman(path.join(OMP_PLUGINS_DIR, 'node_modules', '@krtclcdy', 'tersio', 'extensions'), cavemanRule, installOptions));
+    await capture('caveman', () => stepCaveman(path.join(OMP_PLUGINS_DIR, 'node_modules', '@krtclcdy', 'tersio', 'extensions'), installOptions));
     await capture('combo', () => stepCombo(userExtDir, installOptions));
     await capture('commands', () => stepTersioCommands(userExtDir, installOptions));
     await capture('updater', () => stepUpdater(userExtDir, installOptions));

package/cli/interactive.js

@@ -26,9 +26,9 @@ function tty() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 let spinnerDepth = 0;
-// Run async work under a TTY-only timer spinner. The spinner is cleared before the caller prints its normal result line, preserving locked output shapes.
+// Clack's spinner stop writes an extra newline under CI, shifting later output by a row.
 async function withInteractiveSpinner(message, work) {
-    if (!tty() || spinnerDepth > 0)
+    if (!tty() || spinnerDepth > 0 || process.env.CI === 'true')
         return work(() => { });
     // Clack manages stdin itself. Close the legacy question interface before its first use; non-interactive callers never reach this branch.
     closeRL();

package/cli/manifest.js

@@ -20,6 +20,8 @@ export const TREE_FILES = [
     'lib/utils.ts',
     'caveman-session/index.ts',
     'caveman-session/rule.md',
+    'caveman-session/rule-ultra.md',
+    'caveman-session/rule-wenyan.md',
     'rtk-session/index.ts',
     'combo-toggle/index.ts',
     'tersio-commands/index.ts',

package/cli/rtk-wiring.js

@@ -1,5 +1,5 @@
 // OMP loads only listed extensions, so register rtk's path; fail-open.
-import { promises as fs } from 'node:fs';
+import { existsSync, promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFile } from 'node:child_process';
@@ -47,8 +47,11 @@ export async function wireRtkOmp(rtkBin, options = {}) {
     await ensureRtkInConfig(options);
     return true;
 }
+// The Tersio plugin does the same rewrite, so OpenCode needs no rtk plugin of its own.
 export async function wireRtkOpencode(rtkBin, options = {}) {
-    return runWire(rtkBin, { host: 'OpenCode', mechanism: 'tool.execute.before', initArgs: ['init', '-g', '--opencode'], hint: 'rtk init -g --opencode' }, options);
+    if (!options.dryRun && !options.quiet)
+        console.log('  RTK rewrite runs inside the Tersio plugin — no separate entry');
+    return existsSync(rtkBin);
 }
 export async function wireRtkPi(rtkBin, options = {}) {
     return runWire(rtkBin, { host: 'pi', mechanism: 'bash tool_call', initArgs: ['init', '-g', '--agent', 'pi'], hint: 'rtk init -g --agent pi' }, options);

package/cli/uninstall.js

@@ -4,8 +4,7 @@ import path from 'node:path';
 import { BUN_BIN_DIR, HOME, 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, sayTagged } 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 { piAgentDir, readTextIfExists } from '../extensions/lib/utils.js';
 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';
@@ -42,20 +41,30 @@ async function piRemove(spec, shouldDryRun) {
         sayTagged(`  [hint] Manual: pi remove ${spec}`);
     }
 }
-// Only the skill directories the installer copied, never pi's own skills dir.
+// The installer writes a local package dir; drop it and its settings entry.
 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);
+    const agentDir = piAgentDir();
+    const settingsPath = path.join(agentDir, 'settings.json');
+    try {
+        const settings = JSON.parse(await fs.readFile(settingsPath, 'utf8'));
+        if (!Array.isArray(settings.packages))
+            return;
+        const kept = settings.packages.filter((p) => p !== path.join(agentDir, 'ponytail'));
+        if (kept.length === settings.packages.length)
+            return;
+        if (shouldDryRun)
+            sayTagged(`  [dry-run] would drop the local ponytail entry from ${settingsPath}`);
+        else
+            await fs.writeFile(settingsPath, `${JSON.stringify({ ...settings, packages: kept }, null, 2)}\n`, 'utf8');
     }
+    catch { /* no settings file, nothing to clean */ }
+    await removeUninstallTarget(path.join(agentDir, 'ponytail'), shouldDryRun);
 }
 // pi removal delegates to pi remove; always list and confirm first.
 async function removePiLayer(host, shouldDryRun, shouldRemovePonytail, shouldRemoveRtk, confirmed) {
     const targets = PI_TREE_DIRS.map((dir) => path.join(piAgentDir(), 'extensions', dir));
     const rtkWiring = path.join(piAgentDir(), 'extensions', 'rtk.ts');
+    const piPonytail = path.join(piAgentDir(), 'ponytail');
     if (!host.installed && !host.declared) {
         sayTagged(`  [skip] ${host.label} — nothing installed (${host.installCmd})`);
         return false;
@@ -63,8 +72,10 @@ async function removePiLayer(host, shouldDryRun, shouldRemovePonytail, shouldRem
     console.log('Will remove:');
     for (const t of targets)
         console.log(`  ${t}`);
-    if (shouldRemovePonytail)
+    if (shouldRemovePonytail) {
         console.log(`  npm:${PONYTAIL_PKG} (pi package)`);
+        console.log(`  ${piPonytail} (local Ponytail package)`);
+    }
     if (shouldRemoveRtk)
         console.log(`  ${rtkWiring} (rtk wiring)`);
     console.log(`  ${tersioSettingsFile()} (session defaults)`);
@@ -195,12 +206,14 @@ async function runUninstall(options = {}) {
         }
         console.log('Will remove:');
         console.log(`  ${dir}`);
+        console.log(`  ${path.join(HOME, '.config', 'opencode', 'plugins', 'rtk.ts')} (rtk auto-wrap; reinstall with: rtk init -g --opencode)`);
         console.log(`  the tersio entry in ${configPath}`);
         if (!confirmed && !(await confirmDestructive('Remove these Tersio files?'))) {
             closeRL();
             return false;
         }
         await removeUninstallTarget(dir, shouldDryRun);
+        await removeUninstallTarget(path.join(HOME, '.config', 'opencode', 'plugins', 'rtk.ts'), shouldDryRun, false);
         if (!shouldDryRun) {
             try {
                 const raw = await readTextIfExists(configPath);
@@ -276,7 +289,8 @@ async function runUninstall(options = {}) {
         }
     }
     // Cleared last: writeConfigLines above would just make a fresh one.
-    for (const backup of [`${configPath}.bak`, path.join(pluginsDir, 'node_modules', PACKAGE_NAME, 'extensions', 'caveman-session', 'rule.md.bak')]) {
+    const cavemanDir = path.join(pluginsDir, 'node_modules', PACKAGE_NAME, 'extensions', 'caveman-session');
+    for (const backup of [`${configPath}.bak`, path.join(cavemanDir, 'rule.md.bak'), path.join(cavemanDir, 'rule-ultra.md.bak'), path.join(cavemanDir, 'rule-wenyan.md.bak')]) {
         await removeUninstallTarget(backup, shouldDryRun, false);
     }
     // Remove the bundled Ponytail copy; its config.yml entry is already filtered.

package/cli/update.js

@@ -6,7 +6,7 @@ import { IS_WINDOWS, OMP_PLUGINS_DIR, PACKAGE_BIN, PACKAGE_NAME, PACKAGE_VERSION
 import { execNetwork, sayTagged } from './interactive.js';
 import { readTextIfExists, resolveRtkBinary, tersioDataPath } from '../extensions/lib/utils.js';
 import { refreshPrices } from '../extensions/shared/pricing.js';
-import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, httpsGet, normalizeRtkVersion, sha256Hex, } from '../extensions/lib/utils.js';
+import { CAVEMAN_REMOTE_ULTRA, CAVEMAN_REMOTE_WENYAN, RTK_RELEASE_API, httpsGet, normalizeRtkVersion, sha256Hex, } from '../extensions/lib/utils.js';
 import { parseHostArg } from './hosts.js';
 const UPDATE_CHECK_TTL_MS = 6 * 60 * 60 * 1000;
 function newerThan(a, b) {
@@ -78,20 +78,23 @@ async function execInherit(cmd, args) {
 async function probeUpdatePlan(cliLatest) {
     const rtkBin = resolveRtkBinary();
     const ponytailPkg = path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
-    const tersioRule = path.join(OMP_PLUGINS_DIR, 'node_modules', '@krtclcdy', 'tersio', 'extensions', 'caveman-session', 'rule.md');
+    // rule.md ships with the release; only the tracked bodies can go stale.
+    const tersioRule = (name) => path.join(OMP_PLUGINS_DIR, 'node_modules', '@krtclcdy', 'tersio', 'extensions', 'caveman-session', name);
     const controller = new AbortController();
-    const [rtkLocal, rtkRelease, ruleLocalText, ruleRemoteText, ponytailLocalText] = await Promise.all([
+    const [rtkLocal, rtkRelease, ruleLocal, ruleRemote, ponytailLocalText] = await Promise.all([
         settle(rtkBin ? execP(rtkBin, ['--version'], { timeout: 5000 }).then((r) => normalizeRtkVersion(r.stdout.trim() || r.stderr.trim()) || null) : Promise.resolve(null), 6000),
         settle(httpsGet(RTK_RELEASE_API, { signal: controller.signal }).then((text) => normalizeRtkVersion(JSON.parse(text).tag_name) || null), 1500),
-        readTextIfExists(tersioRule),
-        settle(httpsGet(CAVEMAN_REMOTE_RULE, { signal: controller.signal }).then((text) => sha256Hex(text).slice(0, 8)), 1500),
+        Promise.all([readTextIfExists(tersioRule('rule-ultra.md')), readTextIfExists(tersioRule('rule-wenyan.md'))])
+            .then((texts) => (texts.every(Boolean) ? texts.map((t) => sha256Hex(t).slice(0, 8)).join('+') : null)),
+        settle(Promise.all([httpsGet(CAVEMAN_REMOTE_ULTRA, { signal: controller.signal }), httpsGet(CAVEMAN_REMOTE_WENYAN, { signal: controller.signal })])
+            .then((texts) => texts.map((t) => sha256Hex(t).slice(0, 8)).join('+')), 1500),
         readTextIfExists(ponytailPkg),
     ]);
     controller.abort();
     return {
         cli: cliLatest,
         rtk: [rtkLocal, rtkRelease],
-        rule: [ruleLocalText ? sha256Hex(ruleLocalText).slice(0, 8) : null, ruleRemoteText],
+        rule: [ruleLocal, ruleRemote],
         ponytail: ponytailLocalText ? parseJsonObject(ponytailLocalText)?.version ?? null : null,
     };
 }

package/extensions/ai-addons-updater/index.js

@@ -6,13 +6,18 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { setExtensionLabel } from '../shared/host.js';
-import { CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, httpsDownload, isPiProcess, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, rtkPlatformSpec, resolveRtkBinary, } from '../lib/utils.js';
+import { CAVEMAN_REMOTE_ULTRA, CAVEMAN_REMOTE_WENYAN, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, httpsDownload, isPiProcess, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, rtkPlatformSpec, resolveRtkBinary, } from '../lib/utils.js';
 const IS_WINDOWS = process.platform === 'win32';
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
 const RTK_BINARY = resolveRtkBinary();
-// Beside this file, not a host path: that is the rule.md /caveman reads.
-const CAVEMAN_LOCAL = path.join(EXTENSION_DIR, '..', 'caveman-session', 'rule.md');
+// Beside this file, not a host path: these are the rules /caveman reads.
+const cavemanRule = (name) => path.join(EXTENSION_DIR, '..', 'caveman-session', name);
+const CAVEMAN_LOCAL = cavemanRule('rule.md');
+const CAVEMAN_TRACKED = [
+    { file: cavemanRule('rule-ultra.md'), remote: CAVEMAN_REMOTE_ULTRA },
+    { file: cavemanRule('rule-wenyan.md'), remote: CAVEMAN_REMOTE_WENYAN },
+];
 const HOST_NAME = isPiProcess() ? 'Pi' : 'OMP';
 const RELOAD_MSG = `Reminder: restart ${HOST_NAME} (or reload extensions) for updates to take effect.`;
 // Ponytail is a hoisted dependency, so the installed copy is found by walking up rather than by naming a host directory.
@@ -82,17 +87,20 @@ function checkRtk() {
         return `RTK ${status}: local=${localVer || '—'} latest=${latestTag || '—'}`;
     });
 }
-// Caveman (rule.md)
 function checkCaveman() {
     return runCheck('Caveman', async () => {
-        const remote = await httpsGet(CAVEMAN_REMOTE);
-        const remoteHash = shortHash(remote);
-        const local = await readTextIfExists(CAVEMAN_LOCAL);
-        const localHash = local ? shortHash(local) : null;
-        const status = !local ? 'rule.md missing'
-            : localHash === remoteHash ? 'rule.md up to date'
-                : 'rule.md update available';
-        return `Caveman ${status}: local=${localHash || '—'} remote=${remoteHash}`;
+        const parts = [(await readTextIfExists(CAVEMAN_LOCAL)) ? 'rule.md ok' : 'rule.md missing'];
+        for (const { file, remote } of CAVEMAN_TRACKED) {
+            const name = path.basename(file);
+            try {
+                const [remoteText, localText] = await Promise.all([httpsGet(remote), readTextIfExists(file)]);
+                parts.push(!localText ? `${name} missing` : shortHash(localText) === shortHash(remoteText) ? `${name} up to date` : `${name} update available`);
+            }
+            catch {
+                parts.push(`${name} check skipped`);
+            }
+        }
+        return `Caveman ${parts.join(', ')}`;
     });
 }
 export async function checkAddonsSummary(ctx) {
@@ -317,41 +325,49 @@ async function updateRtk(ctx, dryRun = false) {
     }
 }
 async function updateCaveman(ctx, dryRun = false) {
-    let remote;
-    try {
-        remote = await httpsGet(CAVEMAN_REMOTE);
-    }
-    catch (e) {
-        return report(ctx, `Caveman update failed: ${e.message}`, 'warning');
-    }
-    const remoteHash = shortHash(remote);
-    const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
-    const oldHash = oldLocal ? shortHash(oldLocal) : null;
-    if (dryRun) {
-        const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}.`;
-        return report(ctx, m, 'info');
-    }
-    try {
-        await fs.mkdir(path.dirname(CAVEMAN_LOCAL), { recursive: true });
-        const backupPath = `${CAVEMAN_LOCAL}.bak`;
-        if (oldLocal !== null)
-            await fs.writeFile(backupPath, oldLocal, 'utf8');
-        await fs.writeFile(CAVEMAN_LOCAL, remote, 'utf8');
-        const written = await fs.readFile(CAVEMAN_LOCAL, 'utf8');
-        const writtenHash = shortHash(written);
-        if (writtenHash !== remoteHash) {
+    const results = [];
+    for (const { file, remote } of CAVEMAN_TRACKED) {
+        const name = path.basename(file);
+        let remoteText;
+        try {
+            remoteText = await httpsGet(remote);
+        }
+        catch (e) {
+            results.push(report(ctx, `Caveman ${name} update failed: ${e.message}`, 'warning'));
+            continue;
+        }
+        const remoteHash = shortHash(remoteText);
+        const oldLocal = await readTextIfExists(file);
+        const oldHash = oldLocal ? shortHash(oldLocal) : null;
+        if (oldHash === remoteHash) {
+            results.push(`${name} up to date: ${remoteHash}`);
+            continue;
+        }
+        if (dryRun) {
+            results.push(`Caveman dry-run: would write ${file}\nold=${oldHash || '—'} new=${remoteHash}.`);
+            continue;
+        }
+        try {
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            const backupPath = `${file}.bak`;
             if (oldLocal !== null)
-                await fs.writeFile(CAVEMAN_LOCAL, oldLocal, 'utf8');
-            throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
+                await fs.writeFile(backupPath, oldLocal, 'utf8');
+            await fs.writeFile(file, remoteText, 'utf8');
+            const writtenHash = shortHash(await fs.readFile(file, 'utf8'));
+            if (writtenHash !== remoteHash) {
+                if (oldLocal !== null)
+                    await fs.writeFile(file, oldLocal, 'utf8');
+                throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
+            }
+            results.push(`Caveman ${name} updated → ${file}\nold=${oldHash || '—'} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : '—'}\n${RELOAD_MSG}`);
+        }
+        catch (e) {
+            results.push(`Caveman ${name} update failed: ${e.message}`);
         }
-        const m = `Caveman rule.md updated → ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : '—'}\n${RELOAD_MSG}`;
-        notify(ctx, 'Caveman rule.md updated. ' + RELOAD_MSG, 'info');
-        return m;
-    }
-    catch (e) {
-        const m = `Caveman update failed: ${e.message}`;
-        return report(ctx, m, 'warning');
     }
+    const summary = results.join('\n');
+    notify(ctx, `Caveman update finished. ${RELOAD_MSG}`, 'info');
+    return summary;
 }
 export default function aiAddonsUpdaterExtension(pi) {
     setExtensionLabel(pi, 'AI add-ons updater');

package/extensions/ai-addons-updater/index.ts

@@ -9,7 +9,8 @@ import { fileURLToPath } from 'node:url';
 
 import { setExtensionLabel } from '../shared/host.ts';
 import {
-  CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE,
+  CAVEMAN_REMOTE_ULTRA,
+  CAVEMAN_REMOTE_WENYAN,
   RTK_RELEASE_API,
   RtkRelease,
   fetchJson,
@@ -31,8 +32,13 @@ const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
 const RTK_BINARY = resolveRtkBinary();
-// Beside this file, not a host path: that is the rule.md /caveman reads.
-const CAVEMAN_LOCAL = path.join(EXTENSION_DIR, '..', 'caveman-session', 'rule.md');
+// Beside this file, not a host path: these are the rules /caveman reads.
+const cavemanRule = (name: string) => path.join(EXTENSION_DIR, '..', 'caveman-session', name);
+const CAVEMAN_LOCAL = cavemanRule('rule.md');
+const CAVEMAN_TRACKED: ReadonlyArray<{ file: string; remote: string }> = [
+  { file: cavemanRule('rule-ultra.md'), remote: CAVEMAN_REMOTE_ULTRA },
+  { file: cavemanRule('rule-wenyan.md'), remote: CAVEMAN_REMOTE_WENYAN },
+];
 const HOST_NAME = isPiProcess() ? 'Pi' : 'OMP';
 const RELOAD_MSG = `Reminder: restart ${HOST_NAME} (or reload extensions) for updates to take effect.`;
 
@@ -129,17 +135,19 @@ function checkRtk(): Promise<AddonStatus> {
   });
 }
 
-// Caveman (rule.md)
 function checkCaveman(): Promise<AddonStatus> {
   return runCheck('Caveman', async () => {
-    const remote = await httpsGet(CAVEMAN_REMOTE);
-    const remoteHash = shortHash(remote);
-    const local = await readTextIfExists(CAVEMAN_LOCAL);
-    const localHash = local ? shortHash(local) : null;
-    const status = !local ? 'rule.md missing'
-      : localHash === remoteHash ? 'rule.md up to date'
-        : 'rule.md update available';
-    return `Caveman ${status}: local=${localHash || '—'} remote=${remoteHash}`;
+    const parts: string[] = [(await readTextIfExists(CAVEMAN_LOCAL)) ? 'rule.md ok' : 'rule.md missing'];
+    for (const { file, remote } of CAVEMAN_TRACKED) {
+      const name = path.basename(file);
+      try {
+        const [remoteText, localText] = await Promise.all([httpsGet(remote), readTextIfExists(file)]);
+        parts.push(!localText ? `${name} missing` : shortHash(localText) === shortHash(remoteText) ? `${name} up to date` : `${name} update available`);
+      } catch {
+        parts.push(`${name} check skipped`);
+      }
+    }
+    return `Caveman ${parts.join(', ')}`;
   });
 }
 
@@ -352,37 +360,41 @@ async function updateRtk(ctx: AddonUpdaterCtx, dryRun = false): Promise<string>
 }
 
 async function updateCaveman(ctx: AddonUpdaterCtx, dryRun = false): Promise<string> {
-  let remote: string;
-  try { remote = await httpsGet(CAVEMAN_REMOTE); }
-  catch (e) { return report(ctx, `Caveman update failed: ${(e as Error).message}`, 'warning'); }
-
-  const remoteHash = shortHash(remote);
-  const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
-  const oldHash = oldLocal ? shortHash(oldLocal) : null;
-
-  if (dryRun) {
-    const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}.`;
-    return report(ctx, m, 'info');
-  }
+  const results: string[] = [];
+  for (const { file, remote } of CAVEMAN_TRACKED) {
+    const name = path.basename(file);
+    let remoteText: string;
+    try { remoteText = await httpsGet(remote); }
+    catch (e) { results.push(report(ctx, `Caveman ${name} update failed: ${(e as Error).message}`, 'warning')); continue; }
+
+    const remoteHash = shortHash(remoteText);
+    const oldLocal = await readTextIfExists(file);
+    const oldHash = oldLocal ? shortHash(oldLocal) : null;
+    if (oldHash === remoteHash) { results.push(`${name} up to date: ${remoteHash}`); continue; }
+
+    if (dryRun) {
+      results.push(`Caveman dry-run: would write ${file}\nold=${oldHash || '—'} new=${remoteHash}.`);
+      continue;
+    }
 
-  try {
-    await fs.mkdir(path.dirname(CAVEMAN_LOCAL), { recursive: true });
-    const backupPath = `${CAVEMAN_LOCAL}.bak`;
-    if (oldLocal !== null) await fs.writeFile(backupPath, oldLocal, 'utf8');
-    await fs.writeFile(CAVEMAN_LOCAL, remote, 'utf8');
-    const written = await fs.readFile(CAVEMAN_LOCAL, 'utf8');
-    const writtenHash = shortHash(written);
-    if (writtenHash !== remoteHash) {
-      if (oldLocal !== null) await fs.writeFile(CAVEMAN_LOCAL, oldLocal, 'utf8');
-      throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
+    try {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      const backupPath = `${file}.bak`;
+      if (oldLocal !== null) await fs.writeFile(backupPath, oldLocal, 'utf8');
+      await fs.writeFile(file, remoteText, 'utf8');
+      const writtenHash = shortHash(await fs.readFile(file, 'utf8'));
+      if (writtenHash !== remoteHash) {
+        if (oldLocal !== null) await fs.writeFile(file, oldLocal, 'utf8');
+        throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
+      }
+      results.push(`Caveman ${name} updated → ${file}\nold=${oldHash || '—'} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : '—'}\n${RELOAD_MSG}`);
+    } catch (e) {
+      results.push(`Caveman ${name} update failed: ${(e as Error).message}`);
     }
-    const m = `Caveman rule.md updated → ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : '—'}\n${RELOAD_MSG}`;
-    notify(ctx, 'Caveman rule.md updated. ' + RELOAD_MSG, 'info');
-    return m;
-  } catch (e) {
-    const m = `Caveman update failed: ${(e as Error).message}`;
-    return report(ctx, m, 'warning');
   }
+  const summary = results.join('\n');
+  notify(ctx, `Caveman update finished. ${RELOAD_MSG}`, 'info');
+  return summary;
 }
 
 export default function aiAddonsUpdaterExtension(pi: AddonUpdaterPi): void {

package/extensions/caveman-session/index.js

@@ -6,20 +6,20 @@ import { injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host
 import { announceStatus } from '../shared/status.js';
 import { readCavemanDefault } from '../shared/plugin-settings.js';
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
-const RULE_PATH = join(CAVERN_DIR, 'rule.md');
-// Fail loud: a wrong rule reads to the model as the real one.
-function readFullRule() {
+// Upstream ships one skill per register: default, ultracave, megacave.
+const RULE_FILES = { lite: 'rule.md', full: 'rule.md', ultra: 'rule-ultra.md', 'wenyan-lite': 'rule-wenyan.md', 'wenyan-full': 'rule-wenyan.md', 'wenyan-ultra': 'rule-wenyan.md' };
+const DEFAULT_MODE = 'off';
+function buildInstruction(mode) {
+    const name = RULE_FILES[mode] ?? RULE_FILES.full;
+    // Fail loud: a wrong rule reads to the model as the real one.
+    let body;
     try {
-        return readFileSync(RULE_PATH, 'utf8');
+        body = readFileSync(join(CAVERN_DIR, name), 'utf8');
     }
     catch {
-        return 'Caveman full requested, but rule.md is missing. Run: tersio doctor --fix extensions';
+        body = `Caveman ${mode} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
     }
-}
-const DEFAULT_MODE = 'off';
-// Upstream ships one SKILL.md; the level is a directive inside it, so swap only the header.
-function buildInstruction(mode) {
-    return `Caveman ${mode} active for this session.\n${readFullRule()}`;
+    return `Caveman ${mode} active for this session.\n${body}`;
 }
 function resolveMode(entries, fallback = DEFAULT_MODE) {
     return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;

package/extensions/caveman-session/index.ts

@@ -8,20 +8,19 @@ import { readCavemanDefault } from '../shared/plugin-settings.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
-const RULE_PATH = join(CAVERN_DIR, 'rule.md');
-
-// Fail loud: a wrong rule reads to the model as the real one.
-function readFullRule(): string {
-  try { return readFileSync(RULE_PATH, 'utf8'); } catch {
-    return 'Caveman full requested, but rule.md is missing. Run: tersio doctor --fix extensions';
-  }
-}
+// Upstream ships one skill per register: default, ultracave, megacave.
+const RULE_FILES = { lite: 'rule.md', full: 'rule.md', ultra: 'rule-ultra.md', 'wenyan-lite': 'rule-wenyan.md', 'wenyan-full': 'rule-wenyan.md', 'wenyan-ultra': 'rule-wenyan.md' };
 
 const DEFAULT_MODE = 'off';
 
-// Upstream ships one SKILL.md; the level is a directive inside it, so swap only the header.
 function buildInstruction(mode: string): string {
-  return `Caveman ${mode} active for this session.\n${readFullRule()}`;
+  const name = RULE_FILES[mode as keyof typeof RULE_FILES] ?? RULE_FILES.full;
+  // Fail loud: a wrong rule reads to the model as the real one.
+  let body: string;
+  try { body = readFileSync(join(CAVERN_DIR, name), 'utf8'); } catch {
+    body = `Caveman ${mode} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
+  }
+  return `Caveman ${mode} active for this session.\n${body}`;
 }
 
 function resolveMode(entries: SessionEntry[] | null | undefined, fallback: string = DEFAULT_MODE): string {

package/extensions/caveman-session/rule-ultra.md

@@ -0,0 +1,63 @@
+---
+name: ultracave
+description: >
+  Caveman at maximum compression: fragments, one word when one word is enough,
+  each fact once. Invoke only with /ultracave or /caveman ultra. Stays on until
+  "stop caveman" or "normal mode".
+disable-model-invocation: true
+---
+
+# ultracave
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die. Then cut again.
+
+Ultracave is caveman with the grammar stripped. Payload only.
+
+## Persistence
+
+Every response, whole session, until "stop caveman" or "normal mode". Unsure? Still on. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value or say `Caveman mode: unknown`.
+
+## Floor
+
+Never cut: code, commands, paths, API names, error strings (verbatim). not/never/no/only/except. Numbers and units. The user's language. One term per thing. No invented abbreviations, no arrows.
+
+## Rules
+
+### 1. Fragments
+
+Drop articles, copulas, connectives when order stays clear.
+
+Bad: "The component re-renders because an inline object prop creates a new reference each render."
+Good: "Inline object prop, new ref, re-render. `useMemo`."
+
+### 2. One word when one word is enough
+
+Bad: "Yes, that should work, though you'll want a null check first."
+Good: "Yes. Null check first."
+
+### 3. Each fact once
+
+No restating, no summary after a list.
+
+Good: "Pool reuses open DB connections. No per-request handshake."
+
+### 4. Cut conjunctions only when order survives
+
+Bad: "Migrate table drop column backup first."
+Good: "Back up first. Then migrate: drops column."
+
+### 5. Tool runs
+
+One line in, one line out. Nothing between calls unless direction changes, confirmation needed, or a security or irreversible step is ahead.
+
+### 6. Never perform
+
+No prefix, no announcement, no mangled verbs for flavor. Fragment not shorter than the sentence? Use the sentence.
+
+## When to break the rules
+
+Plain prose, then resume: security warning. Irreversible action, confirm first. Any fragment with two readings. User confused. Anything persisted outside chat (code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages; `/caveman-compress` exempt). Harness asks for a status line.
+
+## Pre-send check
+
+Two readings? Full sentence. Negations present? Payload verbatim? Flavor word? Cut.

package/extensions/caveman-session/rule-wenyan.md

@@ -0,0 +1,63 @@
+---
+name: megacave
+description: >
+  Caveman in Classical Chinese: 文言文 register, far fewer characters, technical
+  terms verbatim. Invoke only with /megacave or /caveman wenyan. Stays on until
+  "stop caveman" or "normal mode".
+disable-model-invocation: true
+---
+
+# megacave
+
+以文言答。技術之實皆存，唯贅言去之。
+
+Megacave is caveman in Classical Chinese. 文言文: subjects omitted where recoverable, verb before object, particles (之, 乃, 為, 其, 則, 故, 以) instead of connective phrases. Fewer characters on screen. Token savings are small and noisy; never claim them.
+
+## Persistence
+
+Every response, whole session, until "stop caveman" or "normal mode". Unsure? Still on. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value or say `Caveman mode: unknown`.
+
+## Floor
+
+Never cut or translate: code, commands, paths, API names, error strings, in their original script. Negation (不, 非, 勿, 未, 毋). Numbers and units, Arabic numerals. One term per thing. A clause ambiguous in 文言 becomes 白話.
+
+## Rules
+
+### 1. Classical register
+
+文言, not 白話. Verb before object. Subjects omitted where recoverable.
+
+Bad: "你的組件每次渲染都會重新渲染，因為你每次都創建了新的對象引用。請用 useMemo 包起來。"
+Good: "每繪新生對象參照，故重繪；以 `useMemo` 包之則免。"
+
+### 2. Particles carry structure
+
+One particle, one relation.
+
+Bad: "因為連接池會重複使用已經打開的連接，所以不需要每次請求都新建連接，這樣就省去了握手的開銷。"
+Good: "池蓄已開之連，不逐請而新開，省握手之費。"
+
+### 3. Each fact once
+
+Good: "新參照則重繪。`useMemo` 包之。"
+
+### 4. Payload in original script
+
+Bad: "以記憶化鉤子包之。"
+Good: "以 `useMemo` 包之。"
+
+### 5. Tool runs
+
+One 文言 line in, one out. Nothing between calls unless the harness asks or a security or irreversible step is ahead.
+
+### 6. Never perform
+
+No "文言模式啟", no modern answer plus classical copy. 文言 not shorter than 白話 for a sentence? Use 白話.
+
+## When to break the rules
+
+白話 or the user's language, full sentences, then resume: security warning. Irreversible action, confirm first. Any clause with two readings. User confused. Anything persisted outside chat (code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages; `/caveman-compress` exempt). Harness asks for a status line.
+
+## Pre-send check
+
+Identifiers verbatim, original script? Negations present? Two readings? 白話. Flavor character? Cut.

package/extensions/caveman-session/rule.md

@@ -43,27 +43,14 @@ Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
 |-------|------------|
 | **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
 | **full** | Drop articles, fragments OK, short synonyms. Classic caveman. No tool-call narration, no decorative tables/emoji, no long raw error-log dumps unless asked. Standard acronyms OK; no invented abbreviations |
-| **ultra** | Strip conjunctions when cause-then-effect stay unambiguous. One word when one word enough. State each fact once. NO prose abbreviations (cfg/impl/req/res/fn/auth), NO arrows (X → Y) measured zero token saving under tokenizer, cost decode clarity. Code symbols, function names, API names, error strings: never touch |
-| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
-| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction chars, not tokens. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
-| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
 
 Example "Why React component re-render?"
 - lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
 - full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
-- ultra: "Inline obj prop, new ref, re-render. `useMemo`."
-- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
-- wenyan-full: "每繪新生對象參照，故重繪；以 useMemo 包之則免。"
-- wenyan-ultra: "新參照則重繪。useMemo 包之。"
 
 Example "Explain database connection pooling."
 - lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
 - full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
-- ultra: "Pool reuse open DB connections. No per-request handshake."
-- wenyan-full: "池蓄已開之連，不逐請而新開，省握手之費。"
-- wenyan-ultra: "池蓄連，免逐請新開，省握手。"
-
-Classical chars = wenyan modes only. Never swap a word to a classical char to shrink at non-wenyan levels.
 
 ## Auto-Clarity
 

package/extensions/lib/utils.js

@@ -18,7 +18,8 @@ export function homeDir() {
     return home && home.trim() !== '' ? home : os.homedir();
 }
 export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
-export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/caveman/SKILL.md';
+export const CAVEMAN_REMOTE_ULTRA = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/ultracave/SKILL.md';
+export const CAVEMAN_REMOTE_WENYAN = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/megacave/SKILL.md';
 const RTK_PLATFORM_SPECS = {
     'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip', binary: 'rtk.exe' },
     'linux/x64': { triple: 'x86_64-unknown-linux-musl', ext: '.tar.gz', binary: 'rtk' },

package/extensions/lib/utils.ts

@@ -27,7 +27,8 @@ export function homeDir(): string {
 }
 
 export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
-export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/caveman/SKILL.md';
+export const CAVEMAN_REMOTE_ULTRA = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/ultracave/SKILL.md';
+export const CAVEMAN_REMOTE_WENYAN = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/megacave/SKILL.md';
 
 export interface RtkPlatformSpec {
   triple: string;

package/extensions/opencode/server.js

@@ -6,10 +6,10 @@ import comboToggleExtension from '../combo-toggle/index.js';
 import tersioCommandsExtension from '../tersio-commands/index.js';
 import { getSharedComboState } from '../shared/session-state.js';
 import { formatStatus } from '../shared/status.js';
-// Plain object, not Plugin.define: define is an identity wrapper, and a value
-// import would force every install to vendor the whole @opencode dependency tree.
+import { resolveRtkBinary } from '../lib/utils.js';
+// The npm name, so the plugin list reads the same as the OMP and pi installs.
 const plugin = {
-    id: 'tersio',
+    id: '@krtclcdy/tersio',
     async setup(ctx) {
         // Entries are scoped per session; an unseen ID restores on its first hook.
         const sessions = new Map();
@@ -20,7 +20,10 @@ const plugin = {
             if (own.length)
                 return own;
             // Pre-scoped installs kept one global list; adopt it once, then diverge.
+            // Clear it after adoption so it can never shadow saved defaults later.
             const legacy = (await ctx.storage.get('entries')) ?? [];
+            if (legacy.length)
+                void ctx.storage.set('entries', []).catch(() => { });
             return [...legacy];
         };
         const sessionEntriesOf = (sid) => {
@@ -185,6 +188,33 @@ const plugin = {
             for (const handler of inputHandlers)
                 void handler({ text: event.prompt.text, source: 'interactive' });
         });
+        // rtk has its own OpenCode plugin; doing this here keeps one entry in the plugin list.
+        await ctx.tool.hook('execute.before', async (event) => {
+            const tool = String(event.tool ?? '').toLowerCase();
+            if (tool !== 'bash' && tool !== 'shell')
+                return;
+            const input = event.input;
+            if (typeof input?.command !== 'string' || !input.command)
+                return;
+            const rewritten = await rewriteCommand(input.command);
+            if (rewritten)
+                input.command = rewritten;
+        });
     },
 };
+function rewriteCommand(command) {
+    const bin = resolveRtkBinary();
+    if (!bin)
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        execFile(bin, ['rewrite', command], { timeout: 5000 }, (error, stdout) => {
+            // A kill or timeout means untrustworthy output; pass the command through.
+            const err = error;
+            if (err && (err.killed || err.signal))
+                return resolve(null);
+            const out = String(stdout).trim();
+            resolve(out && out !== command ? out : null);
+        });
+    });
+}
 export default plugin;

package/extensions/opencode/server.ts

@@ -7,6 +7,7 @@ import comboToggleExtension from '../combo-toggle/index.ts';
 import tersioCommandsExtension from '../tersio-commands/index.ts';
 import { getSharedComboState } from '../shared/session-state.ts';
 import { formatStatus } from '../shared/status.ts';
+import { resolveRtkBinary } from '../lib/utils.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 interface CommandConfig {
@@ -27,10 +28,9 @@ interface ToolConfig {
   ) => Promise<{ isError: boolean; content: { type: string; text: string }[]; details: Record<string, unknown> }>;
 }
 
-// Plain object, not Plugin.define: define is an identity wrapper, and a value
-// import would force every install to vendor the whole @opencode dependency tree.
+// The npm name, so the plugin list reads the same as the OMP and pi installs.
 const plugin: Plugin.Plugin = {
-  id: 'tersio',
+  id: '@krtclcdy/tersio',
   async setup(ctx) {
     // Entries are scoped per session; an unseen ID restores on its first hook.
     const sessions = new Map<string, SessionEntry[]>();
@@ -40,7 +40,9 @@ const plugin: Plugin.Plugin = {
       const own = ((await ctx.storage.get(`entries:${sid}`)) as SessionEntry[] | undefined) ?? [];
       if (own.length) return own;
       // Pre-scoped installs kept one global list; adopt it once, then diverge.
+      // Clear it after adoption so it can never shadow saved defaults later.
       const legacy = ((await ctx.storage.get('entries')) as SessionEntry[] | undefined) ?? [];
+      if (legacy.length) void ctx.storage.set('entries', []).catch(() => {});
       return [...legacy];
     };
     const sessionEntriesOf = (sid: string): SessionEntry[] => {
@@ -194,7 +196,31 @@ const plugin: Plugin.Plugin = {
       if (sid) await ensureSession(sid);
       for (const handler of inputHandlers) void handler({ text: event.prompt.text, source: 'interactive' });
     });
+
+    // rtk has its own OpenCode plugin; doing this here keeps one entry in the plugin list.
+    await ctx.tool.hook('execute.before', async (event) => {
+      const tool = String(event.tool ?? '').toLowerCase();
+      if (tool !== 'bash' && tool !== 'shell') return;
+      const input = event.input as { command?: unknown } | null | undefined;
+      if (typeof input?.command !== 'string' || !input.command) return;
+      const rewritten = await rewriteCommand(input.command);
+      if (rewritten) input.command = rewritten;
+    });
   },
 };
 
+function rewriteCommand(command: string): Promise<string | null> {
+  const bin = resolveRtkBinary();
+  if (!bin) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    execFile(bin, ['rewrite', command], { timeout: 5000 }, (error, stdout) => {
+      // A kill or timeout means untrustworthy output; pass the command through.
+      const err = error as { killed?: boolean; signal?: unknown } | null;
+      if (err && (err.killed || err.signal)) return resolve(null);
+      const out = String(stdout).trim();
+      resolve(out && out !== command ? out : null);
+    });
+  });
+}
+
 export default plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.25.0",
+  "version": "2.25.2",
   "description": "✂️ Token saver and usage tracker for coding agents: terse Caveman replies, compact RTK shell output, lean Ponytail code calls, and a gain dashboard — one-command combo presets over one shared extension tree.",
   "keywords": [
     "token-saving",
@@ -119,7 +119,9 @@
     "dashboard/dist/**/*",
     "extensions/**/*.js",
     "extensions/**/*.ts",
-    "extensions/caveman-session/rule.md"
+    "extensions/caveman-session/rule.md",
+    "extensions/caveman-session/rule-ultra.md",
+    "extensions/caveman-session/rule-wenyan.md"
   ],
   "scripts": {
     "clean": "rm -f tersio.js cli/*.js extensions/**/*.js && rm -rf dashboard/dist",