@reqord/web 0.1.0

package/src/__tests__/components/specification/tab-design.test.tsx

@@ -0,0 +1,42 @@
+// @vitest-environment jsdom
+import React from "react";
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import "@testing-library/jest-dom/vitest";
+import { TabDesign } from "../../../components/specification/tab-design";
+
+// Mock MarkdownRenderer to avoid react-markdown SSR issues
+vi.mock("../../../components/requirement/markdown-renderer", () => ({
+  MarkdownRenderer: ({ content }: { content: string }) => (
+    <div data-testid="markdown-renderer">{content}</div>
+  ),
+}));
+
+describe("TabDesign", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("renders markdown content when content is provided", () => {
+    render(<TabDesign content="# Design\n\nContent here" />);
+
+    const renderer = screen.getByTestId("markdown-renderer");
+    expect(renderer).toBeInTheDocument();
+    expect(renderer).toHaveTextContent("# Design");
+    expect(renderer).toHaveTextContent("Content here");
+  });
+
+  it("shows empty state message when content is null", () => {
+    render(<TabDesign content={null} />);
+
+    expect(screen.getByText("Design document not available")).toBeInTheDocument();
+    expect(screen.queryByTestId("markdown-renderer")).not.toBeInTheDocument();
+  });
+
+  it("renders empty content string as markdown", () => {
+    render(<TabDesign content="" />);
+
+    const renderer = screen.getByTestId("markdown-renderer");
+    expect(renderer).toBeInTheDocument();
+  });
+});

package/src/__tests__/components/specification/tab-history.test.tsx

@@ -0,0 +1,118 @@
+// @vitest-environment jsdom
+import React from "react";
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import "@testing-library/jest-dom/vitest";
+import type { VersionHistoryEntry } from "@reqord/shared";
+import { TabHistory } from "../../../components/specification/tab-history";
+
+describe("TabHistory", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  const mockHistory: VersionHistoryEntry[] = [
+    {
+      version: "2.1.0",
+      status: "approved",
+      changedAt: "2026-02-10T10:00:00Z",
+      summary: "Added new feature X",
+    },
+    {
+      version: "2.0.0",
+      status: "implemented",
+      changedAt: "2026-02-01T10:00:00Z",
+      summary: "Implemented core functionality",
+    },
+    {
+      version: "1.0.0",
+      status: "draft",
+      changedAt: "2026-01-15T10:00:00Z",
+      summary: "Initial draft specification",
+    },
+  ];
+
+  it("renders timeline with all version history entries", () => {
+    render(<TabHistory versionHistory={mockHistory} />);
+
+    expect(screen.getByText("2.1.0")).toBeInTheDocument();
+    expect(screen.getByText("2.0.0")).toBeInTheDocument();
+    expect(screen.getByText("1.0.0")).toBeInTheDocument();
+
+    expect(screen.getByText("Added new feature X")).toBeInTheDocument();
+    expect(screen.getByText("Implemented core functionality")).toBeInTheDocument();
+    expect(screen.getByText("Initial draft specification")).toBeInTheDocument();
+  });
+
+  it("shows empty state when versionHistory is empty array", () => {
+    render(<TabHistory versionHistory={[]} />);
+
+    expect(screen.getByText("No version history yet")).toBeInTheDocument();
+    expect(screen.queryByText("2.1.0")).not.toBeInTheDocument();
+  });
+
+  it("latest version (first entry) is highlighted with ring", () => {
+    const { container } = render(<TabHistory versionHistory={mockHistory} />);
+
+    const dots = container.querySelectorAll(".absolute.-left-\\[33px\\]");
+    expect(dots.length).toBeGreaterThan(0);
+
+    // First dot should have ring-2 and ring-blue-500
+    const firstDot = dots[0];
+    expect(firstDot.className).toContain("ring-2");
+    expect(firstDot.className).toContain("ring-blue-500");
+    expect(firstDot.className).toContain("bg-blue-500");
+  });
+
+  it("older versions have gray dots without ring", () => {
+    const { container } = render(<TabHistory versionHistory={mockHistory} />);
+
+    const dots = container.querySelectorAll(".absolute.-left-\\[33px\\]");
+
+    // Second and third dots should have bg-gray-400 and no ring
+    if (dots.length > 1) {
+      const secondDot = dots[1];
+      expect(secondDot.className).toContain("bg-gray-400");
+      expect(secondDot.className).not.toContain("ring-2");
+    }
+  });
+
+  it("renders timeline with left border", () => {
+    const { container } = render(<TabHistory versionHistory={mockHistory} />);
+
+    const timeline = container.querySelector(".border-l-2");
+    expect(timeline).toBeInTheDocument();
+  });
+
+  it("displays dates in localized format", () => {
+    const singleEntry: VersionHistoryEntry[] = [
+      {
+        version: "1.0.0",
+        status: "draft",
+        changedAt: "2026-02-10T10:00:00Z",
+        summary: "Initial version",
+      },
+    ];
+
+    render(<TabHistory versionHistory={singleEntry} />);
+
+    // Date should be rendered (format depends on locale, so just check it's there)
+    const dateElement = screen.getByText(/2026/);
+    expect(dateElement).toBeInTheDocument();
+  });
+
+  it("displays status badges for each entry", () => {
+    render(<TabHistory versionHistory={mockHistory} />);
+
+    expect(screen.getByText("Approved")).toBeInTheDocument();
+    expect(screen.getByText("Implemented")).toBeInTheDocument();
+    expect(screen.getByText("Draft")).toBeInTheDocument();
+  });
+
+  it("renders dots with correct size", () => {
+    const { container } = render(<TabHistory versionHistory={mockHistory} />);
+
+    const dots = container.querySelectorAll(".w-3.h-3");
+    expect(dots.length).toBe(mockHistory.length);
+  });
+});

