@task-mcp/shared 1.0.22 → 1.0.24

package/src/algorithms/critical-path.test.ts

@@ -0,0 +1,227 @@
+import { describe, test, expect } from "bun:test";
+import { criticalPathAnalysis, findParallelTasks, suggestNextTask } from "./critical-path.js";
+import type { Task } from "../schemas/task.js";
+
+// Helper to create mock tasks
+function createTask(
+  id: string,
+  options: {
+    priority?: string;
+    deps?: string[];
+    estimate?: number;
+    status?: string;
+    contexts?: string[];
+  } = {}
+): Task {
+  const task: Task = {
+    id,
+    title: `Task ${id}`,
+    status: (options.status ?? "pending") as Task["status"],
+    priority: (options.priority ?? "medium") as Task["priority"],
+    workspace: "test-workspace",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    dependencies: (options.deps ?? []).map((depId) => ({
+      taskId: depId,
+      type: "blocked_by" as const,
+    })),
+  };
+  if (options.estimate) {
+    task.estimate = { expected: options.estimate, confidence: "medium" as const };
+  }
+  if (options.contexts) {
+    task.contexts = options.contexts;
+  }
+  return task;
+}
+
+describe("criticalPathAnalysis", () => {
+  test("returns empty result for empty input", () => {
+    const result = criticalPathAnalysis([]);
+    expect(result.tasks).toEqual([]);
+    expect(result.criticalPath).toEqual([]);
+    expect(result.projectDuration).toBe(0);
+  });
+
+  test("returns empty for all completed tasks", () => {
+    const tasks = [createTask("A", { status: "completed" })];
+    const result = criticalPathAnalysis(tasks);
+    expect(result.tasks).toEqual([]);
+  });
+
+  test("calculates single task correctly", () => {
+    const tasks = [createTask("A", { estimate: 60 })];
+    const result = criticalPathAnalysis(tasks);
+
+    expect(result.projectDuration).toBe(60);
+    expect(result.criticalPath.length).toBe(1);
+    expect(result.criticalPath[0]!.id).toBe("A");
+    expect(result.criticalPath[0]!.isCritical).toBe(true);
+  });
+
+  test("identifies critical path in linear chain", () => {
+    // A -> B -> C (each 30 min)
+    const tasks = [
+      createTask("A", { estimate: 30 }),
+      createTask("B", { estimate: 30, deps: ["A"] }),
+      createTask("C", { estimate: 30, deps: ["B"] }),
+    ];
+    const result = criticalPathAnalysis(tasks);
+
+    expect(result.projectDuration).toBe(90);
+    expect(result.criticalPath.length).toBe(3);
+    expect(result.criticalPath.map((t) => t.id)).toEqual(["A", "B", "C"]);
+  });
+
+  test("calculates slack for parallel tasks", () => {
+    // A (60) and B (30) both lead to C
+    // A is on critical path, B has 30 min slack
+    const tasks = [
+      createTask("A", { estimate: 60 }),
+      createTask("B", { estimate: 30 }),
+      createTask("C", { estimate: 30, deps: ["A", "B"] }),
+    ];
+    const result = criticalPathAnalysis(tasks);
+
+    expect(result.projectDuration).toBe(90); // A + C
+
+    const taskA = result.tasks.find((t) => t.id === "A")!;
+    const taskB = result.tasks.find((t) => t.id === "B")!;
+    const taskC = result.tasks.find((t) => t.id === "C")!;
+
+    expect(taskA.isCritical).toBe(true);
+    expect(taskB.slack).toBe(30); // B can start 30 min late
+    expect(taskC.isCritical).toBe(true);
+  });
+
+  test("identifies bottlenecks by dependent count", () => {
+    // A blocks B, C, D
+    const tasks = [
+      createTask("A", { estimate: 30 }),
+      createTask("B", { estimate: 30, deps: ["A"] }),
+      createTask("C", { estimate: 30, deps: ["A"] }),
+      createTask("D", { estimate: 30, deps: ["A"] }),
+    ];
+    const result = criticalPathAnalysis(tasks);
+
+    expect(result.bottlenecks.length).toBeGreaterThan(0);
+    expect(result.bottlenecks[0]!.id).toBe("A"); // A blocks the most tasks
+  });
+});
+
+describe("findParallelTasks", () => {
+  test("returns empty for empty input", () => {
+    const result = findParallelTasks([]);
+    expect(result).toEqual([]);
+  });
+
+  test("returns single group for independent tasks", () => {
+    const tasks = [createTask("A"), createTask("B"), createTask("C")];
+    const result = findParallelTasks(tasks);
+
+    expect(result.length).toBe(1);
+    expect(result[0]!.length).toBe(3);
+  });
+
+  test("excludes tasks with uncompleted dependencies", () => {
+    const tasks = [createTask("A"), createTask("B", { deps: ["A"] })];
+    const result = findParallelTasks(tasks);
+
+    // Only A is available (B is blocked)
+    expect(result.length).toBe(1);
+    expect(result[0]!.length).toBe(1);
+    expect(result[0]![0]!.id).toBe("A");
+  });
+
+  test("includes task when dependency is completed", () => {
+    const tasks = [
+      createTask("A", { status: "completed" }),
+      createTask("B", { deps: ["A"] }),
+      createTask("C"),
+    ];
+    const result = findParallelTasks(tasks);
+
+    // B and C can run in parallel
+    expect(result.length).toBe(1);
+    expect(result[0]!.map((t) => t.id).sort()).toEqual(["B", "C"]);
+  });
+
+  test("excludes completed tasks from result", () => {
+    const tasks = [createTask("A", { status: "completed" }), createTask("B")];
+    const result = findParallelTasks(tasks);
+
+    expect(result.length).toBe(1);
+    expect(result[0]!.length).toBe(1);
+    expect(result[0]![0]!.id).toBe("B");
+  });
+});
+
+describe("suggestNextTask", () => {
+  test("returns null for empty input", () => {
+    const result = suggestNextTask([]);
+    expect(result).toBeNull();
+  });
+
+  test("returns null when all tasks completed", () => {
+    const tasks = [createTask("A", { status: "completed" })];
+    const result = suggestNextTask(tasks);
+    expect(result).toBeNull();
+  });
+
+  test("prefers critical path tasks", () => {
+    // A is critical (longer), B has slack
+    const tasks = [
+      createTask("A", { estimate: 60, priority: "low" }),
+      createTask("B", { estimate: 30, priority: "high" }),
+      createTask("C", { estimate: 30, deps: ["A", "B"] }),
+    ];
+    const result = suggestNextTask(tasks);
+
+    // A is on critical path, should be suggested first
+    expect(result!.id).toBe("A");
+  });
+
+  test("filters by context when specified", () => {
+    const tasks = [
+      createTask("A", { priority: "critical", contexts: ["office"] }),
+      createTask("B", { priority: "high", contexts: ["focus"] }),
+    ];
+    const result = suggestNextTask(tasks, { contexts: ["focus"] });
+
+    expect(result!.id).toBe("B");
+  });
+
+  test("filters by max time when specified", () => {
+    const tasks = [
+      createTask("A", { estimate: 120, priority: "critical" }),
+      createTask("B", { estimate: 30, priority: "high" }),
+    ];
+    const result = suggestNextTask(tasks, { maxMinutes: 60 });
+
+    expect(result!.id).toBe("B");
+  });
+
+  test("skips blocked tasks", () => {
+    const tasks = [
+      createTask("A", { priority: "low" }),
+      createTask("B", { priority: "critical", deps: ["A"] }),
+    ];
+    const result = suggestNextTask(tasks);
+
+    // B is blocked, so A should be suggested
+    expect(result!.id).toBe("A");
+  });
+
+  test("considers tasks with more dependents", () => {
+    const tasks = [
+      createTask("A", { priority: "medium" }),
+      createTask("B", { priority: "medium" }),
+      createTask("C", { priority: "medium", deps: ["A"] }),
+      createTask("D", { priority: "medium", deps: ["A"] }),
+    ];
+    const result = suggestNextTask(tasks);
+
+    // A blocks more tasks (C and D), should be preferred over B
+    expect(result!.id).toBe("A");
+  });
+});

