@krtclcdy/tersio 2.23.0 → 2.24.1

package/extensions/rtk-session/index.js

@@ -1,4 +1,5 @@
-import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.js';
+import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, statusUi, systemPromptIncludes } from '../shared/session-state.js';
+import { injectPromptText, onHostEvent, setExtensionLabel, stringArrayToolParams } from '../shared/host.js';
 import { readRtkDefault } from '../shared/plugin-settings.js';
 const DEFAULT_ENABLED = false;
 function asBoolean(value) {
@@ -21,21 +22,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) {
-    const { z } = pi.zod;
     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 c = lastCtx;
-        if (!c?.ui?.setStatus)
+        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) {
-            c.ui.setStatus('rtk', undefined);
+            ui.setStatus('rtk', undefined);
             return;
         }
-        paintStatusBar(c.ui, 'rtk', '⚡', 'rtk: ON', isActive);
+        paintStatusBar(ui, 'rtk', '⚡', 'rtk: ON', isActive);
     }
     function setEnabled(next, ctx) {
         enabled = Boolean(next);
@@ -45,7 +48,7 @@ export default function rtkSessionExtension(pi) {
         const active = activeModesSummary(getSharedComboState());
         ctx?.ui?.notify?.(enabled ? `RTK on — compact shell output for this session. Active: ${active}.` : `RTK off. Active: ${active}.`, 'info');
     }
-    pi.setLabel?.('RTK session toggle');
+    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.
     function syncFromShared(state) {
@@ -53,7 +56,7 @@ export default function rtkSessionExtension(pi) {
         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) => {
@@ -77,42 +80,33 @@ export default function rtkSessionExtension(pi) {
         name: 'rtk_run',
         label: 'RTK Run',
         description: 'Run the installed `rtk` binary for compact command output when RTK mode is enabled.',
-        parameters: z.object({
-            args: z.array(z.string()).min(1).describe("Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']"),
+        parameters: stringArrayToolParams(pi, 'args', {
+            minItems: 1,
+            description: "Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']",
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
-            if (!enabled) {
+            if (!enabled)
+                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 });
+                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)}`);
+            }
         },
     });
-    pi.on('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.
+        // 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).
@@ -125,7 +119,7 @@ export default function rtkSessionExtension(pi) {
         restoreEnabled(ctx);
         ctx?.ui?.notify?.(`RTK loaded: ${enabled ? 'on' : 'off'}`, 'info');
     });
-    pi.on('session_branch', async (_event, ctx) => {
+    onHostEvent(pi, 'session_branch', async (_event, ctx) => {
         restoreEnabled(ctx);
     });
     pi.on('session_tree', async (_event, ctx) => {
@@ -143,7 +137,9 @@ export default function rtkSessionExtension(pi) {
         const active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === 'on' : enabled;
         if (!active)
             return;
-        const base = asPromptArray(event.systemPrompt);
-        return { systemPrompt: [...base, RTK_PROMPT] };
+        // 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,6 +1,7 @@
-import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.ts';
+import { activeModesSummary, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, statusUi, 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 type { ExtensionApi, ExtensionCtx, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
 
 const DEFAULT_ENABLED = false;
 
@@ -22,27 +23,25 @@ function setRtkProcessEnabled(enabled: boolean): void {
 
 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.`;
 
-interface ZodChain {
-  min: (n: number) => ZodChain;
-  describe: (text: string) => ZodChain;
-}
-
 export default function rtkSessionExtension(pi: ExtensionApi): void {
-  const { z } = pi.zod as { z: { object: (shape: Record<string, unknown>) => Record<string, unknown>; array: (el: unknown) => ZodChain; string: () => ZodChain } };
   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 c = lastCtx;
-    if (!c?.ui?.setStatus) return;
+    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) {
-      c.ui.setStatus('rtk', undefined);
+      ui.setStatus('rtk', undefined);
       return;
     }
-    paintStatusBar(c.ui, 'rtk', '⚡', 'rtk: ON', isActive);
+    paintStatusBar(ui, 'rtk', '⚡', 'rtk: ON', isActive);
   }
 
   function setEnabled(next: unknown, ctx?: ExtensionCtx): void {
@@ -54,7 +53,7 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     ctx?.ui?.notify?.(enabled ? `RTK on — compact shell output for this session. Active: ${active}.` : `RTK off. Active: ${active}.`, 'info');
   }
 
-  pi.setLabel?.('RTK session toggle');
+  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.
@@ -63,7 +62,7 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     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,40 +87,31 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     name: 'rtk_run',
     label: 'RTK Run',
     description: 'Run the installed `rtk` binary for compact command output when RTK mode is enabled.',
-    parameters: z.object({
-      args: z.array(z.string()).min(1).describe("Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']"),
+    parameters: stringArrayToolParams(pi, 'args', {
+      minItems: 1,
+      description: "Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']",
     }),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      if (!enabled) {
+      if (!enabled) 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 });
+        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 },
-      };
     },
   });
 