package/src/__tests__/components/specification/tab-issues.test.tsx

@@ -0,0 +1,126 @@
+// @vitest-environment jsdom
+import React from "react";
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import "@testing-library/jest-dom/vitest";
+import type { IssueItem } from "../../../components/specification/tab-issues";
+import { TabIssues } from "../../../components/specification/tab-issues";
+
+describe("TabIssues", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  const mockIssues: IssueItem[] = [
+    {
+      number: 123,
+      title: "Implement user authentication",
+      url: "https://github.com/user/repo/issues/123",
+      priority: "P0",
+      status: "open",
+    },
+    {
+      number: 124,
+      title: "Add validation for form inputs",
+      url: "https://github.com/user/repo/issues/124",
+      priority: "P1",
+      status: "in_progress",
+    },
+    {
+      number: 125,
+      title: "Update documentation",
+      url: "https://github.com/user/repo/issues/125",
+      priority: "P2",
+      status: "closed",
+    },
+  ];
+
+  it("renders table with correct number of rows when issues are provided", () => {
+    render(<TabIssues issues={mockIssues} />);
+
+    // Check for table headers
+    expect(screen.getByText("#")).toBeInTheDocument();
+    expect(screen.getByText("Title")).toBeInTheDocument();
+    expect(screen.getByText("Priority")).toBeInTheDocument();
+    expect(screen.getByText("Status")).toBeInTheDocument();
+    expect(screen.getByText("Link")).toBeInTheDocument();
+
+    // Check for all issue titles
+    expect(screen.getByText("Implement user authentication")).toBeInTheDocument();
+    expect(screen.getByText("Add validation for form inputs")).toBeInTheDocument();
+    expect(screen.getByText("Update documentation")).toBeInTheDocument();
+  });
+
+  it("shows empty state when issues is null", () => {
+    render(<TabIssues issues={null} />);
+
+    expect(screen.getByText("No issues generated yet")).toBeInTheDocument();
+    expect(screen.queryByText("#")).not.toBeInTheDocument();
+  });
+
+  it("shows empty state when issues is empty array", () => {
+    render(<TabIssues issues={[]} />);
+
+    expect(screen.getByText("No issues generated yet")).toBeInTheDocument();
+    expect(screen.queryByText("#")).not.toBeInTheDocument();
+  });
+
+  it("each row has a GitHub URL link", () => {
+    render(<TabIssues issues={mockIssues} />);
+
+    const links = screen.getAllByText("View");
+    expect(links).toHaveLength(3);
+
+    expect(links[0]).toHaveAttribute("href", "https://github.com/user/repo/issues/123");
+    expect(links[0]).toHaveAttribute("target", "_blank");
+    expect(links[0]).toHaveAttribute("rel", "noopener noreferrer");
+  });
+
+  it("priority badges have correct colors", () => {
+    render(<TabIssues issues={mockIssues} />);
+
+    const p0Badge = screen.getByText("P0");
+    const p1Badge = screen.getByText("P1");
+    const p2Badge = screen.getByText("P2");
+
+    expect(p0Badge.className).toContain("bg-red-100");
+    expect(p0Badge.className).toContain("text-red-800");
+    expect(p1Badge.className).toContain("bg-orange-100");
+    expect(p1Badge.className).toContain("text-orange-800");
+    expect(p2Badge.className).toContain("bg-yellow-100");
+    expect(p2Badge.className).toContain("text-yellow-800");
+  });
+
+  it("status badges have correct colors", () => {
+    render(<TabIssues issues={mockIssues} />);
+
+    const openBadge = screen.getByText("open");
+    const inProgressBadge = screen.getByText("in_progress");
+    const closedBadge = screen.getByText("closed");
+
+    expect(openBadge.className).toContain("bg-gray-100");
+    expect(openBadge.className).toContain("text-gray-800");
+    expect(inProgressBadge.className).toContain("bg-blue-100");
+    expect(inProgressBadge.className).toContain("text-blue-800");
+    expect(closedBadge.className).toContain("bg-green-100");
+    expect(closedBadge.className).toContain("text-green-800");
+  });
+
+  it("renders P3 priority with gray color", () => {
+    const p3Issue: IssueItem[] = [
+      {
+        number: 126,
+        title: "Low priority task",
+        url: "https://github.com/user/repo/issues/126",
+        priority: "P3",
+        status: "open",
+      },
+    ];
+
+    render(<TabIssues issues={p3Issue} />);
+
+    const p3Badge = screen.getByText("P3");
+    expect(p3Badge.className).toContain("bg-gray-100");
+    expect(p3Badge.className).toContain("text-gray-800");
+  });
+});

