@skillkit/core 1.3.1 → 1.4.0

package/dist/index.d.ts

@@ -1952,6 +1952,126 @@ declare function syncToAllAgents(projectPath?: string, options?: ContextSyncOpti
  */
 declare function syncToAgent(agent: AgentType, projectPath?: string, options?: ContextSyncOptions): Promise<SyncResult>;
 
+/**
+ * Context Loader
+ *
+ * Smart context loading with token budgets and category-based loading.
+ */
+/**
+ * Context category with size limits
+ */
+interface ContextCategory {
+    /** Category name */
+    name: string;
+    /** Maximum tokens for this category */
+    maxTokens: number;
+    /** Whether to always load this category */
+    alwaysLoad: boolean;
+    /** File path (relative to project) */
+    file?: string;
+    /** Inline content */
+    content?: string;
+}
+/**
+ * Context loading options
+ */
+interface ContextLoadOptions {
+    /** Total token budget */
+    totalBudget?: number;
+    /** Categories to load (load all if not specified) */
+    categories?: string[];
+    /** Whether to warn when approaching budget limits */
+    warnOnBudgetLimit?: boolean;
+}
+/**
+ * Loaded context result
+ */
+interface LoadedContext {
+    /** All loaded content combined */
+    content: string;
+    /** Total tokens used */
+    totalTokens: number;
+    /** Budget remaining */
+    budgetRemaining: number;
+    /** Categories loaded */
+    categoriesLoaded: string[];
+    /** Categories skipped (due to budget or not found) */
+    categoriesSkipped: string[];
+    /** Warnings generated */
+    warnings: string[];
+    /** Whether budget is near limit (>50% used) */
+    nearBudgetLimit: boolean;
+    /** Whether context is degraded (>70% used) */
+    contextDegraded: boolean;
+}
+/**
+ * Default context categories
+ */
+declare const DEFAULT_CONTEXT_CATEGORIES: ContextCategory[];
+/**
+ * Rough estimate of tokens from text
+ * (approximation: ~4 characters per token for English text)
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Context Loader class
+ */
+declare class ContextLoader {
+    private projectPath;
+    private categories;
+    private defaultBudget;
+    constructor(projectPath: string, options?: {
+        categories?: ContextCategory[];
+        defaultBudget?: number;
+    });
+    /**
+     * Load context based on options
+     */
+    load(options?: ContextLoadOptions): LoadedContext;
+    /**
+     * Load a single category
+     */
+    private loadCategory;
+    /**
+     * Get category by name
+     */
+    getCategory(name: string): ContextCategory | undefined;
+    /**
+     * Add a custom category
+     */
+    addCategory(category: ContextCategory): void;
+    /**
+     * Remove a category
+     */
+    removeCategory(name: string): void;
+    /**
+     * Get estimated context size for categories
+     */
+    estimateSize(categoryNames?: string[]): {
+        category: string;
+        tokens: number;
+        available: boolean;
+    }[];
+    /**
+     * Check if context would exceed budget threshold
+     */
+    wouldExceedThreshold(additionalTokens: number, threshold?: number): boolean;
+    /**
+     * Suggest spawning fresh agent if context is degraded
+     */
+    shouldSpawnFreshAgent(): {
+        should: boolean;
+        reason?: string;
+    };
+}
+/**
+ * Create a context loader
+ */
+declare function createContextLoader(projectPath: string, options?: {
+    categories?: ContextCategory[];
+    defaultBudget?: number;
+}): ContextLoader;
+
 /**
  * Skill summary for recommendation matching
  */
@@ -2231,4 +2351,2056 @@ declare class RecommendationEngine {
  */
 declare function createRecommendationEngine(weights?: Partial<ScoringWeights>): RecommendationEngine;
 
-export { AGENT_FORMAT_MAP, type AgentAdapterInfo, AgentConfig, AgentType, BitbucketProvider, CONTEXT_DIR, CONTEXT_FILE, type CanonicalSkill, type CloneOptions, type CloneResult, type CommandResult, type ContextExportOptions, type ContextImportOptions, ContextManager, ContextSync, type ContextSyncOptions, CopilotTranslator, CursorTranslator, DEFAULT_SCORING_WEIGHTS, DependencyInfo, Detection, type DetectionSource, type DiscoveredSkill, type FormatCategory, type FormatTranslator, type FreshnessResult, GitHubProvider, GitLabProvider, GitProvider, type GitProviderAdapter, type IndexSource, type InstallOptions, LocalProvider, type MatchCategory, type MatchReason, PROJECT_TYPE_HINTS, ProjectContext, ProjectDetector, ProjectPatterns, type ProjectProfile, ProjectStack, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegistrySkill, SKILL_DISCOVERY_PATHS, type ScoredSkill, type ScoringWeights, type SearchOptions, type SearchResult, Skill, SkillFrontmatter, type SkillIndex, SkillLocation, SkillMdTranslator, SkillMetadata, SkillPreferences, SkillSummary, SkillkitConfig, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_TECH, TranslatableSkillFrontmatter, type TranslationOptions, type TranslationPath, type TranslationResult, TranslatorRegistry, type UpdateOptions, WindsurfTranslator, analyzeProject, canTranslate, copilotTranslator, createContextManager, createContextSync, createRecommendationEngine, cursorTranslator, detectProvider, detectSkillFormat, discoverSkills, extractField, extractFrontmatter, findAllSkills, findSkill, getAgentConfigPath, getAllProviders, getGlobalConfigPath, getInstallDir, getProjectConfigPath, getProvider, getSearchDirs, getStackTags, getSupportedTranslationAgents, getTechTags, initContext, initProject, isGitUrl, isLocalPath, isPathInside, loadConfig, loadContext, loadMetadata, loadSkillMetadata, parseShorthand, parseSkill, parseSkillContent, parseSource, readSkillContent, saveConfig, saveSkillMetadata, setSkillEnabled, skillMdTranslator, syncToAgent, syncToAllAgents, translateSkill, translateSkillFile, translatorRegistry, validateSkill, windsurfTranslator };
+/**
+ * Known skill repositories to index
+ */
+declare const KNOWN_SKILL_REPOS: readonly [{
+    readonly owner: "anthropics";
+    readonly repo: "courses";
+    readonly description: "Anthropic official courses and skills";
+}, {
+    readonly owner: "vercel-labs";
+    readonly repo: "ai-sdk-preview-internal-knowledge-base";
+    readonly description: "Vercel AI SDK skills";
+}, {
+    readonly owner: "composioHQ";
+    readonly repo: "awesome-claude-code-skills";
+    readonly description: "Curated Claude Code skills";
+}];
+/**
+ * Index file path
+ */
+declare const INDEX_PATH: string;
+declare const INDEX_CACHE_HOURS = 24;
+/**
+ * Fetch skills from a GitHub repository
+ */
+declare function fetchSkillsFromRepo(owner: string, repo: string): Promise<{
+    skills: SkillSummary[];
+    error?: string;
+}>;
+/**
+ * Fetch skills from all known repositories and build index
+ */
+declare function buildSkillIndex(repos?: typeof KNOWN_SKILL_REPOS, onProgress?: (message: string) => void): Promise<{
+    index: SkillIndex;
+    errors: string[];
+}>;
+/**
+ * Save skill index to cache
+ */
+declare function saveIndex(index: SkillIndex): void;
+/**
+ * Load skill index from cache
+ */
+declare function loadIndex(): SkillIndex | null;
+/**
+ * Check if index is stale
+ */
+declare function isIndexStale(index: SkillIndex): boolean;
+/**
+ * Get index status
+ */
+declare function getIndexStatus(): 'missing' | 'stale' | 'fresh';
+
+/**
+ * Session State Types
+ *
+ * Types for managing skill execution sessions with pause/resume support.
+ */
+/**
+ * Status of a task in execution
+ */
+type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'paused';
+/**
+ * A single task within a skill execution
+ */
+interface SessionTask {
+    /** Task identifier */
+    id: string;
+    /** Task name/description */
+    name: string;
+    /** Task type (auto, checkpoint:human-verify, checkpoint:decision, checkpoint:human-action) */
+    type: 'auto' | 'checkpoint:human-verify' | 'checkpoint:decision' | 'checkpoint:human-action';
+    /** Current status */
+    status: TaskStatus;
+    /** Start time */
+    startedAt?: string;
+    /** Completion time */
+    completedAt?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Output/result of the task */
+    output?: string;
+    /** Files modified by this task */
+    filesModified?: string[];
+    /** Git commit SHA if committed */
+    commitSha?: string;
+}
+/**
+ * Current skill execution state
+ */
+interface CurrentExecution {
+    /** Skill being executed */
+    skillName: string;
+    /** Skill source (repo) */
+    skillSource: string;
+    /** Current step/task index */
+    currentStep: number;
+    /** Total steps */
+    totalSteps: number;
+    /** Execution status */
+    status: 'running' | 'paused' | 'completed' | 'failed';
+    /** When execution started */
+    startedAt: string;
+    /** When execution was paused (if paused) */
+    pausedAt?: string;
+    /** Tasks in this execution */
+    tasks: SessionTask[];
+}
+/**
+ * Historical execution record
+ */
+interface ExecutionHistory {
+    /** Skill name */
+    skillName: string;
+    /** Skill source */
+    skillSource: string;
+    /** When execution completed */
+    completedAt: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Final status */
+    status: 'completed' | 'failed' | 'cancelled';
+    /** Git commits created */
+    commits: string[];
+    /** Files modified */
+    filesModified: string[];
+    /** Error if failed */
+    error?: string;
+}
+/**
+ * User decisions made during skill execution
+ */
+interface SessionDecision {
+    /** Decision key/identifier */
+    key: string;
+    /** Decision value */
+    value: string;
+    /** When decision was made */
+    madeAt: string;
+    /** Skill that prompted the decision */
+    skillName?: string;
+}
+/**
+ * Full session state
+ */
+interface SessionState {
+    /** Schema version */
+    version: 1;
+    /** Last activity timestamp */
+    lastActivity: string;
+    /** Project path this session is for */
+    projectPath: string;
+    /** Current execution (if any) */
+    currentExecution?: CurrentExecution;
+    /** Execution history */
+    history: ExecutionHistory[];
+    /** User decisions */
+    decisions: SessionDecision[];
+}
+/**
+ * Session state file path within .skillkit directory
+ */
+declare const SESSION_FILE = "session.yaml";
+
+/**
+ * Session Manager
+ *
+ * Manages session state for skill execution with pause/resume support.
+ */
+
+/**
+ * Session Manager for tracking skill execution state
+ */
+declare class SessionManager {
+    private projectPath;
+    private sessionPath;
+    private state;
+    constructor(projectPath: string);
+    /**
+     * Get session file path
+     */
+    getSessionPath(): string;
+    /**
+     * Load session state from disk
+     */
+    load(): SessionState | null;
+    /**
+     * Save session state to disk
+     */
+    save(): void;
+    /**
+     * Initialize a new session
+     */
+    init(): SessionState;
+    /**
+     * Get current session state (load if needed)
+     */
+    get(): SessionState | null;
+    /**
+     * Get or create session
+     */
+    getOrCreate(): SessionState;
+    /**
+     * Start a new skill execution
+     */
+    startExecution(skillName: string, skillSource: string, tasks: Omit<SessionTask, 'status'>[]): CurrentExecution;
+    /**
+     * Update task status
+     */
+    updateTask(taskId: string, updates: Partial<Pick<SessionTask, 'status' | 'output' | 'error' | 'filesModified' | 'commitSha'>>): void;
+    /**
+     * Advance to next task
+     */
+    advanceToNextTask(): SessionTask | null;
+    /**
+     * Pause current execution
+     */
+    pause(): boolean;
+    /**
+     * Resume paused execution
+     */
+    resume(): boolean;
+    /**
+     * Complete current execution
+     */
+    completeExecution(status: 'completed' | 'failed' | 'cancelled', error?: string): void;
+    /**
+     * Record a user decision
+     */
+    recordDecision(key: string, value: string, skillName?: string): void;
+    /**
+     * Get a decision value
+     */
+    getDecision(key: string): string | undefined;
+    /**
+     * Get execution history
+     */
+    getHistory(limit?: number): ExecutionHistory[];
+    /**
+     * Check if there's an active execution
+     */
+    hasActiveExecution(): boolean;
+    /**
+     * Check if execution is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Clear session (delete file)
+     */
+    clear(): void;
+}
+/**
+ * Create a new session manager
+ */
+declare function createSessionManager(projectPath: string): SessionManager;
+
+/**
+ * Workflow Types
+ *
+ * Types for skill composition and workflow orchestration.
+ */
+/**
+ * A skill reference within a workflow
+ */
+interface WorkflowSkill {
+    /** Skill name or source (e.g., "typescript-strict-mode" or "owner/repo/skill") */
+    skill: string;
+    /** Optional configuration overrides */
+    config?: Record<string, unknown>;
+    /** Optional condition to run this skill */
+    condition?: string;
+}
+/**
+ * A wave of skills to execute (parallel or sequential)
+ */
+interface WorkflowWave {
+    /** Wave name/description */
+    name?: string;
+    /** Whether skills in this wave run in parallel */
+    parallel: boolean;
+    /** Skills to execute in this wave */
+    skills: (string | WorkflowSkill)[];
+    /** Continue to next wave even if this wave has failures */
+    continueOnError?: boolean;
+}
+/**
+ * Workflow definition
+ */
+interface Workflow {
+    /** Workflow name (used as identifier) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Workflow version */
+    version?: string;
+    /** Author information */
+    author?: string;
+    /** Tags for discovery */
+    tags?: string[];
+    /** Waves of skills to execute */
+    waves: WorkflowWave[];
+    /** Environment variables to set */
+    env?: Record<string, string>;
+    /** Pre-execution hooks */
+    preHooks?: string[];
+    /** Post-execution hooks */
+    postHooks?: string[];
+}
+/**
+ * Workflow execution status
+ */
+type WorkflowExecutionStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Status of a wave execution
+ */
+interface WaveExecutionStatus {
+    /** Wave index */
+    waveIndex: number;
+    /** Wave name */
+    waveName?: string;
+    /** Status */
+    status: WorkflowExecutionStatus;
+    /** Skills statuses */
+    skills: {
+        skill: string;
+        status: WorkflowExecutionStatus;
+        startedAt?: string;
+        completedAt?: string;
+        error?: string;
+    }[];
+    /** When wave started */
+    startedAt?: string;
+    /** When wave completed */
+    completedAt?: string;
+}
+/**
+ * Workflow execution state
+ */
+interface WorkflowExecution {
+    /** Workflow being executed */
+    workflow: Workflow;
+    /** Execution ID */
+    executionId: string;
+    /** Overall status */
+    status: WorkflowExecutionStatus;
+    /** Current wave index */
+    currentWave: number;
+    /** Wave statuses */
+    waves: WaveExecutionStatus[];
+    /** When execution started */
+    startedAt: string;
+    /** When execution completed */
+    completedAt?: string;
+    /** Error if failed */
+    error?: string;
+}
+/**
+ * Workflow file location
+ */
+declare const WORKFLOWS_DIR = "workflows";
+declare const WORKFLOW_EXTENSION = ".yaml";
+
+/**
+ * Workflow Parser
+ *
+ * Parses workflow YAML files into Workflow objects.
+ */
+
+/**
+ * Parse a workflow from YAML content
+ */
+declare function parseWorkflow(content: string): Workflow;
+/**
+ * Load a workflow from a file
+ */
+declare function loadWorkflow(filePath: string): Workflow;
+/**
+ * Load a workflow by name from the project's workflows directory
+ */
+declare function loadWorkflowByName(projectPath: string, name: string): Workflow | null;
+/**
+ * List all workflows in a project
+ */
+declare function listWorkflows(projectPath: string): Workflow[];
+/**
+ * Save a workflow to a file
+ */
+declare function saveWorkflow(projectPath: string, workflow: Workflow): string;
+/**
+ * Serialize a workflow to YAML
+ */
+declare function serializeWorkflow(workflow: Workflow): string;
+/**
+ * Validate a workflow
+ */
+declare function validateWorkflow(workflow: Workflow): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create a new workflow from a template
+ */
+declare function createWorkflowTemplate(name: string, description?: string): Workflow;
+
+/**
+ * Workflow Orchestrator
+ *
+ * Executes workflows with wave-based orchestration.
+ */
+
+/**
+ * Skill executor function type
+ */
+type SkillExecutor = (skillName: string, config?: Record<string, unknown>) => Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Progress callback for workflow execution
+ */
+type WorkflowProgressCallback = (event: {
+    type: 'wave_start' | 'wave_complete' | 'skill_start' | 'skill_complete' | 'workflow_complete';
+    waveIndex?: number;
+    waveName?: string;
+    skillName?: string;
+    status?: WorkflowExecutionStatus;
+    error?: string;
+}) => void;
+/**
+ * Workflow Orchestrator
+ *
+ * Manages the execution of workflows with parallel/sequential waves.
+ */
+declare class WorkflowOrchestrator {
+    private execution;
+    private executor;
+    private onProgress?;
+    constructor(executor: SkillExecutor, onProgress?: WorkflowProgressCallback);
+    /**
+     * Get current execution state
+     */
+    getExecution(): WorkflowExecution | null;
+    /**
+     * Execute a workflow
+     */
+    execute(workflow: Workflow): Promise<WorkflowExecution>;
+    /**
+     * Execute a single wave
+     */
+    private executeWave;
+    /**
+     * Execute a single skill
+     */
+    private executeSkill;
+    /**
+     * Pause execution
+     */
+    pause(): boolean;
+    /**
+     * Check if execution should continue
+     */
+    private shouldContinue;
+    /**
+     * Resume execution
+     */
+    resume(): Promise<WorkflowExecution | null>;
+    /**
+     * Cancel execution
+     */
+    cancel(): boolean;
+}
+/**
+ * Create a new workflow orchestrator
+ */
+declare function createWorkflowOrchestrator(executor: SkillExecutor, onProgress?: WorkflowProgressCallback): WorkflowOrchestrator;
+
+/**
+ * Executor Types
+ *
+ * Types for skill execution engine.
+ */
+
+/**
+ * Task type within a skill
+ */
+type ExecutableTaskType = 'auto' | 'checkpoint:human-verify' | 'checkpoint:decision' | 'checkpoint:human-action';
+/**
+ * Task status
+ */
+type ExecutionTaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+/**
+ * Verification rule for a task
+ */
+interface VerificationRule {
+    /** Command to run for verification */
+    command?: string;
+    /** Expected result (success, contains:<text>, matches:<regex>) */
+    expect?: string;
+    /** Human verification prompt */
+    description?: string;
+    /** URL to show for verification */
+    url?: string;
+}
+/**
+ * An executable task within a skill
+ */
+interface ExecutableTask {
+    /** Task identifier */
+    id: string;
+    /** Task name/description */
+    name: string;
+    /** Task type */
+    type: ExecutableTaskType;
+    /** Action description for AI agent */
+    action: string;
+    /** Files expected to be modified */
+    files?: string[];
+    /** Verification rules */
+    verify?: {
+        automated?: VerificationRule[];
+        human?: VerificationRule[];
+    };
+    /** Options for checkpoint:decision type */
+    options?: string[];
+    /** Dependencies (task IDs that must complete first) */
+    dependsOn?: string[];
+}
+/**
+ * Extended skill with execution metadata
+ */
+interface ExecutableSkill {
+    /** Skill name */
+    name: string;
+    /** Skill description */
+    description?: string;
+    /** Skill version */
+    version?: string;
+    /** Skill source (repo or path) */
+    source: string;
+    /** Skill content (instructions) */
+    content: string;
+    /** Executable tasks */
+    tasks?: ExecutableTask[];
+    /** Environment requirements */
+    requirements?: {
+        frameworks?: string[];
+        languages?: string[];
+        libraries?: string[];
+    };
+}
+/**
+ * Task execution result
+ */
+interface TaskExecutionResult {
+    /** Task ID */
+    taskId: string;
+    /** Task name */
+    taskName: string;
+    /** Final status */
+    status: ExecutionTaskStatus;
+    /** Start time */
+    startedAt: string;
+    /** End time (only present for completed/failed/skipped tasks) */
+    completedAt?: string;
+    /** Duration in milliseconds (only present for completed/failed/skipped tasks) */
+    durationMs?: number;
+    /** Output/result */
+    output?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Files modified */
+    filesModified?: string[];
+    /** Git commit SHA if committed */
+    commitSha?: string;
+    /** Verification results */
+    verificationResults?: {
+        automated: {
+            rule: string;
+            passed: boolean;
+            output?: string;
+        }[];
+        human: {
+            description: string;
+            passed: boolean;
+        }[];
+    };
+}
+/**
+ * Skill execution result
+ */
+interface SkillExecutionResult {
+    /** Skill name */
+    skillName: string;
+    /** Skill source */
+    skillSource: string;
+    /** Overall status */
+    status: 'completed' | 'failed' | 'cancelled' | 'paused';
+    /** Start time */
+    startedAt: string;
+    /** End time */
+    completedAt?: string;
+    /** Total duration in milliseconds */
+    durationMs?: number;
+    /** Task results */
+    tasks: TaskExecutionResult[];
+    /** All files modified */
+    filesModified: string[];
+    /** All commits created */
+    commits: string[];
+    /** Error if failed */
+    error?: string;
+}
+/**
+ * Execution options
+ */
+interface ExecutionOptions {
+    /** Target agent to use */
+    agent?: AgentType;
+    /** Whether to create commits per task */
+    autoCommit?: boolean;
+    /** Whether to run verification checks */
+    verify?: boolean;
+    /** Dry run (show what would be done) */
+    dryRun?: boolean;
+    /** Continue on task failure */
+    continueOnError?: boolean;
+    /** Environment variables to set */
+    env?: Record<string, string>;
+}
+/**
+ * Checkpoint response from user
+ */
+interface CheckpointResponse {
+    /** Whether to continue */
+    continue: boolean;
+    /** Selected option (for decision checkpoints) */
+    selectedOption?: string;
+    /** User notes */
+    notes?: string;
+}
+/**
+ * Checkpoint handler function type
+ */
+type CheckpointHandler = (task: ExecutableTask, context: {
+    skillName: string;
+    taskIndex: number;
+    totalTasks: number;
+}) => Promise<CheckpointResponse>;
+
+/**
+ * Skill Execution Engine
+ *
+ * Executes skills with task-based orchestration, verification, and state management.
+ */
+
+/**
+ * Progress event for execution
+ */
+interface ExecutionProgressEvent {
+    type: 'task_start' | 'task_complete' | 'checkpoint' | 'verification' | 'complete';
+    taskId?: string;
+    taskName?: string;
+    taskIndex?: number;
+    totalTasks?: number;
+    status?: ExecutionTaskStatus | 'paused' | 'cancelled';
+    message?: string;
+    error?: string;
+}
+/**
+ * Progress callback type
+ */
+type ExecutionProgressCallback = (event: ExecutionProgressEvent) => void;
+/**
+ * Skill Execution Engine
+ */
+declare class SkillExecutionEngine {
+    private projectPath;
+    private sessionManager;
+    private checkpointHandler?;
+    private onProgress?;
+    constructor(projectPath: string, options?: {
+        checkpointHandler?: CheckpointHandler;
+        onProgress?: ExecutionProgressCallback;
+    });
+    /**
+     * Execute a skill
+     */
+    execute(skill: ExecutableSkill, options?: ExecutionOptions): Promise<SkillExecutionResult>;
+    /**
+     * Resume a paused execution
+     */
+    private resumeExecution;
+    /**
+     * Execute a single task
+     */
+    private executeTask;
+    /**
+     * Handle a checkpoint
+     */
+    private handleCheckpoint;
+    /**
+     * Check if a regex pattern is potentially dangerous (ReDoS-vulnerable)
+     * Rejects patterns with nested quantifiers and other known problematic constructs
+     */
+    private isUnsafeRegexPattern;
+    /**
+     * Safely test a regex pattern with ReDoS prevention
+     *
+     * This method validates patterns before execution to prevent catastrophic backtracking.
+     * Note: This cannot guarantee protection against all ReDoS patterns, but catches common ones.
+     */
+    private safeRegexTest;
+    /**
+     * Run verification for a task
+     *
+     * SECURITY NOTE: Verification commands are executed from skill configuration.
+     * Only run skills from trusted sources. Commands run with the same privileges
+     * as the skillkit process.
+     */
+    private runVerification;
+    /**
+     * Create a dry run result
+     */
+    private createDryRunResult;
+    /**
+     * Pause current execution
+     */
+    pause(): boolean;
+    /**
+     * Check if execution is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Get session manager
+     */
+    getSessionManager(): SessionManager;
+}
+/**
+ * Create a new skill execution engine
+ */
+declare function createExecutionEngine(projectPath: string, options?: {
+    checkpointHandler?: CheckpointHandler;
+    onProgress?: ExecutionProgressCallback;
+}): SkillExecutionEngine;
+
+/**
+ * Agent Execution Module
+ *
+ * Handles real execution of skills through various AI agent CLIs.
+ */
+
+/**
+ * Agent CLI configuration
+ */
+interface AgentCLIConfig {
+    /** Agent type */
+    type: AgentType;
+    /** CLI command name */
+    command: string;
+    /** Whether the agent supports CLI execution */
+    supportsCLI: boolean;
+    /** Arguments to pass the prompt/skill content */
+    promptArgs?: string[];
+    /** Arguments for non-interactive mode */
+    nonInteractiveArgs?: string[];
+    /** Environment variables needed */
+    envVars?: Record<string, string>;
+    /** How to check if agent is installed */
+    checkCommand?: string;
+}
+/**
+ * Execution result from an agent
+ */
+interface AgentExecutionResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    exitCode: number;
+    duration: number;
+}
+/**
+ * Agent CLI configurations
+ */
+declare const AGENT_CLI_CONFIGS: AgentCLIConfig[];
+/**
+ * Get CLI config for an agent
+ */
+declare function getAgentCLIConfig(agentType: AgentType): AgentCLIConfig | undefined;
+/**
+ * Check if an agent CLI is available
+ */
+declare function isAgentCLIAvailable(agentType: AgentType): Promise<boolean>;
+/**
+ * Get all available CLI agents
+ */
+declare function getAvailableCLIAgents(): Promise<AgentType[]>;
+/**
+ * Execute a skill using an agent CLI
+ */
+declare function executeWithAgent(agentType: AgentType, prompt: string, options?: {
+    cwd?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+}): Promise<AgentExecutionResult>;
+/**
+ * Format skill content as a prompt for an agent
+ */
+declare function formatSkillAsPrompt(skillName: string, skillContent: string, taskDescription?: string): string;
+/**
+ * Agent execution strategy
+ */
+type ExecutionStrategy = 'cli' | 'ide' | 'api' | 'manual';
+/**
+ * Get recommended execution strategy for an agent
+ */
+declare function getExecutionStrategy(agentType: AgentType): ExecutionStrategy;
+/**
+ * Get instructions for manual/IDE execution
+ */
+declare function getManualExecutionInstructions(agentType: AgentType, skillPath: string): string;
+
+/**
+ * Skill Testing Framework Types
+ *
+ * Define test cases in skill frontmatter for automated verification.
+ */
+/**
+ * Test assertion types
+ */
+type TestAssertionType = 'file_exists' | 'file_not_exists' | 'file_contains' | 'file_not_contains' | 'file_matches' | 'command_succeeds' | 'command_fails' | 'command_output_contains' | 'json_valid' | 'json_has_key' | 'yaml_valid' | 'type_check' | 'lint_passes' | 'test_passes' | 'env_var_set' | 'port_available' | 'url_responds' | 'custom';
+/**
+ * Test assertion definition
+ */
+interface TestAssertion {
+    /** Assertion type */
+    type: TestAssertionType;
+    /** Target file, command, or URL */
+    target?: string;
+    /** Expected value or pattern */
+    expected?: string | boolean | number;
+    /** Custom command for 'custom' type */
+    command?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Error message on failure */
+    message?: string;
+}
+/**
+ * Test case definition
+ */
+interface SkillTestCase {
+    /** Test name */
+    name: string;
+    /** Test description */
+    description?: string;
+    /** Assertions to run */
+    assertions: TestAssertion[];
+    /** Setup commands to run before test */
+    setup?: string[];
+    /** Cleanup commands to run after test */
+    cleanup?: string[];
+    /** Skip this test */
+    skip?: boolean;
+    /** Only run this test */
+    only?: boolean;
+    /** Tags for filtering */
+    tags?: string[];
+}
+/**
+ * Test suite for a skill
+ */
+interface SkillTestSuite {
+    /** Skill name */
+    skillName: string;
+    /** Test cases */
+    tests: SkillTestCase[];
+    /** Global setup commands */
+    globalSetup?: string[];
+    /** Global cleanup commands */
+    globalCleanup?: string[];
+    /** Default timeout for all tests */
+    defaultTimeout?: number;
+}
+/**
+ * Individual assertion result
+ */
+interface AssertionResult {
+    /** Assertion that was run */
+    assertion: TestAssertion;
+    /** Whether assertion passed */
+    passed: boolean;
+    /** Actual value found */
+    actual?: string;
+    /** Expected value */
+    expected?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    duration: number;
+}
+/**
+ * Test case result
+ */
+interface TestCaseResult {
+    /** Test case that was run */
+    testCase: SkillTestCase;
+    /** Whether all assertions passed */
+    passed: boolean;
+    /** Individual assertion results */
+    assertions: AssertionResult[];
+    /** Setup error if any */
+    setupError?: string;
+    /** Cleanup error if any */
+    cleanupError?: string;
+    /** Total duration in milliseconds */
+    duration: number;
+    /** Whether test was skipped */
+    skipped: boolean;
+}
+/**
+ * Test suite result
+ */
+interface TestSuiteResult {
+    /** Skill name */
+    skillName: string;
+    /** Whether all tests passed */
+    passed: boolean;
+    /** Individual test results */
+    tests: TestCaseResult[];
+    /** Number of tests passed */
+    passedCount: number;
+    /** Number of tests failed */
+    failedCount: number;
+    /** Number of tests skipped */
+    skippedCount: number;
+    /** Total duration in milliseconds */
+    duration: number;
+    /** Global setup error if any */
+    globalSetupError?: string;
+    /** Global cleanup error if any */
+    globalCleanupError?: string;
+}
+/**
+ * Test runner options
+ */
+interface TestRunnerOptions {
+    /** Working directory */
+    cwd?: string;
+    /** Default timeout in milliseconds */
+    timeout?: number;
+    /** Only run tests with these tags */
+    tags?: string[];
+    /** Skip tests with these tags */
+    skipTags?: string[];
+    /** Verbose output */
+    verbose?: boolean;
+    /** Stop on first failure */
+    bail?: boolean;
+    /** Run tests in parallel */
+    parallel?: boolean;
+    /** Progress callback */
+    onProgress?: (event: TestProgressEvent) => void;
+}
+/**
+ * Test progress event
+ */
+interface TestProgressEvent {
+    type: 'suite_start' | 'suite_end' | 'test_start' | 'test_end' | 'assertion_start' | 'assertion_end';
+    skillName?: string;
+    testName?: string;
+    assertionType?: TestAssertionType;
+    passed?: boolean;
+    error?: string;
+}
+
+/**
+ * Skill Test Runner
+ *
+ * Executes test suites and assertions for skill verification.
+ */
+
+/**
+ * Run a test suite
+ */
+declare function runTestSuite(suite: SkillTestSuite, options?: TestRunnerOptions): Promise<TestSuiteResult>;
+/**
+ * Create a test suite from skill frontmatter
+ */
+declare function createTestSuiteFromFrontmatter(skillName: string, frontmatter: Record<string, unknown>): SkillTestSuite | null;
+
+/**
+ * Skill Marketplace Types
+ *
+ * Types for the aggregated skill marketplace.
+ */
+/**
+ * Skill source repository
+ */
+interface SkillSource {
+    /** Repository owner */
+    owner: string;
+    /** Repository name */
+    repo: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Whether this is an official source */
+    official?: boolean;
+    /** Branch to fetch from */
+    branch?: string;
+    /** Path to skills index file */
+    indexPath?: string;
+}
+/**
+ * Skill entry in the marketplace
+ */
+interface MarketplaceSkill {
+    /** Unique identifier (owner/repo/path) */
+    id: string;
+    /** Skill name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Source repository */
+    source: SkillSource;
+    /** Path within the repository */
+    path: string;
+    /** Version if available */
+    version?: string;
+    /** Author */
+    author?: string;
+    /** Tags for categorization */
+    tags: string[];
+    /** Supported agents */
+    agents?: string[];
+    /** GitHub stars (if available) */
+    stars?: number;
+    /** Last updated date */
+    updatedAt?: string;
+    /** Download/install count */
+    downloads?: number;
+    /** Raw content URL */
+    rawUrl?: string;
+}
+/**
+ * Marketplace index (cached locally)
+ */
+interface MarketplaceIndex {
+    /** Index version */
+    version: number;
+    /** When the index was last updated */
+    updatedAt: string;
+    /** Sources included in this index */
+    sources: SkillSource[];
+    /** All skills in the index */
+    skills: MarketplaceSkill[];
+    /** Total skill count */
+    totalCount: number;
+}
+/**
+ * Search options for the marketplace
+ */
+interface MarketplaceSearchOptions {
+    /** Search query */
+    query?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Filter by source */
+    source?: string;
+    /** Filter by agent compatibility */
+    agent?: string;
+    /** Sort by field */
+    sortBy?: 'name' | 'stars' | 'downloads' | 'updatedAt';
+    /** Sort direction */
+    sortOrder?: 'asc' | 'desc';
+    /** Limit results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Search result
+ */
+interface MarketplaceSearchResult {
+    /** Matching skills */
+    skills: MarketplaceSkill[];
+    /** Total matches (before limit) */
+    total: number;
+    /** Query that was searched */
+    query?: string;
+}
+/**
+ * Marketplace configuration
+ */
+interface MarketplaceConfig {
+    /** Custom sources to include */
+    sources?: SkillSource[];
+    /** Cache directory */
+    cacheDir?: string;
+    /** Cache TTL in milliseconds */
+    cacheTTL?: number;
+    /** GitHub token for API access */
+    githubToken?: string;
+}
+/**
+ * Default skill sources
+ */
+declare const DEFAULT_SKILL_SOURCES: SkillSource[];
+/**
+ * Cache file name
+ */
+declare const MARKETPLACE_CACHE_FILE = "marketplace-index.json";
+/**
+ * Default cache TTL (1 hour)
+ */
+declare const DEFAULT_CACHE_TTL: number;
+
+/**
+ * Marketplace Aggregator
+ *
+ * Fetches and indexes skills from multiple GitHub repositories.
+ */
+
+/**
+ * Marketplace Aggregator
+ */
+declare class MarketplaceAggregator {
+    private config;
+    private cacheDir;
+    private cachePath;
+    private index;
+    constructor(config?: MarketplaceConfig);
+    /**
+     * Get all sources (default + custom)
+     */
+    getSources(): SkillSource[];
+    /**
+     * Load cached index
+     */
+    loadCache(): MarketplaceIndex | null;
+    /**
+     * Save index to cache
+     */
+    saveCache(index: MarketplaceIndex): void;
+    /**
+     * Fetch skills from a single source
+     */
+    fetchSource(source: SkillSource): Promise<MarketplaceSkill[]>;
+    /**
+     * Check if a path is an absolute URL
+     */
+    private isAbsoluteUrl;
+    /**
+     * Convert a GitHub URL to raw content URL
+     */
+    private toRawUrl;
+    /**
+     * Parse a skill entry from JSON
+     */
+    private parseSkillEntry;
+    /**
+     * Parse README for skill links
+     */
+    private parseReadmeForSkills;
+    /**
+     * Build raw URL for a skill
+     */
+    private buildRawUrl;
+    /**
+     * Infer tags from name and description
+     */
+    private inferTags;
+    /**
+     * Refresh the marketplace index
+     */
+    refresh(): Promise<MarketplaceIndex>;
+    /**
+     * Get the marketplace index (from cache or refresh)
+     */
+    getIndex(forceRefresh?: boolean): Promise<MarketplaceIndex>;
+    /**
+     * Search the marketplace
+     */
+    search(options?: MarketplaceSearchOptions): Promise<MarketplaceSearchResult>;
+    /**
+     * Get a skill by ID
+     */
+    getSkill(id: string): Promise<MarketplaceSkill | null>;
+    /**
+     * Get skill content
+     */
+    getSkillContent(skill: MarketplaceSkill): Promise<string | null>;
+    /**
+     * Get popular tags
+     */
+    getPopularTags(limit?: number): Promise<{
+        tag: string;
+        count: number;
+    }[]>;
+    /**
+     * Add a custom source
+     */
+    addSource(source: SkillSource): void;
+    /**
+     * Remove a custom source
+     */
+    removeSource(owner: string, repo: string): void;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+}
+/**
+ * Create a marketplace aggregator
+ */
+declare function createMarketplaceAggregator(config?: MarketplaceConfig): MarketplaceAggregator;
+
+/**
+ * CI/CD Templates
+ *
+ * Provides templates for GitHub Actions, pre-commit hooks, and other CI/CD integrations.
+ */
+/**
+ * GitHub Action workflow for skill validation
+ */
+declare const GITHUB_ACTION_TEMPLATE = "# Skill Validation Workflow\n# This workflow validates skills in your repository\n\nname: Validate Skills\n\non:\n  push:\n    paths:\n      - '.claude/skills/**'\n      - '.cursor/skills/**'\n      - 'skills/**'\n  pull_request:\n    paths:\n      - '.claude/skills/**'\n      - '.cursor/skills/**'\n      - 'skills/**'\n\njobs:\n  validate:\n    runs-on: ubuntu-latest\n\n    steps:\n      - name: Checkout\n        uses: actions/checkout@v4\n\n      - name: Setup Node.js\n        uses: actions/setup-node@v4\n        with:\n          node-version: '20'\n\n      - name: Install SkillKit\n        run: npm install -g skillkit\n\n      - name: Validate Skills\n        run: skillkit validate\n\n      - name: Run Skill Tests\n        run: skillkit test --json > test-results.json\n        continue-on-error: true\n\n      - name: Upload Test Results\n        uses: actions/upload-artifact@v4\n        with:\n          name: skill-test-results\n          path: test-results.json\n          retention-days: 30\n\n      - name: Check Test Results\n        run: |\n          if [ -f test-results.json ]; then\n            passed=$(cat test-results.json | jq -r '.passed')\n            if [ \"$passed\" = \"false\" ]; then\n              echo \"Some skill tests failed\"\n              exit 1\n            fi\n          fi\n";
+/**
+ * Pre-commit hook script for skill validation
+ */
+declare const PRE_COMMIT_HOOK_TEMPLATE = "#!/bin/bash\n# SkillKit Pre-commit Hook\n# Validates skills before commit\n\n# Colors for output\nRED='\\033[0;31m'\nGREEN='\\033[0;32m'\nYELLOW='\\033[0;33m'\nNC='\\033[0m' # No Color\n\necho -e \"${YELLOW}Running SkillKit validation...${NC}\"\n\n# Check if skillkit is installed\nif ! command -v skillkit &> /dev/null; then\n    echo -e \"${RED}SkillKit not found. Install with: npm install -g skillkit${NC}\"\n    exit 1\nfi\n\n# Get list of staged skill files\nSKILL_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(md|mdc)$' | grep -E '(skills|.claude|.cursor)')\n\nif [ -z \"$SKILL_FILES\" ]; then\n    echo -e \"${GREEN}No skill files staged, skipping validation.${NC}\"\n    exit 0\nfi\n\necho \"Validating skill files:\"\necho \"$SKILL_FILES\"\n\n# Run validation\nif ! skillkit validate; then\n    echo -e \"${RED}Skill validation failed. Please fix the errors and try again.${NC}\"\n    exit 1\nfi\n\n# Run tests if any\nif skillkit test --json 2>/dev/null | jq -e '.passed == false' > /dev/null 2>&1; then\n    echo -e \"${RED}Skill tests failed. Please fix the failing tests.${NC}\"\n    exit 1\nfi\n\necho -e \"${GREEN}All skills validated successfully!${NC}\"\nexit 0\n";
+/**
+ * Pre-commit config for .pre-commit-config.yaml
+ */
+declare const PRE_COMMIT_CONFIG_TEMPLATE = "# SkillKit Pre-commit Configuration\n# Add this to your .pre-commit-config.yaml\n\nrepos:\n  - repo: local\n    hooks:\n      - id: skillkit-validate\n        name: SkillKit Validate\n        entry: skillkit validate\n        language: system\n        files: \\.(md|mdc)$\n        pass_filenames: false\n\n      - id: skillkit-test\n        name: SkillKit Test\n        entry: skillkit test\n        language: system\n        files: \\.(md|mdc)$\n        pass_filenames: false\n";
+/**
+ * GitLab CI template
+ */
+declare const GITLAB_CI_TEMPLATE = "# SkillKit GitLab CI Configuration\n# Add this to your .gitlab-ci.yml\n\nskill-validation:\n  image: node:20\n  stage: test\n  before_script:\n    - npm install -g skillkit\n  script:\n    - skillkit validate\n    - skillkit test --json > test-results.json\n  artifacts:\n    # Note: test-results.json is JSON format, not JUnit XML\n    paths:\n      - test-results.json\n    expire_in: 30 days\n  rules:\n    - changes:\n        - \".claude/skills/**\"\n        - \".cursor/skills/**\"\n        - \"skills/**\"\n";
+/**
+ * CircleCI config template
+ */
+declare const CIRCLECI_CONFIG_TEMPLATE = "# SkillKit CircleCI Configuration\n# Add this to your .circleci/config.yml\n\nversion: 2.1\n\njobs:\n  validate-skills:\n    docker:\n      - image: cimg/node:20.0\n    steps:\n      - checkout\n      - run:\n          name: Install SkillKit\n          command: npm install -g skillkit\n      - run:\n          name: Validate Skills\n          command: skillkit validate\n      - run:\n          name: Run Skill Tests\n          command: skillkit test --json > test-results.json\n      - store_artifacts:\n          path: test-results.json\n          destination: skill-tests\n\nworkflows:\n  skill-validation:\n    jobs:\n      - validate-skills:\n          filters:\n            branches:\n              only: /.*/\n";
+/**
+ * Get a CI/CD template by name
+ */
+declare function getCICDTemplate(name: string): string | null;
+/**
+ * List available CI/CD templates
+ */
+declare function listCICDTemplates(): {
+    name: string;
+    description: string;
+}[];
+
+type ObservationType = 'tool_use' | 'decision' | 'error' | 'solution' | 'pattern' | 'file_change' | 'checkpoint';
+interface ObservationContent {
+    action: string;
+    context: string;
+    result?: string;
+    files?: string[];
+    tags?: string[];
+    error?: string;
+    solution?: string;
+}
+interface Observation {
+    id: string;
+    timestamp: string;
+    sessionId: string;
+    agent: AgentType;
+    type: ObservationType;
+    content: ObservationContent;
+    relevance: number;
+}
+interface Learning {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    source: 'session' | 'manual' | 'imported';
+    sourceObservations?: string[];
+    title: string;
+    content: string;
+    scope: 'project' | 'global';
+    project?: string;
+    tags: string[];
+    frameworks?: string[];
+    patterns?: string[];
+    useCount: number;
+    lastUsed?: string;
+    effectiveness?: number;
+}
+interface MemoryIndex {
+    version: 1;
+    lastUpdated: string;
+    entries: Record<string, string[]>;
+    tags: Record<string, string[]>;
+}
+interface MemorySummary {
+    id: string;
+    title: string;
+    tags: string[];
+    relevance: number;
+}
+interface MemoryPreview extends MemorySummary {
+    excerpt: string;
+    lastUsed?: string;
+}
+interface MemoryFull extends MemoryPreview {
+    content: string;
+    sourceObservations?: Observation[];
+}
+interface ObservationStoreData {
+    version: 1;
+    sessionId: string;
+    observations: Observation[];
+}
+interface LearningStoreData {
+    version: 1;
+    learnings: Learning[];
+}
+interface MemoryConfig {
+    autoCompress: boolean;
+    compressionThreshold: number;
+    compressionModel?: string;
+    maxObservations: number;
+    maxLearnings: number;
+}
+declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
+interface MemorySearchOptions {
+    query?: string;
+    tags?: string[];
+    scope?: 'project' | 'global' | 'all';
+    limit?: number;
+    minRelevance?: number;
+}
+interface MemorySearchResult {
+    learning: Learning;
+    score: number;
+    matchedKeywords: string[];
+    matchedTags: string[];
+}
+
+declare class ObservationStore {
+    private readonly filePath;
+    private data;
+    private sessionId;
+    constructor(projectPath: string, sessionId?: string);
+    private ensureDir;
+    private load;
+    private createEmpty;
+    private save;
+    add(type: ObservationType, content: ObservationContent, agent: AgentType, relevance?: number): Observation;
+    getAll(): Observation[];
+    getByType(type: ObservationType): Observation[];
+    getByRelevance(minRelevance: number): Observation[];
+    getRecent(count: number): Observation[];
+    getUncompressed(compressedIds: string[]): Observation[];
+    count(): number;
+    clear(): void;
+    getById(id: string): Observation | undefined;
+    getByIds(ids: string[]): Observation[];
+    getSessionId(): string;
+    setSessionId(sessionId: string): void;
+    exists(): boolean;
+    delete(id: string): boolean;
+    deleteMany(ids: string[]): number;
+}
+
+declare class LearningStore {
+    private readonly filePath;
+    private readonly scope;
+    private readonly projectName?;
+    private data;
+    constructor(scope: 'project' | 'global', projectPath?: string, projectName?: string);
+    private ensureDir;
+    private load;
+    private createEmpty;
+    private save;
+    add(learning: Omit<Learning, 'id' | 'createdAt' | 'updatedAt' | 'useCount' | 'scope' | 'project'>): Learning;
+    update(id: string, updates: Partial<Omit<Learning, 'id' | 'createdAt'>>): Learning | null;
+    delete(id: string): boolean;
+    getAll(): Learning[];
+    getById(id: string): Learning | undefined;
+    getByTags(tags: string[]): Learning[];
+    getByFrameworks(frameworks: string[]): Learning[];
+    getRecent(count: number): Learning[];
+    getMostUsed(count: number): Learning[];
+    getMostEffective(count: number): Learning[];
+    incrementUseCount(id: string): void;
+    setEffectiveness(id: string, effectiveness: number): void;
+    search(query: string): Learning[];
+    count(): number;
+    clear(): void;
+    exists(): boolean;
+    getScope(): 'project' | 'global';
+}
+
+declare class MemoryIndexStore {
+    private readonly filePath;
+    private data;
+    constructor(basePath: string, _isGlobal?: boolean);
+    private ensureDir;
+    private load;
+    private createEmpty;
+    private save;
+    private extractKeywords;
+    indexLearning(learning: Learning): void;
+    removeLearning(learningId: string): void;
+    searchByKeywords(query: string): string[];
+    searchByTags(tags: string[]): string[];
+    search(query: string, tags?: string[]): string[];
+    getAllTags(): string[];
+    getTagCounts(): Record<string, number>;
+    rebuildIndex(learnings: Learning[]): void;
+    clear(): void;
+    exists(): boolean;
+    getStats(): {
+        keywords: number;
+        tags: number;
+        lastUpdated: string;
+    };
+}
+
+interface MemoryPaths {
+    projectMemoryDir: string;
+    globalMemoryDir: string;
+    observationsFile: string;
+    learningsFile: string;
+    indexFile: string;
+    globalLearningsFile: string;
+    globalIndexFile: string;
+}
+declare function getMemoryPaths(projectPath: string): MemoryPaths;
+declare function initializeMemoryDirectory(projectPath: string): MemoryPaths;
+declare function memoryDirectoryExists(projectPath: string): boolean;
+declare function globalMemoryDirectoryExists(): boolean;
+interface MemoryStatus {
+    projectMemoryExists: boolean;
+    globalMemoryExists: boolean;
+    hasObservations: boolean;
+    hasLearnings: boolean;
+    hasGlobalLearnings: boolean;
+    hasIndex: boolean;
+    hasGlobalIndex: boolean;
+}
+declare function getMemoryStatus(projectPath: string): MemoryStatus;
+
+/**
+ * Memory Observer
+ *
+ * Captures observations during skill execution and stores them in the ObservationStore.
+ * Provides intelligent filtering to capture only significant events.
+ */
+
+/**
+ * Event types that can be observed
+ */
+type ObservableEventType = 'task_start' | 'task_complete' | 'task_failed' | 'checkpoint_reached' | 'checkpoint_decision' | 'verification_passed' | 'verification_failed' | 'file_modified' | 'error_encountered' | 'solution_applied' | 'execution_start' | 'execution_complete' | 'execution_paused';
+/**
+ * Observable event structure
+ */
+interface ObservableEvent {
+    type: ObservableEventType;
+    timestamp: string;
+    skillName?: string;
+    taskId?: string;
+    taskName?: string;
+    taskAction?: string;
+    files?: string[];
+    error?: string;
+    output?: string;
+    decision?: string;
+    context?: string;
+}
+/**
+ * Observer configuration
+ */
+interface MemoryObserverConfig {
+    /** Minimum relevance score to store (0-100) */
+    minRelevance?: number;
+    /** Whether to capture task starts */
+    captureTaskStarts?: boolean;
+    /** Whether to capture checkpoints */
+    captureCheckpoints?: boolean;
+    /** Whether to capture file modifications */
+    captureFileModifications?: boolean;
+    /** Whether to capture errors */
+    captureErrors?: boolean;
+    /** Whether to capture solutions */
+    captureSolutions?: boolean;
+    /** Custom relevance scorer */
+    relevanceScorer?: (event: ObservableEvent) => number;
+}
+/**
+ * Memory Observer
+ *
+ * Captures and filters observations during skill execution.
+ */
+declare class MemoryObserver {
+    private store;
+    private config;
+    private currentAgent;
+    private currentSkillName?;
+    private pendingErrors;
+    constructor(projectPath: string, sessionId?: string, config?: MemoryObserverConfig);
+    /**
+     * Set the current agent being used
+     */
+    setAgent(agent: AgentType): void;
+    /**
+     * Set the current skill being executed
+     */
+    setSkillName(skillName: string): void;
+    /**
+     * Get the underlying observation store
+     */
+    getStore(): ObservationStore;
+    /**
+     * Observe an event and potentially store it
+     */
+    observe(event: ObservableEvent): Observation | null;
+    /**
+     * Create an observation callback for the SkillExecutionEngine
+     */
+    createProgressCallback(): (event: ExecutionProgressEvent) => void;
+    /**
+     * Convert ExecutionProgressEvent to ObservableEvent
+     */
+    private convertProgressEvent;
+    /**
+     * Record a file modification event
+     */
+    recordFileModification(files: string[], context: string): Observation | null;
+    /**
+     * Record an error event
+     */
+    recordError(error: string, context: string, taskId?: string): Observation | null;
+    /**
+     * Record a solution event (potentially matching a previous error)
+     */
+    recordSolution(solution: string, context: string, relatedError?: string): Observation | null;
+    /**
+     * Record a decision event
+     */
+    recordDecision(decision: string, options: string[], context: string): Observation | null;
+    /**
+     * Record execution start
+     */
+    recordExecutionStart(skillName: string, agent: AgentType): Observation | null;
+    /**
+     * Record execution pause
+     */
+    recordExecutionPause(reason?: string): Observation | null;
+    /**
+     * Check if we should capture this event type
+     */
+    private shouldCapture;
+    /**
+     * Classify event into observation type
+     */
+    private classifyEvent;
+    /**
+     * Extract content from event
+     */
+    private extractContent;
+    /**
+     * Get action description from event
+     */
+    private getActionDescription;
+    /**
+     * Generate context if not provided
+     */
+    private generateContext;
+    /**
+     * Generate tags for event
+     */
+    private generateTags;
+    /**
+     * Score relevance of event
+     */
+    private scoreRelevance;
+    /**
+     * Generate a key for matching errors to solutions
+     */
+    private generateErrorKey;
+    /**
+     * Get session ID
+     */
+    getSessionId(): string;
+    /**
+     * Get all observations
+     */
+    getObservations(): Observation[];
+    /**
+     * Get observation count
+     */
+    getObservationCount(): number;
+    /**
+     * Clear all observations
+     */
+    clear(): void;
+}
+/**
+ * Create a MemoryObserver instance
+ */
+declare function createMemoryObserver(projectPath: string, sessionId?: string, config?: MemoryObserverConfig): MemoryObserver;
+
+/**
+ * Memory-Enabled Execution Engine Integration
+ *
+ * Provides utilities to integrate MemoryObserver with SkillExecutionEngine.
+ */
+
+/**
+ * Options for creating a memory-enabled execution engine
+ */
+interface MemoryEnabledEngineOptions {
+    /** Checkpoint handler for interactive checkpoints */
+    checkpointHandler?: CheckpointHandler;
+    /** Additional progress callback (called alongside memory observer) */
+    onProgress?: ExecutionProgressCallback;
+    /** Memory observer configuration */
+    memoryConfig?: MemoryObserverConfig;
+    /** Session ID for the memory observer */
+    sessionId?: string;
+    /** Default agent type */
+    defaultAgent?: AgentType;
+}
+/**
+ * Memory-enabled execution engine wrapper
+ */
+declare class MemoryEnabledEngine {
+    private engine;
+    private observer;
+    private userProgressCallback?;
+    constructor(projectPath: string, options?: MemoryEnabledEngineOptions);
+    /**
+     * Execute a skill with memory observation
+     */
+    execute(skill: ExecutableSkill, options?: ExecutionOptions): ReturnType<SkillExecutionEngine['execute']>;
+    /**
+     * Record a manual error observation
+     */
+    recordError(error: string, context: string, taskId?: string): void;
+    /**
+     * Record a manual solution observation
+     */
+    recordSolution(solution: string, context: string, relatedError?: string): void;
+    /**
+     * Record a file modification observation
+     */
+    recordFileModification(files: string[], context: string): void;
+    /**
+     * Record a decision observation
+     */
+    recordDecision(decision: string, options: string[], context: string): void;
+    /**
+     * Pause execution
+     */
+    pause(): boolean;
+    /**
+     * Check if execution is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Get the memory observer
+     */
+    getObserver(): MemoryObserver;
+    /**
+     * Get the underlying execution engine
+     */
+    getEngine(): SkillExecutionEngine;
+    /**
+     * Get the session manager
+     */
+    getSessionManager(): ReturnType<SkillExecutionEngine['getSessionManager']>;
+    /**
+     * Get observation count
+     */
+    getObservationCount(): number;
+    /**
+     * Get all observations
+     */
+    getObservations(): ReturnType<MemoryObserver['getObservations']>;
+    /**
+     * Clear observations
+     */
+    clearObservations(): void;
+}
+/**
+ * Create a memory-enabled execution engine
+ */
+declare function createMemoryEnabledEngine(projectPath: string, options?: MemoryEnabledEngineOptions): MemoryEnabledEngine;
+/**
+ * Wrap an existing progress callback with memory observation
+ */
+declare function wrapProgressCallbackWithMemory(projectPath: string, existingCallback?: ExecutionProgressCallback, memoryConfig?: MemoryObserverConfig, sessionId?: string): {
+    callback: ExecutionProgressCallback;
+    observer: MemoryObserver;
+};
+
+/**
+ * Memory Compression Engine
+ *
+ * Compresses raw observations into learnings using either rule-based
+ * extraction or AI-powered compression.
+ */
+
+/**
+ * Compression result for a single learning
+ */
+interface CompressedLearning {
+    title: string;
+    content: string;
+    tags: string[];
+    frameworks?: string[];
+    patterns?: string[];
+    importance: number;
+    sourceObservationIds: string[];
+}
+/**
+ * Compression result
+ */
+interface CompressionResult {
+    learnings: CompressedLearning[];
+    processedObservationIds: string[];
+    skippedObservationIds: string[];
+    stats: {
+        inputCount: number;
+        outputCount: number;
+        compressionRatio: number;
+    };
+}
+/**
+ * Compression options
+ */
+interface CompressionOptions {
+    /** Minimum observations to trigger compression */
+    minObservations?: number;
+    /** Maximum learnings to generate per compression */
+    maxLearnings?: number;
+    /** Minimum importance score (1-10) to keep a learning */
+    minImportance?: number;
+    /** Whether to include low-relevance observations */
+    includeLowRelevance?: boolean;
+    /** Custom tags to add to all learnings */
+    additionalTags?: string[];
+    /** Project name for context */
+    projectName?: string;
+}
+/**
+ * Compression engine interface
+ */
+interface CompressionEngine {
+    /**
+     * Compress observations into learnings
+     */
+    compress(observations: Observation[], options?: CompressionOptions): Promise<CompressionResult>;
+    /**
+     * Get the engine type
+     */
+    getType(): 'rule-based' | 'api';
+}
+/**
+ * Rule-based compression engine
+ *
+ * Uses heuristics and patterns to extract learnings without AI.
+ */
+declare class RuleBasedCompressor implements CompressionEngine {
+    getType(): 'rule-based' | 'api';
+    compress(observations: Observation[], options?: CompressionOptions): Promise<CompressionResult>;
+    private groupByType;
+    private extractErrorSolutionPairs;
+    private extractDecisionPatterns;
+    private extractFileChangePatterns;
+    private extractToolUsagePatterns;
+    private generateTitle;
+    private formatErrorSolutionContent;
+    private formatStandaloneErrorContent;
+    private formatSolutionContent;
+    private formatDecisionContent;
+    private formatFileChangeContent;
+    private formatToolUsageContent;
+    private extractTags;
+    private extractFrameworks;
+    private getFilePattern;
+    private getActionType;
+    private hasSimilarKeywords;
+    /**
+     * Check for strong keyword overlap (multiple matching words)
+     * More strict than hasSimilarKeywords - requires at least 2 matching words
+     */
+    private hasStrongKeywordOverlap;
+}
+/**
+ * API-based compression engine configuration
+ */
+interface APICompressionConfig {
+    /** API provider */
+    provider: 'anthropic' | 'openai';
+    /** API key */
+    apiKey: string;
+    /** Model to use */
+    model?: string;
+    /** Maximum tokens for response */
+    maxTokens?: number;
+}
+/**
+ * API-based compression engine
+ *
+ * Uses Claude or OpenAI to extract learnings from observations.
+ */
+declare class APIBasedCompressor implements CompressionEngine {
+    private config;
+    constructor(config: APICompressionConfig);
+    getType(): 'rule-based' | 'api';
+    compress(observations: Observation[], options?: CompressionOptions): Promise<CompressionResult>;
+    private formatObservationsForPrompt;
+    private buildCompressionPrompt;
+    private callAPI;
+    private callAnthropic;
+    private callOpenAI;
+    private parseAPIResponse;
+}
+/**
+ * Memory compressor that manages compression and stores results
+ */
+declare class MemoryCompressor {
+    private engine;
+    private learningStore;
+    private indexStore;
+    private projectName?;
+    constructor(projectPath: string, options?: {
+        engine?: CompressionEngine;
+        scope?: 'project' | 'global';
+        projectName?: string;
+    });
+    /**
+     * Set the compression engine
+     */
+    setEngine(engine: CompressionEngine): void;
+    /**
+     * Compress observations without storing (for dry-run/preview)
+     */
+    compress(observations: Observation[], options?: CompressionOptions): Promise<CompressionResult>;
+    /**
+     * Compress observations and store as learnings
+     */
+    compressAndStore(observations: Observation[], options?: CompressionOptions): Promise<{
+        learnings: Learning[];
+        result: CompressionResult;
+    }>;
+    /**
+     * Get the learning store
+     */
+    getLearningStore(): LearningStore;
+    /**
+     * Get the index store
+     */
+    getIndexStore(): MemoryIndexStore;
+    /**
+     * Get compression engine type
+     */
+    getEngineType(): 'rule-based' | 'api';
+}
+/**
+ * Learning consolidator
+ *
+ * Merges similar learnings to reduce redundancy.
+ */
+declare class LearningConsolidator {
+    /**
+     * Find similar learnings
+     */
+    findSimilar(learnings: Learning[], similarity?: number): Array<[Learning, Learning]>;
+    /**
+     * Merge two similar learnings
+     */
+    merge(learning1: Learning, learning2: Learning): Omit<Learning, 'id' | 'createdAt' | 'updatedAt'>;
+    /**
+     * Consolidate a list of learnings
+     */
+    consolidate(learnings: Learning[], store: LearningStore, index: MemoryIndexStore, similarity?: number): {
+        merged: number;
+        remaining: number;
+    };
+    private calculateSimilarity;
+    private getBetterLearning;
+    private mergeContent;
+}
+/**
+ * Create a rule-based compressor
+ */
+declare function createRuleBasedCompressor(): RuleBasedCompressor;
+/**
+ * Create an API-based compressor
+ */
+declare function createAPIBasedCompressor(config: APICompressionConfig): APIBasedCompressor;
+/**
+ * Create a memory compressor
+ */
+declare function createMemoryCompressor(projectPath: string, options?: {
+    engine?: CompressionEngine;
+    scope?: 'project' | 'global';
+    projectName?: string;
+}): MemoryCompressor;
+
+/**
+ * Memory Injector
+ *
+ * Injects relevant memories into agent context with relevance matching,
+ * agent-specific formatting, and token budgeting.
+ */
+
+/**
+ * Injection options
+ */
+interface InjectionOptions {
+    /** Maximum tokens to use for injected memories */
+    maxTokens?: number;
+    /** Minimum relevance score to include (0-100) */
+    minRelevance?: number;
+    /** Maximum number of learnings to inject */
+    maxLearnings?: number;
+    /** Include global memories */
+    includeGlobal?: boolean;
+    /** Specific tags to match */
+    tags?: string[];
+    /** Current task description for relevance matching */
+    currentTask?: string;
+    /** Progressive disclosure level */
+    disclosureLevel?: 'summary' | 'preview' | 'full';
+}
+/**
+ * Injected memory with relevance score
+ */
+interface InjectedMemory {
+    learning: Learning;
+    relevanceScore: number;
+    matchedBy: {
+        frameworks: string[];
+        tags: string[];
+        keywords: string[];
+        patterns: string[];
+    };
+    tokenEstimate: number;
+}
+/**
+ * Injection result
+ */
+interface InjectionResult {
+    memories: InjectedMemory[];
+    formattedContent: string;
+    totalTokens: number;
+    stats: {
+        considered: number;
+        matched: number;
+        injected: number;
+        truncated: number;
+    };
+}
+/**
+ * Memory Injector
+ *
+ * Retrieves and formats relevant memories for injection into agent context.
+ */
+declare class MemoryInjector {
+    private projectStore;
+    private globalStore;
+    private projectContext?;
+    constructor(projectPath: string, projectName?: string, projectContext?: ProjectContext);
+    /**
+     * Set project context for better relevance matching
+     */
+    setProjectContext(context: ProjectContext): void;
+    /**
+     * Get relevant memories for injection
+     */
+    getRelevantMemories(options?: InjectionOptions): Promise<InjectedMemory[]>;
+    /**
+     * Score a learning for relevance to current context
+     */
+    private scoreLearning;
+    /**
+     * Extract framework names from project context
+     */
+    private extractFrameworkNames;
+    /**
+     * Extract keywords from text
+     */
+    private extractKeywords;
+    /**
+     * Calculate days since a date
+     */
+    private daysSince;
+    /**
+     * Estimate tokens for a learning
+     */
+    private estimateTokens;
+    /**
+     * Inject memories and return formatted content
+     */
+    inject(options?: InjectionOptions): Promise<InjectionResult>;
+    /**
+     * Inject memories formatted for a specific agent
+     */
+    injectForAgent(agent: AgentType, options?: InjectionOptions): Promise<InjectionResult>;
+    /**
+     * Format memories for display
+     */
+    private formatMemories;
+    /**
+     * Format memories for a specific agent
+     */
+    formatForAgent(memories: InjectedMemory[], agent: AgentType, level?: 'summary' | 'preview' | 'full'): string;
+    /**
+     * Format memories for Claude (XML tags)
+     */
+    private formatForClaude;
+    /**
+     * Format memories for Cursor (.mdc format)
+     */
+    private formatForCursor;
+    /**
+     * Format memories for Copilot/Codex (concise markdown)
+     */
+    private formatForCopilot;
+    /**
+     * Escape XML special characters
+     */
+    private escapeXml;
+    /**
+     * Get memory summaries (for progressive disclosure)
+     */
+    getSummaries(options?: InjectionOptions): MemorySummary[];
+    /**
+     * Get memory previews (for progressive disclosure)
+     */
+    getPreviews(ids: string[], options?: InjectionOptions): MemoryPreview[];
+    /**
+     * Get full memories (for progressive disclosure)
+     */
+    getFullMemories(ids: string[], options?: InjectionOptions): MemoryFull[];
+    /**
+     * Search memories by query
+     */
+    search(query: string, options?: InjectionOptions): InjectedMemory[];
+}
+/**
+ * Create a MemoryInjector instance
+ */
+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 };