@krtclcdy/tersio 2.25.2 → 2.25.4

package/extensions/caveman-session/index.ts

@@ -9,18 +9,25 @@ import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPrompt
 
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
 // Upstream ships one skill per register: default, ultracave, megacave.
-const RULE_FILES = { lite: 'rule.md', full: 'rule.md', ultra: 'rule-ultra.md', 'wenyan-lite': 'rule-wenyan.md', 'wenyan-full': 'rule-wenyan.md', 'wenyan-ultra': 'rule-wenyan.md' };
+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';
 
+// A rule file is immutable for the process, so read each level once; reinstalling needs a restart.
+const instructionCache = new Map<string, string>();
+
 function buildInstruction(mode: string): string {
+  const cached = instructionCache.get(mode);
+  if (cached) return cached;
   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} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
   }
-  return `Caveman ${mode} active for this session.\n${body}`;
+  const instruction = `Caveman ${mode} active for this session.\n${body}`;
+  instructionCache.set(mode, instruction);
+  return instruction;
 }
 
 function resolveMode(entries: SessionEntry[] | null | undefined, fallback: string = DEFAULT_MODE): string {
@@ -67,7 +74,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');
       }
     },
   });
@@ -118,6 +125,6 @@ export default function cavemanSessionExtension(pi: ExtensionApi): void {
     // 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: 'caveman' });
   });
 }

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.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.

package/extensions/combo-toggle/index.ts

@@ -13,15 +13,18 @@ import {
   sessionEntries,
   setSharedComboLevel,
   setSharedComboListener,
-  setSharedComboMode,
+  setSharedComboModes,
   systemPromptIncludes,
 } from '../shared/session-state.ts';
 import { hostSelect, injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host.ts';
 import { announceStatus } from '../shared/status.ts';
 import {
   isComboSetupComplete,
+  readCavemanDefault,
   readComboDefault,
+  readPluginSettings,
   readPonytailDefault,
+  readRtkDefault,
   saveComboSetup,
 } from '../shared/plugin-settings.ts';
 import { findHoistedPackage, isPiProcess } from '../lib/utils.ts';
@@ -64,7 +67,8 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
 
   let setupPrompted = false;
   let lastInjected: string | undefined = 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: string): void {
@@ -74,23 +78,42 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
     pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
     pi.appendEntry?.('combo-level', { level });
   }
+  function restoreConfiguredDefaults(): void {
+    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?: ExtensionCtx): Readonly<ComboState> {
-    if (!ctx?.hasUI) return getSharedComboState();
-    return reconcileSharedComboEntries(sessionEntries(ctx));
+  function reconcile(ctx?: ExtensionCtx, resetEmpty = false): Readonly<ComboState> {
+    if (!ctx?.hasUI && !(resetEmpty && OPENCODE)) return getSharedComboState();
+    const entries = sessionEntries(ctx);
+    if (!resetEmpty && entries.length === 0) return getSharedComboState();
+    return reconcileSharedComboEntries(entries);
   }
   function listen(ctx?: ExtensionCtx): void {
     if (!ctx?.hasUI) return;
     setSharedComboListener('combo', (state) => { announceStatus(ctx); return state; });
   }
-
-  function track(ctx?: ExtensionCtx): void {
+  function track(ctx?: ExtensionCtx, resetEmpty = false): void {
     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();
@@ -145,26 +168,11 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
   }
 
   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);
   });
@@ -189,7 +197,7 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
     // 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/lib/utils.ts

@@ -28,7 +28,17 @@ export function homeDir(): string {
 
 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: string): string | null {
+  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;
+}
 
 export interface RtkPlatformSpec {
   triple: string;
@@ -83,6 +93,17 @@ export function rtkPlatformSpec(platform: string = process.platform, arch: strin
   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: string): string {
+  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: { statusCode?: number; headers: { location?: string } }, url: string): string | null {
   if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {

package/extensions/opencode/server.ts

@@ -3,6 +3,7 @@ import { execFile } from 'node:child_process';
 import type { Plugin } from '@opencode/plugin';
 import cavemanSessionExtension from '../caveman-session/index.ts';
 import rtkSessionExtension from '../rtk-session/index.ts';
+import rtkFilterExtension, { FILTER_BY_TOOL, MIN_FILTER_BYTES, filterThroughRtk, filterableText, rtkActive } from '../rtk-filter/index.ts';
 import comboToggleExtension from '../combo-toggle/index.ts';
 import tersioCommandsExtension from '../tersio-commands/index.ts';
 import { getSharedComboState } from '../shared/session-state.ts';
@@ -54,6 +55,7 @@ const plugin: Plugin.Plugin = {
       return list;
     };
     const persist = (sid: string): void => {
+      // SAFETY: the storage API is generic over its payload; the value round-trips unchanged.
       void ctx.storage.set(`entries:${sid}`, sessionEntriesOf(sid) as unknown as never).catch(() => {});
     };
     const stubCtx = (sid?: string): ExtensionCtx => ({
@@ -120,7 +122,7 @@ const plugin: Plugin.Plugin = {
       },
     };
 
-    for (const extension of [cavemanSessionExtension, rtkSessionExtension, comboToggleExtension, tersioCommandsExtension]) extension(host);
+    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: unknown): string | undefined =>
@@ -206,9 +208,44 @@ const plugin: Plugin.Plugin = {
       const rewritten = await rewriteCommand(input.command);
       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 as { tool?: unknown; status?: unknown; sessionID?: unknown; result?: { content?: unknown } };
+        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: string, args: string[], opts?: { signal?: AbortSignal; timeout?: number }): Promise<{ stdout: string; code: number }> {
+  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 as { code?: unknown }).code;
+      resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
+    });
+  });
+}
+
 function rewriteCommand(command: string): Promise<string | null> {
   const bin = resolveRtkBinary();
   if (!bin) return Promise.resolve(null);

package/extensions/rtk-filter/index.ts

@@ -0,0 +1,90 @@
+// 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.ts';
+import { readRtkDefault } from '../shared/plugin-settings.ts';
+import { getSharedComboState, lastCustomValue, sessionEntries } from '../shared/session-state.ts';
+import type { ExtensionApi, ExtensionCtx, SessionEntry, ToolResultEvent } from '../shared/types.ts';
+
+/** 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';
+
+export type FilterExec = (
+  cmd: string,
+  args: string[],
+  opts?: { signal?: AbortSignal; cwd?: string; timeout?: number },
+) => Promise<{ stdout: string; code: number }>;
+
+function modeOf(value: unknown): boolean | null {
+  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: SessionEntry[] | null | undefined): boolean {
+  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: unknown): string | null {
+  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 as { type?: unknown } | null)?.type !== 'text')) return null;
+  return parts.map((part) => (part as { text?: unknown } | null)?.text ?? '').join('\n');
+}
+
+/** Pipe text through one rtk filter; null on any failure, so the caller keeps its original. */
+export async function filterThroughRtk(
+  exec: FilterExec,
+  request: { bin: string; filter: string; text: string; signal?: AbortSignal },
+): Promise<string | null> {
+  const { bin, filter, text, signal } = request;
+  let dir: string | undefined;
+  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: ExtensionApi): void {
+  const bin = resolveRtkBinary();
+  const exec = pi.exec;
+  if (!bin || !exec) return;
+  pi.on<ToolResultEvent>('tool_result', async (event, ctx: ExtensionCtx) => {
+    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/rtk-session/index.ts

@@ -23,7 +23,8 @@ function setRtkProcessEnabled(enabled: boolean): void {
   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: ExtensionApi): void {
   let enabled = DEFAULT_ENABLED;
@@ -134,6 +135,6 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     if (!active) return;
     // 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/shared/host.ts

@@ -36,7 +36,7 @@ interface HostAdapter {
   label(pi: HostHandle, text: string): void;
   on<E>(pi: ExtensionApi, event: string, handler: (event: E, ctx: ExtensionCtx) => unknown): void;
   select(ui: UiApi | undefined, title: string, options: SelectOption[], dialogOptions?: Record<string, unknown>): Promise<string | undefined>;
-  inject(event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined;
+  inject(event: SystemPromptEvent, block: PromptBlock): PromptInjection | undefined;
   stringArray(pi: ExtensionApi, name: string, spec: StringArraySpec): ToolParams;
 }
 
@@ -53,15 +53,21 @@ const piAdapter: HostAdapter = {
     if (picked === undefined) 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: string[]): string[] => (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: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
@@ -78,10 +84,10 @@ const ompAdapter: HostAdapter = {
     if (!ui?.select) 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: string[]): string[] => (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 as { z: ZodFactory['z'] };
@@ -98,10 +104,10 @@ const opencodeAdapter: HostAdapter = {
     if (!ui?.select) 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: string[]): string[] => (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: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
@@ -141,8 +147,15 @@ export async function hostSelect(
   return adapterFor(pi).select(ui, title, options, dialogOptions);
 }
 
-export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined {
-  return adapterFor(pi).inject(event, text, staleMarker);
+/** One prompt block: its text, the section tag that owns it, and prior text to drop. */
+export interface PromptBlock {
+  text: string;
+  sectionTag?: string;
+  staleMarker?: string;
+}
+
+export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, block: PromptBlock): PromptInjection | undefined {
+  return adapterFor(pi).inject(event, block);
 }
 
 export function stringArrayToolParams(pi: ExtensionApi, name: string, spec: StringArraySpec = {}): ToolParams {

package/extensions/shared/plugin-settings.ts

@@ -45,7 +45,7 @@ export function readPluginSettings(): Record<string, unknown> {
 }
 
 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: string, valid: Set<string>): string {

package/extensions/shared/session-state.ts

@@ -14,11 +14,14 @@ export const COMBO_LEVELS: Record<string, Readonly<ComboState>> = Object.freeze(
 });
 
 const MODE_VALUES: Record<string, Set<string>> = {
-  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/;
+
 type ModeName = 'caveman' | 'rtk' | 'ponytail';
 type Modes = Record<ModeName, string>;
 
@@ -43,7 +46,9 @@ export function normalizeMode(name: ModeName, value: unknown): string | null {
   if (name === 'rtk' && typeof value === 'boolean') return value ? 'on' : 'off';
   const mode = String(value ?? '').trim().toLowerCase();
   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: Modes | null | undefined): ComboLevel {
@@ -90,7 +95,9 @@ export function normalizeInputCommand(value: unknown): string {
 }
 
 export function asPromptArray(systemPrompt: string | string[]): string[] {
-  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): part is string => typeof part === 'string');
 }
 
 export function systemPromptIncludes(systemPrompt: string | string[], marker: string): boolean {
@@ -153,6 +160,14 @@ export function setSharedComboMode(name: ModeName, value: unknown): Readonly<Com
   return publish(normalizedState(modes));
 }
 
+export function setSharedComboModes(modes: { caveman?: unknown; rtk?: unknown; ponytail?: unknown }): Readonly<ComboState> {
+  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: SessionEntry[] | null | undefined): Readonly<ComboState> {
   let modes: Modes = { ...COMBO_LEVELS.off };
   if (Array.isArray(entries)) {

package/extensions/shared/status.ts

@@ -17,6 +17,11 @@ export function formatStatus(state: StatusState): string {
   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: string): string {
+  return `Caveman mode: ${mode && mode !== 'off' ? mode : 'unknown'}`;
+}
+
 // Stale ctx access throws, so never let it abort a mode restore.
 function statusUi(ctx: ExtensionCtx | undefined): UiApi | undefined {
   try {
@@ -34,7 +39,8 @@ let lastUi: UiApi | undefined;
 
 // Paint the host footer bar; same text on the same UI is skipped, a new ctx repaints it.
 export function announceStatus(ctx: ExtensionCtx | undefined): void {
-  const text = formatStatus(getSharedComboState());
+  const state = getSharedComboState();
+  const text = formatStatus(state);
   const ui = statusUi(ctx) ?? statusUi(remembered);
   if (statusUi(ctx)) remembered = ctx;
   if (!ui) return;
@@ -42,4 +48,5 @@ export function announceStatus(ctx: ExtensionCtx | undefined): void {
   lastText = text;
   lastUi = ui;
   ui.setStatus?.('tersio', text);
+  ui.setStatus?.('caveman', formatCavemanStatus(state.caveman));
 }