@krtclcdy/tersio 2.24.0 → 2.25.0

package/extensions/opencode/server.ts

@@ -0,0 +1,200 @@
+// OpenCode plugin entry: maps its plugin API onto the shared ExtensionApi the mode extensions consume.
+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 comboToggleExtension from '../combo-toggle/index.ts';
+import tersioCommandsExtension from '../tersio-commands/index.ts';
+import { getSharedComboState } from '../shared/session-state.ts';
+import { formatStatus } from '../shared/status.ts';
+import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
+
+interface CommandConfig {
+  description: string;
+  handler: (args: string, ctx: ExtensionCtx) => Promise<void>;
+}
+
+interface ToolConfig {
+  name: string;
+  description: string;
+  parameters: unknown;
+  execute: (
+    toolCallId: string,
+    params: { args: string[] },
+    signal: AbortSignal | undefined,
+    onUpdate: ((data: unknown) => void) | undefined,
+    ctx: ExtensionCtx | undefined,
+  ) => Promise<{ isError: boolean; content: { type: string; text: string }[]; details: Record<string, unknown> }>;
+}
+
+// Plain object, not Plugin.define: define is an identity wrapper, and a value
+// import would force every install to vendor the whole @opencode dependency tree.
+const plugin: Plugin.Plugin = {
+  id: 'tersio',
+  async setup(ctx) {
+    // Entries are scoped per session; an unseen ID restores on its first hook.
+    const sessions = new Map<string, SessionEntry[]>();
+    const started = new Map<string, Promise<void>>();
+    let activeSid: string | undefined;
+    const loadEntries = async (sid: string): Promise<SessionEntry[]> => {
+      const own = ((await ctx.storage.get(`entries:${sid}`)) as SessionEntry[] | undefined) ?? [];
+      if (own.length) return own;
+      // Pre-scoped installs kept one global list; adopt it once, then diverge.
+      const legacy = ((await ctx.storage.get('entries')) as SessionEntry[] | undefined) ?? [];
+      return [...legacy];
+    };
+    const sessionEntriesOf = (sid: string): SessionEntry[] => {
+      let list = sessions.get(sid);
+      if (!list) {
+        list = [];
+        sessions.set(sid, list);
+      }
+      return list;
+    };
+    const persist = (sid: string): void => {
+      void ctx.storage.set(`entries:${sid}`, sessionEntriesOf(sid) as unknown as never).catch(() => {});
+    };
+    const stubCtx = (sid?: string): ExtensionCtx => ({
+      hasUI: false,
+      cwd: ctx.location.directory,
+      sessionManager: sid === undefined
+        ? { getBranch: () => [], getEntries: () => [] }
+        : {
+          getBranch: () => sessionEntriesOf(sid),
+          getEntries: () => sessionEntriesOf(sid),
+        },
+    });
+    // Starts are chained so appends land in the calling session.
+    let startQueue = Promise.resolve();
+    const runSessionStart = (sid: string): void => {
+      const prev = started.get(sid);
+      if (prev) return;
+      const run = startQueue.then(async () => {
+        for (const row of await loadEntries(sid)) sessionEntriesOf(sid).push(row);
+        activeSid = sid;
+        try {
+          for (const handler of lifecycle.get('session_start') ?? []) await handler({}, stubCtx(sid));
+        } finally {
+          persist(sid);
+          activeSid = undefined;
+        }
+      }).catch(() => {});
+      started.set(sid, run);
+      startQueue = run;
+    };
+    const ensureSession = (sid: string): Promise<void> => {
+      runSessionStart(sid);
+      return started.get(sid) ?? Promise.resolve();
+    };
+    const commands = new Map<string, CommandConfig>();
+    const tools = new Map<string, ToolConfig>();
+    const beforeStart: Array<(event: SystemPromptEvent, ctx: ExtensionCtx) => unknown> = [];
+    const inputHandlers: Array<(event: InputEvent) => unknown> = [];
+    const lifecycle = new Map<string, Array<(event: unknown, ctx: ExtensionCtx) => unknown>>();
+
+    const host: ExtensionApi = {
+      hostId: 'opencode',
+      setLabel() {},
+      registerCommand(name, config) { commands.set(name, config); },
+      registerTool(tool) { tools.set(tool.name, tool as ToolConfig); },
+      appendEntry(type, data) {
+        if (activeSid === undefined) return;
+        sessionEntriesOf(activeSid).push({ type: 'custom', customType: type, data });
+        persist(activeSid);
+      },
+      exec: (cmd, args, opts) => new Promise((resolve) => {
+        execFile(cmd, args, { signal: opts?.signal, cwd: opts?.cwd }, (error, stdout, stderr) => {
+          const code = error && typeof (error as { code?: unknown }).code === 'number' ? (error as { code: number }).code : 0;
+          resolve({ stdout: stdout ?? '', stderr: stderr ?? '', code, killed: !!(error as { killed?: boolean } | null)?.killed });
+        });
+      }),
+      cwd: ctx.location.directory,
+      on: (event, handler) => {
+        if (event === 'before_agent_start') { beforeStart.push(handler as (event: SystemPromptEvent, ctx: ExtensionCtx) => unknown); return; }
+        if (event === 'input') { inputHandlers.push(handler as (event: InputEvent) => unknown); return; }
+        const list = lifecycle.get(event) ?? [];
+        list.push(handler as (event: unknown, ctx: ExtensionCtx) => unknown);
+        lifecycle.set(event, list);
+      },
+    };
+
+    for (const extension of [cavemanSessionExtension, rtkSessionExtension, comboToggleExtension, tersioCommandsExtension]) extension(host);
+
+    // The first hook of an unseen session runs its session_start handlers.
+    const sidOf = (value: unknown): string | undefined =>
+      typeof value === 'string' && value ? value : undefined;
+
+    await ctx.command.transform((editor) => {
+      for (const [name, config] of commands) {
+        editor.add({
+          name,
+          description: config.description,
+          execute: async (input) => {
+            const sid = sidOf((input as { sessionID?: unknown }).sessionID);
+            if (sid) await ensureSession(sid);
+            const text = typeof input.prompt?.text === 'string' ? input.prompt.text : '';
+            const args = text.includes(' ') ? text.slice(text.indexOf(' ') + 1).trim() : '';
+            // The shared handlers report through ui.notify, which has no OpenCode
+            // surface. Collect it and send it back so a command never answers blank.
+            const notes: string[] = [];
+            const cmdCtx: ExtensionCtx = {
+              ...stubCtx(sid),
+              hasUI: true,
+              ui: { notify: (message: string) => { notes.push(message); } },
+            };
+            const prev = activeSid;
+            activeSid = sid;
+            try {
+              await config.handler(args, cmdCtx);
+            } finally {
+              activeSid = prev;
+            }
+            const reply = notes.length ? notes.join('\n') : formatStatus(getSharedComboState());
+            await ctx.session.prompt({ sessionID: input.sessionID, text: reply });
+          },
+        });
+      }
+    });
+
+    await ctx.tool.transform((editor) => {
+      for (const tool of tools.values()) {
+        editor.add({
+          name: tool.name,
+          description: tool.description,
+          input: tool.parameters as { type: 'object'; properties: Record<string, unknown>; required?: string[] },
+          execute: async (input) => {
+            const args = Array.isArray((input as { args?: unknown }).args) ? ((input as { args: string[] }).args) : [];
+            const result = await tool.execute('t', { args }, undefined, undefined, stubCtx());
+            return { content: result.content.map((part) => part.text).join('\n') };
+          },
+        });
+      }
+    });
+
+    await ctx.session.hook('context', async (event) => {
+      const sid = sidOf((event as { sessionID?: unknown }).sessionID);
+      if (sid) await ensureSession(sid);
+      const systemParts = event.system.map((part) => (part.type === 'text' ? part.text : '')).filter(Boolean);
+      for (const handler of beforeStart) {
+        const result = await handler({ systemPrompt: [...systemParts] } as SystemPromptEvent, stubCtx(sid));
+        if (!result || typeof result !== 'object' || !('systemPrompt' in result)) continue;
+        const parts = typeof (result as { systemPrompt: unknown }).systemPrompt === 'string'
+          ? [(result as { systemPrompt: string }).systemPrompt]
+          : Array.isArray((result as { systemPrompt: unknown }).systemPrompt)
+            ? (result as { systemPrompt: string[] }).systemPrompt
+            : [];
+        for (const part of parts) {
+          if (!systemParts.includes(part)) event.system.push({ type: 'text', text: part });
+        }
+      }
+    });
+
+    await ctx.session.hook('prompt', async (event) => {
+      const sid = sidOf((event as { sessionID?: unknown }).sessionID);
+      if (sid) await ensureSession(sid);
+      for (const handler of inputHandlers) void handler({ text: event.prompt.text, source: 'interactive' });
+    });
+  },
+};
+
+export default plugin;