package/src/__tests__/components/specification/tab-research.test.tsx

@@ -0,0 +1,42 @@
+// @vitest-environment jsdom
+import React from "react";
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import "@testing-library/jest-dom/vitest";
+import { TabResearch } from "../../../components/specification/tab-research";
+
+// Mock MarkdownRenderer to avoid react-markdown SSR issues
+vi.mock("../../../components/requirement/markdown-renderer", () => ({
+  MarkdownRenderer: ({ content }: { content: string }) => (
+    <div data-testid="markdown-renderer">{content}</div>
+  ),
+}));
+
+describe("TabResearch", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("renders markdown content when content is provided", () => {
+    render(<TabResearch content="# Research\n\nFindings" />);
+
+    const renderer = screen.getByTestId("markdown-renderer");
+    expect(renderer).toBeInTheDocument();
+    expect(renderer).toHaveTextContent("# Research");
+    expect(renderer).toHaveTextContent("Findings");
+  });
+
+  it("shows empty state message when content is null", () => {
+    render(<TabResearch content={null} />);
+
+    expect(screen.getByText("Research document not available")).toBeInTheDocument();
+    expect(screen.queryByTestId("markdown-renderer")).not.toBeInTheDocument();
+  });
+
+  it("renders empty content string as markdown", () => {
+    render(<TabResearch content="" />);
+
+    const renderer = screen.getByTestId("markdown-renderer");
+    expect(renderer).toBeInTheDocument();
+  });
+});

package/src/__tests__/lib/dashboard-data.test.ts

