@krtclcdy/tersio 2.25.2 → 2.25.3

package/dist/cli/headroom.js

@@ -0,0 +1,492 @@
+// cli/headroom.ts — the Headroom add-on: bundle, detect, wrap, unwrap, status, doctor facts.
+// Tersio installs the bundle itself; a Headroom the user installed is detected and left alone.
+import { existsSync, promises as fs, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { execFileSync, spawn } from 'node:child_process';
+import { HOME, args, commandArg, dryRun, execP, flagValue, verbose } from './common.js';
+import { detectHosts } from './hosts.js';
+import { installHeadroom, updateHeadroom, removeHeadroomBundle } from './headroom-install.js';
+import { readTextIfExists, resolveHeadroomBinary, sha256File, tersioDataPath } from '../extensions/lib/utils.js';
+import { appendUsage } from '../extensions/shared/usage-ledger.js';
+import { HEADROOM_AGENTS, HEADROOM_INSTALL_HINT, HEADROOM_MIN_VERSION, HEADROOM_TESTED_VERSION, headroomAgentState, headroomCapability, headroomProxyUp, headroomProxyUrl, headroomVersionIssue, headroomWiringPresent, parseHeadroomVersion, readHeadroomConfig, writeHeadroomConfig, } from '../extensions/shared/headroom.js';
+const configHome = () => process.env.XDG_CONFIG_HOME || path.join(HOME, '.config');
+// The spike verified these two rewrites. pi has no wrap entry, so it stays manual.
+export const HEADROOM_ADAPTERS = {
+    omp: {
+        label: 'Oh My Pi',
+        files: () => [path.join(HOME, '.omp', 'agent', 'models.yml')],
+        wrapArgs: () => ['wrap', 'omp', '--prepare-only'],
+        manualHint: '',
+    },
+    opencode: {
+        label: 'OpenCode',
+        files: () => [path.join(configHome(), 'opencode', 'opencode.json')],
+        // No MCP server and no Serena: Headroom's memory features are not part of this add-on.
+        wrapArgs: () => ['wrap', 'opencode', '--prepare-only', '--no-mcp', '--no-serena'],
+        manualHint: '',
+    },
+    pi: {
+        label: 'Pi',
+        files: () => [path.join(HOME, '.pi', 'agent', 'models-store.json')],
+        wrapArgs: () => [],
+        manualHint: 'Pi has no `headroom wrap` entry. Point one model baseUrl at '
+            + `${headroomProxyUrl()}/v1 in ~/.pi/agent/models-store.json, then set HEADROOM_BEACON=off for that session.`,
+    },
+};
+function proxyRecordPath() {
+    return tersioDataPath('headroom-proxy.json', 'tersio-headroom-proxy.json');
+}
+function readProxyRecord() {
+    try {
+        const raw = JSON.parse(readFileSync(proxyRecordPath(), 'utf8'));
+        if (typeof raw.port !== 'number' || typeof raw.pid !== 'number')
+            return null;
+        return { port: raw.port, pid: raw.pid, startedAt: raw.startedAt ?? 0 };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeProxyRecord(record) {
+    try {
+        await fs.mkdir(path.dirname(proxyRecordPath()), { recursive: true });
+        await fs.writeFile(proxyRecordPath(), `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+    }
+    catch { /* best-effort; a missing record only means an orphan proxy */ }
+}
+async function clearProxyRecord() {
+    try {
+        await fs.rm(proxyRecordPath(), { force: true });
+    }
+    catch { /* nothing to clear */ }
+}
+async function waitForProxy(port, timeoutMs = proxyTimeoutMs()) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (await headroomProxyUp(port))
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+}
+/** How long enable polls a freshly started proxy. Overridable so a test or CI run does not wait the full window. */
+function proxyTimeoutMs() {
+    const raw = Number.parseInt(process.env.TERSIO_HEADROOM_PROXY_TIMEOUT_MS ?? '', 10);
+    return Number.isInteger(raw) && raw > 0 ? raw : 6000;
+}
+/** Beacon and update check off: Tersio is local-only, and the user opted into neither. */
+async function startProxy(bin, port) {
+    try {
+        const child = spawn(bin, ['proxy', '--port', String(port)], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env, HEADROOM_BEACON: 'off', HEADROOM_UPDATE_CHECK: 'off' },
+        });
+        child.unref();
+        await writeProxyRecord({ port, pid: child.pid ?? -1, startedAt: Date.now() });
+    }
+    catch (e) {
+        console.log(`  [warn] could not start the Headroom proxy: ${e.message}`);
+        return false;
+    }
+    const up = await waitForProxy(port);
+    if (!up)
+        console.log(`  [warn] the Headroom proxy did not answer on port ${port}.`);
+    return up;
+}
+async function stopProxy() {
+    const record = readProxyRecord();
+    if (record && record.pid > 0) {
+        try {
+            process.kill(record.pid, 'SIGTERM');
+        }
+        catch { /* already gone */ }
+    }
+    await clearProxyRecord();
+}
+function backupStorePath() {
+    return tersioDataPath('headroom-backup.json', 'tersio-headroom-backup.json');
+}
+async function readBackupStore() {
+    const raw = await readTextIfExists(backupStorePath());
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+async function writeBackupRecord(record) {
+    const store = await readBackupStore();
+    store[record.agent] = record;
+    try {
+        await fs.mkdir(path.dirname(backupStorePath()), { recursive: true });
+        await fs.writeFile(backupStorePath(), `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+    }
+    catch { /* best-effort */ }
+}
+async function snapshotAgent(agent) {
+    const files = [];
+    for (const file of HEADROOM_ADAPTERS[agent].files()) {
+        files.push({ path: file, sha256: existsSync(file) ? await sha256File(file).catch(() => null) : null });
+    }
+    const record = { agent, at: Date.now(), files };
+    await writeBackupRecord(record);
+    return record;
+}
+/** True when every snapshot file is back to the hash recorded before the wrap. */
+async function verifyRestore(record) {
+    for (const file of record.files) {
+        if (file.sha256 === null) {
+            if (existsSync(file.path))
+                return false;
+            continue;
+        }
+        if (!existsSync(file.path))
+            return false;
+        if (await sha256File(file.path).catch(() => null) !== file.sha256)
+            return false;
+    }
+    return true;
+}
+// --- headroom binary -------------------------------------------------------------------
+async function headroomVersion(bin) {
+    try {
+        const result = await execP(bin, ['--version'], { timeout: 5000 });
+        return parseHeadroomVersion(result.stdout || result.stderr);
+    }
+    catch (e) {
+        const err = e;
+        return parseHeadroomVersion(err.stdout || err.stderr);
+    }
+}
+/** Sync variant for callers that cannot await (the dashboard's doctor rows). */
+export function headroomVersionSync(bin) {
+    try {
+        return parseHeadroomVersion(execFileSync(bin, ['--version'], { encoding: 'utf8', timeout: 5000 }));
+    }
+    catch (e) {
+        const err = e;
+        return parseHeadroomVersion(err.stdout || err.stderr);
+    }
+}
+/** True when the proxy Tersio started is still running. Sync, so the dashboard can use it inside row building. */
+export function headroomProxyAlive() {
+    const record = readProxyRecord();
+    if (!record || record.pid <= 0)
+        return false;
+    try {
+        process.kill(record.pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The port Tersio recorded for the running proxy, or null when nothing was started. */
+export function headroomProxyPort() {
+    const record = readProxyRecord();
+    return record && record.port > 0 ? record.port : null;
+}
+async function runHeadroomArgv(bin, argv) {
+    try {
+        await execP(bin, argv, { timeout: 60000 });
+        return true;
+    }
+    catch (e) {
+        const err = e;
+        console.log(`  [fail] headroom ${argv.join(' ')}: ${(err.stderr || err.message || '').trim().slice(0, 200)}`);
+        return false;
+    }
+}
+// --- selectors -------------------------------------------------------------------------
+function installedAgents() {
+    const installed = detectHosts().filter((host) => host.installed).map((host) => host.id);
+    const found = HEADROOM_AGENTS.filter((agent) => installed.includes(agent));
+    return found.length > 0 ? found : [...HEADROOM_AGENTS];
+}
+function parseAgentArg() {
+    const raw = flagValue('--agent');
+    if (raw === undefined)
+        return null;
+    const value = raw.trim().toLowerCase();
+    if (HEADROOM_AGENTS.includes(value))
+        return value;
+    console.error(`[fail] Invalid --agent: ${raw}. Valid: ${HEADROOM_AGENTS.join(', ')}`);
+    process.exit(1);
+}
+function selectedAgents(explicit = parseAgentArg()) {
+    if (explicit)
+        return [explicit];
+    if (args.includes('--all'))
+        return [...HEADROOM_AGENTS];
+    return installedAgents();
+}
+// --- enable / disable ------------------------------------------------------------------
+/** What Headroom actually routes for one agent, read from its config. Null when nothing is wired. Only the routed provider is compressed. */
+export function headroomRouteFor(agent, port) {
+    const file = HEADROOM_ADAPTERS[agent].files()[0];
+    let raw;
+    try {
+        if (!existsSync(file))
+            return null;
+        raw = readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    if (agent === 'pi')
+        return 'manual — point one model baseUrl at the proxy';
+    if (agent === 'omp') {
+        const lines = raw.split('\n');
+        const at = lines.findIndex((line) => line.includes(`127.0.0.1:${port}`));
+        if (at === -1)
+            return null;
+        // The wrapped provider is the block that owns the proxy baseUrl.
+        for (let i = at; i >= 0; i -= 1) {
+            const match = /^ {2}([A-Za-z0-9_-]+):\s*$/.exec(lines[i]);
+            if (match)
+                return `providers.${match[1]}.baseUrl`;
+        }
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed.provider?.headroom ? 'provider.headroom — use a headroom/* model' : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The kill switch mirrors the agent flags: on only while at least one agent is wired. */
+function writeAgent(config, agent, enabled, wrappedByTersio) {
+    const agents = { ...config.agents, [agent]: { enabled, wrappedByTersio } };
+    const next = {
+        support: HEADROOM_AGENTS.some((other) => agents[other]?.enabled === true),
+        port: config.port,
+        agents,
+    };
+    writeHeadroomConfig(next);
+    return next;
+}
+async function enableAgent(agent, bin, port) {
+    const config = readHeadroomConfig();
+    const { label, wrapArgs, manualHint } = HEADROOM_ADAPTERS[agent];
+    const current = headroomAgentState(config, agent);
+    const native = headroomCapability(agent) === 'native';
+    if (current.enabled) {
+        console.log(`  [skip] ${label}: already enabled.`);
+        return true;
+    }
+    if (dryRun) {
+        console.log(`  [dry-run] would ${native ? `run headroom ${wrapArgs().join(' ')}` : 'print the manual base URL'}, start the proxy on port ${port}, and record ${label}`);
+        return true;
+    }
+    // Snapshot before the wrap so the hashes prove a byte-identical restore later.
+    const record = await snapshotAgent(agent);
+    if (native && !(await runHeadroomArgv(bin, wrapArgs())))
+        return false;
+    const record2 = readProxyRecord();
+    const alreadyUp = record2 ? await headroomProxyUp(record2.port) : false;
+    const proxyUp = alreadyUp || await startProxy(bin, port);
+    const next = writeAgent(config, agent, true, native);
+    appendUsage('headroom', `enable ${agent}${proxyUp ? '' : ' (proxy down)'}`, { source: 'headroom', agent });
+    console.log(`  [ok] Headroom enabled for ${label} (${native ? 'native wrap' : 'manual base URL'}).`);
+    if (native && headroomWiringPresent(HEADROOM_ADAPTERS[agent].files()))
+        console.log(`  [ok] Wiring present · snapshot ${record.files.length} file(s) recorded.`);
+    console.log(`  [info] Proxy: ${headroomProxyUrl(next.port)} ${proxyUp ? '(up)' : '(DOWN — run: headroom proxy --port ' + next.port + ')'}`);
+    console.log('  [info] Beacon off, update check off.');
+    console.log('  [info] Tersio leaves HEADROOM_OUTPUT_SHAPER unset: Caveman owns terse output.');
+    if (!native)
+        console.log(`  [manual] ${manualHint}`);
+    console.log(`  [info] Headroom sees prompts and tool output on loopback. It is a separate process Tersio starts and stops.`);
+    return true;
+}
+async function disableAgent(agent, bin) {
+    const config = readHeadroomConfig();
+    const { label } = HEADROOM_ADAPTERS[agent];
+    const current = headroomAgentState(config, agent);
+    if (!current.enabled) {
+        console.log(`  [skip] ${label}: already off.`);
+        return true;
+    }
+    if (dryRun) {
+        console.log(`  [dry-run] would ${current.wrappedByTersio ? `run headroom unwrap ${agent}` : 'clear the manual flag'}, verify the snapshot, and stop the proxy when no agent remains`);
+        return true;
+    }
+    const store = await readBackupStore();
+    const record = store[agent];
+    // Another agent on the same proxy must keep it, so its unwrap may not stop the proxy.
+    const othersEnabled = HEADROOM_AGENTS.some((other) => other !== agent && headroomAgentState(config, other).enabled);
+    if (current.wrappedByTersio) {
+        if (!bin) {
+            console.log(`  [fail] ${label}: the headroom binary is missing, so unwrap cannot run.`);
+            return false;
+        }
+        const unwrapArgs = ['unwrap', agent, ...(othersEnabled ? ['--no-stop-proxy'] : [])];
+        if (!(await runHeadroomArgv(bin, unwrapArgs)))
+            return false;
+        if (record && !(await verifyRestore(record))) {
+            console.log(`  [warn] ${label}: the config did not return to its recorded hash.`);
+            console.log(`  [hint] headroom keeps its own copy at ${HEADROOM_ADAPTERS[agent].files()[0]}.headroom-backup`);
+            return false;
+        }
+        console.log(`  [ok] ${label}: restored${record ? ' byte-identical' : ''}.`);
+    }
+    else {
+        console.log(`  [ok] ${label}: manual flag cleared. Tersio never edited its config.`);
+    }
+    const next = writeAgent(config, agent, false, false);
+    const stillEnabled = HEADROOM_AGENTS.some((other) => headroomAgentState(next, other).enabled);
+    if (!stillEnabled)
+        await stopProxy();
+    appendUsage('headroom', `disable ${agent}`, { source: 'headroom', agent });
+    return true;
+}
+// --- reporting -------------------------------------------------------------------------
+async function statusReport() {
+    const bin = resolveHeadroomBinary();
+    const version = bin ? await headroomVersion(bin) : null;
+    const config = readHeadroomConfig();
+    const up = await headroomProxyUp(config.port);
+    console.log('\n=== Tersio Headroom ===');
+    console.log(`  Binary:  ${bin ? `${bin}${version ? ` ${version}` : ''}` : `not found — ${HEADROOM_INSTALL_HINT}`}`);
+    console.log(`  Support: ${config.support ? 'on' : 'off'}`);
+    console.log(`  Proxy:   ${headroomProxyUrl(config.port)} ${up ? '(up)' : '(down)'}`);
+    for (const agent of HEADROOM_AGENTS) {
+        const state = headroomAgentState(config, agent);
+        const kind = headroomCapability(agent);
+        const how = state.wrappedByTersio ? 'wrapped by tersio' : kind;
+        console.log(`  —  ${HEADROOM_ADAPTERS[agent].label}: ${state.enabled ? `enabled (${how})` : 'off'}`);
+    }
+}
+/** The data doctor renders; it makes no decision of its own. */
+export async function headroomFacts() {
+    const bin = resolveHeadroomBinary();
+    const version = bin ? await headroomVersion(bin) : null;
+    const config = readHeadroomConfig();
+    const wiring = {};
+    for (const agent of HEADROOM_AGENTS) {
+        if (!headroomAgentState(config, agent).enabled)
+            continue;
+        wiring[agent] = headroomWiringPresent(HEADROOM_ADAPTERS[agent].files());
+    }
+    return { bin, version, issue: headroomVersionIssue(version), proxyUp: await headroomProxyUp(config.port), config, wiring };
+}
+// --- uninstall hooks -------------------------------------------------------------------
+export async function headroomUnwrapAgents(agents) {
+    const config = readHeadroomConfig();
+    const bin = resolveHeadroomBinary();
+    for (const agent of agents) {
+        if (headroomAgentState(config, agent).wrappedByTersio)
+            await disableAgent(agent, bin);
+    }
+}
+/** Unwraps every agent Tersio wrapped. A manual agent is only unflagged. */
+export async function headroomUnwrapConfigured() {
+    await headroomUnwrapAgents([...HEADROOM_AGENTS]);
+}
+/** Removes the Tersio-owned bundle once no agent is left enabled, so uninstalling one host cannot break another agent's proxy. */
+export async function headroomRemoveBundleIfUnused(options = {}) {
+    const config = readHeadroomConfig();
+    if (HEADROOM_AGENTS.some((agent) => headroomAgentState(config, agent).enabled))
+        return false;
+    return removeHeadroomBundle(options);
+}
+/** Removes the binary only when the user asks for it. D4: Tersio mirrors `--remove-rtk`. */
+export async function removeHeadroomBinary() {
+    const bin = resolveHeadroomBinary();
+    if (!bin)
+        return true;
+    try {
+        await fs.rm(bin, { force: true });
+        console.log(`  [ok] removed ${bin}`);
+        return true;
+    }
+    catch (e) {
+        console.log(`  [fail] could not remove ${bin}: ${e.message}`);
+        return false;
+    }
+}
+// --- command ---------------------------------------------------------------------------
+function subcommand() {
+    const at = args.indexOf(commandArg ?? '');
+    const next = at >= 0 ? args[at + 1] : undefined;
+    if (!next || next.startsWith('-'))
+        return 'status';
+    return next.toLowerCase();
+}
+function usage() {
+    console.log('  Usage: tersio headroom <install|enable|disable|status|update> [--agent omp|pi|opencode|--all] [--dry-run]');
+}
+/** Enable or disable with every precheck, for callers that want a boolean instead of an exit code (the dashboard HTTP routes). */
+export async function headroomAction(sub, agent = null) {
+    let bin = resolveHeadroomBinary();
+    // Only enable needs the binary: disabling a manual flag is a file write, and a wrapped agent still needs its unwrap.
+    if (sub === 'enable' && !bin) {
+        // The bundle is Tersio's to provide, so enable installs it rather than sending the user to a Python tool.
+        console.log('  [info] Headroom is not installed yet — building the Tersio bundle.');
+        const installed = await installHeadroom({ dryRun, verbose });
+        if (!installed.ok) {
+            console.log(`  [fail] ${installed.detail}`);
+            return false;
+        }
+        bin = resolveHeadroomBinary();
+        if (!bin && !dryRun) {
+            console.log(`  [fail] Headroom installed, but no entrypoint resolved.`);
+            return false;
+        }
+    }
+    const version = bin ? await headroomVersion(bin) : null;
+    const issue = headroomVersionIssue(version);
+    if (sub === 'enable' && issue === 'old') {
+        console.log(`  [fail] Headroom ${version} is older than the supported ${HEADROOM_MIN_VERSION}. Update it, then retry.`);
+        return false;
+    }
+    if (sub === 'enable' && issue === 'newer') {
+        console.log(`  [warn] Headroom ${version} is newer than the tested ${HEADROOM_TESTED_VERSION}. Tersio tests the pinned range only.`);
+    }
+    const port = readHeadroomConfig().port;
+    const targets = agent ? [agent] : selectedAgents();
+    let ok = true;
+    for (const target of targets) {
+        ok = (sub === 'enable' ? await enableAgent(target, bin ?? 'headroom', port) : await disableAgent(target, bin)) && ok;
+    }
+    return ok;
+}
+/** One entry point for the CLI and the interactive menu: an explicit subcommand, plus an optional single agent. */
+export async function runHeadroomCommand(sub, agent = null) {
+    if (!['enable', 'disable', 'status', 'install', 'update'].includes(sub)) {
+        console.error(`[fail] Unknown headroom subcommand: ${sub}`);
+        usage();
+        process.exitCode = 1;
+        return;
+    }
+    if (sub === 'status') {
+        await statusReport();
+        return;
+    }
+    if (sub === 'install' || sub === 'update') {
+        const result = sub === 'install'
+            ? await installHeadroom({ dryRun, verbose })
+            : await updateHeadroom({ dryRun, verbose });
+        if (result.ok)
+            console.log(`  [ok] Headroom ${result.version ?? ''} → ${result.bin} (${result.detail})`);
+        else {
+            console.log(`  [fail] ${result.detail}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (!(await headroomAction(sub, agent)))
+        process.exitCode = 1;
+}
+export async function runHeadroom() {
+    await runHeadroomCommand(subcommand(), parseAgentArg());
+}

package/{cli → dist/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_ULTRA, CAVEMAN_REMOTE_WENYAN, 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_MEGACAVE, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, findPackageRoot, httpsDownload, parseChecksum, piAgentDir, readTextIfExists, resolveRtkBinary, ruleBodyProblem, 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';
@@ -357,10 +357,11 @@ async function stepRtkSession(extDir, options) {
     await copySources(extDir, filesUnder('rtk-session'), 'rtk-session/index.ts', options);
 }
 // rule.md ships with the package; the other bodies track upstream skills.
+// rule.md is a deliberate fork of upstream skills/caveman/SKILL.md; a blind sync would drop the mode switch line and the STE100 rules.
 const CAVEMAN_RULES = [
     ['rule.md', null],
     ['rule-ultra.md', CAVEMAN_REMOTE_ULTRA],
-    ['rule-wenyan.md', CAVEMAN_REMOTE_WENYAN],
+    ['rule-megacave.md', CAVEMAN_REMOTE_MEGACAVE],
 ];
 async function stepCaveman(extDir, options) {
     if (!options.quiet)
@@ -373,7 +374,14 @@ async function stepCaveman(extDir, options) {
         let rule = bundled;
         if (remote && !options.dryRun) {
             try {
-                rule = await withInteractiveSpinner(`Fetching Caveman ${name}`, () => httpsGet(remote));
+                const fetched = await withInteractiveSpinner(`Fetching Caveman ${name}`, () => httpsGet(remote));
+                const problem = ruleBodyProblem(fetched);
+                if (problem && bundled !== null) {
+                    sayTagged(`  [warn] ${name} fetch rejected (${problem}) — keeping the bundled body`);
+                    rule = bundled;
+                }
+                else
+                    rule = fetched;
             }
             catch (e) {
                 if (bundled === null)
@@ -392,6 +400,9 @@ async function stepCaveman(extDir, options) {
         }
     }
     await copySources(extDir, filesUnder('caveman-session').filter(([, to]) => to.endsWith('index.ts')), 'caveman-session/index.ts', options);
+    // Renamed body: drop the stale copy an older install left behind.
+    if (!options.dryRun)
+        await fs.rm(path.join(cavemanDir, 'rule-wenyan.md'), { force: true });
 }
 async function stepTersioCommands(extDir, options) {
     if (!options.quiet)
@@ -413,7 +424,7 @@ const PONYTAIL_BUNDLE_FILES = [
     'skills/ponytail/SKILL.md',
 ];
 async function stepPonytailBundle(treeDir, options) {
-    const root = findHoistedPackage('@dietrichgebert/ponytail', path.dirname(fileURLToPath(import.meta.url)));
+    const root = findHoistedPackage('@dietrichgebert/ponytail', findPackageRoot(path.dirname(fileURLToPath(import.meta.url))));
     if (!root) {
         if (!options.quiet)
             console.log('  [skip] Ponytail package not found next to the CLI — OpenCode keeps the built-in text');
@@ -474,7 +485,7 @@ async function stepOpencode(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.
+    // The chosen preset owns all three modes.
     let comboChosen = comboDefaultFlag !== undefined;
     if (tty() && !profileFlagsGiven && !applyUpdate) {
         const choice = await askInteractiveChoice('Session-start defaults — Combo preset', [
@@ -661,13 +672,14 @@ const PI_PONYTAIL_FILES = [
     'pi-extension/index.js',
     'hooks/ponytail-instructions.js',
     'hooks/ponytail-config.js',
-    'skills/ponytail/SKILL.md',
+    ...['ponytail', 'ponytail-audit', 'ponytail-debt', 'ponytail-gain', 'ponytail-help', 'ponytail-review']
+        .map((skill) => `skills/${skill}/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 — write the local pi package');
-    const root = findHoistedPackage('@dietrichgebert/ponytail', path.dirname(fileURLToPath(import.meta.url)));
+    const root = findHoistedPackage('@dietrichgebert/ponytail', findPackageRoot(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');

package/{cli → dist/cli}/manifest.js

@@ -1,7 +1,8 @@
 // Single list of install writes, shared by installer, doctor, and tests.
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-export const EXT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
+import { findPackageRoot } from '../extensions/lib/utils.js';
+export const EXT_DIR = path.join(findPackageRoot(path.dirname(fileURLToPath(import.meta.url))), 'extensions');
 /** Root entrypoint OpenCode resolves for the installed tree; re-exports the versioned entry beside it. Built by join so the path never reads as a relative import (repo-integrity scans literals). */
 const SERVER_SPEC = `./${['opencode', 'server.ts'].join('/')}`;
 export const OPENCODE_SERVER_SHIM = `// Generated by \`tersio install --host opencode\`: OpenCode resolves <pluginDir>/server.ts.
@@ -21,7 +22,7 @@ export const TREE_FILES = [
     'caveman-session/index.ts',
     'caveman-session/rule.md',
     'caveman-session/rule-ultra.md',
-    'caveman-session/rule-wenyan.md',
+    'caveman-session/rule-megacave.md',
     'rtk-session/index.ts',
     'combo-toggle/index.ts',
     'tersio-commands/index.ts',

package/{cli → dist/cli}/settings.js

@@ -1,6 +1,6 @@
 // cli/settings.ts — view/edit session-start defaults and the display currency.
-import path from 'node:path';
-import { CAVEMAN_DEFAULTS, COMBO_DEFAULTS, COMBO_PRESET_MODES, OMP_PLUGINS_DIR, PACKAGE_NAME, PONYTAIL_DEFAULTS, cavemanDefaultFlag, comboDefaultFlag, currency, currencyGiven, diagScheduleFlag, dryRun, ponytailDefaultFlag, profileFlagsGiven, rtkDefaultFlag, settingArg, subagentMarkerFlags, subagentMarkersGiven, } from './common.js';
+import { CAVEMAN_DEFAULTS, COMBO_DEFAULTS, COMBO_PRESET_MODES, PONYTAIL_DEFAULTS, cavemanDefaultFlag, comboDefaultFlag, currency, currencyGiven, diagScheduleFlag, dryRun, ponytailDefaultFlag, profileFlagsGiven, rtkDefaultFlag, settingArg, subagentMarkerFlags, subagentMarkersGiven, } from './common.js';
+import { tersioSettingsFile } from '../extensions/shared/plugin-settings.js';
 import { CURRENCY_CODES } from './currency.js';
 import { textTable } from './usage.js';
 import { ask, askInteractiveChoice, closeRL, tty } from './interactive.js';
@@ -45,25 +45,6 @@ async function askProfile(current) {
         backupSchedule: current.backupSchedule,
         subagentMarkers: current.subagentMarkers,
     };
-    const caveman = await askInteractiveChoice('Caveman default', [...CAVEMAN_DEFAULTS].map((v) => ({
-        value: v, label: v,
-    })), next.cavemanDefault);
-    if (caveman.status !== 'selected')
-        return null;
-    next.cavemanDefault = caveman.value;
-    const rtk = await askInteractiveChoice('RTK default', [
-        { value: 'on', label: 'on' },
-        { value: 'off', label: 'off' },
-    ], next.rtkDefault ? 'on' : 'off');
-    if (rtk.status !== 'selected')
-        return null;
-    next.rtkDefault = rtk.value === 'on';
-    const ponytail = await askInteractiveChoice('Ponytail default', [...PONYTAIL_DEFAULTS].map((v) => ({
-        value: v, label: v,
-    })), next.ponytailDefault);
-    if (ponytail.status !== 'selected')
-        return null;
-    next.ponytailDefault = ponytail.value;
     const cur = await askInteractiveChoice('Display currency (usage/dashboard reports)', CURRENCY_CODES.map((v) => ({
         value: v, label: v,
     })), next.currency);
@@ -103,7 +84,7 @@ async function askDiagSchedule(current) {
 }
 const SETTING_NAMES = ['combo', 'caveman', 'rtk', 'ponytail', 'currency', 'diagnosis', 'markers'];
 function settingsUsage() {
-    console.log('  Usage: tersio settings [combo|caveman|rtk|ponytail|currency|diagnosis|markers] [--combo-default off|medium|balanced|max] [--caveman-default off|lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra] [--rtk-default on|off] [--ponytail-default off|lite|full|ultra] [--currency USD|PHP|EUR|GBP|JPY|KRW|SGD|AUD|CAD|INR] [--diag-schedule manual|daily|weekly|monthly] [--subagent-marker <text>]... [--dry-run]');
+    console.log('  Usage: tersio settings [combo|caveman|rtk|ponytail|currency|diagnosis|markers] [--combo-default off|medium|balanced|max] [--caveman-default off|lite|full|ultra|megacave-lite|megacave-full|megacave-ultra] [--rtk-default on|off] [--ponytail-default off|lite|full|ultra] [--currency USD|PHP|EUR|GBP|JPY|KRW|SGD|AUD|CAD|INR] [--diag-schedule manual|daily|weekly|monthly] [--subagent-marker <text>]... [--dry-run]');
 }
 // Single-setting jump: `tersio settings diagnosis` prompts only that value instead of walking the whole chain. Returns false when aborted.
 async function runSingleSetting(name, current, nextDiag) {
@@ -198,7 +179,8 @@ function printSettingsTable(current) {
     for (const l of textTable(['Setting', 'Current', 'Valid values'], rows, [false, false, false], 64)) {
         console.log(l);
     }
-    console.log(`  Stored: ${PACKAGE_NAME} in ${path.join(OMP_PLUGINS_DIR, 'omp-plugins.lock.json')}`);
+    console.log(`  Stored: ${tersioSettingsFile()}`);
+    console.log(`  Combo ${current.comboDefault} sets caveman/rtk/ponytail. Tune one: tersio settings <name>`);
 }
 async function runSettings() {
     const current = await storedProfile();

package/{cli → dist/cli}/uninstall.js

@@ -290,7 +290,7 @@ async function runUninstall(options = {}) {
     }
     // Cleared last: writeConfigLines above would just make a fresh one.
     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')]) {
+    for (const backup of [`${configPath}.bak`, path.join(cavemanDir, 'rule.md.bak'), path.join(cavemanDir, 'rule-ultra.md.bak'), path.join(cavemanDir, 'rule-megacave.md.bak')]) {
         await removeUninstallTarget(backup, shouldDryRun, false);
     }
     // Remove the bundled Ponytail copy; its config.yml entry is already filtered.