@kisev/agentomatic 11.0.2-dev.85.gb47f85ffc092 → 11.0.2-dev.87.g5a92e74c6754

package/dist/plugins/rtk.d.ts

@@ -1,13 +1,5 @@
 import type { Plugin } from "@opencode/plugin";
-type HookInput = {
-    tool: string;
-    args?: {
-        command?: unknown;
-    };
-};
-type HookOutput = {
-    output?: unknown;
-};
+import { type ToolAfter } from "./events.js";
 export type RtkMethod = "compressed-rtk" | "truncated-head-tail" | "rtk-unavailable" | "ineligible" | "below-threshold";
 export type RtkStats = {
     schema_version: 1;
@@ -35,17 +27,12 @@ export declare function rtkCharsSaved(stats: RtkStats): number;
 export declare function rtkTokensSavedEstimate(stats: RtkStats): number;
 export declare function readRtkStats(path?: string): Promise<RtkStats | undefined>;
 export declare function rtk(options?: RtkOptions): Promise<{
-    "tool.execute.after"?: undefined;
+    "execute.after"?: undefined;
 } | {
-    "tool.execute.after": (input: HookInput, output: HookOutput) => Promise<void>;
+    "execute.after": (input: ToolAfter) => Promise<void>;
 }>;
 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>;
+    setup(ctx: Plugin.Context): Promise<void>;
 };
 export default _default;

package/dist/plugins/rtk.js