-  pi.on<InputEvent>('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.
+    // 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).
@@ -136,7 +126,7 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     ctx?.ui?.notify?.(`RTK loaded: ${enabled ? 'on' : 'off'}`, 'info');
   });
 
-  pi.on('session_branch', async (_event, ctx) => {
+  onHostEvent(pi, 'session_branch', async (_event, ctx) => {
     restoreEnabled(ctx);
   });
 
@@ -157,7 +147,8 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
   pi.on<SystemPromptEvent>('before_agent_start', async (event) => {
     const active = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().rtk === 'on' : enabled;
     if (!active) return;
-    const base = asPromptArray(event.systemPrompt);
-    return { systemPrompt: [...base, RTK_PROMPT] };
+    // 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,14 +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), following the same served-estimate approach
-// as honey-for-devs' hooks/eco.js: the faithful single-stream (batch-1)
-// ceiling divided by serving_concurrency for continuous-batching amortization.
-//
-// Model params come from EcoLogits' registry where it covers the model;
-// otherwise a documented class borrow (never a silent guess — every borrow
-// carries its source). Unknown ids fall to the gpt-4o default. Everything
-// rendered from here must carry ~est. and never merge 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;
@@ -31,6 +21,8 @@ const GRIDS = {
 };
 // 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';
 // Registry values verbatim from EcoLogits' model_repository; borrows cite
 // the public param disclosure they stand in for (MoE active/total).
 const TABLE = [

package/extensions/shared/carbon.ts

@@ -1,14 +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), following the same served-estimate approach
-// as honey-for-devs' hooks/eco.js: the faithful single-stream (batch-1)
-// ceiling divided by serving_concurrency for continuous-batching amortization.
-//
-// Model params come from EcoLogits' registry where it covers the model;
-// otherwise a documented class borrow (never a silent guess — every borrow
-// carries its source). Unknown ids fall to the gpt-4o default. Everything
-// rendered from here must carry ~est. and never merge with measured figures.
+// EcoLogits v0.8.2 port; always render as ~est, never merged with measured.
 
 export interface ModelCarbon {
   activeB: number;
@@ -42,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;

package/extensions/shared/host.js

@@ -0,0 +1,58 @@
+// One source for both hosts; OMP differs in six APIs, detected by shape not name.
+import { asPromptArray } from './session-state.js';
+export function isPiHost(pi) {
+    return !pi.zod;
+}
+export function setExtensionLabel(pi, label) {
+    if (isPiHost(pi))
+        return;
+    pi.setLabel?.(label);
+}
+export function onHostEvent(pi, event, handler) {
+    if (event === 'session_branch' && isPiHost(pi))
+        return;
+    pi.on(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;
+}
+// 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}` };
+}
+// 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] };
+}

package/extensions/shared/host.ts

@@ -0,0 +1,94 @@
+// One source for both hosts; OMP differs in six APIs, detected by shape not name.
+
+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;
+}
+
+export interface ZodFactory {
+  z: {
+    object: (shape: Record<string, unknown>) => ToolParams;
+    array: (element: unknown) => ZodChain;
+    string: () => ZodChain;
+  };
+}
+
+/** The host fields these adapters read. */
+export interface HostHandle {
+  zod?: unknown;
+  setLabel?: (...args: string[]) => void;
+}
+
+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 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);
+}
+
+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,
+  title: string,
+  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;
+}
+
+// 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 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] };
+}

