diff --git a/package.json b/package.json
index 17f7e4e33..369e536ca 100644
--- a/package.json
+++ b/package.json
@@ -14,10 +14,10 @@
     "lint": "turbo lint",
     "format": "turbo format",
     "format:check": "turbo format:check",
-    "test": "vitest run --config=./vitest/config.ts --workspace=./vitest/workspaces.ts",
-    "test:watch": "vitest run --config=./vitest/config.ts --workspace=./vitest/workspaces.ts --watch",
-    "test:coverage": "vitest run --config=./vitest/config.ts --workspace=./vitest/workspaces.ts --coverage",
-    "test:ci": "vitest run --config=./vitest/config.ts --workspace=./vitest/workspaces.ts --silent --coverage --reporter=junit --outputFile=test-report.junit.xml",
+    "test": "vitest run --config=./vitest/config.ts",
+    "test:watch": "vitest run --config=./vitest/config.ts --watch",
+    "test:coverage": "vitest run --config=./vitest/config.ts --coverage",
+    "test:ci": "vitest run --config=./vitest/config.ts --silent --coverage --reporter=junit --outputFile=test-report.junit.xml",
     "test:integration": "yarn test:integration:react-18 && yarn test:integration:react-19",
     "test:integration:react-18": "./integration/run-integration.sh 18.2.0",
     "test:integration:react-19": "./integration/run-integration.sh 19.1.0",
diff --git a/packages/client/src/clients/guide/client.ts b/packages/client/src/clients/guide/client.ts
index 742c073d8..e458b3d8c 100644
--- a/packages/client/src/clients/guide/client.ts
+++ b/packages/client/src/clients/guide/client.ts
@@ -217,6 +217,13 @@ const predicate = (
     return false;
   }
 
