@vibetasks/core 0.5.6 → 0.5.8

package/dist/index.d.ts

@@ -151,8 +151,38 @@ declare function createSupabaseClientFromEnv(): SupabaseClient<any, "public", "v
 
 type TaskFilter = 'all' | 'today' | 'upcoming' | 'completed' | 'archived';
 type TaskPriority = 'none' | 'low' | 'medium' | 'high';
-type TaskStatus = 'todo' | 'vibing' | 'done' | 'archived';
+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;
+    task_id: string;
+    session_id?: string;
+    user_id?: string;
+    actor_type: 'ai' | 'human' | 'system';
+    change_type: ChangeType;
+    field_changed?: string;
+    old_value?: unknown;
+    new_value?: unknown;
+    message?: string;
+    reverted_change_id?: string;
+    created_at: string;
+}
+interface Workspace {
+    id: string;
+    user_id: string;
+    slug: string;
+    display_name: string;
+    full_path: string;
+    parent_id?: string;
+    depth: number;
+    color?: string;
+    description?: string;
+    settings: Record<string, unknown>;
+    archived_at?: string;
+    created_at: string;
+    updated_at: string;
+}
 /**
  * Source type - where the task originated from
  * Matches TaskSourceType in @vibetasks/shared
@@ -265,15 +295,20 @@ interface Task {
 declare class TaskOperations {
     private supabase;
     constructor(supabase: SupabaseClient<any, any, any>);
+    private currentSessionId?;
     /**
-       * Create TaskOperations from AuthManager
-       * Automatically refreshes expired tokens
-       */
+     * Set the current session ID for change tracking
+     */
+    setSessionId(sessionId: string): void;
+    /**
+     * Create TaskOperations from AuthManager
+     * Automatically refreshes expired tokens
+     */
     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>): Promise<Task>;
+    updateTask(taskId: string, updates: Partial<Task>, logChanges?: boolean): Promise<Task>;
     deleteTask(taskId: string): Promise<void>;
     completeTask(taskId: string): Promise<Task>;
     uncompleteTask(taskId: string): Promise<Task>;
@@ -334,6 +369,127 @@ declare class TaskOperations {
         by_priority: Record<string, number>;
         needs_attention: boolean;
     }>;
+    /**
+     * Create a workspace document (research, domain doc, plan)
+     */
+    createWorkspaceDoc(input: {
+        doc_type: 'research' | 'domain' | 'plan';
+        title: string;
+        content: string;
+        project_tag?: string;
+        created_by?: 'ai' | 'human';
+        source_urls?: string[];
+        search_queries?: string[];
+        applies_to_children?: boolean;
+        tags?: string[];
+        globs?: string[];
+    }): Promise<any>;
+    /**
+     * Get workspace documents
+     */
+    getWorkspaceDocs(filters?: {
+        doc_type?: 'research' | 'domain' | 'plan';
+        project_tag?: string;
+        search?: string;
+        limit?: number;
+    }): Promise<any[]>;
+    /**
+     * Log a change to a task (like a git commit)
+     */
+    logChange(input: {
+        taskId: string;
+        changeType: ChangeType;
+        fieldChanged?: string;
+        oldValue?: unknown;
+        newValue?: unknown;
+        message?: string;
+        revertedChangeId?: string;
+        actorType?: 'ai' | 'human' | 'system';
+    }): Promise<TaskChange>;
+    /**
+     * Get change history for a task (like git log)
+     */
+    getTaskChanges(taskId: string, options?: {
+        limit?: number;
+        since?: string;
+        until?: string;
+        changeTypes?: ChangeType[];
+    }): Promise<TaskChange[]>;
+    /**
+     * Get a specific change (like git show)
+     */
+    getChange(changeId: string): Promise<TaskChange>;
+    /**
+     * Revert a change (non-destructive - creates a new "revert" change)
+     */
+    revertChange(changeId: string, message?: string): Promise<TaskChange>;
+    /**
+     * Get all tasks touched by a session
+     */
+    getSessionTasks(sessionId: string): Promise<{
+        task_id: string;
+        task_title: string;
+        change_count: number;
+        first_change: string;
+        last_change: string;
+    }[]>;
+    /**
+     * Search task changes by message
+     */
+    searchChanges(query: string, limit?: number): Promise<TaskChange[]>;
+    /**
+     * Create a workspace
+     */
+    createWorkspace(input: {
+        slug: string;
+        displayName: string;
+        parentId?: string;
+        color?: string;
+        description?: string;
+    }): Promise<Workspace>;
+    /**
+     * Get workspace tree for the current user
+     */
+    getWorkspaces(includeArchived?: boolean): Promise<Workspace[]>;
+    /**
+     * Get workspace by full path
+     */
+    getWorkspaceByPath(fullPath: string): Promise<Workspace | null>;
+    /**
+     * Get or create workspace from a project_tag (auto-creates hierarchy)
+     */
+    getOrCreateWorkspace(projectTag: string): Promise<Workspace>;
+    /**
+     * Archive a workspace (soft delete)
+     */
+    archiveWorkspace(workspaceId: string): Promise<Workspace>;
+    /**
+     * Restore a workspace from archive
+     */
+    restoreWorkspace(workspaceId: string): Promise<Workspace>;
+    /**
+     * Get workspace descendants (recursive)
+     */
+    getWorkspaceDescendants(workspaceId: string): Promise<{
+        id: string;
+        depth: number;
+    }[]>;
+    /**
+     * Generate consistent color for workspace
+     */
+    private generateWorkspaceColor;
+    /**
+     * Pause a task
+     */
+    pauseTask(taskId: string, reason?: string): Promise<Task>;
+    /**
+     * Resume a paused task
+     */
+    resumeTask(taskId: string): Promise<Task>;
+    /**
+     * Restore a task from archive
+     */
+    restoreTask(taskId: string, toStatus?: TaskStatus): Promise<Task>;
 }
 
 /**
@@ -441,4 +597,4 @@ declare class ClaudeSync {
  */
 declare function syncClaudeTodos(taskOps: TaskOperations, todos: ClaudeTodoItem[], options?: SyncOptions): Promise<SyncAllResult>;
 
