@krtclcdy/tersio 2.20.0 → 2.21.0

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

@@ -0,0 +1,331 @@
+// OMP extension: /ai-addons manual updater for Ponytail, RTK, Caveman.
+// Built-in Node modules only. Default off; registers a single slash command.
+// ponytail: `skipped: none` — semantics match one-liner: fetch + compare + run install.
+// rtk: `skipped: signature verification` — checksums.txt ships only SHA256 of release assets; add sigchain when upstream publishes a signing key.
+// caveman: `skipped: none` — exactly the ask: write rule.md, report old/new hash.
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE, RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, rtkPlatformSpec, } from '../lib/utils.js';
+const IS_WINDOWS = process.platform === 'win32';
+const HOME = os.homedir();
+const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
+const PONYTAIL_NPM_SPEC = '@dietrichgebert/ponytail@latest';
+const PONYTAIL_LOCAL = path.join(HOME, '.omp', 'plugins', 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
+const RTK_BINARY = path.join(HOME, '.bun', 'bin', IS_WINDOWS ? 'rtk.exe' : 'rtk');
+const CAVEMAN_LOCAL = path.join(HOME, '.omp', 'agent', 'extensions', 'caveman-session', 'rule.md');
+const RELOAD_MSG = 'Reminder: restart OMP (or reload extensions) for updates to take effect.';
+function notify(ctx, msg, level) {
+    ctx?.ui?.notify?.(String(msg), level);
+}
+function report(ctx, msg, level) {
+    notify(ctx, msg, level);
+    return msg;
+}
+function shortHash(text) {
+    return sha256Hex(text).slice(0, 16);
+}
+function checkFailed(name, e) {
+    return { text: `${name} check failed: ${e.message}`, level: 'warning' };
+}
+// Single error-handling source for the three probes; messages unchanged.
+function runCheck(name, probe) {
+    return probe().then((text) => ({ text, level: 'info' }), (e) => checkFailed(name, e));
+}
+// Check: no mutation. Probes run concurrently via checkAddons below.
+function checkPonytail() {
+    return runCheck('Ponytail', async () => {
+        const remoteJson = await fetchJson(PONYTAIL_REMOTE);
+        const localRaw = await readTextIfExists(PONYTAIL_LOCAL);
+        const localVer = localRaw ? JSON.parse(localRaw).version ?? null : null;
+        const remoteVer = remoteJson.version;
+        const status = !localVer ? 'not installed'
+            : localVer === remoteVer ? 'up to date'
+                : 'update available';
+        return `Ponytail ${status}: local=${localVer || '—'} latest=${remoteVer}`;
+    });
+}
+async function fetchRelease() {
+    return fetchJson(RTK_RELEASE_API);
+}
+function checkRtk() {
+    return runCheck('RTK', async () => {
+        const release = await fetchRelease();
+        const latestTag = release.tag_name || null;
+        let localVer = null;
+        try {
+            const out = execFileSync(RTK_BINARY, ['--version'], { encoding: 'utf8', windowsHide: true, shell: false, timeout: 10000 }) || '';
+            if (out)
+                localVer = out.trim().split(/\r?\n/)[0];
+        }
+        catch {
+            localVer = null;
+        }
+        const status = localVer === null ? 'not installed'
+            : normalizeRtkVersion(localVer) === normalizeRtkVersion(latestTag ?? undefined) ? 'up to date'
+                : 'update available';
+        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}`;
+    });
+}
+export async function checkAddonsSummary(ctx) {
+    return checkAddons(ctx);
+}
+export async function runAddonUpdate(pi, ctx, target, dryRun = false) {
+    const results = [];
+    const updaters = {
+        ponytail: () => updatePonytail(pi, ctx, dryRun),
+        rtk: () => updateRtk(ctx, dryRun),
+        caveman: () => updateCaveman(ctx, dryRun),
+    };
+    if (target === 'all') {
+        notify(ctx, `ai-addons update all${dryRun ? ' dry-run' : ''}: starting ponytail → rtk → caveman sequentially…`, 'info');
+        for (const name of ['ponytail', 'rtk', 'caveman'])
+            results.push(await updaters[name]());
+        if (!dryRun)
+            results.push(RELOAD_MSG);
+        notify(ctx, `ai-addons update all ${dryRun ? 'dry-run ' : ''}complete.${dryRun ? '' : ` ${RELOAD_MSG}`}`, 'info');
+    }
+    else if (Object.hasOwn(updaters, target)) {
+        results.push(await updaters[target]());
+    }
+    else {
+        const m = 'Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]';
+        return report(ctx, m, 'warning');
+    }
+    return results.join('\n\n');
+}
+async function checkAddons(ctx) {
+    const [ponytail, rtk, caveman] = await Promise.all([checkPonytail(), checkRtk(), checkCaveman()]);
+    const lines = [];
+    for (const status of [ponytail, rtk, caveman]) {
+        lines.push(status.text);
+        notify(ctx, status.text, status.level);
+    }
+    return lines.join('\n');
+}
+async function updatePonytail(pi, ctx, dryRun = false) {
+    const pluginsDir = path.join(HOME, '.omp', 'plugins');
+    if (dryRun) {
+        const m = `Ponytail dry-run: would run \`npm install ${PONYTAIL_NPM_SPEC} --save --no-audit --no-fund\` in ${pluginsDir}.`;
+        return report(ctx, m, 'info');
+    }
+    notify(ctx, 'Ponytail: ensuring plugin directory exists…', 'info');
+    try {
+        await fs.mkdir(pluginsDir, { recursive: true });
+    }
+    catch (e) {
+        const m = `Ponytail update failed: failed to create ${pluginsDir}: ${e.message}`;
+        return report(ctx, m, 'warning');
+    }
+    if (!pi.exec) {
+        const m = 'Ponytail update failed: extension host does not provide exec';
+        return report(ctx, m, 'warning');
+    }
+    notify(ctx, 'Ponytail: running npm install…', 'info');
+    let out = '';
+    try {
+        const r = await pi.exec('npm', ['install', PONYTAIL_NPM_SPEC, '--save', '--no-audit', '--no-fund'], { cwd: pluginsDir });
+        out = [r.stdout, r.stderr].filter(Boolean).join('\n').trim();
+        if (r.code !== 0)
+            throw new Error(r.stderr || `npm exited ${r.code}`);
+    }
+    catch (e) {
+        const m = `Ponytail update failed: ${e.message}`;
+        return report(ctx, m, 'warning');
+    }
+    const m = `Ponytail update finished.${out ? `\n${out}` : ''}\n${RELOAD_MSG}`;
+    notify(ctx, 'Ponytail update finished. ' + RELOAD_MSG, 'info');
+    return m;
+}
+async function updateRtk(ctx, dryRun = false) {
+    let release;
+    try {
+        release = await fetchRelease();
+    }
+    catch (e) {
+        const m = `RTK: cannot fetch release info: ${e.message}`;
+        return report(ctx, m, 'warning');
+    }
+    const tag = release.tag_name || 'unknown';
+    const assets = Array.isArray(release.assets) ? release.assets : [];
+    // Cross-platform asset selection (mirrors installer stepRtk)
+    const PLATFORM = process.platform;
+    const ARCH = process.arch;
+    const spec = rtkPlatformSpec(PLATFORM, ARCH);
+    if (!spec) {
+        const m = `RTK: unsupported platform ${PLATFORM}/${ARCH}`;
+        return report(ctx, m, 'warning');
+    }
+    const { triple: assetTriple, ext: assetExt, binary: binaryName } = spec;
+    const asset = assets.find((a) => a.name === `rtk-${assetTriple}${assetExt}`);
+    const checksAsset = assets.find((a) => a.name === 'checksums.txt');
+    if (!asset || !checksAsset) {
+        const m = `RTK: required assets not found in release ${tag} (need rtk-${assetTriple}${assetExt} and checksums.txt)`;
+        return report(ctx, m, 'warning');
+    }
+    if (dryRun) {
+        const m = `RTK dry-run: would download ${asset.name} (${tag}), verify checksums.txt, and replace ${RTK_BINARY}.`;
+        return report(ctx, m, 'info');
+    }
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'rtk-update-'));
+    const archivePath = path.join(tmp, asset.name);
+    const checksPath = path.join(tmp, 'checksums.txt');
+    try {
+        notify(ctx, `RTK: downloading ${asset.name} (${tag})…`, 'info');
+        notify(ctx, 'RTK: downloading checksums.txt…', 'info');
+        await Promise.all([
+            httpsDownload(asset.browser_download_url, archivePath),
+            httpsDownload(checksAsset.browser_download_url, checksPath),
+        ]);
+        // Verify SHA256 against checksums.txt
+        const checks = await fs.readFile(checksPath, 'utf8');
+        const expected = parseChecksum(checks, asset.name);
+        if (!expected) {
+            const m = `RTK: checksums.txt has no entry for ${asset.name}`;
+            return report(ctx, m, 'warning');
+        }
+        const archiveBuf = await fs.readFile(archivePath);
+        const actual = createHash('sha256').update(archiveBuf).digest('hex').toLowerCase();
+        if (actual !== expected) {
+            const m = `RTK: checksum mismatch! expected=${expected.slice(0, 12)}… actual=${actual.slice(0, 12)}…`;
+            return report(ctx, m, 'warning');
+        }
+        notify(ctx, 'RTK: checksum verified.', 'info');
+        // Extract by archive format
+        const extractDir = path.join(tmp, 'extracted');
+        await fs.mkdir(extractDir, { recursive: true });
+        if (asset.name.endsWith('.zip')) {
+            if (IS_WINDOWS) {
+                execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+                    `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${extractDir}' -Force`], { encoding: 'utf8', windowsHide: true, shell: false });
+            }
+            else {
+                execFileSync('unzip', [archivePath, '-d', extractDir], { encoding: 'utf8', shell: false });
+            }
+        }
+        else if (asset.name.endsWith('.tar.gz') || asset.name.endsWith('.tgz')) {
+            try {
+                execFileSync('tar', ['xzf', archivePath, '-C', extractDir], { encoding: 'utf8', shell: false });
+            }
+            catch (e) {
+                throw new Error(`tar could not extract ${asset.name}: ${e.message}`);
+            }
+        }
+        else {
+            throw new Error(`Unknown archive format: ${asset.name}`);
+        }
+        const rtkExtracted = await findFile(extractDir, binaryName);
+        if (!rtkExtracted) {
+            const m = `RTK: ${binaryName} not found in extracted archive`;
+            return report(ctx, m, 'warning');
+        }
+        await fs.mkdir(path.dirname(RTK_BINARY), { recursive: true });
+        const backupPath = `${RTK_BINARY}.bak`;
+        const backedUp = await fs.copyFile(RTK_BINARY, backupPath).then(() => true, () => false);
+        await fs.copyFile(rtkExtracted, RTK_BINARY);
+        // Set executable bit on Unix
+        if (!IS_WINDOWS) {
+            await fs.chmod(RTK_BINARY, 0o755);
+        }
+        let versionOut = '';
+        try {
+            versionOut = execFileSync(RTK_BINARY, ['--version'], { encoding: 'utf8', windowsHide: true, shell: false, timeout: 10000 }).trim();
+        }
+        catch (e) {
+            if (backedUp)
+                await fs.copyFile(backupPath, RTK_BINARY);
+            throw new Error(`new ${binaryName} failed --version${backedUp ? '; restored backup' : ''}: ${e.message}`);
+        }
+        if (normalizeRtkVersion(versionOut) !== normalizeRtkVersion(tag)) {
+            if (backedUp)
+                await fs.copyFile(backupPath, RTK_BINARY);
+            throw new Error(`new ${binaryName} reports ${versionOut}, expected ${tag}${backedUp ? '; restored backup' : ''}`);
+        }
+        const m = `RTK updated to ${tag} → ${RTK_BINARY}\nbackup=${backedUp ? backupPath : '—'}\n${RELOAD_MSG}`;
+        notify(ctx, 'RTK update finished. ' + RELOAD_MSG, 'info');
+        return m;
+    }
+    catch (e) {
+        const m = `RTK update failed: ${e.message}`;
+        return report(ctx, m, 'warning');
+    }
+    finally {
+        fs.rm(tmp, { recursive: true, force: true }).catch(() => { });
+    }
+}
+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) {
+            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' : ''}`);
+        }
+        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');
+    }
+}
+export default function aiAddonsUpdaterExtension(pi) {
+    pi.setLabel?.('AI add-ons updater');
+    pi.registerCommand?.('ai-addons', {
+        description: 'Check or update AI add-ons (ponytail/rtk/caveman/all). Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]',
+        handler: async (args, ctx) => {
+            const arg = String(args || '').trim().toLowerCase();
+            const parts = arg.split(/\s+/).filter(Boolean);
+            const dryRun = parts.includes('--dry-run') || parts.includes('dry-run');
+            const cleanParts = parts.filter((p) => p !== '--dry-run' && p !== 'dry-run');
+            const sub = cleanParts[0];
+            if (sub === 'check' || sub === 'status') {
+                const summary = await checkAddons(ctx);
+                notify(ctx, 'ai-addons check complete.', 'info');
+                return summary;
+            }
+            if (sub === 'update' && cleanParts[1]) {
+                return runAddonUpdate(pi, ctx, cleanParts.slice(1).join(' '), dryRun);
+            }
+            const m = 'Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]';
+            return report(ctx, m, 'warning');
+        },
+    });
+}
+export { parseChecksum };

