opencode-swarm-plugin 0.22.0 → 0.23.0

package/dist/index.d.ts

@@ -0,0 +1,1299 @@
+/**
+ * OpenCode Swarm Plugin
+ *
+ * A type-safe plugin for multi-agent coordination with beads issue tracking
+ * and Agent Mail integration. Provides structured tools for swarm operations.
+ *
+ * @module opencode-swarm-plugin
+ *
+ * @example
+ * ```typescript
+ * // In opencode.jsonc
+ * {
+ *   "plugins": ["opencode-swarm-plugin"]
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Programmatic usage
+ * import { beadsTools, agentMailTools, swarmMailTools } from "opencode-swarm-plugin"
+ * ```
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode Swarm Plugin
+ *
+ * Registers all swarm coordination tools:
+ * - beads:* - Type-safe beads issue tracker wrappers
+ * - agent-mail:* - Multi-agent coordination via Agent Mail MCP (legacy)
+ * - swarm-mail:* - Multi-agent coordination with embedded event sourcing (recommended)
+ * - structured:* - Structured output parsing and validation
+ * - swarm:* - Swarm orchestration and task decomposition
+ * - repo-crawl:* - GitHub API tools for repository research
+ * - skills:* - Agent skills discovery, activation, and execution
+ * - mandate:* - Agent voting system for collaborative knowledge curation
+ *
+ * @param input - Plugin context from OpenCode
+ * @returns Plugin hooks including tools, events, and tool execution hooks
+ */
+export declare const SwarmPlugin: Plugin;
+/**
+ * Default export for OpenCode plugin loading
+ *
+ * OpenCode loads plugins by their default export, so this allows:
+ * ```json
+ * { "plugins": ["opencode-swarm-plugin"] }
+ * ```
+ */
+export default SwarmPlugin;
+/**
+ * Re-export all schemas for type-safe usage
+ */
+export * from "./schemas";
+/**
+ * Re-export beads module
+ *
+ * Includes:
+ * - beadsTools - All bead tool definitions
+ * - Individual tool exports (beads_create, beads_query, etc.)
+ * - BeadError, BeadValidationError - Error classes
+ */
+export * from "./beads";
+/**
+ * Re-export agent-mail module (legacy MCP-based)
+ *
+ * Includes:
+ * - agentMailTools - All agent mail tool definitions
+ * - AgentMailError, FileReservationConflictError - Error classes
+ * - AgentMailState - Session state type
+ *
+ * NOTE: For OpenCode plugin usage, import from "opencode-swarm-plugin/plugin" instead
+ * to avoid the plugin loader trying to call these classes as functions.
+ *
+ * DEPRECATED: Use swarm-mail module instead for embedded event-sourced implementation.
+ */
+export { agentMailTools, AgentMailError, AgentMailNotInitializedError, FileReservationConflictError, createAgentMailError, setAgentMailProjectDirectory, getAgentMailProjectDirectory, mcpCallWithAutoInit, isProjectNotFoundError, isAgentNotFoundError, type AgentMailState, } from "./agent-mail";
+/**
+ * Re-export swarm-mail module (embedded event-sourced)
+ *
+ * Includes:
+ * - swarmMailTools - All swarm mail tool definitions
+ * - setSwarmMailProjectDirectory, getSwarmMailProjectDirectory - Directory management
+ * - clearSessionState - Session cleanup
+ * - SwarmMailState - Session state type
+ *
+ * Features:
+ * - Embedded PGLite storage (no external server dependency)
+ * - Event sourcing for full audit trail
+ * - Offset-based resumability
+ * - Materialized views for fast queries
+ * - File reservation with conflict detection
+ */
+export { swarmMailTools, setSwarmMailProjectDirectory, getSwarmMailProjectDirectory, clearSessionState, type SwarmMailState, } from "./swarm-mail";
+/**
+ * Re-export shared types from swarm-mail package
+ *
+ * Includes:
+ * - MailSessionState - Shared session state type for Agent Mail and Swarm Mail
+ */
+export { type MailSessionState } from "swarm-mail";
+/**
+ * Re-export structured module
+ *
+ * Includes:
+ * - structuredTools - Structured output parsing tools
+ * - Utility functions for JSON extraction
+ */
+export { structuredTools, extractJsonFromText, formatZodErrors, getSchemaByName, } from "./structured";
+/**
+ * Re-export swarm module
+ *
+ * Includes:
+ * - swarmTools - Swarm orchestration tools
+ * - SwarmError, DecompositionError - Error classes
+ * - formatSubtaskPrompt, formatEvaluationPrompt - Prompt helpers
+ * - selectStrategy, formatStrategyGuidelines - Strategy selection helpers
+ * - STRATEGIES - Strategy definitions
+ *
+ * Types:
+ * - DecompositionStrategy - Strategy type union
+ * - StrategyDefinition - Strategy definition interface
+ *
+ * NOTE: Prompt template strings (DECOMPOSITION_PROMPT, etc.) are NOT exported
+ * to avoid confusing the plugin loader which tries to call all exports as functions
+ */
+export { swarmTools, SwarmError, DecompositionError, formatSubtaskPrompt, formatSubtaskPromptV2, formatEvaluationPrompt, SUBTASK_PROMPT_V2, STRATEGIES, selectStrategy, formatStrategyGuidelines, type DecompositionStrategy, type StrategyDefinition, } from "./swarm";
+/**
+ * All tools in a single registry for CLI tool execution
+ *
+ * This is used by `swarm tool <name>` command to dynamically execute tools.
+ * Each tool has an `execute` function that takes (args, ctx) and returns a string.
+ */
+export declare const allTools: {
+    readonly mandate_file: {
+        description: string;
+        args: {
+            content: import("zod").ZodString;
+            content_type: import("zod").ZodEnum<{
+                idea: "idea";
+                tip: "tip";
+                lore: "lore";
+                snippet: "snippet";
+                feature_request: "feature_request";
+            }>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        };
+        execute(args: {
+            content: string;
+            content_type: "idea" | "tip" | "lore" | "snippet" | "feature_request";
+            tags?: string[] | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly mandate_vote: {
+        description: string;
+        args: {
+            mandate_id: import("zod").ZodString;
+            vote_type: import("zod").ZodEnum<{
+                upvote: "upvote";
+                downvote: "downvote";
+            }>;
+            agent_name: import("zod").ZodString;
+        };
+        execute(args: {
+            mandate_id: string;
+            vote_type: "upvote" | "downvote";
+            agent_name: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly mandate_query: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                candidate: "candidate";
+                established: "established";
+                mandate: "mandate";
+                rejected: "rejected";
+            }>>;
+            content_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                idea: "idea";
+                tip: "tip";
+                lore: "lore";
+                snippet: "snippet";
+                feature_request: "feature_request";
+            }>>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            status?: "candidate" | "established" | "mandate" | "rejected" | undefined;
+            content_type?: "idea" | "tip" | "lore" | "snippet" | "feature_request" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly mandate_list: {
+        description: string;
+        args: {
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                candidate: "candidate";
+                established: "established";
+                mandate: "mandate";
+                rejected: "rejected";
+            }>>;
+            content_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                idea: "idea";
+                tip: "tip";
+                lore: "lore";
+                snippet: "snippet";
+                feature_request: "feature_request";
+            }>>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            status?: "candidate" | "established" | "mandate" | "rejected" | undefined;
+            content_type?: "idea" | "tip" | "lore" | "snippet" | "feature_request" | undefined;
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly mandate_stats: {
+        description: string;
+        args: {
+            mandate_id: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            mandate_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly 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>;
+    };
+    readonly 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>;
+    };
+    readonly 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>;
+    };
+    readonly 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>;
+    };
+    readonly 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<{
+                ".opencode/skills": ".opencode/skills";
+                ".claude/skills": ".claude/skills";
+                skills: "skills";
+                global: "global";
+                "global-claude": "global-claude";
+            }>>;
+        };
+        execute(args: {
+            name: string;
+            description: string;
+            body: string;
+            tags?: string[] | undefined;
+            tools?: string[] | undefined;
+            directory?: ".opencode/skills" | ".claude/skills" | "skills" | "global" | "global-claude" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly skills_update: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: 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;
+            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>;
+    };
+    readonly 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>;
+    };
+    readonly 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>;
+    };
+    readonly skills_init: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+                ".opencode/skills": ".opencode/skills";
+                ".claude/skills": ".claude/skills";
+                skills: "skills";
+                global: "global";
+            }>>;
+            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?: ".opencode/skills" | ".claude/skills" | "skills" | "global" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly repo_readme: {
+        description: string;
+        args: {
+            repo: import("zod").ZodString;
+            maxLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            repo: string;
+            maxLength?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly repo_structure: {
+        description: string;
+        args: {
+            repo: import("zod").ZodString;
+            depth: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            repo: string;
+            depth?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly repo_tree: {
+        description: string;
+        args: {
+            repo: import("zod").ZodString;
+            path: import("zod").ZodOptional<import("zod").ZodString>;
+            maxDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            repo: string;
+            path?: string | undefined;
+            maxDepth?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly repo_file: {
+        description: string;
+        args: {
+            repo: import("zod").ZodString;
+            path: import("zod").ZodString;
+            maxLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            repo: string;
+            path: string;
+            maxLength?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly repo_search: {
+        description: string;
+        args: {
+            repo: import("zod").ZodString;
+            query: import("zod").ZodString;
+            maxResults: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            repo: string;
+            query: string;
+            maxResults?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_init: {
+        description: string;
+        args: {
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            project_path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_status: {
+        description: string;
+        args: {
+            epic_id: import("zod").ZodString;
+            project_key: import("zod").ZodString;
+        };
+        execute(args: {
+            epic_id: string;
+            project_key: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_progress: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            status: import("zod").ZodEnum<{
+                in_progress: "in_progress";
+                blocked: "blocked";
+                failed: "failed";
+                completed: "completed";
+            }>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            progress_percent: import("zod").ZodOptional<import("zod").ZodNumber>;
+            files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").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>;
+    };
+    readonly swarm_broadcast: {
+        description: string;
+        args: {
+            project_path: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            message: import("zod").ZodString;
+            importance: import("zod").ZodDefault<import("zod").ZodEnum<{
+                info: "info";
+                warning: "warning";
+                blocker: "blocker";
+            }>>;
+            files_affected: import("zod").ZodOptional<import("zod").ZodArray<import("zod").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>;
+    };
+    readonly swarm_complete: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            summary: import("zod").ZodString;
+            evaluation: import("zod").ZodOptional<import("zod").ZodString>;
+            files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            skip_ubs_scan: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            skip_verification: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            planned_files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            start_time: import("zod").ZodOptional<import("zod").ZodNumber>;
+            error_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+            retry_count: import("zod").ZodOptional<import("zod").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>;
+    };
+    readonly swarm_record_outcome: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            duration_ms: import("zod").ZodNumber;
+            error_count: import("zod").ZodDefault<import("zod").ZodNumber>;
+            retry_count: import("zod").ZodDefault<import("zod").ZodNumber>;
+            success: import("zod").ZodBoolean;
+            files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            criteria: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                "research-based": "research-based";
+            }>>;
+            failure_mode: import("zod").ZodOptional<import("zod").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: import("zod").ZodOptional<import("zod").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>;
+    };
+    readonly swarm_accumulate_error: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            error_type: import("zod").ZodEnum<{
+                timeout: "timeout";
+                unknown: "unknown";
+                conflict: "conflict";
+                validation: "validation";
+                tool_failure: "tool_failure";
+            }>;
+            message: import("zod").ZodString;
+            stack_trace: import("zod").ZodOptional<import("zod").ZodString>;
+            tool_name: import("zod").ZodOptional<import("zod").ZodString>;
+            context: import("zod").ZodOptional<import("zod").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>;
+    };
+    readonly swarm_get_error_context: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            include_resolved: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            bead_id: string;
+            include_resolved?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_resolve_error: {
+        description: string;
+        args: {
+            error_id: import("zod").ZodString;
+        };
+        execute(args: {
+            error_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_check_strikes: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            action: import("zod").ZodEnum<{
+                check: "check";
+                add_strike: "add_strike";
+                clear: "clear";
+                get_prompt: "get_prompt";
+            }>;
+            attempt: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").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>;
+    };
+    readonly swarm_checkpoint: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            files_modified: import("zod").ZodArray<import("zod").ZodString>;
+            progress_percent: import("zod").ZodNumber;
+            directives: import("zod").ZodOptional<import("zod").ZodObject<{
+                shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+                skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            error_context: import("zod").ZodOptional<import("zod").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>;
+    };
+    readonly swarm_recover: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+        };
+        execute(args: {
+            project_key: string;
+            epic_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_learn: {
+        description: string;
+        args: {
+            summary: import("zod").ZodString;
+            pattern_type: import("zod").ZodEnum<{
+                "code-pattern": "code-pattern";
+                "best-practice": "best-practice";
+                gotcha: "gotcha";
+                "tool-usage": "tool-usage";
+                "domain-knowledge": "domain-knowledge";
+                workflow: "workflow";
+            }>;
+            details: import("zod").ZodString;
+            example: import("zod").ZodOptional<import("zod").ZodString>;
+            when_to_use: import("zod").ZodString;
+            files_context: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            create_skill: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            skill_name: import("zod").ZodOptional<import("zod").ZodString>;
+            skill_tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").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>;
+    };
+    readonly swarm_subtask_prompt: {
+        description: string;
+        args: {
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            subtask_title: import("zod").ZodString;
+            subtask_description: import("zod").ZodOptional<import("zod").ZodString>;
+            files: import("zod").ZodArray<import("zod").ZodString>;
+            shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            agent_name: string;
+            bead_id: string;
+            epic_id: string;
+            subtask_title: string;
+            files: string[];
+            subtask_description?: string | undefined;
+            shared_context?: string | undefined;
+            project_path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_spawn_subtask: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            subtask_title: import("zod").ZodString;
+            subtask_description: import("zod").ZodOptional<import("zod").ZodString>;
+            files: import("zod").ZodArray<import("zod").ZodString>;
+            shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+            recovery_context: import("zod").ZodOptional<import("zod").ZodObject<{
+                shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+                skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        };
+        execute(args: {
+            bead_id: string;
+            epic_id: string;
+            subtask_title: string;
+            files: string[];
+            subtask_description?: string | undefined;
+            shared_context?: string | undefined;
+            project_path?: string | undefined;
+            recovery_context?: {
+                shared_context?: string | undefined;
+                skills_to_load?: string[] | undefined;
+                coordinator_notes?: string | undefined;
+            } | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_evaluation_prompt: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            subtask_title: import("zod").ZodString;
+            files_touched: import("zod").ZodArray<import("zod").ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            subtask_title: string;
+            files_touched: string[];
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_plan_prompt: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                auto: "auto";
+            }>>;
+            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            include_skills: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            task: string;
+            max_subtasks: number;
+            strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            context?: string | undefined;
+            query_cass?: boolean | undefined;
+            cass_limit?: number | undefined;
+            include_skills?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_decompose: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            task: string;
+            max_subtasks: number;
+            context?: string | undefined;
+            query_cass?: boolean | undefined;
+            cass_limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_validate_decomposition: {
+        description: string;
+        args: {
+            response: import("zod").ZodString;
+        };
+        execute(args: {
+            response: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_delegate_planning: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            max_subtasks: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+            strategy: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                auto: "auto";
+            }>>>;
+            query_cass: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        };
+        execute(args: {
+            task: string;
+            max_subtasks: number;
+            strategy: "file-based" | "feature-based" | "risk-based" | "auto";
+            query_cass: boolean;
+            context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarm_select_strategy: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            codebase_context: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            task: string;
+            codebase_context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly structured_extract_json: {
+        description: string;
+        args: {
+            text: import("zod").ZodString;
+        };
+        execute(args: {
+            text: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly structured_validate: {
+        description: string;
+        args: {
+            response: import("zod").ZodString;
+            schema_name: import("zod").ZodEnum<{
+                evaluation: "evaluation";
+                task_decomposition: "task_decomposition";
+                bead_tree: "bead_tree";
+            }>;
+            max_retries: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            response: string;
+            schema_name: "evaluation" | "task_decomposition" | "bead_tree";
+            max_retries?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly structured_parse_evaluation: {
+        description: string;
+        args: {
+            response: import("zod").ZodString;
+        };
+        execute(args: {
+            response: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly structured_parse_decomposition: {
+        description: string;
+        args: {
+            response: import("zod").ZodString;
+        };
+        execute(args: {
+            response: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly structured_parse_bead_tree: {
+        description: string;
+        args: {
+            response: import("zod").ZodString;
+        };
+        execute(args: {
+            response: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_init: {
+        description: string;
+        args: {
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+            agent_name: import("zod").ZodOptional<import("zod").ZodString>;
+            task_description: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            project_path?: string | undefined;
+            agent_name?: string | undefined;
+            task_description?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_send: {
+        description: string;
+        args: {
+            to: import("zod").ZodArray<import("zod").ZodString>;
+            subject: import("zod").ZodString;
+            body: import("zod").ZodString;
+            thread_id: import("zod").ZodOptional<import("zod").ZodString>;
+            importance: import("zod").ZodOptional<import("zod").ZodEnum<{
+                low: "low";
+                normal: "normal";
+                high: "high";
+                urgent: "urgent";
+            }>>;
+            ack_required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            to: string[];
+            subject: string;
+            body: string;
+            thread_id?: string | undefined;
+            importance?: "low" | "normal" | "high" | "urgent" | undefined;
+            ack_required?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_inbox: {
+        description: string;
+        args: {
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            urgent_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            limit?: number | undefined;
+            urgent_only?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_read_message: {
+        description: string;
+        args: {
+            message_id: import("zod").ZodNumber;
+        };
+        execute(args: {
+            message_id: number;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_reserve: {
+        description: string;
+        args: {
+            paths: import("zod").ZodArray<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            exclusive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            ttl_seconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            paths: string[];
+            reason?: string | undefined;
+            exclusive?: boolean | undefined;
+            ttl_seconds?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_release: {
+        description: string;
+        args: {
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            reservation_ids: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+        };
+        execute(args: {
+            paths?: string[] | undefined;
+            reservation_ids?: number[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_ack: {
+        description: string;
+        args: {
+            message_id: import("zod").ZodNumber;
+        };
+        execute(args: {
+            message_id: number;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly swarmmail_health: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_create: {
+        description: string;
+        args: {
+            title: import("zod").ZodString;
+            type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bug: "bug";
+                feature: "feature";
+                task: "task";
+                epic: "epic";
+                chore: "chore";
+            }>>;
+            priority: import("zod").ZodOptional<import("zod").ZodNumber>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            parent_id: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            title: string;
+            type?: "bug" | "feature" | "task" | "epic" | "chore" | undefined;
+            priority?: number | undefined;
+            description?: string | undefined;
+            parent_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_create_epic: {
+        description: string;
+        args: {
+            epic_title: import("zod").ZodString;
+            epic_description: import("zod").ZodOptional<import("zod").ZodString>;
+            epic_id: import("zod").ZodOptional<import("zod").ZodString>;
+            subtasks: import("zod").ZodArray<import("zod").ZodObject<{
+                title: import("zod").ZodString;
+                priority: import("zod").ZodOptional<import("zod").ZodNumber>;
+                files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                id_suffix: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+            }>>;
+            task: import("zod").ZodOptional<import("zod").ZodString>;
+            project_key: import("zod").ZodOptional<import("zod").ZodString>;
+            recovery_context: import("zod").ZodOptional<import("zod").ZodObject<{
+                shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+                skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        };
+        execute(args: {
+            epic_title: string;
+            subtasks: {
+                title: string;
+                priority?: number | undefined;
+                files?: string[] | undefined;
+                id_suffix?: string | undefined;
+            }[];
+            epic_description?: string | undefined;
+            epic_id?: string | undefined;
+            strategy?: "file-based" | "feature-based" | "risk-based" | undefined;
+            task?: string | undefined;
+            project_key?: string | undefined;
+            recovery_context?: {
+                shared_context?: string | undefined;
+                skills_to_load?: string[] | undefined;
+                coordinator_notes?: string | undefined;
+            } | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_query: {
+        description: string;
+        args: {
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                open: "open";
+                in_progress: "in_progress";
+                blocked: "blocked";
+                closed: "closed";
+            }>>;
+            type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bug: "bug";
+                feature: "feature";
+                task: "task";
+                epic: "epic";
+                chore: "chore";
+            }>>;
+            ready: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            status?: "open" | "in_progress" | "blocked" | "closed" | undefined;
+            type?: "bug" | "feature" | "task" | "epic" | "chore" | undefined;
+            ready?: boolean | undefined;
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_update: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                open: "open";
+                in_progress: "in_progress";
+                blocked: "blocked";
+                closed: "closed";
+            }>>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            priority: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            id: string;
+            status?: "open" | "in_progress" | "blocked" | "closed" | undefined;
+            description?: string | undefined;
+            priority?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_close: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            reason: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+            reason: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_start: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_ready: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_sync: {
+        description: string;
+        args: {
+            auto_pull: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            auto_pull?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly beads_link_thread: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            thread_id: import("zod").ZodString;
+        };
+        execute(args: {
+            bead_id: string;
+            thread_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+/**
+ * Type for CLI tool names (all available tools)
+ */
+export type CLIToolName = keyof typeof allTools;
+/**
+ * Re-export storage module
+ *
+ * Includes:
+ * - createStorage, createStorageWithFallback - Factory functions
+ * - getStorage, setStorage, resetStorage - Global instance management
+ * - InMemoryStorage, SemanticMemoryStorage - Storage implementations
+ * - isSemanticMemoryAvailable - Availability check
+ * - DEFAULT_STORAGE_CONFIG - Default configuration
+ *
+ * Types:
+ * - LearningStorage - Unified storage interface
+ * - StorageConfig, StorageBackend, StorageCollections - Configuration types
+ */
+export { createStorage, createStorageWithFallback, getStorage, setStorage, resetStorage, InMemoryStorage, SemanticMemoryStorage, isSemanticMemoryAvailable, DEFAULT_STORAGE_CONFIG, type LearningStorage, type StorageConfig, type StorageBackend, type StorageCollections, } from "./storage";
+/**
+ * Re-export tool-availability module
+ *
+ * Includes:
+ * - checkTool, isToolAvailable - Check individual tool availability
+ * - checkAllTools - Check all tools at once
+ * - withToolFallback, ifToolAvailable - Execute with graceful fallback
+ * - formatToolAvailability - Format availability for display
+ * - resetToolCache - Reset cached availability (for testing)
+ *
+ * Types:
+ * - ToolName - Supported tool names
+ * - ToolStatus, ToolAvailability - Status types
+ */
+export { checkTool, isToolAvailable, checkAllTools, getToolAvailability, withToolFallback, ifToolAvailable, warnMissingTool, requireTool, formatToolAvailability, resetToolCache, type ToolName, type ToolStatus, type ToolAvailability, } from "./tool-availability";
+/**
+ * Re-export repo-crawl module
+ *
+ * Includes:
+ * - repoCrawlTools - All GitHub API repository research tools
+ * - repo_readme, repo_structure, repo_tree, repo_file, repo_search - Individual tools
+ * - RepoCrawlError - Error class
+ *
+ * Features:
+ * - Parse repos from various formats (owner/repo, URLs)
+ * - Optional GITHUB_TOKEN auth for higher rate limits (5000 vs 60 req/hour)
+ * - Tech stack detection from file patterns
+ * - Graceful rate limit handling
+ */
+export { repoCrawlTools, RepoCrawlError } from "./repo-crawl";
+/**
+ * Re-export skills module
+ *
+ * Implements Anthropic's Agent Skills specification for OpenCode.
+ *
+ * Includes:
+ * - skillsTools - All skills tools (list, use, execute, read)
+ * - discoverSkills, getSkill, listSkills - Discovery functions
+ * - parseFrontmatter - YAML frontmatter parser
+ * - getSkillsContextForSwarm - Swarm integration helper
+ * - findRelevantSkills - Task-based skill matching
+ *
+ * Types:
+ * - Skill, SkillMetadata, SkillRef - Skill data types
+ */
+export { skillsTools, discoverSkills, getSkill, listSkills, parseFrontmatter, setSkillsProjectDirectory, invalidateSkillsCache, getSkillsContextForSwarm, findRelevantSkills, type Skill, type SkillMetadata, type SkillRef, } from "./skills";
+/**
+ * Re-export mandates module
+ *
+ * Agent voting system for collaborative knowledge curation.
+ *
+ * Includes:
+ * - mandateTools - All mandate tools (file, vote, query, list, stats)
+ * - MandateError - Error class
+ *
+ * Features:
+ * - Submit ideas, tips, lore, snippets, and feature requests
+ * - Vote on entries (upvote/downvote) with 90-day decay
+ * - Semantic search for relevant mandates
+ * - Status transitions based on consensus (candidate → established → mandate)
+ * - Persistent storage with semantic-memory
+ *
+ * Types:
+ * - MandateEntry, Vote, MandateScore - Core data types
+ * - MandateStatus, MandateContentType - Enum types
+ */
+export { mandateTools, MandateError } from "./mandates";
+/**
+ * Re-export mandate-storage module
+ *
+ * Includes:
+ * - createMandateStorage - Factory function
+ * - getMandateStorage, setMandateStorage, resetMandateStorage - Global instance management
+ * - updateMandateStatus, updateAllMandateStatuses - Status update helpers
+ * - InMemoryMandateStorage, SemanticMemoryMandateStorage - Storage implementations
+ *
+ * Types:
+ * - MandateStorage - Unified storage interface
+ * - MandateStorageConfig, MandateStorageBackend, MandateStorageCollections - Configuration types
+ */
+export { createMandateStorage, getMandateStorage, setMandateStorage, resetMandateStorage, updateMandateStatus, updateAllMandateStatuses, InMemoryMandateStorage, SemanticMemoryMandateStorage, DEFAULT_MANDATE_STORAGE_CONFIG, type MandateStorage, type MandateStorageConfig, type MandateStorageBackend, type MandateStorageCollections, } from "./mandate-storage";
+/**
+ * Re-export mandate-promotion module
+ *
+ * Includes:
+ * - evaluatePromotion - Evaluate status transitions
+ * - shouldPromote - Determine new status based on score
+ * - formatPromotionResult - Format promotion result for display
+ * - evaluateBatchPromotions, getStatusChanges, groupByTransition - Batch helpers
+ *
+ * Types:
+ * - PromotionResult - Promotion evaluation result
+ */
+export { evaluatePromotion, shouldPromote, formatPromotionResult, evaluateBatchPromotions, getStatusChanges, groupByTransition, type PromotionResult, } from "./mandate-promotion";
+/**
+ * Re-export output-guardrails module
+ *
+ * Includes:
+ * - guardrailOutput - Main entry point for truncating tool output
+ * - truncateWithBoundaries - Smart truncation preserving structure
+ * - getToolLimit - Get character limit for a tool
+ * - DEFAULT_GUARDRAIL_CONFIG - Default configuration
+ *
+ * Types:
+ * - GuardrailConfig - Configuration interface
+ * - GuardrailResult - Result of guardrail processing
+ * - GuardrailMetrics - Analytics data
+ */
+export { guardrailOutput, truncateWithBoundaries, createMetrics, DEFAULT_GUARDRAIL_CONFIG, type GuardrailConfig, type GuardrailResult, type GuardrailMetrics, } from "./output-guardrails";
+//# sourceMappingURL=index.d.ts.map