@krtclcdy/tersio 1.0.0

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] };
+    });
+}

package/extensions/combo-toggle/index.js

@@ -0,0 +1,157 @@
+// /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 { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, normalizeComboLevel, reconcileSharedComboEntries, setSharedComboLevel, setSharedComboListener, } from "../shared/session-state.js";
+import { readComboDefault } from "../shared/plugin-settings.js";
+const require = createRequire(import.meta.url);
+function ponytailFallback(mode) {
+    const intensity = mode === "lite"
+        ? "Prefer the simplest correct solution."
+        : mode === "review"
+            ? "Review only for avoidable complexity; recommend the smallest correct replacement."
+            : "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 entriesFrom(ctx) {
+    return ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+}
+function levelSummary(state) {
+    return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
+}
+function hasPonytailInstructions(systemPrompt) {
+    const prompts = Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+    return prompts.some((prompt) => typeof prompt === "string" && prompt.includes("PONYTAIL MODE ACTIVE"));
+}
+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 currentState = getSharedComboState();
+    let lastCtx = undefined;
+    function syncStatus(ctx) {
+        if (ctx)
+            lastCtx = ctx;
+        const c = ctx || 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 (currentState.level !== "medium" && currentState.level !== "balanced" && currentState.level !== "max") {
+            c.ui.setStatus("combo", undefined);
+            return;
+        }
+        const theme = c.ui.theme;
+        const c0 = currentState.caveman.toUpperCase();
+        const r = currentState.rtk.toUpperCase();
+        const p = currentState.ponytail.toUpperCase();
+        const lvl = currentState.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);
+    }
+    function useState(state, ctx) {
+        currentState = state;
+        syncStatus(ctx);
+        return state;
+    }
+    function reconcile(ctx) {
+        if (!ctx?.hasUI)
+            return currentState;
+        return useState(reconcileSharedComboEntries(entriesFrom(ctx)), ctx);
+    }
+    function listen(ctx) {
+        if (ctx?.hasUI)
+            setSharedComboListener((state) => useState(state));
+    }
+    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;
+            }
+            const modes = COMBO_LEVELS[level];
+            // Persist per-extension state so they restore on session_start
+            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 });
+            useState(setSharedComboLevel(level), ctx);
+            ctx?.ui?.notify?.(`Combo ${level} applied: ${levelSummary(currentState)}`, "info");
+            if (ctx?.reload)
+                await ctx.reload();
+        },
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+        else
+            syncStatus(ctx);
+        // Installer/user-configured default applies only to a fresh session with
+        // no persisted state — real session state always wins.
+        if (getSharedComboState().level === "off" && !(ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || []).length) {
+            const fallback = readComboDefault();
+            if (fallback !== "off") {
+                useState(setSharedComboLevel(fallback), ctx);
+                ctx?.ui?.notify?.(`Combo default applied: ${fallback}`, "info");
+            }
+        }
+    });
+    pi.on("session_branch", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    });
+    pi.on("session_tree", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    });
+    pi.on("agent_start", async (_event, ctx) => {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(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" || hasPonytailInstructions(event.systemPrompt))
+            return;
+        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        return { systemPrompt: [...base, loadPonytailInstructions(mode)] };
+    });
+    // Slash commands only; natural-language input caused accidental toggles and has no reload context.
+}

package/extensions/lib/utils.js

