@krtclcdy/tersio 2.25.1 → 2.25.3

package/{extensions → dist/extensions}/opencode/server.js

@@ -6,10 +6,10 @@ import comboToggleExtension from '../combo-toggle/index.js';
 import tersioCommandsExtension from '../tersio-commands/index.js';
 import { getSharedComboState } from '../shared/session-state.js';
 import { formatStatus } from '../shared/status.js';
-// Plain object, not Plugin.define: define is an identity wrapper, and a value
-// import would force every install to vendor the whole @opencode dependency tree.
+import { resolveRtkBinary } from '../lib/utils.js';
+// The npm name, so the plugin list reads the same as the OMP and pi installs.
 const plugin = {
-    id: 'tersio',
+    id: '@krtclcdy/tersio',
     async setup(ctx) {
         // Entries are scoped per session; an unseen ID restores on its first hook.
         const sessions = new Map();
@@ -20,7 +20,10 @@ const plugin = {
             if (own.length)
                 return own;
             // Pre-scoped installs kept one global list; adopt it once, then diverge.
+            // Clear it after adoption so it can never shadow saved defaults later.
             const legacy = (await ctx.storage.get('entries')) ?? [];
+            if (legacy.length)
+                void ctx.storage.set('entries', []).catch(() => { });
             return [...legacy];
         };
         const sessionEntriesOf = (sid) => {
@@ -185,6 +188,33 @@ const plugin = {
             for (const handler of inputHandlers)
                 void handler({ text: event.prompt.text, source: 'interactive' });
         });
+        // rtk has its own OpenCode plugin; doing this here keeps one entry in the plugin list.
+        await ctx.tool.hook('execute.before', async (event) => {
+            const tool = String(event.tool ?? '').toLowerCase();
+            if (tool !== 'bash' && tool !== 'shell')
+                return;
+            const input = event.input;
+            if (typeof input?.command !== 'string' || !input.command)
+                return;
+            const rewritten = await rewriteCommand(input.command);
+            if (rewritten)
+                input.command = rewritten;
+        });
     },
 };
+function rewriteCommand(command) {
+    const bin = resolveRtkBinary();
+    if (!bin)
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        execFile(bin, ['rewrite', command], { timeout: 5000 }, (error, stdout) => {
+            // A kill or timeout means untrustworthy output; pass the command through.
+            const err = error;
+            if (err && (err.killed || err.signal))
+                return resolve(null);
+            const out = String(stdout).trim();
+            resolve(out && out !== command ? out : null);
+        });
+    });
+}
 export default plugin;

package/dist/extensions/shared/headroom.js

