Regulations tracker with AI regulation impact analysis

CLAUDE.md

@@ -175,6 +175,7 @@ Read the relevant file BEFORE implementing changes in that area:
 | Agent Control (AI Gateway native tool-call hook, file-write gating, approval, result capture, run correlation, multi-agent wiring) | `docs/technical/domains/agent-control.md` |
 | Agent Control integrator/developer docs (connect an agent, Claude Code + Cursor, generic contract, API ref) | `shared/user-guide-content/content/developers/` |
 | AI Trust Index | `docs/technical/domains/ai-trust-index.md` |
+| Regulations Tracker (global AI-regulations feed: daily sync, per-country tracking, Horizon/Deadlines/Frameworks, notifications) | `docs/technical/domains/regulations-tracker.md` |
 | AI Detection | `docs/technical/domains/ai-detection.md` |
 | Risk management | `docs/technical/domains/risk-management.md` |
 | Vendors | `docs/technical/domains/vendors.md` |

Clients/src/application/config/routes.tsx

@@ -101,6 +101,29 @@ const AITrustIndexSettings = lazyRoute(
 const AITrustIndexDetail = lazyRoute(
   () => import("../../presentation/pages/AITrustIndex/AppDetail"),
 );
+// ── Regulations Tracker routes ────────────────────────────────────────
+const RegulationsTracker = lazyRoute(() => import("../../presentation/pages/RegulationsTracker"));
+const RegulationsTrackerBrowse = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/Browse"),
+);
+const RegulationsTrackerTracked = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/Tracked"),
+);
+const RegulationsTrackerSettings = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/Settings"),
+);
+const RegulationsTrackerCountryDetail = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/CountryDetail"),
+);
+const RegulationsTrackerHorizon = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/Horizon"),
+);
+const RegulationsTrackerDeadlines = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/Deadlines"),
+);
+const RegulationsTrackerFrameworks = lazyRoute(
+  () => import("../../presentation/pages/RegulationsTracker/Frameworks"),
+);
 
 const InsightsPage = lazyRoute(() => import("../../presentation/pages/ShadowAI/InsightsPage"));
 const UserActivityPage = lazyRoute(
@@ -788,6 +811,70 @@ export const createRoutes = (
         </Suspense>
       }
     />
+    <Route
+      path="/regulations-tracker"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTracker />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/browse"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerBrowse />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/tracked"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerTracked />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/settings"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerSettings />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/horizon"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerHorizon />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/deadlines"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerDeadlines />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/frameworks"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerFrameworks />
+        </Suspense>
+      }
+    />
+    <Route
+      path="/regulations-tracker/:slug"
+      element={
+        <Suspense fallback={<LazyFallback />}>
+          <RegulationsTrackerCountryDetail />
+        </Suspense>
+      }
+    />
     <Route path="/shadow-ai" element={<Navigate to="/shadow-ai/insights" replace />} />
     <Route
       path="/shadow-ai/insights"

Clients/src/application/contexts/RegulationsTrackerSidebar.context.tsx

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Regulations Tracker Sidebar Context
+ *
+ * Provides the tracked-country count badge to the Regulations Tracker sidebar.
+ * Follows the same safe-context pattern as AITrustIndexSidebarContext so the
+ * shared ContextSidebar can read counts without crashing outside the provider.
+ *
+ * @module contexts/RegulationsTrackerSidebar.context
+ */
+
+import { createContext, useContext, useState, useEffect, useCallback, ReactNode, FC } from "react";
+import { getTracked } from "../repository/regulationsTracker.repository";
+
+interface RegulationsTrackerSidebarContextType {
+  trackedCount: number;
+  setTrackedCount: (n: number) => void;
+  refreshTrackedCount: () => void;
+}
+
+const RegulationsTrackerSidebarContext = createContext<RegulationsTrackerSidebarContextType | null>(
+  null,
+);
+
+export const RegulationsTrackerSidebarProvider: FC<{ children: ReactNode }> = ({ children }) => {
+  const [trackedCount, setTrackedCount] = useState(0);
+
+  const refreshTrackedCount = useCallback(async () => {
+    try {
+      const response = await getTracked();
+      const rows = Array.isArray(response?.data) ? response.data : [];
+      setTrackedCount(rows.length);
+    } catch {
+      // Sidebar badge is non-critical; ignore failures.
+    }
+  }, []);
+
+  useEffect(() => {
+    refreshTrackedCount();
+  }, [refreshTrackedCount]);
+
+  return (
+    <RegulationsTrackerSidebarContext.Provider
+      value={{ trackedCount, setTrackedCount, refreshTrackedCount }}
+    >
+      {children}
+    </RegulationsTrackerSidebarContext.Provider>
+  );
+};
+
+export const useRegulationsTrackerSidebarContext = () => {
+  const context = useContext(RegulationsTrackerSidebarContext);
+  if (!context) {
+    throw new Error(
+      "useRegulationsTrackerSidebarContext must be used within RegulationsTrackerSidebarProvider",
+    );
+  }
+  return context;
+};
+
+// Safe version that returns null if not in provider (used by ContextSidebar).
+export const useRegulationsTrackerSidebarContextSafe = () => {
+  return useContext(RegulationsTrackerSidebarContext);
+};

Clients/src/application/hooks/useActiveModule.ts