@@ -0,0 +1,101 @@
+// Shared helpers for the installer and the AI add-ons updater.
+// Node built-ins only — this module must stay dependency-free.
+import { createHash } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import fs from "node:fs/promises";
+import https from "node:https";
+import path from "node:path";
+// Promise.withResolvers is Node 22+; the package supports Node 18+.
+// ponytail: swap for the built-in when engines bumps to >=22.
+function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+    return { promise, resolve, reject };
+}
+export function httpsGet(url, opts = {}) {
+    const { promise, resolve, reject } = withResolvers();
+    const maxRedirects = opts.maxRedirects ?? 5;
+    const req = https.get(url, { headers: { "User-Agent": "tersio", Accept: "application/json,*/*" } }, (res) => {
+        if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            if (maxRedirects <= 0) {
+                res.resume();
+                reject(new Error(`Too many redirects fetching ${url}`));
+                return;
+            }
+            res.resume();
+            const next = new URL(res.headers.location, url).href;
+            resolve(httpsGet(next, { maxRedirects: maxRedirects - 1 }));
+            return;
+        }
+        if (res.statusCode !== 200) {
+            res.resume();
+            reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+            return;
+        }
+        let body = "";
+        // ponytail: streamed accumulation — fine for tens of KB; stream-pipe if assets ever exceed a few MB.
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => { body += chunk; });
+        res.on("end", () => resolve(body));
+    });
+    req.on("error", reject);
+    req.setTimeout(30000, () => req.destroy(new Error(`Timeout fetching ${url}`)));
+    return promise;
+}
+export function httpsDownload(url, dest, opts = {}) {
+    const { promise, resolve, reject } = withResolvers();
+    const maxRedirects = opts.maxRedirects ?? 5;
+    const req = https.get(url, { headers: { "User-Agent": "tersio", Accept: "*/*" } }, (res) => {
+        if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            if (maxRedirects <= 0) {
+                res.resume();
+                reject(new Error(`Too many redirects downloading ${url}`));
+                return;
+            }
+            res.resume();
+            const next = new URL(res.headers.location, url).href;
+            resolve(httpsDownload(next, dest, { maxRedirects: maxRedirects - 1 }));
+            return;
+        }
+        if (res.statusCode !== 200) {
+            res.resume();
+            reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+            return;
+        }
+        const file = createWriteStream(dest);
+        res.pipe(file);
+        file.on("finish", () => file.close(() => resolve()));
+        file.on("error", reject);
+    });
+    req.on("error", reject);
+    req.setTimeout(120000, () => req.destroy(new Error(`Timeout downloading ${url}`)));
+    return promise;
+}
+export function sha256Hex(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+export async function sha256File(filePath) {
+    const buf = await fs.readFile(filePath);
+    return createHash("sha256").update(buf).digest("hex");
+}
+export function parseChecksum(checksumsText, assetName) {
+    const target = path.basename(assetName);
+    for (const line of checksumsText.split(/\r?\n/)) {
+        const m = line.match(/^([0-9a-fA-F]{64})\s+\*?(.+)$/);
+        if (m && path.basename(m[2]) === target)
+            return m[1].toLowerCase();
+    }
+    return null;
+}
+export async function readTextIfExists(p) {
+    try {
+        return await fs.readFile(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeRtkVersion(value) {
+    return String(value || "").replace(/^rtk\s+/i, "").replace(/^v/i, "").trim();
+}

package/extensions/rtk-session/index.js

@@ -0,0 +1,151 @@
+import os from "node:os";
+import path from "node:path";
+import { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, setSharedComboMode } from "../shared/session-state.js";
+import { readRtkDefault } from "../shared/plugin-settings.js";
+const DEFAULT_ENABLED = false;
+function asBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (value === "on" || value === "true")
+        return true;
+    if (value === "off" || value === "false")
+        return false;
+    return null;
+}
+function resolveEnabled(entries) {
+    if (!Array.isArray(entries))
+        return null;
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        const entry = entries[i];
+        if (entry?.type !== "custom" || entry?.customType !== "rtk-mode")
+            continue;
+        return asBoolean(entry?.data?.enabled);
+    }
+    return null;
+}
+const IS_WINDOWS = process.platform === "win32";
+const HOME = os.homedir();
+const RTK_BINARY = path.join(HOME, ".bun", "bin", IS_WINDOWS ? "rtk.exe" : "rtk");
+const RTK_PROMPT = `RTK mode active for this session.
+Use Rust Token Killer for shell output that would otherwise be noisy. Prefer explicit RTK commands in bash: \`rtk git status\`, \`rtk git diff\`, \`rtk read <file>\`, \`rtk grep <pattern> <path>\`, \`rtk find <glob> <path>\`, \`rtk test <cmd...>\`, \`rtk tsc\`, \`rtk lint\`, or \`rtk <tool> ...\` for supported dev commands.
+Do not use RTK when exact raw output is required, when a specialized OMP tool is required by system policy, or when the command changes state and RTK would hide important confirmation text. Specialized OMP tools still win: read/glob/grep/edit/lsp stay preferred over shell equivalents.`;
+export default function rtkSessionExtension(pi) {
+    const { z } = pi.zod;
+    let enabled = DEFAULT_ENABLED;
+    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("rtk", undefined);
+            return;
+        }
+        if (!enabled) {
+            c.ui.setStatus("rtk", undefined);
+            return;
+        }
+        const theme = c.ui.theme;
+        const indicator = isActive && theme?.fg ? theme.fg("accent", "⚡") : "⚡";
+        const label = "rtk: ON";
+        c.ui.setStatus("rtk", theme?.fg ? `${indicator} ${theme.fg("muted", label)}` : `${indicator} ${label}`);
+    }
+    function setEnabled(next, ctx) {
+        enabled = Boolean(next);
+        pi.appendEntry?.("rtk-mode", { enabled });
+        setSharedComboMode("rtk", enabled);
+        syncStatus(ctx);
+        ctx?.ui?.notify?.(`RTK mode ${enabled ? "on" : "off"}.`, "info");
+    }
+    pi.setLabel?.("RTK session toggle");
+    pi.registerCommand?.("rtk", {
+        description: "Toggle RTK compact shell-output guidance for this session",
+        handler: async (args, ctx) => {
+            const arg = String(args || "").trim().toLowerCase();
+            if (!arg || arg === "status") {
+                ctx?.ui?.notify?.(`RTK: ${enabled ? "on" : "off"}`, "info");
+                return;
+            }
+            if (["on", "enable", "enabled", "true"].includes(arg)) {
+                setEnabled(true, ctx);
+                return;
+            }
+            if (["off", "disable", "disabled", "false"].includes(arg)) {
+                setEnabled(false, ctx);
+                return;
+            }
+            ctx?.ui?.notify?.("Usage: /rtk [on|off|status]", "warning");
+        },
+    });
+    pi.registerTool?.({
+        name: "rtk_run",
+        label: "RTK Run",
+        description: "Run the installed `rtk` binary for compact command output when RTK mode is enabled.",
+        parameters: z.object({
+            args: z.array(z.string()).min(1).describe("Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']"),
+        }),
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            if (!enabled) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "RTK mode is off. Run /rtk on for this session, or use bash explicitly." }],
+                    details: { enabled },
+                };
+            }
+            onUpdate?.({ content: [{ type: "text", text: `rtk ${params.args.join(" ")}` }], details: { phase: "start" } });
+            const result = await pi.exec(RTK_BINARY, params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+            const text = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? "\n" : "");
+            return {
+                isError: result.code !== 0,
+                content: [{ type: "text", text: text || `rtk exited ${result.code}` }],
+                details: { code: result.code, killed: result.killed, enabled },
+            };
+        },
+    });
+    pi.on("input", async (event) => {
+        if (event?.source === "extension")
+            return;
+        const t = String(event?.text || "").trim().toLowerCase().replace(/[.!?\s]+$/, "");
+        if (t === "rtk on" || t === "use rtk")
+            setEnabled(true);
+        if (t === "rtk off" || t === "stop rtk")
+            setEnabled(false);
+    });
+    function restoreEnabled(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 = resolveEnabled(entries);
+        enabled = typeof persisted === "boolean" ? persisted : readRtkDefault();
+        syncStatus(ctx);
+    }
+    pi.on("session_start", async (_event, ctx) => {
+        restoreEnabled(ctx);
+        ctx?.ui?.notify?.(`RTK loaded: ${enabled ? "on" : "off"}`, "info");
+    });
+    pi.on("session_branch", async (_event, ctx) => {
+        restoreEnabled(ctx);
+    });
+    pi.on("session_tree", async (_event, ctx) => {
+        restoreEnabled(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 active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === "on" : enabled;
+        if (!active)
+            return;
+        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        return { systemPrompt: [...base, RTK_PROMPT] };
+    });
+}

