@krtclcdy/tersio 1.0.1 → 1.0.2

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

@@ -0,0 +1,398 @@
+// 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 { httpsGet, httpsDownload, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, } 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_LOCAL = path.join(HOME, ".omp", "plugins", "node_modules", "@dietrichgebert", "ponytail", "package.json");
+const RTK_RELEASE_API = "https://api.github.com/repos/rtk-ai/rtk/releases/latest";
+const RTK_BINARY = path.join(HOME, ".bun", "bin", IS_WINDOWS ? "rtk.exe" : "rtk");
+const CAVEMAN_REMOTE = "https://raw.githubusercontent.com/JuliusBrussee/caveman/main/src/rules/caveman-activate.md";
+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);
+}
+// Check: no mutation.
+async function checkAddons(ctx) {
+    const lines = [];
+    // Ponytail
+    try {
+        const remoteRaw = await httpsGet(PONYTAIL_REMOTE);
+        const remoteJson = JSON.parse(remoteRaw);
+        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";
+        const m = `Ponytail ${status}: local=${localVer || "—"} latest=${remoteVer}`;
+        lines.push(m);
+        notify(ctx, m, "info");
+    }
+    catch (e) {
+        const m = `Ponytail check failed: ${e.message}`;
+        lines.push(m);
+        notify(ctx, m, "warning");
+    }
+    // RTK
+    try {
+        const releaseRaw = await httpsGet(RTK_RELEASE_API);
+        const release = JSON.parse(releaseRaw);
+        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";
+        const m = `RTK ${status}: local=${localVer || "—"} latest=${latestTag || "—"}`;
+        lines.push(m);
+        notify(ctx, m, "info");
+    }
+    catch (e) {
+        const m = `RTK check failed: ${e.message}`;
+        lines.push(m);
+        notify(ctx, m, "warning");
+    }
+    // Caveman (rule.md)
+    try {
+        const remote = await httpsGet(CAVEMAN_REMOTE);
+        const remoteHash = sha256Hex(remote).slice(0, 16);
+        const local = await readTextIfExists(CAVEMAN_LOCAL);
+        const localHash = local ? sha256Hex(local).slice(0, 16) : null;
+        const status = !local ? "rule.md missing"
+            : localHash === remoteHash ? "rule.md up to date"
+                : "rule.md update available";
+        const m = `Caveman ${status}: local=${localHash || "—"} remote=${remoteHash}`;
+        lines.push(m);
+        notify(ctx, m, "info");
+    }
+    catch (e) {
+        const m = `Caveman check failed: ${e.message}`;
+        lines.push(m);
+        notify(ctx, m, "warning");
+    }
+    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 @dietrichgebert/ponytail@latest --save --no-audit --no-fund\` in ${pluginsDir}.`;
+        notify(ctx, m, "info");
+        return m;
+    }
+    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}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    notify(ctx, "Ponytail: running npm install…", "info");
+    let out = "";
+    try {
+        const r = await pi.exec("npm", ["install", "@dietrichgebert/ponytail@latest", "--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}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    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 {
+        const raw = await httpsGet(RTK_RELEASE_API);
+        release = JSON.parse(raw);
+    }
+    catch (e) {
+        const m = `RTK: cannot fetch release info: ${e.message}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    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;
+    let assetTriple;
+    let assetExt;
+    let binaryName;
+    if (PLATFORM === "win32" && ARCH === "x64") {
+        assetTriple = "x86_64-pc-windows-msvc";
+        assetExt = ".zip";
+        binaryName = "rtk.exe";
+    }
+    else if (PLATFORM === "linux" && ARCH === "x64") {
+        assetTriple = "x86_64-unknown-linux-musl";
+        assetExt = ".tar.gz";
+        binaryName = "rtk";
+    }
+    else if (PLATFORM === "linux" && ARCH === "arm64") {
+        assetTriple = "aarch64-unknown-linux-gnu";
+        assetExt = ".tar.gz";
+        binaryName = "rtk";
+    }
+    else if (PLATFORM === "darwin" && ARCH === "x64") {
+        assetTriple = "x86_64-apple-darwin";
+        assetExt = ".tar.gz";
+        binaryName = "rtk";
+    }
+    else if (PLATFORM === "darwin" && ARCH === "arm64") {
+        assetTriple = "aarch64-apple-darwin";
+        assetExt = ".tar.gz";
+        binaryName = "rtk";
+    }
+    else {
+        const m = `RTK: unsupported platform ${PLATFORM}/${ARCH}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    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)`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    if (dryRun) {
+        const m = `RTK dry-run: would download ${asset.name} (${tag}), verify checksums.txt, and replace ${RTK_BINARY}.`;
+        notify(ctx, m, "info");
+        return m;
+    }
+    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");
+        await httpsDownload(asset.browser_download_url, archivePath);
+        notify(ctx, "RTK: downloading checksums.txt…", "info");
+        await 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}`;
+            notify(ctx, m, "warning");
+            return m;
+        }
+        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)}…`;
+            notify(ctx, m, "warning");
+            return m;
+        }
+        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) {
+                execFileSync("sh", ["-c", `gunzip < "${archivePath}" | tar xf - -C "${extractDir}"`], { encoding: "utf8", shell: false });
+            }
+        }
+        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`;
+            notify(ctx, m, "warning");
+            return m;
+        }
+        await fs.mkdir(path.dirname(RTK_BINARY), { recursive: true });
+        const backupPath = `${RTK_BINARY}.bak`;
+        let backedUp = false;
+        try {
+            await fs.copyFile(RTK_BINARY, backupPath);
+            backedUp = true;
+        }
+        catch {
+            backedUp = 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}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    finally {
+        fs.rm(tmp, { recursive: true, force: true }).catch(() => { });
+    }
+}
+async function findFile(dir, name) {
+    try {
+        const ents = await fs.readdir(dir, { withFileTypes: true });
+        for (const e of ents) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                const r = await findFile(full, name);
+                if (r)
+                    return r;
+            }
+            else if (e.isFile()) {
+                if (e.name === name)
+                    return full;
+                // Match rtk-* asset names (e.g. rtk-x86_64-unknown-linux-musl)
+                if (name === "rtk" || name === "rtk.exe") {
+                    const base = e.name.toLowerCase();
+                    if (!/\.(txt|md|json|sha256|sig|asc|pem|crt|license)$/i.test(base)) {
+                        if (base === "rtk" || base === "rtk.exe" || /^rtk[-_.]/.test(base))
+                            return full;
+                    }
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+async function updateCaveman(ctx, dryRun = false) {
+    let remote;
+    try {
+        remote = await httpsGet(CAVEMAN_REMOTE);
+    }
+    catch (e) {
+        const m = `Caveman update failed: ${e.message}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    const remoteHash = sha256Hex(remote).slice(0, 16);
+    const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
+    const oldHash = oldLocal ? sha256Hex(oldLocal).slice(0, 16) : null;
+    if (dryRun) {
+        const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || "—"} new=${remoteHash}.`;
+        notify(ctx, m, "info");
+        return m;
+    }
+    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 = sha256Hex(written).slice(0, 16);
+        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}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+}
+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]) {
+                const target = cleanParts.slice(1).join(" ");
+                const results = [];
+                if (target === "ponytail") {
+                    results.push(await updatePonytail(pi, ctx, dryRun));
+                }
+                else if (target === "rtk") {
+                    results.push(await updateRtk(ctx, dryRun));
+                }
+                else if (target === "caveman") {
+                    results.push(await updateCaveman(ctx, dryRun));
+                }
+                else if (target === "all") {
+                    notify(ctx, `ai-addons update all${dryRun ? " dry-run" : ""}: starting ponytail → rtk → caveman sequentially…`, "info");
+                    results.push(await updatePonytail(pi, ctx, dryRun));
+                    results.push(await updateRtk(ctx, dryRun));
+                    results.push(await updateCaveman(ctx, dryRun));
+                    if (!dryRun)
+                        results.push(RELOAD_MSG);
+                    notify(ctx, `ai-addons update all ${dryRun ? "dry-run " : ""}complete.${dryRun ? "" : ` ${RELOAD_MSG}`}`, "info");
+                }
+                else {
+                    const m = "Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]";
+                    notify(ctx, m, "warning");
+                    return m;
+                }
+                return results.join("\n\n");
+            }
+            const m = "Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]";
+            notify(ctx, m, "warning");
+            return m;
+        },
+    });
+}
+export { parseChecksum };

