@kisev/agentomatic 11.0.2-dev.92.gc67bdc97fcd1 → 11.0.2

package/dist/index.js

@@ -1,115 +1,140 @@
-import { z } from "zod";
+import { tool } from "@opencode-ai/plugin";
 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 { resultText, toolInput } from "./plugins/events.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";
-import { matchesWildcard } from "./opencode-config.js";
 export { rulesInjector, rtk, zedBell };
-export default {
-    id: "agentomatic",
-    async setup(ctx) {
-        const gate = new RoutingGate();
-        const hostInventory = async () => {
-            const { data: raw } = await ctx.agent.list({
-                location: { directory: ctx.location.directory },
-            });
-            const capabilities = {
-                mapper: ["read", "search"],
-                architect: ["read", "architecture"],
-                worker: ["read", "write", "verify"],
-                review: ["read", "review"],
-                critic: ["read", "review"],
-            };
-            const agents = raw.map((agent) => ({
-                agent: agent.id,
-                available: true,
-                capabilities: capabilities[agent.id] ??
-                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.id) ? ["read", "review"] : ["read"]),
-                tools: ["read", "glob", "grep", "edit", "shell"].filter((action) => {
-                    const rules = agent.permissions.filter((rule) => matchesWildcard(rule.action, action));
-                    const broad = rules.reduce((last, rule, index) => (rule.resource === "*" ? index : last), -1);
-                    return rules.slice(Math.max(0, broad)).some((rule) => rule.effect !== "deny");
-                }),
-            }));
-            return { agents, revision: digest(raw) };
+const plugin = (async (input) => {
+    const gate = new RoutingGate();
+    const hostInventory = async () => {
+        if (!input.client?.app?.agents)
+            throw new Error("Resolved OpenCode agent inventory is unavailable");
+        const response = await input.client.app.agents({ query: { directory: input.directory } });
+        const raw = response.data;
+        if (!Array.isArray(raw))
+            throw new Error("Resolved OpenCode agent inventory is malformed");
+        const capabilities = {
+            mapper: ["read", "search"],
+            architect: ["read", "architecture"],
+            worker: ["read", "write", "verify"],
+            review: ["read", "review"],
+            critic: ["read", "review"],
         };
-        await ctx.tool.transform((editor) => {
-            editor.add({
-                name: "route",
-                description: "Resolve a capability category and dispatch one eligible agent through a one-use subagent receipt gate.",
-                input: z.object({
-                    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: z.string().optional(), latency_class: z.string().optional() })
-                        .optional(),
-                    decision: z.any().optional(),
-                }),
-                async execute(args, context) {
-                    const inventory = await hostInventory();
-                    const input = {
-                        category: args.category,
-                        task: args.task,
-                        requirements: args.requirements,
-                        agents: inventory.agents,
-                        inventory_revision: inventory.revision,
-                        execution_card: args.execution_card,
-                        override: args.override,
-                        trusted_override: args.trusted_override,
-                        budget: args.budget,
-                    };
-                    if (args.action === "preview")
-                        return { content: JSON.stringify(gate.preview(input)) };
-                    const decision = gate.dispatch(input, args.decision);
-                    if (decision.agent === "worker" && args.execution_card === undefined)
-                        throw new Error("implementation dispatch requires a confirmed execution card");
-                    const receipt = gate.grant(context.sessionID, decision, {
-                        task: args.task,
-                        requirements: args.requirements,
-                        card: args.execution_card,
-                    });
-                    return { content: JSON.stringify({ decision, receipt, status: "routed" }) };
-                },
-            });
+        const agents = raw.map((value) => {
+            const agent = value;
+            if (typeof agent.name !== "string" || !agent.name)
+                throw new Error("Resolved OpenCode agent has no name");
+            return {
+                agent: agent.name,
+                available: true,
+                capabilities: capabilities[agent.name] ??
+                    (/^critic-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent.name) ? ["read", "review"] : ["read"]),
+                tools: [
+                    "read",
+                    ...(agent.permission?.edit !== "deny" ? ["edit"] : []),
+                    ...Object.entries(agent.tools ?? {})
+                        .filter(([, enabled]) => enabled)
+                        .map(([name]) => name),
+                    ...Object.entries(agent.permission?.bash ?? {})
+                        .filter(([, mode]) => mode !== "deny")
+                        .map(() => "bash"),
+                ].filter((name, index, list) => list.indexOf(name) === index),
+            };
         });
-        await ctx.tool.hook("execute.before", async (event) => {
-            if (event.tool !== "subagent")
+        return { agents, revision: digest(raw) };
+    };
+    const route = tool({
+        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
+                .object({
+                cost_class: tool.schema.string().optional(),
+                latency_class: tool.schema.string().optional(),
+            })
+                .optional(),
+            decision: tool.schema.any().optional(),
+        },
+        async execute(args, context) {
+            const inventory = await hostInventory();
+            const input = {
+                category: args.category,
+                task: args.task,
+                requirements: args.requirements,
+                agents: inventory.agents,
+                inventory_revision: inventory.revision,
+                execution_card: args.execution_card,
+                override: args.override,
+                trusted_override: args.trusted_override,
+                budget: args.budget,
+            };
+            if (args.action === "preview")
+                return JSON.stringify(gate.preview(input));
+            const decision = gate.dispatch(input, args.decision);
+            if (decision.agent === "worker" && args.execution_card === undefined)
+                throw new Error("implementation dispatch requires a confirmed execution card");
+            const receipt = gate.grant(context.sessionID, decision, {
+                task: args.task,
+                requirements: args.requirements,
+                card: args.execution_card,
+            });
+            return JSON.stringify({ decision, receipt, status: "routed" });
+        },
+    });
+    return {
+        tool: { route },
+        "tool.execute.before": async (input, output) => {
+            if (input.tool !== "task")
                 return;
-            const args = toolInput(event.input);
-            const agent = typeof args.agent === "string" ? args.agent : undefined;
+            const args = output.args && typeof output.args === "object"
+                ? output.args
+                : {};
+            const agent = typeof args.agent === "string"
+                ? args.agent
+                : typeof args.subagent_type === "string"
+                    ? args.subagent_type
+                    : undefined;
             if (!agent)
-                throw new Error("Native subagent requires an explicit agent and an active routing receipt");
+                throw new Error("Native Task requires an explicit agent and an active routing receipt");
             const hasBinding = "task" in args || "requirements" in args || "execution_card" in args;
             if (!hasBinding)
-                gate.consume(event.sessionID, agent);
-            else
-                gate.consume(event.sessionID, agent, {
-                    task: typeof args.task === "string" ? args.task : "",
-                    requirements: Array.isArray(args.requirements) ? args.requirements : [],
-                    card: args.execution_card,
-                });
-        });
-        await ctx.tool.hook("execute.after", async (event) => {
-            if (event.tool !== "subagent" || event.status !== "completed")
+                gate.consume(input.sessionID, agent);
+            else {
+                const task = typeof args.task === "string" ? args.task : "";
+                const requirements = Array.isArray(args.requirements)
+                    ? args.requirements
+                    : [];
+                gate.consume(input.sessionID, agent, { task, requirements, card: args.execution_card });
+            }
+        },
+        "tool.execute.after": async (input, output) => {
+            if (input.tool !== "task")
                 return;
-            const args = toolInput(event.input);
-            if (typeof args.agent !== "string")
-                throw new Error("Subagent result requires an explicit agent");
+            const args = input.args && typeof input.args === "object" ? input.args : {};
+            const agent = typeof args.agent === "string"
+                ? args.agent
+                : typeof args.subagent_type === "string"
+                    ? args.subagent_type
+                    : undefined;
+            if (!agent)
+                throw new Error("Task result requires an explicit agent");
             let result;
             try {
-                result = JSON.parse(resultText(event.result) ?? "");
+                result = JSON.parse(output.output);
             }
             catch {
-                throw new Error("Subagent result must be JSON structured report");
+                throw new Error("Task result must be JSON structured report");
             }
-            gate.complete(event.sessionID, args.agent, result);
-        });
-    },
-};
+            gate.complete(input.sessionID, agent, result);
+        },
+    };
+});
+export const server = plugin;
+export default plugin;