package/extensions/caveman-session/index.js

@@ -0,0 +1,152 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.js';
+import { dirname, join } from 'node:path';
+import { readCavemanDefault } from '../shared/plugin-settings.js';
+const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
+const RULE_PATH = join(CAVERN_DIR, 'rule.md');
+const FALLBACK_FULL_RULE = `Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+Rules:
+- Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging.
+- Fragments OK. Short synonyms. Technical terms exact. Code unchanged.
+- Pattern: [thing] [action] [reason]. [next step].
+- Not: 'Sure! I'd be happy to help you with that.'
+- Yes: 'Bug in auth middleware. Fix:'
+
+Auto-clarity: drop caveman for security warnings, irreversible actions, or when user seems confused. Resume after.`;
+// ponytail: synchronous read each full-mode injection; ceiling = small file, cold session start. Upgrade path: cache file contents + mtime, invalidate on change.
+function readFullRule() {
+    try {
+        return readFileSync(RULE_PATH, 'utf8');
+    }
+    catch {
+        return FALLBACK_FULL_RULE;
+    }
+}
+const DEFAULT_MODE = 'off';
+const INSTRUCTIONS = {
+    lite: `Caveman lite active for this session.
+Respond concise. Drop pleasantries, filler, and hedging. Keep complete technical substance. Code, commands, paths, errors, commits, and PR text stay normal/exact.`,
+    full: () => `Caveman full active for this session.\n${readFullRule()}`,
+    ultra: `Caveman ultra active for this session.
+Maximum terse prose. Fragments preferred. No pleasantries, no tour, no recap unless needed. Keep all technical substance exact. Code, commands, commits, PR text, paths, and errors stay normal/exact. Drop caveman for security warnings, irreversible actions, or user confusion.`,
+    wenyan: `Caveman wenyan active for this session.
+Use ultra-terse classical-Chinese-style prose only where it preserves clarity for the user. Keep technical terms, code, commands, commits, PR text, paths, and errors exact. If clarity would suffer, use caveman full instead.`,
+};
+function resolveMode(entries, fallback = DEFAULT_MODE) {
+    return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
+}
+function isOffCommand(text) {
+    const t = normalizeInputCommand(text);
+    return t === 'stop caveman' || t === 'normal mode' || t === 'caveman off';
+}
+export default function cavemanSessionExtension(pi) {
+    let currentMode = DEFAULT_MODE;
+    let isActive = false;
+    let lastCtx = undefined;
+    function syncStatus(ctx) {
+        lastCtx = paintableCtx(lastCtx, ctx);
+        const c = lastCtx;
+        if (!c?.ui?.setStatus)
+            return;
+        // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
+        if (isComboPresetActive() || currentMode === 'off') {
+            c.ui.setStatus('caveman', undefined);
+            return;
+        }
+        paintStatusBar(c.ui, 'caveman', '🪨', `caveman: ${currentMode.toUpperCase()}`, isActive);
+    }
+    function setMode(mode, ctx) {
+        const normalized = normalizeMode('caveman', mode);
+        if (!normalized)
+            return false;
+        currentMode = normalized;
+        pi.appendEntry?.('caveman-mode', { mode: normalized });
+        setSharedComboMode('caveman', normalized);
+        syncStatus(ctx);
+        const active = activeModesSummary(getSharedComboState());
+        const msg = normalized === 'off'
+            ? `Caveman off. Active: ${active}.`
+            : `Caveman ${normalized} on — terse replies for this session. Active: ${active}.`;
+        ctx?.ui?.notify?.(msg, 'info');
+        return true;
+    }
+    pi.setLabel?.('Caveman session toggle');
+    // Live mirror: a /tersio or /combo switch publishes shared state — adopt
+    // it at once so the next turn injects the new mode with no session reload.
+    // Stable identity, so the bridge set dedupes across re-inits.
+    function syncFromShared(state) {
+        const mode = normalizeMode('caveman', state.caveman);
+        if (mode) {
+            currentMode = mode;
+            syncStatus();
+        }
+    }
+    setSharedComboListener(syncFromShared);
+    pi.registerCommand?.('caveman', {
+        description: 'Toggle terse caveman replies for this session',
+        handler: async (args, ctx) => {
+            const arg = String(args || '').trim().toLowerCase();
+            if (!arg || arg === 'on') {
+                setMode('full', ctx);
+                return;
+            }
+            if (arg === 'status') {
+                ctx?.ui?.notify?.(`Caveman: ${currentMode}`, 'info');
+                return;
+            }
+            if (!setMode(arg, ctx)) {
+                ctx?.ui?.notify?.('Usage: /caveman [lite|full|ultra|wenyan|off|status]', 'warning');
+            }
+        },
+    });
+    pi.on('input', async (event) => {
+        if (event?.source === 'extension')
+            return;
+        if (currentMode !== 'off' && isOffCommand(event?.text))
+            setMode('off');
+    });
+    function restoreMode(ctx) {
+        const entries = sessionEntries(ctx);
+        // Publish the persisted combo state (incl. combo-level) before painting:
+        // bar suppression reads the in-process bridge, which is empty in a fresh
+        // host until the combo extension reconciles — and its reconcile is
+        // UI-gated. Deriving it here makes suppression independent of load order.
+        reconcileSharedComboEntries(entries);
+        // Persisted session state wins; a fresh session falls back to the
+        // installer/user-configured default (off unless configured).
+        const persisted = resolveMode(entries, '');
+        currentMode = persisted || readCavemanDefault();
+        syncStatus(ctx);
+    }
+    pi.on('session_start', async (_event, ctx) => {
+        restoreMode(ctx);
+        ctx?.ui?.notify?.(`Caveman loaded: ${currentMode}`, 'info');
+    });
+    pi.on('session_branch', async (_event, ctx) => {
+        restoreMode(ctx);
+    });
+    pi.on('session_tree', async (_event, ctx) => {
+        restoreMode(ctx);
+    });
+    pi.on('agent_start', async (_event, ctx) => {
+        isActive = true;
+        syncStatus(ctx);
+    });
+    pi.on('agent_end', async (_event, ctx) => {
+        isActive = false;
+        syncStatus(ctx);
+    });
+    pi.on('before_agent_start', async (event) => {
+        const mode = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().caveman : currentMode;
+        if (!mode || mode === 'off')
+            return;
+        const def = INSTRUCTIONS[mode];
+        if (!def)
+            return;
+        const instruction = typeof def === 'function' ? def() : def;
+        const base = asPromptArray(event.systemPrompt);
+        return { systemPrompt: [...base, instruction] };
+    });
+}

