@krtclcdy/tersio 2.25.2 → 2.25.4

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,23 +55,44 @@ 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>',
+        description: 'Toggle all 3 Tersio modes at once. Usage: /combo <off|medium|balanced|max|status>',
         handler: async (args, ctx) => {
             listen(ctx);
             const arg = String(args || '').trim().toLowerCase();
@@ -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);
     });
@@ -159,7 +169,7 @@ export default function comboToggleExtension(pi) {
         // The previous level's block is replaced, not stacked on.
         const stale = lastInjected;
         lastInjected = instruction;
-        return injectPromptText(pi, event, instruction, stale);
+        return injectPromptText(pi, event, { text: instruction, staleMarker: stale, sectionTag: 'ponytail' });
     });
     // Slash commands only; natural-language input caused accidental toggles and has no reload context.
 }

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

@@ -19,7 +19,20 @@ export function homeDir() {
 }
 export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
 export const CAVEMAN_REMOTE_ULTRA = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/ultracave/SKILL.md';
-export const CAVEMAN_REMOTE_WENYAN = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/megacave/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' },
@@ -55,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) {

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

@@ -2,6 +2,7 @@
 import { execFile } from 'node:child_process';
 import cavemanSessionExtension from '../caveman-session/index.js';
 import rtkSessionExtension from '../rtk-session/index.js';
+import rtkFilterExtension, { FILTER_BY_TOOL, MIN_FILTER_BYTES, filterThroughRtk, filterableText, rtkActive } from '../rtk-filter/index.js';
 import comboToggleExtension from '../combo-toggle/index.js';
 import tersioCommandsExtension from '../tersio-commands/index.js';
 import { getSharedComboState } from '../shared/session-state.js';
@@ -35,6 +36,7 @@ const plugin = {
             return list;
         };
         const persist = (sid) => {
+            // SAFETY: the storage API is generic over its payload; the value round-trips unchanged.
             void ctx.storage.set(`entries:${sid}`, sessionEntriesOf(sid)).catch(() => { });
         };
         const stubCtx = (sid) => ({
@@ -110,7 +112,7 @@ const plugin = {
                 lifecycle.set(event, list);
             },
         };
-        for (const extension of [cavemanSessionExtension, rtkSessionExtension, comboToggleExtension, tersioCommandsExtension])
+        for (const extension of [cavemanSessionExtension, rtkSessionExtension, rtkFilterExtension, comboToggleExtension, tersioCommandsExtension])
             extension(host);
         // The first hook of an unseen session runs its session_start handlers.
         const sidOf = (value) => typeof value === 'string' && value ? value : undefined;
@@ -200,8 +202,50 @@ const plugin = {
             if (rewritten)
                 input.command = rewritten;
         });
+        // Built-in grep and glob output never reaches the bash hook; mutate result.content in place.
+        try {
+            await ctx.tool.hook('execute.after', async (event) => {
+                const hook = event;
+                if (hook.status !== 'completed')
+                    return;
+                const filter = FILTER_BY_TOOL.get(String(hook.tool ?? '').toLowerCase());
+                if (!filter || !hook.result)
+                    return;
+                const text = filterableText(hook.result.content);
+                if (text === null || text.length < MIN_FILTER_BYTES)
+                    return;
+                // Read the mode from the payload's own session, not the last one to run a start hook.
+                const sid = typeof hook.sessionID === 'string' ? hook.sessionID : activeSid;
+                if (sid !== undefined)
+                    await ensureSession(sid);
+                if (!rtkActive(sid === undefined ? undefined : sessionEntriesOf(sid)))
+                    return;
+                const bin = resolveRtkBinary();
+                if (!bin)
+                    return;
+                const filtered = await filterThroughRtk(execRtk, { bin, filter, text });
+                if (filtered)
+                    hook.result.content = [{ type: 'text', text: filtered }];
+            });
+        }
+        catch {
+            // Hosts without the after-hook keep the unfiltered result.
+        }
     },
 };