+  return checkActivatable(guide, location);
+};
+
+export const checkActivatable = (
+  guide: KnockGuide,
+  location: string | undefined,
+) => {
   const url = location ? newUrl(location) : undefined;
 
   const urlRules = guide.activation_url_rules || [];
diff --git a/packages/client/src/clients/guide/index.ts b/packages/client/src/clients/guide/index.ts
index ddcb5e288..7d5519160 100644
--- a/packages/client/src/clients/guide/index.ts
+++ b/packages/client/src/clients/guide/index.ts
@@ -1,4 +1,8 @@
-export { KnockGuideClient, DEBUG_QUERY_PARAMS } from "./client";
+export {
+  KnockGuideClient,
+  DEBUG_QUERY_PARAMS,
+  checkActivatable,
+} from "./client";
 export type {
   KnockGuide,
   KnockGuideStep,
diff --git a/packages/react/src/modules/guide/components/Toolbar/V2/GuideRow.tsx b/packages/react/src/modules/guide/components/Toolbar/V2/GuideRow.tsx
index bc029e2c0..e260425ad 100644
--- a/packages/react/src/modules/guide/components/Toolbar/V2/GuideRow.tsx
+++ b/packages/react/src/modules/guide/components/Toolbar/V2/GuideRow.tsx
@@ -1,9 +1,15 @@
 import { Button } from "@telegraph/button";
-import { Stack } from "@telegraph/layout";
+import { Box, Stack } from "@telegraph/layout";
 import { Tag } from "@telegraph/tag";
 import { Tooltip } from "@telegraph/tooltip";
 import { Text } from "@telegraph/typography";
-import { CheckCircle2, CircleDashed, Eye, UserCircle2 } from "lucide-react";
+import {
+  CheckCircle2,
+  CircleDashed,
+  Eye,
+  LocateFixed,
+  UserCircle2,
+} from "lucide-react";
 import * as React from "react";
 
 import { GuideHoverCard } from "./GuideHoverCard";
@@ -43,6 +49,30 @@ export const GuideRow = ({ guide, orderIndex }: Props) => {
       </Stack>
 
       <Stack justify="flex-end">
+        {!isUnknownGuide(guide) && (
+          <>
+            <Stack gap="1">
+              <Tooltip
+                label={
+                  guide.annotation.activatable.status
+                    ? "This guide can be activated at the current location"
+                    : "This guide cannot be activated at the current location"
+                }
+              >
+                <Button
+                  px="1"
+                  size="1"
+                  variant="soft"
+                  color={guide.annotation.activatable.status ? "green" : "red"}
+                  leadingIcon={{ icon: LocateFixed, alt: "Target" }}
+                />
+              </Tooltip>
+            </Stack>
+            <Stack px="2" align="center">
+              <Box h="3" borderLeft="px" borderColor="gray-6" />
+            </Stack>
+          </>
+        )}
         <Stack gap="1">
           {!isUnknownGuide(guide) && (
             <>
diff --git a/packages/react/src/modules/guide/components/Toolbar/V2/GuidesListDisplaySelect.tsx b/packages/react/src/modules/guide/components/Toolbar/V2/GuidesListDisplaySelect.tsx
index 5c3941261..2b7c51324 100644
--- a/packages/react/src/modules/guide/components/Toolbar/V2/GuidesListDisplaySelect.tsx
+++ b/packages/react/src/modules/guide/components/Toolbar/V2/GuidesListDisplaySelect.tsx
@@ -22,11 +22,9 @@ export const GuidesListDisplaySelect = ({ value, onChange }: Props) => {
         style: { zIndex: TOOLBAR_Z_INDEX },
       }}
     >
-      {/* NOTE: Commented out until we can show relevant indicators for this opt
-        <Select.Option size="1" value="current-page">
-          Displayable on current page
-        </Select.Option>
-      */}
+      <Select.Option size="1" value="current-page">
+        Displayable on current page
+      </Select.Option>
       <Select.Option size="1" value="all-eligible">
         All eligible guides for user
       </Select.Option>
diff --git a/packages/react/src/modules/guide/components/Toolbar/V2/V2.tsx b/packages/react/src/modules/guide/components/Toolbar/V2/V2.tsx
index eef46369c..1a885fd75 100644
--- a/packages/react/src/modules/guide/components/Toolbar/V2/V2.tsx
+++ b/packages/react/src/modules/guide/components/Toolbar/V2/V2.tsx
@@ -27,6 +27,12 @@ const GuidesList = ({
   displayOption: DisplayOption;
 }) => {
   return guides.map((guide, idx) => {
+    if (
+      displayOption === "current-page" &&
+      (!guide.annotation.isEligible || !guide.annotation.isQualified)
+    ) {
+      return null;
+    }
     if (displayOption === "all-eligible" && !guide.annotation.isEligible) {
       return null;
     }
@@ -39,7 +45,7 @@ export const V2 = () => {
   const { client } = useGuideContext();
 
   const [guidesListDisplayOption, setGuidesListDisplayOption] =
-    React.useState<DisplayOption>("all-eligible");
+    React.useState<DisplayOption>("current-page");
 
   const [isVisible, setIsVisible] = React.useState(detectToolbarParam());
   const [isCollapsed, setIsCollapsed] = React.useState(true);
diff --git a/packages/react/src/modules/guide/components/Toolbar/V2/useInspectGuideClientStore.ts b/packages/react/src/modules/guide/components/Toolbar/V2/useInspectGuideClientStore.ts
index 1857297dd..6abbf3bca 100644
--- a/packages/react/src/modules/guide/components/Toolbar/V2/useInspectGuideClientStore.ts
+++ b/packages/react/src/modules/guide/components/Toolbar/V2/useInspectGuideClientStore.ts
@@ -2,6 +2,7 @@ import {
   KnockGuide,
   KnockGuideClientStoreState,
   KnockGuideIneligibilityMarker,
+  checkActivatable,
 } from "@knocklabs/client";
 import { useGuideContext, useStore } from "@knocklabs/react-core";
 
@@ -28,6 +29,10 @@ type TargetableStatusFalse = {
 };
 type TargetableStatus = TargetableStatusTrue | TargetableStatusFalse;
 
+type ActivatableStatus = {
+  status: boolean;
+};
+
 // Archived: `false` status = good
 type ArchivedStatus = {
   status: boolean;
@@ -38,12 +43,18 @@ type AnnotatedStatuses = {
   active: ActiveStatus;
   targetable: TargetableStatus;
   archived: ArchivedStatus;
+  // Individual qualified statuses:
+  activatable: ActivatableStatus;
 };
 
 type GuideAnnotation = AnnotatedStatuses & {
   // Resolved eligibility based on active, targetable and archived statuses,
   // which are backend driven evaluation results that are exposed for debugging.
   isEligible: boolean;
+
+  // Resolved display qualification based on an activatable status, which
+  // informs "when" and "where" an eligible guide can be displayed to user.
+  isQualified: boolean;
 };
 
 export type AnnotatedGuide = KnockGuide & {
@@ -64,6 +75,7 @@ export type UnknownGuide = {
   bypass_global_group_limit: false;
   annotation: {
     isEligible: false;
+    isQualified: false;
   };
 };
 
@@ -116,28 +128,37 @@ const resolveIsEligible = ({
   return true;
 };
 
+export const resolveIsQualified = ({ activatable }: AnnotatedStatuses) => {
+  if (!activatable.status) return false;
+  return true;
+};
+
 type StoreStateSnapshot = Pick<
   KnockGuideClientStoreState,
-  "guides" | "guideGroups" | "ineligibleGuides" | "debug"
+  "location" | "guides" | "guideGroups" | "ineligibleGuides" | "debug"
 >;
 
 const annotateGuide = (
   guide: KnockGuide,
   snapshot: StoreStateSnapshot,
 ): AnnotatedGuide => {
-  const { ineligibleGuides } = snapshot;
+  const { ineligibleGuides, location } = snapshot;
   const marker = ineligibleGuides[guide.key];
   const ineligiblity = marker ? toIneligibilityStatus(marker) : undefined;
 
   const statuses: AnnotatedStatuses = {
+    // isEligible:
     active: ineligiblity?.active || { status: true },
     targetable: ineligiblity?.targetable || { status: true },
     archived: ineligiblity?.archived || { status: false },
+    // isQualified:
+    activatable: { status: checkActivatable(guide, location) },
   };
 
   const annotation: GuideAnnotation = {
     ...statuses,
     isEligible: resolveIsEligible(statuses),
+    isQualified: resolveIsQualified(statuses),
   };
 
   return {
@@ -154,6 +175,7 @@ const newUnknownGuide = (key: KnockGuide["key"]) =>
     bypass_global_group_limit: false,
     annotation: {
       isEligible: false,
+      isQualified: false,
     },
   }) as UnknownGuide;
 
@@ -161,8 +183,9 @@ export const useInspectGuideClientStore = (): InspectionResult | undefined => {
   const { client } = useGuideContext();
 
   // Extract a snapshot of the client store state for debugging.
-  const snapshot = useStore(client.store, (state) => {
+  const snapshot: StoreStateSnapshot = useStore(client.store, (state) => {
     return {
+      location: state.location,
       guides: state.guides,
       guideGroups: state.guideGroups,
       ineligibleGuides: state.ineligibleGuides,
diff --git a/packages/react/test/guide/Toolbar/V2/useInspectGuideClientStore.test.ts b/packages/react/test/guide/Toolbar/V2/useInspectGuideClientStore.test.ts
index 284032a89..54ba472fb 100644
--- a/packages/react/test/guide/Toolbar/V2/useInspectGuideClientStore.test.ts
+++ b/packages/react/test/guide/Toolbar/V2/useInspectGuideClientStore.test.ts
@@ -1,15 +1,27 @@
 import { renderHook } from "@testing-library/react";
-import { describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
 
 import {
   type AnnotatedGuide,
   isUnknownGuide,
+  resolveIsQualified,
   useInspectGuideClientStore,
 } from "../../../../src/modules/guide/components/Toolbar/V2/useInspectGuideClientStore";
 
 // Mutable snapshot that tests can override to simulate different store states.
 let mockStoreState: Record<string, unknown> = {};
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockCheckActivatable = vi.fn((..._args: any[]) => true);
+
+vi.mock("@knocklabs/client", async () => {
+  const actual = await vi.importActual("@knocklabs/client");
+  return {
+    ...actual,
+    checkActivatable: (...args: unknown[]) => mockCheckActivatable(...args),
+  };
+});
+
 vi.mock("@knocklabs/react-core", async () => {
   const actual = await vi.importActual("@knocklabs/react-core");
   return {
@@ -67,6 +79,7 @@ const makeMarker = (
 
 const setSnapshot = (partial: Record<string, unknown>) => {
   mockStoreState = {
+    location: "https://example.com",
     guides: {},
     guideGroups: [],
     ineligibleGuides: {},
@@ -82,6 +95,11 @@ const renderInspect = () => {
 };
 
 describe("useInspectGuideClientStore", () => {
+  beforeEach(() => {
+    mockCheckActivatable.mockReset();
+    mockCheckActivatable.mockReturnValue(true);
+  });
+
   // ----- Early returns -----
 
   test("returns undefined when not in debugging mode", () => {
@@ -119,6 +137,7 @@ describe("useInspectGuideClientStore", () => {
     expect(unknown.key).toBe("missing_key");
     expect(unknown.active).toBe(false);
     expect(unknown.annotation.isEligible).toBe(false);
+    expect(unknown.annotation.isQualified).toBe(false);
   });
 
   // ----- Guide annotation: fully eligible (no marker) -----
@@ -343,4 +362,115 @@ describe("useInspectGuideClientStore", () => {
       expect(annotated.annotation.isEligible).toBe(true);
     });
   });
+
+  // ----- activatable + isQualified -----
+
+  describe("activatable status and isQualified", () => {
+    test("marks guide as activatable and qualified when checkActivatable returns true", () => {
+      mockCheckActivatable.mockReturnValue(true);
+      const guide = makeGuide({ key: "g1" });
+      setSnapshot({
+        guideGroups: [makeGuideGroup(["g1"])],
+        guides: { g1: guide },
+        ineligibleGuides: {},
+      });
+
+      const result = renderInspect()!;
+      const annotated = result.guides[0] as AnnotatedGuide;
+      expect(annotated.annotation.activatable).toEqual({ status: true });
+      expect(annotated.annotation.isQualified).toBe(true);
+    });
+
+    test("marks guide as not activatable and not qualified when checkActivatable returns false", () => {
+      mockCheckActivatable.mockReturnValue(false);
+      const guide = makeGuide({ key: "g1" });
+      setSnapshot({
+        guideGroups: [makeGuideGroup(["g1"])],
+        guides: { g1: guide },
+        ineligibleGuides: {},
+      });
+
+      const result = renderInspect()!;
+      const annotated = result.guides[0] as AnnotatedGuide;
+      expect(annotated.annotation.activatable).toEqual({ status: false });
+      expect(annotated.annotation.isQualified).toBe(false);
+    });
+
+    test("passes the guide and location to checkActivatable", () => {
+      const guide = makeGuide({ key: "g1" });
+      setSnapshot({
+        location: "https://app.example.com/dashboard",
+        guideGroups: [makeGuideGroup(["g1"])],
+        guides: { g1: guide },
+        ineligibleGuides: {},
+      });
+
+      renderInspect();
+      expect(mockCheckActivatable).toHaveBeenCalledWith(
+        expect.objectContaining({ key: "g1" }),
+        "https://app.example.com/dashboard",
+      );
+    });
+
+    test("a guide can be eligible but not qualified", () => {
+      mockCheckActivatable.mockReturnValue(false);
+      const guide = makeGuide({ key: "g1", active: true });
+      setSnapshot({
+        guideGroups: [makeGuideGroup(["g1"])],
+        guides: { g1: guide },
+        ineligibleGuides: {},
+      });
+
+      const result = renderInspect()!;
+      const annotated = result.guides[0] as AnnotatedGuide;
+      expect(annotated.annotation.isEligible).toBe(true);
+      expect(annotated.annotation.isQualified).toBe(false);
+    });
+
+    test("a guide can be ineligible but qualified", () => {
+      mockCheckActivatable.mockReturnValue(true);
+      const guide = makeGuide({ key: "g1", active: true });
+      const marker = makeMarker(
+        "g1",
+        "guide_not_active",
+        "Guide is not active",
+      );
+      setSnapshot({
+        guideGroups: [makeGuideGroup(["g1"])],
+        guides: { g1: guide },
+        ineligibleGuides: { g1: marker },
+      });
+
+      const result = renderInspect()!;
+      const annotated = result.guides[0] as AnnotatedGuide;
+      expect(annotated.annotation.isEligible).toBe(false);
+      expect(annotated.annotation.isQualified).toBe(true);
+    });
+  });
+
+  // ----- resolveIsQualified (unit) -----
+
+  describe("resolveIsQualified", () => {
+    test("returns true when activatable status is true", () => {
+      expect(
+        resolveIsQualified({
+          active: { status: true },
+          targetable: { status: true },
+          archived: { status: false },
+          activatable: { status: true },
+        }),
+      ).toBe(true);
+    });
+
+    test("returns false when activatable status is false", () => {
+      expect(
+        resolveIsQualified({
+          active: { status: true },
+          targetable: { status: true },
+          archived: { status: false },
+          activatable: { status: false },
+        }),
+      ).toBe(false);
+    });
+  });
 });
diff --git a/vitest/config.ts b/vitest/config.ts
index 0f5651de8..d3098f588 100644
--- a/vitest/config.ts
+++ b/vitest/config.ts
@@ -2,6 +2,7 @@ import { defineConfig } from "vitest/config";
 
 const sharedConfig = defineConfig({
   test: {
+    projects: ["packages/*"],
     coverage: {
       provider: "v8",
       all: true,
diff --git a/vitest/workspaces.ts b/vitest/workspaces.ts
deleted file mode 100644
index c1efc9a8b..000000000
--- a/vitest/workspaces.ts
+++ /dev/null
@@ -1 +0,0 @@
-export default ["packages/*"];