@krtclcdy/tersio 2.18.0 → 2.20.0

package/extensions/shared/mode-reinforcement.ts

@@ -0,0 +1,29 @@
+import { asPromptArray, reconcileSharedComboEntries, sessionEntries, systemPromptIncludes } from './session-state.ts';
+import type { ExtensionApi, SystemPromptEvent } from './types.ts';
+
+const MARKER = 'SUPREME TOKEN SAVER MODES ACTIVE';
+
+function instruction(state: { caveman: string; rtk: string; ponytail: string }): string | null {
+  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: ExtensionApi): void {
+  pi.setLabel?.('Tersio mode reinforcement');
+
+  pi.on('before_agent_start', async (event: SystemPromptEvent, ctx) => {
+    if (!ctx?.hasUI) return;
+    const text = instruction(reconcileSharedComboEntries(sessionEntries(ctx)));
+    if (!text) return;
+
+    const base = asPromptArray(event.systemPrompt);
+    if (systemPromptIncludes(base, MARKER)) return;
+    return { systemPrompt: [...base, text] };
+  });
+}

package/extensions/shared/plugin-settings.ts

@@ -0,0 +1,57 @@
+// Plugin settings reader for the Tersio extensions.
+// Reads omp's persisted plugin state (~/.omp/plugins/omp-plugins.lock.json),
+// written by `omp plugin config set @krtclcdy/tersio <key> <value>` and by
+// the installer profile step. Tolerant: any parse failure yields {} so every
+// caller falls back to its own default.
+
+import { existsSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const PLUGIN_NAME = '@krtclcdy/tersio';
+
+function lockPaths(): string[] {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  return [
+    path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
+    path.join(configHome, 'omp', 'plugins', 'omp-plugins.lock.json'),
+  ];
+}
+
+// `settings[PLUGIN_NAME]` in the lock file; empty object when missing.
+export function readPluginSettings(): Record<string, unknown> {
+  for (const p of lockPaths()) {
+    if (!existsSync(p)) continue;
+    try {
+      const config = JSON.parse(readFileSync(p, 'utf8')) as { settings?: Record<string, Record<string, unknown>> };
+      const values = config.settings?.[PLUGIN_NAME];
+      if (values && typeof values === 'object' && !Array.isArray(values)) return values;
+    } catch { /* tolerate corrupt file */ }
+  }
+  return {};
+}
+
+const COMBO_LEVELS = new Set(['off', 'medium', 'balanced', 'max']);
+const CAVEMAN_MODES = new Set(['off', 'lite', 'full', 'ultra', 'wenyan']);
+const PONYTAIL_MODES = new Set(['off', 'lite', 'full', 'ultra', 'review']);
+
+function readStringDefault(key: string, valid: Set<string>): string {
+  const raw = readPluginSettings()[key];
+  return typeof raw === 'string' && valid.has(raw) ? raw : 'off';
+}
+
+export function readComboDefault(): string {
+  return readStringDefault('comboDefault', COMBO_LEVELS);
+}
+
+export function readCavemanDefault(): string {
+  return readStringDefault('cavemanDefault', CAVEMAN_MODES);
+}
+
+export function readRtkDefault(): boolean {
+  const raw = readPluginSettings().rtkDefault;
+  return typeof raw === 'boolean' ? raw : false;
+}
+
+export function readPonytailDefault(): string {
+  return readStringDefault('ponytailDefault', PONYTAIL_MODES);
+}

package/extensions/shared/pricing.ts

@@ -0,0 +1,168 @@
+// extensions/shared/pricing.ts — dynamic model pricing from LiteLLM.
+// Lookup order: exact id in the live cache → provider-prefix strip → default.
+// The cache is the full LiteLLM feed (3k+ ids), refreshed lazily in background
+// and on `tersio update`; every reader is sync and offline-safe. No static
+// per-model table — list prices rot, the feed does not. Unknown models report
+// the default with known:false so the dashboard labels them honestly.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export interface ModelPrice {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+// Sonnet-class default for unpriced models; always paired with known:false.
+export const DEFAULT_PRICE: ModelPrice = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
+
+const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
+// Live cache refreshes lazily: readers use the file even when stale, and only
+// one refresh runs per process. `tersio update` still forces a fresh fetch.
+const CACHE_TTL_MS = 7 * 24 * 3600 * 1000;
+let refreshInflight: Promise<boolean> | null = null;
+
+export function pricesCachePath(): string {
+  const override = process.env.TERSIO_PRICES_FILE;
+  if (override) return override;
+  return path.join(os.homedir(), '.omp', 'plugins', 'tersio-prices.json');
+}
+
+export function pricesUrl(): string {
+  return process.env.TERSIO_PRICES_URL || LITELLM_URL;
+}
+
+export interface LivePrices {
+  fetchedAt: number;
+  // Compact tuples [input, output, cacheRead, cacheWrite] per LiteLLM id —
+  // the full feed caches to ~1MB instead of multi-MB objects.
+  exact: Record<string, [number, number, number, number]>;
+  deprecated?: string[];
+}
+
+function toPrice(t: [number, number, number, number]): ModelPrice {
+  return { input: t[0], output: t[1], cacheRead: t[2], cacheWrite: t[3] };
+}
+
+// Tolerate both cache shapes: compact tuples (new) and ModelPrice objects
+// (written by older refreshes) — a version bump never orphans the cache.
+function asPrice(v: unknown): ModelPrice | null {
+  if (Array.isArray(v) && v.length === 4 && v.every((n) => typeof n === 'number' && Number.isFinite(n) && n >= 0)) {
+    return toPrice(v as [number, number, number, number]);
+  }
+  if (v && typeof v === 'object') {
+    const o = v as Record<string, unknown>;
+    if (['input', 'output', 'cacheRead', 'cacheWrite'].every((k) => typeof o[k] === 'number' && Number.isFinite(o[k]) && (o[k] as number) >= 0)) {
+      return o as unknown as ModelPrice;
+    }
+  }
+  return null;
+}
+
+export function loadLivePrices(): LivePrices | null {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(pricesCachePath(), 'utf8');
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw) as { fetchedAt?: unknown; exact?: unknown; deprecated?: unknown };
+    if (typeof parsed.fetchedAt !== 'number' || !parsed.exact || typeof parsed.exact !== 'object') return null;
+    const exact: Record<string, [number, number, number, number]> = {};
+    for (const [k, v] of Object.entries(parsed.exact as Record<string, unknown>)) {
+      const p = asPrice(v);
+      if (p) exact[k] = [p.input, p.output, p.cacheRead, p.cacheWrite];
+    }
+    if (!Object.keys(exact).length) return null;
+    // Stale entries stay usable; refreshPricesIfStale refreshes in background.
+    const deprecated = Array.isArray(parsed.deprecated) ? (parsed.deprecated as unknown[]).filter((d): d is string => typeof d === 'string') : [];
+    return { fetchedAt: parsed.fetchedAt, exact, deprecated };
+  } catch {
+    return null;
+  }
+}
+
+function num(v: unknown): number | null {
+  return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : null;
+}
+
+export function priceFor(model: string, live?: LivePrices | null): { price: ModelPrice; known: boolean; live: boolean } {
+  const table = live === undefined ? loadLivePrices() : live;
+  if (table) {
+    const hit = asPrice(table.exact[model] ?? table.exact[model.toLowerCase()]);
+    if (hit) return { price: hit, known: true, live: true };
+    // Provider-prefixed ids ("azure/gpt-4o", "dashscope/qwen-max"): match the
+    // first cached id that ends with the bare model name.
+    const name = model.toLowerCase();
+    const key = Object.keys(table.exact).find((k) => k.toLowerCase() === name || k.toLowerCase().endsWith(`/${name}`));
+    const prefixed = key ? asPrice(table.exact[key]) : null;
+    if (prefixed) return { price: prefixed, known: true, live: true };
+  }
+  return { price: DEFAULT_PRICE, known: false, live: false };
+}
+// Fetch LiteLLM pricing, keep every id with valid input/output rates, write
+// the cache. False on any failure (offline, timeout, shape change) — callers
+// fall back silently.
+export async function refreshPrices(): Promise<boolean> {
+  if (refreshInflight) return refreshInflight;
+  refreshInflight = (async () => {
+    let res: Response;
+    try {
+      const ctl = new AbortController();
+      const timer = setTimeout(() => ctl.abort(), 15000);
+      try {
+        res = await fetch(pricesUrl(), { signal: ctl.signal });
+      } finally {
+        clearTimeout(timer);
+      }
+      if (!res.ok) return false;
+    } catch {
+      return false;
+    }
+    let data: Record<string, Record<string, unknown>>;
+    try {
+      data = (await res.json()) as Record<string, Record<string, unknown>>;
+    } catch {
+      return false;
+    }
+    const exact: Record<string, [number, number, number, number]> = {};
+    const deprecated: string[] = [];
+    for (const [id, row] of Object.entries(data)) {
+      if (!row || typeof row !== 'object') continue;
+      const input = num(row.input_cost_per_token);
+      const output = num(row.output_cost_per_token);
+      if (input === null || output === null) continue;
+      exact[id] = [
+        input * 1e6,
+        output * 1e6,
+        (num(row.cache_read_input_token_cost) ?? input) * 1e6,
+        (num(row.cache_creation_input_token_cost) ?? input) * 1e6,
+      ];
+      if (typeof row.deprecation_date === 'string' && row.deprecation_date) deprecated.push(id);
+    }
+    if (!Object.keys(exact).length) return false;
+    try {
+      fs.mkdirSync(path.dirname(pricesCachePath()), { recursive: true });
+      fs.writeFileSync(pricesCachePath(), JSON.stringify({ fetchedAt: Date.now(), exact, deprecated }), 'utf8');
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  try {
+    return await refreshInflight;
+  } finally {
+    refreshInflight = null;
+  }
+}
+
+// Fire-and-forget refresh when the cache is stale or missing. Readers keep
+// using the stale file (or the built-in table) — pricing never blocks.
+export function refreshPricesIfStale(): void {
+  const live = loadLivePrices();
+  if (live && Date.now() - live.fetchedAt <= CACHE_TTL_MS) return;
+  void refreshPrices().catch(() => false);
+}

package/extensions/shared/rtk-gain.ts

@@ -0,0 +1,105 @@
+// extensions/shared/rtk-gain.ts — measured RTK savings from its own store.
+// RTK records every invocation (input/output/saved tokens, savings %, exec
+// time) in history.db; `rtk gain` renders the same rows. We read them with
+// the sqlite3 CLI (present on macOS; best-effort elsewhere) so the dashboard
+// shows measured figures, never estimates. Missing DB/CLI → empty, no throw.
+//
+// Caveman and Ponytail have no per-command counters (instruction-following
+// isn't metered); their gains are bench-measured in BENCHMARK.md and cited
+// as static figures wherever RTK rows appear.
+//
+// Rows group by command alone, machine-wide: one row per command no matter
+// which repo ran it. Project filtering stays out — wasted column, same logic.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export interface RtkCommandRow {
+  command: string;
+  count: number;
+  saved: number;
+  avgPct: number;
+  avgMs: number;
+}
+
+export interface RtkGain {
+  commands: number;
+  input: number;
+  saved: number;
+  avgPct: number;
+  totalMs: number;
+  byCommand: RtkCommandRow[];
+}
+
+const EMPTY: RtkGain = { commands: 0, saved: 0, input: 0, avgPct: 0, totalMs: 0, byCommand: [] };
+
+// RTK stores the whole command line, and `rtk ls -d` with a long path list
+// runs to tens of KB. The table shows one clipped cell, so bound the string
+// before it crosses the sqlite3 CLI and lands in every /data.json poll.
+const MAX_CMD_CHARS = 200;
+
+// The query() reader is line- and tab-delimited, and RTK stores heredocs and
+// `node -e` scripts verbatim (~67 rows here), so one logical row can arrive as
+// several lines and derail every row after it. Fold whitespace into spaces
+// first: the stored command keeps its newlines, only the read view flattens.
+const CMD_ONE_LINE = `replace(replace(replace(rtk_cmd, char(10), ' '), char(13), ' '), char(9), ' ')`;
+
+export function rtkDbPath(): string {
+  const override = process.env.TERSIO_RTK_DB;
+  if (override) return override;
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'rtk', 'history.db');
+  }
+  const xdg = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
+  return path.join(xdg, 'rtk', 'history.db');
+}
+
+function query(db: string, sql: string): string[][] {
+  const out = execFileSync('sqlite3', ['-separator', '\t', db, sql], {
+    encoding: 'utf8',
+    timeout: 5000,
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return out
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => line.split('\t'));
+}
+
+export function readRtkGain(limit = 10, cutoffMs?: number): RtkGain {
+  try {
+    if (!fs.existsSync(rtkDbPath())) return EMPTY;
+    // View-level cutoff only: rows stay in rtk's own database untouched.
+    // strftime('%s') normalizes ISO-8601 timestamps to epoch seconds; rows
+    // with unparseable timestamps (0) drop out of a filtered view.
+    const where = cutoffMs && cutoffMs > 0
+      ? `WHERE CAST(strftime('%s', timestamp) AS INTEGER) >= ${Math.floor(cutoffMs / 1000)}`
+      : '';
+    const [[commands = '0', saved = '0', input = '0', avgPct = '0', totalMs = '0'] = []] = query(
+      rtkDbPath(),
+      `SELECT COUNT(*), COALESCE(SUM(saved_tokens),0), COALESCE(SUM(input_tokens),0), COALESCE(AVG(savings_pct),0), COALESCE(SUM(exec_time_ms),0) FROM commands ${where};`,
+    );
+    const byCommand = query(
+      rtkDbPath(),
+      `SELECT substr(${CMD_ONE_LINE}, 1, ${MAX_CMD_CHARS}), COUNT(*), COALESCE(SUM(saved_tokens),0), COALESCE(AVG(savings_pct),0), COALESCE(AVG(exec_time_ms),0) FROM commands ${where} GROUP BY rtk_cmd ORDER BY SUM(saved_tokens) DESC LIMIT ${Math.max(1, Math.floor(limit))};`,
+    ).map(([command, count, savedRow, pct, ms]) => ({
+      command,
+      count: Number(count) || 0,
+      saved: Number(savedRow) || 0,
+      avgPct: Number(pct) || 0,
+      avgMs: Number(ms) || 0,
+    }));
+    const totalIn = Number(input) || 0;
+    return {
+      commands: Number(commands) || 0,
+      saved: Number(saved) || 0,
+      input: totalIn,
+      avgPct: totalIn ? ((Number(saved) || 0) / totalIn) * 100 : 0,
+      totalMs: Number(totalMs) || 0,
+      byCommand,
+    };
+  } catch {
+    return EMPTY;
+  }
+}

package/extensions/shared/session-state.ts

@@ -0,0 +1,201 @@
+import type { ComboLevel, ComboState, ExtensionCtx, SessionEntry, UiApi } from './types.ts';
+
+const BRIDGE_KEY = Symbol.for('tersio/combo-session-state');
+
+export const OMP_SUBAGENT_MARKER = 'You are operating on a piece of work assigned to you by the main agent.';
+
+export const COMBO_LEVELS: Record<string, Readonly<ComboState>> = Object.freeze({
+  off: Object.freeze({ level: 'off', caveman: 'off', rtk: 'off', ponytail: 'off' }),
+  medium: Object.freeze({ level: 'medium', caveman: 'lite', rtk: 'on', ponytail: 'lite' }),
+  balanced: Object.freeze({ level: 'balanced', caveman: 'full', rtk: 'on', ponytail: 'full' }),
+  max: Object.freeze({ level: 'max', caveman: 'ultra', rtk: 'on', ponytail: 'ultra' }),
+});
+
+const MODE_VALUES: Record<string, Set<string>> = {
+  caveman: new Set(['off', 'lite', 'full', 'ultra', 'wenyan']),
+  rtk: new Set(['off', 'on']),
+  ponytail: new Set(['off', 'lite', 'full', 'ultra', 'review']),
+};
+
+type ModeName = 'caveman' | 'rtk' | 'ponytail';
+type Modes = Record<ModeName, string>;
+
+const MODE_ENTRY_TYPES: Record<string, ModeName> = {
+  'caveman-mode': 'caveman',
+  'rtk-mode': 'rtk',
+  'ponytail-mode': 'ponytail',
+};
+
+interface Bridge {
+  state: Readonly<ComboState>;
+  listeners: Set<(state: Readonly<ComboState>) => void>;
+}
+
+export function normalizeMode(name: ModeName, value: unknown): string | null {
+  if (name === 'rtk' && typeof value === 'boolean') return value ? 'on' : 'off';
+  const mode = String(value ?? '').trim().toLowerCase();
+  return MODE_VALUES[name]?.has(mode) ? mode : null;
+}
+
+export function deriveLevel(modes: Modes | null | undefined): ComboLevel {
+  for (const level of Object.keys(COMBO_LEVELS) as ComboLevel[]) {
+    const preset = COMBO_LEVELS[level];
+    if (preset.caveman === modes?.caveman && preset.rtk === modes?.rtk && preset.ponytail === modes?.ponytail) return level;
+  }
+  return 'custom';
+}
+
+function isPresetLevel(value: string): value is ComboLevel {
+  return Object.prototype.hasOwnProperty.call(COMBO_LEVELS, value);
+}
+
+function isKnownLevel(value: string): boolean {
+  return value === 'custom' || isPresetLevel(value);
+}
+
+function normalizedState(modes: Partial<Modes> | null | undefined, level: ComboLevel = deriveLevel(modes as Modes)): Readonly<ComboState> {
+  const state: Modes = {
+    caveman: normalizeMode('caveman', modes?.caveman) || 'off',
+    rtk: normalizeMode('rtk', modes?.rtk) || 'off',
+    ponytail: normalizeMode('ponytail', modes?.ponytail) || 'off',
+  };
+  return Object.freeze({ level: isKnownLevel(level) ? level : deriveLevel(state), ...state });
+}
+
+function bridge(): Bridge {
+  const existing = (globalThis as Record<symbol, unknown>)[BRIDGE_KEY] as Bridge | undefined;
+  if (existing?.state) return existing;
+  const initial = normalizedState((existing || COMBO_LEVELS.off) as Partial<Modes>);
+  return ((globalThis as Record<symbol, unknown>)[BRIDGE_KEY] = { state: initial, listeners: new Set<(state: Readonly<ComboState>) => void>() });
+}
+
+function publish(state: Readonly<ComboState>): Readonly<ComboState> {
+  const shared = bridge();
+  shared.state = state;
+  for (const listener of shared.listeners) listener(state);
+  return state;
+}
+
+export function normalizeInputCommand(value: unknown): string {
+  return String(value || '').trim().toLowerCase().replace(/[.!?\s]+$/, '');
+}
+
+export function asPromptArray(systemPrompt: string | string[]): string[] {
+  return Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+}
+
+export function systemPromptIncludes(systemPrompt: string | string[], marker: string): boolean {
+  return asPromptArray(systemPrompt).some((prompt) => typeof prompt === 'string' && prompt.includes(marker));
+}
+
+export function isOmpSubagentPrompt(systemPrompt: string | string[]): boolean {
+  return systemPromptIncludes(systemPrompt, OMP_SUBAGENT_MARKER);
+}
+
+export function normalizeComboLevel(value: unknown): ComboLevel | null {
+  const level = String(value || '').trim().toLowerCase();
+  return isPresetLevel(level) ? level : null;
+}
+
+export function paintStatusBar(ui: UiApi | undefined, key: string, emoji: string, label: string, isActive: boolean): void {
+  const theme = ui?.theme;
+  const indicator = isActive && theme?.fg ? theme.fg('accent', emoji) : emoji;
+  ui?.setStatus?.(key, theme?.fg ? `${indicator} ${theme.fg('muted', label)}` : `${indicator} ${label}`);
+}
+
+// Which context a status bar should remember to paint through.
+//
+// A UI-less event — a headless child session_start, or a top-level
+// session_start that fires before the TUI attaches — must never become the
+// remembered context. Two things went wrong when it did: the old
+// `ctx || lastCtx` fallback only triggered for a *falsy* ctx, so a truthy
+// ctx without `ui` returned early anyway, and remembering it destroyed the one
+// paintable context we had. Every later bare syncStatus() then went mute —
+// and the bare call is the bridge-listener path, which is how a mode change
+// made by a sibling extension reaches this bar. The symptom is a bar frozen on
+// a preset the session no longer has: it shows "combo BALANCED" while caveman
+// and rtk are already off.
+export function paintableCtx(remembered: ExtensionCtx | undefined, next: ExtensionCtx | undefined): ExtensionCtx | undefined {
+  return next?.ui?.setStatus ? next : remembered;
+}
+
+// Last-wins scan for a custom session entry; skips entries whose value fails
+// to parse so a corrupt write never shadows an older valid one.
+export function lastCustomValue<T>(entries: SessionEntry[] | null | undefined, customType: string, pick: (data: SessionEntry['data']) => T | null | undefined): T | null {
+  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 !== customType) continue;
+    const value = pick(entry?.data);
+    if (value !== null && value !== undefined) return value;
+  }
+  return null;
+}
+
+export function sessionEntries(ctx: ExtensionCtx | undefined): SessionEntry[] {
+  return ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+}
+
+export function getSharedComboState(): Readonly<ComboState> {
+  return bridge().state;
+}
+
+export function isComboPresetActive(): boolean {
+  const level = getSharedComboState().level;
+  return level !== 'off' && isPresetLevel(level);
+}
+
+export function setSharedComboLevel(value: unknown): Readonly<ComboState> {
+  const level = normalizeComboLevel(value) || 'off';
+  return publish(normalizedState(COMBO_LEVELS[level] as Partial<Modes>, level));
+}
+
+export function setSharedComboMode(name: ModeName, value: unknown): Readonly<ComboState> {
+  const mode = normalizeMode(name, value);
+  if (!mode) return getSharedComboState();
+  const modes = { ...getSharedComboState(), [name]: mode } as Modes;
+  // Derive the level from the final triplet so a redundant same-value write
+  // (entry replay on resume, upstream ponytail re-affirming its mode) cannot
+  // strand a matching preset at 'custom' and drop the combo bar.
+  return publish(normalizedState(modes));
+}
+
+export function reconcileSharedComboEntries(entries: SessionEntry[] | null | undefined): Readonly<ComboState> {
+  let modes: Modes = { ...COMBO_LEVELS.off };
+  if (Array.isArray(entries)) {
+    for (const entry of entries) {
+      if (entry?.type !== 'custom') continue;
+      if (entry.customType === 'combo-level') {
+        const preset = normalizeComboLevel(entry?.data?.level);
+        if (preset) modes = { ...COMBO_LEVELS[preset] };
+        continue;
+      }
+      const name = MODE_ENTRY_TYPES[entry.customType ?? ''] ?? null;
+      if (!name) continue;
+      const value = name === 'rtk' ? entry?.data?.enabled : entry?.data?.mode;
+      const mode = normalizeMode(name, value);
+      if (mode) modes[name] = mode;
+    }
+  }
+  // The level always reflects the final mode triplet, never the write order:
+  // a preset entry followed by the same values reconciles back to the preset.
+  return publish(normalizedState(modes));
+}
+
+// One-line session-wide mode summary for change confirmations, e.g.
+// `caveman=ULTRA, rtk=ON, ponytail=ULTRA`.
+export function activeModesSummary(state: { caveman: string; rtk: string; ponytail: string }): string {
+  return `caveman=${state.caveman.toUpperCase()}, rtk=${state.rtk.toUpperCase()}, ponytail=${state.ponytail.toUpperCase()}`;
+}
+
+export function setSharedComboListener(listener: ((state: Readonly<ComboState>) => void) | null): void {
+  // Additive: every sibling extension syncs its local mirror on publish, so
+  // a /tersio or /combo switch takes effect next turn with no session reload.
+  // A null listener clears all (no current callers; reserved for teardown).
+  if (typeof listener === 'function') bridge().listeners.add(listener);
+  else bridge().listeners.clear();
+}
+
+export function resetSharedComboState(): Readonly<ComboState> {
+  return setSharedComboLevel('off');
+}

