opencode-froggy 0.10.2 → 0.12.0

package/README.md

@@ -78,6 +78,7 @@ Alternatively, clone or copy the plugin files to one of these directories:
 | `/commit-push` | Stage, commit, and push changes with user confirmation | `build` |
 | `/diff-summary [source] [target]` | Show working tree changes or diff between branches | - |
 | `/doc-changes` | Update documentation based on uncommitted changes (new features only) | `doc-writer` |
+| `/linear-stale-check` | Review open Linear issues for the configured team and report whether they are likely active, uncertain, or obsolete | `plan` |
 | `/review-changes` | Review uncommitted changes (staged, unstaged, untracked) | `code-reviewer` |
 | `/review-pr <source> <target>` | Review diff from source branch into target branch | `code-reviewer` |
 | `/send-to [agent] <message>` | Send a message to a child session (subagent) to continue the conversation | - |
@@ -104,6 +105,24 @@ Shows staged changes, unstaged changes, and untracked file contents.
 ```
 Shows stats overview, commits, files changed, and full diff between branches.
 
+### /linear-stale-check
+
+Analyzes open Linear issues for the team configured in `AGENTS.md` with:
+
+```text
+Linear team: <name>
+```
+
+If no team is configured, the command lists available Linear teams and asks which one to use for the current run.
+
+The command is read-only. It fetches open issues, investigates related code, skips code investigation for issues already `In Progress`, and outputs a single report grouped by verdict:
+
+- 🔴 Likely obsolete
+- 🟡 Uncertain
+- 🟢 Likely active
+
+It does not modify Linear issues, add comments, or update project files.
+
 ---
 
 ## Agents

package/command/linear-stale-check.md

@@ -0,0 +1,199 @@
+---
+description: Review open Linear issues to check if they are still relevant
+agent: plan
+---
+
+## Your task
+
+Analyze the team's open Linear issues, diagnose each one by combining Linear
+metadata with codebase investigation, and present a single report.
+
+This command is read-only:
+- Do not ask the user questions except when `AGENTS.md` does not define a
+  Linear team.
+- Do not modify any Linear issue.
+- Do not add comments to Linear issues.
+- Do not modify `AGENTS.md` or any other project file.
+- Do not start an iterative review loop.
+
+The user will read the report and decide what to do next.
+
+## 1. Resolve the Linear team
+
+Read `AGENTS.md` from the current project and look for a plain-text line:
+
+```text
+Linear team: <name>
+```
+
+If the line exists, use `<name>` as the Linear team.
+
+If the line does not exist:
+- Use `linear_list_teams` to list available teams.
+- Ask the user to choose one of the available teams with the `question` tool.
+- Use the selected team for this run.
+- Continue the stale-check report normally.
+- Do not write to `AGENTS.md` yourself.
+
+## 2. Fetch open issues
+
+Use `linear_list_issues` for the resolved team:
+- `team`: resolved Linear team name
+- omit `state` entirely; do not pass `uncompleted`, `backlog`, `unstarted`,
+  `started`, an empty string, or any other status-type alias
+- omit `priority` entirely; do not pass `priority: 0` because that filters to
+  issues with no priority
+- `orderBy`: `updatedAt`, oldest first
+- fetch all matching issues by paginating until there are no more pages
+
+Only pass filters that are intentionally active. For unused filters, omit the
+field entirely instead of passing an empty, zero, or placeholder value. In
+particular, `priority: 0` is an active Linear filter for "No priority" and
+will exclude Medium, High, and Urgent issues.
+
+After fetching all team issues, filter locally:
+- keep issues whose `statusType` is not `completed`
+- keep issues whose `statusType` is not `canceled`
+
+Do not rely on Linear state-type aliases for this command. They can return
+incomplete results. Fetch broadly for the team, then filter locally by
+`statusType`.
+
+For each retained issue, load detailed data with `linear_get_issue` and include relations:
+- title
+- description
+- URL
+- state
+- priority
+- assignee
+- labels
+- project
+- createdAt
+- updatedAt
+- blocking and blocked-by relations
+
+## 3. Diagnose each issue
+
+Diagnose every fetched issue before producing the final report.
+
+### Linear signals
+
+Compute these signals for every issue:
+- Days since last update.
+- No assignee.
+- No project.
+- No useful description.
+- `In Progress` but inactive for more than 30 days.
+- Blockers are already closed or canceled.
+
+### Code investigation
+
+Run code investigation for every issue except issues whose state is exactly
+`In Progress`.
+
+For `In Progress` issues, set code signals to:
+
+```text
+skipped (in progress)
+```
+
+For all other issues, investigate the codebase directly with read-only search
+tools and git history commands. Run searches in parallel batches when possible.
+
+For each issue, use:
+- the Linear identifier
+- the title
+- a concise description excerpt
+- candidate keywords from the title and description
+
+Candidate keywords should include:
+- mentioned files or modules
+- function, class, type, command, hook, or config names
+- the Linear identifier itself
+- meaningful product or domain terms
+
+Search for relevance signals and keep the result to 3-5 concise lines:
+- Does the mentioned code or feature still exist?
+- Is the Linear identifier referenced in code, comments, TODOs, branches, or recent commits?
+- Is there recent git activity on related files or symbols?
+- Are there signs the feature was removed, renamed, or replaced?
+
+Summarize the returned investigation as code signals:
+- code or feature found
+- code or feature not found
+- identifier referenced
+- recent git activity found
+- no recent git activity found
+- no code correlation found
+
+## 4. Assign a verdict
+
+Assign exactly one verdict per issue:
+
+- 🔴 Likely obsolete
+- 🟡 Uncertain
+- 🟢 Likely active
+
+Use these rules as guidance, but apply judgment based on the full evidence.
+
+For `In Progress` issues, base the verdict on update age only:
+- updated less than 30 days ago: 🟢 Likely active
+- updated 30-90 days ago: 🟡 Uncertain
+- updated more than 90 days ago: 🔴 Likely obsolete
+
+For other issues:
+- Use 🟢 Likely active when the issue is referenced in code, has recent related git activity, or clearly describes current code.
+- Use 🟡 Uncertain when signals are mixed or weak.
+- Use 🔴 Likely obsolete when mentioned code is missing, the feature appears removed or replaced, or the issue has weak Linear signals and no code correlation.
+
+## 5. Output a single report
+
+Output one report only. Sort by verdict in this order:
+1. 🔴 Likely obsolete
+2. 🟡 Uncertain
+3. 🟢 Likely active
+
+Use this structure:
+
+```markdown
+# Linear Stale-Check Report
+
+Team: <team>
+Issues analyzed: <count>
+
+## 🔴 Likely Obsolete (<count>)
+
+### LIN-123 — Issue title
+
+URL: <Linear URL>
+State: <state> | Priority: <priority> | Assignee: <assignee or none> | Updated: <N>d ago
+Project: <project or none> | Labels: <labels or none>
+
+Summary: <1-2 line summary of the issue>
+
+Linear signals:
+- <signal>
+- <signal>
+
+Code signals:
+- <signal>
+- <signal>
+
+Verdict: 🔴 Likely obsolete — <short reason>
+
+## 🟡 Uncertain (<count>)
+
+...
+
+## 🟢 Likely Active (<count>)
+
+...
+```
+
+Keep each issue concise. Prefer useful evidence over speculation.
+
+End the report with:
+
+```text
+End of report. No issues were modified.
+```

package/dist/index.js

@@ -5,8 +5,7 @@ import { 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, createSkillTool, formatPluginSkillsAsXmlItems, getPromotedAgents, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
-import { injectPluginSkillsIntoSystem } from "./skill-injection";
+import { gitingestTool, pdfToMarkdownTool, createPromptSessionTool, createListChildSessionsTool, createAgentPromoteTool, getPromotedAgents, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
 export { parseFrontmatter, loadAgents, loadCommands } from "./loaders";
 export { buildSkillActivationBlock } from "./skill-activation";
 import { buildSkillActivationBlock } from "./skill-activation";
@@ -35,15 +34,6 @@ const SmartfrogPlugin = async (ctx) => {
     const skillActivationBlock = skillsWithTriggers.length > 0
         ? buildSkillActivationBlock(skillsWithTriggers)
         : null;
-    const skillTool = createSkillTool({
-        pluginSkills: skills,
-        pluginDir: PLUGIN_ROOT,
-        cwd: ctx.directory,
-        client: ctx.client,
-    });
-    const pluginSkillsXmlItems = skills.length > 0
-        ? formatPluginSkillsAsXmlItems(skills, PLUGIN_ROOT)
-        : null;
     log("[init] Plugin loaded", {
         agents: Object.keys(agents),
         commands: Object.keys(commands),
@@ -53,7 +43,6 @@ const SmartfrogPlugin = async (ctx) => {
         tools: [
             "gitingest",
             "pdf-to-markdown",
-            "skill",
             "agent-promote",
             "eth-transaction",
             "eth-address-txs",
@@ -208,11 +197,20 @@ const SmartfrogPlugin = async (ctx) => {
             if (Object.keys(commands).length > 0) {
                 config.command = { ...(config.command ?? {}), ...commands };
             }
+            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],
+                };
+            }
         },
         tool: {
             gitingest: gitingestTool,
             "pdf-to-markdown": pdfToMarkdownTool,
-            skill: skillTool,
             "prompt-session": createPromptSessionTool(ctx.client),
             "list-child-sessions": createListChildSessionsTool(ctx.client),
             "agent-promote": createAgentPromoteTool(ctx.client, Object.keys(agents)),
@@ -289,7 +287,8 @@ const SmartfrogPlugin = async (ctx) => {
             }
         },
         "experimental.chat.system.transform": async (_input, output) => {
-            injectPluginSkillsIntoSystem(output.system, pluginSkillsXmlItems);
+            // 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);
             }

package/dist/tools/index.d.ts

@@ -4,5 +4,4 @@ export { pdfToMarkdownTool } from "./pdf-to-markdown";
 export { createPromptSessionTool, type PromptSessionArgs } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
 export { createAgentPromoteTool, getPromotedAgents, type AgentPromoteArgs } from "./agent-promote";
-export { createSkillTool, discoverAllSkills, formatPluginSkillsAsXmlItems, type CreateSkillToolOptions, type DiscoverAllSkillsOptions, type SkillInfo, type SkillScope, } from "./skill";
 export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, type EthTransactionArgs, type EthAddressTxsArgs, type EthAddressBalanceArgs, type EthTokenTransfersArgs, } from "./blockchain";

package/dist/tools/index.js

@@ -4,5 +4,4 @@ export { pdfToMarkdownTool } from "./pdf-to-markdown";
 export { createPromptSessionTool } from "./prompt-session";
 export { createListChildSessionsTool } from "./list-child-sessions";
 export { createAgentPromoteTool, getPromotedAgents } from "./agent-promote";
-export { createSkillTool, discoverAllSkills, formatPluginSkillsAsXmlItems, } from "./skill";
 export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, } from "./blockchain";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-froggy",
-  "version": "0.10.2",
+  "version": "0.12.0",
   "description": "OpenCode plugin with a hook layer (tool.before.*, session.idle...), agents (code-reviewer, doc-writer), and commands (/review-pr, /commit)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/skill-injection.d.ts

@@ -1 +0,0 @@
-export declare function injectPluginSkillsIntoSystem(system: string[], pluginSkillsXmlItems: string | null): void;

package/dist/skill-injection.js

@@ -1,13 +0,0 @@
-const AVAILABLE_SKILLS_BLOCK_REGEX = /(<available_skills>[\s\S]*?)(<\/available_skills>)/;
-export function injectPluginSkillsIntoSystem(system, pluginSkillsXmlItems) {
-    if (!pluginSkillsXmlItems)
-        return;
-    for (let i = 0; i < system.length; i++) {
-        const segment = system[i];
-        if (AVAILABLE_SKILLS_BLOCK_REGEX.test(segment)) {
-            system[i] = segment.replace(AVAILABLE_SKILLS_BLOCK_REGEX, `$1${pluginSkillsXmlItems}\n$2`);
-            return;
-        }
-    }
-    system.push(`<available_skills>\n${pluginSkillsXmlItems}\n</available_skills>`);
-}

package/dist/skill-injection.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/skill-injection.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { injectPluginSkillsIntoSystem } from "./skill-injection";
-const SAMPLE_ITEMS = `  <skill>\n    <name>tdd</name>\n    <description>Apply TDD</description>\n  </skill>`;
-describe("injectPluginSkillsIntoSystem", () => {
-    it("should do nothing when pluginSkillsXmlItems is null", () => {
-        const system = ["some prompt", "<available_skills>\n  <skill><name>x</name></skill>\n</available_skills>"];
-        const before = [...system];
-        injectPluginSkillsIntoSystem(system, null);
-        expect(system).toEqual(before);
-    });
-    it("should inject items inside existing <available_skills> block", () => {
-        const system = [
-            "header text",
-            "<available_skills>\n  <skill>\n    <name>x</name>\n    <description>d</description>\n  </skill>\n</available_skills>",
-            "footer text",
-        ];
-        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
-        expect(system[0]).toBe("header text");
-        expect(system[2]).toBe("footer text");
-        expect(system[1]).toContain("<name>x</name>");
-        expect(system[1]).toContain("<name>tdd</name>");
-        const openCount = (system[1].match(/<available_skills>/g) ?? []).length;
-        const closeCount = (system[1].match(/<\/available_skills>/g) ?? []).length;
-        expect(openCount).toBe(1);
-        expect(closeCount).toBe(1);
-    });
-    it("should inject items before </available_skills>", () => {
-        const system = [
-            "<available_skills>\n  <skill>\n    <name>native</name>\n    <description>n</description>\n  </skill>\n</available_skills>",
-        ];
-        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
-        const nativeIndex = system[0].indexOf("<name>native</name>");
-        const tddIndex = system[0].indexOf("<name>tdd</name>");
-        const closeIndex = system[0].indexOf("</available_skills>");
-        expect(nativeIndex).toBeGreaterThan(-1);
-        expect(tddIndex).toBeGreaterThan(nativeIndex);
-        expect(closeIndex).toBeGreaterThan(tddIndex);
-    });
-    it("should push a standalone block when no <available_skills> exists", () => {
-        const system = ["plain prompt", "another segment"];
-        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
-        expect(system).toHaveLength(3);
-        expect(system[2]).toBe(`<available_skills>\n${SAMPLE_ITEMS}\n</available_skills>`);
-    });
-    it("should only inject into the first matching segment", () => {
-        const system = [
-            "<available_skills>\n  <skill>\n    <name>first</name>\n    <description>d</description>\n  </skill>\n</available_skills>",
-            "<available_skills>\n  <skill>\n    <name>second</name>\n    <description>d</description>\n  </skill>\n</available_skills>",
-        ];
-        injectPluginSkillsIntoSystem(system, SAMPLE_ITEMS);
-        expect(system[0]).toContain("<name>tdd</name>");
-        expect(system[1]).not.toContain("<name>tdd</name>");
-    });
-    it("should do nothing when pluginSkillsXmlItems is empty string", () => {
-        const system = ["<available_skills>\n</available_skills>"];
-        const before = [...system];
-        injectPluginSkillsIntoSystem(system, "");
-        expect(system).toEqual(before);
-    });
-});

package/dist/tools/skill.d.ts

@@ -1,34 +0,0 @@
-import { type ToolContext } from "@opencode-ai/plugin";
-import type { createOpencodeClient } from "@opencode-ai/sdk";
-import { type LoadedSkill } from "../loaders";
-type Client = ReturnType<typeof createOpencodeClient>;
-export type SkillScope = "plugin" | "opencode" | "opencode-project" | "claude" | "claude-project";
-export interface SkillInfo {
-    name: string;
-    description: string;
-    location: string;
-    scope: SkillScope;
-}
-export interface DiscoverAllSkillsOptions {
-    pluginSkills: LoadedSkill[];
-    pluginDir: string;
-    cwd: string;
-}
-export declare function discoverAllSkills(options: DiscoverAllSkillsOptions): SkillInfo[];
-export declare function formatPluginSkillsAsXmlItems(skills: LoadedSkill[], pluginDir: string): string;
-export interface CreateSkillToolOptions {
-    pluginSkills: LoadedSkill[];
-    pluginDir: string;
-    cwd: string;
-    client: Client;
-}
-export declare function createSkillTool(options: CreateSkillToolOptions): {
-    description: string;
-    args: {
-        name: import("zod").ZodString;
-    };
-    execute(args: {
-        name: string;
-    }, context: ToolContext): Promise<string>;
-};
-export {};

package/dist/tools/skill.js

@@ -1,137 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { homedir } from "node:os";
-import { parseFrontmatter } from "../loaders";
-import { log } from "../logger";
-const TOOL_DESCRIPTION_PREFIX = `Load a skill to get detailed instructions for a specific task.`;
-const TOOL_DESCRIPTION_NO_SKILLS = `${TOOL_DESCRIPTION_PREFIX} No skills are currently available.`;
-function discoverSkillsFromDir(skillsDir, scope) {
-    if (!existsSync(skillsDir))
-        return [];
-    const skills = [];
-    try {
-        const entries = readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.startsWith("."))
-                continue;
-            if (!entry.isDirectory())
-                continue;
-            const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
-            if (!existsSync(skillMdPath))
-                continue;
-            try {
-                const content = readFileSync(skillMdPath, "utf-8");
-                const { data } = parseFrontmatter(content);
-                if (!data.name || !data.description)
-                    continue;
-                skills.push({
-                    name: data.name,
-                    description: data.description,
-                    location: skillMdPath,
-                    scope,
-                });
-            }
-            catch {
-                // Skip invalid skill files
-            }
-        }
-    }
-    catch {
-        // Directory not accessible
-    }
-    return skills;
-}
-function pluginSkillsToInfo(skills, pluginDir) {
-    return skills.map(s => ({
-        name: s.name,
-        description: s.description,
-        location: s.path || join(pluginDir, "skill", s.name, "SKILL.md"),
-        scope: "plugin",
-    }));
-}
-function formatSkillItems(skills) {
-    return skills
-        .map(skill => [
-        "  <skill>",
-        `    <name>${skill.name}</name>`,
-        `    <description>${skill.description}</description>`,
-        "  </skill>",
-    ].join("\n"))
-        .join("\n");
-}
-function formatSkillsXml(skills) {
-    if (skills.length === 0)
-        return "";
-    return `<available_skills>\n${formatSkillItems(skills)}\n</available_skills>`;
-}
-export function discoverAllSkills(options) {
-    const { pluginSkills, pluginDir, cwd } = options;
-    // Merge order: plugin < claude global < opencode global < claude project < opencode project
-    // Later entries override earlier on name collision (project > global > plugin)
-    const allSkills = [
-        ...pluginSkillsToInfo(pluginSkills, pluginDir),
-        ...discoverSkillsFromDir(join(homedir(), ".claude", "skills"), "claude"),
-        ...discoverSkillsFromDir(join(homedir(), ".config", "opencode", "skills"), "opencode"),
-        ...discoverSkillsFromDir(join(cwd, ".claude", "skills"), "claude-project"),
-        ...discoverSkillsFromDir(join(cwd, ".opencode", "skills"), "opencode-project"),
-    ];
-    const skillMap = new Map();
-    for (const skill of allSkills) {
-        skillMap.set(skill.name, skill);
-    }
-    return Array.from(skillMap.values());
-}
-export function formatPluginSkillsAsXmlItems(skills, pluginDir) {
-    if (skills.length === 0)
-        return "";
-    return formatSkillItems(pluginSkillsToInfo(skills, pluginDir));
-}
-function loadSkillContent(location) {
-    const content = readFileSync(location, "utf-8");
-    const { body } = parseFrontmatter(content);
-    return body.trim();
-}
-export function createSkillTool(options) {
-    const { client, pluginDir, pluginSkills, cwd } = options;
-    const skills = discoverAllSkills({ pluginSkills, pluginDir, cwd });
-    const description = skills.length === 0
-        ? TOOL_DESCRIPTION_NO_SKILLS
-        : `${TOOL_DESCRIPTION_PREFIX}\n\n${formatSkillsXml(skills)}`;
-    return tool({
-        description,
-        args: {
-            name: tool.schema
-                .string()
-                .describe("The skill identifier from available_skills (e.g., 'tdd', 'openspec-propose')"),
-        },
-        async execute(args, _context) {
-            const skill = skills.find(s => s.name === args.name);
-            if (!skill) {
-                const available = skills.map(s => s.name).join(", ");
-                throw new Error(`Skill "${args.name}" not found. Available skills: ${available || "none"}`);
-            }
-            const body = loadSkillContent(skill.location);
-            const dir = dirname(skill.location);
-            try {
-                await client.tui.showToast({
-                    body: {
-                        message: `Skill "${skill.name}" loaded`,
-                        variant: "info",
-                        duration: 3000,
-                    },
-                });
-            }
-            catch (error) {
-                log("[skill] Failed to show toast", { error: String(error) });
-            }
-            return [
-                `## Skill: ${skill.name}`,
-                "",
-                `**Base directory**: ${dir}`,
-                "",
-                body,
-            ].join("\n");
-        },
-    });
-}

