From 3344f72da50f4ff4ac79801112a0c4b58f291feb Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 08:02:39 +0200
Subject: [PATCH 01/10] refactor(project): remove approval toggle

---
 .../projects/ProjectProposalTable.vue         |  58 ------
 app/components/table/ApproveRejectToggle.vue  | 191 ------------------
 .../table/ApproveRejectToggle.spec.ts         | 171 ----------------
 3 files changed, 420 deletions(-)
 delete mode 100644 app/components/table/ApproveRejectToggle.vue
 delete mode 100644 test/components/table/ApproveRejectToggle.spec.ts

diff --git a/app/components/projects/ProjectProposalTable.vue b/app/components/projects/ProjectProposalTable.vue
index 84f91a2..ab8bc1f 100644
--- a/app/components/projects/ProjectProposalTable.vue
+++ b/app/components/projects/ProjectProposalTable.vue
@@ -1,12 +1,9 @@
 <script lang="ts" setup>
 import { getProjectNodes } from "~/composables/useAPIFetch";
-import ApproveRejectToggle from "~/components/table/ApproveRejectToggle.vue";
 import { formatDataRow } from "~/utils/format-data-row";
 import { type ProjectNode } from "~/services/Api";
 import { FilterMatchMode } from "@primevue/core/api";
 import SearchBar from "~/components/table/SearchBar.vue";
-import { getApprovalStatusSeverity } from "~/utils/status-tag-severity";
-import { ApprovalStatus } from "~/types/node";
 
 const proposals = ref();
 const expandedRows = ref({});
@@ -37,15 +34,6 @@ function parseData() {
 
 parseData();
 
-function updateTable(newData: ProjectNode) {
-  for (let row of proposals.value) {
-    if (row.id === newData.id) {
-      row.approval_status = newData.approval_status;
-      return;
-    }
-  }
-}
-
 async function onTableRefresh() {
   await refresh();
   parseData();
@@ -177,52 +165,6 @@ const updateFilters = (filterText: string) => {
               </p>
             </template>
           </Column>
-          <Column
-            :exportable="false"
-            :showAddButton="false"
-            :showApplyButton="false"
-            :showClearButton="false"
-            :showFilterMatchModes="false"
-            :showFilterOperator="false"
-            field="approval_status"
-            style="min-width: 10em"
-          >
-            <template #header>
-              <span
-                v-tooltip.top="
-                  'Set it so that the project is either approved for running on this node or rejected'
-                "
-                class="help-text"
-              >
-                <b>Set Approval</b>
-              </span>
-            </template>
-            <template #body="slotProps">
-              <ApproveRejectToggle
-                :currentStatus="slotProps.data.approval_status"
-                :objectClass="'project'"
-                :objectId="slotProps.data.id"
-                @updatedRow="updateTable"
-              />
-            </template>
-            <template #filter="{ filterModel, filterCallback }">
-              <Select
-                v-model="filterModel.value"
-                :options="Object.values(ApprovalStatus)"
-                :showClear="true"
-                class="p-column-filter"
-                placeholder="Select One"
-                @change="filterCallback()"
-              >
-                <template #option="slotProps">
-                  <Tag
-                    :severity="getApprovalStatusSeverity(slotProps.option)"
-                    :value="slotProps.option"
-                  />
-                </template>
-              </Select>
-            </template>
-          </Column>
         </DataTable>
       </template>
     </Card>
diff --git a/app/components/table/ApproveRejectToggle.vue b/app/components/table/ApproveRejectToggle.vue
deleted file mode 100644
index ca83d27..0000000
--- a/app/components/table/ApproveRejectToggle.vue
+++ /dev/null
@@ -1,191 +0,0 @@
-<script lang="ts" setup>
-import { useNuxtApp } from "nuxt/app";
-import { useToast } from "primevue/usetoast";
-import type { AnalysisNode, ProjectNode } from "~/services/Api";
-import { ApprovalStatus } from "~/types/node";
-import { getApprovalStatusSeverity } from "~/utils/status-tag-severity";
-import Tag from "primevue/tag";
-import { useConfirm } from "primevue/useconfirm";
-
-const props = defineProps<{
-  objectId?: string;
-  objectClass?: string;
-  currentStatus?: ApprovalStatus;
-}>();
-
-const checked = ref(props.currentStatus === ApprovalStatus.Approved);
-
-const toast = useToast();
-const confirm = useConfirm();
-const loading = ref(false);
-
-const toggleApproval = () => {
-  if (loading.value) {
-    // Revert the optimistic v-model flip and ignore while a request is in flight
-    checked.value = !checked.value;
-    return;
-  }
-  if (checked.value) {
-    confirmRejection();
-  } else {
-    confirmApproval();
-  }
-};
-
-const emit = defineEmits(["updatedRow"]);
-
-const confirmApproval = () => {
-  confirm.require({
-    message: `Are you sure you want to approve this ${props.objectClass}?`,
-    header: "Approval Confirmation",
-    icon: "pi pi-exclamation-triangle",
-    rejectProps: {
-      label: "Cancel",
-      severity: "secondary",
-      outlined: true,
-    },
-    acceptProps: {
-      label: "Submit",
-    },
-    accept: () => {
-      onSubmitApproval(true);
-    },
-    reject: () => {
-      // Reset the toggle
-      checked.value = !checked.value;
-    },
-  });
-};
-
-const confirmRejection = () => {
-  confirm.require({
-    message: `Are you sure you want to reject this ${props.objectClass}?`,
-    header: "Rejection Confirmation",
-    icon: "pi pi-exclamation-triangle",
-    rejectProps: {
-      label: "Cancel",
-      severity: "secondary",
-      outlined: true,
-    },
-    acceptProps: {
-      label: "Submit",
-    },
-    accept: () => {
-      onSubmitApproval(false);
-    },
-    reject: () => {
-      // Reset the toggle
-      checked.value = !checked.value;
-    },
-  });
-};
-
-async function onSubmitApproval(isApproved: boolean) {
-  loading.value = true;
-  const formData = new FormData();
-  formData.append("approval_status", isApproved ? "approved" : "rejected");
-  let approvalResp: AnalysisNode | ProjectNode | undefined;
-  let endpoint: string;
-
-  if (props.objectClass == "project") {
-    endpoint = `/project-nodes/${props.objectId}`;
-  } else if (props.objectClass == "analysis") {
-    endpoint = `/analysis-nodes/${props.objectId}`;
-  } else {
-    console.error("Unknown approval props: ", props);
-    toast.add({
-      severity: "error",
-      summary: "Invalid approval prop",
-      detail: `Unable to submit request due to invalid props: ${props}`,
-      life: 6000,
-    });
-    checked.value = !checked.value;
-    loading.value = false;
-    return;
-  }
-
-  approvalResp = (await useNuxtApp()
-    .$hubApi(endpoint, {
-      method: "POST",
-      body: formData,
-    })
-    .catch((e) => {
-      console.error(e);
-      return undefined;
-    })) as AnalysisNode | ProjectNode | undefined;
-
-  if (approvalResp && "approval_status" in approvalResp) {
-    showSuccessfulSubmission(isApproved);
-    // Send data to parent component
-    emit("updatedRow", approvalResp);
-  } else {
-    // Reset toggle and show failed toast
-    checked.value = !checked.value;
-    showFailedSubmission();
-  }
-  loading.value = false;
-}
-
-const showSuccessfulSubmission = (approval: boolean) => {
-  const submissionType = approval ? "Approval" : "Rejection";
-  toast.add({
-    severity: "success",
-    summary: "Submission successful",
-    detail: `${submissionType} successfully submitted.`,
-    life: 3000,
-  });
-};
-
-const showFailedSubmission = () => {
-  toast.add({
-    severity: "error",
-    summary: "Submission failed",
-    detail: "There was an error sending your submission.",
-    life: 3000,
-  });
-};
-</script>
-
-<template>
-  <div class="approval-toggle">
-    <div
-      class="approval-tag approval-tag-rejected"
-      :class="{ dimmed: checked }"
-    >
-      <Tag
-        :severity="getApprovalStatusSeverity(ApprovalStatus.Rejected)"
-        :value="ApprovalStatus.Rejected"
-      />
-    </div>
-    <ToggleSwitch
-      v-model="checked"
-      class="approval-toggle-switch"
-      label="Approval Toggle"
-      @click="toggleApproval()"
-    />
-    <div
-      class="approval-tag approval-tag-approved"
-      :class="{ dimmed: !checked }"
-    >
-      <Tag
-        :severity="getApprovalStatusSeverity(ApprovalStatus.Approved)"
-        :value="ApprovalStatus.Approved"
-      />
-    </div>
-  </div>
-</template>
-
-<style lang="scss" scoped>
-.approval-toggle {
-  display: flex;
-  align-items: center;
-}
-
-.approval-tag {
-  padding: 0.3em;
-
-  &.dimmed {
-    opacity: 0.5;
-  }
-}
-</style>
diff --git a/test/components/table/ApproveRejectToggle.spec.ts b/test/components/table/ApproveRejectToggle.spec.ts
deleted file mode 100644
index 64642be..0000000
--- a/test/components/table/ApproveRejectToggle.spec.ts
+++ /dev/null
@@ -1,171 +0,0 @@
-import { useToast } from "primevue/usetoast";
-import { useConfirm } from "primevue/useconfirm";
-import { flushPromises, mount } from "@vue/test-utils";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import ApproveRejectToggle from "~/components/table/ApproveRejectToggle.vue";
-import { ApprovalStatus } from "~/types/node";
-import {
-  fakeInvalidProposalId,
-  fakeValidProposalId,
-} from "@/test/mockapi/handlers";
-
-// Stubbed ToggleSwitch so we can drive the `@click` handler deterministically.
-// It exposes the bound model value via `data-checked` and intentionally does
-// NOT emit `update:modelValue` on click, so `checked` only changes via the
-// component's own reset logic.
-const ToggleSwitchStub = {
-  props: ["modelValue"],
-  emits: ["update:modelValue"],
-  template: '<button :data-checked="String(modelValue)" />',
-};
-
-function mountToggle(props: Record<string, unknown>) {
-  return mount(ApproveRejectToggle, {
-    props,
-    global: {
-      stubs: { ToggleSwitch: ToggleSwitchStub },
-    },
-  });
-}
-
-describe("ApproveRejectToggle.vue", () => {
-  const confirmRequire = vi.fn();
-  let mockToast: { add: ReturnType<typeof vi.fn> };
-  let toastSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    confirmRequire.mockReset();
-    mockToast = { add: vi.fn() };
-    toastSpy = vi.spyOn(mockToast, "add");
-    vi.mocked(useToast).mockReturnValue(mockToast);
-    vi.mocked(useConfirm).mockReturnValue({
-      require: confirmRequire,
-    } as unknown as ReturnType<typeof useConfirm>);
-  });
-
-  it("dims the approved tag when the proposal is not approved", () => {
-    const wrapper = mountToggle({
-      objectClass: "project",
-      currentStatus: ApprovalStatus.Rejected,
-    });
-
-    expect(wrapper.find(".approval-tag-approved").classes()).toContain(
-      "dimmed",
-    );
-    expect(wrapper.find(".approval-tag-rejected").classes()).not.toContain(
-      "dimmed",
-    );
-  });
-
-  it("dims the rejected tag when the proposal is approved", () => {
-    const wrapper = mountToggle({
-      objectClass: "project",
-      currentStatus: ApprovalStatus.Approved,
-    });
-
-    expect(wrapper.find(".approval-tag-rejected").classes()).toContain(
-      "dimmed",
-    );
-    expect(wrapper.find(".approval-tag-approved").classes()).not.toContain(
-      "dimmed",
-    );
-  });
-
-  it("requests approval confirmation and submits when accepted", async () => {
-    const wrapper = mountToggle({
-      objectId: fakeValidProposalId,
-      objectClass: "project",
-      currentStatus: ApprovalStatus.Rejected,
-    });
-
-    await wrapper.find(".approval-toggle-switch").trigger("click");
-
-    expect(confirmRequire).toHaveBeenCalledTimes(1);
-    const options = confirmRequire.mock.calls[0][0];
-    expect(options.header).toBe("Approval Confirmation");
-    expect(options.message).toContain("approve");
-
-    // Simulate the user confirming the dialog
-    options.accept();
-    await flushPromises();
-
-    expect(toastSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        severity: "success",
-        summary: "Submission successful",
-        detail: "Approval successfully submitted.",
-      }),
-    );
-    expect(wrapper.emitted()).toHaveProperty("updatedRow");
-  });
-
-  it("requests rejection confirmation and submits when accepted", async () => {
-    const wrapper = mountToggle({
-      objectId: fakeValidProposalId,
-      objectClass: "project",
-      currentStatus: ApprovalStatus.Approved,
-    });
-
-    await wrapper.find(".approval-toggle-switch").trigger("click");
-
-    expect(confirmRequire).toHaveBeenCalledTimes(1);
-    const options = confirmRequire.mock.calls[0][0];
-    expect(options.header).toBe("Rejection Confirmation");
-    expect(options.message).toContain("reject");
-
-    options.accept();
-    await flushPromises();
-
-    expect(toastSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        severity: "success",
-        summary: "Submission successful",
-        detail: "Rejection successfully submitted.",
-      }),
-    );
-    expect(wrapper.emitted()).toHaveProperty("updatedRow");
-  });
-
-  it("does not submit when the confirmation is cancelled", async () => {
-    const wrapper = mountToggle({
-      objectId: fakeValidProposalId,
-      objectClass: "project",
-      currentStatus: ApprovalStatus.Rejected,
-    });
-
-    await wrapper.find(".approval-toggle-switch").trigger("click");
-
-    expect(confirmRequire).toHaveBeenCalledTimes(1);
-    const options = confirmRequire.mock.calls[0][0];
-
-    // Simulate the user cancelling the dialog
-    options.reject();
-    await flushPromises();
-
-    expect(toastSpy).not.toHaveBeenCalled();
-    expect(wrapper.emitted()).not.toHaveProperty("updatedRow");
-  });
-
-  it("shows a failure toast and does not emit when the API response is invalid", async () => {
-    const wrapper = mountToggle({
-      objectId: fakeInvalidProposalId,
-      objectClass: "project",
-      currentStatus: ApprovalStatus.Rejected,
-    });
-
-    await wrapper.find(".approval-toggle-switch").trigger("click");
-
-    const options = confirmRequire.mock.calls[0][0];
-    options.accept();
-    await flushPromises();
-
-    expect(toastSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        severity: "error",
-        summary: "Submission failed",
-        detail: "There was an error sending your submission.",
-      }),
-    );
-    expect(wrapper.emitted()).not.toHaveProperty("updatedRow");
-  });
-});

From 2206e83c3a61c88aa67882d7e311f7a72ad04986 Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 08:19:29 +0200
Subject: [PATCH 02/10] refactor(project): rename table

---
 .../{ProjectProposalTable.vue => ProjectsTable.vue}       | 2 +-
 app/pages/projects.vue                                    | 4 ++--
 ...ProjectProposalTable.spec.ts => ProjectsTable.spec.ts} | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)
 rename app/components/projects/{ProjectProposalTable.vue => ProjectsTable.vue} (99%)
 rename test/components/projects/{ProjectProposalTable.spec.ts => ProjectsTable.spec.ts} (93%)