package/dist/jsonc.d.ts

@@ -30,18 +30,7 @@ export type JsoncPath = Array<string | number>;
 export type JsoncEdit = {
     kind: "append-unique";
     path: JsoncPath;
-    value: unknown;
-} | {
-    kind: "set-value";
-    path: JsoncPath;
-    value: unknown;
-} | {
-    kind: "rename-key";
-    path: JsoncPath;
-    to: string;
-} | {
-    kind: "remove-key";
-    path: JsoncPath;
+    value: string;
 } | {
     kind: "replace-array-value";
     path: JsoncPath;

package/dist/jsonc.js

@@ -143,9 +143,6 @@ function parseObject(parser) {
             parser.cursor += 1;
             trailingComma = true;
         }
-        else if (next && !(next.type === "punct" && next.raw === "}")) {
-            throw new JsoncError("invalid_jsonc", `Expected comma at offset ${next.start}`);
-        }
     }
     if (!closed)
         throw new JsoncError("invalid_jsonc", `Unterminated object at offset ${open.start}`);
@@ -183,9 +180,6 @@ function parseArray(parser) {
             parser.cursor += 1;
             trailingComma = true;
         }
-        else if (next && !(next.type === "punct" && next.raw === "]")) {
-            throw new JsoncError("invalid_jsonc", `Expected comma at offset ${next.start}`);
-        }
     }
     if (!closed)
         throw new JsoncError("invalid_jsonc", `Unterminated array at offset ${open.start}`);