package/extensions/shared/types.ts

@@ -0,0 +1,85 @@
+// Shared OMP extension host types. Structural — the real `pi` object comes
+// from the OMP runtime; these describe the surface this package touches.
+
+export interface ComboState {
+  level: string;
+  caveman: string;
+  rtk: string;
+  ponytail: string;
+}
+
+export type ComboLevel = 'off' | 'medium' | 'balanced' | 'max' | 'custom';
+
+export type SessionEntry = {
+  type: string;
+  customType?: string;
+  data?: {
+    mode?: string;
+    enabled?: boolean;
+    level?: string;
+    [key: string]: unknown;
+  };
+};
+
+export interface UiApi {
+  setStatus?: (name: string, value: string | undefined) => void;
+  notify?: (message: string, level?: string) => void;
+  theme?: {
+    fg?: (role: string, text: string) => string;
+  };
+}
+
+export interface ExtensionCtx {
+  hasUI?: boolean;
+  cwd?: string;
+  sessionManager?: {
+    getBranch?: () => SessionEntry[];
+    getEntries?: () => SessionEntry[];
+  };
+  ui?: UiApi;
+  reload?: () => Promise<void>;
+}
+
+export interface SystemPromptEvent {
+  systemPrompt: string | string[];
+}
+
+export interface InputEvent {
+  text?: string;
+  source?: string;
+}
+
+export interface ExtensionApi {
+  setLabel?: (label: string) => void;
+  registerCommand?: (name: string, config: {
+    description: string;
+    handler: (args: string, ctx: ExtensionCtx) => Promise<void>;
+  }) => void;
+  registerTool?: (tool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: unknown;
+    execute: (
+      toolCallId: string,
+      params: { args: string[] },
+      signal: AbortSignal,
+      onUpdate: ((data: unknown) => void) | undefined,
+      ctx: ExtensionCtx | undefined,
+    ) => Promise<{
+      isError: boolean;
+      content: { type: string; text: string }[];
+      details: Record<string, unknown>;
+    }>;
+  }) => void;
+  appendEntry?: (customType: string, data: Record<string, unknown>) => void;
+  exec?: (cmd: string, args: string[], opts?: { signal?: AbortSignal; cwd?: string }) => Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+    killed?: boolean;
+  }>;
+  cwd?: string;
+  zod?: { z: unknown };
+  on<E>(event: string, handler: (event: E, ctx: ExtensionCtx) => unknown): void;
+}