@@ -0,0 +1,334 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { Requirement, Specification, TaskEntry, FeedbackEntry } from "@reqord/shared";
+
+vi.mock("../../lib/data.js", () => ({
+  getAllRequirements: vi.fn(),
+}));
+
+vi.mock("../../lib/specification-data.js", () => ({
+  getAllSpecifications: vi.fn(),
+}));
+
+vi.mock("../../lib/tasks-data.js", () => ({
+  loadTasksYaml: vi.fn(),
+}));
+
+vi.mock("../../lib/feedback-data.js", () => ({
+  getAllFeedbacks: vi.fn().mockResolvedValue([]),
+}));
+
+const makeRequirement = (
+  id: string,
+  status: string,
+  overrides: Partial<Requirement> = {},
+): Requirement => ({
+  id,
+  title: `Req ${id}`,
+  status: status as Requirement["status"],
+  priority: "high",
+  createdAt: "2026-01-01T00:00:00Z",
+  updatedAt: "2026-01-01T00:00:00Z",
+  version: "1.0.0",
+  versionHistory: [],
+  files: {
+    description: `requirements/${id}/description.md`,
+    supplementary: [],
+  },
+  successCriteria: [],
+  format: { type: "free-form" },
+  dependencies: { blockedBy: [], blocks: [], relatedTo: [] },
+  ...overrides,
+});
+
+const makeSpecification = (
+  id: string,
+  requirementId: string,
+  status: string,
+  overrides: Partial<Specification> = {},
+): Specification => ({
+  id,
+  requirementId,
+  status: status as Specification["status"],
+  version: "1.0.0",
+  createdAt: "2026-01-01T00:00:00Z",
+  updatedAt: "2026-01-01T00:00:00Z",
+  versionHistory: [],
+  files: {
+    design: `specifications/${id}/design.md`,
+    supplementary: [],
+  },
+  ...overrides,
+});
+
+const makeTaskEntry = (
+  number: number,
+  status: "open" | "closed",
+  specIds: string[] = [],
+  estimatedHours = 4,
+): TaskEntry => ({
+  number,
+  title: `Issue ${number}`,
+  url: `https://github.com/owner/repo/issues/${number}`,
+  linkedTo: { specifications: specIds },
+  priority: "P1",
+  status,
+  estimatedHours,
+  syncedAt: "2026-01-01T00:00:00Z",
+});
+
+describe("dashboard-data", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  describe("getDashboardData", () => {
+    it("aggregates requirements, specifications, and issues from tasks.yaml correctly", async () => {
+      const { getAllRequirements } = await import("../../lib/data.js");
+      const { getAllSpecifications } = await import("../../lib/specification-data.js");
+      const { loadTasksYaml } = await import("../../lib/tasks-data.js");
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      const { getDashboardData } = await import("../../lib/dashboard-data.js");
+
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      vi.mocked(getAllRequirements).mockResolvedValue([
+        makeRequirement("req-000001", "approved"),
+        makeRequirement("req-000002", "implemented"),
+        makeRequirement("req-000003", "draft"),
+      ]);
+      vi.mocked(getAllSpecifications).mockResolvedValue([
+        makeSpecification("spec-000001", "req-000001", "approved"),
+        makeSpecification("spec-000002", "req-000002", "draft"),
+      ]);
+      vi.mocked(loadTasksYaml).mockResolvedValue({
+        title: "Tasks",
+        tasks: [
+          makeTaskEntry(1, "closed", ["spec-000001"]),
+          makeTaskEntry(2, "open", ["spec-000001"]),
+        ],
+      });
+
+      const result = await getDashboardData();
+
+      expect(result.requirements.total).toBe(3);
+      expect(result.requirements.breakdown).toEqual({ approved: 1, implemented: 1, draft: 1 });
+      expect(result.requirements.approvalRate).toBeCloseTo(0.6667, 3);
+      expect(result.specifications.total).toBe(2);
+      expect(result.specifications.breakdown).toEqual({ approved: 1, draft: 1 });
+      expect(result.specifications.approvalRate).toBe(0.5);
+      expect(result.issues.total).toBe(2);
+      expect(result.issues.completed).toBe(1);
+      expect(result.issues.completionRate).toBe(0.5);
+    });
+
+    it("handles zero requirements correctly", async () => {
+      const { getAllRequirements } = await import("../../lib/data.js");
+      const { getAllSpecifications } = await import("../../lib/specification-data.js");
+      const { loadTasksYaml } = await import("../../lib/tasks-data.js");
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      const { getDashboardData } = await import("../../lib/dashboard-data.js");
+
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      vi.mocked(getAllRequirements).mockResolvedValue([]);
+      vi.mocked(getAllSpecifications).mockResolvedValue([]);
+      vi.mocked(loadTasksYaml).mockResolvedValue({ title: "Tasks", tasks: [] });
+
+      const result = await getDashboardData();
+
+      expect(result.requirements.total).toBe(0);
+      expect(result.requirements.approvalRate).toBe(0);
+      expect(result.specifications.total).toBe(0);
+      expect(result.specifications.approvalRate).toBe(0);
+      expect(result.issues.total).toBe(0);
+      expect(result.issues.completionRate).toBe(0);
+    });
+
+    it("handles tasks.yaml with no tasks (empty tasks array)", async () => {
+      const { getAllRequirements } = await import("../../lib/data.js");
+      const { getAllSpecifications } = await import("../../lib/specification-data.js");
+      const { loadTasksYaml } = await import("../../lib/tasks-data.js");
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      const { getDashboardData } = await import("../../lib/dashboard-data.js");
+
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      vi.mocked(getAllRequirements).mockResolvedValue([makeRequirement("req-000001", "approved")]);
+      vi.mocked(getAllSpecifications).mockResolvedValue([makeSpecification("spec-000001", "req-000001", "approved")]);
+      vi.mocked(loadTasksYaml).mockResolvedValue({ title: "Tasks", tasks: [] });
+
+      const result = await getDashboardData();
+
+      expect(result.issues.total).toBe(0);
+      expect(result.issues.completed).toBe(0);
+      expect(result.issues.completionRate).toBe(0);
+    });
+
+    it("calculates health score correctly", async () => {
+      const { getAllRequirements } = await import("../../lib/data.js");
+      const { getAllSpecifications } = await import("../../lib/specification-data.js");
+      const { loadTasksYaml } = await import("../../lib/tasks-data.js");
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      const { getDashboardData } = await import("../../lib/dashboard-data.js");
+
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      vi.mocked(getAllRequirements).mockResolvedValue([makeRequirement("req-000001", "approved")]);
+      vi.mocked(getAllSpecifications).mockResolvedValue([
+        makeSpecification("spec-000001", "req-000001", "approved"),
+        makeSpecification("spec-000002", "req-000001", "draft"),
+      ]);
+      vi.mocked(loadTasksYaml).mockResolvedValue({
+        title: "Tasks",
+        tasks: [
+          makeTaskEntry(1, "open", ["spec-000001"]),
+          makeTaskEntry(2, "open", ["spec-000001"]),
+        ],
+      });
+
+      const result = await getDashboardData();
+
+      // Health = 1.0 * 40 + 0.5 * 30 + 0.0 * 30 = 55
+      expect(result.healthScore).toBe(55);
+    });
+  });
+
+  describe("detectWarnings", () => {
+    it("detects missing specification warnings", async () => {
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      const { detectWarnings } = await import("../../lib/dashboard-data.js");
+      const warnings = await detectWarnings([makeRequirement("req-000001", "approved")], []);
+      expect(warnings).toHaveLength(1);
+      expect(warnings[0]).toEqual({
+        type: "missing_specification",
+        message: "Requirement req-000001 has no specification",
+        severity: "warning",
+        relatedId: "req-000001",
+      });
+    });
+
+    it("does not warn for draft requirements without specifications", async () => {
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      const { detectWarnings } = await import("../../lib/dashboard-data.js");
+      const warnings = await detectWarnings([makeRequirement("req-000001", "draft")], []);
+      expect(warnings).toHaveLength(0);
+    });
+
+    it("detects unapproved dependency warnings", async () => {
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      const { detectWarnings } = await import("../../lib/dashboard-data.js");
+      const warnings = await detectWarnings(
+        [
+          makeRequirement("req-000001", "draft"),
+          makeRequirement("req-000002", "approved", {
+            dependencies: { blockedBy: ["req-000001"], blocks: [], relatedTo: [] },
+          }),
+        ],
+        [makeSpecification("spec-000002", "req-000002", "approved")]
+      );
+      expect(warnings).toHaveLength(1);
+      expect(warnings[0]).toEqual({
+        type: "unapproved_dependency",
+        message: "Requirement req-000002 is blocked by unapproved requirement req-000001",
+        severity: "warning",
+        relatedId: "req-000002",
+      });
+    });
+
+    it("detects design verification error warnings from critical unresolved feedback", async () => {
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      const criticalFeedback: FeedbackEntry = {
+        githubIssue: 123,
+        type: "bug",
+        severity: "critical",
+        linkedTo: {
+          requirements: [],
+          createdRequirements: [],
+          specifications: ["spec-000001"],
+          createdSpecifications: [],
+        },
+        syncedAt: "2026-01-02T00:00:00Z",
+        status: "open",
+      };
+      vi.mocked(getAllFeedbacks).mockResolvedValue([criticalFeedback]);
+      const { detectWarnings } = await import("../../lib/dashboard-data.js");
+      const warnings = await detectWarnings(
+        [],
+        [makeSpecification("spec-000001", "req-000001", "draft")]
+      );
+      expect(warnings).toHaveLength(1);
+      expect(warnings[0]).toEqual({
+        type: "design_verification_error",
+        message: "Specification spec-000001 has critical/high unresolved feedback requiring attention",
+        severity: "error",
+        relatedId: "spec-000001",
+      });
+    });
+
+    it("returns empty array when no warnings detected", async () => {
+      const { getAllFeedbacks } = await import("../../lib/feedback-data.js");
+      vi.mocked(getAllFeedbacks).mockResolvedValue([]);
+      const { detectWarnings } = await import("../../lib/dashboard-data.js");
+      const warnings = await detectWarnings(
+        [makeRequirement("req-000001", "approved")],
+        [makeSpecification("spec-000001", "req-000001", "approved")]
+      );
+      expect(warnings).toEqual([]);
+    });
+  });
+
+  describe("groupByStatus", () => {
+    it("counts items by status correctly", async () => {
+      const { groupByStatus } = await import("../../lib/dashboard-data.js");
+      const result = groupByStatus([
+        { status: "draft" }, { status: "approved" }, { status: "draft" },
+        { status: "implemented" }, { status: "approved" }, { status: "approved" },
+      ]);
+      expect(result).toEqual({ draft: 2, approved: 3, implemented: 1 });
+    });
+
+    it("returns empty object for empty array", async () => {
+      const { groupByStatus } = await import("../../lib/dashboard-data.js");
+      expect(groupByStatus([])).toEqual({});
+    });
+  });
+
+  describe("extractCriticalPath", () => {
+    it("extracts tasks from tasks.yaml entries", async () => {
+      const { extractCriticalPath } = await import("../../lib/dashboard-data.js");
+      const tasks: TaskEntry[] = [
+        makeTaskEntry(1, "open", ["spec-000001"], 10),
+        makeTaskEntry(2, "closed", ["spec-000001"], 10),
+        makeTaskEntry(3, "open", ["spec-000002"], 5),
+      ];
+      const result = extractCriticalPath(tasks);
+      expect(result).toHaveLength(3);
+      expect(result![0]).toEqual({
+        issueNumber: 1, title: "Issue 1",
+        url: "https://github.com/owner/repo/issues/1",
+        priority: "P1", status: "open", estimatedHours: 10, specId: "spec-000001",
+      });
+      expect(result![1]).toEqual({
+        issueNumber: 2, title: "Issue 2",
+        url: "https://github.com/owner/repo/issues/2",
+        priority: "P1", status: "closed", estimatedHours: 10, specId: "spec-000001",
+      });
+      expect(result![2]).toEqual({
+        issueNumber: 3, title: "Issue 3",
+        url: "https://github.com/owner/repo/issues/3",
+        priority: "P1", status: "open", estimatedHours: 5, specId: "spec-000002",
+      });
+    });
+
+    it("uses empty string for specId when task has no linked specifications", async () => {
+      const { extractCriticalPath } = await import("../../lib/dashboard-data.js");
+      const result = extractCriticalPath([makeTaskEntry(1, "open", [], 4)]);
+      expect(result).toHaveLength(1);
+      expect(result![0].specId).toBe("");
+    });
+
+    it("returns null when no tasks exist", async () => {
+      const { extractCriticalPath } = await import("../../lib/dashboard-data.js");
+      expect(extractCriticalPath([])).toBeNull();
+    });
+  });
+});