opencode-swarm-plugin 0.56.0 → 0.57.0

package/claude-plugin/dist/schemas/worker-handoff.d.ts

@@ -0,0 +1,78 @@
+/**
+ * WorkerHandoff schemas - structured contracts replacing prose instructions
+ *
+ * Replaces the 400-line SUBTASK_PROMPT_V2 with machine-readable contracts.
+ * Workers receive typed handoffs with explicit files, criteria, and escalation paths.
+ */
+import { z } from "zod";
+/**
+ * Contract section - the binding agreement between coordinator and worker
+ *
+ * Defines:
+ * - What task to complete (task_id)
+ * - What files to modify (files_owned) vs read (files_readonly)
+ * - What's already done (dependencies_completed)
+ * - How to know you're done (success_criteria)
+ */
+export declare const WorkerHandoffContractSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    files_owned: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    files_readonly: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependencies_completed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    success_criteria: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type WorkerHandoffContract = z.infer<typeof WorkerHandoffContractSchema>;
+/**
+ * Context section - the narrative explaining the "why"
+ *
+ * Provides:
+ * - Big picture (epic_summary)
+ * - This worker's specific role
+ * - What's already been done
+ * - What comes after
+ */
+export declare const WorkerHandoffContextSchema: z.ZodObject<{
+    epic_summary: z.ZodString;
+    your_role: z.ZodString;
+    what_others_did: z.ZodString;
+    what_comes_next: z.ZodString;
+}, z.core.$strip>;
+export type WorkerHandoffContext = z.infer<typeof WorkerHandoffContextSchema>;
+/**
+ * Escalation section - what to do when things go wrong
+ *
+ * Defines:
+ * - How to report blockers
+ * - Protocol for scope changes
+ */
+export declare const WorkerHandoffEscalationSchema: z.ZodObject<{
+    blocked_contact: z.ZodString;
+    scope_change_protocol: z.ZodString;
+}, z.core.$strip>;
+export type WorkerHandoffEscalation = z.infer<typeof WorkerHandoffEscalationSchema>;
+/**
+ * Complete WorkerHandoff - combines all three sections
+ *
+ * This is the full structured contract that replaces prose instructions.
+ */
+export declare const WorkerHandoffSchema: z.ZodObject<{
+    contract: z.ZodObject<{
+        task_id: z.ZodString;
+        files_owned: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        files_readonly: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dependencies_completed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        success_criteria: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        epic_summary: z.ZodString;
+        your_role: z.ZodString;
+        what_others_did: z.ZodString;
+        what_comes_next: z.ZodString;
+    }, z.core.$strip>;
+    escalation: z.ZodObject<{
+        blocked_contact: z.ZodString;
+        scope_change_protocol: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type WorkerHandoff = z.infer<typeof WorkerHandoffSchema>;
+//# sourceMappingURL=worker-handoff.d.ts.map

package/claude-plugin/dist/schemas/worker-handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-handoff.d.ts","sourceRoot":"","sources":["../../src/schemas/worker-handoff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B;;;;;;iBAwCtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B;;;;;iBAwBrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;;iBAYxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;iBAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/claude-plugin/dist/sessions/agent-discovery.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Agent Discovery Module
+ *
+ * Maps file paths to agent types using pattern matching.
+ * Supports cross-platform paths (Unix and Windows).
+ *
+ * @module sessions/agent-discovery
+ */
+/**
+ * Agent type identifier
+ */
+export type AgentType = "opencode-swarm" | "cursor" | "opencode" | "claude" | "aider";
+/**
+ * Configuration for custom agent patterns
+ */
+interface AgentPatternConfig {
+    /** Pattern string (will be converted to RegExp) */
+    pattern: string;
+    /** Agent type identifier */
+    agentType: AgentType;
+}
+/**
+ * Load custom agent patterns from config
+ *
+ * @param patterns - Array of custom pattern configurations
+ * @returns Number of patterns loaded
+ *
+ * @example
+ * ```typescript
+ * loadAgentPatterns([
+ *   { pattern: "\\.codex[/\\\\]", agentType: "codex" },
+ *   { pattern: "\\.gemini[/\\\\]", agentType: "gemini" }
+ * ]);
+ * ```
+ */
+export declare function loadAgentPatterns(patterns: AgentPatternConfig[]): number;
+/**
+ * Reset agent patterns to defaults
+ * Useful for testing
+ */
+export declare function resetAgentPatterns(): void;
+/**
+ * Detect agent type from file path
+ *
+ * @param filePath - Absolute or relative file path (Unix or Windows)
+ * @returns Agent type identifier, or null if unknown
+ *
+ * @example
+ * ```typescript
+ * detectAgentType("/home/user/.config/swarm-tools/sessions/ses_123.jsonl")
+ * // => "opencode-swarm"
+ *
+ * detectAgentType("/tmp/random.jsonl")
+ * // => null
+ * ```
+ */
+export declare function detectAgentType(filePath: string): AgentType | null;
+export {};
+//# sourceMappingURL=agent-discovery.d.ts.map

package/claude-plugin/dist/sessions/agent-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-discovery.d.ts","sourceRoot":"","sources":["../../src/sessions/agent-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,gBAAgB,GAChB,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,OAAO,CAAC;AA0BZ;;GAEG;AACH,UAAU,kBAAkB;IAC1B,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAMxE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAQzC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAOlE"}

package/claude-plugin/dist/sessions/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Session Indexing Module
+ *
+ * Provides agent session discovery and indexing capabilities.
+ * Part of the CASS Inhousing initiative (ADR-010).
+ *
+ * @module sessions
+ */
+export { detectAgentType, loadAgentPatterns, resetAgentPatterns, type AgentType, } from "./agent-discovery";
+//# sourceMappingURL=index.d.ts.map

package/claude-plugin/dist/sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sessions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,SAAS,GACf,MAAM,mBAAmB,CAAC"}

package/claude-plugin/dist/skills.d.ts

@@ -0,0 +1,490 @@
+/**
+ * Skills Module for OpenCode
+ *
+ * Implements Anthropic's Agent Skills specification for OpenCode.
+ * Skills are markdown files with YAML frontmatter that provide
+ * domain-specific instructions the model can activate when relevant.
+ *
+ * Discovery locations (in priority order):
+ * 1. {projectDir}/.opencode/skills/
+ * 2. {projectDir}/.claude/skills/ (compatibility)
+ * 3. {projectDir}/skills/ (simple projects)
+ *
+ * Skill format:
+ * ```markdown
+ * ---
+ * name: my-skill
+ * description: What it does. Use when X.
+ * ---
+ *
+ * # Skill Instructions
+ * ...
+ * ```
+ *
+ * @module skills
+ */
+/**
+ * Skill metadata from YAML frontmatter
+ */
+export interface SkillMetadata {
+    /** Unique skill identifier (lowercase, hyphens) */
+    name: string;
+    /** Description of what the skill does and when to use it */
+    description: string;
+    /** Optional list of tools this skill works with */
+    tools?: string[];
+    /** Optional tags for categorization */
+    tags?: string[];
+}
+/**
+ * Full skill definition including content
+ */
+export interface Skill {
+    /** Parsed frontmatter metadata */
+    metadata: SkillMetadata;
+    /** Raw markdown body (instructions) */
+    body: string;
+    /** Absolute path to the SKILL.md file */
+    path: string;
+    /** Directory containing the skill */
+    directory: string;
+    /** Whether this skill has executable scripts */
+    hasScripts: boolean;
+    /** List of script files in the skill directory */
+    scripts: string[];
+}
+/**
+ * Lightweight skill reference for listing
+ */
+export interface SkillRef {
+    name: string;
+    description: string;
+    path: string;
+    hasScripts: boolean;
+}
+/**
+ * Role types for always-on guidance injection.
+ */
+export type AlwaysOnGuidanceRole = "coordinator" | "worker";
+/**
+ * Options for always-on guidance skill rendering.
+ */
+export interface AlwaysOnGuidanceOptions {
+    role: AlwaysOnGuidanceRole;
+    model?: string;
+}
+/**
+ * Get the always-on guidance skill content for a role and model.
+ */
+export declare function getAlwaysOnGuidanceSkill(options: AlwaysOnGuidanceOptions): string;
+/**
+ * Set the project directory for skill discovery
+ */
+export declare function setSkillsProjectDirectory(dir: string): void;
+/**
+ * Parse YAML frontmatter from markdown content using gray-matter
+ *
+ * Handles the common frontmatter format:
+ * ```
+ * ---
+ * key: value
+ * ---
+ * body content
+ * ```
+ */
+export declare function parseFrontmatter(content: string): {
+    metadata: Record<string, unknown>;
+    body: string;
+};
+/**
+ * Discover all skills in the project and global directories
+ *
+ * Priority order (first match wins):
+ * 1. Project: .opencode/skills/
+ * 2. Project: .claude/skills/
+ * 3. Project: skills/
+ * 4. Global: ~/.config/opencode/skills/
+ * 5. Global: ~/.claude/skills/
+ */
+export declare function discoverSkills(projectDir?: string): Promise<Map<string, Skill>>;
+/**
+ * Get a single skill by name
+ */
+export declare function getSkill(name: string): Promise<Skill | null>;
+/**
+ * List all available skills (lightweight refs only)
+ */
+export declare function listSkills(): Promise<SkillRef[]>;
+/**
+ * Invalidate the skills cache (call when skills may have changed)
+ */
+export declare function invalidateSkillsCache(): void;
+/**
+ * List available skills with metadata
+ *
+ * Returns lightweight skill references for the model to evaluate
+ * which skills are relevant to the current task.
+ */
+export declare const skills_list: {
+    description: string;
+    args: {
+        tag: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        tag?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Load and activate a skill by name
+ *
+ * Loads the full skill content for injection into context.
+ * The skill's instructions become available for the model to follow.
+ */
+export declare const skills_use: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        include_scripts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        name: string;
+        include_scripts?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Execute a script from a skill
+ *
+ * Skills can include helper scripts in their scripts/ directory.
+ * This tool runs them with appropriate context.
+ */
+export declare const skills_execute: {
+    description: string;
+    args: {
+        skill: import("zod").ZodString;
+        script: import("zod").ZodString;
+        args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    };
+    execute(args: {
+        skill: string;
+        script: string;
+        args?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Read a resource file from a skill directory
+ *
+ * Skills can include additional resources like examples, templates, or reference docs.
+ */
+export declare const skills_read: {
+    description: string;
+    args: {
+        skill: import("zod").ZodString;
+        file: import("zod").ZodString;
+    };
+    execute(args: {
+        skill: string;
+        file: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * CSO validation warnings for skill metadata
+ */
+export interface CSOValidationWarnings {
+    /** Critical warnings (strong indicators of poor discoverability) */
+    critical: string[];
+    /** Suggestions for improvement */
+    suggestions: string[];
+}
+/**
+ * Validate skill metadata against Claude Search Optimization best practices
+ *
+ * Checks:
+ * - 'Use when...' format in description
+ * - Description length (warn > 500, max 1024)
+ * - Third-person voice (no 'I', 'you')
+ * - Name conventions (verb-first, gerunds, hyphens)
+ *
+ * @returns Warnings object with critical issues and suggestions
+ */
+export declare function validateCSOCompliance(name: string, description: string): CSOValidationWarnings;
+/**
+ * Create a new skill in the project
+ *
+ * Agents can use this to codify learned patterns, best practices,
+ * or domain-specific knowledge into reusable skills.
+ */
+export declare const skills_create: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        description: import("zod").ZodString;
+        body: import("zod").ZodString;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+            global: "global";
+            ".opencode/skill": ".opencode/skill";
+            ".claude/skills": ".claude/skills";
+            skill: "skill";
+            "global-claude": "global-claude";
+        }>>;
+    };
+    execute(args: {
+        name: string;
+        description: string;
+        body: string;
+        tags?: string[] | undefined;
+        tools?: string[] | undefined;
+        directory?: "global" | ".opencode/skill" | ".claude/skills" | "skill" | "global-claude" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Update an existing skill
+ *
+ * Modify a skill's metadata or content based on learned improvements.
+ */
+export declare const skills_update: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        content: import("zod").ZodOptional<import("zod").ZodString>;
+        body: import("zod").ZodOptional<import("zod").ZodString>;
+        append_body: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        add_tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    };
+    execute(args: {
+        name: string;
+        description?: string | undefined;
+        content?: string | undefined;
+        body?: string | undefined;
+        append_body?: string | undefined;
+        tags?: string[] | undefined;
+        add_tags?: string[] | undefined;
+        tools?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Delete a skill from the project
+ */
+export declare const skills_delete: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        confirm: import("zod").ZodBoolean;
+    };
+    execute(args: {
+        name: string;
+        confirm: boolean;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Add a script to a skill
+ *
+ * Skills can include helper scripts for automation.
+ */
+export declare const skills_add_script: {
+    description: string;
+    args: {
+        skill: import("zod").ZodString;
+        script_name: import("zod").ZodString;
+        content: import("zod").ZodString;
+        executable: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        skill: string;
+        script_name: string;
+        content: string;
+        executable: boolean;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Initialize a new skill with full directory structure
+ *
+ * Creates a skill template following best practices from the
+ * Anthropic Agent Skills specification and community patterns.
+ */
+export declare const skills_init: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+            global: "global";
+            ".claude/skills": ".claude/skills";
+            skills: "skills";
+            ".opencode/skills": ".opencode/skills";
+        }>>;
+        include_example_script: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        include_reference: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        name: string;
+        include_example_script: boolean;
+        include_reference: boolean;
+        description?: string | undefined;
+        directory?: "global" | ".claude/skills" | "skills" | ".opencode/skills" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * All skills tools for plugin registration
+ */
+export declare const skillsTools: {
+    skills_list: {
+        description: string;
+        args: {
+            tag: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            tag?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_use: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            include_scripts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            name: string;
+            include_scripts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_execute: {
+        description: string;
+        args: {
+            skill: import("zod").ZodString;
+            script: import("zod").ZodString;
+            args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            skill: string;
+            script: string;
+            args?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_read: {
+        description: string;
+        args: {
+            skill: import("zod").ZodString;
+            file: import("zod").ZodString;
+        };
+        execute(args: {
+            skill: string;
+            file: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_create: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            body: import("zod").ZodString;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+                global: "global";
+                ".opencode/skill": ".opencode/skill";
+                ".claude/skills": ".claude/skills";
+                skill: "skill";
+                "global-claude": "global-claude";
+            }>>;
+        };
+        execute(args: {
+            name: string;
+            description: string;
+            body: string;
+            tags?: string[] | undefined;
+            tools?: string[] | undefined;
+            directory?: "global" | ".opencode/skill" | ".claude/skills" | "skill" | "global-claude" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_update: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            content: import("zod").ZodOptional<import("zod").ZodString>;
+            body: import("zod").ZodOptional<import("zod").ZodString>;
+            append_body: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            add_tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            name: string;
+            description?: string | undefined;
+            content?: string | undefined;
+            body?: string | undefined;
+            append_body?: string | undefined;
+            tags?: string[] | undefined;
+            add_tags?: string[] | undefined;
+            tools?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_delete: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            confirm: import("zod").ZodBoolean;
+        };
+        execute(args: {
+            name: string;
+            confirm: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_add_script: {
+        description: string;
+        args: {
+            skill: import("zod").ZodString;
+            script_name: import("zod").ZodString;
+            content: import("zod").ZodString;
+            executable: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            skill: string;
+            script_name: string;
+            content: string;
+            executable: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_init: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+                global: "global";
+                ".claude/skills": ".claude/skills";
+                skills: "skills";
+                ".opencode/skills": ".opencode/skills";
+            }>>;
+            include_example_script: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            include_reference: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            name: string;
+            include_example_script: boolean;
+            include_reference: boolean;
+            description?: string | undefined;
+            directory?: "global" | ".claude/skills" | "skills" | ".opencode/skills" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+/**
+ * Get skill context for swarm task decomposition
+ *
+ * Returns a summary of available skills that can be referenced
+ * in subtask prompts for specialized handling.
+ */
+export declare function getSkillsContextForSwarm(): Promise<string>;
+/**
+ * Find skills relevant to a task description
+ *
+ * Simple keyword matching to suggest skills for a task.
+ * Returns skill names that may be relevant.
+ */
+export declare function findRelevantSkills(taskDescription: string): Promise<string[]>;
+//# sourceMappingURL=skills.d.ts.map

package/claude-plugin/dist/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../src/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAqBH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,kCAAkC;IAClC,QAAQ,EAAE,aAAa,CAAC;IACxB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,UAAU,EAAE,OAAO,CAAC;IACpB,kDAAkD;IAClD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB;AAMD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,QAAQ,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA8DD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,uBAAuB,GAC/B,MAAM,CAoBR;AAgED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAG3D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG;IACjD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd,CAQA;AAoKD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAuD7B;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAGlE;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAQtD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAMD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;CA0CtB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;CAqDrB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;CAyEzB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CAuDtB,CAAC;AAeH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,kCAAkC;IAClC,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA2FvB;AAwGD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;CA0HxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;CAyGxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CA4CxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;CAqE5B,CAAC;AAiGH;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;CAuJtB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUvB,CAAC;AAMF;;;;;GAKG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,CAAC,CAoBhE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,EAAE,CAAC,CA2BnB"}