@stackmemoryai/stackmemory 0.2.9 → 0.3.0

package/dist/features/tasks/__tests__/pebbles-task-store.test.js

@@ -0,0 +1,747 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import Database from "better-sqlite3";
+import {
+  PebblesTaskStore
+} from "../pebbles-task-store.js";
+import {
+  DatabaseError,
+  TaskError
+} from "../../../core/errors/index.js";
+import { join } from "path";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+describe("PebblesTaskStore", () => {
+  let db;
+  let taskStore;
+  let tempDir;
+  let projectRoot;
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "stackmemory-task-test-"));
+    projectRoot = tempDir;
+    const stackmemoryDir = join(tempDir, ".stackmemory");
+    mkdirSync(stackmemoryDir, { recursive: true });
+    const dbPath = join(stackmemoryDir, "context.db");
+    db = new Database(dbPath);
+    taskStore = new PebblesTaskStore(projectRoot, db);
+  });
+  afterEach(() => {
+    if (db) {
+      db.close();
+    }
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+  describe("Initialization", () => {
+    it("should create .stackmemory directory if it does not exist", () => {
+      const stackmemoryDir = join(projectRoot, ".stackmemory");
+      expect(existsSync(stackmemoryDir)).toBe(true);
+    });
+    it("should initialize cache database schema correctly", () => {
+      const tables = db.prepare(
+        `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='task_cache'
+      `
+      ).all();
+      expect(tables).toHaveLength(1);
+    });
+    it("should create required indexes", () => {
+      const indexes = db.prepare(
+        `
+        SELECT name FROM sqlite_master 
+        WHERE type='index' AND name LIKE 'idx_task_%'
+      `
+      ).all();
+      const expectedIndexes = [
+        "idx_task_status",
+        "idx_task_priority",
+        "idx_task_frame",
+        "idx_task_timestamp",
+        "idx_task_parent"
+      ];
+      expectedIndexes.forEach((expectedIndex) => {
+        expect(indexes.some((idx) => idx.name === expectedIndex)).toBe(
+          true
+        );
+      });
+    });
+    it("should load existing tasks from JSONL file", () => {
+      const tasksFile = join(projectRoot, ".stackmemory", "tasks.jsonl");
+      const existingTask = {
+        id: "test-123",
+        type: "task_create",
+        timestamp: Math.floor(Date.now() / 1e3),
+        frame_id: "frame-123",
+        title: "Existing Task",
+        description: "Pre-existing task",
+        status: "pending",
+        priority: "medium",
+        created_at: Math.floor(Date.now() / 1e3),
+        depends_on: [],
+        blocks: [],
+        tags: ["test"],
+        context_score: 0.5
+      };
+      writeFileSync(tasksFile, JSON.stringify(existingTask) + "\n");
+      const newTaskStore = new PebblesTaskStore(projectRoot, db);
+      const loadedTask = newTaskStore.getTask("test-123");
+      expect(loadedTask).toBeDefined();
+      expect(loadedTask.title).toBe("Existing Task");
+    });
+    it("should handle corrupted JSONL lines gracefully", () => {
+      const tasksFile = join(projectRoot, ".stackmemory", "tasks.jsonl");
+      const content = `
+{"valid": "task", "id": "valid-1", "type": "task_create", "timestamp": 1, "frame_id": "f1", "title": "Valid", "status": "pending", "priority": "medium", "created_at": 1, "depends_on": [], "blocks": [], "tags": []}
+{invalid json line
+{"id": "valid-2", "type": "task_create", "timestamp": 2, "frame_id": "f2", "title": "Valid 2", "status": "pending", "priority": "high", "created_at": 2, "depends_on": [], "blocks": [], "tags": []}
+      `.trim();
+      writeFileSync(tasksFile, content);
+      const newTaskStore = new PebblesTaskStore(projectRoot, db);
+      expect(newTaskStore.getTask("valid-1")).toBeDefined();
+      expect(newTaskStore.getTask("valid-2")).toBeDefined();
+    });
+  });
+  describe("Task Creation", () => {
+    it("should create a new task successfully", () => {
+      const taskId = taskStore.createTask({
+        title: "Test Task",
+        description: "A test task",
+        priority: "high",
+        frameId: "frame-123",
+        tags: ["test", "urgent"],
+        estimatedEffort: 60,
+        assignee: "developer"
+      });
+      expect(taskId).toBeDefined();
+      expect(taskId).toMatch(/^tsk-[a-f0-9]{8}$/);
+      const task = taskStore.getTask(taskId);
+      expect(task).toBeDefined();
+      expect(task.title).toBe("Test Task");
+      expect(task.description).toBe("A test task");
+      expect(task.priority).toBe("high");
+      expect(task.status).toBe("pending");
+      expect(task.frame_id).toBe("frame-123");
+      expect(task.tags).toEqual(["test", "urgent"]);
+      expect(task.estimated_effort).toBe(60);
+      expect(task.assignee).toBe("developer");
+      expect(task.depends_on).toEqual([]);
+      expect(task.blocks).toEqual([]);
+    });
+    it("should create task with minimal required fields", () => {
+      const taskId = taskStore.createTask({
+        title: "Minimal Task",
+        frameId: "frame-456"
+      });
+      const task = taskStore.getTask(taskId);
+      expect(task).toBeDefined();
+      expect(task.title).toBe("Minimal Task");
+      expect(task.frame_id).toBe("frame-456");
+      expect(task.priority).toBe("medium");
+      expect(task.status).toBe("pending");
+      expect(task.description).toBeNull();
+      expect(task.tags).toEqual([]);
+    });
+    it("should create task with parent relationship", () => {
+      const parentId = taskStore.createTask({
+        title: "Parent Task",
+        frameId: "frame-parent"
+      });
+      const childId = taskStore.createTask({
+        title: "Child Task",
+        frameId: "frame-child",
+        parentId
+      });
+      const childTask = taskStore.getTask(childId);
+      expect(childTask.parent_id).toBe(parentId);
+    });
+    it("should create task with dependencies", () => {
+      const dep1Id = taskStore.createTask({
+        title: "Dependency 1",
+        frameId: "frame-dep1"
+      });
+      const dep2Id = taskStore.createTask({
+        title: "Dependency 2",
+        frameId: "frame-dep2"
+      });
+      const taskId = taskStore.createTask({
+        title: "Dependent Task",
+        frameId: "frame-main",
+        dependsOn: [dep1Id, dep2Id]
+      });
+      const task = taskStore.getTask(taskId);
+      expect(task.depends_on).toEqual([dep1Id, dep2Id]);
+    });
+    it("should append task to JSONL file", async () => {
+      const taskId = taskStore.createTask({
+        title: "JSONL Test",
+        frameId: "frame-jsonl"
+      });
+      const tasksFile = join(projectRoot, ".stackmemory", "tasks.jsonl");
+      expect(existsSync(tasksFile)).toBe(true);
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const content = readFileSync(tasksFile, "utf-8");
+      expect(content).toContain(taskId);
+      expect(content).toContain("JSONL Test");
+    });
+  });
+  describe("Task Status Updates", () => {
+    let taskId;
+    beforeEach(() => {
+      taskId = taskStore.createTask({
+        title: "Status Test Task",
+        frameId: "frame-status"
+      });
+    });
+    it("should update task status from pending to in_progress", () => {
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      const task = taskStore.getTask(taskId);
+      expect(task.status).toBe("in_progress");
+      expect(task.started_at).toBeDefined();
+    });
+    it("should update task status from in_progress to completed", () => {
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      taskStore.updateTaskStatus(taskId, "completed");
+      const task = taskStore.getTask(taskId);
+      expect(task.status).toBe("completed");
+      expect(task.completed_at).toBeDefined();
+      expect(task.actual_effort).toBeDefined();
+    });
+    it("should update task status to blocked", () => {
+      taskStore.updateTaskStatus(taskId, "blocked", "Waiting for external API");
+      const task = taskStore.getTask(taskId);
+      expect(task.status).toBe("blocked");
+      expect(task.type).toBe("task_block");
+    });
+    it("should update task status to cancelled", () => {
+      taskStore.updateTaskStatus(taskId, "cancelled");
+      const task = taskStore.getTask(taskId);
+      expect(task.status).toBe("cancelled");
+    });
+    it("should throw error when updating non-existent task", () => {
+      expect(() => {
+        taskStore.updateTaskStatus("non-existent", "completed");
+      }).toThrow(TaskError);
+    });
+    it("should throw error when changing completed task status", () => {
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      taskStore.updateTaskStatus(taskId, "completed");
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "in_progress");
+      }).toThrow(TaskError);
+    });
+    it("should allow changing completed task to cancelled", () => {
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      taskStore.updateTaskStatus(taskId, "completed");
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "cancelled");
+      }).not.toThrow();
+      const task = taskStore.getTask(taskId);
+      expect(task.status).toBe("cancelled");
+    });
+    it("should calculate actual effort correctly", () => {
+      const startTime = Date.now();
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      vi.useFakeTimers();
+      vi.advanceTimersByTime(30 * 60 * 1e3);
+      taskStore.updateTaskStatus(taskId, "completed");
+      const task = taskStore.getTask(taskId);
+      expect(task.actual_effort).toBe(30);
+      vi.useRealTimers();
+    });
+    it("should update task type based on status change", () => {
+      const task1 = taskStore.getTask(taskId);
+      expect(task1.type).toBe("task_create");
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      const task2 = taskStore.getTask(taskId);
+      expect(task2.type).toBe("task_update");
+      taskStore.updateTaskStatus(taskId, "completed");
+      const task3 = taskStore.getTask(taskId);
+      expect(task3.type).toBe("task_complete");
+      const blockedTaskId = taskStore.createTask({
+        title: "Blocked Task",
+        frameId: "frame-blocked"
+      });
+      taskStore.updateTaskStatus(blockedTaskId, "blocked");
+      const task4 = taskStore.getTask(blockedTaskId);
+      expect(task4.type).toBe("task_block");
+    });
+  });
+  describe("Task Dependencies", () => {
+    let task1Id;
+    let task2Id;
+    beforeEach(() => {
+      task1Id = taskStore.createTask({
+        title: "Task 1",
+        frameId: "frame-1"
+      });
+      task2Id = taskStore.createTask({
+        title: "Task 2",
+        frameId: "frame-2"
+      });
+    });
+    it("should add dependency relationship", () => {
+      taskStore.addDependency(task2Id, task1Id);
+      const task2 = taskStore.getTask(task2Id);
+      const task1 = taskStore.getTask(task1Id);
+      expect(task2.depends_on).toContain(task1Id);
+      expect(task1.blocks).toContain(task2Id);
+    });
+    it("should prevent duplicate dependencies", () => {
+      taskStore.addDependency(task2Id, task1Id);
+      taskStore.addDependency(task2Id, task1Id);
+      const task2 = taskStore.getTask(task2Id);
+      expect(task2.depends_on.filter((id) => id === task1Id)).toHaveLength(1);
+    });
+    it("should throw error for non-existent task", () => {
+      expect(() => {
+        taskStore.addDependency("non-existent", task1Id);
+      }).toThrow(TaskError);
+      expect(() => {
+        taskStore.addDependency(task2Id, "non-existent");
+      }).toThrow(TaskError);
+    });
+    it("should detect circular dependencies", () => {
+      taskStore.addDependency(task2Id, task1Id);
+      expect(() => {
+        taskStore.addDependency(task1Id, task2Id);
+      }).toThrow(TaskError);
+    });
+    it("should detect complex circular dependencies", () => {
+      const task3Id = taskStore.createTask({
+        title: "Task 3",
+        frameId: "frame-3"
+      });
+      const task4Id = taskStore.createTask({
+        title: "Task 4",
+        frameId: "frame-4"
+      });
+      taskStore.addDependency(task2Id, task1Id);
+      taskStore.addDependency(task3Id, task2Id);
+      taskStore.addDependency(task4Id, task3Id);
+      expect(() => {
+        taskStore.addDependency(task1Id, task4Id);
+      }).toThrow(TaskError);
+    });
+    it("should handle self-dependency prevention", () => {
+      expect(() => {
+        taskStore.addDependency(task1Id, task1Id);
+      }).toThrow(TaskError);
+    });
+  });
+  describe("Task Queries", () => {
+    beforeEach(() => {
+      const tasks = [
+        {
+          title: "Active Task 1",
+          status: "pending",
+          priority: "high",
+          frameId: "frame-1"
+        },
+        {
+          title: "Active Task 2",
+          status: "in_progress",
+          priority: "medium",
+          frameId: "frame-1"
+        },
+        {
+          title: "Completed Task",
+          status: "completed",
+          priority: "low",
+          frameId: "frame-2"
+        },
+        {
+          title: "Blocked Task",
+          status: "blocked",
+          priority: "urgent",
+          frameId: "frame-3"
+        },
+        {
+          title: "Cancelled Task",
+          status: "cancelled",
+          priority: "medium",
+          frameId: "frame-3"
+        }
+      ];
+      tasks.forEach((task) => {
+        const taskId = taskStore.createTask(task);
+        if (task.status !== "pending") {
+          taskStore.updateTaskStatus(taskId, task.status);
+        }
+      });
+    });
+    it("should get all active tasks", () => {
+      const activeTasks = taskStore.getActiveTasks();
+      expect(activeTasks).toHaveLength(2);
+      expect(
+        activeTasks.every((t) => ["pending", "in_progress"].includes(t.status))
+      ).toBe(true);
+    });
+    it("should get active tasks filtered by frame", () => {
+      const frame1Tasks = taskStore.getActiveTasks("frame-1");
+      expect(frame1Tasks).toHaveLength(2);
+      expect(frame1Tasks.every((t) => t.frame_id === "frame-1")).toBe(true);
+    });
+    it("should order active tasks by priority and creation time", () => {
+      const activeTasks = taskStore.getActiveTasks();
+      const priorities = activeTasks.map((t) => t.priority);
+      expect(priorities).toContain("high");
+      expect(priorities).toContain("medium");
+    });
+    it("should get blocking tasks", () => {
+      const blockingTaskId = taskStore.createTask({
+        title: "Blocking Task",
+        frameId: "frame-blocker"
+      });
+      const dependentTaskId = taskStore.createTask({
+        title: "Dependent Task",
+        frameId: "frame-dependent"
+      });
+      taskStore.addDependency(dependentTaskId, blockingTaskId);
+      const blockingTasks = taskStore.getBlockingTasks();
+      expect(blockingTasks.length).toBeGreaterThan(0);
+      const foundBlocking = blockingTasks.find((t) => t.id === blockingTaskId);
+      expect(foundBlocking).toBeDefined();
+    });
+    it("should return empty array when no active tasks exist", () => {
+      let activeTasks = taskStore.getActiveTasks();
+      while (activeTasks.length > 0) {
+        const task = activeTasks[0];
+        if (task.status === "pending") {
+          taskStore.updateTaskStatus(task.id, "in_progress");
+        } else if (task.status === "in_progress") {
+          taskStore.updateTaskStatus(task.id, "completed");
+        }
+        activeTasks = taskStore.getActiveTasks();
+      }
+      const remainingActive = taskStore.getActiveTasks();
+      expect(remainingActive).toHaveLength(0);
+    });
+  });
+  describe("Task Metrics", () => {
+    beforeEach(() => {
+      const tasks = [
+        {
+          title: "Task 1",
+          status: "pending",
+          priority: "high"
+        },
+        {
+          title: "Task 2",
+          status: "pending",
+          priority: "medium"
+        },
+        {
+          title: "Task 3",
+          status: "completed",
+          priority: "low",
+          effort: 30
+        },
+        {
+          title: "Task 4",
+          status: "completed",
+          priority: "high",
+          effort: 60
+        },
+        {
+          title: "Task 5",
+          status: "blocked",
+          priority: "urgent"
+        },
+        {
+          title: "Task 6",
+          status: "cancelled",
+          priority: "medium"
+        }
+      ];
+      tasks.forEach((task) => {
+        const taskId = taskStore.createTask({
+          title: task.title,
+          frameId: "frame-metrics",
+          priority: task.priority,
+          estimatedEffort: task.effort
+        });
+        if (task.status !== "pending") {
+          if (task.status === "completed") {
+            taskStore.updateTaskStatus(taskId, "in_progress");
+          }
+          taskStore.updateTaskStatus(taskId, task.status);
+        }
+      });
+    });
+    it("should calculate basic metrics correctly", () => {
+      const metrics = taskStore.getMetrics();
+      expect(metrics.total_tasks).toBe(6);
+      expect(metrics.by_status.pending).toBe(2);
+      expect(metrics.by_status.completed).toBe(2);
+      expect(metrics.by_status.blocked).toBe(1);
+      expect(metrics.by_status.cancelled).toBe(1);
+      expect(metrics.by_priority.high).toBe(2);
+      expect(metrics.by_priority.medium).toBe(2);
+      expect(metrics.by_priority.low).toBe(1);
+      expect(metrics.by_priority.urgent).toBe(1);
+      expect(metrics.completion_rate).toBe(2 / 6);
+      expect(metrics.blocked_tasks).toBe(1);
+    });
+    it("should handle metrics when no tasks exist", () => {
+      const emptyDb = new Database(":memory:");
+      const emptyStore = new PebblesTaskStore(projectRoot, emptyDb);
+      const metrics = emptyStore.getMetrics();
+      expect(metrics.total_tasks).toBe(0);
+      expect(metrics.completion_rate).toBe(0);
+      expect(metrics.blocked_tasks).toBe(0);
+      emptyDb.close();
+    });
+    it("should calculate effort accuracy", () => {
+      const taskId = taskStore.createTask({
+        title: "Effort Test",
+        frameId: "frame-effort",
+        estimatedEffort: 60
+        // 1 hour estimate
+      });
+      taskStore.updateTaskStatus(taskId, "in_progress");
+      const task = taskStore.getTask(taskId);
+      if (task) {
+        const stmt = db.prepare(`
+          UPDATE task_cache 
+          SET actual_effort = ? 
+          WHERE id = ?
+        `);
+        stmt.run(50, taskId);
+      }
+      const metrics = taskStore.getMetrics();
+      expect(metrics.avg_effort_accuracy).toBeGreaterThan(0);
+    });
+  });
+  describe("Linear Integration Export", () => {
+    beforeEach(() => {
+      taskStore.createTask({
+        title: "Local Task 1",
+        frameId: "frame-1",
+        description: "Task for Linear export",
+        priority: "high",
+        estimatedEffort: 120
+      });
+      taskStore.createTask({
+        title: "Local Task 2",
+        frameId: "frame-2",
+        priority: "medium"
+      });
+      const taskWithLinear = taskStore.createTask({
+        title: "Already Synced",
+        frameId: "frame-3"
+      });
+      db.prepare(
+        `
+        UPDATE task_cache 
+        SET external_refs = ? 
+        WHERE id = ?
+      `
+      ).run(JSON.stringify({ linear: { id: "LIN-123" } }), taskWithLinear);
+    });
+    it("should export tasks for Linear integration", () => {
+      const exported = taskStore.exportForLinear();
+      expect(exported).toHaveLength(2);
+      const task1 = exported.find((t) => t.title === "Local Task 1");
+      expect(task1).toBeDefined();
+      expect(task1.description).toBe("Task for Linear export");
+      expect(task1.priority).toBe(3);
+      expect(task1.estimate).toBe(120);
+      const task2 = exported.find((t) => t.title === "Local Task 2");
+      expect(task2).toBeDefined();
+      expect(task2.priority).toBe(2);
+    });
+    it("should map priorities correctly for Linear", () => {
+      const priorities = {
+        low: 1,
+        medium: 2,
+        high: 3,
+        urgent: 4
+      };
+      Object.entries(priorities).forEach(([priority, expectedValue]) => {
+        const taskId = taskStore.createTask({
+          title: `Priority ${priority}`,
+          frameId: "frame-priority",
+          priority
+        });
+        const exported = taskStore.exportForLinear();
+        const task = exported.find((t) => t.title === `Priority ${priority}`);
+        expect(task.priority).toBe(expectedValue);
+      });
+    });
+    it("should map statuses correctly for Linear", () => {
+      const statusMappings = {
+        pending: "Backlog",
+        in_progress: "In Progress",
+        completed: "Done",
+        blocked: "Blocked",
+        cancelled: "Cancelled"
+      };
+      Object.entries(statusMappings).forEach(
+        ([status, expectedLinearStatus]) => {
+          const taskId = taskStore.createTask({
+            title: `Status ${status}`,
+            frameId: "frame-status"
+          });
+          if (status !== "pending") {
+            taskStore.updateTaskStatus(taskId, status);
+          }
+          const exported = taskStore.exportForLinear();
+          const task = exported.find((t) => t.title === `Status ${status}`);
+          expect(task.status).toBe(expectedLinearStatus);
+        }
+      );
+    });
+  });
+  describe("Error Handling and Edge Cases", () => {
+    it("should handle database errors gracefully", () => {
+      const taskId = taskStore.createTask({
+        title: "Error Test",
+        frameId: "frame-error"
+      });
+      db.close();
+      expect(() => {
+        taskStore.getTask(taskId);
+      }).toThrow(DatabaseError);
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "completed");
+      }).toThrow();
+    });
+    it("should handle JSONL file write errors gracefully", () => {
+      const originalAppendFile = require("fs").appendFile;
+      require("fs").appendFile = vi.fn((path, data, callback) => {
+        callback(new Error("Write failed"));
+      });
+      expect(() => {
+        taskStore.createTask({
+          title: "Write Error Test",
+          frameId: "frame-write-error"
+        });
+      }).not.toThrow();
+      require("fs").appendFile = originalAppendFile;
+    });
+    it("should handle concurrent task operations", () => {
+      const tasks = [];
+      for (let i = 0; i < 20; i++) {
+        const taskId = taskStore.createTask({
+          title: `Concurrent Task ${i}`,
+          frameId: `frame-${i}`,
+          priority: i % 2 === 0 ? "high" : "low"
+        });
+        tasks.push(taskId);
+      }
+      expect(tasks).toHaveLength(20);
+      tasks.forEach((taskId) => {
+        taskStore.updateTaskStatus(taskId, "completed");
+      });
+      const allCompleted = tasks.every((taskId) => {
+        const task = taskStore.getTask(taskId);
+        return task?.status === "completed";
+      });
+      expect(allCompleted).toBe(true);
+    });
+    it("should handle empty or malformed task IDs", () => {
+      expect(taskStore.getTask("")).toBeUndefined();
+      expect(taskStore.getTask("invalid-format")).toBeUndefined();
+      expect(taskStore.getTask("null")).toBeUndefined();
+    });
+    it("should validate task status transitions", () => {
+      const taskId = taskStore.createTask({
+        title: "Status Validation",
+        frameId: "frame-validation"
+      });
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "in_progress");
+      }).not.toThrow();
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "blocked");
+      }).not.toThrow();
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "in_progress");
+      }).not.toThrow();
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "completed");
+      }).not.toThrow();
+      expect(() => {
+        taskStore.updateTaskStatus(taskId, "in_progress");
+      }).toThrow(TaskError);
+    });
+    it("should handle tasks with complex metadata", () => {
+      const taskId = taskStore.createTask({
+        title: "Complex Metadata Task",
+        frameId: "frame-complex",
+        tags: ["complex", "metadata", "test"],
+        dependsOn: []
+      });
+      const depTaskId = taskStore.createTask({
+        title: "Dependency Task",
+        frameId: "frame-dep"
+      });
+      taskStore.addDependency(taskId, depTaskId);
+      const task = taskStore.getTask(taskId);
+      expect(task.tags).toEqual(["complex", "metadata", "test"]);
+      expect(task.depends_on).toContain(depTaskId);
+    });
+  });
+  describe("Data Integrity and Consistency", () => {
+    it("should maintain referential integrity in dependencies", () => {
+      const task1Id = taskStore.createTask({
+        title: "Task 1",
+        frameId: "frame-1"
+      });
+      const task2Id = taskStore.createTask({
+        title: "Task 2",
+        frameId: "frame-2"
+      });
+      taskStore.addDependency(task2Id, task1Id);
+      const task1 = taskStore.getTask(task1Id);
+      const task2 = taskStore.getTask(task2Id);
+      expect(task2.depends_on).toContain(task1Id);
+      expect(task1.blocks).toContain(task2Id);
+    });
+    it("should ensure content-based task IDs are deterministic for same content", () => {
+      const now = Math.floor(Date.now() / 1e3);
+      const originalRandom = Math.random;
+      Math.random = vi.fn(() => 0.5);
+      vi.spyOn(Date, "now").mockReturnValue(now * 1e3);
+      try {
+        const taskId1 = taskStore.createTask({
+          title: "Deterministic Task",
+          frameId: "frame-det"
+        });
+        const taskId2 = taskStore.createTask({
+          title: "Deterministic Task",
+          frameId: "frame-det"
+        });
+        expect(taskId1).toBe(taskId2);
+        expect(taskId1).toMatch(/^tsk-[a-f0-9]{8}$/);
+        expect(taskId2).toMatch(/^tsk-[a-f0-9]{8}$/);
+      } finally {
+        Math.random = originalRandom;
+        vi.restoreAllMocks();
+      }
+    });
+    it("should handle JSON serialization edge cases", () => {
+      const taskId = taskStore.createTask({
+        title: "JSON Edge Cases",
+        frameId: "frame-json",
+        tags: ["tag with spaces", 'tag"with"quotes', "tag\\with\\slashes"],
+        dependsOn: []
+      });
+      const task = taskStore.getTask(taskId);
+      expect(task.tags).toEqual([
+        "tag with spaces",
+        'tag"with"quotes',
+        "tag\\with\\slashes"
+      ]);
+    });
+  });
+});
+//# sourceMappingURL=pebbles-task-store.test.js.map