+/** execFile with the promise shape `filterThroughRtk` expects. */
+function execRtk(cmd, args, opts) {
+    return new Promise((resolve) => {
+        execFile(cmd, args, { signal: opts?.signal, timeout: opts?.timeout }, (error, stdout) => {
+            const out = stdout ?? '';
+            if (!error)
+                return resolve({ stdout: out, code: 0 });
+            // A non-numeric code is a spawn failure (ENOENT, EACCES, killed) and must not read as success.
+            const raw = error.code;
+            resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
+        });
+    });
+}
 function rewriteCommand(command) {
     const bin = resolveRtkBinary();
     if (!bin)

package/dist/extensions/rtk-filter/index.js

@@ -0,0 +1,87 @@
+// pi's built-in grep and glob never reach the bash hook; `read` is absent because rtk has no filter for it.
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveRtkBinary } from '../lib/utils.js';
+import { readRtkDefault } from '../shared/plugin-settings.js';
+import { getSharedComboState, lastCustomValue, sessionEntries } from '../shared/session-state.js';
+/** Tool name to `rtk pipe --filter` name. Exported so the OpenCode host reuses one map. */
+export const FILTER_BY_TOOL = new Map([
+    ['grep', 'grep'],
+    ['glob', 'find'],
+    ['find', 'find'],
+]);
+/** Below this the rtk spawn costs more than the filter saves. */
+export const MIN_FILTER_BYTES = 1200;
+const FILTER_TIMEOUT_MS = 5000;
+/** Absolute, so a minimal PATH in the host cannot break the spawn. */
+const SHELL = '/bin/sh';
+function modeOf(value) {
+    if (value === true)
+        return true;
+    if (value === false)
+        return false;
+    return null;
+}
+/** True when rtk is on for the session: a persisted entry wins, then a live switch, then the configured default. */
+export function rtkActive(entries) {
+    const persisted = lastCustomValue(entries, 'rtk-mode', (data) => modeOf(data?.enabled));
+    if (persisted !== null)
+        return persisted;
+    return getSharedComboState().rtk === 'on' || readRtkDefault();
+}
+/** The text in a result's content parts, or null when the parts are not plain text. */
+export function filterableText(parts) {
+    if (!Array.isArray(parts) || parts.length === 0)
+        return null;
+    // An image or a mixed result is not text to filter.
+    if (parts.some((part) => part?.type !== 'text'))
+        return null;
+    return parts.map((part) => part?.text ?? '').join('\n');
+}
+/** Pipe text through one rtk filter; null on any failure, so the caller keeps its original. */
+export async function filterThroughRtk(exec, request) {
+    const { bin, filter, text, signal } = request;
+    let dir;
+    try {
+        dir = mkdtempSync(join(tmpdir(), 'tersio-rtk-'));
+        const file = join(dir, 'in.txt');
+        writeFileSync(file, text, 'utf8');
+        // `rtk pipe` reads stdin only and execFile has no stdin, so one redirect.
+        const result = await exec(SHELL, ['-c', `"${bin}" pipe -f ${filter} < "${file}"`], { signal, timeout: FILTER_TIMEOUT_MS });
+        if (result.code !== 0)
+            return null;
+        const out = result.stdout;
+        if (!out.trim() || out.length >= text.length)
+            return null;
+        return out;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (dir)
+            rmSync(dir, { recursive: true, force: true });
+    }
+}
+export default function rtkFilterExtension(pi) {
+    const bin = resolveRtkBinary();
+    const exec = pi.exec;
+    if (!bin || !exec)
+        return;
+    pi.on('tool_result', async (event, ctx) => {
+        const filter = FILTER_BY_TOOL.get(String(event?.toolName ?? '').toLowerCase());
+        if (!filter || event?.isError)
+            return;
+        const text = filterableText(event?.content);
+        if (text === null || text.length < MIN_FILTER_BYTES)
+            return;
+        if (!rtkActive(sessionEntries(ctx)))
+            return;
+        const filtered = await filterThroughRtk(exec, { bin, filter, text, signal: ctx?.signal });
+        if (!filtered)
+            return;
+        // Built-in grep and glob declare no output schema, so no structuredContent is lost.
+        return { content: [{ type: 'text', text: filtered }] };
+    });
+}

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

@@ -22,7 +22,8 @@ function setRtkProcessEnabled(enabled) {
     else
         process.env.RTK_DISABLED = '1';
 }
-const RTK_PROMPT = `RTK guidance active. RTK automatically rewrites eligible Bash calls through the installed rtk hook. Prefer rtk for noisy shell output, but use exact raw output for state changes, checksums, patches, and diagnostics that need full bytes.`;
+// rtk's awareness contract: state the output contract, never tell the model to type `rtk`.
+const RTK_PROMPT = `RTK guidance active. Bash output, and large grep and glob results, are condensed to save tokens: every signal kept, costly noise dropped. Treat a condensed result as complete. Re-run something unfiltered only when its result is empty, garbled, or contradicts its exit code.`;
 export default function rtkSessionExtension(pi) {
     let enabled = DEFAULT_ENABLED;
     function fail(text) {
@@ -125,6 +126,6 @@ export default function rtkSessionExtension(pi) {
         // Skip when already present, so a host that re-presents the prompt cannot stack it.
         if (systemPromptIncludes(event.systemPrompt, RTK_PROMPT))
             return;
-        return injectPromptText(pi, event, RTK_PROMPT);
+        return injectPromptText(pi, event, { text: RTK_PROMPT, sectionTag: 'rtk' });
     });
 }

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