package/src/algorithms/critical-path.ts

@@ -1,9 +1,5 @@
 import type { Task } from "../schemas/task.js";
-import {
-  topologicalSort,
-  findDependents,
-  priorityToNumber,
-} from "./topological-sort.js";
+import { topologicalSort, priorityToNumber } from "./topological-sort.js";
 
 /**
  * Task with computed CPM (Critical Path Method) values
@@ -43,9 +39,7 @@ function getTaskDuration(task: Task): number {
  * Get blocked_by dependencies for a task
  */
 function getBlockedByDeps(task: Task): string[] {
-  return (task.dependencies ?? [])
-    .filter((d) => d.type === "blocked_by")
-    .map((d) => d.taskId);
+  return (task.dependencies ?? []).filter((d) => d.type === "blocked_by").map((d) => d.taskId);
 }
 
 /**
@@ -110,7 +104,10 @@ function calculateProjectDuration(taskMap: Map<string, CPMTask>): number {
  * This is O(n * d) where d is average dependencies, done once upfront
  * Allows O(1) successor lookup instead of O(n) per task
  */
-function buildSuccessorIndex(sortedTasks: Task[], taskMap: Map<string, CPMTask>): Map<string, CPMTask[]> {
+function buildSuccessorIndex(
+  sortedTasks: Task[],
+  taskMap: Map<string, CPMTask>
+): Map<string, CPMTask[]> {
   const successorIndex = new Map<string, CPMTask[]>();
 
   // Initialize empty arrays for all tasks
@@ -244,9 +241,7 @@ function extractCriticalPath(sortedTasks: Task[], taskMap: Map<string, CPMTask>)
  * Find top bottlenecks (critical tasks blocking the most downstream work)
  */
 function findBottlenecks(criticalPath: CPMTask[], limit = 5): CPMTask[] {
-  return [...criticalPath]
-    .sort((a, b) => b.dependentCount - a.dependentCount)
-    .slice(0, limit);
+  return [...criticalPath].sort((a, b) => b.dependentCount - a.dependentCount).slice(0, limit);
 }
 
 /**
@@ -262,9 +257,7 @@ function findBottlenecks(criticalPath: CPMTask[], limit = 5): CPMTask[] {
  */
 export function criticalPathAnalysis(tasks: Task[]): CPMResult {
   // Filter to only pending/in_progress tasks
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) {
     return {
@@ -318,16 +311,12 @@ export function criticalPathAnalysis(tasks: Task[]): CPMResult {
  * Optimized to O(n + e) where n = number of tasks, e = number of dependencies
  */
 export function findParallelTasks(tasks: Task[]): Task[][] {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) return [];
 
   // Find tasks with no uncompleted dependencies
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   const available = activeTasks.filter((task) => {
     const deps = getBlockedByDeps(task);
@@ -376,9 +365,7 @@ export function findParallelTasks(tasks: Task[]): Task[][] {
       if (processed.has(other.id)) continue;
 
       // O(1) check: tasks are independent if neither depends on the other
-      const independent =
-        !conflicting.has(other.id) &&
-        !dependsOn.get(other.id)?.has(task.id);
+      const independent = !conflicting.has(other.id) && !dependsOn.get(other.id)?.has(task.id);
 
       if (independent) {
         group.push(other);
@@ -402,9 +389,7 @@ export function suggestNextTask(
     maxMinutes?: number;
   } = {}
 ): Task | null {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) return null;
 
@@ -412,9 +397,7 @@ export function suggestNextTask(
   const cpm = criticalPathAnalysis(tasks);
 
   // Filter by availability (all dependencies completed)
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   let candidates = cpm.tasks.filter((task) => {
     const deps = getBlockedByDeps(task);
@@ -434,9 +417,7 @@ export function suggestNextTask(
 
   // Filter by time if specified
   if (options.maxMinutes) {
-    const timeFiltered = candidates.filter(
-      (t) => getTaskDuration(t) <= options.maxMinutes!
-    );
+    const timeFiltered = candidates.filter((t) => getTaskDuration(t) <= options.maxMinutes!);
     if (timeFiltered.length > 0) {
       candidates = timeFiltered;
     }
@@ -459,4 +440,3 @@ export function suggestNextTask(
   scored.sort((a, b) => b.score - a.score);
   return scored[0]?.task ?? null;
 }
-

package/src/algorithms/dependency-integrity.test.ts

@@ -0,0 +1,335 @@
+import { describe, test, expect } from "bun:test";
+import {
+  DependencyErrorCode,
+  validateDependency,
+  findInvalidDependencies,
+  findSelfDependencies,
+  detectCircularDependencies,
+  checkDependencyIntegrity,
+} from "./dependency-integrity.js";
+import type { Task } from "../schemas/task.js";
+
+// Helper to create mock tasks
+function createTask(
+  id: string,
+  title: string = `Task ${id}`,
+  deps: Array<{ taskId: string; type: "blocked_by" | "blocks" | "related" }> = []
+): Task {
+  return {
+    id,
+    title,
+    status: "pending",
+    priority: "medium",
+    workspace: "test-workspace",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    dependencies: deps,
+  };
+}
+
+describe("validateDependency", () => {
+  test("returns valid for a valid dependency", () => {
+    const tasks = [createTask("A"), createTask("B")];
+    const result = validateDependency({
+      taskId: "B",
+      blockedBy: "A",
+      tasks,
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errorCode).toBeUndefined();
+  });
+
+  test("rejects self-dependency", () => {
+    const tasks = [createTask("A")];
+    const result = validateDependency({
+      taskId: "A",
+      blockedBy: "A",
+      tasks,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(DependencyErrorCode.SELF_DEPENDENCY);
+    expect(result.errorMessage).toContain("cannot depend on itself");
+    expect(result.suggestion).toBeDefined();
+  });
+
+  test("rejects when task not found", () => {
+    const tasks = [createTask("A")];
+    const result = validateDependency({
+      taskId: "B",
+      blockedBy: "A",
+      tasks,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(DependencyErrorCode.TASK_NOT_FOUND);
+    expect(result.errorMessage).toContain("Task not found");
+  });
+
+  test("rejects when blocker not found", () => {
+    const tasks = [createTask("A")];
+    const result = validateDependency({
+      taskId: "A",
+      blockedBy: "B",
+      tasks,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(DependencyErrorCode.BLOCKER_NOT_FOUND);
+    expect(result.errorMessage).toContain("Blocking task not found");
+  });
+
+  test("rejects duplicate dependency", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = validateDependency({
+      taskId: "B",
+      blockedBy: "A",
+      tasks,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(DependencyErrorCode.DUPLICATE_DEPENDENCY);
+    expect(result.errorMessage).toContain("already blocked by");
+  });
+
+  test("allows duplicate when checkDuplicates is false", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = validateDependency({
+      taskId: "B",
+      blockedBy: "A",
+      tasks,
+      checkDuplicates: false,
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  test("rejects circular dependency", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
+      createTask("B"),
+    ];
+    // B is blocking A, so A blocking B would create a cycle
+    const result = validateDependency({
+      taskId: "B",
+      blockedBy: "A",
+      tasks,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(DependencyErrorCode.CIRCULAR_DEPENDENCY);
+    expect(result.errorMessage).toContain("cycle");
+    expect(result.suggestion).toContain("depends on");
+  });
+
+  test("rejects indirect circular dependency", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
+      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
+      createTask("C"),
+    ];
+    // A <- B <- C, adding C <- A would create cycle
+    const result = validateDependency({
+      taskId: "C",
+      blockedBy: "A",
+      tasks,
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errorCode).toBe(DependencyErrorCode.CIRCULAR_DEPENDENCY);
+  });
+});
+
+describe("findInvalidDependencies", () => {
+  test("returns empty array when all dependencies are valid", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = findInvalidDependencies(tasks);
+    expect(result).toEqual([]);
+  });
+
+  test("finds orphaned dependency references", () => {
+    const tasks = [createTask("A", "Task A", [{ taskId: "non-existent", type: "blocked_by" }])];
+    const result = findInvalidDependencies(tasks);
+    expect(result.length).toBe(1);
+    expect(result[0]!.taskId).toBe("A");
+    expect(result[0]!.taskTitle).toBe("Task A");
+    expect(result[0]!.invalidDependencyId).toBe("non-existent");
+    expect(result[0]!.type).toBe("blocked_by");
+  });
+
+  test("finds multiple invalid references across tasks", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "deleted-1", type: "blocked_by" }]),
+      createTask("B", "Task B", [
+        { taskId: "A", type: "blocked_by" },
+        { taskId: "deleted-2", type: "blocks" },
+      ]),
+    ];
+    const result = findInvalidDependencies(tasks);
+    expect(result.length).toBe(2);
+    expect(result.map((r) => r.invalidDependencyId).sort()).toEqual(["deleted-1", "deleted-2"]);
+  });
+
+  test("returns empty array for tasks without dependencies", () => {
+    const tasks = [createTask("A"), createTask("B")];
+    const result = findInvalidDependencies(tasks);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("findSelfDependencies", () => {
+  test("returns empty array when no self-dependencies exist", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = findSelfDependencies(tasks);
+    expect(result).toEqual([]);
+  });
+
+  test("finds task with self-dependency", () => {
+    const tasks = [createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }])];
+    const result = findSelfDependencies(tasks);
+    expect(result).toEqual(["A"]);
+  });
+
+  test("finds multiple self-dependencies", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
+      createTask("B"),
+      createTask("C", "Task C", [{ taskId: "C", type: "blocks" }]),
+    ];
+    const result = findSelfDependencies(tasks);
+    expect(result.sort()).toEqual(["A", "C"]);
+  });
+});
+
+describe("detectCircularDependencies", () => {
+  test("returns empty array when no cycles exist", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]),
+    ];
+    const result = detectCircularDependencies(tasks);
+    expect(result).toEqual([]);
+  });
+
+  test("detects direct circular dependency (A -> B -> A)", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = detectCircularDependencies(tasks);
+    expect(result.length).toBe(1);
+    expect(result[0]!.sort()).toEqual(["A", "B"]);
+  });
+
+  test("detects longer cycle (A -> B -> C -> A)", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
+      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
+      createTask("C", "Task C", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = detectCircularDependencies(tasks);
+    expect(result.length).toBe(1);
+    expect(result[0]!.sort()).toEqual(["A", "B", "C"]);
+  });
+
+  test("ignores non-blocking dependency types for cycle detection", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "B", type: "related" }]),
+      createTask("B", "Task B", [{ taskId: "A", type: "related" }]),
+    ];
+    const result = detectCircularDependencies(tasks);
+    expect(result).toEqual([]);
+  });
+
+  test("handles tasks with missing dependency targets", () => {
+    const tasks = [createTask("A", "Task A", [{ taskId: "non-existent", type: "blocked_by" }])];
+    const result = detectCircularDependencies(tasks);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("checkDependencyIntegrity", () => {
+  test("returns valid for healthy task set", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]),
+    ];
+    const result = checkDependencyIntegrity(tasks);
+    expect(result.valid).toBe(true);
+    expect(result.totalTasks).toBe(3);
+    expect(result.totalDependencies).toBe(2);
+    expect(result.issues.selfDependencies).toEqual([]);
+    expect(result.issues.invalidReferences).toEqual([]);
+    expect(result.issues.circularDependencies).toEqual([]);
+    expect(result.summary).toContain("All 2 dependencies");
+    expect(result.summary).toContain("valid");
+  });
+
+  test("detects self-dependency issues", () => {
+    const tasks = [createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }])];
+    const result = checkDependencyIntegrity(tasks);
+    expect(result.valid).toBe(false);
+    expect(result.issues.selfDependencies).toEqual(["A"]);
+    expect(result.summary).toContain("self-dependencies");
+  });
+
+  test("detects invalid reference issues", () => {
+    const tasks = [createTask("A", "Task A", [{ taskId: "deleted", type: "blocked_by" }])];
+    const result = checkDependencyIntegrity(tasks);
+    expect(result.valid).toBe(false);
+    expect(result.issues.invalidReferences.length).toBe(1);
+    expect(result.summary).toContain("invalid references");
+  });
+
+  test("detects circular dependency issues", () => {
+    const tasks = [
+      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
+      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
+    ];
+    const result = checkDependencyIntegrity(tasks);
+    expect(result.valid).toBe(false);
+    expect(result.issues.circularDependencies.length).toBe(1);
+    expect(result.summary).toContain("circular dependency");
+  });
+
+  test("reports multiple issue types", () => {
+    const tasks = [
+      createTask("A", "Task A", [
+        { taskId: "A", type: "blocked_by" }, // self-dependency
+        { taskId: "deleted", type: "blocked_by" }, // invalid reference
+      ]),
+      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
+      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]), // circular
+    ];
+    const result = checkDependencyIntegrity(tasks);
+    expect(result.valid).toBe(false);
+    expect(result.issues.selfDependencies.length).toBeGreaterThan(0);
+    expect(result.issues.invalidReferences.length).toBeGreaterThan(0);
+    expect(result.issues.circularDependencies.length).toBeGreaterThan(0);
+    expect(result.summary).toContain("self-dependencies");
+    expect(result.summary).toContain("invalid references");
+    expect(result.summary).toContain("circular dependency");
+  });
+
+  test("handles empty task array", () => {
+    const result = checkDependencyIntegrity([]);
+    expect(result.valid).toBe(true);
+    expect(result.totalTasks).toBe(0);
+    expect(result.totalDependencies).toBe(0);
+  });
+
+  test("handles tasks with no dependencies", () => {
+    const tasks = [createTask("A"), createTask("B"), createTask("C")];
+    const result = checkDependencyIntegrity(tasks);
+    expect(result.valid).toBe(true);
+    expect(result.totalTasks).toBe(3);
+    expect(result.totalDependencies).toBe(0);
+  });
+});