@krtclcdy/tersio 2.25.5 → 2.25.6

package/dist/extensions/shared/brand-marks.js

@@ -1,10 +1,4 @@
-// Brand mark catalog: names, not bytes. One list serves both consumers — the dashboard draws from
-// it at runtime, and the CLI export inlines the same URLs so a single-file dashboard keeps its
-// logos with the network off. Simple Icons files are CC0-1.0; the marks stay their owners'
-// property and the dashboard uses them nominatively, to name the service that served a request.
-// A vendor with no Simple Icons entry keeps its owner-hosted mark, one with no hosted mark is
-// drawn inline (`dashboard/app/src/lib/marks/inline.ts`), and bumping `SIMPLE_ICONS` once moves
-// every Simple Icons entry with it.
+// Brand mark catalog: names not bytes; Simple Icons files are CC0-1.0, marks remain their owners'.
 const SIMPLE_ICONS = "https://cdn.jsdelivr.net/npm/simple-icons@16/icons";
 /** Slug to mark URL. Only slugs named here resolve to a mark; the rest get a monogram. */
 export const REMOTE_MARKS = {
@@ -33,6 +27,8 @@ export const REMOTE_MARKS = {
     // Owner-hosted, nominative use.
     groq: "https://groq.com/favicon.svg",
     poolside: "https://poolside.ai/favicon/favicon.svg",
+    // AWS owns Kiro; Wikimedia hosts its vector, as AWS serves only a 16x16 ICO that cannot grow into a tile.
+    amazonaws: "https://upload.wikimedia.org/wikipedia/commons/5/5c/AWS_Simple_Icons_AWS_Cloud.svg",
     cerebras: "https://cdn.sanity.io/images/e4qjo92p/production/e7a55ae5ab7e2c4fdfd4e66a51f628d1f2f44207-967x967.png?w=256&h=256&fit=max",
     inclusionai: "https://cdn-avatars.huggingface.co/v1/production/uploads/662e1f9da266499277937d33/fyKuazRifqiaIO34xrhhm.jpeg",
     // Owner avatars: the vendor or gateway posts no standalone icon, so its account picture stands in.
@@ -46,13 +42,16 @@ export const REMOTE_MARKS = {
     magpie: "https://usemagpie.ai/favicon.png",
     gmicloud: "https://gmicloud.ai/favicon.ico",
     charmhyper: "https://github.com/charmbracelet.png?size=80",
+    // WorkBuddy's own favicon, a hashed asset on the Tencent CDN its page serves.
+    workbuddy: "https://download.codebuddy.ai/web/workbuddy/913b2390aae396c66b937bd9143ae5259306d7d7/assets/logo.svg",
+    // Trae's own favicon: a dark tile carrying its green mark, so the tile matches the artwork.
+    trae: "https://lf16-web-neutral.traecdn.ai/obj/trae-ai-static/trae_website/favicon.png",
+    // Kiro's own icon, a purple tile with the mark drawn inside it.
+    kiro: "https://kiro.dev/icon.svg",
+    // Meituan's own icon: its yellow tile with the logotype.
+    meituan: "https://s3plus.meituan.net/v1/mss_e2821d7f0cfe4ac1bf9202ecf9590e67/cdn-prod/file:1040877d/favicon-mt.ico",
 };
-/**
- * Tile fill, not text. A mark whose tile carries its brand color reads as the brand, and a mark
- * whose logo already fills its own box never shows the fill. Values come from the brand (the
- * service's own page or its own asset), never from a guess; a slug absent here keeps the plain
- * panel and the theme ink.
- */
+/** Tile fill per slug from the brand's own page, never a guess; an absent slug keeps the plain panel. */
 export const MARK_BG = {
     // Simple Icons marks: the vendor's brand color, taken from its own brand page.
     anthropic: "#d97757",
@@ -77,8 +76,7 @@ export const MARK_BG = {
     instagram: "#e4405f",
     reddit: "#ff4500",
     linkedin: "#0a66c2",
-    // Owner-hosted marks: the tile matches the asset's own square, and a slug whose artwork already
-    // carries its own color takes a white tile so the art reads.
+    // Owner-hosted marks match the asset's own square; art that already carries color takes a white tile.
     groq: "#f43e01",
     poolside: "#4137ff",
     cerebras: "#ffffff",
@@ -87,17 +85,21 @@ export const MARK_BG = {
     stepfun: "#ffffff",
     kilo: "#f7f576",
     opencode: "#131010",
+    // The AWS cloud mark draws its own orange and its own white, so the tile stays plain white.
+    amazonaws: "#ffffff",
     // The mark's own artwork is white, so the tile is white and the glyph is black.
     openai: "#ffffff",
     commandcode: "#ffffff",
     gmicloud: "#ffffff",
     magpie: "#0b0b0c",
+    // WorkBuddy's mark is a full-bleed teal tile carrying its own white art.
+    workbuddy: "#01c886",
+    // The mark is a full-bleed tile, so the tile fill repeats the artwork's own background.
+    trae: "#000000",
+    kiro: "#9046ff",
+    meituan: "#ffd100",
 };
-/**
- * Glyph scale per slug, applied to the glyph box the tile clips. Simple Icons art fills its 24 box
- * by very different amounts, so the measured ink box decides the scale: a logo that runs to its
- * box edge shrinks and one with an invisible margin grows. One is the default.
- */
+/** Glyph scale per slug over the tile clip; the measured ink box decides, and one is the default. */
 export const MARK_SCALE = {
     kimi: 0.72,
     zdotai: 0.72,
@@ -113,20 +115,11 @@ export function luminance(hex) {
     });
     return 0.2126 * ch[0] + 0.7152 * ch[1] + 0.0722 * ch[2];
 }
-/**
- * The glyph color that stays legible on a tile fill. The cut sits at 0.35, which keeps white ink
- * on a brand color: Meta blue, DeepSeek blue, Xiaomi orange, Mistral orange, and Kimi blue all
- * carry a white logo, which is how their own brand sheets print them. Only a light neutral takes
- * black: Kilo yellow, StepFun teal, and Lightbend orange.
- */
+/** The ink legible on a tile fill: luminance above 0.35 takes black, else white. */
 export function contrastInk(hex) {
     return luminance(hex) > 0.35 ? "#000000" : "#ffffff";
 }
-/**
- * Marks that carry their own color or their own background. Everything else is opaque black, so
- * it draws as an alpha mask filled with the chosen ink instead of an image. A slug whose asset is
- * a filled tile must draw as an image, or the mask paints one flat block and the logo vanishes.
- */
+/** Marks carrying their own color or background; a filled-tile asset must draw as an image, not a mask. */
 export const COLORED_MARKS = new Set([
     "cerebras",
     "inclusionai",
@@ -137,12 +130,18 @@ export const COLORED_MARKS = new Set([
     "magpie",
     "charmhyper",
     "stepfun",
-    // The ICO and the two inline PNGs are dark tiles with light art drawn inside them. The Groq
-    // favicon is one flat orange, so it draws as a mask instead: a masked glyph on a Groq-orange
-    // tile is a logo, and the same art as an image on the same orange tile is a blank tile.
+    // The ICO and inline PNGs are dark tiles with light art; flat-orange Groq draws as a mask instead.
     "gmicloud",
     "stealth",
     "cognition",
+    // A full-bleed teal tile with its own white art, so a mask would flatten both into one ink.
+    "workbuddy",
+    // Each is a full-bleed brand tile with its own ink, so a mask would flatten both into one color.
+    "trae",
+    "kiro",
+    "meituan",
+    // Carries its own orange and its own white, so a mask would flatten both into one ink.
+    "amazonaws",
 ]);
 /** The URL a mark comes from, or null when the name has no hosted mark. */
 export function markUrl(slug) {

package/dist/extensions/shared/carbon.js

@@ -23,7 +23,7 @@ const GRIDS = {
 export const SERVING_CONCURRENCY = 32;
 /** EcoLogits release this port tracks, so a UI can name it instead of guessing. */
 export const ECOLOGITS_VERSION = '0.8.2';
-// Registry values verbatim from EcoLogits' model_repository; borrows cite the public param disclosure they stand in for (MoE active/total).
+// Verbatim from EcoLogits' model_repository; borrows cite the param disclosure they replace (MoE active/total).
 const TABLE = [
     { match: 'opus', active: 625.0, total: 2000, provider: 'anthropic', source: 'registry' },
     { match: 'sonnet', active: 137.5, total: 440, provider: 'anthropic', source: 'registry' },

package/dist/extensions/shared/plugin-settings.js

@@ -7,7 +7,7 @@ export const PLUGIN_NAME = '@krtclcdy/tersio';
 export function tersioSettingsFile() {
     return path.join(tersioHome(), 'settings.json');
 }
-// Older installs kept these as OMP plugin settings; still read so switching the store does not reset a user's defaults.
+// Older installs kept these as OMP plugin settings; still read so switching stores does not reset a user's defaults.
 function legacyOmpSettings() {
     const configHome = process.env.XDG_CONFIG_HOME || path.join(homeDir(), '.config');
     for (const p of [
@@ -38,13 +38,15 @@ function readSettingsFile() {
         return null;
     }
 }
-// The stored settings; empty when the file is missing, corrupt, or empty.
+// The stored settings; {} when the file is missing or corrupt.
 export function readPluginSettings() {
     return readSettingsFile() ?? legacyOmpSettings() ?? {};
 }
 const COMBO_LEVELS = new Set(['off', 'medium', 'balanced', 'max']);
 const CAVEMAN_MODES = new Set(['off', 'lite', 'full', 'ultra', 'megacave', 'megacave-lite', 'megacave-full', 'megacave-ultra', 'wenyan', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']);
 const PONYTAIL_MODES = new Set(['off', 'lite', 'full', 'ultra']);
+// Opt-in only: no combo preset writes this, so it never reaches a user who did not ask for it.
+const PSTACK_MODES = new Set(['off', 'on']);
 function readStringDefault(key, valid) {
     const raw = readPluginSettings()[key];
     return typeof raw === 'string' && valid.has(raw) ? raw : 'off';
@@ -62,14 +64,17 @@ export function readRtkDefault() {
 export function readPonytailDefault() {
     return readStringDefault('ponytailDefault', PONYTAIL_MODES);
 }
+export function readPstackDefault() {
+    return readStringDefault('pstackDefault', PSTACK_MODES);
+}
 export function isComboSetupComplete() {
     return readPluginSettings().comboSetupComplete === true;
 }
 const COMBO_MODE_DEFAULTS = {
-    off: { cavemanDefault: 'off', rtkDefault: false, ponytailDefault: 'off' },
-    medium: { cavemanDefault: 'lite', rtkDefault: true, ponytailDefault: 'lite' },
-    balanced: { cavemanDefault: 'full', rtkDefault: true, ponytailDefault: 'full' },
-    max: { cavemanDefault: 'ultra', rtkDefault: true, ponytailDefault: 'ultra' },
+    off: { cavemanDefault: 'off', rtkDefault: false, ponytailDefault: 'off', pstackDefault: 'off' },
+    medium: { cavemanDefault: 'lite', rtkDefault: true, ponytailDefault: 'lite', pstackDefault: 'on' },
+    balanced: { cavemanDefault: 'full', rtkDefault: true, ponytailDefault: 'full', pstackDefault: 'on' },
+    max: { cavemanDefault: 'ultra', rtkDefault: true, ponytailDefault: 'ultra', pstackDefault: 'on' },
 };
 export function saveComboSetup(level) {
     if (!(level in COMBO_MODE_DEFAULTS))

package/dist/extensions/shared/pricing.js

@@ -1,13 +1,13 @@
-// extensions/shared/pricing.ts — dynamic model pricing from LiteLLM. Exact id → provider-prefix strip → default, reported with known:false when unpriced.
+// pricing.ts — model pricing from LiteLLM. Exact id → prefix strip → default, known:false if unpriced.
 import fs from 'node:fs';
 import path from 'node:path';
 import { tersioDataPath } from './utils.js';
 // Sonnet-class default for unpriced models; always paired with known:false.
 export const DEFAULT_PRICE = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
-/** Tiers firm enough to call a price. `tail` and `default` are estimates, so they are not. */
+/** Tiers firm enough to call a price; `tail` and `default` are estimates. */
 export const PRICE_TIERS_FIRM = ['measured', 'override', 'exact', 'alias'];
 const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
-// Readers use the file even when stale, and only one refresh runs per process; `tersio update` still forces a fresh fetch.
+// Readers use the file even when stale; one refresh per process. `tersio update` still forces a fresh fetch.
 const CACHE_TTL_MS = 7 * 24 * 3600 * 1000;
 let refreshInflight = null;
 export function pricesCachePath() {
@@ -16,11 +16,7 @@ export function pricesCachePath() {
         return override;
     return tersioDataPath('prices.json', 'tersio-prices.json');
 }
-/**
- * The operator's own prices, merged over the feed and keyed exactly as the transcript spells a
- * model. A `*` prefix matches any gateway suffix. This is where a model the feed keys under a
- * different provider gets a real price.
- */
+/** Operator prices keyed as the transcript spells a model; a `*` prefix matches any gateway suffix. */
 export function pricesOverridePath() {
     const override = process.env.TERSIO_PRICES_OVERRIDE_FILE;
     if (override)
@@ -52,7 +48,6 @@ function loadOverrides(stamp = overrideStamp()) {
             const price = asPrice(row);
             if (!price)
                 continue;
-            // A `*` prefix matches any gateway prefix, so one entry covers every spelling of a model.
             if (id.startsWith('*'))
                 tails.push([id.slice(1).toLowerCase(), price]);
             else
@@ -159,7 +154,7 @@ export function priceFor(model, live) {
     }
     return resolvePrice(model, table, overrideStamp());
 }
-// Recent rows repeat a handful of models; the memo turns thousands of lookups into one per model. Cleared whenever the table identity changes.
+// Recent rows repeat a few models; the memo turns thousands of lookups into one per model. Cleared on table change.
 let memoTable;
 let memoStamp = 0;
 let memo = new Map();
@@ -193,21 +188,18 @@ function resolvePrice(model, table, stamp = overrideStamp()) {
             }
         }
     }
-    // An alias goes through the same chain as any other id, so it still resolves when the feed keys
-    // it under a provider prefix.
+    // An alias runs the same chain, so it still resolves when the feed keys it under a provider prefix.
     const alias = MODEL_ALIASES.find((a) => a.id === model.toLowerCase());
     const id = alias?.feed ?? model;
     if (table) {
         const entries = priceEntries(table);
-        // 1. The id verbatim, then case-folded. Nothing is being guessed here.
+        // The id verbatim, then case-folded; nothing guessed.
         const hit = entries.find(([k]) => k === id) ?? entries.find(([k]) => k === id.toLowerCase());
         if (hit)
             return { price: hit[1], known: true, live: true, tier: alias ? 'alias' : 'exact' };
         const lower = id.toLowerCase();
         const tail = lower.split('/').pop() ?? lower;
-        // The bare model name under any provider, which need not be the provider that billed the row.
-        // Reported as tier `tail`, so a caller keeps it out of a firm total; `prices.local.json` fixes
-        // a specific case.
+        // Bare name under any provider (need not be the billing one); tier `tail` keeps it out of a firm total.
         const bare = entries.find(([k]) => {
             const lk = k.toLowerCase();
             return lk === tail || lk.endsWith(`/${tail}`);

package/dist/extensions/shared/rtk-gain.js

@@ -1,10 +1,10 @@
 // Savings read from rtk history, never estimated; modes bench in docs/BENCHMARK.md.
-import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { sqliteRead } from './sqlite.js';
 const EMPTY = { commands: 0, saved: 0, input: 0, avgPct: 0, totalMs: 0, byCommand: [] };
-// The table shows one clipped cell, so bound the command before it crosses the sqlite3 CLI and lands in every /data.json poll.
+// The table shows one clipped cell, so bound the command before it reaches /data.json.
 const MAX_CMD_CHARS = 200;
 // A multi-line stored command would derail every row after it; flatten on read.
 const CMD_ONE_LINE = `replace(replace(replace(rtk_cmd, char(10), ' '), char(13), ' '), char(9), ' ')`;
@@ -19,12 +19,7 @@ export function rtkDbPath() {
     return path.join(xdg, 'rtk', 'history.db');
 }
 function query(db, sql) {
-    const out = execFileSync('sqlite3', ['-separator', '\t', db, sql], {
-        encoding: 'utf8',
-        timeout: 5000,
-        stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    return out
+    return sqliteRead(db, sql)
         .split('\n')
         .filter((line) => line.trim())
         .map((line) => line.split('\t'));
@@ -33,7 +28,7 @@ export function readRtkGain(limit = 10, cutoffMs) {
     try {
         if (!fs.existsSync(rtkDbPath()))
             return EMPTY;
-        // View-level cutoff only: rtk's own rows stay untouched. Timestamps that do not parse land on 0 and drop out of a filtered view.
+        // View-level cutoff only: rtk's rows stay untouched. Unparseable timestamps land on 0 and drop from filtered views.
         const where = cutoffMs && cutoffMs > 0
             ? `WHERE CAST(strftime('%s', timestamp) AS INTEGER) >= ${Math.floor(cutoffMs / 1000)}`
             : '';

package/dist/extensions/shared/session-state.js

@@ -1,17 +1,19 @@
 import { readPluginSettings } from './plugin-settings.js';
 const BRIDGE_KEY = Symbol.for('tersio/combo-session-state');
-// A verbatim sentence from omp's subagent prompt, so it can drift; read from the installed omp binary on 2026-10-01. pi has no built-in subagent prompt.
+// A verbatim sentence from omp's subagent prompt, so it can drift; read from the installed omp binary on 2026-10-01.
 export const OMP_SUBAGENT_MARKER = 'Worker agent: delegated tasks.';
+// Every level above off turns pstack on with the other three; off is the one level without it.
 export const COMBO_LEVELS = 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' }),
+    off: Object.freeze({ level: 'off', caveman: 'off', rtk: 'off', ponytail: 'off', pstack: 'off' }),
+    medium: Object.freeze({ level: 'medium', caveman: 'lite', rtk: 'on', ponytail: 'lite', pstack: 'on' }),
+    balanced: Object.freeze({ level: 'balanced', caveman: 'full', rtk: 'on', ponytail: 'full', pstack: 'on' }),
+    max: Object.freeze({ level: 'max', caveman: 'ultra', rtk: 'on', ponytail: 'ultra', pstack: 'on' }),
 });
 const MODE_VALUES = {
     caveman: new Set(['off', 'lite', 'full', 'ultra', 'megacave', 'megacave-lite', 'megacave-full', 'megacave-ultra', 'wenyan', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']),
     rtk: new Set(['off', 'on']),
     ponytail: new Set(['off', 'lite', 'full', 'ultra']),
+    pstack: new Set(['off', 'on']),
 };
 // Upstream renamed wenyan to megacave and kept the old spelling as an alias.
 const CAVEMAN_LEGACY_PREFIX = /^wenyan/;
@@ -19,6 +21,7 @@ const MODE_ENTRY_TYPES = {
     'caveman-mode': 'caveman',
     'rtk-mode': 'rtk',
     'ponytail-mode': 'ponytail',
+    'pstack-mode': 'pstack',
 };
 /** True when the branch carries Tersio's own mode state; a subagent starts without it. */
 export function hasModeState(entries) {
@@ -39,7 +42,7 @@ export function normalizeMode(name, value) {
 export function deriveLevel(modes) {
     for (const level of Object.keys(COMBO_LEVELS)) {
         const preset = COMBO_LEVELS[level];
-        if (preset.caveman === modes?.caveman && preset.rtk === modes?.rtk && preset.ponytail === modes?.ponytail)
+        if (preset.caveman === modes?.caveman && preset.rtk === modes?.rtk && preset.ponytail === modes?.ponytail && preset.pstack === modes?.pstack)
             return level;
     }
     return 'custom';
@@ -55,6 +58,7 @@ function normalizedState(modes, level = deriveLevel(modes)) {
         caveman: normalizeMode('caveman', modes?.caveman) || 'off',
         rtk: normalizeMode('rtk', modes?.rtk) || 'off',
         ponytail: normalizeMode('ponytail', modes?.ponytail) || 'off',
+        pstack: normalizeMode('pstack', modes?.pstack) || 'off',
     };
     return Object.freeze({ level: isKnownLevel(level) ? level : deriveLevel(state), ...state });
 }
@@ -98,7 +102,7 @@ export function normalizeComboLevel(value) {
         return level;
     return COMBO_ALIASES[level] ?? null;
 }
-// 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.
+// Last-wins scan for a custom session entry; skips unparseable values so a corrupt write never shadows a valid one.
 export function lastCustomValue(entries, customType, pick) {
     if (!Array.isArray(entries))
         return null;
@@ -131,7 +135,7 @@ export function setSharedComboMode(name, value) {
     if (!mode)
         return getSharedComboState();
     const modes = { ...getSharedComboState(), [name]: mode };
-    // Derive the level from the final triplet so a redundant same-value write cannot strand a matching preset at 'custom' and drop the combo bar.
+    // Derive the level from the final quartet, so a redundant same-value write cannot strand a preset at 'custom'.
     return publish(normalizedState(modes));
 }
 export function setSharedComboModes(modes) {
@@ -139,6 +143,7 @@ export function setSharedComboModes(modes) {
         caveman: normalizeMode('caveman', modes.caveman) || 'off',
         rtk: normalizeMode('rtk', modes.rtk) || 'off',
         ponytail: normalizeMode('ponytail', modes.ponytail) || 'off',
+        pstack: normalizeMode('pstack', modes.pstack) || 'off',
     }));
 }
 export function reconcileSharedComboEntries(entries) {
@@ -162,12 +167,12 @@ export function reconcileSharedComboEntries(entries) {
                 modes[name] = mode;
         }
     }
-    // The level reflects the final triplet, never the write order, so a preset entry followed by the same values reconciles back to the preset.
+    // The level reflects the final quartet, not write order, so a preset followed by the same values reconciles back.
     return publish(normalizedState(modes));
 }
 // One-line session-wide mode summary for change confirmations.
 export function activeModesSummary(state) {
-    return `caveman=${state.caveman.toUpperCase()}, rtk=${state.rtk.toUpperCase()}, ponytail=${state.ponytail.toUpperCase()}`;
+    return `caveman=${state.caveman.toUpperCase()}, rtk=${state.rtk.toUpperCase()}, ponytail=${state.ponytail.toUpperCase()}, pstack=${state.pstack.toUpperCase()}`;
 }
 // Keyed registration drops stale closures; hosts offer no teardown hook.
 export function setSharedComboListener(key, listener) {

package/dist/extensions/shared/sqlite.js

@@ -0,0 +1,168 @@
+// One place that runs SQL against a database file.
+//
+// Bun and Node 22.5+ carry SQLite in process, so the `sqlite3` binary is a fallback rather than a
+// requirement: hosts without it kept silently reading nothing. Reads come back exactly as the sqlite3
+// CLI printed them -- rows on their own lines, cells joined by tabs, NULL an empty cell, one trailing
+// newline -- because every caller already parses that shape. The engine rungs take one statement per
+// read, so a caller with several queries calls once per query.
+//
+// The write path leaves the journal mode alone. The store's own schema sets WAL so a reader (the
+// dashboard) never blocks a writer, and changing the mode needs exclusive access: with a reader holding
+// the file the pragma fails, which is a failure reported after the caller's rows have already committed.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+/** A read this large used to vanish behind a 1MB cap, which cleared on one busy session_message table. */
+const SQLITE_READ_BUFFER = 50 * 1024 * 1024;
+const TIMEOUT = 30_000;
+const requireOptional = createRequire(import.meta.url);
+let cached;
+let cachedFor;
+/** Bun's SQLite, or Node's when this build carries one. Null when neither runtime has an engine. */
+function engine() {
+    const asked = process.env.TERSIO_SQLITE ?? '';
+    if (cached !== undefined && cachedFor === asked)
+        return cached;
+    cachedFor = asked;
+    cached = null;
+    if (asked === 'cli')
+        return cached;
+    try {
+        const { Database } = requireOptional('bun:sqlite');
+        cached = {
+            kind: 'bun',
+            read: (db, sql) => { const d = new Database(db, { readonly: true }); try {
+                return d.query(sql).values();
+            }
+            finally {
+                d.close();
+            } },
+            exec: (db, sql) => { const d = new Database(db); try {
+                d.exec(sql);
+            }
+            finally {
+                d.close();
+            } },
+        };
+        return cached;
+    }
+    catch { /* not Bun, or no SQLite in this build */ }
+    try {
+        const { DatabaseSync } = requireOptional('node:sqlite');
+        // Rows arrive keyed by column name unless the statement returns arrays. A duplicate name collapses
+        // its key and shifts every later cell, so a Node that cannot return arrays is no engine at all.
+        const probe = new DatabaseSync(':memory:');
+        try {
+            if (typeof probe.prepare('SELECT 1').setReturnArrays !== 'function')
+                throw new Error('no positional rows');
+        }
+        finally {
+            probe.close();
+        }
+        cached = {
+            kind: 'node',
+            read: (db, sql) => {
+                const d = new DatabaseSync(db, { readOnly: true });
+                try {
+                    const st = d.prepare(sql);
+                    st.setReturnArrays?.(true);
+                    return st.all();
+                }
+                finally {
+                    d.close();
+                }
+            },
+            exec: (db, sql) => { const d = new DatabaseSync(db); try {
+                d.exec(sql);
+            }
+            finally {
+                d.close();
+            } },
+        };
+        return cached;
+    }
+    catch { /* Node older than 22.5, or one built without SQLite or positional rows */ }
+    return cached;
+}
+/** The `sqlite3` binary, resolved once from PATH so a missing one costs one scan, not one spawn per call. */
+let binary;
+function findBinary() {
+    if (binary !== undefined)
+        return binary;
+    binary = null;
+    for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of process.platform === 'win32' ? ['sqlite3.exe', 'sqlite3'] : ['sqlite3']) {
+            const at = path.join(dir, name);
+            try {
+                fs.accessSync(at, fs.constants.X_OK);
+                binary = at;
+                return binary;
+            }
+            catch { /* not here */ }
+        }
+    }
+    return binary;
+}
+/** `bun`, `node`, `cli`, or null when this host has no way to read SQLite at all. */
+export function sqliteEngine() {
+    return engine()?.kind ?? (findBinary() === null ? null : 'cli');
+}
+/** Whether any path can run SQL: what the tests guard their skips on. */
+export function sqliteAvailable() {
+    return sqliteEngine() !== null;
+}
+/** Rows as the CLI prints them, so a caller cannot tell which engine answered. */
+function toTsv(rows) {
+    if (rows.length === 0)
+        return '';
+    return `${rows.map((row) => row.map((cell) => (cell === null || cell === undefined ? '' : String(cell))).join('\t')).join('\n')}\n`;
+}
+function cliRead(db, sql) {
+    const opts = { encoding: 'utf8', timeout: TIMEOUT, stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: SQLITE_READ_BUFFER, input: sql };
+    try {
+        return execFileSync('sqlite3', ['-separator', '\t', '-readonly', db], opts);
+    }
+    catch { /* the side files may be gone; try the next rung */ }
+    if (!fs.existsSync(`${db}-wal`)) {
+        try {
+            return execFileSync('sqlite3', ['-separator', '\t', `file:${db}?immutable=1`], opts);
+        }
+        catch { /* fall through to the copy */ }
+    }
+    // A live database cannot be read without its write-ahead log, so copy the set and read the copy.
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tersio-sqlite-'));
+    const target = path.join(dir, path.basename(db));
+    try {
+        fs.copyFileSync(db, target);
+        for (const suffix of ['-wal', '-shm']) {
+            if (fs.existsSync(`${db}${suffix}`))
+                fs.copyFileSync(`${db}${suffix}`, `${target}${suffix}`);
+        }
+        return execFileSync('sqlite3', ['-separator', '\t', '-readonly', target], opts);
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Run a read and return the tab-separated rows. Throws when the file is missing, as the callers expect. */
+export function sqliteRead(db, sql) {
+    if (!fs.existsSync(db))
+        throw new Error(`missing database: ${db}`);
+    const e = engine();
+    if (e !== null)
+        return toTsv(e.read(db, sql));
+    return cliRead(db, sql);
+}
+/** Run a script, creating the file if needed. Stops at the first error, so a failed INSERT leaves no DELETEs. */
+export function sqliteExec(db, sql) {
+    const e = engine();
+    if (e !== null) {
+        e.exec(db, sql);
+        return;
+    }
+    execFileSync('sqlite3', ['-bail', db, sql], { stdio: ['ignore', 'ignore', 'ignore'], timeout: TIMEOUT });
+}

package/dist/extensions/shared/status.js

@@ -1,16 +1,16 @@
-// One status string every surface renders: host footer bar, CLI menu title, dashboard banner. Nothing else formats mode state.
+// One status string every surface renders: host footer, CLI title, dashboard banner. Nothing else formats mode state.
 import { getSharedComboState } from './session-state.js';
-/** OFF collapses the three modes into one word; a preset or a mix names itself. */
+/** OFF collapses every mode into one word; a preset or a mix names itself. */
 export function formatStatus(state) {
-    const { level, caveman, rtk, ponytail } = state;
-    if (level === 'off' && caveman === 'off' && rtk === 'off' && ponytail === 'off')
+    const { level, caveman, rtk, ponytail, pstack } = state;
+    if (level === 'off' && caveman === 'off' && rtk === 'off' && ponytail === 'off' && pstack === 'off')
         return '🧩 combo OFF';
     const label = level === 'custom' ? 'CUSTOM' : level.toUpperCase();
-    return `🧩 combo ${label}: 🪨caveman=${caveman.toUpperCase()} ⚡rtk=${rtk.toUpperCase()} 🦥ponytail=${ponytail.toUpperCase()}`;
+    return `🧩 combo ${label}: 🪨caveman=${caveman.toUpperCase()} ⚡rtk=${rtk.toUpperCase()} 🦥ponytail=${ponytail.toUpperCase()} 🥔pstack=${pstack.toUpperCase()}`;
 }
-// The string upstream's skill tells the model to relay for `/caveman status`.
+// The string upstream's skill tells the model to relay for `/caveman status`; `off` is a mode, so it reads as one.
 export function formatCavemanStatus(mode) {
-    return `Caveman mode: ${mode && mode !== 'off' ? mode : 'unknown'}`;
+    return `Caveman mode: ${mode || 'unknown'}`;
 }
 // Stale ctx access throws, so never let it abort a mode restore.
 function statusUi(ctx) {
@@ -27,6 +27,7 @@ let remembered;
 let lastText;
 let lastUi;
 // Paint the host footer bar; same text on the same UI is skipped, a new ctx repaints it.
+// One key only: the combo line already names the caveman mode, and a second key renders as a second footer line.
 export function announceStatus(ctx) {
     const state = getSharedComboState();
     const text = formatStatus(state);
@@ -40,5 +41,4 @@ export function announceStatus(ctx) {
     lastText = text;
     lastUi = ui;
     ui.setStatus?.('tersio', text);
-    ui.setStatus?.('caveman', formatCavemanStatus(state.caveman));
 }

package/dist/extensions/shared/types.js

@@ -1,2 +1,2 @@
-// Shared OMP extension host types. Structural — the real `pi` object comes from the OMP runtime; these describe the surface this package touches.
+// Shared OMP extension host types. Structural — the real `pi` object comes from the OMP runtime.
 export {};