@@ -206,12 +200,7 @@ export function nodeToValue(node) {
         return node.items.map(nodeToValue);
     const value = {};
     for (const key of node.propOrder)
-        Object.defineProperty(value, key, {
-            value: nodeToValue(node.props.get(key)),
-            writable: true,
-            configurable: true,
-            enumerable: true,
-        });
+        value[key] = nodeToValue(node.props.get(key));
     return value;
 }
 function parseDocument(text) {
@@ -289,62 +278,11 @@ function requireObjectPath(text, root, path) {
     return { text: currentText, node };
 }
 function applyEdit(text, root, edit) {
-    if (edit.kind === "rename-key" || edit.kind === "remove-key") {
-        const key = edit.path.at(-1);
-        const parent = resolve(root, edit.path.slice(0, -1));
-        if (typeof key !== "string" || !parent || parent.kind !== "object")
-            throw new JsoncError("conflict", "Key edit requires an object parent");
-        const target = parent.props.get(key);
-        if (!target)
-            return { text, result: "present" };
-        const index = parent.propOrder.indexOf(key);
-        const previous = index ? parent.props.get(parent.propOrder[index - 1]) : undefined;
-        const tokens = tokenize(text).filter((token) => token.start >= (previous?.end ?? parent.start + 1) && token.end <= target.start);
-        const keyToken = tokens.find((token) => token.type === "string");
-        if (!keyToken)
-            throw new JsoncError("conflict", "Object key token is unavailable");
-        if (edit.kind === "rename-key") {
-            if (parent.props.has(edit.to))
-                throw new JsoncError("conflict", `Destination key already exists: ${edit.to}`);
-            return {
-                text: text.slice(0, keyToken.start) + JSON.stringify(edit.to) + text.slice(keyToken.end),
-                result: "replaced",
-            };
-        }
-        const following = tokenize(text).find((token) => token.start >= target.end && token.type !== "ws" && token.type !== "comment");
-        const start = following?.raw === "," || !previous ? keyToken.start : previous.end;
-        const end = following?.raw === "," ? following.end : target.end;
-        const comments = tokenize(text.slice(start, end))
-            .filter((token) => token.type === "comment")
-            .map((token) => `${token.raw}\n`)
-            .join("");
-        return { text: text.slice(0, start) + comments + text.slice(end), result: "replaced" };
-    }
-    if (edit.kind === "set-value") {
-        const target = resolve(root, edit.path);
-        if (!target)
-            return applyEdit(text, root, { ...edit, kind: "set-if-absent" });
-        if (JSON.stringify(nodeToValue(target)) === JSON.stringify(edit.value))
-            return { text, result: "present" };
-        const comments = tokenize(text.slice(target.start, target.end))
-            .filter((token) => token.type === "comment")
-            .map((token) => `${token.raw}\n${lineIndent(text, target.start)}`)
-            .join("");
-        return {
-            text: text.slice(0, target.start) +
-                comments +
-                serialize(edit.value, lineIndent(text, target.start)) +
-                text.slice(target.end),
-            result: "replaced",
-        };
-    }
     if (edit.kind === "append-unique") {
         const target = resolve(root, edit.path);
         if (!target || target.kind !== "array")
             throw new JsoncError("conflict", "append-unique target is missing or not an array");
-        if (target.items
-            .map(nodeToValue)
-            .some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
+        if (target.items.map(nodeToValue).includes(edit.value))
             return { text, result: "present" };
         const insertion = target.empty ? JSON.stringify(edit.value) : `, ${JSON.stringify(edit.value)}`;
         const at = target.empty ? target.start + 1 : target.items.at(-1).end;
@@ -431,24 +369,9 @@ function at(value, path) {
         : undefined, value);
 }
 function verifyEdit(before, after, edit) {
-    if (edit.kind === "set-value") {
-        if (JSON.stringify(at(after, edit.path)) !== JSON.stringify(edit.value))
-            throw new JsoncError("merge_validation_failed", "set-value postcondition failed");
-        return;
-    }
-    if (edit.kind === "rename-key" || edit.kind === "remove-key") {
-        if (at(after, edit.path) !== undefined)
-            throw new JsoncError("merge_validation_failed", "Old key remains after key edit");
-        if (edit.kind === "rename-key" &&
-            JSON.stringify(at(before, edit.path)) !==
-                JSON.stringify(at(after, [...edit.path.slice(0, -1), edit.to])))
-            throw new JsoncError("merge_validation_failed", "Renamed key lost its value");
-        return;
-    }
     if (edit.kind === "append-unique") {
         const target = at(after, edit.path);
-        if (!Array.isArray(target) ||
-            !target.some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
+        if (!Array.isArray(target) || !target.includes(edit.value))
             throw new JsoncError("merge_validation_failed", "append-unique postcondition failed");
         return;
     }
@@ -496,12 +419,12 @@ function verifyEdit(before, after, edit) {
         throw new JsoncError("merge_validation_failed", "widened map lost the original scalar value");
 }
 export function applyJsoncEdits(text, edits) {
-    parseJsonc(text);
+    const before = parseJsonc(text);
     let current = text;
     const results = [];
     for (const edit of edits) {
         const applied = applyEdit(current, parseDocument(current), edit);
-        verifyEdit(parseJsonc(current), parseJsonc(applied.text), edit);
+        verifyEdit(before, parseJsonc(applied.text), edit);
         results.push(applied.result);
         current = applied.text;
     }

package/dist/plugins/rtk.d.ts

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

package/dist/plugins/rtk.js

@@ -1,4 +1,3 @@
-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,33 +137,26 @@ export async function rtk(options = {}) {
         ((selected, input) => external(options.bin ?? "rtk", selected, input));
     const statsPath = options.statsPath === null ? undefined : (options.statsPath ?? rtkStatsPath());
     return {
-        "execute.after": async (input) => {
-            if (input.status !== "completed")
-                return;
-            const output = { output: resultText(input.result) };
+        "tool.execute.after": async (input, output) => {
             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 !== "shell" ||
+                if (input.tool !== "bash" ||
                     typeof output.output !== "string" ||
                     output.output.length < (options.threshold ?? THRESHOLD)) {
-                    if (input.tool === "shell" && typeof output.output === "string" && statsPath)
+                    if (input.tool === "bash" && 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 command = toolInput(input.input).command;
-                const selected = typeof command === "string" ? filter(command) : undefined;
+                const selected = typeof input.args?.command === "string" ? filter(input.args.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"
@@ -182,11 +174,4 @@ export async function rtk(options = {}) {
         },
     };
 }
-export default {
-    id: "agentomatic.rtk",
-    async setup(ctx) {
-        const hooks = await rtk(ctx.options);
-        if (hooks["execute.after"])
-            await ctx.tool.hook("execute.after", hooks["execute.after"]);
-    },
-};
+export default rtk;

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

@@ -1,32 +1,22 @@
-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<{
-    "execute.after"?: undefined;
+    "tool.execute.after"?: undefined;
     event?: undefined;
-    context?: undefined;
+    "experimental.chat.system.transform"?: undefined;
 } | {
-    "execute.after": (input: ToolAfter & {
-        directory?: string;
+    "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
+    event: ({ event, }: {
+        event?: {
+            type?: string;
+            properties?: Record<string, unknown>;
+        };
     }) => Promise<void>;
-    event: (event: {
-        type: string;
-        data?: unknown;
-    }) => Promise<void>;
-    context: (input: {
-        sessionID: string;
-        system: Array<{
-            type: "text";
-            text: string;
-        }>;
+    "experimental.chat.system.transform": (input: unknown, result: {
+        system?: unknown[];
     }) => Promise<void>;
 }>;
-declare const _default: {
-    id: string;
-    setup(ctx: Plugin.Context): Promise<(() => Promise<void>) | undefined>;
-};
-export default _default;
+export default rulesInjector;

package/dist/plugins/rules-injector.js

@@ -1,4 +1,3 @@
-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,6 +9,20 @@ 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}]`;
 }
@@ -31,19 +44,16 @@ export async function rulesInjector(options = {}) {
         }
         return item;
     };
-    const inject = async (input) => {
-        if (input.status !== "completed" || (input.tool !== "read" && input.tool !== "edit"))
+    const inject = async (input, result) => {
+        const call = input;
+        if (call?.tool !== "read" && call?.tool !== "edit")
             return;
-        const identifier = input.sessionID;
-        const target = toolInput(input.input).path;
-        const original = resultText(input.result);
-        if (!identifier || typeof target !== "string" || original === undefined)
+        const identifier = sessionID(input);
+        const target = pathOf(input, result);
+        if (!identifier || !target)
             return;
-        const output = (text) => {
-            input.result = replaceResultText(input.result, `${original}\n${text}`);
-        };
         try {
-            const native = input.directory ?? cwd;
+            const native = typeof call?.directory === "string" ? call.directory : cwd;
             const paths = [];
             let current = dirname(resolve(native, target));
             while (true) {
@@ -93,51 +103,29 @@ export async function rulesInjector(options = {}) {
                 }
             }
             if (additions.length)
-                output(additions.join("\n\n"));
+                output(result, additions.join("\n\n"));
         }
         catch (error) {
-            output(`[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
+            output(result, `[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
         }
     };
     return {
-        "execute.after": inject,
-        event: async (event) => {
-            if (event.type === "session.compacted" || event.type.includes("compaction")) {
-                const identifier = sessionID(event.data);
+        "tool.execute.after": inject,
+        event: async ({ event, }) => {
+            if (event?.type?.includes("compaction")) {
+                const identifier = sessionID(event.properties);
                 if (identifier)
                     state(identifier).replay = true;
             }
         },
-        context: async (input) => {
+        "experimental.chat.system.transform": async (input, result) => {
             const identifier = sessionID(input);
-            if (!identifier || !state(identifier).replay)
+            if (!identifier || !state(identifier).replay || !Array.isArray(result.system))
                 return;
             for (const rule of state(identifier).loaded.values())
-                input.system.push({ type: "text", text: block(rule) });
+                result.system.push(block(rule));
             state(identifier).replay = false;
         },
     };
 }
-export default {
-    id: "agentomatic.rules-injector",
-    async setup(ctx) {
-        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);
-    },
-};
+export default rulesInjector;