@cliangdev/flux-plugin 0.3.1 → 0.4.0

package/src/server/adapters/github/__tests__/prd-crud.test.ts

@@ -0,0 +1,836 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+const TEST_DIR = `${realpathSync(tmpdir())}/flux-prd-crud-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+let mockIssuesCreate: any = null;
+let mockIssuesUpdate: any = null;
+let mockIssuesGet: any = null;
+let mockIssuesList: any[] = [];
+let mockSubIssues: Record<number, any[]> = {};
+let mockGetContent: any = null;
+let mockGraphqlFn: (
+  query: string,
+  variables?: Record<string, unknown>,
+) => Promise<unknown> = async () => ({});
+let lastCreateParams: any = null;
+let _lastUpdateParams: any = null;
+let lastUpdateByNumberParams: Record<number, any> = {};
+let lastPutParams: any = null;
+let issueNodeIdCounter = 0;
+
+mock.module("@octokit/rest", () => ({
+  Octokit: class MockOctokit {
+    repos = {
+      getContent: async (_params: any) => {
+        if (mockGetContent === null) {
+          const err: any = new Error("Not Found");
+          err.status = 404;
+          throw err;
+        }
+        return mockGetContent;
+      },
+      createOrUpdateFileContents: async (params: any) => {
+        lastPutParams = params;
+        return { data: { content: { sha: "new-sha" } } };
+      },
+    };
+
+    issues = {
+      create: async (params: any) => {
+        lastCreateParams = params;
+        return { data: mockIssuesCreate };
+      },
+      update: async (params: any) => {
+        const num = params.issue_number;
+        lastUpdateByNumberParams[num] = params;
+        _lastUpdateParams = params;
+        return { data: mockIssuesUpdate ?? mockIssuesCreate };
+      },
+      get: async (_params: any) => {
+        if (mockIssuesGet === null) {
+          const err: any = new Error("Not Found");
+          err.status = 404;
+          throw err;
+        }
+        return { data: mockIssuesGet };
+      },
+      listForRepo: async (_params: any) => {
+        return { data: mockIssuesList };
+      },
+    };
+  },
+}));
+
+mock.module("@octokit/graphql", () => ({
+  graphql: {
+    defaults: (_opts: any) => {
+      return async (query: string, variables?: Record<string, unknown>) => {
+        return mockGraphqlFn(query, variables);
+      };
+    },
+  },
+}));
+
+function makeIssue(
+  overrides: Partial<{
+    number: number;
+    id: number;
+    title: string;
+    body: string;
+    labels: string[];
+    state: "open" | "closed";
+    created_at: string;
+    updated_at: string;
+    node_id: string;
+  }> = {},
+) {
+  issueNodeIdCounter++;
+  const number = overrides.number ?? issueNodeIdCounter;
+  return {
+    number,
+    id: overrides.id ?? number * 1000,
+    title: overrides.title ?? "Test PRD",
+    body: overrides.body ?? "",
+    labels: (overrides.labels ?? ["flux:prd", "status:draft"]).map((name) => ({
+      name,
+    })),
+    state: overrides.state ?? "open",
+    created_at: overrides.created_at ?? "2026-01-01T00:00:00Z",
+    updated_at: overrides.updated_at ?? "2026-01-01T00:00:00Z",
+    node_id: overrides.node_id ?? `MDU6SXNzdWU${number}`,
+  };
+}
+
+function makeAdapter() {
+  const { GitHubAdapter } = require("../adapter.js");
+  const adapter = new GitHubAdapter({
+    token: "ghp_test",
+    owner: "test-owner",
+    repo: "test-repo",
+    projectId: "PVT_kwDO123",
+    refPrefix: "FP",
+  });
+
+  (adapter as any).client.rest.issues = {
+    create: async (params: any) => {
+      lastCreateParams = params;
+      return { data: mockIssuesCreate };
+    },
+    update: async (params: any) => {
+      const num = params.issue_number;
+      lastUpdateByNumberParams[num] = params;
+      _lastUpdateParams = params;
+      if (mockIssuesUpdate !== null) {
+        return { data: mockIssuesUpdate };
+      }
+      return { data: mockIssuesCreate };
+    },
+    get: async (_params: any) => {
+      if (mockIssuesGet === null) {
+        const err: any = new Error("Not Found");
+        err.status = 404;
+        throw err;
+      }
+      return { data: mockIssuesGet };
+    },
+    listForRepo: async (_params: any) => {
+      return { data: mockIssuesList };
+    },
+    listSubIssues: async (params: any) => {
+      const issueNum = params.issue_number;
+      return { data: mockSubIssues[issueNum] ?? [] };
+    },
+  };
+
+  (adapter as any).client.rest.repos = {
+    getContent: async (_params: any) => {
+      if (mockGetContent === null) {
+        const err: any = new Error("Not Found");
+        err.status = 404;
+        throw err;
+      }
+      return mockGetContent;
+    },
+    createOrUpdateFileContents: async (params: any) => {
+      lastPutParams = params;
+      return { data: { content: { sha: "new-sha" } } };
+    },
+  };
+
+  (adapter as any).client.rest.request = async (url: string, params: any) => {
+    if (url.includes("sub_issues") && url.startsWith("GET")) {
+      return { data: mockSubIssues[params.issue_number] ?? [] };
+    }
+    if (url.includes("sub_issues") && url.startsWith("POST")) {
+      return { data: {} };
+    }
+    throw new Error(`Unmocked request: ${url}`);
+  };
+
+  return adapter;
+}
+
+describe("flux-meta helpers", () => {
+  test("encodeMeta produces valid HTML comment with JSON on its own lines", async () => {
+    const { encodeMeta } = await import("../helpers/meta.js");
+    const result = encodeMeta({ ref: "FP-P1", tag: "feature" });
+    expect(result).toBe(`<!-- flux-meta\n{"ref":"FP-P1","tag":"feature"}\n-->`);
+    expect(result.startsWith("<!-- flux-meta\n")).toBe(true);
+    expect(result.endsWith("\n-->")).toBe(true);
+  });
+
+  test("decodeMeta parses back to original object", async () => {
+    const { encodeMeta, decodeMeta } = await import("../helpers/meta.js");
+    const original = { ref: "FP-P6", tag: "mvp", dependencies: ["FP-P1"] };
+    const encoded = encodeMeta(original);
+    const decoded = decodeMeta(encoded);
+    expect(decoded).toEqual(original);
+  });
+
+  test("decodeMeta returns null when no flux-meta block present", async () => {
+    const { decodeMeta } = await import("../helpers/meta.js");
+    const result = decodeMeta("Just a regular issue body with no meta block.");
+    expect(result).toBeNull();
+  });
+
+  test("decodeMeta returns null for invalid JSON in meta block", async () => {
+    const { decodeMeta } = await import("../helpers/meta.js");
+    const result = decodeMeta("<!-- flux-meta\n{invalid json}\n-->");
+    expect(result).toBeNull();
+  });
+
+  test("decodeMeta works when body has content before and after block", async () => {
+    const { encodeMeta, decodeMeta } = await import("../helpers/meta.js");
+    const meta = { ref: "FP-P2" };
+    const body = `Some description here\n\n${encodeMeta(meta)}\n\nMore content`;
+    const decoded = decodeMeta(body);
+    expect(decoded?.ref).toBe("FP-P2");
+  });
+});
+
+describe("prd status mappers", () => {
+  test("prdStatusToLabel returns correct label for each status", async () => {
+    const { prdStatusToLabel } = await import("../mappers/prd.js");
+    expect(prdStatusToLabel("DRAFT")).toBe("status:draft");
+    expect(prdStatusToLabel("PENDING_REVIEW")).toBe("status:pending-review");
+    expect(prdStatusToLabel("REVIEWED")).toBe("status:reviewed");
+    expect(prdStatusToLabel("APPROVED")).toBe("status:approved");
+    expect(prdStatusToLabel("BREAKDOWN_READY")).toBe("status:breakdown-ready");
+    expect(prdStatusToLabel("COMPLETED")).toBe("status:completed");
+    expect(prdStatusToLabel("ARCHIVED")).toBeNull();
+  });
+
+  test("labelToPrdStatus detects ARCHIVED from closed state", async () => {
+    const { labelToPrdStatus } = await import("../mappers/prd.js");
+    expect(labelToPrdStatus(["flux:prd", "status:draft"], true)).toBe(
+      "ARCHIVED",
+    );
+    expect(labelToPrdStatus(["flux:prd"], true)).toBe("ARCHIVED");
+  });
+
+  test("all non-ARCHIVED statuses round-trip through label encoding", async () => {
+    const { prdStatusToLabel, labelToPrdStatus } = await import(
+      "../mappers/prd.js"
+    );
+    const statuses = [
+      "DRAFT",
+      "PENDING_REVIEW",
+      "REVIEWED",
+      "APPROVED",
+      "BREAKDOWN_READY",
+      "COMPLETED",
+    ] as const;
+    for (const status of statuses) {
+      const label = prdStatusToLabel(status);
+      expect(label).not.toBeNull();
+      const result = labelToPrdStatus([label as string], false);
+      expect(result).toBe(status);
+    }
+  });
+
+  test("ARCHIVED round-trips via closed issue state", async () => {
+    const { labelToPrdStatus } = await import("../mappers/prd.js");
+    expect(labelToPrdStatus([], true)).toBe("ARCHIVED");
+  });
+
+  test("tag round-trips through label encoding", async () => {
+    const { tagToLabel, labelToTag } = await import("../mappers/prd.js");
+    const tag = "mvp";
+    const label = tagToLabel(tag);
+    expect(label).toBe("tag:mvp");
+    const recovered = labelToTag([label]);
+    expect(recovered).toBe(tag);
+  });
+
+  test("labelToTag returns undefined when no tag label", async () => {
+    const { labelToTag } = await import("../mappers/prd.js");
+    expect(labelToTag(["flux:prd", "status:draft"])).toBeUndefined();
+  });
+});
+
+describe("GitHubAdapter PRD CRUD", () => {
+  beforeEach(() => {
+    mockIssuesCreate = null;
+    mockIssuesUpdate = null;
+    mockIssuesGet = null;
+    mockIssuesList = [];
+    mockSubIssues = {};
+    mockGetContent = null;
+    lastCreateParams = null;
+    _lastUpdateParams = null;
+    lastUpdateByNumberParams = {};
+    lastPutParams = null;
+    issueNodeIdCounter = 0;
+    mockGraphqlFn = async () => ({
+      addProjectV2ItemById: { item: { id: "PVTI_123" } },
+    });
+  });
+
+  afterEach(() => {});
+
+  describe("createPrd", () => {
+    test("returns Prd with DRAFT status and correct folderPath", async () => {
+      const issue = makeIssue({
+        number: 42,
+        title: "My New PRD",
+        labels: ["flux:prd", "status:draft"],
+        body: '<!-- flux-meta\n{"ref":"FP-P42"}\n-->',
+        node_id: "MDU6SXNzdWU0Mg==",
+      });
+      mockIssuesCreate = issue;
+
+      const afterUpdate = {
+        ...issue,
+        body: '<!-- flux-meta\n{"ref":"FP-P42"}\n-->',
+        labels: issue.labels,
+      };
+      mockIssuesUpdate = afterUpdate;
+      mockIssuesGet = afterUpdate;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.createPrd({ title: "My New PRD" });
+
+      expect(prd.status).toBe("DRAFT");
+      expect(prd.ref).toBe("FP-P42");
+      expect(prd.folderPath).toBe("prds/fp-p42/");
+      expect(prd.title).toBe("My New PRD");
+    });
+
+    test("created issue has flux:prd and status:draft labels", async () => {
+      const issue = makeIssue({
+        number: 1,
+        labels: ["flux:prd", "status:draft"],
+        node_id: "NODE_1",
+      });
+      mockIssuesCreate = issue;
+      mockIssuesUpdate = issue;
+      mockIssuesGet = issue;
+
+      const adapter = makeAdapter();
+      await adapter.createPrd({ title: "Test PRD" });
+
+      expect(lastCreateParams.labels).toContain("flux:prd");
+      expect(lastCreateParams.labels).toContain("status:draft");
+    });
+
+    test("flux-meta block in issue body contains ref and tag", async () => {
+      const issue = makeIssue({
+        number: 5,
+        labels: ["flux:prd", "status:draft", "tag:mvp"],
+        body: '<!-- flux-meta\n{"ref":"FP-P5","tag":"mvp"}\n-->',
+        node_id: "NODE_5",
+      });
+      mockIssuesCreate = issue;
+      mockIssuesUpdate = issue;
+      mockIssuesGet = issue;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.createPrd({ title: "Tagged PRD", tag: "mvp" });
+
+      expect(lastCreateParams.labels).toContain("tag:mvp");
+      expect(prd.tag).toBe("mvp");
+    });
+
+    test("adds issue to Projects v2 board via graphql", async () => {
+      let capturedMutation: string | null = null;
+      let capturedVariables: Record<string, unknown> | undefined;
+
+      mockGraphqlFn = async (query, variables) => {
+        capturedMutation = query;
+        capturedVariables = variables;
+        return { addProjectV2ItemById: { item: { id: "PVTI_abc" } } };
+      };
+
+      const issue = makeIssue({
+        number: 10,
+        node_id: "NODE_10",
+        labels: ["flux:prd", "status:draft"],
+        body: '<!-- flux-meta\n{"ref":"FP-P10"}\n-->',
+      });
+      mockIssuesCreate = issue;
+      mockIssuesUpdate = issue;
+      mockIssuesGet = issue;
+
+      const adapter = makeAdapter();
+      await adapter.createPrd({ title: "Board PRD" });
+
+      expect(capturedMutation).not.toBeNull();
+      expect(String(capturedMutation)).toContain("addProjectV2ItemById");
+      expect(capturedVariables?.contentId).toBe("NODE_10");
+      expect(capturedVariables?.projectId).toBe("PVT_kwDO123");
+    });
+  });
+
+  describe("updatePrd", () => {
+    test("swaps old status label for new one without duplicating labels", async () => {
+      const existingIssue = makeIssue({
+        number: 3,
+        labels: ["flux:prd", "status:draft"],
+        body: '<!-- flux-meta\n{"ref":"FP-P3"}\n-->',
+      });
+
+      const updatedIssue = makeIssue({
+        number: 3,
+        labels: ["flux:prd", "status:approved"],
+        body: '<!-- flux-meta\n{"ref":"FP-P3"}\n-->',
+      });
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P3": 3 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+      mockIssuesGet = existingIssue;
+      mockIssuesUpdate = updatedIssue;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.updatePrd("FP-P3", { status: "APPROVED" });
+
+      expect(prd.status).toBe("APPROVED");
+      const updatedLabels: string[] = lastUpdateByNumberParams[3]?.labels ?? [];
+      expect(updatedLabels).toContain("status:approved");
+      expect(updatedLabels).not.toContain("status:draft");
+    });
+
+    test("updatePrd with new tag replaces old tag label", async () => {
+      const existingIssue = makeIssue({
+        number: 4,
+        labels: ["flux:prd", "status:draft", "tag:mvp"],
+        body: '<!-- flux-meta\n{"ref":"FP-P4","tag":"mvp"}\n-->',
+      });
+
+      const updatedIssue = makeIssue({
+        number: 4,
+        labels: ["flux:prd", "status:draft", "tag:v2"],
+        body: '<!-- flux-meta\n{"ref":"FP-P4","tag":"v2"}\n-->',
+      });
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P4": 4 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+      mockIssuesGet = existingIssue;
+      mockIssuesUpdate = updatedIssue;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.updatePrd("FP-P4", { tag: "v2" });
+
+      expect(prd.tag).toBe("v2");
+      const updatedLabels: string[] = lastUpdateByNumberParams[4]?.labels ?? [];
+      expect(updatedLabels).toContain("tag:v2");
+      expect(updatedLabels).not.toContain("tag:mvp");
+    });
+
+    test("updatePrd with ARCHIVED status closes the issue", async () => {
+      const existingIssue = makeIssue({
+        number: 7,
+        labels: ["flux:prd", "status:approved"],
+        body: '<!-- flux-meta\n{"ref":"FP-P7"}\n-->',
+      });
+
+      const closedIssue = {
+        ...makeIssue({
+          number: 7,
+          labels: ["flux:prd"],
+          body: '<!-- flux-meta\n{"ref":"FP-P7"}\n-->',
+          state: "closed",
+        }),
+      };
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P7": 7 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+      mockIssuesGet = existingIssue;
+      mockIssuesUpdate = closedIssue;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.updatePrd("FP-P7", { status: "ARCHIVED" });
+
+      expect(prd.status).toBe("ARCHIVED");
+      expect(lastUpdateByNumberParams[7]?.state).toBe("closed");
+    });
+  });
+
+  describe("getPrd", () => {
+    test("returns null for unknown ref", async () => {
+      mockGetContent = null;
+      mockIssuesList = [];
+
+      const adapter = makeAdapter();
+      const result = await adapter.getPrd("FP-P999");
+
+      expect(result).toBeNull();
+    });
+
+    test("returns correct Prd with status parsed from labels", async () => {
+      const issue = makeIssue({
+        number: 8,
+        title: "My PRD",
+        labels: ["flux:prd", "status:reviewed"],
+        body: '<!-- flux-meta\n{"ref":"FP-P8","tag":"feature"}\n-->',
+      });
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P8": 8 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+      mockIssuesGet = issue;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.getPrd("FP-P8");
+
+      expect(prd).not.toBeNull();
+      expect(prd?.ref).toBe("FP-P8");
+      expect(prd?.status).toBe("REVIEWED");
+      expect(prd?.tag).toBe("feature");
+      expect(prd?.title).toBe("My PRD");
+    });
+
+    test("returns Prd with correct folderPath derived from ref", async () => {
+      const issue = makeIssue({
+        number: 9,
+        title: "Folder PRD",
+        labels: ["flux:prd", "status:draft"],
+        body: '<!-- flux-meta\n{"ref":"FP-P9"}\n-->',
+      });
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P9": 9 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+      mockIssuesGet = issue;
+
+      const adapter = makeAdapter();
+      const prd = await adapter.getPrd("FP-P9");
+
+      expect(prd?.folderPath).toBe("prds/fp-p9/");
+    });
+  });
+
+  describe("listPrds", () => {
+    test("returns all PRDs when no filters", async () => {
+      const issues = [
+        makeIssue({
+          number: 11,
+          labels: ["flux:prd", "status:draft"],
+          body: '<!-- flux-meta\n{"ref":"FP-P11"}\n-->',
+        }),
+        makeIssue({
+          number: 12,
+          labels: ["flux:prd", "status:approved"],
+          body: '<!-- flux-meta\n{"ref":"FP-P12"}\n-->',
+        }),
+      ];
+      mockIssuesList = issues;
+
+      const adapter = makeAdapter();
+      const result = await adapter.listPrds();
+
+      expect(result.items.length).toBe(2);
+      expect(result.total).toBe(2);
+    });
+
+    test("listPrds with status filter returns only PRDs with matching status label", async () => {
+      const issues = [
+        makeIssue({
+          number: 13,
+          labels: ["flux:prd", "status:draft"],
+          body: '<!-- flux-meta\n{"ref":"FP-P13"}\n-->',
+        }),
+        makeIssue({
+          number: 14,
+          labels: ["flux:prd", "status:approved"],
+          body: '<!-- flux-meta\n{"ref":"FP-P14"}\n-->',
+        }),
+      ];
+      mockIssuesList = issues;
+
+      const adapter = makeAdapter();
+
+      let lastListParams: any;
+      (adapter as any).client.rest.issues.listForRepo = async (params: any) => {
+        lastListParams = params;
+        return { data: [issues[0]] };
+      };
+
+      const result = await adapter.listPrds({ status: "DRAFT" });
+
+      expect(lastListParams.labels).toContain("status:draft");
+      expect(result.items.length).toBe(1);
+      expect(result.items[0].status).toBe("DRAFT");
+    });
+
+    test("listPrds with tag filter returns only PRDs with matching tag label", async () => {
+      const issues = [
+        makeIssue({
+          number: 15,
+          labels: ["flux:prd", "status:draft", "tag:mvp"],
+          body: '<!-- flux-meta\n{"ref":"FP-P15","tag":"mvp"}\n-->',
+        }),
+      ];
+
+      const adapter = makeAdapter();
+
+      let lastListParams: any;
+      (adapter as any).client.rest.issues.listForRepo = async (params: any) => {
+        lastListParams = params;
+        return { data: issues };
+      };
+
+      const result = await adapter.listPrds({ tag: "mvp" });
+
+      expect(lastListParams.labels).toContain("tag:mvp");
+      expect(result.items.length).toBe(1);
+      expect(result.items[0].tag).toBe("mvp");
+    });
+
+    test("listPrds pagination: limit and offset return correct slice with correct total and has_more", async () => {
+      const issues = Array.from({ length: 5 }, (_, i) =>
+        makeIssue({
+          number: 20 + i,
+          labels: ["flux:prd", "status:draft"],
+          body: `<!-- flux-meta\n{"ref":"FP-P${20 + i}"}\n-->`,
+        }),
+      );
+      mockIssuesList = issues;
+
+      const adapter = makeAdapter();
+      const result = await adapter.listPrds({}, { limit: 2, offset: 1 });
+
+      expect(result.limit).toBe(2);
+      expect(result.offset).toBe(1);
+      expect(result.total).toBe(5);
+      expect(result.items.length).toBe(2);
+      expect(result.hasMore).toBe(true);
+    });
+  });
+
+  describe("deletePrd", () => {
+    test("deletePrd on unknown ref throws descriptive error", async () => {
+      mockGetContent = null;
+      mockIssuesList = [];
+
+      const adapter = makeAdapter();
+
+      await expect(adapter.deletePrd("FP-P999")).rejects.toThrow("FP-P999");
+    });
+
+    test("deletePrd closes PRD issue and all child epic and task issues", async () => {
+      const prdIssue = makeIssue({
+        number: 30,
+        labels: ["flux:prd", "status:approved"],
+        body: '<!-- flux-meta\n{"ref":"FP-P30"}\n-->',
+      });
+
+      const epicIssue = makeIssue({
+        number: 31,
+        labels: ["flux:epic"],
+        body: '<!-- flux-meta\n{"ref":"FP-E31","prd_ref":"FP-P30"}\n-->',
+      });
+
+      const taskIssue = makeIssue({
+        number: 32,
+        labels: ["flux:task"],
+        body: '<!-- flux-meta\n{"ref":"FP-T32","epic_ref":"FP-E31"}\n-->',
+      });
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P30": 30 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+
+      mockIssuesList = [epicIssue, taskIssue];
+
+      const closedIssues: number[] = [];
+
+      const adapter = makeAdapter();
+      (adapter as any).client.rest.issues.get = async (params: any) => {
+        const issueNum = params.issue_number;
+        if (issueNum === 30) return { data: prdIssue };
+        if (issueNum === 31) return { data: epicIssue };
+        if (issueNum === 32) return { data: taskIssue };
+        throw Object.assign(new Error("Not Found"), { status: 404 });
+      };
+      (adapter as any).client.rest.issues.update = async (params: any) => {
+        closedIssues.push(params.issue_number);
+        return { data: { ...prdIssue, state: "closed" } };
+      };
+
+      const result = await adapter.deletePrd("FP-P30");
+
+      expect(result.deleted).toBe("FP-P30");
+      expect(result.cascade.epics).toBe(1);
+      expect(result.cascade.tasks).toBe(1);
+      expect(closedIssues).toContain(30);
+      expect(closedIssues).toContain(31);
+      expect(closedIssues).toContain(32);
+    });
+
+    test("returns CascadeResult with correct epics, tasks counts", async () => {
+      const prdIssue = makeIssue({
+        number: 40,
+        labels: ["flux:prd", "status:draft"],
+        body: '<!-- flux-meta\n{"ref":"FP-P40"}\n-->',
+      });
+
+      const epicIssue1 = makeIssue({
+        number: 41,
+        labels: ["flux:epic"],
+        body: '<!-- flux-meta\n{"ref":"FP-E41","prd_ref":"FP-P40"}\n-->',
+      });
+      const epicIssue2 = makeIssue({
+        number: 42,
+        labels: ["flux:epic"],
+        body: '<!-- flux-meta\n{"ref":"FP-E42","prd_ref":"FP-P40"}\n-->',
+      });
+      const taskIssue1 = makeIssue({
+        number: 43,
+        labels: ["flux:task"],
+        body: '<!-- flux-meta\n{"ref":"FP-T43","epic_ref":"FP-E41"}\n-->',
+      });
+      const taskIssue2 = makeIssue({
+        number: 44,
+        labels: ["flux:task"],
+        body: '<!-- flux-meta\n{"ref":"FP-T44","epic_ref":"FP-E41"}\n-->',
+      });
+
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify({ "FP-P40": 40 })).toString(
+            "base64",
+          ),
+          encoding: "base64",
+        },
+      };
+
+      mockIssuesList = [epicIssue1, epicIssue2, taskIssue1, taskIssue2];
+
+      const adapter = makeAdapter();
+      (adapter as any).client.rest.issues.get = async (params: any) => {
+        const n = params.issue_number;
+        const map: Record<number, any> = {
+          40: prdIssue,
+          41: epicIssue1,
+          42: epicIssue2,
+          43: taskIssue1,
+          44: taskIssue2,
+        };
+        if (map[n]) return { data: map[n] };
+        throw Object.assign(new Error("Not Found"), { status: 404 });
+      };
+      (adapter as any).client.rest.issues.update = async (_params: any) => ({
+        data: { ...prdIssue, state: "closed" },
+      });
+
+      const result = await adapter.deletePrd("FP-P40");
+
+      expect(result.cascade.epics).toBe(2);
+      expect(result.cascade.tasks).toBe(2);
+      expect(result.cascade.criteria).toBe(0);
+      expect(result.cascade.dependencies).toBe(0);
+    });
+
+    test("all deleted refs removed from index", async () => {
+      const prdIssue = makeIssue({
+        number: 50,
+        labels: ["flux:prd"],
+        body: '<!-- flux-meta\n{"ref":"FP-P50"}\n-->',
+      });
+      const epicIssue = makeIssue({
+        number: 51,
+        labels: ["flux:epic"],
+        body: '<!-- flux-meta\n{"ref":"FP-E51","prd_ref":"FP-P50"}\n-->',
+      });
+      const taskIssue = makeIssue({
+        number: 52,
+        labels: ["flux:task"],
+        body: '<!-- flux-meta\n{"ref":"FP-T52","epic_ref":"FP-E51"}\n-->',
+      });
+
+      const indexData = { "FP-P50": 50, "FP-E51": 51, "FP-T52": 52 };
+      mockGetContent = {
+        data: {
+          sha: "sha1",
+          content: Buffer.from(JSON.stringify(indexData)).toString("base64"),
+          encoding: "base64",
+        },
+      };
+
+      mockSubIssues[50] = [epicIssue];
+      mockSubIssues[51] = [taskIssue];
+
+      const adapter = makeAdapter();
+      (adapter as any).client.rest.issues.get = async (params: any) => {
+        const n = params.issue_number;
+        if (n === 50) return { data: prdIssue };
+        if (n === 51) return { data: epicIssue };
+        if (n === 52) return { data: taskIssue };
+        throw Object.assign(new Error("Not Found"), { status: 404 });
+      };
+      (adapter as any).client.rest.issues.update = async (_params: any) => ({
+        data: { ...prdIssue, state: "closed" },
+      });
+
+      await adapter.deletePrd("FP-P50");
+
+      const written = JSON.parse(
+        Buffer.from(lastPutParams.content, "base64").toString("utf-8"),
+      );
+      expect(written["FP-P50"]).toBeUndefined();
+    });
+  });
+});