opencode-swarm-plugin 0.22.0 → 0.23.0

package/dist/swarm-orchestrate.d.ts

@@ -0,0 +1,708 @@
+/**
+ * Swarm Orchestrate Module - Status tracking and completion handling
+ *
+ * Handles swarm execution lifecycle:
+ * - Initialization and tool availability
+ * - Status tracking and progress reporting
+ * - Completion verification and gates
+ * - Error accumulation and 3-strike detection
+ * - Learning from outcomes
+ *
+ * Key responsibilities:
+ * - swarm_init - Check tools and discover skills
+ * - swarm_status - Query epic progress
+ * - swarm_progress - Report agent progress
+ * - swarm_complete - Verification gate and completion
+ * - swarm_record_outcome - Learning signals
+ * - swarm_broadcast - Mid-task context sharing
+ * - Error accumulation tools
+ * - 3-strike detection for architectural problems
+ */
+import { z } from "zod";
+/**
+ * Initialize swarm and check tool availability
+ *
+ * Call this at the start of a swarm session to see what tools are available,
+ * what skills exist in the project, and what features will be degraded.
+ *
+ * Skills are automatically discovered from:
+ * - .opencode/skills/
+ * - .claude/skills/
+ * - skills/
+ */
+export declare const swarm_init: {
+    description: string;
+    args: {
+        project_path: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        project_path?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Get status of a swarm by epic ID
+ *
+ * Requires project_key to query Agent Mail for message counts.
+ */
+export declare const swarm_status: {
+    description: string;
+    args: {
+        epic_id: z.ZodString;
+        project_key: z.ZodString;
+    };
+    execute(args: {
+        epic_id: string;
+        project_key: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Report progress on a subtask
+ *
+ * Takes explicit agent identity since tools don't have persistent state.
+ */
+export declare const swarm_progress: {
+    description: string;
+    args: {
+        project_key: z.ZodString;
+        agent_name: z.ZodString;
+        bead_id: z.ZodString;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            blocked: "blocked";
+            failed: "failed";
+            completed: "completed";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+        progress_percent: z.ZodOptional<z.ZodNumber>;
+        files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    };
+    execute(args: {
+        project_key: string;
+        agent_name: string;
+        bead_id: string;
+        status: "in_progress" | "blocked" | "failed" | "completed";
+        message?: string | undefined;
+        progress_percent?: number | undefined;
+        files_touched?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Broadcast context updates to all agents in the epic
+ *
+ * Enables mid-task coordination by sharing discoveries, warnings, or blockers
+ * with all agents working on the same epic. Agents can broadcast without
+ * waiting for task completion.
+ *
+ * Based on "Patterns for Building AI Agents" p.31: "Ensure subagents can share context along the way"
+ */
+export declare const swarm_broadcast: {
+    description: string;
+    args: {
+        project_path: z.ZodString;
+        agent_name: z.ZodString;
+        epic_id: z.ZodString;
+        message: z.ZodString;
+        importance: z.ZodDefault<z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            blocker: "blocker";
+        }>>;
+        files_affected: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    };
+    execute(args: {
+        project_path: string;
+        agent_name: string;
+        epic_id: string;
+        message: string;
+        importance: "info" | "warning" | "blocker";
+        files_affected?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Mark a subtask as complete
+ *
+ * Implements the Verification Gate (from superpowers):
+ * 1. IDENTIFY: What commands prove this claim?
+ * 2. RUN: Execute verification (UBS, typecheck, tests)
+ * 3. READ: Check exit codes and output
+ * 4. VERIFY: All checks must pass
+ * 5. ONLY THEN: Close the bead
+ *
+ * Closes bead, releases reservations, notifies coordinator.
+ */
+export declare const swarm_complete: {
+    description: string;
+    args: {
+        project_key: z.ZodString;
+        agent_name: z.ZodString;
+        bead_id: z.ZodString;
+        summary: z.ZodString;
+        evaluation: z.ZodOptional<z.ZodString>;
+        files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skip_ubs_scan: z.ZodOptional<z.ZodBoolean>;
+        skip_verification: z.ZodOptional<z.ZodBoolean>;
+        planned_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        start_time: z.ZodOptional<z.ZodNumber>;
+        error_count: z.ZodOptional<z.ZodNumber>;
+        retry_count: z.ZodOptional<z.ZodNumber>;
+    };
+    execute(args: {
+        project_key: string;
+        agent_name: string;
+        bead_id: string;
+        summary: string;
+        evaluation?: string | undefined;
+        files_touched?: string[] | undefined;
+        skip_ubs_scan?: boolean | undefined;
+        skip_verification?: boolean | undefined;
+        planned_files?: string[] | undefined;
+        start_time?: number | undefined;
+        error_count?: number | undefined;
+        retry_count?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Record outcome signals from a completed subtask
+ *
+ * Tracks implicit feedback (duration, errors, retries) to score
+ * decomposition quality over time. This data feeds into criterion
+ * weight calculations.
+ *
+ * Strategy tracking enables learning about which decomposition strategies
+ * work best for different task types.
+ *
+ * @see src/learning.ts for scoring logic
+ */
+export declare const swarm_record_outcome: {
+    description: string;
+    args: {
+        bead_id: z.ZodString;
+        duration_ms: z.ZodNumber;
+        error_count: z.ZodDefault<z.ZodNumber>;
+        retry_count: z.ZodDefault<z.ZodNumber>;
+        success: z.ZodBoolean;
+        files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            "file-based": "file-based";
+            "feature-based": "feature-based";
+            "risk-based": "risk-based";
+            "research-based": "research-based";
+        }>>;
+        failure_mode: z.ZodOptional<z.ZodEnum<{
+            timeout: "timeout";
+            unknown: "unknown";
+            conflict: "conflict";
+            validation: "validation";
+            tool_failure: "tool_failure";
+            context_overflow: "context_overflow";
+            dependency_blocked: "dependency_blocked";
+            user_cancelled: "user_cancelled";
+        }>>;
+        failure_details: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        bead_id: string;
+        duration_ms: number;
+        error_count: number;
+        retry_count: number;
+        success: boolean;
+        files_touched?: string[] | undefined;
+        criteria?: string[] | undefined;
+        strategy?: "file-based" | "feature-based" | "risk-based" | "research-based" | undefined;
+        failure_mode?: "timeout" | "unknown" | "conflict" | "validation" | "tool_failure" | "context_overflow" | "dependency_blocked" | "user_cancelled" | undefined;
+        failure_details?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Record an error during subtask execution
+ *
+ * Implements pattern from "Patterns for Building AI Agents" p.40:
+ * "Good agents examine and correct errors when something goes wrong"
+ *
+ * Errors are accumulated and can be fed into retry prompts to help
+ * agents learn from past failures.
+ */
+export declare const swarm_accumulate_error: {
+    description: string;
+    args: {
+        bead_id: z.ZodString;
+        error_type: z.ZodEnum<{
+            timeout: "timeout";
+            unknown: "unknown";
+            conflict: "conflict";
+            validation: "validation";
+            tool_failure: "tool_failure";
+        }>;
+        message: z.ZodString;
+        stack_trace: z.ZodOptional<z.ZodString>;
+        tool_name: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        bead_id: string;
+        error_type: "timeout" | "unknown" | "conflict" | "validation" | "tool_failure";
+        message: string;
+        stack_trace?: string | undefined;
+        tool_name?: string | undefined;
+        context?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Get accumulated errors for a bead to feed into retry prompts
+ *
+ * Returns formatted error context that can be injected into retry prompts
+ * to help agents learn from past failures.
+ */
+export declare const swarm_get_error_context: {
+    description: string;
+    args: {
+        bead_id: z.ZodString;
+        include_resolved: z.ZodOptional<z.ZodBoolean>;
+    };
+    execute(args: {
+        bead_id: string;
+        include_resolved?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Mark an error as resolved
+ *
+ * Call this after an agent successfully addresses an error to update
+ * the accumulator state.
+ */
+export declare const swarm_resolve_error: {
+    description: string;
+    args: {
+        error_id: z.ZodString;
+    };
+    execute(args: {
+        error_id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Check if a bead has struck out (3 consecutive failures)
+ *
+ * The 3-Strike Rule:
+ * IF 3+ fixes have failed:
+ *   STOP → Question the architecture
+ *   DON'T attempt Fix #4
+ *   Discuss with human partner
+ *
+ * This is NOT a failed hypothesis.
+ * This is a WRONG ARCHITECTURE.
+ *
+ * Use this tool to:
+ * - Check strike count before attempting a fix
+ * - Get architecture review prompt if struck out
+ * - Record a strike when a fix fails
+ * - Clear strikes when a fix succeeds
+ */
+export declare const swarm_check_strikes: {
+    description: string;
+    args: {
+        bead_id: z.ZodString;
+        action: z.ZodEnum<{
+            check: "check";
+            add_strike: "add_strike";
+            clear: "clear";
+            get_prompt: "get_prompt";
+        }>;
+        attempt: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        bead_id: string;
+        action: "check" | "add_strike" | "clear" | "get_prompt";
+        attempt?: string | undefined;
+        reason?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Checkpoint swarm context for recovery
+ *
+ * Records the current state of a subtask to enable recovery after crashes,
+ * context overflows, or agent restarts. Non-fatal errors - logs warnings
+ * and continues if checkpoint fails.
+ *
+ * Integration:
+ * - Called automatically by swarm_progress at milestone thresholds (25%, 50%, 75%)
+ * - Can be called manually by agents at critical points
+ * - Emits SwarmCheckpointedEvent for audit trail
+ * - Updates swarm_contexts table for fast recovery queries
+ */
+export declare const swarm_checkpoint: {
+    description: string;
+    args: {
+        project_key: z.ZodString;
+        agent_name: z.ZodString;
+        bead_id: z.ZodString;
+        epic_id: z.ZodString;
+        files_modified: z.ZodArray<z.ZodString>;
+        progress_percent: z.ZodNumber;
+        directives: z.ZodOptional<z.ZodObject<{
+            shared_context: z.ZodOptional<z.ZodString>;
+            skills_to_load: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            coordinator_notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        error_context: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        project_key: string;
+        agent_name: string;
+        bead_id: string;
+        epic_id: string;
+        files_modified: string[];
+        progress_percent: number;
+        directives?: {
+            shared_context?: string | undefined;
+            skills_to_load?: string[] | undefined;
+            coordinator_notes?: string | undefined;
+        } | undefined;
+        error_context?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Recover swarm context from last checkpoint
+ *
+ * Queries swarm_contexts table for the most recent checkpoint of an epic.
+ * Returns the full context including files, progress, and recovery state.
+ * Emits SwarmRecoveredEvent for audit trail.
+ *
+ * Graceful fallback: Returns { found: false } if no checkpoint exists.
+ */
+export declare const swarm_recover: {
+    description: string;
+    args: {
+        project_key: z.ZodString;
+        epic_id: z.ZodString;
+    };
+    execute(args: {
+        project_key: string;
+        epic_id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Learn from completed work and optionally create a skill
+ *
+ * This tool helps agents reflect on patterns, best practices, or domain
+ * knowledge discovered during task execution and codify them into reusable
+ * skills for future swarms.
+ *
+ * Implements the "learning swarm" pattern where swarms get smarter over time.
+ */
+export declare const swarm_learn: {
+    description: string;
+    args: {
+        summary: z.ZodString;
+        pattern_type: z.ZodEnum<{
+            "code-pattern": "code-pattern";
+            "best-practice": "best-practice";
+            gotcha: "gotcha";
+            "tool-usage": "tool-usage";
+            "domain-knowledge": "domain-knowledge";
+            workflow: "workflow";
+        }>;
+        details: z.ZodString;
+        example: z.ZodOptional<z.ZodString>;
+        when_to_use: z.ZodString;
+        files_context: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        create_skill: z.ZodOptional<z.ZodBoolean>;
+        skill_name: z.ZodOptional<z.ZodString>;
+        skill_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    };
+    execute(args: {
+        summary: string;
+        pattern_type: "code-pattern" | "best-practice" | "gotcha" | "tool-usage" | "domain-knowledge" | "workflow";
+        details: string;
+        when_to_use: string;
+        example?: string | undefined;
+        files_context?: string[] | undefined;
+        create_skill?: boolean | undefined;
+        skill_name?: string | undefined;
+        skill_tags?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const orchestrateTools: {
+    swarm_init: {
+        description: string;
+        args: {
+            project_path: z.ZodOptional<z.ZodString>;
+        };
+        execute(args: {
+            project_path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_status: {
+        description: string;
+        args: {
+            epic_id: z.ZodString;
+            project_key: z.ZodString;
+        };
+        execute(args: {
+            epic_id: string;
+            project_key: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_progress: {
+        description: string;
+        args: {
+            project_key: z.ZodString;
+            agent_name: z.ZodString;
+            bead_id: z.ZodString;
+            status: z.ZodEnum<{
+                in_progress: "in_progress";
+                blocked: "blocked";
+                failed: "failed";
+                completed: "completed";
+            }>;
+            message: z.ZodOptional<z.ZodString>;
+            progress_percent: z.ZodOptional<z.ZodNumber>;
+            files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        };
+        execute(args: {
+            project_key: string;
+            agent_name: string;
+            bead_id: string;
+            status: "in_progress" | "blocked" | "failed" | "completed";
+            message?: string | undefined;
+            progress_percent?: number | undefined;
+            files_touched?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_broadcast: {
+        description: string;
+        args: {
+            project_path: z.ZodString;
+            agent_name: z.ZodString;
+            epic_id: z.ZodString;
+            message: z.ZodString;
+            importance: z.ZodDefault<z.ZodEnum<{
+                info: "info";
+                warning: "warning";
+                blocker: "blocker";
+            }>>;
+            files_affected: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        };
+        execute(args: {
+            project_path: string;
+            agent_name: string;
+            epic_id: string;
+            message: string;
+            importance: "info" | "warning" | "blocker";
+            files_affected?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_complete: {
+        description: string;
+        args: {
+            project_key: z.ZodString;
+            agent_name: z.ZodString;
+            bead_id: z.ZodString;
+            summary: z.ZodString;
+            evaluation: z.ZodOptional<z.ZodString>;
+            files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            skip_ubs_scan: z.ZodOptional<z.ZodBoolean>;
+            skip_verification: z.ZodOptional<z.ZodBoolean>;
+            planned_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            start_time: z.ZodOptional<z.ZodNumber>;
+            error_count: z.ZodOptional<z.ZodNumber>;
+            retry_count: z.ZodOptional<z.ZodNumber>;
+        };
+        execute(args: {
+            project_key: string;
+            agent_name: string;
+            bead_id: string;
+            summary: string;
+            evaluation?: string | undefined;
+            files_touched?: string[] | undefined;
+            skip_ubs_scan?: boolean | undefined;
+            skip_verification?: boolean | undefined;
+            planned_files?: string[] | undefined;
+            start_time?: number | undefined;
+            error_count?: number | undefined;
+            retry_count?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_record_outcome: {
+        description: string;
+        args: {
+            bead_id: z.ZodString;
+            duration_ms: z.ZodNumber;
+            error_count: z.ZodDefault<z.ZodNumber>;
+            retry_count: z.ZodDefault<z.ZodNumber>;
+            success: z.ZodBoolean;
+            files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            strategy: z.ZodOptional<z.ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                "research-based": "research-based";
+            }>>;
+            failure_mode: z.ZodOptional<z.ZodEnum<{
+                timeout: "timeout";
+                unknown: "unknown";
+                conflict: "conflict";
+                validation: "validation";
+                tool_failure: "tool_failure";
+                context_overflow: "context_overflow";
+                dependency_blocked: "dependency_blocked";
+                user_cancelled: "user_cancelled";
+            }>>;
+            failure_details: z.ZodOptional<z.ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            duration_ms: number;
+            error_count: number;
+            retry_count: number;
+            success: boolean;
+            files_touched?: string[] | undefined;
+            criteria?: string[] | undefined;
+            strategy?: "file-based" | "feature-based" | "risk-based" | "research-based" | undefined;
+            failure_mode?: "timeout" | "unknown" | "conflict" | "validation" | "tool_failure" | "context_overflow" | "dependency_blocked" | "user_cancelled" | undefined;
+            failure_details?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_accumulate_error: {
+        description: string;
+        args: {
+            bead_id: z.ZodString;
+            error_type: z.ZodEnum<{
+                timeout: "timeout";
+                unknown: "unknown";
+                conflict: "conflict";
+                validation: "validation";
+                tool_failure: "tool_failure";
+            }>;
+            message: z.ZodString;
+            stack_trace: z.ZodOptional<z.ZodString>;
+            tool_name: z.ZodOptional<z.ZodString>;
+            context: z.ZodOptional<z.ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            error_type: "timeout" | "unknown" | "conflict" | "validation" | "tool_failure";
+            message: string;
+            stack_trace?: string | undefined;
+            tool_name?: string | undefined;
+            context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_get_error_context: {
+        description: string;
+        args: {
+            bead_id: z.ZodString;
+            include_resolved: z.ZodOptional<z.ZodBoolean>;
+        };
+        execute(args: {
+            bead_id: string;
+            include_resolved?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_resolve_error: {
+        description: string;
+        args: {
+            error_id: z.ZodString;
+        };
+        execute(args: {
+            error_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_check_strikes: {
+        description: string;
+        args: {
+            bead_id: z.ZodString;
+            action: z.ZodEnum<{
+                check: "check";
+                add_strike: "add_strike";
+                clear: "clear";
+                get_prompt: "get_prompt";
+            }>;
+            attempt: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            action: "check" | "add_strike" | "clear" | "get_prompt";
+            attempt?: string | undefined;
+            reason?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_checkpoint: {
+        description: string;
+        args: {
+            project_key: z.ZodString;
+            agent_name: z.ZodString;
+            bead_id: z.ZodString;
+            epic_id: z.ZodString;
+            files_modified: z.ZodArray<z.ZodString>;
+            progress_percent: z.ZodNumber;
+            directives: z.ZodOptional<z.ZodObject<{
+                shared_context: z.ZodOptional<z.ZodString>;
+                skills_to_load: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                coordinator_notes: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            error_context: z.ZodOptional<z.ZodString>;
+        };
+        execute(args: {
+            project_key: string;
+            agent_name: string;
+            bead_id: string;
+            epic_id: string;
+            files_modified: string[];
+            progress_percent: number;
+            directives?: {
+                shared_context?: string | undefined;
+                skills_to_load?: string[] | undefined;
+                coordinator_notes?: string | undefined;
+            } | undefined;
+            error_context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_recover: {
+        description: string;
+        args: {
+            project_key: z.ZodString;
+            epic_id: z.ZodString;
+        };
+        execute(args: {
+            project_key: string;
+            epic_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_learn: {
+        description: string;
+        args: {
+            summary: z.ZodString;
+            pattern_type: z.ZodEnum<{
+                "code-pattern": "code-pattern";
+                "best-practice": "best-practice";
+                gotcha: "gotcha";
+                "tool-usage": "tool-usage";
+                "domain-knowledge": "domain-knowledge";
+                workflow: "workflow";
+            }>;
+            details: z.ZodString;
+            example: z.ZodOptional<z.ZodString>;
+            when_to_use: z.ZodString;
+            files_context: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            create_skill: z.ZodOptional<z.ZodBoolean>;
+            skill_name: z.ZodOptional<z.ZodString>;
+            skill_tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        };
+        execute(args: {
+            summary: string;
+            pattern_type: "code-pattern" | "best-practice" | "gotcha" | "tool-usage" | "domain-knowledge" | "workflow";
+            details: string;
+            when_to_use: string;
+            example?: string | undefined;
+            files_context?: string[] | undefined;
+            create_skill?: boolean | undefined;
+            skill_name?: string | undefined;
+            skill_tags?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=swarm-orchestrate.d.ts.map