package/extensions/shared/headroom-status.js

@@ -0,0 +1,72 @@
+// Headroom proxy presence for the combo status bar.
+// Wrap-marker read is sync so paint stays cheap; proxy /health is probed async,
+// cached per port, and callers repaint when the probe settles.
+import { readFileSync } from "node:fs";
+import https from "node:https";
+import os from "node:os";
+import path from "node:path";
+export const HEADROOM_MARKER = "# managed by `headroom wrap omp`";
+const PROBE_TTL_MS = 60_000;
+function modelsPath() {
+    const base = process.env.PI_CODING_AGENT_DIR?.trim();
+    if (base)
+        return path.join(path.resolve(base), "models.yml");
+    return path.join(os.homedir(), ".omp", "agent", "models.yml");
+}
+export function readHeadroomWrap() {
+    let raw;
+    try {
+        raw = readFileSync(modelsPath(), "utf8");
+    }
+    catch {
+        return { wrapped: false, port: null };
+    }
+    if (!raw.includes(HEADROOM_MARKER))
+        return { wrapped: false, port: null };
+    const match = raw.match(/baseUrl:\s*https?:\/\/127\.0\.0\.1:(\d+)/);
+    return { wrapped: true, port: match ? Number(match[1]) : null };
+}
+function probeProxy(port) {
+    return new Promise((resolve) => {
+        const req = https.get({ host: "127.0.0.1", port, path: "/health", timeout: 2000 }, (res) => {
+            res.resume();
+            resolve(res.statusCode !== undefined && res.statusCode < 500);
+        });
+        req.on("timeout", () => { req.destroy(); resolve(false); });
+        req.on("error", () => resolve(false));
+    });
+}
+let lastPort;
+let lastHealthy = true;
+let lastProbeAt = 0;
+let inflight = null;
+export function refreshHeadroomStatus() {
+    if (inflight)
+        return inflight;
+    inflight = (async () => {
+        const { wrapped, port } = readHeadroomWrap();
+        if (!wrapped || port === null) {
+            lastPort = port;
+            lastHealthy = true;
+            lastProbeAt = Date.now();
+            return;
+        }
+        lastHealthy = await probeProxy(port);
+        lastPort = port;
+        lastProbeAt = Date.now();
+    })();
+    inflight.then(() => { inflight = null; }, () => { inflight = null; });
+    return inflight;
+}
+export function getHeadroomStatus() {
+    const { wrapped, port } = readHeadroomWrap();
+    if (!wrapped)
+        return "off";
+    if (port !== null && port === lastPort && Date.now() - lastProbeAt < PROBE_TTL_MS) {
+        return lastHealthy ? "on" : "stale";
+    }
+    // No fresh probe for this port: kick one off and assume on until a probe
+    // says otherwise, so first paint never blocks on the network.
+    void refreshHeadroomStatus();
+    return port !== null && port === lastPort && !lastHealthy ? "stale" : "on";
+}