@@ -36,6 +36,9 @@ export function useActiveModule() {
     if (pathname.startsWith("/ai-trust-index")) {
       return "ai-trust-index";
     }
+    if (pathname.startsWith("/regulations-tracker")) {
+      return "regulations-tracker";
+    }
     if (pathname.startsWith("/super-admin")) {
       return "super-admin";
     }
@@ -76,6 +79,9 @@ export function useActiveModule() {
         case "ai-trust-index":
           navigate("/ai-trust-index/browse");
           break;
+        case "regulations-tracker":
+          navigate("/regulations-tracker/browse");
+          break;
         case "super-admin":
           navigate("/super-admin");
           break;
@@ -100,6 +106,7 @@ export function useActiveModule() {
         "shadow-ai",
         "ai-gateway",
         "ai-trust-index",
+        "regulations-tracker",
         "super-admin",
       ].includes(stored)
     ) {

Clients/src/application/hooks/useRegulationsTracker.ts

@@ -0,0 +1,164 @@
+// Clients/src/application/hooks/useRegulationsTracker.ts
+import { useQuery, useMutation, useQueryClient, keepPreviousData } from "@tanstack/react-query";
+import {
+  getCountries,
+  getCountryDetail,
+  getTracked,
+  trackCountry,
+  trackBulk,
+  untrackCountry,
+  getSettings,
+  updateSettings,
+  getHorizon,
+  getDeadlines,
+  getFrameworks,
+  triggerSync,
+  getImpactAnalysis,
+  refreshImpactAnalysis,
+} from "../repository/regulationsTracker.repository";
+
+const KEY = "regulations-tracker";
+
+// keepPreviousData on the read queries: track/untrack invalidates these keys,
+// which triggers a background refetch. Without it, `data` briefly becomes
+// undefined and the page's content unmounts and re-mounts — a visible flicker.
+// Keeping the previous data holds the UI steady while the fresh data loads.
+export function useCountries(filters: { region?: string; q?: string } = {}) {
+  return useQuery({
+    queryKey: [KEY, "countries", filters],
+    queryFn: () => getCountries(filters),
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useCountryDetail(slug: string) {
+  return useQuery({
+    queryKey: [KEY, "country", slug],
+    queryFn: () => getCountryDetail(slug),
+    enabled: !!slug,
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useTracked() {
+  return useQuery({
+    queryKey: [KEY, "tracked"],
+    queryFn: () => getTracked(),
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useTrackCountry() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (slug: string) => trackCountry(slug),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: [KEY, "countries"] });
+      qc.invalidateQueries({ queryKey: [KEY, "tracked"] });
+      // The detail page reads is_tracked from [KEY, "country", slug]; invalidate the
+      // "country" prefix so its Track/Untrack button reflects the new state.
+      qc.invalidateQueries({ queryKey: [KEY, "country"] });
+    },
+  });
+}
+
+export function useUntrackCountry() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (slug: string) => untrackCountry(slug),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: [KEY, "countries"] });
+      qc.invalidateQueries({ queryKey: [KEY, "tracked"] });
+      qc.invalidateQueries({ queryKey: [KEY, "country"] });
+    },
+  });
+}
+
+export function useTrackBulk() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (slugs: string[]) => trackBulk(slugs),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: [KEY, "countries"] });
+      qc.invalidateQueries({ queryKey: [KEY, "tracked"] });
+      qc.invalidateQueries({ queryKey: [KEY, "country"] });
+    },
+  });
+}
+
+export function useSettings() {
+  // Settings change rarely; a 60s staleTime avoids the global 2s default
+  // refetching on every interaction.
+  return useQuery({
+    queryKey: [KEY, "settings"],
+    queryFn: () => getSettings(),
+    staleTime: 60 * 1000,
+  });
+}
+
+export function useUpdateSettings() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (body: {
+      recipient_user_ids: number[];
+      recipient_emails: string[];
+      impact_enabled?: boolean;
+    }) => updateSettings(body),
+    onSuccess: () => qc.invalidateQueries({ queryKey: [KEY, "settings"] }),
+  });
+}
+
+export function useHorizon() {
+  return useQuery({
+    queryKey: [KEY, "horizon"],
+    queryFn: getHorizon,
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useDeadlines() {
+  return useQuery({
+    queryKey: [KEY, "deadlines"],
+    queryFn: getDeadlines,
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useFrameworks() {
+  return useQuery({
+    queryKey: [KEY, "frameworks"],
+    queryFn: getFrameworks,
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useTriggerSync() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: triggerSync,
+    onSuccess: () => {
+      // Refresh everything the sync may have changed: catalog, tracked list,
+      // the global feeds, and settings (which carries last-run status).
+      qc.invalidateQueries({ queryKey: [KEY] });
+    },
+  });
+}
+
+export function useImpactAnalysis(slug: string) {
+  return useQuery({
+    queryKey: [KEY, "impact", slug],
+    queryFn: () => getImpactAnalysis(slug),
+    enabled: !!slug,
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useRefreshImpactAnalysis() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (slug: string) => refreshImpactAnalysis(slug),
+    onSuccess: (_data, slug) => {
+      qc.invalidateQueries({ queryKey: [KEY, "impact", slug] });
+    },
+  });
+}

Clients/src/application/redux/ui/uiSlice.ts

@@ -7,6 +7,7 @@ export type AppModule =
   | "shadow-ai"
   | "ai-gateway"
   | "ai-trust-index"
+  | "regulations-tracker"
   | "super-admin";
 
 const initialState = {