package/extensions/combo-toggle/index.js

@@ -0,0 +1,165 @@
+// /combo session toggle — set all three (caveman, rtk, ponytail) at once.
+// Modes: off | medium | balanced | max
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { activeModesSummary, asPromptArray, COMBO_LEVELS, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, normalizeComboLevel, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, setSharedComboMode, systemPromptIncludes, } from '../shared/session-state.js';
+import { readComboDefault, readPonytailDefault } from '../shared/plugin-settings.js';
+const require = createRequire(import.meta.url);
+const PONYTAIL_FALLBACK_INTENSITY = {
+    lite: 'Prefer the simplest correct solution.',
+    review: 'Review only for avoidable complexity; recommend the smallest correct replacement.',
+};
+function ponytailFallback(mode) {
+    const intensity = PONYTAIL_FALLBACK_INTENSITY[mode] ?? 'Use the minimum correct solution. Delete or reuse before adding.';
+    return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
+}
+function levelSummary(state) {
+    return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
+}
+function loadPonytailInstructions(mode) {
+    try {
+        const installed = path.join(os.homedir(), '.omp', 'plugins', 'node_modules', '@dietrichgebert', 'ponytail', 'hooks', 'ponytail-instructions.js');
+        const { getPonytailInstructions } = require(installed);
+        if (typeof getPonytailInstructions === 'function')
+            return getPonytailInstructions(mode);
+    }
+    catch { }
+    return ponytailFallback(mode);
+}
+export default function comboToggleExtension(pi) {
+    pi.setLabel?.('Combo session toggle (all 3 add-ons)');
+    let lastCtx = undefined;
+    function syncStatus(ctx) {
+        lastCtx = paintableCtx(lastCtx, ctx);
+        const c = lastCtx;
+        if (!c?.ui?.setStatus)
+            return;
+        // Single unified bar replaces the three per-extension bars while a preset is
+        // active. In custom/off, the individual bars come back and combo stays clear.
+        if (!isComboPresetActive()) {
+            c.ui.setStatus('combo', undefined);
+            return;
+        }
+        // Read the live bridge, not cached extension state: sibling extensions
+        // reconcile it from persisted entries before this one runs.
+        const state = getSharedComboState();
+        const theme = c.ui.theme;
+        const c0 = state.caveman.toUpperCase();
+        const r = state.rtk.toUpperCase();
+        const p = state.ponytail.toUpperCase();
+        const lvl = state.level.toUpperCase();
+        const label = `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`;
+        c.ui.setStatus('combo', theme?.fg ? `${theme.fg('accent', '🧩')} ${theme.fg('muted', label)}` : `🧩 ${label}`);
+        // Clobber any sibling bars another extension may have painted in a race
+        // during session_start — our bar is canonical for the duration of the preset.
+        c.ui.setStatus('caveman', undefined);
+        c.ui.setStatus('rtk', undefined);
+        c.ui.setStatus('ponytail', undefined);
+    }
+    // ponytail: same persistence as /combo — siblings (incl. upstream ponytail)
+    // restore from these entries, so the fallback must write them too or the
+    // preset evaporates on resume and ponytail never activates.
+    function persistPreset(level) {
+        const modes = COMBO_LEVELS[level];
+        pi.appendEntry?.('caveman-mode', { mode: modes.caveman });
+        pi.appendEntry?.('rtk-mode', { enabled: modes.rtk === 'on' });
+        pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
+        pi.appendEntry?.('combo-level', { level });
+    }
+    function useState(state, ctx) {
+        syncStatus(ctx);
+        return state;
+    }
+    function reconcile(ctx) {
+        if (!ctx?.hasUI)
+            return getSharedComboState();
+        return useState(reconcileSharedComboEntries(sessionEntries(ctx)), ctx);
+    }
+    function listen(ctx) {
+        // Stable identity: the bridge set dedupes, so repeated track()/command
+        // calls register once instead of stacking duplicate listeners.
+        if (ctx?.hasUI)
+            setSharedComboListener(useState);
+    }
+    function track(ctx) {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    }
+    pi.registerCommand?.('combo', {
+        description: 'Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>',
+        handler: async (args, ctx) => {
+            listen(ctx);
+            const arg = String(args || '').trim().toLowerCase();
+            if (!arg || arg === 'status') {
+                const state = reconcile(ctx);
+                ctx?.ui?.notify?.(`Combo: ${state.level === 'custom' ? 'INACTIVE' : state.level.toUpperCase()} (${levelSummary(state)})`, 'info');
+                return;
+            }
+            if (arg === 'help') {
+                ctx?.ui?.notify?.('/combo off      — disables all 3 (caveman, rtk, ponytail)\n' +
+                    '/combo medium   — light: caveman=lite, rtk=on, ponytail=lite\n' +
+                    '/combo balanced — middle: caveman=full, rtk=on, ponytail=full\n' +
+                    '/combo max      — aggressive: caveman=ultra, rtk=on, ponytail=ultra', 'info');
+                return;
+            }
+            const level = normalizeComboLevel(arg);
+            if (!level) {
+                ctx?.ui?.notify?.(`Unknown combo level: ${arg}. Use: off | medium | balanced | max`, 'warning');
+                return;
+            }
+            persistPreset(level);
+            useState(setSharedComboLevel(level), ctx);
+            const active = activeModesSummary(getSharedComboState());
+            ctx?.ui?.notify?.(level === 'off' ? `Combo off — all tersio modes inactive for this session. Active: ${active}.` : `Combo ${level} on — ${active} active for this session.`, 'info');
+        },
+    });
+    pi.on('session_start', async (_event, ctx) => {
+        track(ctx);
+        if (!ctx?.hasUI)
+            syncStatus(ctx);
+        // Installer/user-configured default applies only when no persisted *mode*
+        // state exists — unrelated session entries must not block it, or the
+        // combo bar never paints on sessions that already carry other entries.
+        const entries = sessionEntries(ctx);
+        const hasModeState = entries.some((e) => e?.type === 'custom' && (e.customType === 'combo-level' || e.customType === 'caveman-mode' ||
+            e.customType === 'rtk-mode' || e.customType === 'ponytail-mode'));
+        if (getSharedComboState().level === 'off' && !hasModeState) {
+            const fallback = readComboDefault();
+            if (fallback !== 'off') {
+                persistPreset(fallback);
+                useState(setSharedComboLevel(fallback), ctx);
+                ctx?.ui?.notify?.(`Combo default applied: ${fallback} — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
+            }
+        }
+        // Standalone ponytail default: no sibling extension restores it (upstream
+        // owns the command), so apply it here when nothing persisted a
+        // ponytail-mode entry. Skipped when it matches the active preset — the
+        // preset entry already covers that, no redundant write.
+        if (!entries.some((e) => e?.type === 'custom' && e.customType === 'ponytail-mode')) {
+            const ponytailFallback = readPonytailDefault();
+            if (ponytailFallback !== 'off' && ponytailFallback !== getSharedComboState().ponytail) {
+                pi.appendEntry?.('ponytail-mode', { mode: ponytailFallback });
+                useState(setSharedComboMode('ponytail', ponytailFallback), ctx);
+            }
+        }
+    });
+    for (const event of ['session_branch', 'session_tree', 'agent_start']) {
+        pi.on(event, async (_event, ctx) => {
+            track(ctx);
+        });
+    }
+    pi.on('before_agent_start', async (event, ctx) => {
+        if (ctx?.hasUI)
+            reconcile(ctx);
+        if (!isOmpSubagentPrompt(event.systemPrompt))
+            return;
+        const mode = getSharedComboState().ponytail;
+        if (mode === 'off' || systemPromptIncludes(event.systemPrompt, 'PONYTAIL MODE ACTIVE'))
+            return;
+        const base = asPromptArray(event.systemPrompt);
+        return { systemPrompt: [...base, loadPonytailInstructions(mode)] };
+    });
+    // Slash commands only; natural-language input caused accidental toggles and has no reload context.
+}