package/extensions/shared/mode-reinforcement.js

@@ -0,0 +1,29 @@
+import { reconcileSharedComboEntries } from "./session-state.js";
+const MARKER = "SUPREME TOKEN SAVER MODES ACTIVE";
+function entriesFrom(ctx) {
+    return ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+}
+function instruction(state) {
+    const modes = [
+        state.caveman !== "off" && `caveman=${state.caveman}`,
+        state.rtk === "on" && "rtk=on",
+        state.ponytail !== "off" && `ponytail=${state.ponytail}`,
+    ].filter(Boolean);
+    if (!modes.length)
+        return null;
+    return `${MARKER}: ${modes.join(" · ")}. Keep these active for the entire response: concise Caveman prose, RTK for eligible noisy shell output, and the smallest correct Ponytail solution. Do not weaken or disable a mode unless the user explicitly asks.`;
+}
+export default function modeReinforcementExtension(pi) {
+    pi.setLabel?.("Tersio mode reinforcement");
+    pi.on("before_agent_start", async (event, ctx) => {
+        if (!ctx?.hasUI)
+            return;
+        const text = instruction(reconcileSharedComboEntries(entriesFrom(ctx)));
+        if (!text)
+            return;
+        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        if (base.some((prompt) => typeof prompt === "string" && prompt.includes(MARKER)))
+            return;
+        return { systemPrompt: [...base, text] };
+    });
+}