@krtclcdy/tersio 2.25.1 → 2.25.3

package/{extensions → dist/extensions}/ai-addons-updater/index.js

@@ -6,13 +6,18 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { setExtensionLabel } from '../shared/host.js';
-import { CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, httpsDownload, isPiProcess, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, rtkPlatformSpec, resolveRtkBinary, } from '../lib/utils.js';
+import { CAVEMAN_REMOTE_ULTRA, CAVEMAN_REMOTE_MEGACAVE, RTK_RELEASE_API, fetchJson, findFile, findHoistedPackage, httpsGet, httpsDownload, isPiProcess, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, rtkPlatformSpec, resolveRtkBinary, } from '../lib/utils.js';
 const IS_WINDOWS = process.platform === 'win32';
 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) => path.join(EXTENSION_DIR, '..', 'caveman-session', name);
+const CAVEMAN_LOCAL = cavemanRule('rule.md');
+const CAVEMAN_TRACKED = [
+    { 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.`;
 // Ponytail is a hoisted dependency, so the installed copy is found by walking up rather than by naming a host directory.
@@ -82,17 +87,20 @@ function checkRtk() {
         return `RTK ${status}: local=${localVer || '—'} latest=${latestTag || '—'}`;
     });
 }
-// Caveman (rule.md)
 function checkCaveman() {
     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 = [(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(', ')}`;
     });
 }
 export async function checkAddonsSummary(ctx) {
@@ -317,41 +325,49 @@ async function updateRtk(ctx, dryRun = false) {
     }
 }
 async function updateCaveman(ctx, dryRun = false) {
-    let remote;
-    try {
-        remote = await httpsGet(CAVEMAN_REMOTE);
-    }
-    catch (e) {
-        return report(ctx, `Caveman update failed: ${e.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');
-    }
-    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) {
+    const results = [];
+    for (const { file, remote } of CAVEMAN_TRACKED) {
+        const name = path.basename(file);
+        let remoteText;
+        try {
+            remoteText = await httpsGet(remote);
+        }
+        catch (e) {
+            results.push(report(ctx, `Caveman ${name} update failed: ${e.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(file), { recursive: true });
+            const backupPath = `${file}.bak`;
             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' : ''}`);
+                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.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.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) {
     setExtensionLabel(pi, 'AI add-ons updater');

package/{extensions → dist/extensions}/caveman-session/index.js

@@ -6,20 +6,20 @@ import { injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host
 import { announceStatus } from '../shared/status.js';
 import { readCavemanDefault } from '../shared/plugin-settings.js';
 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() {
+// 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';
+function buildInstruction(mode) {
+    const name = RULE_FILES[mode] ?? RULE_FILES.full;
+    // Fail loud: a wrong rule reads to the model as the real one.
+    let body;
     try {
-        return readFileSync(RULE_PATH, 'utf8');
+        body = readFileSync(join(CAVERN_DIR, name), 'utf8');
     }
     catch {
-        return 'Caveman full requested, but rule.md is missing. Run: tersio doctor --fix extensions';
+        body = `Caveman ${mode} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
     }
-}
-const DEFAULT_MODE = 'off';
-// Upstream ships one SKILL.md; the level is a directive inside it, so swap only the header.
-function buildInstruction(mode) {
-    return `Caveman ${mode} active for this session.\n${readFullRule()}`;
+    return `Caveman ${mode} active for this session.\n${body}`;
 }
 function resolveMode(entries, fallback = DEFAULT_MODE) {
     return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
@@ -62,7 +62,7 @@ export default function cavemanSessionExtension(pi) {
                 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/dist/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/dist/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/dist/extensions/caveman-session/rule.md

@@ -0,0 +1,79 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode that cuts output tokens while keeping
+  technical accuracy. Levels: lite, full, ultra and the megacave variants. Use for
+  /caveman, "caveman mode", "talk like caveman", "be brief" or "less tokens".
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+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|megacave-lite|megacave-full|megacave-ultra|off`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) tokenizer split them same as full word: zero token saved, reader still decode. Full word cheaper AND clearer. No causal arrows (→) either own token, save nothing. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Never drop not/never/no/only/except flip meaning worse than any token saved. Numbers, units exact.
+
+Never ADD word to sound caveman. Compression only style never grow output. No inserted pronoun or copula to fake broken grammar: "when it not" cost one token more than "when not" and say same thing. Keep correct verb form when correct form cost same "sees" one token, "see" one token, so mangle buy nothing and read worse. Same rule as abbreviations and arrows: if caveman phrasing not shorter than plain phrasing, use plain.
+
+Clarity register: mix ASD-STE100 Simplified Technical English into caveman, always. One idea per sentence. Sentence short, target 20 words max. Active voice. Present tense where true. One word one meaning: same term for same thing every time, no synonym rotation. Instruction = imperative: "Run X", not "X should be run". Noun cluster 3 words max. Pronoun only with one clear referent, else repeat noun. Caveman cut filler; STE keep what make meaning unambiguous. Conflict between them → clarity win.
+
+Tool calls: fire direct. No preamble, plan, or progress note before or between calls. After result: next call direct or final answer never announce next call. Text before call only to clarify, warn security/irreversible, or resolve ambiguity.
+
+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.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **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 |
+
+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`."
+
+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."
+
+## Auto-Clarity
+
+Drop caveman when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g., `"migrate table drop column backup first"` order unclear without articles/conjunctions)
+- User asks to clarify or repeats question
+
+Resume caveman after clear part done.
+
+Example shows FORMAT only write warning in session language, not example's.
+
+Example destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Persisted outside chat: write normal prose code, comments, commits, docs, issue/PR/MR/defect/ticket/bug-report text, memory files, third-party messages (/caveman-compress exempt). "Open a defect" or "file a bug" mean the same as "open issue": body go to other humans, so body normal English. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

package/{extensions → dist/extensions}/combo-toggle/index.js

@@ -10,10 +10,10 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { activeModesSummary, COMBO_LEVELS, getSharedComboState, hasModeState, normalizeComboLevel, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, setSharedComboMode, systemPromptIncludes, } from '../shared/session-state.js';
+import { activeModesSummary, COMBO_LEVELS, getSharedComboState, hasModeState, normalizeComboLevel, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, setSharedComboModes, systemPromptIncludes, } from '../shared/session-state.js';
 import { hostSelect, injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host.js';
 import { announceStatus } from '../shared/status.js';
-import { isComboSetupComplete, readComboDefault, readPonytailDefault, saveComboSetup, } from '../shared/plugin-settings.js';
+import { isComboSetupComplete, readCavemanDefault, readComboDefault, readPluginSettings, readPonytailDefault, readRtkDefault, saveComboSetup, } from '../shared/plugin-settings.js';
 import { findHoistedPackage, isPiProcess } from '../lib/utils.js';
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PONYTAIL_FALLBACK_INTENSITY = {
@@ -45,6 +45,8 @@ export default function comboToggleExtension(pi) {
     setExtensionLabel(pi, 'Combo session toggle (all 3 add-ons)');
     let setupPrompted = false;
     let lastInjected = undefined;
+    // opencode has no UI event stream, so only its empty branch reconciles.
+    const OPENCODE = pi.hostId === 'opencode';
     // Siblings restore from these entries, so the fallback must write them too.
     function persistPreset(level) {
         const modes = COMBO_LEVELS[level];
@@ -53,20 +55,41 @@ export default function comboToggleExtension(pi) {
         pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
         pi.appendEntry?.('combo-level', { level });
     }
-    function reconcile(ctx) {
-        if (!ctx?.hasUI)
+    function restoreConfiguredDefaults() {
+        const settings = readPluginSettings();
+        const hasModeDefaults = ['cavemanDefault', 'rtkDefault', 'ponytailDefault'].some((key) => key in settings);
+        const combo = readComboDefault();
+        const preset = COMBO_LEVELS[combo];
+        const modes = hasModeDefaults
+            ? { caveman: readCavemanDefault(), rtk: readRtkDefault() ? 'on' : 'off', ponytail: readPonytailDefault() }
+            : preset;
+        setSharedComboModes(modes);
+        if (modes.caveman === 'off' && modes.rtk === 'off' && modes.ponytail === 'off')
+            return;
+        pi.appendEntry?.('caveman-mode', { mode: modes.caveman });
+        pi.appendEntry?.('rtk-mode', { enabled: modes.rtk === 'on' });
+        pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
+        if (preset && modes.caveman === preset.caveman && modes.rtk === preset.rtk && modes.ponytail === preset.ponytail) {
+            pi.appendEntry?.('combo-level', { level: combo });
+        }
+    }
+    function reconcile(ctx, resetEmpty = false) {
+        if (!ctx?.hasUI && !(resetEmpty && OPENCODE))
             return getSharedComboState();
-        return reconcileSharedComboEntries(sessionEntries(ctx));
+        const entries = sessionEntries(ctx);
+        if (!resetEmpty && entries.length === 0)
+            return getSharedComboState();
+        return reconcileSharedComboEntries(entries);
     }
     function listen(ctx) {
         if (!ctx?.hasUI)
             return;
         setSharedComboListener('combo', (state) => { announceStatus(ctx); return state; });
     }
-    function track(ctx) {
+    function track(ctx, resetEmpty = false) {
         listen(ctx);
-        if (ctx?.hasUI)
-            reconcile(ctx);
+        if (ctx?.hasUI || (resetEmpty && OPENCODE))
+            reconcile(ctx, resetEmpty);
     }
     pi.registerCommand?.('combo', {
         description: 'Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>',
@@ -113,26 +136,13 @@ export default function comboToggleExtension(pi) {
         }
     }
     pi.on('session_start', async (_event, ctx) => {
-        track(ctx);
-        await runFirstRunSetup(ctx);
-        // The configured default applies only when no persisted mode state exists.
+        track(ctx, true);
+        if (!isComboSetupComplete() && ctx?.hasUI && ctx.ui?.select)
+            await runFirstRunSetup(ctx);
+        // The configured defaults apply when a fresh session has no persisted mode state.
         const entries = sessionEntries(ctx);
-        const persisted = hasModeState(entries);
-        if (getSharedComboState().level === 'off' && !persisted) {
-            const fallback = readComboDefault();
-            if (fallback !== 'off') {
-                persistPreset(fallback);
-                setSharedComboLevel(fallback);
-            }
-        }
-        // No sibling restores a standalone ponytail default, so apply it here; skip it when the active preset already writes the same mode.
-        if (!entries.some((e) => e?.type === 'custom' && e.customType === 'ponytail-mode')) {
-            const ponytailFallback = readPonytailDefault();
-            if (ponytailFallback !== 'off' && ponytailFallback !== getSharedComboState().ponytail) {
-                pi.appendEntry?.('ponytail-mode', { mode: ponytailFallback });
-                setSharedComboMode('ponytail', ponytailFallback);
-            }
-        }
+        if (!hasModeState(entries) && (ctx?.hasUI || OPENCODE))
+            restoreConfiguredDefaults();
         // Announced last, so any default above is reflected.
         announceStatus(ctx);
     });

package/dist/extensions/headroom-session/index.js

@@ -0,0 +1,93 @@
+// /headroom session toggle. Headroom is a machine-level add-on, so this extension mirrors the stored per-agent flags and delegates every state change to the CLI.
+import { HEADROOM_INSTALL_HINT, headroomAgentState, headroomCapability, headroomProxyUp, headroomStatusFor, readHeadroomConfig, setHeadroomStatus, } from '../shared/headroom.js';
+import { onHostEvent, setExtensionLabel } from '../shared/host.js';
+import { announceStatus } from '../shared/status.js';
+/** The host's own key in the per-agent Headroom flags. */
+function agentOf(pi) {
+    return pi.hostId ?? 'omp';
+}
+function statusText(agent, status) {
+    const manual = headroomCapability(agent) === 'manual';
+    const port = readHeadroomConfig().port;
+    if (status === 'down')
+        return `Headroom is on for ${agent}${manual ? ' (manual base URL)' : ''}, but the proxy does not answer. Restart it with: headroom proxy --port ${port}`;
+    if (status === 'manual')
+        return `Headroom is on for ${agent} (manual base URL). Point the model base URL at the proxy.`;
+    if (status === 'on')
+        return `Headroom is on for ${agent}.`;
+    return `Headroom is off for ${agent}.`;
+}
+export default function headroomSessionExtension(pi) {
+    setExtensionLabel(pi, 'Headroom session toggle');
+    const agent = agentOf(pi);
+    let shaperWarned = false;
+    // Reads the stored flags, then probes the proxy only when this agent is wired. Off installs never touch the network.
+    async function refresh(ctx) {
+        const config = readHeadroomConfig();
+        const state = headroomAgentState(config, agent);
+        // No segment until the user opts in, so a machine that merely has Headroom installed keeps the old status line.
+        if (!config.support || !state.enabled) {
+            setHeadroomStatus(null);
+            return null;
+        }
+        const up = await headroomProxyUp(config.port);
+        const status = headroomStatusFor(config, agent, up);
+        setHeadroomStatus(status);
+        // Caveman already owns terse output, so two shapers would fight over one prompt.
+        if (!shaperWarned && process.env.HEADROOM_OUTPUT_SHAPER && process.env.HEADROOM_OUTPUT_SHAPER !== '0') {
+            shaperWarned = true;
+            ctx?.ui?.notify?.(`HEADROOM_OUTPUT_SHAPER is set while Caveman is active. Unset it: one prompt owner only.`, 'warning');
+        }
+        return status;
+    }
+    async function runCli(action, ctx) {
+        if (typeof pi.exec !== 'function') {
+            ctx?.ui?.notify?.(`Run in a shell: tersio headroom ${action} --agent ${agent}`, 'warning');
+            return;
+        }
+        try {
+            const result = await pi.exec('tersio', ['headroom', action, '--agent', agent], { cwd: ctx?.cwd ?? pi.cwd });
+            const text = [result.stdout, result.stderr].map((part) => part.trim()).filter(Boolean).join('\n');
+            ctx?.ui?.notify?.(text || `tersio headroom ${action} exited ${result.code}`, result.code === 0 ? 'info' : 'warning');
+        }
+        catch (e) {
+            ctx?.ui?.notify?.(`tersio headroom ${action} failed (${e.message}). Run it in a shell.`, 'warning');
+        }
+        await refresh(ctx);
+        announceStatus(ctx);
+    }
+    pi.registerCommand?.('headroom', {
+        description: 'Toggle the Headroom compression proxy for this agent',
+        handler: async (args, ctx) => {
+            const arg = String(args || '').trim().toLowerCase();
+            if (!arg || arg === 'status') {
+                const status = await refresh(ctx);
+                ctx?.ui?.notify?.(status === null
+                    ? `Headroom is not installed — ${HEADROOM_INSTALL_HINT}`
+                    : statusText(agent, status), 'info');
+                announceStatus(ctx);
+                return;
+            }
+            if (['on', 'enable', 'enabled', 'true'].includes(arg)) {
+                await runCli('enable', ctx);
+                return;
+            }
+            if (['off', 'disable', 'disabled', 'false'].includes(arg)) {
+                await runCli('disable', ctx);
+                return;
+            }
+            ctx?.ui?.notify?.('Usage: /headroom [on|off|status]', 'warning');
+        },
+    });
+    // Start, resume, branch, and compaction all land here, so every session type shows the state.
+    pi.on('session_start', async (_event, ctx) => {
+        await refresh(ctx);
+        announceStatus(ctx);
+    });
+    for (const event of ['session_branch', 'session_tree', 'session_switch', 'session_compact']) {
+        onHostEvent(pi, event, async (_event, ctx) => {
+            await refresh(ctx);
+            announceStatus(ctx);
+        });
+    }
+}

package/{extensions → dist/extensions}/lib/utils.js

@@ -18,7 +18,21 @@ export function homeDir() {
     return home && home.trim() !== '' ? home : os.homedir();
 }
 export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
-export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/caveman/SKILL.md';
+export const CAVEMAN_REMOTE_ULTRA = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/ultracave/SKILL.md';
+export const CAVEMAN_REMOTE_MEGACAVE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/megacave/SKILL.md';
+// A fetch that returns an error page or a truncated body must not reach the extension tree.
+export function ruleBodyProblem(text) {
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return 'empty body';
+    if (/^\s*<(!doctype|html)/i.test(trimmed))
+        return 'HTML page, not markdown';
+    if (/^\s*404\b/im.test(trimmed))
+        return 'upstream 404 page';
+    if (trimmed.length < 800)
+        return `truncated (${trimmed.length} chars)`;
+    return null;
+}
 const RTK_PLATFORM_SPECS = {
     'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip', binary: 'rtk.exe' },
     'linux/x64': { triple: 'x86_64-unknown-linux-musl', ext: '.tar.gz', binary: 'rtk' },
@@ -54,6 +68,18 @@ export function resolveHostBinary(name, managedDir = path.join(homeDir(), '.bun'
 export function rtkPlatformSpec(platform = process.platform, arch = process.arch) {
     return RTK_PLATFORM_SPECS[`${platform}/${arch}`] || null;
 }
+// Walk up to the nearest package.json; identical for the source and compiled trees.
+export function findPackageRoot(fromDir) {
+    let dir = fromDir;
+    for (;;) {
+        if (existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            throw new Error('package root not found');
+        dir = parent;
+    }
+}
 // The 3xx+location redirect rule shared by httpsGet/httpsDownload.
 function redirectNext(res, url) {
     if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {