@krtclcdy/tersio 2.24.0 → 2.25.0

package/extensions/caveman-session/index.ts

@@ -1,45 +1,28 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.ts';
+import { getSharedComboState, hasModeState, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, systemPromptIncludes } from '../shared/session-state.ts';
 import { dirname, join } from 'node:path';
 import { injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host.ts';
+import { announceStatus } from '../shared/status.ts';
 import { readCavemanDefault } from '../shared/plugin-settings.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
 const RULE_PATH = join(CAVERN_DIR, 'rule.md');
 
-const FALLBACK_FULL_RULE = `Caveman full active for this session.
-Respond terse like smart caveman. Keep all technical substance. Drop filler, pleasantries, and hedging.
-
-Rules:
-- Drop articles where meaning stays clear. Keep fragments and short sentences.
-- Keep technical terms, code, commands, paths, API names, numbers, units, and errors exact.
-- Never invent abbreviations or causal arrows. Do not add words to sound caveman.
-- Use ASD-STE100 Simplified Technical English. Keep one idea per sentence, target 20 words, active voice, and consistent terms.
-- Make no tool-call narration. Use no decorative tables or emoji.
-- Preserve the user's reply language. Compress style, not language.
-- Drop caveman for security warnings, irreversible actions, ambiguous multi-step sequences, or requests to clarify.
-- Write code, comments, commits, docs, issues, pull requests, and third-party messages in normal prose.
-
-Default: **full**. Switch: \`/caveman lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off\`. Stop: "stop caveman" or "normal mode".`;
-
-// ponytail: synchronous read each full-mode injection; ceiling = small file, cold session start. Upgrade path: cache file contents + mtime, invalidate on change.
+// Fail loud: a wrong rule reads to the model as the real one.
 function readFullRule(): string {
-  try { return readFileSync(RULE_PATH, 'utf8'); } catch { return FALLBACK_FULL_RULE; }
+  try { return readFileSync(RULE_PATH, 'utf8'); } catch {
+    return 'Caveman full requested, but rule.md is missing. Run: tersio doctor --fix extensions';
+  }
 }
 
 const DEFAULT_MODE = 'off';
-const INSTRUCTIONS: Record<string, string | (() => string)> = {
-  lite: `Caveman lite active for this session.
-Respond concise. Drop pleasantries, filler, and hedging. Keep complete technical substance. Code, commands, paths, errors, commits, and PR text stay normal/exact.`,
-  full: () => `Caveman full active for this session.\n${readFullRule()}`,
-  ultra: `Caveman ultra active for this session.
-Maximum terse prose. Strip conjunctions only when meaning stays clear. State each fact once. Use no invented abbreviations or causal arrows. Keep code, commands, commits, PR text, paths, API names, numbers, units, and errors exact. Drop caveman for security warnings, irreversible actions, ambiguous multi-step sequences, or user confusion.`,
-  'wenyan-lite': `Caveman wenyan-lite active for this session. Use semi-classical terse prose. Keep grammar structure, user language, technical terms, code, commands, paths, API names, numbers, units, and errors exact. Drop caveman when clarity or safety needs normal prose.`,
-  'wenyan-full': `Caveman wenyan-full active for this session. Use maximum classical terseness where meaning stays clear. Use classical sentence patterns, verbs before objects, and optional omitted subjects. Keep user language, technical terms, code, commands, paths, API names, numbers, units, and errors exact. Drop caveman when clarity or safety needs normal prose.`,
-  'wenyan-ultra': `Caveman wenyan-ultra active for this session. Use extreme classical abbreviation while keeping a classical Chinese feel and meaning clear. Keep user language, technical terms, code, commands, paths, API names, numbers, units, and errors exact. Drop caveman when clarity or safety needs normal prose.`,
-};
+
+// Upstream ships one SKILL.md; the level is a directive inside it, so swap only the header.
+function buildInstruction(mode: string): string {
+  return `Caveman ${mode} active for this session.\n${readFullRule()}`;
+}
 
 function resolveMode(entries: SessionEntry[] | null | undefined, fallback: string = DEFAULT_MODE): string {
   return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
@@ -52,20 +35,7 @@ function isOffCommand(text: unknown): boolean {
 
 export default function cavemanSessionExtension(pi: ExtensionApi): void {
   let currentMode = DEFAULT_MODE;
-  let isActive = false;
-  let lastCtx: ExtensionCtx | undefined = undefined;
-
-  function syncStatus(ctx?: ExtensionCtx): void {
-    lastCtx = paintableCtx(lastCtx, ctx);
-    const c = lastCtx;
-    if (!c?.ui?.setStatus) return;
-    // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
-    if (isComboPresetActive() || currentMode === 'off') {
-      c.ui.setStatus('caveman', undefined);
-      return;
-    }
-    paintStatusBar(c.ui, 'caveman', '🪨', `caveman: ${currentMode.toUpperCase()}`, isActive);
-  }
+  let lastInjected: string | undefined = undefined;
 
   function setMode(mode: string, ctx?: ExtensionCtx): boolean {
     const normalized = normalizeMode('caveman', mode);
@@ -73,28 +43,18 @@ export default function cavemanSessionExtension(pi: ExtensionApi): void {
     currentMode = normalized;
     pi.appendEntry?.('caveman-mode', { mode: normalized });
     setSharedComboMode('caveman', normalized);
-    syncStatus(ctx);
-    const active = activeModesSummary(getSharedComboState());
-    const msg = normalized === 'off'
-      ? `Caveman off. Active: ${active}.`
-      : `Caveman ${normalized} on — terse replies for this session. Active: ${active}.`;
-    ctx?.ui?.notify?.(msg, 'info');
+    announceStatus(ctx);
     return true;
   }
 
   setExtensionLabel(pi, 'Caveman session toggle');
 
-  // Live mirror: a /tersio or /combo switch publishes shared state — adopt
-  // it at once so the next turn injects the new mode with no session reload.
-  // Stable identity, so the bridge set dedupes across re-inits.
+  // Adopt a /tersio or /combo switch at once, so the next turn needs no reload.
   function syncFromShared(state: { caveman: string }): void {
     const mode = normalizeMode('caveman', state.caveman);
-    if (mode) {
-      currentMode = mode;
-      syncStatus();
-    }
+    if (mode) currentMode = mode;
   }
-  setSharedComboListener(syncFromShared);
+  setSharedComboListener('caveman', syncFromShared);
   pi.registerCommand?.('caveman', {
     description: 'Toggle terse caveman replies for this session',
     handler: async (args, ctx) => {
@@ -104,7 +64,7 @@ export default function cavemanSessionExtension(pi: ExtensionApi): void {
         return;
       }
       if (arg === 'status') {
-        ctx?.ui?.notify?.(`Caveman: ${currentMode}`, 'info');
+        announceStatus(ctx);
         return;
       }
       if (!setMode(arg, ctx)) {
@@ -120,21 +80,18 @@ export default function cavemanSessionExtension(pi: ExtensionApi): void {
 
   function restoreMode(ctx?: ExtensionCtx): void {
     const entries = sessionEntries(ctx);
-    // Publish the persisted combo state (incl. combo-level) before painting:
-    // bar suppression reads the in-process bridge, which is empty in a fresh
-    // host until the combo extension reconciles — and its reconcile is
-    // UI-gated. Deriving it here makes suppression independent of load order.
-    reconcileSharedComboEntries(entries);
-    // Persisted session state wins; a fresh session falls back to the
-    // installer/user-configured default (off unless configured).
+    // A subagent's branch has no Tersio entries; reconciling it would wipe shared state.
+    if (hasModeState(entries)) reconcileSharedComboEntries(entries);
+    // Persisted state wins, then a mode already chosen this session, then the configured default. `off` is the start value, not "unset".
     const persisted = resolveMode(entries, '');
-    currentMode = persisted || normalizeMode('caveman', readCavemanDefault()) || DEFAULT_MODE;
-    syncStatus(ctx);
+    const alreadyChosen = currentMode !== DEFAULT_MODE;
+    currentMode = persisted || (alreadyChosen ? currentMode : normalizeMode('caveman', readCavemanDefault())) || DEFAULT_MODE;
+    announceStatus(ctx);
   }
 
+  // Start, resume, and branch all land here, so every session type shows it.
   pi.on('session_start', async (_event, ctx) => {
     restoreMode(ctx);
-    ctx?.ui?.notify?.(`Caveman loaded: ${currentMode}`, 'info');
   });
 
   onHostEvent(pi, 'session_branch', async (_event, ctx) => {
@@ -145,22 +102,23 @@ export default function cavemanSessionExtension(pi: ExtensionApi): void {
     restoreMode(ctx);
   });
 
-  pi.on('agent_start', async (_event, ctx) => {
-    isActive = true;
-    syncStatus(ctx);
+  onHostEvent(pi, 'session_switch', async (_event, ctx) => {
+    restoreMode(ctx);
   });
 
-  pi.on('agent_end', async (_event, ctx) => {
-    isActive = false;
-    syncStatus(ctx);
+  onHostEvent(pi, 'session_compact', async (_event, ctx) => {
+    restoreMode(ctx);
   });
 
   pi.on('before_agent_start', async (event: SystemPromptEvent) => {
     const mode = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().caveman : currentMode;
     if (!mode || mode === 'off') return;
-    const def = INSTRUCTIONS[mode];
-    if (!def) return;
-    const instruction = typeof def === 'function' ? def() : def;
-    return injectPromptText(pi, event, instruction);
+    const instruction = buildInstruction(mode);
+    // Match the whole instruction so a re-presented prompt cannot stack it.
+    if (systemPromptIncludes(event.systemPrompt, instruction)) return;
+    // The previous level's block is replaced, not stacked on.
+    const stale = lastInjected;
+    lastInjected = instruction;
+    return injectPromptText(pi, event, instruction, stale);
   });
 }

package/extensions/combo-toggle/index.js

@@ -8,11 +8,13 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import path from 'node:path';
+import { existsSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { activeModesSummary, COMBO_LEVELS, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, normalizeComboLevel, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, setSharedComboMode, systemPromptIncludes, themeStatus, } from '../shared/session-state.js';
+import { activeModesSummary, COMBO_LEVELS, getSharedComboState, hasModeState, normalizeComboLevel, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, setSharedComboMode, 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 { findHoistedPackage } from '../lib/utils.js';
+import { findHoistedPackage, isPiProcess } from '../lib/utils.js';
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PONYTAIL_FALLBACK_INTENSITY = {
     lite: 'Prefer the simplest correct solution.',
@@ -22,16 +24,15 @@ export function ponytailFallback(mode) {
     const intensity = PONYTAIL_FALLBACK_INTENSITY[mode] ?? 'Use the minimum correct solution. Delete or reuse before adding.';
     return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
 }
-function levelSummary(state) {
-    return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
-}
-// Ponytail is hoisted, so one upward walk covers every install layout. The hook
-// is CommonJS, so both namespace shapes are tried.
+// Ponytail is hoisted, so one upward walk covers every install layout. The hook is CommonJS, so both namespace shapes are tried.
 async function loadPonytailInstructions(mode) {
     const installed = findHoistedPackage('@dietrichgebert/ponytail', EXTENSION_DIR, 'hooks', 'ponytail-instructions.js');
-    if (installed) {
+    // The OpenCode tree ships no node_modules; the installer bundles the ruleset beside the extensions.
+    const bundled = path.join(EXTENSION_DIR, '..', 'ponytail-bundle', 'hooks', 'ponytail-instructions.js');
+    const treeLocal = installed ?? (existsSync(bundled) ? bundled : null);
+    if (treeLocal) {
         try {
-            const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(installed).href));
+            const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(treeLocal).href));
             const build = loaded.getPonytailInstructions ?? loaded.default?.getPonytailInstructions;
             if (build)
                 return build(mode);
@@ -42,30 +43,8 @@ async function loadPonytailInstructions(mode) {
 }
 export default function comboToggleExtension(pi) {
     setExtensionLabel(pi, 'Combo session toggle (all 3 add-ons)');
-    let lastCtx = undefined;
     let setupPrompted = false;
-    function syncStatus(ctx) {
-        lastCtx = paintableCtx(lastCtx, ctx);
-        const c = lastCtx;
-        if (!c?.ui?.setStatus)
-            return;
-        // One unified bar replaces the per-extension bars while a preset is active.
-        if (!isComboPresetActive()) {
-            c.ui.setStatus('combo', undefined);
-            return;
-        }
-        // Read the live bridge, not a cache: siblings reconcile it first.
-        const state = getSharedComboState();
-        const c0 = state.caveman.toUpperCase();
-        const r = state.rtk.toUpperCase();
-        const p = state.ponytail.toUpperCase();
-        const lvl = state.level.toUpperCase();
-        c.ui.setStatus('combo', themeStatus(c.ui, '🧩', `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`, true));
-        // Our bar is canonical for the preset, so clear any sibling bar.
-        c.ui.setStatus('caveman', undefined);
-        c.ui.setStatus('rtk', undefined);
-        c.ui.setStatus('ponytail', undefined);
-    }
+    let lastInjected = undefined;
     // Siblings restore from these entries, so the fallback must write them too.
     function persistPreset(level) {
         const modes = COMBO_LEVELS[level];
@@ -74,19 +53,15 @@ export default function comboToggleExtension(pi) {
         pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
         pi.appendEntry?.('combo-level', { level });
     }
-    function useState(state, ctx) {
-        syncStatus(ctx);
-        return state;
-    }
     function reconcile(ctx) {
         if (!ctx?.hasUI)
             return getSharedComboState();
-        return useState(reconcileSharedComboEntries(sessionEntries(ctx)), ctx);
+        return reconcileSharedComboEntries(sessionEntries(ctx));
     }
     function listen(ctx) {
-        // Stable identity: the bridge set dedupes, so repeat calls register once.
-        if (ctx?.hasUI)
-            setSharedComboListener(useState);
+        if (!ctx?.hasUI)
+            return;
+        setSharedComboListener('combo', (state) => { announceStatus(ctx); return state; });
     }
     function track(ctx) {
         listen(ctx);
@@ -99,8 +74,8 @@ export default function comboToggleExtension(pi) {
             listen(ctx);
             const arg = String(args || '').trim().toLowerCase();
             if (!arg || arg === 'status') {
-                const state = reconcile(ctx);
-                ctx?.ui?.notify?.(`Combo: ${state.level === 'custom' ? 'INACTIVE' : state.level.toUpperCase()} (${levelSummary(state)})`, 'info');
+                reconcile(ctx);
+                announceStatus(ctx);
                 return;
             }
             if (arg === 'help') {
@@ -116,9 +91,8 @@ export default function comboToggleExtension(pi) {
                 return;
             }
             persistPreset(level);
-            useState(setSharedComboLevel(level), ctx);
-            const active = activeModesSummary(getSharedComboState());
-            ctx?.ui?.notify?.(level === 'off' ? `Combo off — all tersio modes inactive for this session. Active: ${active}.` : `Combo ${level} on — ${active} active for this session.`, 'info');
+            setSharedComboLevel(level);
+            announceStatus(ctx);
         },
     });
     async function runFirstRunSetup(ctx) {
@@ -134,40 +108,39 @@ export default function comboToggleExtension(pi) {
         const level = choice || 'off';
         if (saveComboSetup(level) && level !== 'off') {
             persistPreset(level);
-            useState(setSharedComboLevel(level), ctx);
+            setSharedComboLevel(level);
             ctx.ui.notify?.(`Combo default saved: ${level} — ${activeModesSummary(getSharedComboState())} will activate on fresh sessions.`, 'info');
         }
     }
     pi.on('session_start', async (_event, ctx) => {
         track(ctx);
-        if (!ctx?.hasUI)
-            syncStatus(ctx);
         await runFirstRunSetup(ctx);
         // The configured default applies only when no persisted mode state exists.
         const entries = sessionEntries(ctx);
-        const hasModeState = entries.some((e) => e?.type === 'custom' && (e.customType === 'combo-level' || e.customType === 'caveman-mode' ||
-            e.customType === 'rtk-mode' || e.customType === 'ponytail-mode'));
-        if (getSharedComboState().level === 'off' && !hasModeState) {
+        const persisted = hasModeState(entries);
+        if (getSharedComboState().level === 'off' && !persisted) {
             const fallback = readComboDefault();
             if (fallback !== 'off') {
                 persistPreset(fallback);
-                useState(setSharedComboLevel(fallback), ctx);
-                ctx?.ui?.notify?.(`Combo default applied: ${fallback} — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
+                setSharedComboLevel(fallback);
             }
         }
-        // No sibling restores a standalone ponytail default, so apply it here; skip
-        // it when the active preset already writes the same mode.
+        // 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 });
-                useState(setSharedComboMode('ponytail', ponytailFallback), ctx);
+                setSharedComboMode('ponytail', ponytailFallback);
             }
         }
+        // Announced last, so any default above is reflected.
+        announceStatus(ctx);
     });
-    for (const event of ['session_branch', 'session_tree', 'agent_start']) {
+    // Resume, branch, and compaction re-announce; dedupe keeps repeats silent.
+    for (const event of ['session_branch', 'session_tree', 'agent_start', 'session_switch', 'session_compact']) {
         onHostEvent(pi, event, async (_event, ctx) => {
             track(ctx);
+            announceStatus(ctx);
             if (event === 'agent_start')
                 await runFirstRunSetup(ctx);
         });
@@ -175,13 +148,18 @@ export default function comboToggleExtension(pi) {
     pi.on('before_agent_start', async (event, ctx) => {
         if (ctx?.hasUI)
             reconcile(ctx);
-        if (!isOmpSubagentPrompt(event.systemPrompt))
-            return;
         const mode = getSharedComboState().ponytail;
-        if (mode === 'off' || systemPromptIncludes(event.systemPrompt, 'PONYTAIL MODE ACTIVE'))
+        // On pi the upstream ponytail pi-extension is the single injector; it reads these 'ponytail-mode' entries at session start, so Tersio only persists.
+        if (isPiProcess())
+            return;
+        // Match the level's own header: the shared phrase alone makes every level block every other, so a `/combo` level switch is ignored all session.
+        if (mode === 'off' || systemPromptIncludes(event.systemPrompt, `PONYTAIL MODE ACTIVE — level: ${mode}`))
             return;
-        const instructions = await loadPonytailInstructions(mode);
-        return injectPromptText(pi, event, instructions);
+        const instruction = await loadPonytailInstructions(mode);
+        // The previous level's block is replaced, not stacked on.
+        const stale = lastInjected;
+        lastInjected = instruction;
+        return injectPromptText(pi, event, instruction, stale);
     });
     // Slash commands only; natural-language input caused accidental toggles and has no reload context.
 }

package/extensions/combo-toggle/index.ts

@@ -1,32 +1,30 @@
 // /combo session toggle: off | medium | balanced | max.
 
-import os from 'node:os';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import {
   activeModesSummary,
   COMBO_LEVELS,
   getSharedComboState,
-  isComboPresetActive,
-  isOmpSubagentPrompt,
+  hasModeState,
   normalizeComboLevel,
-  paintableCtx,
   reconcileSharedComboEntries,
   sessionEntries,
   setSharedComboLevel,
   setSharedComboListener,
   setSharedComboMode,
   systemPromptIncludes,
-  themeStatus,
 } from '../shared/session-state.ts';
 import { hostSelect, injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host.ts';
+import { announceStatus } from '../shared/status.ts';
 import {
   isComboSetupComplete,
   readComboDefault,
   readPonytailDefault,
   saveComboSetup,
 } from '../shared/plugin-settings.ts';
-import { findHoistedPackage } from '../lib/utils.ts';
+import { findHoistedPackage, isPiProcess } from '../lib/utils.ts';
 import type { ComboState, ExtensionApi, ExtensionCtx, SystemPromptEvent } from '../shared/types.ts';
 
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -41,17 +39,16 @@ export function ponytailFallback(mode: string): string {
   return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
 }
 
-function levelSummary(state: ComboState): string {
-  return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
-}
 
-// Ponytail is hoisted, so one upward walk covers every install layout. The hook
-// is CommonJS, so both namespace shapes are tried.
+// Ponytail is hoisted, so one upward walk covers every install layout. The hook is CommonJS, so both namespace shapes are tried.
 async function loadPonytailInstructions(mode: string): Promise<string> {
   const installed = findHoistedPackage('@dietrichgebert/ponytail', EXTENSION_DIR, 'hooks', 'ponytail-instructions.js');
-  if (installed) {
+  // The OpenCode tree ships no node_modules; the installer bundles the ruleset beside the extensions.
+  const bundled = path.join(EXTENSION_DIR, '..', 'ponytail-bundle', 'hooks', 'ponytail-instructions.js');
+  const treeLocal = installed ?? (existsSync(bundled) ? bundled : null);
+  if (treeLocal) {
     try {
-      const loaded = await import(pathToFileURL(installed).href) as {
+      const loaded = await import(pathToFileURL(treeLocal).href) as {
         getPonytailInstructions?: (level: string) => string;
         default?: { getPonytailInstructions?: (level: string) => string };
       };
@@ -65,30 +62,9 @@ async function loadPonytailInstructions(mode: string): Promise<string> {
 export default function comboToggleExtension(pi: ExtensionApi): void {
   setExtensionLabel(pi, 'Combo session toggle (all 3 add-ons)');
 
-  let lastCtx: ExtensionCtx | undefined = undefined;
   let setupPrompted = false;
+  let lastInjected: string | undefined = undefined;
 
-  function syncStatus(ctx?: ExtensionCtx): void {
-    lastCtx = paintableCtx(lastCtx, ctx);
-    const c = lastCtx;
-    if (!c?.ui?.setStatus) return;
-    // One unified bar replaces the per-extension bars while a preset is active.
-    if (!isComboPresetActive()) {
-      c.ui.setStatus('combo', undefined);
-      return;
-    }
-    // Read the live bridge, not a cache: siblings reconcile it first.
-    const state = getSharedComboState();
-    const c0 = state.caveman.toUpperCase();
-    const r = state.rtk.toUpperCase();
-    const p = state.ponytail.toUpperCase();
-    const lvl = state.level.toUpperCase();
-    c.ui.setStatus('combo', themeStatus(c.ui, '🧩', `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`, true));
-    // Our bar is canonical for the preset, so clear any sibling bar.
-    c.ui.setStatus('caveman', undefined);
-    c.ui.setStatus('rtk', undefined);
-    c.ui.setStatus('ponytail', undefined);
-  }
 
   // Siblings restore from these entries, so the fallback must write them too.
   function persistPreset(level: string): void {
@@ -99,18 +75,13 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
     pi.appendEntry?.('combo-level', { level });
   }
 
-  function useState(state: Readonly<ComboState>, ctx?: ExtensionCtx): Readonly<ComboState> {
-    syncStatus(ctx);
-    return state;
-  }
-
   function reconcile(ctx?: ExtensionCtx): Readonly<ComboState> {
     if (!ctx?.hasUI) return getSharedComboState();
-    return useState(reconcileSharedComboEntries(sessionEntries(ctx)), ctx);
+    return reconcileSharedComboEntries(sessionEntries(ctx));
   }
   function listen(ctx?: ExtensionCtx): void {
-    // Stable identity: the bridge set dedupes, so repeat calls register once.
-    if (ctx?.hasUI) setSharedComboListener(useState);
+    if (!ctx?.hasUI) return;
+    setSharedComboListener('combo', (state) => { announceStatus(ctx); return state; });
   }
 
   function track(ctx?: ExtensionCtx): void {
@@ -125,11 +96,8 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
       const arg = String(args || '').trim().toLowerCase();
 
       if (!arg || arg === 'status') {
-        const state = reconcile(ctx);
-        ctx?.ui?.notify?.(
-          `Combo: ${state.level === 'custom' ? 'INACTIVE' : state.level.toUpperCase()} (${levelSummary(state)})`,
-          'info'
-        );
+        reconcile(ctx);
+        announceStatus(ctx);
         return;
       }
 
@@ -154,13 +122,8 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
       }
 
       persistPreset(level);
-      useState(setSharedComboLevel(level), ctx);
-
-      const active = activeModesSummary(getSharedComboState());
-      ctx?.ui?.notify?.(
-        level === 'off' ? `Combo off — all tersio modes inactive for this session. Active: ${active}.` : `Combo ${level} on — ${active} active for this session.`,
-        'info'
-      );
+      setSharedComboLevel(level);
+      announceStatus(ctx);
     },
   });
 
@@ -176,54 +139,57 @@ export default function comboToggleExtension(pi: ExtensionApi): void {
     const level = choice || 'off';
     if (saveComboSetup(level) && level !== 'off') {
       persistPreset(level);
-      useState(setSharedComboLevel(level), ctx);
+      setSharedComboLevel(level);
       ctx.ui.notify?.(`Combo default saved: ${level} — ${activeModesSummary(getSharedComboState())} will activate on fresh sessions.`, 'info');
     }
   }
 
   pi.on('session_start', async (_event, ctx) => {
     track(ctx);
-    if (!ctx?.hasUI) syncStatus(ctx);
     await runFirstRunSetup(ctx);
     // The configured default applies only when no persisted mode state exists.
     const entries = sessionEntries(ctx);
-    const hasModeState = entries.some((e) => e?.type === 'custom' && (
-      e.customType === 'combo-level' || e.customType === 'caveman-mode' ||
-      e.customType === 'rtk-mode' || e.customType === 'ponytail-mode'));
-    if (getSharedComboState().level === 'off' && !hasModeState) {
+    const persisted = hasModeState(entries);
+    if (getSharedComboState().level === 'off' && !persisted) {
       const fallback = readComboDefault();
       if (fallback !== 'off') {
         persistPreset(fallback);
-        useState(setSharedComboLevel(fallback), ctx);
-        ctx?.ui?.notify?.(`Combo default applied: ${fallback} — ${activeModesSummary(getSharedComboState())} active for this session.`, 'info');
+        setSharedComboLevel(fallback);
       }
     }
-    // No sibling restores a standalone ponytail default, so apply it here; skip
-    // it when the active preset already writes the same mode.
+    // 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 });
-        useState(setSharedComboMode('ponytail', ponytailFallback), ctx);
+        setSharedComboMode('ponytail', ponytailFallback);
       }
     }
+    // Announced last, so any default above is reflected.
+    announceStatus(ctx);
   });
 
-  for (const event of ['session_branch', 'session_tree', 'agent_start']) {
+  // Resume, branch, and compaction re-announce; dedupe keeps repeats silent.
+  for (const event of ['session_branch', 'session_tree', 'agent_start', 'session_switch', 'session_compact']) {
     onHostEvent(pi, event, async (_event, ctx) => {
       track(ctx);
+      announceStatus(ctx);
       if (event === 'agent_start') await runFirstRunSetup(ctx);
     });
   }
 
   pi.on<SystemPromptEvent>('before_agent_start', async (event, ctx) => {
     if (ctx?.hasUI) reconcile(ctx);
-    if (!isOmpSubagentPrompt(event.systemPrompt)) return;
-
     const mode = getSharedComboState().ponytail;
-    if (mode === 'off' || systemPromptIncludes(event.systemPrompt, 'PONYTAIL MODE ACTIVE')) return;
-    const instructions = await loadPonytailInstructions(mode);
-    return injectPromptText(pi, event, instructions);
+    // On pi the upstream ponytail pi-extension is the single injector; it reads these 'ponytail-mode' entries at session start, so Tersio only persists.
+    if (isPiProcess()) return;
+    // Match the level's own header: the shared phrase alone makes every level block every other, so a `/combo` level switch is ignored all session.
+    if (mode === 'off' || systemPromptIncludes(event.systemPrompt, `PONYTAIL MODE ACTIVE — level: ${mode}`)) return;
+    const instruction = await loadPonytailInstructions(mode);
+    // The previous level's block is replaced, not stacked on.
+    const stale = lastInjected;
+    lastInjected = instruction;
+    return injectPromptText(pi, event, instruction, stale);
   });
 
   // Slash commands only; natural-language input caused accidental toggles and has no reload context.