@krtclcdy/tersio 2.24.1 → 2.25.0

package/extensions/rtk-session/index.js

@@ -1,6 +1,8 @@
-import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, statusUi, systemPromptIncludes } 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,38 +25,21 @@ 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 fail(text) {
         return { isError: true, content: [{ type: 'text', text }], details: { enabled } };
     }
-    function syncStatus(ctx) {
-        lastCtx = paintableCtx(lastCtx, ctx);
-        const ui = statusUi(lastCtx);
-        if (!ui)
-            return;
-        // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
-        if (isComboPresetActive() || !enabled) {
-            ui.setStatus('rtk', undefined);
-            return;
-        }
-        paintStatusBar(ui, 'rtk', '⚡', 'rtk: ON', isActive);
-    }
     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('rtk', syncFromShared);
     pi.registerCommand?.('rtk', {
@@ -85,13 +70,15 @@ 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 {
-                const result = await pi.exec('rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+                // 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: result.code !== 0,
@@ -106,18 +93,18 @@ export default function rtkSessionExtension(pi) {
     });
     function restoreEnabled(ctx) {
         const entries = sessionEntries(ctx);
-        // Derive the bridge here so bar suppression does not depend on 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);
@@ -125,13 +112,11 @@ 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;

package/extensions/rtk-session/index.ts

@@ -1,6 +1,8 @@
-import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, statusUi, systemPromptIncludes } 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 { 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,42 +27,26 @@ 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 fail(text: string) {
     return { isError: true as const, content: [{ type: 'text' as const, text }], details: { enabled } };
   }
 
-  function syncStatus(ctx?: ExtensionCtx): void {
-    lastCtx = paintableCtx(lastCtx, ctx);
-    const ui = statusUi(lastCtx);
-    if (!ui) return;
-    // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
-    if (isComboPresetActive() || !enabled) {
-      ui.setStatus('rtk', undefined);
-      return;
-    }
-    paintStatusBar(ui, 'rtk', '⚡', 'rtk: ON', isActive);
-  }
 
   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('rtk', syncFromShared);
   pi.registerCommand?.('rtk', {
@@ -92,11 +78,13 @@ 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) return fail('RTK mode is off. Run /rtk on for this session, or use bash explicitly.');
+      // 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 {
-        const result = await pi.exec('rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+        // 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: result.code !== 0,
@@ -111,19 +99,18 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
 
   function restoreEnabled(ctx?: ExtensionCtx): void {
     const entries = sessionEntries(ctx);
-    // Derive the bridge here so bar suppression does not depend on 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) => {
@@ -134,14 +121,12 @@ 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) => {

package/extensions/shared/carbon.js

@@ -23,8 +23,7 @@ const GRIDS = {
 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';
-// 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 = [
     { 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

@@ -44,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' },

package/extensions/shared/host.js

@@ -1,58 +1,107 @@
-// One source for both hosts; OMP differs in six APIs, detected by shape not name.
+// One source for both hosts; each host-specific behaviour lives in one adapter row.
 import { asPromptArray } from './session-state.js';
+const piAdapter = {
+    label() { },
+    on(pi, event, handler) {
+        if (event === 'session_branch')
+            return;
+        pi.on(event, handler);
+    },
+    async select(ui, title, options, dialogOptions) {
+        if (!ui?.select)
+            return undefined;
+        const shown = options.map((o) => (o.description ? `${o.label} — ${o.description}` : o.label));
+        const picked = await ui.select(title, shown, dialogOptions);
+        if (picked === undefined)
+            return undefined;
+        return options[shown.indexOf(picked)]?.label ?? picked;
+    },
+    inject(event, text, staleMarker) {
+        const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+        const dropStale = (parts) => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
+        const options = event.systemPromptOptions;
+        if (options && typeof options.appendSystemPrompt === 'string') {
+            options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(text).filter(Boolean).join('\n\n');
+            return undefined;
+        }
+        return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${text}` };
+    },
+    stringArray(_pi, name, spec) {
+        const array = { type: 'array', items: { type: 'string' } };
+        if (spec.minItems)
+            array.minItems = spec.minItems;
+        if (spec.description)
+            array.description = spec.description;
+        return { type: 'object', properties: { [name]: array }, required: [name] };
+    },
+};
+const ompAdapter = {
+    label(pi, text) { pi.setLabel?.(text); },
+    on(pi, event, handler) { pi.on(event, handler); },
+    async select(ui, title, options, dialogOptions) {
+        if (!ui?.select)
+            return undefined;
+        return ui.select(title, options, dialogOptions);
+    },
+    inject(event, text, staleMarker) {
+        const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+        const dropStale = (parts) => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
+        return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+    },
+    stringArray(pi, name, spec) {
+        const { z } = pi.zod;
+        const array = z.array(z.string());
+        const constrained = spec.minItems ? array.min(spec.minItems) : array;
+        return z.object({ [name]: spec.description ? constrained.describe(spec.description) : constrained });
+    },
+};
+const opencodeAdapter = {
+    label() { },
+    on(pi, event, handler) { pi.on(event, handler); },
+    async select(ui, title, options, dialogOptions) {
+        if (!ui?.select)
+            return undefined;
+        return ui.select(title, options, dialogOptions);
+    },
+    inject(event, text, staleMarker) {
+        const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+        const dropStale = (parts) => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
+        return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+    },
+    stringArray(_pi, name, spec) {
+        const array = { type: 'array', items: { type: 'string' } };
+        if (spec.minItems)
+            array.minItems = spec.minItems;
+        if (spec.description)
+            array.description = spec.description;
+        return { type: 'object', properties: { [name]: array }, required: [name] };
+    },
+};
+// Explicit hostId wins; the legacy zod sniff keeps old callers working.
+function adapterFor(pi) {
+    if (pi.hostId === 'opencode')
+        return opencodeAdapter;
+    if (pi.hostId === 'omp')
+        return ompAdapter;
+    if (pi.hostId === 'pi')
+        return piAdapter;
+    return pi.zod ? ompAdapter : piAdapter;
+}
 export function isPiHost(pi) {
     return !pi.zod;
 }
-export function setExtensionLabel(pi, label) {
-    if (isPiHost(pi))
-        return;
-    pi.setLabel?.(label);
+export function setExtensionLabel(pi, text) {
+    adapterFor(pi).label(pi, text);
 }
 export function onHostEvent(pi, event, handler) {
-    if (event === 'session_branch' && isPiHost(pi))
-        return;
-    pi.on(event, handler);
+    adapterFor(pi).on(pi, event, handler);
 }
-// Returns the option's label on both hosts: pi renders plain strings, so the
-// description rides along inside the label and is stripped back out.
 export async function hostSelect(pi, ui, title, options, dialogOptions) {
-    if (!ui?.select)
-        return undefined;
-    if (!isPiHost(pi))
-        return ui.select(title, options, dialogOptions);
-    const shown = options.map((option) => (option.description ? `${option.label} — ${option.description}` : option.label));
-    const picked = await ui.select(title, shown, dialogOptions);
-    if (picked === undefined)
-        return undefined;
-    return options[shown.indexOf(picked)]?.label ?? picked;
+    return adapterFor(pi).select(ui, title, options, dialogOptions);
 }
-// What a `before_agent_start` handler hands back; undefined once pi was
-// updated in place.
-export function injectPromptText(pi, event, text) {
-    if (!isPiHost(pi))
-        return { systemPrompt: [...asPromptArray(event.systemPrompt), text] };
-    // Appending keeps pi's sections and the transcript diff; replacing the
-    // prompt the OMP way would drop every section.
-    const options = event.systemPromptOptions;
-    if (options && typeof options.appendSystemPrompt === 'string') {
-        options.appendSystemPrompt = [options.appendSystemPrompt, text].filter(Boolean).join('\n\n');
-        return undefined;
-    }
-    return { systemPrompt: `${asPromptArray(event.systemPrompt).join('\n\n')}\n\n${text}` };
+export function injectPromptText(pi, event, text, staleMarker) {
+    return adapterFor(pi).inject(event, text, staleMarker);
 }
-// One string-array argument in the active host's dialect. pi only requires an
-// object, so a JSON Schema literal suffices and no `typebox` import is needed.
 export function stringArrayToolParams(pi, name, spec = {}) {
-    if (!isPiHost(pi)) {
-        const { z } = pi.zod;
-        const array = z.array(z.string());
-        const constrained = spec.minItems ? array.min(spec.minItems) : array;
-        return z.object({ [name]: spec.description ? constrained.describe(spec.description) : constrained });
-    }
-    const array = { type: 'array', items: { type: 'string' } };
-    if (spec.minItems)
-        array.minItems = spec.minItems;
-    if (spec.description)
-        array.description = spec.description;
-    return { type: 'object', properties: { [name]: array }, required: [name] };
+    return adapterFor(pi).stringArray(pi, name, spec);
 }

package/extensions/shared/host.ts

@@ -1,9 +1,8 @@
-// One source for both hosts; OMP differs in six APIs, detected by shape not name.
+// One source for both hosts; each host-specific behaviour lives in one adapter row.
 
 import { asPromptArray } from './session-state.ts';
 import type { ExtensionApi, ExtensionCtx, PromptInjection, SystemPromptEvent, ToolParams, UiApi } from './types.ts';
 
-/** The zod subset the one tool schema needs. */
 export interface ZodChain {
   min: (n: number) => ZodChain;
   describe: (text: string) => ZodChain;
@@ -17,33 +16,121 @@ export interface ZodFactory {
   };
 }
 
-/** The host fields these adapters read. */
 export interface HostHandle {
   zod?: unknown;
   setLabel?: (...args: string[]) => void;
+  hostId?: 'pi' | 'omp' | 'opencode';
+}
+
+export interface SelectOption {
+  label: string;
+  description?: string;
+}
+
+export interface StringArraySpec {
+  minItems?: number;
+  description?: string;
+}
+
+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;
+  stringArray(pi: ExtensionApi, name: string, spec: StringArraySpec): ToolParams;
+}
+
+const piAdapter: HostAdapter = {
+  label() { /* no label surface */ },
+  on(pi, event, handler) {
+    if (event === 'session_branch') return;
+    pi.on(event, handler);
+  },
+  async select(ui, title, options, dialogOptions) {
+    if (!ui?.select) return undefined;
+    const shown = options.map((o) => (o.description ? `${o.label} — ${o.description}` : o.label));
+    const picked = await ui.select(title, shown, dialogOptions);
+    if (picked === undefined) return undefined;
+    return options[shown.indexOf(picked)]?.label ?? picked;
+  },
+  inject(event, text, staleMarker) {
+    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+    const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
+    const options = event.systemPromptOptions;
+    if (options && typeof options.appendSystemPrompt === 'string') {
+      options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(text).filter(Boolean).join('\n\n');
+      return undefined;
+    }
+    return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${text}` };
+  },
+  stringArray(_pi, name, spec) {
+    const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
+    if (spec.minItems) array.minItems = spec.minItems;
+    if (spec.description) array.description = spec.description;
+    return { type: 'object', properties: { [name]: array }, required: [name] };
+  },
+};
+
+const ompAdapter: HostAdapter = {
+  label(pi, text) { pi.setLabel?.(text); },
+  on(pi, event, handler) { pi.on(event, handler); },
+  async select(ui, title, options, dialogOptions) {
+    if (!ui?.select) return undefined;
+    return ui.select(title, options, dialogOptions);
+  },
+  inject(event, text, staleMarker) {
+    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+    const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
+    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+  },
+  stringArray(pi, name, spec) {
+    const { z } = pi.zod as { z: ZodFactory['z'] };
+    const array = z.array(z.string());
+    const constrained = spec.minItems ? array.min(spec.minItems) : array;
+    return z.object({ [name]: spec.description ? constrained.describe(spec.description) : constrained });
+  },
+};
+
+const opencodeAdapter: HostAdapter = {
+  label() { /* no label surface */ },
+  on(pi, event, handler) { pi.on(event, handler); },
+  async select(ui, title, options, dialogOptions) {
+    if (!ui?.select) return undefined;
+    return ui.select(title, options, dialogOptions);
+  },
+  inject(event, text, staleMarker) {
+    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+    const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
+    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+  },
+  stringArray(_pi, name, spec) {
+    const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
+    if (spec.minItems) array.minItems = spec.minItems;
+    if (spec.description) array.description = spec.description;
+    return { type: 'object', properties: { [name]: array }, required: [name] };
+  },
+};
+
+// Explicit hostId wins; the legacy zod sniff keeps old callers working.
+function adapterFor(pi: HostHandle): HostAdapter {
+  if (pi.hostId === 'opencode') return opencodeAdapter;
+  if (pi.hostId === 'omp') return ompAdapter;
+  if (pi.hostId === 'pi') return piAdapter;
+  return pi.zod ? ompAdapter : piAdapter;
 }
 
 export function isPiHost(pi: HostHandle): boolean {
   return !pi.zod;
 }
 
-export function setExtensionLabel(pi: HostHandle, label: string): void {
-  if (isPiHost(pi)) return;
-  pi.setLabel?.(label);
+export function setExtensionLabel(pi: HostHandle, text: string): void {
+  adapterFor(pi).label(pi, text);
 }
 
 export function onHostEvent<E>(pi: ExtensionApi, event: string, handler: (event: E, ctx: ExtensionCtx) => unknown): void {
-  if (event === 'session_branch' && isPiHost(pi)) return;
-  pi.on<E>(event, handler);
+  adapterFor(pi).on<E>(pi, event, handler);
 }
 
-export interface SelectOption {
-  label: string;
-  description?: string;
-}
-
-// Returns the option's label on both hosts: pi renders plain strings, so the
-// description rides along inside the label and is stripped back out.
 export async function hostSelect(
   pi: HostHandle,
   ui: UiApi | undefined,
@@ -51,44 +138,13 @@ export async function hostSelect(
   options: SelectOption[],
   dialogOptions?: Record<string, unknown>,
 ): Promise<string | undefined> {
-  if (!ui?.select) return undefined;
-  if (!isPiHost(pi)) return ui.select(title, options, dialogOptions);
-  const shown = options.map((option) => (option.description ? `${option.label} — ${option.description}` : option.label));
-  const picked = await ui.select(title, shown, dialogOptions);
-  if (picked === undefined) return undefined;
-  return options[shown.indexOf(picked)]?.label ?? picked;
+  return adapterFor(pi).select(ui, title, options, dialogOptions);
 }
 
-// What a `before_agent_start` handler hands back; undefined once pi was
-// updated in place.
-export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, text: string): PromptInjection | undefined {
-  if (!isPiHost(pi)) return { systemPrompt: [...asPromptArray(event.systemPrompt), text] };
-  // Appending keeps pi's sections and the transcript diff; replacing the
-  // prompt the OMP way would drop every section.
-  const options = event.systemPromptOptions;
-  if (options && typeof options.appendSystemPrompt === 'string') {
-    options.appendSystemPrompt = [options.appendSystemPrompt, text].filter(Boolean).join('\n\n');
-    return undefined;
-  }
-  return { systemPrompt: `${asPromptArray(event.systemPrompt).join('\n\n')}\n\n${text}` };
+export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined {
+  return adapterFor(pi).inject(event, text, staleMarker);
 }
 
-export interface StringArraySpec {
-  minItems?: number;
-  description?: string;
-}
-
-// One string-array argument in the active host's dialect. pi only requires an
-// object, so a JSON Schema literal suffices and no `typebox` import is needed.
 export function stringArrayToolParams(pi: ExtensionApi, name: string, spec: StringArraySpec = {}): ToolParams {
-  if (!isPiHost(pi)) {
-    const { z } = pi.zod as { z: ZodFactory['z'] };
-    const array = z.array(z.string());
-    const constrained = spec.minItems ? array.min(spec.minItems) : array;
-    return z.object({ [name]: spec.description ? constrained.describe(spec.description) : constrained });
-  }
-  const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
-  if (spec.minItems) array.minItems = spec.minItems;
-  if (spec.description) array.description = spec.description;
-  return { type: 'object', properties: { [name]: array }, required: [name] };
+  return adapterFor(pi).stringArray(pi, name, spec);
 }

package/extensions/shared/plugin-settings.js

@@ -1,19 +1,17 @@
 // One settings file for every host; parse failure yields {} with per-caller defaults.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
-import { tersioHome } from '../lib/utils.js';
+import { homeDir, tersioHome } from '../lib/utils.js';
 export const PLUGIN_NAME = '@krtclcdy/tersio';
 // The one store both hosts read; this module owns its path.
 export function tersioSettingsFile() {
     return path.join(tersioHome(), 'settings.json');
 }
-// Older installs kept these as OMP plugin settings; still read so switching
-// the store does not reset a user's defaults.
+// Older installs kept these as OMP plugin settings; still read so switching the store does not reset a user's defaults.
 function legacyOmpSettings() {
-    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(homeDir(), '.config');
     for (const p of [
-        path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
+        path.join(homeDir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
         path.join(configHome, 'omp', 'plugins', 'omp-plugins.lock.json'),
     ]) {
         if (!existsSync(p))

package/extensions/shared/plugin-settings.ts

@@ -1,9 +1,8 @@
 // One settings file for every host; parse failure yields {} with per-caller defaults.
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
-import { tersioHome } from '../lib/utils.ts';
+import { homeDir, tersioHome } from '../lib/utils.ts';
 
 export const PLUGIN_NAME = '@krtclcdy/tersio';
 
@@ -12,12 +11,11 @@ export function tersioSettingsFile(): string {
   return path.join(tersioHome(), 'settings.json');
 }
 
-// Older installs kept these as OMP plugin settings; still read so switching
-// the store does not reset a user's defaults.
+// Older installs kept these as OMP plugin settings; still read so switching the store does not reset a user's defaults.
 function legacyOmpSettings(): Record<string, unknown> | null {
-  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(homeDir(), '.config');
   for (const p of [
-    path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
+    path.join(homeDir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
     path.join(configHome, 'omp', 'plugins', 'omp-plugins.lock.json'),
   ]) {
     if (!existsSync(p)) continue;