opencode-froggy 0.12.0 → 1.0.0

package/dist/index.js

@@ -1,298 +1,365 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadAgents, loadCommands, loadHooks, loadSkills, mergeHooks, } from "./loaders";
-import { getGlobalHookDir, getProjectHookDir } from "./config-paths";
+import { Plugin } from "@opencode/plugin";
+import { loadAgents, loadHooks, loadSkills, mergeHooks, } from "./loaders";
+import { getGlobalAgentDir, getGlobalCommandDir, getGlobalHookDir, getProjectHookDir } from "./config-paths";
 import { hasCodeExtension } from "./code-files";
 import { log } from "./logger";
 import { executeBashAction, DEFAULT_BASH_TIMEOUT, } from "./bash-executor";
-import { gitingestTool, pdfToMarkdownTool, createPromptSessionTool, createListChildSessionsTool, createAgentPromoteTool, getPromotedAgents, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
+import { gitingestTool, pdfToMarkdownTool, createPromptSessionTool, createListChildSessionsTool, createAgentPromoteTool, setPromotedAgent, getPromotedAgents, AGENT_PROMOTE_STORAGE_KEY, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
+import { buildSkillActivationBlock } from "./skill-activation";
+import { installBundledFiles } from "./command-installer";
+import { ChildSessionTracker } from "./session-children";
 export { parseFrontmatter, loadAgents, loadCommands } from "./loaders";
 export { buildSkillActivationBlock } from "./skill-activation";
-import { buildSkillActivationBlock } from "./skill-activation";
-// ============================================================================
-// CONSTANTS
-// ============================================================================
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PLUGIN_ROOT = join(__dirname, "..");
 const AGENT_DIR = join(PLUGIN_ROOT, "agent");
 const COMMAND_DIR = join(PLUGIN_ROOT, "command");
 const SKILL_DIR = join(PLUGIN_ROOT, "skill");
-// ============================================================================
-// PLUGIN
-// ============================================================================
-const SmartfrogPlugin = async (ctx) => {
-    const agents = loadAgents(AGENT_DIR);
-    const commands = loadCommands(COMMAND_DIR);
-    const skills = loadSkills(SKILL_DIR);
-    const globalHooks = loadHooks(getGlobalHookDir());
-    const projectHooks = loadHooks(getProjectHookDir(ctx.directory));
-    const hooks = mergeHooks(globalHooks, projectHooks);
-    const modifiedCodeFiles = new Map();
-    const pendingToolArgs = new Map();
-    const skillsWithTriggers = skills.filter(s => s.useWhen);
-    const skillActivationBlock = skillsWithTriggers.length > 0
-        ? buildSkillActivationBlock(skillsWithTriggers)
-        : null;
-    log("[init] Plugin loaded", {
-        agents: Object.keys(agents),
-        commands: Object.keys(commands),
-        skills: skills.map(s => s.name),
-        skillsWithTriggers: skillsWithTriggers.map(s => s.name),
-        hooks: Array.from(hooks.keys()),
-        tools: [
-            "gitingest",
-            "pdf-to-markdown",
-            "agent-promote",
-            "eth-transaction",
-            "eth-address-txs",
-            "eth-address-balance",
-            "eth-token-transfers",
-        ],
-    });
-    async function executeHookActions(hook, sessionID, extraLog, options) {
-        const prefix = `[hook:${hook.event}]`;
-        const canBlock = options?.canBlock ?? false;
-        const conditions = hook.conditions ?? [];
-        for (const condition of conditions) {
-            if (condition === "isMainSession") {
-                const sessionInfo = await ctx.client.session.get({ path: { id: sessionID } });
-                if (sessionInfo.data?.parentID) {
-                    log(`${prefix} condition not met, skipping`, { sessionID, condition });
-                    return { blocked: false };
-                }
-            }
-            if (condition === "hasCodeChange") {
-                const files = extraLog?.files;
-                if (!files || !files.some(hasCodeExtension)) {
-                    log(`${prefix} condition not met, skipping`, { sessionID, condition });
-                    return { blocked: false };
+const TRACKED_FILE_TOOLS = new Set(["write", "edit", "patch"]);
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function readSessionID(event) {
+    const data = asRecord(asRecord(event).data);
+    const sessionID = data.sessionID;
+    return typeof sessionID === "string" ? sessionID : undefined;
+}
+function readParentID(event) {
+    const data = asRecord(asRecord(event).data);
+    const parentID = data.parentID;
+    return typeof parentID === "string" ? parentID : undefined;
+}
+function readTitle(event) {
+    const data = asRecord(asRecord(event).data);
+    const title = data.title;
+    return typeof title === "string" ? title : undefined;
+}
+export default Plugin.define({
+    id: "opencode-froggy",
+    async setup(ctx) {
+        const agents = loadAgents(AGENT_DIR);
+        const skills = loadSkills(SKILL_DIR);
+        const emptyInstall = { installed: [], skipped: [], updated: [] };
+        let installedCommands = { ...emptyInstall };
+        let installedAgents = { ...emptyInstall };
+        try {
+            installedCommands = installBundledFiles(COMMAND_DIR, getGlobalCommandDir());
+        }
+        catch (error) {
+            log("[init] failed to install commands", { error: String(error) });
+        }
+        try {
+            installedAgents = installBundledFiles(AGENT_DIR, getGlobalAgentDir());
+        }
+        catch (error) {
+            log("[init] failed to install agents", { error: String(error) });
+        }
+        try {
+            await ctx.agent.reload();
+        }
+        catch (error) {
+            log("[init] failed to reload agents", { error: String(error) });
+        }
+        try {
+            await ctx.command.reload();
+        }
+        catch (error) {
+            log("[init] failed to reload commands", { error: String(error) });
+        }
+        const globalHooks = loadHooks(getGlobalHookDir());
+        const projectHooks = loadHooks(getProjectHookDir(ctx.location.directory));
+        const hooks = mergeHooks(globalHooks, projectHooks);
+        const modifiedCodeFiles = new Map();
+        const tracker = new ChildSessionTracker();
+        try {
+            const stored = await ctx.storage.get(AGENT_PROMOTE_STORAGE_KEY);
+            if (stored && typeof stored === "object" && !Array.isArray(stored)) {
+                for (const [name, mode] of Object.entries(stored)) {
+                    if (mode === "primary" || mode === "subagent" || mode === "all") {
+                        setPromotedAgent(name, mode);
+                    }
                 }
             }
         }
-        log(`${prefix} starting`, {
-            sessionID,
-            conditions,
-            actions: hook.actions.length,
-            ...extraLog
+        catch (error) {
+            log("[init] failed to load promoted agents", { error: String(error) });
+        }
+        const skillsWithTriggers = skills.filter((s) => s.useWhen);
+        const skillActivationBlock = skillsWithTriggers.length > 0 ? buildSkillActivationBlock(skillsWithTriggers) : null;
+        log("[init] Plugin loaded", {
+            agents: Object.keys(agents),
+            commandsInstalled: installedCommands.installed,
+            commandsUpdated: installedCommands.updated,
+            agentsInstalled: installedAgents.installed,
+            agentsUpdated: installedAgents.updated,
+            skills: skills.map((s) => s.name),
+            skillsWithTriggers: skillsWithTriggers.map((s) => s.name),
+            hooks: Array.from(hooks.keys()),
+            tools: [
+                "gitingest",
+                "pdf-to-markdown",
+                "prompt-session",
+                "list-child-sessions",
+                "agent-promote",
+                "eth-transaction",
+                "eth-address-txs",
+                "eth-address-balance",
+                "eth-token-transfers",
+            ],
         });
-        for (const action of hook.actions) {
-            try {
-                if ("command" in action) {
-                    const { name, args = "" } = typeof action.command === "string"
-                        ? { name: action.command }
-                        : action.command;
-                    const { agent, model } = commands[name] ?? {};
-                    log(`${prefix} executing command`, { command: name, args, agent, model });
-                    const result = await ctx.client.session.command({
-                        path: { id: sessionID },
-                        body: {
-                            command: name,
-                            arguments: args,
-                            agent,
-                            model,
-                        },
-                        query: { directory: ctx.directory },
-                    });
-                    log(`${prefix} command result`, { command: name, status: result.response?.status, error: result.error });
-                }
-                else if ("tool" in action) {
-                    log(`${prefix} executing tool`, { tool: action.tool.name });
-                    const result = await ctx.client.session.prompt({
-                        path: { id: sessionID },
-                        body: { parts: [{ type: "text", text: `Use the ${action.tool.name} tool with these arguments: ${JSON.stringify(action.tool.args)}` }] },
-                        query: { directory: ctx.directory },
-                    });
-                    log(`${prefix} tool result`, { tool: action.tool.name, status: result.response?.status, error: result.error });
-                }
-                else if ("bash" in action) {
-                    const { command, timeout } = typeof action.bash === "string"
-                        ? { command: action.bash, timeout: DEFAULT_BASH_TIMEOUT }
-                        : { command: action.bash.command, timeout: action.bash.timeout ?? DEFAULT_BASH_TIMEOUT };
-                    const startTime = Date.now();
-                    log(`${prefix} executing bash`, { command, timeout });
-                    const bashContext = {
-                        session_id: sessionID,
-                        event: hook.event,
-                        cwd: ctx.directory,
-                        files: extraLog?.files,
-                        tool_name: extraLog?.tool_name,
-                        tool_args: extraLog?.tool_args,
-                    };
-                    const result = await executeBashAction(command, timeout, bashContext, ctx.directory);
-                    const duration = Date.now() - startTime;
-                    const statusIcon = result.exitCode === 0 ? "✓" : "✗";
-                    const hookMessage = [
-                        `[BASH HOOK ${statusIcon}] ${command}`,
-                        `Exit: ${result.exitCode} | Duration: ${duration}ms`,
-                        result.stdout.trim() ? `Stdout: ${result.stdout.slice(0, 500).trim()}` : null,
-                        result.stderr.trim() ? `Stderr: ${result.stderr.slice(0, 500).trim()}` : null,
-                    ].filter(Boolean).join("\n");
-                    await ctx.client.session.prompt({
-                        path: { id: sessionID },
-                        body: {
-                            noReply: true,
-                            parts: [{ type: "text", text: hookMessage }],
-                        },
-                        query: { directory: ctx.directory },
-                    }).catch((err) => {
-                        log(`${prefix} failed to send hook message`, { error: String(err) });
-                    });
-                    if (result.exitCode === 2) {
-                        log(`${prefix} bash exit code 2`, { stderr: result.stderr, canBlock });
-                        if (canBlock) {
-                            const blockReason = result.stderr.trim() || "Blocked by hook";
-                            return { blocked: true, blockReason };
+        async function executeHookActions(hook, sessionID, extraLog, options) {
+            const prefix = `[hook:${hook.event}]`;
+            const canBlock = options?.canBlock ?? false;
+            const conditions = hook.conditions ?? [];
+            for (const condition of conditions) {
+                if (condition === "isMainSession") {
+                    try {
+                        const sessionInfo = (await ctx.session.get({ sessionID }));
+                        if (sessionInfo?.parentID) {
+                            log(`${prefix} condition not met, skipping`, { sessionID, condition });
+                            return { blocked: false };
                         }
-                        return { blocked: false };
                     }
-                    if (result.exitCode !== 0) {
-                        log(`${prefix} bash failed (non-blocking)`, { exitCode: result.exitCode, stderr: result.stderr });
+                    catch (error) {
+                        log(`${prefix} failed to check session, continuing`, { error: String(error) });
                     }
-                    else {
-                        log(`${prefix} bash completed`, { stdout: result.stdout.slice(0, 200) });
+                }
+                if (condition === "hasCodeChange") {
+                    const files = extraLog?.files;
+                    if (!files || !files.some(hasCodeExtension)) {
+                        log(`${prefix} condition not met, skipping`, { sessionID, condition });
+                        return { blocked: false };
                     }
                 }
             }
-            catch (error) {
-                log(`${prefix} action failed, continuing`, { error: String(error) });
+            log(`${prefix} starting`, {
+                sessionID,
+                conditions,
+                actions: hook.actions.length,
+                ...extraLog,
+            });
+            for (const action of hook.actions) {
+                try {
+                    if ("command" in action) {
+                        const { name, args = "" } = typeof action.command === "string" ? { name: action.command } : action.command;
+                        log(`${prefix} executing command`, { command: name, args });
+                        await ctx.session.command({ sessionID, command: name, text: args });
+                    }
+                    else if ("tool" in action) {
+                        log(`${prefix} executing tool`, { tool: action.tool.name });
+                        await ctx.session.prompt({
+                            sessionID,
+                            text: `Use the ${action.tool.name} tool with these arguments: ${JSON.stringify(action.tool.args)}`,
+                        });
+                    }
+                    else if ("bash" in action) {
+                        const { command, timeout } = typeof action.bash === "string"
+                            ? { command: action.bash, timeout: DEFAULT_BASH_TIMEOUT }
+                            : { command: action.bash.command, timeout: action.bash.timeout ?? DEFAULT_BASH_TIMEOUT };
+                        const startTime = Date.now();
+                        log(`${prefix} executing bash`, { command, timeout });
+                        const bashContext = {
+                            session_id: sessionID,
+                            event: hook.event,
+                            cwd: ctx.location.directory,
+                            files: extraLog?.files,
+                            tool_name: extraLog?.tool_name,
+                            tool_args: extraLog?.tool_args,
+                        };
+                        const result = await executeBashAction(command, timeout, bashContext, ctx.location.directory);
+                        const duration = Date.now() - startTime;
+                        const statusIcon = result.exitCode === 0 ? "✓" : "✗";
+                        const hookMessage = [
+                            `[BASH HOOK ${statusIcon}] ${command}`,
+                            `Exit: ${result.exitCode} | Duration: ${duration}ms`,
+                            result.stdout.trim() ? `Stdout: ${result.stdout.slice(0, 500).trim()}` : null,
+                            result.stderr.trim() ? `Stderr: ${result.stderr.slice(0, 500).trim()}` : null,
+                        ]
+                            .filter(Boolean)
+                            .join("\n");
+                        await ctx.session
+                            .synthetic({ sessionID, text: hookMessage })
+                            .catch((err) => {
+                            log(`${prefix} failed to send hook message`, { error: String(err) });
+                        });
+                        if (result.exitCode === 2) {
+                            log(`${prefix} bash exit code 2`, { stderr: result.stderr, canBlock });
+                            if (canBlock) {
+                                const blockReason = result.stderr.trim() || "Blocked by hook";
+                                return { blocked: true, blockReason };
+                            }
+                            return { blocked: false };
+                        }
+                        if (result.exitCode !== 0) {
+                            log(`${prefix} bash failed (non-blocking)`, {
+                                exitCode: result.exitCode,
+                                stderr: result.stderr,
+                            });
+                        }
+                        else {
+                            log(`${prefix} bash completed`, { stdout: result.stdout.slice(0, 200) });
+                        }
+                    }
+                }
+                catch (error) {
+                    log(`${prefix} action failed, continuing`, { error: String(error) });
+                }
             }
-        }
-        log(`${prefix} completed`);
-        return { blocked: false };
-    }
-    async function triggerHooks(event, sessionID, extraLog, options) {
-        const eventHooks = hooks.get(event);
-        if (!eventHooks)
+            log(`${prefix} completed`);
             return { blocked: false };
-        for (const hook of eventHooks) {
-            const result = await executeHookActions(hook, sessionID, extraLog, options);
-            if (result.blocked)
-                return result;
         }
-        return { blocked: false };
-    }
-    async function triggerToolHooks(phase, toolName, sessionID, toolArgs) {
-        const canBlock = phase === "before";
-        const extraLog = { tool_name: toolName, tool_args: toolArgs };
-        const wildcardEvent = `tool.${phase}.*`;
-        const wildcardResult = await triggerHooks(wildcardEvent, sessionID, extraLog, { canBlock });
-        if (wildcardResult.blocked)
-            return wildcardResult;
-        const specificEvent = `tool.${phase}.${toolName}`;
-        const specificResult = await triggerHooks(specificEvent, sessionID, extraLog, { canBlock });
-        return specificResult;
-    }
-    return {
-        config: async (config) => {
-            const loadedAgents = loadAgents(AGENT_DIR);
-            for (const [name, mode] of getPromotedAgents()) {
-                if (loadedAgents[name]) {
-                    loadedAgents[name].mode = mode;
-                }
+        async function triggerHooks(event, sessionID, extraLog, options) {
+            const eventHooks = hooks.get(event);
+            if (!eventHooks)
+                return { blocked: false };
+            for (const hook of eventHooks) {
+                const result = await executeHookActions(hook, sessionID, extraLog, options);
+                if (result.blocked)
+                    return result;
             }
-            if (Object.keys(loadedAgents).length > 0) {
-                config.agent = { ...loadedAgents, ...(config.agent ?? {}) };
+            return { blocked: false };
+        }
+        async function triggerToolHooks(phase, toolName, sessionID, toolArgs) {
+            const canBlock = phase === "before";
+            const extraLog = { tool_name: toolName, tool_args: toolArgs };
+            const wildcardEvent = `tool.${phase}.*`;
+            const wildcardResult = await triggerHooks(wildcardEvent, sessionID, extraLog, { canBlock });
+            if (wildcardResult.blocked)
+                return wildcardResult;
+            const specificEvent = `tool.${phase}.${toolName}`;
+            return triggerHooks(specificEvent, sessionID, extraLog, { canBlock });
+        }
+        function trackModifiedFile(sessionID, toolName, toolArgs) {
+            if (!TRACKED_FILE_TOOLS.has(toolName))
+                return;
+            const filePath = (toolArgs.filePath ?? toolArgs.file_path ?? toolArgs.path);
+            if (!filePath)
+                return;
+            log("[tool.execute.before] File modified", { sessionID, filePath, tool: toolName });
+            let files = modifiedCodeFiles.get(sessionID);
+            if (!files) {
+                files = new Set();
+                modifiedCodeFiles.set(sessionID, files);
             }
-            if (Object.keys(commands).length > 0) {
-                config.command = { ...(config.command ?? {}), ...commands };
+            files.add(filePath);
+        }
+        await ctx.agent.transform((editor) => {
+            for (const [name, mode] of getPromotedAgents()) {
+                if (!editor.get(name))
+                    continue;
+                editor.update(name, (agent) => {
+                    agent.mode = mode;
+                });
             }
-            if (skills.length > 0) {
-                const existingSkills = config.skills ?? {};
-                const existingPaths = Array.isArray(existingSkills.paths) ? existingSkills.paths : [];
-                config.skills = {
-                    ...existingSkills,
-                    paths: existingPaths.includes(SKILL_DIR)
-                        ? existingPaths
-                        : [...existingPaths, SKILL_DIR],
-                };
+        });
+        await ctx.skill.transform((editor) => {
+            for (const skill of skills) {
+                editor.add({
+                    id: skill.name,
+                    name: skill.name,
+                    description: skill.description || undefined,
+                    location: skill.path,
+                    content: skill.body,
+                });
             }
-        },
-        tool: {
-            gitingest: gitingestTool,
-            "pdf-to-markdown": pdfToMarkdownTool,
-            "prompt-session": createPromptSessionTool(ctx.client),
-            "list-child-sessions": createListChildSessionsTool(ctx.client),
-            "agent-promote": createAgentPromoteTool(ctx.client, Object.keys(agents)),
-            "eth-transaction": ethTransactionTool,
-            "eth-address-txs": ethAddressTxsTool,
-            "eth-address-balance": ethAddressBalanceTool,
-            "eth-token-transfers": ethTokenTransfersTool,
-        },
-        "tool.execute.before": async (input, output) => {
-            const sessionID = input.sessionID;
-            if (!sessionID)
+        });
+        const promptSessionTool = createPromptSessionTool(ctx.session, tracker);
+        const listChildSessionsTool = createListChildSessionsTool(tracker);
+        const agentPromoteTool = createAgentPromoteTool(ctx.agent, ctx.agent, ctx.storage, Object.keys(agents));
+        await ctx.tool.transform((editor) => {
+            editor.add(gitingestTool);
+            editor.add(pdfToMarkdownTool);
+            editor.add(promptSessionTool);
+            editor.add(listChildSessionsTool);
+            editor.add(agentPromoteTool);
+            editor.add(ethTransactionTool);
+            editor.add(ethAddressTxsTool);
+            editor.add(ethAddressBalanceTool);
+            editor.add(ethTokenTransfersTool);
+        });
+        await ctx.tool.hook("execute.before", async (event) => {
+            if (!event.sessionID)
                 return;
-            const toolArgs = output.args ?? {};
-            pendingToolArgs.set(input.callID, toolArgs);
-            const result = await triggerToolHooks("before", input.tool, sessionID, toolArgs);
+            const toolArgs = asRecord(event.input);
+            const result = await triggerToolHooks("before", event.tool, event.sessionID, toolArgs);
             if (result.blocked) {
-                pendingToolArgs.delete(input.callID);
                 throw new Error(result.blockReason ?? "Blocked by hook");
             }
-            if (["write", "edit"].includes(input.tool)) {
-                const filePath = (toolArgs.filePath ?? toolArgs.file_path ?? toolArgs.path);
-                if (filePath) {
-                    log("[tool.execute.before] File modified", { sessionID, filePath, tool: input.tool });
-                    let files = modifiedCodeFiles.get(sessionID);
-                    if (!files) {
-                        files = new Set();
-                        modifiedCodeFiles.set(sessionID, files);
-                    }
-                    files.add(filePath);
-                }
-            }
-        },
-        "tool.execute.after": async (input, _output) => {
-            const sessionID = input.sessionID;
-            if (!sessionID)
+            trackModifiedFile(event.sessionID, event.tool, toolArgs);
+        });
+        await ctx.tool.hook("execute.after", async (event) => {
+            if (!event.sessionID)
                 return;
-            const toolArgs = pendingToolArgs.get(input.callID) ?? {};
-            pendingToolArgs.delete(input.callID);
-            await triggerToolHooks("after", input.tool, sessionID, toolArgs);
-        },
-        event: async ({ event }) => {
-            const props = event.properties;
-            if (event.type === "session.created") {
-                const info = props?.info;
-                const sessionID = info?.id;
-                if (!sessionID)
-                    return;
-                if (!info.parentID) {
-                    log("[event] session.created - main session", { sessionID });
+            const toolArgs = asRecord(event.input);
+            await triggerToolHooks("after", event.tool, event.sessionID, toolArgs);
+        });
+        if (skillActivationBlock) {
+            await ctx.session.hook("context", (event) => {
+                event.system.push({ type: "text", text: skillActivationBlock });
+            });
+        }
+        const controller = new AbortController();
+        void (async () => {
+            try {
+                for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+                    const record = event;
+                    if (record.type === "session.created") {
+                        const sessionID = readSessionID(event);
+                        if (!sessionID)
+                            continue;
+                        const parentID = readParentID(event);
+                        if (parentID) {
+                            tracker.trackChild({
+                                id: sessionID,
+                                parentID,
+                                title: readTitle(event),
+                                created: Date.now(),
+                                updated: Date.now(),
+                            });
+                        }
+                        else {
+                            log("[event] session.created - main session", { sessionID });
+                        }
+                        await triggerHooks("session.created", sessionID);
+                    }
+                    if (record.type === "session.deleted") {
+                        const sessionID = readSessionID(event);
+                        if (!sessionID)
+                            continue;
+                        log("[event] session.deleted", { sessionID });
+                        await triggerHooks("session.deleted", sessionID);
+                        modifiedCodeFiles.delete(sessionID);
+                        tracker.removeSession(sessionID);
+                    }
+                    if (record.type === "session.idle") {
+                        const sessionID = readSessionID(event);
+                        if (!sessionID)
+                            continue;
+                        log("[event] session.idle", { sessionID });
+                        if (!hooks.has("session.idle")) {
+                            log("[event] session.idle - no hooks defined, skipping");
+                            continue;
+                        }
+                        const files = modifiedCodeFiles.get(sessionID);
+                        modifiedCodeFiles.delete(sessionID);
+                        await triggerHooks("session.idle", sessionID, {
+                            files: files ? Array.from(files) : [],
+                        });
+                    }
                 }
-                await triggerHooks("session.created", sessionID);
             }
-            if (event.type === "session.deleted") {
-                const info = props?.info;
-                const sessionID = info?.id;
-                if (!sessionID)
-                    return;
-                log("[event] session.deleted", { sessionID });
-                await triggerHooks("session.deleted", sessionID);
-                modifiedCodeFiles.delete(sessionID);
-            }
-            if (event.type === "session.idle") {
-                const sessionID = props?.sessionID;
-                if (!sessionID)
-                    return;
-                log("[event] session.idle", { sessionID });
-                if (!hooks.has("session.idle")) {
-                    log("[event] session.idle - no hooks defined, skipping");
-                    return;
+            catch (error) {
+                if (error?.name !== "AbortError") {
+                    log("[event] subscription ended", { error: String(error) });
                 }
-                const files = modifiedCodeFiles.get(sessionID);
-                modifiedCodeFiles.delete(sessionID);
-                await triggerHooks("session.idle", sessionID, { files: files ? Array.from(files) : [] });
-            }
-        },
-        "experimental.chat.system.transform": async (_input, output) => {
-            // The activation block relies on OpenCode's native `skill` tool after we
-            // expose the plugin's bundled skills through `config.skills.paths`.
-            if (skillActivationBlock) {
-                output.system.push(skillActivationBlock);
             }
-        },
-    };
-};
-export default SmartfrogPlugin;
+        })();
+        return () => controller.abort();
+    },
+});

package/dist/index.test.js

@@ -822,7 +822,7 @@ describe("buildSkillActivationBlock", () => {
         ];
         const result = buildSkillActivationBlock(skills);
         expect(result).toContain("MANDATORY");
-        expect(result).toContain('skill({ name: "code-review" })');
+        expect(result).toContain('skill({ id: "code-review" })');
         expect(result).toContain("After writing code");
     });
     it("should preserve quotes in trigger text", () => {
@@ -871,8 +871,8 @@ describe("buildSkillActivationBlock", () => {
             { name: "skill-b", description: "B", useWhen: "Trigger B", path: "/b", body: "" },
         ];
         const result = buildSkillActivationBlock(skills);
-        expect(result).toContain('skill({ name: "skill-a" })');
-        expect(result).toContain('skill({ name: "skill-b" })');
+        expect(result).toContain('skill({ id: "skill-a" })');
+        expect(result).toContain('skill({ id: "skill-b" })');
         expect(result).toContain("Trigger A");
         expect(result).toContain("Trigger B");
         expect(result.match(/MANDATORY/g)).toHaveLength(2);