@krtclcdy/tersio 2.24.1 → 2.25.1

package/extensions/lib/utils.ts

@@ -1,5 +1,4 @@
-// Shared helpers for the installer and the AI add-ons updater. Node built-ins
-// only — this module must stay dependency-free.
+// Shared helpers for the installer and the AI add-ons updater. Node built-ins only — this module must stay dependency-free.
 
 import { createHash } from 'node:crypto';
 import { accessSync, constants, createWriteStream, existsSync, mkdirSync, renameSync, statSync } from 'node:fs';
@@ -21,6 +20,12 @@ export function withResolvers<T>(): PromiseWithResolvers<T> {
   return { promise, resolve, reject };
 }
 
+// os.homedir() can ignore a runtime HOME, so a redirected home would read the real one.
+export function homeDir(): string {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  return home && home.trim() !== '' ? home : os.homedir();
+}
+
 export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
 export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/caveman/SKILL.md';
 
@@ -47,10 +52,13 @@ const RTK_PLATFORM_SPECS: Record<string, RtkPlatformSpec> = {
   'darwin/x64': { triple: 'x86_64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
   'darwin/arm64': { triple: 'aarch64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
 };
-export function resolveRtkBinary(managedDir = path.join(os.homedir(), '.bun', 'bin')): string | null {
-  const name = process.platform === 'win32' ? 'rtk.exe' : 'rtk';
-  const candidates = (process.env.PATH || '').split(path.delimiter).filter(Boolean).map((dir) => path.join(dir, name));
-  if (managedDir) candidates.push(path.join(managedDir, name));
+
+// First executable `name` on PATH, else the managed Bun bin dir.
+function firstExecutable(name: string, managedDir: string | null): string | null {
+  const ext = process.platform === 'win32' ? '.cmd' : '';
+  const candidates = (process.env.PATH || '').split(path.delimiter).filter(Boolean)
+    .flatMap((dir) => [path.join(dir, name + ext), path.join(dir, name)]);
+  if (managedDir) candidates.push(path.join(managedDir, name + ext), path.join(managedDir, name));
   for (const candidate of candidates) {
     try {
       if (!statSync(candidate).isFile()) continue;
@@ -61,6 +69,15 @@ export function resolveRtkBinary(managedDir = path.join(os.homedir(), '.bun', 'b
   return null;
 }
 
+export function resolveRtkBinary(managedDir = path.join(homeDir(), '.bun', 'bin')): string | null {
+  return firstExecutable(process.platform === 'win32' ? 'rtk.exe' : 'rtk', managedDir);
+}
+
+// A host binary to scan for its subagent marker.
+export function resolveHostBinary(name: string, managedDir = path.join(homeDir(), '.bun', 'bin')): string | null {
+  return firstExecutable(name, managedDir);
+}
+
 export function rtkPlatformSpec(platform: string = process.platform, arch: string = process.arch): RtkPlatformSpec | null {
   return RTK_PLATFORM_SPECS[`${platform}/${arch}`] || null;
 }
@@ -73,24 +90,25 @@ function redirectNext(res: { statusCode?: number; headers: { location?: string }
   return null;
 }
 
-// pi sets PI_CODING_AGENT; OMP does not. OMP does read PI_CODING_AGENT_DIR as
-// its own relocation variable, so the override only counts under that marker.
+// pi sets PI_CODING_AGENT; OMP does not. OMP does read PI_CODING_AGENT_DIR as its own relocation variable, so the override only counts under that marker.
 export function isPiProcess(): boolean {
   return process.env.PI_CODING_AGENT === 'true';
 }
 
 export function piAgentDir(): string {
   const override = process.env.PI_CODING_AGENT_DIR;
-  return isPiProcess() && override ? override : path.join(os.homedir(), '.pi', 'agent');
+  return isPiProcess() && override ? override : path.join(homeDir(), '.pi', 'agent');
 }
 
-// Ponytail is a Tersio dependency that npm hoists, so it can sit in Tersio's
-// node_modules, a host's plugin dir, or beside it. Walking up covers all.
+// Ponytail is a Tersio dependency that npm hoists, so it can sit in Tersio's node_modules, a host's plugin dir, or beside it. Walking up covers all.
 export function findHoistedPackage(pkg: string, fromDir: string, ...relInside: string[]): string | null {
   let dir = fromDir;
   for (;;) {
     const candidate = path.join(dir, 'node_modules', ...pkg.split('/'), ...relInside);
     if (existsSync(candidate)) return candidate;
+    // pi installs npm packages under ~/.pi/agent/npm/node_modules.
+    const piCandidate = path.join(dir, 'npm', 'node_modules', ...pkg.split('/'), ...relInside);
+    if (existsSync(piCandidate)) return piCandidate;
     const parent = path.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -200,15 +218,41 @@ export async function readTextIfExists(p: string): Promise<string | null> {
   try { return await fs.readFile(p, 'utf8'); } catch { return null; }
 }
 
-// Tersio-owned data home: ~/.tersio. First use moves legacy
-// ~/.omp/plugins/tersio-* files over so existing installs keep their history.
+// Chunked so a 200 MiB host binary is never held in memory. `tail` keeps the last needle.length-1 bytes of the previous chunk, because a match can begin near the end of one chunk and finish inside the next.
+export async function fileContains(filePath: string, needleText: string): Promise<boolean> {
+  const needle = Buffer.from(needleText, 'utf8');
+  if (needle.length === 0) return false;
+  const keep = needle.length - 1;
+  let handle;
+  try {
+    handle = await fs.open(filePath, 'r');
+    const { size } = await handle.stat();
+    const chunk = Buffer.allocUnsafe(1 << 20);
+    let tail = Buffer.alloc(0);
+    for (let position = 0; position < size;) {
+      const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
+      if (bytesRead === 0) break;
+      const window = Buffer.concat([tail, chunk.subarray(0, bytesRead)]);
+      if (window.includes(needle)) return true;
+      tail = window.subarray(Math.max(0, window.length - keep));
+      position += bytesRead;
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    await handle?.close().catch(() => { });
+  }
+}
+
+// Tersio-owned data home: ~/.tersio. First use moves legacy ~/.omp/plugins/tersio-* files over so existing installs keep their history.
 const migratedTersioFiles = new Set<string>();
 
 export function tersioHome(): string {
   // Matches the other TERSIO_* overrides so a test never reads the real home.
   const override = process.env.TERSIO_HOME;
   if (override && override.trim() !== '') return override;
-  return path.join(os.homedir(), '.tersio');
+  return path.join(homeDir(), '.tersio');
 }
 
 
@@ -218,7 +262,7 @@ export function tersioDataPath(name: string, legacy: string): string {
     migratedTersioFiles.add(name);
     try {
       if (!existsSync(dest)) {
-        const src = path.join(os.homedir(), '.omp', 'plugins', legacy);
+        const src = path.join(homeDir(), '.omp', 'plugins', legacy);
         if (existsSync(src)) {
           mkdirSync(tersioHome(), { recursive: true });
           renameSync(src, dest);

package/extensions/opencode/index.js

@@ -0,0 +1,104 @@
+// OpenCode plugin entry: maps its plugin API onto the shared ExtensionApi the mode extensions consume.
+import { execFile } from 'node:child_process';
+import { Plugin } from '@opencode/plugin';
+import cavemanSessionExtension from '../caveman-session/index.js';
+import rtkSessionExtension from '../rtk-session/index.js';
+import comboToggleExtension from '../combo-toggle/index.js';
+import tersioCommandsExtension from '../tersio-commands/index.js';
+export default Plugin.define({
+    id: 'tersio',
+    async setup(ctx) {
+        const entries = (await ctx.storage.get('entries')) ?? [];
+        const persist = () => { void ctx.storage.set('entries', entries).catch(() => { }); };
+        const stubCtx = () => ({
+            hasUI: false,
+            cwd: ctx.location.directory,
+            sessionManager: { getBranch: () => entries, getEntries: () => entries },
+        });
+        const commands = new Map();
+        const tools = new Map();
+        const beforeStart = [];
+        const inputHandlers = [];
+        const lifecycle = new Map();
+        const host = {
+            hostId: 'opencode',
+            setLabel() { },
+            registerCommand(name, config) { commands.set(name, config); },
+            registerTool(tool) { tools.set(tool.name, tool); },
+            appendEntry(type, data) { entries.push({ type: 'custom', customType: type, data }); persist(); },
+            exec: (cmd, args, opts) => new Promise((resolve) => {
+                execFile(cmd, args, { signal: opts?.signal, cwd: opts?.cwd }, (error, stdout, stderr) => {
+                    const code = error && typeof error.code === 'number' ? error.code : 0;
+                    resolve({ stdout: stdout ?? '', stderr: stderr ?? '', code, killed: !!error?.killed });
+                });
+            }),
+            cwd: ctx.location.directory,
+            on: (event, handler) => {
+                if (event === 'before_agent_start') {
+                    beforeStart.push(handler);
+                    return;
+                }
+                if (event === 'input') {
+                    inputHandlers.push(handler);
+                    return;
+                }
+                const list = lifecycle.get(event) ?? [];
+                list.push(handler);
+                lifecycle.set(event, list);
+            },
+        };
+        for (const extension of [cavemanSessionExtension, rtkSessionExtension, comboToggleExtension, tersioCommandsExtension])
+            extension(host);
+        // OpenCode has no session_start event surfaced to plugins, so restore once at setup.
+        for (const handler of lifecycle.get('session_start') ?? [])
+            await handler({}, stubCtx());
+        await ctx.command.transform((editor) => {
+            for (const [name, config] of commands) {
+                editor.add({
+                    name,
+                    description: config.description,
+                    execute: async (input) => {
+                        const text = typeof input.prompt?.text === 'string' ? input.prompt.text : '';
+                        const args = text.includes(' ') ? text.slice(text.indexOf(' ') + 1).trim() : '';
+                        await config.handler(args, stubCtx());
+                    },
+                });
+            }
+        });
+        await ctx.tool.transform((editor) => {
+            for (const tool of tools.values()) {
+                editor.add({
+                    name: tool.name,
+                    description: tool.description,
+                    input: tool.parameters,
+                    execute: async (input) => {
+                        const args = Array.isArray(input.args) ? (input.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 systemParts = event.system.map((part) => (part.type === 'text' ? part.text : '')).filter(Boolean);
+            for (const handler of beforeStart) {
+                const result = await handler({ systemPrompt: [...systemParts] }, stubCtx());
+                if (!result || typeof result !== 'object' || !('systemPrompt' in result))
+                    continue;
+                const parts = typeof result.systemPrompt === 'string'
+                    ? [result.systemPrompt]
+                    : Array.isArray(result.systemPrompt)
+                        ? result.systemPrompt
+                        : [];
+                for (const part of parts) {
+                    if (!systemParts.includes(part))
+                        event.system.push({ type: 'text', text: part });
+                }
+            }
+        });
+        await ctx.session.hook('prompt', (event) => {
+            for (const handler of inputHandlers)
+                void handler({ text: event.prompt.text, source: 'interactive' });
+        });
+    },
+});

package/extensions/opencode/server.js

@@ -0,0 +1,190 @@
+// OpenCode plugin entry: maps its plugin API onto the shared ExtensionApi the mode extensions consume.
+import { execFile } from 'node:child_process';
+import cavemanSessionExtension from '../caveman-session/index.js';
+import rtkSessionExtension from '../rtk-session/index.js';
+import comboToggleExtension from '../combo-toggle/index.js';
+import tersioCommandsExtension from '../tersio-commands/index.js';
+import { getSharedComboState } from '../shared/session-state.js';
+import { formatStatus } from '../shared/status.js';
+// 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 = {
+    id: 'tersio',
+    async setup(ctx) {
+        // Entries are scoped per session; an unseen ID restores on its first hook.
+        const sessions = new Map();
+        const started = new Map();
+        let activeSid;
+        const loadEntries = async (sid) => {
+            const own = (await ctx.storage.get(`entries:${sid}`)) ?? [];
+            if (own.length)
+                return own;
+            // Pre-scoped installs kept one global list; adopt it once, then diverge.
+            const legacy = (await ctx.storage.get('entries')) ?? [];
+            return [...legacy];
+        };
+        const sessionEntriesOf = (sid) => {
+            let list = sessions.get(sid);
+            if (!list) {
+                list = [];
+                sessions.set(sid, list);
+            }
+            return list;
+        };
+        const persist = (sid) => {
+            void ctx.storage.set(`entries:${sid}`, sessionEntriesOf(sid)).catch(() => { });
+        };
+        const stubCtx = (sid) => ({
+            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) => {
+            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) => {
+            runSessionStart(sid);
+            return started.get(sid) ?? Promise.resolve();
+        };
+        const commands = new Map();
+        const tools = new Map();
+        const beforeStart = [];
+        const inputHandlers = [];
+        const lifecycle = new Map();
+        const host = {
+            hostId: 'opencode',
+            setLabel() { },
+            registerCommand(name, config) { commands.set(name, config); },
+            registerTool(tool) { tools.set(tool.name, tool); },
+            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.code === 'number' ? error.code : 0;
+                    resolve({ stdout: stdout ?? '', stderr: stderr ?? '', code, killed: !!error?.killed });
+                });
+            }),
+            cwd: ctx.location.directory,
+            on: (event, handler) => {
+                if (event === 'before_agent_start') {
+                    beforeStart.push(handler);
+                    return;
+                }
+                if (event === 'input') {
+                    inputHandlers.push(handler);
+                    return;
+                }
+                const list = lifecycle.get(event) ?? [];
+                list.push(handler);
+                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) => 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.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 = [];
+                        const cmdCtx = {
+                            ...stubCtx(sid),
+                            hasUI: true,
+                            ui: { notify: (message) => { 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,
+                    execute: async (input) => {
+                        const args = Array.isArray(input.args) ? (input.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.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] }, stubCtx(sid));
+                if (!result || typeof result !== 'object' || !('systemPrompt' in result))
+                    continue;
+                const parts = typeof result.systemPrompt === 'string'
+                    ? [result.systemPrompt]
+                    : Array.isArray(result.systemPrompt)
+                        ? result.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.sessionID);
+            if (sid)
+                await ensureSession(sid);
+            for (const handler of inputHandlers)
+                void handler({ text: event.prompt.text, source: 'interactive' });
+        });
+    },
+};
+export default plugin;

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;