@@ -16,15 +16,21 @@ const piAdapter = {
             return undefined;
         return options[shown.indexOf(picked)]?.label ?? picked;
     },
-    inject(event, text, staleMarker) {
-        const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+    inject(event, block) {
+        const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
         const dropStale = (parts) => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
         const options = event.systemPromptOptions;
+        // A named section is replaced in place; returning systemPrompt replaces the whole prompt.
+        const sections = options?.sections;
+        if (block.sectionTag && sections && typeof sections === 'object') {
+            sections[block.sectionTag] = block.text;
+            return undefined;
+        }
         if (options && typeof options.appendSystemPrompt === 'string') {
-            options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(text).filter(Boolean).join('\n\n');
+            options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(block.text).filter(Boolean).join('\n\n');
             return undefined;
         }
-        return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${text}` };
+        return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${block.text}` };
     },
     stringArray(_pi, name, spec) {
         const array = { type: 'array', items: { type: 'string' } };
@@ -43,10 +49,10 @@ const ompAdapter = {
             return undefined;
         return ui.select(title, options, dialogOptions);
     },
-    inject(event, text, staleMarker) {
-        const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+    inject(event, block) {
+        const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
         const dropStale = (parts) => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
-        return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+        return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), block.text] };
     },
     stringArray(pi, name, spec) {
         const { z } = pi.zod;
@@ -63,10 +69,10 @@ const opencodeAdapter = {
             return undefined;
         return ui.select(title, options, dialogOptions);
     },
-    inject(event, text, staleMarker) {
-        const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+    inject(event, block) {
+        const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
         const dropStale = (parts) => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
-        return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+        return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), block.text] };
     },
     stringArray(_pi, name, spec) {
         const array = { type: 'array', items: { type: 'string' } };
@@ -99,8 +105,8 @@ export function onHostEvent(pi, event, handler) {
 export async function hostSelect(pi, ui, title, options, dialogOptions) {
     return adapterFor(pi).select(ui, title, options, dialogOptions);
 }
-export function injectPromptText(pi, event, text, staleMarker) {
-    return adapterFor(pi).inject(event, text, staleMarker);
+export function injectPromptText(pi, event, block) {
+    return adapterFor(pi).inject(event, block);
 }
 export function stringArrayToolParams(pi, name, spec = {}) {
     return adapterFor(pi).stringArray(pi, name, spec);

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)) {
@@ -71,7 +76,9 @@ export function normalizeInputCommand(value) {
     return String(value || '').trim().toLowerCase().replace(/[.!?\s]+$/, '');
 }
 export function asPromptArray(systemPrompt) {
-    return Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+    const parts = Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+    // OMP can hand back a hole in the array; a non-string breaks every marker check.
+    return parts.filter((part) => typeof part === 'string');
 }
 export function systemPromptIncludes(systemPrompt, marker) {
     return asPromptArray(systemPrompt).some((prompt) => typeof prompt === 'string' && prompt.includes(marker));
@@ -127,6 +134,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

@@ -10,7 +10,7 @@ import { fileURLToPath } from 'node:url';
 import { setExtensionLabel } from '../shared/host.ts';
 import {
   CAVEMAN_REMOTE_ULTRA,
-  CAVEMAN_REMOTE_WENYAN,
+  CAVEMAN_REMOTE_MEGACAVE,
   RTK_RELEASE_API,
   RtkRelease,
   fetchJson,
@@ -18,7 +18,6 @@ import {
   findHoistedPackage,
   httpsGet,
   httpsDownload,
-  isPiProcess,
   sha256Hex,
   parseChecksum,
   normalizeRtkVersion,
@@ -37,10 +36,10 @@ const cavemanRule = (name: string) => path.join(EXTENSION_DIR, '..', 'caveman-se
 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-wenyan.md'), remote: CAVEMAN_REMOTE_WENYAN },
+  { 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.`;
+// Host-neutral: this updater runs inside pi, OMP, and OpenCode alike.
+const RELOAD_MSG = 'Reminder: restart your agent (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.
 function ponytailLocal(): string | null {