-export { type Attachment, AuthManager, ClaudeSync, type ClaudeTodoItem, ConfigManager, type SourceType, type Subtask, type SupabaseConfig, type SyncAllResult, type SyncOptions, type SyncResult, type Tag, type Task, type TaskFilter, type TaskFlowConfig, TaskOperations, type TaskPriority, type TaskStatus, createSupabaseClient, createSupabaseClientFromEnv, syncClaudeTodos };
+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 };

package/dist/index.js

@@ -378,10 +378,18 @@ var TaskOperations = class _TaskOperations {
   constructor(supabase) {
     this.supabase = supabase;
   }
+  // Current session ID for change tracking
+  currentSessionId;
   /**
-     * Create TaskOperations from AuthManager
-     * Automatically refreshes expired tokens
-     */
+   * Set the current session ID for change tracking
+   */
+  setSessionId(sessionId) {
+    this.currentSessionId = sessionId;
+  }
+  /**
+   * Create TaskOperations from AuthManager
+   * Automatically refreshes expired tokens
+   */
   static async fromAuthManager(authManager) {
     const supabaseUrl = await authManager.getConfig("supabase_url") || "https://ihmayqzxqyednchbezya.supabase.co";
     const supabaseKey = await authManager.getConfig("supabase_key") || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNia2t6dGJjb2l0cmZjbGVnaGZkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3Njc3NTc0MjgsImV4cCI6MjA4MzMzMzQyOH0.G7ILx-nntP0NbxO1gKt5yASb7nt7OmpJ8qtykeGYbQA";
@@ -448,6 +456,8 @@ var TaskOperations = class _TaskOperations {
   async createTask(task) {
     const { data: { user } } = await this.supabase.auth.getUser();
     if (!user) throw new Error("Not authenticated");
+    const { data: maxIdResult } = await this.supabase.from("tasks").select("short_id").eq("user_id", user.id).order("short_id", { ascending: false }).limit(1).single();
+    const nextShortId = (maxIdResult?.short_id || 0) + 1;
     const { data, error } = await this.supabase.from("tasks").insert({
       user_id: user.id,
       title: task.title,
@@ -470,15 +480,26 @@ var TaskOperations = class _TaskOperations {
       project_tag: task.project_tag,
       created_by: task.created_by,
       context_notes: task.context_notes,
-      energy_required: task.energy_required
+      energy_required: task.energy_required,
+      short_id: nextShortId,
+      // Stable short ID
+      session_id: task.session_id,
+      session_history: task.session_history || []
     }).select().single();
     if (error) throw error;
     if (task.tags && task.tags.length > 0) {
       await this.linkTaskTags(data.id, task.tags.map((t) => t.id));
     }
+    await this.logChange({
+      taskId: data.id,
+      changeType: "created",
+      message: `Created task: "${task.title}"`,
+      actorType: task.created_by === "human" ? "human" : "ai"
+    });
     return data;
   }
-  async updateTask(taskId, updates) {
+  async updateTask(taskId, updates, logChanges = true) {
+    const oldTask = logChanges ? await this.getTask(taskId) : null;
     const updateData = {};
     if (updates.title !== void 0) updateData.title = updates.title;
     if (updates.description !== void 0) updateData.description = updates.description;
@@ -510,6 +531,85 @@ var TaskOperations = class _TaskOperations {
         await this.linkTaskTags(taskId, updates.tags.map((t) => t.id));
       }
     }
+    if (logChanges && oldTask) {
+      if (updates.status !== void 0 && updates.status !== oldTask.status) {
+        await this.logChange({
+          taskId,
+          changeType: "status_changed",
+          fieldChanged: "status",
+          oldValue: oldTask.status,
+          newValue: updates.status,
+          message: `Status: ${oldTask.status} \u2192 ${updates.status}`
+        });
+      }
+      if (updates.title !== void 0 && updates.title !== oldTask.title) {
+        await this.logChange({
+          taskId,
+          changeType: "title_changed",
+          fieldChanged: "title",
+          oldValue: oldTask.title,
+          newValue: updates.title,
+          message: `Title changed`
+        });
+      }
+      if (updates.context_notes !== void 0 && updates.context_notes !== oldTask.context_notes) {
+        await this.logChange({
+          taskId,
+          changeType: "context_updated",
+          fieldChanged: "context_notes",
+          oldValue: oldTask.context_notes,
+          newValue: updates.context_notes,
+          message: `Updated context notes`
+        });
+      }
+      if (updates.priority !== void 0 && updates.priority !== oldTask.priority) {
+        await this.logChange({
+          taskId,
+          changeType: "priority_changed",
+          fieldChanged: "priority",
+          oldValue: oldTask.priority,
+          newValue: updates.priority,
+          message: `Priority: ${oldTask.priority} \u2192 ${updates.priority}`
+        });
+      }
+      if (updates.subtasks_json !== void 0 && oldTask.subtasks_json) {
+        const oldSubtasks = oldTask.subtasks_json || [];
+        const newSubtasks = updates.subtasks_json || [];
+        for (const newSub of newSubtasks) {
+          const oldSub = oldSubtasks.find((s) => s.id === newSub.id);
+          if (oldSub && !oldSub.done && newSub.done) {
+            await this.logChange({
+              taskId,
+              changeType: "subtask_done",
+              fieldChanged: "subtasks",
+              oldValue: { id: newSub.id, done: false },
+              newValue: { id: newSub.id, done: true },
+              message: `Completed: ${newSub.title}`
+            });
+          } else if (oldSub && oldSub.done && !newSub.done) {
+            await this.logChange({
+              taskId,
+              changeType: "subtask_undone",
+              fieldChanged: "subtasks",
+              oldValue: { id: newSub.id, done: true },
+              newValue: { id: newSub.id, done: false },
+              message: `Unchecked: ${newSub.title}`
+            });
+          }
+        }
+        for (const newSub of newSubtasks) {
+          if (!oldSubtasks.find((s) => s.id === newSub.id)) {
+            await this.logChange({
+              taskId,
+              changeType: "subtask_added",
+              fieldChanged: "subtasks",
+              newValue: newSub,
+              message: `Added subtask: ${newSub.title}`
+            });
+          }
+        }
+      }
+    }
     return data;
   }
   async deleteTask(taskId) {
@@ -517,12 +617,29 @@ var TaskOperations = class _TaskOperations {
     if (error) throw error;
   }
   async completeTask(taskId) {
-    const { data, error } = await this.supabase.from("tasks").update({
+    const { data: existingTask } = await this.supabase.from("tasks").select("subtasks, acceptance_criteria, status, title").eq("id", taskId).single();
+    const oldStatus = existingTask?.status || "todo";
+    const updatePayload = {
       completed: true,
       completed_at: (/* @__PURE__ */ new Date()).toISOString(),
       status: "done"
-    }).eq("id", taskId).select().single();
+    };
+    if (existingTask?.subtasks && Array.isArray(existingTask.subtasks)) {
+      updatePayload.subtasks = existingTask.subtasks.map((s) => ({ ...s, done: true }));
+    }
+    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;
+    await this.logChange({
+      taskId,
+      changeType: "status_changed",
+      fieldChanged: "status",
+      oldValue: oldStatus,
+      newValue: "done",
+      message: `Completed: ${existingTask?.title || "task"}`
+    });
     return data;
   }
   async uncompleteTask(taskId) {
@@ -541,11 +658,20 @@ var TaskOperations = class _TaskOperations {
    * Typically used for completed tasks you want to hide from views
    */
   async archiveTask(taskId) {
+    const oldTask = await this.getTask(taskId);
     const { data, error } = await this.supabase.from("tasks").update({
       status: "archived",
       archived_at: (/* @__PURE__ */ new Date()).toISOString()
     }).eq("id", taskId).select().single();
     if (error) throw error;
+    await this.logChange({
+      taskId,
+      changeType: "archived",
+      fieldChanged: "status",
+      oldValue: oldTask.status,
+      newValue: "archived",
+      message: `Archived: ${oldTask.title}`
+    });
     return data;
   }
   /**
@@ -751,6 +877,340 @@ var TaskOperations = class _TaskOperations {
       needs_attention: unacknowledged.length > 3 || byPriority.high > 0
     };
   }
+  // ============================================
+  // WORKSPACE DOC OPERATIONS
+  // ============================================
+  /**
+   * Create a workspace document (research, domain doc, plan)
+   */
+  async createWorkspaceDoc(input) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) {
+      throw new Error("Not authenticated");
+    }
+    const { data, error } = await this.supabase.from("workspace_docs").insert({
+      user_id: user.id,
+      doc_type: input.doc_type,
+      title: input.title,
+      content: input.content,
+      project_tag: input.project_tag || "sparktory",
+      created_by: input.created_by || "ai",
+      source_urls: input.source_urls || [],
+      search_queries: input.search_queries || [],
+      applies_to_children: input.applies_to_children ?? true,
+      tags: input.tags || [],
+      globs: input.globs || []
+    }).select().single();
+    if (error) {
+      throw new Error(`Failed to create workspace doc: ${error.message}`);
+    }
+    return data;
+  }
+  /**
+   * Get workspace documents
+   */
+  async getWorkspaceDocs(filters) {
+    let query = this.supabase.from("workspace_docs").select("*").order("created_at", { ascending: false });
+    if (filters?.doc_type) {
+      query = query.eq("doc_type", filters.doc_type);
+    }
+    if (filters?.project_tag) {
+      query = query.eq("project_tag", filters.project_tag);
+    }
+    if (filters?.search) {
+      query = query.or(`title.ilike.%${filters.search}%,content.ilike.%${filters.search}%`);
+    }
+    if (filters?.limit) {
+      query = query.limit(filters.limit);
+    }
+    const { data, error } = await query;
+    if (error) {
+      throw new Error(`Failed to get workspace docs: ${error.message}`);
+    }
+    return data || [];
+  }
+  // ============================================
+  // CHANGE TRACKING (Git-for-Tasks)
+  // ============================================
+  /**
+   * Log a change to a task (like a git commit)
+   */
+  async logChange(input) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const { data, error } = await this.supabase.from("task_changes").insert({
+      task_id: input.taskId,
+      user_id: user.id,
+      session_id: this.currentSessionId,
+      actor_type: input.actorType || "ai",
+      change_type: input.changeType,
+      field_changed: input.fieldChanged,
+      old_value: input.oldValue,
+      new_value: input.newValue,
+      message: input.message,
+      reverted_change_id: input.revertedChangeId
+    }).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Get change history for a task (like git log)
+   */
+  async getTaskChanges(taskId, options) {
+    let query = this.supabase.from("task_changes").select("*").eq("task_id", taskId).order("created_at", { ascending: false });
+    if (options?.limit) {
+      query = query.limit(options.limit);
+    }
+    if (options?.since) {
+      query = query.gte("created_at", options.since);
+    }
+    if (options?.until) {
+      query = query.lte("created_at", options.until);
+    }
+    if (options?.changeTypes && options.changeTypes.length > 0) {
+      query = query.in("change_type", options.changeTypes);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return data || [];
+  }
+  /**
+   * Get a specific change (like git show)
+   */
+  async getChange(changeId) {
+    const { data, error } = await this.supabase.from("task_changes").select("*").eq("id", changeId).single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Revert a change (non-destructive - creates a new "revert" change)
+   */
+  async revertChange(changeId, message) {
+    const change = await this.getChange(changeId);
+    const task = await this.getTask(change.task_id);
+    if (change.field_changed && change.old_value !== void 0) {
+      const updates = {};
+      updates[change.field_changed] = change.old_value;
+      await this.updateTask(change.task_id, updates);
+    }
+    return await this.logChange({
+      taskId: change.task_id,
+      changeType: "revert",
+      fieldChanged: change.field_changed,
+      oldValue: change.new_value,
+      newValue: change.old_value,
+      message: message || `Reverted: ${change.message || change.change_type}`,
+      revertedChangeId: changeId
+    });
+  }
+  /**
+   * Get all tasks touched by a session
+   */
+  async getSessionTasks(sessionId) {
+    const { data, error } = await this.supabase.rpc("get_session_tasks", { p_session_id: sessionId });
+    if (error) throw error;
+    return data || [];
+  }
+  /**
+   * Search task changes by message
+   */
+  async searchChanges(query, limit = 50) {
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user) throw new Error("Not authenticated");
+    const { data, error } = await this.supabase.rpc("search_task_changes", {
+      p_user_id: user.id,
+      p_query: query,
+      p_limit: limit
+    });
+    if (error) throw error;
+    return data || [];
+  }
+  // ============================================
+  // WORKSPACE OPERATIONS
+  // ============================================
+  /**
+   * Create 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,
+      color: input.color,
+      description: input.description
+    }).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Get workspace tree for the current user
+   */
+  async getWorkspaces(includeArchived = false) {
+    let query = this.supabase.from("workspaces").select("*").order("full_path", { ascending: true });
+    if (!includeArchived) {
+      query = query.is("archived_at", null);
+    }
+    const { data, error } = await query;
+    if (error) throw error;
+    return data || [];
+  }
+  /**
+   * Get workspace by full path
+   */
+  async getWorkspaceByPath(fullPath) {
+    const { data, error } = await this.supabase.from("workspaces").select("*").eq("full_path", fullPath).single();
+    if (error && error.code !== "PGRST116") throw error;
+    return data;
+  }
+  /**
+   * Get or create workspace from a project_tag (auto-creates hierarchy)
+   */
+  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);
+  }
+  /**
+   * Archive a workspace (soft delete)
+   */
+  async archiveWorkspace(workspaceId) {
+    const { data, error } = await this.supabase.from("workspaces").update({ archived_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", workspaceId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Restore a workspace from archive
+   */
+  async restoreWorkspace(workspaceId) {
+    const { data, error } = await this.supabase.from("workspaces").update({ archived_at: null }).eq("id", workspaceId).select().single();
+    if (error) throw error;
+    return data;
+  }
+  /**
+   * Get workspace descendants (recursive)
+   */
+  async getWorkspaceDescendants(workspaceId) {
+    const { data, error } = await this.supabase.rpc("get_workspace_descendants", { root_id: workspaceId });
+    if (error) throw error;
+    return data || [];
+  }
+  /**
+   * Generate consistent color for workspace
+   */
+  generateWorkspaceColor(name) {
+    const colors = [
+      "#8b5cf6",
+      "#3b82f6",
+      "#10b981",
+      "#f59e0b",
+      "#ef4444",
+      "#06b6d4",
+      "#ec4899",
+      "#84cc16"
+    ];
+    let hash = 0;
+    for (let i = 0; i < name.length; i++) {
+      hash = name.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    return colors[Math.abs(hash) % colors.length];
+  }
+  // ============================================
+  // PAUSE/RESUME OPERATIONS
+  // ============================================
+  /**
+   * Pause a task
+   */
+  async pauseTask(taskId, reason) {
+    const oldTask = await this.getTask(taskId);
+    const { data, error } = await this.supabase.from("tasks").update({ status: "paused" }).eq("id", taskId).select().single();
+    if (error) throw error;
+    await this.logChange({
+      taskId,
+      changeType: "status_changed",
+      fieldChanged: "status",
+      oldValue: oldTask.status,
+      newValue: "paused",
+      message: reason || `Paused task`
+    });
+    return data;
+  }
+  /**
+   * Resume a paused task
+   */
+  async resumeTask(taskId) {
+    const oldTask = await this.getTask(taskId);
+    const { data, error } = await this.supabase.from("tasks").update({ status: "vibing" }).eq("id", taskId).select().single();
+    if (error) throw error;
+    await this.logChange({
+      taskId,
+      changeType: "status_changed",
+      fieldChanged: "status",
+      oldValue: oldTask.status,
+      newValue: "vibing",
+      message: `Resumed task`
+    });
+    return data;
+  }
+  /**
+   * Restore a task from archive
+   */
+  async restoreTask(taskId, toStatus = "todo") {
+    const oldTask = await this.getTask(taskId);
+    const { data, error } = await this.supabase.from("tasks").update({
+      status: toStatus,
+      archived_at: null
+    }).eq("id", taskId).select().single();
+    if (error) throw error;
+    await this.logChange({
+      taskId,
+      changeType: "restored",
+      fieldChanged: "status",
+      oldValue: oldTask.status,
+      newValue: toStatus,
+      message: `Restored from archive`
+    });
+    return data;
+  }
 };
 
 // src/claude-sync.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetasks/core",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Shared core logic for VibeTasks MCP server and CLI - authentication, task operations, and config management",
   "author": "Vyas",
   "license": "MIT",