package/extensions/rtk-session/index.js

@@ -1,6 +1,8 @@
-import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.js';
+import { getSharedComboState, hasModeState, isOmpSubagentPrompt, lastCustomValue, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, systemPromptIncludes } from '../shared/session-state.js';
 import { injectPromptText, onHostEvent, setExtensionLabel, stringArrayToolParams } from '../shared/host.js';
 import { readRtkDefault } from '../shared/plugin-settings.js';
+import { resolveRtkBinary } from '../lib/utils.js';
+import { announceStatus } from '../shared/status.js';
 const DEFAULT_ENABLED = false;
 function asBoolean(value) {
     if (typeof value === 'boolean')
@@ -23,37 +25,23 @@ function setRtkProcessEnabled(enabled) {
 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.`;
 export default function rtkSessionExtension(pi) {
     let enabled = DEFAULT_ENABLED;
-    let isActive = false;
-    let lastCtx = undefined;
-    function syncStatus(ctx) {
-        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() || !enabled) {
-            c.ui.setStatus('rtk', undefined);
-            return;
-        }
-        paintStatusBar(c.ui, 'rtk', '⚡', 'rtk: ON', isActive);
+    function fail(text) {
+        return { isError: true, content: [{ type: 'text', text }], details: { enabled } };
     }
     function setEnabled(next, ctx) {
         enabled = Boolean(next);
         pi.appendEntry?.('rtk-mode', { enabled });
         setSharedComboMode('rtk', enabled);
         setRtkProcessEnabled(enabled);
-        const active = activeModesSummary(getSharedComboState());
-        ctx?.ui?.notify?.(enabled ? `RTK on — compact shell output for this session. Active: ${active}.` : `RTK off. Active: ${active}.`, 'info');
+        announceStatus(ctx);
     }
     setExtensionLabel(pi, 'RTK session toggle');
-    // Live mirror: a /tersio or /combo switch publishes shared state — adopt
-    // it at once so the next turn and the rtk_run gate see it, no reload.
+    // Live mirror: a /tersio or /combo switch publishes shared state — adopt it at once so the next turn and the rtk_run gate see it, no reload.
     function syncFromShared(state) {
         enabled = state.rtk === 'on';
         setRtkProcessEnabled(enabled);
-        syncStatus();
     }
-    setSharedComboListener(syncFromShared);
+    setSharedComboListener('rtk', syncFromShared);
     pi.registerCommand?.('rtk', {
         description: 'Toggle RTK compact shell-output guidance for this session',
         handler: async (args, ctx) => {
@@ -82,49 +70,41 @@ export default function rtkSessionExtension(pi) {
             description: "Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']",
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
-            if (!enabled) {
+            // A subagent's own flag sits at its start-up default, so honour shared state too.
+            if (!(enabled || getSharedComboState().rtk === 'on'))
+                return fail('RTK mode is off. Run /rtk on for this session, or use bash explicitly.');
+            if (typeof pi.exec !== 'function')
+                return fail('This host cannot run rtk.');
+            onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
+            try {
+                // A GUI-launched host may lack ~/.bun/bin on PATH, so prefer the resolved path.
+                const result = await pi.exec(resolveRtkBinary() ?? 'rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+                const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
                 return {
-                    isError: true,
-                    content: [{ type: 'text', text: 'RTK mode is off. Run /rtk on for this session, or use bash explicitly.' }],
-                    details: { enabled },
+                    isError: result.code !== 0,
+                    content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
+                    details: { code: result.code, killed: result.killed, enabled },
                 };
             }
-            onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
-            const result = await pi.exec('rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
-            const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
-            return {
-                isError: result.code !== 0,
-                content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
-                details: { code: result.code, killed: result.killed, enabled },
-            };
+            catch (e) {
+                return fail(`rtk could not run: ${e instanceof Error ? e.message : String(e)}`);
+            }
         },
     });
-    onHostEvent(pi, 'input', async (event) => {
-        if (event?.source === 'extension')
-            return;
-        const t = normalizeInputCommand(event?.text);
-        if (t === 'rtk on' || t === 'use rtk')
-            setEnabled(true);
-        if (t === 'rtk off' || t === 'stop rtk')
-            setEnabled(false);
-    });
     function restoreEnabled(ctx) {
         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 session state wins; a fresh session falls back to the installer/user-configured default (off unless configured).
         const persisted = resolveEnabled(entries);
-        enabled = typeof persisted === 'boolean' ? persisted : readRtkDefault();
+        enabled = typeof persisted === 'boolean' ? persisted : enabled || readRtkDefault();
         setRtkProcessEnabled(enabled);
-        syncStatus(ctx);
+        announceStatus(ctx);
     }
+    // Start, resume, and branch all land here, so every session type shows it.
     pi.on('session_start', async (_event, ctx) => {
         restoreEnabled(ctx);
-        ctx?.ui?.notify?.(`RTK loaded: ${enabled ? 'on' : 'off'}`, 'info');
     });
     onHostEvent(pi, 'session_branch', async (_event, ctx) => {
         restoreEnabled(ctx);
@@ -132,18 +112,19 @@ export default function rtkSessionExtension(pi) {
     pi.on('session_tree', async (_event, ctx) => {
         restoreEnabled(ctx);
     });
-    pi.on('agent_start', async (_event, ctx) => {
-        isActive = true;
-        syncStatus(ctx);
+    onHostEvent(pi, 'session_switch', async (_event, ctx) => {
+        restoreEnabled(ctx);
     });
-    pi.on('agent_end', async (_event, ctx) => {
-        isActive = false;
-        syncStatus(ctx);
+    onHostEvent(pi, 'session_compact', async (_event, ctx) => {
+        restoreEnabled(ctx);
     });
     pi.on('before_agent_start', async (event) => {
         const active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === 'on' : enabled;
         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);
     });
 }

package/extensions/rtk-session/index.ts

@@ -1,7 +1,9 @@
-import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.ts';
+import { getSharedComboState, hasModeState, isOmpSubagentPrompt, lastCustomValue, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, systemPromptIncludes } from '../shared/session-state.ts';
 import { injectPromptText, onHostEvent, setExtensionLabel, stringArrayToolParams } from '../shared/host.ts';
 import { readRtkDefault } from '../shared/plugin-settings.ts';
-import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
+import { resolveRtkBinary } from '../lib/utils.ts';
+import { announceStatus } from '../shared/status.ts';
+import type { ExtensionApi, ExtensionCtx, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 const DEFAULT_ENABLED = false;
 
@@ -25,40 +27,28 @@ const RTK_PROMPT = `RTK guidance active. RTK automatically rewrites eligible Bas
 
 export default function rtkSessionExtension(pi: ExtensionApi): void {
   let enabled = DEFAULT_ENABLED;
-  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() || !enabled) {
-      c.ui.setStatus('rtk', undefined);
-      return;
-    }
-    paintStatusBar(c.ui, 'rtk', '⚡', 'rtk: ON', isActive);
+
+  function fail(text: string) {
+    return { isError: true as const, content: [{ type: 'text' as const, text }], details: { enabled } };
   }
 
+
   function setEnabled(next: unknown, ctx?: ExtensionCtx): void {
     enabled = Boolean(next);
     pi.appendEntry?.('rtk-mode', { enabled });
     setSharedComboMode('rtk', enabled);
     setRtkProcessEnabled(enabled);
-    const active = activeModesSummary(getSharedComboState());
-    ctx?.ui?.notify?.(enabled ? `RTK on — compact shell output for this session. Active: ${active}.` : `RTK off. Active: ${active}.`, 'info');
+    announceStatus(ctx);
   }
 
   setExtensionLabel(pi, 'RTK session toggle');
 
-  // Live mirror: a /tersio or /combo switch publishes shared state — adopt
-  // it at once so the next turn and the rtk_run gate see it, no reload.
+  // Live mirror: a /tersio or /combo switch publishes shared state — adopt it at once so the next turn and the rtk_run gate see it, no reload.
   function syncFromShared(state: { rtk: string }): void {
     enabled = state.rtk === 'on';
     setRtkProcessEnabled(enabled);
-    syncStatus();
   }
-  setSharedComboListener(syncFromShared);
+  setSharedComboListener('rtk', syncFromShared);
   pi.registerCommand?.('rtk', {
     description: 'Toggle RTK compact shell-output guidance for this session',
     handler: async (args, ctx) => {
@@ -88,48 +78,39 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
       description: "Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']",
     }),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      if (!enabled) {
+      // A subagent's own flag sits at its start-up default, so honour shared state too.
+      if (!(enabled || getSharedComboState().rtk === 'on')) return fail('RTK mode is off. Run /rtk on for this session, or use bash explicitly.');
+      if (typeof pi.exec !== 'function') return fail('This host cannot run rtk.');
+      onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
+      try {
+        // A GUI-launched host may lack ~/.bun/bin on PATH, so prefer the resolved path.
+        const result = await pi.exec(resolveRtkBinary() ?? 'rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+        const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
         return {
-          isError: true,
-          content: [{ type: 'text', text: 'RTK mode is off. Run /rtk on for this session, or use bash explicitly.' }],
-          details: { enabled },
+          isError: result.code !== 0,
+          content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
+          details: { code: result.code, killed: result.killed, enabled },
         };
+      } catch (e) {
+        return fail(`rtk could not run: ${e instanceof Error ? e.message : String(e)}`);
       }
-      onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
-      const result = await pi.exec!('rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
-      const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
-      return {
-        isError: result.code !== 0,
-        content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
-        details: { code: result.code, killed: result.killed, enabled },
-      };
     },
   });
 
-  onHostEvent<InputEvent>(pi, 'input', async (event) => {
-    if (event?.source === 'extension') return;
-    const t = normalizeInputCommand(event?.text);
-    if (t === 'rtk on' || t === 'use rtk') setEnabled(true);
-    if (t === 'rtk off' || t === 'stop rtk') setEnabled(false);
-  });
   function restoreEnabled(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 session state wins; a fresh session falls back to the installer/user-configured default (off unless configured).
     const persisted = resolveEnabled(entries);
-    enabled = typeof persisted === 'boolean' ? persisted : readRtkDefault();
+    enabled = typeof persisted === 'boolean' ? persisted : enabled || readRtkDefault();
     setRtkProcessEnabled(enabled);
-    syncStatus(ctx);
+    announceStatus(ctx);
   }
 
+  // Start, resume, and branch all land here, so every session type shows it.
   pi.on('session_start', async (_event, ctx) => {
     restoreEnabled(ctx);
-    ctx?.ui?.notify?.(`RTK loaded: ${enabled ? 'on' : 'off'}`, 'info');
   });
 
   onHostEvent(pi, 'session_branch', async (_event, ctx) => {
@@ -140,19 +121,19 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     restoreEnabled(ctx);
   });
 
-  pi.on('agent_start', async (_event, ctx) => {
-    isActive = true;
-    syncStatus(ctx);
+  onHostEvent(pi, 'session_switch', async (_event, ctx) => {
+    restoreEnabled(ctx);
   });
 
-  pi.on('agent_end', async (_event, ctx) => {
-    isActive = false;
-    syncStatus(ctx);
+  onHostEvent(pi, 'session_compact', async (_event, ctx) => {
+    restoreEnabled(ctx);
   });
 
   pi.on<SystemPromptEvent>('before_agent_start', async (event) => {
     const active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === 'on' : enabled;
     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);
   });
 }

package/extensions/shared/carbon.js

@@ -1,11 +1,4 @@
-// extensions/shared/carbon.ts — CO2/energy footprints, EcoLogits-style.
-//
-// Port of the EcoLogits v0.8.2 LLM impact model (genai-impact/ecologits,
-// MPL-2.0 — see ECO_NOTICE.md): the single-stream (batch-1) ceiling divided by
-// serving_concurrency for continuous-batching amortization. Model params come
-// from EcoLogits' registry, else a documented class borrow; unknown ids fall
-// to the gpt-4o default. Render everything from here as ~est., never merged
-// with measured figures.
+// EcoLogits v0.8.2 port; always render as ~est, never merged with measured.
 // EcoLogits 0.8.2 constants — kWh, kgCO2eq, seconds, GB.
 const Q_BITS = 4;
 const E_ALPHA = 8.91e-8;
@@ -28,8 +21,9 @@ const GRIDS = {
 };
 // Serving amortization: single-stream ceiling ÷ concurrency ≈ served impact.
 export const SERVING_CONCURRENCY = 32;
-// Registry values verbatim from EcoLogits' model_repository; borrows cite
-// the public param disclosure they stand in for (MoE active/total).
+/** EcoLogits release this port tracks, so a UI can name it instead of guessing. */
+export const ECOLOGITS_VERSION = '0.8.2';
+// Registry values verbatim from EcoLogits' model_repository; borrows cite the public param disclosure they stand in for (MoE active/total).
 const TABLE = [
     { match: 'opus', active: 625.0, total: 2000, provider: 'anthropic', source: 'registry' },
     { match: 'sonnet', active: 137.5, total: 440, provider: 'anthropic', source: 'registry' },

package/extensions/shared/carbon.ts

@@ -1,11 +1,4 @@
-// extensions/shared/carbon.ts — CO2/energy footprints, EcoLogits-style.
-//
-// Port of the EcoLogits v0.8.2 LLM impact model (genai-impact/ecologits,
-// MPL-2.0 — see ECO_NOTICE.md): the single-stream (batch-1) ceiling divided by
-// serving_concurrency for continuous-batching amortization. Model params come
-// from EcoLogits' registry, else a documented class borrow; unknown ids fall
-// to the gpt-4o default. Render everything from here as ~est., never merged
-// with measured figures.
+// EcoLogits v0.8.2 port; always render as ~est, never merged with measured.
 
 export interface ModelCarbon {
   activeB: number;
@@ -39,6 +32,9 @@ const GRIDS: Record<string, number> = {
 // Serving amortization: single-stream ceiling ÷ concurrency ≈ served impact.
 export const SERVING_CONCURRENCY = 32;
 
+/** EcoLogits release this port tracks, so a UI can name it instead of guessing. */
+export const ECOLOGITS_VERSION = '0.8.2';
+
 interface RegistryEntry {
   match?: string;
   exact?: string;
@@ -48,8 +44,7 @@ interface RegistryEntry {
   source: 'registry' | 'borrowed';
 }
 
-// Registry values verbatim from EcoLogits' model_repository; borrows cite
-// the public param disclosure they stand in for (MoE active/total).
+// Registry values verbatim from EcoLogits' model_repository; borrows cite the public param disclosure they stand in for (MoE active/total).
 const TABLE: RegistryEntry[] = [
   { match: 'opus', active: 625.0, total: 2000, provider: 'anthropic', source: 'registry' },
   { match: 'sonnet', active: 137.5, total: 440, provider: 'anthropic', source: 'registry' },