fix: folder-scoped case selection, bulk-edit issue unlink + version snapshots, and sync-button clarity (#453)

* fix(repository): scope test-case selection to the current folder view

Repository case selection lived in a single global list that was never
cleared on folder navigation, so a bulk action could silently span cases
in folders the user had navigated away from -- and inconsistently between
Select All and manual picks.

Clear the bulk-edit selection when the folder/view/filter changes.
Selection still persists across pagination and sorting within a view, and
run-mode (test-run building) selection is parent-owned and left untouched.

Adds unit coverage (clear-on-folder-switch, keep-on-paginate,
clear-on-filter-change, preserve-in-selection-mode) plus an E2E spec that
reproduces the Select-All cross-folder scenario through the TreeView.

* fix(test-cases): remove issue links cleared during bulk edit

Bulk Edit only ever computed an issues `connect` set and skipped the
update entirely when the new selection was empty, so clearing or
removing linked issues left them attached. Mirror the tags branch:
compute both connect and disconnect and apply whichever changed.

* fix(test-cases): snapshot post-update relations in bulk-edit versions

The bulk-edit version snapshot passed tags/issues/steps/stateName
overrides built from the pre-update case, so a new version recorded the
old relations and state name after a bulk change. Drop those overrides
and let the version service read the freshly-updated row inside the same
transaction.

* fix(integrations): clarify that sync re-syncs only linked issues

The integration sync button read "Sync all issues from issue
integration", but it only refreshes issues already linked into
TestPlanIt. Relabel it "Re-sync linked issues", add a tooltip hint
explaining new issues aren't imported, and document the behavior so it
isn't mistaken for importing every external issue.

* style: apply prettier formatting to bulk-edit and folder-selection tests

Run the three test/spec files through Prettier so `pnpm format:check`
(part of the precommit gate) passes.

Author: therealbrad

docs/docs/user-guide/integrations.md

@@ -433,6 +433,14 @@ To delete:
 2. Click **Delete** and confirm
 3. Linked issues remain in the database but become unlinked
 
+### Re-syncing Linked Issues
+
+Each integration row exposes a **Re-sync linked issues** action (the refresh icon). It queues a background job that refreshes every issue **already linked into TestPlanIt** for that integration — pulling the latest status, priority, title, and description from the external tracker. A toast confirms the job was queued; the Issues table updates automatically when it finishes.
+
+:::info
+This action **re-syncs issues that already exist in TestPlanIt — it does not import new issues from the external tracker.** Issues enter TestPlanIt when you link them (see [Manual Linking](#manual-linking)) or when an [inbound webhook](#real-time-updates-via-inbound-webhooks) references them for the first time; a re-sync only refreshes that existing set. The action is unavailable for **Simple URL** integrations, which have no upstream API to pull from.
+:::
+
 ## Project Configuration
 
 After creating an integration, assign it to projects:

testplanit/app/[locale]/admin/integrations/SyncIntegrationButton.tsx

@@ -81,6 +81,9 @@ export function SyncIntegrationButton({
       </TooltipTrigger>
       <TooltipContent>
         <p>{t("syncIntegration")}</p>
+        <p className="mt-1 max-w-xs text-xs text-muted-foreground">
+          {t("syncIntegrationHint")}
+        </p>
       </TooltipContent>
     </Tooltip>
   );

testplanit/app/[locale]/projects/repository/[projectId]/BulkEditModal.test.tsx

@@ -173,6 +173,25 @@ vi.mock("~/lib/hooks/project-llm-integration", () => ({
   }),
 }));
 
+// Stub the issue picker so tests can deterministically drive issue selection
+// without rendering the real UnifiedIssueManager (network + provider heavy).
+vi.mock("@/components/issues/UnifiedIssueManager", () => ({
+  UnifiedIssueManager: ({ linkedIssueIds, setLinkedIssueIds }: any) => (
+    <div data-testid="mock-issue-manager">
+      <span data-testid="linked-issue-ids">
+        {(linkedIssueIds ?? []).join(",")}
+      </span>
+      <button
+        type="button"
+        data-testid="clear-issues"
+        onClick={() => setLinkedIssueIds([])}
+      >
+        clear issues
+      </button>
+    </div>
+  ),
+}));
+
 // Now import everything else after the mocks
 import {
   DateFormat,
@@ -1732,6 +1751,128 @@ describe("BulkEditModal", () => {
       );
     });
 
+    it("disconnects issues that are removed during bulk edit", async () => {
+      // Reproduce the reported bug: two cases linked to the same issue, then
+      // the issue is cleared in bulk edit. The payload must request a
+      // disconnect — previously it only ever sent connect, so links survived.
+      const casesSharingIssue = mockCasesWithTextFields.map((c) => ({
+        ...c,
+        issues: [mockIssuesData[0]],
+      }));
+
+      global.fetch = vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
+        const url =
+          typeof input === "string"
+            ? input
+            : input instanceof URL
+              ? input.toString()
+              : input.url;
+
+        if (
+          url.includes("/api/projects/") &&
+          (url.includes("/cases/fetch-many") ||
+            url.includes("/cases/bulk-edit-fetch"))
+        ) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({ cases: casesSharingIssue }),
+            status: 200,
+            statusText: "OK",
+            headers: new Headers(),
+          } as Response);
+        }
+
+        if (
+          url.includes("/api/projects/") &&
+          url.includes("/cases/bulk-edit") &&
+          !url.includes("bulk-edit-fetch") &&
+          init?.method === "POST"
+        ) {
+          const payload = init.body ? JSON.parse(init.body as string) : {};
+          bulkEditCalls.push({ url, payload });
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({
+              success: true,
+              updatedCount: payload.caseIds?.length || 0,
+            }),
+            status: 200,
+            statusText: "OK",
+            headers: new Headers(),
+          } as Response);
+        }
+
+        return Promise.resolve({
+          ok: true,
+          json: async () => ({}),
+          status: 200,
+          statusText: "OK",
+          headers: new Headers(),
+        } as Response);
+      }) as any;
+
+      render(
+        <BulkEditModal
+          isOpen={true}
+          onClose={vi.fn()}
+          onSaveSuccess={vi.fn()}
+          selectedCaseIds={[1, 2]}
+          projectId={1}
+        />
+      );
+
+      // Wait for loading spinner to disappear
+      await waitFor(() => {
+        const spinner = document.querySelector(".animate-spin");
+        expect(spinner).not.toBeInTheDocument();
+      });
+
+      // Enable editing for the issues field
+      const issuesCheckbox = document.getElementById(
+        "edit-issues"
+      ) as HTMLInputElement;
+      await act(async () => {
+        fireEvent.click(issuesCheckbox);
+      });
+
+      await waitFor(() => {
+        expect(issuesCheckbox).toBeChecked();
+      });
+
+      // Both cases share issue id 1, so editing starts with it selected
+      await waitFor(() => {
+        expect(screen.getByTestId("linked-issue-ids")).toHaveTextContent("1");
+      });
+
+      // Remove all linked issues
+      await act(async () => {
+        fireEvent.click(screen.getByTestId("clear-issues"));
+      });
+
+      const saveButton = screen.getByRole("button", {
+        name: "[t]common.actions.save",
+      });
+      await waitFor(() => {
+        expect(saveButton).not.toBeDisabled();
+      });
+      await act(async () => {
+        fireEvent.click(saveButton);
+      });
+
+      await waitFor(
+        () => {
+          expect(bulkEditCalls.length).toBe(1);
+          const { payload } = bulkEditCalls[0];
+          expect(payload.caseIds).toEqual([1, 2]);
+          // The fix: removed issues are disconnected, not silently dropped
+          expect(payload.updates.issues).toEqual({
+            disconnect: [{ id: 1 }],
+          });
+        },
+        { timeout: 10000 }
+      );
+    });
+
     it("should handle bulk delete", async () => {
       const user = userEvent.setup();
       const onSaveSuccess = vi.fn();

testplanit/app/[locale]/projects/repository/[projectId]/BulkEditModal.tsx

@@ -1462,7 +1462,7 @@ export function BulkEditModal({
             }
           }
         } else if (fieldKey === "issues") {
-          // Similar logic to tags
+          // Get all unique issue IDs from all cases
           const allCurrentIssueIds = new Set<number>();
           casesData.forEach((c) => {
             (c.issues || []).forEach((i) => allCurrentIssueIds.add(i.id));
@@ -1472,14 +1472,25 @@ export function BulkEditModal({
             ? newValue.map(Number)
             : [];
 
+          // Connect new issues that aren't currently on any case
           const issuesToConnect = newIssueIds
             .filter((id) => !allCurrentIssueIds.has(id))
             .map((id) => ({ id }));
 
-          if (newIssueIds.length > 0) {
-            payload.updates.issues = {
-              connect: issuesToConnect.length > 0 ? issuesToConnect : [],
-            };
+          // Disconnect issues that were removed (were on cases but not in new selection)
+          const issuesToDisconnect = Array.from(allCurrentIssueIds)
+            .filter((id) => !newIssueIds.includes(id))
+            .map((id) => ({ id }));
+
+          // Only update issues if there are actual changes
+          if (issuesToConnect.length > 0 || issuesToDisconnect.length > 0) {
+            payload.updates.issues = {};
+            if (issuesToConnect.length > 0) {
+              payload.updates.issues.connect = issuesToConnect;
+            }
+            if (issuesToDisconnect.length > 0) {
+              payload.updates.issues.disconnect = issuesToDisconnect;
+            }
           }
         }
       }

testplanit/app/[locale]/projects/repository/[projectId]/Cases.test.tsx

@@ -291,7 +291,8 @@ vi.mock("./columns", () => ({
 }));
 
 // ---- Imports ----
-import { render, screen, waitFor } from "@testing-library/react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { DataTable } from "@/components/tables/DataTable";
 import React from "react";
 import * as NextAuth from "next-auth/react";
 import { useFindManyRepositoryCasesByDescendants } from "~/hooks/useRepositoryCasesByDescendants";
@@ -701,4 +702,156 @@ describe("Cases component", () => {
     expect(dataTable).toBeInTheDocument();
     expect(dataTable.getAttribute("data-count")).toBe("1");
   });
+
+  // The default DataTable stub does not render interactive rows. Swap in a stub
+  // that exposes a button to drive the table's row-selection callback, so a test
+  // can simulate selecting the first visible case. Returns a restore function;
+  // afterEach's clearAllMocks does not reset implementations, so callers must
+  // restore to avoid leaking the stub into later tests.
+  function installSelectableDataTable() {
+    const dataTableMock = vi.mocked(DataTable);
+    const originalImpl = dataTableMock.getMockImplementation();
+    dataTableMock.mockImplementation(({ onRowSelectionChange }: any) => (
+      <button
+        data-testid="simulate-select-first-row"
+        onClick={() => onRowSelectionChange?.(() => ({ "0": true }))}
+      >
+        select first row
+      </button>
+    ));
+    return () => dataTableMock.mockImplementation(originalImpl!);
+  }
+
+  it("clears the bulk-edit selection when switching folders", async () => {
+    const restoreDataTable = installSelectableDataTable();
+    try {
+      setupMocks({ data: [{ ...mockCase, id: 101, folderId: 1 }] });
+
+      const { rerender } = render(
+        <Cases {...defaultProps} viewType="folders" folderId={1} />
+      );
+
+      // Selecting a case in folder 1 surfaces the bulk-edit action.
+      fireEvent.click(await screen.findByTestId("simulate-select-first-row"));
+      expect(await screen.findByTestId("bulk-edit-button")).toBeInTheDocument();
+
+      // Navigating to a different folder must clear the selection so a bulk
+      // action can't silently span cases the user can no longer see.
+      setupMocks({ data: [{ ...mockCase, id: 202, folderId: 2 }] });
+      rerender(<Cases {...defaultProps} viewType="folders" folderId={2} />);
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId("bulk-edit-button")
+        ).not.toBeInTheDocument();
+      });
+    } finally {
+      restoreDataTable();
+    }
+  });
+
+  it("keeps the bulk-edit selection when paginating within the same folder", async () => {
+    const restoreDataTable = installSelectableDataTable();
+    try {
+      setupMocks({ data: [{ ...mockCase, id: 101, folderId: 1 }] });
+
+      const { rerender } = render(
+        <Cases {...defaultProps} viewType="folders" folderId={1} />
+      );
+
+      fireEvent.click(await screen.findByTestId("simulate-select-first-row"));
+      expect(await screen.findByTestId("bulk-edit-button")).toBeInTheDocument();
+
+      // Changing pages within the same folder must NOT clear the selection —
+      // the cross-page merge logic depends on it persisting across pages.
+      setupMocks({
+        data: [{ ...mockCase, id: 101, folderId: 1 }],
+        paginationOverrides: { currentPage: 2 },
+      });
+      rerender(<Cases {...defaultProps} viewType="folders" folderId={1} />);
+
+      // Give effects a chance to (incorrectly) clear before asserting it stayed.
+      await waitFor(() => {
+        expect(screen.getByTestId("bulk-edit-button")).toBeInTheDocument();
+      });
+    } finally {
+      restoreDataTable();
+    }
+  });
+
+  it("clears the bulk-edit selection when the filter changes", async () => {
+    const restoreDataTable = installSelectableDataTable();
+    try {
+      setupMocks({ data: [{ ...mockCase, id: 101, folderId: 1 }] });
+
+      const { rerender } = render(
+        <Cases
+          {...defaultProps}
+          viewType="folders"
+          folderId={1}
+          filterId={null}
+        />
+      );
+
+      fireEvent.click(await screen.findByTestId("simulate-select-first-row"));
+      expect(await screen.findByTestId("bulk-edit-button")).toBeInTheDocument();
+
+      // Changing the filter swaps which cases are visible, so the selection is
+      // scoped out the same way a folder switch is.
+      setupMocks({ data: [{ ...mockCase, id: 202, folderId: 1 }] });
+      rerender(
+        <Cases
+          {...defaultProps}
+          viewType="folders"
+          folderId={1}
+          filterId={[7]}
+        />
+      );
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId("bulk-edit-button")
+        ).not.toBeInTheDocument();
+      });
+    } finally {
+      restoreDataTable();
+    }
+  });
+
+  it("does not clear the parent-owned selection on folder switch in selection mode", async () => {
+    const onSelectionChange = vi.fn();
+    setupMocks({ data: [{ ...mockCase, id: 101, folderId: 1 }] });
+
+    const { rerender } = render(
+      <Cases
+        {...defaultProps}
+        isSelectionMode={true}
+        selectedTestCases={[101]}
+        onSelectionChange={onSelectionChange}
+        viewType="folders"
+        folderId={1}
+      />
+    );
+
+    await screen.findByTestId("data-table");
+
+    // Run-mode selection is owned by the parent and may legitimately span
+    // folders, so switching folders must not reset it.
+    setupMocks({ data: [{ ...mockCase, id: 202, folderId: 2 }] });
+    rerender(
+      <Cases
+        {...defaultProps}
+        isSelectionMode={true}
+        selectedTestCases={[101]}
+        onSelectionChange={onSelectionChange}
+        viewType="folders"
+        folderId={2}
+      />
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId("data-table")).toBeInTheDocument();
+    });
+    expect(onSelectionChange).not.toHaveBeenCalledWith([]);
+  });
 });