package/extensions/amanai-reward/index.js

@@ -0,0 +1,24 @@
+const REWARD_KEY = /(?<![A-Za-z0-9_-])AMANAI-GACHA-[A-Za-z0-9]+-[A-Za-z0-9]+(?![A-Za-z0-9_-])/;
+const NOTIFICATION = "Amanai reward key detected in the final response. Redeem it manually in the Amanai billing dashboard.";
+export default function amanaiRewardExtension(pi) {
+    pi.on("agent_end", (event, ctx) => {
+        if (event.willContinue)
+            return;
+        const messages = Array.isArray(event.messages) ? event.messages : [];
+        let message;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            if (messages[index]?.role === "assistant") {
+                message = messages[index];
+                break;
+            }
+        }
+        if (!message || message.stopReason !== "stop" || !Array.isArray(message.content))
+            return;
+        for (const block of message.content) {
+            if (block?.type === "text" && typeof block.text === "string" && REWARD_KEY.test(block.text)) {
+                ctx?.ui?.notify?.(NOTIFICATION, "info");
+                return;
+            }
+        }
+    });
+}

package/extensions/amanai-reward/pi.js

@@ -0,0 +1,32 @@
+const REWARD_KEY = /(?<![A-Za-z0-9_-])AMANAI-GACHA-[A-Za-z0-9]+-[A-Za-z0-9]+(?![A-Za-z0-9_-])/;
+const NOTIFICATION = "Amanai reward key detected in the final response. Redeem it manually in the Amanai billing dashboard.";
+export default function amanaiRewardExtension(pi) {
+    let candidate = false;
+    pi.on("agent_start", () => {
+        candidate = false;
+    });
+    pi.on("agent_end", (event) => {
+        candidate = false;
+        const messages = Array.isArray(event?.messages) ? event.messages : [];
+        let message;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            if (messages[index]?.role === "assistant") {
+                message = messages[index];
+                break;
+            }
+        }
+        if (message?.stopReason !== "stop" || !Array.isArray(message.content))
+            return;
+        candidate = message.content.some((block) => block?.type === "text" && typeof block.text === "string" && REWARD_KEY.test(block.text));
+    });
+    pi.on("agent_settled", (_event, ctx) => {
+        const c = ctx;
+        try {
+            if (candidate && c?.hasUI && c.ui)
+                c.ui.notify(NOTIFICATION, "info");
+        }
+        finally {
+            candidate = false;
+        }
+    });
+}