package/dist/tools/skill.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/skill.test.js

@@ -1,218 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { discoverAllSkills, formatPluginSkillsAsXmlItems, } from "./skill";
-function createSkillFile(dir, name, content) {
-    const skillDir = join(dir, name);
-    mkdirSync(skillDir, { recursive: true });
-    const skillPath = join(skillDir, "SKILL.md");
-    writeFileSync(skillPath, content);
-    return skillPath;
-}
-describe("formatPluginSkillsAsXmlItems", () => {
-    it("should return empty string for no skills", () => {
-        expect(formatPluginSkillsAsXmlItems([], "/plugin")).toBe("");
-    });
-    it("should format skills without wrapping <available_skills> tags", () => {
-        const skills = [
-            { name: "tdd", description: "Apply TDD", path: "/p/SKILL.md", body: "" },
-        ];
-        const result = formatPluginSkillsAsXmlItems(skills, "/plugin");
-        expect(result).toContain("<skill>");
-        expect(result).toContain("<name>tdd</name>");
-        expect(result).toContain("<description>Apply TDD</description>");
-        expect(result).not.toContain("<available_skills>");
-    });
-    it("should format multiple skills", () => {
-        const skills = [
-            { name: "a", description: "A", path: "/a", body: "" },
-            { name: "b", description: "B", path: "/b", body: "" },
-        ];
-        const result = formatPluginSkillsAsXmlItems(skills, "/plugin");
-        expect(result).toContain("<name>a</name>");
-        expect(result).toContain("<name>b</name>");
-    });
-});
-describe("discoverAllSkills", () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = join(tmpdir(), `skill-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        mkdirSync(testDir, { recursive: true });
-    });
-    afterEach(() => {
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    it("should return empty array when no skills and no plugin skills", () => {
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toEqual([]);
-    });
-    it("should include plugin skills with scope=plugin", () => {
-        const pluginSkills = [
-            { name: "tdd", description: "TDD", path: "/plugin/skill/tdd/SKILL.md", body: "" },
-        ];
-        const result = discoverAllSkills({
-            pluginSkills,
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("tdd");
-        expect(result[0].scope).toBe("plugin");
-    });
-    it("should discover .opencode/skills/ in cwd", () => {
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        mkdirSync(opencodeDir, { recursive: true });
-        createSkillFile(opencodeDir, "project-skill", `---
-name: project-skill
-description: From project
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe("project-skill");
-        expect(result[0].scope).toBe("opencode-project");
-    });
-    it("should discover .claude/skills/ in cwd", () => {
-        const claudeDir = join(testDir, ".claude", "skills");
-        mkdirSync(claudeDir, { recursive: true });
-        createSkillFile(claudeDir, "claude-skill", `---
-name: claude-skill
-description: From claude
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0].scope).toBe("claude-project");
-    });
-    it("should let project skills override plugin skills with same name", () => {
-        const pluginSkills = [
-            { name: "shared", description: "Plugin version", path: "/p", body: "" },
-        ];
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        mkdirSync(opencodeDir, { recursive: true });
-        createSkillFile(opencodeDir, "shared", `---
-name: shared
-description: Project version
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills,
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0].description).toBe("Project version");
-        expect(result[0].scope).toBe("opencode-project");
-    });
-    it("should ignore directories without SKILL.md", () => {
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        const incompleteDir = join(opencodeDir, "no-skill");
-        mkdirSync(incompleteDir, { recursive: true });
-        writeFileSync(join(incompleteDir, "README.md"), "not a skill");
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(0);
-    });
-    it("should ignore skills missing name or description", () => {
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        mkdirSync(opencodeDir, { recursive: true });
-        createSkillFile(opencodeDir, "no-name", `---
-description: no name
----
-Body`);
-        createSkillFile(opencodeDir, "no-desc", `---
-name: no-desc
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(0);
-    });
-    it("should ignore hidden directories", () => {
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        mkdirSync(opencodeDir, { recursive: true });
-        createSkillFile(opencodeDir, ".hidden", `---
-name: hidden
-description: hidden skill
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(0);
-    });
-    it("should let opencode-project override claude-project with same name", () => {
-        const claudeDir = join(testDir, ".claude", "skills");
-        mkdirSync(claudeDir, { recursive: true });
-        createSkillFile(claudeDir, "shared", `---
-name: shared
-description: Claude version
----
-Body`);
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        mkdirSync(opencodeDir, { recursive: true });
-        createSkillFile(opencodeDir, "shared", `---
-name: shared
-description: Opencode version
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills: [],
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0].description).toBe("Opencode version");
-        expect(result[0].scope).toBe("opencode-project");
-    });
-    it("should aggregate multiple sources", () => {
-        const pluginSkills = [
-            { name: "plugin-only", description: "P", path: "/p", body: "" },
-        ];
-        const opencodeDir = join(testDir, ".opencode", "skills");
-        mkdirSync(opencodeDir, { recursive: true });
-        createSkillFile(opencodeDir, "opencode-only", `---
-name: opencode-only
-description: O
----
-Body`);
-        const claudeDir = join(testDir, ".claude", "skills");
-        mkdirSync(claudeDir, { recursive: true });
-        createSkillFile(claudeDir, "claude-only", `---
-name: claude-only
-description: C
----
-Body`);
-        const result = discoverAllSkills({
-            pluginSkills,
-            pluginDir: "/plugin",
-            cwd: testDir,
-        });
-        expect(result).toHaveLength(3);
-        const byName = new Map(result.map((s) => [s.name, s]));
-        expect(byName.get("plugin-only")?.scope).toBe("plugin");
-        expect(byName.get("opencode-only")?.scope).toBe("opencode-project");
-        expect(byName.get("claude-only")?.scope).toBe("claude-project");
-    });
-});