diff --git a/app/components/projects/ProjectProposalTable.vue b/app/components/projects/ProjectsTable.vue
similarity index 99%
rename from app/components/projects/ProjectProposalTable.vue
rename to app/components/projects/ProjectsTable.vue
index ab8bc1f..d3c1ed4 100644
--- a/app/components/projects/ProjectProposalTable.vue
+++ b/app/components/projects/ProjectsTable.vue
@@ -67,7 +67,7 @@ const updateFilters = (filterText: string) => {
   <ConfirmDialog />
   <div class="proposal-card">
     <Card class="content-card">
-      <template #title>Project Proposals</template>
+      <template #title>Projects</template>
       <template #content>
         <div class="table-header-row">
           <SearchBar
diff --git a/app/pages/projects.vue b/app/pages/projects.vue
index 94c95b5..757ecdd 100644
--- a/app/pages/projects.vue
+++ b/app/pages/projects.vue
@@ -1,9 +1,9 @@
 <script setup>
-import ProjectProposalTable from "~/components/projects/ProjectProposalTable.vue";
+import ProjectsTable from "~/components/projects/ProjectsTable.vue";
 </script>
 
 <template>
-  <ProjectProposalTable />
+  <ProjectsTable />
 </template>
 
 <style scoped lang="scss"></style>
diff --git a/test/components/projects/ProjectProposalTable.spec.ts b/test/components/projects/ProjectsTable.spec.ts
similarity index 93%
rename from test/components/projects/ProjectProposalTable.spec.ts
rename to test/components/projects/ProjectsTable.spec.ts
index 3799fe5..5a5cc6d 100644
--- a/test/components/projects/ProjectProposalTable.spec.ts
+++ b/test/components/projects/ProjectsTable.spec.ts
@@ -2,7 +2,7 @@ import { useToast } from "primevue/usetoast";
 import { defineComponent } from "vue";
 import { flushPromises, mount } from "@vue/test-utils";
 import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
-import ProjectProposalTable from "~/components/projects/ProjectProposalTable.vue";
+import ProjectsTable from "~/components/projects/ProjectsTable.vue";
 import { getProjectNodes } from "~/composables/useAPIFetch";
 import type { ProjectNode } from "~/services/Api";
 import { fakeProposalsResp } from "@/test/components/projects/constants";
@@ -11,7 +11,7 @@ vi.mock("~/composables/useAPIFetch", () => ({
   getProjectNodes: vi.fn(),
 }));
 
-describe("ProjectProposalTable.vue", () => {
+describe("ProjectsTable.vue", () => {
   let mockToast;
   let ProjectProposalTableTestComponent;
 
@@ -23,8 +23,8 @@ describe("ProjectProposalTable.vue", () => {
   // Render the component with the fake params
   beforeAll(async () => {
     ProjectProposalTableTestComponent = defineComponent({
-      components: { ProjectProposalTable },
-      template: "<Suspense><ProjectProposalTable/></Suspense>",
+      components: { ProjectProposalTable: ProjectsTable },
+      template: "<Suspense><ProjectsTable/></Suspense>",
     });
   });
 

From 51931766a58809b0ab5b365d6a6bcb2caa0c3d44 Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 09:06:42 +0200
Subject: [PATCH 03/10] test(project): update tests for new project component
 name

---
 .../components/projects/ProjectsTable.spec.ts | 27 ++++++++-----------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/test/components/projects/ProjectsTable.spec.ts b/test/components/projects/ProjectsTable.spec.ts
index 5a5cc6d..364bd22 100644
--- a/test/components/projects/ProjectsTable.spec.ts
+++ b/test/components/projects/ProjectsTable.spec.ts
@@ -13,7 +13,7 @@ vi.mock("~/composables/useAPIFetch", () => ({
 
 describe("ProjectsTable.vue", () => {
   let mockToast;
-  let ProjectProposalTableTestComponent;
+  let ProjectsTableTestComponent;
 
   beforeEach(() => {
     vi.restoreAllMocks(); // Reset mocks before each test
@@ -22,8 +22,8 @@ describe("ProjectsTable.vue", () => {
 
   // Render the component with the fake params
   beforeAll(async () => {
-    ProjectProposalTableTestComponent = defineComponent({
-      components: { ProjectProposalTable: ProjectsTable },
+    ProjectsTableTestComponent = defineComponent({
+      components: { ProjectsTable },
       template: "<Suspense><ProjectsTable/></Suspense>",
     });
   });
@@ -39,11 +39,11 @@ describe("ProjectsTable.vue", () => {
       clear: vi.fn(),
     });
 
-    const wrapper = mount(ProjectProposalTableTestComponent);
+    const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
 
-    expect(ProjectProposalTableTestComponent).toBeTruthy();
-    expect(wrapper.text()).toContain("Project Proposals"); // H1 of the page
+    expect(ProjectsTableTestComponent).toBeTruthy();
+    expect(wrapper.text()).toContain("Projects"); // Card title
 
     // Find header and all rows
     const rows = wrapper.findAll("tbody tr");
@@ -53,23 +53,18 @@ describe("ProjectsTable.vue", () => {
     const headerRow = wrapper.findAll("thead tr");
     expect(headerRow.length).toBe(1);
     const headerCols = headerRow[0].findAll("th");
-    expect(headerCols.length).toBe(6);
+    expect(headerCols.length).toBe(5);
     expect(headerCols[0].text()).toBe("Project Name");
     expect(headerCols[1].text()).toBe("Number of Analyses");
     expect(headerCols[2].text()).toBe("Number of Nodes");
     expect(headerCols[3].text()).toBe("Created On");
     expect(headerCols[4].text()).toBe("Last Updated");
-    expect(headerCols[5].text()).toBe("Set Approval");
 
     // Verify the row's content
     const rowCells = rows[0].findAll("td");
     expect(rowCells[0].text()).toBe("fake-project"); // Project name
     expect(rowCells[1].text()).toBe("17"); // Number of analyses
     expect(rowCells[2].text()).toBe("0"); // Number of nodes
-
-    // The "Set Approval" column renders the toggle with both status tags
-    expect(rowCells[5].text()).toContain("approved");
-    expect(rowCells[5].text()).toContain("rejected");
   });
 
   test("No projects returned", async () => {
@@ -84,10 +79,10 @@ describe("ProjectsTable.vue", () => {
       clear: vi.fn(),
     });
 
-    const wrapper = mount(ProjectProposalTableTestComponent);
+    const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
 
-    expect(ProjectProposalTableTestComponent).toBeTruthy();
+    expect(ProjectsTableTestComponent).toBeTruthy();
     expect(wrapper.text()).toContain("No projects found"); // H1 of the page
   });
 
@@ -102,10 +97,10 @@ describe("ProjectsTable.vue", () => {
       clear: vi.fn(),
     });
 
-    const wrapper = mount(ProjectProposalTableTestComponent);
+    const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
 
-    expect(ProjectProposalTableTestComponent).toBeTruthy();
+    expect(ProjectsTableTestComponent).toBeTruthy();
     expect(wrapper.text()).toContain("No projects found"); // H1 of the page
   });
 });

From c0f519eccaf9570a65cf129c3735173a859578a3 Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 13:35:59 +0200
Subject: [PATCH 04/10] feat(project): add analysis overview and status tags to
 project table

---
 app/components/analysis/AnalysesTable.vue    |  70 +-----
 app/components/projects/ProjectsTable.vue    | 211 ++++++++++++++++++-
 app/components/shared/DataStoreBadge.vue     |  70 ++++++
 app/composables/useProjectAnalysisSummary.ts | 141 +++++++++++++
 app/utils/summarise-project-analyses.ts      | 163 ++++++++++++++
 5 files changed, 586 insertions(+), 69 deletions(-)
 create mode 100644 app/components/shared/DataStoreBadge.vue
 create mode 100644 app/composables/useProjectAnalysisSummary.ts
 create mode 100644 app/utils/summarise-project-analyses.ts

diff --git a/app/components/analysis/AnalysesTable.vue b/app/components/analysis/AnalysesTable.vue
index af6741a..b40244f 100644
--- a/app/components/analysis/AnalysesTable.vue
+++ b/app/components/analysis/AnalysesTable.vue
@@ -1,6 +1,5 @@
 <script lang="ts" setup>
 import { useNuxtApp, useState } from "nuxt/app";
-import Badge from "primevue/badge";
 import { useToast } from "primevue/usetoast";
 import ProgressBar from "primevue/progressbar";
 import { getAnalysisNodes } from "~/composables/useAPIFetch";
@@ -29,6 +28,7 @@ import {
 import { ApprovalStatus } from "~/types/node";
 import { parseKongTags } from "~/utils/parse-kong-tags";
 import ContainerCounter from "~/components/analysis/ContainerCounter.vue";
+import DataStoreBadge from "~/components/shared/DataStoreBadge.vue";
 import { useDatastoreRequirement } from "~/composables/useDatastoreRequirement";
 import type {
   HubStatuses,
@@ -43,15 +43,6 @@ const tableLoading = ref(true);
 const { nodeType, requireDataStore: datastoreRequired } =
   useDatastoreRequirement();
 
-const datastoreBadgeSeverity = computed(() =>
-  datastoreRequired.value ? "danger" : "secondary",
-);
-const datastoreBadgeTooltip = computed(() =>
-  datastoreRequired.value
-    ? "Data store missing, click here to create a data store for this project"
-    : "Data store missing, but not required",
-);
-
 const analysesMap = ref<Map<string, ModifiedAnalysisNode>>(new Map());
 const analyses = computed(() => Array.from(analysesMap.value.values()));
 const projMap = new Map<string, string>();
@@ -128,7 +119,7 @@ const hubStatusFilterOptions = [
   },
 ];
 
-// Match a row when ANY of the selected statuses matches its respective column
+// Match a row when any of the selected statuses matches its respective column
 FilterService.register(
   HUB_STATUS_FILTER_MATCH_MODE,
   (value: HubStatuses | undefined, filter: string[] | undefined | null) => {
@@ -482,7 +473,7 @@ const onNavigate = () => {
 };
 
 // Navigate to data store creation with the analysis' project preselected
-const onCreateDataStore = (projectId: string | undefined) => {
+const onCreateDataStore = (projectId: string | null | undefined) => {
   navigateTo({
     path: "/data-stores/create",
     query: projectId ? { projectId } : undefined,
@@ -751,31 +742,12 @@ const onCloseNavToast = () => {
               </span>
             </template>
             <template #body="{ data }">
-              <div v-if="data.datastore" class="datastore-badge">
-                <Badge class="w-8 h-8 rounded-full" severity="success"
-                  ><i v-tooltip.top="'Data store found'" class="pi pi-check"></i
-                ></Badge>
-              </div>
-              <div v-else class="datastore-badge">
-                <Badge
-                  :severity="datastoreBadgeSeverity"
-                  class="w-8 h-8 rounded-full"
-                >
-                  <button
-                    v-tooltip.top="datastoreBadgeTooltip"
-                    type="button"
-                    :disabled="!datastoreRequired"
-                    :aria-label="datastoreBadgeTooltip"
-                    :class="[
-                      'datastore-icon-btn',
-                      { 'datastore-create-link': datastoreRequired },
-                    ]"
-                    @click="onCreateDataStore(data.analysis.project_id)"
-                  >
-                    <i class="pi pi-times"></i>
-                  </button>
-                </Badge>
-              </div>
+              <DataStoreBadge
+                :hasDataStore="data.datastore"
+                :projectId="data.analysis.project_id"
+                :required="datastoreRequired!"
+                @createDataStore="onCreateDataStore"
+              />
             </template>
           </Column>
           <Column :sortable="true" dataType="date" field="created_at.timestamp">
@@ -884,30 +856,6 @@ const onCloseNavToast = () => {
   width: 100%;
 }
 
-.datastore-badge {
-  display: flex;
-  justify-content: center;
-}
-
-.datastore-icon-btn {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  padding: 0;
-  background: none;
-  border: none;
-  color: inherit;
-  font: inherit;
-}
-
-.datastore-icon-btn:disabled {
-  cursor: default;
-}
-
-.datastore-create-link {
-  cursor: pointer;
-}
-
 .hub-statuses {
   display: inline-grid;
   grid-template-columns: auto auto;
diff --git a/app/components/projects/ProjectsTable.vue b/app/components/projects/ProjectsTable.vue
index d3c1ed4..d51e062 100644
--- a/app/components/projects/ProjectsTable.vue
+++ b/app/components/projects/ProjectsTable.vue
@@ -1,9 +1,18 @@
 <script lang="ts" setup>
 import { getProjectNodes } from "~/composables/useAPIFetch";
+import { useDatastoreRequirement } from "~/composables/useDatastoreRequirement";
+import { useProjectAnalysisSummary } from "~/composables/useProjectAnalysisSummary";
 import { formatDataRow } from "~/utils/format-data-row";
+import {
+  deriveProjectStatus,
+  PROJECT_STATUS_FILTER_OPTIONS,
+  type ProjectAnalysisSummary,
+  type ProjectStatus,
+} from "~/utils/summarise-project-analyses";
 import { type ProjectNode } from "~/services/Api";
 import { FilterMatchMode } from "@primevue/core/api";
 import SearchBar from "~/components/table/SearchBar.vue";
+import DataStoreBadge from "~/components/shared/DataStoreBadge.vue";
 
 const proposals = ref();
 const expandedRows = ref({});
@@ -13,6 +22,30 @@ const expandRowEntries = [];
 
 const filters = ref();
 
+const { requireDataStore } = useDatastoreRequirement();
+const { refreshSummaries, summaryFor } = useProjectAnalysisSummary();
+
+const METER_BUCKETS = [
+  { key: "executed", label: "Executed" },
+  { key: "running", label: "Running" },
+  { key: "waiting", label: "Waiting on Hub" },
+  { key: "stopped", label: "Stopped" },
+  { key: "failed", label: "Failed" },
+  { key: "idle", label: "Idle" },
+] as const;
+
+function meterSegments(summary: ProjectAnalysisSummary) {
+  return METER_BUCKETS.filter((bucket) => summary[bucket.key] > 0).map(
+    (bucket) => ({ ...bucket, count: summary[bucket.key] }),
+  );
+}
+
+function meterTooltip(summary: ProjectAnalysisSummary) {
+  return meterSegments(summary)
+    .map((segment) => `${segment.count} ${segment.label.toLowerCase()}`)
+    .join(", ");
+}
+
 const { data: response, status, refresh } = await getProjectNodes();
 
 function parseData() {
@@ -22,27 +55,46 @@ function parseData() {
       dataRowUnixCols,
       expandRowEntries,
     ) as unknown as
-      | Array<ProjectNode & { project_name?: string | null }>
+      | Array<
+          ProjectNode & {
+            project_name?: string | null;
+            summary?: ProjectAnalysisSummary;
+            project_status?: ProjectStatus;
+          }
+        >
       | undefined;
     formatted?.forEach((row) => {
       row.project_name =
         row.project?.display_name ?? row.project?.name ?? row.project?.id;
+      row.summary = summaryFor(row.project?.id);
+      row.project_status = deriveProjectStatus(
+        row.summary,
+        requireDataStore.value,
+      );
     });
     proposals.value = formatted;
   }
 }
 
+await refreshSummaries();
 parseData();
 
 async function onTableRefresh() {
-  await refresh();
+  await Promise.all([refresh(), refreshSummaries()]);
   parseData();
 }
 
+function onCreateDataStore(projectId?: string | null) {
+  navigateTo({
+    path: "/data-stores/create",
+    query: projectId ? { projectId } : undefined,
+  });
+}
+
 // Table filters
 const defaultFilters = {
   global: { value: undefined, matchMode: FilterMatchMode.CONTAINS },
-  approval_status: { value: undefined, matchMode: FilterMatchMode.EQUALS },
+  "project_status.key": { value: undefined, matchMode: FilterMatchMode.IN },
 };
 
 filters.value = defaultFilters;
@@ -75,6 +127,16 @@ const updateFilters = (filterText: string) => {
             @clearFilters="resetFilters"
             @updateSearch="updateFilters"
           />
+          <div class="status-legend">
+            <span
+              v-for="bucket in METER_BUCKETS"
+              :key="bucket.key"
+              class="status-legend-item"
+            >
+              <i :class="`status-meter-seg status-meter-${bucket.key}`" />
+              {{ bucket.label }}
+            </span>
+          </div>
           <div class="card flex justify-content-center refresh-switch">
             <Button
               v-tooltip.top="'Refresh table'"
@@ -101,7 +163,7 @@ const updateFilters = (filterText: string) => {
         >
           <template #empty> No projects found.</template>
           <Column v-if="expandRowEntries.length" expander style="width: 5rem" />
-          <Column :sortable="true" field="project_name" style="width: 30rem">
+          <Column :sortable="true" field="project_name" style="width: 20rem">
             <template #header>
               <span v-tooltip.top="'Name of the project'" class="help-text">
                 <b>Project Name</b>
@@ -113,15 +175,15 @@ const updateFilters = (filterText: string) => {
               </span>
             </template>
           </Column>
-          <Column :sortable="true" field="project.analyses">
+          <Column :sortable="true" field="summary.total">
             <template #header>
               <span
                 v-tooltip.top="
-                  'Number of analyses associated with this project'
+                  'Number of analyses from this project registered on this node'
                 "
                 class="help-text"
               >
-                <b>Number of Analyses</b>
+                <b>Analyses</b>
               </span>
             </template>
           </Column>
@@ -135,6 +197,75 @@ const updateFilters = (filterText: string) => {
               </span>
             </template>
           </Column>
+          <Column
+            :showAddButton="false"
+            :showApplyButton="false"
+            :showClearButton="false"
+            :showFilterMatchModes="false"
+            :showFilterOperator="false"
+            field="project_status.rank"
+            filterField="project_status.key"
+          >
+            <template #header>
+              <span
+                v-tooltip.top="
+                  'What needs attention in this project on this node'
+                "
+                class="help-text"
+              >
+                <b>Status</b>
+              </span>
+            </template>
+            <template #body="{ data }">
+              <div class="project-status">
+                <Tag
+                  :severity="data.project_status.severity"
+                  :value="data.project_status.label"
+                />
+                <div
+                  v-if="data.summary.total > 0"
+                  v-tooltip.top="meterTooltip(data.summary)"
+                  class="status-meter"
+                >
+                  <span
+                    v-for="segment in meterSegments(data.summary)"
+                    :key="segment.key"
+                    :class="`status-meter-seg status-meter-${segment.key}`"
+                    :style="{ flexGrow: segment.count }"
+                  />
+                </div>
+              </div>
+            </template>
+            <template #filter="{ filterModel, filterCallback }">
+              <MultiSelect
+                v-model="filterModel.value"
+                :options="PROJECT_STATUS_FILTER_OPTIONS"
+                class="p-column-filter"
+                optionLabel="label"
+                optionValue="value"
+                placeholder="Any status"
+                @change="filterCallback()"
+              />
+            </template>
+          </Column>
+          <Column :sortable="true" field="summary.hasDataStore">
+            <template #header>
+              <span
+                v-tooltip.top="'Whether the project has a data store'"
+                class="help-text"
+              >
+                <b>Data Store</b>
+              </span>
+            </template>
+            <template #body="{ data }">
+              <DataStoreBadge
+                :hasDataStore="data.summary.hasDataStore"
+                :projectId="data.project?.id"
+                :required="requireDataStore"
+                @createDataStore="onCreateDataStore"
+              />
+            </template>
+          </Column>
           <Column :sortable="true" dataType="date" field="created_at.timestamp">
             <template #header>
               <span
@@ -171,4 +302,68 @@ const updateFilters = (filterText: string) => {
   </div>
 </template>
 
-<style lang="scss"></style>
+<style>
+.project-status {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.375rem;
+  min-width: 8rem;
+}
+
+.status-meter {
+  display: flex;
+  width: 100%;
+  height: 0.4375rem;
+  border-radius: 0.25rem;
+  overflow: hidden;
+}
+
+.status-meter-seg {
+  display: block;
+  min-width: 0.125rem;
+}
+
+.status-meter-executed {
+  background: #22c55e;
+}
+
+.status-meter-running {
+  background: #3b82f6;
+}
+
+.status-meter-waiting {
+  background: #f59e0b;
+}
+
+.status-meter-stopped {
+  background: #fb4d1c;
+}
+
+.status-meter-failed {
+  background: #ef4444;
+}
+
+.status-meter-idle {
+  background: #4b5563;
+}
+
+.status-legend {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.875rem;
+  align-items: center;
+  font-size: 0.6875rem;
+  width: 100%;
+  margin-top: 0.5rem;
+}
+
+.status-legend-item i {
+  width: 0.5625rem;
+  height: 0.5625rem;
+  border-radius: 0.125rem;
+  margin-right: 0.3125rem;
+  display: inline-block;
+  vertical-align: middle;
+}
+</style>
diff --git a/app/components/shared/DataStoreBadge.vue b/app/components/shared/DataStoreBadge.vue
new file mode 100644
index 0000000..d27e710
--- /dev/null
+++ b/app/components/shared/DataStoreBadge.vue
@@ -0,0 +1,70 @@
+<script lang="ts" setup>
+import Badge from "primevue/badge";
+import { computed } from "vue";
+
+const props = defineProps<{
+  hasDataStore: boolean;
+  required: boolean;
+  projectId?: string | null;
+}>();
+
+const emit = defineEmits<{
+  createDataStore: [projectId?: string | null];
+}>();
+
+const missingTooltip = computed(() =>
+  props.required
+    ? "Data store missing, click here to create a data store for this project"
+    : "Data store missing, but not required",
+);
+</script>
+
+<template>
+  <div class="datastore-badge">
+    <Badge v-if="hasDataStore" class="w-8 h-8 rounded-full" severity="success">
+      <i v-tooltip.top="'Data store found'" class="pi pi-check"></i>
+    </Badge>
+    <Badge
+      v-else
+      :severity="required ? 'danger' : 'secondary'"
+      class="w-8 h-8 rounded-full"
+    >
+      <button
+        v-tooltip.top="missingTooltip"
+        :aria-label="missingTooltip"
+        :class="['datastore-icon-btn', { 'datastore-create-link': required }]"
+        :disabled="!required"
+        type="button"
+        @click="emit('createDataStore', projectId)"
+      >
+        <i class="pi pi-times"></i>
+      </button>
+    </Badge>
+  </div>
+</template>
+
+<style scoped>
+.datastore-badge {
+  display: flex;
+  justify-content: center;
+}
+
+.datastore-icon-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  background: none;
+  border: none;
+  color: inherit;
+  font: inherit;
+}
+
+.datastore-icon-btn:disabled {
+  cursor: default;
+}
+
+.datastore-create-link {
+  cursor: pointer;
+}
+</style>
diff --git a/app/composables/useProjectAnalysisSummary.ts b/app/composables/useProjectAnalysisSummary.ts
new file mode 100644
index 0000000..aad6ab4
--- /dev/null
+++ b/app/composables/useProjectAnalysisSummary.ts
@@ -0,0 +1,141 @@
+import { ref } from "vue";
+import { useNuxtApp } from "nuxt/app";
+import {
+  type AnalysisNode,
+  type ListRoutes,
+  type PodProgressResponse,
+  PodStatus,
+  type Route,
+} from "~/services/Api";
+import { parseKongTags } from "~/utils/parse-kong-tags";
+import {
+  emptyProjectAnalysisSummary,
+  type ProjectAnalysisSummary,
+  summariseProjectAnalyses,
+} from "~/utils/summarise-project-analyses";
+
+export type HubFetch = (
+  url: string,
+  opts?: Record<string, unknown>,
+) => Promise<unknown>;
+
+const PAGE_LIMIT = 50;
+const MAX_PAGES = 40;
+
+const FINISHED_STATUSES: Array<PodStatus | null | undefined> = [
+  PodStatus.Failed,
+  PodStatus.Executed,
+];
+
+export async function fetchAllAnalysisNodes(
+  hubApi: HubFetch,
+): Promise<AnalysisNode[]> {
+  const allNodes: AnalysisNode[] = [];
+
+  for (let pageIndex = 0; pageIndex < MAX_PAGES; pageIndex++) {
+    const nextPage = (await hubApi("/analysis-nodes", {
+      method: "GET",
+      query: {
+        include: "analysis",
+        sort: "-updated_at",
+        page: { offset: pageIndex * PAGE_LIMIT, limit: PAGE_LIMIT },
+      },
+    }).catch(() => undefined)) as AnalysisNode[] | undefined;
+
+    if (!nextPage || nextPage.length === 0) break;
+    allNodes.push(...nextPage);
+    if (nextPage.length < PAGE_LIMIT) break;
+  }
+
+  return allNodes;
+}
+
+export async function fetchDataStoreProjectIds(
+  hubApi: HubFetch,
+): Promise<Set<string>> {
+  const routesResp = (await hubApi("/kong/project", { method: "GET" }).catch(
+    () => undefined,
+  )) as ListRoutes | undefined;
+
+  const projectIds = new Set<string>();
+  routesResp?.data?.forEach((route: Route) => {
+    const projectId = parseKongTags(route.tags).project;
+    if (projectId) projectIds.add(projectId);
+  });
+  return projectIds;
+}
+
+export async function fetchExecutionStatuses(
+  hubApi: HubFetch,
+): Promise<PodProgressResponse | undefined> {
+  return (await hubApi("/po/status", { method: "GET" }).catch(
+    () => undefined,
+  )) as PodProgressResponse | undefined;
+}
+
+export function mergeExecutionStatuses(
+  analysisNodes: AnalysisNode[],
+  executionStatuses: PodProgressResponse | undefined,
+): AnalysisNode[] {
+  return analysisNodes.map((analysisNode) => {
+    const merged = { ...analysisNode };
+    const analysisId = merged.analysis_id;
+
+    if (executionStatuses && analysisId in executionStatuses) {
+      merged.execution_status = executionStatuses[analysisId]!
+        .status as AnalysisNode["execution_status"];
+    } else if (
+      !FINISHED_STATUSES.includes(merged.execution_status as PodStatus)
+    ) {
+      merged.execution_status = null;
+    }
+
+    return merged;
+  });
+}
+
+export function useProjectAnalysisSummary() {
+  const summaries = ref<Map<string, ProjectAnalysisSummary>>(new Map());
+  const dataStoreProjectIds = ref<Set<string>>(new Set());
+  const loading = ref(false);
+
+  async function refreshSummaries() {
+    loading.value = true;
+    try {
+      const hubApi = useNuxtApp().$hubApi as unknown as HubFetch;
+      const [analysisNodes, projectIdsWithDataStore, executionStatuses] =
+        await Promise.all([
+          fetchAllAnalysisNodes(hubApi),
+          fetchDataStoreProjectIds(hubApi),
+          fetchExecutionStatuses(hubApi),
+        ]);
+
+      dataStoreProjectIds.value = projectIdsWithDataStore;
+      summaries.value = summariseProjectAnalyses(
+        mergeExecutionStatuses(analysisNodes, executionStatuses),
+        projectIdsWithDataStore,
+      );
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  // Handle projects with no analyses or missing proj ID
+  function summaryFor(
+    projectId: string | undefined | null,
+  ): ProjectAnalysisSummary {
+    if (!projectId) return emptyProjectAnalysisSummary(false);
+    return (
+      summaries.value.get(projectId) ??
+      emptyProjectAnalysisSummary(dataStoreProjectIds.value.has(projectId))
+    );
+  }
+
+  return {
+    summaries,
+    dataStoreProjectIds,
+    loading,
+    refreshSummaries,
+    summaryFor,
+  };
+}
diff --git a/app/utils/summarise-project-analyses.ts b/app/utils/summarise-project-analyses.ts
new file mode 100644
index 0000000..5f6205c
--- /dev/null
+++ b/app/utils/summarise-project-analyses.ts
@@ -0,0 +1,163 @@
+import { type AnalysisNode, PodStatus } from "~/services/Api";
+import { ApprovalStatus } from "~/types/node";
+import { ProcessStatus } from "~/types/analysis";
+
+export interface ProjectAnalysisSummary {
+  total: number;
+  executed: number;
+  running: number;
+  failed: number;
+  stopped: number;
+  waiting: number;
+  idle: number;
+  hasDataStore: boolean;
+}
+
+export function emptyProjectAnalysisSummary(
+  hasDataStore: boolean,
+): ProjectAnalysisSummary {
+  return {
+    total: 0,
+    executed: 0,
+    running: 0,
+    failed: 0,
+    stopped: 0,
+    waiting: 0,
+    idle: 0,
+    hasDataStore,
+  };
+}
+
+// An analysis is still waiting to be approved, built or distributed
+function isWaitingOnHub(analysisNode: AnalysisNode): boolean {
+  if (analysisNode.approval_status !== ApprovalStatus.Approved) return true;
+  if (analysisNode.analysis?.build_status !== ProcessStatus.Executed)
+    return true;
+  return analysisNode.analysis?.distribution_status !== ProcessStatus.Executed;
+}
+
+export function summariseProjectAnalyses(
+  analysisNodes: AnalysisNode[],
+  dataStoreProjectIds: Set<string>,
+): Map<string, ProjectAnalysisSummary> {
+  const summaries = new Map<string, ProjectAnalysisSummary>();
+
+  for (const analysisNode of analysisNodes) {
+    const projectId = analysisNode.analysis?.project_id;
+    if (!projectId) continue;
+
+    let summary = summaries.get(projectId);
+    if (!summary) {
+      summary = emptyProjectAnalysisSummary(dataStoreProjectIds.has(projectId));
+      summaries.set(projectId, summary);
+    }
+    summary.total++;
+
+    switch (analysisNode.execution_status) {
+      case PodStatus.Failed:
+        summary.failed++;
+        break;
+
+      case PodStatus.Executed:
+        summary.executed++;
+        break;
+
+      case PodStatus.Starting:
+      case PodStatus.Started:
+      case PodStatus.Executing:
+        summary.running++;
+        break;
+
+      case PodStatus.Stopping:
+      case PodStatus.Stopped:
+        summary.stopped++;
+        break;
+
+      default:
+        if (isWaitingOnHub(analysisNode)) {
+          summary.waiting++;
+        } else {
+          summary.idle++;
+        }
+    }
+  }
+
+  return summaries;
+}
+
+export type ProjectStatusKey =
+  | "noDataStore"
+  | "failed"
+  | "waiting"
+  | "running"
+  | "idle"
+  | "complete"
+  | "noAnalyses";
+
+export type ProjectStatusSeverity =
+  | "danger"
+  | "warn"
+  | "info"
+  | "success"
+  | "secondary";
+
+export interface ProjectStatus {
+  key: ProjectStatusKey;
+  label: string;
+  severity: ProjectStatusSeverity;
+  rank: number;
+}
+
+// Severity ordering, 1 is top priority (most egregious and requires attention)
+const STATUS_RANK: Record<ProjectStatusKey, number> = {
+  noDataStore: 1,
+  failed: 2,
+  waiting: 3,
+  running: 4,
+  idle: 5,
+  complete: 6,
+  noAnalyses: 7,
+};
+
+const STATUS_SEVERITY: Record<ProjectStatusKey, ProjectStatusSeverity> = {
+  noDataStore: "danger",
+  failed: "danger",
+  waiting: "warn",
+  running: "info",
+  idle: "secondary",
+  complete: "success",
+  noAnalyses: "secondary",
+};
+
+function status(key: ProjectStatusKey, label: string): ProjectStatus {
+  return { key, label, severity: STATUS_SEVERITY[key], rank: STATUS_RANK[key] };
+}
+
+export function deriveProjectStatus(
+  summary: ProjectAnalysisSummary,
+  requireDataStore: boolean,
+): ProjectStatus {
+  if (summary.total === 0) return status("noAnalyses", "No analyses");
+  if (!summary.hasDataStore && requireDataStore)
+    return status("noDataStore", "No data store");
+  if (summary.failed > 0) return status("failed", `${summary.failed} failed`);
+  if (summary.running > 0)
+    return status("running", `${summary.running} running`);
+  if (summary.waiting > 0)
+    return status("waiting", `${summary.waiting} waiting`);
+  if (summary.executed === summary.total) return status("complete", "Complete");
+  return status("idle", "Idle");
+}
+
+export const PROJECT_STATUS_FILTER_OPTIONS: Array<{
+  label: string;
+  value: ProjectStatusKey;
+}> = [
+  { label: "No data store", value: "noDataStore" },
+  { label: "Failed", value: "failed" },
+  { label: "Waiting on Hub", value: "waiting" },
+  { label: "Running", value: "running" },
+  { label: "Idle", value: "idle" },
+  { label: "Complete", value: "complete" },
+  { label: "No analyses", value: "noAnalyses" },
+];

From eeeb0a7712429192d6041664255f6074aaed39aa Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 17:26:09 +0200
Subject: [PATCH 05/10] test(project): add unit tests

---
 .../components/projects/ProjectsTable.spec.ts | 153 +++++++++-
 test/components/shared/DataStoreBadge.spec.ts |  65 ++++
 .../useProjectAnalysisSummary.test.ts         | 118 ++++++++
 test/utils/summarise-project-analyses.test.ts | 286 ++++++++++++++++++
 4 files changed, 616 insertions(+), 6 deletions(-)
 create mode 100644 test/components/shared/DataStoreBadge.spec.ts
 create mode 100644 test/composables/useProjectAnalysisSummary.test.ts
 create mode 100644 test/utils/summarise-project-analyses.test.ts

diff --git a/test/components/projects/ProjectsTable.spec.ts b/test/components/projects/ProjectsTable.spec.ts
index 364bd22..5a1937e 100644
--- a/test/components/projects/ProjectsTable.spec.ts
+++ b/test/components/projects/ProjectsTable.spec.ts
@@ -1,9 +1,13 @@
 import { useToast } from "primevue/usetoast";
-import { defineComponent } from "vue";
+import { computed, defineComponent } from "vue";
 import { flushPromises, mount } from "@vue/test-utils";
 import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 import ProjectsTable from "~/components/projects/ProjectsTable.vue";
 import { getProjectNodes } from "~/composables/useAPIFetch";
+import { useDatastoreRequirement } from "~/composables/useDatastoreRequirement";
+import { useProjectAnalysisSummary } from "~/composables/useProjectAnalysisSummary";
+import { emptyProjectAnalysisSummary } from "~/utils/summarise-project-analyses";
+import type { ProjectAnalysisSummary } from "~/utils/summarise-project-analyses";
 import type { ProjectNode } from "~/services/Api";
 import { fakeProposalsResp } from "@/test/components/projects/constants";
 
@@ -11,6 +15,30 @@ vi.mock("~/composables/useAPIFetch", () => ({
   getProjectNodes: vi.fn(),
 }));
 
+vi.mock("~/composables/useDatastoreRequirement", () => ({
+  useDatastoreRequirement: vi.fn(),
+}));
+
+vi.mock("~/composables/useProjectAnalysisSummary", () => ({
+  useProjectAnalysisSummary: vi.fn(),
+}));
+
+const FAKE_PROJECT_ID = "7f2f3b59-3b6d-4fb6-a900-2a4d5c2ea483";
+
+function mockSummary(overrides: Partial<ProjectAnalysisSummary> = {}) {
+  const summary = { ...emptyProjectAnalysisSummary(true), ...overrides };
+  vi.mocked(useProjectAnalysisSummary).mockReturnValue({
+    summaries: ref(new Map([[FAKE_PROJECT_ID, summary]])),
+    dataStoreProjectIds: ref(new Set([FAKE_PROJECT_ID])),
+    loading: ref(false),
+    refreshSummaries: vi.fn(),
+    // Id-aware on purpose: a mock that ignored its argument would pass even if
+    // the component looked the summary up by the wrong id (row.id, node_id...).
+    summaryFor: (id: string | undefined | null) =>
+      id === FAKE_PROJECT_ID ? summary : emptyProjectAnalysisSummary(false),
+  } as never);
+}
+
 describe("ProjectsTable.vue", () => {
   let mockToast;
   let ProjectsTableTestComponent;
@@ -18,6 +46,12 @@ describe("ProjectsTable.vue", () => {
   beforeEach(() => {
     vi.restoreAllMocks(); // Reset mocks before each test
     vi.mocked(useToast).mockReturnValue(mockToast);
+
+    vi.mocked(useDatastoreRequirement).mockReturnValue({
+      nodeType: computed(() => "default"),
+      requireDataStore: computed(() => true),
+    } as never);
+    mockSummary({ total: 6, executed: 4, running: 2 });
   });
 
   // Render the component with the fake params
@@ -53,20 +87,127 @@ describe("ProjectsTable.vue", () => {
     const headerRow = wrapper.findAll("thead tr");
     expect(headerRow.length).toBe(1);
     const headerCols = headerRow[0].findAll("th");
-    expect(headerCols.length).toBe(5);
+    expect(headerCols.length).toBe(7);
     expect(headerCols[0].text()).toBe("Project Name");
-    expect(headerCols[1].text()).toBe("Number of Analyses");
+    expect(headerCols[1].text()).toBe("Analyses");
     expect(headerCols[2].text()).toBe("Number of Nodes");
-    expect(headerCols[3].text()).toBe("Created On");
-    expect(headerCols[4].text()).toBe("Last Updated");
+    expect(headerCols[3].text()).toBe("Status");
+    expect(headerCols[4].text()).toBe("Data Store");
+    expect(headerCols[5].text()).toBe("Created On");
+    expect(headerCols[6].text()).toBe("Last Updated");
 
     // Verify the row's content
     const rowCells = rows[0].findAll("td");
     expect(rowCells[0].text()).toBe("fake-project"); // Project name
-    expect(rowCells[1].text()).toBe("17"); // Number of analyses
+    expect(rowCells[1].text()).toBe("6"); // Node-local analyses, not project.analyses (17)
     expect(rowCells[2].text()).toBe("0"); // Number of nodes
   });
 
+  test("Marks a project that has a data store", async () => {
+    mockSummary({ total: 2, executed: 2, hasDataStore: true });
+    vi.mocked(getProjectNodes).mockResolvedValue({
+      data: ref(fakeProposalsResp),
+      pending: ref(false),
+      error: ref(undefined),
+      status: ref("success"),
+      refresh: vi.fn(),
+      execute: vi.fn(),
+      clear: vi.fn(),
+    });
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const dataStoreCell = wrapper.findAll("tbody tr")[0].findAll("td")[4];
+    expect(dataStoreCell.find(".pi-check").exists()).toBe(true);
+    expect(dataStoreCell.find("a").exists()).toBe(false);
+  });
+
+  test("Links a project with no data store to data store creation", async () => {
+    mockSummary({ total: 2, waiting: 2, hasDataStore: false });
+    vi.mocked(getProjectNodes).mockResolvedValue({
+      data: ref(fakeProposalsResp),
+      pending: ref(false),
+      error: ref(undefined),
+      status: ref("success"),
+      refresh: vi.fn(),
+      execute: vi.fn(),
+      clear: vi.fn(),
+    });
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const dataStoreCell = wrapper.findAll("tbody tr")[0].findAll("td")[4];
+    expect(dataStoreCell.find(".pi-times").exists()).toBe(true);
+    expect(dataStoreCell.find("button").attributes("aria-label")).toContain(
+      "create a data store",
+    );
+  });
+
+  test("Renders the status tag and one meter segment per non-empty bucket", async () => {
+    mockSummary({ total: 6, executed: 3, failed: 2, idle: 1 });
+    vi.mocked(getProjectNodes).mockResolvedValue({
+      data: ref(fakeProposalsResp),
+      pending: ref(false),
+      error: ref(undefined),
+      status: ref("success"),
+      refresh: vi.fn(),
+      execute: vi.fn(),
+      clear: vi.fn(),
+    });
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const statusCell = wrapper.findAll("tbody tr")[0].findAll("td")[3];
+    expect(statusCell.text()).toContain("2 failed");
+
+    const segments = statusCell.findAll(".status-meter-seg");
+    expect(segments.length).toBe(3); // executed, failed, idle — not the empty buckets
+    expect(segments[0].classes()).toContain("status-meter-executed");
+    expect(segments[1].classes()).toContain("status-meter-failed");
+    expect(segments[2].classes()).toContain("status-meter-idle");
+  });
+
+  test("Renders no meter when the project has no analyses on this node", async () => {
+    mockSummary({ total: 0 });
+    vi.mocked(getProjectNodes).mockResolvedValue({
+      data: ref(fakeProposalsResp),
+      pending: ref(false),
+      error: ref(undefined),
+      status: ref("success"),
+      refresh: vi.fn(),
+      execute: vi.fn(),
+      clear: vi.fn(),
+    });
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const statusCell = wrapper.findAll("tbody tr")[0].findAll("td")[3];
+    expect(statusCell.text()).toContain("No analyses");
+    expect(statusCell.findAll(".status-meter-seg").length).toBe(0);
+  });
+
+  test("Renders the legend once, above the table", async () => {
+    mockSummary({ total: 3, executed: 3 });
+    vi.mocked(getProjectNodes).mockResolvedValue({
+      data: ref(fakeProposalsResp),
+      pending: ref(false),
+      error: ref(undefined),
+      status: ref("success"),
+      refresh: vi.fn(),
+      execute: vi.fn(),
+      clear: vi.fn(),
+    });
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    expect(wrapper.findAll(".status-legend").length).toBe(1);
+  });
+
   test("No projects returned", async () => {
     const emptyResp: ProjectNode[] = [];
     vi.mocked(getProjectNodes).mockResolvedValue({
diff --git a/test/components/shared/DataStoreBadge.spec.ts b/test/components/shared/DataStoreBadge.spec.ts
new file mode 100644
index 0000000..e1da80f
--- /dev/null
+++ b/test/components/shared/DataStoreBadge.spec.ts
@@ -0,0 +1,65 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, test } from "vitest";
+import DataStoreBadge from "~/components/shared/DataStoreBadge.vue";
+
+describe("DataStoreBadge.vue", () => {
+  test("shows a check when the data store is present", () => {
+    const wrapper = mount(DataStoreBadge, {
+      props: { hasDataStore: true, required: true, projectId: "proj-1" },
+    });
+
+    expect(wrapper.find(".pi-check").exists()).toBe(true);
+    expect(wrapper.find("button").exists()).toBe(false);
+  });
+
+  test("shows an actionable cross when the data store is missing and required", () => {
+    const wrapper = mount(DataStoreBadge, {
+      props: { hasDataStore: false, required: true, projectId: "proj-1" },
+    });
+
+    const button = wrapper.find("button");
+    expect(wrapper.find(".pi-times").exists()).toBe(true);
+    expect(button.attributes("disabled")).toBeUndefined();
+    expect(button.attributes("aria-label")).toContain("create a data store");
+  });
+
+  test("disables the cross when a data store is not required", () => {
+    const wrapper = mount(DataStoreBadge, {
+      props: { hasDataStore: false, required: false, projectId: "proj-1" },
+    });
+
+    const button = wrapper.find("button");
+    expect(button.attributes("disabled")).toBeDefined();
+    expect(button.attributes("aria-label")).toContain("not required");
+  });
+
+  test("emits createDataStore with the project id when clicked", async () => {
+    const wrapper = mount(DataStoreBadge, {
+      props: { hasDataStore: false, required: true, projectId: "proj-1" },
+    });
+
+    await wrapper.find("button").trigger("click");
+
+    expect(wrapper.emitted("createDataStore")).toEqual([["proj-1"]]);
+  });
+
+  test("emits createDataStore with a null project id when there is none", async () => {
+    const wrapper = mount(DataStoreBadge, {
+      props: { hasDataStore: false, required: true, projectId: null },
+    });
+
+    await wrapper.find("button").trigger("click");
+
+    expect(wrapper.emitted("createDataStore")).toEqual([[null]]);
+  });
+
+  test("does not emit when a data store is not required", async () => {
+    const wrapper = mount(DataStoreBadge, {
+      props: { hasDataStore: false, required: false, projectId: "proj-1" },
+    });
+
+    await wrapper.find("button").trigger("click");
+
+    expect(wrapper.emitted("createDataStore")).toBeUndefined();
+  });
+});
diff --git a/test/composables/useProjectAnalysisSummary.test.ts b/test/composables/useProjectAnalysisSummary.test.ts
new file mode 100644
index 0000000..8ae03da
--- /dev/null
+++ b/test/composables/useProjectAnalysisSummary.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  fetchAllAnalysisNodes,
+  fetchDataStoreProjectIds,
+  fetchExecutionStatuses,
+  mergeExecutionStatuses,
+} from "~/composables/useProjectAnalysisSummary";
+import { PodStatus, type AnalysisNode } from "~/services/Api";
+
+function page(size: number, idPrefix = "a"): AnalysisNode[] {
+  return Array.from({ length: size }, (_, i) => ({
+    analysis_id: `${idPrefix}-${i}`,
+  })) as unknown as AnalysisNode[];
+}
+
+describe("fetchAllAnalysisNodes", () => {
+  it("stops after a short page", async () => {
+    const hubApi = vi
+      .fn()
+      .mockResolvedValueOnce(page(50, "p1"))
+      .mockResolvedValueOnce(page(7, "p2"));
+
+    const result = await fetchAllAnalysisNodes(hubApi);
+
+    expect(result).toHaveLength(57);
+    expect(hubApi).toHaveBeenCalledTimes(2);
+    expect(hubApi.mock.calls[0][1].query.page).toEqual({ offset: 0, limit: 50 });
+    expect(hubApi.mock.calls[1][1].query.page).toEqual({ offset: 50, limit: 50 });
+  });
+
+  it("stops on an empty page", async () => {
+    const hubApi = vi
+      .fn()
+      .mockResolvedValueOnce(page(50))
+      .mockResolvedValueOnce([]);
+    expect(await fetchAllAnalysisNodes(hubApi)).toHaveLength(50);
+  });
+
+  it("returns what it has when a page request fails", async () => {
+    const hubApi = vi
+      .fn()
+      .mockResolvedValueOnce(page(50))
+      .mockRejectedValueOnce(new Error("boom"));
+    expect(await fetchAllAnalysisNodes(hubApi)).toHaveLength(50);
+  });
+
+  it("caps pagination so a misbehaving API cannot loop forever", async () => {
+    const hubApi = vi.fn().mockResolvedValue(page(50));
+    const result = await fetchAllAnalysisNodes(hubApi);
+    expect(hubApi).toHaveBeenCalledTimes(40);
+    expect(result).toHaveLength(2000);
+  });
+});
+
+describe("fetchDataStoreProjectIds", () => {
+  it("collects project ids from route tags", async () => {
+    const hubApi = vi.fn().mockResolvedValue({
+      data: [
+        { tags: ["project:proj-1", "type:fhir"] },
+        { tags: ["project:proj-2"] },
+        { tags: ["health"] },
+        { tags: null },
+      ],
+    });
+    const result = await fetchDataStoreProjectIds(hubApi);
+    expect(result).toEqual(new Set(["proj-1", "proj-2"]));
+  });
+
+  it("returns an empty set when Kong is unreachable", async () => {
+    const hubApi = vi.fn().mockRejectedValue(new Error("boom"));
+    expect(await fetchDataStoreProjectIds(hubApi)).toEqual(new Set());
+  });
+});
+
+describe("fetchExecutionStatuses", () => {
+  it("returns undefined when the pod orchestrator is unreachable", async () => {
+    const hubApi = vi.fn().mockRejectedValue(new Error("boom"));
+    expect(await fetchExecutionStatuses(hubApi)).toBeUndefined();
+  });
+});
+
+describe("mergeExecutionStatuses", () => {
+  const node = (analysisId: string, executionStatus: PodStatus | null) =>
+    ({ analysis_id: analysisId, execution_status: executionStatus }) as unknown as AnalysisNode;
+
+  it("prefers the pod orchestrator's status", () => {
+    const result = mergeExecutionStatuses(
+      [node("a-1", PodStatus.Executed)],
+      { "a-1": { status: PodStatus.Executing, progress: 40 } } as never,
+    );
+    expect(result[0].execution_status).toBe(PodStatus.Executing);
+  });
+
+  it("keeps failed and executed Hub statuses when the pod orchestrator has no entry", () => {
+    const result = mergeExecutionStatuses(
+      [node("a-1", PodStatus.Failed), node("a-2", PodStatus.Executed)],
+      {} as never,
+    );
+    expect(result[0].execution_status).toBe(PodStatus.Failed);
+    expect(result[1].execution_status).toBe(PodStatus.Executed);
+  });
+
+  it("discards other Hub statuses when the pod orchestrator has no entry", () => {
+    const result = mergeExecutionStatuses([node("a-1", PodStatus.Started)], {} as never);
+    expect(result[0].execution_status).toBeNull();
+  });
+
+  it("discards non-terminal Hub statuses when the pod orchestrator is unreachable", () => {
+    const result = mergeExecutionStatuses([node("a-1", PodStatus.Executing)], undefined);
+    expect(result[0].execution_status).toBeNull();
+  });
+
+  it("does not mutate the input nodes", () => {
+    const input = [node("a-1", PodStatus.Started)];
+    mergeExecutionStatuses(input, {} as never);
+    expect(input[0].execution_status).toBe(PodStatus.Started);
+  });
+});
diff --git a/test/utils/summarise-project-analyses.test.ts b/test/utils/summarise-project-analyses.test.ts
new file mode 100644
index 0000000..9fd651a
--- /dev/null
+++ b/test/utils/summarise-project-analyses.test.ts
@@ -0,0 +1,286 @@
+import { describe, expect, it } from "vitest";
+import {
+  deriveProjectStatus,
+  emptyProjectAnalysisSummary,
+  PROJECT_STATUS_FILTER_OPTIONS,
+  type ProjectAnalysisSummary,
+  summariseProjectAnalyses,
+} from "~/utils/summarise-project-analyses";
+import { type AnalysisNode, PodStatus } from "~/services/Api";
+
+const PROJECT_A = "aaaaaaaa-0000-0000-0000-000000000000";
+const PROJECT_B = "bbbbbbbb-0000-0000-0000-000000000000";
+
+function makeNode(overrides: {
+  projectId?: string;
+  executionStatus?: PodStatus | null;
+  approvalStatus?: "approved" | "rejected" | null;
+  buildStatus?: string | null;
+  distributionStatus?: string | null;
+}): AnalysisNode {
+  return {
+    approval_status:
+      overrides.approvalStatus !== undefined
+        ? overrides.approvalStatus
+        : "approved",
+    execution_status:
+      overrides.executionStatus !== undefined
+        ? overrides.executionStatus
+        : null,
+    analysis: {
+      project_id:
+        overrides.projectId !== undefined ? overrides.projectId : PROJECT_A,
+      build_status:
+        overrides.buildStatus !== undefined
+          ? overrides.buildStatus
+          : "executed",
+      distribution_status:
+        overrides.distributionStatus !== undefined
+          ? overrides.distributionStatus
+          : "executed",
+    },
+  } as unknown as AnalysisNode;
+}
+
+describe("emptyProjectAnalysisSummary", () => {
+  it("returns all-zero counts and carries hasDataStore through", () => {
+    expect(emptyProjectAnalysisSummary(true)).toEqual({
+      total: 0,
+      executed: 0,
+      running: 0,
+      failed: 0,
+      stopped: 0,
+      waiting: 0,
+      idle: 0,
+      hasDataStore: true,
+    });
+    expect(emptyProjectAnalysisSummary(false).hasDataStore).toBe(false);
+  });
+});
+
+describe("summariseProjectAnalyses", () => {
+  it("returns an empty map for no analysis nodes", () => {
+    expect(summariseProjectAnalyses([], new Set()).size).toBe(0);
+  });
+
+  it("groups counts by project id", () => {
+    const result = summariseProjectAnalyses(
+      [
+        makeNode({ projectId: PROJECT_A, executionStatus: PodStatus.Executed }),
+        makeNode({ projectId: PROJECT_A, executionStatus: PodStatus.Failed }),
+        makeNode({ projectId: PROJECT_B, executionStatus: PodStatus.Executed }),
+      ],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.total).toBe(2);
+    expect(result.get(PROJECT_A)!.failed).toBe(1);
+    expect(result.get(PROJECT_B)!.total).toBe(1);
+  });
+
+  it("counts failed as failed", () => {
+    const result = summariseProjectAnalyses(
+      [makeNode({ executionStatus: PodStatus.Failed })],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.failed).toBe(1);
+  });
+
+  it("counts starting, started and executing as running", () => {
+    const result = summariseProjectAnalyses(
+      [
+        makeNode({ executionStatus: PodStatus.Starting }),
+        makeNode({ executionStatus: PodStatus.Started }),
+        makeNode({ executionStatus: PodStatus.Executing }),
+      ],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.running).toBe(3);
+  });
+
+  it("counts stopping and stopped as stopped", () => {
+    const result = summariseProjectAnalyses(
+      [
+        makeNode({ executionStatus: PodStatus.Stopping }),
+        makeNode({ executionStatus: PodStatus.Stopped }),
+      ],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.stopped).toBe(2);
+  });
+
+  it("counts an unapproved analysis with no execution status as waiting", () => {
+    const result = summariseProjectAnalyses(
+      [makeNode({ approvalStatus: null, executionStatus: null })],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.waiting).toBe(1);
+    expect(result.get(PROJECT_A)!.idle).toBe(0);
+  });
+
+  it("counts an unbuilt or undistributed analysis as waiting", () => {
+    const result = summariseProjectAnalyses(
+      [
+        makeNode({ buildStatus: null }),
+        makeNode({ distributionStatus: "starting" }),
+      ],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.waiting).toBe(2);
+  });
+
+  it("counts a fully-approved, built and distributed analysis with no execution status as idle", () => {
+    const result = summariseProjectAnalyses([makeNode({})], new Set());
+    expect(result.get(PROJECT_A)!.idle).toBe(1);
+    expect(result.get(PROJECT_A)!.waiting).toBe(0);
+  });
+
+  it("classifies by execution status even when the Hub is incomplete", () => {
+    const result = summariseProjectAnalyses(
+      [makeNode({ executionStatus: PodStatus.Executing, buildStatus: null })],
+      new Set(),
+    );
+    expect(result.get(PROJECT_A)!.running).toBe(1);
+    expect(result.get(PROJECT_A)!.waiting).toBe(0);
+  });
+
+  it("sets hasDataStore from the supplied set", () => {
+    const result = summariseProjectAnalyses(
+      [makeNode({ projectId: PROJECT_A }), makeNode({ projectId: PROJECT_B })],
+      new Set([PROJECT_A]),
+    );
+    expect(result.get(PROJECT_A)!.hasDataStore).toBe(true);
+    expect(result.get(PROJECT_B)!.hasDataStore).toBe(false);
+  });
+
+  it("skips analysis nodes with no project id", () => {
+    const orphan = {
+      approval_status: "approved",
+      analysis: {},
+    } as unknown as AnalysisNode;
+    expect(summariseProjectAnalyses([orphan], new Set()).size).toBe(0);
+  });
+
+  it("keeps every counted analysis in exactly one bucket", () => {
+    const result = summariseProjectAnalyses(
+      [
+        makeNode({ executionStatus: PodStatus.Executed }),
+        makeNode({ executionStatus: PodStatus.Failed }),
+        makeNode({ executionStatus: PodStatus.Executing }),
+        makeNode({ executionStatus: PodStatus.Stopped }),
+        makeNode({ approvalStatus: null }),
+        makeNode({}),
+      ],
+      new Set(),
+    );
+    const s = result.get(PROJECT_A)!;
+    expect(
+      s.executed + s.failed + s.running + s.stopped + s.waiting + s.idle,
+    ).toBe(s.total);
+  });
+});
+
+describe("deriveProjectStatus", () => {
+  function summary(overrides: Partial<ProjectAnalysisSummary> = {}) {
+    return { ...emptyProjectAnalysisSummary(true), ...overrides };
+  }
+
+  it("reports no analyses when the project has none on this node", () => {
+    const status = deriveProjectStatus(summary({ total: 0 }), true);
+    expect(status.key).toBe("noAnalyses");
+    expect(status.severity).toBe("secondary");
+    expect(status.rank).toBe(7);
+  });
+
+  it("reports a missing data store ahead of failures", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 4, failed: 3, hasDataStore: false }),
+      true,
+    );
+    expect(status.key).toBe("noDataStore");
+    expect(status.label).toBe("No data store");
+    expect(status.severity).toBe("danger");
+    expect(status.rank).toBe(1);
+  });
+
+  it("suppresses the data store check when a data store is not required", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 4, failed: 3, hasDataStore: false }),
+      false,
+    );
+    expect(status.key).toBe("failed");
+  });
+
+  it("reports failures with a count", () => {
+    const status = deriveProjectStatus(summary({ total: 5, failed: 2 }), true);
+    expect(status.label).toBe("2 failed");
+    expect(status.severity).toBe("danger");
+    expect(status.rank).toBe(2);
+  });
+
+  it("reports running ahead of waiting", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 5, running: 1, waiting: 3 }),
+      true,
+    );
+    expect(status.label).toBe("1 running");
+    expect(status.severity).toBe("info");
+    expect(status.rank).toBe(4);
+  });
+
+  it("reports waiting when nothing is running", () => {
+    const status = deriveProjectStatus(summary({ total: 3, waiting: 3 }), true);
+    expect(status.label).toBe("3 waiting");
+    expect(status.severity).toBe("warn");
+    expect(status.rank).toBe(3);
+  });
+
+  it("reports complete when every analysis has executed", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 4, executed: 4 }),
+      true,
+    );
+    expect(status.key).toBe("complete");
+    expect(status.label).toBe("Complete");
+    expect(status.severity).toBe("success");
+    expect(status.rank).toBe(6);
+  });
+
+  it("falls through to idle", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 4, executed: 1, stopped: 1, idle: 2 }),
+      true,
+    );
+    expect(status.key).toBe("idle");
+    expect(status.label).toBe("Idle");
+    expect(status.rank).toBe(5);
+  });
+
+  it("sorts worst-first by rank", () => {
+    const ranks = [
+      deriveProjectStatus(summary({ total: 1, hasDataStore: false }), true)
+        .rank,
+      deriveProjectStatus(summary({ total: 1, failed: 1 }), true).rank,
+      deriveProjectStatus(summary({ total: 1, waiting: 1 }), true).rank,
+      deriveProjectStatus(summary({ total: 1, running: 1 }), true).rank,
+      deriveProjectStatus(summary({ total: 2, executed: 1, idle: 1 }), true)
+        .rank,
+      deriveProjectStatus(summary({ total: 1, executed: 1 }), true).rank,
+      deriveProjectStatus(summary({ total: 0 }), true).rank,
+    ];
+    expect(ranks).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  });
+});
+
+describe("PROJECT_STATUS_FILTER_OPTIONS", () => {
+  it("offers one option per status key", () => {
+    expect(PROJECT_STATUS_FILTER_OPTIONS.map((o) => o.value)).toEqual([
+      "noDataStore",
+      "failed",
+      "waiting",
+      "running",
+      "idle",
+      "complete",
+      "noAnalyses",
+    ]);
+  });
+});

From b15538531f1c7b5d5340889c7ecfd8ccc73ddb5e Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 19:12:14 +0200
Subject: [PATCH 06/10] fix(project): handle stopped and share DS badge

---
 app/components/analysis/AnalysesTable.vue    |  2 +-
 app/components/projects/ProjectsTable.vue    | 39 ++++++++++++++++++--
 app/composables/useProjectAnalysisSummary.ts | 19 ++++++++--
 app/utils/summarise-project-analyses.ts      | 12 ++++--
 4 files changed, 60 insertions(+), 12 deletions(-)

diff --git a/app/components/analysis/AnalysesTable.vue b/app/components/analysis/AnalysesTable.vue
index b40244f..e7c9c2e 100644
--- a/app/components/analysis/AnalysesTable.vue
+++ b/app/components/analysis/AnalysesTable.vue
@@ -743,7 +743,7 @@ const onCloseNavToast = () => {
             </template>
             <template #body="{ data }">
               <DataStoreBadge
-                :hasDataStore="data.datastore"
+                :hasDataStore="!!data.datastore"
                 :projectId="data.analysis.project_id"
                 :required="datastoreRequired!"
                 @createDataStore="onCreateDataStore"
diff --git a/app/components/projects/ProjectsTable.vue b/app/components/projects/ProjectsTable.vue
index d51e062..0561810 100644
--- a/app/components/projects/ProjectsTable.vue
+++ b/app/components/projects/ProjectsTable.vue
@@ -11,6 +11,7 @@ import {
 } from "~/utils/summarise-project-analyses";
 import { type ProjectNode } from "~/services/Api";
 import { FilterMatchMode } from "@primevue/core/api";
+import Message from "primevue/message";
 import SearchBar from "~/components/table/SearchBar.vue";
 import DataStoreBadge from "~/components/shared/DataStoreBadge.vue";
 
@@ -22,8 +23,13 @@ const expandRowEntries = [];
 
 const filters = ref();
 
-const { requireDataStore } = useDatastoreRequirement();
-const { refreshSummaries, summaryFor } = useProjectAnalysisSummary();
+const { nodeType, requireDataStore } = useDatastoreRequirement();
+const {
+  loading: summariesLoading,
+  truncated,
+  refreshSummaries,
+  summaryFor,
+} = useProjectAnalysisSummary();
 
 const METER_BUCKETS = [
   { key: "executed", label: "Executed" },
@@ -79,6 +85,8 @@ function parseData() {
 await refreshSummaries();
 parseData();
 
+watch(requireDataStore, () => parseData());
+
 async function onTableRefresh() {
   await Promise.all([refresh(), refreshSummaries()]);
   parseData();
@@ -140,7 +148,7 @@ const updateFilters = (filterText: string) => {
           <div class="card flex justify-content-center refresh-switch">
             <Button
               v-tooltip.top="'Refresh table'"
-              :loading="status === 'pending'"
+              :loading="status === 'pending' || summariesLoading"
               aria-label="Refresh table"
               icon="pi pi-refresh"
               severity="contrast"
@@ -148,17 +156,29 @@ const updateFilters = (filterText: string) => {
             />
           </div>
         </div>
+        <Message
+          v-if="truncated"
+          class="status-truncation-warning"
+          icon="pi pi-exclamation-triangle"
+          severity="warn"
+        >
+          More analyses are registered on this node than can be loaded at once.
+          The analysis counts and statuses below are partial and exclude the
+          least recently updated analyses.
+        </Message>
         <DataTable
           v-model:expandedRows="expandedRows"
           v-model:filters="filters"
           :globalFilterFields="['id', 'project_name', 'node.name']"
           :rows="10"
           :rowsPerPageOptions="[10, 20, 50]"
+          :sortOrder="1"
           :value="proposals"
           class="rounded-table project-table structured-table"
           dataKey="id"
           filterDisplay="menu"
           paginator
+          sortField="project_status.rank"
           tableStyle="min-width: 50rem"
         >
           <template #empty> No projects found.</template>
@@ -203,6 +223,7 @@ const updateFilters = (filterText: string) => {
             :showClearButton="false"
             :showFilterMatchModes="false"
             :showFilterOperator="false"
+            :sortable="true"
             field="project_status.rank"
             filterField="project_status.key"
           >
@@ -225,7 +246,9 @@ const updateFilters = (filterText: string) => {
                 <div
                   v-if="data.summary.total > 0"
                   v-tooltip.top="meterTooltip(data.summary)"
+                  :aria-label="meterTooltip(data.summary)"
                   class="status-meter"
+                  role="img"
                 >
                   <span
                     v-for="segment in meterSegments(data.summary)"
@@ -248,7 +271,11 @@ const updateFilters = (filterText: string) => {
               />
             </template>
           </Column>
-          <Column :sortable="true" field="summary.hasDataStore">
+          <Column
+            :hidden="nodeType === 'aggregator'"
+            :sortable="true"
+            field="summary.hasDataStore"
+          >
             <template #header>
               <span
                 v-tooltip.top="'Whether the project has a data store'"
@@ -303,6 +330,10 @@ const updateFilters = (filterText: string) => {
 </template>
 
 <style>
+.status-truncation-warning {
+  margin: 0.75rem 0;
+}
+
 .project-status {
   display: flex;
   flex-direction: column;
diff --git a/app/composables/useProjectAnalysisSummary.ts b/app/composables/useProjectAnalysisSummary.ts
index aad6ab4..e9cb689 100644
--- a/app/composables/useProjectAnalysisSummary.ts
+++ b/app/composables/useProjectAnalysisSummary.ts
@@ -27,10 +27,16 @@ const FINISHED_STATUSES: Array<PodStatus | null | undefined> = [
   PodStatus.Executed,
 ];
 
+export interface AnalysisNodeFetchResult {
+  nodes: AnalysisNode[];
+  truncated: boolean;
+}
+
 export async function fetchAllAnalysisNodes(
   hubApi: HubFetch,
-): Promise<AnalysisNode[]> {
+): Promise<AnalysisNodeFetchResult> {
   const allNodes: AnalysisNode[] = [];
+  let truncated = false;
 
   for (let pageIndex = 0; pageIndex < MAX_PAGES; pageIndex++) {
     const nextPage = (await hubApi("/analysis-nodes", {
@@ -45,9 +51,11 @@ export async function fetchAllAnalysisNodes(
     if (!nextPage || nextPage.length === 0) break;
     allNodes.push(...nextPage);
     if (nextPage.length < PAGE_LIMIT) break;
+    // Full set = yet more results to fetch
+    if (pageIndex === MAX_PAGES - 1) truncated = true;
   }
 
-  return allNodes;
+  return { nodes: allNodes, truncated };
 }
 
 export async function fetchDataStoreProjectIds(
@@ -98,12 +106,13 @@ export function useProjectAnalysisSummary() {
   const summaries = ref<Map<string, ProjectAnalysisSummary>>(new Map());
   const dataStoreProjectIds = ref<Set<string>>(new Set());
   const loading = ref(false);
+  const truncated = ref(false);
 
   async function refreshSummaries() {
     loading.value = true;
     try {
       const hubApi = useNuxtApp().$hubApi as unknown as HubFetch;
-      const [analysisNodes, projectIdsWithDataStore, executionStatuses] =
+      const [analysisNodeResult, projectIdsWithDataStore, executionStatuses] =
         await Promise.all([
           fetchAllAnalysisNodes(hubApi),
           fetchDataStoreProjectIds(hubApi),
@@ -111,8 +120,9 @@ export function useProjectAnalysisSummary() {
         ]);
 
       dataStoreProjectIds.value = projectIdsWithDataStore;
+      truncated.value = analysisNodeResult.truncated;
       summaries.value = summariseProjectAnalyses(
-        mergeExecutionStatuses(analysisNodes, executionStatuses),
+        mergeExecutionStatuses(analysisNodeResult.nodes, executionStatuses),
         projectIdsWithDataStore,
       );
     } finally {
@@ -135,6 +145,7 @@ export function useProjectAnalysisSummary() {
     summaries,
     dataStoreProjectIds,
     loading,
+    truncated,
     refreshSummaries,
     summaryFor,
   };
diff --git a/app/utils/summarise-project-analyses.ts b/app/utils/summarise-project-analyses.ts
index 5f6205c..18791cf 100644
--- a/app/utils/summarise-project-analyses.ts
+++ b/app/utils/summarise-project-analyses.ts
@@ -90,6 +90,7 @@ export type ProjectStatusKey =
   | "failed"
   | "waiting"
   | "running"
+  | "stopped"
   | "idle"
   | "complete"
   | "noAnalyses";
@@ -114,9 +115,10 @@ const STATUS_RANK: Record<ProjectStatusKey, number> = {
   failed: 2,
   waiting: 3,
   running: 4,
-  idle: 5,
-  complete: 6,
-  noAnalyses: 7,
+  stopped: 5,
+  idle: 6,
+  complete: 7,
+  noAnalyses: 8,
 };
 
 const STATUS_SEVERITY: Record<ProjectStatusKey, ProjectStatusSeverity> = {
@@ -124,6 +126,7 @@ const STATUS_SEVERITY: Record<ProjectStatusKey, ProjectStatusSeverity> = {
   failed: "danger",
   waiting: "warn",
   running: "info",
+  stopped: "warn",
   idle: "secondary",
   complete: "success",
   noAnalyses: "secondary",
@@ -145,6 +148,8 @@ export function deriveProjectStatus(
     return status("running", `${summary.running} running`);
   if (summary.waiting > 0)
     return status("waiting", `${summary.waiting} waiting`);
+  if (summary.stopped > 0)
+    return status("stopped", `${summary.stopped} stopped`);
   if (summary.executed === summary.total) return status("complete", "Complete");
   return status("idle", "Idle");
 }
@@ -157,6 +162,7 @@ export const PROJECT_STATUS_FILTER_OPTIONS: Array<{
   { label: "Failed", value: "failed" },
   { label: "Waiting on Hub", value: "waiting" },
   { label: "Running", value: "running" },
+  { label: "Stopped", value: "stopped" },
   { label: "Idle", value: "idle" },
   { label: "Complete", value: "complete" },
   { label: "No analyses", value: "noAnalyses" },

From 5bf111dee4f2185d746f147bb842c090b39f991c Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 19:13:14 +0200
Subject: [PATCH 07/10] test(project): update tests for fixes

---
 .../components/projects/ProjectsTable.spec.ts | 278 +++++++++++++-----
 test/components/projects/constants.ts         |  21 ++
 .../useProjectAnalysisSummary.test.ts         |  29 +-
 test/utils/summarise-project-analyses.test.ts |  32 +-
 4 files changed, 270 insertions(+), 90 deletions(-)

diff --git a/test/components/projects/ProjectsTable.spec.ts b/test/components/projects/ProjectsTable.spec.ts
index 5a1937e..e108e90 100644
--- a/test/components/projects/ProjectsTable.spec.ts
+++ b/test/components/projects/ProjectsTable.spec.ts
@@ -2,6 +2,7 @@ import { useToast } from "primevue/usetoast";
 import { computed, defineComponent } from "vue";
 import { flushPromises, mount } from "@vue/test-utils";
 import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+import { FilterMatchMode } from "@primevue/core/api";
 import ProjectsTable from "~/components/projects/ProjectsTable.vue";
 import { getProjectNodes } from "~/composables/useAPIFetch";
 import { useDatastoreRequirement } from "~/composables/useDatastoreRequirement";
@@ -9,7 +10,12 @@ import { useProjectAnalysisSummary } from "~/composables/useProjectAnalysisSumma
 import { emptyProjectAnalysisSummary } from "~/utils/summarise-project-analyses";
 import type { ProjectAnalysisSummary } from "~/utils/summarise-project-analyses";
 import type { ProjectNode } from "~/services/Api";
-import { fakeProposalsResp } from "@/test/components/projects/constants";
+import {
+  FAKE_PROJECT_ID,
+  SECOND_FAKE_PROJECT_ID,
+  fakeProposalsResp,
+  fakeTwoProposalsResp,
+} from "@/test/components/projects/constants";
 
 vi.mock("~/composables/useAPIFetch", () => ({
   getProjectNodes: vi.fn(),
@@ -23,22 +29,53 @@ vi.mock("~/composables/useProjectAnalysisSummary", () => ({
   useProjectAnalysisSummary: vi.fn(),
 }));
 
-const FAKE_PROJECT_ID = "7f2f3b59-3b6d-4fb6-a900-2a4d5c2ea483";
+function mockProjectNodes(
+  data: ProjectNode[] | undefined,
+  status: "success" | "error" = "success",
+) {
+  vi.mocked(getProjectNodes).mockResolvedValue({
+    data: ref(data),
+    pending: ref(false),
+    error: ref(undefined),
+    status: ref(status),
+    refresh: vi.fn(),
+    execute: vi.fn(),
+    clear: vi.fn(),
+  });
+}
+
+function mockSummaries(
+  entries: Record<string, Partial<ProjectAnalysisSummary>>,
+  composableOverrides: { truncated?: boolean; loading?: boolean } = {},
+) {
+  const summaries = new Map<string, ProjectAnalysisSummary>(
+    Object.entries(entries).map(([projectId, overrides]) => [
+      projectId,
+      { ...emptyProjectAnalysisSummary(true), ...overrides },
+    ]),
+  );
 
-function mockSummary(overrides: Partial<ProjectAnalysisSummary> = {}) {
-  const summary = { ...emptyProjectAnalysisSummary(true), ...overrides };
   vi.mocked(useProjectAnalysisSummary).mockReturnValue({
-    summaries: ref(new Map([[FAKE_PROJECT_ID, summary]])),
-    dataStoreProjectIds: ref(new Set([FAKE_PROJECT_ID])),
-    loading: ref(false),
+    summaries: ref(summaries),
+    dataStoreProjectIds: ref(new Set(summaries.keys())),
+    loading: ref(composableOverrides.loading ?? false),
+    truncated: ref(composableOverrides.truncated ?? false),
     refreshSummaries: vi.fn(),
     // Id-aware on purpose: a mock that ignored its argument would pass even if
     // the component looked the summary up by the wrong id (row.id, node_id...).
     summaryFor: (id: string | undefined | null) =>
-      id === FAKE_PROJECT_ID ? summary : emptyProjectAnalysisSummary(false),
+      (id ? summaries.get(id) : undefined) ??
+      emptyProjectAnalysisSummary(false),
   } as never);
 }
 
+function mockSummary(
+  overrides: Partial<ProjectAnalysisSummary> = {},
+  composableOverrides: { truncated?: boolean; loading?: boolean } = {},
+) {
+  mockSummaries({ [FAKE_PROJECT_ID]: overrides }, composableOverrides);
+}
+
 describe("ProjectsTable.vue", () => {
   let mockToast;
   let ProjectsTableTestComponent;
@@ -63,15 +100,7 @@ describe("ProjectsTable.vue", () => {
   });
 
   test("Return project data", async () => {
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(fakeProposalsResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(fakeProposalsResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
@@ -105,35 +134,18 @@ describe("ProjectsTable.vue", () => {
 
   test("Marks a project that has a data store", async () => {
     mockSummary({ total: 2, executed: 2, hasDataStore: true });
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(fakeProposalsResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(fakeProposalsResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
 
     const dataStoreCell = wrapper.findAll("tbody tr")[0].findAll("td")[4];
     expect(dataStoreCell.find(".pi-check").exists()).toBe(true);
-    expect(dataStoreCell.find("a").exists()).toBe(false);
   });
 
   test("Links a project with no data store to data store creation", async () => {
     mockSummary({ total: 2, waiting: 2, hasDataStore: false });
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(fakeProposalsResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(fakeProposalsResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
@@ -145,17 +157,51 @@ describe("ProjectsTable.vue", () => {
     );
   });
 
+  test("Hides the data store column on an aggregator node", async () => {
+    vi.mocked(useDatastoreRequirement).mockReturnValue({
+      nodeType: computed(() => "aggregator"),
+      requireDataStore: computed(() => false),
+    } as never);
+    mockSummary({ total: 2, executed: 2, hasDataStore: false });
+    mockProjectNodes(fakeProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const headerCols = wrapper.findAll("thead tr")[0].findAll("th");
+    expect(headerCols.length).toBe(6);
+    expect(headerCols.map((col) => col.text())).not.toContain("Data Store");
+  });
+
+  test("Re-derives the status when the data store requirement resolves late", async () => {
+    // The node settings plugin does not await fetchSettings(), so the getter
+    // sits at its default `true` until the request lands.
+    const requireDataStore = ref(true);
+    vi.mocked(useDatastoreRequirement).mockReturnValue({
+      nodeType: computed(() => "default"),
+      requireDataStore,
+    } as never);
+    mockSummary({ total: 3, failed: 2, idle: 1, hasDataStore: false });
+    mockProjectNodes(fakeProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const statusCell = () =>
+      wrapper.findAll("tbody tr")[0].findAll("td")[3].text();
+    expect(statusCell()).toContain("No data store");
+
+    requireDataStore.value = false;
+    await flushPromises();
+
+    // The verdict must follow the setting, otherwise it contradicts the
+    // "not required" data store badge rendered from the same setting.
+    expect(statusCell()).toContain("2 failed");
+  });
+
   test("Renders the status tag and one meter segment per non-empty bucket", async () => {
     mockSummary({ total: 6, executed: 3, failed: 2, idle: 1 });
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(fakeProposalsResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(fakeProposalsResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
@@ -170,17 +216,21 @@ describe("ProjectsTable.vue", () => {
     expect(segments[2].classes()).toContain("status-meter-idle");
   });
 
+  test("Exposes the meter counts to assistive technology", async () => {
+    mockSummary({ total: 6, executed: 3, failed: 2, idle: 1 });
+    mockProjectNodes(fakeProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const meter = wrapper.findAll("tbody tr")[0].find(".status-meter");
+    expect(meter.attributes("role")).toBe("img");
+    expect(meter.attributes("aria-label")).toBe("3 executed, 2 failed, 1 idle");
+  });
+
   test("Renders no meter when the project has no analyses on this node", async () => {
     mockSummary({ total: 0 });
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(fakeProposalsResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(fakeProposalsResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
@@ -192,15 +242,7 @@ describe("ProjectsTable.vue", () => {
 
   test("Renders the legend once, above the table", async () => {
     mockSummary({ total: 3, executed: 3 });
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(fakeProposalsResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(fakeProposalsResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
@@ -208,17 +250,99 @@ describe("ProjectsTable.vue", () => {
     expect(wrapper.findAll(".status-legend").length).toBe(1);
   });
 
+  test("Warns that the counts are partial when pagination was truncated", async () => {
+    mockSummary({ total: 3, executed: 3 }, { truncated: true });
+    mockProjectNodes(fakeProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const warning = wrapper.find(".status-truncation-warning");
+    expect(warning.exists()).toBe(true);
+    expect(warning.text()).toContain("partial");
+  });
+
+  test("Shows no truncation warning when everything was loaded", async () => {
+    mockSummary({ total: 3, executed: 3 }, { truncated: false });
+    mockProjectNodes(fakeProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    expect(wrapper.find(".status-truncation-warning").exists()).toBe(false);
+  });
+
+  test("Sorts rows worst-first by status rank", async () => {
+    // Healthy project first in the API response, broken one second — so raw
+    // (unsorted) order and rank order disagree.
+    mockSummaries({
+      [FAKE_PROJECT_ID]: { total: 4, executed: 4 }, // Complete, rank 7
+      [SECOND_FAKE_PROJECT_ID]: { total: 3, failed: 3 }, // 3 failed, rank 2
+    });
+    mockProjectNodes(fakeTwoProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    const names = () =>
+      wrapper.findAll("tbody tr").map((row) => row.findAll("td")[0].text());
+
+    expect(names()).toEqual(["second-project", "fake-project"]);
+    expect(wrapper.findAll("tbody tr")[0].findAll("td")[3].text()).toContain(
+      "3 failed",
+    );
+
+    // The column must also be sortable, otherwise the default ordering is
+    // fixed and the administrator cannot re-sort it.
+    const statusHeader = wrapper.findAll("thead tr")[0].findAll("th")[3];
+    expect(statusHeader.attributes("data-p-sortable-column")).toBe("true");
+
+    await statusHeader.trigger("click");
+    await flushPromises();
+
+    expect(names()).toEqual(["fake-project", "second-project"]);
+  });
+
+  test("Filters rows by the selected status", async () => {
+    mockSummaries({
+      [FAKE_PROJECT_ID]: { total: 4, executed: 4 }, // complete
+      [SECOND_FAKE_PROJECT_ID]: { total: 3, failed: 3 }, // failed
+    });
+    mockProjectNodes(fakeTwoProposalsResp);
+
+    const wrapper = mount(ProjectsTableTestComponent);
+    await flushPromises();
+
+    expect(wrapper.findAll("tbody tr").length).toBe(2);
+
+    // Drive the real filter menu rather than poking the filters object, so the
+    // column's filterField -> filterModel -> FilterMatchMode.IN wiring is
+    // exercised end to end.
+    const statusHeader = wrapper.findAll("thead tr")[0].findAll("th")[3];
+    await statusHeader
+      .find(".p-datatable-column-filter-button")
+      .trigger("click");
+    await flushPromises();
+
+    const statusFilter = wrapper.findComponent({ name: "MultiSelect" });
+    expect(statusFilter.exists()).toBe(true);
+    expect(
+      statusFilter.props("options").map((option) => option.value),
+    ).toContain("failed");
+
+    statusFilter.vm.$emit("update:modelValue", ["failed"]);
+    statusFilter.vm.$emit("change", { value: ["failed"] });
+    await flushPromises();
+
+    const rows = wrapper.findAll("tbody tr");
+    expect(rows.length).toBe(1);
+    expect(rows[0].findAll("td")[0].text()).toBe("second-project");
+    expect(rows[0].findAll("td")[3].text()).toContain("3 failed");
+  });
+
   test("No projects returned", async () => {
     const emptyResp: ProjectNode[] = [];
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(emptyResp),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("success"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(emptyResp);
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
@@ -228,15 +352,7 @@ describe("ProjectsTable.vue", () => {
   });
 
   test("API error", async () => {
-    vi.mocked(getProjectNodes).mockResolvedValue({
-      data: ref(undefined),
-      pending: ref(false),
-      error: ref(undefined),
-      status: ref("error"),
-      refresh: vi.fn(),
-      execute: vi.fn(),
-      clear: vi.fn(),
-    });
+    mockProjectNodes(undefined, "error");
 
     const wrapper = mount(ProjectsTableTestComponent);
     await flushPromises();
diff --git a/test/components/projects/constants.ts b/test/components/projects/constants.ts
index 516a5d1..f510314 100644
--- a/test/components/projects/constants.ts
+++ b/test/components/projects/constants.ts
@@ -1,5 +1,8 @@
 import type { ProjectNode } from "~/services/Api";
 
+export const FAKE_PROJECT_ID = "7f2f3b59-3b6d-4fb6-a900-2a4d5c2ea483";
+export const SECOND_FAKE_PROJECT_ID = "0d4c1e57-8b2a-4d16-9e33-5f7a1c8b2e90";
+
 export const fakeProposalsResp: ProjectNode[] = [
   {
     id: "73497486-a46d-49b4-b6ec-9f463e18d7dd",
@@ -43,3 +46,21 @@ export const fakeProposalsResp: ProjectNode[] = [
     },
   },
 ];
+
+// Two projects, deliberately supplied in the API's `-updated_at` order so that
+// the healthy one comes FIRST in the raw response. Any test asserting
+// worst-first order therefore fails if the table stops sorting by status rank.
+export const fakeTwoProposalsResp: ProjectNode[] = [
+  fakeProposalsResp[0]!,
+  {
+    ...fakeProposalsResp[0]!,
+    id: "1a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d",
+    project_id: SECOND_FAKE_PROJECT_ID,
+    project: {
+      ...fakeProposalsResp[0]!.project!,
+      id: SECOND_FAKE_PROJECT_ID,
+      name: "second-project",
+      display_name: "second-project",
+    },
+  },
+];
diff --git a/test/composables/useProjectAnalysisSummary.test.ts b/test/composables/useProjectAnalysisSummary.test.ts
index 8ae03da..c28b0b7 100644
--- a/test/composables/useProjectAnalysisSummary.test.ts
+++ b/test/composables/useProjectAnalysisSummary.test.ts
@@ -22,7 +22,8 @@ describe("fetchAllAnalysisNodes", () => {
 
     const result = await fetchAllAnalysisNodes(hubApi);
 
-    expect(result).toHaveLength(57);
+    expect(result.nodes).toHaveLength(57);
+    expect(result.truncated).toBe(false);
     expect(hubApi).toHaveBeenCalledTimes(2);
     expect(hubApi.mock.calls[0][1].query.page).toEqual({ offset: 0, limit: 50 });
     expect(hubApi.mock.calls[1][1].query.page).toEqual({ offset: 50, limit: 50 });
@@ -33,7 +34,9 @@ describe("fetchAllAnalysisNodes", () => {
       .fn()
       .mockResolvedValueOnce(page(50))
       .mockResolvedValueOnce([]);
-    expect(await fetchAllAnalysisNodes(hubApi)).toHaveLength(50);
+    const result = await fetchAllAnalysisNodes(hubApi);
+    expect(result.nodes).toHaveLength(50);
+    expect(result.truncated).toBe(false);
   });
 
   it("returns what it has when a page request fails", async () => {
@@ -41,14 +44,32 @@ describe("fetchAllAnalysisNodes", () => {
       .fn()
       .mockResolvedValueOnce(page(50))
       .mockRejectedValueOnce(new Error("boom"));
-    expect(await fetchAllAnalysisNodes(hubApi)).toHaveLength(50);
+    const result = await fetchAllAnalysisNodes(hubApi);
+    expect(result.nodes).toHaveLength(50);
+    expect(result.truncated).toBe(false);
   });
 
   it("caps pagination so a misbehaving API cannot loop forever", async () => {
     const hubApi = vi.fn().mockResolvedValue(page(50));
     const result = await fetchAllAnalysisNodes(hubApi);
     expect(hubApi).toHaveBeenCalledTimes(40);
-    expect(result).toHaveLength(2000);
+    expect(result.nodes).toHaveLength(2000);
+  });
+
+  it("reports truncation when it stops at the page cap", async () => {
+    const hubApi = vi.fn().mockResolvedValue(page(50));
+    expect((await fetchAllAnalysisNodes(hubApi)).truncated).toBe(true);
+  });
+
+  it("does not report truncation when the last page lands exactly on the cap", async () => {
+    // 39 full pages then a short one: every row was read, so nothing is missing
+    const hubApi = vi.fn().mockImplementation((_url, opts) => {
+      const offset = opts.query.page.offset;
+      return Promise.resolve(offset < 39 * 50 ? page(50) : page(10));
+    });
+    const result = await fetchAllAnalysisNodes(hubApi);
+    expect(result.nodes).toHaveLength(39 * 50 + 10);
+    expect(result.truncated).toBe(false);
   });
 });
 
diff --git a/test/utils/summarise-project-analyses.test.ts b/test/utils/summarise-project-analyses.test.ts
index 9fd651a..d08eabe 100644
--- a/test/utils/summarise-project-analyses.test.ts
+++ b/test/utils/summarise-project-analyses.test.ts
@@ -188,7 +188,7 @@ describe("deriveProjectStatus", () => {
     const status = deriveProjectStatus(summary({ total: 0 }), true);
     expect(status.key).toBe("noAnalyses");
     expect(status.severity).toBe("secondary");
-    expect(status.rank).toBe(7);
+    expect(status.rank).toBe(8);
   });
 
   it("reports a missing data store ahead of failures", () => {
@@ -242,17 +242,37 @@ describe("deriveProjectStatus", () => {
     expect(status.key).toBe("complete");
     expect(status.label).toBe("Complete");
     expect(status.severity).toBe("success");
-    expect(status.rank).toBe(6);
+    expect(status.rank).toBe(7);
+  });
+
+  it("reports stopped analyses ahead of complete", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 4, executed: 2, stopped: 2 }),
+      true,
+    );
+    expect(status.key).toBe("stopped");
+    expect(status.label).toBe("2 stopped");
+    expect(status.severity).toBe("warn");
+    expect(status.rank).toBe(5);
+  });
+
+  it("reports waiting ahead of stopped", () => {
+    const status = deriveProjectStatus(
+      summary({ total: 4, waiting: 1, stopped: 3 }),
+      true,
+    );
+    expect(status.key).toBe("waiting");
   });
 
   it("falls through to idle", () => {
     const status = deriveProjectStatus(
-      summary({ total: 4, executed: 1, stopped: 1, idle: 2 }),
+      summary({ total: 4, executed: 1, idle: 3 }),
       true,
     );
     expect(status.key).toBe("idle");
     expect(status.label).toBe("Idle");
-    expect(status.rank).toBe(5);
+    expect(status.severity).toBe("secondary");
+    expect(status.rank).toBe(6);
   });
 
   it("sorts worst-first by rank", () => {
@@ -262,12 +282,13 @@ describe("deriveProjectStatus", () => {
       deriveProjectStatus(summary({ total: 1, failed: 1 }), true).rank,
       deriveProjectStatus(summary({ total: 1, waiting: 1 }), true).rank,
       deriveProjectStatus(summary({ total: 1, running: 1 }), true).rank,
+      deriveProjectStatus(summary({ total: 1, stopped: 1 }), true).rank,
       deriveProjectStatus(summary({ total: 2, executed: 1, idle: 1 }), true)
         .rank,
       deriveProjectStatus(summary({ total: 1, executed: 1 }), true).rank,
       deriveProjectStatus(summary({ total: 0 }), true).rank,
     ];
-    expect(ranks).toEqual([1, 2, 3, 4, 5, 6, 7]);
+    expect(ranks).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
   });
 });
 
@@ -278,6 +299,7 @@ describe("PROJECT_STATUS_FILTER_OPTIONS", () => {
       "failed",
       "waiting",
       "running",
+      "stopped",
       "idle",
       "complete",
       "noAnalyses",

From 27bafd109f8ded9779f254ad09aa10f6b9b7ac47 Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 20:20:23 +0200
Subject: [PATCH 08/10] fix(ds): ensure tooltip always shows

---
 app/components/projects/ProjectsTable.vue     |  4 ++--
 app/components/shared/DataStoreBadge.vue      | 16 ++++++++++------
 test/components/shared/DataStoreBadge.spec.ts | 11 ++++++-----
 3 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/app/components/projects/ProjectsTable.vue b/app/components/projects/ProjectsTable.vue
index 0561810..9c35a66 100644
--- a/app/components/projects/ProjectsTable.vue
+++ b/app/components/projects/ProjectsTable.vue
@@ -7,7 +7,7 @@ import {
   deriveProjectStatus,
   PROJECT_STATUS_FILTER_OPTIONS,
   type ProjectAnalysisSummary,
-  type ProjectStatus,
+  type ProjectStatus
 } from "~/utils/summarise-project-analyses";
 import { type ProjectNode } from "~/services/Api";
 import { FilterMatchMode } from "@primevue/core/api";
@@ -190,7 +190,7 @@ const updateFilters = (filterText: string) => {
               </span>
             </template>
             <template #body="{ data }">
-              <span v-tooltip.right="data.project.id" class="help-text">
+              <span v-tooltip.right="data.project?.id" class="help-text">
                 {{ data.project_name }}
               </span>
             </template>
diff --git a/app/components/shared/DataStoreBadge.vue b/app/components/shared/DataStoreBadge.vue
index d27e710..dea1284 100644
--- a/app/components/shared/DataStoreBadge.vue
+++ b/app/components/shared/DataStoreBadge.vue
@@ -30,15 +30,23 @@ const missingTooltip = computed(() =>
       class="w-8 h-8 rounded-full"
     >
       <button
+        v-if="required"
         v-tooltip.top="missingTooltip"
         :aria-label="missingTooltip"
-        :class="['datastore-icon-btn', { 'datastore-create-link': required }]"
-        :disabled="!required"
+        class="datastore-icon-btn datastore-create-link"
         type="button"
         @click="emit('createDataStore', projectId)"
       >
         <i class="pi pi-times"></i>
       </button>
+      <span
+        v-else
+        v-tooltip.top="missingTooltip"
+        :aria-label="missingTooltip"
+        class="datastore-icon-btn"
+      >
+        <i class="pi pi-times"></i>
+      </span>
     </Badge>
   </div>
 </template>
@@ -60,10 +68,6 @@ const missingTooltip = computed(() =>
   font: inherit;
 }
 
-.datastore-icon-btn:disabled {
-  cursor: default;
-}
-
 .datastore-create-link {
   cursor: pointer;
 }
diff --git a/test/components/shared/DataStoreBadge.spec.ts b/test/components/shared/DataStoreBadge.spec.ts
index e1da80f..6060f56 100644
--- a/test/components/shared/DataStoreBadge.spec.ts
+++ b/test/components/shared/DataStoreBadge.spec.ts
@@ -23,14 +23,15 @@ describe("DataStoreBadge.vue", () => {
     expect(button.attributes("aria-label")).toContain("create a data store");
   });
 
-  test("disables the cross when a data store is not required", () => {
+  test("renders a non-interactive cross when a data store is not required", () => {
     const wrapper = mount(DataStoreBadge, {
       props: { hasDataStore: false, required: false, projectId: "proj-1" },
     });
 
-    const button = wrapper.find("button");
-    expect(button.attributes("disabled")).toBeDefined();
-    expect(button.attributes("aria-label")).toContain("not required");
+    expect(wrapper.find("button").exists()).toBe(false);
+    const span = wrapper.find("span.datastore-icon-btn");
+    expect(span.exists()).toBe(true);
+    expect(span.attributes("aria-label")).toContain("not required");
   });
 
   test("emits createDataStore with the project id when clicked", async () => {
@@ -58,7 +59,7 @@ describe("DataStoreBadge.vue", () => {
       props: { hasDataStore: false, required: false, projectId: "proj-1" },
     });
 
-    await wrapper.find("button").trigger("click");
+    await wrapper.find("span.datastore-icon-btn").trigger("click");
 
     expect(wrapper.emitted("createDataStore")).toBeUndefined();
   });

From 714a6c89935773e252ca40bf10e5ac5fbbca11e8 Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 20:20:55 +0200
Subject: [PATCH 09/10] fix(project): add stopped to checked stauses to avoid
 collision

---
 app/composables/useProjectAnalysisSummary.ts       | 1 +
 test/composables/useProjectAnalysisSummary.test.ts | 9 +++++++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/app/composables/useProjectAnalysisSummary.ts b/app/composables/useProjectAnalysisSummary.ts
index e9cb689..f3a28ea 100644
--- a/app/composables/useProjectAnalysisSummary.ts
+++ b/app/composables/useProjectAnalysisSummary.ts
@@ -25,6 +25,7 @@ const MAX_PAGES = 40;
 const FINISHED_STATUSES: Array<PodStatus | null | undefined> = [
   PodStatus.Failed,
   PodStatus.Executed,
+  PodStatus.Stopped,
 ];
 
 export interface AnalysisNodeFetchResult {
diff --git a/test/composables/useProjectAnalysisSummary.test.ts b/test/composables/useProjectAnalysisSummary.test.ts
index c28b0b7..f914a45 100644
--- a/test/composables/useProjectAnalysisSummary.test.ts
+++ b/test/composables/useProjectAnalysisSummary.test.ts
@@ -112,13 +112,18 @@ describe("mergeExecutionStatuses", () => {
     expect(result[0].execution_status).toBe(PodStatus.Executing);
   });
 
-  it("keeps failed and executed Hub statuses when the pod orchestrator has no entry", () => {
+  it("keeps failed, executed and stopped Hub statuses when the pod orchestrator has no entry", () => {
     const result = mergeExecutionStatuses(
-      [node("a-1", PodStatus.Failed), node("a-2", PodStatus.Executed)],
+      [
+        node("a-1", PodStatus.Failed),
+        node("a-2", PodStatus.Executed),
+        node("a-3", PodStatus.Stopped),
+      ],
       {} as never,
     );
     expect(result[0].execution_status).toBe(PodStatus.Failed);
     expect(result[1].execution_status).toBe(PodStatus.Executed);
+    expect(result[2].execution_status).toBe(PodStatus.Stopped);
   });
 
   it("discards other Hub statuses when the pod orchestrator has no entry", () => {

From ecc5cc13f7c4465eade621a393e863c9f9a68b87 Mon Sep 17 00:00:00 2001
From: Bruce Schultz <bschultz013@gmail.com>
Date: Tue, 4 Aug 2026 20:30:18 +0200
Subject: [PATCH 10/10] fix(project): prevent errors from masquerading as end
 of results

---
 app/composables/useProjectAnalysisSummary.ts  | 69 ++++++++++++-------
 .../useProjectAnalysisSummary.test.ts         | 18 +++--
 2 files changed, 58 insertions(+), 29 deletions(-)

diff --git a/app/composables/useProjectAnalysisSummary.ts b/app/composables/useProjectAnalysisSummary.ts
index f3a28ea..0b66c0f 100644
--- a/app/composables/useProjectAnalysisSummary.ts
+++ b/app/composables/useProjectAnalysisSummary.ts
@@ -1,17 +1,11 @@
 import { ref } from "vue";
 import { useNuxtApp } from "nuxt/app";
-import {
-  type AnalysisNode,
-  type ListRoutes,
-  type PodProgressResponse,
-  PodStatus,
-  type Route,
-} from "~/services/Api";
+import { type AnalysisNode, type ListRoutes, type PodProgressResponse, PodStatus, type Route } from "~/services/Api";
 import { parseKongTags } from "~/utils/parse-kong-tags";
 import {
   emptyProjectAnalysisSummary,
   type ProjectAnalysisSummary,
-  summariseProjectAnalyses,
+  summariseProjectAnalyses
 } from "~/utils/summarise-project-analyses";
 
 export type HubFetch = (
@@ -31,6 +25,7 @@ const FINISHED_STATUSES: Array<PodStatus | null | undefined> = [
 export interface AnalysisNodeFetchResult {
   nodes: AnalysisNode[];
   truncated: boolean;
+  incomplete: boolean;
 }
 
 export async function fetchAllAnalysisNodes(
@@ -38,16 +33,24 @@ export async function fetchAllAnalysisNodes(
 ): Promise<AnalysisNodeFetchResult> {
   const allNodes: AnalysisNode[] = [];
   let truncated = false;
+  let incomplete = false;
 
   for (let pageIndex = 0; pageIndex < MAX_PAGES; pageIndex++) {
-    const nextPage = (await hubApi("/analysis-nodes", {
-      method: "GET",
-      query: {
-        include: "analysis",
-        sort: "-updated_at",
-        page: { offset: pageIndex * PAGE_LIMIT, limit: PAGE_LIMIT },
-      },
-    }).catch(() => undefined)) as AnalysisNode[] | undefined;
+    let nextPage: AnalysisNode[] | undefined;
+    try {
+      nextPage = (await hubApi("/analysis-nodes", {
+        method: "GET",
+        query: {
+          include: "analysis",
+          sort: "-updated_at",
+          page: { offset: pageIndex * PAGE_LIMIT, limit: PAGE_LIMIT },
+        },
+      })) as AnalysisNode[];
+    } catch {
+      // To avoid it thinking it's the end of the result set
+      incomplete = true;
+      break;
+    }
 
     if (!nextPage || nextPage.length === 0) break;
     allNodes.push(...nextPage);
@@ -56,14 +59,23 @@ export async function fetchAllAnalysisNodes(
     if (pageIndex === MAX_PAGES - 1) truncated = true;
   }
 
-  return { nodes: allNodes, truncated };
+  return { nodes: allNodes, truncated, incomplete };
+}
+
+export interface DataStoreProjectIdsResult {
+  projectIds: Set<string>;
+  unavailable: boolean;
 }
 
 export async function fetchDataStoreProjectIds(
   hubApi: HubFetch,
-): Promise<Set<string>> {
+): Promise<DataStoreProjectIdsResult> {
+  let unavailable = false;
   const routesResp = (await hubApi("/kong/project", { method: "GET" }).catch(
-    () => undefined,
+    () => {
+      unavailable = true;
+      return undefined;
+    },
   )) as ListRoutes | undefined;
 
   const projectIds = new Set<string>();
@@ -71,7 +83,7 @@ export async function fetchDataStoreProjectIds(
     const projectId = parseKongTags(route.tags).project;
     if (projectId) projectIds.add(projectId);
   });
-  return projectIds;
+  return { projectIds, unavailable };
 }
 
 export async function fetchExecutionStatuses(
@@ -86,6 +98,8 @@ export function mergeExecutionStatuses(
   analysisNodes: AnalysisNode[],
   executionStatuses: PodProgressResponse | undefined,
 ): AnalysisNode[] {
+  const orchestratorReachable = executionStatuses !== undefined;
+
   return analysisNodes.map((analysisNode) => {
     const merged = { ...analysisNode };
     const analysisId = merged.analysis_id;
@@ -94,6 +108,7 @@ export function mergeExecutionStatuses(
       merged.execution_status = executionStatuses[analysisId]!
         .status as AnalysisNode["execution_status"];
     } else if (
+      orchestratorReachable &&
       !FINISHED_STATUSES.includes(merged.execution_status as PodStatus)
     ) {
       merged.execution_status = null;
@@ -108,23 +123,29 @@ export function useProjectAnalysisSummary() {
   const dataStoreProjectIds = ref<Set<string>>(new Set());
   const loading = ref(false);
   const truncated = ref(false);
+  const incomplete = ref(false);
+
+  // Kong could not be reached, so dataStoreProjectIds is not reliable
+  const dataStoreUnavailable = ref(false);
 
   async function refreshSummaries() {
     loading.value = true;
     try {
       const hubApi = useNuxtApp().$hubApi as unknown as HubFetch;
-      const [analysisNodeResult, projectIdsWithDataStore, executionStatuses] =
+      const [analysisNodeResult, dataStoreResult, executionStatuses] =
         await Promise.all([
           fetchAllAnalysisNodes(hubApi),
           fetchDataStoreProjectIds(hubApi),
           fetchExecutionStatuses(hubApi),
         ]);
 
-      dataStoreProjectIds.value = projectIdsWithDataStore;
+      dataStoreProjectIds.value = dataStoreResult.projectIds;
+      dataStoreUnavailable.value = dataStoreResult.unavailable;
       truncated.value = analysisNodeResult.truncated;
+      incomplete.value = analysisNodeResult.incomplete;
       summaries.value = summariseProjectAnalyses(
         mergeExecutionStatuses(analysisNodeResult.nodes, executionStatuses),
-        projectIdsWithDataStore,
+        dataStoreResult.projectIds,
       );
     } finally {
       loading.value = false;
@@ -147,6 +168,8 @@ export function useProjectAnalysisSummary() {
     dataStoreProjectIds,
     loading,
     truncated,
+    incomplete,
+    dataStoreUnavailable,
     refreshSummaries,
     summaryFor,
   };
diff --git a/test/composables/useProjectAnalysisSummary.test.ts b/test/composables/useProjectAnalysisSummary.test.ts
index f914a45..71b41e4 100644
--- a/test/composables/useProjectAnalysisSummary.test.ts
+++ b/test/composables/useProjectAnalysisSummary.test.ts
@@ -39,7 +39,7 @@ describe("fetchAllAnalysisNodes", () => {
     expect(result.truncated).toBe(false);
   });
 
-  it("returns what it has when a page request fails", async () => {
+  it("returns what it has when a page request fails, flagged as incomplete", async () => {
     const hubApi = vi
       .fn()
       .mockResolvedValueOnce(page(50))
@@ -47,6 +47,7 @@ describe("fetchAllAnalysisNodes", () => {
     const result = await fetchAllAnalysisNodes(hubApi);
     expect(result.nodes).toHaveLength(50);
     expect(result.truncated).toBe(false);
+    expect(result.incomplete).toBe(true);
   });
 
   it("caps pagination so a misbehaving API cannot loop forever", async () => {
@@ -84,12 +85,15 @@ describe("fetchDataStoreProjectIds", () => {
       ],
     });
     const result = await fetchDataStoreProjectIds(hubApi);
-    expect(result).toEqual(new Set(["proj-1", "proj-2"]));
+    expect(result.projectIds).toEqual(new Set(["proj-1", "proj-2"]));
+    expect(result.unavailable).toBe(false);
   });
 
-  it("returns an empty set when Kong is unreachable", async () => {
+  it("returns an empty set flagged unavailable when Kong is unreachable", async () => {
     const hubApi = vi.fn().mockRejectedValue(new Error("boom"));
-    expect(await fetchDataStoreProjectIds(hubApi)).toEqual(new Set());
+    const result = await fetchDataStoreProjectIds(hubApi);
+    expect(result.projectIds).toEqual(new Set());
+    expect(result.unavailable).toBe(true);
   });
 });
 
@@ -131,9 +135,11 @@ describe("mergeExecutionStatuses", () => {
     expect(result[0].execution_status).toBeNull();
   });
 
-  it("discards non-terminal Hub statuses when the pod orchestrator is unreachable", () => {
+  it("preserves non-terminal Hub statuses when the pod orchestrator is unreachable", () => {
+    // Unlike a reachable orchestrator with no entry, "unreachable" tells us
+    // nothing - discarding here would hide genuinely running analyses.
     const result = mergeExecutionStatuses([node("a-1", PodStatus.Executing)], undefined);
-    expect(result[0].execution_status).toBeNull();
+    expect(result[0].execution_status).toBe(PodStatus.Executing);
   });
 
   it("does not mutate the input nodes", () => {