@kisev/agentomatic 11.0.0-dev.76.ge1ca4a43f0f3 → 11.0.0-dev.77.g09da04664b2e

package/README.md

@@ -61,7 +61,7 @@ migration guide](../../docs/how-to/memomatic.md).
 ## Requirements
 
 - Node.js 22 or later.
-- OpenCode `>=1.18.29 <1.19.0`.
+- OpenCode `>=1.18.0 <1.19.0 || >=2.0.0 <2.1.0`.
 - A persistent npm project that owns the dependency.
 
 ## Project Install

package/README.ru.md

@@ -63,7 +63,7 @@ Agentomatic не зависит от memomatic. См. [настройку MCP и
 ## Требования
 
 - Node.js 22 или новее.
-- OpenCode `>=1.18.29 <1.19.0`.
+- OpenCode `>=1.18.0 <1.19.0 || >=2.0.0 <2.1.0`.
 - Постоянный npm-проект, которому принадлежит зависимость.
 
 ## Установка в проект

package/dist/assets/plugins/rtk.js

@@ -1,3 +1,3 @@
 import plugin from "@kisev/agentomatic/plugins/rtk";
 
-export default (input) => plugin(input);
+export default plugin;

package/dist/assets/plugins/rules-injector.js

@@ -1,3 +1,3 @@
 import plugin from "@kisev/agentomatic/plugins/rules-injector";
 
-export default (input) => plugin(input);
+export default plugin;

package/dist/assets/plugins/zed-bell.js

@@ -1,3 +1,3 @@
 import plugin from "@kisev/agentomatic/plugins/zed-bell";
 
-export default (input) => plugin(input, { enabled: false });
+export default plugin;

package/dist/config-setup.js

@@ -171,16 +171,17 @@ function fragmentEdits(fragment, target, current) {
         ? value.permission
         : {};
     if (fragment === "core-plugin") {
+        const key = "plugins" in value ? "plugins" : "plugin";
         return [
             { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/config.json" },
-            { kind: "set-if-absent", path: ["plugin"], value: [] },
+            { kind: "set-if-absent", path: [key], value: [] },
             {
                 kind: "replace-array-value",
-                path: ["plugin"],
+                path: [key],
                 from: LEGACY_PACKAGE_NAME,
                 to: PACKAGE_NAME,
             },
-            { kind: "append-unique", path: ["plugin"], value: PACKAGE_NAME },
+            { kind: "append-unique", path: [key], value: PACKAGE_NAME },
         ];
     }
     if (fragment === "skills-state-permissions") {

package/dist/doctor.js

@@ -114,12 +114,15 @@ function agentManifestValid(raw) {
 }
 function redactedConfig(value) {
     const object = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    const rawPlugins = Array.isArray(object.plugin)
-        ? object.plugin.flatMap((item) => {
+    const configuredPlugins = object.plugins ?? object.plugin;
+    const rawPlugins = Array.isArray(configuredPlugins)
+        ? configuredPlugins.flatMap((item) => {
             if (typeof item === "string")
                 return [item];
             if (Array.isArray(item) && typeof item[0] === "string")
                 return [item[0]];
+            if (item && typeof item === "object" && typeof item.package === "string")
+                return [item.package];
             return [];
         })
         : [];
@@ -141,6 +144,7 @@ function redactedConfig(value) {
             "command",
             "watcher",
             "plugin",
+            "plugins",
             "lsp",
             "formatter",
             "provider",

package/dist/index.d.ts

@@ -1,109 +1,68 @@
-import { type PluginInput } from "@opencode-ai/plugin";
-import rulesInjector, { type RulesInjectorOptions } from "./plugins/rules-injector.js";
-import rtk, { type RtkOptions } from "./plugins/rtk.js";
-import zedBell, { type ZedBellOptions } from "./plugins/zed-bell.js";
+import type { Plugin as V2Plugin } from "@opencode/plugin";
+import { z } from "zod";
+import { type Category, type RoutingInput } from "./routing.js";
+import { rulesInjector, type RulesInjectorOptions } from "./plugins/rules-injector.js";
+import { rtk, type RtkOptions } from "./plugins/rtk.js";
+import { zedBell, type ZedBellOptions } from "./plugins/zed-bell.js";
 export { rulesInjector, rtk, zedBell };
 export type OpenCodeOptions = {
     rulesInjector?: RulesInjectorOptions;
     rtk?: RtkOptions;
     zedBell?: ZedBellOptions;
 };
-declare const plugin: (input: PluginInput) => Promise<{
-    tool: {
-        route: {
-            description: string;
-            args: {
-                action: import("zod").ZodEnum<{
-                    dispatch: "dispatch";
-                    preview: "preview";
-                }>;
-                category: import("zod").ZodEnum<{
-                    architecture: "architecture";
-                    exploration: "exploration";
-                    implementation: "implementation";
-                    review: "review";
-                }>;
-                task: import("zod").ZodString;
-                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                execution_card: import("zod").ZodOptional<import("zod").ZodAny>;
-                override: import("zod").ZodOptional<import("zod").ZodString>;
-                trusted_override: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                budget: import("zod").ZodOptional<import("zod").ZodObject<{
-                    cost_class: import("zod").ZodOptional<import("zod").ZodString>;
-                    latency_class: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-                decision: import("zod").ZodOptional<import("zod").ZodAny>;
-            };
-            execute(args: {
-                action: "dispatch" | "preview";
-                category: "architecture" | "exploration" | "implementation" | "review";
-                task: string;
-                requirements: string[];
-                execution_card?: any;
-                override?: string | undefined;
-                trusted_override?: boolean | undefined;
-                budget?: {
-                    cost_class?: string | undefined;
-                    latency_class?: string | undefined;
-                } | undefined;
-                decision?: any;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+type RuntimeInput = {
+    directory: string;
+    client?: {
+        app?: {
+            agents?: (input: {
+                query: {
+                    directory: string;
+                };
+            }) => Promise<{
+                data?: unknown;
+            }>;
         };
     };
-    "tool.execute.before": (input: {
-        tool: string;
-        sessionID: string;
-    }, output: {
-        args: unknown;
-    }) => Promise<void>;
-    "tool.execute.after": (input: {
-        tool: string;
-        sessionID: string;
-        args: unknown;
-    }, output: {
-        output: string;
-    }) => Promise<void>;
-}>;
-export declare const server: (input: PluginInput) => Promise<{
+};
+export declare const server: (input: RuntimeInput) => Promise<{
     tool: {
         route: {
             description: string;
             args: {
-                action: import("zod").ZodEnum<{
+                action: z.ZodEnum<{
                     dispatch: "dispatch";
                     preview: "preview";
                 }>;
-                category: import("zod").ZodEnum<{
+                category: z.ZodEnum<{
                     architecture: "architecture";
                     exploration: "exploration";
                     implementation: "implementation";
                     review: "review";
                 }>;
-                task: import("zod").ZodString;
-                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
-                execution_card: import("zod").ZodOptional<import("zod").ZodAny>;
-                override: import("zod").ZodOptional<import("zod").ZodString>;
-                trusted_override: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                budget: import("zod").ZodOptional<import("zod").ZodObject<{
-                    cost_class: import("zod").ZodOptional<import("zod").ZodString>;
-                    latency_class: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-                decision: import("zod").ZodOptional<import("zod").ZodAny>;
+                task: z.ZodString;
+                requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                execution_card: z.ZodOptional<z.ZodAny>;
+                override: z.ZodOptional<z.ZodString>;
+                trusted_override: z.ZodOptional<z.ZodBoolean>;
+                budget: z.ZodOptional<z.ZodObject<{
+                    cost_class: z.ZodOptional<z.ZodString>;
+                    latency_class: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                decision: z.ZodOptional<z.ZodAny>;
             };
             execute(args: {
-                action: "dispatch" | "preview";
-                category: "architecture" | "exploration" | "implementation" | "review";
+                action: "preview" | "dispatch";
+                category: Category;
                 task: string;
                 requirements: string[];
-                execution_card?: any;
-                override?: string | undefined;
-                trusted_override?: boolean | undefined;
-                budget?: {
-                    cost_class?: string | undefined;
-                    latency_class?: string | undefined;
-                } | undefined;
-                decision?: any;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+                execution_card?: unknown;
+                override?: string;
+                trusted_override?: boolean;
+                budget?: RoutingInput["budget"];
+                decision?: unknown;
+            }, context: {
+                sessionID: string;
+            }): Promise<string>;
         };
     };
     "tool.execute.before": (input: {
@@ -120,4 +79,63 @@ export declare const server: (input: PluginInput) => Promise<{
         output: string;
     }) => Promise<void>;
 }>;
-export default plugin;
+declare const _default: {
+    id: string;
+    server: (input: RuntimeInput) => Promise<{
+        tool: {
+            route: {
+                description: string;
+                args: {
+                    action: z.ZodEnum<{
+                        dispatch: "dispatch";
+                        preview: "preview";
+                    }>;
+                    category: z.ZodEnum<{
+                        architecture: "architecture";
+                        exploration: "exploration";
+                        implementation: "implementation";
+                        review: "review";
+                    }>;
+                    task: z.ZodString;
+                    requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    execution_card: z.ZodOptional<z.ZodAny>;
+                    override: z.ZodOptional<z.ZodString>;
+                    trusted_override: z.ZodOptional<z.ZodBoolean>;
+                    budget: z.ZodOptional<z.ZodObject<{
+                        cost_class: z.ZodOptional<z.ZodString>;
+                        latency_class: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    decision: z.ZodOptional<z.ZodAny>;
+                };
+                execute(args: {
+                    action: "preview" | "dispatch";
+                    category: Category;
+                    task: string;
+                    requirements: string[];
+                    execution_card?: unknown;
+                    override?: string;
+                    trusted_override?: boolean;
+                    budget?: RoutingInput["budget"];
+                    decision?: unknown;
+                }, context: {
+                    sessionID: string;
+                }): Promise<string>;
+            };
+        };
+        "tool.execute.before": (input: {
+            tool: string;
+            sessionID: string;
+        }, output: {
+            args: unknown;
+        }) => Promise<void>;
+        "tool.execute.after": (input: {
+            tool: string;
+            sessionID: string;
+            args: unknown;
+        }, output: {
+            output: string;
+        }) => Promise<void>;
+    }>;
+    setup(ctx: V2Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/dist/index.js

@@ -1,8 +1,9 @@
-import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { registerV2Hooks } from "./plugins/compatibility.js";
 import { CATEGORIES, RoutingGate, } from "./routing.js";
-import rulesInjector from "./plugins/rules-injector.js";
-import rtk from "./plugins/rtk.js";
-import zedBell from "./plugins/zed-bell.js";
+import { rulesInjector } from "./plugins/rules-injector.js";
+import { rtk } from "./plugins/rtk.js";
+import { zedBell } from "./plugins/zed-bell.js";
 import { digest } from "./lifecycle.js";
 export { rulesInjector, rtk, zedBell };
 const plugin = (async (input) => {
@@ -44,23 +45,23 @@ const plugin = (async (input) => {
         });
         return { agents, revision: digest(raw) };
     };
-    const route = tool({
+    const route = {
         description: "Resolve a capability category and dispatch one eligible agent through a one-use Task receipt gate.",
         args: {
-            action: tool.schema.enum(["preview", "dispatch"]),
-            category: tool.schema.enum(CATEGORIES),
-            task: tool.schema.string(),
-            requirements: tool.schema.array(tool.schema.string()).default([]),
-            execution_card: tool.schema.any().optional(),
-            override: tool.schema.string().optional(),
-            trusted_override: tool.schema.boolean().optional(),
-            budget: tool.schema
+            action: z.enum(["preview", "dispatch"]),
+            category: z.enum(CATEGORIES),
+            task: z.string(),
+            requirements: z.array(z.string()).default([]),
+            execution_card: z.any().optional(),
+            override: z.string().optional(),
+            trusted_override: z.boolean().optional(),
+            budget: z
                 .object({
-                cost_class: tool.schema.string().optional(),
-                latency_class: tool.schema.string().optional(),
+                cost_class: z.string().optional(),
+                latency_class: z.string().optional(),
             })
                 .optional(),
-            decision: tool.schema.any().optional(),
+            decision: z.any().optional(),
         },
         async execute(args, context) {
             const inventory = await hostInventory();
@@ -87,7 +88,7 @@ const plugin = (async (input) => {
             });
             return JSON.stringify({ decision, receipt, status: "routed" });
         },
-    });
+    };
     return {
         tool: { route },
         "tool.execute.before": async (input, output) => {
@@ -137,4 +138,54 @@ const plugin = (async (input) => {
     };
 });
 export const server = plugin;
-export default plugin;
+export default {
+    id: "agentomatic",
+    server,
+    async setup(ctx) {
+        const hooks = await plugin({
+            directory: ctx.location.directory,
+            client: {
+                app: {
+                    agents: async () => {
+                        const { data: agents } = await ctx.agent.list({
+                            location: { directory: ctx.location.directory },
+                        });
+                        return {
+                            data: agents.map((agent) => ({
+                                name: agent.id,
+                                tools: Object.fromEntries(["read", "glob", "grep", "edit", "bash"].map((tool) => [
+                                    tool,
+                                    [...agent.permissions]
+                                        .reverse()
+                                        .find((rule) => (rule.action === (tool === "bash" ? "shell" : tool) ||
+                                        rule.action === "*") &&
+                                        rule.resource === "*")?.effect !== "deny",
+                                ])),
+                                permission: {
+                                    edit: agent.permissions.some((rule) => rule.action === "edit" && rule.resource === "*" && rule.effect === "deny")
+                                        ? "deny"
+                                        : "allow",
+                                    bash: Object.fromEntries(agent.permissions
+                                        .filter((rule) => rule.action === "shell")
+                                        .map((rule) => [rule.resource, rule.effect])),
+                                },
+                            })),
+                        };
+                    },
+                },
+            },
+        });
+        await ctx.tool.transform((editor) => {
+            const route = hooks.tool.route;
+            editor.add({
+                name: "route",
+                description: route.description,
+                input: z.object(route.args),
+                async execute(args, context) {
+                    return { content: await route.execute(args, context) };
+                },
+            });
+        });
+        return registerV2Hooks(ctx, hooks);
+    },
+};

package/dist/plugins/compatibility.d.ts

@@ -0,0 +1,30 @@
+import type { Plugin } from "@opencode/plugin";
+type Input = {
+    tool: string;
+    sessionID: string;
+    args: Record<string, unknown>;
+    directory?: string;
+};
+type Hooks = {
+    "tool.execute.before"?: (input: Input, output: {
+        args: unknown;
+    }) => Promise<void>;
+    "tool.execute.after"?: (input: Input, output: {
+        output: string;
+    }) => Promise<void>;
+    event?: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+    "experimental.chat.system.transform"?: (input: {
+        sessionID: string;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+};
+export declare function registerV2Hooks(ctx: Plugin.Context, hooks: Hooks, options?: {
+    sessionDirectory?: boolean;
+}): Promise<(() => Promise<void>) | undefined>;
+export {};

package/dist/plugins/compatibility.js

@@ -0,0 +1,87 @@
+function toolName(name) {
+    return name === "shell" ? "bash" : name === "subagent" ? "task" : name;
+}
+function args(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function text(result) {
+    if (typeof result.content === "string")
+        return result.content;
+    if (Array.isArray(result.content))
+        return result.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n");
+    return undefined;
+}
+function replaceText(result, output) {
+    if (!Array.isArray(result.content))
+        return { ...result, content: output };
+    let replaced = false;
+    return {
+        ...result,
+        content: result.content.flatMap((part) => {
+            if (part.type !== "text")
+                return [part];
+            if (replaced)
+                return [];
+            replaced = true;
+            return [{ type: "text", text: output }];
+        }),
+    };
+}
+export async function registerV2Hooks(ctx, hooks, options = {}) {
+    if (hooks["tool.execute.before"])
+        await ctx.tool.hook("execute.before", async (event) => {
+            const output = { args: event.input };
+            await hooks["tool.execute.before"]({ ...event, tool: toolName(event.tool), args: args(event.input) }, output);
+            event.input = output.args;
+        });
+    if (hooks["tool.execute.after"])
+        await ctx.tool.hook("execute.after", async (event) => {
+            if (event.status !== "completed")
+                return;
+            const original = text(event.result);
+            if (original === undefined)
+                return;
+            const output = { output: original };
+            let directory = ctx.location.directory;
+            if (options.sessionDirectory && (event.tool === "read" || event.tool === "edit")) {
+                const session = await ctx.session
+                    .get({ sessionID: event.sessionID })
+                    .catch(() => undefined);
+                if (!session)
+                    return;
+                directory = session.location.directory;
+            }
+            await hooks["tool.execute.after"]({ ...event, tool: toolName(event.tool), args: args(event.input), directory }, output);
+            if (output.output !== original)
+                event.result = replaceText(event.result, output.output);
+        });
+    if (hooks["experimental.chat.system.transform"])
+        await ctx.session.hook("context", async (event) => {
+            const output = { system: [] };
+            await hooks["experimental.chat.system.transform"]({ sessionID: event.sessionID }, output);
+            event.system.push(...output.system.map((text) => ({ type: "text", text })));
+        });
+    if (!hooks.event)
+        return;
+    const controller = new AbortController();
+    const subscription = (async () => {
+        try {
+            for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+                await hooks.event({ event: { type: event.type, properties: args(event.data) } });
+            }
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                console.error("agentomatic event subscription failed", error);
+        }
+    })();
+    return async () => {
+        controller.abort();
+        await subscription;
+    };
+}

package/dist/plugins/rtk.d.ts

@@ -1,3 +1,4 @@
+import type { Plugin } from "@opencode/plugin";
 type HookInput = {
     tool: string;
     args?: {
@@ -38,4 +39,13 @@ export declare function rtk(options?: RtkOptions): Promise<{
 } | {
     "tool.execute.after": (input: HookInput, output: HookOutput) => Promise<void>;
 }>;
-export default rtk;
+declare const _default: {
+    id: string;
+    server: (_input: unknown, options?: RtkOptions) => Promise<{
+        "tool.execute.after"?: undefined;
+    } | {
+        "tool.execute.after": (input: HookInput, output: HookOutput) => Promise<void>;
+    }>;
+    setup(ctx: Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/dist/plugins/rtk.js

@@ -1,3 +1,4 @@
+import { registerV2Hooks } from "./compatibility.js";
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -174,4 +175,10 @@ export async function rtk(options = {}) {
         },
     };
 }
-export default rtk;
+export default {
+    id: "agentomatic.rtk",
+    server: async (_input, options = {}) => rtk(options),
+    async setup(ctx) {
+        return registerV2Hooks(ctx, await rtk(ctx.options));
+    },
+};

package/dist/plugins/rules-injector.d.ts

@@ -1,3 +1,4 @@
+import type { Plugin } from "@opencode/plugin";
 export type RulesInjectorOptions = {
     budget?: number;
     cwd?: string;
@@ -19,4 +20,26 @@ export declare function rulesInjector(options?: RulesInjectorOptions): Promise<{
         system?: unknown[];
     }) => Promise<void>;
 }>;
-export default rulesInjector;
+declare const _default: {
+    id: string;
+    server: (input: {
+        directory?: string;
+    }, options?: RulesInjectorOptions) => Promise<{
+        "tool.execute.after"?: undefined;
+        event?: undefined;
+        "experimental.chat.system.transform"?: undefined;
+    } | {
+        "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
+        event: ({ event, }: {
+            event?: {
+                type?: string;
+                properties?: Record<string, unknown>;
+            };
+        }) => Promise<void>;
+        "experimental.chat.system.transform": (input: unknown, result: {
+            system?: unknown[];
+        }) => Promise<void>;
+    }>;
+    setup(ctx: Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/dist/plugins/rules-injector.js

@@ -1,3 +1,4 @@
+import { registerV2Hooks } from "./compatibility.js";
 import { lstat, readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
@@ -112,7 +113,7 @@ export async function rulesInjector(options = {}) {
     return {
         "tool.execute.after": inject,
         event: async ({ event, }) => {
-            if (event?.type?.includes("compaction")) {
+            if (event?.type === "session.compacted" || event?.type?.includes("compaction")) {
                 const identifier = sessionID(event.properties);
                 if (identifier)
                     state(identifier).replay = true;
@@ -128,4 +129,10 @@ export async function rulesInjector(options = {}) {
         },
     };
 }
-export default rulesInjector;
+export default {
+    id: "agentomatic.rules-injector",
+    server: async (input, options = {}) => rulesInjector({ ...options, cwd: options.cwd ?? input.directory }),
+    async setup(ctx) {
+        return registerV2Hooks(ctx, await rulesInjector({ ...ctx.options, cwd: ctx.location.directory }), { sessionDirectory: true });
+    },
+};

package/dist/plugins/zed-bell.d.ts

@@ -1,3 +1,4 @@
+import type { Plugin } from "@opencode/plugin";
 export type ZedBellOptions = {
     enabled?: boolean;
 };
@@ -10,4 +11,17 @@ export declare function zedBell(options?: ZedBellOptions): Promise<{
         };
     }) => Promise<void>;
 }>;
-export default zedBell;
+declare const _default: {
+    id: string;
+    server: (_input: unknown, options?: ZedBellOptions) => Promise<{
+        event?: undefined;
+    } | {
+        event: ({ event }: {
+            event: {
+                type?: string;
+            };
+        }) => Promise<void>;
+    }>;
+    setup(ctx: Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/dist/plugins/zed-bell.js

@@ -1,3 +1,4 @@
+import { registerV2Hooks } from "./compatibility.js";
 export async function zedBell(options = {}) {
     if (!options.enabled)
         return {};
@@ -11,4 +12,10 @@ export async function zedBell(options = {}) {
         },
     };
 }
-export default zedBell;
+export default {
+    id: "agentomatic.zed-bell",
+    server: async (_input, options = {}) => zedBell(options),
+    async setup(ctx) {
+        return registerV2Hooks(ctx, await zedBell(ctx.options));
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/agentomatic",
-  "version": "11.0.0-dev.76.ge1ca4a43f0f3",
+  "version": "11.0.0-dev.77.g09da04664b2e",
   "description": "OpenCode integration and opt-in installer for portable Agent Skills.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -40,26 +40,32 @@
   },
   "scripts": {
     "build": "node scripts/clean-dist.mjs && tsc --project tsconfig.json && node dist/generate-assets.js",
-    "test": "node --test test/agent-profiles.test.mjs test/config-setup.test.mjs test/legacy-migration.test.mjs test/doctor.test.mjs test/package.test.mjs test/rtk.test.mjs test/self-install.test.mjs test/stage19.test.mjs test/surface-coverage.test.mjs",
+    "test": "node --test test/agent-profiles.test.mjs test/config-setup.test.mjs test/legacy-migration.test.mjs test/doctor.test.mjs test/package.test.mjs test/rtk.test.mjs test/self-install.test.mjs test/stage19.test.mjs test/surface-coverage.test.mjs test/opencode-compatibility.test.mjs",
     "smoke": "node test/smoke.mjs",
     "pack:check": "node test/pack-allowlist.mjs"
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@kisev/safe-fs": "1.0.0-dev.76.ge1ca4a43f0f3",
-    "commander": "15.0.0"
+    "@kisev/safe-fs": "1.0.0-dev.77.g09da04664b2e",
+    "commander": "15.0.0",
+    "zod": "4.1.8"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "1.18.29",
+    "@opencode-ai/plugin": "1.18.32",
+    "@opencode/plugin": "2.0.19",
     "@types/node": "22.15.30",
     "typescript": "7.0.2"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.18.29 <1.19.0"
+    "@opencode-ai/plugin": ">=1.18.0 <1.19.0",
+    "@opencode/plugin": ">=2.0.0 <2.1.0"
   },
   "peerDependenciesMeta": {
     "@opencode-ai/plugin": {
       "optional": true
+    },
+    "@opencode/plugin": {
+      "optional": true
     }
   },
   "engines": {