@@ -1,4 +1,4 @@
-import { registerV2Hooks } from "./compatibility.js";
+import { resultText, replaceResultText, toolInput } from "./events.js";
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -138,26 +138,33 @@ export async function rtk(options = {}) {
         ((selected, input) => external(options.bin ?? "rtk", selected, input));
     const statsPath = options.statsPath === null ? undefined : (options.statsPath ?? rtkStatsPath());
     return {
-        "tool.execute.after": async (input, output) => {
+        "execute.after": async (input) => {
+            if (input.status !== "completed")
+                return;
+            const output = { output: resultText(input.result) };
             try {
                 if (input.tool === "edit" &&
                     typeof output.output === "string" &&
                     /oldString (not found|found multiple times|and newString must be different)/i.test(output.output))
                     output.output = `${output.output}\nSTOP. Read the file before retrying Edit.`;
-                if (input.tool !== "bash" ||
+                if (input.tool !== "shell" ||
                     typeof output.output !== "string" ||
                     output.output.length < (options.threshold ?? THRESHOLD)) {
-                    if (input.tool === "bash" && typeof output.output === "string" && statsPath)
+                    if (input.tool === "shell" && typeof output.output === "string" && statsPath)
                         await recordStats(statsPath, "below-threshold", output.output.length, output.output.length);
+                    if (output.output !== undefined)
+                        input.result = replaceResultText(input.result, output.output);
                     return;
                 }
-                const selected = typeof input.args?.command === "string" ? filter(input.args.command) : undefined;
+                const command = toolInput(input.input).command;
+                const selected = typeof command === "string" ? filter(command) : undefined;
                 const compressed = selected ? await run(selected, output.output) : undefined;
                 const result = compressed && compressed.length < output.output.length
                     ? compressed
                     : truncate(output.output);
                 const originalSize = output.output.length;
                 output.output = `${result}\n[rtk: compressed method=${result === compressed ? `rtk/${selected}` : "head+tail"}; sizes=${originalSize}->${result.length}; evidence_complete=false; loss=possible]`;
+                input.result = replaceResultText(input.result, output.output);
                 if (statsPath) {
                     const method = result === compressed
                         ? "compressed-rtk"
@@ -177,8 +184,9 @@ export async function rtk(options = {}) {
 }
 export default {
     id: "agentomatic.rtk",
-    server: async (_input, options = {}) => rtk(options),
     async setup(ctx) {
-        return registerV2Hooks(ctx, await rtk(ctx.options));
+        const hooks = await rtk(ctx.options);
+        if (hooks["execute.after"])
+            await ctx.tool.hook("execute.after", hooks["execute.after"]);
     },
 };

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

@@ -1,45 +1,32 @@
 import type { Plugin } from "@opencode/plugin";
+import { type ToolAfter } from "./events.js";
 export type RulesInjectorOptions = {
     budget?: number;
     cwd?: string;
     enabled?: boolean;
 };
 export declare function rulesInjector(options?: RulesInjectorOptions): Promise<{
-    "tool.execute.after"?: undefined;
+    "execute.after"?: undefined;
     event?: undefined;
-    "experimental.chat.system.transform"?: undefined;
+    context?: undefined;
 } | {
-    "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
-    event: ({ event, }: {
-        event?: {
-            type?: string;
-            properties?: Record<string, unknown>;
-        };
+    "execute.after": (input: ToolAfter & {
+        directory?: string;
+    }) => Promise<void>;
+    event: (event: {
+        type: string;
+        data?: unknown;
     }) => Promise<void>;
-    "experimental.chat.system.transform": (input: unknown, result: {
-        system?: unknown[];
+    context: (input: {
+        sessionID: string;
+        system: Array<{
+            type: "text";
+            text: string;
+        }>;
     }) => Promise<void>;
 }>;
 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,4 +1,4 @@
-import { registerV2Hooks } from "./compatibility.js";
+import { resultText, replaceResultText, subscribeEvents, toolInput, } from "./events.js";
 import { lstat, readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
@@ -10,20 +10,6 @@ function sessionID(value) {
             return item[key];
     return undefined;
 }
-function pathOf(input, output) {
-    for (const value of [input, output]) {
-        const args = value?.args;
-        for (const key of ["filePath", "file_path", "path"])
-            if (typeof args?.[key] === "string")
-                return args[key];
-    }
-    return undefined;
-}
-function output(value, text) {
-    const item = value;
-    if (typeof item?.output === "string")
-        item.output = `${item.output}\n${text}`;
-}
 function marker(rule) {
     return `[rules-injector source=${rule.path} revision=${rule.revision}]`;
 }
@@ -45,16 +31,19 @@ export async function rulesInjector(options = {}) {
         }
         return item;
     };
-    const inject = async (input, result) => {
-        const call = input;
-        if (call?.tool !== "read" && call?.tool !== "edit")
+    const inject = async (input) => {
+        if (input.status !== "completed" || (input.tool !== "read" && input.tool !== "edit"))
             return;
-        const identifier = sessionID(input);
-        const target = pathOf(input, result);
-        if (!identifier || !target)
+        const identifier = input.sessionID;
+        const target = toolInput(input.input).path;
+        const original = resultText(input.result);
+        if (!identifier || typeof target !== "string" || original === undefined)
             return;
+        const output = (text) => {
+            input.result = replaceResultText(input.result, `${original}\n${text}`);
+        };
         try {
-            const native = typeof call?.directory === "string" ? call.directory : cwd;
+            const native = input.directory ?? cwd;
             const paths = [];
             let current = dirname(resolve(native, target));
             while (true) {
@@ -104,35 +93,51 @@ export async function rulesInjector(options = {}) {
                 }
             }
             if (additions.length)
-                output(result, additions.join("\n\n"));
+                output(additions.join("\n\n"));
         }
         catch (error) {
-            output(result, `[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
+            output(`[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
         }
     };
     return {
-        "tool.execute.after": inject,
-        event: async ({ event, }) => {
-            if (event?.type === "session.compacted" || event?.type?.includes("compaction")) {
-                const identifier = sessionID(event.properties);
+        "execute.after": inject,
+        event: async (event) => {
+            if (event.type === "session.compacted" || event.type.includes("compaction")) {
+                const identifier = sessionID(event.data);
                 if (identifier)
                     state(identifier).replay = true;
             }
         },
-        "experimental.chat.system.transform": async (input, result) => {
+        context: async (input) => {
             const identifier = sessionID(input);
-            if (!identifier || !state(identifier).replay || !Array.isArray(result.system))
+            if (!identifier || !state(identifier).replay)
                 return;
             for (const rule of state(identifier).loaded.values())
-                result.system.push(block(rule));
+                input.system.push({ type: "text", text: block(rule) });
             state(identifier).replay = false;
         },
     };
 }
 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 });
+        const hooks = await rulesInjector({ ...ctx.options, cwd: ctx.location.directory });
+        if (hooks["execute.after"])
+            await ctx.tool.hook("execute.after", async (event) => {
+                if (event.status !== "completed" || (event.tool !== "read" && event.tool !== "edit"))
+                    return;
+                const session = await ctx.session
+                    .get({ sessionID: event.sessionID })
+                    .catch(() => undefined);
+                if (session) {
+                    const scoped = { ...event, directory: session.location.directory };
+                    await hooks["execute.after"](scoped);
+                    event.result = scoped.result;
+                }
+            });
+        if (hooks.context)
+            await ctx.session.hook("context", hooks.context);
+        if (hooks.event)
+            return subscribeEvents(ctx, hooks.event);
     },
 };

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

@@ -5,23 +5,12 @@ export type ZedBellOptions = {
 export declare function zedBell(options?: ZedBellOptions): Promise<{
     event?: undefined;
 } | {
-    event: ({ event }: {
-        event: {
-            type?: string;
-        };
+    event: (event: {
+        type: string;
     }) => Promise<void>;
 }>;
 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,9 +1,9 @@
-import { registerV2Hooks } from "./compatibility.js";
+import { subscribeEvents } from "./events.js";
 export async function zedBell(options = {}) {
     if (!options.enabled)
         return {};
     return {
-        event: async ({ event }) => {
+        event: async (event) => {
             if (event.type !== "session.idle" && event.type !== "permission.asked")
                 return;
             const acp = process.env.OPENCODE_CLIENT === "acp" || process.argv.includes("acp");
@@ -14,8 +14,9 @@ export async function zedBell(options = {}) {
 }
 export default {
     id: "agentomatic.zed-bell",
-    server: async (_input, options = {}) => zedBell(options),
     async setup(ctx) {
-        return registerV2Hooks(ctx, await zedBell(ctx.options));
+        const hooks = await zedBell(ctx.options);
+        if (hooks.event)
+            return subscribeEvents(ctx, hooks.event);
     },
 };

package/dist/registry.js

@@ -57,7 +57,7 @@ const COMMANDS = [
             "Show the RTK output-compression observability summary for this host.",
             `Run \`npx --yes @kisev/agentomatic@${requirePackageVersion()} doctor --json\` and render the \`rtk.observability\` check as a short human summary: wrapper status, rtk binary availability, event counters, characters saved, and the token estimate.`,
             "When the doctor command is unavailable, read the stats file directly: `$XDG_STATE_HOME/opencode/skills/rtk/stats.json`, or `~/.local/state/opencode/skills/rtk/stats.json` when that variable is unset.",
-            "Zero counters with an active wrapper mean no verbose bash output has been compressed yet.",
+            "Zero counters with an active wrapper mean no verbose shell output has been compressed yet.",
             "The `/rtk` command still loads the portable rtk skill and is unaffected by this summary.",
         ],
     },

package/dist/routing.js

@@ -21,7 +21,7 @@ const MATRIX = {
         implementation: {
             profiles: ["worker"],
             capabilities: ["read", "write", "verify"],
-            tools: ["read", "edit", "bash"],
+            tools: ["read", "edit", "shell"],
             cost: "medium",
             latency: "standard",
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/agentomatic",
-  "version": "11.0.2-dev.85.gb47f85ffc092",
+  "version": "11.0.2-dev.87.g5a92e74c6754",
   "description": "OpenCode integration and opt-in installer for portable Agent Skills.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -46,24 +46,19 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@kisev/safe-fs": "1.0.0-dev.85.gb47f85ffc092",
+    "@kisev/safe-fs": "1.0.0-dev.87.g5a92e74c6754",
     "commander": "15.0.0",
     "zod": "4.1.8"
   },
   "devDependencies": {
-    "@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.0 <1.19.0",
     "@opencode/plugin": ">=2.0.0 <2.1.0"
   },
   "peerDependenciesMeta": {
-    "@opencode-ai/plugin": {
-      "optional": true
-    },
     "@opencode/plugin": {
       "optional": true
     }

package/dist/plugins/compatibility.d.ts

@@ -1,30 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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;
-    };
-}