@vibetasks/core 0.5.8 → 0.5.10

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { SupabaseClient } from '@supabase/supabase-js';
+import { TaskFilter, TaskPriority, TaskStatus, EnergyLevel, Task as Task$2 } from '@vibetasks/shared';
+export { TaskFilter, TaskPriority, TaskStatus } from '@vibetasks/shared';
 
 interface TaskFlowConfig {
     supabase_url?: string;
@@ -149,10 +151,6 @@ declare function createSupabaseClient(config: SupabaseConfig): SupabaseClient<an
  */
 declare function createSupabaseClientFromEnv(): SupabaseClient<any, "public", "vibetasks", any, any>;
 
-type TaskFilter = 'all' | 'today' | 'upcoming' | 'completed' | 'archived';
-type TaskPriority = 'none' | 'low' | 'medium' | 'high';
-type TaskStatus = 'todo' | 'vibing' | 'done' | 'paused' | 'archived';
-type EnergyLevel = 'low' | 'medium' | 'high';
 type ChangeType = 'created' | 'status_changed' | 'title_changed' | 'description_changed' | 'context_updated' | 'priority_changed' | 'due_date_changed' | 'subtask_added' | 'subtask_removed' | 'subtask_done' | 'subtask_undone' | 'tag_added' | 'tag_removed' | 'workspace_moved' | 'handoff' | 'revert' | 'archived' | 'restored';
 interface TaskChange {
     id: string;
@@ -168,13 +166,23 @@ interface TaskChange {
     reverted_change_id?: string;
     created_at: string;
 }
+/**
+ * Workspace interface
+ *
+ * FLAT WORKSPACE MODEL (2026):
+ * - Workspaces = top-level projects only (git repos or named cloud projects)
+ * - Sub-organization within a workspace uses tags, not nested workspaces
+ * - Git remote URL is the stable identifier
+ */
 interface Workspace {
     id: string;
     user_id: string;
     slug: string;
     display_name: string;
     full_path: string;
+    /** @deprecated Use tags for sub-organization within workspace */
     parent_id?: string;
+    /** @deprecated Workspaces are flat now, depth should be 0 */
     depth: number;
     color?: string;
     description?: string;
@@ -219,7 +227,7 @@ interface Attachment {
  * Task interface - comprehensive type matching @vibetasks/shared
  * All fields are optional except id and title for flexibility in operations
  */
-interface Task {
+interface Task$1 {
     id: string;
     user_id?: string;
     title: string;
@@ -242,7 +250,7 @@ interface Task {
     updated_at?: string;
     tags?: Tag[];
     attachments?: Attachment[];
-    subtasks?: Task[];
+    subtasks?: Task$1[];
     subtasks_json?: Subtask[];
     status?: TaskStatus;
     project_tag?: string;
@@ -250,6 +258,8 @@ interface Task {
     context_notes?: string;
     energy_required?: EnergyLevel;
     source_type?: SourceType;
+    workspace_id?: string;
+    a2a_task_id?: string;
     github_issue_id?: number | string;
     github_issue_number?: number;
     github_repo?: string;
@@ -287,6 +297,14 @@ interface Task {
         captured_at: string;
         capture_source?: 'paste' | 'clipboard' | 'terminal' | 'browser' | 'sentry' | 'ci';
     };
+    /** OpenAI embedding vector (1536-dim) for semantic similarity search */
+    semantic_vector?: number[];
+    /** Extracted intent from first session message (e.g., "Implement OAuth flow for Apple Sign-In") */
+    intent?: string;
+    /** Auto-generated semantic tags (3-5 per task) for context grouping */
+    context_tags?: string[];
+    /** Flag indicating semantic_vector needs regeneration (internal) */
+    needs_embedding_update?: boolean;
 }
 /**
  * TaskOperations class provides a high-level API for task management
@@ -294,42 +312,118 @@ interface Task {
  */
 declare class TaskOperations {
     private supabase;
-    constructor(supabase: SupabaseClient<any, any, any>);
+    private workspaceId?;
+    constructor(supabase: SupabaseClient<any, any, any>, workspaceId?: string);
     private currentSessionId?;
     /**
      * Set the current session ID for change tracking
      */
     setSessionId(sessionId: string): void;
+    /**
+     * Set the workspace ID for workspace isolation
+     * 🔒 WORKSPACE ISOLATION: Filter all queries by workspace
+     */
+    setWorkspaceId(workspaceId: string): void;
+    /**
+     * Get current workspace ID
+     */
+    getWorkspaceId(): string | undefined;
     /**
      * Create TaskOperations from AuthManager
      * Automatically refreshes expired tokens
+     * 🔒 WORKSPACE ISOLATION: Accepts optional workspaceId parameter
      */
-    static fromAuthManager(authManager: AuthManager): Promise<TaskOperations>;
-    getTasks(filter?: TaskFilter, includeArchived?: boolean): Promise<Task[]>;
-    getTask(taskId: string): Promise<Task>;
-    createTask(task: Partial<Task>): Promise<Task>;
-    updateTask(taskId: string, updates: Partial<Task>, logChanges?: boolean): Promise<Task>;
+    static fromAuthManager(authManager: AuthManager, workspaceId?: string): Promise<TaskOperations>;
+    getTasks(filter?: TaskFilter, includeArchived?: boolean): Promise<Task$1[]>;
+    getTask(taskId: string): Promise<Task$1>;
+    createTask(task: Partial<Task$1>): Promise<Task$1>;
+    updateTask(taskId: string, updates: Partial<Task$1>, logChanges?: boolean): Promise<Task$1>;
     deleteTask(taskId: string): Promise<void>;
-    completeTask(taskId: string): Promise<Task>;
-    uncompleteTask(taskId: string): Promise<Task>;
+    completeTask(taskId: string): Promise<Task$1>;
+    uncompleteTask(taskId: string): Promise<Task$1>;
     /**
      * Archive a task - moves it to archived status
      * Typically used for completed tasks you want to hide from views
      */
-    archiveTask(taskId: string): Promise<Task>;
+    archiveTask(taskId: string): Promise<Task$1>;
     /**
      * Unarchive a task - restores it to its previous state (done by default)
      */
-    unarchiveTask(taskId: string, restoreStatus?: TaskStatus): Promise<Task>;
+    unarchiveTask(taskId: string, restoreStatus?: TaskStatus): Promise<Task$1>;
     /**
      * Get all archived tasks
      */
-    getArchivedTasks(limit?: number): Promise<Task[]>;
+    getArchivedTasks(limit?: number): Promise<Task$1[]>;
+    /**
+     * Get tasks ready to work on (no blockers, not deferred)
+     */
+    getReadyTasks(options?: {
+        status?: string;
+        limit?: number;
+    }): Promise<Task$1[]>;
+    /**
+     * Fallback for ready tasks when RPC function doesn't exist
+     */
+    private getReadyTasksFallback;
+    /**
+     * Get stale tasks (not updated in X days)
+     */
+    getStaleTasks(options?: {
+        days?: number;
+        status?: string;
+        limit?: number;
+    }): Promise<Task$1[]>;
+    /**
+     * Fallback for stale tasks when RPC function doesn't exist
+     */
+    private getStaleTasksFallback;
+    /**
+     * Get orphaned tasks (incomplete tasks from old AI sessions)
+     */
+    getOrphanedTasks(options?: {
+        currentSessionId?: string;
+        limit?: number;
+    }): Promise<Task$1[]>;
+    /**
+     * Fallback for orphaned tasks when RPC function doesn't exist
+     */
+    private getOrphanedTasksFallback;
+    /**
+     * Get blocked tasks (tasks with open dependencies)
+     */
+    getBlockedTasks(options?: {
+        limit?: number;
+    }): Promise<Task$1[]>;
+    /**
+     * Fallback for blocked tasks when RPC function doesn't exist
+     */
+    private getBlockedTasksFallback;
+    /**
+     * Get tasks eligible for compaction (completed, old, not yet compacted)
+     */
+    getCompactableTasks(options?: {
+        minDaysOld?: number;
+        maxCompactionLevel?: number;
+        limit?: number;
+    }): Promise<Task$1[]>;
+    /**
+     * Update a task with compaction results
+     */
+    applyCompaction(taskId: string, summary: string): Promise<Task$1>;
+    /**
+     * Get compaction statistics for the user
+     */
+    getCompactionStats(): Promise<{
+        totalCompleted: number;
+        compacted: number;
+        eligible: number;
+        savedBytes: number;
+    }>;
     getTags(): Promise<Tag[]>;
     createTag(name: string, color?: string): Promise<Tag>;
     linkTaskTags(taskId: string, tagIds: string[]): Promise<void>;
     unlinkAllTaskTags(taskId: string): Promise<void>;
-    searchTasks(query: string, limit?: number, includeArchived?: boolean): Promise<Task[]>;
+    searchTasks(query: string, limit?: number, includeArchived?: boolean): Promise<Task$1[]>;
     /**
      * Find tag by name (case-insensitive), create if doesn't exist
      */
@@ -358,7 +452,7 @@ declare class TaskOperations {
         priority?: TaskPriority | TaskPriority[];
         unacknowledged_only?: boolean;
         limit?: number;
-    }): Promise<Task[]>;
+    }): Promise<Task$1[]>;
     /**
      * Get inbox statistics
      */
@@ -393,6 +487,16 @@ declare class TaskOperations {
         search?: string;
         limit?: number;
     }): Promise<any[]>;
+    /**
+     * Log an action to the current AI session
+     */
+    logSessionAction(sessionId: string, action: {
+        action_type: string;
+        description: string;
+        task_id?: string;
+        doc_id?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Log a change to a task (like a git commit)
      */
@@ -439,10 +543,17 @@ declare class TaskOperations {
     searchChanges(query: string, limit?: number): Promise<TaskChange[]>;
     /**
      * Create a workspace
+     *
+     * FLAT WORKSPACE MODEL (2026):
+     * - Workspaces are top-level only (no parent/child hierarchy)
+     * - full_path = display_name (no hierarchy separator needed)
+     * - depth is always 0
+     * - Use tags for sub-organization within a workspace
      */
     createWorkspace(input: {
         slug: string;
         displayName: string;
+        /** @deprecated Workspaces are flat now - this parameter is ignored */
         parentId?: string;
         color?: string;
         description?: string;
@@ -456,7 +567,12 @@ declare class TaskOperations {
      */
     getWorkspaceByPath(fullPath: string): Promise<Workspace | null>;
     /**
-     * Get or create workspace from a project_tag (auto-creates hierarchy)
+     * Get or create workspace from a project_tag
+     *
+     * FLAT WORKSPACE MODEL (2026):
+     * - Only creates top-level workspace from the LAST segment of the tag
+     * - Legacy hierarchical tags like "sparktory > vibetasks > web" → creates "web" workspace
+     * - For new code, just pass the workspace name directly
      */
     getOrCreateWorkspace(projectTag: string): Promise<Workspace>;
     /**
@@ -481,15 +597,46 @@ declare class TaskOperations {
     /**
      * Pause a task
      */
-    pauseTask(taskId: string, reason?: string): Promise<Task>;
+    pauseTask(taskId: string, reason?: string): Promise<Task$1>;
     /**
      * Resume a paused task
      */
-    resumeTask(taskId: string): Promise<Task>;
+    resumeTask(taskId: string): Promise<Task$1>;
     /**
      * Restore a task from archive
      */
-    restoreTask(taskId: string, toStatus?: TaskStatus): Promise<Task>;
+    restoreTask(taskId: string, toStatus?: TaskStatus): Promise<Task$1>;
+    /**
+     * Get meetings for the current user
+     */
+    getMeetings(options?: {
+        workspace_id?: string;
+        limit?: number;
+        since?: string;
+    }): Promise<any[]>;
+    /**
+     * Create a custom skill
+     */
+    createSkill(skill: {
+        name: string;
+        description: string;
+        category: string;
+        trigger_phrases: string[];
+        steps: Array<{
+            action: string;
+            tool?: string;
+            params?: Record<string, any>;
+        }>;
+        workspace_id?: string;
+    }): Promise<any>;
+    /**
+     * List user's skills
+     */
+    getSkills(options?: {
+        workspace_id?: string;
+        category?: string;
+        enabled_only?: boolean;
+    }): Promise<any[]>;
 }
 
 /**
@@ -531,6 +678,10 @@ interface SyncResult {
     previousStatus?: TaskStatus;
     /** New status (if updated) */
     newStatus?: TaskStatus;
+    /** Match type: exact (A2A ID) or fuzzy (string similarity) */
+    matchType?: 'exact' | 'fuzzy';
+    /** A2A task ID (for debugging/logging) */
+    a2aTaskId?: string;
     /** Error message if any */
     error?: string;
 }
@@ -561,6 +712,10 @@ interface SyncOptions {
     matchThreshold?: number;
     /** Whether to sync 'pending' todos as 'todo' status (default: true) */
     syncPending?: boolean;
+    /** Workspace ID for A2A task ID generation */
+    workspaceId?: string;
+    /** Created by (user ID or session ID) for A2A task ID generation */
+    createdBy?: string;
 }
 /**
  * Claude Sync class for managing TodoWrite synchronization
@@ -571,7 +726,7 @@ declare class ClaudeSync {
     /**
      * Sync a single Claude todo item with VibeTasks
      */
-    syncTodo(todo: ClaudeTodoItem, existingTasks?: Task[], options?: SyncOptions): Promise<SyncResult>;
+    syncTodo(todo: ClaudeTodoItem, existingTasks?: Task$1[], options?: SyncOptions): Promise<SyncResult>;
     /**
      * Sync all Claude todos with VibeTasks
      */
@@ -579,15 +734,15 @@ declare class ClaudeSync {
     /**
      * Get current vibing tasks (for comparison with Claude's in_progress)
      */
-    getVibingTasks(): Promise<Task[]>;
+    getVibingTasks(): Promise<Task$1[]>;
     /**
      * Auto-start vibing on a task when Claude marks it as in_progress
      */
-    startVibing(taskId: string): Promise<Task>;
+    startVibing(taskId: string): Promise<Task$1>;
     /**
      * Complete a task when Claude marks it as completed
      */
-    completeTask(taskId: string): Promise<Task>;
+    completeTask(taskId: string): Promise<Task$1>;
 }
 /**
  * MCP Tool: sync_claude_todos
@@ -597,4 +752,649 @@ declare class ClaudeSync {
  */
 declare function syncClaudeTodos(taskOps: TaskOperations, todos: ClaudeTodoItem[], options?: SyncOptions): Promise<SyncAllResult>;
 
-export { type Attachment, AuthManager, type ChangeType, ClaudeSync, type ClaudeTodoItem, ConfigManager, type SourceType, type Subtask, type SupabaseConfig, type SyncAllResult, type SyncOptions, type SyncResult, type Tag, type Task, type TaskChange, type TaskFilter, type TaskFlowConfig, TaskOperations, type TaskPriority, type TaskStatus, type Workspace, createSupabaseClient, createSupabaseClientFromEnv, syncClaudeTodos };
+/**
+ * Integration Sync Service
+ * Handles two-way sync with external integrations (Sentry, GitHub, etc.)
+ *
+ * When a task is completed in VibeTasks:
+ * - If it came from Sentry → resolve the issue in Sentry
+ * - If it came from GitHub → close the issue in GitHub
+ */
+
+interface IntegrationSyncResult {
+    success: boolean;
+    integration: 'sentry' | 'github' | 'slack' | 'email';
+    action: string;
+    externalId?: string;
+    externalUrl?: string;
+    error?: string;
+}
+interface Task {
+    id: string;
+    user_id: string;
+    title?: string;
+    status?: string;
+    sentry_issue_id?: string;
+    sentry_project?: string;
+    sentry_url?: string;
+    github_issue_id?: number;
+    github_issue_number?: number;
+    github_repo?: string;
+    github_url?: string;
+    source_type?: string;
+}
+declare class IntegrationSyncService {
+    private supabase;
+    constructor(supabase: SupabaseClient);
+    /**
+     * Sync task completion to external integrations
+     * Called when a task is marked as done
+     */
+    syncTaskComplete(task: Task): Promise<IntegrationSyncResult[]>;
+    /**
+     * Resolve a Sentry issue when the task is completed
+     */
+    private resolveSentryIssue;
+    /**
+     * Close a GitHub issue when the task is completed
+     */
+    private closeGitHubIssue;
+    /**
+     * Log sync attempt for debugging and auditing
+     */
+    private logSyncAttempt;
+    /**
+     * Sync task reopen to external integrations
+     * Called when a task is moved back to todo/vibing from done
+     */
+    syncTaskReopen(task: Task): Promise<IntegrationSyncResult[]>;
+    /**
+     * Unresolve a Sentry issue when the task is reopened
+     */
+    private unresolveSentryIssue;
+    /**
+     * Reopen a GitHub issue when the task is reopened
+     */
+    private reopenGitHubIssue;
+}
+
+/**
+ * Generate semantic vector (embedding) for task content
+ *
+ * @param title - Task title
+ * @param notes - Task notes/description (optional)
+ * @param intent - Extracted intent from first session message (optional)
+ * @returns 1536-dimensional embedding vector
+ */
+declare function generateTaskEmbedding(input: {
+    title: string;
+    notes?: string;
+    intent?: string;
+}): Promise<number[]>;
+/**
+ * Generate context tags for a task using simple keyword extraction
+ *
+ * For now uses a simple heuristic approach. In the future, could use:
+ * - GPT-4o-mini for intelligent tag generation
+ * - TF-IDF for keyword extraction
+ * - Domain-specific dictionaries
+ *
+ * @param title - Task title
+ * @param notes - Task notes (optional)
+ * @returns Array of 3-5 semantic tags
+ */
+declare function generateContextTags(input: {
+    title: string;
+    notes?: string;
+    projectTag?: string;
+}): string[];
+/**
+ * Extract intent from task title and notes
+ *
+ * Intent is a concise statement of what the user is trying to accomplish.
+ * Used for RLM context propagation.
+ *
+ * @param title - Task title
+ * @param notes - Task notes (optional)
+ * @returns Extracted intent (up to 200 chars)
+ */
+declare function extractIntent(input: {
+    title: string;
+    notes?: string;
+    description?: string;
+}): string;
+
+/**
+ * AI-based semantic analysis for RLM integration
+ * Uses RECOMMENDED_MODELS for cost-optimized intent extraction and tag generation
+ */
+/**
+ * Extract semantic intent from task using Claude
+ */
+declare function extractIntentWithClaude(input: {
+    title: string;
+    notes?: string;
+    description?: string;
+}): Promise<string>;
+/**
+ * Generate semantic context tags using Claude
+ */
+declare function generateContextTagsWithClaude(input: {
+    title: string;
+    notes?: string;
+    projectTag?: string;
+}): Promise<string[]>;
+/**
+ * Generate task embedding using Voyage AI (Anthropic-recommended)
+ *
+ * Uses voyage-code-3 model optimized for code and technical content.
+ * Produces 1024-dimensional embeddings for semantic similarity search.
+ */
+declare function generateTaskEmbeddingWithClaude(input: {
+    title: string;
+    notes?: string;
+    intent?: string;
+}): Promise<number[]>;
+/**
+ * Batch process multiple tasks with Claude
+ * Includes rate limiting to avoid API throttling
+ */
+declare function batchProcessTasksWithClaude(tasks: Array<{
+    id: string;
+    title: string;
+    notes?: string;
+    description?: string;
+}>, onProgress?: (completed: number, total: number) => void): Promise<Array<{
+    id: string;
+    intent: string;
+    contextTags: string[];
+    embedding: number[];
+}>>;
+
+/**
+ * Recursive Language Model (RLM) Engine
+ *
+ * Based on MIT's RLM paper: https://arxiv.org/abs/2512.24601v1
+ * Enables LLMs to process 10M+ token contexts by treating context as
+ * an external environment that can be programmatically explored.
+ *
+ * Key concepts:
+ * - Context stored as variable in REPL environment (not in prompt)
+ * - LLM writes Python code to search/filter/chunk context
+ * - Recursive llm_query() calls for sub-problems
+ * - 3x cheaper and 29% more accurate than traditional approaches
+ *
+ * Uses RECOMMENDED_MODELS for cost-optimized model selection.
+ */
+interface RLMConfig {
+    apiKey: string;
+    model?: string;
+    maxDepth?: number;
+    subLLMModel?: string;
+    timeout?: number;
+    verbose?: boolean;
+}
+interface RLMResult {
+    answer: string;
+    totalCost: number;
+    tokensUsed: {
+        input: number;
+        output: number;
+    };
+    callCount: number;
+    depth: number;
+    executionTime: number;
+}
+declare class RLMEngine {
+    private client;
+    private config;
+    private currentDepth;
+    private callCount;
+    private totalTokens;
+    private startTime;
+    private logs;
+    constructor(config: RLMConfig);
+    /**
+     * Main RLM completion function
+     * Replaces traditional llm.completion(prompt) calls
+     */
+    completion(query: string, context: string): Promise<RLMResult>;
+    /**
+     * Recursive query function - core of RLM
+     */
+    private recursiveQuery;
+    /**
+     * Create REPL environment with context and tools
+     */
+    private createREPLEnvironment;
+    /**
+     * Execute Python code in sandboxed VM
+     */
+    private executeREPLCode;
+    /**
+     * Base LLM query without recursion (for depth limit or simple queries)
+     */
+    private baseLLMQuery;
+    /**
+     * Build system prompt teaching LLM how to use RLM
+     */
+    private buildSystemPrompt;
+    /**
+     * Build prompt for REPL interaction
+     */
+    private buildREPLPrompt;
+    /**
+     * Extract code blocks from LLM response
+     */
+    private extractCodeBlocks;
+    /**
+     * Extract final answer from FINAL() or FINAL_VAR()
+     */
+    private extractFinalAnswer;
+    /**
+     * Calculate total cost based on token usage
+     */
+    private calculateCost;
+    /**
+     * Logging helper
+     */
+    private log;
+    /**
+     * Get execution logs
+     */
+    getLogs(): string[];
+}
+
+/**
+ * RLM Context Loader
+ *
+ * Loads codebase files into a massive context string for RLM processing.
+ * Integrates with existing VibeTasks file system and context engine.
+ */
+interface CodebaseContext {
+    content: string;
+    fileCount: number;
+    totalSize: number;
+    files: {
+        path: string;
+        size: number;
+        lines: number;
+    }[];
+    metadata: {
+        generatedAt: Date;
+        rootPath: string;
+        excludePatterns: string[];
+    };
+}
+interface ContextLoaderOptions {
+    rootPath: string;
+    excludePatterns?: string[];
+    includePatterns?: string[];
+    maxFileSize?: number;
+    addFileHeaders?: boolean;
+    addLineNumbers?: boolean;
+}
+declare class RLMContextLoader {
+    private defaultExcludePatterns;
+    private defaultIncludePatterns;
+    /**
+     * Load entire codebase into single context string
+     */
+    loadCodebase(options: ContextLoaderOptions): Promise<CodebaseContext>;
+    /**
+     * Load specific files or directories
+     */
+    loadPaths(rootPath: string, paths: string[], options?: Partial<ContextLoaderOptions>): Promise<CodebaseContext>;
+    /**
+     * Find files matching patterns
+     */
+    private findFiles;
+    /**
+     * Create a focused context for specific query
+     * Uses existing context engine's semantic search to pre-filter
+     */
+    loadFocusedContext(rootPath: string, query: string, options?: {
+        maxFiles?: number;
+        semanticSearch?: boolean;
+    }): Promise<CodebaseContext>;
+    /**
+     * Extract keywords from query for relevance scoring
+     */
+    private extractKeywords;
+    /**
+     * Stream large codebase in chunks (for progressive loading)
+     */
+    streamCodebase(options: ContextLoaderOptions, chunkSize?: number): AsyncGenerator<{
+        chunk: string;
+        progress: number;
+    }>;
+    /**
+     * Get context statistics without loading full content
+     */
+    getCodebaseStats(options: ContextLoaderOptions): Promise<{
+        fileCount: number;
+        totalSize: number;
+        estimatedTokens: number;
+        topFileTypes: {
+            ext: string;
+            count: number;
+        }[];
+    }>;
+}
+
+/**
+ * RLM MCP Tool
+ *
+ * Exposes RLM capabilities as MCP tools for VibeTasks agents.
+ * Enables AI to query massive codebases (10M+ tokens) using recursive search.
+ */
+
+interface RLMQueryInput {
+    query: string;
+    workspacePath?: string;
+    focused?: boolean;
+    maxFiles?: number;
+    verbose?: boolean;
+    maxDepth?: number;
+}
+interface RLMQueryOutput extends RLMResult {
+    contextUsed: {
+        fileCount: number;
+        totalSize: number;
+        estimatedTokens: number;
+    };
+    logs?: string[];
+}
+declare class RLMMCPTool {
+    private engine;
+    private contextLoader;
+    private contextCache;
+    constructor(anthropicApiKey: string);
+    /**
+     * Main RLM query tool
+     */
+    queryCodebase(input: RLMQueryInput): Promise<RLMQueryOutput>;
+    /**
+     * Get codebase statistics (fast, no LLM calls)
+     */
+    getCodebaseStats(workspacePath?: string): Promise<{
+        fileCount: number;
+        totalSize: number;
+        estimatedTokens: number;
+        estimatedCost: number;
+        topFileTypes: {
+            ext: string;
+            count: number;
+        }[];
+    }>;
+    /**
+     * Clear context cache
+     */
+    clearCache(): void;
+    /**
+     * Prefetch and cache codebase context
+     */
+    prefetchContext(workspacePath?: string, focused?: boolean): Promise<void>;
+}
+/**
+ * MCP Tool Schema for registration
+ */
+declare const RLM_MCP_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            focused: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            maxFiles: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            verbose: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query?: undefined;
+            focused?: undefined;
+            maxFiles?: undefined;
+            verbose?: undefined;
+        };
+        required?: undefined;
+    };
+})[];
+
+/**
+ * Task Compaction Service
+ *
+ * AI-powered summarization of old completed tasks to reduce context size
+ * while preserving important information for future reference.
+ *
+ * Inspired by beads' haiku compaction system.
+ */
+
+/**
+ * Compaction result for a task
+ */
+interface CompactionResult {
+    taskId: string;
+    originalSize: number;
+    compactedSize: number;
+    summary: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Options for running compaction
+ */
+interface CompactionOptions {
+    /** Minimum days since completion before compacting (default: 7) */
+    minDaysOld?: number;
+    /** Maximum number of tasks to compact in one run (default: 10) */
+    limit?: number;
+    /** Dry run - don't actually update tasks (default: false) */
+    dryRun?: boolean;
+    /** Only compact tasks at this compaction level or below (default: 0) */
+    maxCompactionLevel?: number;
+}
+/**
+ * Task Compaction Service
+ *
+ * Summarizes old completed tasks using AI to reduce context size.
+ */
+declare class TaskCompactionService {
+    private anthropic;
+    private model;
+    constructor(apiKey?: string);
+    /**
+     * Compact a single task by generating a summary
+     */
+    compactTask(task: Task$2): Promise<CompactionResult>;
+    /**
+     * Build the full content of a task for summarization
+     */
+    private buildTaskContent;
+    /**
+     * Generate summary with exponential backoff retry
+     */
+    private generateSummaryWithRetry;
+    /**
+     * Generate the actual summary using Claude
+     */
+    private generateSummary;
+    /**
+     * Build the compaction prompt
+     */
+    private buildPrompt;
+    /**
+     * Check if an error is retryable
+     */
+    private isRetryable;
+    private sleep;
+}
+/**
+ * Create a task compaction service
+ */
+declare function createCompactionService(apiKey?: string): TaskCompactionService;
+
+/**
+ * Task Auto-Complete Detection
+ *
+ * Detects task references from multiple sources:
+ * - Branch names: feature/VT-42-description
+ * - Commit messages: "Fixes VT-42, closes VT-43"
+ * - PR titles: "[VT-42] Add login feature"
+ * - PR bodies: "Closes VT-42, VT-43, VT-44"
+ *
+ * Uses the issue-parser library (2M+ weekly downloads) from semantic-release.
+ *
+ * @see https://github.com/semantic-release/issue-parser
+ */
+type TaskRefAction = 'close' | 'progress';
+type TaskRefSource = 'commit_message' | 'branch_name' | 'pr_title' | 'pr_body' | 'issue_body';
+interface TaskReference {
+    /** The task short ID (e.g., "42") */
+    taskId: string;
+    /** What action to take: close the task or mark as in progress */
+    action: TaskRefAction;
+    /** Where the reference was found */
+    source: TaskRefSource;
+    /** The raw matched text (e.g., "VT-42", "#42") */
+    raw: string;
+    /** The prefix used (e.g., "VT-", "#") */
+    prefix?: string;
+}
+interface GitHubCommit {
+    id: string;
+    message: string;
+    author?: {
+        name?: string;
+        email?: string;
+        username?: string;
+    };
+    timestamp?: string;
+    url?: string;
+}
+interface GitHubPullRequest {
+    number: number;
+    title: string;
+    body: string | null;
+    html_url: string;
+    head: {
+        ref: string;
+    };
+    merged: boolean;
+    merged_by?: {
+        login: string;
+    };
+}
+interface ExtractTaskRefsOptions {
+    /** Array of commit objects with message field */
+    commits?: GitHubCommit[];
+    /** Branch name (e.g., "feature/VT-42-fix-login") */
+    branchName?: string;
+    /** PR title */
+    prTitle?: string;
+    /** PR body/description */
+    prBody?: string;
+}
+interface AutoCompleteResult {
+    /** Tasks to mark as complete */
+    tasksToClose: TaskReference[];
+    /** Tasks to mark as in progress */
+    tasksToProgress: TaskReference[];
+    /** All unique task IDs referenced */
+    allTaskIds: string[];
+}
+/**
+ * Extract task IDs from a branch name.
+ */
+declare function extractFromBranch(branchName: string): TaskReference | null;
+/**
+ * Extract task references from a single text (commit message, PR title, etc.)
+ */
+declare function extractFromText(text: string, source: TaskRefSource): TaskReference[];
+/**
+ * Extract task references from all provided sources.
+ *
+ * @example
+ * ```typescript
+ * const refs = extractTaskRefs({
+ *   commits: [{ message: "Fix VT-42, closes VT-43" }],
+ *   branchName: "feature/VT-42-fix-login",
+ *   prTitle: "[VT-42] Fix login bug",
+ *   prBody: "This PR fixes VT-42 and also addresses VT-44",
+ * });
+ * ```
+ */
+declare function extractTaskRefs(options: ExtractTaskRefsOptions): TaskReference[];
+/**
+ * Process extracted refs into a structured result.
+ */
+declare function processTaskRefs(options: ExtractTaskRefsOptions): AutoCompleteResult;
+/**
+ * Create a standardized branch name from a task.
+ *
+ * @example
+ * ```typescript
+ * createBranchName({ short_id: 42, title: "Fix Login Bug!" }, "fix")
+ * // => "fix/VT-42-fix-login-bug"
+ * ```
+ */
+declare function createBranchName(task: {
+    short_id: number;
+    title: string;
+}, type?: 'feature' | 'fix' | 'bugfix' | 'hotfix' | 'chore' | 'refactor' | 'docs' | 'test'): string;
+/**
+ * Check if a branch name contains a task reference.
+ */
+declare function branchHasTaskRef(branchName: string): boolean;
+/**
+ * Get the task ID from a branch name, if present.
+ */
+declare function getTaskIdFromBranch(branchName: string): string | null;
+/**
+ * Process a GitHub push event to extract task references from all commits.
+ */
+declare function processGitHubPush(payload: {
+    ref: string;
+    commits: GitHubCommit[];
+}): AutoCompleteResult;
+/**
+ * Process a GitHub pull_request event to extract task references.
+ */
+declare function processGitHubPullRequest(payload: {
+    action: string;
+    pull_request: GitHubPullRequest;
+}): AutoCompleteResult;
+/**
+ * Generate completion notes for a task closed via GitHub.
+ */
+declare function generateCompletionNotes(options: {
+    source: 'push' | 'pr_merged';
+    prNumber?: number;
+    prUrl?: string;
+    mergedBy?: string;
+    commitId?: string;
+    branchName?: string;
+}): string;
+
+export { type Attachment, AuthManager, type AutoCompleteResult, type ChangeType, ClaudeSync, type ClaudeTodoItem, type CodebaseContext, type CompactionOptions, type CompactionResult, ConfigManager, type ContextLoaderOptions, type ExtractTaskRefsOptions, type GitHubCommit, type GitHubPullRequest, type IntegrationSyncResult, IntegrationSyncService, type RLMConfig, RLMContextLoader, RLMEngine, RLMMCPTool, type RLMQueryInput, type RLMQueryOutput, type RLMResult, RLM_MCP_TOOLS, type SourceType, type Subtask, type SupabaseConfig, type SyncAllResult, type SyncOptions, type SyncResult, type Tag, type Task$1 as Task, type TaskChange, TaskCompactionService, type TaskFlowConfig, TaskOperations, type TaskRefAction, type TaskRefSource, type TaskReference, type Workspace, batchProcessTasksWithClaude, branchHasTaskRef, createBranchName, createCompactionService, createSupabaseClient, createSupabaseClientFromEnv, extractFromBranch, extractFromText, extractIntent, extractIntentWithClaude, extractTaskRefs, generateCompletionNotes, generateContextTags, generateContextTagsWithClaude, generateTaskEmbedding, generateTaskEmbeddingWithClaude, getTaskIdFromBranch, processGitHubPullRequest, processGitHubPush, processTaskRefs, syncClaudeTodos };