package/extensions/shared/omp-prompt.js

@@ -0,0 +1,12 @@
+// extensions/omp/omp-prompt.ts — OMP's system-prompt surface.
+// The subagent marker OMP puts in a delegated agent's prompt.
+export const OMP_SUBAGENT_MARKER = 'You are operating on a piece of work assigned to you by the main agent.';
+export function asPromptArray(systemPrompt) {
+    return Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+}
+export function systemPromptIncludes(systemPrompt, marker) {
+    return asPromptArray(systemPrompt).some((prompt) => typeof prompt === 'string' && prompt.includes(marker));
+}
+export function isOmpSubagentPrompt(systemPrompt) {
+    return systemPromptIncludes(systemPrompt, OMP_SUBAGENT_MARKER);
+}

package/extensions/shared/plugin-settings.js

@@ -1,22 +1,21 @@
-// Plugin settings reader for the Tersio extensions.
-// Reads omp's persisted plugin state (~/.omp/plugins/omp-plugins.lock.json),
-// written by `omp plugin config set @krtclcdy/tersio <key> <value>` and by
-// the installer profile step. Tolerant: any parse failure yields {} so every
-// caller falls back to its own default.
+// 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';
 export const PLUGIN_NAME = '@krtclcdy/tersio';
-function lockPaths() {
+// 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.
+function legacyOmpSettings() {
     const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-    return [
+    for (const p of [
         path.join(os.homedir(), '.omp', 'plugins', 'omp-plugins.lock.json'),
         path.join(configHome, 'omp', 'plugins', 'omp-plugins.lock.json'),
-    ];
-}
-// `settings[PLUGIN_NAME]` in the lock file; empty object when missing.
-export function readPluginSettings() {
-    for (const p of lockPaths()) {
+    ]) {
         if (!existsSync(p))
             continue;
         try {
@@ -27,7 +26,23 @@ export function readPluginSettings() {
         }
         catch { /* tolerate corrupt file */ }
     }
-    return {};
+    return null;
+}
+function readSettingsFile() {
+    const p = tersioSettingsFile();
+    if (!existsSync(p))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(p, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+// The stored settings; empty when the file is missing, corrupt, or empty.
+export function readPluginSettings() {
+    return readSettingsFile() ?? legacyOmpSettings() ?? {};
 }
 const COMBO_LEVELS = new Set(['off', 'medium', 'balanced', 'max']);
 const CAVEMAN_MODES = new Set(['off', 'lite', 'full', 'ultra', 'wenyan', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']);
@@ -61,25 +76,13 @@ const COMBO_MODE_DEFAULTS = {
 export function saveComboSetup(level) {
     if (!(level in COMBO_MODE_DEFAULTS))
         return false;
-    const lockPath = lockPaths()[0];
-    let lock = {};
-    if (existsSync(lockPath)) {
-        try {
-            lock = JSON.parse(readFileSync(lockPath, 'utf8'));
-        }
-        catch {
-            lock = {};
-        }
-    }
-    lock.plugins ||= {};
-    lock.settings ||= {};
-    lock.settings[PLUGIN_NAME] = {
-        ...lock.settings[PLUGIN_NAME],
+    const file = tersioSettingsFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify({
+        ...readPluginSettings(),
         comboDefault: level,
         ...COMBO_MODE_DEFAULTS[level],
         comboSetupComplete: true,
-    };
-    mkdirSync(path.dirname(lockPath), { recursive: true });
-    writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n', 'utf8');
+    }, null, 2)}\n`, 'utf8');
     return true;
 }