@vibetasks/core 0.5.8 → 0.5.10

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
 // src/config-manager.ts
 import fs from "fs/promises";
 import path from "path";
@@ -372,11 +376,283 @@ var AuthManager = class {
   }
 };
 
+// src/integration-sync.ts
+var IntegrationSyncService = class {
+  supabase;
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  /**
+   * Sync task completion to external integrations
+   * Called when a task is marked as done
+   */
+  async syncTaskComplete(task) {
+    const results = [];
+    if (task.sentry_issue_id) {
+      const sentryResult = await this.resolveSentryIssue(task);
+      results.push(sentryResult);
+    }
+    if (task.github_issue_id || task.github_issue_number) {
+      const githubResult = await this.closeGitHubIssue(task);
+      results.push(githubResult);
+    }
+    return results;
+  }
+  /**
+   * Resolve a Sentry issue when the task is completed
+   */
+  async resolveSentryIssue(task) {
+    const result = {
+      success: false,
+      integration: "sentry",
+      action: "resolve",
+      externalId: task.sentry_issue_id,
+      externalUrl: task.sentry_url
+    };
+    try {
+      const { data: integration, error: integrationError } = await this.supabase.from("sentry_integrations").select("sentry_auth_token, sentry_org_slug, sync_to_sentry, is_enabled").eq("user_id", task.user_id).single();
+      if (integrationError || !integration) {
+        result.error = "No Sentry integration configured";
+        return result;
+      }
+      if (!integration.is_enabled || !integration.sync_to_sentry) {
+        result.error = "Sentry sync is disabled";
+        return result;
+      }
+      if (!integration.sentry_auth_token) {
+        result.error = "No Sentry auth token configured";
+        return result;
+      }
+      const projectSlug = task.sentry_project?.split("/").pop() || "";
+      const orgSlug = integration.sentry_org_slug || task.sentry_project?.split("/")[0] || "";
+      if (!orgSlug || !projectSlug) {
+        result.error = "Cannot determine Sentry org/project from task data";
+        return result;
+      }
+      const sentryApiUrl = `https://sentry.io/api/0/issues/${task.sentry_issue_id}/`;
+      const response = await fetch(sentryApiUrl, {
+        method: "PUT",
+        headers: {
+          "Authorization": `Bearer ${integration.sentry_auth_token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          status: "resolved"
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        result.error = `Sentry API error: ${response.status} - ${errorText}`;
+        await this.logSyncAttempt(task, result, response.status);
+        return result;
+      }
+      result.success = true;
+      await this.logSyncAttempt(task, result, response.status);
+      return result;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : "Unknown error";
+      await this.logSyncAttempt(task, result);
+      return result;
+    }
+  }
+  /**
+   * Close a GitHub issue when the task is completed
+   */
+  async closeGitHubIssue(task) {
+    const result = {
+      success: false,
+      integration: "github",
+      action: "close",
+      externalId: task.github_issue_number?.toString() || task.github_issue_id?.toString(),
+      externalUrl: task.github_url
+    };
+    try {
+      const { data: integration, error: integrationError } = await this.supabase.from("github_integrations").select("github_token, sync_to_github, is_enabled").eq("user_id", task.user_id).single();
+      if (integrationError || !integration) {
+        result.error = "No GitHub integration configured";
+        return result;
+      }
+      if (!integration.is_enabled || !integration.sync_to_github) {
+        result.error = "GitHub sync is disabled";
+        return result;
+      }
+      if (!integration.github_token) {
+        result.error = "No GitHub token configured";
+        return result;
+      }
+      const [owner, repo] = (task.github_repo || "").split("/");
+      const issueNumber = task.github_issue_number || task.github_issue_id;
+      if (!owner || !repo || !issueNumber) {
+        result.error = "Cannot determine GitHub repo/issue from task data";
+        return result;
+      }
+      const githubApiUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`;
+      const response = await fetch(githubApiUrl, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${integration.github_token}`,
+          "Accept": "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          state: "closed",
+          state_reason: "completed"
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        result.error = `GitHub API error: ${response.status} - ${errorText}`;
+        await this.logSyncAttempt(task, result, response.status);
+        return result;
+      }
+      result.success = true;
+      await this.logSyncAttempt(task, result, response.status);
+      return result;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : "Unknown error";
+      await this.logSyncAttempt(task, result);
+      return result;
+    }
+  }
+  /**
+   * Log sync attempt for debugging and auditing
+   */
+  async logSyncAttempt(task, result, responseStatus) {
+    try {
+      await this.supabase.from("integration_sync_logs").insert({
+        user_id: task.user_id,
+        task_id: task.id,
+        integration: result.integration,
+        action: result.action,
+        external_id: result.externalId,
+        external_url: result.externalUrl,
+        success: result.success,
+        error_message: result.error,
+        response_status: responseStatus
+      });
+    } catch (error) {
+      console.error("Failed to log sync attempt:", error);
+    }
+  }
+  /**
+   * Sync task reopen to external integrations
+   * Called when a task is moved back to todo/vibing from done
+   */
+  async syncTaskReopen(task) {
+    const results = [];
+    if (task.sentry_issue_id) {
+      const sentryResult = await this.unresolveSentryIssue(task);
+      results.push(sentryResult);
+    }
+    if (task.github_issue_id || task.github_issue_number) {
+      const githubResult = await this.reopenGitHubIssue(task);
+      results.push(githubResult);
+    }
+    return results;
+  }
+  /**
+   * Unresolve a Sentry issue when the task is reopened
+   */
+  async unresolveSentryIssue(task) {
+    const result = {
+      success: false,
+      integration: "sentry",
+      action: "unresolve",
+      externalId: task.sentry_issue_id,
+      externalUrl: task.sentry_url
+    };
+    try {
+      const { data: integration } = await this.supabase.from("sentry_integrations").select("sentry_auth_token, sync_to_sentry, is_enabled").eq("user_id", task.user_id).single();
+      if (!integration?.is_enabled || !integration?.sync_to_sentry || !integration?.sentry_auth_token) {
+        result.error = "Sentry sync not configured or disabled";
+        return result;
+      }
+      const sentryApiUrl = `https://sentry.io/api/0/issues/${task.sentry_issue_id}/`;
+      const response = await fetch(sentryApiUrl, {
+        method: "PUT",
+        headers: {
+          "Authorization": `Bearer ${integration.sentry_auth_token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          status: "unresolved"
+        })
+      });
+      if (!response.ok) {
+        result.error = `Sentry API error: ${response.status}`;
+        await this.logSyncAttempt(task, result, response.status);
+        return result;
+      }
+      result.success = true;
+      await this.logSyncAttempt(task, result, response.status);
+      return result;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : "Unknown error";
+      await this.logSyncAttempt(task, result);
+      return result;
+    }
+  }
+  /**
+   * Reopen a GitHub issue when the task is reopened
+   */
+  async reopenGitHubIssue(task) {
+    const result = {
+      success: false,
+      integration: "github",
+      action: "reopen",
+      externalId: task.github_issue_number?.toString(),
+      externalUrl: task.github_url
+    };
+    try {
+      const { data: integration } = await this.supabase.from("github_integrations").select("github_token, sync_to_github, is_enabled").eq("user_id", task.user_id).single();
+      if (!integration?.is_enabled || !integration?.sync_to_github || !integration?.github_token) {
+        result.error = "GitHub sync not configured or disabled";
+        return result;
+      }
+      const [owner, repo] = (task.github_repo || "").split("/");
+      const issueNumber = task.github_issue_number || task.github_issue_id;
+      if (!owner || !repo || !issueNumber) {
+        result.error = "Cannot determine GitHub repo/issue from task data";
+        return result;
+      }
+      const githubApiUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`;
+      const response = await fetch(githubApiUrl, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${integration.github_token}`,
+          "Accept": "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          state: "open"
+        })
+      });
+      if (!response.ok) {
+        result.error = `GitHub API error: ${response.status}`;
+        await this.logSyncAttempt(task, result, response.status);
+        return result;
+      }
+      result.success = true;
+      await this.logSyncAttempt(task, result, response.status);
+      return result;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : "Unknown error";
+      await this.logSyncAttempt(task, result);
+      return result;
+    }
+  }
+};
+
 // src/task-operations.ts
 var TaskOperations = class _TaskOperations {
   supabase;
-  constructor(supabase) {
+  // 🔒 WORKSPACE ISOLATION: Track workspace context
+  workspaceId;
+  constructor(supabase, workspaceId) {
     this.supabase = supabase;
+    this.workspaceId = workspaceId;
   }
   // Current session ID for change tracking
   currentSessionId;
@@ -386,13 +662,27 @@ var TaskOperations = class _TaskOperations {
   setSessionId(sessionId) {
     this.currentSessionId = sessionId;
   }
+  /**
+   * Set the workspace ID for workspace isolation
+   * 🔒 WORKSPACE ISOLATION: Filter all queries by workspace
+   */
+  setWorkspaceId(workspaceId) {
+    this.workspaceId = workspaceId;
+  }
+  /**
+   * Get current workspace ID
+   */
+  getWorkspaceId() {
+    return this.workspaceId;
+  }
   /**
    * Create TaskOperations from AuthManager
    * Automatically refreshes expired tokens
+   * 🔒 WORKSPACE ISOLATION: Accepts optional workspaceId parameter
    */
-  static async fromAuthManager(authManager) {
+  static async fromAuthManager(authManager, workspaceId) {
     const supabaseUrl = await authManager.getConfig("supabase_url") || "https://ihmayqzxqyednchbezya.supabase.co";
-    const supabaseKey = await authManager.getConfig("supabase_key") || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNia2t6dGJjb2l0cmZjbGVnaGZkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3Njc3NTc0MjgsImV4cCI6MjA4MzMzMzQyOH0.G7ILx-nntP0NbxO1gKt5yASb7nt7OmpJ8qtykeGYbQA";
+    const supabaseKey = await authManager.getConfig("supabase_key") || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImlobWF5cXp4cXllZG5jaGJlenlhIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjgxNzcyOTgsImV4cCI6MjA4Mzc1MzI5OH0._xhGhkqoy7AMm7M5dxSHXM_yeP8zVAJG-BaGMICtHFo";
     const accessToken = await authManager.getValidAccessToken();
     if (!accessToken) {
       throw new Error("Not authenticated or session expired. Run: vibetasks login --browser");
@@ -402,16 +692,21 @@ var TaskOperations = class _TaskOperations {
       supabaseKey,
       accessToken
     });
-    return new _TaskOperations(supabase);
+    return new _TaskOperations(supabase, workspaceId);
   }
   // ============================================
   // TASK CRUD OPERATIONS
   // ============================================
   async getTasks(filter = "all", includeArchived = false) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
     let query = this.supabase.from("tasks").select(`
         *,
         tags:task_tags(tag:tags(*))
-      `).is("parent_task_id", null).order("position", { ascending: true });
+      `).eq("user_id", user.id).is("parent_task_id", null).order("position", { ascending: true });
+    if (this.workspaceId) {
+      query = query.eq("workspace_id", this.workspaceId);
+    }
     if (!includeArchived) {
       query = query.neq("status", "archived");
     }
@@ -439,11 +734,13 @@ var TaskOperations = class _TaskOperations {
     }));
   }
   async getTask(taskId) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
     const { data, error } = await this.supabase.from("tasks").select(`
         *,
         tags:task_tags(tag:tags(*)),
         attachments:task_attachments(*)
-      `).eq("id", taskId).single();
+      `).eq("id", taskId).eq("user_id", user.id).single();
     if (error) throw error;
     return {
       ...data,
@@ -460,6 +757,8 @@ var TaskOperations = class _TaskOperations {
     const nextShortId = (maxIdResult?.short_id || 0) + 1;
     const { data, error } = await this.supabase.from("tasks").insert({
       user_id: user.id,
+      workspace_id: task.workspace_id || this.workspaceId || null,
+      // 🔒 WORKSPACE ISOLATION
       title: task.title,
       description: task.description,
       notes: task.notes,
@@ -523,6 +822,10 @@ var TaskOperations = class _TaskOperations {
     if (updates.created_by !== void 0) updateData.created_by = updates.created_by;
     if (updates.context_notes !== void 0) updateData.context_notes = updates.context_notes;
     if (updates.energy_required !== void 0) updateData.energy_required = updates.energy_required;
+    if (updates.semantic_vector !== void 0) updateData.semantic_vector = updates.semantic_vector;
+    if (updates.intent !== void 0) updateData.intent = updates.intent;
+    if (updates.context_tags !== void 0) updateData.context_tags = updates.context_tags;
+    if (updates.needs_embedding_update !== void 0) updateData.needs_embedding_update = updates.needs_embedding_update;
     const { data, error } = await this.supabase.from("tasks").update(updateData).eq("id", taskId).select().single();
     if (error) throw error;
     if (updates.tags !== void 0) {
@@ -617,7 +920,7 @@ var TaskOperations = class _TaskOperations {
     if (error) throw error;
   }
   async completeTask(taskId) {
-    const { data: existingTask } = await this.supabase.from("tasks").select("subtasks, acceptance_criteria, status, title").eq("id", taskId).single();
+    const { data: existingTask } = await this.supabase.from("tasks").select("subtasks, acceptance_criteria, status, title, user_id, sentry_issue_id, sentry_project, sentry_url, github_issue_id, github_issue_number, github_repo, github_url").eq("id", taskId).single();
     const oldStatus = existingTask?.status || "todo";
     const updatePayload = {
       completed: true,
@@ -630,8 +933,18 @@ var TaskOperations = class _TaskOperations {
     if (existingTask?.acceptance_criteria && Array.isArray(existingTask.acceptance_criteria)) {
       updatePayload.acceptance_criteria = existingTask.acceptance_criteria.map((c) => ({ ...c, done: true }));
     }
-    const { data, error } = await this.supabase.from("tasks").update(updatePayload).eq("id", taskId).select().single();
-    if (error) throw error;
+    const { data, error } = await this.supabase.from("tasks").update(updatePayload).eq("id", taskId).select();
+    if (error) {
+      console.error("Error updating task:", error);
+      throw new Error(`Failed to complete task: ${error.message}`);
+    }
+    if (!data || data.length === 0) {
+      throw new Error(`Task ${taskId} not found or update failed`);
+    }
+    if (data.length > 1) {
+      console.warn(`Warning: Multiple rows updated for task ${taskId}`);
+    }
+    const updatedTask = data[0];
     await this.logChange({
       taskId,
       changeType: "status_changed",
@@ -640,7 +953,33 @@ var TaskOperations = class _TaskOperations {
       newValue: "done",
       message: `Completed: ${existingTask?.title || "task"}`
     });
-    return data;
+    if (existingTask?.sentry_issue_id || existingTask?.github_issue_id || existingTask?.github_issue_number) {
+      try {
+        const syncService = new IntegrationSyncService(this.supabase);
+        const syncResults = await syncService.syncTaskComplete({
+          id: taskId,
+          user_id: existingTask.user_id,
+          title: existingTask.title,
+          sentry_issue_id: existingTask.sentry_issue_id,
+          sentry_project: existingTask.sentry_project,
+          sentry_url: existingTask.sentry_url,
+          github_issue_id: existingTask.github_issue_id,
+          github_issue_number: existingTask.github_issue_number,
+          github_repo: existingTask.github_repo,
+          github_url: existingTask.github_url
+        });
+        for (const result of syncResults) {
+          if (result.success) {
+            console.log(`[IntegrationSync] ${result.integration}: ${result.action} successful`);
+          } else if (result.error && !result.error.includes("disabled") && !result.error.includes("not configured")) {
+            console.warn(`[IntegrationSync] ${result.integration}: ${result.error}`);
+          }
+        }
+      } catch (syncError) {
+        console.error("[IntegrationSync] Error syncing task completion:", syncError);
+      }
+    }
+    return updatedTask;
   }
   async uncompleteTask(taskId) {
     const { data, error } = await this.supabase.from("tasks").update({
@@ -700,6 +1039,260 @@ var TaskOperations = class _TaskOperations {
     }));
   }
   // ============================================
+  // TASK HEALTH & DEPENDENCY OPERATIONS
+  // (Inspired by beads: ready, stale, orphans, blocked)
+  // ============================================
+  /**
+   * Get tasks ready to work on (no blockers, not deferred)
+   */
+  async getReadyTasks(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const status = options.status || "vibing";
+    const limit = options.limit || 50;
+    const { data, error } = await this.supabase.rpc("get_ready_tasks", {
+      p_user_id: user.id,
+      p_workspace_id: this.workspaceId || null,
+      p_status: status,
+      p_limit: limit
+    });
+    if (error) {
+      if (error.message.includes("function") || error.code === "42883") {
+        return this.getReadyTasksFallback(status, limit);
+      }
+      throw error;
+    }
+    return data || [];
+  }
+  /**
+   * Fallback for ready tasks when RPC function doesn't exist
+   */
+  async getReadyTasksFallback(status, limit) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    let query = this.supabase.from("tasks").select(`
+        *,
+        tags:task_tags(tag:tags(*))
+      `).eq("user_id", user.id).is("parent_task_id", null).order("priority", { ascending: false }).order("due_date", { ascending: true, nullsFirst: false }).limit(limit);
+    if (this.workspaceId) {
+      query = query.eq("workspace_id", this.workspaceId);
+    }
+    if (status) {
+      query = query.eq("status", status);
+    } else {
+      query = query.in("status", ["todo", "vibing"]);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return (data || []).map((task) => ({
+      ...task,
+      tags: task.tags?.map((t) => t.tag).filter(Boolean) || []
+    }));
+  }
+  /**
+   * Get stale tasks (not updated in X days)
+   */
+  async getStaleTasks(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const days = options.days || 7;
+    const limit = options.limit || 50;
+    const { data, error } = await this.supabase.rpc("get_stale_tasks", {
+      p_user_id: user.id,
+      p_days: days,
+      p_status: options.status || null,
+      p_workspace_id: this.workspaceId || null,
+      p_limit: limit
+    });
+    if (error) {
+      if (error.message.includes("function") || error.code === "42883") {
+        return this.getStaleTasksFallback(days, options.status, limit);
+      }
+      throw error;
+    }
+    return data || [];
+  }
+  /**
+   * Fallback for stale tasks when RPC function doesn't exist
+   */
+  async getStaleTasksFallback(days, status, limit = 50) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const staleDate = /* @__PURE__ */ new Date();
+    staleDate.setDate(staleDate.getDate() - days);
+    let query = this.supabase.from("tasks").select("*").eq("user_id", user.id).not("status", "in", '("done","archived")').lt("updated_at", staleDate.toISOString()).order("updated_at", { ascending: true }).limit(limit);
+    if (this.workspaceId) {
+      query = query.eq("workspace_id", this.workspaceId);
+    }
+    if (status) {
+      query = query.eq("status", status);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return (data || []).map((task) => ({
+      ...task,
+      days_stale: Math.floor((Date.now() - new Date(task.updated_at).getTime()) / (1e3 * 60 * 60 * 24))
+    }));
+  }
+  /**
+   * Get orphaned tasks (incomplete tasks from old AI sessions)
+   */
+  async getOrphanedTasks(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const limit = options.limit || 50;
+    const { data, error } = await this.supabase.rpc("get_orphaned_tasks", {
+      p_user_id: user.id,
+      p_current_session_id: options.currentSessionId || null,
+      p_workspace_id: this.workspaceId || null,
+      p_limit: limit
+    });
+    if (error) {
+      if (error.message.includes("function") || error.code === "42883") {
+        return this.getOrphanedTasksFallback(options.currentSessionId, limit);
+      }
+      throw error;
+    }
+    return data || [];
+  }
+  /**
+   * Fallback for orphaned tasks when RPC function doesn't exist
+   */
+  async getOrphanedTasksFallback(currentSessionId, limit = 50) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    let query = this.supabase.from("tasks").select("*").eq("user_id", user.id).in("status", ["vibing", "todo"]).order("updated_at", { ascending: false }).limit(limit);
+    if (this.workspaceId) {
+      query = query.eq("workspace_id", this.workspaceId);
+    }
+    if (currentSessionId) {
+      query = query.or(`session_id.is.null,session_id.neq.${currentSessionId}`);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return (data || []).map((task) => {
+      const subtasks = task.subtasks || [];
+      return {
+        ...task,
+        subtasks_total: subtasks.length,
+        subtasks_done: subtasks.filter((s) => s.done).length
+      };
+    });
+  }
+  /**
+   * Get blocked tasks (tasks with open dependencies)
+   */
+  async getBlockedTasks(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const limit = options.limit || 50;
+    const { data, error } = await this.supabase.rpc("get_blocked_tasks", {
+      p_user_id: user.id,
+      p_workspace_id: this.workspaceId || null,
+      p_limit: limit
+    });
+    if (error) {
+      if (error.message.includes("function") || error.code === "42883") {
+        return this.getBlockedTasksFallback(limit);
+      }
+      throw error;
+    }
+    return data || [];
+  }
+  /**
+   * Fallback for blocked tasks when RPC function doesn't exist
+   */
+  async getBlockedTasksFallback(limit = 50) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const { data, error } = await this.supabase.from("task_dependencies").select(`
+        task_id,
+        depends_on_task_id,
+        task:tasks!task_dependencies_task_id_fkey(
+          id, title, status, priority, short_id
+        ),
+        blocker:tasks!task_dependencies_depends_on_task_id_fkey(
+          id, title, status
+        )
+      `).eq("dependency_type", "blocks").limit(limit * 2);
+    if (error) throw error;
+    const blockedMap = /* @__PURE__ */ new Map();
+    for (const dep of data || []) {
+      const blocker = Array.isArray(dep.blocker) ? dep.blocker[0] : dep.blocker;
+      const task = Array.isArray(dep.task) ? dep.task[0] : dep.task;
+      if (blocker?.status !== "done" && blocker?.status !== "archived") {
+        const taskId = dep.task_id;
+        if (!blockedMap.has(taskId)) {
+          blockedMap.set(taskId, {
+            ...task,
+            blocked_by_count: 0,
+            blocker_ids: [],
+            blocker_titles: []
+          });
+        }
+        const mappedTask = blockedMap.get(taskId);
+        mappedTask.blocked_by_count++;
+        mappedTask.blocker_ids.push(blocker.id);
+        mappedTask.blocker_titles.push(blocker.title);
+      }
+    }
+    return Array.from(blockedMap.values()).slice(0, limit);
+  }
+  // ============================================
+  // TASK COMPACTION OPERATIONS
+  // ============================================
+  /**
+   * Get tasks eligible for compaction (completed, old, not yet compacted)
+   */
+  async getCompactableTasks(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const minDays = options.minDaysOld || 7;
+    const maxLevel = options.maxCompactionLevel || 0;
+    const limit = options.limit || 10;
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - minDays);
+    let query = this.supabase.from("tasks").select("*").eq("user_id", user.id).eq("status", "done").lte("completed_at", cutoffDate.toISOString()).or(`compaction_level.is.null,compaction_level.lte.${maxLevel}`).order("completed_at", { ascending: true }).limit(limit);
+    if (this.workspaceId) {
+      query = query.eq("workspace_id", this.workspaceId);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return data || [];
+  }
+  /**
+   * Update a task with compaction results
+   */
+  async applyCompaction(taskId, summary) {
+    const { data, error } = await this.supabase.from("tasks").update({
+      context_summary: summary,
+      compaction_level: 1,
+      compacted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", taskId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Get compaction statistics for the user
+   */
+  async getCompactionStats() {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const { count: totalCompleted } = await this.supabase.from("tasks").select("*", { count: "exact", head: true }).eq("user_id", user.id).eq("status", "done");
+    const { count: compacted } = await this.supabase.from("tasks").select("*", { count: "exact", head: true }).eq("user_id", user.id).eq("status", "done").gt("compaction_level", 0);
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - 7);
+    const { count: eligible } = await this.supabase.from("tasks").select("*", { count: "exact", head: true }).eq("user_id", user.id).eq("status", "done").lte("completed_at", cutoffDate.toISOString()).or("compaction_level.is.null,compaction_level.eq.0");
+    return {
+      totalCompleted: totalCompleted || 0,
+      compacted: compacted || 0,
+      eligible: eligible || 0,
+      savedBytes: 0
+      // Would need to track original vs compacted sizes
+    };
+  }
+  // ============================================
   // TAG OPERATIONS
   // ============================================
   async getTags() {
@@ -767,6 +1360,10 @@ var TaskOperations = class _TaskOperations {
    * Get all attachments for a task with signed URLs
    */
   async getTaskAttachments(taskId) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const task = await this.getTask(taskId);
+    if (!task) throw new Error("Task not found or access denied");
     const { data, error } = await this.supabase.from("task_attachments").select("*").eq("task_id", taskId);
     if (error) throw error;
     const attachmentsWithUrls = await Promise.all(
@@ -930,6 +1527,43 @@ var TaskOperations = class _TaskOperations {
     return data || [];
   }
   // ============================================
+  // SESSION ACTIONS
+  // ============================================
+  /**
+   * Log an action to the current AI session
+   */
+  async logSessionAction(sessionId, action) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) return;
+    const { data: session } = await this.supabase.from("ai_sessions").select("id").eq("user_id", user.id).eq("session_id", sessionId).single();
+    if (!session) {
+      console.warn(`Session ${sessionId} not found, skipping action log`);
+      return;
+    }
+    const { error } = await this.supabase.from("session_actions").insert({
+      session_id: session.id,
+      user_id: user.id,
+      action_type: action.action_type,
+      description: action.description,
+      task_id: action.task_id,
+      doc_id: action.doc_id,
+      metadata: action.metadata || {},
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (error) {
+      console.error("Failed to log session action:", error);
+      return;
+    }
+    const { data: stats } = await this.supabase.rpc("get_session_stats", { p_session_id: session.id });
+    if (stats && stats[0]) {
+      await this.supabase.from("ai_sessions").update({
+        tasks_created: stats[0].tasks_created,
+        tasks_completed: stats[0].tasks_completed,
+        action_count: stats[0].action_count
+      }).eq("id", session.id);
+    }
+  }
+  // ============================================
   // CHANGE TRACKING (Git-for-Tasks)
   // ============================================
   /**
@@ -978,9 +1612,18 @@ var TaskOperations = class _TaskOperations {
    * Get a specific change (like git show)
    */
   async getChange(changeId) {
-    const { data, error } = await this.supabase.from("task_changes").select("*").eq("id", changeId).single();
+    const { data, error } = await this.supabase.from("task_changes").select(`
+        *,
+        task:tasks!inner(user_id)
+      `).eq("id", changeId).single();
     if (error) throw error;
-    return data;
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const change = data;
+    if (change.task?.user_id !== user.id) {
+      throw new Error("Access denied: Change belongs to another user");
+    }
+    return change;
   }
   /**
    * Revert a change (non-destructive - creates a new "revert" change)
@@ -1030,26 +1673,25 @@ var TaskOperations = class _TaskOperations {
   // ============================================
   /**
    * 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
    */
   async createWorkspace(input) {
     const { data: { user } } = await this.supabase.auth.getUser();
     if (!user) throw new Error("Not authenticated");
-    let fullPath = input.displayName;
-    let depth = 0;
-    if (input.parentId) {
-      const { data: parent } = await this.supabase.from("workspaces").select("full_path, depth").eq("id", input.parentId).single();
-      if (parent) {
-        fullPath = `${parent.full_path} > ${input.displayName}`;
-        depth = parent.depth + 1;
-      }
-    }
     const { data, error } = await this.supabase.from("workspaces").insert({
       user_id: user.id,
       slug: input.slug,
       display_name: input.displayName,
-      full_path: fullPath,
-      parent_id: input.parentId,
-      depth,
+      full_path: input.displayName,
+      // No hierarchy - just the name
+      // parent_id omitted - workspaces are top-level only
+      depth: 0,
+      // Always 0 in flat model
       color: input.color,
       description: input.description
     }).select().single();
@@ -1077,38 +1719,36 @@ var TaskOperations = class _TaskOperations {
     return data;
   }
   /**
-   * 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
    */
   async getOrCreateWorkspace(projectTag) {
     const existing = await this.getWorkspaceByPath(projectTag);
     if (existing) return existing;
     const { data: { user } } = await this.supabase.auth.getUser();
     if (!user) throw new Error("Not authenticated");
-    const parts = projectTag.split(/\s*>\s*/).map((p) => p.trim()).filter(Boolean);
-    let parentId;
-    let currentPath = "";
-    for (let i = 0; i < parts.length; i++) {
-      const displayName = parts[i];
-      const slug = displayName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-      currentPath = i === 0 ? displayName : `${currentPath} > ${displayName}`;
-      const existing2 = await this.getWorkspaceByPath(currentPath);
-      if (existing2) {
-        parentId = existing2.id;
-        continue;
-      }
-      const { data, error } = await this.supabase.from("workspaces").insert({
-        user_id: user.id,
-        slug,
-        display_name: displayName,
-        full_path: currentPath,
-        parent_id: parentId,
-        depth: i,
-        color: this.generateWorkspaceColor(currentPath)
-      }).select().single();
-      if (error) throw error;
-      parentId = data.id;
-    }
-    return await this.getWorkspaceByPath(projectTag);
+    const parts = projectTag.split(/\s*[>›]\s*/).map((p) => p.trim()).filter(Boolean);
+    const displayName = parts[parts.length - 1] || projectTag;
+    const slug = displayName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const { data: existingByName } = await this.supabase.from("workspaces").select("*").eq("display_name", displayName).single();
+    if (existingByName) return existingByName;
+    const { data, error } = await this.supabase.from("workspaces").insert({
+      user_id: user.id,
+      slug,
+      display_name: displayName,
+      full_path: displayName,
+      // Flat model: full_path = display_name
+      // parent_id omitted - workspaces are top-level only
+      depth: 0,
+      // Always 0 in flat model
+      color: this.generateWorkspaceColor(displayName)
+    }).select().single();
+    if (error) throw error;
+    return data;
   }
   /**
    * Archive a workspace (soft delete)
@@ -1211,14 +1851,135 @@ var TaskOperations = class _TaskOperations {
     });
     return data;
   }
-};
-
-// src/claude-sync.ts
-function mapStatus(claudeStatus) {
-  switch (claudeStatus) {
-    case "pending":
-      return "todo";
-    case "in_progress":
+  // ============================================
+  // MEETING OPERATIONS
+  // ============================================
+  /**
+   * Get meetings for the current user
+   */
+  async getMeetings(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const limit = options.limit || 20;
+    let query = this.supabase.from("meetings").select(`
+        id,
+        title,
+        description,
+        meeting_type,
+        started_at,
+        ended_at,
+        duration_seconds,
+        participants,
+        organizer_name,
+        organizer_email,
+        summary,
+        key_points,
+        decisions,
+        tags,
+        sync_status,
+        created_at,
+        updated_at
+      `).eq("user_id", user.id).order("started_at", { ascending: false }).limit(limit);
+    if (options.workspace_id) {
+      query = query.eq("workspace_id", options.workspace_id);
+    } else if (this.workspaceId) {
+      query = query.eq("workspace_id", this.workspaceId);
+    }
+    if (options.since) {
+      query = query.gte("started_at", options.since);
+    }
+    const { data: meetings, error } = await query;
+    if (error) {
+      if (error.code === "42P01") {
+        return [];
+      }
+      throw error;
+    }
+    const meetingIds = (meetings || []).map((m) => m.id);
+    if (meetingIds.length > 0) {
+      const { data: actionItems } = await this.supabase.from("meeting_action_items").select("meeting_id").in("meeting_id", meetingIds);
+      const actionCounts = {};
+      (actionItems || []).forEach((ai) => {
+        actionCounts[ai.meeting_id] = (actionCounts[ai.meeting_id] || 0) + 1;
+      });
+      return (meetings || []).map((m) => ({
+        ...m,
+        action_items_count: actionCounts[m.id] || 0
+      }));
+    }
+    return meetings || [];
+  }
+  // ============================================
+  // SKILL OPERATIONS
+  // ============================================
+  /**
+   * Create a custom skill
+   */
+  async createSkill(skill) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const slug = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const instructions = `## ${skill.name}
+
+${skill.description}
+
+### Steps:
+${skill.steps.map((s, i) => `${i + 1}. ${s.action}${s.tool ? ` (use ${s.tool})` : ""}`).join("\n")}`;
+    const skillData = {
+      user_id: user.id,
+      workspace_id: skill.workspace_id || this.workspaceId,
+      name: skill.name,
+      slug,
+      description: skill.description,
+      category: skill.category,
+      instructions,
+      trigger_phrases: skill.trigger_phrases,
+      workflow_dag: { nodes: skill.steps.map((s, i) => ({ id: `step-${i + 1}`, data: s })) },
+      is_enabled: true
+    };
+    const { data, error } = await this.supabase.from("skills").insert(skillData).select().single();
+    if (error) {
+      if (error.code === "23505") {
+        throw new Error(`A skill with slug "${slug}" already exists. Choose a different name.`);
+      }
+      if (error.code === "42P01") {
+        throw new Error("Skills system not yet set up. Run migrations first.");
+      }
+      throw error;
+    }
+    return data;
+  }
+  /**
+   * List user's skills
+   */
+  async getSkills(options = {}) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    let query = this.supabase.from("skills").select("*").eq("user_id", user.id).order("created_at", { ascending: false });
+    if (options.workspace_id) {
+      query = query.eq("workspace_id", options.workspace_id);
+    }
+    if (options.category) {
+      query = query.eq("category", options.category);
+    }
+    if (options.enabled_only !== false) {
+      query = query.eq("is_enabled", true);
+    }
+    const { data, error } = await query;
+    if (error) {
+      if (error.code === "42P01") return [];
+      throw error;
+    }
+    return data || [];
+  }
+};
+
+// src/claude-sync.ts
+function mapStatus(claudeStatus) {
+  switch (claudeStatus) {
+    case "pending":
+      return "todo";
+    case "in_progress":
       return "vibing";
     case "completed":
       return "done";
@@ -1226,6 +1987,19 @@ function mapStatus(claudeStatus) {
       return "todo";
   }
 }
+function generateA2ATaskId(title, workspaceId = "00000000-0000-0000-0000-000000000000", createdBy = "unknown") {
+  const normalizedTitle = title.toLowerCase().trim().replace(/\s+/g, " ");
+  const hashInput = `${normalizedTitle}::${workspaceId}::${createdBy}`;
+  const crypto = __require("crypto");
+  const hash = crypto.createHash("md5").update(hashInput).digest("hex");
+  return [
+    hash.substring(0, 8),
+    hash.substring(8, 12),
+    hash.substring(12, 16),
+    hash.substring(16, 20),
+    hash.substring(20, 32)
+  ].join("-");
+}
 function calculateSimilarity(str1, str2) {
   const s1 = str1.toLowerCase().trim();
   const s2 = str2.toLowerCase().trim();
@@ -1246,19 +2020,27 @@ function calculateSimilarity(str1, str2) {
   if (totalWords === 0) return 0;
   return commonWords / totalWords;
 }
-function findBestMatch(todoContent, tasks, threshold = 0.6) {
+function findBestMatch(todoContent, tasks, threshold = 0.6, workspaceId, createdBy) {
+  if (workspaceId && createdBy) {
+    const targetA2AId = generateA2ATaskId(todoContent, workspaceId, createdBy);
+    for (const task of tasks) {
+      if (task.a2a_task_id === targetA2AId) {
+        return { task, similarity: 1, matchType: "exact" };
+      }
+    }
+  }
   let bestMatch = null;
   for (const task of tasks) {
     const similarity = calculateSimilarity(todoContent, task.title);
     if (similarity >= threshold) {
       if (!bestMatch || similarity > bestMatch.similarity) {
-        bestMatch = { task, similarity };
+        bestMatch = { task, similarity, matchType: "fuzzy" };
       }
     }
     if (task.context_notes) {
       const noteSimilarity = calculateSimilarity(todoContent, task.context_notes);
       if (noteSimilarity >= threshold && noteSimilarity > (bestMatch?.similarity || 0)) {
-        bestMatch = { task, similarity: noteSimilarity };
+        bestMatch = { task, similarity: noteSimilarity, matchType: "fuzzy" };
       }
     }
   }
@@ -1277,18 +2059,22 @@ var ClaudeSync = class {
       createMissing = false,
       projectTag,
       matchThreshold = 0.6,
-      syncPending = true
+      syncPending = true,
+      workspaceId,
+      createdBy
     } = options;
     try {
+      const a2aTaskId = workspaceId && createdBy ? generateA2ATaskId(todo.content, workspaceId, createdBy) : void 0;
       if (todo.status === "pending" && !syncPending) {
         return {
           content: todo.content,
           matched: false,
-          action: "skipped"
+          action: "skipped",
+          a2aTaskId
         };
       }
       const tasks = existingTasks || await this.taskOps.getTasks("all");
-      const match = findBestMatch(todo.content, tasks, matchThreshold);
+      const match = findBestMatch(todo.content, tasks, matchThreshold, workspaceId, createdBy);
       if (match) {
         const vibeStatus = mapStatus(todo.status);
         const currentStatus = match.task.status || "todo";
@@ -1307,14 +2093,18 @@ var ClaudeSync = class {
             taskId: match.task.id,
             action: "updated",
             previousStatus: currentStatus,
-            newStatus: vibeStatus
+            newStatus: vibeStatus,
+            matchType: match.matchType,
+            a2aTaskId: match.task.a2a_task_id || a2aTaskId
           };
         }
         return {
           content: todo.content,
           matched: true,
           taskId: match.task.id,
-          action: "skipped"
+          action: "skipped",
+          matchType: match.matchType,
+          a2aTaskId: match.task.a2a_task_id || a2aTaskId
         };
       }
       if (createMissing) {
@@ -1325,20 +2115,27 @@ var ClaudeSync = class {
           project_tag: projectTag,
           created_by: "ai",
           context_notes: todo.activeForm ? `Started: ${todo.activeForm}` : void 0,
-          completed: vibeStatus === "done"
+          completed: vibeStatus === "done",
+          workspace_id: workspaceId,
+          a2a_task_id: a2aTaskId
+          // Set A2A task ID on creation
         });
         return {
           content: todo.content,
           matched: false,
           taskId: newTask.id,
           action: "created",
-          newStatus: vibeStatus
+          newStatus: vibeStatus,
+          matchType: "exact",
+          // Created with A2A ID
+          a2aTaskId: newTask.a2a_task_id || a2aTaskId
         };
       }
       return {
         content: todo.content,
         matched: false,
-        action: "not_found"
+        action: "not_found",
+        a2aTaskId
       };
     } catch (error) {
       return {
@@ -1416,12 +2213,1394 @@ async function syncClaudeTodos(taskOps, todos, options = {}) {
   const sync = new ClaudeSync(taskOps);
   return await sync.syncAllTodos(todos, options);
 }
+
+// src/openai-embeddings.ts
+import OpenAI from "openai";
+var openaiClient = null;
+function getOpenAIClient() {
+  if (!openaiClient) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OPENAI_API_KEY environment variable not set. Semantic vector generation requires an OpenAI API key.");
+    }
+    openaiClient = new OpenAI({ apiKey });
+  }
+  return openaiClient;
+}
+async function generateTaskEmbedding(input) {
+  const client = getOpenAIClient();
+  const textParts = [input.title];
+  if (input.notes) textParts.push(input.notes);
+  if (input.intent) textParts.push(input.intent);
+  const combinedText = textParts.join("\n");
+  try {
+    const response = await client.embeddings.create({
+      model: "text-embedding-3-small",
+      input: combinedText,
+      encoding_format: "float"
+    });
+    return response.data[0].embedding;
+  } catch (error) {
+    console.error("Error generating embedding:", error);
+    throw new Error(`Failed to generate semantic vector: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+function generateContextTags(input) {
+  const tags = /* @__PURE__ */ new Set();
+  const keywords = [
+    // Languages
+    "typescript",
+    "javascript",
+    "python",
+    "rust",
+    "go",
+    "java",
+    "sql",
+    // Frameworks
+    "react",
+    "vue",
+    "angular",
+    "next",
+    "expo",
+    "supabase",
+    "postgres",
+    // Areas
+    "frontend",
+    "backend",
+    "database",
+    "api",
+    "ui",
+    "ux",
+    "auth",
+    "oauth",
+    // Actions
+    "fix",
+    "bug",
+    "feature",
+    "refactor",
+    "test",
+    "docs",
+    "deploy",
+    "migration",
+    // Tools
+    "github",
+    "git",
+    "docker",
+    "vercel",
+    "aws",
+    "gcp"
+  ];
+  const text = `${input.title} ${input.notes || ""}`.toLowerCase();
+  for (const keyword of keywords) {
+    if (text.includes(keyword)) {
+      tags.add(keyword);
+      if (tags.size >= 5) break;
+    }
+  }
+  if (input.projectTag) {
+    tags.add(input.projectTag.toLowerCase());
+  }
+  if (tags.size < 3) {
+    const titleWords = input.title.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3 && !["this", "that", "with", "from", "into"].includes(w));
+    for (const word of titleWords) {
+      tags.add(word);
+      if (tags.size >= 5) break;
+    }
+  }
+  return Array.from(tags).slice(0, 5);
+}
+function extractIntent(input) {
+  let intent = input.description || input.notes || input.title;
+  const firstSentence = intent.match(/^[^.!?]+[.!?]/);
+  if (firstSentence) {
+    intent = firstSentence[0].trim();
+  }
+  if (intent.length > 200) {
+    intent = intent.slice(0, 197) + "...";
+  }
+  return intent;
+}
+
+// src/claude-embeddings.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { RECOMMENDED_MODELS } from "@vibetasks/ralph-engine";
+var anthropicClient = null;
+function getAnthropicClient() {
+  if (!anthropicClient) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("ANTHROPIC_API_KEY environment variable is required");
+    }
+    anthropicClient = new Anthropic({ apiKey });
+  }
+  return anthropicClient;
+}
+async function extractIntentWithClaude(input) {
+  const client = getAnthropicClient();
+  const combinedText = [input.title, input.notes, input.description].filter(Boolean).join("\n");
+  const quickModel = RECOMMENDED_MODELS.quick;
+  const response = await client.messages.create({
+    model: quickModel.apiModel,
+    max_tokens: 200,
+    messages: [
+      {
+        role: "user",
+        content: `Extract the core intent/purpose from this task in one concise sentence (max 200 chars):
+
+Task: ${combinedText}
+
+Intent:`
+      }
+    ]
+  });
+  const intent = response.content[0].type === "text" ? response.content[0].text.trim() : "";
+  return intent.slice(0, 200);
+}
+async function generateContextTagsWithClaude(input) {
+  const client = getAnthropicClient();
+  const combinedText = [input.title, input.notes].filter(Boolean).join("\n");
+  const quickModel = RECOMMENDED_MODELS.quick;
+  const response = await client.messages.create({
+    model: quickModel.apiModel,
+    max_tokens: 100,
+    messages: [
+      {
+        role: "user",
+        content: `Extract 3-5 semantic tags from this task. Choose from common categories like:
+Languages: typescript, javascript, python, rust, go, java, sql
+Frameworks: react, vue, next, expo, supabase, postgres
+Areas: frontend, backend, database, api, ui, auth, oauth
+Actions: fix, bug, feature, refactor, test, docs, deploy
+
+Task: ${combinedText}
+
+Return ONLY a comma-separated list of tags (lowercase, no spaces after commas):`
+      }
+    ]
+  });
+  const tagsText = response.content[0].type === "text" ? response.content[0].text.trim() : "";
+  let tags = tagsText.toLowerCase().split(",").map((t) => t.trim()).filter((t) => t.length > 0).slice(0, 5);
+  if (input.projectTag && !tags.includes(input.projectTag.toLowerCase())) {
+    tags.push(input.projectTag.toLowerCase());
+  }
+  return tags.slice(0, 5);
+}
+async function generateTaskEmbeddingWithClaude(input) {
+  const { generateVoyageEmbedding } = await import("./voyage-embeddings-VXPM2I5X.js");
+  const combinedText = [input.title, input.notes, input.intent].filter(Boolean).join("\n");
+  return generateVoyageEmbedding(combinedText);
+}
+async function batchProcessTasksWithClaude(tasks, onProgress) {
+  const results = [];
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    try {
+      const [intent, contextTags, embedding] = await Promise.all([
+        extractIntentWithClaude(task),
+        generateContextTagsWithClaude(task),
+        generateTaskEmbeddingWithClaude(task)
+      ]);
+      results.push({
+        id: task.id,
+        intent,
+        contextTags,
+        embedding
+      });
+      if (onProgress) {
+        onProgress(i + 1, tasks.length);
+      }
+      if (i < tasks.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+    } catch (error) {
+      console.error(`Failed to process task ${task.id}:`, error);
+    }
+  }
+  return results;
+}
+
+// src/rlm/engine.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+import { VM } from "vm2";
+import { RECOMMENDED_MODELS as RECOMMENDED_MODELS2 } from "@vibetasks/ralph-engine";
+var RLMEngine = class {
+  client;
+  config;
+  currentDepth = 0;
+  callCount = 0;
+  totalTokens = { input: 0, output: 0 };
+  startTime = 0;
+  logs = [];
+  constructor(config) {
+    this.client = new Anthropic2({ apiKey: config.apiKey });
+    const codingModel = RECOMMENDED_MODELS2.coding;
+    const quickModel = RECOMMENDED_MODELS2.quick;
+    this.config = {
+      model: config.model || codingModel.apiModel,
+      subLLMModel: config.subLLMModel || quickModel.apiModel,
+      maxDepth: config.maxDepth || 3,
+      timeout: config.timeout || 6e4,
+      verbose: config.verbose || false,
+      apiKey: config.apiKey
+    };
+  }
+  /**
+   * Main RLM completion function
+   * Replaces traditional llm.completion(prompt) calls
+   */
+  async completion(query, context) {
+    this.startTime = Date.now();
+    this.currentDepth = 0;
+    this.callCount = 0;
+    this.totalTokens = { input: 0, output: 0 };
+    this.logs = [];
+    this.log(`[RLM] Starting query with context size: ${context.length} chars`);
+    this.log(`[RLM] Context preview: ${context.substring(0, 200)}...`);
+    const repl = this.createREPLEnvironment(context);
+    const systemPrompt = this.buildSystemPrompt(context.length);
+    try {
+      const answer = await this.recursiveQuery(
+        query,
+        context,
+        repl,
+        systemPrompt,
+        0
+      );
+      const executionTime = Date.now() - this.startTime;
+      const totalCost = this.calculateCost();
+      this.log(`[RLM] Completed in ${executionTime}ms with ${this.callCount} calls`);
+      return {
+        answer,
+        totalCost,
+        tokensUsed: this.totalTokens,
+        callCount: this.callCount,
+        depth: this.currentDepth,
+        executionTime
+      };
+    } catch (error) {
+      this.log(`[RLM] Error: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Recursive query function - core of RLM
+   */
+  async recursiveQuery(query, contextSlice, repl, systemPrompt, depth) {
+    if (depth > this.config.maxDepth) {
+      this.log(`[RLM] Max depth ${this.config.maxDepth} reached, using base LLM`);
+      return this.baseLLMQuery(query, contextSlice.substring(0, 1e5));
+    }
+    this.currentDepth = Math.max(this.currentDepth, depth);
+    this.callCount++;
+    const model = depth === 0 ? this.config.model : this.config.subLLMModel;
+    this.log(`[RLM] Depth ${depth}: Using model ${model}`);
+    const prompt = this.buildREPLPrompt(query, contextSlice, depth);
+    try {
+      const response = await this.client.messages.create({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: [{
+          role: "user",
+          content: prompt
+        }]
+      });
+      this.totalTokens.input += response.usage.input_tokens;
+      this.totalTokens.output += response.usage.output_tokens;
+      const content = response.content[0];
+      if (content.type !== "text") {
+        throw new Error("Unexpected response type");
+      }
+      const llmResponse = content.text;
+      this.log(`[RLM] Depth ${depth} response: ${llmResponse.substring(0, 200)}...`);
+      if (llmResponse.includes("FINAL(") || llmResponse.includes("FINAL_VAR(")) {
+        return this.extractFinalAnswer(llmResponse);
+      }
+      const codeBlocks = this.extractCodeBlocks(llmResponse);
+      if (codeBlocks.length > 0) {
+        return this.executeREPLCode(codeBlocks, repl, query, systemPrompt, depth);
+      }
+      return llmResponse;
+    } catch (error) {
+      this.log(`[RLM] Error at depth ${depth}: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Create REPL environment with context and tools
+   */
+  createREPLEnvironment(context) {
+    const self = this;
+    return {
+      context,
+      // Core recursive function available in REPL
+      llm_query: async (query, contextSlice) => {
+        const slice = contextSlice || context;
+        return self.recursiveQuery(
+          query,
+          slice,
+          self.createREPLEnvironment(slice),
+          self.buildSystemPrompt(slice.length),
+          self.currentDepth + 1
+        );
+      },
+      print: (...args) => {
+        self.log(`[REPL] ${args.join(" ")}`);
+      },
+      // Helper: Regex search
+      regex_search: (pattern, text) => {
+        const target = text || context;
+        const regex = new RegExp(pattern, "gm");
+        const matches = target.match(regex);
+        return matches || [];
+      },
+      // Helper: Chunk text with overlap
+      chunk_text: (text, chunkSize, overlap = 0) => {
+        const chunks = [];
+        const step = chunkSize - overlap;
+        for (let i = 0; i < text.length; i += step) {
+          chunks.push(text.substring(i, i + chunkSize));
+        }
+        return chunks;
+      },
+      // Helper: Extract line range
+      extract_lines: (text, start, end) => {
+        const lines = text.split("\n");
+        return lines.slice(start, end).join("\n");
+      }
+    };
+  }
+  /**
+   * Execute Python code in sandboxed VM
+   */
+  async executeREPLCode(codeBlocks, repl, query, systemPrompt, depth) {
+    this.log(`[RLM] Executing ${codeBlocks.length} code blocks`);
+    const vm = new VM({
+      timeout: this.config.timeout,
+      sandbox: {
+        context: repl.context,
+        llm_query: repl.llm_query,
+        print: repl.print,
+        regex_search: repl.regex_search,
+        chunk_text: repl.chunk_text,
+        extract_lines: repl.extract_lines,
+        // Results storage
+        results: []
+      }
+    });
+    let finalResult;
+    for (const code of codeBlocks) {
+      try {
+        this.log(`[REPL] Executing code:
+${code}`);
+        finalResult = await vm.run(code);
+        this.log(`[REPL] Code result: ${JSON.stringify(finalResult)?.substring(0, 200)}`);
+      } catch (error) {
+        this.log(`[REPL] Code execution error: ${error}`);
+        throw new Error(`REPL execution failed: ${error}`);
+      }
+    }
+    if (finalResult) {
+      return String(finalResult);
+    }
+    return this.recursiveQuery(
+      `Based on the REPL execution results, answer: ${query}`,
+      repl.context,
+      repl,
+      systemPrompt,
+      depth
+    );
+  }
+  /**
+   * Base LLM query without recursion (for depth limit or simple queries)
+   */
+  async baseLLMQuery(query, context) {
+    this.callCount++;
+    this.log(`[RLM] Base LLM query (no recursion)`);
+    const response = await this.client.messages.create({
+      model: this.config.subLLMModel,
+      max_tokens: 2048,
+      messages: [{
+        role: "user",
+        content: `Context:
+${context}
+
+Query: ${query}`
+      }]
+    });
+    this.totalTokens.input += response.usage.input_tokens;
+    this.totalTokens.output += response.usage.output_tokens;
+    const content = response.content[0];
+    return content.type === "text" ? content.text : "";
+  }
+  /**
+   * Build system prompt teaching LLM how to use RLM
+   */
+  buildSystemPrompt(contextLength) {
+    return `You are an RLM (Recursive Language Model) agent. You have access to a massive context (${contextLength} characters) stored in the 'context' variable within a Python REPL environment.
+
+AVAILABLE TOOLS IN REPL:
+
+1. **context** (str): The full input context you need to analyze
+2. **llm_query(query: str, context_slice: str = None) -> str**: Recursively call yourself on a sub-problem or context chunk
+3. **print(*args)**: Debug output
+4. **regex_search(pattern: str, text: str = None) -> List[str]**: Search for patterns
+5. **chunk_text(text: str, chunk_size: int, overlap: int = 0) -> List[str]**: Split text into chunks
+6. **extract_lines(text: str, start: int, end: int) -> str**: Get specific line range
+
+YOUR STRATEGY:
+
+1. **Explore**: First, examine the context structure using print() or regex_search()
+2. **Decompose**: Break the problem into sub-queries
+3. **Chunk**: Use chunk_text() or regex to find relevant sections
+4. **Recurse**: Call llm_query() on each chunk with specific questions
+5. **Aggregate**: Combine results from sub-queries
+6. **Respond**: Wrap your final answer in FINAL("your answer here")
+
+IMPORTANT RULES:
+
+- Do NOT try to process the entire context at once (it's too large)
+- DO write Python code to search, filter, and chunk the context
+- DO use llm_query() for recursive sub-problems
+- DO return your final answer wrapped in FINAL("...")
+- Keep code simple and focused on the task
+
+EXAMPLE PATTERN:
+
+\`\`\`python
+# 1. Explore context structure
+print(f"Context length: {len(context)}")
+print(f"First 500 chars: {context[:500]}")
+
+# 2. Find relevant sections
+matches = regex_search(r"function \\w+\\(", context)
+print(f"Found {len(matches)} functions")
+
+# 3. Chunk and recurse
+chunks = chunk_text(context, chunk_size=5000, overlap=200)
+results = []
+
+for i, chunk in enumerate(chunks):
+    result = llm_query(
+        f"In this code chunk, find all TODO comments",
+        chunk
+    )
+    results.append(result)
+
+# 4. Return final answer
+FINAL(f"Found {len(results)} chunks with TODOs: {results}")
+\`\`\``;
+  }
+  /**
+   * Build prompt for REPL interaction
+   */
+  buildREPLPrompt(query, contextSlice, depth) {
+    if (depth === 0) {
+      return `You have access to a large context in the 'context' variable.
+
+User Query: ${query}
+
+Write Python code to explore the context and answer the query. Use llm_query() for recursive sub-problems.`;
+    } else {
+      return `Sub-query at depth ${depth}:
+
+${query}
+
+Context slice:
+${contextSlice.substring(0, 1e3)}...
+
+Analyze this context slice and provide a focused answer.`;
+    }
+  }
+  /**
+   * Extract code blocks from LLM response
+   */
+  extractCodeBlocks(text) {
+    const codeBlockRegex = /```(?:python)?\n([\s\S]*?)```/g;
+    const blocks = [];
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+      blocks.push(match[1].trim());
+    }
+    return blocks;
+  }
+  /**
+   * Extract final answer from FINAL() or FINAL_VAR()
+   */
+  extractFinalAnswer(text) {
+    const finalRegex = /FINAL\(["']?(.*?)["']?\)/s;
+    const match = text.match(finalRegex);
+    if (match) {
+      return match[1];
+    }
+    return text;
+  }
+  /**
+   * Calculate total cost based on token usage
+   */
+  calculateCost() {
+    const sonnetInputCost = 3 / 1e6;
+    const sonnetOutputCost = 15 / 1e6;
+    const haikuInputCost = 0.8 / 1e6;
+    const haikuOutputCost = 4 / 1e6;
+    const avgInputCost = (sonnetInputCost + haikuInputCost) / 2;
+    const avgOutputCost = (sonnetOutputCost + haikuOutputCost) / 2;
+    return this.totalTokens.input * avgInputCost + this.totalTokens.output * avgOutputCost;
+  }
+  /**
+   * Logging helper
+   */
+  log(message) {
+    if (this.config.verbose) {
+      console.log(message);
+    }
+    this.logs.push(message);
+  }
+  /**
+   * Get execution logs
+   */
+  getLogs() {
+    return this.logs;
+  }
+};
+
+// src/rlm/context-loader.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { glob } from "glob";
+var RLMContextLoader = class {
+  defaultExcludePatterns = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.next/**",
+    "**/.vercel/**",
+    "**/.turbo/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.min.js",
+    "**/*.map",
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml",
+    "**/.DS_Store",
+    "**/*.log",
+    "**/.env*",
+    "**/*.sqlite",
+    "**/*.db"
+  ];
+  defaultIncludePatterns = [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.py",
+    "**/*.java",
+    "**/*.go",
+    "**/*.rs",
+    "**/*.c",
+    "**/*.cpp",
+    "**/*.md",
+    "**/*.json",
+    "**/*.yaml",
+    "**/*.yml",
+    "**/*.sql",
+    "**/*.sh"
+  ];
+  /**
+   * Load entire codebase into single context string
+   */
+  async loadCodebase(options) {
+    const {
+      rootPath,
+      excludePatterns = [],
+      includePatterns = this.defaultIncludePatterns,
+      maxFileSize = 1e6,
+      // 1MB default
+      addFileHeaders = true,
+      addLineNumbers = false
+    } = options;
+    console.log(`[RLM Context Loader] Loading codebase from ${rootPath}`);
+    const allExcludes = [...this.defaultExcludePatterns, ...excludePatterns];
+    const files = await this.findFiles(rootPath, includePatterns, allExcludes);
+    console.log(`[RLM Context Loader] Found ${files.length} files`);
+    const fileContents = [];
+    const fileMetadata = [];
+    let totalSize = 0;
+    for (const filePath of files) {
+      try {
+        const stats = await fs2.stat(filePath);
+        if (stats.size > maxFileSize) {
+          console.log(`[RLM Context Loader] Skipping large file: ${filePath} (${stats.size} bytes)`);
+          continue;
+        }
+        const content = await fs2.readFile(filePath, "utf-8");
+        const relativePath = path2.relative(rootPath, filePath);
+        const lines = content.split("\n").length;
+        let formattedContent = "";
+        if (addFileHeaders) {
+          formattedContent += `
+${"=".repeat(80)}
+`;
+          formattedContent += `FILE: ${relativePath}
+`;
+          formattedContent += `SIZE: ${stats.size} bytes | LINES: ${lines}
+`;
+          formattedContent += `${"=".repeat(80)}
+
+`;
+        }
+        if (addLineNumbers) {
+          const numberedLines = content.split("\n").map((line, i) => {
+            const lineNum = (i + 1).toString().padStart(5, " ");
+            return `${lineNum} | ${line}`;
+          });
+          formattedContent += numberedLines.join("\n");
+        } else {
+          formattedContent += content;
+        }
+        formattedContent += "\n\n";
+        fileContents.push(formattedContent);
+        fileMetadata.push({
+          path: relativePath,
+          size: stats.size,
+          lines
+        });
+        totalSize += stats.size;
+      } catch (error) {
+        console.error(`[RLM Context Loader] Error reading ${filePath}:`, error);
+      }
+    }
+    const fullContext = fileContents.join("");
+    console.log(`[RLM Context Loader] Loaded ${fileMetadata.length} files, ${totalSize} bytes`);
+    console.log(`[RLM Context Loader] Context length: ${fullContext.length} characters`);
+    return {
+      content: fullContext,
+      fileCount: fileMetadata.length,
+      totalSize,
+      files: fileMetadata,
+      metadata: {
+        generatedAt: /* @__PURE__ */ new Date(),
+        rootPath,
+        excludePatterns: allExcludes
+      }
+    };
+  }
+  /**
+   * Load specific files or directories
+   */
+  async loadPaths(rootPath, paths, options) {
+    const includePatterns = paths.map((p) => {
+      if (p.endsWith("/")) {
+        return `${p}**/*`;
+      }
+      return p;
+    });
+    return this.loadCodebase({
+      rootPath,
+      includePatterns,
+      ...options
+    });
+  }
+  /**
+   * Find files matching patterns
+   */
+  async findFiles(rootPath, includePatterns, excludePatterns) {
+    const allFiles = /* @__PURE__ */ new Set();
+    for (const pattern of includePatterns) {
+      const matches = await glob(pattern, {
+        cwd: rootPath,
+        absolute: true,
+        ignore: excludePatterns,
+        nodir: true
+      });
+      matches.forEach((file) => allFiles.add(file));
+    }
+    return Array.from(allFiles).sort();
+  }
+  /**
+   * Create a focused context for specific query
+   * Uses existing context engine's semantic search to pre-filter
+   */
+  async loadFocusedContext(rootPath, query, options) {
+    const { maxFiles = 50, semanticSearch = true } = options || {};
+    console.log(`[RLM Context Loader] Creating focused context for query: ${query}`);
+    const keywords = this.extractKeywords(query);
+    const allFiles = await this.findFiles(
+      rootPath,
+      this.defaultIncludePatterns,
+      this.defaultExcludePatterns
+    );
+    const scoredFiles = allFiles.map((file) => {
+      const relativePath = path2.relative(rootPath, file).toLowerCase();
+      let score = 0;
+      for (const keyword of keywords) {
+        if (relativePath.includes(keyword.toLowerCase())) {
+          score += 10;
+        }
+      }
+      return { file, score };
+    });
+    const topFiles = scoredFiles.sort((a, b) => b.score - a.score).slice(0, maxFiles).map((f) => f.file);
+    console.log(`[RLM Context Loader] Selected ${topFiles.length} focused files`);
+    return this.loadCodebase({
+      rootPath,
+      includePatterns: topFiles.map((f) => path2.relative(rootPath, f)),
+      excludePatterns: []
+    });
+  }
+  /**
+   * Extract keywords from query for relevance scoring
+   */
+  extractKeywords(query) {
+    const stopWords = /* @__PURE__ */ new Set(["the", "a", "an", "in", "on", "at", "for", "to", "of", "and", "or", "is", "are", "was", "were", "how", "what", "where", "when", "why", "which"]);
+    return query.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 2 && !stopWords.has(word));
+  }
+  /**
+   * Stream large codebase in chunks (for progressive loading)
+   */
+  async *streamCodebase(options, chunkSize = 50) {
+    const {
+      rootPath,
+      excludePatterns = [],
+      includePatterns = this.defaultIncludePatterns
+    } = options;
+    const allExcludes = [...this.defaultExcludePatterns, ...excludePatterns];
+    const files = await this.findFiles(rootPath, includePatterns, allExcludes);
+    for (let i = 0; i < files.length; i += chunkSize) {
+      const chunkFiles = files.slice(i, i + chunkSize);
+      const context = await this.loadCodebase({
+        ...options,
+        includePatterns: chunkFiles.map((f) => path2.relative(rootPath, f)),
+        excludePatterns: []
+      });
+      yield {
+        chunk: context.content,
+        progress: Math.min((i + chunkSize) / files.length, 1)
+      };
+    }
+  }
+  /**
+   * Get context statistics without loading full content
+   */
+  async getCodebaseStats(options) {
+    const {
+      rootPath,
+      excludePatterns = [],
+      includePatterns = this.defaultIncludePatterns
+    } = options;
+    const allExcludes = [...this.defaultExcludePatterns, ...excludePatterns];
+    const files = await this.findFiles(rootPath, includePatterns, allExcludes);
+    let totalSize = 0;
+    const fileTypes = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const stats = await fs2.stat(file);
+        totalSize += stats.size;
+        const ext = path2.extname(file);
+        fileTypes.set(ext, (fileTypes.get(ext) || 0) + 1);
+      } catch (error) {
+      }
+    }
+    const topFileTypes = Array.from(fileTypes.entries()).map(([ext, count]) => ({ ext, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const estimatedTokens = Math.ceil(totalSize / 4);
+    return {
+      fileCount: files.length,
+      totalSize,
+      estimatedTokens,
+      topFileTypes
+    };
+  }
+};
+
+// src/rlm/mcp-tool.ts
+var RLMMCPTool = class {
+  engine;
+  contextLoader;
+  contextCache = /* @__PURE__ */ new Map();
+  constructor(anthropicApiKey) {
+    this.engine = new RLMEngine({
+      apiKey: anthropicApiKey,
+      verbose: false
+      // Controlled per query
+    });
+    this.contextLoader = new RLMContextLoader();
+  }
+  /**
+   * Main RLM query tool
+   */
+  async queryCodebase(input) {
+    const {
+      query,
+      workspacePath = process.cwd(),
+      focused = true,
+      maxFiles = 100,
+      verbose = false,
+      maxDepth = 3
+    } = input;
+    console.log(`[RLM MCP Tool] Query: ${query}`);
+    console.log(`[RLM MCP Tool] Workspace: ${workspacePath}`);
+    console.log(`[RLM MCP Tool] Focused mode: ${focused}`);
+    this.engine = new RLMEngine({
+      apiKey: this.engine["config"].apiKey,
+      verbose,
+      maxDepth
+    });
+    let context;
+    const cacheKey = `${workspacePath}-${focused}-${maxFiles}`;
+    if (this.contextCache.has(cacheKey)) {
+      console.log(`[RLM MCP Tool] Using cached context`);
+      context = this.contextCache.get(cacheKey);
+    } else {
+      console.log(`[RLM MCP Tool] Loading context...`);
+      if (focused) {
+        context = await this.contextLoader.loadFocusedContext(
+          workspacePath,
+          query,
+          { maxFiles }
+        );
+      } else {
+        context = await this.contextLoader.loadCodebase({
+          rootPath: workspacePath,
+          addFileHeaders: true,
+          addLineNumbers: false
+        });
+      }
+      this.contextCache.set(cacheKey, context);
+      setTimeout(() => this.contextCache.delete(cacheKey), 5 * 60 * 1e3);
+    }
+    console.log(`[RLM MCP Tool] Context loaded: ${context.fileCount} files, ${context.content.length} chars`);
+    const result = await this.engine.completion(query, context.content);
+    console.log(`[RLM MCP Tool] Query completed in ${result.executionTime}ms`);
+    console.log(`[RLM MCP Tool] Cost: $${result.totalCost.toFixed(4)}`);
+    return {
+      ...result,
+      contextUsed: {
+        fileCount: context.fileCount,
+        totalSize: context.totalSize,
+        estimatedTokens: Math.ceil(context.content.length / 4)
+      },
+      logs: verbose ? this.engine.getLogs() : void 0
+    };
+  }
+  /**
+   * Get codebase statistics (fast, no LLM calls)
+   */
+  async getCodebaseStats(workspacePath) {
+    const path3 = workspacePath || process.cwd();
+    const stats = await this.contextLoader.getCodebaseStats({
+      rootPath: path3
+    });
+    const estimatedCost = stats.estimatedTokens / 1e5 * 0.01;
+    return {
+      ...stats,
+      estimatedCost
+    };
+  }
+  /**
+   * Clear context cache
+   */
+  clearCache() {
+    this.contextCache.clear();
+    console.log(`[RLM MCP Tool] Context cache cleared`);
+  }
+  /**
+   * Prefetch and cache codebase context
+   */
+  async prefetchContext(workspacePath, focused = true) {
+    const path3 = workspacePath || process.cwd();
+    const cacheKey = `${path3}-${focused}-100`;
+    console.log(`[RLM MCP Tool] Prefetching context for ${path3}...`);
+    const context = await this.contextLoader.loadCodebase({
+      rootPath: path3,
+      addFileHeaders: true,
+      addLineNumbers: false
+    });
+    this.contextCache.set(cacheKey, context);
+    console.log(`[RLM MCP Tool] Context prefetched and cached`);
+  }
+};
+var RLM_MCP_TOOLS = [
+  {
+    name: "rlm_query_codebase",
+    description: `Query massive codebases (10M+ tokens) using Recursive Language Models (RLM).
+
+RLM treats the codebase as an external environment and recursively searches through it,
+allowing you to ask complex questions across thousands of files without context window limits.
+
+Use this for:
+- "Find all API endpoints that handle user authentication"
+- "What files depend on UserService and how do they use it?"
+- "List all TODO comments across the entire codebase"
+- "How does the payment flow work end-to-end?"
+- "Find all functions that make database queries"
+
+Key benefits:
+- Handles 10M+ tokens (thousands of files)
+- 29% more accurate than traditional approaches
+- 3x cheaper than loading everything into context
+- No information loss (no summarization)
+
+Parameters:
+- query: Your question about the codebase
+- focused: Use semantic search to pre-filter relevant files (faster, cheaper, recommended)
+- maxFiles: Max files to include in focused mode (default: 100)
+- verbose: Show detailed execution logs`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Your question about the codebase"
+        },
+        focused: {
+          type: "boolean",
+          description: "Use semantic search to pre-filter files (recommended)",
+          default: true
+        },
+        maxFiles: {
+          type: "number",
+          description: "Max files to include (focused mode only)",
+          default: 100
+        },
+        verbose: {
+          type: "boolean",
+          description: "Show detailed execution logs",
+          default: false
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "rlm_get_codebase_stats",
+    description: `Get statistics about the current codebase without querying the LLM.
+
+Shows:
+- File count
+- Total size (bytes)
+- Estimated tokens
+- Estimated cost for RLM query
+- Top file types`,
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "rlm_clear_cache",
+    description: "Clear the RLM context cache to force reloading files",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+
+// src/task-compaction.ts
+import Anthropic3 from "@anthropic-ai/sdk";
+import { RECOMMENDED_MODELS as RECOMMENDED_MODELS3 } from "@vibetasks/ralph-engine";
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 1e3;
+var TaskCompactionService = class {
+  anthropic;
+  model;
+  constructor(apiKey) {
+    const key = apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!key) {
+      throw new Error("ANTHROPIC_API_KEY required for task compaction");
+    }
+    this.anthropic = new Anthropic3({ apiKey: key });
+    this.model = RECOMMENDED_MODELS3.quick.apiModel;
+  }
+  /**
+   * Compact a single task by generating a summary
+   */
+  async compactTask(task) {
+    const originalContent = this.buildTaskContent(task);
+    const originalSize = originalContent.length;
+    try {
+      const summary = await this.generateSummaryWithRetry(task, originalContent);
+      const compactedSize = summary.length;
+      return {
+        taskId: task.id,
+        originalSize,
+        compactedSize,
+        summary,
+        success: true
+      };
+    } catch (error) {
+      return {
+        taskId: task.id,
+        originalSize,
+        compactedSize: 0,
+        summary: "",
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  /**
+   * Build the full content of a task for summarization
+   */
+  buildTaskContent(task) {
+    const parts = [];
+    parts.push(`**Title:** ${task.title}`);
+    if (task.description) {
+      parts.push(`
+**Description:**
+${task.description}`);
+    }
+    if (task.notes) {
+      parts.push(`
+**Notes:**
+${task.notes}`);
+    }
+    if (task.context_notes) {
+      parts.push(`
+**Context Notes:**
+${task.context_notes}`);
+    }
+    const criteria = task.acceptance_criteria;
+    if (criteria && Array.isArray(criteria) && criteria.length > 0) {
+      const criteriaList = criteria.map((c) => `- [${c.met ? "x" : " "}] ${c.description}`).join("\n");
+      parts.push(`
+**Acceptance Criteria:**
+${criteriaList}`);
+    }
+    const subtasks = task.subtasks || [];
+    if (subtasks.length > 0) {
+      const subtaskList = subtasks.map((s) => `- [${s.done ? "x" : " "}] ${s.title}`).join("\n");
+      parts.push(`
+**Subtasks:**
+${subtaskList}`);
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Generate summary with exponential backoff retry
+   */
+  async generateSummaryWithRetry(task, content) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      if (attempt > 0) {
+        const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1);
+        await this.sleep(backoff);
+      }
+      try {
+        return await this.generateSummary(task, content);
+      } catch (error) {
+        lastError = error;
+        if (!this.isRetryable(error)) {
+          throw error;
+        }
+      }
+    }
+    throw lastError || new Error("Failed after retries");
+  }
+  /**
+   * Generate the actual summary using Claude
+   */
+  async generateSummary(task, content) {
+    const prompt = this.buildPrompt(task, content);
+    const response = await this.anthropic.messages.create({
+      model: this.model,
+      max_tokens: 512,
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ]
+    });
+    if (response.content.length === 0) {
+      throw new Error("Empty response from API");
+    }
+    const textBlock = response.content.find((block) => block.type === "text");
+    if (!textBlock || textBlock.type !== "text") {
+      throw new Error("No text content in response");
+    }
+    return textBlock.text;
+  }
+  /**
+   * Build the compaction prompt
+   */
+  buildPrompt(task, content) {
+    return `You are summarizing a completed software task for long-term storage. Your goal is to COMPRESS the content - the output MUST be significantly shorter than the input while preserving key technical decisions and outcomes.
+
+${content}
+
+IMPORTANT: Your summary must be shorter than the original. Be concise and eliminate redundancy. Focus on what was actually accomplished.
+
+Provide a summary in this exact format:
+
+**Summary:** [2-3 concise sentences covering what was done and why]
+
+**Key Decisions:** [Brief bullet points of only the most important technical choices, if any]
+
+**Resolution:** [One sentence on final outcome]`;
+  }
+  /**
+   * Check if an error is retryable
+   */
+  isRetryable(error) {
+    if (!error) return false;
+    if (error.code === "ETIMEDOUT" || error.code === "ECONNRESET") {
+      return true;
+    }
+    const status = error.status || error.statusCode;
+    if (status === 429 || status >= 500 && status < 600) {
+      return true;
+    }
+    return false;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createCompactionService(apiKey) {
+  return new TaskCompactionService(apiKey);
+}
+
+// src/task-auto-complete.ts
+import issueParser from "issue-parser";
+var createVibetasksParser = () => issueParser({
+  actions: {
+    // Keywords that close/complete a task
+    close: [
+      "close",
+      "closes",
+      "closed",
+      "closing",
+      "fix",
+      "fixes",
+      "fixed",
+      "fixing",
+      "resolve",
+      "resolves",
+      "resolved",
+      "resolving",
+      "complete",
+      "completes",
+      "completed",
+      "completing",
+      "done",
+      "finish",
+      "finishes",
+      "finished",
+      "finishing",
+      "implement",
+      "implements",
+      "implemented",
+      "implementing",
+      "ship",
+      "ships",
+      "shipped",
+      "shipping"
+    ],
+    // Keywords that indicate progress (not closing)
+    progress: [
+      "ref",
+      "refs",
+      "reference",
+      "references",
+      "see",
+      "related",
+      "relates",
+      "wip",
+      "working",
+      "progress",
+      "part",
+      "partial",
+      "towards",
+      "for"
+    ]
+  },
+  // Prefixes that identify task IDs
+  issuePrefixes: ["#", "VT-", "VT#", "vt-", "vt#", "TASK-", "task-"]
+});
+var parseTaskRefs = createVibetasksParser();
+var BRANCH_PATTERNS = [
+  // feature/VT-42-description or fix/VT-42-description
+  /^(?:feature|fix|bugfix|hotfix|chore|refactor|docs|test)\/VT-(\d+)/i,
+  // feature/42-description (just the number)
+  /^(?:feature|fix|bugfix|hotfix|chore|refactor|docs|test)\/(\d+)-/i,
+  // VT-42 anywhere in branch name
+  /VT-(\d+)/i,
+  // vt-42 lowercase
+  /vt-(\d+)/i,
+  // TASK-42 format
+  /TASK-(\d+)/i,
+  // Just issue-42 or issue/42
+  /issue[-\/](\d+)/i
+];
+function extractFromBranch(branchName) {
+  for (const pattern of BRANCH_PATTERNS) {
+    const match = branchName.match(pattern);
+    if (match && match[1]) {
+      return {
+        taskId: match[1],
+        action: "progress",
+        // Branch creation = in progress, not closing
+        source: "branch_name",
+        raw: branchName,
+        prefix: match[0].replace(match[1], "")
+      };
+    }
+  }
+  return null;
+}
+function extractFromText(text, source) {
+  if (!text || typeof text !== "string") return [];
+  const refs = [];
+  const parsed = parseTaskRefs(text);
+  if (parsed.actions?.close) {
+    for (const ref of parsed.actions.close) {
+      refs.push({
+        taskId: ref.issue,
+        action: "close",
+        source,
+        raw: ref.raw,
+        prefix: ref.prefix
+      });
+    }
+  }
+  if (parsed.actions?.progress) {
+    for (const ref of parsed.actions.progress) {
+      refs.push({
+        taskId: ref.issue,
+        action: "progress",
+        source,
+        raw: ref.raw,
+        prefix: ref.prefix
+      });
+    }
+  }
+  const barePattern = /\bVT-(\d+)\b/gi;
+  let match;
+  while ((match = barePattern.exec(text)) !== null) {
+    const taskId = match[1];
+    if (!refs.some((r) => r.taskId === taskId)) {
+      refs.push({
+        taskId,
+        action: "progress",
+        source,
+        raw: match[0],
+        prefix: "VT-"
+      });
+    }
+  }
+  return refs;
+}
+function extractTaskRefs(options) {
+  const refs = [];
+  if (options.commits?.length) {
+    for (const commit of options.commits) {
+      if (commit.message) {
+        refs.push(...extractFromText(commit.message, "commit_message"));
+      }
+    }
+  }
+  if (options.branchName) {
+    const branchRef = extractFromBranch(options.branchName);
+    if (branchRef) {
+      refs.push(branchRef);
+    }
+  }
+  if (options.prTitle) {
+    refs.push(...extractFromText(options.prTitle, "pr_title"));
+  }
+  if (options.prBody) {
+    refs.push(...extractFromText(options.prBody, "pr_body"));
+  }
+  return dedupeRefs(refs);
+}
+function dedupeRefs(refs) {
+  const byTaskId = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const existing = byTaskId.get(ref.taskId);
+    if (!existing || ref.action === "close" && existing.action === "progress") {
+      byTaskId.set(ref.taskId, ref);
+    }
+  }
+  return Array.from(byTaskId.values());
+}
+function processTaskRefs(options) {
+  const refs = extractTaskRefs(options);
+  const tasksToClose = refs.filter((r) => r.action === "close");
+  const tasksToProgress = refs.filter((r) => r.action === "progress");
+  const allTaskIds = [...new Set(refs.map((r) => r.taskId))];
+  return {
+    tasksToClose,
+    tasksToProgress,
+    allTaskIds
+  };
+}
+function createBranchName(task, type = "feature") {
+  const slug = task.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return `${type}/VT-${task.short_id}-${slug}`;
+}
+function branchHasTaskRef(branchName) {
+  return extractFromBranch(branchName) !== null;
+}
+function getTaskIdFromBranch(branchName) {
+  const ref = extractFromBranch(branchName);
+  return ref?.taskId ?? null;
+}
+function processGitHubPush(payload) {
+  const branchName = payload.ref.replace("refs/heads/", "");
+  return processTaskRefs({
+    commits: payload.commits,
+    branchName
+  });
+}
+function processGitHubPullRequest(payload) {
+  const pr = payload.pull_request;
+  return processTaskRefs({
+    branchName: pr.head.ref,
+    prTitle: pr.title,
+    prBody: pr.body ?? void 0
+  });
+}
+function generateCompletionNotes(options) {
+  if (options.source === "pr_merged" && options.prNumber) {
+    const mergedBy = options.mergedBy ? ` by @${options.mergedBy}` : "";
+    return `Auto-completed: PR #${options.prNumber} merged${mergedBy}`;
+  }
+  if (options.source === "push" && options.commitId) {
+    return `Auto-completed: Commit ${options.commitId.substring(0, 7)} pushed`;
+  }
+  return "Auto-completed via GitHub integration";
+}
 export {
   AuthManager,
   ClaudeSync,
   ConfigManager,
+  IntegrationSyncService,
+  RLMContextLoader,
+  RLMEngine,
+  RLMMCPTool,
+  RLM_MCP_TOOLS,
+  TaskCompactionService,
   TaskOperations,
+  batchProcessTasksWithClaude,
+  branchHasTaskRef,
+  createBranchName,
+  createCompactionService,
   createSupabaseClient,
   createSupabaseClientFromEnv,
+  extractFromBranch,
+  extractFromText,
+  extractIntent,
+  extractIntentWithClaude,
+  extractTaskRefs,
+  generateCompletionNotes,
+  generateContextTags,
+  generateContextTagsWithClaude,
+  generateTaskEmbedding,
+  generateTaskEmbeddingWithClaude,
+  getTaskIdFromBranch,
+  processGitHubPullRequest,
+  processGitHubPush,
+  processTaskRefs,
   syncClaudeTodos
 };