package/extensions/caveman-session/index.js

@@ -0,0 +1,153 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, setSharedComboMode } from "../shared/session-state.js";
+import { readCavemanDefault } from "../shared/plugin-settings.js";
+const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
+const RULE_PATH = join(CAVERN_DIR, "rule.md");
+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 MODES = new Set(["off", "lite", "full", "ultra", "wenyan"]);
+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 normalizeMode(value) {
+    const mode = String(value || "").trim().toLowerCase();
+    return MODES.has(mode) ? mode : null;
+}
+function resolveMode(entries, fallback = DEFAULT_MODE) {
+    if (!Array.isArray(entries))
+        return fallback;
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        const entry = entries[i];
+        if (entry?.type !== "custom" || entry?.customType !== "caveman-mode")
+            continue;
+        const mode = normalizeMode(entry?.data?.mode);
+        if (mode)
+            return mode;
+    }
+    return fallback;
+}
+function isOffCommand(text) {
+    const t = String(text || "").trim().toLowerCase().replace(/[.!?\s]+$/, "");
+    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) {
+        if (ctx)
+            lastCtx = ctx;
+        const c = ctx || lastCtx;
+        if (!c?.ui?.setStatus)
+            return;
+        // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
+        if (getSharedComboState().level in COMBO_LEVELS && getSharedComboState().level !== "off") {
+            c.ui.setStatus("caveman", undefined);
+            return;
+        }
+        if (currentMode === "off") {
+            c.ui.setStatus("caveman", undefined);
+            return;
+        }
+        const theme = c.ui.theme;
+        const indicator = isActive && theme?.fg ? theme.fg("accent", "🪨") : "🪨";
+        const label = `caveman: ${currentMode.toUpperCase()}`;
+        c.ui.setStatus("caveman", theme?.fg ? `${indicator} ${theme.fg("muted", label)}` : `${indicator} ${label}`);
+    }
+    function setMode(mode, ctx) {
+        const normalized = normalizeMode(mode);
+        if (!normalized)
+            return false;
+        currentMode = normalized;
+        pi.appendEntry?.("caveman-mode", { mode: normalized });
+        setSharedComboMode("caveman", normalized);
+        syncStatus(ctx);
+        ctx?.ui?.notify?.(`Caveman mode ${normalized === "off" ? "off" : `set to ${normalized}`}.`, "info");
+        return true;
+    }
+    pi.setLabel?.("Caveman session toggle");
+    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 = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+        // 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];
+        const instruction = typeof def === "function" ? def() : def;
+        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        return { systemPrompt: [...base, instruction] };
+    });
+}