@@ -0,0 +1,131 @@
+// Headroom is a local proxy that compresses input-side context. Agent-neutral core: one adapter row per agent, no agent name in the logic below.
+import { existsSync, readFileSync } from 'node:fs';
+import { patchPluginSettings, readPluginSettings } from './plugin-settings.js';
+export const HEADROOM_AGENTS = ['omp', 'pi', 'opencode'];
+export const HEADROOM_DEFAULT_PORT = 8787;
+/** Lowest Headroom the spike verified. */
+export const HEADROOM_MIN_VERSION = '0.40.0';
+/** Newest Headroom the spike verified; a newer one only warns. */
+export const HEADROOM_TESTED_VERSION = '0.40.0';
+/** What to say when the binary is absent. Headroom ships with the add-ons, so the fix is a Tersio install, not a hand-run Python tool. */
+export const HEADROOM_INSTALL_HINT = 'run `tersio install` (or `tersio update`) to add the bundled Headroom add-on';
+/** Native or manual, from the spike's `wrap` table. */
+export function headroomCapability(agent) {
+    return agent === 'pi' ? 'manual' : 'native';
+}
+export function isHeadroomAgent(value) {
+    return typeof value === 'string' && HEADROOM_AGENTS.includes(value);
+}
+/** `headroom 0.40.0` and a bare `0.40.0` both parse. */
+export function parseHeadroomVersion(raw) {
+    const match = /\d+\.\d+\.\d+/.exec(String(raw ?? ''));
+    return match ? match[0] : null;
+}
+export function compareVersions(a, b) {
+    const left = a.split('.').map((part) => Number.parseInt(part, 10) || 0);
+    const right = b.split('.').map((part) => Number.parseInt(part, 10) || 0);
+    for (let i = 0; i < 3; i += 1) {
+        const delta = (left[i] ?? 0) - (right[i] ?? 0);
+        if (delta !== 0)
+            return delta > 0 ? 1 : -1;
+    }
+    return 0;
+}
+export function headroomVersionIssue(version) {
+    if (!version)
+        return 'unknown';
+    if (compareVersions(version, HEADROOM_MIN_VERSION) < 0)
+        return 'old';
+    if (compareVersions(version, HEADROOM_TESTED_VERSION) > 0)
+        return 'newer';
+    return 'ok';
+}
+function asAgentState(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const value = raw;
+    return { enabled: value.enabled === true, wrappedByTersio: value.wrappedByTersio === true };
+}
+function asAgentMap(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (!isHeadroomAgent(key))
+            continue;
+        const state = asAgentState(value);
+        if (state)
+            out[key] = state;
+    }
+    return out;
+}
+export function readHeadroomConfig() {
+    const settings = readPluginSettings();
+    const port = Number(settings.headroomPort);
+    return {
+        support: settings.headroomSupport === true,
+        port: Number.isInteger(port) && port > 0 && port < 65536 ? port : HEADROOM_DEFAULT_PORT,
+        agents: asAgentMap(settings.headroom),
+    };
+}
+export function headroomAgentState(config, agent) {
+    return config.agents[agent] ?? { enabled: false, wrappedByTersio: false };
+}
+/** The one write path for the kill switch, the port, and the per-agent flags. Keeps unrelated settings keys intact. */
+export function writeHeadroomConfig(config) {
+    return patchPluginSettings({ headroomSupport: config.support, headroomPort: config.port, headroom: config.agents });
+}
+export function headroomProxyUrl(port = HEADROOM_DEFAULT_PORT) {
+    return `http://127.0.0.1:${port}`;
+}
+/** Fails open: a dead or absent proxy reports false, never an exception. */
+export async function headroomProxyUp(port = HEADROOM_DEFAULT_PORT, timeoutMs = 400) {
+    try {
+        const res = await fetch(`${headroomProxyUrl(port)}/health`, { signal: AbortSignal.timeout(timeoutMs) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export function headroomStatusSegment(state) {
+    if (state === null)
+        return null;
+    if (state === 'on')
+        return '🗜️ headroom=ON';
+    if (state === 'manual')
+        return '🗜️ headroom=ON (manual)';
+    if (state === 'down')
+        return '🗜️ headroom=DOWN';
+    return '🗜️ headroom=OFF';
+}
+// One process paints one status line, so a module mirror is enough. null means "no Headroom in this install".
+let status = null;
+export function getHeadroomStatus() {
+    return status;
+}
+export function setHeadroomStatus(next) {
+    status = next;
+}
+/** The status for one agent, from its stored flags. `off` when support is off or nothing is wired. */
+export function headroomStatusFor(config, agent, proxyUp) {
+    if (!config.support)
+        return 'off';
+    const state = headroomAgentState(config, agent);
+    if (!state.enabled)
+        return 'off';
+    return proxyUp ? (headroomCapability(agent) === 'manual' ? 'manual' : 'on') : 'down';
+}
+/** True when the agent's config file already carries a Headroom marker. */
+export function headroomWiringPresent(files) {
+    for (const file of files) {
+        try {
+            if (!existsSync(file))
+                continue;
+            if (/headroom|127\.0\.0\.1:8787/i.test(readFileSync(file, 'utf8')))
+                return true;
+        }
+        catch { /* unreadable counts as unwired */ }
+    }
+    return false;
+}

package/{extensions → dist/extensions}/shared/plugin-settings.js

@@ -43,7 +43,7 @@ export function readPluginSettings() {
     return readSettingsFile() ?? legacyOmpSettings() ?? {};
 }
 const COMBO_LEVELS = new Set(['off', 'medium', 'balanced', 'max']);
-const CAVEMAN_MODES = new Set(['off', 'lite', 'full', 'ultra', 'wenyan', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']);
+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']);
 function readStringDefault(key, valid) {
     const raw = readPluginSettings()[key];

package/{extensions → dist/extensions}/shared/session-state.js

@@ -9,10 +9,12 @@ export const COMBO_LEVELS = Object.freeze({
     max: Object.freeze({ level: 'max', caveman: 'ultra', rtk: 'on', ponytail: 'ultra' }),
 });
 const MODE_VALUES = {
-    caveman: new Set(['off', 'lite', 'full', 'ultra', 'wenyan', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']),
+    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']),
 };
+// Upstream renamed wenyan to megacave and kept the old spelling as an alias.
+const CAVEMAN_LEGACY_PREFIX = /^wenyan/;
 const MODE_ENTRY_TYPES = {
     'caveman-mode': 'caveman',
     'rtk-mode': 'rtk',
@@ -29,7 +31,10 @@ export function normalizeMode(name, value) {
     const mode = String(value ?? '').trim().toLowerCase();
     if (!MODE_VALUES[name]?.has(mode))
         return null;
-    return name === 'caveman' && mode === 'wenyan' ? 'wenyan-full' : mode;
+    if (name !== 'caveman')
+        return mode;
+    const canonical = mode.replace(CAVEMAN_LEGACY_PREFIX, 'megacave');
+    return canonical === 'megacave' ? 'megacave-full' : canonical;
 }
 export function deriveLevel(modes) {
     for (const level of Object.keys(COMBO_LEVELS)) {
@@ -127,6 +132,13 @@ export function setSharedComboMode(name, value) {
     // 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.
     return publish(normalizedState(modes));
 }
+export function setSharedComboModes(modes) {
+    return publish(normalizedState({
+        caveman: normalizeMode('caveman', modes.caveman) || 'off',
+        rtk: normalizeMode('rtk', modes.rtk) || 'off',
+        ponytail: normalizeMode('ponytail', modes.ponytail) || 'off',
+    }));
+}
 export function reconcileSharedComboEntries(entries) {
     let modes = { ...COMBO_LEVELS.off };
     if (Array.isArray(entries)) {

package/{extensions → dist/extensions}/shared/status.js

@@ -8,6 +8,10 @@ export function formatStatus(state) {
     const label = level === 'custom' ? 'CUSTOM' : level.toUpperCase();
     return `🧩 combo ${label}: 🪨caveman=${caveman.toUpperCase()} ⚡rtk=${rtk.toUpperCase()} 🦥ponytail=${ponytail.toUpperCase()}`;
 }
+// The string upstream's skill tells the model to relay for `/caveman status`.
+export function formatCavemanStatus(mode) {
+    return `Caveman mode: ${mode && mode !== 'off' ? mode : 'unknown'}`;
+}
 // Stale ctx access throws, so never let it abort a mode restore.
 function statusUi(ctx) {
     try {
@@ -24,7 +28,8 @@ let lastText;
 let lastUi;
 // Paint the host footer bar; same text on the same UI is skipped, a new ctx repaints it.
 export function announceStatus(ctx) {
-    const text = formatStatus(getSharedComboState());
+    const state = getSharedComboState();
+    const text = formatStatus(state);
     const ui = statusUi(ctx) ?? statusUi(remembered);
     if (statusUi(ctx))
         remembered = ctx;
@@ -35,4 +40,5 @@ export function announceStatus(ctx) {
     lastText = text;
     lastUi = ui;
     ui.setStatus?.('tersio', text);
+    ui.setStatus?.('caveman', formatCavemanStatus(state.caveman));
 }

package/{tersio.js → dist/tersio.js}

@@ -32,7 +32,7 @@ Options:
   --keep-ponytail (uninstall: keep the bundled Ponytail copy — removed by default)
   --remove-rtk (uninstall: also remove the RTK binary; its OMP wiring always goes)
   --combo-default off|medium|balanced|max (implies caveman, rtk, ponytail)
-  --caveman-default off|lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra (override; default follows combo)
+  --caveman-default off|lite|full|ultra|megacave-lite|megacave-full|megacave-ultra (override; default follows combo)
   --ponytail-default off|lite|full|ultra (override; default follows combo)
   --rtk-default on|off (override; default follows combo)
   --yes, -y

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

@@ -9,7 +9,8 @@ import { fileURLToPath } from 'node:url';
 
 import { setExtensionLabel } from '../shared/host.ts';
 import {
-  CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE,
+  CAVEMAN_REMOTE_ULTRA,
+  CAVEMAN_REMOTE_MEGACAVE,
   RTK_RELEASE_API,
   RtkRelease,
   fetchJson,
@@ -31,8 +32,13 @@ const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
 const RTK_BINARY = resolveRtkBinary();
-// Beside this file, not a host path: that is the rule.md /caveman reads.
-const CAVEMAN_LOCAL = path.join(EXTENSION_DIR, '..', 'caveman-session', 'rule.md');
+// Beside this file, not a host path: these are the rules /caveman reads.
+const cavemanRule = (name: string) => path.join(EXTENSION_DIR, '..', 'caveman-session', name);
+const CAVEMAN_LOCAL = cavemanRule('rule.md');
+const CAVEMAN_TRACKED: ReadonlyArray<{ file: string; remote: string }> = [
+  { file: cavemanRule('rule-ultra.md'), remote: CAVEMAN_REMOTE_ULTRA },
+  { file: cavemanRule('rule-megacave.md'), remote: CAVEMAN_REMOTE_MEGACAVE },
+];
 const HOST_NAME = isPiProcess() ? 'Pi' : 'OMP';
 const RELOAD_MSG = `Reminder: restart ${HOST_NAME} (or reload extensions) for updates to take effect.`;
 
@@ -129,17 +135,19 @@ function checkRtk(): Promise<AddonStatus> {
   });
 }
 
-// Caveman (rule.md)
 function checkCaveman(): Promise<AddonStatus> {
   return runCheck('Caveman', async () => {
-    const remote = await httpsGet(CAVEMAN_REMOTE);
-    const remoteHash = shortHash(remote);
-    const local = await readTextIfExists(CAVEMAN_LOCAL);
-    const localHash = local ? shortHash(local) : null;
-    const status = !local ? 'rule.md missing'
-      : localHash === remoteHash ? 'rule.md up to date'
-        : 'rule.md update available';
-    return `Caveman ${status}: local=${localHash || '—'} remote=${remoteHash}`;
+    const parts: string[] = [(await readTextIfExists(CAVEMAN_LOCAL)) ? 'rule.md ok' : 'rule.md missing'];
+    for (const { file, remote } of CAVEMAN_TRACKED) {
+      const name = path.basename(file);
+      try {
+        const [remoteText, localText] = await Promise.all([httpsGet(remote), readTextIfExists(file)]);
+        parts.push(!localText ? `${name} missing` : shortHash(localText) === shortHash(remoteText) ? `${name} up to date` : `${name} update available`);
+      } catch {
+        parts.push(`${name} check skipped`);
+      }
+    }
+    return `Caveman ${parts.join(', ')}`;
   });
 }
 
@@ -352,37 +360,41 @@ async function updateRtk(ctx: AddonUpdaterCtx, dryRun = false): Promise<string>
 }
 
 async function updateCaveman(ctx: AddonUpdaterCtx, dryRun = false): Promise<string> {
-  let remote: string;
-  try { remote = await httpsGet(CAVEMAN_REMOTE); }
-  catch (e) { return report(ctx, `Caveman update failed: ${(e as Error).message}`, 'warning'); }
-
-  const remoteHash = shortHash(remote);
-  const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
-  const oldHash = oldLocal ? shortHash(oldLocal) : null;
-
-  if (dryRun) {
-    const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}.`;
-    return report(ctx, m, 'info');
-  }
+  const results: string[] = [];
+  for (const { file, remote } of CAVEMAN_TRACKED) {
+    const name = path.basename(file);
+    let remoteText: string;
+    try { remoteText = await httpsGet(remote); }
+    catch (e) { results.push(report(ctx, `Caveman ${name} update failed: ${(e as Error).message}`, 'warning')); continue; }
+
+    const remoteHash = shortHash(remoteText);
+    const oldLocal = await readTextIfExists(file);
+    const oldHash = oldLocal ? shortHash(oldLocal) : null;
+    if (oldHash === remoteHash) { results.push(`${name} up to date: ${remoteHash}`); continue; }
+
+    if (dryRun) {
+      results.push(`Caveman dry-run: would write ${file}\nold=${oldHash || '—'} new=${remoteHash}.`);
+      continue;
+    }
 
-  try {
-    await fs.mkdir(path.dirname(CAVEMAN_LOCAL), { recursive: true });
-    const backupPath = `${CAVEMAN_LOCAL}.bak`;
-    if (oldLocal !== null) await fs.writeFile(backupPath, oldLocal, 'utf8');
-    await fs.writeFile(CAVEMAN_LOCAL, remote, 'utf8');
-    const written = await fs.readFile(CAVEMAN_LOCAL, 'utf8');
-    const writtenHash = shortHash(written);
-    if (writtenHash !== remoteHash) {
-      if (oldLocal !== null) await fs.writeFile(CAVEMAN_LOCAL, oldLocal, 'utf8');
-      throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
+    try {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      const backupPath = `${file}.bak`;
+      if (oldLocal !== null) await fs.writeFile(backupPath, oldLocal, 'utf8');
+      await fs.writeFile(file, remoteText, 'utf8');
+      const writtenHash = shortHash(await fs.readFile(file, 'utf8'));
+      if (writtenHash !== remoteHash) {
+        if (oldLocal !== null) await fs.writeFile(file, oldLocal, 'utf8');
+        throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
+      }
+      results.push(`Caveman ${name} updated → ${file}\nold=${oldHash || '—'} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : '—'}\n${RELOAD_MSG}`);
+    } catch (e) {
+      results.push(`Caveman ${name} update failed: ${(e as Error).message}`);
     }
-    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 as Error).message}`;
-    return report(ctx, m, 'warning');
   }
+  const summary = results.join('\n');
+  notify(ctx, `Caveman update finished. ${RELOAD_MSG}`, 'info');
+  return summary;
 }
 
 export default function aiAddonsUpdaterExtension(pi: AddonUpdaterPi): void {

package/extensions/caveman-session/index.ts

@@ -8,20 +8,19 @@ import { readCavemanDefault } from '../shared/plugin-settings.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
-const RULE_PATH = join(CAVERN_DIR, 'rule.md');
-
-// Fail loud: a wrong rule reads to the model as the real one.
-function readFullRule(): string {
-  try { return readFileSync(RULE_PATH, 'utf8'); } catch {
-    return 'Caveman full requested, but rule.md is missing. Run: tersio doctor --fix extensions';
-  }
-}
+// Upstream ships one skill per register: default, ultracave, megacave.
+const RULE_FILES = { lite: 'rule.md', full: 'rule.md', ultra: 'rule-ultra.md', 'megacave-lite': 'rule-megacave.md', 'megacave-full': 'rule-megacave.md', 'megacave-ultra': 'rule-megacave.md' };
 
 const DEFAULT_MODE = 'off';
 
-// Upstream ships one SKILL.md; the level is a directive inside it, so swap only the header.
 function buildInstruction(mode: string): string {
-  return `Caveman ${mode} active for this session.\n${readFullRule()}`;
+  const name = RULE_FILES[mode as keyof typeof RULE_FILES] ?? RULE_FILES.full;
+  // Fail loud: a wrong rule reads to the model as the real one.
+  let body: string;
+  try { body = readFileSync(join(CAVERN_DIR, name), 'utf8'); } catch {
+    body = `Caveman ${mode} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
+  }
+  return `Caveman ${mode} active for this session.\n${body}`;
 }
 
 function resolveMode(entries: SessionEntry[] | null | undefined, fallback: string = DEFAULT_MODE): string {
@@ -68,7 +67,7 @@ export default function cavemanSessionExtension(pi: ExtensionApi): void {
         return;
       }
       if (!setMode(arg, ctx)) {
-        ctx?.ui?.notify?.('Usage: /caveman [lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off|status]', 'warning');
+        ctx?.ui?.notify?.('Usage: /caveman [lite|full|ultra|megacave-lite|megacave-full|megacave-ultra|off|status]', 'warning');
       }
     },
   });

package/extensions/caveman-session/rule-megacave.md

@@ -0,0 +1,63 @@
+---
+name: megacave
+description: >
+  Caveman in Classical Chinese: 文言文 register, far fewer characters, technical
+  terms verbatim. Invoke only with /megacave or /caveman wenyan. Stays on until
+  "stop caveman" or "normal mode".
+disable-model-invocation: true
+---
+
+# megacave
+
+以文言答。技術之實皆存，唯贅言去之。
+
+Megacave is caveman in Classical Chinese. 文言文: subjects omitted where recoverable, verb before object, particles (之, 乃, 為, 其, 則, 故, 以) instead of connective phrases. Fewer characters on screen. Token savings are small and noisy; never claim them.
+
+## Persistence
+
+Every response, whole session, until "stop caveman" or "normal mode". Unsure? Still on. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value or say `Caveman mode: unknown`.
+
+## Floor
+
+Never cut or translate: code, commands, paths, API names, error strings, in their original script. Negation (不, 非, 勿, 未, 毋). Numbers and units, Arabic numerals. One term per thing. A clause ambiguous in 文言 becomes 白話.
+
+## Rules
+
+### 1. Classical register
+
+文言, not 白話. Verb before object. Subjects omitted where recoverable.
+
+Bad: "你的組件每次渲染都會重新渲染，因為你每次都創建了新的對象引用。請用 useMemo 包起來。"
+Good: "每繪新生對象參照，故重繪；以 `useMemo` 包之則免。"
+
+### 2. Particles carry structure
+
+One particle, one relation.
+
+Bad: "因為連接池會重複使用已經打開的連接，所以不需要每次請求都新建連接，這樣就省去了握手的開銷。"
+Good: "池蓄已開之連，不逐請而新開，省握手之費。"
+
+### 3. Each fact once
+
+Good: "新參照則重繪。`useMemo` 包之。"
+
+### 4. Payload in original script
+
+Bad: "以記憶化鉤子包之。"
+Good: "以 `useMemo` 包之。"
+
+### 5. Tool runs
+
+One 文言 line in, one out. Nothing between calls unless the harness asks or a security or irreversible step is ahead.
+
+### 6. Never perform
+
+No "文言模式啟", no modern answer plus classical copy. 文言 not shorter than 白話 for a sentence? Use 白話.
+
+## When to break the rules
+
+白話 or the user's language, full sentences, then resume: security warning. Irreversible action, confirm first. Any clause with two readings. User confused. Anything persisted outside chat (code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages; `/caveman-compress` exempt). Harness asks for a status line.
+
+## Pre-send check
+
+Identifiers verbatim, original script? Negations present? Two readings? 白話. Flavor character? Cut.

package/extensions/caveman-session/rule-ultra.md

@@ -0,0 +1,63 @@
+---
+name: ultracave
+description: >
+  Caveman at maximum compression: fragments, one word when one word is enough,
+  each fact once. Invoke only with /ultracave or /caveman ultra. Stays on until
+  "stop caveman" or "normal mode".
+disable-model-invocation: true
+---
+
+# ultracave
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die. Then cut again.
+
+Ultracave is caveman with the grammar stripped. Payload only.
+
+## Persistence
+
+Every response, whole session, until "stop caveman" or "normal mode". Unsure? Still on. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value or say `Caveman mode: unknown`.
+
+## Floor
+
+Never cut: code, commands, paths, API names, error strings (verbatim). not/never/no/only/except. Numbers and units. The user's language. One term per thing. No invented abbreviations, no arrows.
+
+## Rules
+
+### 1. Fragments
+
+Drop articles, copulas, connectives when order stays clear.
+
+Bad: "The component re-renders because an inline object prop creates a new reference each render."
+Good: "Inline object prop, new ref, re-render. `useMemo`."
+
+### 2. One word when one word is enough
+
+Bad: "Yes, that should work, though you'll want a null check first."
+Good: "Yes. Null check first."
+
+### 3. Each fact once
+
+No restating, no summary after a list.
+
+Good: "Pool reuses open DB connections. No per-request handshake."
+
+### 4. Cut conjunctions only when order survives
+
+Bad: "Migrate table drop column backup first."
+Good: "Back up first. Then migrate: drops column."
+
+### 5. Tool runs
+
+One line in, one line out. Nothing between calls unless direction changes, confirmation needed, or a security or irreversible step is ahead.
+
+### 6. Never perform
+
+No prefix, no announcement, no mangled verbs for flavor. Fragment not shorter than the sentence? Use the sentence.
+
+## When to break the rules
+
+Plain prose, then resume: security warning. Irreversible action, confirm first. Any fragment with two readings. User confused. Anything persisted outside chat (code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages; `/caveman-compress` exempt). Harness asks for a status line.
+
+## Pre-send check
+
+Two readings? Full sentence. Negations present? Payload verbatim? Flavor word? Cut.

package/extensions/caveman-session/rule.md

@@ -2,7 +2,7 @@
 name: caveman
 description: >
   Ultra-compressed communication mode that cuts output tokens while keeping
-  technical accuracy. Levels: lite, full, ultra and the wenyan variants. Use for
+  technical accuracy. Levels: lite, full, ultra and the megacave variants. Use for
   /caveman, "caveman mode", "talk like caveman", "be brief" or "less tokens".
 ---
 
@@ -12,7 +12,7 @@ Respond terse like smart caveman. All technical substance stay. Only fluff die.
 
 Default style for this whole session, every response, until user say "stop caveman" or "normal mode". Keep terse on long sessions no filler drift.
 
-Default: **full**. Switch: `/caveman lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off`.
+Default: **full**. Switch: `/caveman lite|full|ultra|megacave-lite|megacave-full|megacave-ultra|off`.
 
 ## Rules
 
@@ -28,6 +28,8 @@ Tool calls: fire direct. No preamble, plan, or progress note before or between c
 
 Follow explicit reply-language instructions from the user or project. Otherwise preserve the user's dominant language. Never switch because of example text or multilingual context elsewhere. Compress the style, not the language. Every emitted line in that language openings, pre-tool status lines, all not just final reply. ALWAYS keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim unless user explicitly ask for translation.
 
+Ownership: caveman owns reply compression, so project or host prose rules that set article use, sentence length, or filler never override it. Treat those as applying to persisted artifacts instead: code, comments, commits, docs, and issue text. Any project rule naming caveman or tersio directly wins over both.
+
 'Drop articles' = article languages only. Where small markers carry case/role (particles, postpositions), keep them grammar, not filler; compress politeness/filler instead.
 
 Answer directly in this style. Skip "caveman mode on", "me caveman think", "Caveman:" prefix or recap redundant with the reply itself. No normal answer plus caveman duplicate. User ask what mode is → say so plainly.
@@ -43,27 +45,14 @@ Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
 |-------|------------|
 | **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
 | **full** | Drop articles, fragments OK, short synonyms. Classic caveman. No tool-call narration, no decorative tables/emoji, no long raw error-log dumps unless asked. Standard acronyms OK; no invented abbreviations |
-| **ultra** | Strip conjunctions when cause-then-effect stay unambiguous. One word when one word enough. State each fact once. NO prose abbreviations (cfg/impl/req/res/fn/auth), NO arrows (X → Y) measured zero token saving under tokenizer, cost decode clarity. Code symbols, function names, API names, error strings: never touch |
-| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
-| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction chars, not tokens. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
-| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
 
 Example "Why React component re-render?"
 - lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
 - full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
-- ultra: "Inline obj prop, new ref, re-render. `useMemo`."
-- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
-- wenyan-full: "每繪新生對象參照，故重繪；以 useMemo 包之則免。"
-- wenyan-ultra: "新參照則重繪。useMemo 包之。"
 
 Example "Explain database connection pooling."
 - lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
 - full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
-- ultra: "Pool reuse open DB connections. No per-request handshake."
-- wenyan-full: "池蓄已開之連，不逐請而新開，省握手之費。"
-- wenyan-ultra: "池蓄連，免逐請新開，省握手。"
-
-Classical chars = wenyan modes only. Never swap a word to a classical char to shrink at non-wenyan levels.
 
 ## Auto-Clarity