@skillkit/core 1.4.0 → 1.6.0

package/dist/index.d.ts

@@ -161,6 +161,9 @@ declare const SkillkitConfig: z.ZodObject<{
     enabledSkills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     disabledSkills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     autoSync: z.ZodDefault<z.ZodBoolean>;
+    cacheDir: z.ZodOptional<z.ZodString>;
+    marketplaceSources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    defaultTimeout: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
     agent: "claude-code" | "codex" | "cursor" | "antigravity" | "opencode" | "gemini-cli" | "amp" | "clawdbot" | "droid" | "github-copilot" | "goose" | "kilo" | "kiro-cli" | "roo" | "trae" | "windsurf" | "universal";
@@ -168,6 +171,9 @@ declare const SkillkitConfig: z.ZodObject<{
     skillsDir?: string | undefined;
     enabledSkills?: string[] | undefined;
     disabledSkills?: string[] | undefined;
+    cacheDir?: string | undefined;
+    marketplaceSources?: string[] | undefined;
+    defaultTimeout?: number | undefined;
 }, {
     version: 1;
     agent?: "claude-code" | "codex" | "cursor" | "antigravity" | "opencode" | "gemini-cli" | "amp" | "clawdbot" | "droid" | "github-copilot" | "goose" | "kilo" | "kiro-cli" | "roo" | "trae" | "windsurf" | "universal" | undefined;
@@ -175,6 +181,9 @@ declare const SkillkitConfig: z.ZodObject<{
     enabledSkills?: string[] | undefined;
     disabledSkills?: string[] | undefined;
     autoSync?: boolean | undefined;
+    cacheDir?: string | undefined;
+    marketplaceSources?: string[] | undefined;
+    defaultTimeout?: number | undefined;
 }>;
 type SkillkitConfig = z.infer<typeof SkillkitConfig>;
 interface InstallOptions {
@@ -247,7 +256,7 @@ declare function isPathInside(child: string, parent: string): boolean;
 
 declare function getProjectConfigPath(): string;
 declare function getGlobalConfigPath(): string;
-declare function loadConfig(): SkillkitConfig;
+declare function loadConfig(global?: boolean): SkillkitConfig;
 declare function saveConfig(config: SkillkitConfig, global?: boolean): void;
 declare function getSearchDirs(adapter: AgentAdapterInfo): string[];
 declare function getInstallDir(adapter: AgentAdapterInfo, global?: boolean): string;
@@ -3171,6 +3180,56 @@ declare function getExecutionStrategy(agentType: AgentType): ExecutionStrategy;
  */
 declare function getManualExecutionInstructions(agentType: AgentType, skillPath: string): string;
 
+/**
+ * Skill Executor for Workflows
+ *
+ * Provides a real skill executor that finds skills by name
+ * and executes them using available agent CLIs.
+ */
+
+/**
+ * Options for creating a skill executor
+ */
+interface SkillExecutorOptions {
+    /** Project path to search for skills */
+    projectPath?: string;
+    /** Preferred agent to use for execution */
+    preferredAgent?: AgentType;
+    /** Timeout for skill execution (ms) */
+    timeout?: number;
+    /** Whether to fall back to other agents if preferred is unavailable */
+    fallbackToAvailable?: boolean;
+    /** Callback for execution events */
+    onExecutionEvent?: (event: SkillExecutionEvent) => void;
+}
+/**
+ * Skill execution event
+ */
+interface SkillExecutionEvent {
+    type: 'skill_found' | 'skill_not_found' | 'agent_selected' | 'execution_start' | 'execution_complete';
+    skillName: string;
+    agent?: AgentType;
+    message?: string;
+    success?: boolean;
+    error?: string;
+}
+/**
+ * Create a skill executor for workflow orchestration
+ *
+ * This returns a function compatible with the WorkflowOrchestrator's SkillExecutor type.
+ */
+declare function createSkillExecutor(options?: SkillExecutorOptions): SkillExecutor;
+/**
+ * Create a simulated skill executor for testing/dry-run
+ *
+ * This executor doesn't actually run skills but simulates execution.
+ */
+declare function createSimulatedSkillExecutor(options?: {
+    delay?: number;
+    shouldFail?: (skillName: string) => boolean;
+    onExecute?: (skillName: string) => void;
+}): SkillExecutor;
+
 /**
  * Skill Testing Framework Types
  *
@@ -4403,4 +4462,3190 @@ declare class MemoryInjector {
  */
 declare function createMemoryInjector(projectPath: string, projectName?: string, projectContext?: ProjectContext): MemoryInjector;
 
-export { AGENT_CLI_CONFIGS, AGENT_FORMAT_MAP, APIBasedCompressor, type APICompressionConfig, type AgentAdapterInfo, type AgentCLIConfig, AgentConfig, type AgentExecutionResult, AgentType, type AssertionResult, BitbucketProvider, CIRCLECI_CONFIG_TEMPLATE, CONTEXT_DIR, CONTEXT_FILE, type CanonicalSkill, type CheckpointHandler, type CheckpointResponse, type CloneOptions, type CloneResult, type CommandResult, type CompressedLearning, type CompressionEngine, type CompressionOptions, type CompressionResult, type ContextCategory, type ContextExportOptions, type ContextImportOptions, type ContextLoadOptions, ContextLoader, ContextManager, ContextSync, type ContextSyncOptions, CopilotTranslator, type CurrentExecution, CursorTranslator, DEFAULT_CACHE_TTL, DEFAULT_CONTEXT_CATEGORIES, DEFAULT_MEMORY_CONFIG, DEFAULT_SCORING_WEIGHTS, DEFAULT_SKILL_SOURCES, DependencyInfo, Detection, type DetectionSource, type DiscoveredSkill, type ExecutableSkill, type ExecutableTask, type ExecutableTaskType, type ExecutionHistory, type ExecutionOptions, type ExecutionProgressCallback, type ExecutionProgressEvent, type ExecutionStrategy, type ExecutionTaskStatus, type FormatCategory, type FormatTranslator, type FreshnessResult, GITHUB_ACTION_TEMPLATE, GITLAB_CI_TEMPLATE, GitHubProvider, GitLabProvider, GitProvider, type GitProviderAdapter, INDEX_CACHE_HOURS, INDEX_PATH, type IndexSource, type InjectedMemory, type InjectionOptions, type InjectionResult, type InstallOptions, KNOWN_SKILL_REPOS, type Learning, LearningConsolidator, LearningStore, type LearningStoreData, type LoadedContext, LocalProvider, MARKETPLACE_CACHE_FILE, MarketplaceAggregator, type MarketplaceConfig, type MarketplaceIndex, type MarketplaceSearchOptions, type MarketplaceSearchResult, type MarketplaceSkill, type MatchCategory, type MatchReason, MemoryCompressor, type MemoryConfig, MemoryEnabledEngine, type MemoryEnabledEngineOptions, type MemoryFull, type MemoryIndex, MemoryIndexStore, MemoryInjector, MemoryObserver, type MemoryObserverConfig, type MemoryPaths, type MemoryPreview, type MemorySearchOptions, type MemorySearchResult, type MemoryStatus, type MemorySummary, type ObservableEvent, type ObservableEventType, type Observation, type ObservationContent, ObservationStore, type ObservationStoreData, type ObservationType, PRE_COMMIT_CONFIG_TEMPLATE, PRE_COMMIT_HOOK_TEMPLATE, PROJECT_TYPE_HINTS, ProjectContext, ProjectDetector, ProjectPatterns, type ProjectProfile, ProjectStack, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegistrySkill, RuleBasedCompressor, SESSION_FILE, SKILL_DISCOVERY_PATHS, type ScoredSkill, type ScoringWeights, type SearchOptions, type SearchResult, type SessionDecision, SessionManager, type SessionState, type SessionTask, Skill, SkillExecutionEngine, type SkillExecutionResult, type SkillExecutor, SkillFrontmatter, type SkillIndex, SkillLocation, SkillMdTranslator, SkillMetadata, SkillPreferences, type SkillSource, SkillSummary, type SkillTestCase, type SkillTestSuite, SkillkitConfig, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_TECH, type TaskExecutionResult, type TaskStatus, type TestAssertion, type TestAssertionType, type TestCaseResult, type TestProgressEvent, type TestRunnerOptions, type TestSuiteResult, TranslatableSkillFrontmatter, type TranslationOptions, type TranslationPath, type TranslationResult, TranslatorRegistry, type UpdateOptions, type VerificationRule, WORKFLOWS_DIR, WORKFLOW_EXTENSION, type WaveExecutionStatus, WindsurfTranslator, type Workflow, type WorkflowExecution, type WorkflowExecutionStatus, WorkflowOrchestrator, type WorkflowProgressCallback, type WorkflowSkill, type WorkflowWave, analyzeProject, buildSkillIndex, canTranslate, copilotTranslator, createAPIBasedCompressor, createContextLoader, createContextManager, createContextSync, createExecutionEngine, createMarketplaceAggregator, createMemoryCompressor, createMemoryEnabledEngine, createMemoryInjector, createMemoryObserver, createRecommendationEngine, createRuleBasedCompressor, createSessionManager, createTestSuiteFromFrontmatter, createWorkflowOrchestrator, createWorkflowTemplate, cursorTranslator, detectProvider, detectSkillFormat, discoverSkills, estimateTokens, executeWithAgent, extractField, extractFrontmatter, fetchSkillsFromRepo, findAllSkills, findSkill, formatSkillAsPrompt, getAgentCLIConfig, getAgentConfigPath, getAllProviders, getAvailableCLIAgents, getCICDTemplate, getExecutionStrategy, getGlobalConfigPath, getIndexStatus, getInstallDir, getManualExecutionInstructions, getMemoryPaths, getMemoryStatus, getProjectConfigPath, getProvider, getSearchDirs, getStackTags, getSupportedTranslationAgents, getTechTags, globalMemoryDirectoryExists, initContext, initProject, initializeMemoryDirectory, isAgentCLIAvailable, isGitUrl, isIndexStale, isLocalPath, isPathInside, listCICDTemplates, listWorkflows, loadConfig, loadContext, loadIndex, loadMetadata, loadSkillMetadata, loadWorkflow, loadWorkflowByName, memoryDirectoryExists, parseShorthand, parseSkill, parseSkillContent, parseSource, parseWorkflow, readSkillContent, runTestSuite, saveConfig, saveIndex, saveSkillMetadata, saveWorkflow, serializeWorkflow, setSkillEnabled, skillMdTranslator, syncToAgent, syncToAllAgents, translateSkill, translateSkillFile, translatorRegistry, validateSkill, validateWorkflow, windsurfTranslator, wrapProgressCallbackWithMemory };
+/**
+ * Team Collaboration Types
+ */
+
+/**
+ * Team member information
+ */
+interface TeamMember {
+    id: string;
+    name: string;
+    email?: string;
+    role: 'admin' | 'contributor' | 'viewer';
+    joinedAt: string;
+}
+/**
+ * Shared skill metadata
+ */
+interface SharedSkill {
+    name: string;
+    version: string;
+    description?: string;
+    author: string;
+    sharedAt: string;
+    updatedAt: string;
+    source: string;
+    tags?: string[];
+    agents: AgentType[];
+    downloads?: number;
+    rating?: number;
+}
+/**
+ * Team configuration
+ */
+interface TeamConfig {
+    /** Team identifier */
+    teamId: string;
+    /** Team name */
+    teamName: string;
+    /** Team registry URL (git repo or registry endpoint) */
+    registryUrl: string;
+    /** Authentication method */
+    auth?: {
+        type: 'token' | 'ssh' | 'none';
+        token?: string;
+        keyPath?: string;
+    };
+    /** Auto-sync interval in minutes (0 = disabled) */
+    autoSyncInterval?: number;
+    /** Members list (for admin features) */
+    members?: TeamMember[];
+}
+/**
+ * Team registry containing shared skills
+ */
+interface TeamRegistry {
+    version: number;
+    teamId: string;
+    teamName: string;
+    skills: SharedSkill[];
+    updatedAt: string;
+    createdAt: string;
+}
+/**
+ * Bundle manifest for exporting skills
+ */
+interface BundleManifest {
+    version: number;
+    name: string;
+    description?: string;
+    author: string;
+    createdAt: string;
+    skills: {
+        name: string;
+        path: string;
+        agents: AgentType[];
+    }[];
+    totalSize: number;
+}
+/**
+ * Options for sharing a skill
+ */
+interface ShareOptions {
+    /** Skill name to share */
+    skillName: string;
+    /** Description override */
+    description?: string;
+    /** Tags to add */
+    tags?: string[];
+    /** Target agents (default: all compatible) */
+    agents?: AgentType[];
+    /** Visibility level */
+    visibility?: 'team' | 'public';
+}
+/**
+ * Options for importing skills
+ */
+interface ImportOptions {
+    /** Overwrite existing skills */
+    overwrite?: boolean;
+    /** Target agents to install for */
+    agents?: AgentType[];
+    /** Dry run mode */
+    dryRun?: boolean;
+}
+
+/**
+ * Team Manager
+ *
+ * Manages team skill sharing and collaboration
+ */
+
+/**
+ * Team Manager for collaboration features
+ */
+declare class TeamManager {
+    private projectPath;
+    private config;
+    private registry;
+    constructor(projectPath: string);
+    /**
+     * Initialize team configuration
+     */
+    init(config: Omit<TeamConfig, 'teamId'>): Promise<TeamConfig>;
+    /**
+     * Load existing team configuration
+     */
+    load(): TeamConfig | null;
+    /**
+     * Get current config
+     */
+    getConfig(): TeamConfig | null;
+    /**
+     * Get current registry
+     */
+    getRegistry(): TeamRegistry | null;
+    /**
+     * Share a skill to the team registry
+     */
+    shareSkill(options: ShareOptions): Promise<SharedSkill>;
+    /**
+     * List all shared skills in the team registry
+     */
+    listSharedSkills(): SharedSkill[];
+    /**
+     * Search shared skills
+     */
+    searchSkills(query: string): SharedSkill[];
+    /**
+     * Import a shared skill from the team registry
+     */
+    importSkill(skillName: string, options?: ImportOptions): Promise<{
+        success: boolean;
+        path?: string;
+        error?: string;
+    }>;
+    /**
+     * Sync with remote registry
+     */
+    sync(): Promise<{
+        added: string[];
+        updated: string[];
+        removed: string[];
+    }>;
+    /**
+     * Remove a skill from the team registry
+     */
+    removeSkill(skillName: string): boolean;
+    private generateTeamId;
+    private saveConfig;
+    private loadRegistry;
+    private saveRegistry;
+    private findLocalSkill;
+    private getAuthor;
+    private detectCompatibleAgents;
+    private extractFrontmatter;
+    private parseYaml;
+    private toYaml;
+}
+/**
+ * Create a team manager instance
+ */
+declare function createTeamManager(projectPath: string): TeamManager;
+
+/**
+ * Skill Bundle
+ *
+ * Package multiple skills into a shareable bundle
+ */
+
+/**
+ * Skill Bundle class for creating and managing skill bundles
+ */
+declare class SkillBundle {
+    private manifest;
+    private skills;
+    constructor(name: string, author: string, description?: string);
+    /**
+     * Add a skill to the bundle
+     */
+    addSkill(skillPath: string, agents?: AgentType[]): void;
+    /**
+     * Remove a skill from the bundle
+     */
+    removeSkill(skillName: string): boolean;
+    /**
+     * Get bundle manifest
+     */
+    getManifest(): BundleManifest;
+    /**
+     * Get all skill names in bundle
+     */
+    getSkillNames(): string[];
+    /**
+     * Get skill content by name
+     */
+    getSkillContent(skillName: string): string | undefined;
+    /**
+     * Calculate bundle checksum
+     */
+    getChecksum(): string;
+    private readSkillContent;
+    private detectAgents;
+}
+/**
+ * Create a new skill bundle
+ */
+declare function createSkillBundle(name: string, author: string, description?: string): SkillBundle;
+/**
+ * Export a bundle to a file
+ */
+declare function exportBundle(bundle: SkillBundle, outputPath: string): {
+    success: boolean;
+    path?: string;
+    error?: string;
+};
+/**
+ * Import a bundle from a file
+ */
+declare function importBundle(bundlePath: string, targetDir: string, options?: {
+    overwrite?: boolean;
+}): {
+    success: boolean;
+    imported: string[];
+    errors: string[];
+};
+
+/**
+ * Plugin System Types
+ */
+
+/**
+ * Plugin metadata
+ */
+interface PluginMetadata {
+    /** Unique plugin identifier */
+    name: string;
+    /** Plugin version (semver) */
+    version: string;
+    /** Human-readable description */
+    description?: string;
+    /** Plugin author */
+    author?: string;
+    /** Plugin homepage or repository URL */
+    homepage?: string;
+    /** Required SkillKit version */
+    skillkitVersion?: string;
+    /** Plugin dependencies */
+    dependencies?: string[];
+    /** Plugin keywords for discovery */
+    keywords?: string[];
+}
+/**
+ * Plugin lifecycle hooks
+ */
+interface PluginHooks {
+    /** Called when a skill is installed */
+    onSkillInstall?: (skill: CanonicalSkill, agent: AgentType) => Promise<void>;
+    /** Called when a skill is removed */
+    onSkillRemove?: (skillName: string, agent: AgentType) => Promise<void>;
+    /** Called when skills are synced */
+    onSync?: (agents: AgentType[]) => Promise<void>;
+    /** Called before translation */
+    beforeTranslate?: (skill: CanonicalSkill, targetAgent: AgentType) => Promise<CanonicalSkill>;
+    /** Called after translation */
+    afterTranslate?: (content: string, targetAgent: AgentType) => Promise<string>;
+    /** Called when plugin is loaded */
+    onLoad?: (context: PluginContext) => Promise<void>;
+    /** Called when plugin is unloaded */
+    onUnload?: () => Promise<void>;
+}
+/**
+ * Translator plugin - adds support for new agent formats
+ */
+interface TranslatorPlugin {
+    type: 'translator';
+    /** Agent type this translator handles */
+    agentType: AgentType | string;
+    /** The translator implementation */
+    translator: FormatTranslator;
+}
+/**
+ * Provider plugin - adds support for new skill sources
+ */
+interface ProviderPlugin {
+    type: 'provider';
+    /** Provider name (e.g., 'bitbucket', 's3') */
+    providerName: string;
+    /** The provider implementation */
+    provider: GitProviderAdapter;
+}
+/**
+ * Command plugin - adds new CLI commands
+ */
+interface CommandPlugin {
+    type: 'command';
+    /** Command name */
+    name: string;
+    /** Command aliases */
+    aliases?: string[];
+    /** Command description */
+    description: string;
+    /** Command options */
+    options?: Array<{
+        name: string;
+        description: string;
+        type: 'string' | 'boolean' | 'number';
+        required?: boolean;
+        default?: unknown;
+    }>;
+    /** Command handler */
+    handler: (args: Record<string, unknown>, context: PluginContext) => Promise<number>;
+}
+/**
+ * Plugin context passed to plugins
+ */
+interface PluginContext {
+    /** Project path */
+    projectPath: string;
+    /** SkillKit version */
+    skillkitVersion: string;
+    /** Plugin configuration */
+    config: PluginConfig;
+    /** Logger instance */
+    log: {
+        info: (message: string) => void;
+        warn: (message: string) => void;
+        error: (message: string) => void;
+        debug: (message: string) => void;
+    };
+    /** Get a registered translator by agent type */
+    getTranslator: (agentType: AgentType) => FormatTranslator | undefined;
+    /** Get a registered provider by name */
+    getProvider: (name: string) => GitProviderAdapter | undefined;
+}
+/**
+ * Plugin configuration
+ */
+interface PluginConfig {
+    /** Plugin-specific settings */
+    settings?: Record<string, unknown>;
+    /** Whether plugin is enabled */
+    enabled?: boolean;
+}
+/**
+ * Main plugin interface
+ */
+interface Plugin {
+    /** Plugin metadata */
+    metadata: PluginMetadata;
+    /** Plugin hooks */
+    hooks?: PluginHooks;
+    /** Translator extensions */
+    translators?: TranslatorPlugin[];
+    /** Provider extensions */
+    providers?: ProviderPlugin[];
+    /** Command extensions */
+    commands?: CommandPlugin[];
+    /** Plugin initialization */
+    init?: (context: PluginContext) => Promise<void>;
+    /** Plugin cleanup */
+    destroy?: () => Promise<void>;
+}
+
+/**
+ * Plugin Manager
+ *
+ * Manages plugin registration, lifecycle, and execution
+ */
+
+/**
+ * Plugin Manager class
+ */
+declare class PluginManager {
+    private projectPath;
+    private plugins;
+    private translators;
+    private providers;
+    private commands;
+    private hooks;
+    private state;
+    private context;
+    constructor(projectPath: string);
+    /**
+     * Register a plugin
+     */
+    register(plugin: Plugin): Promise<void>;
+    /**
+     * Unregister a plugin
+     */
+    unregister(name: string): Promise<void>;
+    /**
+     * Get a registered plugin
+     */
+    getPlugin(name: string): Plugin | undefined;
+    /**
+     * Get all registered plugins
+     */
+    getAllPlugins(): Plugin[];
+    /**
+     * Get plugin metadata for all plugins
+     */
+    listPlugins(): PluginMetadata[];
+    /**
+     * Get a translator by agent type
+     */
+    getTranslator(agentType: AgentType | string): FormatTranslator | undefined;
+    /**
+     * Get all registered translators
+     */
+    getAllTranslators(): Map<string, FormatTranslator>;
+    /**
+     * Get a provider by name
+     */
+    getProvider(name: string): GitProviderAdapter | undefined;
+    /**
+     * Get all registered providers
+     */
+    getAllProviders(): Map<string, GitProviderAdapter>;
+    /**
+     * Get a command by name
+     */
+    getCommand(name: string): CommandPlugin | undefined;
+    /**
+     * Get all registered commands
+     */
+    getAllCommands(): CommandPlugin[];
+    /**
+     * Execute hooks for an event
+     */
+    executeHook<K extends keyof PluginHooks>(hookName: K, ...args: Parameters<NonNullable<PluginHooks[K]>>): Promise<void>;
+    /**
+     * Execute beforeTranslate hooks (returns transformed skill)
+     */
+    executeBeforeTranslate(skill: CanonicalSkill, targetAgent: AgentType): Promise<CanonicalSkill>;
+    /**
+     * Execute afterTranslate hooks (returns transformed content)
+     */
+    executeAfterTranslate(content: string, targetAgent: AgentType): Promise<string>;
+    /**
+     * Set plugin configuration
+     */
+    setPluginConfig(name: string, config: PluginConfig): void;
+    /**
+     * Get plugin configuration
+     */
+    getPluginConfig(name: string): PluginConfig | undefined;
+    /**
+     * Enable a plugin
+     */
+    enablePlugin(name: string): void;
+    /**
+     * Disable a plugin
+     */
+    disablePlugin(name: string): void;
+    /**
+     * Check if plugin is enabled
+     */
+    isPluginEnabled(name: string): boolean;
+    private loadState;
+    private saveState;
+    private createContext;
+}
+/**
+ * Create a plugin manager instance
+ */
+declare function createPluginManager(projectPath: string): PluginManager;
+
+/**
+ * Plugin Loader
+ *
+ * Loads plugins from various sources:
+ * - Local files
+ * - npm packages
+ * - Git repositories
+ */
+
+/**
+ * Plugin Loader class
+ */
+declare class PluginLoader {
+    /**
+     * Load a plugin from a file path
+     */
+    loadFromFile(filePath: string): Promise<Plugin>;
+    /**
+     * Load a plugin from an npm package
+     */
+    loadFromPackage(packageName: string): Promise<Plugin>;
+    /**
+     * Load a plugin from a JSON definition (for simple plugins)
+     */
+    loadFromJson(jsonPath: string): Plugin;
+    /**
+     * Scan a directory for plugins
+     */
+    scanDirectory(dirPath: string): Promise<PluginMetadata[]>;
+    /**
+     * Validate a plugin structure
+     */
+    private validatePlugin;
+}
+/**
+ * Load a plugin from a file
+ */
+declare function loadPlugin(source: string): Promise<Plugin>;
+/**
+ * Load all plugins from a directory
+ */
+declare function loadPluginsFromDirectory(dirPath: string): Promise<Plugin[]>;
+
+/**
+ * Methodology Framework Types
+ *
+ * Defines types for methodology packs, skills, and the management system.
+ * SkillKit's methodology framework is composable, community-driven, and
+ * methodology-agnostic (supports TDD, BDD, DDD, or custom approaches).
+ */
+
+/**
+ * Methodology pack manifest - defines a collection of related skills
+ */
+interface MethodologyPack {
+    /** Pack name (e.g., 'testing', 'debugging') */
+    name: string;
+    /** Semantic version */
+    version: string;
+    /** Human-readable description */
+    description: string;
+    /** Skills included in this pack */
+    skills: string[];
+    /** Tags for discovery */
+    tags: string[];
+    /** Agent compatibility ('all' or specific agents) */
+    compatibility: ('all' | AgentType)[];
+    /** Author information */
+    author?: string;
+    /** Repository/homepage URL */
+    repository?: string;
+    /** License */
+    license?: string;
+    /** Pack dependencies (other packs) */
+    dependencies?: string[];
+}
+/**
+ * Methodology skill - a skill within a methodology pack
+ */
+interface MethodologySkill {
+    /** Unique skill identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Skill description */
+    description: string;
+    /** Skill version */
+    version: string;
+    /** Parent pack name */
+    pack: string;
+    /** Tags for discovery */
+    tags: string[];
+    /** File path to SKILL.md content */
+    path: string;
+    /** Raw SKILL.md content */
+    content: string;
+    /** Skill metadata from frontmatter */
+    metadata: MethodologySkillMetadata;
+}
+/**
+ * Skill metadata from SKILL.md frontmatter
+ */
+interface MethodologySkillMetadata {
+    /** Skill triggers/keywords for activation */
+    triggers?: string[];
+    /** Related skills that work well together */
+    relatedSkills?: string[];
+    /** Difficulty level */
+    difficulty?: 'beginner' | 'intermediate' | 'advanced';
+    /** Estimated time to apply (in minutes) */
+    estimatedTime?: number;
+    /** Prerequisites (other skills or knowledge) */
+    prerequisites?: string[];
+    /** Custom metadata */
+    [key: string]: unknown;
+}
+/**
+ * Installed methodology state
+ */
+interface MethodologyState {
+    /** State format version */
+    version: number;
+    /** Installed packs */
+    installedPacks: Record<string, InstalledPackInfo>;
+    /** Installed skills (for individual skill installs) */
+    installedSkills: Record<string, InstalledSkillInfo>;
+    /** Last sync timestamp */
+    lastSync?: string;
+}
+/**
+ * Information about an installed pack
+ */
+interface InstalledPackInfo {
+    /** Pack version */
+    version: string;
+    /** Installation timestamp */
+    installedAt: string;
+    /** Skills installed from this pack */
+    skills: string[];
+    /** Whether auto-sync is enabled */
+    autoSync?: boolean;
+}
+/**
+ * Information about an installed skill
+ */
+interface InstalledSkillInfo {
+    /** Skill version */
+    version: string;
+    /** Pack name (if installed from pack) */
+    pack?: string;
+    /** Installation timestamp */
+    installedAt: string;
+    /** Agents synced to */
+    syncedAgents: AgentType[];
+}
+/**
+ * Options for methodology manager
+ */
+interface MethodologyManagerOptions {
+    /** Project path */
+    projectPath: string;
+    /** Custom packs directory */
+    packsDir?: string;
+    /** Whether to auto-sync on install */
+    autoSync?: boolean;
+}
+/**
+ * Result of pack/skill installation
+ */
+interface InstallResult {
+    /** Whether installation succeeded */
+    success: boolean;
+    /** Installed items */
+    installed: string[];
+    /** Skipped items (already installed) */
+    skipped: string[];
+    /** Failed items with error messages */
+    failed: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+/**
+ * Result of skill sync operation
+ */
+interface MethodologySyncResult {
+    /** Whether sync succeeded */
+    success: boolean;
+    /** Skills synced */
+    synced: Array<{
+        skill: string;
+        agents: AgentType[];
+    }>;
+    /** Skills that failed to sync */
+    failed: Array<{
+        skill: string;
+        agent: AgentType;
+        error: string;
+    }>;
+}
+/**
+ * Pack validation result
+ */
+interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Validation errors */
+    errors: ValidationError[];
+    /** Validation warnings */
+    warnings: ValidationWarning[];
+}
+/**
+ * Validation error
+ */
+interface ValidationError {
+    /** Error code */
+    code: string;
+    /** Error message */
+    message: string;
+    /** Path to the problematic item */
+    path?: string;
+    /** Line number (if applicable) */
+    line?: number;
+}
+/**
+ * Validation warning
+ */
+interface ValidationWarning {
+    /** Warning code */
+    code: string;
+    /** Warning message */
+    message: string;
+    /** Recommendation */
+    recommendation?: string;
+}
+/**
+ * Methodology search query
+ */
+interface MethodologySearchQuery {
+    /** Search term */
+    query?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Filter by pack name */
+    pack?: string;
+    /** Filter by difficulty */
+    difficulty?: MethodologySkillMetadata['difficulty'];
+    /** Filter by agent compatibility */
+    agent?: AgentType;
+}
+/**
+ * Methodology search result
+ */
+interface MethodologySearchResult {
+    /** Matching skills */
+    skills: MethodologySkill[];
+    /** Matching packs */
+    packs: MethodologyPack[];
+    /** Total count */
+    total: number;
+}
+
+/**
+ * Methodology Loader
+ *
+ * Loads methodology packs and skills from the built-in packs directory
+ * and custom locations.
+ */
+
+/**
+ * Methodology Loader class
+ */
+declare class MethodologyLoader {
+    private packsDir;
+    private loadedPacks;
+    private loadedSkills;
+    constructor(customPacksDir?: string);
+    /**
+     * Load all available packs
+     */
+    loadAllPacks(): Promise<MethodologyPack[]>;
+    /**
+     * Load a specific pack by name
+     */
+    loadPack(packName: string): Promise<MethodologyPack | null>;
+    /**
+     * Load all skills from a pack
+     */
+    loadPackSkills(packName: string): Promise<MethodologySkill[]>;
+    /**
+     * Load a specific skill
+     */
+    loadSkill(packName: string, skillName: string): Promise<MethodologySkill | null>;
+    /**
+     * Get skill by full ID (pack/skill)
+     */
+    getSkillById(skillId: string): Promise<MethodologySkill | null>;
+    /**
+     * Search skills by query
+     */
+    searchSkills(query: string): Promise<MethodologySkill[]>;
+    /**
+     * Get skills by tag
+     */
+    getSkillsByTag(tag: string): Promise<MethodologySkill[]>;
+    /**
+     * Get built-in packs directory path
+     */
+    getPacksDir(): string;
+    /**
+     * Check if a pack exists
+     */
+    packExists(packName: string): boolean;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+}
+/**
+ * Create a methodology loader instance
+ */
+declare function createMethodologyLoader(customPacksDir?: string): MethodologyLoader;
+/**
+ * Get the built-in packs directory
+ */
+declare function getBuiltinPacksDir(): string;
+
+/**
+ * Methodology Manager
+ *
+ * Manages methodology pack installation, syncing, and lifecycle.
+ */
+
+/**
+ * Methodology Manager class
+ */
+declare class MethodologyManager {
+    private projectPath;
+    private loader;
+    private state;
+    private autoSync;
+    constructor(options: MethodologyManagerOptions);
+    /**
+     * Install a methodology pack
+     */
+    installPack(packName: string): Promise<InstallResult>;
+    /**
+     * Install all available packs
+     */
+    installAllPacks(): Promise<InstallResult>;
+    /**
+     * Install a single skill by ID
+     */
+    installSkill(skillId: string): Promise<InstallResult>;
+    /**
+     * Uninstall a pack
+     */
+    uninstallPack(packName: string): Promise<void>;
+    /**
+     * Uninstall a skill
+     */
+    uninstallSkill(skillId: string): Promise<void>;
+    /**
+     * Sync a pack to all detected agents
+     */
+    syncPack(packName: string, agents?: AgentType[]): Promise<MethodologySyncResult>;
+    /**
+     * Sync a skill to all detected agents
+     */
+    syncSkill(skillId: string, agents?: AgentType[]): Promise<MethodologySyncResult>;
+    /**
+     * Sync all installed skills
+     */
+    syncAll(agents?: AgentType[]): Promise<MethodologySyncResult>;
+    /**
+     * List installed packs
+     */
+    listInstalledPacks(): Array<{
+        name: string;
+        version: string;
+        skills: string[];
+    }>;
+    /**
+     * List installed skills
+     */
+    listInstalledSkills(): Array<{
+        id: string;
+        version: string;
+        pack?: string;
+        syncedAgents: AgentType[];
+    }>;
+    /**
+     * List available packs (not yet installed)
+     */
+    listAvailablePacks(): Promise<MethodologyPack[]>;
+    /**
+     * Search methodology skills
+     */
+    search(query: MethodologySearchQuery): Promise<MethodologySearchResult>;
+    /**
+     * Get the loader instance
+     */
+    getLoader(): MethodologyLoader;
+    private loadState;
+    private saveState;
+    private installSkillLocally;
+    private removeSkillLocally;
+    private writeSkillToAgent;
+    private detectAgents;
+}
+/**
+ * Create a methodology manager instance
+ */
+declare function createMethodologyManager(options: MethodologyManagerOptions): MethodologyManager;
+
+/**
+ * Methodology Validator
+ *
+ * Validates methodology packs and skills for correctness and completeness.
+ */
+
+/**
+ * Validates a methodology pack manifest
+ */
+declare function validatePackManifest(pack: unknown): ValidationResult;
+/**
+ * Validates SKILL.md content
+ */
+declare function validateSkillContent(content: string): ValidationResult;
+/**
+ * Validates a pack directory structure
+ */
+declare function validatePackDirectory(packPath: string): ValidationResult;
+/**
+ * Validates all built-in packs
+ */
+declare function validateBuiltinPacks(packsDir: string): Map<string, ValidationResult>;
+/**
+ * Extract skill metadata from SKILL.md frontmatter
+ */
+declare function extractSkillMetadata(content: string): Record<string, unknown>;
+
+/**
+ * Hooks & Automatic Triggering System Types
+ *
+ * Provides event-driven skill activation across all supported agents.
+ */
+
+/**
+ * Hook events that can trigger skill activation
+ */
+type HookEvent = 'session:start' | 'session:resume' | 'session:end' | 'file:open' | 'file:save' | 'file:create' | 'file:delete' | 'task:start' | 'task:complete' | 'commit:pre' | 'commit:post' | 'error:occur' | 'test:fail' | 'test:pass' | 'build:start' | 'build:fail' | 'build:success';
+/**
+ * How to inject the skill when triggered
+ */
+type InjectionMode = 'content' | 'reference' | 'prompt';
+/**
+ * Skill hook configuration
+ */
+interface SkillHook {
+    /** Unique identifier for this hook */
+    id: string;
+    /** Event that triggers this hook */
+    event: HookEvent;
+    /** Pattern to match (e.g., "*.test.ts", "src/**\/*.tsx") */
+    matcher?: string | RegExp;
+    /** Skills to activate when triggered */
+    skills: string[];
+    /** How to inject the skill */
+    inject: InjectionMode;
+    /** Priority (higher = earlier execution) */
+    priority?: number;
+    /** Condition expression (optional) */
+    condition?: string;
+    /** Whether hook is enabled */
+    enabled: boolean;
+    /** Agent-specific overrides */
+    agentOverrides?: Partial<Record<AgentType, Partial<SkillHook>>>;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Context provided when a hook is triggered
+ */
+interface HookContext {
+    /** The event that was triggered */
+    event: HookEvent;
+    /** What triggered the event (filename, command, etc.) */
+    trigger: string;
+    /** Project path */
+    projectPath: string;
+    /** Target agent */
+    agent: AgentType;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Result of activating a skill via hook
+ */
+interface ActivatedSkill {
+    /** Skill ID */
+    skillId: string;
+    /** Hook that activated it */
+    hookId: string;
+    /** Injection mode used */
+    injectionMode: InjectionMode;
+    /** The skill content (if injection mode is 'content') */
+    content?: string;
+    /** The skill reference (if injection mode is 'reference') */
+    reference?: string;
+    /** Activation timestamp */
+    activatedAt: Date;
+}
+/**
+ * Hook trigger result
+ */
+interface HookTriggerResult {
+    /** Event that was triggered */
+    event: HookEvent;
+    /** Hooks that matched */
+    matchedHooks: SkillHook[];
+    /** Skills that were activated */
+    activatedSkills: ActivatedSkill[];
+    /** Any errors that occurred */
+    errors: HookError[];
+    /** Total execution time in ms */
+    executionTimeMs: number;
+}
+/**
+ * Hook error
+ */
+interface HookError {
+    hookId: string;
+    skillId?: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Hook configuration file format
+ */
+interface HookConfig {
+    version: number;
+    hooks: SkillHook[];
+    defaults?: {
+        inject?: InjectionMode;
+        priority?: number;
+        enabled?: boolean;
+    };
+}
+/**
+ * Agent-specific hook format generator
+ */
+interface AgentHookFormat {
+    /** Agent type */
+    agent: AgentType;
+    /** Generate hook configuration for this agent */
+    generate(hooks: SkillHook[]): string | Record<string, unknown>;
+    /** Parse agent-specific hook format */
+    parse(content: string | Record<string, unknown>): SkillHook[];
+    /** File path for hook configuration */
+    configPath: string;
+}
+/**
+ * Hook manager options
+ */
+interface HookManagerOptions {
+    /** Project path */
+    projectPath: string;
+    /** Path to hooks configuration file */
+    configPath?: string;
+    /** Whether to auto-load hooks on init */
+    autoLoad?: boolean;
+    /** Default injection mode */
+    defaultInjectionMode?: InjectionMode;
+}
+/**
+ * Trigger engine options
+ */
+interface TriggerEngineOptions {
+    /** Project path */
+    projectPath: string;
+    /** Whether to enable file watching */
+    watchFiles?: boolean;
+    /** Debounce time for file events (ms) */
+    debounceMs?: number;
+}
+/**
+ * Hook event listener
+ */
+type HookEventListener = (event: HookEvent, context: HookContext, result: HookTriggerResult) => void | Promise<void>;
+/**
+ * Matcher function type
+ */
+type MatcherFunction = (trigger: string, context: HookContext) => boolean;
+
+/**
+ * Hook Manager
+ *
+ * Manages skill hooks for automatic triggering across all supported agents.
+ */
+
+/**
+ * HookManager - Manages skill hooks for automatic triggering
+ */
+declare class HookManager {
+    private hooks;
+    private listeners;
+    private options;
+    constructor(options: HookManagerOptions);
+    /**
+     * Register a new hook
+     */
+    registerHook(hook: Omit<SkillHook, 'id'> & {
+        id?: string;
+    }): SkillHook;
+    /**
+     * Unregister a hook by ID
+     */
+    unregisterHook(id: string): boolean;
+    /**
+     * Get a hook by ID
+     */
+    getHook(id: string): SkillHook | undefined;
+    /**
+     * Get all hooks
+     */
+    getAllHooks(): SkillHook[];
+    /**
+     * Get hooks for a specific event
+     */
+    getHooksForEvent(event: HookEvent): SkillHook[];
+    /**
+     * Update a hook
+     */
+    updateHook(id: string, updates: Partial<SkillHook>): SkillHook | undefined;
+    /**
+     * Enable a hook
+     */
+    enableHook(id: string): boolean;
+    /**
+     * Disable a hook
+     */
+    disableHook(id: string): boolean;
+    /**
+     * Trigger hooks for an event
+     */
+    trigger(event: HookEvent, context: HookContext): Promise<HookTriggerResult>;
+    /**
+     * Add event listener
+     */
+    addListener(listener: HookEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeListener(listener: HookEventListener): void;
+    /**
+     * Load hooks from config file
+     */
+    load(): void;
+    /**
+     * Save hooks to config file
+     */
+    save(): void;
+    /**
+     * Generate agent-specific hook configuration
+     */
+    generateAgentHooks(agent: AgentType): string | Record<string, unknown>;
+    /**
+     * Generate Claude Code hooks.json format
+     */
+    private generateClaudeCodeHooks;
+    /**
+     * Map SkillKit events to Claude Code events
+     */
+    private mapToClaudeCodeEvent;
+    /**
+     * Generate Claude Code command for a hook
+     */
+    private generateClaudeCommand;
+    /**
+     * Generate Cursor rules with hooks
+     */
+    private generateCursorHooks;
+    /**
+     * Generate OpenCode hooks
+     */
+    private generateOpenCodeHooks;
+    /**
+     * Generate generic AGENTS.md injection for unsupported agents
+     */
+    private generateGenericHooks;
+    /**
+     * Check if trigger matches the pattern
+     */
+    private matchesTrigger;
+    /**
+     * Evaluate condition expression
+     */
+    private evaluateCondition;
+    /**
+     * Resolve a value from context
+     */
+    private resolveValue;
+    /**
+     * Apply agent-specific overrides to a hook
+     */
+    private applyAgentOverrides;
+    /**
+     * Activate a skill from a hook
+     */
+    private activateSkill;
+    /**
+     * Load skill content (placeholder - integrates with skill loader)
+     */
+    private loadSkillContent;
+    /**
+     * Notify all listeners of a trigger event
+     */
+    private notifyListeners;
+}
+/**
+ * Create a HookManager instance
+ */
+declare function createHookManager(options: HookManagerOptions): HookManager;
+
+/**
+ * Skill Trigger Engine
+ *
+ * Monitors events and triggers skill activation based on configured hooks.
+ */
+
+/**
+ * SkillTriggerEngine - Monitors events and triggers skill activation
+ */
+declare class SkillTriggerEngine {
+    private hookManager;
+    private options;
+    private watchers;
+    private listeners;
+    private isRunning;
+    private currentAgent;
+    constructor(hookManager: HookManager, options: TriggerEngineOptions);
+    /**
+     * Start the trigger engine
+     */
+    start(agent?: AgentType): void;
+    /**
+     * Stop the trigger engine
+     */
+    stop(): void;
+    /**
+     * Set the current agent
+     */
+    setAgent(agent: AgentType): void;
+    /**
+     * Manually trigger an event
+     */
+    triggerEvent(event: HookEvent, trigger: string, metadata?: Record<string, unknown>): Promise<HookTriggerResult>;
+    /**
+     * Trigger file:open event
+     */
+    triggerFileOpen(filePath: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger file:save event
+     */
+    triggerFileSave(filePath: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger file:create event
+     */
+    triggerFileCreate(filePath: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger file:delete event
+     */
+    triggerFileDelete(filePath: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger task:start event
+     */
+    triggerTaskStart(taskName: string, taskId?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger task:complete event
+     */
+    triggerTaskComplete(taskName: string, taskId?: string, success?: boolean): Promise<HookTriggerResult>;
+    /**
+     * Trigger commit:pre event
+     */
+    triggerPreCommit(message?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger commit:post event
+     */
+    triggerPostCommit(commitHash?: string, message?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger error:occur event
+     */
+    triggerError(error: Error | string, context?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger test:fail event
+     */
+    triggerTestFail(testName: string, error?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger test:pass event
+     */
+    triggerTestPass(testName: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger build:start event
+     */
+    triggerBuildStart(command?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger build:fail event
+     */
+    triggerBuildFail(error?: string): Promise<HookTriggerResult>;
+    /**
+     * Trigger build:success event
+     */
+    triggerBuildSuccess(): Promise<HookTriggerResult>;
+    /**
+     * Add event listener
+     */
+    addListener(listener: HookEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeListener(listener: HookEventListener): void;
+    /**
+     * Check if engine is running
+     */
+    isActive(): boolean;
+    /**
+     * Start file watcher
+     */
+    private startFileWatcher;
+    /**
+     * Stop file watcher
+     */
+    private stopFileWatcher;
+    /**
+     * Check if a path should be ignored
+     */
+    private shouldIgnore;
+}
+/**
+ * Create a SkillTriggerEngine instance
+ */
+declare function createTriggerEngine(hookManager: HookManager, options: TriggerEngineOptions): SkillTriggerEngine;
+
+/**
+ * Team Orchestration Types
+ *
+ * Types for multi-agent team coordination with task assignment and review workflows.
+ */
+
+/**
+ * Team status
+ */
+type TeamStatus = 'forming' | 'working' | 'reviewing' | 'completing' | 'shutdown';
+/**
+ * Agent instance status
+ */
+type AgentStatus = 'idle' | 'planning' | 'executing' | 'reviewing' | 'shutdown_requested' | 'shutdown';
+/**
+ * Orchestrator task status
+ */
+type OrchestratorTaskStatus = 'pending' | 'assigned' | 'planning' | 'plan_pending' | 'approved' | 'in_progress' | 'review' | 'completed' | 'failed';
+/**
+ * Message type
+ */
+type MessageType = 'direct' | 'broadcast' | 'plan_submit' | 'plan_approve' | 'plan_reject' | 'shutdown_request' | 'shutdown_approve' | 'task_assign' | 'task_update' | 'review_request' | 'review_complete';
+/**
+ * Review stage name
+ */
+type ReviewStageName = 'spec-compliance' | 'code-quality' | 'security' | 'testing' | 'custom';
+/**
+ * Issue severity
+ */
+type IssueSeverity = 'critical' | 'important' | 'minor';
+/**
+ * Team orchestrator configuration
+ */
+interface OrchestratorTeamConfig {
+    /** Team name */
+    name: string;
+    /** Leader agent type */
+    leaderAgent: AgentType;
+    /** Teammate agent types */
+    teammateAgents?: AgentType[];
+    /** Auto-spawn teammates */
+    autoSpawn?: boolean;
+    /** Require plan approval before execution */
+    requirePlanApproval?: boolean;
+    /** Review stages to apply */
+    reviewStages?: ReviewStageName[];
+    /** Timeout for tasks (ms) */
+    taskTimeout?: number;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Team instance
+ */
+interface Team {
+    /** Unique team ID */
+    id: string;
+    /** Team name */
+    name: string;
+    /** Leader agent */
+    leader: AgentInstance;
+    /** Teammate agents */
+    teammates: AgentInstance[];
+    /** Team tasks */
+    tasks: Task[];
+    /** Team status */
+    status: TeamStatus;
+    /** Creation time */
+    createdAt: Date;
+    /** Configuration */
+    config: OrchestratorTeamConfig;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agent instance
+ */
+interface AgentInstance {
+    /** Unique agent ID */
+    id: string;
+    /** Agent role */
+    role: 'leader' | 'teammate';
+    /** Agent type */
+    agentType: AgentType;
+    /** Agent status */
+    status: AgentStatus;
+    /** Current task ID */
+    currentTask?: string;
+    /** Spawn time */
+    spawnedAt: Date;
+    /** Last activity time */
+    lastActivityAt: Date;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Task files specification
+ */
+interface TaskFiles {
+    /** Files to create */
+    create?: string[];
+    /** Files to modify */
+    modify?: string[];
+    /** Test files */
+    test?: string[];
+}
+/**
+ * Plan step
+ */
+interface PlanStep {
+    /** Step number */
+    number: number;
+    /** Step description */
+    description: string;
+    /** Step type */
+    type: 'test' | 'verify' | 'implement' | 'commit' | 'review';
+    /** Code snippet (optional) */
+    code?: string;
+    /** Command to run (optional) */
+    command?: string;
+    /** Expected output (optional) */
+    expectedOutput?: string;
+}
+/**
+ * Task plan
+ */
+interface TaskPlan {
+    /** Plan steps */
+    steps: PlanStep[];
+    /** Estimated time in minutes */
+    estimatedMinutes?: number;
+    /** Plan submission time */
+    submittedAt: Date;
+    /** Plan approval time */
+    approvedAt?: Date;
+    /** Rejection reason */
+    rejectionReason?: string;
+    /** Approver ID */
+    approvedBy?: string;
+}
+/**
+ * Task result
+ */
+interface TaskResult {
+    /** Whether task succeeded */
+    success: boolean;
+    /** Output/summary */
+    output: string;
+    /** Files created */
+    filesCreated?: string[];
+    /** Files modified */
+    filesModified?: string[];
+    /** Test results */
+    testResults?: TestResult[];
+    /** Completion time */
+    completedAt: Date;
+    /** Errors if any */
+    errors?: string[];
+}
+/**
+ * Test result
+ */
+interface TestResult {
+    /** Test name */
+    name: string;
+    /** Whether test passed */
+    passed: boolean;
+    /** Error message */
+    error?: string;
+    /** Duration in ms */
+    durationMs?: number;
+}
+/**
+ * Task
+ */
+interface Task {
+    /** Unique task ID */
+    id: string;
+    /** Task name */
+    name: string;
+    /** Task description */
+    description: string;
+    /** Full specification */
+    spec: string;
+    /** Files involved */
+    files: TaskFiles;
+    /** Assigned agent ID */
+    assignee?: string;
+    /** Task status */
+    status: OrchestratorTaskStatus;
+    /** Task plan */
+    plan?: TaskPlan;
+    /** Task result */
+    result?: TaskResult;
+    /** Priority (higher = more important) */
+    priority?: number;
+    /** Dependencies (task IDs) */
+    dependencies?: string[];
+    /** Creation time */
+    createdAt: Date;
+    /** Last update time */
+    updatedAt: Date;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Review issue
+ */
+interface ReviewIssue {
+    /** Issue severity */
+    severity: IssueSeverity;
+    /** Issue description */
+    description: string;
+    /** File path */
+    file?: string;
+    /** Line number */
+    line?: number;
+    /** Suggested fix */
+    suggestion?: string;
+}
+/**
+ * Review result
+ */
+interface ReviewResult {
+    /** Whether review passed */
+    passed: boolean;
+    /** Review issues */
+    issues: ReviewIssue[];
+    /** Summary */
+    summary: string;
+    /** Reviewer ID */
+    reviewerId?: string;
+    /** Review time */
+    reviewedAt: Date;
+}
+/**
+ * Review stage
+ */
+interface ReviewStage {
+    /** Stage name */
+    name: ReviewStageName;
+    /** Stage prompt */
+    prompt: string;
+    /** Required to pass */
+    required: boolean;
+    /** Reviewer (leader or specific agent) */
+    reviewer?: 'leader' | string;
+}
+/**
+ * Team message
+ */
+interface TeamMessage {
+    /** Message ID */
+    id: string;
+    /** Message type */
+    type: MessageType;
+    /** Sender agent ID */
+    from: string;
+    /** Recipient agent ID (for direct messages) */
+    to?: string;
+    /** Message content */
+    content: string;
+    /** Related task ID */
+    taskId?: string;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Task filter
+ */
+interface TaskFilter {
+    /** Filter by status */
+    status?: OrchestratorTaskStatus | OrchestratorTaskStatus[];
+    /** Filter by assignee */
+    assignee?: string;
+    /** Filter by priority */
+    minPriority?: number;
+    /** Include completed tasks */
+    includeCompleted?: boolean;
+}
+/**
+ * Team orchestrator options
+ */
+interface OrchestratorOptions {
+    /** Project path */
+    projectPath: string;
+    /** Default review stages */
+    defaultReviewStages?: ReviewStage[];
+    /** Require plan approval by default */
+    requirePlanApproval?: boolean;
+    /** Task timeout (ms) */
+    taskTimeout?: number;
+    /** Enable methodology integration */
+    enableMethodology?: boolean;
+    /** Verbose logging */
+    verbose?: boolean;
+}
+/**
+ * Plan result
+ */
+interface PlanResult {
+    /** Whether all tasks completed */
+    success: boolean;
+    /** Task results */
+    taskResults: Map<string, TaskResult>;
+    /** Failed tasks */
+    failedTasks: string[];
+    /** Total duration (ms) */
+    durationMs: number;
+}
+/**
+ * Message handler
+ */
+type MessageHandler = (message: TeamMessage) => void | Promise<void>;
+/**
+ * Task event
+ */
+type TaskEvent = 'task:created' | 'task:assigned' | 'task:plan_submitted' | 'task:plan_approved' | 'task:plan_rejected' | 'task:started' | 'task:completed' | 'task:failed';
+/**
+ * Team event
+ */
+type TeamEvent = 'team:created' | 'team:teammate_spawned' | 'team:teammate_shutdown' | 'team:shutdown';
+/**
+ * Task event listener
+ */
+type TaskEventListener = (event: TaskEvent, task: Task) => void | Promise<void>;
+/**
+ * Team event listener
+ */
+type TeamEventListener = (event: TeamEvent, team: Team, agent?: AgentInstance) => void | Promise<void>;
+
+/**
+ * Task Manager
+ *
+ * Manages tasks within a team with status tracking and assignment.
+ */
+
+/**
+ * TaskManager - Manages team tasks
+ */
+declare class TaskManager {
+    private tasks;
+    private listeners;
+    /**
+     * Create a new task
+     */
+    createTask(name: string, description: string, spec: string, options?: {
+        files?: TaskFiles;
+        priority?: number;
+        dependencies?: string[];
+        metadata?: Record<string, unknown>;
+    }): Task;
+    /**
+     * Get a task by ID
+     */
+    getTask(taskId: string): Task | undefined;
+    /**
+     * Get all tasks
+     */
+    getAllTasks(): Task[];
+    /**
+     * List tasks with optional filter
+     */
+    listTasks(filter?: TaskFilter): Task[];
+    /**
+     * Assign a task to an agent
+     */
+    assignTask(taskId: string, agentId: string): Task | undefined;
+    /**
+     * Unassign a task
+     */
+    unassignTask(taskId: string): Task | undefined;
+    /**
+     * Submit a plan for a task
+     */
+    submitPlan(taskId: string, plan: Omit<TaskPlan, 'submittedAt'>): Task | undefined;
+    /**
+     * Approve a task plan
+     */
+    approvePlan(taskId: string, approverId: string): Task | undefined;
+    /**
+     * Reject a task plan
+     */
+    rejectPlan(taskId: string, reason: string): Task | undefined;
+    /**
+     * Start a task (mark as in progress)
+     */
+    startTask(taskId: string): Task | undefined;
+    /**
+     * Mark task as under review
+     */
+    markForReview(taskId: string): Task | undefined;
+    /**
+     * Complete a task
+     */
+    completeTask(taskId: string, result: TaskResult): Task | undefined;
+    /**
+     * Fail a task
+     */
+    failTask(taskId: string, errors: string[]): Task | undefined;
+    /**
+     * Update task status
+     */
+    updateStatus(taskId: string, status: OrchestratorTaskStatus): Task | undefined;
+    /**
+     * Delete a task
+     */
+    deleteTask(taskId: string): boolean;
+    /**
+     * Get tasks by status
+     */
+    getTasksByStatus(status: OrchestratorTaskStatus): Task[];
+    /**
+     * Get tasks for an agent
+     */
+    getTasksForAgent(agentId: string): Task[];
+    /**
+     * Get pending tasks (unassigned)
+     */
+    getPendingTasks(): Task[];
+    /**
+     * Get next available task for assignment
+     */
+    getNextTask(): Task | undefined;
+    /**
+     * Check if all tasks are complete
+     */
+    allTasksComplete(): boolean;
+    /**
+     * Get completion stats
+     */
+    getStats(): {
+        total: number;
+        pending: number;
+        inProgress: number;
+        completed: number;
+        failed: number;
+    };
+    /**
+     * Add event listener
+     */
+    addListener(listener: TaskEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeListener(listener: TaskEventListener): void;
+    /**
+     * Emit task event
+     */
+    private emit;
+    /**
+     * Clear all tasks
+     */
+    clear(): void;
+    /**
+     * Export tasks to JSON
+     */
+    toJSON(): Task[];
+    /**
+     * Import tasks from JSON
+     */
+    fromJSON(tasks: Task[]): void;
+}
+/**
+ * Create a TaskManager instance
+ */
+declare function createTaskManager(): TaskManager;
+
+/**
+ * Team Message Bus
+ *
+ * Handles inter-agent communication within a team.
+ */
+
+/**
+ * TeamMessageBus - Handles team communication
+ */
+declare class TeamMessageBus {
+    private messages;
+    private handlers;
+    private globalHandlers;
+    private maxMessages;
+    constructor(options?: {
+        maxMessages?: number;
+    });
+    /**
+     * Send a direct message to a specific agent
+     */
+    send(from: string, to: string, content: string, options?: {
+        type?: MessageType;
+        taskId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<TeamMessage>;
+    /**
+     * Broadcast a message to all agents
+     */
+    broadcast(from: string, content: string, options?: {
+        taskId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<TeamMessage>;
+    /**
+     * Submit a plan for approval
+     */
+    submitPlan(from: string, leaderId: string, taskId: string, planSummary: string): Promise<TeamMessage>;
+    /**
+     * Approve a plan
+     */
+    approvePlan(leaderId: string, teammateId: string, taskId: string, feedback?: string): Promise<TeamMessage>;
+    /**
+     * Reject a plan
+     */
+    rejectPlan(leaderId: string, teammateId: string, taskId: string, reason: string): Promise<TeamMessage>;
+    /**
+     * Request shutdown
+     */
+    requestShutdown(from: string, leaderId: string, reason?: string): Promise<TeamMessage>;
+    /**
+     * Approve shutdown
+     */
+    approveShutdown(leaderId: string, agentId: string): Promise<TeamMessage>;
+    /**
+     * Send task assignment notification
+     */
+    notifyTaskAssignment(leaderId: string, agentId: string, taskId: string, taskSummary: string): Promise<TeamMessage>;
+    /**
+     * Request review
+     */
+    requestReview(from: string, reviewerId: string, taskId: string, details: string): Promise<TeamMessage>;
+    /**
+     * Complete review
+     */
+    completeReview(reviewerId: string, agentId: string, taskId: string, result: string, passed: boolean): Promise<TeamMessage>;
+    /**
+     * Register a message handler for an agent
+     */
+    registerHandler(agentId: string, handler: MessageHandler): void;
+    /**
+     * Unregister a message handler
+     */
+    unregisterHandler(agentId: string, handler: MessageHandler): void;
+    /**
+     * Register a global message handler (receives all messages)
+     */
+    registerGlobalHandler(handler: MessageHandler): void;
+    /**
+     * Unregister a global handler
+     */
+    unregisterGlobalHandler(handler: MessageHandler): void;
+    /**
+     * Get messages for an agent
+     */
+    getMessagesForAgent(agentId: string): TeamMessage[];
+    /**
+     * Get messages from an agent
+     */
+    getMessagesFromAgent(agentId: string): TeamMessage[];
+    /**
+     * Get messages for a task
+     */
+    getMessagesForTask(taskId: string): TeamMessage[];
+    /**
+     * Get all messages
+     */
+    getAllMessages(): TeamMessage[];
+    /**
+     * Get recent messages
+     */
+    getRecentMessages(count: number): TeamMessage[];
+    /**
+     * Get messages by type
+     */
+    getMessagesByType(type: MessageType): TeamMessage[];
+    /**
+     * Get conversation between two agents
+     */
+    getConversation(agent1: string, agent2: string): TeamMessage[];
+    /**
+     * Clear all messages
+     */
+    clear(): void;
+    /**
+     * Add a message to the history
+     */
+    private addMessage;
+    /**
+     * Notify handlers for a specific agent
+     */
+    private notifyHandlers;
+    /**
+     * Notify global handlers
+     */
+    private notifyGlobalHandlers;
+    /**
+     * Get message count
+     */
+    get messageCount(): number;
+}
+/**
+ * Create a TeamMessageBus instance
+ */
+declare function createMessageBus(options?: {
+    maxMessages?: number;
+}): TeamMessageBus;
+
+/**
+ * Team Orchestrator
+ *
+ * Coordinates multi-agent teams with task assignment, plan approval, and review workflows.
+ */
+
+/**
+ * TeamOrchestrator - Coordinates multi-agent teams
+ */
+declare class TeamOrchestrator {
+    private teams;
+    private taskManagers;
+    private messageBuses;
+    private listeners;
+    private options;
+    constructor(options: OrchestratorOptions);
+    /**
+     * Spawn a new team
+     */
+    spawnTeam(config: OrchestratorTeamConfig): Promise<Team>;
+    /**
+     * Spawn a teammate agent
+     */
+    spawnTeammate(teamId: string, agentType: AgentType): Promise<AgentInstance>;
+    /**
+     * Get a team by ID
+     */
+    getTeam(teamId: string): Team | undefined;
+    /**
+     * Get all teams
+     */
+    getAllTeams(): Team[];
+    /**
+     * Get task manager for a team
+     */
+    getTaskManager(teamId: string): TaskManager | undefined;
+    /**
+     * Get message bus for a team
+     */
+    getMessageBus(teamId: string): TeamMessageBus | undefined;
+    /**
+     * Create a task in a team
+     */
+    createTask(teamId: string, name: string, description: string, spec: string, options?: Parameters<TaskManager['createTask']>[3]): Promise<Task>;
+    /**
+     * Assign a task to an agent
+     */
+    assignTask(teamId: string, taskId: string, agentId: string): Promise<Task | undefined>;
+    /**
+     * List tasks in a team
+     */
+    listTasks(teamId: string, filter?: TaskFilter): Task[];
+    /**
+     * Submit a plan for a task
+     */
+    submitPlan(teamId: string, taskId: string, plan: Omit<TaskPlan, 'submittedAt'>): Promise<Task | undefined>;
+    /**
+     * Approve a task plan
+     */
+    approvePlan(teamId: string, taskId: string): Promise<Task | undefined>;
+    /**
+     * Reject a task plan
+     */
+    rejectPlan(teamId: string, taskId: string, reason: string): Promise<Task | undefined>;
+    /**
+     * Request agent shutdown
+     */
+    requestShutdown(teamId: string, agentId: string, reason?: string): Promise<void>;
+    /**
+     * Approve agent shutdown
+     */
+    approveShutdown(teamId: string, agentId: string): Promise<void>;
+    /**
+     * Send a message
+     */
+    send(teamId: string, from: string, to: string, content: string, taskId?: string): Promise<void>;
+    /**
+     * Broadcast a message
+     */
+    broadcast(teamId: string, from: string, content: string): Promise<void>;
+    /**
+     * Run review on a task
+     */
+    runReview(teamId: string, taskId: string, stage: ReviewStage, _implementation: string): Promise<ReviewResult>;
+    /**
+     * Execute a full plan with all tasks
+     */
+    executePlan(teamId: string): Promise<PlanResult>;
+    /**
+     * Shutdown a team
+     */
+    shutdownTeam(teamId: string): Promise<void>;
+    /**
+     * Get team stats
+     */
+    getTeamStats(teamId: string): {
+        agents: {
+            total: number;
+            active: number;
+            idle: number;
+        };
+        tasks: ReturnType<TaskManager['getStats']>;
+        messages: number;
+    } | undefined;
+    /**
+     * Add event listener
+     */
+    addListener(listener: TeamEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeListener(listener: TeamEventListener): void;
+    /**
+     * Find an agent in a team
+     */
+    private findAgent;
+    /**
+     * Emit team event
+     */
+    private emit;
+}
+/**
+ * Create a TeamOrchestrator instance
+ */
+declare function createTeamOrchestrator(options: OrchestratorOptions): TeamOrchestrator;
+
+/**
+ * Structured Plan Types
+ *
+ * Types for bite-sized task plans with structured execution.
+ * Supports parsing, validation, and execution of development plans.
+ */
+/**
+ * Step type in a task
+ */
+type StepType = 'test' | 'verify' | 'implement' | 'commit' | 'review' | 'setup' | 'cleanup';
+/**
+ * Plan status
+ */
+type PlanStatus = 'draft' | 'ready' | 'executing' | 'paused' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Task step within a plan task
+ */
+interface TaskStep {
+    /** Step number */
+    number: number;
+    /** Step description */
+    description: string;
+    /** Step type */
+    type: StepType;
+    /** Code snippet (optional) */
+    code?: string;
+    /** Programming language for code */
+    language?: string;
+    /** Command to run (optional) */
+    command?: string;
+    /** Expected output (optional) */
+    expectedOutput?: string;
+    /** Whether this step is critical (failure stops execution) */
+    critical?: boolean;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Task files specification
+ */
+interface PlanTaskFiles {
+    /** Files to create */
+    create?: string[];
+    /** Files to modify */
+    modify?: string[];
+    /** Test files */
+    test?: string[];
+    /** Files to delete */
+    delete?: string[];
+}
+/**
+ * Task within a structured plan
+ */
+interface PlanTask {
+    /** Task ID */
+    id: number;
+    /** Task name */
+    name: string;
+    /** Task description */
+    description?: string;
+    /** Files involved */
+    files: PlanTaskFiles;
+    /** Steps to complete the task */
+    steps: TaskStep[];
+    /** Estimated time in minutes (target: 2-5 min) */
+    estimatedMinutes?: number;
+    /** Dependencies (task IDs that must complete first) */
+    dependencies?: number[];
+    /** Tags for categorization */
+    tags?: string[];
+    /** Priority (higher = more important) */
+    priority?: number;
+    /** Assigned agent type */
+    assignee?: string;
+    /** Task status */
+    status?: 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped';
+    /** Completion result */
+    result?: PlanTaskResult;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Task result after execution
+ */
+interface PlanTaskResult {
+    /** Whether task succeeded */
+    success: boolean;
+    /** Output summary */
+    output: string;
+    /** Files created */
+    filesCreated?: string[];
+    /** Files modified */
+    filesModified?: string[];
+    /** Errors if any */
+    errors?: string[];
+    /** Duration in milliseconds */
+    durationMs?: number;
+    /** Completion timestamp */
+    completedAt: Date;
+}
+/**
+ * Structured plan
+ */
+interface StructuredPlan {
+    /** Plan name */
+    name: string;
+    /** Version */
+    version?: string;
+    /** Goal/objective */
+    goal: string;
+    /** Architecture description */
+    architecture?: string;
+    /** Tech stack */
+    techStack?: string[];
+    /** Tasks in the plan */
+    tasks: PlanTask[];
+    /** Plan status */
+    status: PlanStatus;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt?: Date;
+    /** Link to design document */
+    designDoc?: string;
+    /** Author */
+    author?: string;
+    /** Tags */
+    tags?: string[];
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Validation issue
+ */
+interface ValidationIssue {
+    /** Issue type */
+    type: 'error' | 'warning' | 'info';
+    /** Issue message */
+    message: string;
+    /** Related task ID */
+    taskId?: number;
+    /** Related step number */
+    stepNumber?: number;
+    /** Suggestion for fix */
+    suggestion?: string;
+}
+/**
+ * Validation result
+ */
+interface PlanValidationResult {
+    /** Whether the plan is valid */
+    valid: boolean;
+    /** Validation issues */
+    issues: ValidationIssue[];
+    /** Statistics */
+    stats: {
+        /** Total tasks */
+        totalTasks: number;
+        /** Total steps */
+        totalSteps: number;
+        /** Estimated total time in minutes */
+        estimatedMinutes: number;
+        /** Tasks with tests */
+        tasksWithTests: number;
+        /** Tasks with commits */
+        tasksWithCommits: number;
+        /** Average steps per task */
+        avgStepsPerTask: number;
+    };
+}
+/**
+ * Plan parse options
+ */
+interface ParseOptions {
+    /** Strict mode (fail on warnings) */
+    strict?: boolean;
+    /** Validate after parsing */
+    validate?: boolean;
+    /** Default step type */
+    defaultStepType?: StepType;
+}
+/**
+ * Plan generation options
+ */
+interface GenerateOptions {
+    /** Target task size in minutes */
+    targetTaskMinutes?: number;
+    /** Include tests in every task */
+    includeTests?: boolean;
+    /** Include commits after each task */
+    includeCommits?: boolean;
+    /** Tech stack to use */
+    techStack?: string[];
+    /** Author name */
+    author?: string;
+}
+/**
+ * Plan execution options
+ */
+interface PlanExecutionOptions {
+    /** Dry run (don't actually execute) */
+    dryRun?: boolean;
+    /** Stop on first error */
+    stopOnError?: boolean;
+    /** Parallel execution (for independent tasks) */
+    parallel?: boolean;
+    /** Timeout per task in milliseconds */
+    taskTimeout?: number;
+    /** Progress callback */
+    onProgress?: (taskId: number, step: number, status: string) => void;
+    /** Task complete callback */
+    onTaskComplete?: (task: PlanTask, result: PlanTaskResult) => void;
+}
+/**
+ * Plan execution result
+ */
+interface PlanExecutionResult {
+    /** Whether the plan completed successfully */
+    success: boolean;
+    /** Tasks that completed */
+    completedTasks: number[];
+    /** Tasks that failed */
+    failedTasks: number[];
+    /** Tasks that were skipped */
+    skippedTasks: number[];
+    /** Total duration in milliseconds */
+    durationMs: number;
+    /** Task results */
+    taskResults: Map<number, PlanTaskResult>;
+    /** Errors */
+    errors?: string[];
+}
+/**
+ * Plan event types
+ */
+type PlanEvent = 'plan:created' | 'plan:updated' | 'plan:validated' | 'plan:execution_started' | 'plan:task_started' | 'plan:task_completed' | 'plan:task_failed' | 'plan:execution_completed' | 'plan:execution_failed' | 'plan:execution_cancelled' | 'plan:paused' | 'plan:resumed';
+/**
+ * Plan event listener
+ */
+type PlanEventListener = (event: PlanEvent, plan: StructuredPlan, task?: PlanTask, result?: PlanTaskResult) => void | Promise<void>;
+
+/**
+ * Plan Parser
+ *
+ * Parses markdown plans into structured StructuredPlan format.
+ * Supports multiple plan formats and extracts tasks, steps, and metadata.
+ */
+
+/**
+ * PlanParser - Parse markdown plans to structured format
+ */
+declare class PlanParser {
+    private defaultStepType;
+    constructor(options?: {
+        defaultStepType?: StepType;
+    });
+    /**
+     * Parse a markdown plan into structured format
+     */
+    parse(markdown: string, _options?: ParseOptions): StructuredPlan;
+    /**
+     * Parse files from a line
+     */
+    private parseFiles;
+    /**
+     * Extract file paths from a string
+     */
+    private extractFilePaths;
+    /**
+     * Infer step type from description
+     */
+    private inferStepType;
+    /**
+     * Finalize a step
+     */
+    private finalizeStep;
+    /**
+     * Finalize a task
+     */
+    private finalizeTask;
+    /**
+     * Parse a plan file from path
+     */
+    parseFile(filePath: string, options?: ParseOptions): Promise<StructuredPlan>;
+}
+/**
+ * Create a PlanParser instance
+ */
+declare function createPlanParser(options?: {
+    defaultStepType?: StepType;
+}): PlanParser;
+
+/**
+ * Plan Validator
+ *
+ * Validates structured plans for completeness, correctness, and best practices.
+ */
+
+/**
+ * Validation options
+ */
+interface ValidatorOptions {
+    /** Maximum task duration in minutes */
+    maxTaskMinutes?: number;
+    /** Minimum task duration in minutes */
+    minTaskMinutes?: number;
+    /** Require tests in each task */
+    requireTests?: boolean;
+    /** Require commits in each task */
+    requireCommits?: boolean;
+    /** Maximum steps per task */
+    maxStepsPerTask?: number;
+    /** Minimum steps per task */
+    minStepsPerTask?: number;
+    /** Require file specifications */
+    requireFiles?: boolean;
+    /** Strict mode (treat warnings as errors) */
+    strict?: boolean;
+}
+/**
+ * PlanValidator - Validate structured plans
+ */
+declare class PlanValidator {
+    private options;
+    constructor(options?: ValidatorOptions);
+    /**
+     * Validate a structured plan
+     */
+    validate(plan: StructuredPlan): PlanValidationResult;
+    /**
+     * Validate plan-level fields
+     */
+    private validatePlanFields;
+    /**
+     * Validate tasks
+     */
+    private validateTasks;
+    /**
+     * Validate task fields
+     */
+    private validateTaskFields;
+    /**
+     * Validate task steps
+     */
+    private validateTaskSteps;
+    /**
+     * Validate dependencies
+     */
+    private validateDependencies;
+    /**
+     * Find circular dependencies
+     */
+    private findCircularDependencies;
+    /**
+     * Calculate plan statistics
+     */
+    private calculateStats;
+    /**
+     * Quick validation check (just returns valid/invalid)
+     */
+    isValid(plan: StructuredPlan): boolean;
+    /**
+     * Get errors only
+     */
+    getErrors(plan: StructuredPlan): ValidationIssue[];
+    /**
+     * Get warnings only
+     */
+    getWarnings(plan: StructuredPlan): ValidationIssue[];
+}
+/**
+ * Create a PlanValidator instance
+ */
+declare function createPlanValidator(options?: ValidatorOptions): PlanValidator;
+/**
+ * Quick validation helper
+ */
+declare function validatePlan(plan: StructuredPlan, options?: ValidatorOptions): PlanValidationResult;
+
+/**
+ * Plan Generator
+ *
+ * Generates structured plans and converts them to markdown format.
+ */
+
+/**
+ * Task template for common patterns
+ */
+interface TaskTemplate {
+    name: string;
+    description: string;
+    steps: Array<{
+        type: StepType;
+        description: string;
+        code?: string;
+        command?: string;
+    }>;
+    estimatedMinutes: number;
+}
+/**
+ * Common task templates
+ */
+declare const TASK_TEMPLATES: Record<string, TaskTemplate>;
+/**
+ * PlanGenerator - Generate and format structured plans
+ */
+declare class PlanGenerator {
+    private options;
+    constructor(options?: GenerateOptions);
+    /**
+     * Create a new empty plan
+     */
+    createPlan(name: string, goal: string): StructuredPlan;
+    /**
+     * Add a task to a plan
+     */
+    addTask(plan: StructuredPlan, name: string, options?: {
+        description?: string;
+        files?: PlanTaskFiles;
+        steps?: Partial<TaskStep>[];
+        estimatedMinutes?: number;
+        dependencies?: number[];
+        tags?: string[];
+        priority?: number;
+    }): PlanTask;
+    /**
+     * Add a task from a template
+     */
+    addTaskFromTemplate(plan: StructuredPlan, templateName: keyof typeof TASK_TEMPLATES | string, customization?: {
+        name?: string;
+        description?: string;
+        files?: PlanTaskFiles;
+        dependencies?: number[];
+        tags?: string[];
+    }): PlanTask | undefined;
+    /**
+     * Generate markdown from a structured plan
+     */
+    toMarkdown(plan: StructuredPlan): string;
+    /**
+     * Generate a plan from a simple task list
+     */
+    fromTaskList(name: string, goal: string, taskNames: string[], options?: {
+        architecture?: string;
+        techStack?: string[];
+        template?: keyof typeof TASK_TEMPLATES;
+    }): StructuredPlan;
+    /**
+     * Clone a plan
+     */
+    clonePlan(plan: StructuredPlan, newName?: string): StructuredPlan;
+    /**
+     * Merge two plans
+     */
+    mergePlans(plan1: StructuredPlan, plan2: StructuredPlan, newName?: string): StructuredPlan;
+}
+/**
+ * Create a PlanGenerator instance
+ */
+declare function createPlanGenerator(options?: GenerateOptions): PlanGenerator;
+
+/**
+ * Plan Executor
+ *
+ * Executes structured plans with progress tracking and event handling.
+ */
+
+/**
+ * Step executor function type
+ */
+type StepExecutor = (step: TaskStep, task: PlanTask, plan: StructuredPlan) => Promise<{
+    success: boolean;
+    output: string;
+    error?: string;
+}>;
+/**
+ * PlanExecutor - Execute structured plans
+ */
+declare class PlanExecutor {
+    private listeners;
+    private stepExecutor?;
+    private abortController?;
+    private isPaused;
+    private resumePromise?;
+    private resumeResolve?;
+    constructor(options?: {
+        stepExecutor?: StepExecutor;
+    });
+    /**
+     * Set the step executor
+     */
+    setStepExecutor(executor: StepExecutor): void;
+    /**
+     * Execute a plan
+     */
+    execute(plan: StructuredPlan, options?: PlanExecutionOptions): Promise<PlanExecutionResult>;
+    /**
+     * Execute a single task
+     */
+    private executeTask;
+    /**
+     * Execute with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Build dependency graph
+     */
+    private buildDependencyGraph;
+    /**
+     * Get execution order using topological sort
+     */
+    private getExecutionOrder;
+    /**
+     * Check if dependencies are completed
+     */
+    private checkDependencies;
+    /**
+     * Pause execution
+     */
+    pause(): void;
+    /**
+     * Resume execution
+     */
+    resume(): void;
+    /**
+     * Cancel execution
+     */
+    cancel(): void;
+    /**
+     * Wait if paused
+     */
+    private waitIfPaused;
+    /**
+     * Add event listener
+     */
+    addListener(listener: PlanEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeListener(listener: PlanEventListener): void;
+    /**
+     * Emit event
+     */
+    private emit;
+    /**
+     * Check if currently executing
+     */
+    isExecuting(): boolean;
+    /**
+     * Check if paused
+     */
+    isPausedState(): boolean;
+}
+/**
+ * Create a PlanExecutor instance
+ */
+declare function createPlanExecutor(options?: {
+    stepExecutor?: StepExecutor;
+}): PlanExecutor;
+/**
+ * Default step executor (dry run)
+ */
+declare const dryRunExecutor: StepExecutor;
+/**
+ * Shell step executor (runs commands)
+ */
+declare const shellExecutor: StepExecutor;
+
+/**
+ * Command Types
+ *
+ * Type definitions for slash commands and agent integration.
+ */
+
+/**
+ * Command argument definition
+ */
+interface CommandArg {
+    /** Argument name */
+    name: string;
+    /** Argument description */
+    description: string;
+    /** Whether the argument is required */
+    required?: boolean;
+    /** Default value */
+    default?: string;
+    /** Argument type */
+    type?: 'string' | 'number' | 'boolean' | 'file' | 'choice';
+    /** Valid choices (for type: 'choice') */
+    choices?: string[];
+    /** Validation pattern (regex) */
+    pattern?: string;
+}
+/**
+ * Slash command definition
+ */
+interface SlashCommand {
+    /** Command name (without slash) */
+    name: string;
+    /** Command description */
+    description: string;
+    /** Skill to invoke when command is executed */
+    skill: string;
+    /** Alternative names for the command */
+    aliases?: string[];
+    /** Whether to disable model invocation (user-only) */
+    disableModelInvocation?: boolean;
+    /** Command arguments */
+    args?: CommandArg[];
+    /** Category for grouping */
+    category?: string;
+    /** Usage examples */
+    examples?: string[];
+    /** Tags for filtering */
+    tags?: string[];
+    /** Priority for ordering */
+    priority?: number;
+    /** Whether the command is hidden from help */
+    hidden?: boolean;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Command execution context
+ */
+interface CommandContext {
+    /** The command being executed */
+    command: SlashCommand;
+    /** Parsed arguments */
+    args: Record<string, unknown>;
+    /** Agent executing the command */
+    agent: AgentType;
+    /** Working directory */
+    cwd: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Additional context */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Command execution result
+ */
+interface SlashCommandResult {
+    /** Whether execution succeeded */
+    success: boolean;
+    /** Output message */
+    output?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Data returned by the command */
+    data?: unknown;
+    /** Duration in milliseconds */
+    durationMs?: number;
+}
+/**
+ * Command handler function
+ */
+type CommandHandler = (context: CommandContext) => Promise<SlashCommandResult>;
+/**
+ * Registered command with handler
+ */
+interface RegisteredCommand extends SlashCommand {
+    /** Command handler function */
+    handler?: CommandHandler;
+    /** Whether the command is enabled */
+    enabled: boolean;
+    /** Source of the command (plugin, skill, etc.) */
+    source?: string;
+}
+/**
+ * Command registry options
+ */
+interface CommandRegistryOptions {
+    /** Allow command overrides */
+    allowOverrides?: boolean;
+    /** Validate commands on registration */
+    validateOnRegister?: boolean;
+    /** Default handler for commands without one */
+    defaultHandler?: CommandHandler;
+}
+/**
+ * Command generator options
+ */
+interface CommandGeneratorOptions {
+    /** Target agent */
+    agent: AgentType;
+    /** Include hidden commands */
+    includeHidden?: boolean;
+    /** Include disabled commands */
+    includeDisabled?: boolean;
+    /** Output format */
+    format?: 'markdown' | 'json' | 'native';
+    /** Custom template */
+    template?: string;
+}
+/**
+ * Command search options
+ */
+interface CommandSearchOptions {
+    /** Search query */
+    query?: string;
+    /** Filter by category */
+    category?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Include hidden commands */
+    includeHidden?: boolean;
+    /** Include disabled commands */
+    includeDisabled?: boolean;
+    /** Maximum results */
+    limit?: number;
+}
+/**
+ * Command validation result
+ */
+interface CommandValidationResult {
+    /** Whether the command is valid */
+    valid: boolean;
+    /** Validation errors */
+    errors: string[];
+    /** Validation warnings */
+    warnings: string[];
+}
+/**
+ * Agent command format
+ */
+interface AgentCommandFormat {
+    /** Agent type */
+    agent: AgentType;
+    /** File extension */
+    extension: string;
+    /** Directory for commands */
+    directory: string;
+    /** Whether agent supports slash commands */
+    supportsSlashCommands: boolean;
+    /** Whether agent supports command files */
+    supportsCommandFiles: boolean;
+    /** Template for generating commands */
+    template?: string;
+}
+/**
+ * Command event types
+ */
+type CommandEvent = 'command:registered' | 'command:unregistered' | 'command:enabled' | 'command:disabled' | 'command:executed' | 'command:failed';
+/**
+ * Command event listener
+ */
+type CommandEventListener = (event: CommandEvent, command: RegisteredCommand, result?: SlashCommandResult) => void;
+/**
+ * Command import/export format
+ */
+interface CommandBundle {
+    /** Bundle version */
+    version: string;
+    /** Commands in the bundle */
+    commands: SlashCommand[];
+    /** Bundle metadata */
+    metadata?: {
+        name?: string;
+        description?: string;
+        author?: string;
+        createdAt?: Date;
+    };
+}
+
+/**
+ * Command Registry
+ *
+ * Central registry for managing slash commands.
+ */
+
+/**
+ * CommandRegistry - Central registry for slash commands
+ */
+declare class CommandRegistry {
+    private commands;
+    private aliases;
+    private listeners;
+    private options;
+    constructor(options?: CommandRegistryOptions);
+    /**
+     * Register a command
+     */
+    register(command: SlashCommand, handler?: CommandHandler, source?: string): void;
+    /**
+     * Register multiple commands
+     */
+    registerAll(commands: SlashCommand[], handler?: CommandHandler, source?: string): void;
+    /**
+     * Unregister a command
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a command by name or alias
+     */
+    get(name: string): RegisteredCommand | undefined;
+    /**
+     * Check if a command exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered commands
+     */
+    getAll(includeDisabled?: boolean): RegisteredCommand[];
+    /**
+     * Search commands
+     */
+    search(options?: CommandSearchOptions): RegisteredCommand[];
+    /**
+     * Enable a command
+     */
+    enable(name: string): boolean;
+    /**
+     * Disable a command
+     */
+    disable(name: string): boolean;
+    /**
+     * Execute a command
+     */
+    execute(name: string, context: Omit<CommandContext, 'command'>): Promise<SlashCommandResult>;
+    /**
+     * Validate a command
+     */
+    validate(command: SlashCommand): CommandValidationResult;
+    /**
+     * Get categories
+     */
+    getCategories(): string[];
+    /**
+     * Get commands by category
+     */
+    getByCategory(category: string): RegisteredCommand[];
+    /**
+     * Export commands to bundle
+     */
+    export(includeDisabled?: boolean): CommandBundle;
+    /**
+     * Import commands from bundle
+     */
+    import(bundle: CommandBundle, handler?: CommandHandler, source?: string): number;
+    /**
+     * Clear all commands
+     */
+    clear(): void;
+    /**
+     * Get command count
+     */
+    get size(): number;
+    /**
+     * Add event listener
+     */
+    addListener(listener: CommandEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeListener(listener: CommandEventListener): void;
+    /**
+     * Emit event
+     */
+    private emit;
+}
+/**
+ * Create a CommandRegistry instance
+ */
+declare function createCommandRegistry(options?: CommandRegistryOptions): CommandRegistry;
+
+/**
+ * Command Generator
+ *
+ * Generates agent-specific slash commands from skills.
+ */
+
+/**
+ * CommandGenerator - Generate agent-specific commands
+ */
+declare class CommandGenerator {
+    private options;
+    constructor(options?: Partial<CommandGeneratorOptions>);
+    /**
+     * Get agent command format
+     */
+    getAgentFormat(agent: AgentType): AgentCommandFormat;
+    /**
+     * Generate command from skill
+     */
+    fromSkill(skill: CanonicalSkill, commandName?: string): SlashCommand;
+    /**
+     * Generate commands from multiple skills
+     */
+    fromSkills(skills: CanonicalSkill[]): SlashCommand[];
+    /**
+     * Generate Claude Code command file
+     */
+    generateClaudeCommand(command: SlashCommand | RegisteredCommand): string;
+    /**
+     * Generate Claude Code commands
+     */
+    generateClaudeCommands(commands: (SlashCommand | RegisteredCommand)[]): Map<string, string>;
+    /**
+     * Generate Cursor rules with @-mention syntax
+     */
+    generateCursorRules(commands: (SlashCommand | RegisteredCommand)[]): string;
+    /**
+     * Generate OpenCode commands
+     */
+    generateOpenCodeCommands(commands: (SlashCommand | RegisteredCommand)[]): Map<string, string>;
+    /**
+     * Generate Copilot commands (agent skills format)
+     */
+    generateCopilotCommands(commands: (SlashCommand | RegisteredCommand)[]): Map<string, string>;
+    /**
+     * Generate commands for any agent
+     */
+    generate(commands: (SlashCommand | RegisteredCommand)[], agent: AgentType): Map<string, string> | string;
+    /**
+     * Generate JSON manifest of commands
+     */
+    generateManifest(commands: (SlashCommand | RegisteredCommand)[]): string;
+    /**
+     * Check if command should be included
+     */
+    private shouldInclude;
+    /**
+     * Slugify a string for command name
+     */
+    private slugify;
+    /**
+     * Infer category from skill
+     */
+    private inferCategory;
+    /**
+     * Generate usage examples
+     */
+    private generateExamples;
+}
+/**
+ * Create a CommandGenerator instance
+ */
+declare function createCommandGenerator(options?: Partial<CommandGeneratorOptions>): CommandGenerator;
+/**
+ * Get agent format info
+ */
+declare function getAgentFormat(agent: AgentType): AgentCommandFormat;
+/**
+ * Check if agent supports slash commands
+ */
+declare function supportsSlashCommands(agent: AgentType): boolean;
+
+interface AIProvider {
+    name: string;
+    search(query: string, skills: SearchableSkill[]): Promise<AISearchResult[]>;
+    generateSkill(example: SkillExample): Promise<GeneratedSkill>;
+}
+interface SearchableSkill {
+    name: string;
+    description?: string;
+    content: string;
+    tags?: string[];
+    source?: string;
+}
+interface AISearchResult {
+    skill: SearchableSkill;
+    relevance: number;
+    reasoning: string;
+}
+interface SkillExample {
+    description: string;
+    context?: string;
+    codeExamples?: string[];
+    expectedBehavior?: string;
+    targetAgent?: string;
+}
+interface GeneratedSkill {
+    name: string;
+    description: string;
+    content: string;
+    tags: string[];
+    confidence: number;
+    reasoning: string;
+}
+interface AIConfig {
+    provider: 'anthropic' | 'openai' | 'none';
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+interface AISearchOptions {
+    limit?: number;
+    minRelevance?: number;
+    includeReasoning?: boolean;
+}
+interface AIGenerateOptions {
+    targetAgent?: string;
+    includeTests?: boolean;
+    includeDocumentation?: boolean;
+}
+
+declare class AISearch {
+    private provider;
+    constructor(provider: AIProvider);
+    search(query: string, skills: SearchableSkill[], options?: AISearchOptions): Promise<AISearchResult[]>;
+    searchByIntent(intent: string, skills: SearchableSkill[], options?: AISearchOptions): Promise<AISearchResult[]>;
+    findSimilar(skill: SearchableSkill, allSkills: SearchableSkill[], options?: AISearchOptions): Promise<AISearchResult[]>;
+}
+
+declare class AISkillGenerator {
+    private provider;
+    constructor(provider: AIProvider);
+    generate(example: SkillExample, options?: AIGenerateOptions): Promise<GeneratedSkill>;
+    generateFromCode(code: string, description: string, options?: AIGenerateOptions): Promise<GeneratedSkill>;
+    generateFromTemplate(templateName: string, variables: Record<string, string>, options?: AIGenerateOptions): Promise<GeneratedSkill>;
+    private addAgentMetadata;
+    validateGenerated(skill: GeneratedSkill): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+
+declare class AIManager {
+    private config;
+    private provider;
+    private search;
+    private generator;
+    constructor(config: AIConfig);
+    searchSkills(query: string, skills: SearchableSkill[], options?: AISearchOptions): Promise<AISearchResult[]>;
+    searchByIntent(intent: string, skills: SearchableSkill[], options?: AISearchOptions): Promise<AISearchResult[]>;
+    findSimilar(skill: SearchableSkill, allSkills: SearchableSkill[], options?: AISearchOptions): Promise<AISearchResult[]>;
+    generateSkill(example: SkillExample, options?: AIGenerateOptions): Promise<GeneratedSkill>;
+    generateFromCode(code: string, description: string, options?: AIGenerateOptions): Promise<GeneratedSkill>;
+    generateFromTemplate(templateName: string, variables: Record<string, string>, options?: AIGenerateOptions): Promise<GeneratedSkill>;
+    validateGenerated(skill: GeneratedSkill): {
+        valid: boolean;
+        errors: string[];
+    };
+    private createProvider;
+    getProviderName(): string;
+    updateConfig(config: Partial<AIConfig>): void;
+}
+
+declare abstract class BaseAIProvider implements AIProvider {
+    abstract name: string;
+    abstract search(query: string, skills: SearchableSkill[]): Promise<AISearchResult[]>;
+    abstract generateSkill(example: SkillExample): Promise<GeneratedSkill>;
+    protected buildSearchPrompt(query: string, skills: SearchableSkill[]): string;
+    protected buildGeneratePrompt(example: SkillExample): string;
+    protected parseSearchResponse(response: string, skills: SearchableSkill[]): AISearchResult[];
+    protected parseGenerateResponse(response: string): GeneratedSkill;
+}
+
+declare class MockAIProvider extends BaseAIProvider {
+    name: string;
+    search(query: string, skills: SearchableSkill[]): Promise<AISearchResult[]>;
+    generateSkill(example: SkillExample): Promise<GeneratedSkill>;
+    private buildReasoning;
+    private generateName;
+    private generateTags;
+    private generateContent;
+}
+
+type AuditEventType = 'skill.install' | 'skill.uninstall' | 'skill.sync' | 'skill.translate' | 'skill.execute' | 'team.create' | 'team.share' | 'team.import' | 'team.sync' | 'bundle.create' | 'bundle.export' | 'bundle.import' | 'plugin.install' | 'plugin.uninstall' | 'plugin.enable' | 'plugin.disable' | 'workflow.execute' | 'ai.search' | 'ai.generate';
+interface AuditEvent {
+    id: string;
+    timestamp: Date;
+    type: AuditEventType;
+    user?: string;
+    action: string;
+    resource: string;
+    details?: Record<string, unknown>;
+    success: boolean;
+    error?: string;
+    duration?: number;
+}
+interface AuditQuery {
+    types?: AuditEventType[];
+    user?: string;
+    resource?: string;
+    startDate?: Date;
+    endDate?: Date;
+    success?: boolean;
+    limit?: number;
+    offset?: number;
+}
+interface AuditStats {
+    totalEvents: number;
+    successRate: number;
+    eventsByType: Record<AuditEventType, number>;
+    recentErrors: AuditEvent[];
+    topResources: Array<{
+        resource: string;
+        count: number;
+    }>;
+}
+interface AuditExportOptions {
+    format: 'json' | 'csv' | 'text';
+    query?: AuditQuery;
+}
+
+declare class AuditLogger {
+    private logFile;
+    private buffer;
+    private flushInterval;
+    private flushing;
+    constructor(logDir: string);
+    log(type: AuditEventType, action: string, resource: string, details?: Record<string, unknown>, success?: boolean, error?: string, duration?: number): Promise<void>;
+    query(query?: AuditQuery): Promise<AuditEvent[]>;
+    stats(): Promise<AuditStats>;
+    export(options: AuditExportOptions): Promise<string>;
+    clear(olderThan?: Date): Promise<number>;
+    flush(): Promise<void>;
+    private doFlush;
+    destroy(): Promise<void>;
+    private startAutoFlush;
+    private loadEvents;
+    private saveEvents;
+    private filterEvents;
+    private generateId;
+    private toCsv;
+    private toText;
+}
+
+export { AGENT_CLI_CONFIGS, AGENT_FORMAT_MAP, type AIConfig, type AIGenerateOptions, AIManager, type AIProvider, AISearch, type AISearchOptions, type AISearchResult, AISkillGenerator, APIBasedCompressor, type APICompressionConfig, type ActivatedSkill, type AgentAdapterInfo, type AgentCLIConfig, type AgentCommandFormat, AgentConfig, type AgentExecutionResult, type AgentHookFormat, type AgentInstance, type AgentStatus, AgentType, type AssertionResult, type AuditEvent, type AuditEventType, type AuditExportOptions, AuditLogger, type AuditQuery, type AuditStats, BaseAIProvider, BitbucketProvider, type BundleManifest, CIRCLECI_CONFIG_TEMPLATE, CONTEXT_DIR, CONTEXT_FILE, type CanonicalSkill, type CheckpointHandler, type CheckpointResponse, type CloneOptions, type CloneResult, type CommandArg, type CommandBundle, type CommandContext, type CommandEvent, type CommandEventListener, CommandGenerator, type CommandGeneratorOptions, type CommandHandler, type CommandPlugin, CommandRegistry, type CommandRegistryOptions, type CommandResult, type CommandSearchOptions, type CommandValidationResult, type CompressedLearning, type CompressionEngine, type CompressionOptions, type CompressionResult, type ContextCategory, type ContextExportOptions, type ContextImportOptions, type ContextLoadOptions, ContextLoader, ContextManager, ContextSync, type ContextSyncOptions, CopilotTranslator, type CurrentExecution, CursorTranslator, DEFAULT_CACHE_TTL, DEFAULT_CONTEXT_CATEGORIES, DEFAULT_MEMORY_CONFIG, DEFAULT_SCORING_WEIGHTS, DEFAULT_SKILL_SOURCES, DependencyInfo, Detection, type DetectionSource, type DiscoveredSkill, type ExecutableSkill, type ExecutableTask, type ExecutableTaskType, type ExecutionHistory, type ExecutionOptions, type ExecutionProgressCallback, type ExecutionProgressEvent, type ExecutionStrategy, type ExecutionTaskStatus, type FormatCategory, type FormatTranslator, type FreshnessResult, GITHUB_ACTION_TEMPLATE, GITLAB_CI_TEMPLATE, type GenerateOptions, type GeneratedSkill, GitHubProvider, GitLabProvider, GitProvider, type GitProviderAdapter, type HookConfig, type HookContext, type HookError, type HookEvent, type HookEventListener, HookManager, type HookManagerOptions, type HookTriggerResult, INDEX_CACHE_HOURS, INDEX_PATH, type ImportOptions, type IndexSource, type InjectedMemory, type InjectionMode, type InjectionOptions, type InjectionResult, type InstallOptions, type InstallResult, type InstalledPackInfo, type InstalledSkillInfo, type IssueSeverity, KNOWN_SKILL_REPOS, type Learning, LearningConsolidator, LearningStore, type LearningStoreData, type LoadedContext, LocalProvider, MARKETPLACE_CACHE_FILE, MarketplaceAggregator, type MarketplaceConfig, type MarketplaceIndex, type MarketplaceSearchOptions, type MarketplaceSearchResult, type MarketplaceSkill, type MatchCategory, type MatchReason, type MatcherFunction, MemoryCompressor, type MemoryConfig, MemoryEnabledEngine, type MemoryEnabledEngineOptions, type MemoryFull, type MemoryIndex, MemoryIndexStore, MemoryInjector, MemoryObserver, type MemoryObserverConfig, type MemoryPaths, type MemoryPreview, type MemorySearchOptions, type MemorySearchResult, type MemoryStatus, type MemorySummary, type MessageHandler, type MessageType, MethodologyLoader, MethodologyManager, type MethodologyManagerOptions, type MethodologyPack, type MethodologySearchQuery, type MethodologySearchResult, type MethodologySkill, type MethodologySkillMetadata, type MethodologyState, type MethodologySyncResult, MockAIProvider, type ObservableEvent, type ObservableEventType, type Observation, type ObservationContent, ObservationStore, type ObservationStoreData, type ObservationType, type OrchestratorOptions, type OrchestratorTaskStatus, type OrchestratorTeamConfig, PRE_COMMIT_CONFIG_TEMPLATE, PRE_COMMIT_HOOK_TEMPLATE, PROJECT_TYPE_HINTS, type ParseOptions, type PlanEvent, type PlanEventListener, type PlanExecutionOptions, type PlanExecutionResult, PlanExecutor, PlanGenerator, PlanParser, type PlanResult, type PlanStatus, type PlanStep, type PlanTask, type PlanTaskFiles, type PlanTaskResult, type PlanValidationResult, PlanValidator, type Plugin, type PluginConfig, type PluginContext, type PluginHooks, PluginLoader, PluginManager, type PluginMetadata, ProjectContext, ProjectDetector, ProjectPatterns, type ProjectProfile, ProjectStack, type ProviderPlugin, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegisteredCommand, type RegistrySkill, type ReviewIssue, type ReviewResult, type ReviewStage, type ReviewStageName, RuleBasedCompressor, SESSION_FILE, SKILL_DISCOVERY_PATHS, type ScoredSkill, type ScoringWeights, type SearchOptions, type SearchResult, type SearchableSkill, type SessionDecision, SessionManager, type SessionState, type SessionTask, type ShareOptions, type SharedSkill, Skill, SkillBundle, type SkillExample, SkillExecutionEngine, type SkillExecutionEvent, type SkillExecutionResult, type SkillExecutor, type SkillExecutorOptions, SkillFrontmatter, type SkillHook, type SkillIndex, SkillLocation, SkillMdTranslator, SkillMetadata, SkillPreferences, type SkillSource, SkillSummary, type SkillTestCase, type SkillTestSuite, SkillTriggerEngine, SkillkitConfig, type SlashCommand, type SlashCommandResult, type StepExecutor, type StepType, type StructuredPlan, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_TECH, TASK_TEMPLATES, type Task, type TaskEvent, type TaskEventListener, type TaskExecutionResult, type TaskFiles, type TaskFilter, TaskManager, type TaskPlan, type TaskResult, type TaskStatus, type TaskStep, type TaskTemplate, type Team, type TeamConfig, type TeamEvent, type TeamEventListener, TeamManager, type TeamMember, type TeamMessage, TeamMessageBus, TeamOrchestrator, type TeamRegistry, type TeamStatus, type TestAssertion, type TestAssertionType, type TestCaseResult, type TestProgressEvent, type TestResult, type TestRunnerOptions, type TestSuiteResult, TranslatableSkillFrontmatter, type TranslationOptions, type TranslationPath, type TranslationResult, type TranslatorPlugin, TranslatorRegistry, type TriggerEngineOptions, type UpdateOptions, type ValidationError, type ValidationIssue, type ValidationResult, type ValidationWarning, type ValidatorOptions, type VerificationRule, WORKFLOWS_DIR, WORKFLOW_EXTENSION, type WaveExecutionStatus, WindsurfTranslator, type Workflow, type WorkflowExecution, type WorkflowExecutionStatus, WorkflowOrchestrator, type WorkflowProgressCallback, type WorkflowSkill, type WorkflowWave, analyzeProject, buildSkillIndex, canTranslate, copilotTranslator, createAPIBasedCompressor, createCommandGenerator, createCommandRegistry, createContextLoader, createContextManager, createContextSync, createExecutionEngine, createHookManager, createMarketplaceAggregator, createMemoryCompressor, createMemoryEnabledEngine, createMemoryInjector, createMemoryObserver, createMessageBus, createMethodologyLoader, createMethodologyManager, createPlanExecutor, createPlanGenerator, createPlanParser, createPlanValidator, createPluginManager, createRecommendationEngine, createRuleBasedCompressor, createSessionManager, createSimulatedSkillExecutor, createSkillBundle, createSkillExecutor, createTaskManager, createTeamManager, createTeamOrchestrator, createTestSuiteFromFrontmatter, createTriggerEngine, createWorkflowOrchestrator, createWorkflowTemplate, cursorTranslator, detectProvider, detectSkillFormat, discoverSkills, dryRunExecutor, estimateTokens, executeWithAgent, exportBundle, extractField, extractFrontmatter, extractSkillMetadata, fetchSkillsFromRepo, findAllSkills, findSkill, formatSkillAsPrompt, getAgentCLIConfig, getAgentConfigPath, getAgentFormat, getAllProviders, getAvailableCLIAgents, getBuiltinPacksDir, getCICDTemplate, getExecutionStrategy, getGlobalConfigPath, getIndexStatus, getInstallDir, getManualExecutionInstructions, getMemoryPaths, getMemoryStatus, getProjectConfigPath, getProvider, getSearchDirs, getStackTags, getSupportedTranslationAgents, getTechTags, globalMemoryDirectoryExists, importBundle, initContext, initProject, initializeMemoryDirectory, isAgentCLIAvailable, isGitUrl, isIndexStale, isLocalPath, isPathInside, listCICDTemplates, listWorkflows, loadConfig, loadContext, loadIndex, loadMetadata, loadPlugin, loadPluginsFromDirectory, loadSkillMetadata, loadWorkflow, loadWorkflowByName, memoryDirectoryExists, parseShorthand, parseSkill, parseSkillContent, parseSource, parseWorkflow, readSkillContent, runTestSuite, saveConfig, saveIndex, saveSkillMetadata, saveWorkflow, serializeWorkflow, setSkillEnabled, shellExecutor, skillMdTranslator, supportsSlashCommands, syncToAgent, syncToAllAgents, translateSkill, translateSkillFile, translatorRegistry, validateBuiltinPacks, validatePackDirectory, validatePackManifest, validatePlan, validateSkill, validateSkillContent, validateWorkflow, windsurfTranslator, wrapProgressCallbackWithMemory };